Lazarus IDE Tools/sk

From Lazarus wiki
Jump to navigationJump to search

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

Prepínanie deklarácií (Declaration Jumping) Ctrl+Click alebo Alt+Up
Prepínanie metód (Method Jumping) Ctrl+Shift+Up
Š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+Space
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 ste '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 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.

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 Environment -> Editor 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.

Dokončovanie kódu

(Code Completion)

Dokončovanie kódu nájdete v menu IDE Edit -> Complete Code a má štandartnú klávespvú 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 pridajtemetó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 Environment > Codetools Options -> Code Creation.

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+Up 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 Environment > Codetools Options -> Code Creation.

Vytvorenie read only vlastnosti:

property PropName: PropType read;

Bude rozšírené na:

property PropName: PropType read FPropName;

Vytvorenie write only vlstnosti:

 property PropName: PropType write;

Bude rozšírené na:

property PropName: PropType write SetPropName;

Vytvorenie read only vlastnosti s metódou Read:

property PropName: PropType read GetPropName;

Ostane nezmenené a 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ú kľúčové slová read a write pridané tiež.

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 forward procedúr

(Forward Procedure Completion)

Dokončovanie forward 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.

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

procedure DoSomething;

Umiestnite kurzor na ňu a stlačte Ctrl+Shift+C pre dokončovaniekó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 Environment > Codetools Options -> Code Creation.

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

Prečo sa to volá Dokončovanie forward procedúr"?

Pretože 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.

Napríklad: V metóde, povedzme udalosti FormCreate event, 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ávaniem etód v Object inspectore.

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 lokálnych premenných

(Local Variable Completion)

Dokončovanie lokálnych premenných je časťou Dokončovania kódu a pridáva definíciu lokálnej premennej pre príkaz Identifier:=Term;. Je spustené, 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;

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 priradenie

(Invert Assignments)

Otočenie priradenia 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;

Extract Procedure

Zhrnutie
: "Export Procedure" pracuje s vybratými príkazmi Pascalu a vytvára z tohoto výberu novú procedúru/metódu. Tento nástroj je užitočný na rozdelenie veľkých provedúr alebo na jednoduché vytvorenie novej procedúry z nejakého kódu.

Základný príklad:

procedure DoSomething;
begin
  CallSomething;
end;

Vyberte riadok "CallSomething;" a vykonajte Extract Proc. Vyskočí dialóg a môžete zvoliť typ a meno procedúry, ktorá má byť vytvorená. Napríklad: procedure, "NewProc". Výsledok:

procedure NewProc;
begin
  CallSomething;
end;

procedure DoSomething;
begin
  NewProc;
end;

Všimnite si, že nová procedúra "NewProc" bola vytvorená z vybratého textu, teda vybratý text bol pridaný do jej tela a a starý kód bol nahradený jej volaním.

Lokálne premenné a parametre: "Extract Proc" kontroluje použité premenné a automaticky vytvára zoznam parametrov a locálnych premenných. Napríklad:

procedure TForm1.DoSomething(var Erni, Bert: integer);
var
  i: Integer; // Comment
begin
  Erni:=Erni+Bert;
  for i:=Erni to 5 do begin
  |
  end;
end;

Vyberte cyklus for a vytvorte novú procedúru "NewProc". Lokálna premenná "i" je použitá len vo výbere, tak bude presunutá do novej procedúry. "Erni" je použité aj vo zvyšku kódu, tak sa z neho stane parameter:

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;

Všimnite si, že "i" bolo presunuté do novej procedúry vrátane komentára.

Obmedzenia: Pascal je veľmi výkonný jazyk, tak neočakávajte, že tento nástroj bude pracovať s celým kódom. Aktuálne obmedzenia:

  • preverte, či hranice výberu sú na hraniciach príkazov
  • heuristika pre parametre 'var'. Všetky parametre sú pridávané ako "const". Ak potrebujete "var", musíte to dokončiť manuálne.
  • príkazy "with"

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

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)