Sign in Join
Wiki copytemporary

Lazarus IDE Tools/pt: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

OldNewLine
11## Introdução
22
33A 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).
44
55Porque 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.
66
77## Sumário da tabela de teclas de atalho da IDE
88
99| | |
1010|----|----|
1111| [[Lazarus IDE Tools|Declaration Jumping]] | Ctrl+Click or Alt+Up (pula para a declaração do tipo ou variável) |
1212| [[Lazarus IDE Tools|Method Jumping]] | Ctrl+Shift+Up (alterna entre definição e corpo) |
1313| [[Lazarus IDE Tools|Code Templates]] | Ctrl+J |
1414| [[Lazarus IDE Tools|Code Completion]] (Completa Classe) | Ctrl+Shift+C |
1515| [[Lazarus IDE Tools|Identifier Completion]] | Ctrl+Space |
1616| [[Lazarus IDE Tools|Word Completion]] | Ctrl+W |
1717| [[Lazarus IDE Tools|Parameter Hints]] | Ctrl+Shift+Space |
1818
1919## Alternando no Método
2020
2121Para pular entre o corpo do procedimento(begin..end) e a definição do procedimento (procedure Name;) use Ctrl+Shift+Up.
2222
2323Por Exemplo:
2424
25-`interface`\
25+``` pascal
26+interface
2627
27-`procedure DoSomething; // procedure definition`\
28-` `\
29-`implementation`\
30-` `\
31-`procedure DoSomething; // procedure body `\
32-`begin`\
33-`end;`
28+procedure DoSomething; // procedure definition
29+
30+implementation
31+
32+procedure DoSomething; // procedure body
33+begin
34+end;
35+```
3436
3537Se 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'.
3638
3739Isto trabalha entre métodos(procedimentos nas classes) muito bem.
3840
3941Dicas: '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).
4042
4143Por exemplo um procedimento com diferentes tipos de parâmetros:
4244
43-`interface`\
45+``` pascal
46+interface
4447
45-`procedure DoSomething(p: char); // procedure definition`\
48+procedure DoSomething(p: char); // procedure definition
4649
47-`implementation`\
48-`  `\
49-`procedure DoSomething(p: string); // procedure body`\
50-`begin`\
51-`end;`
50+implementation
51+
52+procedure DoSomething(p: string); // procedure body
53+begin
54+end;
55+```
5256
5357## Incluir Arquivos
5458
5559Incluir 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.
5660
5761Ao 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.
5862
5963Por 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.
6064
6165"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.
6266
6367Assim 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á.
6468
6569É claro que este mecanismo tem seus limites. Alguns arquivos incluídos o são duas ou mais. Por exemplo:lcl/include/winapih.inc.
6670
6771Saltar 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.;)
6872
6973## Code Templates - Moldes de Código
7074
7175"Code Templates" converte um identificador em um texto ou fragmento de código.
7276
7377Code 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.
7478
7579Exemplo: Escreva um identificador 'classf', deixe o cursor à direita sobre o 'f' e pressione Ctrl+J. A 'classf' irá ser substituida por
7680
77-`T = class(T)`\
78-`private`\
81+``` pascal
82+T = class(T)
83+private
7984
80-`public`\
81-`  constructor Create;`\
82-`  destructor Destroy; override;`\
83-`end;`
85+public
86+ constructor Create;
87+ destructor Destroy; override;
88+end;
89+```
8490
8591e 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.
8692
8793O grande redutor de tempo é o template 'b'+Ctrl+J para begin..end.
8894
8995## Sugestão de Parâmetros
9096
9197Sugestão de parâmetros exibe uma caixa com as declarações dos parâmetros da lista corrente de parâmetros.
9298
9399Por exemplo
94100
95-` Canvas.FillRect(|);`
101+```text
102+ Canvas.FillRect(|);
103+```
96104
97105Posicione o cursor entre os parenteses e pressione Ctrl+Shift+Space. Uma caixa de sugestões irá aparecer exibindo os parâmetros de FillRect.
98106
99107## Deduzir Código (Code Completion)
100108
101109Deduzir 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.
102110
103111Para 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".
104112
105113Deduzir código combina várias funções poderosas. Exemplos:
106114
107115- Deduzir Classe : completa propriedades, adiciona corpos aos métodos, adiciona variáveis e métodos de acesso privados
108116- Deduzir procedimento antecipadamente: adiciona corpo ao procedimento
109117- Deduzir associação de evento: completa associação de evento e adicina definição de método e seu corpo
110118- Deduzir declaração de variável: adiciona definição da variável local
111119- Reversa dedução da classe: adiciona declaração de um método para seu corpo.
112120
113121Que função é usada, depende da posição do cursor no editor.
114122
115123Deduzir código pode ser encontrado na IDE menu Edit -\> Complete Code e tem o atalho de teclado por padrão: Ctrl+Shift+C.
116124
117125### Deduzir Classe (Class Completion)
118126
119127A 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.
120128
121129Por exemplo: Crie uma classe (veja Moldes de Código - Code Templates para salvar como um tipo de trabalho):
122130
123-`TExample = class(TObject)`\
124-`public`\
125-`  constructor Create;`\
126-`  destructor Destroy; override;`\
127-`end;`
131+``` pascal
132+TExample = class(TObject)
133+public
134+ constructor Create;
135+ destructor Destroy; override;
136+end;
137+```
128138
129139Posicione 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:
130140
131-`{ TExample }`\
141+``` pascal
142+{ TExample }
132143
133-`constructor TExample.Create;`\
134-`begin`\
135-`  |`\
136-`end;`\
144+constructor TExample.Create;
145+begin
146+ |
147+end;
137148
138-`destructor TExample.Destroy;`\
139-`begin`\
140-`  inherited Destroy;`\
141-`end;`
149+destructor TExample.Destroy;
150+begin
151+ inherited Destroy;
152+end;
153+```
142154
143155Nota: O '\|' é o cursor e não é adicionado.
144156
145157Dica: Você pode pular entre o método e seu corpo com Ctrl+Shift+Up.
146158
147159Você pode ver, que a IDE adicionou o 'inherited Destroy' também. Isto é feito, se na definição do método da classe tiver 'override'.
148160
149161Agora Adicione o método DoSomething:
150162
151-`TExample = class(TObject)`\
152-`public`\
153-`  constructor Create;`\
154-`  procedure DoSomething(i: integer);`\
155-`  destructor Destroy; override;`\
156-`end;`
163+``` pascal
164+TExample = class(TObject)
165+public
166+ constructor Create;
167+ procedure DoSomething(i: integer);
168+ destructor Destroy; override;
169+end;
170+```
157171
158172Then press Ctrl+Shift+C and the IDE will add
159173
160-`procedure TExample.DoSomething(i: integer);`\
161-`begin`\
162-`  |`\
163-`end;`
174+``` pascal
175+procedure TExample.DoSomething(i: integer);
176+begin
177+ |
178+end;
179+```
164180
165181Você 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.
166182
167183**Deduzir Propriedades**\
168184Adicione uma propriedade AnInteger:
169185
170-`TExample = class(TObject)`\
171-`public`\
172-`  constructor Create;`\
173-`  procedure DoSomething(i: integer);`\
174-`  destructor Destroy; override;`\
175-`  property AnInteger: Integer;`\
176-`end;`
186+``` pascal
187+TExample = class(TObject)
188+public
189+ constructor Create;
190+ procedure DoSomething(i: integer);
191+ destructor Destroy; override;
192+ property AnInteger: Integer;
193+end;
194+```
177195
178196Pressione Ctrl+Shift+C e você irá ter:
179197
180-`procedure TExample.SetAnInteger(const AValue: integer);`\
181-`begin`\
182-`  |if FAnInteger=AValue then exit;`\
183-`  FAnInteger:=AValue;`\
184-`end;`
198+``` pascal
199+procedure TExample.SetAnInteger(const AValue: integer);
200+begin
201+ |if FAnInteger=AValue then exit;
202+ FAnInteger:=AValue;
203+end;
204+```
185205
186206A 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:
187207
188-`TExample = class(TObject)`\
189-`private`\
190-`  FAnInteger: integer;`\
191-`  procedure SetAnInteger(const AValue: integer);`\
192-`public`\
193-`  constructor Create;`\
194-`  procedure DoSomething(i: integer);`\
195-`  destructor Destroy; override;`\
196-`  property AnInteger: integer read FAnInteger write SetAnInteger;`\
197-`end;`
208+``` pascal
209+TExample = class(TObject)
210+private
211+ FAnInteger: integer;
212+ procedure SetAnInteger(const AValue: integer);
213+public
214+ constructor Create;
215+ procedure DoSomething(i: integer);
216+ destructor Destroy; override;
217+ property AnInteger: integer read FAnInteger write SetAnInteger;
218+end;
219+```
198220
199221A 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'.
200222
201223...para fazer
202224
203225---
204226*From the Free Pascal wiki, page "Lazarus IDE Tools/pt", as it stood on 2007-05-02 after a change by Aliotti, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).*

Back to history