Lazarus IDE Tools/pt: what changed

Revision 0 to 1. Removed lines have a minus sign; added lines have a plus sign.

Title: Lazarus IDE Tools/pt

New		Line
1	+	## Introdução
2	+
3	+	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).
4	+
5	+	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.
6	+
7	+	## Sumário da tabela de teclas de atalho da IDE
8	+
9	+	\| \| \|
10	+	\|----\|----\|
11	+	\| [[Lazarus IDE Tools\|Declaration Jumping]] \| Ctrl+Click or Alt+Up (pula para a declaração do tipo ou variável) \|
12	+	\| [[Lazarus IDE Tools\|Method Jumping]] \| Ctrl+Shift+Up (alterna entre definição e corpo) \|
13	+	\| [[Lazarus IDE Tools\|Code Templates]] \| Ctrl+J \|
14	+	\| [[Lazarus IDE Tools\|Code Completion]] (Completa Classe) \| Ctrl+Shift+C \|
15	+	\| [[Lazarus IDE Tools\|Identifier Completion]] \| Ctrl+Space \|
16	+	\| [[Lazarus IDE Tools\|Word Completion]] \| Ctrl+W \|
17	+	\| [[Lazarus IDE Tools\|Parameter Hints]] \| Ctrl+Shift+Space \|
18	+
19	+	## Alternando no Método
20	+
21	+	Para pular entre o corpo do procedimento(begin..end) e a definição do procedimento (procedure Name;) use Ctrl+Shift+Up.
22	+
23	+	Por Exemplo:
24	+
25	+	`interface`\
26	+	\
27	+	`procedure DoSomething; // procedure definition`\
28	+	` `\
29	+	`implementation`\
30	+	` `\
31	+	`procedure DoSomething; // procedure body `\
32	+	`begin`\
33	+	`end;`
34	+
35	+	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'.
36	+
37	+	Isto trabalha entre métodos(procedimentos nas classes) muito bem.
38	+
39	+	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).
40	+
41	+	Por exemplo um procedimento com diferentes tipos de parâmetros:
42	+
43	+	`interface`\
44	+	\
45	+	`procedure DoSomething(p: char); // procedure definition`\
46	+	\
47	+	`implementation`\
48	+	` `\
49	+	`procedure DoSomething(p: string); // procedure body`\
50	+	`begin`\
51	+	`end;`
52	+
53	+	## Incluir Arquivos
54	+
55	+	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.
56	+
57	+	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.
58	+
59	+	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.
60	+
61	+	"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.
62	+
63	+	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á.
64	+
65	+	É claro que este mecanismo tem seus limites. Alguns arquivos incluídos o são duas ou mais. Por exemplo:lcl/include/winapih.inc.
66	+
67	+	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.;)
68	+
69	+	## Code Templates - Moldes de Código
70	+
71	+	"Code Templates" converte um identificador em um texto ou fragmento de código.
72	+
73	+	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.
74	+
75	+	Exemplo: Escreva um identificador 'classf', deixe o cursor à direita sobre o 'f' e pressione Ctrl+J. A 'classf' irá ser substituida por
76	+
77	+	`T = class(T)`\
78	+	`private`\
79	+	\
80	+	`public`\
81	+	` constructor Create;`\
82	+	` destructor Destroy; override;`\
83	+	`end;`
84	+
85	+	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.
86	+
87	+	O grande redutor de tempo é o template 'b'+Ctrl+J para begin..end.
88	+
89	+	## Sugestão de Parâmetros
90	+
91	+	Sugestão de parâmetros exibe uma caixa com as declarações dos parâmetros da lista corrente de parâmetros.
92	+
93	+	Por exemplo
94	+
95	+	` Canvas.FillRect(\|);`
96	+
97	+	Posicione o cursor entre os parenteses e pressione Ctrl+Shift+Space. Uma caixa de sugestões irá aparecer exibindo os parâmetros de FillRect.
98	+
99	+	## Deduzir Código (Code Completion)
100	+
101	+	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.
102	+
103	+	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".
104	+
105	+	Deduzir código combina várias funções poderosas. Exemplos:
106	+
107	+	- Deduzir Classe : completa propriedades, adiciona corpos aos métodos, adiciona variáveis e métodos de acesso privados
108	+	- Deduzir procedimento antecipadamente: adiciona corpo ao procedimento
109	+	- Deduzir associação de evento: completa associação de evento e adicina definição de método e seu corpo
110	+	- Deduzir declaração de variável: adiciona definição da variável local
111	+	- Reversa dedução da classe: adiciona declaração de um método para seu corpo.
112	+
113	+	Que função é usada, depende da posição do cursor no editor.
114	+
115	+	Deduzir código pode ser encontrado na IDE menu Edit -\> Complete Code e tem o atalho de teclado por padrão: Ctrl+Shift+C.
116	+
117	+	### Deduzir Classe (Class Completion)
118	+
119	+	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.
120	+
121	+	Por exemplo: Crie uma classe (veja Moldes de Código - Code Templates para salvar como um tipo de trabalho):
122	+
123	+	`TExample = class(TObject)`\
124	+	`public`\
125	+	` constructor Create;`\
126	+	` destructor Destroy; override;`\
127	+	`end;`
128	+
129	+	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:
130	+
131	+	`{ TExample }`\
132	+	\
133	+	`constructor TExample.Create;`\
134	+	`begin`\
135	+	` \|`\
136	+	`end;`\
137	+	\
138	+	`destructor TExample.Destroy;`\
139	+	`begin`\
140	+	` inherited Destroy;`\
141	+	`end;`
142	+
143	+	Nota: O '\\|' é o cursor e não é adicionado.
144	+
145	+	Dica: Você pode pular entre o método e seu corpo com Ctrl+Shift+Up.
146	+
147	+	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'.
148	+
149	+	Agora Adicione o método DoSomething:
150	+
151	+	`TExample = class(TObject)`\
152	+	`public`\
153	+	` constructor Create;`\
154	+	` procedure DoSomething(i: integer);`\
155	+	` destructor Destroy; override;`\
156	+	`end;`
157	+
158	+	Then press Ctrl+Shift+C and the IDE will add
159	+
160	+	`procedure TExample.DoSomething(i: integer);`\
161	+	`begin`\
162	+	` \|`\
163	+	`end;`
164	+
165	+	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.
166	+
167	+	Deduzir Propriedades\
168	+	Adicione uma propriedade AnInteger:
169	+
170	+	`TExample = class(TObject)`\
171	+	`public`\
172	+	` constructor Create;`\
173	+	` procedure DoSomething(i: integer);`\
174	+	` destructor Destroy; override;`\
175	+	` property AnInteger: Integer;`\
176	+	`end;`
177	+
178	+	Pressione Ctrl+Shift+C e você irá ter:
179	+
180	+	`procedure TExample.SetAnInteger(const AValue: integer);`\
181	+	`begin`\
182	+	` \|if FAnInteger=AValue then exit;`\
183	+	` FAnInteger:=AValue;`\
184	+	`end;`
185	+
186	+	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:
187	+
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;`
198	+
199	+	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'.
200	+
201	+	...para fazer
202	+
203	+	---
204	+	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