Difference between revisions of "Lazarus IDE Tools/sk"

From Lazarus wiki
Jump to navigationJump to search
m (Fixed syntax highlighting)
 
(35 intermediate revisions by 7 users not shown)
Line 1: Line 1:
=Nástroje IDE Lazarus=
+
{{Lazarus IDE Tools}}
 +
 
 
==Úvod==
 
==Úvod==
IDE používa knižnicu analýzy zdrojového kódu Pascal a editačných nástrojov, zvanú "codetools". Tieto nástrojeposkytujú 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 mnoho času a dupľovanej roboty. Sú nastaviteľné a každá funkcia je dostupná pomocou klávesovej skratky (viz Editor Options).
+
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).
  
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 naraz. Tým sa stáva prenos kódu Delphi ešte jednoduchší.
+
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ší.
  
 
==Zhrnutie klávesových skratiek IDE==
 
==Zhrnutie klávesových skratiek IDE==
 
{|
 
{|
 
|-
 
|-
| Method Jumping || Ctrl+Shift+Up (toggle between definition and body)
+
| [[Lazarus IDE Tools/sk#Hľadanie_deklarácie | Hľadanie deklarácie]] (Declaration Jumping) || '''Ctrl+Click''' alebo '''Alt+Up'''
 +
|-
 +
| [[Lazarus IDE Tools/sk#Prepínanie_metód | Prepínanie metód]] (Method Jumping) || '''Ctrl+Shift+Up''' a '''Ctrl+Shift+Down'''
 +
|-
 +
| [[Lazarus IDE Tools/sk#Šablóny_kódu | Šablóny kódu]] (Code Templates) || '''Ctrl+J'''
 +
|-
 +
| [[Lazarus IDE Tools/sk#Dokončovanie_kódu | Dokončovanie kódu]] (Code/Class Completion) || '''Ctrl+Shift+C'''
 
|-
 
|-
| Code Templates || Ctrl+J
+
| [[Lazarus IDE Tools/sk#Dokončovanie_identifikátorov | Dokončovanie identifikátorov]] (Identifier Completion) || '''Ctrl+Medzerník'''
 
|-
 
|-
| Code Completion (Class Completion)   || Ctrl+Shift+C
+
| [[Lazarus IDE Tools/sk#Dokončovanie_slov | Dokončovanie slov]] (Word Completion) || '''Ctrl+W'''
 
|-
 
|-
| Identifier Completion || Ctrl+Space
+
| [[Lazarus IDE Tools/sk#Pomoc_s_parametrami |Pomoc s parametrami]] (Parameter Hints) || '''Ctrl+Shift+Space'''
 
|}
 
|}
  
 
==Prepínanie metód==
 
==Prepínanie metód==
(Method Jumping)
+
(''Method Jumping'')
 +
 
 
Na prepínanie medzi telom procedúry (begin..end) a jej definíciou (procedure Name;) použite Ctrl+Shift+Up.
 
Na prepínanie medzi telom procedúry (begin..end) a jej definíciou (procedure Name;) použite Ctrl+Shift+Up.
  
 
Príklad:
 
Príklad:
interface
+
<syntaxhighlight lang=pascal> interface
 
   
 
   
 
  procedure DoSomething; // procedure definition
 
  procedure DoSomething; // procedure definition
Line 30: Line 38:
 
  procedure DoSomething; // procedure body  
 
  procedure DoSomething; // procedure body  
 
  begin
 
  begin
  end;
+
  end;</syntaxhighlight>
 +
 
 
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).
 
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).
  
Line 37: Line 46:
  
 
Príklad procedúry s rôznymi typmi parametrov:
 
Príklad procedúry s rôznymi typmi parametrov:
interface
+
<syntaxhighlight lang=pascal> interface
 
   
 
   
 
  procedure DoSomething(p: char); // procedure definition
 
  procedure DoSomething(p: char); // procedure definition
Line 45: Line 54:
 
  procedure DoSomething(p: string); // procedure body
 
  procedure DoSomething(p: string); // procedure body
 
  begin
 
  begin
  end;
+
  end;</syntaxhighlight>
 +
 
 
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.
 
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.
  
 
Príklad:
 
Príklad:
Premenovali ste 'DoSomething' na 'MakeIt':
+
Premenovali sme 'DoSomething' na 'MakeIt':
interface
+
<syntaxhighlight lang=pascal> interface
 
   
 
   
 
  procedure MakeIt; // procedure definition
 
  procedure MakeIt; // procedure definition
Line 58: Line 68:
 
  procedure DoSomething; // procedure body
 
  procedure DoSomething; // procedure body
 
  begin
 
  begin
  end;
+
  end;</syntaxhighlight>
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 stepremenovali 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 pracuje s parametrami.
+
 
 +
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.
  
 
==Include súbory==
 
==Include súbory==
(Include Files)
+
(''Include Files'')
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 vyhnuutie sa nečitateľnosti konštrukcií {$IFDEF} pri podpore rôznych platforiem.
+
 
 +
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.
 +
 
 
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.
 
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.
 +
 
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.
 
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.
 +
 
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.
 
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.
 +
 
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ť.
 
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ť.
 +
 
Tento mechanizmus má samozrejme obmedzenia, niektoré include súbory sú zahrnuté dva i viackrát. Napríklad: lcl/include/winapih.inc.
 
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. ;)
 
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. ;)
  
 
==Šablóny kódu==
 
==Šablóny kódu==
(Code Templates)
+
(''Code Templates'')
Š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 Environment -> Editor Options -> CodeTools.
+
 
 +
Š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.
  
 
Príklad:
 
Príklad:
 
Napíšte identifikátor 'classf', ponechajte kurzor vpravo za 'f' a stlačte Ctrl+J. Identifikátor 'classf' bude nahradený týmto:
 
Napíšte identifikátor 'classf', ponechajte kurzor vpravo za 'f' a stlačte Ctrl+J. Identifikátor 'classf' bude nahradený týmto:
T = class(T)
+
<syntaxhighlight lang=pascal> T = class(T)
 
  private
 
  private
 
   
 
   
Line 83: Line 101:
 
   constructor Create;
 
   constructor Create;
 
   destructor Destroy; override;
 
   destructor Destroy; override;
  end;
+
  end;</syntaxhighlight>
 +
 
 
a kurzor bude za 'T'.
 
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.
 
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.
 +
 +
==Pomoc s parametrami==
 +
(''Parameter Hints'')
 +
Pomoc s parametrami ukazuje pomocné okno s deklaráciami parametrov aktuálneho zoznamu parametrov.
 +
 +
Napríklad
 +
<syntaxhighlight lang=pascal>  Canvas.FillRect(|);</syntaxhighlight>
 +
 +
Umiestnite kurzor do zátvoriek a stlačte Ctrl+Shift+Space. Objaví sa pomocné okno, ukazujúce parametre FillRect.
  
 
==Dokončovanie kódu==
 
==Dokončovanie kódu==
(Code Completion)
+
(''Code Completion'')
Dokončovanie kódu nájdete v menu IDE Edit -> Complete Code a má štandartnú klávespvú skratku Ctrl+Shift+C.
+
 
 +
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í:
 
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í:
  
Line 95: Line 124:
 
* '''Dokončovanie forward procedúr''' (Forward Procedure Completion): pridáva telá forward procedúr;
 
* '''Dokončovanie forward procedúr''' (Forward Procedure Completion): pridáva telá forward procedúr;
 
* '''Dokončovanie priradenia udalostí''' (Event Assignment Completion): * dokončuje pridelenie udalostí a pridávanie tiel a definícií metód;
 
* '''Dokončovanie priradenia udalostí''' (Event Assignment Completion): * dokončuje pridelenie udalostí a pridávanie tiel a definícií metód;
* '''* Dokončovanie lokálnych premenných''' (Local Variable Completion): pridáva definície lokálnych premenných.
+
* '''Dokončovanie lokálnych premenných''' (Local Variable Completion): pridáva definície lokálnych premenných.
 
Ktorá funkcia je použitá, závisí na pozícii kurzora v editore zdrojového kódu.
 
Ktorá funkcia je použitá, závisí na pozícii kurzora v editore zdrojového kódu.
  
===Class Completion===
+
===Dokončovanie tried===
The most powerful code completion feature is "Class Completion".
+
(''Class Completion'')
You write a class, add the methods and properties and Code Completion will add the method bodies, the property access methods/variables and the private variables.  
+
 
 +
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.  
  
For example:
+
Príklad:
Create a class (see Code Templates to save you some type work):
+
Vytvorte triedu (viz [[Lazarus IDE Tools/sk#Šablóny_kódu | Šablóny kódu]], aby ste ušetrili rovnakú prácu):
TExample = class(TObject)
+
<syntaxhighlight lang=pascal> TExample = class(TObject)
 
  public
 
  public
 
   constructor Create;
 
   constructor Create;
 
   destructor Destroy; override;
 
   destructor Destroy; override;
  end;
+
  end;</syntaxhighlight>
Position the cursor somewhere in the class and press Ctrl+Shift+C. This will create the method missing bodies and move the cursor to the first created method body, so you can just start writing the class code:
+
 
{ TExample }
+
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:
 +
<syntaxhighlight lang=pascal> { TExample }
 
   
 
   
 
  constructor TExample.Create;
 
  constructor TExample.Create;
Line 120: Line 151:
 
  begin
 
  begin
 
   inherited Destroy;
 
   inherited Destroy;
  end;
+
  end;</syntaxhighlight>
Note: The '|' is the cursor and is not added.
+
 
 +
:'''Poznámka''': Značka '|' nie je pridaná, len ukazuje umiestnenie kurzora.
  
Hint: You can jump between a method and its body with Ctrl+Shift+Up.
+
Tip: Prepínať medzi telom a definíciou metódy môžete pomocou  Ctrl+Shift+Up.
  
You can see, that the IDE added the 'inherited Destroy' call too. This is done, if there is an 'override' keyword in the class definition.
+
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'''.
  
Now add a method DoSomething:
+
Teraz pridajte metódu '''DoSomething''':
TExample = class(TObject)
+
<syntaxhighlight lang=pascal> TExample = class(TObject)
 
  public
 
  public
 
   constructor Create;
 
   constructor Create;
 
   procedure DoSomething(i: integer);
 
   procedure DoSomething(i: integer);
 
   destructor Destroy; override;
 
   destructor Destroy; override;
  end;
+
  end;</syntaxhighlight>
Then press Ctrl+Shift+C and the IDE will add
+
 
procedure TExample.DoSomething(i: integer);
+
Potom stlačte '''Ctrl+Shift+C''' a IDE pridá:
 +
<syntaxhighlight lang=pascal> procedure TExample.DoSomething(i: integer);
 
  begin
 
  begin
 
   |
 
   |
  end;
+
  end;</syntaxhighlight>
You can see, that the new method body is inserted between Create and Destroy, exactly as in the class definition. This way the bodies keep the same logical ordering as you define. You can define the insertion policy in Environment > Codetools Options -> Code Creation.
+
 
 +
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.
  
'''Complete Properties'''<br>
+
===Dokončovanie vlastností===
Add a property AnInteger:
+
Pridajte vlastnosť '''AnInteger''':
TExample = class(TObject)
+
<syntaxhighlight lang=pascal> TExample = class(TObject)
 
  public
 
  public
 
   constructor Create;
 
   constructor Create;
Line 149: Line 183:
 
   destructor Destroy; override;
 
   destructor Destroy; override;
 
   property AnInteger;
 
   property AnInteger;
  end;
+
  end;</syntaxhighlight>
Press Ctrl+Shift+C and you will get:
+
 
procedure TExample.SetAnInteger(const AValue: integer);
+
Stlačte Ctrl+Shift+C a dostanete:
 +
<syntaxhighlight lang=pascal> procedure TExample.SetAnInteger(const AValue: integer);
 
  begin
 
  begin
 
   |if FAnInteger=AValue then exit;
 
   |if FAnInteger=AValue then exit;
 
   FAnInteger:=AValue;
 
   FAnInteger:=AValue;
  end;
+
  end;</syntaxhighlight>
The code completion has added a Write access modifier and added some common code.
+
 
Jump to the class with Ctrl+Shift+Up to see the new class:
+
Dokončovanie kódu pridalo metódu pre prístup k zápisu do vlastnosti a nejaký základný kód.
TExample = class(TObject)
+
 
 +
Preskočte do triedy pomocou '''Ctrl+Shift+C''' a uvidíte, že v triede pribudlo:
 +
<syntaxhighlight lang=pascal> TExample = class(TObject)
 
  private
 
  private
 
   FAnInteger: integer;
 
   FAnInteger: integer;
Line 167: Line 204:
 
   destructor Destroy; override;
 
   destructor Destroy; override;
 
   property AnInteger: integer read FAnInteger write SetAnInteger;
 
   property AnInteger: integer read FAnInteger write SetAnInteger;
  end;
+
  end;</syntaxhighlight>
The property was extended by a Read and Write access modifier. The class got the new section 'private' with a Variable 'FAnInteger' and the method 'SetAnInteger'.
+
 
It is a common Delphi style rule to prepend private variables with an 'F' and the write method with a 'Set'. If you don't like that, you can change this in Environment > Codetools Options -> Code Creation.
+
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.
 +
 
 +
Vytvorenie vlastnosti len na čítanie:
 +
<syntaxhighlight lang=pascal> property PropName: PropType read;</syntaxhighlight>
 +
 
 +
Bude rozšírené na:
 +
<syntaxhighlight lang=pascal> property PropName: PropType read FPropName;</syntaxhighlight>
 +
 
 +
Vytvorenie vlastnosti len pre zápis:
 +
<syntaxhighlight lang=pascal>  property PropName: PropType write;</syntaxhighlight>
 +
 
 +
Bude rozšírené na:
 +
<syntaxhighlight lang=pascal> property PropName: PropType write SetPropName;</syntaxhighlight>
 +
 
 +
Vytvorenie read only vlastnosti s metódou na čítanie:
 +
<syntaxhighlight lang=pascal> property PropName: PropType read GetPropName;</syntaxhighlight>
 +
 
 +
Deklarácia ostane nezmenená, ale bude pridaná funkcia '''GetPropName''':
 +
<syntaxhighlight lang=pascal> function GetpropName: PropType;</syntaxhighlight>
 +
 
 +
Vytvorenie vlastnosti s direktívou '''stored''':
 +
<syntaxhighlight lang=pascal> property PropName: PropType stored;</syntaxhighlight>
 +
 
 +
Bude rozšírené na:
 +
<syntaxhighlight lang=pascal> property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;</syntaxhighlight>
 +
 
 +
Pretože direktíva '''stored''' je používaná pre streamovanie čítania a zápisu, sú pridané aj kľúčové slová '''read''' a '''write'''.
 +
 
 +
Tip:
 +
Dokončovanie identifikátorov tiež rozpoznáva nekompletné vlastnosti a  navrhne predvolené mená. Napríklad:
 +
<syntaxhighlight lang=pascal> property PropName: PropType read |;</syntaxhighlight>
 +
 
 +
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'''.
  
Creating a read only property:
+
===Dokončovanie procedúr===
property PropName: PropType read;
+
(''Forward Procedure Completion'')
Will be expanded to
 
property PropName: PropType read FPropName;
 
Creating a write only property:
 
  property PropName: PropType write;
 
Will be expanded to
 
property PropName: PropType write SetPropName;
 
Creating a read only property with a Read method:
 
property PropName: PropType read GetPropName;
 
Will be kept and a GetPropName function will be added:
 
function GetpropName: PropType;
 
Creating a property with a stored modifier:
 
property PropName: PropType stored;
 
Will be expanded to
 
property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
 
Because stored is used for streaming read and write modifiers are automatically added as well.
 
  
Hint:
+
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'''.
Identifier completion also recognizes incomplete properties and will suggest the default names. For example:
 
property PropName: PropType read |;
 
Place the cursor one space behind the 'read' keyword and press Ctrl+Space for the identifier completion. It will present you the variable 'FPropName' and the procedure 'SetPropName'.
 
  
===Forward Procedure Completion===
+
Napríklad:
"Forward Procedure Completion" is part of the Code Completion and adds missing procedure bodies. It is invoked, when the cursor is on a forward defined procedure.
+
Pridajte novú procedúru do časti '''interface''':
 +
<syntaxhighlight lang=pascal> procedure DoSomething;</syntaxhighlight>
  
For example:
+
Umiestnite kurzor na ňu a stlačte '''Ctrl+Shift+C''' pre dokončovanie kódu. V časti '''implementation''' bude doplnené:
Add a new procedure to the interface section:
+
<syntaxhighlight lang=pascal> procedure DoSomething;
procedure DoSomething;
 
Place the cursor on it and press Ctrl+Shift+C for code completion. It will create in the implementation section:
 
procedure DoSomething;
 
 
  begin
 
  begin
 
   |
 
   |
  end;
+
  end;</syntaxhighlight>
Hint: You can jump between a procedure definition and its body with Ctrl+Shift+Up.
+
 
 +
:Tip: Pomocou  '''Ctrl+Shift+Up''' môžete prepínať medzi definíciou a telom procedúry.
 +
 
 +
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:
 +
<syntaxhighlight lang=pascal>  procedure Proc1;
 +
  procedure Proc2; // nová procedúra
 +
  procedure Proc3;</syntaxhighlight>
  
The new procedure body will be added in front of the class methods. If there are already some procedures in the interface the IDE tries to keep the ordering. For example:
+
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'''.
  procedure Proc1;
 
  procedure Proc2; // new proc
 
  procedure Proc3;
 
If the bodies of Proc1 and Proc3 already exists, then the Proc2 body will be inserted between the bodies of Proc1 and Proc3. This behaviour can be setup in Environment > Codetools Options -> Code Creation.
 
  
Multiple procedures:
+
Viacero procedúr:
procedure Proc1_Old; // body exists
+
<syntaxhighlight lang=pascal> procedure Proc1_Old; // telo existuje
  procedure Proc2_New; // body does not exists
+
  procedure Proc2_New; // telo neexistuje
 
  procedure Proc3_New; //  "
 
  procedure Proc3_New; //  "
 
  procedure Proc4_New; //  "
 
  procedure Proc4_New; //  "
  procedure Proc5_Old; // body exists
+
  procedure Proc5_Old; // telo existuje</syntaxhighlight>
Code Completion will add all 3 procedure bodies (Proc2_New, Proc3_New, Proc4_New).
 
  
Why calling it "Forward Procedure Completion"?
+
Dokončovanie kódu pridá 3 telá procedúr (Proc2_New, Proc3_New, Proc4_New).
  
Because it does not only work for procedures defined in the interface, but for procedures with the "forward" modifier as well.
+
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'''.
  
===Event Assignment Completion===
+
===Dokončovanie priradenia udalostí===
"Event Assignment Completion" is part of the Code Completion and completes a single Event:=| statement. It is invoked, when the cursor is behind an assignment to an event.
+
(''Event Assignment Completion'')
  
For example:
+
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'''.
In a method, say the FormCreate event, add a line 'OnPaint:=':
+
 
procedure TForm1.Form1Create(Sender: TObject);
+
;Napríklad:
 +
V metóde, povedzme udalosti FormCreate, pridajte riadok: 'OnPaint:=':
 +
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
 
  begin
 
  begin
 
   OnPaint:=|
 
   OnPaint:=|
  end;
+
  end;</syntaxhighlight>
The '|' is the cursor and should not be typed.
+
 
Then press Ctrl+Shift+C for code completion. The statement will be completed to
+
Značka '|' je umiestnenie kurzora a netreba ju zadávať.
OnPaint:=@Form1Paint;
+
 
A new method Form1Paint will be added to the TForm1 class. Then class completion is started and you get:
+
Potom stlačte '''Ctrl+Shift+C''' pre dokončovanie kódu. Príkaz priradenia udalosti bude doplnený takto:
procedure TForm1.Form1Paint(Sender: TObject);
+
<syntaxhighlight lang=pascal> OnPaint:=@Form1Paint;</syntaxhighlight>
 +
 
 +
Do triedy '''TForm1''' bude pridaná nová metóda '''Form1Paint'''. Potom je spustené dokončovanie tried a dostanete:
 +
<syntaxhighlight lang=pascal> procedure TForm1.Form1Paint(Sender: TObject);
 
  begin
 
  begin
 
   |
 
   |
  end;
+
  end;</syntaxhighlight>
This works just like adding methods in the object inspector.
+
 
 +
Pracuje presne ako pridávanie metód v '''Inšpektore objektov'''.
 +
 
 +
:'''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á.
  
Note:<br>
+
Tip:
You must place the cursor behind the ':=' assignment operator. If you place the cursor on the identifier (e.g. OnPaint) code completion will invoke "Local Variable Completion", which fails, because OnPaint is already defined.
+
Môžete definovať meno novej metódi aj sami, a to jej zadaním do priradenia, napríklad:
 +
<syntaxhighlight lang=pascal> OnPaint:=@ThePaintMethod;</syntaxhighlight>
  
Hint:<br>
+
===Dokončovanie deklarácie premenných===
You can define the new method name by yourself. For example:
+
(''Variable Declaration Completion'')
  OnPaint:=@ThePaintMethod;
 
  
===Local Variable Completion===
+
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í.
"Local Variable Completion" is part of the Code Completion and adds a local variable definition for a Identifier:=Term; statement. It is invoked, when the cursor is on the identifier of the assignment.
 
  
For example:
+
Napríklad:
procedure TForm1.Form1Create(Sender: TObject);
+
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
 
  begin
 
  begin
 
   i:=3;
 
   i:=3;
  end;
+
  end;</syntaxhighlight>
Place the cursor on the 'i' or just behind it. Then press Ctrl+Shift+C for code completion and you will get:
+
 
procedure TForm1.Form1Create(Sender: TObject);
+
Umiestnite kurzor na 'i' alebo tesne za neho, potom stlačte Ctrl+Shift+C pre dokončovanie kódu a dostanete:
 +
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
 
  var
 
  var
 
   i: Integer;
 
   i: Integer;
 
  begin
 
  begin
 
   i:=3;
 
   i:=3;
  end;
+
  end;</syntaxhighlight>
The codetools first checks, if the identifier 'i' is already defined and if not it will add the declaration 'var i: integer;'. The type of the identifier is guessed from the term right to the assignment ':=' operator. Numbers like the 3 defaults to Integer.
+
 
 +
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.
  
Another example:
+
Iný príklad:
type
+
<syntaxhighlight lang=pascal> type
 
   TWhere = (Behind, Middle, InFront);
 
   TWhere = (Behind, Middle, InFront);
 
   
 
   
Line 277: Line 336:
 
   begin
 
   begin
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
 
     for Where:=Low(a) to High(a) do writeln(a[Where]);
   end;
+
   end;</syntaxhighlight>
Place the cursor on 'Where' and press Ctrl+Shift+C for code completion. You get:
+
 
procedure TForm1.Form1Create(Sender: TObject);
+
Umiestnite kurzor na 'Where' a stlačte Ctrl+Shift+C pre dokončenie kódu. Dostanete:
 +
<syntaxhighlight lang=pascal> procedure TForm1.Form1Create(Sender: TObject);
 
  var
 
  var
 
   a: array[TWhere] of char;
 
   a: array[TWhere] of char;
Line 285: Line 345:
 
  begin
 
  begin
 
   for Where:=Low(a) to High(a) do writeln(a[Where]);
 
   for Where:=Low(a) to High(a) do writeln(a[Where]);
  end;
+
  end;</syntaxhighlight>
 +
 
 +
===Spätné dokončovanie triedy===
 +
(''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.
 +
 
 +
Táto vlastnosť je dostupná od 0.9.21.
 +
 
 +
Napríklad:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.DoSomething(Sender: TObject);
 +
  begin
 +
  end;</syntaxhighlight>
 +
 
 +
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.
 +
 
 +
Pre  Delphianov:
 +
Dokončovanie tried pracuje pod Lazarus vždy jednym spôsobom:
 +
*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.
 +
 
 +
===Komentáre a dokončovanie kódu===
 +
(''Comments and Code Completion'')
 +
 
 +
Dokončovanie kódu sa pokúša uchovávať komentáre tam, kde sú.
 +
Príklad:
 +
<syntaxhighlight lang=pascal>  FList: TList; // zoznam prvkov TComponent
 +
  FInt: integer;</syntaxhighlight>
  
===Comments and Code Completion===
+
Pri vkladaní novej premennej medzi FList a FInt, je komentár ponechaný na riadku spolu s FList. To platí i pre:
Code completion tries to keep comments where they belong.
+
<syntaxhighlight lang=pascal>  FList: TList; { zoznam prvkov TComponent
For example:
+
     Toto je komentár na niekoľkých riadkoch, začínajúci
  FList: TList; // list of TComponent
+
     na riadku s FList, tak nástroj dokončenia kódu predpokladá že patrí
  FInt: integer;
+
     k riadku s FList a nepreruší tento vzťah.
When inserting a new variable between FList and FInt, the comment is kept in the FList line. Same is true for
+
     Kód bude vložený za komentár. }
  FList: TList; { list of TComponent
+
   FInt: integer;</syntaxhighlight>
     This is a comment over several lines, starting
 
     in the FList line, so codetools assumes it belongs
 
     to the FLIst line and will not break this
 
     relationship. Code is inserted behind the comment. }
 
   FInt: integer;
 
If the comment starts in the next line:
 
  FList: TList; // list of TComponent
 
    { This comment belongs to the statement below.
 
      New code is inserted above this comment and
 
      behind the comment of the FList line. }
 
  FInt: integer;
 
  
 +
Ak komentár začína na ďalšom riadku:
 +
<syntaxhighlight lang=pascal>  FList: TList; // zoznam prvkov TComponent
 +
    { Tento komentár patrí k nasledujúcemu riadku.
 +
      Nový kód je vložený pred tentokomentár a
 +
      za komentár na riadku s FList. }
 +
  FInt: integer;</syntaxhighlight>
  
 
==Refactoring==
 
==Refactoring==
  
===Invert Assignments===
+
===Otočenie priradení===
 +
(''Invert Assignments'')
  
;Abstract: : "Invert Assignments" takes some selected pascal statements and inverts all assignments from this code. This tool is usefull for transforming a "save" code to a "load" one and inverse operation.
+
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.
  
Example:<br>
+
Príklad:
procedure DoSomething;
+
<syntaxhighlight lang=pascal> procedure DoSomething;
 
  begin
 
  begin
 
   AValueStudio:= BValueStudio;
 
   AValueStudio:= BValueStudio;
 
   AValueAppartment :=BValueAppartment;
 
   AValueAppartment :=BValueAppartment;
 
   AValueHouse:=BValueHouse;
 
   AValueHouse:=BValueHouse;
  end;
+
  end;</syntaxhighlight>
Select the lines with assignments (between begin and end) and do Invert Assignments. All assignments will be inverted and identation will be add automatically. For example:
 
  
Result:
+
Vyberte riadky s priradeniami (medzi begin a end) a urobte Otočenie priradenia, všetky priradenia budú otočené a automaticky odsadené. Výsledok:
procedure DoSomething;
+
<syntaxhighlight lang=pascal> procedure DoSomething;
 
  begin
 
  begin
 
   BValueStudio    := AValueStudio;
 
   BValueStudio    := AValueStudio;
 
   BValueAppartment := AValueAppartment;
 
   BValueAppartment := AValueAppartment;
 
   BValueHouse      := AValueHouse;
 
   BValueHouse      := AValueHouse;
  end;
+
  end;</syntaxhighlight>
 +
 
 +
=== Uzavrieť výber ===
 +
 
 +
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.
 +
 
 +
=== Premenovať identifikátor ===
 +
 
 +
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.
 +
* 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é.
 +
* najprv bude vykonaná kontrola konfliktov mena.
 +
* Obmedzenia: Pracuje len so zdrojovými kódmi Pascalu, zatiaľ nepremenúva súbory ani neupravuje súbory lfm/lrs, či súbory lazdoc.
 +
 
 +
=== Nájdi odkazy na identifikátor ===
 +
 
 +
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é.
 +
 
 +
=== Zobraziť abstraktné metódy ===
 +
 
 +
Táto funkcia vypisuje a automaticky kompletuje virtuálne, abstraktné metódy, ktoré je majú byť implementované.
 +
 
 +
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.
 +
 
 +
=== Vytiahnuť procedúru ===
 +
Viz [[IDE_Window:_Extract_Procedure/sk|Extract Procedure]]
 +
 
 +
==Hľadanie deklarácie==
 +
(''Find Declaration'')
 +
 
 +
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.
 +
 
 +
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.
 +
 
 +
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:
 +
 
 +
: 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.
 +
 
 +
Obdobne je to s TColor.
 +
Pre prekladač je to jednoducho 'longint', ale v zdrojovom kóde je to definované ako:
 +
<syntaxhighlight lang=pascal> TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
 +
TColor = TGraphicsColor;</syntaxhighlight>
 +
 
 +
Obdobné je to aj s forward definovanými triedami:
 +
Napríklad v TControl je priávtna premenná
 +
<syntaxhighlight lang=pascal> FHostDockSite: TWinControl;</syntaxhighlight>
 +
 
 +
Hľadanie deklarácie pre TWinControl skočí na forward definíciu:
 +
<syntaxhighlight lang=pascal> TWinControl = class;</syntaxhighlight>
 +
 
 +
A opätovné spustenie hľadania deklarácie skočí na skutočnú implementáciu:
 +
<syntaxhighlight lang=pascal> TWinControl = class(TControl)</syntaxhighlight>
 +
 
 +
Týmto spôsobom môžete stopovať každý identifikátor a nájsť každé predefinovanie, či preťaženie.
 +
 
 +
==Dokončovanie identifikátorov==
 +
(''Identifier Completion'')
 +
 
 +
Dokončovanie identifikátorov je vyvolané pomocou Ctrl+Space a zobrazuje všetky vyhovujúce identifikátory.
 +
 
 +
Napríklad:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.FormCreate(Sender: TObject);
 +
  begin
 +
    |
 +
  end;</syntaxhighlight>
 +
 
 +
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ší.
  
===Extract Procedure===
+
'''Poznámka pre Delphianov:''' Delphi to volá ''Dokončovanie kódu''.
;Abstract: : "Export Procedure" takes some selected pascal statements and creates a new procedure/method from this code. This tool is useful to split big procedures or to easily create a new procedure from some code.
 
  
Basic example:<br>
+
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'').
procedure DoSomething;
 
begin
 
  CallSomething;
 
end;
 
Select the line "CallSomething;" and do Extract Proc. A dialog pop ups and
 
you can select the type and name of the procedure to create. For example:
 
procedure, "NewProc". Result:
 
procedure NewProc;
 
begin
 
  CallSomething;
 
end;
 
 
procedure DoSomething;
 
begin
 
  NewProc;
 
end;
 
You can see, that the new procedure "NewProc" was created with the selection
 
as body and the old code was replaced by a call.
 
  
Local Variables and Parameters:<br>
+
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|Dokončovanie slov]] alebo Ctrl+J [[#Šablóny_kódu|Šablóny kódu]].
"Extract Proc" scans for used variables and automatically creates the
 
parameter list and local variables. Example:
 
procedure TForm1.DoSomething(var Erni, Bert: integer);
 
var
 
  i: Integer; // Comment
 
begin
 
  Erni:=Erni+Bert;
 
  for i:=Erni to 5 do begin
 
  |
 
  end;
 
end;
 
Select the for loop and create a new Procedure "NewProc". The local variable i is only used in the selection, so it will be moved to the new procedure. Erni is also used in the remaining code, so it will become a parameter.
 
  
Result:<br>
+
Dokončovanie identifikátorov nezobrazuje len tie identifikátory, ktoré nie sú kompatibilné.
procedure NewProc(const Erni: integer);
 
var
 
  i: Integer; // Comment
 
begin
 
  for i:=Erni to 5 do begin
 
  |
 
  end;
 
end;
 
 
procedure TForm1.DoSomething(var Erni, Bert: integer);
 
begin
 
  Erni:=Erni+Bert;
 
  NewProc(Erni);
 
end;
 
  
You can see "i" was moved to the new procedure (Note: including its comment) and Erni.
+
===Predpona===
 +
Môžete začať dokončovanie identifikátorov v existujúcom slove. Potom budú písmená vľavo od kurzora brané ako predpona.  
  
Limitations:<br>
+
Napríklad:
Pascal is a very powerful language, so don't expect it will work with every code. Current limits/ToDos:
+
<syntaxhighlight lang=pascal> procedure TForm1.FormCreate(Sender: TObject);
* check if selection bounds on statement bounds
+
  begin
* heuristic for parameter specifiers 'var'. At the moment all parameters are "const". If you need "var", you have to edit it manually.
+
    Ca|ption
* "with" statements
+
  end;</syntaxhighlight>
  
==Find Declaration==
+
Okno bude zobrazovať len identifikátory začínajúce sa na 'Ca'.
Position the cursor on an identifier and do 'Find Declaration'. Then it will search the declaration of this identifier, open the file and jump to it.
 
  
Every find declaration sets a Jump Point. That means you jump with find declaration to the declaration and easily jump back with Search -> Jump back.
+
===Klávesy===
  
There are some differences to Delphi:
+
* Písmená/čísla: pridávajú znak do editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam.
The codetools work on sources following the normal pascal rules, instead of using the compiler output. The compiler returns the final type. The codetools see the sources and all steps in between. For example:
+
* Backspace: odstraňuje posledný znak z editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam.
 +
* Return: nahradzuje celé slovo na kurzore zvoleným identifikátorom a zatvára vyskakovacie okno.
 +
* Shift+Return: as ''Return'', but replaces only the prefix (left part) of the word at the cursor.
 +
* Hore/Dole: presúva výber.
 +
* Esc: zatvára vyskakovacie okno bez zmeny.
 +
* 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'.
 +
* Else: ako ''Return'' a pridá znak do editora zdrojového kódu.
  
The 'Visible' property is first defined in TControl (controls.pp), then redefined in TCustomForm and finally redefined in TForm.
+
==Dokončovanie slov==
Invoking find declaration on Visible will you first bring to Visible in TForm. Then you can invoke Find Declaration again to jump to Visible in TCustomForm and again to jump to Visible in TControl.
+
(''Word Completion'')
  
Same is true for types like TColor.
+
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.
For the compiler it is simply a 'longint'. But in the sources it is defined as
 
TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
 
TColor = TGraphicsColor;
 
  
And the same for forward defined classes:
+
==Prejdi do direktívy include==
For instance in TControl, there is a private variable
+
(''Goto Include Directive'')
FHostDockSite: TWinControl;
 
Find declaration on TWinControl jumps to the forward definition
 
TWinControl = class;
 
And invoking it again jumps to the real implementation
 
TWinControl = class(TControl)
 
This way you can track down every identifier and find every overload.
 
  
==Goto Include Directive==
+
Tento príkaz v menu Searchskočí do príkazu (direktívy) {$I filename}, v ktorej je použitý aktuálny súbor.
"Goto Include Directive" in the search menu of the IDE jumps to {$I filename} statement where the current include file is used.
 
  
==Publish Project==
+
==Publikuj Projekt==
Creates a copy of the whole project. If you want to send someone just the sources and compiler settings of your code, this function is your friend.
+
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.
  
A normal project directory contains a lot of information. Most of it is not needed to be published:
+
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.
The .lpi file contains session information (like caret position and bookmarks of closed units) and the project directory contains a lot of .ppu, .o files and the executable.
 
To create a lpi file with only the base information and only the sources, along with all sub directories use "Publish Project".
 
  
In the dialog you can setup the exclude and include filter, and with the command after you can compress the output into one archive.
+
V ponúknutom dialógu môžete nastaviť filter pre zahrnutie/vynechanie, či pre kompresiu výstupu do jediného archívu.
  
==Original contributors==
+
==Spolupracovníci==
 
This page has been converted from the epikwiki [http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools version].
 
This page has been converted from the epikwiki [http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusIdeTools version].
 
* Created page and initial template - 4/6/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Created page and initial template - 4/6/2004 [[User:Tom Lisjac| VlxAdmin]]
Line 434: Line 529:
 
* Small wiki and formatting fixes - 4/11/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Small wiki and formatting fixes - 4/11/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Added a summary table for IdeTools shortcuts - 12 July 2004 [[User:Kirkpatc]]
 
* Added a summary table for IdeTools shortcuts - 12 July 2004 [[User:Kirkpatc]]
 +
* Preložené z originálu [[Lazarus IDE Tools]] - [[User:Slavko|Slavko]] 13:51, 25 Mar 2005 (PST)

Latest revision as of 01:06, 19 February 2020

Deutsch (de) English (en) español (es) suomi (fi) français (fr) 日本語 (ja) 한국어 (ko) Nederlands (nl) português (pt) русский (ru) slovenčina (sk) 中文(中国大陆)‎ (zh_CN)

Úvod

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).

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ší.

Zhrnutie klávesových skratiek IDE

Hľadanie deklarácie (Declaration Jumping) Ctrl+Click alebo Alt+Up
Prepínanie metód (Method Jumping) Ctrl+Shift+Up a Ctrl+Shift+Down
Šablóny kódu (Code Templates) Ctrl+J
Dokončovanie kódu (Code/Class Completion) Ctrl+Shift+C
Dokončovanie identifikátorov (Identifier Completion) Ctrl+Medzerník
Dokončovanie slov (Word Completion) Ctrl+W
Pomoc s parametrami (Parameter Hints) Ctrl+Shift+Space

Prepínanie metód

(Method Jumping)

Na prepínanie medzi telom procedúry (begin..end) a jej definíciou (procedure Name;) použite Ctrl+Shift+Up.

Príklad:

 interface
 
 procedure DoSomething; // procedure definition
  
 implementation
  
 procedure DoSomething; // procedure body 
 begin
 end;

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).

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.

Príklad procedúry s rôznymi typmi parametrov:

 interface
 
 procedure DoSomething(p: char); // procedure definition
 
 implementation
   
 procedure DoSomething(p: string); // procedure body
 begin
 end;

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.

Príklad: Premenovali sme 'DoSomething' na 'MakeIt':

 interface
 
 procedure MakeIt; // procedure definition
 
 implementation
 
 procedure DoSomething; // procedure body
 begin
 end;

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.

Include súbory

(Include Files)

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.

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.

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.

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.

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ť.

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. ;)

Šablóny kódu

(Code Templates)

Š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.

Príklad: Napíšte identifikátor 'classf', ponechajte kurzor vpravo za 'f' a stlačte Ctrl+J. Identifikátor 'classf' bude nahradený týmto:

 T = class(T)
 private
 
 public
   constructor Create;
   destructor Destroy; override;
 end;

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.

Pomoc s parametrami

(Parameter Hints) Pomoc s parametrami ukazuje pomocné okno s deklaráciami parametrov aktuálneho zoznamu parametrov.

Napríklad

  Canvas.FillRect(|);

Umiestnite kurzor do zátvoriek a stlačte Ctrl+Shift+Space. Objaví sa pomocné okno, ukazujúce parametre FillRect.

Dokončovanie kódu

(Code Completion)

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í:

  • Dokončovanie tried (Class Completion): dokončuje vlastnosti, pridáva telá metód, pridáva súkromné premenné a súkromné metódy;
  • Dokončovanie forward procedúr (Forward Procedure Completion): pridáva telá forward procedúr;
  • Dokončovanie priradenia udalostí (Event Assignment Completion): * dokončuje pridelenie udalostí a pridávanie tiel a definícií metód;
  • Dokončovanie lokálnych premenných (Local Variable Completion): pridáva definície lokálnych premenných.

Ktorá funkcia je použitá, závisí na pozícii kurzora v editore zdrojového kódu.

Dokončovanie tried

(Class Completion)

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.

Príklad: Vytvorte triedu (viz Šablóny kódu, aby ste ušetrili rovnakú prácu):

 TExample = class(TObject)
 public
   constructor Create;
   destructor Destroy; override;
 end;

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:

 { TExample }
 
 constructor TExample.Create;
 begin
   |
 end;
 
 destructor TExample.Destroy;
 begin
   inherited Destroy;
 end;
Poznámka: Značka '|' nie je pridaná, len ukazuje umiestnenie kurzora.

Tip: Prepínať medzi telom a definíciou metódy môžete pomocou Ctrl+Shift+Up.

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.

Teraz pridajte metódu DoSomething:

 TExample = class(TObject)
 public
   constructor Create;
   procedure DoSomething(i: integer);
   destructor Destroy; override;
 end;

Potom stlačte Ctrl+Shift+C a IDE pridá:

 procedure TExample.DoSomething(i: integer);
 begin
   |
 end;

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.

Dokončovanie vlastností

Pridajte vlastnosť AnInteger:

 TExample = class(TObject)
 public
   constructor Create;
   procedure DoSomething(i: integer);
   destructor Destroy; override;
   property AnInteger;
 end;

Stlačte Ctrl+Shift+C a dostanete:

 procedure TExample.SetAnInteger(const AValue: integer);
 begin
   |if FAnInteger=AValue then exit;
   FAnInteger:=AValue;
 end;

Dokončovanie kódu pridalo metódu pre prístup k zápisu do vlastnosti a nejaký základný kód.

Preskočte do triedy pomocou Ctrl+Shift+C a uvidíte, že v triede pribudlo:

 TExample = class(TObject)
 private
   FAnInteger: integer;
   procedure SetAnInteger(const AValue: integer);
 public
   constructor Create;
   procedure DoSomething(i: integer);
   destructor Destroy; override;
   property AnInteger: integer read FAnInteger write SetAnInteger;
 end;

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.

Vytvorenie vlastnosti len na čítanie:

 property PropName: PropType read;

Bude rozšírené na:

 property PropName: PropType read FPropName;

Vytvorenie vlastnosti len pre zápis:

  property PropName: PropType write;

Bude rozšírené na:

 property PropName: PropType write SetPropName;

Vytvorenie read only vlastnosti s metódou na čítanie:

 property PropName: PropType read GetPropName;

Deklarácia ostane nezmenená, ale bude pridaná funkcia GetPropName:

 function GetpropName: PropType;

Vytvorenie vlastnosti s direktívou stored:

 property PropName: PropType stored;

Bude rozšírené na:

 property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;

Pretože direktíva stored je používaná pre streamovanie čítania a zápisu, sú pridané aj kľúčové slová read a write.

Tip: Dokončovanie identifikátorov tiež rozpoznáva nekompletné vlastnosti a navrhne predvolené mená. Napríklad:

 property PropName: PropType read |;

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.

Dokončovanie procedúr

(Forward Procedure Completion)

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.

Napríklad: Pridajte novú procedúru do časti interface:

 procedure DoSomething;

Umiestnite kurzor na ňu a stlačte Ctrl+Shift+C pre dokončovanie kódu. V časti implementation bude doplnené:

 procedure DoSomething;
 begin
   |
 end;
Tip: Pomocou Ctrl+Shift+Up môžete prepínať medzi definíciou a telom procedúry.

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:

  procedure Proc1;
  procedure Proc2; // nová procedúra
  procedure Proc3;

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.

Viacero procedúr:

 procedure Proc1_Old; // telo existuje
 procedure Proc2_New; // telo neexistuje
 procedure Proc3_New; //  "
 procedure Proc4_New; //  "
 procedure Proc5_Old; // telo existuje

Dokončovanie kódu pridá 3 telá procedúr (Proc2_New, Proc3_New, Proc4_New).

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.

Dokončovanie priradenia udalostí

(Event Assignment Completion)

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.

Napríklad

V metóde, povedzme udalosti FormCreate, pridajte riadok: 'OnPaint:=':

 procedure TForm1.Form1Create(Sender: TObject);
 begin
   OnPaint:=|
 end;

Značka '|' je umiestnenie kurzora a netreba ju zadávať.

Potom stlačte Ctrl+Shift+C pre dokončovanie kódu. Príkaz priradenia udalosti bude doplnený takto:

 OnPaint:=@Form1Paint;

Do triedy TForm1 bude pridaná nová metóda Form1Paint. Potom je spustené dokončovanie tried a dostanete:

 procedure TForm1.Form1Paint(Sender: TObject);
 begin
   |
 end;

Pracuje presne ako pridávanie metód v Inšpektore objektov.

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á.

Tip: Môžete definovať meno novej metódi aj sami, a to jej zadaním do priradenia, napríklad:

 OnPaint:=@ThePaintMethod;

Dokončovanie deklarácie premenných

(Variable Declaration Completion)

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í.

Napríklad:

 procedure TForm1.Form1Create(Sender: TObject);
 begin
   i:=3;
 end;

Umiestnite kurzor na 'i' alebo tesne za neho, potom stlačte Ctrl+Shift+C pre dokončovanie kódu a dostanete:

 procedure TForm1.Form1Create(Sender: TObject);
 var
   i: Integer;
 begin
   i:=3;
 end;

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.

Iný príklad:

 type
  TWhere = (Behind, Middle, InFront);
 
  procedure TForm1.Form1Create(Sender: TObject);
  var
    a: array[TWhere] of char;
  begin
    for Where:=Low(a) to High(a) do writeln(a[Where]);
  end;

Umiestnite kurzor na 'Where' a stlačte Ctrl+Shift+C pre dokončenie kódu. Dostanete:

 procedure TForm1.Form1Create(Sender: TObject);
 var
   a: array[TWhere] of char;
   Where: TWhere;
 begin
   for Where:=Low(a) to High(a) do writeln(a[Where]);
 end;

Spätné dokončovanie triedy

(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.

Táto vlastnosť je dostupná od 0.9.21.

Napríklad:

  procedure TForm1.DoSomething(Sender: TObject);
  begin
  end;

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.

Pre Delphianov: Dokončovanie tried pracuje pod Lazarus vždy jednym spôsobom:

  • 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.

Komentáre a dokončovanie kódu

(Comments and Code Completion)

Dokončovanie kódu sa pokúša uchovávať komentáre tam, kde sú. Príklad:

  FList: TList; // zoznam prvkov TComponent
  FInt: integer;

Pri vkladaní novej premennej medzi FList a FInt, je komentár ponechaný na riadku spolu s FList. To platí i pre:

  FList: TList; { zoznam prvkov TComponent
    Toto je komentár na niekoľkých riadkoch, začínajúci
    na riadku s FList, tak nástroj dokončenia kódu predpokladá že patrí 
    k riadku s FList a nepreruší tento vzťah.
    Kód bude vložený za komentár. }
  FInt: integer;

Ak komentár začína na ďalšom riadku:

  FList: TList; // zoznam prvkov TComponent
    { Tento komentár patrí k nasledujúcemu riadku. 
      Nový kód je vložený pred tentokomentár a 
      za komentár na riadku s FList. }
  FInt: integer;

Refactoring

Otočenie priradení

(Invert Assignments)

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.

Príklad:

 procedure DoSomething;
 begin
   AValueStudio:= BValueStudio;
   AValueAppartment :=BValueAppartment;
   AValueHouse:=BValueHouse;
 end;

Vyberte riadky s priradeniami (medzi begin a end) a urobte Otočenie priradenia, všetky priradenia budú otočené a automaticky odsadené. Výsledok:

 procedure DoSomething;
 begin
   BValueStudio     := AValueStudio;
   BValueAppartment := AValueAppartment;
   BValueHouse      := AValueHouse;
 end;

Uzavrieť výber

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.

Premenovať identifikátor

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.

  • 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é.
  • najprv bude vykonaná kontrola konfliktov mena.
  • Obmedzenia: Pracuje len so zdrojovými kódmi Pascalu, zatiaľ nepremenúva súbory ani neupravuje súbory lfm/lrs, či súbory lazdoc.

Nájdi odkazy na identifikátor

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é.

Zobraziť abstraktné metódy

Táto funkcia vypisuje a automaticky kompletuje virtuálne, abstraktné metódy, ktoré je majú byť implementované.

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.

Vytiahnuť procedúru

Viz Extract Procedure

Hľadanie deklarácie

(Find Declaration)

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.

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.

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:

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.

Obdobne je to s TColor. Pre prekladač je to jednoducho 'longint', ale v zdrojovom kóde je to definované ako:

 TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
 TColor = TGraphicsColor;

Obdobné je to aj s forward definovanými triedami: Napríklad v TControl je priávtna premenná

 FHostDockSite: TWinControl;

Hľadanie deklarácie pre TWinControl skočí na forward definíciu:

 TWinControl = class;

A opätovné spustenie hľadania deklarácie skočí na skutočnú implementáciu:

 TWinControl = class(TControl)

Týmto spôsobom môžete stopovať každý identifikátor a nájsť každé predefinovanie, či preťaženie.

Dokončovanie identifikátorov

(Identifier Completion)

Dokončovanie identifikátorov je vyvolané pomocou Ctrl+Space a zobrazuje všetky vyhovujúce identifikátory.

Napríklad:

  procedure TForm1.FormCreate(Sender: TObject);
  begin
    |
  end;

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ší.

Poznámka pre Delphianov: Delphi to volá Dokončovanie kódu.

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).

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.

Dokončovanie identifikátorov nezobrazuje len tie identifikátory, ktoré nie sú kompatibilné.

Predpona

Môžete začať dokončovanie identifikátorov v existujúcom slove. Potom budú písmená vľavo od kurzora brané ako predpona.

Napríklad:

  procedure TForm1.FormCreate(Sender: TObject);
  begin
    Ca|ption
  end;

Okno bude zobrazovať len identifikátory začínajúce sa na 'Ca'.

Klávesy

  • Písmená/čísla: pridávajú znak do editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam.
  • Backspace: odstraňuje posledný znak z editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam.
  • Return: nahradzuje celé slovo na kurzore zvoleným identifikátorom a zatvára vyskakovacie okno.
  • Shift+Return: as Return, but replaces only the prefix (left part) of the word at the cursor.
  • Hore/Dole: presúva výber.
  • Esc: zatvára vyskakovacie okno bez zmeny.
  • 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'.
  • Else: ako Return a pridá znak do editora zdrojového kódu.

Dokončovanie slov

(Word Completion)

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.

Prejdi do direktívy include

(Goto Include Directive)

Tento príkaz v menu Searchskočí do príkazu (direktívy) {$I filename}, v ktorej je použitý aktuálny súbor.

Publikuj Projekt

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.

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.

V ponúknutom dialógu môžete nastaviť filter pre zahrnutie/vynechanie, či pre kompresiu výstupu do jediného archívu.

Spolupracovníci

This page has been converted from the epikwiki version.

  • Created page and initial template - 4/6/2004 VlxAdmin
  • Initial content posted - 4/10/2004 MattiasG
  • Small wiki and formatting fixes - 4/11/2004 VlxAdmin
  • Added a summary table for IdeTools shortcuts - 12 July 2004 User:Kirkpatc
  • Preložené z originálu Lazarus IDE Tools - Slavko 13:51, 25 Mar 2005 (PST)