Lazarus IDE Tools/pt

From Free Pascal wiki
Jump to: navigation, 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