1. Introduction

Qu’est-ce qu’un composant (component) ?

Les composants Gambas sont de librairies partagées écrites en C ou C++ qui ajoutent de nouvelles fonctions à l’interpréteur Gambas.

Elles agissent comme les pilotes Linux envers le noyau Linux :

• Les composants et l’interpréteur communiquent via l’Interface de Programmation Gambas.

• Ils doivent être compilés à l’intérieur du paquetage source Gambas.

• Ils sont exécutés dans l’environnement de l’interpréteur, et ne doivent donc pas faire ce qu’ils veulent.

Un composant peut contenir:

• Les classes New qui sont ajoutées aux autres classes Gambas. Ces classes sont déclarées à l’interpréteur en utilisant une structure C qui contient la description de chaque symbole, méthode, constante et évènement.

• Les connections Interpréteur (hooks) : fonctions spéciales qui implémentent des opérations importantes de l’interpréteur, telles que gestion de la boucle d’évènement, lecture des paramètres du programme...

• Une interface de programmation qui enrichit l’Interface de Programmation Gambas, et que les autres composants peuvent utiliser.

Un composant doit avoir un nom. Ce nom est le mot gb suivi par une liste séparée par des points de tous les mots décrivant le rôle du composant et d’un autre composant duquel il dépend, s’il y en a.

Par exemple, gb.qt.kde est uncomposant qui transforme une application Gambas en application KDE. Ce composant s’appuie sur le composant gb.qt, c.a.d. que le chargement du premier implique le chargement du second.

L’Interface de Programmation Gambas

L’Interface de Programmation Gambas est un assortiment d’utilités, fonctions et macros qui vous permettent de :

• Décrire le composant.

• Définir les connexions interpréteur.

• Manipuler tableaux, tables de hachage...

• Manipuler des type de données natives Gambas.

• Créer tableaux et collections Gambas.

• Déclencher des évènements.

• Manipuler des objets Gambas.

• Charger un fichier à partir de l’archive du projet.

• Charger d’autres composants.

• ...

L’utilisation de cette Interface de Programmation est hautement recommandée, car elle évite qu’un composant fasse des choses bizarres.

L’Interface de Programmation Gambas est une structure C qui contient un pointeur de fonction pour chaque fonction de l’interface.

Cette structure est déclarée dans le fichier principal de votre composant, elle est automatiquement initialisée par l’interpréteur au chargement du composant.

Ecrire de Bons Composants.

L’écriture de bons composants est la partie difficile! Supposons que vous vouliez écrire un composant SDL, c.a.d. un composant qui permette à un projet Gambas d’utiliser toute la puissance de la librairie SDL: graphiques, sons, CD-ROM...

Vous pourriez vous contenter de lier seulement les fonctions de la librairie, la structure et les constantes. C’est la facilité, même si la liaison avec les structures et les fonctions C risque, avec Gambas, de ne pas être possible dans tous les cas.

Votre composant serait utile, mais pas très intéressant pour le programmeur Gambas, parce qu’il serait contraint de programmer dans le style C ou C++.

Au lieu de cela, vous devriez vous creuser les méninges pour créer une interface différente entre Gambas et la librairie, en essayant de généraliser et simplifier l’interface originale de la librairie.

C’est ce que j’ai fait avec QT : c’est nettement plus aisé d’utiliser le composant QT que de programmer directement la librairie QT. Et si un jour quelqu’un écrit un composant GTK+, il pourra utiliser la même interface parce que j’ai essayé de généraliser l’interface QT en évitant tous les trucs spécifiques de QT... Bien, pour être franc, j’ai mis toutes les spécificités utiles de QT dans un composant étendu dédié, gb.qt.ext

Organisation des Sources des Composants.

Les fichiers sources d’un composant sont enregistrés dans un sous-répertoire du répertoire lib du paquetage source. Le chemin de ce répertoire reflète le nom du composant.

Par exemple, les composant sources gb.qt.kde sont enregistrés dans le répertoire ./src/lib/qt/kde.

Un répertoire de composant typique contient :

• Le bidule autoconf/automake, c.a.d. un fichier Makefile.am qui décrit comment compiler le composant. (new topic)

• Un fichier source et une entête de fichier pour chaque classe principale implémentée dans le composant.

• Un fichier main qui implémente les points d’entrée du composant.

• Un fichier description du composant.

Par exemple, voici le résultat de ls ./src/lib/qt/kde juste avant compilation :

La structure du répertoire source du composant ressemble à quelque chose comme ceci :