Lazarus IDE Tools/pt

From Lazarus wiki
Jump to navigationJump to search

Deutsch (de) English (en) español (es) suomi (fi) français (fr) 日本語 (ja) 한국어 (ko) Nederlands (nl) português (pt) русский (ru) slovenčina (sk) 中文(中国大陆) (zh_CN)

Introdução

A IDE usa uma biblioteca do código pascal analisando gramaticalmente e editando ferramentas, chamada de "codetools". Estas ferramentes dão capacidades como encontrar declaração (find declaration), completar código(code completion), extração (extraction), movendo inserindo e embelezando códigos pascal. Estas funções reduzem o seu tempo e facilitam o seu trabalho. Eles são customizáveis e cada um deles está disponível via teclas de atalho (veja Editor Options).

Porque trabalham unicamente em fontes e compreendem o código do FPC, do Delphi e do Kylix, não requerem unidades compiladas nem um compilador instalado da Borland. Você pode editar Delphi e código de FPC ao mesmo tempo. Você pode mesmo trabalhar com diversos Delphi e versões de FPC ao mesmo tempo. Isto faz o código do Delphi ser portado muito mais facilmente.

Sumário da tabela de teclas de atalho da IDE

Declaration Jumping Ctrl+Click or Alt+Up (pula para a declaração do tipo ou variável)
Method Jumping Ctrl+Shift+Up (alterna entre definição e corpo)
Code Templates Ctrl+J
Code Completion (Completa Classe) Ctrl+Shift+C
Identifier Completion Ctrl+Space
Word Completion Ctrl+W
Parameter Hints Ctrl+Shift+Space

Alternando no Método

Para pular entre o corpo do procedimento(begin..end) e a definição do procedimento (procedure Name;) use Ctrl+Shift+Up.

Por Exemplo:

interface

procedure DoSomething; // procedure definition
 
implementation
 
procedure DoSomething; // procedure body 
begin
end;

Se o cursor está no corpo do procedimento e você pressionar Ctrl+Shift+Up, o cursor irá pular para a definição. Pressionando Ctrl+Shift+Up outra vez irá para o corpo, depois do 'begin'.

Isto trabalha entre métodos(procedimentos nas classes) muito bem.

Dicas: 'Método Pulando' pula para o mesmo procedimento com o mesmo nome e parâmetros. Se não há exato procedimento, pula para melhor candidato e posiciona o cursor na primeira diferença.(o Delphi não faz isto).

Por exemplo um procedimento com diferentes tipos de parâmetros:

interface

procedure DoSomething(p: char); // procedure definition

implementation
  
procedure DoSomething(p: string); // procedure body
begin
end;

Incluir Arquivos

Incluir arquivos como o nome diz: insere dentro dos códigos fontes com as diretivas de compilação:{$I nomedoarquivo} ou {$INCLUDE nomedoarquivo}. Lazarus e FPC usam muitas coisas para reduzir a redundância e evita {$IFDEF} ilegíveis construções para suportar diferentes plataformas.

Ao contrário do Delphi, a IDE do Lazarus tem total suporte a inclusão de arquivos. Você pode por exemplo pular do método no arquivo .pas para o seu corpo no arquivo incluído. Todas as ferramentas de códigos como a de completar o código consideram arquivos incluídos como áreas especiais.

Por exemplo: Quando completar o código adiciona um corpo novo do método atrás de um outro corpo do método, mantém ambos na mesmo arquivo. Esta maneira você pode pôr a implementação da classe dentro de arquivos incluídos, como o LCL faz para quase todos os controles.

"Mas há uma armadilha para novatos: Se você abrir um arquivo incluído pela a primeira vez e tentar o método que salta ou acha a declaração você irá ter um erro. O IDE não sabe a que unidade o arquivo incluído pertence. Você deve abrir a unidade primeiramente.

Assim que o IDE analisar a unidade, analisará as diretrizes orientadoras incluídas aqui e o IDE recordará este relacionamento. Salvando esta informação na saída e no projeto salva em ~/.lazarus/includelinks.xml. A próxima vez que você abre este arquivo incluído e saltar ou faça localizar a declaração, o IDE abrirá internamente a unidade e o salto trabalhará.

É claro que este mecanismo tem seus limites. Alguns arquivos incluídos o são duas ou mais. Por exemplo:lcl/include/winapih.inc.

Saltar das definições de procedimento/método neste arquivo incluído aos corpos depende de suas últimas ações. Se você trabalhar em lcl/lclintf.pp o IDE saltará a winapi.inc. Se você trabalhou em lcl/interfacebase.pp, então saltará a lcl/include/interfacebase.inc (ou a um do outro arquivo incluído). Se você estiver trabalhando em ambos, a seguir você pode ficar confundindo.;)

Code Templates - Moldes de Código

"Code Templates" converte um identificador em um texto ou fragmento de código.

Code Templates tem como tecla de atalho por padrão: Ctrl+J. Você pode escrever um identificador, pressione Ctrl+J e o identificador é substituído pelo texto definido para o identificador. Os Code Templates podem ser definidos no Environment -> Editor Options -> CodeTools.

Exemplo: Escreva um identificador 'classf', deixe o cursor à direita sobre o 'f' e pressione Ctrl+J. A 'classf' irá ser substituida por

T = class(T)
private

public
  constructor Create;
  destructor Destroy; override;
end;

e o cursor fica atrás do 'T'. Você pode pegar a lista de templates posicionando o cursor no espaço em branco(não é um identificador) e pressionando a tecla Ctrl+J. A lista de code templates irá aparecer numa janela a parte. Use as teclas do cursor ou digite alguns caracteres para escolher um. Pressionando Enter cria-se o template selecionado e Escape(ESC) fecha a janela aberta dos templates.

O grande redutor de tempo é o template 'b'+Ctrl+J para begin..end.

Sugestão de Parâmetros

Sugestão de parâmetros exibe uma caixa com as declarações dos parâmetros da lista corrente de parâmetros.

Por exemplo

 Canvas.FillRect(|);

Posicione o cursor entre os parenteses e pressione Ctrl+Shift+Space. Uma caixa de sugestões irá aparecer exibindo os parâmetros de FillRect.

Deduzir Código (Code Completion)

Deduzir código pode ser encontrado no menu da IDE em Edit -> Complete Code e tem por padrão o atalho de teclado: Ctrl+Shift+C.

Para os Programadores Delphi: Delphi chama "deduzir código" a função exibe a lista de identificadores na posição atual da fonte (Ctrl+Space). Sob Lazarus isto é chamado do "completando identificador".

Deduzir código combina várias funções poderosas. Exemplos:

  • Deduzir Classe : completa propriedades, adiciona corpos aos métodos, adiciona variáveis e métodos de acesso privados
  • Deduzir procedimento antecipadamente: adiciona corpo ao procedimento
  • Deduzir associação de evento: completa associação de evento e adicina definição de método e seu corpo
  • Deduzir declaração de variável: adiciona definição da variável local
  • Reversa dedução da classe: adiciona declaração de um método para seu corpo.

Que função é usada, depende da posição do cursor no editor.

Deduzir código pode ser encontrado na IDE menu Edit -> Complete Code e tem o atalho de teclado por padrão: Ctrl+Shift+C.

Deduzir Classe (Class Completion)

A mais poderosa ferramenta de dedução de código é a de "Deduzir Classe"(Class Completion). Você escreve uma classe, adiciona os métodos e propriedades e a ferramenta irá adicionar o corpo dos métodos, os métodos de acesso as propriedades/variáveis e as variáveis privadas.

Por exemplo: Crie uma classe (veja Moldes de Código - Code Templates para salvar como um tipo de trabalho):

TExample = class(TObject)
public
  constructor Create;
  destructor Destroy; override;
end;

Posicione o cursor em algum lugar na classe e pressione Ctrl+Shift+C. Isto irá criar os corpos dos métodos não encontrados e mover o cursor para o primeiro corpo de método criado, então você somente inicia escrevendo o código da classe:

{ TExample }

constructor TExample.Create;
begin
  |
end;

destructor TExample.Destroy;
begin
  inherited Destroy;
end;

Nota: O '|' é o cursor e não é adicionado.

Dica: Você pode pular entre o método e seu corpo com Ctrl+Shift+Up.

Você pode ver, que a IDE adicionou o 'inherited Destroy' também. Isto é feito, se na definição do método da classe tiver 'override'.

Agora Adicione o método DoSomething:

TExample = class(TObject)
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
end;

Then press Ctrl+Shift+C and the IDE will add

procedure TExample.DoSomething(i: integer);
begin
  |
end;

Você pode ver, que o novo método é inserido entre o Create e Destroy, exatamente como na definição da classe. Este caminho os corpos mantém a mesma ordenação exata de suas definições na classe. Você pode definir a política de inserção no Environment > Codetools Options -> Code Creation.

Deduzir Propriedades
Adicione uma propriedade AnInteger:

TExample = class(TObject)
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
  property AnInteger: Integer;
end;

Pressione Ctrl+Shift+C e você irá ter:

procedure TExample.SetAnInteger(const AValue: integer);
begin
  |if FAnInteger=AValue then exit;
  FAnInteger:=AValue;
end;

A ferramente de deduzir código terá adicionado um acesso de escrita(método e seu corpo) e adicionado algum código. Pule para a classe com Ctrl+Shift+Up para ver a nova classe:

TExample = class(TObject)
private
  FAnInteger: integer;
  procedure SetAnInteger(const AValue: integer);
public
  constructor Create;
  procedure DoSomething(i: integer);
  destructor Destroy; override;
  property AnInteger: integer read FAnInteger write SetAnInteger;
end;

A propriedade foi extendida pelos acessos de leitura e escrita. A classe recebeu uma nova seção 'private' com uma variável 'FAnInteger' e o método 'SetAnInteger'.


...para fazer