Difference between revisions of "Lazarus IDE Tools/fi"

From Lazarus wiki
Jump to navigationJump to search
m (Fixed syntax highlighting)
 
(14 intermediate revisions by 2 users not shown)
Line 1: Line 1:
 
{{Lazarus IDE Tools}}
 
{{Lazarus IDE Tools}}
  
==Yleistä==
+
'''[[Lazarus Faq|Lazarus]] IDE Tools''' on [[Free Pascal]]- lähdekoodin jäsentämis- ja muokkaustyökalu, jota kutsutaan "codetoolsiksi".
The IDE uses a library of pascal source parsing and editing tools, called the "codetools". These tools provide features like find declaration, code completion, extraction, moving inserting and beautifying pascal sources.
 
Nämä toiminnat säästävät paljon aikaa ja kahdenkertaiselta työltä. Nämä ovat muokattavissa ja jokaista toiminnallisuutta voi hyödyntää  myös näppäinydistelmän avulla (katso editorin asetuksista).
 
  
Koska nämä toimivat ainoastaan lähdekoodissa ja ymmärtävät myös FreePascal, Delphi ja Kylix koodia nei eivät tarvitse käännettyjä käännösyksikköjä eikä asennettua Borlandin käätäjää. Voit editoida myös Delphi ja FreePascal koodia samaan aikaa.Voit sama aikaan tehdä eriversiot Delphi ja FreePascal -kääntäjälle. Tämä mhdollistaa Delphi version teon paljon helpommin.
+
Tämä työkalu tarjoaa ominaisuuksia, kuten ''Find Declaration'', ''Code Completion'', ''Extraction'', ''Moving Inserting'' ja ''Beautifying Pascal'' lähdekoodia.  
 +
Nämä toiminnot voivat säästää paljon aikaa ja päällekkäistä työtä. Ne ovat muokattavissa ja jokainen ominaisuus on käytettävissä pikavalintojen kautta (katso editoriasetukset).
  
==Yhteenveto kehitysympäristön näppäinyhdistelmistä==
+
Koska ne työskentelevät pelkästään Pascal-lähdekoodeilla ja ymmärtävät FPC-, [[Delphi]]- ja [[Kylix]]- koodeja, ne eivät tarvitse käännettyjä käännösyksiköitä tai asennettua Borland / Embarcadero-kääntäjää. Delphi- ja FPC-koodia voidaan muokata samanaikaisesti useilla Delphi- ja FPC-versioilla. Tämä tekee Delphi-koodin siirtämisen FPC / Lazarukselle paljon helpompaa.
 +
 
 +
==Yhteenvetoraportti IDEn-pikanäppäimestä==
 
{|
 
{|
 
|-
 
|-
| Declaration Jumping || Ctrl+Click or Alt+Up (jump to declaration of type or variable)
+
| [[Lazarus_IDE_Tools#Find Declaration|Declaration Jumping]] || {{keypress|Ctrl}}+klikkaa tai {{keypress|Alt}}+{{keypress|Up}} (Hyppää tyypin tai muuttujan määrittelyyn)
 +
|-
 +
| [[Lazarus_IDE_Tools/fi#Siirtyminen esittelyn ja toteuksen välillä|Siirtyminen esittelyn ja toteuksen välillä]] || {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}} (vaihtaa määritelmäosion ja toteutusosion välillä)
 +
|-
 +
| [[Lazarus_IDE_Tools#Code Templates|Code Templates]] || {{keypress|Ctrl}}+{{keypress|J}}
 +
|-
 +
| [[Lazarus_IDE_Tools#Syncro Edit|Syncro Edit]] || {{keypress|Ctrl}}+{{keypress|J}} (while text is selected)
 
|-
 
|-
| Method Jumping || Ctrl+Shift+Up (toggle between definition and body)
+
| [[Lazarus_IDE_Tools#Code Completion|Code Completion]] (Class Completion) || {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}},  {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|X}} for creating class fields instead of local variables
 
|-
 
|-
| Code Templates || Ctrl+J
+
| [[Lazarus_IDE_Tools#Identifier Completion|Identifier Completion]] || {{keypress|Ctrl}}+{{keypress|space}}
 
|-
 
|-
| Code Completion (Class Completion)   || Ctrl+Shift+C
+
| [[Lazarus_IDE_Tools#Word Completion|Word Completion]] || {{keypress|Ctrl}}+{{keypress|W}}
 
|-
 
|-
| Identifier Completion || Ctrl+Space
+
| [[Lazarus_IDE_Tools/fi#Parametrivihjeet|Parametrivihjeet]] || {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|space}}
 
|-
 
|-
| Word Completion || Ctrl+W
+
| [[Lazarus_IDE_Tools/fi#Etsi kirjain kerrallaan|Etsi kirjain kerrallaan]] || {{keypress|Ctrl}}+{{keypress|E}}
 
|-
 
|-
| Parameter Hints || Ctrl+Shift+Space
+
| [[Lazarus_IDE_Tools#Rename Identifier|Rename Identifier]] || {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|E}}
 
|}
 
|}
  
 
==Siirtyminen esittelyn ja toteuksen välillä==
 
==Siirtyminen esittelyn ja toteuksen välillä==
Aliohjelmien toteuksen (begin ... end) ja niiden esittelyjen välillä voi siirtyä painamallaAliohjelmien toteuksen (begin ... end) ja niiden esittelyjen välillä voi siirtyä painamalla Ctrl+Shift+nuoli ylöspäin näppäimiä yhtäaikaa.
+
 
 +
Jos halutaan siirtyä aliohjelman rungon (begin..end) ja aliohjelman (procedure Name;) esittelyn välillä käytä näppäinyhdistelmää {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}}.
  
 
Esimerkiksi:
 
Esimerkiksi:
interface
+
<syntaxhighlight lang=pascal>interface
 
   
 
   
procedure DoSomething; // procedure definition
+
procedure DoSomething; // Aliohjelman esittely
 
    
 
    
implementation
+
implementation
 
    
 
    
procedure DoSomething; // procedure body
+
procedure DoSomething; // Aliohjelman määrittely
begin
+
begin
end;
+
end;</syntaxhighlight>
Jos kursori on aliohjelman runko-osassa ja painat Ctrl+Shift+nuoli ylöspäin näppäimiä, kursori hyppää kyseisen aliohjelman esittelyyn. Painamalla uudestaan Ctrl+Shift+nuoli ylöspäin näppäimiä siirrytään takaisin aliohjelman toteuksen runko-osan alkuun eli heti begin sanan jälkeiseen kohtaan.
 
  
Tämä toimii samanlailla myös luokan metodin esittelyn ja toteutuksen välillä.
+
Jos kursori on aliohjelman toteutusosiossa ja painetaan {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}}
 +
niin kursori siirtyy aliohjelman esittelyyn. Painamalla {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|Up}}
 +
uudelleen niin tullan takaisin määrittelyyn heti 'begin' sanan jälkeiseen kohtaan.  
  
Vihje: Siirtyminen tapahtuu siihen aliohjelmaan jossa on samat parametrit. Jos ei löydy täysin samaa niin siirtyminen tapahtuu sopivampaan eli siihen jossa on vähiten eroja (Tälläistä toimintaa ei välttämättä löydy esim. Delphistä).
+
Tämä toimii samanlailla myös luokan (class) metodin esittelyn ja toteutuksen välillä.
 +
 
 +
Vihje: Siirtyminen tapahtuu siihen aliohjelmaan jossa on samat parametrit. Jos ei löydy täysin samaa niin siirtyminen tapahtuu sopivampaan eli siihen jossa on vähiten eroja (Tälläistä toimintaa ei välttämättä löydy esim. Delphistä).  
  
 
Esimerkki aliohjelmasta joiden esittelyssä ja toteutuksessa on erilaiset parametrityypit:
 
Esimerkki aliohjelmasta joiden esittelyssä ja toteutuksessa on erilaiset parametrityypit:
 
+
<syntaxhighlight lang=pascal>interface
interface
 
 
   
 
   
procedure DoSomething(p: char); // procedure definition
+
procedure DoSomething(p: char); // procedure definition
 
   
 
   
implementation
+
implementation
 
    
 
    
procedure DoSomething(p: string); // procedure body
+
procedure DoSomething(p: string); // procedure body
begin
+
begin
end;
+
end;</syntaxhighlight>
Siirtyminen toteuksen ja niiden esittelyjen välillä avainsanana on merkit. Tätä voi käyttää kun haluaa uudelleen nimetä metodin ja/tai muuttaa parametrejä.
+
 
 +
Siirtyminen toteuksen ja niiden esittelyjen välillä 'string' avainsana. Tätä voi käyttää kun haluaa uudelleen nimetä metodin ja/tai muuttaa parametrejä.
  
 
Esimerkiksi: uudelleen nimetään 'DoSomething' -> 'MakeIt':ksi:  
 
Esimerkiksi: uudelleen nimetään 'DoSomething' -> 'MakeIt':ksi:  
interface
 
 
   
 
   
procedure MakeIt; // procedure definition
+
<syntaxhighlight lang=pascal>interface
 
   
 
   
implementation
+
procedure MakeIt; // procedure definition
 
   
 
   
  procedure DoSomething; // procedure body
+
implementation
begin
+
   
end;
+
procedure DoSomething; // procedure body
Kun siirrytään 'MakeIt':n esittelystä toteukseen (joka on siis vielä väärän niminen). Lazarus etsii sopivaa toteustusta, jota ei löydy, sen jälkeen muita sopivia. Jos nimeä on muutettu ainoastaan yhdestä aliohjelmasta jolloin on yksi toteutus josta ei löydy määrittelyä niin tällöin siirrytään siihen. Näin voidaan yksinkertaisesti vaihtaa nimeä tai parametrejä.
+
begin
 +
end;</syntaxhighlight>
 +
 
 +
Kun siirrytään 'MakeIt':n esittelystä toteukseen (joka on siis vielä väärän niminen). Lazarus etsii sopivaa toteustusta, jota ei löydy, sen jälkeen muita sopivia. Jos nimeä on muutettu ainoastaan yhdestä aliohjelmasta jolloin on yksi toteutus josta ei löydy määrittelyä niin tällöin siirrytään siihen. Näin voidaan yksinkertaisesti vaihtaa nimeä tai parametrejä.  
  
 
==Include Files==
 
==Include Files==
Include files are files inserted into sources with the {$I filename} or {$INCLUDE filename} compiler directive. Lazarus and FPC uses a lot of these things to reduce redundancy and avoid unreadable {$IFDEF} constructs to support different platforms.
+
Include files ovat tiedostoja, jotka on lisätty lähdekoodiin  {$I filename} tai {$INCLUDE filename} kääntäjän ohjeella.  
 +
Lazarus ja FPC käyttävät usein include tiedostoja vähentämään redundanssia ja välttävät lukemattomia {$ IFDEF} -rakenteita, joita tarvitaan eri alustojen tukemiseen.
  
Contrary to Delphi, the Lazarus IDE has full support for include files. You can for example jump from the method in the .pas file to the method body in the include file. All codetools like code completion consider include files as special bounds.
+
Toisin kuin Delphi, Lazarus IDE: llä on täysi tuki myös include-tiedostoihin. Voit esimerkiksi hypätä .pas-tiedoston aliohjelmasta sisällytetyn tiedoston toteutukseen. Kaikki codetools osiot, kuten koodin täydentäminen, käsittelevät include tiedostoja erityistapauksina.
+
 
For instance: When code completion adds a new method body behind another method body, it keeps them both in the same file. This way you can put whole class implementations in include files, like the LCL does for nearly all controls.
+
Esimerkiksi: Kun koodin täydentäminen lisää uuden metodin toteuksen rungon toisen metodin rungon taakse, se pitää ne molemmissa samassa tiedostossa. Tällä tavalla voit laittaa kokoluokan toteutuksia include-tiedostoihin, kuten LCL tekee lähes kaikille kontrolleille.
  
But there is a newbie trap:
+
Mutta aloittelijoille löytyy ansa: Jos avataan include tiedosto ensimmäisen kerran ja yritetään siirtyä esittelyn ja toteuksen välillä tai löytää määrittely niin saadaan virhe. IDE ei vielä tiedä, mihin yksikköön sisällytettävä tiedosto kuuluu. Sillä on ensin avattava käännösyksikkö.
If you open an include file for the first time and try method jumping or find declaration you will get an error. The IDE does not know to which unit the include file belongs. You must open the unit first.
 
  
As soon as the IDE parses the unit, it will parse the include directives there and the IDE will remember this relationship. It saves this information on exit and on project save to ~/.lazarus/includelinks.xml. The next time you open this include file and jump or do a find declaration, the IDE will internally open the unit and the jump will work.
+
Niin pian kuin IDE analysoi käännösyksikön, se analysoi include kääntäjänohjeet siellä ja IDE muistaa tämän suhteen. Se tallentaa nämä tiedot poistumiseen ja projektin tallentamiseen ~ / .lazarus / includelinks.xml. Kun seuraavan kerran avataan tämän include tiedosto ja siirrytään toteuksen ja niiden esittelyjen välillä, IDE avaa laitteen sisäisesti ja siirtyminen toimii. Voidaan myös viitata IDE: een asettamalla
 +
<syntaxhighlight lang=pascal>{%mainunit yourunit.pas}</syntaxhighlight>
 +
tiedoston yourinclude.inc alkuun.
  
This mechanism has of course limits. Some include files are included twice or more. For example: lcl/include/winapih.inc.
+
Tällä mekanismilla on rajoituksia. Joihinkin tiedostoihin sisältyy kaksi tai useampia include tiedostoja. Esimerkiksi: lcl/include/winapih.inc.
  
Jumping from the procedure/method definitions in this include file to the bodies depends on your last actions. If you worked on lcl/lclintf.pp the IDE will jump to winapi.inc. If you worked on lcl/interfacebase.pp, then it will jump to lcl/include/interfacebase.inc (or one of the other include files). If you are working on both, then you can get confused. ;)
+
Se miten siirrytään aliohjelman/metodin määrityksistä niiden include tiedostoihin riippuu viimeisestä toiminnosta. Jos ollaan työskennelty lcl / lclintf.pp: llä, IDE siirtyy winapi.inc: hen. Jos ollaan työskennelty lcl / interfacebase.pp: llä niin se siirtyy lcl / include / interfacebase.inc (tai johonkin muuhun include tiedostoon). Jos työskennellään molemmilla, niin se saadaan sekaisin. ;)
  
 
==Code Templates==
 
==Code Templates==
Code Templates converts an identifier into a text or code fragment.
+
Code Templates muuntaa tietyn tunnisteen tekstiksi tai koodin palaseksi.
  
Code Templates default short cut is Ctrl+J. You can type an identifier, press Ctrl+J and the identifier is replaced by the text defined for the identifier. Code Templates can be defined in Environment -> Editor Options -> CodeTools.
+
Code Templates oletuspikanäppäin on {{keypress|Ctrl}}+{{keypress|J}}. Kun kirjoittaa sopivan tunnisteen, painaa {{keypress|Ctrl}}+{{keypress|J}} niin
 +
tunniste korvataan tunnisteella määritellyllä tekstillä. Code Templates voidaan määritellä Työkalut -> Optiot -> CodeTools.
  
Example:
+
Esim:
Write the identifier 'classf', leave the cursor right behind the 'f' and press Ctrl+J. The 'classf' will be replaced by
+
Kirjoita teksti 'classf', jätä kursori kirjaimen 'f' oikealle puolen ja paina {{keypress|Ctrl}}+{{keypress|J}}. Teksti 'classf' korvautuu riveillä
T = class(T)
+
<syntaxhighlight lang=pascal>T = class(T)
private
+
private
 
   
 
   
public
+
public
  constructor Create;
+
  constructor Create;
  destructor Destroy; override;
+
  destructor Destroy; override;
end;
+
end;</syntaxhighlight>
and the cursor is behind the 'T'.
+
 
You can get the list of templates by positioning the cursor on space (not on an identifier) and pressing Ctrl+J. The list of code templates will pop up. Use the cursor keys or type some chars to choose one. Return creates the selected template and Escape closes the pop up.
+
ja kursori on kirjaimen 'T' takana. Luettelo kaikista Code Template vaihtoehdoista saadaan sijoittamalla kohdistin välilyönnin perään (ei tunnisteeseen) ja painamalla {{keypress|Ctrl}}+{{keypress|J}}.  
 +
Luettelo kaikista Code Template vaihtoehdoista  ponnahtaa esiin. Käytä kursorinäppäimiä tai kirjoita joitain merkkejä valitaksesi. Painamalla {{keypress|Return}} luodaan valittu malli ja {{keypress|Esc}} sulkee ponnahdusikkunan.
 +
 
 +
Suurin ajan säästäjä on Code Template 'b'+{{keypress|Ctrl}}+{{keypress|J}} varatuille sanoille begin..end.
 +
 
 +
==Parametrivihjeet==
 +
 
 +
Parametrivihjeet näyttävät vihjeruutu, jossa on parametriluettelot kutsun parametrilistalle.
 +
 
 +
Esimerkiksi
  
==Parameter Hints==
+
<syntaxhighlight lang=pascal>  Canvas.FillRect(|);</syntaxhighlight>
 
Parameter Hints shows a hint box with the parameter declarations for the current parameter list.
 
  
For example
+
Aseta kursori sulkujen väliin ja paina {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|space}}. Näyttöön tulee vihjeruutu, joka näyttää FillRectin parametrit.
  
Canvas.FillRect(|);
+
[[Image:Parameterhints1.png]]
  
Place the cursor in the brackets and press Ctrl+Shift+Space. A hint box will show up showing the parameters of FillRect.
+
Versiosta 0.9.31 asti on ollut jokaisen Parametrivihjeen oikealla puolella painike puuttuvien parametrien lisäämiseksi. Tämä kopioi parametrin nimet valitusta vihjeestä kohdistimen kohtaan.  
  
 +
[[Image:Parameterhints2.png]]
 +
 +
 +
Vihje: Käytä [[#Variable Declaration Completion|Variable Declaration Completion]] määrittääksesi muuttujia.
 +
 +
{{Note| Pikanäppäimen nimi on "Show code context".}}
 +
 +
==Etsi kirjain kerrallaan==
 +
 +
Etsi kirjain kerrallaan muuttaa lähdekoodieditorin tilarivin. Kirjoita joitain kirjaimia ja editori etsii ja korostaa välittömästi kaikki niiden esiintymät tekstissä. Pikanäppäin on {{keypress|Ctrl}}+{{keypress|e}}.
 +
*Esimerkiksi painamalla {{keypress|e}}. Se etsii ja korostaa kaikki 'e':n esiintymät.
 +
*Sitten painetaan {{keypress|t}}. Se  etsii ja korostaa kaikki esiintymät "et" ja niin edelleen.
 +
*Seuraavaan esiintymään voidaan siirtyä painamalla {{keypress|F3}} (tai {{keypress|Ctrl}}+{{keypress|e}} kun ollaan haussa) ja edelliseen painamalla {{keypress|Shift}}+{{keypress|F3}}.
 +
*Backspace eli {{keypress|<-}} poistaa edellisen merkin
 +
*{{keypress|Return}} lopettaa haun lisäämättä uutta riviä editoriin.
 +
*Viimeistä hakua voidaan jatkaa painamalla {{keypress|Ctrl}}+{{keypress|e}} -näppäintä toisen kerran välittömästi sen jälkeen, kun olet käynnistänyt etsinnän painamalla {{keypress|Ctrl}}+{{keypress|e}}. Toisin sanoen hakutermi on vielä tyhjä.
 +
*Liittäminen {{keypress|Ctrl}}+{{keypress|V}} liittää tekstin leikepöydältä nykyiseen hakutekstiin (Ollut Lazarus versiosta 0.9.27 lähtien).
 +
 +
===Vihje: Nopea haku tunnistimella käyttäen etsi kirjain kerrallaan toimintoa===
 +
 +
*Aseta tekstikohdistin tunnisteeseen (älä valitse mitään)
 +
*Paina {{keypress|Ctrl}}+{{keypress|C}}. Lähdekoodieditori valitsee tunnuksen ja kopioi sen leikepöydälle
 +
*Paina {{keypress|Ctrl}}+{{keypress|E}} aloittaaksesi etsi kirjain kerrallaan toiminnon.
 +
*Paina {{keypress|Ctrl}}+{{keypress|V}} joka liittää tekstin leikepöydältä nykyiseen hakutekstiin.
 +
*Käyttämällä {{keypress|F3}} ja {{keypress|Shift}}+{{keypress|F3}} siirtyäksesi nopeasti seuraavaan / edelliseen.
 +
*Lopeta haku painamalla mitä tahansa näppäintä (esimerkiksi kohdistinta vasemmalle tai oikealle).
 +
 +
 +
==Syncro Edit==
 +
 +
Syncro Edit:llä voidaan muokata samanaikaisesti kaikkia sanojen esiintymiä (synkronoitu). Yksinkertaisesti voidaan muokata sanaa yhdessä paikassa ja kun sitä muutetaan niin kaikki muut sanan tapahtumat päivittyvät.
 +
 +
Syncro Edit toimii kaikkien valitun alueen sanoilla:
 +
* Valitse tekstilohko
 +
* Paina {{keypress|Ctrl}}+{{keypress|J}} tai klikkaa kuvaketta reunuksessa. (Tämä toimii vain, jos valittu sana esiintyy useamman kerran).
 +
* Valitse muokattava sana {{keypress|tab}} näppäimellä  (jos valittu sana esiintyy useamman kerran)
 +
* Muokkaa sanaa
 +
* Lopeta painamalla {{keypress|Esc}} näppäimellä
 +
 +
Katso animoitu esimerkki [[New_IDE_features_since#Syncron-Edit|tästä]]
 +
 +
{{Note| {{keypress|Ctrl}}+{{keypress|J}} käytetään myös template edit:ssä. Se vaihtaa merkitystään, jos valitset jonkin tekstin. }}
 +
 +
==Etsi sanan seuraava esiintymiskohta/ Etsi sanan edellinen esiintymiskohta==
 +
 +
Nämä kaksi funktiota löytyvät lähdekoodieditorin ponnahdusvalikosta
 +
 +
*Lähdekoodieditori / ponnahdusvalikko / Etsi / Etsi sanan seuraava esiintymiskohta
 +
*Lähdekoodieditori / ponnahdusvalikko / Etsi / Etsi sanan edellinen esiintymiskohta
 +
 +
Näihin voidaan määrittää pikanäppäimet editorin asetuksissa.
  
 
==Code Completion==
 
==Code Completion==
Code Completion can be found in the IDE menu Edit -> Complete Code and has as standard short cut Ctrl+Shift+C.
+
Code Completion löytyy IDE-valikosta Edit -> Complete Code ja sen pikanäppäin on {{keypress|Ctrl|Shift|C}}.
  
For Delphians:
+
Delphi-käyttäjille:
Delphi calls "code completion" the function showing the list of identifiers at the current source position (Ctrl+Space). Under Lazarus this is called "Identifier completion".
+
Delphi nimeää "code completion" funktioksi, joka näyttää tunnistetietojen luettelon kursorin kohdalla lähdekoodissa ( {{keypress|Ctrl|Space}} ).  
 +
Lazaruksessa se on "Identifier completion".
  
Code Completion combines several powerful functions. Examples:
+
Code Completion yhdistää useita tehokkaita toimintoja. esimerkkejä:
* Class Completion: completes properties, adds method bodies, add private variables and private access methods
+
* [[#Class Completion|Class Completion]]: täydentää ominaisuuksia(property), lisää / päivittää metodien runkoja, lisää yksityisiä muuttujia ja yksityisiä käyttömetodeja
* Forward Procedure Completion: adds procedure bodies
+
* [[#Forward Procedure Completion|Forward Procedure Completion]]: Lisää aliohjelmien runkoja
* Event Assignment Completion: completes event assignments and adds method definition and body
+
* [[#Event Assignment Completion|Event Assignment Completion]]: Tapahtumien tekeminen ja lisää metodit määrittelyt ja niiden rungot
* Variable Declaration Completion: adds local variable definitions
+
* [[#Variable Declaration Completion|Variable Declaration Completion]]: lisää paikalliset muuttujan määrittelyt
* Reversed class completion: adds method declarations for method bodies
+
* [[#Procedure Call Completion|Procedure Call Completion]]: Lisää uusia aliohjelmia
 +
* [[#Reversed Procedure Completion|Reversed procedure completion]]: Lisää aliohjelman määrittelyn
 +
* [[#Reversed Class Completion|Reversed Class Completion]]: Lisää metodien määrittelyn
  
Which function is used, depends on the cursor position in the editor.  
+
Mikä toiminto on käytössä, riippuu kohdistimen sijainnista editorissa ja sitä selitetään alla.  
  
Code Completion can be found in the IDE menu Edit -> Complete Code and has as standard short cut Ctrl+Shift+C.
+
Code Completion löytyy IDE-valikosta  Edit -> Complete Code ja sen pikanäppäin on {{keypress|Ctrl|Shift|C}}.
  
 
===Class Completion===
 
===Class Completion===
  
The most powerful code completion feature is "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.  
+
Tehokkain koodin täydentäjä ominaisuus on "Class Completion". Kun kirjoitetaan luokkaa (class) johon lisätään metodeja ja ominaisuuksia niin Code Completion lisää metodien toteutuksen rungot, ominaisuuksien käyttörutiinit / muuttujat ja yksityiset muuttujat.
  
For example: Create a class (see Code Templates to save you some type work):  
+
Esimerkiksi: Luo luokka eli class (Katso Code Templates jonka avulla voidaan säästää kirjoittamistyötä):  
  
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 }
+
Aseta kohdistin johonkin kohtaan luokkaan ja paina {{keypress|Ctrl|Shift|C}}. Tämä luo metodien puuttuvat rungot ja siirtää kohdistimen ensimmäiselle luodulle metodin rungolle, joten voidaan aloittaa luokan koodin kirjoittaminen:
 +
 
 +
<syntaxhighlight lang=pascal>{ TExample }
 
   
 
   
constructor TExample.Create;
+
constructor TExample.Create;
begin
+
begin
  |
+
  |
end;
+
end;
 
   
 
   
destructor TExample.Destroy;
+
destructor TExample.Destroy;
begin
+
begin
  inherited Destroy;
+
  inherited Destroy;
end;
+
end;</syntaxhighlight>
Note: The '|' is the cursor and is not added.  
+
 
 +
{{Note|Merkki '&#124;' on kohdistin eikä sitä lisätä.}}
 +
 
 +
Vihje: On mahdollista siirtyä metodin ja sen rungon välillä {{keypress|Ctrl|Shift|Up}}.  
  
Hint: You can jump between a method and its body with Ctrl+Shift+Up.  
+
Nähdään, että IDE lisäsi myös 'inherited Destroy' kutsun. Tämä tehdään, jos luokan määritelmässä on '[[Override|override]]' avainsana.
  
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.
+
Nyt lisätään metodi DoSomething:
  
Now add a method DoSomething:  
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
 +
public
 +
  constructor Create;
 +
  procedure DoSomething(i: integer);
 +
  destructor Destroy; override;
 +
end;</syntaxhighlight>
  
TExample = class(TObject)
+
Sitten paina {{keypress|Ctrl|Shift|C}} ja IDE lisää
public
 
  constructor Create;
 
  procedure DoSomething(i: integer);
 
  destructor Destroy; override;
 
end;
 
Then press Ctrl+Shift+C and the IDE will add
 
  
procedure TExample.DoSomething(i: integer);
+
<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.
 
  
'''Complete Properties'''<br>
+
Nähdään että uusi metodin runko on sijoitettu Create ja Destroy -toimintojen väliin aivan kuten luokkamäärittelyssä. Tällä tavoin rungot pitävät saman loogisen järjestyksen kuin on määritetty. Lisäyskäytäntö voidaan määrittää Työkalut> Asetukset -> Codetools -> Code Creation.
Add a property AnInteger:
 
TExample = class(TObject)
 
public
 
  constructor Create;
 
  procedure DoSomething(i: integer);
 
  destructor Destroy; override;
 
  property AnInteger: Integer;
 
end;
 
Press Ctrl+Shift+C and you will get:
 
procedure TExample.SetAnInteger(const AValue: integer);
 
begin
 
  |if FAnInteger=AValue then exit;
 
  FAnInteger:=AValue;
 
end;
 
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:
 
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;
 
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.
 
  
Creating a read only property:
+
'''Täydennä ominaisuuksilla'''<br>
property PropName: PropType read;
+
Lisää ominaisuus AnInteger:
Will be expanded to
+
<syntaxhighlight lang=pascal>TExample = class(TObject)
property PropName: PropType read FPropName;
+
public
Creating a write only property:
+
   constructor Create;
   property PropName: PropType write;
+
  procedure DoSomething(i: integer);
Will be expanded to
+
  destructor Destroy; override;
property PropName: PropType write SetPropName;
+
  property AnInteger: Integer;
Creating a read only property with a Read method:
+
end;</syntaxhighlight>
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:
+
Paina {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}} jolloin saadaan:
Identifier completion also recognizes incomplete properties and will suggest the default names. For example:
+
<syntaxhighlight lang=pascal>procedure TExample.SetAnInteger(const AValue: integer);
property PropName: PropType read |;
+
begin
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'.
+
  |if FAnInteger=AValue then exit;
 +
  FAnInteger:=AValue;
 +
end;</syntaxhighlight>
 +
 
 +
code completion on lisännyt kirjoitusoikeuden muokkaajan ja lisännyt yleistä koodia.
 +
Siirry luokalle painamalla {{keypress|Ctrl|Shift|Up}} nähdäksesi uuden luokan:
 +
 
 +
 
 +
<syntaxhighlight lang=pascal>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;</syntaxhighlight>
 +
 
 +
Ominaisuutta laajennettiin Read (luku) ja Write (kirjoitus)-ominaisuuden avulla. Luokka sai uuden 'private' osion johon tuli muuttuja "FAnInteger" ja metodi "SetAnInteger".
 +
Yleisen Delphi-tyylisen käytännön mukaan yksityisiin muuttujiin lisätään 'F' kirjain ja kirjoitusmetodiin  'Set'. Tätä ominaisuutta voidaan muuttaa Työkalut -> Valinnat> Codetools -> Code Creation.
 +
 
 +
 
 +
Luodaan property:n vain luku (read) :
 +
<syntaxhighlight lang=pascal>property PropName: PropType read;</syntaxhighlight>
 +
Laajennetaan
 +
<syntaxhighlight lang=pascal>property PropName: PropType read FPropName;</syntaxhighlight>
 +
Luodaan property:n vain kirjoitus (write) :
 +
<syntaxhighlight lang=pascal>property PropName: PropType write;</syntaxhighlight>
 +
Laajennetaan
 +
<syntaxhighlight lang=pascal>property PropName: PropType write SetPropName;</syntaxhighlight>
 +
 
 +
Luodaan property:n vain luku (read) ja lukumetodi:
 +
<syntaxhighlight lang=pascal>property PropName: PropType read GetPropName;</syntaxhighlight>
 +
 
 +
Säilytetään ja GetPropName-funktio lisätään:
 +
<syntaxhighlight lang=pascal>function GetpropName: PropType;</syntaxhighlight>
 +
Luodaan property jossa on stored määrite:
 +
<syntaxhighlight lang=pascal>property PropName: PropType stored;</syntaxhighlight>
 +
Laajennetaan
 +
<syntaxhighlight lang=pascal>property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;</syntaxhighlight>
 +
 
 +
Koska stored käytetään tietovirtojen lukemiseen ja kirjoittamiseen, ne myös lisätään automaattisesti.
 +
 +
Vihje: Identifier completion tunnistaa myös puutteelliset ominaisuudet ja ehdottaa oletusnimiä. Esimerkiksi:
 +
<syntaxhighlight lang=pascal>property PropName: PropType read |;</syntaxhighlight>
 +
Aseta kohdistin yksi välilyönti read-avainsanan taakse ja paina {{keypress|Ctrl}}+{{keypress|Space}}. Se antaa muuttujan "FPropName" ja aliohjelman "SetPropName".
  
 
===Forward Procedure Completion===
 
===Forward Procedure Completion===
"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.
+
"Forward Procedure Completion" on osa Code Completion ja lisää aliohjelman rungon. Sitä käytetään, kun kohdistin on aliohjelman esittelyssä.
 +
It is invoked, when the cursor is on a forward defined procedure.
  
For example:
+
Esimerkiksi: Lisätään uusi aliohjelma interface osioon:
Add a new procedure to the interface section:
+
<syntaxhighlight lang=pascal>procedure DoSomething;</syntaxhighlight>
procedure DoSomething;
+
Aseta kohdistin sille ja paina {{keypress|Ctrl|Shift|C}}. Se luo toteutusosassa (implementation):
Place the cursor on it and press Ctrl+Shift+C for code completion. It will create in the implementation section:
 
procedure DoSomething;
 
begin
 
  |
 
end;
 
Hint: You can jump between a procedure definition and its body with Ctrl+Shift+Up.
 
  
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:
+
<syntaxhighlight lang=pascal>procedure DoSomething;
   procedure Proc1;
+
begin
  procedure Proc2; // new proc
+
   |
  procedure Proc3;
+
end;</syntaxhighlight>
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.
+
Vihje: Voidaan siirtyä aliohjelman esittelyn ja sen rungon välillä painamalla{{keypress|Ctrl|Shift|Up}}.
  
Multiple procedures:
+
Uusi aliohjelman runko lisätään luokkametodien eteen. Jos rajapinnassa on jo joitain aliohjelmia, IDE yrittää säilyttää järjestyksen. Esimerkiksi:
procedure Proc1_Old; // body exists
+
<syntaxhighlight lang=pascal>procedure Proc1;
procedure Proc2_New; // body does not exists
+
procedure Proc2; // new proc
procedure Proc3_New; //  "
+
procedure Proc3;</syntaxhighlight>
procedure Proc4_New; //  "
 
procedure Proc5_Old; // body exists
 
Code Completion will add all 3 procedure bodies (Proc2_New, Proc3_New, Proc4_New).
 
  
Why calling it "Forward Procedure Completion"?
+
Jos aliohjelmien Proc1: n ja Proc3: n rungot ovat jo olemassa, niin Proc2 runko lisätään Proc1: n ja Proc3: n rungon väliin. Tämä toiminto voidaan asettaa Työkalut -> Valinnat -> Codetools -> Code Creation.
  
Because it does not only work for procedures defined in the interface, but for procedures with the "forward" modifier as well. And because the codetools treats procedures in the interface as having an implicit 'forward' modifier.
+
Useita aliohjelmia:
 +
<syntaxhighlight lang=pascal>procedure Proc1_Old; // runko on jo olemassa
 +
procedure Proc2_New; // runkoa ei ole vielä
 +
procedure Proc3_New; //  "
 +
procedure Proc4_New; //  "
 +
procedure Proc5_Old; // runko on jo olemassa</syntaxhighlight>
 +
 
 +
Code Completion lisää kaikki kolme (3) aliohjelman runkoa (Proc2_New, Proc3_New, Proc4_New).
 +
 
 +
Miksi kutsua "Forward Procedure Completion"?
 +
 
 +
Koska se ei toimi vain interface osiossa määriteltyjen aliohjelmien, vaan myös "forward" -määritteen kanssa. Ja koska codetools käsittelee interface osiossa olevia aliohjelmia niin, että niillä on implisiittinen 'forward' -määrite.
  
 
===Event Assignment Completion===
 
===Event Assignment Completion===
"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" on osa Code Completion:a. Se täydentää yhden tapahtuman := | lauseen. Sitä kutsutaan, kun kohdistin on järjestetty tapahtumalle.
 +
completes a single Event:=| statement. It is invoked, when the cursor is behind an assignment to an event.
 +
 
 +
Esimerkiksi: Kirjoita lomakkeen FormCreate-tapahtumaan rivi 'OnPaint:=':
 +
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
 +
begin
 +
  OnPaint:=|
 +
end;</syntaxhighlight>
 +
 
 +
Kursorin paikka on merkitty '|' -kirjaimella eikä kyseistä kirjainta kirjoiteta.
 +
Code completion kutsutaan painamalla {{keypress|Ctrl}}+{{keypress|Shift}}+{{keypress|C}}. Lause täydennetään
 +
<syntaxhighlight lang=pascal>OnPaint:=@Form1Paint;</syntaxhighlight>
 +
ja uusi metodi Form1Paint lisätään TForm1 luokkaan.  Tällöin luokka valmistuu ja saadaan myös:
 +
<syntaxhighlight lang=pascal>procedure TForm1.Form1Paint(Sender: TObject);
 +
begin
 +
  |
 +
end;</syntaxhighlight>
 +
Tämä toimii samalla tavoin kuin lisätään menetelmiä komponenttimuokkaimella.
 +
 
 +
 
 +
{{Note| Kursori on sijoitettava heti ':&#61;' saa arvokseen operatorin jälkeen. Jos kursori sijoitetaan osoittamaan esim. OnPaint tunnisteeseen niin koodin suorittaminen viittaa "Local Variable Completion", joka epäonnistuu, koska OnPaint on jo määritetty.}}
 +
 
 +
Vinkit:<br>
 +
*Uuden metodin oletusarvoinen näkyvyys voidaan valita Työkalut / Asetukset /  Codetools / Luokan täydennys / Default section of methods (versiosta 1.8 lähtien)
 +
*Uuden metodin nimen voi määrittää itse. Esimerkiksi:
 +
<syntaxhighlight lang=pascal>  OnPaint:=@ThePaintMethod;</syntaxhighlight>
 +
 
 +
 
 +
Versiosta 0.9.31 Lazarus täydentää aliohjelman parametreja. Esimerkiksi
  
For example:
+
<syntaxhighlight lang=pascal>procedure TForm1.FormCreate(Sender: TObject);
In a method, say the FormCreate event, add a line 'OnPaint:=':
+
var
procedure TForm1.Form1Create(Sender: TObject);
+
  List: TList;
begin
+
begin
  OnPaint:=|
+
  List:=TList.Create;
end;
+
  List.Sort(@MySortFunction|);
The '|' is the cursor and should not be typed.
+
end;</syntaxhighlight>
Then press Ctrl+Shift+C for code completion. The statement will be completed to
 
OnPaint:=@Form1Paint;
 
A new method Form1Paint will be added to the TForm1 class. Then class completion is started and you get:
 
procedure TForm1.Form1Paint(Sender: TObject);
 
begin
 
  |
 
end;
 
This works just like adding methods in the object inspector.
 
  
Note:<br>
+
Sijoita kursori 'MySortFunction' kohtaan ja paina {{keypress|Ctrl|Shift|C}} niin saadaan uusi aliohjelma:
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.
+
 
 +
<syntaxhighlight lang=pascal>function MySortFunction(Item1, Item2: Pointer): Integer;
 +
begin
 +
  |
 +
end;
 +
 
 +
procedure TForm1.FormCreate(Sender: TObject);
 +
var
 +
  List: TList;
 +
begin
 +
  List:=TList.Create;
 +
  List.Sort(@MySortFunction);
 +
end;</syntaxhighlight>
  
Hint:<br>
 
You can define the new method name by yourself. For example:
 
  OnPaint:=@ThePaintMethod;
 
  
 
===Variable Declaration Completion===
 
===Variable Declaration Completion===
"Variable Declaration 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 an assignment or a parameter.
+
"Variable Declaration Completion" on osa Code Completion:a.
 +
Se lisää paikallisen muuttujan määritelmän tunnisteelle := Term; lause. Sitä kutsutaan, kun kohdistin on osoittaa parametria tai tunnistetta.
 +
 
 +
Esimerkiksi:
 +
 
 +
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
 +
begin
 +
  i:=3;
 +
end;</syntaxhighlight>
 +
Kursorin paikka on tunnisteessa 'i' tai sen jälkeen. Painamalla {{keypress|Ctrl|Shift|C}} saadaan:
 +
<syntaxhighlight lang=pascal>procedure TForm1.Form1Create(Sender: TObject);
 +
var
 +
  i: Integer;
 +
begin
 +
  i:=3;
 +
end;</syntaxhighlight>
  
For example:
+
Toiminto ensin tarkastaa onko tunnistetta 'i' jo määritelty. Jos sitä ei ole niin lisää määrittelyn 'var i: integer;'.
procedure TForm1.Form1Create(Sender: TObject);
+
Tunnisteen tyyppi arvatellaan  ": =" operaattorista. Kokonaisluvun, kuten 3 oletustyyppinä on Integer.
begin
 
  i:=3;
 
end;
 
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);
 
var
 
  i: Integer;
 
begin
 
  i:=3;
 
end;
 
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.
 
  
Another example:
+
Toinen esimerkki:
type
+
<syntaxhighlight lang=pascal>type
 
   TWhere = (Behind, Middle, InFront);
 
   TWhere = (Behind, Middle, InFront);
 
   
 
   
Line 312: Line 437:
 
   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);
+
Kursorin paikka on 'Where'-sanan kohdalla ja painetaan {{keypress|Ctrl|Shift|C}} niin saadaan:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.Form1Create(Sender: TObject);
 
   var
 
   var
 
     a: array[TWhere] of char;
 
     a: array[TWhere] of char;
Line 320: Line 446:
 
   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>
  
Since 0.9.11 Lazarus also completes parameters. For example
+
Lazarus on versiosta 0.9.11 lähtien myös täydentänyt parametreja. Esimerkiksi
  procedure TForm1.FormPaint(Sender: TObject);
+
<syntaxhighlight lang=pascal>  procedure TForm1.FormPaint(Sender: TObject);
 
   begin
 
   begin
 
     with Canvas do begin
 
     with Canvas do begin
 
       Line(x1,y1,x2,y2);
 
       Line(x1,y1,x2,y2);
 
     end;
 
     end;
   end;
+
   end;</syntaxhighlight>
Place the cursor on 'x1' and press Ctrl+Shift+C for code completion. You get:
+
 
  procedure TForm1.FormPaint(Sender: TObject);
+
Sijoita kursori 'x1' ja paina {{keypress|Ctrl|Shift|C}} niin saadaan:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.FormPaint(Sender: TObject);
 
   var
 
   var
 
     x1: integer;
 
     x1: integer;
Line 337: Line 464:
 
       Line(x1,y1,x2,y2);
 
       Line(x1,y1,x2,y2);
 
     end;
 
     end;
   end;
+
   end;</syntaxhighlight>
 +
 
 +
Lazarus on versiosta 0.9.31 täydentänyt osoittimen parametrit. Esimerkiksi
 +
 
 +
<syntaxhighlight lang=pascal>  procedure TForm1.FormCreate(Sender: TObject);
 +
  begin
 +
    CreateIconIndirect(@IconInfo);
 +
  end;</syntaxhighlight>
 +
 
 +
Sijoita kursori 'IconInfo':n ja paina {{keypress|Ctrl|Shift|C}} niin saadaan:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.FormCreate(Sender: TObject);
 +
  var
 +
    IconInfo: TIconInfo;
 +
  begin
 +
    CreateIconIndirect(@IconInfo);
 +
  end;</syntaxhighlight>
 +
 
 +
Kaikissa edellä olevissa esimerkeissä voit käyttää {{keypress|Ctrl|Shift|X}}-näppäintä näyttääksesi koodin luomisen valintaikkunan, jossa voit asettaa lisää vaihtoehtoja.
 +
 
 +
===Procedure Call Completion===
 +
 
 +
Code completion voi luoda uuden aliohjelman sen kutsusta.
 +
 
 +
Oletataan että kirjoitettiin vain lause "DoSomething(Width);"
 +
<syntaxhighlight lang=pascal>procedure SomeProcedure;
 +
var
 +
  Width: integer;
 +
begin
 +
  Width:=3;
 +
  DoSomething(Width);
 +
end;</syntaxhighlight>
 +
 
 +
Sijoita kursori tekstiin "DoSomething" ja paina {{keypress|Ctrl|Shift|C}} niin saadaan:
 +
 
 +
<syntaxhighlight lang=pascal>procedure DoSomething(aWidth: LongInt);
 +
begin
 +
 
 +
end;
 +
 
 +
procedure SomeProcedure;
 +
var
 +
  Width: integer;
 +
begin
 +
  Width:=3;
 +
  DoSomething(Width);
 +
end;</syntaxhighlight>
 +
 
 +
Se ei vielä luo funktioita tai metodeja.
  
 
===Reversed Class Completion===
 
===Reversed Class Completion===
  
"Reversed Class Completion" is part of the '''Code Completion''' and adds a private method declaration for the current method body. It is invoked, when the cursor is in a method body, not yet defined in the class.
+
"Reversed Class Completion" on osa '''Code Completion''' toimintaa.
 +
Se lisää yksityisen metodin ilmoituksen nykyiselle metodiryhmälle. Sitä kutsutaan, kun kursori on metodin rungossa, jota ei ole vielä määritelty luokassa. Tämä ominaisuus on saatavana Lazarus 0.9.21 versiosta alkaen.
 +
 
 +
Esimerkiksi:
 +
<syntaxhighlight lang=pascal>  procedure TForm1.DoSomething(Sender: TObject);
 +
  begin
 +
  end;</syntaxhighlight>
 +
 
 +
DoSomething-metodia ei ole vielä määritelty TForm1: ssä. Paina {{keypress|Ctrl|Shift|C}} ja IDE lisää aliohjelman "procedure DoSomething (Sender: TObject);" TForm1: n yksityisiin metodeihin.
 +
 
 +
Delphi käyttäjille:
 +
Class completion  toimii Lazaruksen mukaan aina yhdellä tavalla: Luokan käyttöliittymästä toteutukseen tai taaksepäin / päinvastoin luokan toteutuksesta käyttöliittymään. Delphi kutsuu aina molempiin suuntiin. Delphi-tapa on haitta, että jos on typo se luo helposti uuden tynkä metodin ilman huomaamatta.
 +
 
 +
===Kommentit ja Code Completion===
 +
Code completion yrittää pitää kommentteja, johon ne kuuluvat.
 +
Esimerkiksi:
 +
 
 +
<syntaxhighlight lang=pascal>  FList: TList; // list of TComponent
 +
  FInt: integer;</syntaxhighlight>
 +
Kun lisätään uusi muuttuja FListin ja FInt: n välillä, kommentti pidetään FList-rivillä. Sama pätee myös
 +
<syntaxhighlight lang=pascal>  FList: TList; { list of TComponent
 +
      Tämä on usean rivin kommentti, alkaen
 +
      FList-riviltä, joten codetools olettaa sen kuuluvan 
 +
      FLIst-riviin ja ei riko tätä 
 +
      suhdetta. Koodi lisätään kommentin taakse.  }
 +
  FInt: integer;</syntaxhighlight>
 +
Jos kommentti alkaa seuraavalla rivillä, sitä käsitellään kuin se kuuluu alla olevaan koodiin. Esimerkiksi:
 +
<syntaxhighlight lang=pascal>  FList: TList; // list of TComponent
 +
      { Tämä kommentti kuuluu alla olevaan lauseeseen. 
 +
        Uusi koodi lisätään tämän kommentin yläpuolelle ja 
 +
        FList-rivin kommentin taakse.  }
 +
  FInt: integer;</syntaxhighlight>
 +
 
 +
===Metodin päivitys===
 +
 
 +
Normaalisti luokan täydennys lisää kaikki puuttuvat metodin rungot (Ollut versiosta 0.9.27 lähtien). Jos täsmälleen yksi metodi eroaa luokan ja rungon välillä, niin metodin runko päivitetään. Esimerkiksi: On metodi DoSomething ''DoSomething''.
 +
<syntaxhighlight lang=pascal>  public
 +
    procedure DoSomething;
 +
  end;
  
This feature is available since Lazarus 0.9.21.
+
procedure TForm.DoSomething;
 +
begin
 +
end;</syntaxhighlight>
  
For example:
+
Nyt lisätään parameteri:
  
  procedure TForm1.DoSomething(Sender: TObject);
+
<syntaxhighlight lang=pascal> public
begin
+
    procedure DoSomething(i: integer);
end;
+
  end;</syntaxhighlight>
  
The method DoSomething is not yet declared in TForm1. Press Ctrl+Shift+C and the IDE will add "procedure DoSomething(Sender: TObject);" to the private methods of TForm1.
+
Code Completion kutsuminen ({{keypress|Ctrl|Shift|C}}) päivittää metodin rungon ja uusi parametri kopioidaan:
  
===Comments and Code Completion===
+
<syntaxhighlight lang=pascal>procedure TForm.DoSomething(i: integer);
Code completion tries to keep comments where they belong.
+
begin
For example:
+
end;</syntaxhighlight>
  FList: TList; // list of TComponent
 
  FInt: integer;
 
When inserting a new variable between FList and FInt, the comment is kept in the FList line. Same is true for
 
  FList: TList; { list of TComponent
 
    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, then it will be treated as if it belongs to the code below. For example:
 
  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;
 
  
 
==Refactoring==
 
==Refactoring==
  
===Invert Assignments===
+
===Käännä sijoitus päinvastaiseksi===
 +
 
 +
;Abstract: : "Käännä sijoitus päinvastaiseksi" ottaa valitut pascal-lauseet ja invertoi kaikki tämän koodin tehtävät. Tämä työkalu on hyödyllinen "tallentaa" -koodin muuttamiseksi "lataukseksi" ja käänteiseksi.
 +
 
 +
Esimerkki:<br>
 +
<syntaxhighlight lang=pascal>procedure DoSomething;
 +
begin
 +
  AValueStudio:= BValueStudio;
 +
  AValueAppartment :=BValueAppartment;
 +
  AValueHouse:=BValueHouse;
 +
end;</syntaxhighlight>
 +
 
 +
Valitaan rivit, joissa on tehtäviä (sanojen begin ja end väliset) ja käännä sijoitus päinvastaiseksi. Kaikki tehtävät käännetään ja identiteetti lisätään automaattisesti. Esimerkiksi:
 +
 
 +
Tulos:
 +
<syntaxhighlight lang=pascal>procedure DoSomething;
 +
begin
 +
  BValueStudio    := AValueStudio;
 +
  BValueAppartment := AValueAppartment;
 +
  BValueHouse      := AValueHouse;
 +
end;</syntaxhighlight>
 +
 
 +
===Kapseloi valinta===
 +
Valitse jokin teksti ja ota "Kapseloi valinta" käyttöön. Avautuu valintaikkuna, jossa voidaan valita, haluaako valinnan '''try..finally''' tai monista muista tavoista .
  
;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.
+
===Vaihda tunnisteen nimeä===
 +
Aseta kohdistin tunnisteeseen ja valitse "Vaihda tunnisteen nimeä". Näyttöön tulee valintaikkuna, jossa voit määrittää hakualueen ja uuden nimen.
 +
* Se nimeää kaikki esiintymät uudelleen ja vain ne, jotka todella kuuluvat tähän määritykseen. Tämä tarkoittaa, ettei se koske toisten määrityksten osalla olevia samaa nimeä sisältäviä osia.
 +
* Se tarkistaa ensin nimen ristiriidat.
 +
* Rajoitukset: Se toimii vain pascal-lähdekoodeilla, ei vielä nimeä tiedostoja eikä muokkaa lfm / lrs-tiedostoja eikä lazdoc-tiedostoja.
  
Example:<br>
+
===Etsi viittauksia tunnisteeseen===
procedure DoSomething;
+
Aseta kohdistin tunnisteeseen ja ja valitse "Etsi viittauksia tunnisteeseen". Näyttöön tulee valintaikkuna, jossa voidaan määrittää hakualue. IDE etsii sitten kaikki esiintymät ja vain ne, jotka todella käyttävät tätä määritystä. Tämä tarkoittaa sitä, että siinä ei näytetä muita samannimisiä sanoja.
begin
 
  AValueStudio:= BValueStudio;
 
  AValueAppartment :=BValueAppartment;
 
  AValueHouse:=BValueHouse;
 
end;
 
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:
+
===Abstraktit metodit===
procedure DoSomething;
+
Tämä ominaisuus luetteloi ja täydentää automaattisesti virtuaalisia, abstrakteja menetelmiä, jotka on toteutettava. Aseta kohdistin luokan ilmoitukseen ja valitse tämä. Jos abstrakteja menetelmiä puuttuu, näkyviin tulee valintaikkuna. Valitse toteutettavat menetelmät ja IDE luo "tynkämetodin".
begin
+
Lazarus 1.3 versiosta lähtien se lisää myös puuttuvat luokan rajapinnat (''class interface'') .
  BValueStudio    := AValueStudio;
 
  BValueAppartment := AValueAppartment;
 
  BValueHouse      := AValueHouse;
 
end;
 
  
 
===Extract Procedure===
 
===Extract Procedure===
  
See [[IDE_Window:_Extract_Procedure|Extract Procedure]]
+
Katso [[IDE Window: Extract Procedure|Extract Procedure]].
 +
 
 +
==Etsi määritys==
 +
Aseta kohdistin tunnisteeseen ja tee 'Etsi määritys'. Sitten se etsii tämän tunnisteen määrityksen, avaa tiedoston ja siirtyy siihen. Jos kohdistin on jo määrityksessä, se siirtyy edelliseen määritykseen samalla nimellä. Tämä mahdollistaa uudelleenmäärittelyjen ja ohitusten (override9 löytymisen.
 +
 
 +
Jokainen löydettävä määrittely asettaa hyppypisteen. Tämä tarkoittaa sitä, että se hyppää etsimällä määritykseen ja hyppää helposti takaisin Etsi -> Hyppää takaisin.
 +
 
 +
Delphissä on joitain eroja: codetools toimivat lähdekoodissa normaalien pascal-sääntöjen jälkeen, eikä käytä kääntäjän tuloksen käyttöä. Kääntäjä palauttaa lopullisen tyypin. Codetools näkee lähdekoodin ja kaikki sen väliset vaiheet. Esimerkiksi:
 +
 
 +
''Visible'' property on ensin määritelty ''TControl'' (controls.pp), sitten se määritellään uudelleen TCustomForm:ssa ja lopuksi uudelleen  TForm:ssa.
 +
Kutsu "Etsi Visible:n määritys" tuo ensin näkyviin Visible:n TForm:ssa.
 +
Sitten voidaan hakea "Etsi Visible:n määritys" uudelleen joka siirtyy Visible:n TCustomForm:ssa
 +
ja seuraava uudelleen haku siirtyy TControl:n.
 +
 
 +
Sama pätee myös tyypeille kuten ''TColor''.  Kääntäjälle se on yksinkertaisesti 'longint'. Mutta lähdekoodissa se on määritelty
 +
<syntaxhighlight lang=pascal>TGraphicsColor = -$7FFFFFFF-1..$7FFFFFFF;
 +
TColor = TGraphicsColor;</syntaxhighlight>
 +
 
 +
Ja sama '''forward defined classes''': esimerkiksi ''TControl'':ssa on yksityinen muuttuja
 +
<syntaxhighlight lang=pascal>FHostDockSite: TWinControl;</syntaxhighlight>
 +
Etsi määritys hyppää TWinControl eteenpäin määrittelyyn
 +
<syntaxhighlight lang=pascal>TWinControl = class;</syntaxhighlight>
 +
Ja se taas hyppää todelliseen toteutukseen
 +
<syntaxhighlight lang=pascal>TWinControl = class(TControl)</syntaxhighlight>
 +
Tällä tavoin voit etsiä jokaisen tunnisteen ja löytää jokaisen ylikuormituksen (overload).
 +
 
 +
===Vihjeitä===
 +
* Hyppää takaisin {{keypress|Ctrl|H}}.
 +
* Voidaan tarkastella / navigoida kaikki vierailut kohteet valikon kautta: Näytä -> "hyppyhistoria"
 +
* 5-näppäimellä hiirellä voidaan 2 ylimääräistä painiketta hyödyntää siirtyäksesi eteenpäin / taaksepäin vierailtujen kohteiden välillä
 +
 
 +
[[IDE_Window:_EditorMouseOptionsAdvanced#Change_History_Jumps_for_3_button_Mouse_.28follow_back_the_.22Source_Link.22_trail.29|advanced mouse options]]  painikkeet voidaan uudelleen määrittää.
 +
 
 +
==Identifier Completion==
 +
"Identifier Completion" kutsutaan painamalla {{keypress|Ctrl|space}}. Se näyttää kaikki näkyvyyden tunnisteet. Esimerkiksi:
 +
 
 +
<syntaxhighlight lang=pascal>procedure TForm1.FormCreate(Sender: TObject);
 +
begin
 +
  |
 +
end;</syntaxhighlight>
 +
 
 +
Sijoita kursori ''begin'' ja ''end'' lauseiden väliin ja paina {{keypress|Ctrl|space}}. IDE/CodeTools analysoi nyt kaikki tavoitettavissa olevat koodit ja esittää luettelon kaikista löydetyistä tunnisteista. CodeTools välittää tulokset välimuistiin, joten toisen kerran kutsuminen on paljon nopeampaa.
 +
 
 +
{{Note| Delphi käyttäjille: Delphi kutsuu tätä nimellä ''Code completion''.}}
 +
 
 +
Joitakin tunnisteita, kuten 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' on rakennettu kääntäjään eikä niitä ole määritelty missään lähteessä.
 +
Identifier Completion on paljon näitä asioita myös sisäänrakennettu. Jos löytyy joku puuttuva, niin luo  ominaisuuspyyntö bug tracker:n.
 +
 
 +
''Identifier completion'' ei täydennä kaikkia '''avainsanoja'''.  Joten sitä ei voi käyttää  täyttämään 'repe' sanaa 'repeat':ksi.
 +
Tälläisissä tapauksissa käytä{{keypress|Ctrl|W}} [[#Word Completion|Word Completion]] tai {{keypress|Ctrl|J}} [[#Code Templates|Code Templates]]. Versiosta 0.9.27  lähtien ''identifier completion'' täydentää jotain avainsanoja.
 +
 
 +
Identifier completion näyttää myös ne tunnisteet, jotka eivät ole yhteensopivia.
 +
 
 +
===Täydennys sanan alkuosan mukaan===
 +
Identifier completion voidaan kutsua kun on muutamia kirjaimia sanasta. Sijoita kursori sanaan.
 +
Jolloin kursorin vasemmalla puolella olevia merkkejä käytetään tunnisteiden etsimiseen. Esimerkiksi:
 +
 
 +
<syntaxhighlight lang=pascal>procedure TForm1.FormCreate(Sender: TObject);
 +
begin
 +
  Ca|ption
 +
end;</syntaxhighlight>
 +
 
 +
Sanaluettelolaatikko näyttää vain tunnukset, jotka alkavat "Ca": lla (| osoittaa kursorin sijainnin).
 +
 
 +
 
 +
===Näppäimet===
 +
* Kirjain tai numero :  lisää merkin lähdekoodieditoriin ja käytettyyn etuliitteeseen. Tämä päivittää luettelon.
 +
* {{keypress|Backspace}}: poistaa viimeisen merkin lähdekoodieditorista ja etuliitteestä. Päivittää luettelon
 +
* {{keypress|Return}}: vaihtaa koko sanan kohdistimella valittuun tunnisteeseen ja sulkee ponnahdusikkunan.
 +
* {{keypress|Shift|Return}}: kuten ''Return'', mutta korvaa vain sanan etuliitteen (kursorin vasemmanpuolinen osa)
 +
* {{keypress|Up}}/{{keypress|Down}}: Siirtyy valintaluettelossa (ylöspäin/alaspäin)
 +
* {{keypress|Esc}}: sulkee ponnahdusikkunan ilman muutosta
 +
* {{keypress|Tab}}: täydentää etuliitteen seuraavaan valintaan. Esimerkiksi: Nykyinen etuliite on 'But' ja tunnuksen loppuun saattaminen näyttää vain 'Button1' ja 'Button1Click'. Tällöin {{keypress|Tab}}:in painamisella saadaan etuliite 'Button1'.
 +
* Muutoin: kuten {{keypress|Return}} ja lisätään merkki lähdekoodieditoriin
 +
 
 +
===Metodit===
 +
 
 +
Kun kohdistin on luokkamäärittelyssä ja identifier complete määrittää metodia esi-luokassa niin parametrit ja override avainsana lisätään automaattisesti. Esimerkiksi:
 +
 
 +
<syntaxhighlight lang=pascal>TMainForm = class(TForm)
 +
protected
 +
  mous|
 +
end;</syntaxhighlight>
 +
 
 +
Täydennys '''MouseDown''' antaa:
 +
 
 +
<syntaxhighlight lang=pascal>TMainForm = class(TForm)
 +
protected
 +
  procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
 +
        Y: Integer); override;
 +
end;</syntaxhighlight>
 +
 
 +
===Ominaisuudet===
 +
<syntaxhighlight lang=pascal>property MyInt: integer read |;</syntaxhighlight>
 +
 
 +
Identifier completion näyttää '''FMyInt''' ja '''GetMyInt'''.
 +
 
 +
<syntaxhighlight lang=pascal>property MyInt: integer write |;</syntaxhighlight>
 +
 
 +
Identifier completion näyttää '''FMyInt''' ja '''SetMyInt'''.
 +
 
 +
===Uses osio / käännösyksikön nimet===
 +
 
 +
Uses osiossa identifier completion näytetään kaikkien hakuehtojen yksiköiden tiedostonimet. Nämä näyttävät kaikki pienet kirjaimet (esim. ''avl_tree'' ), koska useimmilla käännösyksiköillä on pieniä tiedostonimiä. Valmistuttuaan se lisää käännösyksikön (esim. ''AVL_Tree'' ).
 +
 
 +
===Lauseet===
 +
<syntaxhighlight lang=pascal>procedure TMainForm.Button1Click(Sender: TObject);
 +
begin
 +
  ModalRe|;
 +
end;</syntaxhighlight>
 +
 
 +
tulee:
 +
 
 +
<syntaxhighlight lang=pascal>procedure TMainForm.Button1Click(Sender: TObject);
 +
begin
 +
  ModalResult:=|;
 +
end;</syntaxhighlight>
 +
 
 +
===Kuvakkeet täydennysikkunassa===
 +
 
 +
Lazarus versiosta 1.9 lähtien on olemassa vaihtoehto, jolla näytetään kuvakkeita "tyyppien" sijaan täydennysikkunassa. Kuvassa nähdään nämä kuvakkeet:
 +
 
 +
[[Image:ide_completion_icons.png]]
 +
 
 +
==Word Completion==
 +
''Word Completion'' kutsutaan {{keypress|Ctrl|W}}. Se näyttää kaikki lähdekoodieditorissa olevat sanat ja sitä voidaan käyttää myös ei-pascal-lähdekoodeissa, kommenteissa ja avainsanoissa.
 +
 
 +
Muutoin se toimii samoin kuin identifier completion.
 +
 
 +
==Siirry Include määrittelyyn==
 +
"Siirry Include määrittelyyn" hyppää {$ I filename} -lauseen, jossa käytetään nykyistä tiedostoa.
 +
 
 +
==Julkaise projekti==
 +
 
 +
Luo kopion koko projektista. Jos halutaan lähettää jollekulle vain lähdekoodi ja kääntäjän asetukset niin tämä toiminto on ystäväsi.
 +
 
 +
Tavallinen projektihakemisto sisältää paljon tietoa. Suurinta osaa sitä ei tarvitse julkaista: .lpi-tiedosto voi sisältää istuntotietoja (kuten suljettujen yksiköiden varmenteen sijainti ja kirjanmerkit) ja projektin hakemisto sisältää paljon .ppu, .o-tiedostoja ja suoritettavan tiedoston. Voidaan luoda lpi-tiedoston, jossa on vain perustiedot ja vain lähdekoodi sekä kaikki alihakemistot sisältävä "Publish Project".
 +
 
 +
 
 +
 
 +
{{Note| Versiosta 0.9.13 lähtien on uusi projektiasetus-vaihtoehto, jonka avulla voidaan tallentaa istunnon tiedot erilliseen tiedostoon tavallisesta .lpi-tiedostosta. Tämä uusi tiedosto päättyy .lps-laajennukseen ja sisältää vain istunnon tiedot, jotka jättävät .lpi-tiedoston paljon siistimmäksi.}}
 +
 
 +
Valintaikkunassa voidaan määrittää suodattimen tiettyjen tiedostojen sisällyttämiseksi ja sulkemiseksi pois. Komennolla voidaan pakata tuotos yhteen arkistoon.
 +
 
 +
==Huomautuksia näytettävistä vihjeistä==
 +
 
 +
Useilla kohdilla IDE näyttää vihjeitä tunnisteista. Esimerkiksi kun liikutetaan hiirtä tunnisteen päällä lähdekoodieditorissa ja odotetaan muutaman sekunti. Kun IDE näyttää vihjeenä tunnuksen, se etsii määrityksen ja kaikki sen esi-isät ja etsii kommentteja ja fpdoc-tiedostoja. On monia koodaustapoja ja monia kommentoitavia tyylejä. Monien yhteisten kommenttityylien tukemiseksi IDE käyttää seuraavia heuristiikkaa:
 +
 
 +
===Comments shown in the hint===
 +
Comments in front of a declaration, without empty line and not starting with the ''<'' sign:
 +
 
 +
<syntaxhighlight lang=pascal>var
 +
  {Comment}
 +
  Identifier: integer;</syntaxhighlight>
 +
 
 +
Comments with the ''<'' sign belong to the prior identifier.
 +
 
 +
Comments behind an identifier on the same line:
 +
 
 +
<syntaxhighlight lang=pascal>var
 +
  identifier, // Comment
 +
  other,</syntaxhighlight>
 +
 
 +
Comments behind the definition on the same line:
 +
 
 +
<syntaxhighlight lang=pascal>var
 +
  identifier:
 +
    char; // Comment</syntaxhighlight>
 +
 
 +
An example for '''<''' sign:
 +
 
 +
<syntaxhighlight lang=pascal>const
 +
  a = 1;
 +
  //< comment for a
 +
  b = 2;
 +
  // comment for c
 +
  c = 3;</syntaxhighlight>
 +
 
 +
All three comment types are supported:
 +
<syntaxhighlight lang=pascal>  {Comment}(*Comment*)//Comment
 +
  c = 1;</syntaxhighlight>
  
==Find Declaration==
+
===Comments not shown in the hint===
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.
+
Comments starting with '''$''' or '''%''' are ignored. For example ''//% Hiddden'', ''//$ Hidden'', ''(*$ Hidden*)''.
  
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.
+
Comments in front separated with an empty line are treated as not specific to the following identifier. For example the following class header comment is not shown in the hint:
  
There are some differences to Delphi:
+
<syntaxhighlight lang=pascal>type
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:
+
  { TMyClass }
 +
 
 +
  TMyClass = class</syntaxhighlight>
  
The ''Visible'' property is first defined in TControl (controls.pp), then redefined in TCustomForm and finally redefined in TForm.
+
The class header comments are created on class completion. You can turn this off in the ''Options / Codetools / Class completion / Header comment for class''. If you want to show the header comment in the hint, just remove the empty line.
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.
 
  
Same is true for types like TColor.
+
The following comment will be shown for GL_TRUE, but not for GL_FALSE:
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''':
+
<syntaxhighlight lang=pascal> // Boolean
For instance in TControl, there is a private variable
+
  GL_TRUE                          = 1;
  FHostDockSite: TWinControl;
+
  GL_FALSE                          = 0;</syntaxhighlight>
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.
 
  
'''Hints:''' You can jump back with Ctrl+H.
+
==Quick Fixes==
 +
Quick Fixes are menu items for specific compiler messages. They help you to quickly fix the problem. Select a message in the ''Messages'' window and right click, or right click in the source editor on the icon to the left.
 +
*Unit not found: remove from uses section
 +
*Unit not found: find unit in loaded packages and allow to auto add package dependency
 +
*Constructing a class "$1" with abstract method "$2": show dialog to override all abstract methods
 +
*Local variable "$1" not used: remove definition
 +
*Circular unit reference between $1 and $2: show Unit Dependencies dialog with full path between the two units
 +
*Identifier not found: search via Code Browser
 +
*Identifier not found: search via Cody Dictionary (needs package [[Cody]])
 +
*Identifier not found: add local variable
 +
*Recompiling $1, checksum changed for $2: show a dialog with search paths and other information
 +
*IDE warning: other sources path of package %s contains directory...: open package
 +
*any hint, note, warning: add IDE directive {%H-}
 +
*any hint, note, warning: add compiler directive {$warn id off} (since 1.7)
 +
*any hint, note, warning: add compiler option -vm<messageid>
 +
*Local variable "i" does not seem to be initialized: insert assignment (since 1.5)
  
==Goto Include Directive==
+
==Outline==
"Goto Include Directive" in the search menu of the IDE jumps to {$I filename} statement where the current include file is used.
 
  
==Publish Project==
+
Tämä asetus sijaitsee IDEn asetukset ikkunassa, Editori - Näkymä - Merkintä ja osumat - Outline (global).
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.
 
  
A normal project directory contains a lot of information. Most of it is not needed to be published:
+
Se korostaa Pascalin avainsanoja yhdistäen vastaavat begin - end parit. Tämä sallii isot sisäkkäiset lohkot
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.
+
Esimerkiksi vaikka tälläinen aliohjelman runko:
To create a lpi file with only the base information and only the sources, along with all sub directories use "Publish Project".
 
  
'''Note''': Since version 0.9.13 there is a new ''Project Option'' that allows you to store session information in a seperate file from the normal .lpi file.  This new file ends with the .lps extension and only contains session information, which will leave you .lpi file much cleaner.
+
<syntaxhighlight lang=pascal>
 +
  with ADockObject do
 +
  begin
 +
    if DropAlign = alNone then
 +
    begin
 +
      if DropOnControl <> nil then
 +
        DropAlign := DropOnControl.GetDockEdge(DropOnControl.ScreenToClient(DragPos))
 +
      else
 +
        DropAlign := Control.GetDockEdge(DragTargetPos);
 +
    end;
 +
    PositionDockRect(Control, DropOnControl, DropAlign, FDockRect);
 +
  end;
 +
</syntaxhighlight>
 +
 
 +
Tuodaan korostaen esiin:
  
In the dialog you can setup the exclude and include filter, and with the command after you can compress the output into one archive.
+
* ulompi with-do-begin-end  oranssin värisenä
 +
* seuraavan tason if-then-begin-end vihreän värisenä
 +
* sisempi if-then-else cyanin värisenä
  
==Original contributors==
+
[[Image:ide_outline.png]]
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]]
 
* Initial content posted - 4/10/2004 MattiasG
 
* Small wiki and formatting fixes - 4/11/2004 [[User:Tom Lisjac| VlxAdmin]]
 
* Added a summary table for IdeTools shortcuts - 12 July 2004 [[User:Kirkpatc]]
 

Latest revision as of 00:10, 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)

Lazarus IDE Tools on Free Pascal- lähdekoodin jäsentämis- ja muokkaustyökalu, jota kutsutaan "codetoolsiksi".

Tämä työkalu tarjoaa ominaisuuksia, kuten Find Declaration, Code Completion, Extraction, Moving Inserting ja Beautifying Pascal lähdekoodia. Nämä toiminnot voivat säästää paljon aikaa ja päällekkäistä työtä. Ne ovat muokattavissa ja jokainen ominaisuus on käytettävissä pikavalintojen kautta (katso editoriasetukset).

Koska ne työskentelevät pelkästään Pascal-lähdekoodeilla ja ymmärtävät FPC-, Delphi- ja Kylix- koodeja, ne eivät tarvitse käännettyjä käännösyksiköitä tai asennettua Borland / Embarcadero-kääntäjää. Delphi- ja FPC-koodia voidaan muokata samanaikaisesti useilla Delphi- ja FPC-versioilla. Tämä tekee Delphi-koodin siirtämisen FPC / Lazarukselle paljon helpompaa.

Yhteenvetoraportti IDEn-pikanäppäimestä

Declaration Jumping Ctrl+klikkaa tai Alt+ (Hyppää tyypin tai muuttujan määrittelyyn)
Siirtyminen esittelyn ja toteuksen välillä Ctrl+ Shift+ (vaihtaa määritelmäosion ja toteutusosion välillä)
Code Templates Ctrl+J
Syncro Edit Ctrl+J (while text is selected)
Code Completion (Class Completion) Ctrl+ Shift+C, Ctrl+ Shift+X for creating class fields instead of local variables
Identifier Completion Ctrl+space
Word Completion Ctrl+W
Parametrivihjeet Ctrl+ Shift+space
Etsi kirjain kerrallaan Ctrl+E
Rename Identifier Ctrl+ Shift+E

Siirtyminen esittelyn ja toteuksen välillä

Jos halutaan siirtyä aliohjelman rungon (begin..end) ja aliohjelman (procedure Name;) esittelyn välillä käytä näppäinyhdistelmää Ctrl+ Shift+.

Esimerkiksi:

interface
 
procedure DoSomething; // Aliohjelman esittely
  
implementation
  
procedure DoSomething; // Aliohjelman määrittely 
begin
end;

Jos kursori on aliohjelman toteutusosiossa ja painetaan Ctrl+ Shift+ niin kursori siirtyy aliohjelman esittelyyn. Painamalla Ctrl+ Shift+ uudelleen niin tullan takaisin määrittelyyn heti 'begin' sanan jälkeiseen kohtaan.

Tämä toimii samanlailla myös luokan (class) metodin esittelyn ja toteutuksen välillä.

Vihje: Siirtyminen tapahtuu siihen aliohjelmaan jossa on samat parametrit. Jos ei löydy täysin samaa niin siirtyminen tapahtuu sopivampaan eli siihen jossa on vähiten eroja (Tälläistä toimintaa ei välttämättä löydy esim. Delphistä).

Esimerkki aliohjelmasta joiden esittelyssä ja toteutuksessa on erilaiset parametrityypit:

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

Siirtyminen toteuksen ja niiden esittelyjen välillä 'string' avainsana. Tätä voi käyttää kun haluaa uudelleen nimetä metodin ja/tai muuttaa parametrejä.

Esimerkiksi: uudelleen nimetään 'DoSomething' -> 'MakeIt':ksi:

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

Kun siirrytään 'MakeIt':n esittelystä toteukseen (joka on siis vielä väärän niminen). Lazarus etsii sopivaa toteustusta, jota ei löydy, sen jälkeen muita sopivia. Jos nimeä on muutettu ainoastaan yhdestä aliohjelmasta jolloin on yksi toteutus josta ei löydy määrittelyä niin tällöin siirrytään siihen. Näin voidaan yksinkertaisesti vaihtaa nimeä tai parametrejä.

Include Files

Include files ovat tiedostoja, jotka on lisätty lähdekoodiin {$I filename} tai {$INCLUDE filename} kääntäjän ohjeella. Lazarus ja FPC käyttävät usein include tiedostoja vähentämään redundanssia ja välttävät lukemattomia {$ IFDEF} -rakenteita, joita tarvitaan eri alustojen tukemiseen.

Toisin kuin Delphi, Lazarus IDE: llä on täysi tuki myös include-tiedostoihin. Voit esimerkiksi hypätä .pas-tiedoston aliohjelmasta sisällytetyn tiedoston toteutukseen. Kaikki codetools osiot, kuten koodin täydentäminen, käsittelevät include tiedostoja erityistapauksina.

Esimerkiksi: Kun koodin täydentäminen lisää uuden metodin toteuksen rungon toisen metodin rungon taakse, se pitää ne molemmissa samassa tiedostossa. Tällä tavalla voit laittaa kokoluokan toteutuksia include-tiedostoihin, kuten LCL tekee lähes kaikille kontrolleille.

Mutta aloittelijoille löytyy ansa: Jos avataan include tiedosto ensimmäisen kerran ja yritetään siirtyä esittelyn ja toteuksen välillä tai löytää määrittely niin saadaan virhe. IDE ei vielä tiedä, mihin yksikköön sisällytettävä tiedosto kuuluu. Sillä on ensin avattava käännösyksikkö.

Niin pian kuin IDE analysoi käännösyksikön, se analysoi include kääntäjänohjeet siellä ja IDE muistaa tämän suhteen. Se tallentaa nämä tiedot poistumiseen ja projektin tallentamiseen ~ / .lazarus / includelinks.xml. Kun seuraavan kerran avataan tämän include tiedosto ja siirrytään toteuksen ja niiden esittelyjen välillä, IDE avaa laitteen sisäisesti ja siirtyminen toimii. Voidaan myös viitata IDE: een asettamalla

{%mainunit yourunit.pas}

tiedoston yourinclude.inc alkuun.

Tällä mekanismilla on rajoituksia. Joihinkin tiedostoihin sisältyy kaksi tai useampia include tiedostoja. Esimerkiksi: lcl/include/winapih.inc.

Se miten siirrytään aliohjelman/metodin määrityksistä niiden include tiedostoihin riippuu viimeisestä toiminnosta. Jos ollaan työskennelty lcl / lclintf.pp: llä, IDE siirtyy winapi.inc: hen. Jos ollaan työskennelty lcl / interfacebase.pp: llä niin se siirtyy lcl / include / interfacebase.inc (tai johonkin muuhun include tiedostoon). Jos työskennellään molemmilla, niin se saadaan sekaisin. ;)

Code Templates

Code Templates muuntaa tietyn tunnisteen tekstiksi tai koodin palaseksi.

Code Templates oletuspikanäppäin on Ctrl+J. Kun kirjoittaa sopivan tunnisteen, painaa Ctrl+J niin tunniste korvataan tunnisteella määritellyllä tekstillä. Code Templates voidaan määritellä Työkalut -> Optiot -> CodeTools.

Esim: Kirjoita teksti 'classf', jätä kursori kirjaimen 'f' oikealle puolen ja paina Ctrl+J. Teksti 'classf' korvautuu riveillä

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

ja kursori on kirjaimen 'T' takana. Luettelo kaikista Code Template vaihtoehdoista saadaan sijoittamalla kohdistin välilyönnin perään (ei tunnisteeseen) ja painamalla Ctrl+J. Luettelo kaikista Code Template vaihtoehdoista ponnahtaa esiin. Käytä kursorinäppäimiä tai kirjoita joitain merkkejä valitaksesi. Painamalla Return luodaan valittu malli ja Esc sulkee ponnahdusikkunan.

Suurin ajan säästäjä on Code Template 'b'+Ctrl+J varatuille sanoille begin..end.

Parametrivihjeet

Parametrivihjeet näyttävät vihjeruutu, jossa on parametriluettelot kutsun parametrilistalle.

Esimerkiksi

  Canvas.FillRect(|);

Aseta kursori sulkujen väliin ja paina Ctrl+ Shift+space. Näyttöön tulee vihjeruutu, joka näyttää FillRectin parametrit.

Parameterhints1.png

Versiosta 0.9.31 asti on ollut jokaisen Parametrivihjeen oikealla puolella painike puuttuvien parametrien lisäämiseksi. Tämä kopioi parametrin nimet valitusta vihjeestä kohdistimen kohtaan.

Parameterhints2.png


Vihje: Käytä Variable Declaration Completion määrittääksesi muuttujia.

Light bulb  Huomaa: Pikanäppäimen nimi on "Show code context".

Etsi kirjain kerrallaan

Etsi kirjain kerrallaan muuttaa lähdekoodieditorin tilarivin. Kirjoita joitain kirjaimia ja editori etsii ja korostaa välittömästi kaikki niiden esiintymät tekstissä. Pikanäppäin on Ctrl+e.

  • Esimerkiksi painamalla e. Se etsii ja korostaa kaikki 'e':n esiintymät.
  • Sitten painetaan t. Se etsii ja korostaa kaikki esiintymät "et" ja niin edelleen.
  • Seuraavaan esiintymään voidaan siirtyä painamalla F3 (tai Ctrl+e kun ollaan haussa) ja edelliseen painamalla Shift+F3.
  • Backspace eli <- poistaa edellisen merkin
  • Return lopettaa haun lisäämättä uutta riviä editoriin.
  • Viimeistä hakua voidaan jatkaa painamalla Ctrl+e -näppäintä toisen kerran välittömästi sen jälkeen, kun olet käynnistänyt etsinnän painamalla Ctrl+e. Toisin sanoen hakutermi on vielä tyhjä.
  • Liittäminen Ctrl+V liittää tekstin leikepöydältä nykyiseen hakutekstiin (Ollut Lazarus versiosta 0.9.27 lähtien).

Vihje: Nopea haku tunnistimella käyttäen etsi kirjain kerrallaan toimintoa

  • Aseta tekstikohdistin tunnisteeseen (älä valitse mitään)
  • Paina Ctrl+C. Lähdekoodieditori valitsee tunnuksen ja kopioi sen leikepöydälle
  • Paina Ctrl+E aloittaaksesi etsi kirjain kerrallaan toiminnon.
  • Paina Ctrl+V joka liittää tekstin leikepöydältä nykyiseen hakutekstiin.
  • Käyttämällä F3 ja Shift+F3 siirtyäksesi nopeasti seuraavaan / edelliseen.
  • Lopeta haku painamalla mitä tahansa näppäintä (esimerkiksi kohdistinta vasemmalle tai oikealle).


Syncro Edit

Syncro Edit:llä voidaan muokata samanaikaisesti kaikkia sanojen esiintymiä (synkronoitu). Yksinkertaisesti voidaan muokata sanaa yhdessä paikassa ja kun sitä muutetaan niin kaikki muut sanan tapahtumat päivittyvät.

Syncro Edit toimii kaikkien valitun alueen sanoilla:

  • Valitse tekstilohko
  • Paina Ctrl+J tai klikkaa kuvaketta reunuksessa. (Tämä toimii vain, jos valittu sana esiintyy useamman kerran).
  • Valitse muokattava sana Tab näppäimellä (jos valittu sana esiintyy useamman kerran)
  • Muokkaa sanaa
  • Lopeta painamalla Esc näppäimellä

Katso animoitu esimerkki tästä

Light bulb  Huomaa: Ctrl+J käytetään myös template edit:ssä. Se vaihtaa merkitystään, jos valitset jonkin tekstin.

Etsi sanan seuraava esiintymiskohta/ Etsi sanan edellinen esiintymiskohta

Nämä kaksi funktiota löytyvät lähdekoodieditorin ponnahdusvalikosta

  • Lähdekoodieditori / ponnahdusvalikko / Etsi / Etsi sanan seuraava esiintymiskohta
  • Lähdekoodieditori / ponnahdusvalikko / Etsi / Etsi sanan edellinen esiintymiskohta

Näihin voidaan määrittää pikanäppäimet editorin asetuksissa.

Code Completion

Code Completion löytyy IDE-valikosta Edit -> Complete Code ja sen pikanäppäin on Ctrl+ Shift+C.

Delphi-käyttäjille: Delphi nimeää "code completion" funktioksi, joka näyttää tunnistetietojen luettelon kursorin kohdalla lähdekoodissa ( Ctrl+Space ). Lazaruksessa se on "Identifier completion".

Code Completion yhdistää useita tehokkaita toimintoja. esimerkkejä:

Mikä toiminto on käytössä, riippuu kohdistimen sijainnista editorissa ja sitä selitetään alla.

Code Completion löytyy IDE-valikosta Edit -> Complete Code ja sen pikanäppäin on Ctrl+ Shift+C.

Class Completion

Tehokkain koodin täydentäjä ominaisuus on "Class Completion". Kun kirjoitetaan luokkaa (class) johon lisätään metodeja ja ominaisuuksia niin Code Completion lisää metodien toteutuksen rungot, ominaisuuksien käyttörutiinit / muuttujat ja yksityiset muuttujat.

Esimerkiksi: Luo luokka eli class (Katso Code Templates jonka avulla voidaan säästää kirjoittamistyötä):

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

Aseta kohdistin johonkin kohtaan luokkaan ja paina Ctrl+ Shift+C. Tämä luo metodien puuttuvat rungot ja siirtää kohdistimen ensimmäiselle luodulle metodin rungolle, joten voidaan aloittaa luokan koodin kirjoittaminen:

{ TExample }
 
constructor TExample.Create;
begin
  |
end;
 
destructor TExample.Destroy;
begin
  inherited Destroy;
end;
Light bulb  Huomaa: Merkki '|' on kohdistin eikä sitä lisätä.

Vihje: On mahdollista siirtyä metodin ja sen rungon välillä Ctrl+ Shift+.

Nähdään, että IDE lisäsi myös 'inherited Destroy' kutsun. Tämä tehdään, jos luokan määritelmässä on 'override' avainsana.

Nyt lisätään metodi DoSomething:

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

Sitten paina Ctrl+ Shift+C ja IDE lisää

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

Nähdään että uusi metodin runko on sijoitettu Create ja Destroy -toimintojen väliin aivan kuten luokkamäärittelyssä. Tällä tavoin rungot pitävät saman loogisen järjestyksen kuin on määritetty. Lisäyskäytäntö voidaan määrittää Työkalut> Asetukset -> Codetools -> Code Creation.

Täydennä ominaisuuksilla
Lisää ominaisuus AnInteger:

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

Paina Ctrl+ Shift+C jolloin saadaan:

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

code completion on lisännyt kirjoitusoikeuden muokkaajan ja lisännyt yleistä koodia. Siirry luokalle painamalla Ctrl+ Shift+ nähdäksesi uuden luokan:


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;

Ominaisuutta laajennettiin Read (luku) ja Write (kirjoitus)-ominaisuuden avulla. Luokka sai uuden 'private' osion johon tuli muuttuja "FAnInteger" ja metodi "SetAnInteger". Yleisen Delphi-tyylisen käytännön mukaan yksityisiin muuttujiin lisätään 'F' kirjain ja kirjoitusmetodiin 'Set'. Tätä ominaisuutta voidaan muuttaa Työkalut -> Valinnat> Codetools -> Code Creation.


Luodaan property:n vain luku (read) :

property PropName: PropType read;

Laajennetaan

property PropName: PropType read FPropName;

Luodaan property:n vain kirjoitus (write) :

property PropName: PropType write;

Laajennetaan

property PropName: PropType write SetPropName;

Luodaan property:n vain luku (read) ja lukumetodi:

property PropName: PropType read GetPropName;

Säilytetään ja GetPropName-funktio lisätään:

function GetpropName: PropType;

Luodaan property jossa on stored määrite:

property PropName: PropType stored;

Laajennetaan

property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;

Koska stored käytetään tietovirtojen lukemiseen ja kirjoittamiseen, ne myös lisätään automaattisesti.

Vihje: Identifier completion tunnistaa myös puutteelliset ominaisuudet ja ehdottaa oletusnimiä. Esimerkiksi:

property PropName: PropType read |;

Aseta kohdistin yksi välilyönti read-avainsanan taakse ja paina Ctrl+Space. Se antaa muuttujan "FPropName" ja aliohjelman "SetPropName".

Forward Procedure Completion

"Forward Procedure Completion" on osa Code Completion ja lisää aliohjelman rungon. Sitä käytetään, kun kohdistin on aliohjelman esittelyssä. It is invoked, when the cursor is on a forward defined procedure.

Esimerkiksi: Lisätään uusi aliohjelma interface osioon:

procedure DoSomething;

Aseta kohdistin sille ja paina Ctrl+ Shift+C. Se luo toteutusosassa (implementation):

procedure DoSomething;
begin
  |
end;

Vihje: Voidaan siirtyä aliohjelman esittelyn ja sen rungon välillä painamallaCtrl+ Shift+.

Uusi aliohjelman runko lisätään luokkametodien eteen. Jos rajapinnassa on jo joitain aliohjelmia, IDE yrittää säilyttää järjestyksen. Esimerkiksi:

procedure Proc1;
procedure Proc2; // new proc
procedure Proc3;

Jos aliohjelmien Proc1: n ja Proc3: n rungot ovat jo olemassa, niin Proc2 runko lisätään Proc1: n ja Proc3: n rungon väliin. Tämä toiminto voidaan asettaa Työkalut -> Valinnat -> Codetools -> Code Creation.

Useita aliohjelmia:

procedure Proc1_Old; // runko on jo olemassa
procedure Proc2_New; // runkoa ei ole vielä
procedure Proc3_New; //  "
procedure Proc4_New; //  "
procedure Proc5_Old; // runko on jo olemassa

Code Completion lisää kaikki kolme (3) aliohjelman runkoa (Proc2_New, Proc3_New, Proc4_New).

Miksi kutsua "Forward Procedure Completion"?

Koska se ei toimi vain interface osiossa määriteltyjen aliohjelmien, vaan myös "forward" -määritteen kanssa. Ja koska codetools käsittelee interface osiossa olevia aliohjelmia niin, että niillä on implisiittinen 'forward' -määrite.

Event Assignment Completion

"Event Assignment Completion" on osa Code Completion:a. Se täydentää yhden tapahtuman := | lauseen. Sitä kutsutaan, kun kohdistin on järjestetty tapahtumalle.

completes a single Event:=| statement. It is invoked, when the cursor is behind an assignment to an event.

Esimerkiksi: Kirjoita lomakkeen FormCreate-tapahtumaan rivi 'OnPaint:=':

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

Kursorin paikka on merkitty '|' -kirjaimella eikä kyseistä kirjainta kirjoiteta. Code completion kutsutaan painamalla Ctrl+ Shift+C. Lause täydennetään

OnPaint:=@Form1Paint;

ja uusi metodi Form1Paint lisätään TForm1 luokkaan. Tällöin luokka valmistuu ja saadaan myös:

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

Tämä toimii samalla tavoin kuin lisätään menetelmiä komponenttimuokkaimella.


Light bulb  Huomaa: Kursori on sijoitettava heti ':=' saa arvokseen operatorin jälkeen. Jos kursori sijoitetaan osoittamaan esim. OnPaint tunnisteeseen niin koodin suorittaminen viittaa "Local Variable Completion", joka epäonnistuu, koska OnPaint on jo määritetty.

Vinkit:

  • Uuden metodin oletusarvoinen näkyvyys voidaan valita Työkalut / Asetukset / Codetools / Luokan täydennys / Default section of methods (versiosta 1.8 lähtien)
  • Uuden metodin nimen voi määrittää itse. Esimerkiksi:
  OnPaint:=@ThePaintMethod;


Versiosta 0.9.31 Lazarus täydentää aliohjelman parametreja. Esimerkiksi

procedure TForm1.FormCreate(Sender: TObject);
var
  List: TList;
begin
  List:=TList.Create;
  List.Sort(@MySortFunction|);
end;

Sijoita kursori 'MySortFunction' kohtaan ja paina Ctrl+ Shift+C niin saadaan uusi aliohjelma:

function MySortFunction(Item1, Item2: Pointer): Integer;
begin
  |
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  List: TList;
begin
  List:=TList.Create;
  List.Sort(@MySortFunction);
end;


Variable Declaration Completion

"Variable Declaration Completion" on osa Code Completion:a. Se lisää paikallisen muuttujan määritelmän tunnisteelle := Term; lause. Sitä kutsutaan, kun kohdistin on osoittaa parametria tai tunnistetta.

Esimerkiksi:

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

Kursorin paikka on tunnisteessa 'i' tai sen jälkeen. Painamalla Ctrl+ Shift+C saadaan:

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

Toiminto ensin tarkastaa onko tunnistetta 'i' jo määritelty. Jos sitä ei ole niin lisää määrittelyn 'var i: integer;'. Tunnisteen tyyppi arvatellaan ": =" operaattorista. Kokonaisluvun, kuten 3 oletustyyppinä on Integer.

Toinen esimerkki:

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;

Kursorin paikka on 'Where'-sanan kohdalla ja painetaan Ctrl+ Shift+C niin saadaan:

  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;

Lazarus on versiosta 0.9.11 lähtien myös täydentänyt parametreja. Esimerkiksi

  procedure TForm1.FormPaint(Sender: TObject);
  begin
    with Canvas do begin
      Line(x1,y1,x2,y2);
    end;
  end;

Sijoita kursori 'x1' ja paina Ctrl+ Shift+C niin saadaan:

  procedure TForm1.FormPaint(Sender: TObject);
  var
    x1: integer;
  begin
    with Canvas do begin
      Line(x1,y1,x2,y2);
    end;
  end;

Lazarus on versiosta 0.9.31 täydentänyt osoittimen parametrit. Esimerkiksi

  procedure TForm1.FormCreate(Sender: TObject);
  begin
    CreateIconIndirect(@IconInfo);
  end;

Sijoita kursori 'IconInfo':n ja paina Ctrl+ Shift+C niin saadaan:

  procedure TForm1.FormCreate(Sender: TObject);
  var
    IconInfo: TIconInfo;
  begin
    CreateIconIndirect(@IconInfo);
  end;

Kaikissa edellä olevissa esimerkeissä voit käyttää Ctrl+ Shift+X-näppäintä näyttääksesi koodin luomisen valintaikkunan, jossa voit asettaa lisää vaihtoehtoja.

Procedure Call Completion

Code completion voi luoda uuden aliohjelman sen kutsusta.

Oletataan että kirjoitettiin vain lause "DoSomething(Width);"

procedure SomeProcedure;
var
  Width: integer;
begin
  Width:=3;
  DoSomething(Width);
end;

Sijoita kursori tekstiin "DoSomething" ja paina Ctrl+ Shift+C niin saadaan:

procedure DoSomething(aWidth: LongInt);
begin

end;

procedure SomeProcedure;
var
  Width: integer;
begin
  Width:=3;
  DoSomething(Width);
end;

Se ei vielä luo funktioita tai metodeja.

Reversed Class Completion

"Reversed Class Completion" on osa Code Completion toimintaa. Se lisää yksityisen metodin ilmoituksen nykyiselle metodiryhmälle. Sitä kutsutaan, kun kursori on metodin rungossa, jota ei ole vielä määritelty luokassa. Tämä ominaisuus on saatavana Lazarus 0.9.21 versiosta alkaen.

Esimerkiksi:

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

DoSomething-metodia ei ole vielä määritelty TForm1: ssä. Paina Ctrl+ Shift+C ja IDE lisää aliohjelman "procedure DoSomething (Sender: TObject);" TForm1: n yksityisiin metodeihin.

Delphi käyttäjille: Class completion toimii Lazaruksen mukaan aina yhdellä tavalla: Luokan käyttöliittymästä toteutukseen tai taaksepäin / päinvastoin luokan toteutuksesta käyttöliittymään. Delphi kutsuu aina molempiin suuntiin. Delphi-tapa on haitta, että jos on typo se luo helposti uuden tynkä metodin ilman huomaamatta.

Kommentit ja Code Completion

Code completion yrittää pitää kommentteja, johon ne kuuluvat. Esimerkiksi:

  FList: TList; // list of TComponent
  FInt: integer;

Kun lisätään uusi muuttuja FListin ja FInt: n välillä, kommentti pidetään FList-rivillä. Sama pätee myös

  FList: TList; { list of TComponent
      Tämä on usean rivin kommentti, alkaen 
      FList-riviltä, joten codetools olettaa sen kuuluvan  
      FLIst-riviin ja ei riko tätä  
      suhdetta.  Koodi lisätään kommentin taakse.  }
  FInt: integer;

Jos kommentti alkaa seuraavalla rivillä, sitä käsitellään kuin se kuuluu alla olevaan koodiin. Esimerkiksi:

  FList: TList; // list of TComponent
      { Tämä kommentti kuuluu alla olevaan lauseeseen.  
        Uusi koodi lisätään tämän kommentin yläpuolelle ja  
        FList-rivin kommentin taakse.  }
  FInt: integer;

Metodin päivitys

Normaalisti luokan täydennys lisää kaikki puuttuvat metodin rungot (Ollut versiosta 0.9.27 lähtien). Jos täsmälleen yksi metodi eroaa luokan ja rungon välillä, niin metodin runko päivitetään. Esimerkiksi: On metodi DoSomething DoSomething.

  public
    procedure DoSomething;
  end;

procedure TForm.DoSomething;
begin
end;

Nyt lisätään parameteri:

  public
    procedure DoSomething(i: integer);
  end;

Code Completion kutsuminen (Ctrl+ Shift+C) päivittää metodin rungon ja uusi parametri kopioidaan:

procedure TForm.DoSomething(i: integer);
begin
end;

Refactoring

Käännä sijoitus päinvastaiseksi

Abstract
: "Käännä sijoitus päinvastaiseksi" ottaa valitut pascal-lauseet ja invertoi kaikki tämän koodin tehtävät. Tämä työkalu on hyödyllinen "tallentaa" -koodin muuttamiseksi "lataukseksi" ja käänteiseksi.

Esimerkki:

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

Valitaan rivit, joissa on tehtäviä (sanojen begin ja end väliset) ja käännä sijoitus päinvastaiseksi. Kaikki tehtävät käännetään ja identiteetti lisätään automaattisesti. Esimerkiksi:

Tulos:

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

Kapseloi valinta

Valitse jokin teksti ja ota "Kapseloi valinta" käyttöön. Avautuu valintaikkuna, jossa voidaan valita, haluaako valinnan try..finally tai monista muista tavoista .

Vaihda tunnisteen nimeä

Aseta kohdistin tunnisteeseen ja valitse "Vaihda tunnisteen nimeä". Näyttöön tulee valintaikkuna, jossa voit määrittää hakualueen ja uuden nimen.

  • Se nimeää kaikki esiintymät uudelleen ja vain ne, jotka todella kuuluvat tähän määritykseen. Tämä tarkoittaa, ettei se koske toisten määrityksten osalla olevia samaa nimeä sisältäviä osia.
  • Se tarkistaa ensin nimen ristiriidat.
  • Rajoitukset: Se toimii vain pascal-lähdekoodeilla, ei vielä nimeä tiedostoja eikä muokkaa lfm / lrs-tiedostoja eikä lazdoc-tiedostoja.

Etsi viittauksia tunnisteeseen

Aseta kohdistin tunnisteeseen ja ja valitse "Etsi viittauksia tunnisteeseen". Näyttöön tulee valintaikkuna, jossa voidaan määrittää hakualue. IDE etsii sitten kaikki esiintymät ja vain ne, jotka todella käyttävät tätä määritystä. Tämä tarkoittaa sitä, että siinä ei näytetä muita samannimisiä sanoja.

Abstraktit metodit

Tämä ominaisuus luetteloi ja täydentää automaattisesti virtuaalisia, abstrakteja menetelmiä, jotka on toteutettava. Aseta kohdistin luokan ilmoitukseen ja valitse tämä. Jos abstrakteja menetelmiä puuttuu, näkyviin tulee valintaikkuna. Valitse toteutettavat menetelmät ja IDE luo "tynkämetodin". Lazarus 1.3 versiosta lähtien se lisää myös puuttuvat luokan rajapinnat (class interface) .

Extract Procedure

Katso Extract Procedure.

Etsi määritys

Aseta kohdistin tunnisteeseen ja tee 'Etsi määritys'. Sitten se etsii tämän tunnisteen määrityksen, avaa tiedoston ja siirtyy siihen. Jos kohdistin on jo määrityksessä, se siirtyy edelliseen määritykseen samalla nimellä. Tämä mahdollistaa uudelleenmäärittelyjen ja ohitusten (override9 löytymisen.

Jokainen löydettävä määrittely asettaa hyppypisteen. Tämä tarkoittaa sitä, että se hyppää etsimällä määritykseen ja hyppää helposti takaisin Etsi -> Hyppää takaisin.

Delphissä on joitain eroja: codetools toimivat lähdekoodissa normaalien pascal-sääntöjen jälkeen, eikä käytä kääntäjän tuloksen käyttöä. Kääntäjä palauttaa lopullisen tyypin. Codetools näkee lähdekoodin ja kaikki sen väliset vaiheet. Esimerkiksi:

Visible property on ensin määritelty TControl (controls.pp), sitten se määritellään uudelleen TCustomForm:ssa ja lopuksi uudelleen TForm:ssa. Kutsu "Etsi Visible:n määritys" tuo ensin näkyviin Visible:n TForm:ssa. Sitten voidaan hakea "Etsi Visible:n määritys" uudelleen joka siirtyy Visible:n TCustomForm:ssa ja seuraava uudelleen haku siirtyy TControl:n.

Sama pätee myös tyypeille kuten TColor. Kääntäjälle se on yksinkertaisesti 'longint'. Mutta lähdekoodissa se on määritelty

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

Ja sama forward defined classes: esimerkiksi TControl:ssa on yksityinen muuttuja

FHostDockSite: TWinControl;

Etsi määritys hyppää TWinControl eteenpäin määrittelyyn

TWinControl = class;

Ja se taas hyppää todelliseen toteutukseen

TWinControl = class(TControl)

Tällä tavoin voit etsiä jokaisen tunnisteen ja löytää jokaisen ylikuormituksen (overload).

Vihjeitä

  • Hyppää takaisin Ctrl+H.
  • Voidaan tarkastella / navigoida kaikki vierailut kohteet valikon kautta: Näytä -> "hyppyhistoria"
  • 5-näppäimellä hiirellä voidaan 2 ylimääräistä painiketta hyödyntää siirtyäksesi eteenpäin / taaksepäin vierailtujen kohteiden välillä

advanced mouse options painikkeet voidaan uudelleen määrittää.

Identifier Completion

"Identifier Completion" kutsutaan painamalla Ctrl+space. Se näyttää kaikki näkyvyyden tunnisteet. Esimerkiksi:

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

Sijoita kursori begin ja end lauseiden väliin ja paina Ctrl+space. IDE/CodeTools analysoi nyt kaikki tavoitettavissa olevat koodit ja esittää luettelon kaikista löydetyistä tunnisteista. CodeTools välittää tulokset välimuistiin, joten toisen kerran kutsuminen on paljon nopeampaa.

Light bulb  Huomaa: Delphi käyttäjille: Delphi kutsuu tätä nimellä Code completion.

Joitakin tunnisteita, kuten 'Write', 'ReadLn', 'Low', 'SetLength', 'Self', 'Result', 'Copy' on rakennettu kääntäjään eikä niitä ole määritelty missään lähteessä. Identifier Completion on paljon näitä asioita myös sisäänrakennettu. Jos löytyy joku puuttuva, niin luo ominaisuuspyyntö bug tracker:n.

Identifier completion ei täydennä kaikkia avainsanoja. Joten sitä ei voi käyttää täyttämään 'repe' sanaa 'repeat':ksi. Tälläisissä tapauksissa käytäCtrl+W Word Completion tai Ctrl+J Code Templates. Versiosta 0.9.27 lähtien identifier completion täydentää jotain avainsanoja.

Identifier completion näyttää myös ne tunnisteet, jotka eivät ole yhteensopivia.

Täydennys sanan alkuosan mukaan

Identifier completion voidaan kutsua kun on muutamia kirjaimia sanasta. Sijoita kursori sanaan. Jolloin kursorin vasemmalla puolella olevia merkkejä käytetään tunnisteiden etsimiseen. Esimerkiksi:

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

Sanaluettelolaatikko näyttää vain tunnukset, jotka alkavat "Ca": lla (| osoittaa kursorin sijainnin).


Näppäimet

  • Kirjain tai numero : lisää merkin lähdekoodieditoriin ja käytettyyn etuliitteeseen. Tämä päivittää luettelon.
  • ← Backspace: poistaa viimeisen merkin lähdekoodieditorista ja etuliitteestä. Päivittää luettelon
  • Return: vaihtaa koko sanan kohdistimella valittuun tunnisteeseen ja sulkee ponnahdusikkunan.
  • Shift+Return: kuten Return, mutta korvaa vain sanan etuliitteen (kursorin vasemmanpuolinen osa)
  • /: Siirtyy valintaluettelossa (ylöspäin/alaspäin)
  • Esc: sulkee ponnahdusikkunan ilman muutosta
  • Tab : täydentää etuliitteen seuraavaan valintaan. Esimerkiksi: Nykyinen etuliite on 'But' ja tunnuksen loppuun saattaminen näyttää vain 'Button1' ja 'Button1Click'. Tällöin Tab :in painamisella saadaan etuliite 'Button1'.
  • Muutoin: kuten Return ja lisätään merkki lähdekoodieditoriin

Metodit

Kun kohdistin on luokkamäärittelyssä ja identifier complete määrittää metodia esi-luokassa niin parametrit ja override avainsana lisätään automaattisesti. Esimerkiksi:

TMainForm = class(TForm)
protected
  mous|
end;

Täydennys MouseDown antaa:

TMainForm = class(TForm)
protected
  procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X,
         Y: Integer); override;
end;

Ominaisuudet

property MyInt: integer read |;

Identifier completion näyttää FMyInt ja GetMyInt.

property MyInt: integer write |;

Identifier completion näyttää FMyInt ja SetMyInt.

Uses osio / käännösyksikön nimet

Uses osiossa identifier completion näytetään kaikkien hakuehtojen yksiköiden tiedostonimet. Nämä näyttävät kaikki pienet kirjaimet (esim. avl_tree ), koska useimmilla käännösyksiköillä on pieniä tiedostonimiä. Valmistuttuaan se lisää käännösyksikön (esim. AVL_Tree ).

Lauseet

procedure TMainForm.Button1Click(Sender: TObject);
begin
  ModalRe|;
end;

tulee:

procedure TMainForm.Button1Click(Sender: TObject);
begin
  ModalResult:=|;
end;

Kuvakkeet täydennysikkunassa

Lazarus versiosta 1.9 lähtien on olemassa vaihtoehto, jolla näytetään kuvakkeita "tyyppien" sijaan täydennysikkunassa. Kuvassa nähdään nämä kuvakkeet:

ide completion icons.png

Word Completion

Word Completion kutsutaan Ctrl+W. Se näyttää kaikki lähdekoodieditorissa olevat sanat ja sitä voidaan käyttää myös ei-pascal-lähdekoodeissa, kommenteissa ja avainsanoissa.

Muutoin se toimii samoin kuin identifier completion.

Siirry Include määrittelyyn

"Siirry Include määrittelyyn" hyppää {$ I filename} -lauseen, jossa käytetään nykyistä tiedostoa.

Julkaise projekti

Luo kopion koko projektista. Jos halutaan lähettää jollekulle vain lähdekoodi ja kääntäjän asetukset niin tämä toiminto on ystäväsi.

Tavallinen projektihakemisto sisältää paljon tietoa. Suurinta osaa sitä ei tarvitse julkaista: .lpi-tiedosto voi sisältää istuntotietoja (kuten suljettujen yksiköiden varmenteen sijainti ja kirjanmerkit) ja projektin hakemisto sisältää paljon .ppu, .o-tiedostoja ja suoritettavan tiedoston. Voidaan luoda lpi-tiedoston, jossa on vain perustiedot ja vain lähdekoodi sekä kaikki alihakemistot sisältävä "Publish Project".


Light bulb  Huomaa: Versiosta 0.9.13 lähtien on uusi projektiasetus-vaihtoehto, jonka avulla voidaan tallentaa istunnon tiedot erilliseen tiedostoon tavallisesta .lpi-tiedostosta. Tämä uusi tiedosto päättyy .lps-laajennukseen ja sisältää vain istunnon tiedot, jotka jättävät .lpi-tiedoston paljon siistimmäksi.

Valintaikkunassa voidaan määrittää suodattimen tiettyjen tiedostojen sisällyttämiseksi ja sulkemiseksi pois. Komennolla voidaan pakata tuotos yhteen arkistoon.

Huomautuksia näytettävistä vihjeistä

Useilla kohdilla IDE näyttää vihjeitä tunnisteista. Esimerkiksi kun liikutetaan hiirtä tunnisteen päällä lähdekoodieditorissa ja odotetaan muutaman sekunti. Kun IDE näyttää vihjeenä tunnuksen, se etsii määrityksen ja kaikki sen esi-isät ja etsii kommentteja ja fpdoc-tiedostoja. On monia koodaustapoja ja monia kommentoitavia tyylejä. Monien yhteisten kommenttityylien tukemiseksi IDE käyttää seuraavia heuristiikkaa:

Comments shown in the hint

Comments in front of a declaration, without empty line and not starting with the < sign:

var
  {Comment}
  Identifier: integer;

Comments with the < sign belong to the prior identifier.

Comments behind an identifier on the same line:

var 
  identifier, // Comment
  other,

Comments behind the definition on the same line:

var
  identifier: 
    char; // Comment

An example for < sign:

const
  a = 1;
  //< comment for a
  b = 2;
  // comment for c
  c = 3;

All three comment types are supported:

  {Comment}(*Comment*)//Comment
  c = 1;

Comments not shown in the hint

Comments starting with $ or % are ignored. For example //% Hiddden, //$ Hidden, (*$ Hidden*).

Comments in front separated with an empty line are treated as not specific to the following identifier. For example the following class header comment is not shown in the hint:

type
  { TMyClass }
  
  TMyClass = class

The class header comments are created on class completion. You can turn this off in the Options / Codetools / Class completion / Header comment for class. If you want to show the header comment in the hint, just remove the empty line.

The following comment will be shown for GL_TRUE, but not for GL_FALSE:

  // Boolean
  GL_TRUE                           = 1;
  GL_FALSE                          = 0;

Quick Fixes

Quick Fixes are menu items for specific compiler messages. They help you to quickly fix the problem. Select a message in the Messages window and right click, or right click in the source editor on the icon to the left.

  • Unit not found: remove from uses section
  • Unit not found: find unit in loaded packages and allow to auto add package dependency
  • Constructing a class "$1" with abstract method "$2": show dialog to override all abstract methods
  • Local variable "$1" not used: remove definition
  • Circular unit reference between $1 and $2: show Unit Dependencies dialog with full path between the two units
  • Identifier not found: search via Code Browser
  • Identifier not found: search via Cody Dictionary (needs package Cody)
  • Identifier not found: add local variable
  • Recompiling $1, checksum changed for $2: show a dialog with search paths and other information
  • IDE warning: other sources path of package %s contains directory...: open package
  • any hint, note, warning: add IDE directive {%H-}
  • any hint, note, warning: add compiler directive {$warn id off} (since 1.7)
  • any hint, note, warning: add compiler option -vm<messageid>
  • Local variable "i" does not seem to be initialized: insert assignment (since 1.5)

Outline

Tämä asetus sijaitsee IDEn asetukset ikkunassa, Editori - Näkymä - Merkintä ja osumat - Outline (global).

Se korostaa Pascalin avainsanoja yhdistäen vastaavat begin - end parit. Tämä sallii isot sisäkkäiset lohkot Esimerkiksi vaikka tälläinen aliohjelman runko:

  with ADockObject do
  begin
    if DropAlign = alNone then
    begin
      if DropOnControl <> nil then
        DropAlign := DropOnControl.GetDockEdge(DropOnControl.ScreenToClient(DragPos))
      else
        DropAlign := Control.GetDockEdge(DragTargetPos);
    end;
    PositionDockRect(Control, DropOnControl, DropAlign, FDockRect);
  end;

Tuodaan korostaen esiin:

  • ulompi with-do-begin-end oranssin värisenä
  • seuraavan tason if-then-begin-end vihreän värisenä
  • sisempi if-then-else cyanin värisenä

ide outline.png