Lazarus IDE Tools/pt
│
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