Lazarus - Développement rapide : Le Free Pascal

Voici comment procéder pour créer son premier logiciel.

Avant de créer son premier logiciel, il faut d'abord savoir si c'est utile de créer le logiciel voulu. Il faut d'abord vérifier que ce qu'on veut ne se fait pas déjà. À l'heure actuelle, seuls les logiciels avec une personnalisation accrue sont à créer.

Dans notre premier exemple, nous allons tester la création de notre interface homme-machine. On créera un utilitaire de recherche ou de remplacement à personnaliser. Nous créerons aussi notre propre savoir-faire centralisé.

Un logiciel se doit d'être créé rapidement. Nous allons rapidement créer une interface homme-machine. LAZARUS est un outil permettant de créer rapidement un logiciel grâce à son interface graphique et du code uniquement dédié au développement.

Avant de commencer, il faut savoir s'il est possible de créer rapidement son logiciel. Aller dans « Fichier » puis ..

Pour créer rapidement son logiciel, il suffit de placer correctement les composants après avoir cliqué sur un composant de la palette de composants. La palette de composants comporte un ensemble d'onglets identiques à des onglets de classeur. Lorsque vous cliquez sur un onglet portant un certain nom, un ensemble de composants classés sous ce nom s'affichent.

Vous voyez qu'il est possible de placer un certain nombre de composants sans limites de présentation.

Certains composants que vous placez sur votre formulaire ne seront représentés que par le même graphisme de même taille que son icône situé dans la palette. Ces composants n'ont en général aucune propriété graphique. Ce sont des composants invisibles capables de réaliser certaines opérations visuelles ou pas.

D'autres composants que vous placerez ajouteront un visuel à votre formulaire. Ce sont des composants visuels. Avant de placer vos composants visuels, n'oubliez pas d'utiliser un composant « TPanel » pour une présentation soignée. Les Composants « TPanel » permettent à vos composants visuels de se disposer sur l'ensemble de l'espace visuel disponible.

Disposez un composant de présentation.

1-6-1. Une présentation soignée▲

1-6-2. L'Interface Homme Machine▲

procedure TForm1.ConvertirClick(Sender: TObject);
var li_i : Integer ;
begin
  For Li_i := 0 To FileListBox.Items.Count - 1 do
    Begin
      ConvertitFichier ( DirectoryEdit.Directory + DirectorySeparator + FileListBox.Items.Strings [ li_i ], FileListBox.Items.Strings [ li_i ] );
    End ;
end;

procedure TForm1.ConvertitFichier(const FilePath, FileName : String);
var li_i : Integer ;
    ls_Lignes : WideString ;
    lb_DFM ,
    lb_LFM : Boolean ;
    lst_Lignes : TStringList ;
begin
  lb_DFM := PosEx ( '.dfm', LowerCase ( FilePath ), length ( FilePath ) - 5 ) >= length ( FilePath ) - 5 ;
  lb_LFM := PosEx ( '.lfm', LowerCase ( FilePath ), length ( FilePath ) - 5 ) >= length ( FilePath ) - 5 ;
  lst_Lignes := TStringList.Create;
  try
    lst_Lignes.LoadFromFile ( FilePath );
    ls_Lignes := lst_Lignes.Text;
 
    Application.ProcessMessages;
        // Conversion Extended
    ls_Lignes := StringReplace ( ls_Lignes, 'TADOQuery', 'TZQuery', [rfReplaceAll,rfIgnoreCase] );
 
     if lb_DFM
     or lb_LFM Then
       Begin
       End;
      else
       Begin
       End;
 
    Application.ProcessMessages ;
    lst_Lignes.Text :=  ls_Lignes ;
    lst_Lignes.SaveToFile   ( FilePath );
  finally
    lst_Lignes.Free;
 
  end;
end;

Si vous observez que les caractères accentués ne sont pas gardés, c'est à cause des caractères ANSI. En effet, il existe des caractères deux fois plus longs, les caractères UTF16. Ces caractères permettent une lecture presque internationale pour les pays possédant un alphabet de lettres.

Il faut vérifier si le TStringlist utilise des WideStrings. Ce sont des chaines avec des caractères deux fois plus volumineux.

Ce chapitre est une aide servant à améliorer vos projets grâce à INTERNET.

LAZARUS possède à son installation un nombre limité de composants. Il est possible de trouver des savoir-faire sur INTERNET. Pour trouver un composant, il faut définir ce que l'on souhaite ainsi que les alternatives possibles. Ce ne sera qu'avec l'expérience que l'on trouvera des composants adéquats.

Sur votre moteur de recherche, il faudra de préférence taper des mots anglais comme « component », « project » ou « visual » avec « LAZARUS » voire « DELPHI ». Puis avec ces mots, tapez votre spécification en anglais. Changez de mots ou de domaines si vous ne trouvez pas.

1-8-1. Vérifier les licences▲

1-8-2. Compilateur FREE PASCAL▲

Dans votre logiciel, le développeur et l'utilisateur doivent être guidés. Des erreurs peuvent se produire dans le code servant au développement ou celui servant à l'utilisateur. En général, les erreurs de développement doivent être en anglais tandis que les erreurs de l'utilisateur sont multilingues.

Il faut donc anticiper ce qui va se passer dans son programme. Imaginez un utilisateur tombant sur une erreur en anglais alors qu'il ne connaît pas cette langue. Il faut donc en plus un manuel de l'utilisateur permettant de trouver les informations nécessaires à la poursuite de l'utilisation du logiciel.

Les exceptions permettent de gérer les erreurs ou bien de les rediriger correctement vers l'utilisateur. Méfiez-vous des logiciels qui rapportent peu d'erreurs. En général, on ne sait pas comment les utiliser.

try
  for i:=0 to 20 do
    chaine := chaine + chaine;
except
    Showmessage ( 'La chaine de mon formulaire est trop longue. Il n'y a plus assez de mémoire.' );
end;

Cette gestion d'exception commence à « try » et finit à « end ». La partie entre « try » et « except » rapporte vers la partie entre « except » et « end » l'erreur éventuelle.
Dans cette gestion d'exception, on induit qu'une erreur produite est due au manque de mémoire.

Voici la même gestion d'exception mieux construite :

try
  for i:=0 to 20 do
    chaine := chaine + chaine;
except
  On E:EOutOfMemory do
    Begin
       Showmessage ( 'La chaine de mon formulaire est trop longue. Il n'y a plus assez de mémoire.' );
    End;
  On E:Exception do
    Showmessage ('Erreur avec la chaine. Le résultat peut être tronqué.');
end;

L'instruction « On E:Exception do » suivie de sa gestion récupère toutes les erreurs d'exception produites. Si elle est seule, elle peut être éludée. C'est pourquoi on place une exception héritée au-dessus de l'exception ancêtre lorsqu'on utilise ce genre de gestion d'exception.

1-10-1. Renvoyer les exceptions▲

type EStringTooLarge : EOutOfMemory;
begin
  if length ( chaine ) > 1000 Then raise (  EStringTooLarge );
  for i:=0 to 20 do
    chaine := chaine + chaine;
end;

Les bases de données sont des espaces de stockage organisés permettant de sauvegarder les informations nombreuses de ou des utilisateurs d'un logiciel. Un logiciel créé grâce à une base de données pourra en général accepter un grand nombre d'informations voire d'utilisateurs.

1-11-1. Le pouvoir du libre▲

SQL Lite permet de créer des logiciels possédant une base de données embarquée. Cette base de données embarquée sera indépendante de tout serveur de données centralisé. Cela permet de créer des logiciels possédant beaucoup de données sans avoir besoin d'être connecté à un réseau.
Il sera possible d'envoyer des données et de les réceptionner. Il faudra donc vérifier si le Système de Gestion de Données peut le faire. Il est possible de créer des composants de communication de données. Il en existe sur DELPHI.

Un objet est une entité interagissant avec son environnement. Par exemple, votre « clavier » d'ordinateur est un objet. Ce « clavier » possède des « touches » qui peuvent aussi être des objets « touche ». Vous voyez qu'il est possible de définir un objet « Clavier » ou un objet « Touches ». Préférez l'unicité en mettant en tableau votre objet « Touche » au sein de votre objet « Clavier ». Vous créez un attribut au sein de votre objet « Touche ».

Avec la notion de programmation par objets, une méthode de programmation proche de l'humain, il convient d'énoncer la notion de classe. Lors du tout premier exemple, on avait déclaré une classe dans le premier chapitre. Cette notion de classe est présente dans le FREE PASCAL. Elle a été ajoutée au PASCAL standard.

Ce que l'on a pu nommer jusqu'à présent objet est, pour FREE PASCAL, une classe d'objet. Il s'agit donc d'un type FREE PASCAL. L'objet FREE PASCAL est une instance de classe, plus simplement un exemplaire d'une classe, son utilisation en mémoire.

On peut remarquer que FreePascal pour sa part définit une classe comme un « pointeur vers un objet (type « classe ») ou un enregistrement (type « record ») ».

2-2-1. Les attributs et propriétés▲

Deux objets « Clavier » peuvent être faits de la même manière avec une couleur différente. Ce seront toujours deux objets « Clavier » avec un attribut différent. L'attribut est une propriété d'un objet. Un attribut peut être une couleur, un nombre, du texte, ou bien un autre objet.

Seulement, en LAZARUS, les variables peuvent être enregistrées dans l'EDI comme des propriétés. Elles sont alors sauvées dans l'objet « TForm » visible ou le « TDataModule » invisible. Seulement, ces objets n'ont pas besoin de LAZARUS pour charger leurs propriétés à l'exécution.

Au début du livre, un formulaire possédait des propriétés permettant d'automatiser facilement le développement. Les propriétés de l'inspecteur d'objets sont du code source servant uniquement au développement. Elles vous ont permis de gagner beaucoup de temps dans la création de votre premier logiciel LAZARUS.
Les développeurs LAZARUS ont soigneusement séparé les unités de propriétés servant au développement du code source exécuté. Vous ne trouverez pas les objets lisant les propriétés dans l'inspecteur d'objets incluses dans votre exécutable. Lorsque vous concevrez votre premier composant, il faudra aussi séparer le code source de développement du code source exécuté. Vous ne devrez jamais lier dans vos projets une unité de propriétés puisqu'elles ne servent qu'à LAZARUS. C'est pour cette raison que des unités spécifiques à l'enregistrement des composants sont à part des unités de composants.

2-2-2. Les méthodes et évènements▲

Les formulaires LAZARUS utilisent l'objet. Vous voyez une définition d'un type Objet dans chacune des unités de votre formulaire. Vous avez donc utilisé de l'Objet sans le savoir.
Un type Objet se déclare de cette manière :

type
    TForm1 = class ( TForm )
    end;

On crée ici une nouvelle classe qui hérite de la class « TForm ». Vous pouvez appuyer sur « Ctrl » puis cliquer sur « TForm » pour aller sur la déclaration du type « TForm ». Vous ne voyez alors que des propriétés, car « TForm » hérite lui aussi de « TCustomForm », etc.

Notre formulaire se crée donc grâce à l'objet « TForm ». Cet objet possède la particularité de gérer un fichier « lfm » contenant les objets visibles dans la conception du formulaire.
Votre formulaire est compris par LAZARUS par le procédé de l'héritage. Il n'utilise que rarement toutes les possibilités du type formulaire surchargé.
Vous pourriez donc utiliser un autre type descendant de « TForm » pour votre formulaire. C'est possible. Cependant, tout composant LAZARUS est hérité du composant le plus proche de son résultat demandé. Il faut donc hériter votre formulaire du composant « TForm » ou « TCustomForm ». Vous pouvez voir que ces deux Objets ne diffèrent que par la visibilité de leurs propriétés, car « TForm » hérite de « TCustomForm ».

Vous voyez des déclarations de variables dans l'objet « TForm ». Ces variables seront mises en mémoire par le constructeur du formulaire. Vous ne voyez en général pas de constructeur dans un formulaire descendant de « TForm ». En effet, LAZARUS met automatiquement en mémoire vos variables de composants déclarées grâce à chaque fichier « .lfm » créé. Ce fichier « .lfm », c'est votre formulaire visuellement modifiable grâce à la souris et à l'inspecteur d'objets.

2-3-1. La surcharge▲

procedure DoClose(var CloseAction: TCloseAction); virtual;

procedure DoClose(var CloseAction: TCloseAction); override;

procedure TForm1.DoClose(var CloseAction: TCloseAction);
begin
  inherited DoClose(CloseAction);
end;

Nous venons de voir par la surcharge le procédé de l'encapsulation. L'encapsulation permet de cacher des comportements d'un objet afin d'en créer un nouveau.

L'encapsulation existe déjà dans les langages procéduraux. Vous pouvez déjà réutiliser une fonction ou procédure en affectant le même nom à la nouvelle fonction ou procédure. Seulement, il faut alors utiliser le nom de l'unité pour distinguer les deux fonctions ou procédures. L'encapsulation en PASCAL non Objet est donc approximative, car on peut se tromper facilement de fonction ou procédure identique. En effet, on évite de créer les mêmes noms de fonctions ou procédures, car cela crée des conflits sans forcément que l'on s'en aperçoive.

Au travers des unités et autres librairies, l'encapsulation prend une dimension objet.
L'intérêt de l'encapsulation est subtil et humain. Si vous créez un descendant d'un bouton en surchargeant la méthode « Click » afin de créer un évènement centralisé et que vous utilisez ce bouton dans votre formulaire, vous vous apercevez que vous ne pourrez jamais appeler la méthode « Click » de ses ancêtres. Autrement dit, l'encapsulation permet de modifier légèrement le comportement d'un objet afin d'en créer un nouveau répondant mieux à ce que l'on cherche.

Autrement dit, on s'aperçoit ici que la programmation objet demande plus de mémoire que la programmation procédurale. En effet, il est possible d'éluder le code source de la méthode encapsulée.

Cependant, l'objet permet de gagner du temps dans le développement grâce à l'automatisation des systèmes humains puis informatiques. L'objet permet aussi de maintenir plus facilement le code source créé. Avec LAZARUS, tout objet composant d'un formulaire est consultable par simple clic de souris grâce à l'inspecteur d'objet.
Une variable ne peut pas être héritée, mais peut être de nouveau déclarée. Cependant, l'ancienne variable prend alors la place réservée à son pointeur à l'exécution. Il est même possible que vous ne puissiez empêcher le constructeur de la variable de mettre en mémoire ses autres variables s'il s'agit d'une classe. Quand trop de variables fantômes sont présentes dans l'ancien composant hérité, il faut se demander s'il est utile de créer un nouveau composant héritant du composant précédent. En effet, les variables fantômes sont tout de même en mémoire.

2-4-1. La déclaration « private »▲

2-4-2. La déclaration « protected »▲

2-4-3. La déclaration « public »▲

2-4-4. La déclaration « published »▲

// récupère une propriété d'objet
// aComp_ComponentToSet : Composant cible
// as_Name      : Propriété cible
// a_ValueToSet         : Valeur à affecter
function fmet_getComponentMethodProperty ( const aComp_Component : TComponent ; const as_Name : String ) : TMethod ;
Begin
  if   assigned ( GetPropInfo ( aComp_Component, as_Name ))
  and  PropIsType      ( aComp_Component, as_Name , tkMethod)
  then Result := GetMethodProp   ( aComp_Component, as_Name );
End ;

{$mode Delphi} // Directive de compilation permettant d'enlever les ^ de pointeurs
 
Var MonClick : TNotifyEvent ;
Begin
MonClick :=TNotifyEvent ( fmet_getComponentMethodProperty ( AComponent , 'OnClick' ));
if assigned ( MonClick ) Then
  MonClick (  Acomponent );
End;

2-4-5. Les constructeurs et destructeurs▲

Interface
uses Classes ;
 
  TReadText = class(TComponent)
  MonFichierTexte : TStringlist;
  public
    constructor Create(TheOwner : TComponent);
    destructor Destroy;
  end ;
 
implementation
 
constructor TReadText.Create(TheOwner : TComponent);
begin
  Inherited Create(TheOwner);
  MonFichierTexte := nil;
end ;
destructor TReadText.Destroy;
begin
  Inherited Create(TheOwner);
  MonFichierTexte.Free;
end;

Le terme polymorphisme est certainement celui que l'on appréhende le plus. Pour le comprendre analysons la sémantique du mot : « poly » signifie plusieurs et « morphisme » signife forme. Le polymorphisme traite de la capacité de l'objet à posséder plusieurs formes.
Cette capacité dérive directement du principe d'héritage vu précédemment. En effet, un objet hérite des champs et méthodes de ses ancêtres. On peut redéfinir une méthode afin de la réécrire ou de la compléter.

Le concept de polymorphisme permet de choisir en fonction des besoins quelle méthode ancêtre appeler, et ce pendant l'exécution. Le comportement d'un objet polymorphe devient donc modifiable à volonté.

Le polymorphisme est donc la capacité du système à choisir dynamiquement la méthode de l'objet en cours. Ainsi, si l'on considère un objet Véhicule et ses descendants Bateau, Avion, Voiture. Ces objets possèdent tous une méthode Avancer, le système appelle la fonction Avancer spécifique suivant que le véhicule est un Bateau, un Avion ou bien une Voiture.

2-5-1. Le type « interface »▲

2-5-2. Polymorphe avec les propriétés publiées▲

L'Abstraction ne sert en LAZARUS qu'à centraliser plusieurs objets en héritant d'un objet abstrait, donc pas utilisable. Cet objet abstrait possède en fait des méthodes dites « abstraites » ou « abstract » non implémentées dans l'objet abstrait. Voici à quoi l'abstraction ressemble :

procedure Nager; abstract;

Cette déclaration est la seule à ne pas demander d'implémentation. Elle crée une erreur malgré tout si son descendant n'implémente pas la méthode « Nager ».
Ainsi, l'objet abstrait qui nage n'a pas besoin de savoir comment il nage. Les différents descendants nagent en fonction du type classe créé. Une classe « Poisson » nage en oscillations horizontales. Une classe « Humain » nage en brasse, en crawl, en papillon, etc. On crée donc dans la classe Humain des méthodes secondaires. Il reste à définir comment on choisit le type de nage en fonction de l'objet créé.

Une instance d'objet en UML est un objet en mémoire en FREE PASCAL.
L'objet en UML est une classe d'objet en FREE PASCAL.

Le PASCAL Objet permet de créer des Instances d'Objets. Une Instance d'Objet, c'est un objet mis dans la mémoire de l'ordinateur à l'exécution. Une Instance d'Objet peut être dupliquée et sera personnalisée grâce à ses variables. Si votre Classe d'Objet et ses Classes parentes ne contiennent aucune variable, il faut se poser la question de leur utilité. Puis-je gagner du temps en créant une unité de fonctions à la place ?
Vous créerez votre Objet, qui est instancié une ou n fois en exécution. Par exemple, les formulaires prennent beaucoup de place en mémoire donc on les instancie en général une fois.
Les variables simples de votre objet sont dupliquées et initialisées à zéro pour chaque Instance créée.

FREE PASCAL possède une syntaxe permettant de créer des composants qui sont des Objets avec des propriétés. Les propriétés permettent, si elles sont correctement créées, de mieux gérer le polymorphisme. Les propriétés publiées permettent la rapidité en étant présentes dans l'inspecteur d'objets.

Il ne faut pas être créatif pour nommer ses propriétés. Il faut reprendre ce qui existe déjà au sein de LAZARUS afin de mieux gérer le polymorphisme. Une propriété doit être nommée du même nom que les propriétés de même nature. Il faut donc connaître le nom des propriétés des composants de même nature afin de créer des propriétés identiques. On essaie d'être compatible avec certains composants de même nature en définissant des propriétés identiques.

STAR UML est un outil libre donc partagé en licence GNU/GPL.
Il a été fait sous DELPHI. Vous pouvez donc tenter de le traduire vers LAZARUS après avoir vérifié que quelqu'un ne le fait pas déjà. Dans ce cas, il faut participer au projet de traduction qui peut être intégré au projet STAR UML.

Vous pourrez vous aussi créer votre savoir-faire en créant d'abord des projets. En créant ces projets, nous vous apprendrons à centraliser ce qui aurait été redondant. Il faut éviter le copier-coller. Vous créez des unités de fonctions en centralisant un code redondant.
Une unité de fonctions, c'est un regroupement de fonctions autour d'un même thème. Si la fonction que vous ajoutez n'est pas immédiatement associée à ce thème, n'hésitez pas à en trouver un nouveau. On crée alors une nouvelle unité.

LAZARUS sans les composants ne serait pas utile. LAZARUS permet de créer rapidement des logiciels grâce aux composants. La programmation par composants est rapide sur LAZARUS grâce à l'inspecteur d'objets. Vous pouvez décupler votre vitesse de création avec LAZARUS et ses composants visuels.
Il est recommandé d'améliorer ou de créer des composants qui sont facilement mis en place. Ainsi, votre savoir-faire ou vos composants sont centralisés dans des paquets de composants puis dans une voire plusieurs librairies utilisant vos composants.
Un paquet est un regroupement de composants. Les paquets sont installés rapidement sur LAZARUS.

Les composants sont visibles dans LAZARUS. Les composants visuels sont directement modifiables dans LAZARUS. Vous disposez d'un inspecteur d'objet permettant de voir en temps réel la visibilité de votre composant.

Vos unités de fonctions pourront ensuite améliorer des composants par le procédé de l'héritage ou par la participation Open Source. Vous créerez votre premier paquet en apprenant l'objet. Vos unités de fonctions seront utilisées et améliorées. Vous participerez à un projet Open Source après avoir vérifié la licence Open Source. Si la participation au projet est refusée, il faut se poser des questions de l'utilité de cette participation. L'entreprise qui refuse la participation peut avoir d'autres objectifs que les vôtres.

LAZARUS, c'est une interface facilitant la programmation. Un composant LAZARUS est mis en place rapidement grâce à l'inspecteur d'objets. Cet inspecteur permet d'affecter les propriétés de vos composants comme si vous étiez un simple utilisateur. Les propriétés permettant de développer sont un supplément sur le formulaire ouvert. Elles sont et doivent donc être situées en dehors du code source d'exécution.
Votre composant peut être amélioré grâce à la communauté. Cela ne vous empêche pas, par contre, de toujours être compétitif en recherchant d'autres projets à créer pour hériter vos ou d'autres composants.

Nous allons changer la couleur d'un bouton et lui affecter une image. À chaque bouton créé sera affectée une seule image. Ainsi, l'exécutable sera plus léger. Ce bouton permettra de fermer un formulaire.

Le composant qui va être créé va donc répondre à une demande technique : la taille de l'exécutable et la centralisation des sources. La centralisation des sources va cependant permettre de répondre à l'automatisation de son savoir-faire. Cela va donc permettre de répondre plus rapidement à la demande du client.

Pour créer votre paquet personnalisé, faites « Fichier » puis « Nouveau » puis « Paquet ».

« Ajouter » un « Nouveau fichier » « Unité », puis « Ajouter » la condition « LCL ». Une condition est un paquet utilisé. Le paquet LCL contient tous les composants standards.
Sauvegardez votre unité sous le nom « u_buttons_appli ».
Créez dans le répertoire du paquet un fichier vide « u_buttons_appli.lrs ».

Enregistrez votre paquet en cliquant sur « Enregistrer » dans le projet paquet. Affectez-lui le nom « LazBoutonsPersonnalises ».
Ajoutez ses deux types dans la partie interface de votre unité :

type
   IMyButton = interface
   ['{620FE27F-98C1-4A6D-E54F-FE57A06207D5}']
   End ;

On déclare un type interface permettant d'indiquer que nos boutons supportent tous le type « IMyButton ». La chaine hexadécimale permet d'utiliser la méthode « support » dans toute classe afin de reconnaître le type « IMyButton ». Ainsi, nous retrouvons plus facilement nos boutons. Nous utilisons le polymorphisme pour reconnaître nos propres boutons.

Voici le code source permettant de reconnaître nos boutons :

If VariableDeTypeClasse.Support ( IMyButton ) Then
  Begin
    ShowMessage ( 'C'est mon bouton !' );
  End;

Il faut en FREE PASCAL définir au maximum ce que l'on fait. Les définitions permettent d'utiliser l'objet afin d'améliorer l'utilisation de nos composants.
Juste après la définition de l'interface « IMyButton », placez ce code :

TMyClose = class ( TBitBtn,IMyButton )
      private
      public
       constructor Create(TheOwner: TComponent); override;
       procedure Click; override;
      published
       property Glyph stored False;
     End;

Le constructeur Create et la méthode Click sont présents dans le composant TBitButton par l'héritage. Nous les surchargeons par le mot clé « override » suivi d'un « ; ».

Grâce au polymorphisme LAZARUS, vous pouvez changer l'ancêtre « TBitBtn » par un ancêtre bouton possédant un « Glyph ». D'autres boutons avec « Glyph » existent en dehors du projet LAZARUS.
Tous les composants LAZARUS possèdent le constructeur Create avec, comme paramètre, le propriétaire du composant. Notre composant sera donc automatiquement détruit lorsque son parent se détruira.

Aussi tous les composants descendants de la classe TLCLComponent possèdent la méthode « Click » sans aucun paramètre. Une méthode qui peut être surchargée possède le mot clé « virtual ». Le composant ancêtre définissant la méthode utilise donc le mot clé « virtual » sur la méthode créée. Vous pouvez donc facilement vérifier si c'est bien TLCLComponent qui définit « Click » en maintenant « Ctrl » enfoncée puis en cliquant sur chaque type ascendant utilisé.
Pour chercher l'unité du bouton « TBitBtn », cherchez dans tous les répertoires du code source de LAZARUS la bonne unité. Sinon, cette unité s'appelle « Buttons ». Cette unité est incluse dans le paquet LCL. Il faut donc « Ajouter » la « Condition » « LCL » dans le paquet.

Si votre code source est bon, vous pouvez appuyer sur « Ctrl »+ « Shift » + « C ». Cela va créer les deux méthodes. Vous pouvez compiler le paquet pour trouver des erreurs.
Maintenant, nous allons remplir les deux méthodes surchargées dans la partie « implémentation » :

uses Forms;
 
 // Créer des constantes permet d'éviter de se tromper  pour leur réutilisation
const
   CST_FWCLOSE='TMyClose';  // Nom du fichier XPM
 
{ TMyClose }
 
procedure TMyClose.Click;
begin
  if not assigned ( OnClick )
  and ( Owner is TCustomForm ) then
    Begin
      ( Owner as TCustomForm ).Close; // Fermeture du formulaire
      Exit;
    End;
  inherited;
end;
constructor TMyClose.Create(TheOwner: TComponent);
begin
  inherited Create ( TheOwner );
  if Glyph.Empty then
    Begin
      Glyph.LoadFromLazarusResource ( CST_FWCLOSE); // Charge le fichier XPM
    End;
end;

Voilà l'essentiel de notre composant « TMyClose ». La procédure surchargée « Click » ferme le formulaire s'il n'y a pas d'évènement de Click sur le Bouton dans le formulaire. Il suffit que ce code source soit exécuté une seule fois dans l'application pour que ce code source ait rempli un objectif d'automatisation.
On passe la méthode « Click » héritée par la méthode « Exit ». On a vérifié, avant d'éluder la méthode « Click » de l'ancêtre, qu'il n'y avait que la gestion de l'évènement « OnClick » que l'on évitait. Nous n'éludons effectivement pas l'évènement « OnClick » en vérifiant s'il existe. Ainsi, on évite de revérifier l'évènement « OnClick ».

Le code spécifique est automatisé avec le maximum de composants possédant différents objectifs. Il faut cependant se rendre compte que, bien que le composant permette de centraliser, il augmente aussi la taille de l'exécutable.

Si la fonction de fermeture était sur chaque évènement de chaque bouton, cela alourdirait l'exécutable. Aussi, si les conditions techniques de fermeture du formulaire changeaient, il faudrait changer le code source de chaque bouton.

4-3-1. Choix de l'image▲

initialization
  {$I u_buttons_appli.lrs}
end.

À l'enregistrement du composant et en fonction de la surcharge effectuée, celui-ci voit certaines de ses propriétés reconnues par LAZARUS afin d'éditer rapidement le composant. Il est possible d'utiliser des propriétés voire de les surcharger dans son unité d'enregistrement de composants.

Un composant est un objet descendant de l'objet TComponent. Tout composant LAZARUS descendant de TComponent peut être accessible dans la palette de composants. Pour qu'un composant soit enregistré dans une palette, voici le code source à affecter à une unité d'enregistrement du composant.

L'unité d'enregistrement ne doit jamais être utilisée dans votre programme. En effet, le code source de développement est inutile pour le programme exécutable. Créez cette nouvelle unité dans votre paquet :

Unit u_regboutons;
 
interface
 
uses Classes ;
 
procedure Register ;
 
implementation
 
uses u_buttons_appli;
 
procedure Register;
begin
  RegisterComponents('MesBoutons', [TMyClose]);
end ;
 
end.

La procédure « Register » doit être exécutée par le paquet qui installe le composant. Il faut donc vérifier pour cette unité si la case à cocher « Référencer l'unité » est cochée.

4-4-1. Modifier ou Surcharger ?▲

4-4-2. Surcharger un composant▲

Un paquet de composants est mis en place rapidement. En voulant être encore plus rapides, vos paquets deviennent une librairie complète paramétrable au minimum voulu. Vous sublimerez alors votre capacité d'adaptation en ne créant que l'utile.

Ce qui sera personnalisé sera paramétrable. Le reste se configurera automatiquement. Une librairie fournit des outils et des procédés pour créer son logiciel sans perdre de temps. Il faudra améliorer l'IDE LAZARUS ou bien éviter d'utiliser l'IDE avec des fichiers de configuration. Ces fichiers pourront être idéalement des fichiers analytiques UML ou MERISE. Ces fichiers vous permettront d'être indépendant de LAZARUS en utilisant les mêmes savoir-faire sur d'autres outils de programmation.

LAZARUS contredit les professeurs ou institutions indiquant que les composants passent plus de temps à être maintenus qu'à être utilisés. Un composant LAZARUS fait gagner beaucoup de temps grâce à l'inspecteur d'objets et au code source de développement.
Votre composant, s'il est bien documenté, peut devenir un atout fiable faisant connaître votre société. Il peut aussi être sauvé de l'abandon grâce à une communauté toujours plus avare de composants libres. Un composant qui devient libre veut soit être populaire soit se faire connaître pour survivre.

Créer un composant libre permet de certes faire connaître votre composant, mais aussi de trouver le moyen de savoir si on reste le meilleur dans son domaine en créant une communauté sondant les utilisateurs et contributeurs. N'espérez pas des contributeurs qu'ils collaborent sans être rémunérés. Mais attendez d'eux une expertise sur votre savoir, des aides pour vous promouvoir. Ces aides ne sont peut-être pas celles que vous souhaitez. Elles permettent donc de trouver de nouveaux marchés.

FREE PASCAL permet de créer des savoir-faire multiplateformes à partir de savoir-faire WINDOWS comme DELPHI ou TURBO PASCAL.
À partir de ces savoir-faire ou logiciels, on peut créer des librairies FREE PASCAL. Mais cela demande l'adaptation d'une partie des sources.

Pour transférer un logiciel TURBO PASCAL textuel, il faut juste réutiliser les bonnes unités. Elles se trouvent nécessairement dans LAZARUS ou FREE PASCAL.
Pour transférer un savoir-faire TURBO PASCAL graphique, il faut soit :

• Insérer la partie graphique dans une fenêtre et adapter la taille graphique à la fenêtre
• Recréer la partie graphique avec les composants visuels

5-2-1. Choisir un gestionnaire de données▲

Lorsque son logiciel est créé en DELPHI, le transfert consiste à utiliser des composants LAZARUS à la place des composants DELPHI. Il est possible que son logiciel reste compatible DELPHI grâce aux directives de compilation.
Vous pouvez trouver les composants qui vous manquent grâce à une recherche sur un site web de composants comme lazarus-components.org.

Pour traduire un composant DELPHI vers LAZARUS, il est préférable que ce composant reste compatible DELPHI grâce aux directives de compilation. Cela permet de participer au projet existant et de centraliser les sources.
Il faut remplacer le code graphique et les liens vers les librairies WINDOWS par du code source LAZARUS. LAZARUS possède une large bibliothèque de code source.
Le code graphique LAZARUS utilise les différentes librairies libres de chaque plateforme. Ces différentes librairies sont homogénéisées en des librairies génériques.
Les unités à ne pas utiliser sont les unités spécifiques à une seule plateforme comme les unités :

• win pour WINDOWS ;
• gtk pour LINUX ;
• carbon pour MAC OS ;
• unix pour UNIX.

Si vous êtes obligé d'utiliser une de ces unités, sachez que vous aurez peut-être une unité générique dans la prochaine version de LAZARUS. Votre composant sera compatible avec la seule plateforme de l'unité non générique utilisée.

Si vous ne trouvez pas ce qu'il vous faut, recherchez dans les sources LAZARUS ou FREE PASCAL. Contactez sinon un développeur LAZARUS. Il vous indiquera ce que vous pouvez faire.