Lazarus IDE Tools/fi: what changed

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

Old	New		Line
1	1		[[Lazarus Faq\|Lazarus]] IDE Tools on [[Free Pascal]]- lähdekoodin jäsentämis- ja muokkaustyökalu, jota kutsutaan "codetoolsiksi".
2	2
3	3		Tämä työkalu tarjoaa ominaisuuksia, kuten Find Declaration, Code Completion, Extraction, Moving Inserting ja Beautifying Pascal lähdekoodia. Nämä toiminnot voivat säästää paljon aikaa ja päällekkäistä työtä. Ne ovat muokattavissa ja jokainen ominaisuus on käytettävissä pikavalintojen kautta (katso editoriasetukset).
4	4
5	5		Koska ne työskentelevät pelkästään Pascal-lähdekoodeilla ja ymmärtävät FPC-, [[Delphi]]- ja [[Kylix]]- koodeja, ne eivät tarvitse käännettyjä käännösyksiköitä tai asennettua Borland / Embarcadero-kääntäjää. Delphi- ja FPC-koodia voidaan muokata samanaikaisesti useilla Delphi- ja FPC-versioilla. Tämä tekee Delphi-koodin siirtämisen FPC / Lazarukselle paljon helpompaa.
6	6
7	7		## Yhteenvetoraportti IDEn-pikanäppäimestä
8	8
9	9		\| \| \|
10	10		\|----\|----\|
11	11		\| [[Lazarus IDE Tools\|Declaration Jumping]] \| `Ctrl`+klikkaa tai `Alt`+`Up` (Hyppää tyypin tai muuttujan määrittelyyn) \|
12	12		\| [[Lazarus IDE Tools/fi\|Siirtyminen esittelyn ja toteuksen välillä]] \| `Ctrl`+`Shift`+`Up` (vaihtaa määritelmäosion ja toteutusosion välillä) \|
13	13		\| [[Lazarus IDE Tools\|Code Templates]] \| `Ctrl`+`J` \|
14	14		\| [[Lazarus IDE Tools\|Syncro Edit]] \| `Ctrl`+`J` (while text is selected) \|
15	15		\| [[Lazarus IDE Tools\|Code Completion]] (Class Completion) \| `Ctrl`+`Shift`+`C`, `Ctrl`+`Shift`+`X` for creating class fields instead of local variables \|
16	16		\| [[Lazarus IDE Tools\|Identifier Completion]] \| `Ctrl`+`space` \|
17	17		\| [[Lazarus IDE Tools\|Word Completion]] \| `Ctrl`+`W` \|
18	18		\| [[Lazarus IDE Tools/fi\|Parametrivihjeet]] \| `Ctrl`+`Shift`+`space` \|
19	19		\| [[Lazarus IDE Tools/fi\|Etsi kirjain kerrallaan]] \| `Ctrl`+`E` \|
20	20		\| [[Lazarus IDE Tools\|Rename Identifier]] \| `Ctrl`+`Shift`+`E` \|
21	21
22	22		## Siirtyminen esittelyn ja toteuksen välillä
23	23
24	24		Jos halutaan siirtyä aliohjelman rungon (begin..end) ja aliohjelman (procedure Name;) esittelyn välillä käytä näppäinyhdistelmää `Ctrl`+`Shift`+`Up`.
25	25
26	26		Esimerkiksi:
27	27
28	28		``` pascal
29	29		interface
30	30
31	31		procedure DoSomething; // Aliohjelman esittely
32	32
33	33		implementation
34	34
35	35		procedure DoSomething; // Aliohjelman määrittely
36	36		begin
37	37		end;
38	38		```
39	39
40	40		Jos kursori on aliohjelman toteutusosiossa ja painetaan `Ctrl`+`Shift`+`Up` niin kursori siirtyy aliohjelman esittelyyn. Painamalla `Ctrl`+`Shift`+`Up` uudelleen niin tullan takaisin määrittelyyn heti 'begin' sanan jälkeiseen kohtaan.
41	41
42	42		Tämä toimii samanlailla myös luokan (class) metodin esittelyn ja toteutuksen välillä.
43	43
44	44		Vihje: Siirtyminen tapahtuu siihen aliohjelmaan jossa on samat parametrit. Jos ei löydy täysin samaa niin siirtyminen tapahtuu sopivampaan eli siihen jossa on vähiten eroja (Tälläistä toimintaa ei välttämättä löydy esim. Delphistä).
45	45
46	46		Esimerkki aliohjelmasta joiden esittelyssä ja toteutuksessa on erilaiset parametrityypit:
47	47
48	48		``` pascal
49	49		interface
50	50
51	51		procedure DoSomething(p: char); // procedure definition
52	52
53	53		implementation
54	54
55	55		procedure DoSomething(p: string); // procedure body
56	56		begin
57	57		end;
58	58		```
59	59
60	60		Siirtyminen toteuksen ja niiden esittelyjen välillä 'string' avainsana. Tätä voi käyttää kun haluaa uudelleen nimetä metodin ja/tai muuttaa parametrejä.
61	61
62	62		Esimerkiksi: uudelleen nimetään 'DoSomething' -\> 'MakeIt':ksi:
63	63
64	64		``` pascal
65	65		interface
66	66
67	67		procedure MakeIt; // procedure definition
68	68
69	69		implementation
70	70
71	71		procedure DoSomething; // procedure body
72	72		begin
73	73		end;
74	74		```
75	75
76	76		Kun siirrytään 'MakeIt':n esittelystä toteukseen (joka on siis vielä väärän niminen). Lazarus etsii sopivaa toteustusta, jota ei löydy, sen jälkeen muita sopivia. Jos nimeä on muutettu ainoastaan yhdestä aliohjelmasta jolloin on yksi toteutus josta ei löydy määrittelyä niin tällöin siirrytään siihen. Näin voidaan yksinkertaisesti vaihtaa nimeä tai parametrejä.
77	77
78	78		## Include Files
79	79
80	80		Include files ovat tiedostoja, jotka on lisätty lähdekoodiin {\$I filename} tai {\$INCLUDE filename} kääntäjän ohjeella. Lazarus ja FPC käyttävät usein include tiedostoja vähentämään redundanssia ja välttävät lukemattomia {\$ IFDEF} -rakenteita, joita tarvitaan eri alustojen tukemiseen.
81	81
82	82		Toisin kuin Delphi, Lazarus IDE: llä on täysi tuki myös include-tiedostoihin. Voit esimerkiksi hypätä .pas-tiedoston aliohjelmasta sisällytetyn tiedoston toteutukseen. Kaikki codetools osiot, kuten koodin täydentäminen, käsittelevät include tiedostoja erityistapauksina.
83	83
84	84		Esimerkiksi: Kun koodin täydentäminen lisää uuden metodin toteuksen rungon toisen metodin rungon taakse, se pitää ne molemmissa samassa tiedostossa. Tällä tavalla voit laittaa kokoluokan toteutuksia include-tiedostoihin, kuten LCL tekee lähes kaikille kontrolleille.
85	85
86	86		Mutta aloittelijoille löytyy ansa: Jos avataan include tiedosto ensimmäisen kerran ja yritetään siirtyä esittelyn ja toteuksen välillä tai löytää määrittely niin saadaan virhe. IDE ei vielä tiedä, mihin yksikköön sisällytettävä tiedosto kuuluu. Sillä on ensin avattava käännösyksikkö.
87	87
88	88		Niin pian kuin IDE analysoi käännösyksikön, se analysoi include kääntäjänohjeet siellä ja IDE muistaa tämän suhteen. Se tallentaa nämä tiedot poistumiseen ja projektin tallentamiseen ~ / .lazarus / includelinks.xml. Kun seuraavan kerran avataan tämän include tiedosto ja siirrytään toteuksen ja niiden esittelyjen välillä, IDE avaa laitteen sisäisesti ja siirtyminen toimii. Voidaan myös viitata IDE: een asettamalla
89	89
90	90		``` pascal
91	91		{%mainunit yourunit.pas}
92	92		```
93	93
94	94		tiedoston yourinclude.inc alkuun.
95	95
96	96		Tällä mekanismilla on rajoituksia. Joihinkin tiedostoihin sisältyy kaksi tai useampia include tiedostoja. Esimerkiksi: lcl/include/winapih.inc.
97	97
98	98		Se miten siirrytään aliohjelman/metodin määrityksistä niiden include tiedostoihin riippuu viimeisestä toiminnosta. Jos ollaan työskennelty lcl / lclintf.pp: llä, IDE siirtyy winapi.inc: hen. Jos ollaan työskennelty lcl / interfacebase.pp: llä niin se siirtyy lcl / include / interfacebase.inc (tai johonkin muuhun include tiedostoon). Jos työskennellään molemmilla, niin se saadaan sekaisin. ;)
99	99
100	100		## Code Templates
101	101
102	102		Code Templates muuntaa tietyn tunnisteen tekstiksi tai koodin palaseksi.
103	103
104	104		Code Templates oletuspikanäppäin on `Ctrl`+`J`. Kun kirjoittaa sopivan tunnisteen, painaa `Ctrl`+`J` niin tunniste korvataan tunnisteella määritellyllä tekstillä. Code Templates voidaan määritellä Työkalut -\> Optiot -\> CodeTools.
105	105
106	106		Esim: Kirjoita teksti 'classf', jätä kursori kirjaimen 'f' oikealle puolen ja paina `Ctrl`+`J`. Teksti 'classf' korvautuu riveillä
107	107
108	108		``` pascal
109	109		T = class(T)
110	110		private
111	111
112	112		public
113	113		constructor Create;
114	114		destructor Destroy; override;
115	115		end;
116	116		```
117	117
118	118		ja kursori on kirjaimen 'T' takana. Luettelo kaikista Code Template vaihtoehdoista saadaan sijoittamalla kohdistin välilyönnin perään (ei tunnisteeseen) ja painamalla `Ctrl`+`J`. Luettelo kaikista Code Template vaihtoehdoista ponnahtaa esiin. Käytä kursorinäppäimiä tai kirjoita joitain merkkejä valitaksesi. Painamalla `Return` luodaan valittu malli ja `Esc` sulkee ponnahdusikkunan.
119	119
120	120		Suurin ajan säästäjä on Code Template 'b'+`Ctrl`+`J` varatuille sanoille begin..end.
121	121
122	122		## Parametrivihjeet
123	123
124	124		Parametrivihjeet näyttävät vihjeruutu, jossa on parametriluettelot kutsun parametrilistalle.
125	125
126	126		Esimerkiksi
127	127
128	128		``` pascal
129	129		Canvas.FillRect(\|);
130	130		```
131	131
132	132		Aseta kursori sulkujen väliin ja paina `Ctrl`+`Shift`+`space`. Näyttöön tulee vihjeruutu, joka näyttää FillRectin parametrit.
133	133
134	134		![](/wiki-images/c/c8/Parameterhints1.png)
135	135
136	136		Versiosta 0.9.31 asti on ollut jokaisen Parametrivihjeen oikealla puolella painike puuttuvien parametrien lisäämiseksi. Tämä kopioi parametrin nimet valitusta vihjeestä kohdistimen kohtaan.
137	137
138	138		![](/wiki-images/4/48/Parameterhints2.png)
139	139
140	140		Vihje: Käytä Variable Declaration Completion määrittääksesi muuttujia.
141	141
142	142		> Note: Pikanäppäimen nimi on "Show code context".
143	143
144	144		## Etsi kirjain kerrallaan
145	145
146	146		Etsi kirjain kerrallaan muuttaa lähdekoodieditorin tilarivin. Kirjoita joitain kirjaimia ja editori etsii ja korostaa välittömästi kaikki niiden esiintymät tekstissä. Pikanäppäin on `Ctrl`+`e`.
147	147
148	148		- Esimerkiksi painamalla `e`. Se etsii ja korostaa kaikki 'e':n esiintymät.
149	149		- Sitten painetaan `t`. Se etsii ja korostaa kaikki esiintymät "et" ja niin edelleen.
150	150		- Seuraavaan esiintymään voidaan siirtyä painamalla `F3` (tai `Ctrl`+`e` kun ollaan haussa) ja edelliseen painamalla `Shift`+`F3`.
151	151		- Backspace eli `<-` poistaa edellisen merkin
152	152		- `Return` lopettaa haun lisäämättä uutta riviä editoriin.
153	153		- Viimeistä hakua voidaan jatkaa painamalla `Ctrl`+`e` -näppäintä toisen kerran välittömästi sen jälkeen, kun olet käynnistänyt etsinnän painamalla `Ctrl`+`e`. Toisin sanoen hakutermi on vielä tyhjä.
154	154		- Liittäminen `Ctrl`+`V` liittää tekstin leikepöydältä nykyiseen hakutekstiin (Ollut Lazarus versiosta 0.9.27 lähtien).
155	155
156	156		### Vihje: Nopea haku tunnistimella käyttäen etsi kirjain kerrallaan toimintoa
157	157
158	158		- Aseta tekstikohdistin tunnisteeseen (älä valitse mitään)
159	159		- Paina `Ctrl`+`C`. Lähdekoodieditori valitsee tunnuksen ja kopioi sen leikepöydälle
160	160		- Paina `Ctrl`+`E` aloittaaksesi etsi kirjain kerrallaan toiminnon.
161	161		- Paina `Ctrl`+`V` joka liittää tekstin leikepöydältä nykyiseen hakutekstiin.
162	162		- Käyttämällä `F3` ja `Shift`+`F3` siirtyäksesi nopeasti seuraavaan / edelliseen.
163	163		- Lopeta haku painamalla mitä tahansa näppäintä (esimerkiksi kohdistinta vasemmalle tai oikealle).
164	164
165	165		## Syncro Edit
166	166
167	167		Syncro Edit:llä voidaan muokata samanaikaisesti kaikkia sanojen esiintymiä (synkronoitu). Yksinkertaisesti voidaan muokata sanaa yhdessä paikassa ja kun sitä muutetaan niin kaikki muut sanan tapahtumat päivittyvät.
168	168
169	169		Syncro Edit toimii kaikkien valitun alueen sanoilla:
170	170
171	171		- Valitse tekstilohko
172	172		- Paina `Ctrl`+`J` tai klikkaa kuvaketta reunuksessa. (Tämä toimii vain, jos valittu sana esiintyy useamman kerran).
173	173		- Valitse muokattava sana `tab` näppäimellä (jos valittu sana esiintyy useamman kerran)
174	174		- Muokkaa sanaa
175	175		- Lopeta painamalla `Esc` näppäimellä
176	176
177	177		Katso animoitu esimerkki [[New IDE features since\|tästä]]
178	178
179	179		> Note: `Ctrl`+`J` käytetään myös template edit:ssä. Se vaihtaa merkitystään, jos valitset jonkin tekstin.
180	180
181	181		## Etsi sanan seuraava esiintymiskohta/ Etsi sanan edellinen esiintymiskohta
182	182
183	183		Nämä kaksi funktiota löytyvät lähdekoodieditorin ponnahdusvalikosta
184	184
185	185		- Lähdekoodieditori / ponnahdusvalikko / Etsi / Etsi sanan seuraava esiintymiskohta
186	186		- Lähdekoodieditori / ponnahdusvalikko / Etsi / Etsi sanan edellinen esiintymiskohta
187	187
188	188		Näihin voidaan määrittää pikanäppäimet editorin asetuksissa.
189	189
190	190		## Code Completion
191	191
192	192		Code Completion löytyy IDE-valikosta Edit -\> Complete Code ja sen pikanäppäin on `Ctrl`+`Shift`+`C`.
193	193
194	194		Delphi-käyttäjille: Delphi nimeää "code completion" funktioksi, joka näyttää tunnistetietojen luettelon kursorin kohdalla lähdekoodissa ( `Ctrl`+`Space` ). Lazaruksessa se on "Identifier completion".
195	195
196	196		Code Completion yhdistää useita tehokkaita toimintoja. esimerkkejä:
197	197
198	198		- Class Completion: täydentää ominaisuuksia(property), lisää / päivittää metodien runkoja, lisää yksityisiä muuttujia ja yksityisiä käyttömetodeja
199	199		- Forward Procedure Completion: Lisää aliohjelmien runkoja
200	200		- Event Assignment Completion: Tapahtumien tekeminen ja lisää metodit määrittelyt ja niiden rungot
201	201		- Variable Declaration Completion: lisää paikalliset muuttujan määrittelyt
202	202		- Procedure Call Completion: Lisää uusia aliohjelmia
203	203		- Reversed procedure completion: Lisää aliohjelman määrittelyn
204	204		- Reversed Class Completion: Lisää metodien määrittelyn
205	205
206	206		Mikä toiminto on käytössä, riippuu kohdistimen sijainnista editorissa ja sitä selitetään alla.
207	207
208	208		Code Completion löytyy IDE-valikosta Edit -\> Complete Code ja sen pikanäppäin on `Ctrl`+`Shift`+`C`.
209	209
210	210		### Class Completion
211	211
212	212		Tehokkain koodin täydentäjä ominaisuus on "Class Completion". Kun kirjoitetaan luokkaa (class) johon lisätään metodeja ja ominaisuuksia niin Code Completion lisää metodien toteutuksen rungot, ominaisuuksien käyttörutiinit / muuttujat ja yksityiset muuttujat.
213	213
214	214		Esimerkiksi: Luo luokka eli class (Katso Code Templates jonka avulla voidaan säästää kirjoittamistyötä):
215	215
216	216		``` pascal
217	217		TExample = class(TObject)
218	218		public
219	219		constructor Create;
220	220		destructor Destroy; override;
221	221		end;
222	222		```
223	223
224	224		Aseta kohdistin johonkin kohtaan luokkaan ja paina `Ctrl`+`Shift`+`C`. Tämä luo metodien puuttuvat rungot ja siirtää kohdistimen ensimmäiselle luodulle metodin rungolle, joten voidaan aloittaa luokan koodin kirjoittaminen:
225	225
226	226		``` pascal
227	227		{ TExample }
228	228
229	229		constructor TExample.Create;
230	230		begin
231	231		\|
232	232		end;
233	233
234	234		destructor TExample.Destroy;
235	235		begin
236	236		inherited Destroy;
237	237		end;
238	238		```
239	239
240	240		> Note: Merkki '\\|' on kohdistin eikä sitä lisätä.
241	241
242	242		Vihje: On mahdollista siirtyä metodin ja sen rungon välillä `Ctrl`+`Shift`+`Up`.
243	243
244	244		Nähdään, että IDE lisäsi myös 'inherited Destroy' kutsun. Tämä tehdään, jos luokan määritelmässä on '[[Override\|override]]' avainsana.
245	245
246	246		Nyt lisätään metodi DoSomething:
247	247
248	248		``` pascal
249	249		TExample = class(TObject)
250	250		public
251	251		constructor Create;
252	252		procedure DoSomething(i: integer);
253	253		destructor Destroy; override;
254	254		end;
255	255		```
256	256
257	257		Sitten paina `Ctrl`+`Shift`+`C` ja IDE lisää
258	258
259	259		``` pascal
260	260		procedure TExample.DoSomething(i: integer);
261	261		begin
262	262		\|
263	263		end;
264	264		```
265	265
266	266		Nähdään että uusi metodin runko on sijoitettu Create ja Destroy -toimintojen väliin aivan kuten luokkamäärittelyssä. Tällä tavoin rungot pitävät saman loogisen järjestyksen kuin on määritetty. Lisäyskäytäntö voidaan määrittää Työkalut\> Asetukset -\> Codetools -\> Code Creation.
267	267
268	268		Täydennä ominaisuuksilla\
269	269		Lisää ominaisuus AnInteger:
270	270
271	271		``` pascal
272	272		TExample = class(TObject)
273	273		public
274	274		constructor Create;
275	275		procedure DoSomething(i: integer);
276	276		destructor Destroy; override;
277	277		property AnInteger: Integer;
278	278		end;
279	279		```
280	280
281	281		Paina `Ctrl`+`Shift`+`C` jolloin saadaan:
282	282
283	283		``` pascal
284	284		procedure TExample.SetAnInteger(const AValue: integer);
285	285		begin
286	286		\|if FAnInteger=AValue then exit;
287	287		FAnInteger:=AValue;
288	288		end;
289	289		```
290	290
291	291		code completion on lisännyt kirjoitusoikeuden muokkaajan ja lisännyt yleistä koodia. Siirry luokalle painamalla `Ctrl`+`Shift`+`Up` nähdäksesi uuden luokan:
292	292
293	293		``` pascal
294	294		TExample = class(TObject)
295	295		private
296	296		FAnInteger: integer;
297	297		procedure SetAnInteger(const AValue: integer);
298	298		public
299	299		constructor Create;
300	300		procedure DoSomething(i: integer);
301	301		destructor Destroy; override;
302	302		property AnInteger: integer read FAnInteger write SetAnInteger;
303	303		end;
304	304		```
305	305
306	306		Ominaisuutta laajennettiin Read (luku) ja Write (kirjoitus)-ominaisuuden avulla. Luokka sai uuden 'private' osion johon tuli muuttuja "FAnInteger" ja metodi "SetAnInteger". Yleisen Delphi-tyylisen käytännön mukaan yksityisiin muuttujiin lisätään 'F' kirjain ja kirjoitusmetodiin 'Set'. Tätä ominaisuutta voidaan muuttaa Työkalut -\> Valinnat\> Codetools -\> Code Creation.
307	307
308	308		Luodaan property:n vain luku (read) :
309	309
310	310		``` pascal
311	311		property PropName: PropType read;
312	312		```
313	313
314	314		Laajennetaan
315	315
316	316		``` pascal
317	317		property PropName: PropType read FPropName;
318	318		```
319	319
320	320		Luodaan property:n vain kirjoitus (write) :
321	321
322	322		``` pascal
323	323		property PropName: PropType write;
324	324		```
325	325
326	326		Laajennetaan
327	327
328	328		``` pascal
329	329		property PropName: PropType write SetPropName;
330	330		```
331	331
332	332		Luodaan property:n vain luku (read) ja lukumetodi:
333	333
334	334		``` pascal
335	335		property PropName: PropType read GetPropName;
336	336		```
337	337
338	338		Säilytetään ja GetPropName-funktio lisätään:
339	339
340	340		``` pascal
341	341		function GetpropName: PropType;
342	342		```
343	343
344	344		Luodaan property jossa on stored määrite:
345	345
346	346		``` pascal
347	347		property PropName: PropType stored;
348	348		```
349	349
350	350		Laajennetaan
351	351
352	352		``` pascal
353	353		property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
354	354		```
355	355
356	356		Koska stored käytetään tietovirtojen lukemiseen ja kirjoittamiseen, ne myös lisätään automaattisesti.
357	357
358	358		Vihje: Identifier completion tunnistaa myös puutteelliset ominaisuudet ja ehdottaa oletusnimiä. Esimerkiksi:
359	359
360	360		``` pascal
361	361		property PropName: PropType read \|;
362	362		```
363	363
364	364		Aseta kohdistin yksi välilyönti read-avainsanan taakse ja paina `Ctrl`+`Space`. Se antaa muuttujan "FPropName" ja aliohjelman "SetPropName".
365	365
366	366		### Forward Procedure Completion
367	367
368	368		"Forward Procedure Completion" on osa Code Completion ja lisää aliohjelman rungon. Sitä käytetään, kun kohdistin on aliohjelman esittelyssä. It is invoked, when the cursor is on a forward defined procedure.
369	369
370	370		Esimerkiksi: Lisätään uusi aliohjelma interface osioon:
371	371
372	372		``` pascal
373	373		procedure DoSomething;
374	374		```
375	375
376	376		Aseta kohdistin sille ja paina `Ctrl`+`Shift`+`C`. Se luo toteutusosassa (implementation):
377	377
378	378		``` pascal
379	379		procedure DoSomething;
380	380		begin
381	381		\|
382	382		end;
383	383		```
384	384
385	385		Vihje: Voidaan siirtyä aliohjelman esittelyn ja sen rungon välillä painamalla`Ctrl`+`Shift`+`Up`.
386	386
387	387		Uusi aliohjelman runko lisätään luokkametodien eteen. Jos rajapinnassa on jo joitain aliohjelmia, IDE yrittää säilyttää järjestyksen. Esimerkiksi:
388	388
389	389		``` pascal
390	390		procedure Proc1;
391	391		procedure Proc2; // new proc
392	392		procedure Proc3;
393	393		```
394	394
395	395		Jos aliohjelmien Proc1: n ja Proc3: n rungot ovat jo olemassa, niin Proc2 runko lisätään Proc1: n ja Proc3: n rungon väliin. Tämä toiminto voidaan asettaa Työkalut -\> Valinnat -\> Codetools -\> Code Creation.
396	396
397	397		Useita aliohjelmia:
398	398
399	399		``` pascal
400	400		procedure Proc1_Old; // runko on jo olemassa
401	401		procedure Proc2_New; // runkoa ei ole vielä
402	402		procedure Proc3_New; // "
403	403		procedure Proc4_New; // "
404	404		procedure Proc5_Old; // runko on jo olemassa
405	405		```
406	406
407	407		Code Completion lisää kaikki kolme (3) aliohjelman runkoa (Proc2_New, Proc3_New, Proc4_New).
408	408
409	409		Miksi kutsua "Forward Procedure Completion"?
410	410
411	411		Koska se ei toimi vain interface osiossa määriteltyjen aliohjelmien, vaan myös "forward" -määritteen kanssa. Ja koska codetools käsittelee interface osiossa olevia aliohjelmia niin, että niillä on implisiittinen 'forward' -määrite.
412	412
413	413		### Event Assignment Completion
414	414
415	415		"Event Assignment Completion" on osa Code Completion:a. Se täydentää yhden tapahtuman := \\| lauseen. Sitä kutsutaan, kun kohdistin on järjestetty tapahtumalle.
416	416
417		-	~~`completes a single Event:=\| statement. It is invoked, when the cursor is behind an assignment to an event.`~~
	417	+	``` pascal
	418	+	completes a single Event:=\| statement. It is invoked, when the cursor is behind an assignment to an event.
	419	+	```
418	420
419	421		Esimerkiksi: Kirjoita lomakkeen FormCreate-tapahtumaan rivi 'OnPaint:=':
420	422
421	423		``` pascal
422	424		procedure TForm1.Form1Create(Sender: TObject);
423	425		begin
424	426		OnPaint:=\|
425	427		end;
426	428		```
427	429
428	430		Kursorin paikka on merkitty '\\|' -kirjaimella eikä kyseistä kirjainta kirjoiteta. Code completion kutsutaan painamalla `Ctrl`+`Shift`+`C`. Lause täydennetään
429	431
430	432		``` pascal
431	433		OnPaint:=@Form1Paint;
432	434		```
433	435
434	436		ja uusi metodi Form1Paint lisätään TForm1 luokkaan. Tällöin luokka valmistuu ja saadaan myös:
435	437
436	438		``` pascal
437	439		procedure TForm1.Form1Paint(Sender: TObject);
438	440		begin
439	441		\|
440	442		end;
441	443		```
442	444
443	445		Tämä toimii samalla tavoin kuin lisätään menetelmiä komponenttimuokkaimella.
444	446
445	447		> Note: Kursori on sijoitettava heti ':=' saa arvokseen operatorin jälkeen. Jos kursori sijoitetaan osoittamaan esim. OnPaint tunnisteeseen niin koodin suorittaminen viittaa "Local Variable Completion", joka epäonnistuu, koska OnPaint on jo määritetty.
446	448
447	449		Vinkit:\
448	450		*Uuden metodin oletusarvoinen näkyvyys voidaan valita Työkalut / Asetukset / Codetools / Luokan täydennys / Default section of methods (versiosta 1.8 lähtien)
449	451
450	452		- Uuden metodin nimen voi määrittää itse. Esimerkiksi:
451	453
452	454		``` pascal
453	455		OnPaint:=@ThePaintMethod;
454	456		```
455	457
456	458		Versiosta 0.9.31 Lazarus täydentää aliohjelman parametreja. Esimerkiksi
457	459
458	460		``` pascal
459	461		procedure TForm1.FormCreate(Sender: TObject);
460	462		var
461	463		List: TList;
462	464		begin
463	465		List:=TList.Create;
464	466		List.Sort(@MySortFunction\|);
465	467		end;
466	468		```
467	469
468	470		Sijoita kursori 'MySortFunction' kohtaan ja paina `Ctrl`+`Shift`+`C` niin saadaan uusi aliohjelma:
469	471
470	472		``` pascal
471	473		function MySortFunction(Item1, Item2: Pointer): Integer;
472	474		begin
473	475		\|
474	476		end;
475	477
476	478		procedure TForm1.FormCreate(Sender: TObject);
477	479		var
478	480		List: TList;
479	481		begin
480	482		List:=TList.Create;
481	483		List.Sort(@MySortFunction);
482	484		end;
483	485		```
484	486
485	487		### Variable Declaration Completion
486	488
487	489		"Variable Declaration Completion" on osa Code Completion:a. Se lisää paikallisen muuttujan määritelmän tunnisteelle := Term; lause. Sitä kutsutaan, kun kohdistin on osoittaa parametria tai tunnistetta.
488	490
489	491		Esimerkiksi:
490	492
491	493		``` pascal
492	494		procedure TForm1.Form1Create(Sender: TObject);
493	495		begin
494	496		i:=3;
495	497		end;
496	498		```
497	499
498	500		Kursorin paikka on tunnisteessa 'i' tai sen jälkeen. Painamalla `Ctrl`+`Shift`+`C` saadaan:
499	501
500	502		``` pascal
501	503		procedure TForm1.Form1Create(Sender: TObject);
502	504		var
503	505		i: Integer;
504	506		begin
505	507		i:=3;
506	508		end;
507	509		```
508	510
509	511		Toiminto ensin tarkastaa onko tunnistetta 'i' jo määritelty. Jos sitä ei ole niin lisää määrittelyn 'var i: integer;'. Tunnisteen tyyppi arvatellaan ": =" operaattorista. Kokonaisluvun, kuten 3 oletustyyppinä on Integer.
510	512
511	513		Toinen esimerkki:
512	514
513	515		``` pascal
514	516		type
515	517		TWhere = (Behind, Middle, InFront);
516	518
517	519		procedure TForm1.Form1Create(Sender: TObject);
518	520		var
519	521		a: array[TWhere] of char;
520	522		begin
521	523		for Where:=Low(a) to High(a) do writeln(a[Where]);
522	524		end;
523	525		```
524	526
525	527		Kursorin paikka on 'Where'-sanan kohdalla ja painetaan `Ctrl`+`Shift`+`C` niin saadaan:
526	528
527	529		``` pascal
528	530		procedure TForm1.Form1Create(Sender: TObject);
529	531		var
530	532		a: array[TWhere] of char;
531	533		Where: TWhere;
532	534		begin
533	535		for Where:=Low(a) to High(a) do writeln(a[Where]);
534	536		end;
535	537		```
536	538
537	539		Lazarus on versiosta 0.9.11 lähtien myös täydentänyt parametreja. Esimerkiksi
538	540
539	541		``` pascal
540	542		procedure TForm1.FormPaint(Sender: TObject);
541	543		begin
542	544		with Canvas do begin
543	545		Line(x1,y1,x2,y2);
544	546		end;
545	547		end;
546	548		```
547	549
548	550		Sijoita kursori 'x1' ja paina `Ctrl`+`Shift`+`C` niin saadaan:
549	551
550	552		``` pascal
551	553		procedure TForm1.FormPaint(Sender: TObject);
552	554		var
553	555		x1: integer;
554	556		begin
555	557		with Canvas do begin
556	558		Line(x1,y1,x2,y2);
557	559		end;
558	560		end;
559	561		```
560	562
561	563		Lazarus on versiosta 0.9.31 täydentänyt osoittimen parametrit. Esimerkiksi
562	564
563	565		``` pascal
564	566		procedure TForm1.FormCreate(Sender: TObject);
565	567		begin
566	568		CreateIconIndirect(@IconInfo);
567	569		end;
568	570		```
569	571
570	572		Sijoita kursori 'IconInfo':n ja paina `Ctrl`+`Shift`+`C` niin saadaan:
571	573
572	574		``` pascal
573	575		procedure TForm1.FormCreate(Sender: TObject);
574	576		var
575	577		IconInfo: TIconInfo;
576	578		begin
577	579		CreateIconIndirect(@IconInfo);
578	580		end;
579	581		```
580	582
581	583		Kaikissa edellä olevissa esimerkeissä voit käyttää `Ctrl`+`Shift`+`X`-näppäintä näyttääksesi koodin luomisen valintaikkunan, jossa voit asettaa lisää vaihtoehtoja.
582	584
583	585		### Procedure Call Completion
584	586
585	587		Code completion voi luoda uuden aliohjelman sen kutsusta.
586	588
587	589		Oletataan että kirjoitettiin vain lause "DoSomething(Width);"
588	590
589	591		``` pascal
590	592		procedure SomeProcedure;
591	593		var
592	594		Width: integer;
593	595		begin
594	596		Width:=3;
595	597		DoSomething(Width);
596	598		end;
597	599		```
598	600
599	601		Sijoita kursori tekstiin "DoSomething" ja paina `Ctrl`+`Shift`+`C` niin saadaan:
600	602
601	603		``` pascal
602	604		procedure DoSomething(aWidth: LongInt);
603	605		begin
604	606
605	607		end;
606	608
607	609		procedure SomeProcedure;
608	610		var
609	611		Width: integer;
610	612		begin
611	613		Width:=3;
612	614		DoSomething(Width);
613	615		end;
614	616		```
615	617
616	618		Se ei vielä luo funktioita tai metodeja.
617	619
618	620		### Reversed Class Completion
619	621
620	622		"Reversed Class Completion" on osa Code Completion toimintaa. Se lisää yksityisen metodin ilmoituksen nykyiselle metodiryhmälle. Sitä kutsutaan, kun kursori on metodin rungossa, jota ei ole vielä määritelty luokassa. Tämä ominaisuus on saatavana Lazarus 0.9.21 versiosta alkaen.
621	623
622	624		Esimerkiksi:
623	625
624	626		``` pascal
625	627		procedure TForm1.DoSomething(Sender: TObject);
626	628		begin
627	629		end;
628	630		```
629	631
630	632		DoSomething-metodia ei ole vielä määritelty TForm1: ssä. Paina `Ctrl`+`Shift`+`C` ja IDE lisää aliohjelman "procedure DoSomething (Sender: TObject);" TForm1: n yksityisiin metodeihin.
631	633
632	634		Delphi käyttäjille: Class completion toimii Lazaruksen mukaan aina yhdellä tavalla: Luokan käyttöliittymästä toteutukseen tai taaksepäin / päinvastoin luokan toteutuksesta käyttöliittymään. Delphi kutsuu aina molempiin suuntiin. Delphi-tapa on haitta, että jos on typo se luo helposti uuden tynkä metodin ilman huomaamatta.
633	635
634	636		### Kommentit ja Code Completion
635	637
636	638		Code completion yrittää pitää kommentteja, johon ne kuuluvat. Esimerkiksi:
637	639
638	640		``` pascal
639	641		FList: TList; // list of TComponent
640	642		FInt: integer;
641	643		```
642	644
643	645		Kun lisätään uusi muuttuja FListin ja FInt: n välillä, kommentti pidetään FList-rivillä. Sama pätee myös
644	646
645	647		``` pascal
646	648		FList: TList; { list of TComponent
647	649		Tämä on usean rivin kommentti, alkaen
648	650		FList-riviltä, joten codetools olettaa sen kuuluvan
649	651		FLIst-riviin ja ei riko tätä
650	652		suhdetta. Koodi lisätään kommentin taakse. }
651	653		FInt: integer;
652	654		```
653	655
654	656		Jos kommentti alkaa seuraavalla rivillä, sitä käsitellään kuin se kuuluu alla olevaan koodiin. Esimerkiksi:
655	657
656	658		``` pascal
657	659		FList: TList; // list of TComponent
658	660		{ Tämä kommentti kuuluu alla olevaan lauseeseen.
659	661		Uusi koodi lisätään tämän kommentin yläpuolelle ja
660	662		FList-rivin kommentin taakse. }
661	663		FInt: integer;
662	664		```
663	665
664	666		### Metodin päivitys
665	667
666	668		Normaalisti luokan täydennys lisää kaikki puuttuvat metodin rungot (Ollut versiosta 0.9.27 lähtien). Jos täsmälleen yksi metodi eroaa luokan ja rungon välillä, niin metodin runko päivitetään. Esimerkiksi: On metodi DoSomething DoSomething.
667	669
668	670		``` pascal
669	671		public
670	672		procedure DoSomething;
671	673		end;
672	674
673	675		procedure TForm.DoSomething;
674	676		begin
675	677		end;
676	678		```
677	679
678	680		Nyt lisätään parameteri:
679	681
680	682		``` pascal
681	683		public
682	684		procedure DoSomething(i: integer);
683	685		end;
684	686		```
685	687
686	688		Code Completion kutsuminen (`Ctrl`+`Shift`+`C`) päivittää metodin rungon ja uusi parametri kopioidaan:
687	689
688	690		``` pascal
689	691		procedure TForm.DoSomething(i: integer);
690	692		begin
691	693		end;
692	694		```
693	695
694	696		## Refactoring
695	697
696	698		### Käännä sijoitus päinvastaiseksi
697	699
698	700		Abstract
699	701
700	702		"Käännä sijoitus päinvastaiseksi" ottaa valitut pascal-lauseet ja invertoi kaikki tämän koodin tehtävät. Tämä työkalu on hyödyllinen "tallentaa" -koodin muuttamiseksi "lataukseksi" ja käänteiseksi.
701	703
702	704		Esimerkki:\
703	705
704	706		``` pascal
705	707		procedure DoSomething;
706	708		begin
707	709		AValueStudio:= BValueStudio;
708	710		AValueAppartment :=BValueAppartment;
709	711		AValueHouse:=BValueHouse;
710	712		end;
711	713		```
712	714
713	715		Valitaan rivit, joissa on tehtäviä (sanojen begin ja end väliset) ja käännä sijoitus päinvastaiseksi. Kaikki tehtävät käännetään ja identiteetti lisätään automaattisesti. Esimerkiksi:
714	716
715	717		Tulos:
716	718
717	719		``` pascal
718	720		procedure DoSomething;
719	721		begin
720	722		BValueStudio := AValueStudio;
721	723		BValueAppartment := AValueAppartment;
722	724		BValueHouse := AValueHouse;
723	725		end;
724	726		```
725	727
726	728		### Kapseloi valinta
727	729
728	730		Valitse jokin teksti ja ota "Kapseloi valinta" käyttöön. Avautuu valintaikkuna, jossa voidaan valita, haluaako valinnan try..finally tai monista muista tavoista .
729	731
730	732		### Vaihda tunnisteen nimeä
731	733
732	734		Aseta kohdistin tunnisteeseen ja valitse "Vaihda tunnisteen nimeä". Näyttöön tulee valintaikkuna, jossa voit määrittää hakualueen ja uuden nimen.
733	735
734	736		- Se nimeää kaikki esiintymät uudelleen ja vain ne, jotka todella kuuluvat tähän määritykseen. Tämä tarkoittaa, ettei se koske toisten määrityksten osalla olevia samaa nimeä sisältäviä osia.
735	737		- Se tarkistaa ensin nimen ristiriidat.
736	738		- Rajoitukset: Se toimii vain pascal-lähdekoodeilla, ei vielä nimeä tiedostoja eikä muokkaa lfm / lrs-tiedostoja eikä lazdoc-tiedostoja.
737	739
738	740		### Etsi viittauksia tunnisteeseen
739	741
740	742		Aseta kohdistin tunnisteeseen ja ja valitse "Etsi viittauksia tunnisteeseen". Näyttöön tulee valintaikkuna, jossa voidaan määrittää hakualue. IDE etsii sitten kaikki esiintymät ja vain ne, jotka todella käyttävät tätä määritystä. Tämä tarkoittaa sitä, että siinä ei näytetä muita samannimisiä sanoja.
741	743
742	744		### Abstraktit metodit
743	745
744	746		Tämä ominaisuus luetteloi ja täydentää automaattisesti virtuaalisia, abstrakteja menetelmiä, jotka on toteutettava. Aseta kohdistin luokan ilmoitukseen ja valitse tämä. Jos abstrakteja menetelmiä puuttuu, näkyviin tulee valintaikkuna. Valitse toteutettavat menetelmät ja IDE luo "tynkämetodin". Lazarus 1.3 versiosta lähtien se lisää myös puuttuvat luokan rajapinnat (class interface) .
745	747
746	748		### Extract Procedure
747	749
748	750		Katso [[IDE Window: Extract Procedure\|Extract Procedure]].
749	751
750	752		## Etsi määritys
751	753
752	754		Aseta kohdistin tunnisteeseen ja tee 'Etsi määritys'. Sitten se etsii tämän tunnisteen määrityksen, avaa tiedoston ja siirtyy siihen. Jos kohdistin on jo määrityksessä, se siirtyy edelliseen määritykseen samalla nimellä. Tämä mahdollistaa uudelleenmäärittelyjen ja ohitusten (override9 löytymisen.
753	755
754	756		Jokainen löydettävä määrittely asettaa hyppypisteen. Tämä tarkoittaa sitä, että se hyppää etsimällä määritykseen ja hyppää helposti takaisin Etsi -\> Hyppää takaisin.
755	757
756	758		Delphissä on joitain eroja: codetools toimivat lähdekoodissa normaalien pascal-sääntöjen jälkeen, eikä käytä kääntäjän tuloksen käyttöä. Kääntäjä palauttaa lopullisen tyypin. Codetools näkee lähdekoodin ja kaikki sen väliset vaiheet. Esimerkiksi:
757	759
758	760		Visible property on ensin määritelty TControl (controls.pp), sitten se määritellään uudelleen TCustomForm:ssa ja lopuksi uudelleen TForm:ssa. Kutsu "Etsi Visible:n määritys" tuo ensin näkyviin Visible:n TForm:ssa. Sitten voidaan hakea "Etsi Visible:n määritys" uudelleen joka siirtyy Visible:n TCustomForm:ssa ja seuraava uudelleen haku siirtyy TControl:n.
759	761
760	762		Sama pätee myös tyypeille kuten TColor. Kääntäjälle se on yksinkertaisesti 'longint'. Mutta lähdekoodissa se on määritelty
761	763
762	764		``` pascal
763	765		TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
764	766		TColor = TGraphicsColor;
765	767		```
766	768
767	769		Ja sama forward defined classes: esimerkiksi TControl:ssa on yksityinen muuttuja
768	770
769	771		``` pascal
770	772		FHostDockSite: TWinControl;
771	773		```
772	774
773	775		Etsi määritys hyppää TWinControl eteenpäin määrittelyyn
774	776
775	777		``` pascal
776	778		TWinControl = class;
777	779		```
778	780
779	781		Ja se taas hyppää todelliseen toteutukseen
780	782
781	783		``` pascal
782	784		TWinControl = class(TControl)
783	785		```
784	786
785	787		Tällä tavoin voit etsiä jokaisen tunnisteen ja löytää jokaisen ylikuormituksen (overload).
786	788
787	789		### Vihjeitä
788	790
789	791		- Hyppää takaisin `Ctrl`+`H`.
790	792		- Voidaan tarkastella / navigoida kaikki vierailut kohteet valikon kautta: Näytä -\> "hyppyhistoria"
791	793		- 5-näppäimellä hiirellä voidaan 2 ylimääräistä painiketta hyödyntää siirtyäksesi eteenpäin / taaksepäin vierailtujen kohteiden välillä
792	794
793	795		[[IDE Window: EditorMouseOptionsAdvanced\|advanced mouse options]] painikkeet voidaan uudelleen määrittää.
794	796
795	797		## Identifier Completion
796	798
797	799		"Identifier Completion" kutsutaan painamalla `Ctrl`+`space`. Se näyttää kaikki näkyvyyden tunnisteet. Esimerkiksi:
798	800
799	801		``` pascal
800	802		procedure TForm1.FormCreate(Sender: TObject);
801	803		begin
802	804		\|
803	805		end;
804	806		```
805	807
806	808		Sijoita kursori begin ja end lauseiden väliin ja paina `Ctrl`+`space`. IDE/CodeTools analysoi nyt kaikki tavoitettavissa olevat koodit ja esittää luettelon kaikista löydetyistä tunnisteista. CodeTools välittää tulokset välimuistiin, joten toisen kerran kutsuminen on paljon nopeampaa.
807	809
808	810		> Note: Delphi käyttäjille: Delphi kutsuu tätä nimellä Code completion.
809	811
810	812		Joitakin tunnisteita, kuten 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' on rakennettu kääntäjään eikä niitä ole määritelty missään lähteessä. Identifier Completion on paljon näitä asioita myös sisäänrakennettu. Jos löytyy joku puuttuva, niin luo ominaisuuspyyntö bug tracker:n.
811	813
812	814		Identifier completion ei täydennä kaikkia avainsanoja. Joten sitä ei voi käyttää täyttämään 'repe' sanaa 'repeat':ksi. Tälläisissä tapauksissa käytä`Ctrl`+`W` Word Completion tai `Ctrl`+`J` Code Templates. Versiosta 0.9.27 lähtien identifier completion täydentää jotain avainsanoja.
813	815
814	816		Identifier completion näyttää myös ne tunnisteet, jotka eivät ole yhteensopivia.
815	817
816	818		### Täydennys sanan alkuosan mukaan
817	819
818	820		Identifier completion voidaan kutsua kun on muutamia kirjaimia sanasta. Sijoita kursori sanaan. Jolloin kursorin vasemmalla puolella olevia merkkejä käytetään tunnisteiden etsimiseen. Esimerkiksi:
819	821
820	822		``` pascal
821	823		procedure TForm1.FormCreate(Sender: TObject);
822	824		begin
823	825		Ca\|ption
824	826		end;
825	827		```
826	828
827	829		Sanaluettelolaatikko näyttää vain tunnukset, jotka alkavat "Ca": lla (\\| osoittaa kursorin sijainnin).
828	830
829	831		### Näppäimet
830	832
831	833		- Kirjain tai numero : lisää merkin lähdekoodieditoriin ja käytettyyn etuliitteeseen. Tämä päivittää luettelon.
832	834		- `Backspace`: poistaa viimeisen merkin lähdekoodieditorista ja etuliitteestä. Päivittää luettelon
833	835		- `Return`: vaihtaa koko sanan kohdistimella valittuun tunnisteeseen ja sulkee ponnahdusikkunan.
834	836		- `Shift`+`Return`: kuten Return, mutta korvaa vain sanan etuliitteen (kursorin vasemmanpuolinen osa)
835	837		- `Up`/`Down`: Siirtyy valintaluettelossa (ylöspäin/alaspäin)
836	838		- `Esc`: sulkee ponnahdusikkunan ilman muutosta
837	839		- `Tab`: täydentää etuliitteen seuraavaan valintaan. Esimerkiksi: Nykyinen etuliite on 'But' ja tunnuksen loppuun saattaminen näyttää vain 'Button1' ja 'Button1Click'. Tällöin `Tab`:in painamisella saadaan etuliite 'Button1'.
838	840		- Muutoin: kuten `Return` ja lisätään merkki lähdekoodieditoriin
839	841
840	842		### Metodit
841	843
842	844		Kun kohdistin on luokkamäärittelyssä ja identifier complete määrittää metodia esi-luokassa niin parametrit ja override avainsana lisätään automaattisesti. Esimerkiksi:
843	845
844	846		``` pascal
845	847		TMainForm = class(TForm)
846	848		protected
847	849		mous\|
848	850		end;
849	851		```
850	852
851	853		Täydennys MouseDown antaa:
852	854
853	855		``` pascal
854	856		TMainForm = class(TForm)
855	857		protected
856	858		procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
857	859		Y: Integer); override;
858	860		end;
859	861		```
860	862
861	863		### Ominaisuudet
862	864
863	865		``` pascal
864	866		property MyInt: integer read \|;
865	867		```
866	868
867	869		Identifier completion näyttää FMyInt ja GetMyInt.
868	870
869	871		``` pascal
870	872		property MyInt: integer write \|;
871	873		```
872	874
873	875		Identifier completion näyttää FMyInt ja SetMyInt.
874	876
875	877		### Uses osio / käännösyksikön nimet
876	878
877	879		Uses osiossa identifier completion näytetään kaikkien hakuehtojen yksiköiden tiedostonimet. Nämä näyttävät kaikki pienet kirjaimet (esim. avl_tree ), koska useimmilla käännösyksiköillä on pieniä tiedostonimiä. Valmistuttuaan se lisää käännösyksikön (esim. AVL_Tree ).
878	880
879	881		### Lauseet
880	882
881	883		``` pascal
882	884		procedure TMainForm.Button1Click(Sender: TObject);
883	885		begin
884	886		ModalRe\|;
885	887		end;
886	888		```
887	889
888	890		tulee:
889	891
890	892		``` pascal
891	893		procedure TMainForm.Button1Click(Sender: TObject);
892	894		begin
893	895		ModalResult:=\|;
894	896		end;
895	897		```
896	898
897	899		### Kuvakkeet täydennysikkunassa
898	900
899	901		Lazarus versiosta 1.9 lähtien on olemassa vaihtoehto, jolla näytetään kuvakkeita "tyyppien" sijaan täydennysikkunassa. Kuvassa nähdään nämä kuvakkeet:
900	902
901	903		![](/wiki-images/e/e6/Ide_completion_icons.png)
902	904
903	905		## Word Completion
904	906
905	907		Word Completion kutsutaan `Ctrl`+`W`. Se näyttää kaikki lähdekoodieditorissa olevat sanat ja sitä voidaan käyttää myös ei-pascal-lähdekoodeissa, kommenteissa ja avainsanoissa.
906	908
907	909		Muutoin se toimii samoin kuin identifier completion.
908	910
909	911		## Siirry Include määrittelyyn
910	912
911	913		"Siirry Include määrittelyyn" hyppää {\$ I filename} -lauseen, jossa käytetään nykyistä tiedostoa.
912	914
913	915		## Julkaise projekti
914	916
915	917		Luo kopion koko projektista. Jos halutaan lähettää jollekulle vain lähdekoodi ja kääntäjän asetukset niin tämä toiminto on ystäväsi.
916	918
917	919		Tavallinen projektihakemisto sisältää paljon tietoa. Suurinta osaa sitä ei tarvitse julkaista: .lpi-tiedosto voi sisältää istuntotietoja (kuten suljettujen yksiköiden varmenteen sijainti ja kirjanmerkit) ja projektin hakemisto sisältää paljon .ppu, .o-tiedostoja ja suoritettavan tiedoston. Voidaan luoda lpi-tiedoston, jossa on vain perustiedot ja vain lähdekoodi sekä kaikki alihakemistot sisältävä "Publish Project".
918	920
919	921		> Note: Versiosta 0.9.13 lähtien on uusi projektiasetus-vaihtoehto, jonka avulla voidaan tallentaa istunnon tiedot erilliseen tiedostoon tavallisesta .lpi-tiedostosta. Tämä uusi tiedosto päättyy .lps-laajennukseen ja sisältää vain istunnon tiedot, jotka jättävät .lpi-tiedoston paljon siistimmäksi.
920	922
921	923		Valintaikkunassa voidaan määrittää suodattimen tiettyjen tiedostojen sisällyttämiseksi ja sulkemiseksi pois. Komennolla voidaan pakata tuotos yhteen arkistoon.
922	924
923	925		## Huomautuksia näytettävistä vihjeistä
924	926
925	927		Useilla kohdilla IDE näyttää vihjeitä tunnisteista. Esimerkiksi kun liikutetaan hiirtä tunnisteen päällä lähdekoodieditorissa ja odotetaan muutaman sekunti. Kun IDE näyttää vihjeenä tunnuksen, se etsii määrityksen ja kaikki sen esi-isät ja etsii kommentteja ja fpdoc-tiedostoja. On monia koodaustapoja ja monia kommentoitavia tyylejä. Monien yhteisten kommenttityylien tukemiseksi IDE käyttää seuraavia heuristiikkaa:
926	928
927	929		### Comments shown in the hint
928	930
929	931		Comments in front of a declaration, without empty line and not starting with the \< sign:
930	932
931	933		``` pascal
932	934		var
933	935		{Comment}
934	936		Identifier: integer;
935	937		```
936	938
937	939		Comments with the \< sign belong to the prior identifier.
938	940
939	941		Comments behind an identifier on the same line:
940	942
941	943		``` pascal
942	944		var
943	945		identifier, // Comment
944	946		other,
945	947		```
946	948
947	949		Comments behind the definition on the same line:
948	950
949	951		``` pascal
950	952		var
951	953		identifier:
952	954		char; // Comment
953	955		```
954	956
955	957		An example for \< sign:
956	958
957	959		``` pascal
958	960		const
959	961		a = 1;
960	962		//< comment for a
961	963		b = 2;
962	964		// comment for c
963	965		c = 3;
964	966		```
965	967
966	968		All three comment types are supported:
967	969
968	970		``` pascal
969	971		{Comment}(Comment)//Comment
970	972		c = 1;
971	973		```
972	974
973	975		### Comments not shown in the hint
974	976
975	977		Comments starting with \$ or % are ignored. For example //% Hiddden, //\$ Hidden, (\$ Hidden).
976	978
977	979		Comments in front separated with an empty line are treated as not specific to the following identifier. For example the following class header comment is not shown in the hint:
978	980
979	981		``` pascal
980	982		type
981	983		{ TMyClass }
982	984
983	985		TMyClass = class
984	986		```
985	987
986	988		The class header comments are created on class completion. You can turn this off in the Options / Codetools / Class completion / Header comment for class. If you want to show the header comment in the hint, just remove the empty line.
987	989
988	990		The following comment will be shown for GL_TRUE, but not for GL_FALSE:
989	991
990	992		``` pascal
991	993		// Boolean
992	994		GL_TRUE = 1;
993	995		GL_FALSE = 0;
994	996		```
995	997
996	998		## Quick Fixes
997	999
998	1000		Quick Fixes are menu items for specific compiler messages. They help you to quickly fix the problem. Select a message in the Messages window and right click, or right click in the source editor on the icon to the left.
999	1001
1000	1002		- Unit not found: remove from uses section
1001	1003		- Unit not found: find unit in loaded packages and allow to auto add package dependency
1002	1004		- Constructing a class "\$1" with abstract method "\$2": show dialog to override all abstract methods
1003	1005		- Local variable "\$1" not used: remove definition
1004	1006		- Circular unit reference between \$1 and \$2: show Unit Dependencies dialog with full path between the two units
1005	1007		- Identifier not found: search via Code Browser
1006	1008		- Identifier not found: search via Cody Dictionary (needs package [[Cody]])
1007	1009		- Identifier not found: add local variable
1008	1010		- Recompiling \$1, checksum changed for \$2: show a dialog with search paths and other information
1009	1011		- IDE warning: other sources path of package %s contains directory...: open package
1010	1012		- any hint, note, warning: add IDE directive {%H-}
1011	1013		- any hint, note, warning: add compiler directive {\$warn id off} (since 1.7)
1012	1014		- any hint, note, warning: add compiler option -vm\<messageid\>
1013	1015		- Local variable "i" does not seem to be initialized: insert assignment (since 1.5)
1014	1016
1015	1017		## Outline
1016	1018
1017	1019		Tämä asetus sijaitsee IDEn asetukset ikkunassa, Editori - Näkymä - Merkintä ja osumat - Outline (global).
1018	1020
1019	1021		Se korostaa Pascalin avainsanoja yhdistäen vastaavat begin - end parit. Tämä sallii isot sisäkkäiset lohkot Esimerkiksi vaikka tälläinen aliohjelman runko:
1020	1022
1021	1023		``` pascal
1022	1024		with ADockObject do
1023	1025		begin
1024	1026		if DropAlign = alNone then
1025	1027		begin
1026	1028		if DropOnControl <> nil then
1027	1029		DropAlign := DropOnControl.GetDockEdge(DropOnControl.ScreenToClient(DragPos))
1028	1030		else
1029	1031		DropAlign := Control.GetDockEdge(DragTargetPos);
1030	1032		end;
1031	1033		PositionDockRect(Control, DropOnControl, DropAlign, FDockRect);
1032	1034		end;
1033	1035		```
1034	1036
1035	1037		Tuodaan korostaen esiin:
1036	1038
1037	1039		- ulompi with-do-begin-end oranssin värisenä
1038	1040		- seuraavan tason if-then-begin-end vihreän värisenä
1039	1041		- sisempi if-then-else cyanin värisenä
1040	1042
1041	1043		![](/wiki-images/3/3c/Ide_outline.png)
1042	1044
1043	1045		---
1044	1046		From the Free Pascal wiki, page "Lazarus IDE Tools/fi", as it stood on 2020-02-18 after a change by Trev, 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