Sign in Join
Wiki copytemporary

Lazarus IDE Tools/sk: what changed

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

Title: Lazarus IDE Tools/sk

OldNewLine
1+## Úvod
2+
3+IDE používa knižnicu analýzy zdrojového kódu Pascal a editačných nástrojov, zvanú "codetools". Tieto nástroje poskytujú funkcie ako hľadanie deklarácie (find declaration), dokončovanie kódu (code completion), odstraňovanie, presúvanie, vkladanie a formátovanie zdrojového kódu Pascal. Tieto funkcie šetria množstvo času a duplicitných úloh. Sú nastaviteľné a každá funkcia je dostupná pomocou klávesovej skratky (viď Editor Options).
4+
5+Pretože ich práca záleží na zdrojovom kóde a pochopení FreePascal, Delphi a Kylix kódu, nevyžadujú preložené jednotky ani nainštalovaný prekladač Borland. Môžete naraz upravovať kód Delphi aj FreePascal. Môžete dokonca pracovať s rôznymi verziami Delphi a FreePascal súčasne. Tým sa stáva prenos Delphi kódu ešte jednoduchší.
6+
7+## Zhrnutie klávesových skratiek IDE
8+
9+| | |
10+|----|----|
11+| [[Lazarus IDE Tools/sk|Hľadanie deklarácie]] (Declaration Jumping) | **Ctrl+Click** alebo **Alt+Up** |
12+| [[Lazarus IDE Tools/sk|Prepínanie metód]] (Method Jumping) | **Ctrl+Shift+Up** a **Ctrl+Shift+Down** |
13+| [[Lazarus IDE Tools/sk|Šablóny kódu]] (Code Templates) | **Ctrl+J** |
14+| [[Lazarus IDE Tools/sk|Dokončovanie kódu]] (Code/Class Completion) | **Ctrl+Shift+C** |
15+| [[Lazarus IDE Tools/sk|Dokončovanie identifikátorov]] (Identifier Completion) | **Ctrl+Medzerník** |
16+| [[Lazarus IDE Tools/sk|Dokončovanie slov]] (Word Completion) | **Ctrl+W** |
17+| [[Lazarus IDE Tools/sk|Pomoc s parametrami]] (Parameter Hints) | **Ctrl+Shift+Space** |
18+
19+## Prepínanie metód
20+
21+(*Method Jumping*)
22+
23+Na prepínanie medzi telom procedúry (begin..end) a jej definíciou (procedure Name;) použite Ctrl+Shift+Up.
24+
25+Príklad:
26+
27+``` pascal
28+ interface
29+
30+ procedure DoSomething; // procedure definition
31+
32+ implementation
33+
34+ procedure DoSomething; // procedure body
35+ begin
36+ end;
37+```
38+
39+Ak je kurzor v tele provedúry a stlačíte Ctrl+Shift+Up, kurzor skočí na definíciu. Ak znova stlačíte Ctrl+Shift+Up preskočí do tela procedúry, za 'begin'. Funkcia pracuje aj s metódami (procedúrami v triedach).
40+
41+Tipy: 'Method Jumping' presúva kurzor na rovnakú procedúru s rovnakým menom i zoznamom parametrov. Ak presná procedúra neexistuje, skočí na najpodobnejšiu a umiestni kurzor na prvý rozdiel. V Delphi táto funkcia neexistuje.
42+
43+Príklad procedúry s rôznymi typmi parametrov:
44+
45+``` pascal
46+ interface
47+
48+ procedure DoSomething(p: char); // procedure definition
49+
50+ implementation
51+
52+ procedure DoSomething(p: string); // procedure body
53+ begin
54+ end;
55+```
56+
57+Preskočenie z definície do tela umiestni kurzor na kľúčové slovo 'string'. Túto vlastnosť môžete využiť na premenovanie metódy a/alebo zmenu jej parametrov.
58+
59+Príklad: Premenovali sme 'DoSomething' na 'MakeIt':
60+
61+``` pascal
62+ interface
63+
64+ procedure MakeIt; // procedure definition
65+
66+ implementation
67+
68+ procedure DoSomething; // procedure body
69+ begin
70+ end;
71+```
72+
73+Potom urobte skok z definície MakeIt do tela. IDE hľadá vhodné telo, nenájde žiadne, preto začne hľadať kandidátov. Keďže ste premenovali len jednu procedúru, tak je len jedno telo bez definície (DoSomething) a tak skočí do DoSomething a umiestni kurzor vpravo od 'DoSomething'. Potomm ju môžete jednoducho premenovať tiež. Toto rovnako funguje aj s parametrami.
74+
75+## Include súbory
76+
77+(*Include Files*)
78+
79+Include súbory sú súbory vložené do zdrojového kódu pomocou direktív prekladača {\$I filename} alebo {\$INCLUDE filename}. Lazarus a FreePascal používajú veľa takýchto vecí na redukciu nadbytočnosti a vyhnutie sa nečitateľnosti konštrukcií {\$IFDEF} pri podpore rôznych platforiem.
80+
81+Narozdiel od Delphi, IDE Lazarus plne podporuje include súbory. Napríklad môžete skočiť z metódy v súbore .pas do tela metódy v include súbore. Všetky nástroje kódu, ako dokončovanie kódu, považuje include súbory za špeciálne hranice.
82+
83+Napríklad: keď dokončovanie kódu pridáva telo novej metódy za telom inej metódy, ponechá ich obe v rovnakom súbore. Týmto spôsobom môžete vložiť celú implementáciu triedy do include súborov, ako to robí LCL pre skoro všetky prvky.
84+
85+Ale je tu začiatočnícka chyba: Ak najprv otvoríte include súbor a skúsite prepínanie metód alebo hľadanie deklarácie, dostanete chybu. IDE nevie do ktorej jednotky include súbor patrí. Najprv musíte otvoriť jednotku.
86+
87+Hneď ako IDE zanalyzuje jednotku, zachytí v nej include direktívy a IDE si bude pamätať tento vzťah. Tieto informácie IDE ukladá pri skončení a pri uložení projektu do ~/.lazarus/includelinks.xml. Keď nabudúce otvoríte súbor include a urobíte skok do neho alebo hľadanie deklarácie, IDE interne otvorí jednotku a skoky budú fungovať.
88+
89+Tento mechanizmus má samozrejme obmedzenia, niektoré include súbory sú zahrnuté dva i viackrát. Napríklad: lcl/include/winapih.inc. Skákanie z definície procedúry/metódy v tomto include súbore do tela závisí na poslednej akcii. Ak ste pracovali v lcl/lclintf.pp, IDE skočí do winapi.inc. Ak ste pracovali v lcl/interfacebase.pp, potom skočíte do lcl/include/interfacebase.inc (alebo do jedného z ďalších include súborov). Ak pracujete s obomi, potom môže nastať zmätok. ;)
90+
91+## Šablóny kódu
92+
93+(*Code Templates*)
94+
95+Šablóny kódu konvertujú identifikátor v texte alebo fragmente kódu. Šablóny kódu majú prednastavenú klávesovú skratku Ctrl+J. Môžete napísať identifikátor, stlačiť Ctrl+J a identifikátor je nahradený textom definovaným pre identifikátor. Šablóny kódu môžete definovať v Tools -\> Options -\> CodeTools.
96+
97+Príklad: Napíšte identifikátor 'classf', ponechajte kurzor vpravo za 'f' a stlačte Ctrl+J. Identifikátor 'classf' bude nahradený týmto:
98+
99+``` pascal
100+ T = class(T)
101+ private
102+
103+ public
104+ constructor Create;
105+ destructor Destroy; override;
106+ end;
107+```
108+
109+a kurzor bude za 'T'. Zoznam šablón získate tak, že kurzor ponecháte na medzere (nie ne identifikátore) a stlačíte Ctrl+J. Pomocou kurzorových klávesov alebon apísania niekoľkých znakov vyberte jeden. Enter vytvorí zvolenú šablónu a Esc zatvorí zoznam.
110+
111+## Pomoc s parametrami
112+
113+(*Parameter Hints*) Pomoc s parametrami ukazuje pomocné okno s deklaráciami parametrov aktuálneho zoznamu parametrov.
114+
115+Napríklad
116+
117+``` pascal
118+ Canvas.FillRect(|);
119+```
120+
121+Umiestnite kurzor do zátvoriek a stlačte Ctrl+Shift+Space. Objaví sa pomocné okno, ukazujúce parametre FillRect.
122+
123+## Dokončovanie kódu
124+
125+(*Code Completion*)
126+
127+Dokončovanie kódu nájdete v menu IDE Edit -\> Complete Code a má štandartnú klávesovú skratku Ctrl+Shift+C. V Delphi je dokončovaním kódu volaná funkcia zobrazujúca zoznam identifikátorov na aktuálnej pozícii v zdrojovom kóde (Ctrl+Space). V Lazarus je toto nazývané dokončovanie identifikátorov (Identifier completion). Dokončovanie kódu v sebe združuje niekoľko užitočných funkcií:
128+
129+- **Dokončovanie tried** (Class Completion): dokončuje vlastnosti, pridáva telá metód, pridáva súkromné premenné a súkromné metódy;
130+- **Dokončovanie forward procedúr** (Forward Procedure Completion): pridáva telá forward procedúr;
131+- **Dokončovanie priradenia udalostí** (Event Assignment Completion): * dokončuje pridelenie udalostí a pridávanie tiel a definícií metód;
132+- **Dokončovanie lokálnych premenných** (Local Variable Completion): pridáva definície lokálnych premenných.
133+
134+Ktorá funkcia je použitá, závisí na pozícii kurzora v editore zdrojového kódu.
135+
136+### Dokončovanie tried
137+
138+(*Class Completion*)
139+
140+Veľmi výkonnou funkciou dokončovania kódu je "Dokončovanie tried". Vy píšete triedu, pridáte metódy a vlastnosti, a dokončovanie kódu pridá telá metód, metódy prístupu k vlastnostiam a súkromným premenným.
141+
142+Príklad: Vytvorte triedu (viz [[Lazarus IDE Tools/sk|Šablóny kódu]], aby ste ušetrili rovnakú prácu):
143+
144+``` pascal
145+ TExample = class(TObject)
146+ public
147+ constructor Create;
148+ destructor Destroy; override;
149+ end;
150+```
151+
152+Umiestnite kurzor niekde v definícii triedy a stlačte **Ctrl+Shift+C**. Tým budú vytvorené chýbajúce telá metód a kurzor bude presunutý na prvé vytvorené telo, takže môžete rovno začať písať kód triedy:
153+
154+``` pascal
155+ { TExample }
156+
157+ constructor TExample.Create;
158+ begin
159+ |
160+ end;
161+
162+ destructor TExample.Destroy;
163+ begin
164+ inherited Destroy;
165+ end;
166+```
167+
168+
169+**Poznámka**: Značka '\|' nie je pridaná, len ukazuje umiestnenie kurzora.
170+
171+Tip: Prepínať medzi telom a definíciou metódy môžete pomocou Ctrl+Shift+Up.
172+
173+Všimnite si, že IDE tiež pridáva volanie deštruktora základnej triedy (inherited Destroy). Toto je urobené, ak v definícii treidy použijete kľúčové slovo **override**.
174+
175+Teraz pridajte metódu **DoSomething**:
176+
177+``` pascal
178+ TExample = class(TObject)
179+ public
180+ constructor Create;
181+ procedure DoSomething(i: integer);
182+ destructor Destroy; override;
183+ end;
184+```
185+
186+Potom stlačte **Ctrl+Shift+C** a IDE pridá:
187+
188+``` pascal
189+ procedure TExample.DoSomething(i: integer);
190+ begin
191+ |
192+ end;
193+```
194+
195+Ako môžete vidieť, nové telo metódy je vložené medzi Create a Destroy, presne ako je to v definícii. Týmto sú telá metód uchovávané v rovnakom logickom poradí, ako v definícii. Spôsob vkladania môžete definovať pomocou Prostredie \> Voľby Codetools -\> Tvorenie kódu.
196+
197+### Dokončovanie vlastností
198+
199+Pridajte vlastnosť **AnInteger**:
200+
201+``` pascal
202+ TExample = class(TObject)
203+ public
204+ constructor Create;
205+ procedure DoSomething(i: integer);
206+ destructor Destroy; override;
207+ property AnInteger;
208+ end;
209+```
210+
211+Stlačte Ctrl+Shift+C a dostanete:
212+
213+``` pascal
214+ procedure TExample.SetAnInteger(const AValue: integer);
215+ begin
216+ |if FAnInteger=AValue then exit;
217+ FAnInteger:=AValue;
218+ end;
219+```
220+
221+Dokončovanie kódu pridalo metódu pre prístup k zápisu do vlastnosti a nejaký základný kód.
222+
223+Preskočte do triedy pomocou **Ctrl+Shift+C** a uvidíte, že v triede pribudlo:
224+
225+``` pascal
226+ TExample = class(TObject)
227+ private
228+ FAnInteger: integer;
229+ procedure SetAnInteger(const AValue: integer);
230+ public
231+ constructor Create;
232+ procedure DoSomething(i: integer);
233+ destructor Destroy; override;
234+ property AnInteger: integer read FAnInteger write SetAnInteger;
235+ end;
236+```
237+
238+Vlastnosť bola rozšírená pridaním kľúčových slov **Read** a **Write**. V triede je nová sekcia **private** s premennou **FAnInteger** a metódou **SetAnInteger**. Pridanie **F** na začiatok privátnej premennej je bežnou notáciou Delphi, rovnako ako označenie prístupovej metódy pomocou **Set**. Ak to nechcete, môžete to zmeniť ponmocou Prostredie \> Voľby Codetools -\> Tvorenie kódu.
239+
240+Vytvorenie vlastnosti len na čítanie:
241+
242+``` pascal
243+ property PropName: PropType read;
244+```
245+
246+Bude rozšírené na:
247+
248+``` pascal
249+ property PropName: PropType read FPropName;
250+```
251+
252+Vytvorenie vlastnosti len pre zápis:
253+
254+``` pascal
255+ property PropName: PropType write;
256+```
257+
258+Bude rozšírené na:
259+
260+``` pascal
261+ property PropName: PropType write SetPropName;
262+```
263+
264+Vytvorenie read only vlastnosti s metódou na čítanie:
265+
266+``` pascal
267+ property PropName: PropType read GetPropName;
268+```
269+
270+Deklarácia ostane nezmenená, ale bude pridaná funkcia **GetPropName**:
271+
272+``` pascal
273+ function GetpropName: PropType;
274+```
275+
276+Vytvorenie vlastnosti s direktívou **stored**:
277+
278+``` pascal
279+ property PropName: PropType stored;
280+```
281+
282+Bude rozšírené na:
283+
284+``` pascal
285+ property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
286+```
287+
288+Pretože direktíva **stored** je používaná pre streamovanie čítania a zápisu, sú pridané aj kľúčové slová **read** a **write**.
289+
290+Tip: Dokončovanie identifikátorov tiež rozpoznáva nekompletné vlastnosti a navrhne predvolené mená. Napríklad:
291+
292+``` pascal
293+ property PropName: PropType read |;
294+```
295+
296+Umiestnite kurzor za medzeru za kľúčovým slovom **read** a stlačte Ctrl+Space pre dokončovanie identifikátorov. To vám ponúkne premennú **FPropName** a procedúru **SetPropName**.
297+
298+### Dokončovanie procedúr
299+
300+(*Forward Procedure Completion*)
301+
302+Dokončovanie dopredných deklarácií procedúr je časťou dokončovania kódu a pridáva telá chýbajúcich procedúr, ktoré sú definované. Je vyvolané, ak je kurzor na pripravenej definícii procedúry, pomocou klávesovej skratky **Ctrl+Shift+C**.
303+
304+Napríklad: Pridajte novú procedúru do časti **interface**:
305+
306+``` pascal
307+ procedure DoSomething;
308+```
309+
310+Umiestnite kurzor na ňu a stlačte **Ctrl+Shift+C** pre dokončovanie kódu. V časti **implementation** bude doplnené:
311+
312+``` pascal
313+ procedure DoSomething;
314+ begin
315+ |
316+ end;
317+```
318+
319+
320+Tip: Pomocou **Ctrl+Shift+Up** môžete prepínať medzi definíciou a telom procedúry.
321+
322+Telo novej procedúry bude pridané pred metódy tried. Ak už sú v časti **interface** nejaké definície procedúr, IDE sa pokúsi zachovať ich poradie, napríklad:
323+
324+``` pascal
325+ procedure Proc1;
326+ procedure Proc2; // nová procedúra
327+ procedure Proc3;
328+```
329+
330+Ak telá **Proc1** a **Proc3** už existujú, potom bude telo **Proc2** vložené medzi telá procedúr **Proc1** a **Proc3**. Toto správanie môže byť zmené pomocou **Prostredie \> Voľby Codetools -\> Tvorenie kódu**.
331+
332+Viacero procedúr:
333+
334+``` pascal
335+ procedure Proc1_Old; // telo existuje
336+ procedure Proc2_New; // telo neexistuje
337+ procedure Proc3_New; // "
338+ procedure Proc4_New; // "
339+ procedure Proc5_Old; // telo existuje
340+```
341+
342+Dokončovanie kódu pridá 3 telá procedúr (Proc2_New, Proc3_New, Proc4_New).
343+
344+Tento nástroj nepracuje len s procedúrami definovanými v časti **interface**, ale aj s procedúrami, ktoré sú definované pomocou kľúčového slova **forward**.
345+
346+### Dokončovanie priradenia udalostí
347+
348+(*Event Assignment Completion*)
349+
350+Dokončovanie priradenia udalostí je čsťou Dokončovania kódu a dokončuje jeden príkaz Event:=\|. Nastáva, keď je kurzor umiestnený za príkazom priradenia udalosti a stlačíte **Ctrl+Shift+C**.
351+
352+Napríklad
353+
354+V metóde, povedzme udalosti FormCreate, pridajte riadok: 'OnPaint:=':
355+
356+``` pascal
357+ procedure TForm1.Form1Create(Sender: TObject);
358+ begin
359+ OnPaint:=|
360+ end;
361+```
362+
363+Značka '\|' je umiestnenie kurzora a netreba ju zadávať.
364+
365+Potom stlačte **Ctrl+Shift+C** pre dokončovanie kódu. Príkaz priradenia udalosti bude doplnený takto:
366+
367+``` pascal
368+ OnPaint:=@Form1Paint;
369+```
370+
371+Do triedy **TForm1** bude pridaná nová metóda **Form1Paint**. Potom je spustené dokončovanie tried a dostanete:
372+
373+``` pascal
374+ procedure TForm1.Form1Paint(Sender: TObject);
375+ begin
376+ |
377+ end;
378+```
379+
380+Pracuje presne ako pridávanie metód v **Inšpektore objektov**.
381+
382+
383+**Poznámka**: Kurzor musíte umiestniť za operátor priradenia ':='. Ak ho umiestnite na identifikátor (tj. **OnPaint**), dokončovanie kódu spustí Dokončovanie lokálnych premenných, ktoré zlyhá, pretože **OnPaint** je už definovaná.
384+
385+Tip: Môžete definovať meno novej metódi aj sami, a to jej zadaním do priradenia, napríklad:
386+
387+``` pascal
388+ OnPaint:=@ThePaintMethod;
389+```
390+
391+### Dokončovanie deklarácie premenných
392+
393+(*Variable Declaration Completion*)
394+
395+Dokončovanie deklarácie premenných je časťou **Dokončovania kódu** a pridáva definíciu lokálnej premennej pre príkaz Identifier:=Term;. Dokončovanie deklarácie premenných je vyvolané, keď je kurzor umiestnený na identifikátore v priradení.
396+
397+Napríklad:
398+
399+``` pascal
400+ procedure TForm1.Form1Create(Sender: TObject);
401+ begin
402+ i:=3;
403+ end;
404+```
405+
406+Umiestnite kurzor na 'i' alebo tesne za neho, potom stlačte Ctrl+Shift+C pre dokončovanie kódu a dostanete:
407+
408+``` pascal
409+ procedure TForm1.Form1Create(Sender: TObject);
410+ var
411+ i: Integer;
412+ begin
413+ i:=3;
414+ end;
415+```
416+
417+Nástroj dokončovania kódu najprv skontroluje, či identifikátor 'i' už nie je definovaný a ak nie, pridá deklaráciu 'var i: integer;'. Typ identifikátora je odhadovaný podľa pravej strany príkazu priradenia. Čísla ako 3 sú identifikované ako Integer.
418+
419+Iný príklad:
420+
421+``` pascal
422+ type
423+ TWhere = (Behind, Middle, InFront);
424+
425+ procedure TForm1.Form1Create(Sender: TObject);
426+ var
427+ a: array[TWhere] of char;
428+ begin
429+ for Where:=Low(a) to High(a) do writeln(a[Where]);
430+ end;
431+```
432+
433+Umiestnite kurzor na 'Where' a stlačte Ctrl+Shift+C pre dokončenie kódu. Dostanete:
434+
435+``` pascal
436+ procedure TForm1.Form1Create(Sender: TObject);
437+ var
438+ a: array[TWhere] of char;
439+ Where: TWhere;
440+ begin
441+ for Where:=Low(a) to High(a) do writeln(a[Where]);
442+ end;
443+```
444+
445+### Spätné dokončovanie triedy
446+
447+(*Reversed Class Completion*) Spätné dokončovanie triedy je časťou **Dokončovania kódu** a pridáva deklarácie súkromných metód pre aktuálne telo metódy. Je vyvolané, keď je kurzor v tele metódy, zatiaľ nie je definované pre triedy.
448+
449+Táto vlastnosť je dostupná od 0.9.21.
450+
451+Napríklad:
452+
453+``` pascal
454+ procedure TForm1.DoSomething(Sender: TObject);
455+ begin
456+ end;
457+```
458+
459+Metóda DoSomething zatiaľ nie je v TForm1 deklarovaná. Stlačte Ctrl+Shift+C a IDE pridá "procedure DoSomething(Sender: TObject);" k súkromným metódam triedy TForm1.
460+
461+Pre Delphianov: Dokončovanie tried pracuje pod Lazarus vždy jednym spôsobom:
462+
463+- Z rozhrania triedy do jej implementácie alebo naopak z implementácie triedy do jej rozhrania. Delphi vždy vyvoláva oba smery. Poszup v Delphi má nevýhodu, že ak dôjde k preklepu, ľahko vytvoríte bez upozornenia zvyšok novej metódy.
464+
465+### Komentáre a dokončovanie kódu
466+
467+(*Comments and Code Completion*)
468+
469+Dokončovanie kódu sa pokúša uchovávať komentáre tam, kde sú. Príklad:
470+
471+``` pascal
472+ FList: TList; // zoznam prvkov TComponent
473+ FInt: integer;
474+```
475+
476+Pri vkladaní novej premennej medzi FList a FInt, je komentár ponechaný na riadku spolu s FList. To platí i pre:
477+
478+``` pascal
479+ FList: TList; { zoznam prvkov TComponent
480+ Toto je komentár na niekoľkých riadkoch, začínajúci
481+ na riadku s FList, tak nástroj dokončenia kódu predpokladá že patrí
482+ k riadku s FList a nepreruší tento vzťah.
483+ Kód bude vložený za komentár. }
484+ FInt: integer;
485+```
486+
487+Ak komentár začína na ďalšom riadku:
488+
489+``` pascal
490+ FList: TList; // zoznam prvkov TComponent
491+ { Tento komentár patrí k nasledujúcemu riadku.
492+ Nový kód je vložený pred tentokomentár a
493+ za komentár na riadku s FList. }
494+ FInt: integer;
495+```
496+
497+## Refactoring
498+
499+### Otočenie priradení
500+
501+(*Invert Assignments*)
502+
503+Otočenie priradení pracuje s vybratými príkazmi Pascalu a obracia všetky priradenia z tohoto výberu. Tento nástroj je užitočný pre transformáciu "save" kódu na "load" a naopak.
504+
505+Príklad:
506+
507+``` pascal
508+ procedure DoSomething;
509+ begin
510+ AValueStudio:= BValueStudio;
511+ AValueAppartment :=BValueAppartment;
512+ AValueHouse:=BValueHouse;
513+ end;
514+```
515+
516+Vyberte riadky s priradeniami (medzi begin a end) a urobte Otočenie priradenia, všetky priradenia budú otočené a automaticky odsadené. Výsledok:
517+
518+``` pascal
519+ procedure DoSomething;
520+ begin
521+ BValueStudio := AValueStudio;
522+ BValueAppartment := AValueAppartment;
523+ BValueHouse := AValueHouse;
524+ end;
525+```
526+
527+### Uzavrieť výber
528+
529+Vyberte nejaký text a vyvolajte nástroj. Zobrazí sa dialóg, kde si môžete vybrať či má výber uzatvorený medzi **try..finally** ale do mnoho iných blokov.
530+
531+### Premenovať identifikátor
532+
533+Umiestnite kurzor na identifikátor a vyvolajte tento nástroj, obaví sa dialóg, v ktorom môžete nastaviť rozsah hľadania a nové meno identifikátora.
534+
535+- premenované budú všetky výskyty a len tie, ktoré momentálne používajú túto deklaráciu, čiže edklarácie s rovnakým menom nebudú premenované.
536+- najprv bude vykonaná kontrola konfliktov mena.
537+- Obmedzenia: Pracuje len so zdrojovými kódmi Pascalu, zatiaľ nepremenúva súbory ani neupravuje súbory lfm/lrs, či súbory lazdoc.
538+
539+### Nájdi odkazy na identifikátor
540+
541+Umiestnite kurzor na identifikátor a vyvolajte nástroj. Objaví sa dialóg, v ktorom môžete nastaviť rozsah hľadania. IDE bude hľadať všetky výskyty a len tie, ktoré používajú aktuálnu deklaráciu. Čiže iné deklarácia s rovnakým menom, nebudú zobrazené.
542+
543+### Zobraziť abstraktné metódy
544+
545+Táto funkcia vypisuje a automaticky kompletuje virtuálne, abstraktné metódy, ktoré je majú byť implementované.
546+
547+Umiestnite kurzor na deklaráciu triedu a vyvolajte nástroj. Ak existujú nejaké chýbajúce abstraktné metódy, nude zobrazený dialóg s ich zoznamom. Zvoľte metódy pre implementovanie a IDE vytvorí základy metód.
548+
549+### Vytiahnuť procedúru
550+
551+Viz [[IDE Window: Extract Procedure/sk|Extract Procedure]]
552+
553+## Hľadanie deklarácie
554+
555+(*Find Declaration*)
556+
557+Umiestnite kurzor na identifikátor a urobte Hľadanie deklarácie, tým bude nájdená deklarácia tohoto identifikátora, prípadne otvorený príslušný súbor a kurzor bude premiestnený na miesto deklarácie.
558+
559+Každé hľadanie deklarácie nastavuje bod skoku. Tzn. po skoku na nájdenú deklaráciu môžete jednoduchos skočiť naspäť pomocou Search -\> Jump back.
560+
561+Oproti Delphi má nástroj isté rozdiely: Nástroj pracuje so zdrojovým kódom na základe pravidiel Pascalu, a nie s výsledkom prekladača. The compiler returns the final type. Nástroj prezerá zdrojové kódy a všetky kroky medzi. Napríklad:
562+
563+
564+Vlastnosť 'Visible' je najprv definovaná v TControl (controls.pp), potom je predefinovaná v TCustomForm a nakoniec predefinovaná aj v TForm. Spustenie hľadania deklarácie vlastnosti Visible vás najprv presunie na Visible v TForm. Potom môžete spustiť hľadanie deklarácie znova a skočíte na Visible v TCustomForm a znova pre skočenie na Visible v TControl.
565+
566+Obdobne je to s TColor. Pre prekladač je to jednoducho 'longint', ale v zdrojovom kóde je to definované ako:
567+
568+``` pascal
569+ TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
570+ TColor = TGraphicsColor;
571+```
572+
573+Obdobné je to aj s forward definovanými triedami: Napríklad v TControl je priávtna premenná
574+
575+``` pascal
576+ FHostDockSite: TWinControl;
577+```
578+
579+Hľadanie deklarácie pre TWinControl skočí na forward definíciu:
580+
581+``` pascal
582+ TWinControl = class;
583+```
584+
585+A opätovné spustenie hľadania deklarácie skočí na skutočnú implementáciu:
586+
587+``` pascal
588+ TWinControl = class(TControl)
589+```
590+
591+Týmto spôsobom môžete stopovať každý identifikátor a nájsť každé predefinovanie, či preťaženie.
592+
593+## Dokončovanie identifikátorov
594+
595+(*Identifier Completion*)
596+
597+Dokončovanie identifikátorov je vyvolané pomocou Ctrl+Space a zobrazuje všetky vyhovujúce identifikátory.
598+
599+Napríklad:
600+
601+``` pascal
602+ procedure TForm1.FormCreate(Sender: TObject);
603+ begin
604+ |
605+ end;
606+```
607+
608+Umiestnite kurzor medzi *begin* a *end* a stlačte Ctrl+Space. Nástroj IDE spracuje celý dosiahnuteľný kód a zobrazí zoznam všetkých nájdených identifikátorov. CodeTools kešuje výsledok, takže druhý krát bude oveľa rýchlejší.
609+
610+**Poznámka pre Delphianov:** Delphi to volá *Dokončovanie kódu*.
611+
612+Niektoré identifikátory, ako 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' sú zabudované v prekladači a teda nie sú definované nikde v zdrojovom kóde, al Dokončovanie identifikátorov má veľa z nich tež zabudovaných. Ak nájdete nejaký chýbajúci, jednoducho vytvorte požiadadvku na vlastnosť v sledovači chýb (*bug tracker*).
613+
614+Dokončovanie identifikátorov nedokončuje kľúčové slová, takže ho nemožno použiť na dokončenie proc' na 'procedure'. Na toto je určené Ctrl+W Dokončovanie slov alebo Ctrl+J Šablóny kódu.
615+
616+Dokončovanie identifikátorov nezobrazuje len tie identifikátory, ktoré nie sú kompatibilné.
617+
618+### Predpona
619+
620+Môžete začať dokončovanie identifikátorov v existujúcom slove. Potom budú písmená vľavo od kurzora brané ako predpona.
621+
622+Napríklad:
623+
624+``` pascal
625+ procedure TForm1.FormCreate(Sender: TObject);
626+ begin
627+ Ca|ption
628+ end;
629+```
630+
631+Okno bude zobrazovať len identifikátory začínajúce sa na 'Ca'.
632+
633+### Klávesy
634+
635+- Písmená/čísla: pridávajú znak do editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam.
636+- Backspace: odstraňuje posledný znak z editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam.
637+- Return: nahradzuje celé slovo na kurzore zvoleným identifikátorom a zatvára vyskakovacie okno.
638+- Shift+Return: as *Return*, but replaces only the prefix (left part) of the word at the cursor.
639+- Hore/Dole: presúva výber.
640+- Esc: zatvára vyskakovacie okno bez zmeny.
641+- Tab: dokončuje predponu na ďalšiu voľbu. Napríklad: aktuálna predpona je 'But' a dokončovanie identifikátora zobrazuje len 'Button1' a 'Button1Click', potom stlačenie *Tab* dokončí predponu na 'Button1'.
642+- Else: ako *Return* a pridá znak do editora zdrojového kódu.
643+
644+## Dokončovanie slov
645+
646+(*Word Completion*)
647+
648+Dokončovanie slov je vyvolané stlačením Ctrl+W a zobrazuje všetky slová všetkých aktuálne otvorených editorov. Inak pracuje presne ako Dokončovanie identifikátorov.
649+
650+## Prejdi do direktívy include
651+
652+(*Goto Include Directive*)
653+
654+Tento príkaz v menu Searchskočí do príkazu (direktívy) {\$I filename}, v ktorej je použitý aktuálny súbor.
655+
656+## Publikuj Projekt
657+
658+Vytvára kópiu celého projektu. Ak chcete niekomu poslať len zdrojové kódy a nastavenia prekladača pre svoj kód, budete kamarátis touto funkciou.
659+
660+Bežný adresár projektu obsahuje množstvo informácií. Väčšinu z nich publikovať netreba. Súbor **.lpi** obsahuje informácie o relácii (ako pozíciu caret a záložiek zatvorených jednotiek) a adresár projektu obsahuje mnoho súborov **.ppu** a **.o**, a tiež .exe. A práve príkaz Publikuj projekt vytvorí súbor **.lpi** len so základnými informáciami a všetky zdrojové kódy, so všetkých podadresárov.
661+
662+V ponúknutom dialógu môžete nastaviť filter pre zahrnutie/vynechanie, či pre kompresiu výstupu do jediného archívu.
663+
664+## Spolupracovníci
665+
666+This page has been converted from the epikwiki [version](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools).
667+
668+- Created page and initial template - 4/6/2004 VlxAdmin
669+- Initial content posted - 4/10/2004 MattiasG
670+- Small wiki and formatting fixes - 4/11/2004 VlxAdmin
671+- Added a summary table for IdeTools shortcuts - 12 July 2004 User:Kirkpatc
672+- Preložené z originálu [[Lazarus IDE Tools]] - Slavko 13:51, 25 Mar 2005 (PST)
673+
674+---
675+*From the Free Pascal wiki, page "Lazarus IDE Tools/sk", 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