Kategória: ObjectPascal

Zmenené: 8. december 2008

Nástroje vývojára

Integrované vývojové prostredie (IDE) Lazarus sa hrdí tým, že je to prostredie pre Rýchly vývoj aplikácii (RAD). A myslím si, že právom. IDE ponúka vývojárovi mnoho nástrojov pre zrýchlenie práce so zdrojovým kódom, ktoré sú však málo známe.

Nástroje IDE sú popísané aj v slovenskom preklade dokumentácie, napriek tomu chcem tieto nástroje popísať znova. Vzhľadom k tomu, že som tú stránku dokumentácie prekladal, dovolím si niektoré časti použiť doslovne.

Niektoré nástroje sú prístupné prostredníctvom kontextového menu, iné pomocou klávesovej skratky. Zväčša však obomi spôsobmi. V popise sa zamerám na ovládanie klávesovými skratkami, pretože predpokladám, že väčšina vývojárov píše kód na klávesnici a je preto málo efektívne neustále premiestňovanie ruky z klávesnice na myš a naopak.

Nástroje, ktoré ponúka IDE Lazarus vývojárovi na zjednodušenie i zrýchlenie práce možno rozdeliť do niekoľkých kategórií:

• nástroje presunu v kóde
• dokončovanie kódu
• refactoring
• šablóny
• publikovanie projektu

Zhrnutie klávesových skratiek

Názov		Klávesová skratka
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

Úplne na začiatok popíšem tri, asi najužitočnejšie nástroje, ktoré ponúka IDE.

Dokončovanie identifikátorov

V originále Identifier Completion, je naozaj užitočný nástroj. Keďže programovanie v Lazare nie je mojou prácou, ale len koníčkom, nenosím v hlave všetky možné aj nemožné mená vlastností, metód, procedúr či funkcií. Nepamätám si aj preto, lebo nemusím, napíšem niekoľko prvých písmen a potom stlačím Ctrl+Medzerník a v zozname, ktorý sa objaví, si nájdem to čo práve potrebujem. A nemusím napísať ani tých niekoľko znakov na začiatku. Predstavte si procedúru:

Dokončenie identifikátora

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

Umiestnite v nej 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. Prvý krát to môže chvíľu trvať, ale CodeTools si ukladajú výsledok do medzipamäte, takže ďalšie hľadania sú rýchlejšie.

Niektoré identifikátory, ako napríklad Write, ReadLn, Low, SetLength, a podobne sú zabudované v prekladači, a teda nie sú definované nikde v zdrojovom kóde. Ak by dokončovanie identifikátorov pracovalo len so zdrojovými kódmi, nenašlo by ich. Preto má funkcia Dokončovanie identifikátorov veľa z takýchto slov tiež zabudovaných.

Dokončovanie identifikátorov nedokončuje kľúčové slová prekladača, takže ho nemožno použiť na dokončenie proc na procedure. Na toto je určené Dokončovanie slov alebo Šablóny kódu. Dokončovanie identifikátorov nezobrazuje tie identifikátory, ktoré sú nekompatibilné a tiež rozpoznáva nekompletné vlastnosti a navrhne predvolené mená:

property PropName: PropType read |;

Keď umiestnite kurzor za medzeru za kľúčovým slovom read a stlačíte Ctrl+Medzerník pre dokončovanie identifikátorov, bude v zozname ponúknutá len premenná FPropName a procedúra SetPropName. Ak b bola v zozname ponúknutá len jedna možnosť, je táto možnosť automaticky doplnená.

Pri vyhľadávaní vhodných kandidátov na doplnenie identifikátora berie do úvahy všetky znaky vľavo od kurzora a poskytuje v zozname len identifikátory, ktorá sa na dané znaky začínajú. Takto môžete začať dokončovanie identifikátorov aj v už existujúcom slove. Potom budú písmená vľavo od kurzora brané ako predpona:

Doplňovanie uprostred slova

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

V totmo prípade nástroj ponúkne v zozname len identifikátory, ktoré sa začínajú na Ca.

Klávesy v okne identifikátorov

Pri zobrazenom okne so zoznamom ponúkaných identifikátorov majú jednotlivé klávesy takúto funkciu:

• 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,
• Enter: nahradzuje celé slovo na kurzore zvoleným identifikátorom a zatvára vyskakovacie okno,
• Shift+Enter: ako Enter, ale nahradzuje len predponu (ľavú časť) slova na kurzore,
• Hore/Dole: presúva výber,
• Esc: zatvára vyskakovacie okno bez zmeny,
• Tabulátor: dokončuje predponu na ďalšiu zhodu, ak napríklad aktuálna predpona je But a dokončovanie identifikátora zobrazuje len Button1 a Button1Click, potom stlačenie Tabulátora dokončí predponu na Button1.

Dokončovanie slov

Dokončovanie slov (Word Completion) dokončuje kľúčové slová prekladača, je vyvolané stlačením Ctrl+W a na dokončenie ponúka všetky slová všetkých aktuálne otvorených editorov. Inak pracuje presne ako Dokončovanie identifikátorov.

Pomoc s parametrami

Toto je môj ďalší problém. Keď sa už dopátram k menu funkcie, či procedúry, ako sa dostať k zoznamu jej parametrov? To je práve úloha pre Pomoc s parametrami (Parameter Hints). Po stlačení Ctrl+Shift+Medzerník ukazuje pomocné okno s deklaráciami parametrov aktuálneho zoznamu parametrov:

Canvas.FillRect(|);

Umiestnite kurzor do zátvoriek, stlačte skratku Ctrl+Shift+Medzerník a objaví sa pomocné okno, ukazujúce parametre FillRect. Ak je funkcia preťažená, okno poskytuje zoznam parametrov podľa aktuálne zadaných údajov.

Skákanie v kóde

Určite ste sa stretli s tým, že ste potrebovali pozrieť na iné miesto v kóde. IDE poskytuje pre tento účel niekoľko praktických nástrojov.

Prepínanie metód

V anglickom origináli sa tento nástroj volá Method Jumping, čiže doslovný preklad by mohol znieť Metódové skákanie. Ale myslím, že prepínanie je výstižnejšie, pretože sa jedná o prepínanie medzi telom metódy a jej deklaráciou.

Na samotné prepínanie slúžia klávesové skratky Ctrl+Shift+ŠípkaHore, respektíve Ctrl+Shit+ŠípkaDole. Skratku využijete, ak sa nachádzate (kurzor) v tele metódy, teda medzi kľúčovými slovami begin a end metódy. Stlačením Ctrl+Shift+ŠípkaHore sa kurzor prenesie na jej deklaráciu. Ak sa kurzor nachádza niekde v deklarácii procedúry, presuniete sa do jej tela pomocou klávesovej skratky Ctrl+Shit+ŠípkaDole.

Tento nástroj IDE nie je obmedzený len metódy, ale pracuje aj s bežnými procedúrami a funkciami. Dôležité je uvedomiť si, že pri romro prepínaní je urobený skok na metódu s rovnakým názvom aj zoznamom parametrov.

V prípade, že nástroj Prepínanie metód nenájde deklaráciu (alebo telo) metódy s rovnakým názvom a rovnakou deklaráciou parametrov, skočí na metódu, ktorá je najpodobnejšia a kurzor umiestni na prvý rozdiel v mene alebo parametroch metódy. Takto môžete pomerne jednoducho identifikovať preklep v mene metódy, alebo zabudnuté zmeny v deklarácii parametrov.

Príklad rôznych parametrov

interface

procedure DoSomething(p: char); // deklarácia procedúry

implementation

procedure DoSomething(p: string); // telo procedúry
begin
    // ...
end;

Preskočenie z deklarácie do tela umiestni kurzor na kľúčové slovo string, pretože v ňom je rozdiel. Túto vlastnosť môžete využiť na premenovanie metódy a/alebo zmenu jej parametrov.

Premenovaná metóda ‚DoSomething‘ na ‚MakeIt‘

interface

procedure MakeIt; // deklarácia procedúry

implementation

procedure DoSomething; // telo procedúry
begin
    // ...
end;

Ak v tomto prípade urobíte prepnutie z deklarácie MakeIt do jej tela, bude IDE hľadať vhodné telo, ale keďže žiadne nenájde, začne hľadať kandidátov. Premenovaná bola len jedna procedúra, tak existuje len jedno telo bez deklarácie (DoSomething), a tak kurzor skočí do DoSomething a IDE ho umiestni vpravo od DoSomething. Teraz je možné ľahko premenovať aj implementáciu procedúry. V prípade premenovaných parametrov je funkcia obdobná.

Hľadanie deklarácie

V originálnom názve Find Declaration. Tento nástroj je určený pre rýchle vyhľadanie deklarácie identifikátora. Stačí, ak je kurzor kdekoľvek v mene identifikátora, stlačiť skratku Alt+Up` a kurzor skočí na deklaráciu daného identifikátora. Ak máte v ruke myš, môžete využiť skratku Ctrl+ĽavéTlačidlo.

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é takéto hľadanie deklarácie nastavuje bod skoku. Tzn. po skoku na nájdenú deklaráciu môžete jednoducho skočiť naspäť pomocou kontextového menu Hľadať ‣ Skok späť.

Oproti Delphi má nástroj hlavný rozdiel v tom, že pracuje so zdrojovým kódom na základe pravidiel Pascalu, a nie s výsledkom prekladača. Prekladač potom vracia konečný typ identifikátora, len Hľadanie deklarácie prezerá zdrojové kódy a všetky kroky medzi získaním výsledného typu. Týmto spôsobom môžete stopovať každý identifikátor a nájsť každé predefinovanie, či preťaženie.

Napríklad, vlastnosť Visible je najprv deklarovaná 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 možno spustiť hľadanie deklarácie znova a skočíte na Visible v TCustomForm a znova pre skočenie na Visible v TControl.

Vnorené súbory

V originále Include Files . Jedná sa o súbory vložené do zdrojového kódu pomocou direktív prekladača {$I filename} alebo {$INCLUDE filename}. Lazarus a FreePascal často používajú tento spôsob rozdelenia zdrojového kódu na redukciu nadbytočnosti a zlepšenie čitateľnosti, napríklad konštrukcií {$IFDEF} pri podpore rôznych platforiem.

Narozdiel od Delphi, IDE Lazarus plne podporuje vnorené súbory. Napríklad môžete skočiť z deklarácie metódy v súbore .pas do tela metódy vo vnorenom (include) súbore. Všetky nástroje kódu, považujú vnorené 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 skoro pre všetky svoje ovládacie prvky.

Pri práci s vnorenými súbormi je však treba dávať pozor na jednu začiatočnícku chybu, a to ak najprv otvoríte vnorený súbor a skúsite prepínanie metód alebo hľadanie deklarácie, nemusí to fungovať. IDE totiž nevie (a ani nemá odkiaľ), do ktorej jednotky vnorený súbor patrí, preto je potebné najprv otvoriť jednotku.

Po zanalyzovaní jednotky, IDE v nej rozpozná direktívy include a bude pamätať vzťahy jednotlivých súborov. Tieto informácie si IDE ukladá pri skončení a pri uložení projektu, a keď nabudúce otvoríte vnorený súbor a urobíte do neho skok alebo hľadanie deklarácie, IDE interne otvorí jednotku a skoky budú fungovať.

Tento mechanizmus má aj svoje obmedzenia. Ak je vnorený súbor použitý dvomi, či viacerými jednotkami, potom jednotlivé skoky z deklarácie procedúry/metódy v tomto vnorenom súbore do tela závisia na poslednej akcii. Ak ste pracovali s jednou jednotkou, bude urobený skok do nej, ak s druho, potom do druhej. Ak pracujete s obomi, potom nastane zmätok.

Prejdi do direktívy include

Tento nástroj sa v origináli volá (Goto Include Directive). Tento príkaz, v menu Search, využijete vprípade, že sa nachádzate vo vnorenom súbore. Po jeho použití IDE urobí skok na miesto príkazu (direktívy) {$I filename}, pomocou ktorého je aktuálny súbor vnorený.

Záložky

Poznáte to, máte rozsiahly projekt, niečo v ňom upravujete, ale to neustále posúvanie sa o 20 riadkov, či o tri súbory vedľa… IDE ponúka riešenie, v súboroch zdrojového kódu si môžete definovať záložky, na ktoré potom môžete skákať pomocou klávesovej skratky alebo kontextového menu.

Záložku môžete vytvoriť pomocou klávesových skratiek Ctrl+Shift+Číslo a skočiť na už vytvorenú záložku pomocou skratky Ctrl+Číslo, pričom Číslo sú klávesy 0..9. Môžete využiť aj príkaz Nastaviť voľnú záložku. Tento príkaz priradí najnižšiu z voľných záložiek v mieste kurzora. Prístup k záložkam je aj prostredníctvom kontextového menu.

Všimnite si, že v kontextovom menu je pri každej nastavenej záložke zobrazené meno príslušného súboru spolu s číslom riadku a stĺpca. Takže skok na danú záložku prenesie kurzor na konkrétne miesto riadku.

Dokončovanie kódu

Nástroje dokončovania kódu využívam pomerne často, najmä dokončovanie identifikátorv, pretože si mená jednotlivých vlastností a metód jednoducho nepamätám. Zdá sa Vám to divné? Je to nakoniec jedno, hlavne, že sú tieto nástroje užitočné. A v skutku sa jedná o mocný nástroj, ktorý dokáže ušetriť veľa práce.

Dokončovanie tried

V originále nazvané Class Completion. Jedná sa o veľmi výkonnú funkciu dokončovania kódu a jej funkcia je prostá. Stačí napísať definíciu triedy, pridáte deklaráciu metód a vlastností, a Dokončovanie kódu pridá telá metód, metódy prístupu k vlastnostiam a súkromným premenným. A polovica práce je hotová. Nerozumiete? Všetko si ukážeme na príklade. Vytvorte triedu TExample:

Definícia triedy

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

Umiestnite kurzor niekde do tela definície triedy a stlačte skratku Ctrl+Shift+C. Dokončovanie tried vytvorí chýbajúce telá metód a presunie kurzor na prvé vytvorené telo, takže môžno rovno začať písať kód metódy:

Doplnené telá metód

{ TExample }

constructor TExample.Create;
begin
    |
end;

destructor TExample.Destroy;
begin
    inherited Destroy;
end;

Poznámka

Značka ‚|‘ nie je pridaná, len ukazuje umiestnenie kurzora.

Všimnite si, že Dokončovanie tried automaticky pridáva volanie deštruktora základnej triedy (inherited Destroy). Toto automatické vloženie je urobené, ak pri deklarácii metódy v triede použijete kľúčové slovo override. Teraz pridajte ďalšiu metódu, napríklad DoSomething:

Deklarované procedúry

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

Keď teraz použijeme Dokončovanie tried a bude pridané telo novej metódy:

Doplnené telo metódy

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

Všimnite si, že nové telo metódy je vložené medzi telá metódy Create a Destroy, teda presne na miesto ako je to v definícii. Týmto sú telá metód uchovávané v rovnakom logickom poradí, ako v deklarácii. Spôsob vkladania môžete definovať pomocou Prostredie ‣ Voľby Codetools ‣ Tvorba kódu.

Dokončovanie vlastností

Ale týmto Dokončovanie tried ani zďaleka nekončí. Táto funkcia dokáže aj dokončovať aj deklaráciu vlastností. Pre ukážku si do triedy pridáme vlastnosť AnInteger:

Pridaná vlastnosť

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

Stlačíme Ctrl+Shift+C a Dokončovanie tried pridá metódu pre prístup k zápisu do vlastnosti a nejaký základný kód:

Doplnená obsluha vlastnosti

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

A nie len to, Dokončovanie kódu pridalo deklaráciu čítania vlastnosti, a deklarácie súkromneho člena a metódy, ktoré slúžia na uchovávanie hodnoty a prístup k vlastnosti:

Doplnené súkromné členy

TExample = class(TObject)
    private
        FAnInteger: integer;
        procedure SetAnInteger(const AValue: integer);
    public
        constructor Create;
        procedure DoSomething(i: integer);
        destructor Destroy; override;
        property AnInteger: integerread 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 súkromného člena triedy je bežnou notáciou Delphi, rovnako ako označenie prístupovej metódy pomocou Set. Ak nechcete používať túto notáciu, môžete to zmeniť ponmocou Prostredie ‣ Voľby Codetools ‣ Tvorenie kódu.

Ďalšie možnosti doplňovania vlastností sú rovnako zaujímavé. Ak deklarujete vlastnosť takto:

property PropName: PropType read;

Dokončovanie triedy rozšíri deklaráciu na vlastnosť len na čítanie:

property PropName: PropType read FPropName;

Ak deklarujete vlastnosť takto:

property PropName: PropType write;

Dokončovanie triedy rozšíri deklaráciu na vlastnosť len na zápis:

property PropName: PropType write SetPropName;

Ak deklarujete vlastnosť s metódou read:

property PropName: PropType read GetPropName;

Dokončovanie triedy nechá deklaráciu vlastnosti nezmenenú, ale pridá deklaráciu funkcie GetPropName:

function GetpropName: PropType;

Ak pri deklarácii vlastnosti použijete direktívu stored:

property PropName: PropType stored;

Dokončovanie triedy túto deklaráciu rozšíri 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ú do deklarácie pridané aj kľúčové slová read a write.

Dokončovanie procedúr

V pôvodnom názve Forward Procedure Completion, táto časť dokončovania kódu dokončuje deklarácie procedúr pridaním tela 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. Tento nástroj nepracuje len s procedúrami definovanými v časti interface, ale aj s dopredne definovanými procedúrami, ktoré sú definované pomocou kľúčového slova forward.

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

procedure DoSomething;

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

Doplnené telo procedúry

procedure DoSomething;
begin
    |
end;

Telo novej procedúry je 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 nich. Toto správanie môže byť zmené pomocou Prostredie ‣ Voľby Codetools ‣ Tvorenie kódu. Ak pri spustení dokončovanie procedúr chýbajú telá viacerých 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á všetky tri telá procedúr (Proc2_New, Proc3_New, Proc4_New).

Dokončovanie priradenia udalostí

V originále nazvané Event Assignment Completion . Dokončovanie priradenia udalostí dokončuje jeden príkaz Udalosť := a pracuje presne tak, ako pridávanie metód v Inšpektore objektov. Na použitie dokončovania priradenia udalostí stačí umiestniť kurzor za príkaz priradenia udalosti a stlačiť Ctrl+Shift+C. Napríklad v metóde udalosti FormCreate, pridajte riadok OnPaint :=:

Písanie priradenia udalosti

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

Potom stlačte Ctrl+Shift+C pre spustenie dokončovania kódu a príkaz priradenia udalosti bude doplnený takto:

OnPaint:=@Form1Paint;

Zároveň bude do triedy TForm1 pridaná nová metóda Form1Paint.

Dôležité je aby ste kurzor umiestnili za operátor priradenia :=. Ak by ste ho umiestnili na identifikátor (tj. OnPaint), dokončovanie kódu spustí Dokončovanie lokálnych premenných, ale toto dokončovanie zlyhá, pretože premenná OnPaint už definovaná je.

Tip

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

OnPaint := @ThePaintMethod;

Dokončovanie deklarácie premenných

V anglickom origináli sa tento nástroj volá Variable Declaration Completion. Dokončovanie deklarácie premenných pridáva definíciu lokálnej premennej, ktorá sa vyskytuje v príkaze priradenia. Dokončovanie deklarácie premenných spustíte, stlačením skratky Ctrl+Shift+C, keď je kurzor umiestnený na identifikátore v priradení. Predstavte si, že máte kód:

Pôvodný kód

type
    TWhere = (Behind, Middle, InFront);

procedure TForm1.Form1Create(Sender: TObject);
var
    a: array[TWhere]ofchar];
begin
    for Where:=Low(a)toHigh(a)dowriteln(a[Where]);
end;

Umiestnite kurzor na identifikátor Where` v priradení začiatku cyklu a stlačte skratku :kbd:`Ctrl+Shift+C` pre dokončenie kódu. Výsledkom bude deklarácia premennej typu ``TWhere:

Výsledok dokončovania

procedure TForm1.Form1Create(Sender: TObject);
var
    a:     array[TWhere]ofchar;
    Where: TWhere;
begin
    for Where:=Low(a)toHigh(a)dowriteln(a[Where]);
end;

Typ identifikátora je odhadovaný podľa pravej strany príkazu priradenia. V tomto prípade je použitý typ podľa premennej a. Napríklad čísla sú identifikované ako Integer.

Spätné dokončovanie triedy

Pôvodný názov tejto funkcie dokončovania kódu je Reversed Class Completion . Spätné dokončovanie triedy pridáva deklarácie súkromných metód pre aktuálne telo metódy. Je vyvolané, keď je kurzor v tele metódy, ktorá zatiaľ v triede deklarovaná nie je a je stlačená klávesová skratka Ctrl+Shift+C:

Nedeklarovaná metóda

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

Metóda DoSomething zatiaľ nie je v TForm1 deklarovaná, preto stlačte Ctrl+Shift+C a medzi súkromné metódy triedy TForm1 bude pridaná deklarácia metódy

Pridaná deklarácia

procedure DoSomething(Sender: TObject);

Na rozdiel od Delphi je táto funkcia dokončovania kódu vykonávaná vždy len jednym smerom, a to buď Z rozhrania triedy do jej implementácie alebo naopak z implementácie triedy do jej rozhrania. Delphi vždy vyvoláva oba smery, čo však už pri malom preklepe môže spôsobiť, že bude bez upozornenia vytvorená definícia novej metódy.

Komentáre a dokončovanie kódu

Pri použití funkcií dokončovania kódu sa IDE Lazarus pokúša zachovať komentáre tam, kde sú. Ak máte takýto kód:

Deklarácia s jednoriadkovým komentárom

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

Bude, pri vkladaní novej premennej medzi FList a FInt, komentár ponechaný na riadku spolu s FList. To platí i pre viacriadkové komentáre:

Deklarácia s viacriadkovým komentárom

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 však komentár začína na ďalšom riadku:

Kombinácia jedno a viacriadkového komentára

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

bude IDE predpokladať, že komentár patrí k nasledujúcemu riadku a novú premennú pridá pred viacriadkový komentár.

Refactoring

Otočenie priradenia

V originále 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.

Pôvodné priradenia

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

Vyberte riadky s priradeniami (medzi begin a end) a vyvolajte funkciu Otočenie priradenia, ktorá je dostupná cez kontextové menu Refactoring ‣ Otočiť priradenie. Takto budú všetky priradenia otočené a automaticky odsadené:

Výsledok otočenia

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

Uzavrieť výber

Nástroj Uzavrieť výber môžete používať z kontextového menu Refatoring alebo ho nájdete v menu Upraviť. Slúži na vloženie uzatvorených blokov kódu k už napísanému kódu. Na jeho použitie nejaký vyberte blok textu a vyvolajte nástroj. Zobrazí sa dialóg, v ktorom si môžete vybrať aký blok má byť vytvorený.

Napríklad v procedúre:

Pôvodný kód

procedure VytvoritObjekt();
var
    lObjekt:TStringList;
begin
    WriteLn;
end;

vyberte slovo writeln, spusťte nástroj Uzavrieť výber a zvoľte, povedzme, blok Try .. Except. Procedúra bude doplnená takto:

Doplnený uzatvorený blok

procedure VytvoritObjekt();
var
    lObjekt:TStringList;
begin
    try
        WriteLn;
    except
        |
    end;
end;

Premenovať identifikátor

Niekedy v priebehu písania kódu zistíte, že ste pre premennú zvolili nesprávny identifikátor. Ak máte premennú použitú veľa krát, pravdepodobne sa s tým zmierite, lebo prepisovanie by bolo príliš pracné. Ale IDE ponúka pomoc aj v tomto prípade a premenuje všetky výskyty identifikátora, takže kedykoľvek v priebehu písania kódu môžete identifikátor jednoducho zmeniť tak, aby čo najlepšie vyhovoval vyšej potrebe.

Umiestnite kurzor na identifikátor a vyvolajte tento nástroj z kontextového menu Refactoring, objaví sa dialóg, v ktorom môžete nastaviť rozsah hľadania a nové meno identifikátora. Premenovanie je robené s týmito podmienkami:

• premenované budú všetky výskyty indentifikátora, ktoré momentálne používajú túto deklaráciu, čiže deklarácie s rovnakým menom premenované nebudú,
• pred premenovaním je vykonaná kontrola mena, čiže nástroj neumožní vytvoriť duplicitný identifikátor,
• premenovanie indentifikátorov je robené v súbore zdrojového kódu, preto si úpravy najprv uložte; premenovanie v novom, ešte neuloženom, súbore skončí chybou,
• premenovanie pracuje len so zdrojovými kódmi Pascalu, nepremenúva súbory ani neupravuje súbory lfm/ lrs či lazdoc.

Nájdi odkazy na identifikátor

V prípade, že potebujete zistiť, kde všade je v kóde použitý identifikátor, stačí ak umiestnite kurzor na identifikátor a z kontextového menu Refatoring ‣ Nájsť odkazy na identifikátor. Nástroj zobrazí dialógové okno, podobné tomu na premenovanie identifikátora, v ktorom si môžete zvoliť rozsah hľadania a potom zobrazí výsledky hľadania v okne hľadaní:

Oddeliť procedúru

Nástroj Oddeliť procedúru (Extract Procedure) pomáha pri tvorbe štruktúrovaného kódu tak, že umožňuje vystrihne vybratú časť kódu a vytvorí z nej novú procedúru alebo metódu.

Tento nástroj je užitočný na rozdelenie veľkých procedúr alebo na jednoduché vytvorenie novej procedúry z nejakého kódu. Ako príklad si zoberme jednoduchú procedúru s jedniným príkazom:

Základný príklad

procedure DoSomething;
begin
    Writeln;
end;

Vyberte riadok s príkazom WriteLn; a z kontextového menu vyberte Refactoring ‣ Oddeliť procedúru. Vyskočí dialógové okno, v ktorom môžete zvoliť typ a meno novej procedúry, ktorá má byť vytvorená. Zvoľte napríklad: Procedúra s menom NewProc a nástroj vytvorí kód:

Nová procedúra

procedure NewProc;
begin
    Writeln;
end;

procedure DoSomething;
begin
    NewProc;
end;

V príklade vidno, že bola vytvorená nová procedúra s menom NewProc a do jej tela bol vložený výber, ktorý bol v pôvodnej procedúre nahradený volaním novej procedúry. Ak by ste zvolili podprocedúru, bude vytvorená lokálna procedúra:

Nová podprocedúra

procedure DoSomething;
procedure NewProc;
begin
    Writeln;
end;

begin
    NewProc;
end;

Lokálne premenné a parametre:

Nástroj Oddeliť procedúru hľadá použité premenné a automaticky vytvára zoznam parametrov a lokálnych premenných, napríklad:

Ukážka s premennými

procedure DoSomething(var Erni, Bert: Integer);
var
    i: Integer; // Komentár
begin
    Erni:=Erni+Bert;
    for i:=Erni to5dobegin
        // nejaký kód
    end;
end;

Vyberte celú slučku For a nechajte vytvoriť novú procedúru NewProc. Lokálna premenná i je použitá len vo výbere, tak bude presunutá do novej procedúry. Premenná Erni je však použitá aj vo zvyšku kódu, tak sa z nej stane parameter:

Presunutie premenej

procedure NewProc(const Erni: Integer);
var
    i: Integer; // Komentár
begin
    for i:=Erni to 5 do begin
        // nejaký kód
    end;
end;

procedure DoSomething(var Erni, Bert: Integer);
begin
    Erni:=Erni+Bert;
    NewProc(Erni);
end;

Všimnite si, že premenná i je presunutá do procedúry NewProc vrátane komentára.

Šablóny kódu a Publikovať projekt

Šablóny kódu

Šablóny kódu (Code Templates) je šikovný nástroj, ktorý môže pri písaní kódu ušetriť mnoho práce a času tým, že stačí do kódu napísať len prednastavený identifikátor šablóny, použiť klávesúvú skratku Ctrl+J a nástroj tento identifikátor nahradí kódom šablóny. Lazarus už s inštaláciou prichádza s množstvom pripravených šablón, ktoré sú prístupné v menu Prostredie ‣ Šablóny kódu …

Na obrázku si môžete všimnúť v hornej časti okna preddefinované šablóny. Každá začína nastavenou skratkou a pokračuje krátkym popisom šablóny. Každú šablónu si môžete upraviť, zmazať alebo si môžete pridať vlastnú. Obsah zvolenej šablóny je zobrazený v spodnom okne. Znak rúry (|) v tele šablóny udáva pozíciu kurzora, po použití šablóny teda miesto kde môžete hneď pokračovať v písaní.

Každej šablóne je možné priradiť makro a nastaviť možnosti automatického dokončovania.

Samozrejme, môže byť problém zapamätať si také množstvo šablón, preto ak ponecháte kurzor na prázdnom znaku (medzere, nie na identifikátore) a stlačíte skratku Ctrl+J, IDE Vám ponúkne zoznam dostupných šablón. Pomocou kurzorových kláves alebo napísania niekoľkých počiatočných znakov vyberte príslušný identifikátor a stlačením klávesy Enter vytvorte zvolenú šablónu. Stlačenie klávesy Esc zatvorí zoznam.

Použitie nástroja Šablóny kódu si môžte predstaviť na príklade, v ktorom vytvoríte definíciu triedy. Na túto operáciu je pripravená šablóna s identifikátorom classf, preto na začiatok riadku napíšte tento identifikátor, kurzor ponechajte vpravo za f a stlačte Ctrl+J. Identifikátor classf bude nahradený pripravenou šablónou kódu:

Kód zo šablóny

T = class(T)

    private

    public
        constructor Create;
        destructor Destroy; override;
    end;

a kurzor bude umiestnený za T, aby ste mohli priamo zadať meno triedy, ale už nemuseli písať dohodnuté T na začiatku mena.

Publikovať projekt

Nástroj (Publish Project) pomáha s publikovaním zdrojového kódu projektu je dostupný z menu Projekt ‣ Publikovať projekt. Načo je takýto nástroj potrebný? Predstavte si situáciu, keď chcete niekomu (napríklad do svn) poslať len zdrojové kódy projektu a nastavenia prekladača pre svoj kód. Lenže bežný adresár projektu obsahuje množstvo informácií a súborov, z ktorých väčšinu publikovať netreba:

• súbor .lpi obsahuje informácie o relácii (napr. pozíciu záložiek zatvorených jednotiek),
• súbory .ppu, .o, a .exe tiež nie sú potrebné k zdrojovému kódu,
• a podobne …

Práve príkaz Publikuj projekt vyexportuje adresár do nového umiestnenia, v ktorom vytvorí súbor .lpi len so základnými informáciami a prekopíruje zdrojové kódy, so všetkých podadresárov. V ponúknutom dialógu môžete nastaviť filter pre zahrnutie/vynechanie súborov, či pre kompresiu výstupu do jediného archívu.