Lazarus - Premier exemple : développement rapide

L’objectif du livre est d’apprendre facilement LAZARUS afin de créer rapidement un logiciel. On met en avant la création de composants, étape indispensable dans l’automatisation et l’optimisation. On donnera la démarche pour créer très rapidement un logiciel.

Ce livre a été écrit par Matthieu GIROUX et d’autres auteurs. Ce livre est sous licence CREATIVE COMMON BY SA.
Vous pouvez télécharger ce livre, l’utiliser en citant l’auteur, le vendre au même prix.

Si vous voulez apprendre la programmation d’interfaces homme-machine, LAZARUS est fait pour vous. LAZARUS c’est une utilisation des librairies libres les plus fiables avec une interface facile à utiliser. DELPHI est beaucoup enseigné dans les écoles françaises. Nous souhaitons le même destin à LAZARUS qui ne possède pas de licence payante. LAZARUS est un logiciel libre.

LAZARUS c’est un EDI, un Environnement de Développement Intégré, qui est multiplateforme et compatible DELPHI. Vous pourrez donc avec adapter des composants DELPHI pour que vos logiciels deviennent multiplateformes. DELPHI a été créé en 1995. Le projet LAZARUS commence en 1999. Il est actuellement préférable d’utiliser LAZARUS plutôt que les composants KYLIX, un DELPHI sous LINUX créé en 2001. En effet KYLIX, a été abandonné dès sa deuxième version.

On utilise LAZARUS pour créer des logiciels Client/Serveur multiplateformes. Il faut cependant participer au projet LAZARUS afin, par exemple, de permettre les tests détaillés. Si vous voulez créer ce genre de logiciel, vous pouvez compter sur les librairies permettant de réaliser vos interfaces exécutables sur vos plateformes préférées. Mais il existe aussi des composants libres ou payants sur le web.

Si vous voulez créer votre jeu multiplateforme, LAZARUS possède des librairies OPEN GL permettant de créer des jeux 2D ou 3D. On utilisera LAZARUS pour créer des logiciels graphiques multiplateformes. Il existe des librairies permettant de lire des formats de fichiers 3D libres ou propriétaires.

Indéniablement, LAZARUS manque encore de librairies. Cependant, il existe toutes sortes de composants libres ou gratuits sur DELPHI facilement traduisibles.

LAZARUS, ce sont les atouts de JAVA sans des contraintes de JAVA. On s’aperçoit que les destructeurs permettent une meilleure optimisation de la mémoire. Au lieu d’installer un serveur avec TOMCAT qui devra être optimisé, il est plus judicieux de détecter les fuites mémoires au sein des destructeurs afin d’optimiser les variables créées. En effet, libérer la mémoire dès qu’elle est inutilisée permet déjà d’optimiser. LAZARUS permettra bientôt de détecter les fuites mémoires.

Il n’y a pas de JVM sous LAZARUS. Votre exécutable LAZARUS est aussi suffisamment complet pour être indépendant de librairies. Les librairies utilisées par LAZARUS ne sont en général pas nécessaires à votre exécutable.

Vous ne connaissez peut-être pas les BEANS sous JAVA. La partie composants des BEANS JAVA ne permet pas de gagner autant de temps que les composants RAD. On appelle cela les LCL sur LAZARUS, pour Librairie de Composants Lazarus (Lazarus Component Library). Dans LAZARUS même les composants non visuels sont dans cette librairie. Un EDI JAVA nécessite plus de temps de maintenance et de développement qu’un framework LAZARUS, à cause d’une gestion rendue complexe par la programmation JAVA nécessitant d’utiliser toujours des classes, ainsi que par la réinvention d’un nouvel EDI.
Dans LAZARUS ou DELPHI, tout composant est facilement remplaçable par un autre. Il suffit pour cela de changer le type de composant dans le fichier PASCAL et dans le code du formulaire.

Comme vous le savez sans doute, l’inspecteur d’objet permet de mettre en place rapidement tout composant. Vous gagnerez un temps précieux à créer des composants en Développement Rapide d’Applications, contrairement à JAVA.

Tout comme JAVA, vous pouvez utiliser l’orienté objet pour créer des classes qui seront les objets instanciés de votre logiciel. Mais vous avez des alternatives comme les unités de fonctions. À quoi bon créer une classe statique. En PASCAL Objet, vous pouvez créer des unités avec des fonctions et procédures sans avoir à créer une classe statique. Il est par ailleurs recommandé d’utiliser un maximum d’unités pour que l’exécutable prenne moins de place.

LAZARUS est basé sur un langage nommé PASCAL objet. Ce langage possède une grammaire et des instructions PASCAL basées sur l’algorithmique. Le PASCAL est donc enseigné pour cette raison particulière.

Le langage PASCAL Objet est l’un des plus simples du marché. Il permet de trouver facilement les erreurs. Le compilateur FREE PASCAL permet de créer des exécutables indépendants de toute librairie complémentaire.

LAZARUS a certes été créé en 1999, mais il ne fait que reprendre les instructions de PASCAL Objet existantes grâce au compilateur multiplateforme FREE PASCAL, point de départ de départ de LAZARUS. Le compilateur FREE PASCAL évolue maintenant grâce à LAZARUS.

Nous vous apprendrons à connaître les instructions permettant de réaliser votre logiciel adapté à vos besoins. Il faudra pour aller loin connaître l’objet et les différentes architectures logicielles.

Le langage PASCAL Objet permet de créer des objets grâce à ses variables typées. Pour créer du code source propre, vous devez respecter la syntaxe ainsi que les règles de destruction de vos variables en mémoire.

Les variables simples comme les nombres, les chaînes de caractères, les tableaux typés sont détruits dès que leur objet ou unité parente est détruit.

Vous ne trouverez pas chez LAZARUS de destruction automatique des variables d’Objets. Seulement les composants Objets se détruisent dès que leur fenêtre ou module est détruit.
On voit que l’autodestruction, si besoin, n’est pas aussi fiable qu’elle le prétendait. LAZARUS permet donc de créer des interfaces hommes-machines fiables si vous informez correctement vos constructeurs et destructeurs d’Objets.

LAZARUS dispose d’une communauté active. Elle ajoute au fur et à mesure de nouvelles possibilités. Des communautés s’ouvrent régulièrement. Il existe un wiki LAZARUS ainsi qu’un espace de documentation français. Un espace de traduction facilite la compréhension de LAZARUS. Vous pouvez participer à ces espaces ou donner vos avis.

LAZARUS évolue continuellement. Il faudra éviter certaines versions.

Le site de www.sourceforge.net ne diffuse que des logiciels Open Source. LAZARUS est donc Open Source. Vous pouvez le modifier. Ce site permet aussi de disposer d’une mise à jour des sources fichier par fichier selon les modifications. Ces fichiers sources ne sont pour certains pas testés.

LAZARUS est un logiciel libre. Autrement dit, vous avez accès aux sources et vous avez le droit de les modifier librement. Vous pouvez donc intégrer le projet LAZARUS. On aura intérêt à mettre à jour LAZARUS afin de disposer des dernières améliorations libres. LAZARUS gère des numéros de version.

Le Versioning LAZARUS se présente avec des chiffres disposés de cette façon : A.B.CC-D

Le premier chiffre ou nombre « A » présente une version majeure de LAZARUS. Par exemple, la version 1.0.00-0 de LAZARUS permettra de traduire tout composant DELPHI vers LAZARUS. Plus ce chiffre ou nombre est grand et récent, plus cette version est recommandée.

Le deuxième chiffre ou nombre présente une version mineure de LAZARUS. Plus ce nombre ou chiffre est grand, plus cette version est recommandée.

Les deux troisièmes chiffres présentent la maturité de la version mineure. Si le chiffre est pair, la version est utilisable, car elle a été testée. Si le chiffre est impair, il s’agit d’une version non testée créée un jour donné. Les versions à troisième nombre impair ne veulent rien dire sans leur jour de création. Les versions à troisième nombre impair permettent de montrer un aperçu de la prochaine version paire. Elle n’est donc pas testée. Les versions à troisième nombre impair ne sont jamais recommandées. Elles servent à créer les versions testées.

Le quatrième chiffre ou nombre montre une création de la version normalement paire à partir d’une base plus récente. En fait, le quatrième chiffre ne vous apportera presque rien excepté la possibilité de créer des composants sur chaque plateforme plus facilement, ce qui est un haut niveau de programmation.

Vous pouvez donc maintenant télécharger LAZARUS pour votre environnement sur la page de téléchargement du projet LAZARUS à http://sourceforge.net/projects/lazarus/.
Vous pouvez par la même occasion voir l’avancement du projet à http://www.lazarus.freepascal.org/ dans la page « Roadmap ».
Si vous souhaitez connaître l’état de la prochaine version, allez à http://bugs.freepascal.org/my_view_page.php.

Il est possible de télécharger la version LAZARUS du jour sur http://freepascal.dfmk.hu/test/lazarus/. On télécharge un Snapshot LAZARUS, c’est-à-dire une vue sur les modifications du jour apportées à LAZARUS. Un Snapshot sert à travailler sur des composants LAZARUS en cours de publication. Il compile rarement un exécutable.

Si on souhaite participer à LAZARUS, il est possible de télécharger directement les sources sur le site web de sourceforge à http://sourceforge.net/projects/lazarus/.

LAZARUS s’installe en vous demandant de relier les fichiers PASCAL ou LAZARUS au logiciel LAZARUS. Notez le répertoire d’installation de LAZARUS.

Une version moins récente est disponible dans votre gestionnaire de paquets. Pour disposer de la version plus récente, il faut ajouter le serveur de tests à votre gestionnaire de paquets. Il faut avant vérifier si la version de www.sourceforge.net est plus récente que celle de votre gestionnaire.

Si vous possédez un LINUX DEBIAN ou un LINUX UBUNTU votre version de LAZARUS est dans le gestionnaire de paquets SYNAPTIC. Il suffit d’installer le paquet « lazarus » graphiquement ou en tapant cette commande en mode « root »(Administrateur) :

apt-get install lazarus

Sinon il faut installer l’ensemble des paquets FREE PASCAL COMPILER débutant par « fpc » et « fp- » ainsi que les paquets LAZARUS débutant par « lazarus ». FREE PASCAL COMPILER peut être trop récent. Il faut faire attention à la version reconnue par LAZARUS.
Pour reconstruire LAZARUS, il faut démarrer LAZARUS comme ceci :

su root  startlazarus

Si vous voulez travailler sur les composants LAZARUS, le mieux est de rendre le répertoire LAZARUS à votre compte. Seul votre compte peut alors construire LAZARUS. LAZARUS s’installe dans /usr/lib/lazarus. Si vous souhaitez travailler souvent sur les composants, il vous est possible d’accéder à ce répertoire en devenant propriétaire du répertoire grâce au terminal LINUX. Utilisez cette commande en mode Administrateur :

chown -R mon_login.root /usr/lib/lazarus

Après avoir créé un nouveau projet, allez dans l’éditeur de source. Vous voyez une source créée automatiquement ainsi qu’une fenêtre qui ne réagit pas comme une fenêtre habituelle. C’est votre base de travail permettant de créer un programme fenêtré.
Vous voyez aussi une fenêtre (ou un formulaire) avec une grille en pointillés permettant de travailler graphiquement. Allez dans le menu « Projet » puis dans « Inspecteur de Projet ». Vous voyez les fichiers qui ont été créés automatiquement. Le fichier commençant par « Unit1 » c’est le formulaire de votre nouveau projet en source PASCAL Objet.
Vous voyez aussi un fichier « .lpr ». Cette extension de fichier signifie LAZARUS Project Resource ou Ressource d’un Projet LAZARUS. Cette ressource centralisant le projet permettra de compiler et d’exécuter votre formulaire.
Pour compiler et exécuter ce projet vide, cliquez sur dans la barre d’outils LAZARUS.
Vous voyez la même fenêtre vide sans les pointillés de présentation. C’est votre formulaire qui est exécuté. Vous pouvez le déplacer, l’agrandir, le diminuer et le fermer contrairement au formulaire précédent.
Il s’agit bien d’un programme exécuté. Pour exécuter ce programme avec ce formulaire, le compilateur FREE PASCAL a d’abord compilé le formulaire grâce à ces sources et celles de LAZARUS. Le formulaire dans son ensemble appartient par contre au projet LAZARUS. LAZARUS c’est un Environnement de Développement Intégré regroupant des composants tous visuels.

4-11-1. Le nom d’unité▲

4-11-2. La clause « uses »▲

4-11-3. L’Exemple▲

L’exemple consiste à créer une fenêtre permettant d’afficher « Hello World ! ».
Nous allons éditer un nouveau projet. Allez dans « Fichier » puis « Nouveau ». Choisissez « Application ».
Tout d’abord, nous allons rechercher l’unité « Dialogs » avec beaucoup de fainéantise.

Placez-vous après une virgule de la clause « uses ». Elle se termine comme chaque instruction par un « ; ».
En respectant la présentation LAZARUS, tapez uniquement « di ».

Ce qui va suivre ne fonctionne que si votre code source est correct des unités utilisées jusqu’à votre ligne éditée.
Appuyez en même temps d’abord sur « Ctrl » avec ensuite la barre d’espacement. Relâchez. Il s’affiche une liste d’unités LAZARUS. Choisissez « dialogs » avec les flèches et la touche « Entrée ». N’oubliez pas de placer ensuite une virgule pour ne pas créer d’erreur de compilation. Vous avez ajouté l’unité Dialogs.

Pour voir ce que vous avez ajouté, maintenez enfoncé « Ctrl » tout en cliquant sur l’unité « Dialogs ». L’unité « Dialogs » s’affiche. Vous irez toujours vers la source première en faisant de cette manière. LAZARUS ira chercher ce qu’il pourra aller chercher grâce aux liens de vos projets et un code correct.

Vous pouvez voir que la clause « uses » de « Dialogs » contient d’autres unités. Celles-ci seront elles aussi ajoutées à votre projet si elles ne l’étaient pas déjà. En effet, des unités obligatoires seront toujours utilisées.
Toute écriture de code ajoute des informations à votre exécutable avec en plus des unités qui seront intégrées. Elles permettent le maximum d’indépendance. Votre programme compilé contiendra beaucoup de code, mais sera indépendant.

Grâce aux onglets de l’éditeur de source, vous pouvez retourner sur votre source en cliquant sur l’onglet « Unit1 ».
Ce nom « Unit1 » n’est pas explicite. Nous allons le renommer en gardant une partie des informations importantes. Cliquez dans le menu LAZARUS sur « Fichier » puis « Enregistrer ». Créez votre répertoire de projet et sauvegardez votre unité en commençant par « u_ ». Cela indique comme avant que l’on sauvegarde une unité. Les fichiers seront ainsi regroupés au même endroit. Ensuite, on mettra le thème de l’unité comme « hello ». Cela donne « u_hello ». Sauvegardez.

Si vous avez mis des majuscules dans le nom d’unité, LAZARUS peut vous demander de renommer ce nom d’unité en minuscule. N’allez que rarement contre ses recommandations. Acceptez.
Votre nom d’unité est donc « u_hello ». Elle peut être rajoutée dans une autre unité du projet dans une clauses « uses » d’une autre unité du projet. Nous allons rajouter un bouton à notre formulaire. Pour aller sur le formulaire de l’unité u_hello, appuyez sur « F12 » quand vous êtes sur l’unité dans l’« éditeur de source ». Cliquer de nouveau sur « F12 » permet de revenir sur l’« éditeur de source ».

Allez sur la palette des composants. Sélectionnez dans le premier onglet « Standard » le bouton « TButton ». Cliquez l’icône « TButton ». Il s’enfonce. Cliquez sur le formulaire pour placer votre « TButton ». Vous verrez à l’exécution la même fenêtre avec son « TButton » sans les points noirs. Ces points noirs servent à se repérer à la conception.

Cliquez sur le bouton de votre formulaire puis sur « F11 ». Vous sélectionnez l’« Inspecteur d’Objets », qui va permettre de modifier votre « TButton ». Vous êtes sur l’onglet « Propriétés » de l’« Inspecteur d’Objets ». Cet onglet classe les propriétés par ordre alphabétique. Vous pouvez changer la propriété « Name » de votre « TButton » et renommer votre « TButton » en « BCliquez ». Vous voyez alors le texte du « TButton » changer. C’est une automatisation de ce composant qui change sa propriété « Caption » quand on change pour la première fois son nom.

Pour vous rendre compte, allez sur la propriété « Caption » et enlevez le « B ». Le nom de votre composant n’a pas changé et pourtant la propriété « Caption » a bien changé le texte de votre « TButton ».
Allez sur l’onglet « Évènements » de l’« Inspecteur d’Objets ». Double cliquez sur l’évènement « OnClick ». Cela fait le même effet que d’appuyer sur les trois points : vous créez un lien vers une procédure dans votre « Éditeur de source ».

Tapez entre le « Begin » et le « End » de cette nouvelle procédure deux espaces puis « show ». Puis appuyez en même temps sur « Ctrl » suivi de « Espace ». Si vous avez ajouté l’unité « Dialogs », vous devez voir la procédure « ShowMessage ». Vous voyez que cette procédure simple possède un seul paramètre chaîne. Sélectionnez cette procédure avec les flèches et entrée ou la souris.

Vous avez maintenant à ajouter le paramètre. Les paramètres des procédures sont intégrés grâce aux parenthèses. Ouvrez votre parenthèse. Les chaînes sont ajoutées grâce en les entourant par un caractère « ' ». L’instruction se terminera par un « ; ». Il faut donc écrire :

 

Sélectionnez

Begin
  ShowMessage ( 'Hello World' );
End;

Nous allons afficher un message « Hello World » quand on clique sur le bouton « BCliquez ».

Appuyez simultanément sur « Ctrl » suivi de « F9 ». Cela compile votre exécutable en vérifiant la syntaxe et en donnant des avertissements. Cliquez sur ou appuyez sur « F9 » pour exécuter votre logiciel fenêtre.

Après avoir appuyé sur le bouton, voici, ce que cela donne ci-après :

4-11-4. La source du formulaire▲

Le type égal à « class (TForm) » décrit l’élément essentiel de l’EDI LAZARUS. Il s’agit de la fenêtre affichée contenant le bouton. On ne voit pas dans cette déclaration l’endroit où on a placé le bouton. L’endroit où on a placé le bouton se modifie dans l’« Inspecteur d’Objets ». L’inspecteur d’objet sauve les propriétés dans le fichier portant l’extension « .lfm ». Vous pouvez voir ce fichier en affichant sur le formulaire modifiable un menu grâce au bouton droit de la souris. Dans ce menu, cliquez sur « Afficher le source ».

En scrutant le fichier « .lfm », vous voyez le bouton et ses coordonnées affichées.
Le type égal à « class (TForm) » permet d’afficher la fenêtre et son bouton en lisant ce fichier « .lfm ».

Les modifications apportées au fichier permettent entre autres d’intervertir des composants.
Pour cela il faut avoir relié le paquet du composant au projet grâce au gestionnaire de projet.

Vous voyez dans l’exemple que le code source est joliment présenté. Cela n’est pas une futilité puisque vous avez eu envie de le regarder. Vous avez peut-être eu envie de prendre exemple sur ce qui avait été fait. Voici la recette à suivre pour faire de même et mieux encore.

Un code source bien présenté, ce sont des développeurs clairs et précis. L’indentation, c’est la présentation du code source pour qu’il devienne lisible. En effet, vous créez du code machine alors que ce sont des hommes et femmes qui seuls peuvent le scruter et le modifier correctement. Les erreurs sont toujours humaines.

L’indentation c’est donc du code source lisible. L’indentation c’est présenter le code source afin de le comprendre comme clair sans avoir à le regarder de près.
L’indentation des éditeurs PASCAL est simple. En voici un résumé :

• Chaque instruction ou nÅ“ud ( var, type, class, if, while, case, etc. ) commence au début de la ligne
• Chaque imbrication d’un nÅ“ud doit être décalée de deux espaces vers la droite
• Les instructions incluses entre les Begin et End sont décalées de deux espaces vers la droite

Cette présentation permet de passer du code source plus facilement. Les développeurs qui regardent du code source avec cette présentation seront plus précis et plus sûrs d’eux.

Pour aider à indenter, deux combinaisons de touches sont très importantes dans les éditeurs PASCAL :

• Ctrl + K + U permet de décaler votre sélection de deux espaces vers la gauche ;
• Ctrl + K + I permet de décaler votre sélection de deux espaces vers la droite.

Vous pouvez aussi ajouter des règles de présentation du code qui facilitent la maintenance. Nous vous disons pourquoi appliquer ces règles de présentation :

• des commentaires obligatoirement avant chaque code source de fonctions ou procédures

  • ainsi les commentaires avant chaque fonction ou procédure seront vus dans l’éditeur FREE PASCAL ;

• des commentaires dans le code source si on y trouve un bug

  • Si on trouve un bug dans le code source, il est possible que ce bug revienne s’il n’y a pas de commentaires.

• des commentaires dans le code source dès que l’on réfléchit pour écrire une source

  • si le code demande réflexion pour être fait, c’est que vous y réfléchirez à nouveau si vous n’y mettez pas de commentaires. Notre mémoire oubliera ce que l’on a écrit ;

• chaque fonction doit tenir sur la hauteur d’un écran

  • une fonction qui ne tient pas sur la hauteur d’un écran est non structurée, illisible, difficile à maintenir, difficilement compilable si retravaillée.

Il existe d’autres méthodes de structuration comme, par exemple, mettre des séries d’instructions alignées mot à mot. Cela permet de retrouver facilement les différences si le code source se répète.
Comme l’éditeur FREE PASCAL peut terminer les mots, il est possible de mettre des longs noms de variables et procédures.
Toute nouveauté de l’éditeur est à saisir. Cela facilite le travail.
Vous pouvez définir votre présentation et la tester.

4-12-1. Structure du code source▲

{$mode Delphi} // Compilation compatible DELPHI

{$IFDEF FPC}
{$mode Delphi}
{$ELSE}
{$R *.dfm}
{$ENDIF}

{$IFNDEF FPC}
instruction_delphi;
{$ENDIF}

{$IFDEF WINDOWS}
DirectorySeparator := '\';
{$ENDIF}

{$IFDEF UNIX}
DirectorySeparator := '/';
{$ENDIF}
{$IFDEF LINUX}
DirectorySeparator := '/';
{$ENDIF}

À la fin du fichier PASCAL voici ce que l’on peut mettre :

{$IFDEF FPC}
{$i Unite.lrs}
{$ENDIF}

Ces trois lignes signifient : si la directive FPC ou COMPILATEUR FREE PASCAL est activée alors inclure le fichier « Unite.lrs ».

LAZARUS utilise d’autres fichiers ressources que Turbo PASCAL ou DELPHI.

On appelle les fichiers ressources LAZARUS les fichiers .lrs qui nécessitent idéalement d’avoir des fichiers images en format image compressée XPM. Les images compressées permettent de réduire la taille de l’exécutable. Il faut éviter de répéter les mêmes images à différents endroits de votre logiciel. C’est pour cela que les fichiers ressources et les composants LAZARUS existent.

Vous avez peut-être des ressources bitmap non compressées; alors, l’idéal serait de les traduire grâce à GIMP en fichier XPM. Pour faire cela, ouvrez votre fichier BITMAP avec GIMP puis enregistrez le fichier en remplaçant l’extension BMP par XPM.
Dans C:\LAZARUS sous WINDOWS ou /usr/lib/lazarus sur LINUX, il y a l’outil lazres dans le répertoire tools de LAZARUS. Après avoir compilé le projet, cet outil permet de créer le fichier ressource lrs avec comme premier paramètre le fichier ressources. Puis les images peuvent être indéfiniment ajoutées en séparant chaque paramètre par un espace.

4-13-1. Les déclarations publiques▲

4-13-2. Le code source exécuté▲

4-13-3. Le code source exécuté au chargement▲

4-13-4. Fin de l’unité▲

La complétion permet d’écrire à votre place. C’est indispensable pour tout programmeur voulant être aidé à coder.

procedure TForm1.ButtonClick(Sender: TObject);
begin
   ShowMessage(const Msg:String);
end;

type
  TForm1 = class(TForm)
  private
    procedure toto(s:string);
  public

procedure TForm1.toto(s:string);
begin
 
end;

begin
  if X >0 then x=0;
  if X<0 then x=-1;
  A:=truc+machintruc;
end;

begin
        if X >0 then x=0;
        if X<0 then x=-1;
        À:=truc+machintruc;
end;

if then
begin
 
end
else
begin
 
end;

4-14-1. Touches de raccourci projet▲

Les raccourcis de débogage sont généralement utilisés dans l’éditeur de source. Ils permettent de scruter le code source.