Difference between revisions of "Code Conversion Guide/sk"

From Lazarus wiki
Jump to navigationJump to search
 
m (Fixed syntax highlighting)
 
(34 intermediate revisions by 5 users not shown)
Line 1: Line 1:
Konverzia a prenos zdrojového kódu Delphi pre Lazarus
+
{{Code Conversion Guide}}
  
== About ==
+
Cieľom tejto príručky je zdokumentovať niektoré zo špecifických rozdielov , ktoré sa najčastejšie vyskytujú pri konverii počas prekladu existujúceho kódu z Delphi do Lazarus.
  
Tento článok je o konverzii existujúceho zdrojového kódu Delphi tak, aby pracoval s prekladačom [FreePascal|] Compiler a IDE Lazarus. Keďže Lazarus a Free Pascal majú spoločné črty s Delphi a Kylix, nejedná sa o klony. Existuje veľa rozdielov vo volaní knižníc a konvenčných rozdielov... a v niektorých oblastiach je Free Pascal rozšírený a môže byť viac náročný na správnu syntax. Pozrite si príručku [Lazarus for Delphi Users/sk], v ktorej nájdete popis niektorých funkčných rozdielov.  
+
Tento článok je o konverzii existujúceho zdrojového kódu Delphi alebo Kylix tak, aby pracoval s prekladačom [[Free Pascal]] a IDE Lazarus. Hoci majú Lazarus a Free Pascal spoločné črty s Delphi a Kylix, nejedná sa o ich klony. Existuje veľa rozdielov vo volaní knižníc a konvencii... a v niektorých oblastiach je Free Pascal rozšírený a môže byť náročnejší na správnu syntax. Pozrite si príručku [[Lazarus For Delphi Users/sk|Lazarus pre používateľov Delphi]], v ktorej nájdete popis niektorých funkčných rozdielov.  
  
The purpose of this guide is to document some of the specific differences that are frequently encountered during the code conversion process when translating existing code from Delphi to Lazarus.
+
Cieľom tejto príručky je zdokumentovať niektoré zo špecifických rozdielov, s ktorými sa často stretnete počas procesu konverzie kódu pri prekladaní existujúceho kódu z Delphi na Lazarus.
  
This document was placed into the wiki knowledge-base area so it could be easily extended by anyone who had encountered a unique problem and would like to post it for others to be aware of.  
+
Tento dokument bol umiestnený na Wiki aby mohol byť jednoducho rozšírený každým, kto sa stretol s unikátnym problémom a zverejní ho aj pre ostatných.  
  
== Selecting a component or library for conversion ==
+
==Výber komponentov alebo knižnice pre konverziu==
  
=== Where to find code to convert ===
+
===Kde hľadať kód na konverziu===
  
There is a LOT of code available on the net that can be converted for use with FPC and Lazarus. Here is a [PageOfCodeSites|] that is just a start. Please add to it if you know of any other good locations. Turbo-Power Software has recently released their entire commercial offering under the MPL. A list of available packages can be found [http://sourceforge.net/users/tpsfadmin/|here].
+
Na nete je dostupného veľa kódu, ktorý môže byť konvertovaný pre použitie s FreePascal a Lazarus. Tu je [[Page Of Code Sites | Stránka kódov]], ktorá je dobrým začiatkom. Prosím vás, pridajte na do nej, ak poznáte nejaký iný dobrý odkaz. Turbo-Power Software uvoľnil ich celú ponuku pod MPL. Zoznam dostupných balíčkov môžete nájsť na [http://sourceforge.net/users/tpsfadmin/ Sourceforge].
  
To avoid duplicating effort, packages that have already been converted are listed on the [CodeAndComponents|] page. If you've converted a package or are working on one, please add a note on the [CurrentProjects|] page.
+
Aby sme predišli duplicitným snahám, balíčky, ktoré už sú konvertované sú vypísané na stránke [[Components and Code examples]]. Ak ste prekonvertovali balíček alebo na nejakom pracujete, pridajteprosím poznámku na stránku [Current Projects].
  
=== Licensing ===
+
===Licencovanie===
  
Licenses for existing code range from freeware/public domain to restrictive versions that prohibit modification, re-distribution and commercial use. Before converting any package, it's a good idea to examine its licensing and make sure it's going to be compatible with Lazarus and the Free Pascal Compiler. License selection is especially important with components since dropping one on a form can impose an unwanted or incompatible license on an entire application.
+
Licencie existujúceho kódu siahajú od freeware/public domain po reštriktívne verzie, ktoré bránia modifikácii, redistribúcii a komerčnému použitiu. Pred konverziou každého balíčka, je dobré preskúmať jeho licenciu a zaistiť, že je kompatibilná s Lazarus a Free Pascal. Výber licencie je veľmi dôležitý pri komponentoch, pretože umiestnenie jedného na formulár môže navodiť nechcenú alebo nekompatibilnú licenciu na celú aplikáciu.
  
When converting components, please respect the wishes of the original author and retain all copyright and licensing headers along with email addresses and url's. It's courteous and often useful to inform the author that their component is being converted... especially if the component is under a restrictive license.  New interest in an old or forgotten component can sometimes inspire authors to revise their original and overly restrictive licensing.
+
Keď konvertujete komponenty, rešopektujte prosím elanie pôvodného autora a ponechajte všetky copyrighty a licenčné hlavičky spolu s emailovou adresou a url. Je slušné a často i užitočné informovať autora, že jeho komponent je konvertovaný... hlavne ak je komponent pod obmedzujúcou licenciou. Nový záujem o staré alebo zabudnuté komponenty môže často podnietiť autora na revíziu originálu a zmeniť reštriktívnu licenciu.
  
In general, Public Domain (freeware), and the LGPL/MPL are the the most flexible for distributing components. For more information, the [http://www.opensource.org/docs/definition.php Open Source Definition] is a good place to start. There are also several comparisons available to help clarify how the various types of licenses work and what impact they'll have on code they're linked to. Search for "open source license comparison"
+
Vo všeobecnosti, Public Domain (freeware) a LGPL/MPL sú najprispôsobiteľnejšie pre distribúciu komponentov. Dobrým začiatkom pre nájdenie ďalších informácií môže byť [http://www.opensource.org/docs/definition.php definícia Open Source]. Existuje niekoľko porovnaní, ktoré môžu pomôcť objasniť ako pracujú rôzne typy licencií a aký budú mať dosah na kód, ku ktorému patria. Hľadajte "open source license comparison".
  
=== Dependencies ===
+
===Závislosti ===
  
Another step before starting to work on a conversion is to verify that the code doesn't have deep dependancies on other packages that might not be available or represent a considerable conversion challenge. Some freeware offerings are bound to or extend proprietary packages that are frequently no longer available or come with inappropriate licenses.
+
Ďalším krokom pred začatím práce na konverzii je overiť si, že kód nie je závislý na na iných balíčkoch, ktoré možno nemáte alebo predstavujú veľkú výzvu pre konverziu. Niektoré ponuky freeware sú obmedzené alebo rozšírené vlastnené balíčky, ktoré často nie sú dostupné alebo prichádzajú s nevhodnou licenciou.
  
=== Compiler Issues ===
+
===Poznámky k prekladaču===
  
Currently the stable 1.0.x version of the Free Pascal Compiler doesn't support interfaces, threads or Variant records. If the code you're converting needs these constructs, you'll have to use the 1.1 development branch of the compiler... which isn't always guaranteed to work with Lazarus.
+
Viz:
 +
* [http://www.freepascal.org/probs.html Známe problémy]
 +
* [http://www.freepascal.org/bugs/db.php3?statusfield=Unfixed Neopravené chyby]
  
=== Platform and OS Issues ===
+
===Poznámky k platforme a OS===
  
Lazarus and the Free Pascal Compiler are cross-platform and cross-architecture development tools. In contrast, most existing Delphi code was specifically designed to run on an Intel processor under Win32. If your candidate component has a lot of Win32 specific code, it might be wise to try and find a less platform dependant alternative. But don't let this stop you... it's genuinely amazing what the LCL supports!
+
Lazarus a Free Pascal sú nadplatformové a nadarchitektúrne vývojové nástroje. Naopak, väčšina existujúceho kódu Delphi bola špecificky navrhnutá pre beh na procesore Intel a s Win32. Ak má Váš komponent veľa špecifického kódu Win32, bude možno múdrejšie skúsiť nájsť alternatívu, ktorá je menej závislá na platforme. Ale nenechajte sa tým zastaviť... je naozaj prekvapujúce čo všetko LCL podporuje!
  
== Doing the conversion ==
+
==Konverzia ==
  
=== Setting up the Lazarus environment for a conversion project ===
+
===Nastavenie IDE Lazarus pre konverziu projektu===
  
====Create a test project====
+
====Vytvorenie skúšobného projektu====
* Place code to be converted into a subdirectory (ie: convertdir)
+
* Umiestnite konvertovaný kód do podadresára (napr: convertdir)
* Bring up Lazarus
+
* Spusťte Lazarus
* File->Save All to the convertdir subdirectory. Meaningful names for the Project and default unit are optional.
+
* '''File->Save All''' do adresára convertdir. Zmysluplné mená pre Project a predvolenú jednotku sú voliteľné.
* Open the "main" unit to be converted in convertdir
+
* Otvorte "základnú" konvertovanú jednotku v convertdir
* Add it to the project: Project->Add Active Unit to Project
+
* Pridajte ju do projektu: '''Project->Add Active Unit to Project'''
* Run Tools->Quick Syntax Check or Run Build All to get started.
+
* Spusťte '''Tools->Quick Syntax Check''' alebo '''Run->Build All''', čím začnete.
====Initial items to watch out for====
 
* Filenames are case sensitive with the 1.0.x series compilers. If you're working with this version, make all your filenames lower case. You'll get "File not found" errors if you don't.
 
====Delphi VCL, Kylix CLX Sources in Lazarus====
 
  
When converting Delphi/Kylix sources, it is often useful to do a find declaration to see, what a specific function is doing. The Lazarus IDE can parse the Delphi/Kylix sources. To do this it needs some searchpaths and compiler settings. You can easily setup this in
+
====Na čo treba dať pozor====
Environment->CodeTools Defines Editor->Insert Template
+
* Mená súborov sú citlivé na veľkosť pri prekladačoch série 1.0.x. Ak pracujete s touto verziou, premenujte všetky súbory malými písmenami. Ak to neurobíte, ľahko dostanete chybové hlásenie '''File not found'''.
 +
====Zdrojové kódy Delphi VCL a Kylix CLX v Lazarus====
 +
Pri konverzii zdrojových kódov Delphi/Kylix, je často užitočné použiť '''Find declaration''', aby ste sa presvedčili, či daná funkcia funguje. IDE Lazarus môže analyzovať zdrojové kódy Delphi/Kylix. Na to potrebujete nastaviť niektoré cesty a nastavenia prekladača. Jednoducho to môžete nastaviť pomocou '''Environment->CodeTools Defines Editor->Insert Template'''.
  
=== Conversion problems and solutions ===
+
===Problémy konverzie a ich riešenie ===
  
==== Converting Delphi forms/units to Lazarus ====
+
==== Ekvivalenty Delphi/Kylix súborov v Lazarus ====
  
Many existing Delphi forms can be converted to work with Lazarus by using the IDE's built in DFM to LFM form converter. It can be found under the Tools menu item as "Convert DFM file to LFM". Bring up the file dialog, select the dfm and the converter will do the rest.
+
{|border="1" width="800" 
 +
! Delphi / Kylix !! Popis !! Lazarus !! Popis
 +
|-
 +
|valign="top"| .pas
 +
 +
.dfm/.xfm,
  
If you need to convert the whole unit (with or without a form), Lazarus also includes a built in "Convert Delphi unit to Lazarus unit" which will do the following for you -
+
.dcu/.dpu,
  
# renames the .pas and .dfm file to lowercase.
+
.dpr(main project file),
# converts .dfm file to .lfm file (currently without content check, just format)
 
# creates an empty .lrs file (the content will be created later)
 
# adds <div class="dir">{$mode delphi}</div> directive
 
# replaces windows unit with LCLIntf
 
# adds LResources unit if needed
 
# removes variants unit
 
# removes <div class="dir">{$R *.dfm}</div> directive
 
# adds initialization section and <div class="dir">{$i unit.lrs}</div> directive
 
  
This allows quick and easy conversion of most units from Delphi format to Lazarus format. It does not do any validity check, or automatic syntax changes, so any syntax changes you need to make, additional unit/unit name changes, or dfm/pas changes for control/component differences you must still do manually, though in time some wizards to help facilitate some of this, especially the repairing of converted forms(lfm), may become available.
+
.res,
  
==== Selecting the right compiler mode ====
+
.dof/.kof
  
The [FreePascal|] Compiler supports 5 different pascal modes. For example TP for turbo pascal, lets you compile turbo pascal units. There is also a DELPHI compatibility mode that can be set to make existing code easier to convert. Lazarus prefers the OBJFPC mode, which almost the DELPHI mode, but less ambigious than the Delphi syntax. Here are the important points:
+
---
  
The mode can be selected at command line or at the start of the source. Using the command line has the advantage, that you don't need to change the source, but the disadvantage, that others must be told.
+
---
  
Most Delphi units can be compiled by the [[Free Pascal]] compiler by adding
+
---
 +
 
 +
|valign="top"| súbor zdrojového kódu Delphi,
 +
 
 +
formulár Delphi,
 +
 
 +
preložená jednotka Delphi,
 +
 
 +
projekt Delphi,
 +
 
 +
Resource súbor Windows,
 +
 
 +
súbor volieb Delphi
 +
 
 +
|valign="top"| .pas, .pp
 +
.lfm,
 +
 
 +
.o,
 +
 
 +
.lpr
 +
 
 +
---
 +
 
 +
---
 +
 
 +
.lrs,
 +
 
 +
.lpi(hlavný súbor projketu),
 +
 
 +
.ppu
 +
 
 +
|valign="top"| súbor jednotky Pascal,
 +
 
 +
dátový súbor formulára,
 +
 
 +
súbor preloženej jednotky,
 +
 
 +
súbor projektu,
 +
 
 +
Resource súbor,
 +
 
 +
súbor volieb projektu,
 +
 
 +
Resource súbor Lazarus,
 +
 
 +
informačný súbor projektu Lazarus,
 +
 
 +
popisný súbor jednotky FPC
 +
|}
 +
 
 +
Teda súbor Delphi .dcu zhruba korenšponduje so súbormi FPC .o a .ppu spolu v jednom súbore. Súbor .PPU je prevažne hlavičková (interface) časť, the .o prevažne časť implementation. Hlavnou výnimkou sú inlined funkcie, ktoré vo forme to-be-inlined v .ppu.
 +
 
 +
====Konverzia projektov/formulárov/jednotiek Delphi do Lazarus====
 +
 
 +
Premenujte alebo prekopírujte súbor .dpr na súbor .lpr. Zakomentujte alebo odstráňte direktívu
 +
{$R *.res}
 +
a pridajte direktívu
 +
{$mode delphi}{$H+}
 +
alebo
 +
{$mode objfpc}{$H+}
 +
do súboru .lpr.
 +
 
 +
S touto konverziou Vám môže pomôcť Lazarus IDE prostredníctvom položky menu '''Tools menu>Convert Delphi Project to Lazarus Project'''. Vyžiada si zadanie súboru .dpr (projekt Delphi) a skonvertuje ho na .lpr, ďalej vytvorí súbor .lpi a skonveruje všetky jednotky.
 +
 
 +
Mnoho existujúcich formulárov Delphi môžete konvertovať pomocou IDE Lazarus pomocou zabudovaného konvertora formulárov DFM na LFM. Nájdete ho v menu '''Tools->Convert DFM file to LFM'''. Vyvolajte súborový dialóg, vyberte *.dfm a konvertor urobí zvyšok.
 +
 
 +
Ak potrebujete konvertovať celú jednotku (s alebo bez formulára), Lazarus má tiež zabudovaný nástroj: '''Convert Delphi unit to Lazarus unit''', ktorý urobí nasledujúce:
 +
 
 +
# upraví veľkosť písmen v sekciách uses a iclude.
 +
# konvertuje súbory .dfm na súbory .lfm (bez kontroly obsahu, len formát)
 +
# vytvorí prázdny súbor .lrs (obsah bude pridaný neskôr)
 +
# pridá direktívu
 +
{$mode delphi}
 +
# nahradí jednotku Windows jednotkou LCLIntf
 +
# ak je to potrebné, pridá jednotku LResources
 +
# odoberie jednotku Variants
 +
# odoberie direktívu
 +
{$R *.dfm}
 +
# pridá do sekcie initialization direktívu
 +
{$i unit.lrs}
 +
 
 +
Toto umožní rýchlu a ľahkú konverziu väčšiny jednotiek z formátu Delphi do formátu Lazarus. Tento nástroj nevykonáva žiadnu kontrolu platnosti alebo automatické zmeny syntaxe, tak všetky potrebné zmeny syntaxe, dodatočné zmeny jednotiek, alebo zmeny dfm/pas pre rozdiely v prvkoch/komponentoch, musíte urobiť manuálne, pomocou niekoľkých sprievodcov, ktorý vám pomôžu niektoré kroky, hlavne opravovanie konvertovaných formulárov (lfm).
 +
 
 +
====Výber správneho módu prekladača====
 +
 
 +
Prekladač [[Free Pascal]] podporuje 5 rôznych módov Pascalu. Napríklad TP pre Turbo Pascal, vám dovolí prekladať jednotky Turbo Pascal. Má i mód pre kompatibilitu s DELPHI, ktorý môžete nastaviť na uľahčenie konverzie kódu. Lazarus preferuje mód OBJFPC, ktorý je skoro ako mód DELPHI, ale bez mnohoznačnosti syntaxe Delphi. Tu sú dôležité body:
 +
 
 +
Mód môže byť zvolený na príkazovom riadku alebo na začiatku zdrojového kódu. Použitie príkazového riadku má výhodu, že nemusíte meniť zdrojový kód, ale i nevýhody, ktoré musia vysvetliť iní.
 +
 
 +
Väčšinu jednotiek Delphi môžete jednoducho preložiť pomocou [[Free Pascal]] pridaním tejto konštrukcie, hneď za meno jednotky
 
  {$IFDEF FPC}
 
  {$IFDEF FPC}
 
   {$MODE DELPHI}
 
   {$MODE DELPHI}
 
  {$ENDIF}
 
  {$ENDIF}
right after the unit name.
 
 
For more details about [[Free Pascal]] modes see the [http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html Free Pascal Documentation]
 
 
==== Cross-Platform considerations ====
 
  
* Inline assembler is always a problem because it will bind the code to the Intel architecture. Some developers do algorithm prototypes in Pascal and ifdef the their optimized assembler. Fortunately Turbo-Power did this in numerous places with their code. If this is the case with the package you're converting, throw the switch back to Pascal.
+
Ďalšie podrobnosti o módoch [[Free Pascal]] nájdete v [http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html dokumentácii Free Pascal].
* Don't reference specific memory location like the BIOS data area. Find out what the code needs and try to find a cross platform alternative.
 
* Don't do processor specific tricks (like using the Intel TSC) without enclosing your code in an ifdef for the platform the code needs... and providing an alternative for environments that don't have the hardware capability.
 
* If you need some OS specific code, than you can use IFDEFs. See below for a list of macros.
 
  
==== Useful compiler variables ====
+
====Viac-platformové poznámky====
 +
* Zahrnutý assembler býva vždy problémom, pretože zväzuje kód s architektúrou Intel. Niektorí vývojári robia prototypy algoritmov v Pascale a pomocou '''ifdef''' vkladajú oprimizovaný assembler. Našťastie Turbo-Power toto urobil na mnohých miestach svojho kódu. Ak je toto prípad balíčka, ktorý chcete konvertovať, prepnite ho späť do Pascalu.
 +
* Neodkazujte na špecifické pamäťové miesto, ako dátová oblasť BIOS. Zistite čo kód potrebuje a skúste nájsť cezplatformovú alternatívu.
 +
* Nepoužívajte triky, ktoré sú špecifické pre procesor (ako použitie Intel TSC) bez zatvorenia svojho kódu do '''ifdef''' pre platformu potrebnú pre kód... a poskytnutia alternatívy pre prostredia, ktoré nie sú hardvérovo kompatibilné.
 +
* Ak potrebujete nejaký kód, špecifický pre OS, používajte '''IFDEF'''. Viz zoznam makier neskôr.
  
To write code, that behaves on different systems differently, you can use the <div class="dir">{$IFDEF Name}</div> directives.
+
====Užitočné premenné prekladača====
  
* <div class="dir">{$IfDef LCL}</div>
+
Pre písanie kódu, ktorý sa má správať na rôznych systémoch rôzne, môžete použiť direktívy
This variable is defined, when using the LCL package. Useful to write code, that works with the LCL and Delphi.
+
{$IFDEF Name}
* <div class="dir">{$IfDef FPC}</div>
+
Pričom Name môže byť
This variable is defined, when using the FPC compiler. Useful to write code, that works with FPC and Delphi.
+
*'''LCL''' - táto premenná je definovaná pri použití balíčka LCL a je vhodná pre písanie kódu, ktorý pracuje s LCL a Delphi.
* <div class="dir">{$IfDef Unix}</div>, <div class="dir">{$IfDef Win32}</div>, ...
+
{$IfDef LCL}
Defined by FPC for the current Target OS. Delphi defines "Linux", "Win32" and "MSWindows". [[Free Pascal]] runs on much more platforms and so it is recommended to use the more general items. For example "Unix" is defined for Linux, FreeBSD, NetBSD and OpenBSD, where Lazarus already runs.
+
*'''FPC''' - táto premenná je definovaná pri použití prekladača Free Pascal a je vhodná pre písanie kódu, ktorý pracuje s Free Pascal a Delphi.
Use
+
{$IfDef FPC}
 +
*'''LCLGtk''', '''LCLWin32''', '''LCLQt''', ... - tieto premenné sú definované keď je použitý balíček LCL a špecifický WidgetSet. Užitočné pre písanie kódu, pracuje s LCL na určitej platforme.
 +
{$IfDef LCLGtk}
 +
{$IfDef LCLWin32}
 +
{$IfDef LCLQt}
 +
...
 +
*'''Unix''', '''Win32''',... -  tieto sú definované pre cieľový OS. Delphi definuje '''Linux''', '''Win32''' a '''MSWindows'''. [[Free Pascal]] beží na oveľa väčšom počte platforiem a tak je vhodné použiť oveľa všeobecnejšie položky. Napríklad '''Unix''' je definované pre Linux, FreeBSD, NetBSD a OpenBSD, na ktorých už Lazarus beží.
 +
{$IfDef Unix}
 +
{$IfDef Win32}
 +
...
 +
: Pre prácu v Kylix použite nasledujúcu konštrukciu:
 
  {$IfDef Linux}
 
  {$IfDef Linux}
 
   {$Define Unix}
 
   {$Define Unix}
 
  {$EndIf}
 
  {$EndIf}
to work around this for Kylix.
+
*'''ENDIAN_BIG''' - táto premenná je definovaná na procesoreoch ako PowerPC (napr. staré počítače Apple, tj. do MacOSX 10.2), ktoré majú obrátené poradie ako Intel kompatibilné procesory.
 +
{$IfDef ENDIAN_BIG}
 +
 
 +
Ďalšie podrobnosti nájdete v [http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21 dokumentácii Free Pascal].
 +
 
 +
==== Podpora 32bit/64bit ====
 +
 
 +
Ukazovatele pod 64bit potrebujú 8 bajtov namiesto 4 na 32bit. Typ 'Integer' zostáva pre kompatibilitu s 32bit. To znamená, že už nepotrebujete pretypovanie ukazovatele na integer a naopak. FPC definuje dva nové typy:
 +
*'''PtrInt''' je 32bit Integer so znamienkom na 32bit platformách a 64bit Integer sp znamienkom na 64bit platformách.
 +
*'''PtrUInt''', je rovnaké ako predchádzajúce s tým rozdielom, že sa jedná o Integer bez znamienka.
 +
 
 +
Pre kód, ktorý má pracovať s Delphi a FPC použite:
 +
  {$IFNDEF FPC}
 +
  type
 +
    PtrInt = integer;
 +
    PtrUInt = cardinal;
 +
  {$ENDIF}
  
For more details see the [http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21 Free Pascal Documentation].
+
Nahrďte všetky
 +
integer(SomePointerOrObject)
 +
týmto
 +
PtrInt(SomePointerOrObject)
  
==== Finding a missing identifier ====
+
====Hľadanie chýbajúcich identifikátorov====
  
There are differences in how the LCL is organized when compared to the Delphi VCL. If you get a "not found" compiler error about a major class or identifier, the chances are good that it's in a different unit. A complete cross reference can be found by grep'ing lazarus/docs/xml or the lcl subdirectory.
+
V organizácii LCL, v porovnaní s Delphi VCL, sú rozdiely. Ak sa stretnete s chybovým hlásením prekladača '''not found''' pri významných triedach alebo identifikátoroch, je veľká šanca, že je v inej jednotke. Úplný rížový odkaz môžete nájsť pomocou programu '''grep''' na  lazarus/docs/xml alebo na podadresár lcl.
  
For example the commonly used tbutton typically throws an error in Delphi code because it's located in a unit named buttons.pp. The following command finds the correct unit very quickly (in the lazarus source directory):
+
Napríklad bežne používaný '''TButton''' vyvoláva v kóde Delphi chybu, pretože je umiestnený v jednotke '''buttons.pp'''. Tento príkaz nájde správnu jednotku veľmi rýchlo (v adresári zdrojového kódu Lazarus):
  
 
   grep -in ' tbutton =' lcl/*
 
   grep -in ' tbutton =' lcl/*
  
 +
====Rozdiely v dôležitých jednotkách Lazarus a Delphi ====
  
==== Major unit differences between Lazarus and Delphi ====
+
;Prosím dopĺňajte túto časť!;
  
** Please add to this topic! **
+
* Windows -> LCLIntf, LCLType, LCLProc, VCLGlobals, ...
  
* Windows->LCLIntf, LCLType, LCLProc, VCLGlobals, ...)
+
Keďže LCL nie je špecificky Windowsová knižnica, kód, ktorý je v jednotke Windows z Delphi pre priamy prístup k Win32 API je  abstrahovaný do samostatných rozhraní, do ktorých môžete pristupovať z jednotky '''LCLIntf'''. Majte na pamäti, že Lazarus neemuluje Win32, tak veľa funkcií cýba a niektoré nepracujú ako ich Win32 náprotivky. Tieto funkcie existujú len pre kompatibiltu s Delphi a sú určené len pre rýchly a (s)prostý prenos. LCL tiež tiež nemá mnoho z typov, tak je často potrebná jednotka '''LCLType''' a niekedy aj '''VCLGlobals'''. '''LCLProc''' tiež obsahuje niekoľko funkcií, ktoré môžu byť užitočné pre najnižšiu úroveň obslúh ako '''FreeThenNil''', '''DeleteAmpersands''' na odstránenie dodatočných ampersandov z reťazcov pre ovládacie prvky (& - && atď).
  
As the LCL is not windows specific, the code that is in the Delphi Windows unit for directly accessing the Win32 API is abstracted into seperate interfaces, which can be accessed from the LCLIntf unit. Keep in mind, that Lazarus does not emulate win32, so many functions are missing and some do not work as their win32 counterparts. These functions only exist for Delphi compatibility and should only be used for quick & dirty porting. LCL also breaks out many of the types, so often LCLType, and sometimes VCLGlobals are required. LCLProc also contains a few functions which can be usefull for lower level handling such as "FreeThenNil" as is in Delphi 5 and higher, "DeleteAmpersands" to remove additional ampersands from a string for controls(& vs && etc).
+
Jednotka '''Interfaces''' musí byť zahrnutá v súbore .lpr file pre správnu inicializáciu príslušného WidgetSet.
  
 
* Messages->LMessages
 
* Messages->LMessages
  
TControl Messages for win32 event callbacks of the format WM_CALLBACK and the structs associated with them are often found in the Messages unit in Delphi. In the LCL these types of messages and there structs are usually found in LMessages, usually with name changes of WM to LM, so for instance WM_MOUSEENTER becomes LM_MOUSEENTER, and TWMMouse becomes TLMMouse.
+
Správy TControl pre spätné volania (callbacks) udalostí Win32 vo formáte WM_CALLBACK a ich príslušná štruktúra je väčšinou umiestnená v jednotke Messages v Delphi. V LCL tieto typy správ a ich štruktúry zvyčajne nájdete v LMessages, zvyčajne premenované z WM_ na LM_, tak sa napríklad WM_MOUSEENTER stáva '''LM_MOUSEENTER''', a TWMMouse sa stáva '''TLMMouse'''.
  
 
* Graphics, Controls->GraphTypes, GraphMath, Graphics, Controls
 
* Graphics, Controls->GraphTypes, GraphMath, Graphics, Controls
  
To simplify some things and break complexity of circles between units, a few types have been abstracted into a shared unit called GraphType, which includes things, which in Delphi are located in Graphics or Controls, for instance the bvNone etc of panels. So sometimes you have to include it. Also a unit which, although incompatible with Delphi, adds other usefull functionality is GraphMath, which adds a TFloatPoint for precision, misc routines for dealing with beziers, lines, and arcs, as well as some operator overloading for use with TPoints and TRect, such as for instance Point1 := Point2 + Point3, and comparing two rects like if (rect1 = rect2) then ...
+
Na zjednodušenie niektorých vecí a prerušenie zložitosti krúženia medzi jednotkami, sú abstrahované niektoré typy do zdieľanej jednotky, zvanej GraphType, ktorá zahŕňa potreby, ktoré sú v Delphi umiestnené v jednotkách '''Graphics''' alebo '''Controls'''. Tak ju niekedy budete potrebovať zahrnúť, rovnako ako jednotku '''GraphMath''', ktorá, hoci nekompatibilne s Delphi, pridáva ďalšie užitočné funkcie, ako TFloatPoint pre presnosť, užitožné rutiny pre spoluprácu s bezériovými krivkami, čiarami a oblúkmi, ako aj perťažené operátory pre použitie s typmi TPoints a TRect, ako napr.
 +
 
 +
Point1 := Point2 + Point3
 +
 
 +
či porovnanie dvoch pravouholníkov ako
 +
 
 +
if (rect1 = rect2) then ...
  
 
* Mask->MaskEdit
 
* Mask->MaskEdit
  
For more intelligent naming considerations, the unit for TMaskEdit is called [MaskEdit|] instead of the slightly more nebulous Mask as in many versions of Delphi.
+
Kvôli inteligentnejšej názvovej úvahe, je jednotka pre '''TMaskEdit''' nazvaná [Mask Edit] na rozdiel od tochu nešikovného '''Mask''', ako tomu je v mnohých verziách Delphi.
  
 
* StdCtrls->StdCtrls,Buttons
 
* StdCtrls->StdCtrls,Buttons
  
In many version of Delphi TButton is located in StdCtrls, while TSpeedButton and TBitBtn are in Buttons. For consistency and simplicity the LCL puts all button types in Buttons, which can occasionally break code conversion, so it is always a good idea to include.
+
V mnohých verziách Delphi je TButton umiestnený v '''StdCtrls''', zatiaľ čo TSpeedButton a TBitBtn sú v '''Buttons'''. Pre zjednodušenie vkladá LCL všetky tlačítka do '''Buttons''', čo môže niekedy sťažiť konverziu, preto je vhodné túto jednotku vždy zahrnúť.
 +
 
 +
====Rozdiely vo vlastnostiach a metódach Delphi -> FPC/LCL ====
 +
* v LCL je Canvas obsahnutý v TBitmap
 +
====Sémantické rozdiely ====
 +
 
 +
===== Poradie vyhodnocovania parametrov =====
 +
 
 +
Delphi garantuje, že všetky parametre sú vyhodnocované z ľava do prava. FPC takúto garanciu neposkytuje a môže vyhodnocovať parametre v ľubovoľnom poradí, kvôli generovaniu optimálneho kódu.
 +
 
 +
===== Vnorené procedúry/funkcie sú procedurálne premenné =====
 +
 
 +
Delphi posiela framepointer rodičovskej procedúry vždy do zásobníka a vždy volá ich opätovné odstránenie. To znamená, že ak pokiaľ nepristupujute k premenným rodičovskej procedúry, môžete poslať adresu vnorenej procedúry do inej funkcie, ktorá ich potom môže volať ako každú procedurálnu premennú.
 +
 
 +
FPC vždy posiela framepointer rodičovskej procedúry ako skrytý prvý parameter, podľa aktuálnej konvecie volania, čiže ak voláte vnorenú procedúru ako bežnú procedurálnu premennú, všetky parametre budú posunuté o jednu pozíciu.
  
 +
Inými slovami, nevolajte vnorené procedúry pomocou procedurálnych premenných.
  
==== Property and method differences Delphi -> FPC/LCL ====
+
==== Syntaktické rozdiely ====
* TBitmap contains a canvas in the LCL
 
==== Syntax differences ====
 
  
'''Please add to this topic!'''
+
;Prosím dopĺňajte túto kapitolu!
  
Because of the inherent strictness in FPC, some syntax changes are necessary, even though !!;dir {$Mode Delphi}!!;! does allow more lazyness like Delphi does. For this reason complying as much with the syntax rules of !!;dir {$Mode ObjFPC}!!;! as possible is highly recommended, even when the codebase is still going to be shared between Delphi and the LCL. Some of these are simply better coding practises, and sometimes because occasionally Delphi mode is not entirely accurate, or in a few instances Delphi acceptible code does not function as expected with FPC, even though it might compile. To that end even though not all such are strictly required, the following list of changes should be considered mandatory :
+
Kvôli zdedenej prísnosti FPC, budú potrebné niektoré syntaktické zmeny, napriek direktíve
 +
{$Mode Delphi}
 +
pracuje oveľa pomalšie ako Delphi. Kvôli tomu oveľa viac vyhovujú pravidlá syntaxe
 +
{$Mode ObjFPC}
 +
ak je to možné, vrelo doporučujem, dokonca i keď bude kód zdieľaný medzi Delphi a LCL.
  
;Variables initialization in FPC 1.0.x
+
Niektoré z týchto sú jednoducho lepšie praktiky kódovania a niekedy pretože mód Delphi nie je celkom presný, alebo v niektorých prípadoch kód akceptovaný Delphi nefunguje podľa očakávania s Free Pascal, hoci môže byť preložený. Tkže nakoniec nie všetky sú presne vyžadované, nasledujúci zoznam zmien vždy zvážte:
  
With Delphi it is possible (and quite common) to initialize a variable in its declaration, however this is not possible in FPC 1.0.x, const must be used instead, or prefereably in many situations, initialized elsewhere at some point before the variable is used (like unit initialization).
+
=====Pri priraďovaní vstupného bodu obsluhy udalosti, pridajte predponu "@"=====
  
For example -
+
Napríklad, môžete manuálne priradiť udalosť tlačítka
{| class="code"
+
{| border="1" width="800"
|- 
+
! Delphi !! OBJFPC
| class="header" | Delphi || class="header" | FPC
+
|-
|- class="code"
+
|<syntaxhighlight lang="pascal">
| class="code" | <div class="key">var</div>
+
begin
  MyObject: TSomeObject= <div class="key">nil</div>;
+
  if not Assigned(MyButton.OnClick) then
  <div class="cmt">//More code...</div>
+
    MyButton.OnClick:= SomeFunction;
<div class="key">implementation</div>
+
    //@ nie je vyžadované
  <div class="cmt">//More code...</div>
+
    //ďalší kód...
<div class="key">initialization</div>
+
end;
  <div class="cmt">//More code...</div>
+
</syntaxhighlight>
<div class="key">end</div>.
+
|<syntaxhighlight lang="pascal">
| class="code" | <div class="key">var</div>
+
begin
  MyObject<div class="symbol">:</div> TSomeObject;
+
  if not Assigned(MyButton.OnClick) then
  <div class="cmt">//More code...</div>
+
    MyButton.OnClick:= @SomeFunction;
<div class="key">implementation</div>
+
    //@ je vyžadované
  <div class="cmt">//More code...</div>
+
    //ďalší kód...
<div class="key">initialization</div>
+
end;
  MyObject:= <div class="key">nil</div>;
+
</syntaxhighlight>
  <div class="cmt">//More code...</div>
 
<div class="key">end</div>.
 
 
|}
 
|}
  
;When assigning an event handling entry point, prefix it with an "@"
+
=====Pri volaní procedurálnej premennej používajte túto syntax: theprocname()=====
  
For instance, you might assign a button callback manually
+
V Delphi nie je rozdiel medzi výsledkom funkcie a premennou, ale v FPC je. Preto volanie function, hoci aj nemá parametre, musí obsahovať zátvorky. Napríklad
{| class="code"
+
{| border="1" width="800"
|- 
+
! Delphi !! OBJFPC
| class="header" | Delphi || class="header" | FPC
+
|-
|- class="code"
+
|<syntaxhighlight lang="pascal">
| class="code" | <div class="key">begin</div>
+
With (SomeObject) do
  <div class="key">if not</div> Assigned(MyButton.OnClick) <div class="key">then</div>
+
begin
    MyButton.OnClick:= SomeFunction; <div class="cmt">//@ not required</div>
+
  If Assigned(OnMyCallback) then
  <div class="cmt">//more code...</div>
+
    OnMyCallback;
<div class="key">end</div>;
+
    //zátvorky nie sú vyžadované
| class="code" | <div class="key">begin</div>
+
end;
  <div class="key">if not</div> Assigned(MyButton.OnClick) <div class="key">then</div>
+
</syntaxhighlight>
    MyButton.OnClick:= @SomeFunction; <div class="cmt">//@ IS required</div>
+
|<syntaxhighlight lang="pascal">
  <div class="cmt">//more code...</div>
+
With (SomeObject) do
<div class="key">end</div>;
+
begin
 +
  If Assigned(OnMyCallback) then
 +
    OnMyCallback();
 +
    //zátvorky sú vyžadované
 +
end;
 +
</syntaxhighlight>
 
|}
 
|}
  
;When calling a procedure variable use this syntax: theprocname()
+
===== Pri pristupovaní k hodnotám v ukazovateli na záznam ho musíte najprv dereferencovať =====
 +
 
 +
V Delphi nie je nutné dereferencovať ukazovateľ na záznam pre prístup k hodnotám v ňom, môže byť spracovaný presne ako záznam samotný, či iný objekt.
  
In Delphi there is no difference between a procedure and a procedure variable,  however there is in FPC, so to call a procedure, even if it has no paramaters, you must append parenthesis. For Example -
+
V FPC musí byť najprv dereferencovaný, napríklad:
{| class="code"
+
{| border="1" width="800"
|- 
+
! Delphi !! OBJFPC
| class="header" | Delphi || class="header" | FPC
+
|-
|- class="code"
+
|<syntaxhighlight lang="pascal">
| class="code" | <div class="key">With</div> (SomeObject) <div class="key">do begin</div>
+
Function GetSomeValue(ARecord: PMyRecord):Integer;
  <div class="key">If</div> Assigned(OnMyCallback) <div class="key">then</div>
+
begin
    OnMyCallback; <div class="cmt">//parenthesis not required</div>
+
  If Assigned(ARecord) then
<div class="key">end</div>;
+
    Result:=ARecord.SomeValue
| class="code" |  <div class="key">With</div> (SomeObject) <div class="key">do begin</div>
+
  else
  <div class="key">If</div> Assigned(OnMyCallback) <div class="key">then</div>
+
    Result:=0;
    OnMyCallback(); <div class="cmt">//parenthesis  required</div>
+
end;
<div class="key">end</div>;
+
</syntaxhighlight>
 +
|<syntaxhighlight lang="pascal">
 +
Function GetSomeValue(ARecord: PMyRecord):Integer;
 +
begin
 +
  If Assigned(ARecord) then
 +
    Result:=ARecord^.SomeValue
 +
  else
 +
    Result:=0;
 +
end;
 +
</syntaxhighlight>
 
|}
 
|}
  
;When accessing values in a pointer to a record you must dereference first
+
=====Pri pristupovaní znakov indexovaného reťazca Vlastnosti objektu, musí byť najprv uzatvorený v zátvorkách =====
 +
 
 +
V Delphi je možné spracovať Vlastnosť priamo ako každú inú konštantu alebo premennú, dokonca i pre prístup k jednotlivým znakom reťazca priamo.
 +
 
 +
V FPC toto nie je možné, hlavne pre indexované vlastnosti. Namiesto toho to musí byť uzatvorené v zátvorkách , kvôli jednoznačnosti. Hoci to nie je vždypravda, je to dobrý zvyk na zváženie. Napríklad
 +
{| border="1" width="800"
 +
! Delphi !! OBJFPC
 +
|-
 +
|<syntaxhighlight lang="pascal">
 +
Type TSomeComponent=class(TComponent)
 +
  //Ďalší kód...
 +
Published
 +
Property MyString:String index 3 read GetMyString;
 +
//Ďalší kód...
 +
End;
 +
 
 +
var
 +
  MyChar:char;
 +
begin
 +
  If Length(MyString)>2 then
 +
    //nie sú potrebné zátvorky
 +
    MyChar:= MyString[3];
 +
    //Ďalší kód...
 +
end;
 +
</syntaxhighlight>
 +
|<syntaxhighlight lang="pascal">
 +
Type TSomeComponent=class(TComponent)
 +
//Ďalší kód...
 +
Published
 +
Property MyString:String index 3 read GetMyString;
 +
//Ďalší kód...
 +
End;
  
In Delphi it is not required to dereference a pointer to a record to acces values within it, it can in fact be treated just like the record itself, or any other object. In FPC it must be first dereferenced. As an example,
+
var
{| class="code"
+
  MyChar:char;
|- 
+
begin
| class="header" | Delphi || class="header" | FPC
+
  If Length(MyString)>2 then
|- class="code"
+
    //niekedy sú potrebné zátvorky
| class="code" | <div class="key">Function</div> GetSomeValue(ARecord: PMyRecord)
+
    MyChar:= (MyString)[3];
  <div class="symbol">:</div> Integer;
+
    //Ďalší kód...
<div class="key">begin</div>
+
end;
  <div class="key">If</div> Assigned(ARecord) <div class="key">then</div>
+
</syntaxhighlight>
    Result<div class="symbol">:=</div> ARecord.SomeValue
 
  <div class="key">else</div>
 
    Result:= <div class="int">0</div>;
 
<div class="key">end</div>;
 
| class="code" | <div class="key">Function</div> GetSomeValue(ARecord: PMyRecord)  
 
  <div class="symbol">:</div> Integer;
 
<div class="key">begin</div>
 
  <div class="key">If</div> Assigned(ARecord) <div class="key">then</div>
 
    Result<div class="symbol">:=</div> ARecord^.SomeValue
 
  <div class="key">else</div>
 
    Result:= <div class="int">0</div>;
 
<div class="key">end</div>;
 
 
|}
 
|}
  
;When accessing chars of an indexed string Property of an object, it must be enclosed in parenthesis
+
=====Pri použití ukazovateľov s premennými alebo funkciami, musíte ich najprv pretypovať na príslušný typ =====
 +
 
 +
Niekedy máte v Delphi prázdnu ukazovateľovú premennú , reprezentujúcu objekt. Hoci to možno vyzerá ako komplexná situácia, je to nezvyčajne bežné, najmä vo veľkých komponentových balíčkoch, ako metóda predcdhádzajúca mnohým kruhovým includes medzi objektmi v rôznych jednotkách.
 +
 
 +
V Delphi je potom možné polať tento prázdny ukazovateľ do funkcie očakávajúcej objekt, bez trápenia sa nad jeho aktuálnym typom, v FPC ho musíte najprv pretypovať. Napríklad
 +
 
 +
{| border="1" width="800"
 +
! Delphi !! OBJFPC
 +
|-
 +
|<syntaxhighlight lang="pascal">
 +
Unit 1
 +
  Type
 +
    TSomeObject=class(TComponent)
 +
      //Ďalší kód...
 +
    End;
 +
 
 +
  Procedure DoSomething(Value: TSomeObject);
 +
  Function GetSomeObject: TSomeObject;
  
With Delphi it is possible to treat a Property exactly like some other const or var, even to accessing for instance individual chars of a string directly, while this is not always possible in FPC, specifically for indexed properties. Instead it must be enclosed in parenthesis, to make distinct. While this may not always hold true it is probably a good practice to consider anyway. For example
+
Unit 2
{| class="code"
+
  Type  
|- 
+
    TSomeComponent=class(TComponent)
| class="header" | Delphi || class="header" | FPC
+
    //Ďalší kód...
|- class="code"
+
    Published SomeObject: Pointer;
| class="code" | <div class="key">Type</div> TSomeComponent= <div class="key">class</div>(TComponent)
+
    //Ďalší kód...
  <div class="cmt">//More code...</div>
+
  End;
<div class="key">Published</div>
 
  <div class="key">Property</div> MyString: <div class="key">String</div> <div class="key">index</div> <div class="int">3</div>
 
    <div class="key">read</div> GetMyString;
 
  <div class="cmt">//More code...</div>
 
<div class="key">End</div>;
 
<div></div>
 
<div class="key">var</div>
 
  MyChar<div class="symbol">:</div> char;
 
<div class="key">begin</div>
 
  <div class="key">If</div> Length(MyString)> <div class="int">2</div> <div class="key">then</div>
 
    <div class="cmt">//no parenthesis needed</div>
 
    MyChar:= MyString[<div class="int">3</div>];
 
  <div class="cmt">//More code...</div>
 
<div class="key">end</div>;
 
| class="code" | <div class="key">Type</div> TSomeComponent= <div class="key">class</div>(TComponent)
 
  <div class="cmt">//More code...</div>
 
<div class="key">Published</div>
 
  <div class="key">Property</div> MyString: <div class="key">String</div> <div class="key">index</div> <div class="int">3</div>
 
    <div class="key">read</div> GetMyString;
 
  <div class="cmt">//More code...</div>
 
<div class="key">End</div>;
 
<div></div>
 
<div class="key">var</div>
 
  MyChar<div class="symbol">:</div> char;
 
<div class="key">begin</div>
 
  <div class="key">If</div> Length(MyString)> <div class="int">2</div> <div class="key">then</div>
 
    <div class="cmt">//parenthesis sometimes needed</div>
 
    MyChar:= (MyString)[<div class="int">3</div>];
 
  <div class="cmt">//More code...</div>
 
<div class="key">end</div>;
 
|}
 
  
 +
Application
 +
var
 +
  MyComponent: TSomeComponent;
 +
begin
 +
  MyComponent.SomeObject:=GetSomeObject;
 +
  //Ďalší kód...
 +
  DoSomething(MyComponent.SomeObject);
 +
end;
 +
</syntaxhighlight>
 +
|<syntaxhighlight lang="pascal">
 +
Unit 1
 +
  Type
 +
    TSomeObject=class(TComponent)
 +
  //Ďalší kód...
 +
  End;
  
;You must typecast pointers to actual type when using with var or function of that type
+
  Procedure DoSomething(Value: TSomeObject);
 +
  Function GetSomeObject: TSomeObject;
  
Sometimes in Delphi you will have a null pointer variable representing an object. While it might seem a complex situation, it is oddly quite common especially in large component packs as a method of preventing too many circular includes between objects in different units. In Delphi it is then possible to send this null pointer to a function expecting that object, without bothering to typecast to actual type, in fpc you must typecast.  
+
Unit 2
 +
  Type
 +
    TSomeComponent=class(TComponent)
 +
    //Ďalší kód...
 +
    Published SomeObject: Pointer;
 +
    //Ďalší kód...
 +
  End;
  
For example -
+
Application
{| class="code"
+
var  
|- 
+
  MyComponent: TSomeComponent;
| class="header" | Delphi || class="header" | FPC
+
begin
|- class="code"
+
   MyComponent.SomeObject:=Pointer(GetSomeObject);
| class="code" |Unit 1
+
  //Ďalší kód...
<div class="key">Type</div> TSomeObject= <div class="key">class</div>(TComponent)
+
  DoSomething(TSomeObject(MyComponent.SomeObject));
  <div class="cmt">//More code...</div>
+
end;
<div class="key">End</div>;
+
</syntaxhighlight>
<div></div>
 
<div class="key">Procedure</div> DoSomething(Value: TSomeObject);
 
<div class="key">Function</div> GetSomeObject: TSomeObject;
 
<div></div>
 
<div class="symbol">Unit 2</div>
 
<div class="key">Type</div> TSomeComponent= <div class="key">class</div>(TComponent)
 
  <div class="cmt">//More code...</div>
 
<div class="key">Published</div>
 
  SomeObject: Pointer<div class="symbol">;</div>
 
  <div class="cmt">//More code...</div>
 
<div class="key">End</div>;
 
<div></div>
 
<div class="symbol">Application</div>
 
<div class="key">var</div>
 
  MyComponent: TSomeComponent<div class="symbol">;</div>
 
<div class="key">begin</div>
 
  MyComponent.SomeObject<div class="symbol">:=</div> GetSomeObject;
 
  <div class="cmt">//More code...</div>
 
  DoSomething(MyComponent.SomeObject)<div class="symbol">;</div>
 
<div class="key">end</div>;
 
| class="code" |Unit 1
 
<div class="key">Type</div> TSomeObject= <div class="key">class</div>(TComponent)
 
  <div class="cmt">//More code...</div>
 
<div class="key">End</div>;
 
<div></div>
 
<div class="key">Procedure</div> DoSomething(Value: TSomeObject);
 
<div class="key">Function</div> GetSomeObject: TSomeObject;
 
<div></div>
 
<div class="symbol">Unit 2</div>
 
<div class="key">Type</div> TSomeComponent= <div class="key">class</div>(TComponent)
 
  <div class="cmt">//More code...</div>
 
<div class="key">Published</div>
 
  SomeObject: Pointer<div class="symbol">;</div>
 
  <div class="cmt">//More code...</div>
 
<div class="key">End</div>;
 
<div></div>
 
<div class="symbol">Application</div>
 
<div class="key">var</div>
 
   MyComponent: TSomeComponent<div class="symbol">;</div>
 
<div class="key">begin</div>
 
  MyComponent.SomeObject<div class="symbol">:=</div> Pointer(GetSomeObject);
 
  <div class="cmt">//More code...</div>
 
  DoSomething(TSomeObject(MyComponent.SomeObject))<div class="symbol">;</div>
 
<div class="key">end</div>;
 
 
|}
 
|}
  
 
==== Resources ====
 
==== Resources ====
  
Delphi resource files are win32 specific and not compatible with Lazarus, so you'll have to recreate and compile them using the lazres. Lazres can be found in the lazarus/tools subdirectory. If you've downloaded the Lazarus sources, you'll need to compile it first.
+
Súbory zdrojov Delphi sú špecifické pre Win32 a nie sú kompatibilné s Lazarus, takže ich budete musieť znova vytvoriť a preložiť pomocou '''lazres'''. '''Lazres''' nájdete v podadresári lazarus/tools. Ak máte stiahnutý zdrojový kód Lazarus, najprv ho musíte preložiť:
* cd lazarus/tools
+
cd lazarus/tools
* make install
+
make install
To add a resource to your application:
+
Pre pridanie resource do svojej aplikácie spusťte:
* lazres myresource.lrs mypix.xpm anotherpix.xpm
+
lazres myresource.lrs mypix.xpm anotherpix.xpm
* Add the LResources unit to your Uses clause
+
A potom
* Include the .lrs file you created under the initialization block
+
* pridajte jednotku '''LResources''' do sekcie '''Uses'''
Example:
+
* zahrňte vami vytvorený súbor .lrs do bloku ''initialization''
{| class="code"
+
 
|- class="code"
+
;Príklad:
| class="code" | <div class="key">function</div> TForm1.LoadGlyph(<div class="key">const</div> GlyphName: <div class="key">String</div>): TBitMap;
+
<syntaxhighlight lang="pascal">
<div class="key">begin</div>
+
function TForm1.LoadGlyph(const GlyphName: String): TBitMap;
  Result:= TPixmap.Create<div class="symbol">;</div>
+
    begin
  Result.LoadFromLazarusResource(GlyphName)<div class="symbol">;</div>
+
      Result:= TPixmap.Create;
<div class="key">end</div>;  
+
      Result.LoadFromLazarusResource(GlyphName);
  <div class="cmt">//More code...</div>
+
    end;
  <div class="key">begin</div>
+
    //Ďalší kód...
   Speedbutton1.glyph:= LoadGlyph('mypix')<div class="symbol">;</div>
+
  begin
   <div class="cmt">//More code...</div>
+
   Speedbutton1.glyph:= LoadGlyph('mypix');
  <div class="key">end</div>;
+
   //Ďalší kód...
<div></div>
+
  end
  <div class="key">initialization</div>
+
   <div class="dir">{$I unit1.lrs}</div>
+
  initialization
   <div class="dir">{$I myresource.lrs}</div>
+
   {$I unit1.lrs}
  <div class="key">end</div>.
+
   {$I myresource.lrs}
|}
+
  end.
 +
</syntaxhighlight>
 +
 
 +
=== Iná metóda konverzie projektu Delphi/Kylix do Lazarus ===
  
== Getting Help ==
+
* premenujte alebo prekopírujte všetky súbory .dfm alebo .xfm na .lfm (skoršie verzie Delphi neposkytovali textový súbor .dfm, konverzný nástroj, by mal byť v adresári \bin a možno ho použiť na konverziu .dfm)
 +
* premeujte súbor .dpr na '''.lpr'''
 +
* urobte potrebné zmeny súboru '''.lpr''':
 +
# pridajte direktívy '''{$mode delphi}{$H+}''' alebo '''{$mode objfpc}{H+}'''
 +
# pridajte jednotku '''Interfaces''' do sekcie uses
 +
# zakomentujte alebo zmažte direktívu {$R *.res}
 +
* urobte potrebné zmeny vo všetkých súboroch jednotiek '''.pas''':
 +
# pridajte direktívu '''{$mode delphi}{$H+}''' alebo '''{$mode objfpc}{H+}'''
 +
# pridajte '''LResources''' a, ak má formulár tlačítka, aj '''Buttons''' do sekcie uses
 +
# zakomentujte alebo zmažte direktívu {$R *.dfm} alebo {$R *.xfm}
 +
# pridajte sekciu '''Initialization''' nakoniec každého súboru jednotky a pridajte do nej direktívu '''{$I unitname.lrs}'''
 +
* vyberte '''Project->New Project from file'''
 +
* zvoľte súbor '''.lpr'''
 +
* v okne 'Create a new project' zvoľte 'Application'
 +
* vybudujte projekt a zaistite ďalšie potrebné opravy, v tomto okamžiku je automaticky vygenerovaný súbor .lpi.
 +
**Môžete sa stretnúť so správou 'Error reading Form', ak to nastane kliknite na 'Continue Loading'
 +
* všetko uložte a máte projekt Lazarus :-)
  
If you encounter a problem during conversion that you just can't solve, there are a wide variety of places to get help. For pure Object Pascal and FPC issues, the best place to start is the Free Pascal [http://www.freepascal.org/docs-html/ Documentation] by Michaël Van Canneyt and Florian Klämpfl. For more Lazarus oriented problems, the Lazarus Project Documentation in the Lazarus-CCR Knowledgebase [Main Page] is the next place to look. Finally you can post a question on any of the [http://www.freepascal.org/maillist.html mailing lists for the Free Pascal Compiler] or the [http://community.freepascal.org:10000/bboard/ FPC forums] where a lot of experts are subscribed.
+
== Získanie nápovedy ==
  
There are some outstanding search and knowledge bases online that can also be a great help for learning new techniques and solving problems. Tamarack Associates operates a fast [http://www.tamaracka.com/search.htm search] engine specifically for the Borland usenet archives. Mer Systems Inc. provides a similar search [http://www.mers.com/searchsite.html engine]. Another outstanding source of information along with a sitewide [http://www.efg2.com/Lab/search.htm search] capability is Earl F. Glynn's Computer Lab and Reference [http://www.efg2.com/ Library].
+
Ak sa počas konverzie stretnete sproblémom, ktorý neviete vyriešiť, sú široké možnosti ako získať pomoc:
  
== Packaging and Releasing your component ==
+
=== Documentation ===
  
=== Creating a Lazarus package for your component(s) ===
+
* Pre čisto Object Pascal a FPC problémy, jen ajlepšie začať s [http://www.freepascal.org/docs-html/ Dokumentáciou Free Pascal] od Michaëla Van Canneyta a Floriana Klämpfla.
 +
* Pre problémy viac orientované na Lazarus, hľadajte aj v [[Main Page|Dokumentácii projektu Lazarus]].
  
Creating a package makes installing the code you've converted a much easier process... especially if you're providing more then one component. Mattias Gärtner has written an overview of [[Lazarus Packages]] that should be read before beginning this process.
+
=== Partnerská podpora ===
  
=== Documentation ===
+
* Mailing listy - otázky môžete posielať do niektorého z [http://www.freepascal.org/maillist.html mailing listov pre Free Pascal Compiler] alebo [http://community.freepascal.org:10000/bboard/ FPC fór], kde je prihlásených veľa odborníkov.
 +
* IRC - na irc.freenode.net: [irc://irc.freenode.net/fpc #fpc] rpe FPC alebo [irc://irc.freenode.net/lazarus-ide #lazarus-ide] pre Lazarus
  
The purpose of this site and the wiki format is to make the generation of professional documentation an easy and quick process. The wiki also makes it possible to see the results of your posting immediately and make any changes you'd like in real time.
+
=== Vedomostné bázy ===
  
Using the Lazarus-CCR wiki to create nice looking documentation is very easy. If you've never used wiki markup before, you can get familiar with it in the [[Sand Box]] practice area.
+
Existujú aj online vyhľadávacie a vedomostné bázy, ktoré tiež môžu poskytnúť významnú pomoc pre učení sa nových techník a riešení problémov:
 +
* Tamarack Associates poskytuej rýchly [<!--http://www.tamaracka.com/search.htm-->http://codenewsfast.com/ vyhľadávací] stroj špecifické pre archívy Borland usenet.
 +
* Mer Systems Inc. poskytuje podobný vyhľadávací [http://www.mers.com/searchsite.html stroj].
 +
* Ďalšie zdroje informácií spolu s s možnosťou [http://www.efg2.com/Lab/search.htm hľadania] je Earl F. Glynn's Computer Lab and Reference [http://www.efg2.com/ knižnica].
  
=== Creating a Code Release Page ===
+
== Balíčkovanie a Uvoľňovanie komponentov ==
  
The Code Release Page contains vital information about your component that a potential downloader will need to know, such as license, intended platform, status (alpha, beta, stable...), where to download it, who wrote it, is support available... etc.
+
=== Vytvorenie Lazarus balíčka s vašim komponentom ===
  
The following procedure will let you create a Code Release Page with your browser:
+
Vytvorenie balíčka výrazne zjednodušuje inštaláciu Vymi skonvertovaného kódu... hlavne ak poskytujete viac ako jeden komponent. Mattias Gärtner má napísaný prehľad [[Lazarus Packages/sk|Balíčky Lazarus]], ktorý si musíte prečítať najprv.
  
* Edit the [[Code And Components]] page and add a project name wiki link entry for your component in the "Released Components" section. Save the modified page.
+
=== Dokumentácia ===
  
* Go to the [[Component Release Template]], select all and copy. Hit the back button on your browser to return to the [[Code And Components]] page.
+
Cieľom tejto stránky a formátu wiki je vytvoriť profesionálnu dokumentáciu ľahko a rýchlo. wiki tiež umožňuje ihneď vidieť výsledok Vašich príspevkov a robiť zmeny v reálnom čase.
* Click on your new wiki component name entry and paste the release template into the blank edit box.
 
* Edit the template accordingly and hit save.
 
* Do edit-saves until your document looks the way you want it to.
 
  
=== Creating a Comment Page for your component ===
+
Použitie Lazarus wiki pre vytváranie vzhľadnej dokumentácie je veľmi jednoduché. Ak ste ešte wiki nepoužívali, oboznámte sa s ňou pomocou [[Sand Box/sk|pieskoviska]] - cvičnej oblasti.
  
When your component is posted to the Sourceforge File Release System, the Lazarus-CCR admins will lock your code release page to prevent the unlikely event of someone changing your license, name or other release info.
+
=== Tvorba Code Release stránky ===
  
While you're building your code release page, you have the option to create another wiki link to a "news and comments" page for your component that will always be writable. This is called a ComponentCommentTemplate. The link to it should be added to the bottom of the code release template where there's a topic heading and a brief howto. The wiki name link should be your wiki component name with a Comments suffix like [[EpikTimer Comments]] or [[JpegLazarus Comments]] . The comments page will remain writable to collect feedback from users and for you to post updated information.
+
Stránka Code Release obsahuje informácie o vašom komponente, ktoré má prípadný sťahovač vedieť, ako licencia, zamýšľaná polatforma, stav (alpha, beta, stable...), odkiaľ sťahovať, kto ho napísal, či je odstupná podpora, atď.
  
A comment page can be added like this:
+
Pre vytvorenie svojej stránky Code Release vo svojom prehliadači:  
  
* Edit your component release page and add the wiki comment link (in the format described above). Save the modified page.
+
* prejdite na [[Release new component]]
* Go to the [[Component Comment Template]] , select all and copy. Hit the back button on your browser to return to your component release page.
+
* napíšte meno komponentu do editačného poľa a kliknite na ''Create Article''
* Click on the comment entry entry you created and paste the comment template into the edit box.
+
* vyplňte šablónu a stlačte uložiť.
* Edit the template accordingly and hit save.
+
* upravte stránku [[Components and Code examples]] pridaním odkazu na svoju novo vytvorenú stránku do sekcie "Uvoľnené komponenty" a ulože upravenú stránku.
* Do edit-saves until your comment page looks the way you want it to.
 
  
While the Lazarus-CCR admins initially lock code release pages, any member of the project can use their shell acount to unlock, edit and re-lock their pages.
+
=== Poslanie komponentu ===
  
=== Submitting the component ===
+
Ak ste technik uvoľňovania (''release technician'') projektu, uploadnite svoj komponent do SourceForge File Release System a pridajte ho na zoznam uvoľnených balíčkov. Inak ho pošlite niektorému z administrátorov projektu ([[User:Tom |Tom Lisjac]] alebo [[User:Vincent |Vincent Snijders]]) a budep ridaný do úložiska. Pred uploadom do SourceForge, majte vytvorenú ''stránku Code Release'' s popisom komponentu, podľa predchádzajúceho popisu.
  
If you're a release technician on the project, upload your component to the SourceForge File Release System and add it to the list of release packages. Otherwise send it to one of the project administrators and we'll add it to the repository. We'll also put it into CVS so you'll continue to have access to it.
+
Ak si myslíte, že potrebujete pokračovať s vývojom komponentu, môžeme ho tiež uložiť do SVN, aby ste k nemu mali stále prístup. Ak nás unavia úpravy z poslaných patcheov, poskytneme Vám prístup so zápisom do SVN, aby ste mohli odovzdávať svoje patche sami. Detaily nájdete v [[Using the Lazarus-ccr SVN repository|Použitie SVN úložiska Lazarus]].
  
 
== Contributors and Changes ==
 
== Contributors and Changes ==

Latest revision as of 00:32, 11 February 2020

Deutsch (de) English (en) español (es) français (fr) 日本語 (ja) português (pt) русский (ru) slovenčina (sk)

Cieľom tejto príručky je zdokumentovať niektoré zo špecifických rozdielov , ktoré sa najčastejšie vyskytujú pri konverii počas prekladu existujúceho kódu z Delphi do Lazarus.

Tento článok je o konverzii existujúceho zdrojového kódu Delphi alebo Kylix tak, aby pracoval s prekladačom Free Pascal a IDE Lazarus. Hoci majú Lazarus a Free Pascal spoločné črty s Delphi a Kylix, nejedná sa o ich klony. Existuje veľa rozdielov vo volaní knižníc a konvencii... a v niektorých oblastiach je Free Pascal rozšírený a môže byť náročnejší na správnu syntax. Pozrite si príručku Lazarus pre používateľov Delphi, v ktorej nájdete popis niektorých funkčných rozdielov.

Cieľom tejto príručky je zdokumentovať niektoré zo špecifických rozdielov, s ktorými sa často stretnete počas procesu konverzie kódu pri prekladaní existujúceho kódu z Delphi na Lazarus.

Tento dokument bol umiestnený na Wiki aby mohol byť jednoducho rozšírený každým, kto sa stretol s unikátnym problémom a zverejní ho aj pre ostatných.

Výber komponentov alebo knižnice pre konverziu

Kde hľadať kód na konverziu

Na nete je dostupného veľa kódu, ktorý môže byť konvertovaný pre použitie s FreePascal a Lazarus. Tu je Stránka kódov, ktorá je dobrým začiatkom. Prosím vás, pridajte na do nej, ak poznáte nejaký iný dobrý odkaz. Turbo-Power Software uvoľnil ich celú ponuku pod MPL. Zoznam dostupných balíčkov môžete nájsť na Sourceforge.

Aby sme predišli duplicitným snahám, balíčky, ktoré už sú konvertované sú vypísané na stránke Components and Code examples. Ak ste prekonvertovali balíček alebo na nejakom pracujete, pridajteprosím poznámku na stránku [Current Projects].

Licencovanie

Licencie existujúceho kódu siahajú od freeware/public domain po reštriktívne verzie, ktoré bránia modifikácii, redistribúcii a komerčnému použitiu. Pred konverziou každého balíčka, je dobré preskúmať jeho licenciu a zaistiť, že je kompatibilná s Lazarus a Free Pascal. Výber licencie je veľmi dôležitý pri komponentoch, pretože umiestnenie jedného na formulár môže navodiť nechcenú alebo nekompatibilnú licenciu na celú aplikáciu.

Keď konvertujete komponenty, rešopektujte prosím elanie pôvodného autora a ponechajte všetky copyrighty a licenčné hlavičky spolu s emailovou adresou a url. Je slušné a často i užitočné informovať autora, že jeho komponent je konvertovaný... hlavne ak je komponent pod obmedzujúcou licenciou. Nový záujem o staré alebo zabudnuté komponenty môže často podnietiť autora na revíziu originálu a zmeniť reštriktívnu licenciu.

Vo všeobecnosti, Public Domain (freeware) a LGPL/MPL sú najprispôsobiteľnejšie pre distribúciu komponentov. Dobrým začiatkom pre nájdenie ďalších informácií môže byť definícia Open Source. Existuje niekoľko porovnaní, ktoré môžu pomôcť objasniť ako pracujú rôzne typy licencií a aký budú mať dosah na kód, ku ktorému patria. Hľadajte "open source license comparison".

Závislosti

Ďalším krokom pred začatím práce na konverzii je overiť si, že kód nie je závislý na na iných balíčkoch, ktoré možno nemáte alebo predstavujú veľkú výzvu pre konverziu. Niektoré ponuky freeware sú obmedzené alebo rozšírené vlastnené balíčky, ktoré často nie sú dostupné alebo prichádzajú s nevhodnou licenciou.

Poznámky k prekladaču

Viz:

Poznámky k platforme a OS

Lazarus a Free Pascal sú nadplatformové a nadarchitektúrne vývojové nástroje. Naopak, väčšina existujúceho kódu Delphi bola špecificky navrhnutá pre beh na procesore Intel a s Win32. Ak má Váš komponent veľa špecifického kódu Win32, bude možno múdrejšie skúsiť nájsť alternatívu, ktorá je menej závislá na platforme. Ale nenechajte sa tým zastaviť... je naozaj prekvapujúce čo všetko LCL podporuje!

Konverzia

Nastavenie IDE Lazarus pre konverziu projektu

Vytvorenie skúšobného projektu

  • Umiestnite konvertovaný kód do podadresára (napr: convertdir)
  • Spusťte Lazarus
  • File->Save All do adresára convertdir. Zmysluplné mená pre Project a predvolenú jednotku sú voliteľné.
  • Otvorte "základnú" konvertovanú jednotku v convertdir
  • Pridajte ju do projektu: Project->Add Active Unit to Project
  • Spusťte Tools->Quick Syntax Check alebo Run->Build All, čím začnete.

Na čo treba dať pozor

  • Mená súborov sú citlivé na veľkosť pri prekladačoch série 1.0.x. Ak pracujete s touto verziou, premenujte všetky súbory malými písmenami. Ak to neurobíte, ľahko dostanete chybové hlásenie File not found.

Zdrojové kódy Delphi VCL a Kylix CLX v Lazarus

Pri konverzii zdrojových kódov Delphi/Kylix, je často užitočné použiť Find declaration, aby ste sa presvedčili, či daná funkcia funguje. IDE Lazarus môže analyzovať zdrojové kódy Delphi/Kylix. Na to potrebujete nastaviť niektoré cesty a nastavenia prekladača. Jednoducho to môžete nastaviť pomocou Environment->CodeTools Defines Editor->Insert Template.

Problémy konverzie a ich riešenie

Ekvivalenty Delphi/Kylix súborov v Lazarus

Delphi / Kylix Popis Lazarus Popis
.pas

.dfm/.xfm,

.dcu/.dpu,

.dpr(main project file),

.res,

.dof/.kof

---

---

---

súbor zdrojového kódu Delphi,

formulár Delphi,

preložená jednotka Delphi,

projekt Delphi,

Resource súbor Windows,

súbor volieb Delphi

.pas, .pp

.lfm,

.o,

.lpr

---

---

.lrs,

.lpi(hlavný súbor projketu),

.ppu

súbor jednotky Pascal,

dátový súbor formulára,

súbor preloženej jednotky,

súbor projektu,

Resource súbor,

súbor volieb projektu,

Resource súbor Lazarus,

informačný súbor projektu Lazarus,

popisný súbor jednotky FPC

Teda súbor Delphi .dcu zhruba korenšponduje so súbormi FPC .o a .ppu spolu v jednom súbore. Súbor .PPU je prevažne hlavičková (interface) časť, the .o prevažne časť implementation. Hlavnou výnimkou sú inlined funkcie, ktoré vo forme to-be-inlined v .ppu.

Konverzia projektov/formulárov/jednotiek Delphi do Lazarus

Premenujte alebo prekopírujte súbor .dpr na súbor .lpr. Zakomentujte alebo odstráňte direktívu

{$R *.res}

a pridajte direktívu

{$mode delphi}{$H+}

alebo

{$mode objfpc}{$H+}

do súboru .lpr.

S touto konverziou Vám môže pomôcť Lazarus IDE prostredníctvom položky menu Tools menu>Convert Delphi Project to Lazarus Project. Vyžiada si zadanie súboru .dpr (projekt Delphi) a skonvertuje ho na .lpr, ďalej vytvorí súbor .lpi a skonveruje všetky jednotky.

Mnoho existujúcich formulárov Delphi môžete konvertovať pomocou IDE Lazarus pomocou zabudovaného konvertora formulárov DFM na LFM. Nájdete ho v menu Tools->Convert DFM file to LFM. Vyvolajte súborový dialóg, vyberte *.dfm a konvertor urobí zvyšok.

Ak potrebujete konvertovať celú jednotku (s alebo bez formulára), Lazarus má tiež zabudovaný nástroj: Convert Delphi unit to Lazarus unit, ktorý urobí nasledujúce:

  1. upraví veľkosť písmen v sekciách uses a iclude.
  2. konvertuje súbory .dfm na súbory .lfm (bez kontroly obsahu, len formát)
  3. vytvorí prázdny súbor .lrs (obsah bude pridaný neskôr)
  4. pridá direktívu
{$mode delphi}
  1. nahradí jednotku Windows jednotkou LCLIntf
  2. ak je to potrebné, pridá jednotku LResources
  3. odoberie jednotku Variants
  4. odoberie direktívu
{$R *.dfm}
  1. pridá do sekcie initialization direktívu
{$i unit.lrs}

Toto umožní rýchlu a ľahkú konverziu väčšiny jednotiek z formátu Delphi do formátu Lazarus. Tento nástroj nevykonáva žiadnu kontrolu platnosti alebo automatické zmeny syntaxe, tak všetky potrebné zmeny syntaxe, dodatočné zmeny jednotiek, alebo zmeny dfm/pas pre rozdiely v prvkoch/komponentoch, musíte urobiť manuálne, pomocou niekoľkých sprievodcov, ktorý vám pomôžu niektoré kroky, hlavne opravovanie konvertovaných formulárov (lfm).

Výber správneho módu prekladača

Prekladač Free Pascal podporuje 5 rôznych módov Pascalu. Napríklad TP pre Turbo Pascal, vám dovolí prekladať jednotky Turbo Pascal. Má i mód pre kompatibilitu s DELPHI, ktorý môžete nastaviť na uľahčenie konverzie kódu. Lazarus preferuje mód OBJFPC, ktorý je skoro ako mód DELPHI, ale bez mnohoznačnosti syntaxe Delphi. Tu sú dôležité body:

Mód môže byť zvolený na príkazovom riadku alebo na začiatku zdrojového kódu. Použitie príkazového riadku má výhodu, že nemusíte meniť zdrojový kód, ale i nevýhody, ktoré musia vysvetliť iní.

Väčšinu jednotiek Delphi môžete jednoducho preložiť pomocou Free Pascal pridaním tejto konštrukcie, hneď za meno jednotky

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}

Ďalšie podrobnosti o módoch Free Pascal nájdete v dokumentácii Free Pascal.

Viac-platformové poznámky

  • Zahrnutý assembler býva vždy problémom, pretože zväzuje kód s architektúrou Intel. Niektorí vývojári robia prototypy algoritmov v Pascale a pomocou ifdef vkladajú oprimizovaný assembler. Našťastie Turbo-Power toto urobil na mnohých miestach svojho kódu. Ak je toto prípad balíčka, ktorý chcete konvertovať, prepnite ho späť do Pascalu.
  • Neodkazujte na špecifické pamäťové miesto, ako dátová oblasť BIOS. Zistite čo kód potrebuje a skúste nájsť cezplatformovú alternatívu.
  • Nepoužívajte triky, ktoré sú špecifické pre procesor (ako použitie Intel TSC) bez zatvorenia svojho kódu do ifdef pre platformu potrebnú pre kód... a poskytnutia alternatívy pre prostredia, ktoré nie sú hardvérovo kompatibilné.
  • Ak potrebujete nejaký kód, špecifický pre OS, používajte IFDEF. Viz zoznam makier neskôr.

Užitočné premenné prekladača

Pre písanie kódu, ktorý sa má správať na rôznych systémoch rôzne, môžete použiť direktívy

{$IFDEF Name}

Pričom Name môže byť

  • LCL - táto premenná je definovaná pri použití balíčka LCL a je vhodná pre písanie kódu, ktorý pracuje s LCL a Delphi.
{$IfDef LCL}
  • FPC - táto premenná je definovaná pri použití prekladača Free Pascal a je vhodná pre písanie kódu, ktorý pracuje s Free Pascal a Delphi.
{$IfDef FPC}
  • LCLGtk, LCLWin32, LCLQt, ... - tieto premenné sú definované keď je použitý balíček LCL a špecifický WidgetSet. Užitočné pre písanie kódu, pracuje s LCL na určitej platforme.
{$IfDef LCLGtk}
{$IfDef LCLWin32}
{$IfDef LCLQt}
... 
  • Unix, Win32,... - tieto sú definované pre cieľový OS. Delphi definuje Linux, Win32 a MSWindows. Free Pascal beží na oveľa väčšom počte platforiem a tak je vhodné použiť oveľa všeobecnejšie položky. Napríklad Unix je definované pre Linux, FreeBSD, NetBSD a OpenBSD, na ktorých už Lazarus beží.
{$IfDef Unix}
{$IfDef Win32}
...
Pre prácu v Kylix použite nasledujúcu konštrukciu:
{$IfDef Linux}
  {$Define Unix}
{$EndIf}
  • ENDIAN_BIG - táto premenná je definovaná na procesoreoch ako PowerPC (napr. staré počítače Apple, tj. do MacOSX 10.2), ktoré majú obrátené poradie ako Intel kompatibilné procesory.
{$IfDef ENDIAN_BIG}

Ďalšie podrobnosti nájdete v dokumentácii Free Pascal.

Podpora 32bit/64bit

Ukazovatele pod 64bit potrebujú 8 bajtov namiesto 4 na 32bit. Typ 'Integer' zostáva pre kompatibilitu s 32bit. To znamená, že už nepotrebujete pretypovanie ukazovatele na integer a naopak. FPC definuje dva nové typy:

  • PtrInt je 32bit Integer so znamienkom na 32bit platformách a 64bit Integer sp znamienkom na 64bit platformách.
  • PtrUInt, je rovnaké ako predchádzajúce s tým rozdielom, že sa jedná o Integer bez znamienka.

Pre kód, ktorý má pracovať s Delphi a FPC použite:

 {$IFNDEF FPC}
 type
   PtrInt = integer;
   PtrUInt = cardinal;
 {$ENDIF}

Nahrďte všetky

integer(SomePointerOrObject)

týmto

PtrInt(SomePointerOrObject)

Hľadanie chýbajúcich identifikátorov

V organizácii LCL, v porovnaní s Delphi VCL, sú rozdiely. Ak sa stretnete s chybovým hlásením prekladača not found pri významných triedach alebo identifikátoroch, je veľká šanca, že je v inej jednotke. Úplný rížový odkaz môžete nájsť pomocou programu grep na lazarus/docs/xml alebo na podadresár lcl.

Napríklad bežne používaný TButton vyvoláva v kóde Delphi chybu, pretože je umiestnený v jednotke buttons.pp. Tento príkaz nájde správnu jednotku veľmi rýchlo (v adresári zdrojového kódu Lazarus):

 grep -in ' tbutton =' lcl/*

Rozdiely v dôležitých jednotkách Lazarus a Delphi

Prosím dopĺňajte túto časť!;
  • Windows -> LCLIntf, LCLType, LCLProc, VCLGlobals, ...

Keďže LCL nie je špecificky Windowsová knižnica, kód, ktorý je v jednotke Windows z Delphi pre priamy prístup k Win32 API je abstrahovaný do samostatných rozhraní, do ktorých môžete pristupovať z jednotky LCLIntf. Majte na pamäti, že Lazarus neemuluje Win32, tak veľa funkcií cýba a niektoré nepracujú ako ich Win32 náprotivky. Tieto funkcie existujú len pre kompatibiltu s Delphi a sú určené len pre rýchly a (s)prostý prenos. LCL tiež tiež nemá mnoho z typov, tak je často potrebná jednotka LCLType a niekedy aj VCLGlobals. LCLProc tiež obsahuje niekoľko funkcií, ktoré môžu byť užitočné pre najnižšiu úroveň obslúh ako FreeThenNil, DeleteAmpersands na odstránenie dodatočných ampersandov z reťazcov pre ovládacie prvky (& - && atď).

Jednotka Interfaces musí byť zahrnutá v súbore .lpr file pre správnu inicializáciu príslušného WidgetSet.

  • Messages->LMessages

Správy TControl pre spätné volania (callbacks) udalostí Win32 vo formáte WM_CALLBACK a ich príslušná štruktúra je väčšinou umiestnená v jednotke Messages v Delphi. V LCL tieto typy správ a ich štruktúry zvyčajne nájdete v LMessages, zvyčajne premenované z WM_ na LM_, tak sa napríklad WM_MOUSEENTER stáva LM_MOUSEENTER, a TWMMouse sa stáva TLMMouse.

  • Graphics, Controls->GraphTypes, GraphMath, Graphics, Controls

Na zjednodušenie niektorých vecí a prerušenie zložitosti krúženia medzi jednotkami, sú abstrahované niektoré typy do zdieľanej jednotky, zvanej GraphType, ktorá zahŕňa potreby, ktoré sú v Delphi umiestnené v jednotkách Graphics alebo Controls. Tak ju niekedy budete potrebovať zahrnúť, rovnako ako jednotku GraphMath, ktorá, hoci nekompatibilne s Delphi, pridáva ďalšie užitočné funkcie, ako TFloatPoint pre presnosť, užitožné rutiny pre spoluprácu s bezériovými krivkami, čiarami a oblúkmi, ako aj perťažené operátory pre použitie s typmi TPoints a TRect, ako napr.

Point1 := Point2 + Point3

či porovnanie dvoch pravouholníkov ako

if (rect1 = rect2) then ...
  • Mask->MaskEdit

Kvôli inteligentnejšej názvovej úvahe, je jednotka pre TMaskEdit nazvaná [Mask Edit] na rozdiel od tochu nešikovného Mask, ako tomu je v mnohých verziách Delphi.

  • StdCtrls->StdCtrls,Buttons

V mnohých verziách Delphi je TButton umiestnený v StdCtrls, zatiaľ čo TSpeedButton a TBitBtn sú v Buttons. Pre zjednodušenie vkladá LCL všetky tlačítka do Buttons, čo môže niekedy sťažiť konverziu, preto je vhodné túto jednotku vždy zahrnúť.

Rozdiely vo vlastnostiach a metódach Delphi -> FPC/LCL

  • v LCL je Canvas obsahnutý v TBitmap

Sémantické rozdiely

Poradie vyhodnocovania parametrov

Delphi garantuje, že všetky parametre sú vyhodnocované z ľava do prava. FPC takúto garanciu neposkytuje a môže vyhodnocovať parametre v ľubovoľnom poradí, kvôli generovaniu optimálneho kódu.

Vnorené procedúry/funkcie sú procedurálne premenné

Delphi posiela framepointer rodičovskej procedúry vždy do zásobníka a vždy volá ich opätovné odstránenie. To znamená, že ak pokiaľ nepristupujute k premenným rodičovskej procedúry, môžete poslať adresu vnorenej procedúry do inej funkcie, ktorá ich potom môže volať ako každú procedurálnu premennú.

FPC vždy posiela framepointer rodičovskej procedúry ako skrytý prvý parameter, podľa aktuálnej konvecie volania, čiže ak voláte vnorenú procedúru ako bežnú procedurálnu premennú, všetky parametre budú posunuté o jednu pozíciu.

Inými slovami, nevolajte vnorené procedúry pomocou procedurálnych premenných.

Syntaktické rozdiely

Prosím dopĺňajte túto kapitolu!

Kvôli zdedenej prísnosti FPC, budú potrebné niektoré syntaktické zmeny, napriek direktíve

{$Mode Delphi}

pracuje oveľa pomalšie ako Delphi. Kvôli tomu oveľa viac vyhovujú pravidlá syntaxe {$Mode ObjFPC} ak je to možné, vrelo doporučujem, dokonca i keď bude kód zdieľaný medzi Delphi a LCL.

Niektoré z týchto sú jednoducho lepšie praktiky kódovania a niekedy pretože mód Delphi nie je celkom presný, alebo v niektorých prípadoch kód akceptovaný Delphi nefunguje podľa očakávania s Free Pascal, hoci môže byť preložený. Tkže nakoniec nie všetky sú presne vyžadované, nasledujúci zoznam zmien vždy zvážte:

Pri priraďovaní vstupného bodu obsluhy udalosti, pridajte predponu "@"

Napríklad, môžete manuálne priradiť udalosť tlačítka

Delphi OBJFPC
begin
  if not Assigned(MyButton.OnClick) then 
    MyButton.OnClick:= SomeFunction;
    //@ nie je vyžadované
    //ďalší kód...
end;
begin
  if not Assigned(MyButton.OnClick) then
    MyButton.OnClick:= @SomeFunction;
    //@ je vyžadované
    //ďalší kód...
end;
Pri volaní procedurálnej premennej používajte túto syntax: theprocname()

V Delphi nie je rozdiel medzi výsledkom funkcie a premennou, ale v FPC je. Preto volanie function, hoci aj nemá parametre, musí obsahovať zátvorky. Napríklad

Delphi OBJFPC
With (SomeObject) do 
begin
  If Assigned(OnMyCallback) then
    OnMyCallback;
    //zátvorky nie sú vyžadované
end;
With (SomeObject) do 
begin
  If Assigned(OnMyCallback) then
    OnMyCallback();
    //zátvorky sú vyžadované
end;
Pri pristupovaní k hodnotám v ukazovateli na záznam ho musíte najprv dereferencovať

V Delphi nie je nutné dereferencovať ukazovateľ na záznam pre prístup k hodnotám v ňom, môže byť spracovaný presne ako záznam samotný, či iný objekt.

V FPC musí byť najprv dereferencovaný, napríklad:

Delphi OBJFPC
Function GetSomeValue(ARecord: PMyRecord):Integer;
begin
  If Assigned(ARecord) then
    Result:=ARecord.SomeValue
  else
    Result:=0;
end;
Function GetSomeValue(ARecord: PMyRecord):Integer;
begin
  If Assigned(ARecord) then
    Result:=ARecord^.SomeValue
  else
    Result:=0;
end;
Pri pristupovaní znakov indexovaného reťazca Vlastnosti objektu, musí byť najprv uzatvorený v zátvorkách

V Delphi je možné spracovať Vlastnosť priamo ako každú inú konštantu alebo premennú, dokonca i pre prístup k jednotlivým znakom reťazca priamo.

V FPC toto nie je možné, hlavne pre indexované vlastnosti. Namiesto toho to musí byť uzatvorené v zátvorkách , kvôli jednoznačnosti. Hoci to nie je vždypravda, je to dobrý zvyk na zváženie. Napríklad

Delphi OBJFPC
Type TSomeComponent=class(TComponent)
  //Ďalší kód...
Published
Property MyString:String index 3 read GetMyString;
//Ďalší kód...
End;

var
  MyChar:char;
begin
  If Length(MyString)>2 then
    //nie sú potrebné zátvorky
    MyChar:= MyString[3];
    //Ďalší kód...
end;
Type TSomeComponent=class(TComponent)
//Ďalší kód...
Published
Property MyString:String index 3 read GetMyString;
//Ďalší kód...
End;

var
  MyChar:char;
begin
  If Length(MyString)>2 then
    //niekedy sú potrebné zátvorky
    MyChar:= (MyString)[3];
    //Ďalší kód...
end;
Pri použití ukazovateľov s premennými alebo funkciami, musíte ich najprv pretypovať na príslušný typ

Niekedy máte v Delphi prázdnu ukazovateľovú premennú , reprezentujúcu objekt. Hoci to možno vyzerá ako komplexná situácia, je to nezvyčajne bežné, najmä vo veľkých komponentových balíčkoch, ako metóda predcdhádzajúca mnohým kruhovým includes medzi objektmi v rôznych jednotkách.

V Delphi je potom možné polať tento prázdny ukazovateľ do funkcie očakávajúcej objekt, bez trápenia sa nad jeho aktuálnym typom, v FPC ho musíte najprv pretypovať. Napríklad

Delphi OBJFPC
Unit 1
  Type 
    TSomeObject=class(TComponent)
      //Ďalší kód...
    End;

  Procedure DoSomething(Value: TSomeObject);
  Function GetSomeObject: TSomeObject;

Unit 2
  Type 
    TSomeComponent=class(TComponent)
    //Ďalší kód...
    Published SomeObject: Pointer;
    //Ďalší kód...
  End;

Application
var 
  MyComponent: TSomeComponent;
begin
  MyComponent.SomeObject:=GetSomeObject;
  //Ďalší kód...
  DoSomething(MyComponent.SomeObject);
end;
Unit 1
  Type 
    TSomeObject=class(TComponent)
   //Ďalší kód...
  End;

  Procedure DoSomething(Value: TSomeObject);
  Function GetSomeObject: TSomeObject;

Unit 2
  Type
    TSomeComponent=class(TComponent)
    //Ďalší kód...
    Published SomeObject: Pointer;
    //Ďalší kód...
  End;

Application
var 
  MyComponent: TSomeComponent;
begin
  MyComponent.SomeObject:=Pointer(GetSomeObject);
  //Ďalší kód...
  DoSomething(TSomeObject(MyComponent.SomeObject));
end;

Resources

Súbory zdrojov Delphi sú špecifické pre Win32 a nie sú kompatibilné s Lazarus, takže ich budete musieť znova vytvoriť a preložiť pomocou lazres. Lazres nájdete v podadresári lazarus/tools. Ak máte stiahnutý zdrojový kód Lazarus, najprv ho musíte preložiť:

cd lazarus/tools
make install

Pre pridanie resource do svojej aplikácie spusťte:

lazres myresource.lrs mypix.xpm anotherpix.xpm

A potom

  • pridajte jednotku LResources do sekcie Uses
  • zahrňte vami vytvorený súbor .lrs do bloku initialization
Príklad
 function TForm1.LoadGlyph(const GlyphName: String): TBitMap;
    begin
      Result:= TPixmap.Create;
      Result.LoadFromLazarusResource(GlyphName);
    end;
    //Ďalší kód...
 begin
   Speedbutton1.glyph:= LoadGlyph('mypix');
   //Ďalší kód...
 end
 
 initialization
   {$I unit1.lrs}
   {$I myresource.lrs}
 end.

Iná metóda konverzie projektu Delphi/Kylix do Lazarus

  • premenujte alebo prekopírujte všetky súbory .dfm alebo .xfm na .lfm (skoršie verzie Delphi neposkytovali textový súbor .dfm, konverzný nástroj, by mal byť v adresári \bin a možno ho použiť na konverziu .dfm)
  • premeujte súbor .dpr na .lpr
  • urobte potrebné zmeny súboru .lpr:
  1. pridajte direktívy {$mode delphi}{$H+} alebo {$mode objfpc}{H+}
  2. pridajte jednotku Interfaces do sekcie uses
  3. zakomentujte alebo zmažte direktívu {$R *.res}
  • urobte potrebné zmeny vo všetkých súboroch jednotiek .pas:
  1. pridajte direktívu {$mode delphi}{$H+} alebo {$mode objfpc}{H+}
  2. pridajte LResources a, ak má formulár tlačítka, aj Buttons do sekcie uses
  3. zakomentujte alebo zmažte direktívu {$R *.dfm} alebo {$R *.xfm}
  4. pridajte sekciu Initialization nakoniec každého súboru jednotky a pridajte do nej direktívu {$I unitname.lrs}
  • vyberte Project->New Project from file
  • zvoľte súbor .lpr
  • v okne 'Create a new project' zvoľte 'Application'
  • vybudujte projekt a zaistite ďalšie potrebné opravy, v tomto okamžiku je automaticky vygenerovaný súbor .lpi.
    • Môžete sa stretnúť so správou 'Error reading Form', ak to nastane kliknite na 'Continue Loading'
  • všetko uložte a máte projekt Lazarus :-)

Získanie nápovedy

Ak sa počas konverzie stretnete sproblémom, ktorý neviete vyriešiť, sú široké možnosti ako získať pomoc:

Documentation

Partnerská podpora

Vedomostné bázy

Existujú aj online vyhľadávacie a vedomostné bázy, ktoré tiež môžu poskytnúť významnú pomoc pre učení sa nových techník a riešení problémov:

  • Tamarack Associates poskytuej rýchly vyhľadávací stroj špecifické pre archívy Borland usenet.
  • Mer Systems Inc. poskytuje podobný vyhľadávací stroj.
  • Ďalšie zdroje informácií spolu s s možnosťou hľadania je Earl F. Glynn's Computer Lab and Reference knižnica.

Balíčkovanie a Uvoľňovanie komponentov

Vytvorenie Lazarus balíčka s vašim komponentom

Vytvorenie balíčka výrazne zjednodušuje inštaláciu Vymi skonvertovaného kódu... hlavne ak poskytujete viac ako jeden komponent. Mattias Gärtner má napísaný prehľad Balíčky Lazarus, ktorý si musíte prečítať najprv.

Dokumentácia

Cieľom tejto stránky a formátu wiki je vytvoriť profesionálnu dokumentáciu ľahko a rýchlo. wiki tiež umožňuje ihneď vidieť výsledok Vašich príspevkov a robiť zmeny v reálnom čase.

Použitie Lazarus wiki pre vytváranie vzhľadnej dokumentácie je veľmi jednoduché. Ak ste ešte wiki nepoužívali, oboznámte sa s ňou pomocou pieskoviska - cvičnej oblasti.

Tvorba Code Release stránky

Stránka Code Release obsahuje informácie o vašom komponente, ktoré má prípadný sťahovač vedieť, ako licencia, zamýšľaná polatforma, stav (alpha, beta, stable...), odkiaľ sťahovať, kto ho napísal, či je odstupná podpora, atď.

Pre vytvorenie svojej stránky Code Release vo svojom prehliadači:

  • prejdite na Release new component
  • napíšte meno komponentu do editačného poľa a kliknite na Create Article
  • vyplňte šablónu a stlačte uložiť.
  • upravte stránku Components and Code examples pridaním odkazu na svoju novo vytvorenú stránku do sekcie "Uvoľnené komponenty" a ulože upravenú stránku.

Poslanie komponentu

Ak ste technik uvoľňovania (release technician) projektu, uploadnite svoj komponent do SourceForge File Release System a pridajte ho na zoznam uvoľnených balíčkov. Inak ho pošlite niektorému z administrátorov projektu (Tom Lisjac alebo Vincent Snijders) a budep ridaný do úložiska. Pred uploadom do SourceForge, majte vytvorenú stránku Code Release s popisom komponentu, podľa predchádzajúceho popisu.

Ak si myslíte, že potrebujete pokračovať s vývojom komponentu, môžeme ho tiež uložiť do SVN, aby ste k nemu mali stále prístup. Ak nás unavia úpravy z poslaných patcheov, poskytneme Vám prístup so zápisom do SVN, aby ste mohli odovzdávať svoje patche sami. Detaily nájdete v Použitie SVN úložiska Lazarus.

Contributors and Changes

This page has been converted from the epikwiki version.

  • Initial version by Tom Lisjac and Mattias Gärtner - 9/22/2003 VlxAdmin
  • Moved Getting help from the main page. T. Lisjac - 9/24/2003 VlxAdmin
  • Added documentation templates, procedure and links. 9/25/2003 VlxAdmin
  • LCLLinux was renamed to LCLIntf, Jesus Reyes, 9/27/2003
  • added more information on Unit changes, AndrewJohnson 9/27/2003
  • Updated Syntax differences, including some examples, AndrewJohnson 9/27/2003
  • FPC 1.0.x doesn't support interfaces, Vincent Snijders 9/28/2003
  • Fixed some of the examples per new WikiWord definition, 9/28/2003 VlxAdmin
  • Made code more consistant to remove last accidental Pascal WikiWord definitions, AndrewJohnson 9/27/2003
  • Use tables for code examples for nice blocks, and easy side by side view of Delphi->FPC differences, AndrewJohnson 10/17/2003
  • Use pascal stylesheet to make example code more readable, AndrewJohnson 10/18/2003