Integrované vývojové prostředí Lazarus: jen zdánlivý anachronismus

Obsah

1. Integrované vývojové prostředí Lazarus: jen zdánlivý anachronismus

2. Nástroje typu RAD – Rapid Application Development

3. Lazarus: návrh GUI + programovací jazyk + debugger

4. A co databáze?

5. Od standardního Pascalu přes Turbo Pascal a Object Pascal k Free Pascalu

6. Vybrané vlastnosti podporované Free Pascalem

7. Lazarus Component Library (LCL)

8. Jednoduchý příklad: aplikace s formulářem

9. Soubory, z nichž se projekt skládá

10. Ukázka obsahu vybraných souborů

11. Poznámka k výslednému binárnímu souboru s aplikací

12. Ladění vyvíjených aplikací

13. Přizpůsobení vývojového prostředí

14. SynEdit

15. Kombinace Pascalu s assemblerem

16. Vytváření dokumentace

17. Alternativní projekty

18. Gambas – Gambas Almost Means BASIC

19. PySide a Qt Creator

20. Odkazy na Internetu

1. Integrované vývojové prostředí Lazarus: jen zdánlivý anachronismus

V dnešním článku se seznámíme s multiplatformním integrovaným vývojovým prostředím, které se jmenuje Lazarus. Jedná se o programátorské prostředí, které se snaží (a nutno říci, že velmi úspěšně) o napodobení stylu (a dnes spíše ještě dalšího vylepšení) vývoje aplikací použitého ve známém a především v minulosti velmi populárním komerčním IDE nazvaném Delphi. Toto vývojové prostředí bylo vyvíjeno původně společností Borland a později firmou Embarcadero Technologies následované společností Idera. Samotné Delphi, jehož první verze vydaná v roce 1995 byla původně určena pro šestnáctibitový systém Windows 3.x, bylo v dalších verzích upraveno pro 32bitové systémy Windows 95, Windows NT i navazující řadu operačních systémů společnosti Microsoft. Současná verze Delphi vydaná výše zmíněnou společností Idera je pochopitelně určena i pro 64bitové operační systémy.

Mimochodem – původně se mělo Delphi jmenovat Borland AppBuilder, ovšem krátce před vydáním Delphi byla vydána aplikace AppBuilder společnosti Novell (s jiným zaměřením). Z tohoto důvodu se přešlo na interní (a to velmi populární) jméno Delphi, navíc s tím, že tento RAD nástroj dokázal dobře komunikovat s databázemi, v té době především s Oracle. Takže bylo možné psát „If you want to talk to [the] Oracle, go to Delphi“.

Obrázek 1: Integrované vývojové prostředí projektu Lazarus spuštěné v Linuxu.

2. Nástroje typu RAD – Rapid Application Development

Programová a tedy de facto i ruční tvorba grafického uživatelského rozhraní trpí hned několika dosti zásadními neduhy. Zejména se jedná o mnohdy zbytečně nízkoúrovňovou práci, ovšem horší problém spočívá v tom, že požadavek na změnu GUI (například i pouhé posunutí nějakého ovládacího prvku) vyžaduje zásah do programového kódu, který navíc není či nemusí vždy být triviální a intuitivní. Tohoto úskalí si byly některé softwarové firmy vědomy již minimálně od začátku devadesátých let minulého století a právě z tohoto důvodu vznikly nástroje typu RAD neboli Rapid Application Development. Tyto nástroje umožňují nejenom velmi rychlou tvorbu grafického uživatelského rozhraní s využitím návrhářů GUI, ale – což je možná ještě důležitější – obousměrnou vazbu mezi grafickým uživatelským rozhraním a programovým kódem. Dnes se zkratkou RAD označují (alespoň v některých případech) i nástroje typu Glade, které ovšem ve skutečnosti „pouze“ slouží k návrhu GUI. Ovšem skutečné RAD mají vazbu mezi návrhem GUI a kódem oboustrannou A přesně do této kategorie spadá i Lazarus.

Obrázek 2: Historická první verze vývojového prostředí Delphi 1.0 běžícího ve Windows 3.11.

3. Lazarus: návrh GUI + programovací jazyk + debugger

Silnou stránkou projektu Lazarus je jeho orientace na rychlou tvorbu aplikací s plnohodnotným grafickým uživatelským rozhraním popř. aplikací, které nějakým způsobem komunikují s databázemi. Tvorba grafického uživatelského rozhraní přitom vyžaduje jak GUI navrhnout (tj. navrhnout rozmístění ovládacích prvků do formulářů), tak ho propojit s programovým kódem, konkrétně naprogramováním reakcí na události. A právě snadnost tohoto propojení GUI a kódu byl asi největší faktor úspěchu projektu Delphi, na který Lazarus navázal.

Obrázek 3. Samotné Delphi, přesněji řečeno jeho část orientovaná na návrh grafického uživatelského rozhraní, bylo inspirováno Visual Basicem (zde konkrétně první 32bitová verze Delphi 2.0).

Vzhledem k tomu, že je Delphi založeno na programovacím jazyku Object Pascal, je v integrovaném vývojovém prostředí Lazarus vytvořeno propojení s multiplatformním překladačem fpc programovacího jazyka Free Pascal a samotné prostředí obsahuje jak poměrně pokročilý programátorský editor (se zvýrazněním syntaxe, foldingem, šablonami, podporou jednoduchého refaktoringu atd.) tak i interaktivní grafický editor určený pro návrh formulářů. Nesmíme samozřejmě zapomenout ani na ladicí program (debugger), který je do Lazaru plně integrován (stejně jako debugger do Delphi – ostatně vývojová prostředí vyvíjená firmou Borland byla oblíbena mj. i díky kvalitním interním debuggerům).

Obrázek 4: Obrazovka nástroje Pygubu designer určeného pro návrh grafického uživatelského rozhraní aplikací vytvářených v Pythonu. Jedná se o jeden z mnoha projektů, které byly inspirovány prostředím Borland Delphi a Microsoft Visual Basic.

4. A co databáze?

Jednou z velmi důležitých součástí integrovaného vývojového prostředí Lazarus a taktéž jeho ideového předchůdce Delphi jsou komponenty nabídnuté v nástrojovém panelu nazvaném Data Access, které do značné míry zjednodušují použití relačních databází ve vyvíjených aplikacích, protože nabízí dvě abstrakce: připojení k databázím a práci s výsledky dotazů. Podporovány jsou různé typy a verze (většinou relačních) databází, do nichž se vyvíjené aplikace mohou připojovat s využitím takzvaných datových zdrojů (data source, představováno komponentou TDataSource). Pro prezentaci dat získaných z databází na formulářích vytvářené aplikace slouží množství specializovaných a mnohdy i dosti komplikovaných ovládacích prvků, které lze nalézt na nástrojovém panelu Data Controls a taktéž na panelu SQLdb.

Obrázek 5: Paleta (nástrojový panel) s komponentami Data Controls.

Podporováno je připojení k následujícím databázím resp. přesněji řečeno k datovým zdrojům (protože například textové soubory ve formátu CSV atd. nejsou plnohodnotnou databází):

1. Advantage
2. DBase
3. TurboPower
4. In memory
5. Firebird
6. (Visual) FoxPro
7. Interbase
8. Microsoft SQL Server
9. MySQL
10. ODBC
11. Oracle
12. Paradox
13. PostgreSQL
14. Sybase Adaptive Server Enterprise (ASE)
15. SQLite
16. Textové soubory s daty

Obrázek 6: Paleta (nástrojový panel) s komponentami Data Access.

5. Od standardního Pascalu přes Turbo Pascal a Object Pascal k Free Pascalu

Lazarus je projekt, v němž se (alespoň zdánlivě) setkáme s mnoha anachronismy, což může být považováno jak za velkou přednost (stabilita), tak za nedostatek (použití technologií, které dnes nejsou považovány za moderní či alespoň „moderní“). Týká se to zejména samotného programovacího jazyka, na němž je celý projekt Lazarus postaven. Již v úvodní kapitole jsme se zmínili o tom, že předlohou pro Lazarus bylo integrované vývojové prostředí Delphi, které je založeno na programovacím jazyku Object Pascal odvozeného od Turbo Pascalu, který sám vznikl úpravami a rozšířením standardního Pascalu (ovšem s několika důležitými odlišnostmi od původního Pascalu).

Lazarus používá programovací jazyk nazvaný Free Pascal, jenž je od Object Pascalu odvozen, ovšem ve skutečnosti došlo k dalším rozšířením tohoto jazyka o další vlastnosti. Navíc je možné ve Free Pascalu definovat použitý jazyk pro každý modul zvlášť a lze tak například zkombinovat několik modulů, z nichž každý je naprogramovaný v jiné variantě Pascalu. Buďme ovšem konkrétní – podporovány jsou tyto dialekty programovacího jazyka Pascal:

1. Free Pascal
2. Object Pascal
3. Turbo Pascal
4. Delphi
5. Delphi with Unicode
6. Mac Pascal
7. GNU Pascal
8. ISO 7185 Standard Pascal
9. Extended Pascal

Obrázek 7: Součástí Free Pascalu je i integrované vývojové prostředí pracující v terminálu, které jako by z oka vypadlo slavnému Turbo Pascalu.

6. Vybrané vlastnosti podporované Free Pascalem

V této kapitole se seznámíme s vybranými zajímavými vlastnostmi podporovanými Free Pascalem. Některé z těchto vlastností byly převzaty z Turbo Pascalu (například skvělá integrace s assemblerem), další pak buď z Delphi nebo se jedná o novinky představené přímo ve Free Pascalu.

Jedním z relativně nových konceptů ve světě Pascalu (od Delphi 4) jsou takzvaná dynamická pole (dynamic arrays), jejichž velikost není resp. ani nemusí být známá v době překladu (compile time). V původním Pascalu, ale například ještě i v Turbo Pascalu, totiž byla součástí datového typu „pole“ i informace o dolním a současně i o horním indexu – a nepřímo tedy i velikost pole (překročení indexů navíc bylo kontrolováno i v době běhu; kontrolu lze vypnout):

mzdy : Array[1..12] of Integer;

Možnost definovat jak horní, tak i dolní index je ve skutečnosti velmi silná technika, která zjednodušuje mnoho algoritmů, ovšem na druhou stranu není vždy možné znát již v době překladu aplikace velikost pole. A právě v takových případech se (pochopitelně kromě dalších více či méně vhodných datových struktur) používají dynamická pole. Jedná se o datový typ, u něhož se definuje typ prvků, ovšem nikoli již délka pole ani horní a dolní index:

pixels: Array of Byte

Alokace paměti pro dynamické pole se provádí v čase běhu aplikace (runtime), a to konkrétně procedurou setLength. To ovšem není vše, protože stejným způsobem, tj. zavoláním procedury setLength, je možné pole zvětšit i zmenšit. To se interně provádí alokací nového bloku paměti a kopií prvků z původního pole do pole nového (což nemusí být velmi efektivní, pokud se realokace provádí velmi často). Navíc je typ Array of Typ pochopitelně použitelný i v deklaracích procedur a funkcí – v tomto případě se tedy jedná o rozšíření již dříve používaného typu nazvaného open array.

Interně jsou dynamická pole vlastně obdobou ukazatelů, což znamená, že sémantika práce s nimi je odlišná od statických polí. Týká se to i indexování, které začíná od nuly atd.

Obrázek 8: Informace o použité verzi projektu Lazarus.

Dalším užitečným rozšířením Free Pascalu je podpora pro generické datové typy. Pro příklad nemusíme chodit daleko, protože je popsán přímo v referenční příručce tohoto jazyka. Jedná se o implementaci seznamu, přičemž jeho prvky jsou popsány genericky:

Type
  generic TList<_T>=class(TObject)
  Public
    type
       TCompareFunc = function(const Item1, Item2: _T): Integer;
    var
      data : _T;
    procedure Add(item: _T);
    procedure Sort(compare: TCompareFunc);
  end

Za touto definicí by měla následovat implementace metod Add a Sort, opět s generickým datovým typem:

procedure TList.Add(item: _T);
begin
    ...
    ...
    ...
end;
 
procedure TList.Sort(compare: TCompareFunc);
begin
    ...
    ...
    ...
end;

Ve skutečnosti nejsou generické typy navázány pouze na třídy. Lze vytvářet například i generické záznamy (struktury) apod:

type
 
  generic PlanarCoordinate<t> = record
    x,y : t;
  end;
  
  TScreenCoordinate = specialize PLanarCoordinate<word>;
  TDiscreteCoordinate = specialize PlanarCoordinate<integer>;
  TRealCoordinate = specialize PlanarCoordinate<extended>;
 
  generic TDistanceFunction<t> = function (x,y : t) : Extended of object;

Obrázek 9: Dialog s konfigurací prostředí projektu Lazarus.

7. Lazarus Component Library (LCL)

Součástí integrovaného vývojového prostředí Lazarus je i LCL, neboli plným jménem Lazarus Component Library. Toto jméno zcela záměrně připomíná VCL (Visual Component Library), což byla knihovna (nejenom grafických) komponent používaná v originálním prostředí Delphi. Ovšem zatímco VCL bylo orientováno především na použití v operačních systémech Microsoft Windows, obsahuje LCL rozhraní hned pro několik „nativních“ GUI knihoven, zejména GTK+ (verze 2.x i 3.x), Qt, Win API a pro operační systém Mac OS X existuje vazba pro knihovny Cocoa a Carbon.

Obrázek 10: Rozšiřující komponenty, z nichž lze skládat GUI aplikace.

To mj. znamená, že programátor vytvářející svoji aplikaci s grafickým uživatelským rozhraním s využitím knihovny LCL nemusí ve svém programovém kódu složitě řešit, jaké konkrétní grafické prvky (widgety) se ve výsledku použijí, protože bude komunikovat pouze s univerzálním rozhraním společným pro všechny zmíněné GUI knihovny. Napojení projektu na zvolenou konkrétní GUI knihovnu se provede v čase překladu aplikace. Na druhou stranu ovšem snadné tímto způsobem není možné využívat některé speciality konkrétní nativní knihovny, například některé specifické ovládací prvky.

Obrázek 11: Seznam všech nainstalovaných komponent s možností jejich vyhledávání.

8. Jednoduchý příklad: aplikace s formulářem

Pro prozatím velmi stručné představení možností projektu Lazarus si zkusme vytvořit jednoduchou aplikaci s jediným formulářem, který bude obsahovat jedno tlačítko. Po stisku tohoto tlačítka se zobrazí dialog s klasickou zprávou „Hello, world!“. Samotný návrh takové aplikace není nijak složitý. Ihned po spuštění projektu Lazarus by se totiž měl otevřít předpřipravený projekt. Ten obsahuje prázdný formulář. Přitom každý formulář (tedy okno aplikace) se skládá jak z vizuálního návrhu formuláře, tak i z programové jednotky (unit) naprogramované ve Free Pascalu. Připraveny jsou přitom obě tyto části:

Obrázek 12: Prostředí projektu Lazarus po spuštění s otevřeným výchozím projektem. Na popředí vidíme návrh formuláře, na pozadí pak programovou jednotku (unit) přiřazenou k tomuto formuláři.

Do formuláře přidáme tlačítko z nástrojového pruhu „Standard“. Následně u tlačítka změníme jeho popisek (Caption). Vazba mezi vlastností (properties) Caption a skutečným popisem tlačítka je okamžitá:

Obrázek 13: Přidání tlačítka do formuláře se změnou popisku tohoto tlačítka.

Nakonec se dvojím klikem na tlačítko automaticky vytvoří metoda Button1Click (lze později přejmenovat) formuláře TForm1, která bude při běhu aplikace zavolána po stisku daného tlačítka. Prozatím je tělo této metody prázdné:

{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
begin
end;

Naprogramování reakce na stisk tlačítka je v našem případě triviální, protože můžeme použít proceduru ShowMessage pro zobrazení standardního dialogu:

{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage('Hello, world!')
end;

Aplikaci lze nyní spustit. Již tradičně (a tato tradice je delší než 30 let!) se pro tento účel používá klávesa F9:

Obrázek 14: Aplikace po spuštění.

Po kliknutí na tlačítko ve formuláři se zobrazí standardní dialog s připraveným hlášením:

Obrázek 15: Otevření dialogu po výběru tlačítka.

9. Soubory, z nichž se projekt skládá

Lazarus vytváří několik souborů, z nichž se skládá výsledný projekt. V našem konkrétním případě, tj. pro projekt s jediným formulářem, se jedná o následující soubory (ponechal jsem výchozí jména, i když v praxi je pochopitelně mnohem lepší používat správné identifikátory):

10. Ukázka obsahu vybraných souborů

Nejprve se podívejme na to, jak vlastně vypadá soubor nazvaný project1.lpr. Víme již, že lpr znamená Lazarus Program file. Jde o zdrojový soubor psaný v Pascalu, který tvoří vstupní bod do aplikace a lze ho pochopitelně upravovat:

program project1;
 
{$mode objfpc}{$H+}
 
uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Interfaces, // this includes the LCL widgetset
  Forms, Unit1
  { you can add units after this };
 
{$R *.res}
 
begin
  RequireDerivedFormResource:=True;
  Application.Scaled:=True;
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
end.

Povšimněte si především zvýrazněných řádků, které provádí inicializaci aplikace, vytvoření formuláře (na obrazovce) a následné spuštění aplikace.

Dále se podívejme na soubor nazvaný unit1.pas. Opět se jedná o zdrojový soubor, tentokrát s definicí (jediného) formuláře aplikace. Je zde definována i výše zmíněná callback metoda (viz sekci nazvanou příznačně implementation):

unit Unit1;
 
{$mode objfpc}{$H+}
 
interface
 
uses
  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
type
 
  { TForm1 }
 
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
 
  public
 
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.lfm}
 
{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage('Hello, world!')
end;
 
end.

A konečně se podívejme na soubor Unit1.lfm. Tento soubor je v čitelné (textové) podobně a obsahuje definici (popis) formuláře, tedy jak jeho vizuální podobu, tak i například vazby na callback metody atd.:

object Form1: TForm1
  Left = 335
  Height = 240
  Top = 269
  Width = 320
  Caption = 'Form1'
  ClientHeight = 240
  ClientWidth = 320
  LCLVersion = '2.0.6.0'
  object Button1: TButton
    Left = 16
    Height = 25
    Top = 16
    Width = 75
    Caption = 'Say Hello'
    OnClick = Button1Click
    TabOrder = 0
  end
end

Obrázek 16: Nastavení vlastností projektu.

11. Poznámka k výslednému binárnímu souboru s aplikací

V mém konkrétním případě (Linux na 64bitové architektuře) má spustitelný soubor project1, který vznikl překladem projektu, velikost úctyhodných 21 458 912 bajtů (tedy přibližně 21MB). To se může zdát hodně, ovšem mnoho prostoru zabírají ladicí symboly. Pokud nepočítáte s laděním výsledného binárního spustitelného souboru, lze velikost zmenšit například nástrojem strip. Po této operaci bude jeho velikost „pouhých“ 6 030 512 bajtů (tedy zhruba 6MB). I to se může zdát hodně, ovšem relativně značná velikost tohoto souboru je způsobena statickou kompilací knihoven Lazaru. Jinými slovy – výsledný binární soubor by měl být přenositelný i na další počítače se stejným operačním systémem běžícím na shodné architektuře.

Pro zajímavost se ještě podívejme, které dynamické knihovny jsou zapotřebí pro běh:

linux-vdso.so.1 (0x00007ffd5dff2000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f02c72b3000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007f02c7290000)
libgdk-x11-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libgdk-x11-2.0.so.0 (0x00007f02c71d5000)
libX11.so.6 => /usr/lib/x86_64-linux-gnu/libX11.so.6 (0x00007f02c7098000)
libgdk_pixbuf-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libgdk_pixbuf-2.0.so.0 (0x00007f02c7070000)
libgtk-x11-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libgtk-x11-2.0.so.0 (0x00007f02c6c16000)
libgobject-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libgobject-2.0.so.0 (0x00007f02c6bb4000)
libglib-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libglib-2.0.so.0 (0x00007f02c6a8b000)
libgthread-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0 (0x00007f02c6a86000)
libgmodule-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libgmodule-2.0.so.0 (0x00007f02c6a80000)
libpango-1.0.so.0 => /usr/lib/x86_64-linux-gnu/libpango-1.0.so.0 (0x00007f02c6a31000)
libcairo.so.2 => /usr/lib/x86_64-linux-gnu/libcairo.so.2 (0x00007f02c690e000)
libatk-1.0.so.0 => /usr/lib/x86_64-linux-gnu/libatk-1.0.so.0 (0x00007f02c68e2000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f02c66f0000)
/lib64/ld-linux-x86-64.so.2 (0x00007f02c72d6000)
libpangocairo-1.0.so.0 => /usr/lib/x86_64-linux-gnu/libpangocairo-1.0.so.0 (0x00007f02c66de000)
libgio-2.0.so.0 => /usr/lib/x86_64-linux-gnu/libgio-2.0.so.0 (0x00007f02c64fd000)
libfontconfig.so.1 => /usr/lib/x86_64-linux-gnu/libfontconfig.so.1 (0x00007f02c64b6000)
libXrender.so.1 => /usr/lib/x86_64-linux-gnu/libXrender.so.1 (0x00007f02c62ac000)
libXinerama.so.1 => /usr/lib/x86_64-linux-gnu/libXinerama.so.1 (0x00007f02c62a5000)
libXi.so.6 => /usr/lib/x86_64-linux-gnu/libXi.so.6 (0x00007f02c6293000)
libXrandr.so.2 => /usr/lib/x86_64-linux-gnu/libXrandr.so.2 (0x00007f02c6286000)
libXcursor.so.1 => /usr/lib/x86_64-linux-gnu/libXcursor.so.1 (0x00007f02c6279000)
libXcomposite.so.1 => /usr/lib/x86_64-linux-gnu/libXcomposite.so.1 (0x00007f02c6274000)
libXdamage.so.1 => /usr/lib/x86_64-linux-gnu/libXdamage.so.1 (0x00007f02c626f000)
libXfixes.so.3 => /usr/lib/x86_64-linux-gnu/libXfixes.so.3 (0x00007f02c6265000)
libXext.so.6 => /usr/lib/x86_64-linux-gnu/libXext.so.6 (0x00007f02c6250000)
libxcb.so.1 => /usr/lib/x86_64-linux-gnu/libxcb.so.1 (0x00007f02c6226000)
libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f02c60d7000)
libpangoft2-1.0.so.0 => /usr/lib/x86_64-linux-gnu/libpangoft2-1.0.so.0 (0x00007f02c60be000)
libffi.so.7 => /usr/lib/x86_64-linux-gnu/libffi.so.7 (0x00007f02c60b0000)
libpcre.so.3 => /lib/x86_64-linux-gnu/libpcre.so.3 (0x00007f02c603d000)
libfribidi.so.0 => /usr/lib/x86_64-linux-gnu/libfribidi.so.0 (0x00007f02c6020000)
libthai.so.0 => /usr/lib/x86_64-linux-gnu/libthai.so.0 (0x00007f02c6015000)
libharfbuzz.so.0 => /usr/lib/x86_64-linux-gnu/libharfbuzz.so.0 (0x00007f02c5f10000)
libpixman-1.so.0 => /usr/lib/x86_64-linux-gnu/libpixman-1.so.0 (0x00007f02c5e67000)
libfreetype.so.6 => /usr/lib/x86_64-linux-gnu/libfreetype.so.6 (0x00007f02c5da8000)
libpng16.so.16 => /usr/lib/x86_64-linux-gnu/libpng16.so.16 (0x00007f02c5d70000)
libxcb-shm.so.0 => /usr/lib/x86_64-linux-gnu/libxcb-shm.so.0 (0x00007f02c5d6b000)
libxcb-render.so.0 => /usr/lib/x86_64-linux-gnu/libxcb-render.so.0 (0x00007f02c5d5c000)
libz.so.1 => /lib/x86_64-linux-gnu/libz.so.1 (0x00007f02c5d40000)
libmount.so.1 => /lib/x86_64-linux-gnu/libmount.so.1 (0x00007f02c5cde000)
libselinux.so.1 => /lib/x86_64-linux-gnu/libselinux.so.1 (0x00007f02c5cb3000)
libresolv.so.2 => /lib/x86_64-linux-gnu/libresolv.so.2 (0x00007f02c5c97000)
libexpat.so.1 => /lib/x86_64-linux-gnu/libexpat.so.1 (0x00007f02c5c69000)
libuuid.so.1 => /lib/x86_64-linux-gnu/libuuid.so.1 (0x00007f02c5c60000)
libXau.so.6 => /usr/lib/x86_64-linux-gnu/libXau.so.6 (0x00007f02c5c58000)
libXdmcp.so.6 => /usr/lib/x86_64-linux-gnu/libXdmcp.so.6 (0x00007f02c5c50000)
libdatrie.so.1 => /usr/lib/x86_64-linux-gnu/libdatrie.so.1 (0x00007f02c5c46000)
libgraphite2.so.3 => /usr/lib/x86_64-linux-gnu/libgraphite2.so.3 (0x00007f02c5c19000)
libblkid.so.1 => /lib/x86_64-linux-gnu/libblkid.so.1 (0x00007f02c5bc2000)
libpcre2-8.so.0 => /usr/lib/x86_64-linux-gnu/libpcre2-8.so.0 (0x00007f02c5b30000)
libbsd.so.0 => /usr/lib/x86_64-linux-gnu/libbsd.so.0 (0x00007f02c5b16000)

12. Ladění vyvíjených aplikací

Vývojová prostředí společnosti Borland byla oblíbená mj. i kvůli velmi dobré integraci s debuggery. Tyto ladicí prostředky byly většinou přímo součástí vývojového prostředí. V projektu Lazarus, který se snaží o podobnou uživatelskou přítulnost, se pro ladění používá GNU debugger neboli gdb, kterému jsme se již na stránkách Roota věnovali. Ovšem GNU debugger je ve skutečnosti volán na pozadí, tj. sice se skutečně používá, ovšem bez nutnosti opuštění grafického uživatelského rozhraní projektu Lazarus.

Lazarus podporuje všechny základní možnosti debuggerů, tj. krokování, nastavení breakpointů, zobrazení obsahu lokálních proměnných, sledování obsahu vybraných proměnných, zobrazení zásobníku s historií volání funkcí atd. Většinou při ladění postačuje nastavit do laděné části kódu breakpoint (buď bez nebo s podmínkou):

Obrázek 17: Nastavení breakpointu v laděné aplikaci.

Následně se po spuštění aplikace a příchodu na breakpoint může začít s laděním. Některá okna používaná pro ladění jsou zobrazena na dalším screenshotu:

Obrázek 18: Průběh ladění aplikace. Tři další okna obsahují zásobník s volanými funkcemi/procedurami/metodami, dále obsah lokálních proměnných a třetí okno pak obsah uživatelem vybraných proměnných.

13. Přizpůsobení vývojového prostředí

Nastavení integrovaného vývojového prostředí Lazarus je možné poměrně široce modifikovat. Týká se to například chování integrovaného programátorského textového editoru, konfigurace překladače, ale v neposlední řadě i chování GUI. Některé možnosti jsou ukázány na následujících screenshotech, včetně jedné (alespoň podle mého názoru) velmi důležité volby, která mění chování GUI v okenních manažerech.

Obrázek 19: Nastavení chování integrovaného textového editoru.

Obrázek 20: Toto je velmi důležitá volba, která dokáže nastavit chování podobné, jaké má původní Delphi. Jedná se o to, jestli se každé okno IDE bude v okenním manažeru zobrazovat samostatně (například na dolní liště, což je výchozí chování), či zda se bude celý Lazarus chovat jako jediná aplikace (a to včetně minimalizace/obnovení oken atd.).

Obrázek 21: Nakonfigurovat je možné i automatické či poloautomatické formátování zdrojového kódu v prostředí IDE.

14. SynEdit

Velmi užitečnou komponentou, kterou je možné použít v projektech s GUI, je SynEdit. Jedná se o implementaci textového editoru (což je mnohem sofistikovanější komponenta, než běžné víceřádkové textové pole), který je možné nakonfigurovat takovým způsobem, aby zvýrazňoval syntaxi, která je definována v dalších komponentách na paletě SynEditu. Tyto komponenty podporují syntaxi Pascalu, Pythonu, C++, Visual Basicu, Perlu (což si myslím, že nelze vyřešit 100% korektně), ale i SQL, XML či HTML. Ostatně i vlastní programátorský textový editor projektu Lazarus je na SynEditu založen.

Obrázek 22: Informace o nepatrně starší verzi projektu Lazarus.

15. Kombinace Pascalu s assemblerem

Jen pro zajímavost si ukažme, jak je implementována další typicky „turbopascalácká“ vlastnost. Jedná se o možnost kombinace zdrojového kódu psaného ve Free Pascalu s assemblerem. Původně se ve Free Pascalu pro tyto účely volal GNU Assembler, nyní se používá interní assembler, takže překlad není zdržován voláním externího nástroje. Podporována je především architektura x86(64) a taktéž z historického pohledu přelomová architektura Motorola 68k (68000).

Obrázek 23: Přes deset let stará verze projektu Lazarus již byla považována za relativně stabilní projekt.

Následuje příklad kombinace kódu psaného v Pascalu a v assembleru v rámci jediného programového bloku (samotný asm-end tvoří nový podblok). Povšimněte si, že z assembleru je možné přistupovat k proměnným Pascalu:

var
    x : integer;
begin
    x := 42;
    asm
        movl x,%eax
    end;
end;

Dokonce je možné deklarovat celou funkci či proceduru, jejíž tělo je psané v assembleru:

function foobar : pointer;assembler;
asm
    movl (%esp),%ebx
    ret
end;

Obrázek 24: Historická verze projektu Lazarus.

16. Vytváření dokumentace

Pro tvorbu dokumentace o jednotlivých programových jednotkách ale i o celém projektu slouží nástroj nazvaný fpdoc. Ten dokáže načíst zdrojové kódy, zpracovat jejich strukturu, najít v nich dokumentační řetězce atd. a následně vytvořit dokumentaci ve zvoleném formátu. Výstup může být proveden do HTML (tak ostatně vznikla i celá dokumentace ke standardní knihovně Free Pascalu), XML, LaTeXu, ale i do prostého textu či do formátu Microsoft Compiled HTML Help (CHM) používaném primárně ve Windows, ovšem zobrazitelném i v Linuxu.

Obrázek 25: Historická verze projektu Lazarus.

17. Alternativní projekty

V závěru dnešního článku se ve stručnosti seznámíme s některými alternativními projekty, které vývojářům většinou nabízí plnohodnotné RAD. Do této skupiny aplikací patří kromě Lazara i projekt Gambas, jenž vývojářům přináší obdobu nechvalně proslulého programovacího jazyka Visual Basic (ovšem spíše se jedná o dialekt) a konečně nesmíme zapomenout ani na projekt Qt Creator (dříve Qt Designer). S příchodem aplikací založených na webových technologiích sice význam těchto nástrojů poněkud klesl, ovšem například pro vnitropodnikové aplikace se stále (podle mého skromného názoru) jedná o velmi snadno a především rychle použitelnou technologii vyžadující méně vstupních znalostí (a méně systémových prostředků na straně uživatele).

Obrázek 26: Dnes již historická verze Gambasu 1.0.

18. Gambas – Gambas Almost Means BASIC

První „alternativní“ integrované vývojové prostředí s možnostmi RAD, s nímž se v dnešním článku alespoň ve stručnosti seznámíme, se jmenuje Gambas neboli Gambas Almost Means BASic. Jak již druhá část jména tohoto IDE napovídá, jedná se o integrované vývojové prostředí, v němž se používá programovací jazyk odvozený (či spíše inspirovaný) Visual Basicem. Autor Gambasu, jímž je programátor Benoit Minisini, sám v přiložené dokumentaci píše, že na vývoji Gambasu začal původně pracovat především z toho důvodu, že mu množství chyb a různých nekonzistencí, které můžeme najít v původním Visual Basicu (nikoli ovšem nutně ve VB .NET) prostě připadalo rozkošné, takže se nechal Visual Basicem inspirovat (a tím pádem demonstroval platnost tvrzení „worse is better“).

Obrázek 27: SDI (Single Document Interface) integrovaného vývojového prostředí Gambasu.

Obrázek 28: Dialog zobrazený při vytváření nového projektu v prostředí Gambasu.

Ovšem tím hlavním důvodem, proč se vůbec integrovaným vývojovým prostředím Gambas v dnešním článku zabýváme, však není zvolený programovací jazyk, ale další velmi důležitá součást tohoto IDE – jedná se totiž mj. i o interaktivní grafický návrhář formulářů, díky jehož existenci je možné velmi jednoduše a především rychle a navíc s relativně velkým komfortem vytvořit i poměrně složitou aplikaci s plnohodnotným grafickým uživatelským rozhraním.

Interaktivní návrhář formulářů v prostředí Gambas je samozřejmě obousměrně propojen s ostatními částmi integrovaného vývojového prostředí, zejména s programátorským editorem zdrojových kódů. To například znamená, že pokud se na formuláři vytvoří nové tlačítko, je možné ihned začít psát obslužný kód zavolaný ve chvíli, kdy bude toto tlačítko na reálném GUI použito. Způsob propojení návrháře a programátorského editoru je obdobný způsobu, který byl využit v již výše zmíněném Visual Basicu (Microsoft) a později taktéž ve slavném Delphi vytvořeném a prodávaném společností Borland. Později došlo – to již ovšem víme z úvodních kapitol – k rozšíření tohoto úspěšného konceptu i do dalších IDE, konkrétně například do Lazaru.

19. PySide a Qt Creator

Možnou alternativou k projektu Lazarus může být PySide založené na frameworku Qt. Zde se používají tzv. UI soubory popř. QML (Qt Modeling Language).

Do souborů UI se ukládají popisy jednotlivých uživatelsky definovaných ovládacích prvků (widgetů), formulářů i celých oken. Jedná se o formát založený na XML, což znamená, že tyto soubory je možné relativně snadno zpracovat i dalšími nástroji (XML editory atd.). Tyto soubory lze vytvářet například Qt Creatorem. Ve chvíli, kdy je soubor UI s popisem nějakého prvku GUI (widget, formulář, okno) vytvořen, dá se použít několika různými způsoby:

• Soubor UI lze načíst do běžící aplikace naprogramované v C++ s využitím třídy QUiLoader.
• Soubor UI lze načíst do běžící aplikace naprogramované v Pythonu, opět s využitím třídy QUiLoader.
• Soubor UI je možné konvertovat na zdrojový kód v C++ nástrojemUIC (User Interface Compiler).
• Soubor UI je možné konvertovat na zdrojový kód v Pythonu nástrojemPython-uic. Výsledek by měl být dobře pochopitelný, protože se používají postupy, které jsme si popsali v předchozích článcích.

Jedním z nástrojů, který dokáže vytvářet soubory .ui, je aplikace nazvaná Qt Creator. Jak již název tohoto nástroje napovídá, jedná se o IDE určené primárně pro desktopové prostředí KDE založené na knihovně Qt, ovšem ve skutečnosti nám samozřejmě nic nebrání použít Qt Creator i na desktopu se spuštěným Gnome Shellem popř. s nějakým „alternativním“ desktopovým prostředím (jediným problémem bude nepatrně delší čas spouštění zapříčiněný načítáním knihovny Qt do paměti). To, že je Qt Creator původně orientován na vývoj aplikací postavených na knihovně Qt a tím pádem i na programovacím jazyku C++, je patrné již při pohledu na screenshoty, kde jsou ukázány dialogy zobrazené při vytváření nového projektu.

Obrázek 29: Vítací obrazovka dnes již poněkud starší verze Qt Creatoru.

Formát souborů vytvářených Qt Creatorem se však odlišuje od stejně pojmenovaných souborů vytvářených systémem Pygubu:

<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow" >
  <property name="geometry" >
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>300</height>
   </rect>
  </property>
  <property name="windowTitle" >
   <string>MainWindow</string>
  </property>
  <widget class="QMenuBar" name="menuBar" />
  <widget class="QToolBar" name="mainToolBar" />
  <widget class="QWidget" name="centralWidget" />
  <widget class="QStatusBar" name="statusBar" />
 </widget>
 <layoutDefault spacing="6" margin="11" />
 <pixmapfunction></pixmapfunction>
 <resources/>
 <connections/>
</ui>

20. Odkazy na Internetu

1. Lazarus – home page
   https://www.lazarus-ide.org/
2. Lazarus (IDE)
   https://en.wikipedia.org/wi­ki/Lazarus_(IDE)
3. Lazarus – dokumentace
   https://www.getlazarus.org/learn/
4. Lazarus – dokumentace ve formátu chm
   https://sourceforge.net/pro­jects/lazarus/files/Lazarus%20Do­cumentation/Lazarus%202.2RC2/
5. Lazarus – getting started
   https://www.getlazarus.or­g/learn/tutorials/start/
6. Introducing Lazarus
   https://www.getlazarus.or­g/learn/tutorials/introduc­tion/#introducing_lazarus
7. Lexikální struktura Free Pascalu
   https://www.getlazarus.or­g/learn/language/lexical/
8. Object Pascal
   https://en.wikipedia.org/wi­ki/Object_Pascal
9. Comparison of integrated development environments: Pascal, Object Pascal
   https://en.wikipedia.org/wi­ki/Comparison_of_integrated_de­velopment_environments#Pas­cal,_Object_Pascal
10. Free Pascal and Lazarus Wiki
    https://wiki.lazarus.freepascal.org/
11. Projects using Free Pascal
    https://wiki.freepascal.or­g/Projects_using_Free_Pas­cal
12. Free Pascal
    https://www.freepascal.org/
13. Free Pascal: Online documentation
    https://www.freepascal.org/docs.html
14. Free Pascal User’s Guide
    https://www.freepascal.org/docs-html/current/user/user.html
15. Free Pascal Programmer’s Guide
    https://www.freepascal.org/docs-html/current/prog/prog.html
16. Free Pascal Reference guide
    https://www.freepascal.org/docs-html/current/ref/ref.html
17. Free Pascal Run-Time Library
    https://www.freepascal.org/docs-html/current/rtl/index.html
18. Free Pascal FCL: Free Component Library
    https://www.freepascal.org/docs-html/current/fcl/index.html
19. Reference for package ‚fcl-res‘
    https://www.freepascal.org/docs-html/current/fclres/index.html
20. Free Pascal code documenter: Reference manual
    https://www.freepascal.org/docs-html/current/fpdoc/fpdoc.html
21. Free Pascal Run-Time Library: Reference guide (zastaralé)
    https://www.root.cz/knihy/free-pascal-run-time-library-reference-guide/
22. Topic: The future of Free Pascal
    https://forum.lazarus.fre­epascal.org/index.php?topic=31347­.30
23. Free Pascal: Future plans
    https://freepascal.org/future.var
24. SynEdit
    https://wiki.freepascal.org/SynEdit
25. Interaktivní tvorba grafického uživatelského rozhraní nástrojem Pygubu
    https://www.root.cz/clanky/in­teraktivni-tvorba-grafickeho-uzivatelskeho-rozhrani-nastrojem-pygubu/
26. Interaktivní tvorba grafického uživatelského rozhraní s využitím nástroje Pygubu (2)
    https://www.root.cz/clanky/in­teraktivni-tvorba-grafickeho-uzivatelskeho-rozhrani-s-vyuzitim-nastroje-pygubu-2/
27. Interaktivní tvorba grafického uživatelského rozhraní s využitím nástroje Pygubu (dokončení)
    https://www.root.cz/clanky/in­teraktivni-tvorba-grafickeho-uzivatelskeho-rozhrani-s-vyuzitim-nastroje-pygubu-dokonceni/
28. Graphical user interface builder
    https://en.wikipedia.org/wi­ki/Graphical_user_interfa­ce_builder
29. Seriál Grafické uživatelské rozhraní v Pythonu
    https://www.root.cz/serialy/graficke-uzivatelske-rozhrani-v-pythonu/
30. User interface markup language
    https://en.wikipedia.org/wi­ki/User_interface_markup_lan­guage
31. Dynamic array
    https://wiki.freepascal.or­g/Dynamic_array
32. Platformy podporované Free Pascalem
    https://wiki.freepascal.or­g/Platform_list
33. Databases
    https://wiki.freepascal.org/Databases
34. Lazarus Database Overview
    https://wiki.freepascal.or­g/Lazarus_Database_Overvi­ew
35. PostgreSQL Data Access Components
    https://www.devart.com/pgdac/
36. Trasování a ladění nativních aplikací v Linuxu: použití GDB a jeho nadstaveb
    https://www.root.cz/clanky/trasovani-a-ladeni-nativnich-aplikaci-v-linuxu-pouziti-gdb-a-jeho-nadstaveb/