Lazarus IDE Tools/pt: what changed

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

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