Programmation XPCom pour XUL
Cross-platform Component Object Model- Qu'est-ce que XPCom?
- Pourquoi utiliser XPCom?
- Comment utiliser XPCom?
- Vocabulaire
- XPConnect
- L'interface nsISupport
- Comment créer un composant XPCom
- Les outils de XPCom
- Regxpcom
- Xpidl
- Générateur de GUID
- Le SDK Gecko
- Création d'une interface
- Création du projet pour Windows
- Liens et ressources
Qu'est-ce que XPCom?
C'est une plateforme de développement de composants logiciels.
C'est un moyen de créer des librairies de fonctions réutilisables,
ou sous un autre point de vue, de morceler des programmes en composants indépendant,
construits séparément.
XPCom sépare le composant en deux parties: l'implémentation,
donc le code, et l'interface, la partie publique.
Le format prévoit de faire évoluer le code, tout en maintenant
la compatibilité avec les versions précédente.
Pourquoi utiliser XPCom?
- XPCom s'utilise avec Gecko, le programme d'affichage HTML et XML de Mozilla.
Il permet d'intégrer Gecko dans une application.
- C'est une alternative aux DLL de Windows, avec l'avantage de fonctionner
sur les principaux systèmes (Donc Windows, Linux, MacOS).
- On peut mettre à jour les composants sans réécrire
l'application entière.
- On ne charge en mémoire que les composants utilisés.
- La tâche de programmation est divisée sur les gros programmes.
Il est plus facile de travailler avec des composants spécialisés,
de taille réduite.
et surtout...
- XPCom est indispensable quand on utilise XUL, car il permet d'utiliser des
librairies écrites dans d'autres langages que JavaScript, lequel ne
permet par le traitement de fichiers notamment.
Comment utiliser XPCom?
Pour utiliser un composant, on crée une instance de la classe
qui, dans l'interface, représente ce composant.
Il y a aussi des objets appelés services, qui sont l'objet d'une
unique instance.
Les services fournissent un point d'accès unique aux fonctionnalités
du composant.
Vocabulaire
- Client Le programme qui utilise le fichier XPCom.
- Compilateur xpidl Outil qui compile la définition de l'interface écrite en xpidl, en fichiers d'en-têtes C++.
- Compteur de référence Compteur associé à un composant qui est incrémenté quand un programme charge le composant et décrémenté quand il le libère (quand le programme s'arrête).
- IDL Interface Definition Language. Langage utilisé pour définir un interface.
- Interface C'est ce que le client connaît du composant. Contrairement au code exécutable qui est caché.
- Module On parle de module lorsqu'un fichier XPCom contient plusieurs composants, rassemblés après compilation.
- Requête Utilisation du composant XPCom en passant par l'interface.
- Service Objet utilisé par plusieurs programme, mais dont il n'existe qu'un instance unique.
- XPConnect Voir ci-dessous.
- XPIDL Variante d'IDL utilisé par XPCom. Donc son propre langage d'interface. On s'en sert pour définir les méthodes, attributs et constantes des interfaces.
XPConnect
C'est une surcouche de XPCom qui permet à des langages de scripts
d'utiliser un composant.
XPConnect consiste en une représentation binaire de l'interface,
générée à partir de la définition
de l'interface dans le langage de définition d'interface, XPIDL.
L'interface nsISupport
C'est l'interface de base XPCom. Elle traite à la fois de la
question de la durée d'utilisation du composant et des requêtes.
Elle gère le compteur de référence. Elle gère
les requêtes.
Dans la pratique, c'est une classe avec quelques méthodes aux
noms cabalistiques.
Comment créer un composant XPCom
Le plus fréquemment, c'est un programme en C ou C++ et compilé
sous forme de DLL sous Windows, ou DSO sous Unix.
Ce module va exporter une méthode unique appelée NSGetModule.
Cette méthode est le point d'entrée dans le module, autrement
dit, on va appeler cette méthode avec certains paramètres pour
utiliser les fonctions du module.
Il y a aussi deux interfaces qui contrôlent la création
du module:
- nsIModule
- nsIFactory
Les outils de XPCom
Ces outils sont inclus dans le SDK Gecko.Regxpcom
C'est un programme qui sert à enregistrer des composants XPCom.
Une fois le composant doté des deux interfaces précédentes
(Module et Factory), il suffit d'appeler regxpcom pour l'enregistrer.
On utilise l'option -h pour obtenir la liste des options.
Cependant, les utilisateurs de XUL peuvent se passer de cet outil en utilisant
XPInstall à la place.
Xpidl
Génère le fichier d'en-tête d'une interface et la librairie, à partir d'un fichier d'interface IDL.
Générateur de GUID
Vous aurez besoin d'un nombre d'identification "Guid" pour
votre composant. Vous pouvez le créer:
- sous Windows avec guidgen.
- sous Linux avec uuidgen.
Le SDK Gecko
Gecko est le moteur d'affichage de XUL. Son environnement de développement
contient tous les outils nécessaires pour créer un composant
XPCom.
Voir en ressources l'adresse où le télécharger.
Création d'une interface
Elle s'appelle par exemple: Zool. Le fichier de génération
d'interface sera IZool.idl.
Le modèle ci-dessous peut être réutilisé.
#include "nsISupports.idl"
[ scriptable, uuid(votreGUID) ]
interface IZool : nsISupports
{
long Add(in long a, in long b);
};
Ensuite vous utilisez xpidl pour générer l'interface.
D'abord, générer l'en-tête:
xpidl -m header -Idiringecko IZool.idl
Puis créer le typelib:
xpidl -m typelib -Idiringecko IZool.idl
Vous disposez maintenant d'un fichier IZool.h qui contient un
modèle d'en-tête.
Création de Zool.h (ne pas confondre avec IZool.h)
- Vous pouvez enclore votre code:
#ifndef _ZOOL_
#define _ZOOL_
#endif - Il faut inclure le modèle généré par
xpidl:
#include "IMyComponent.h" - Définir le nom du composant:
#define ZOOL_CLASSNAME "Mon exemple XPCom" - Définir l'identification
#define ZOOL_CONTRACTID "@mondomaine.com/XPCOMSample/Zool;1" - Générer un GUID avec un des programmes indiqué
et l'insérer:
#define ZOOL_CID lecodegénéré - Copier le modèle d'en-tête.
Il commence par: /* Header file */ - Remplacer _MY_CLASS_ par Zool.
Création de Zool.cpp qui contient votre code:
- Créer le fichier.
- Inclure l'en-tête:
#include "Zool.h" - Copier le modèle d'implémentation.
Il commence par: /* Implementation file */ - Remplace _MY_CLASS_ par Zool.
- Et ajouter vos propres fonctions...
Création du fichier de définition de module ZoolModule.cpp.
- Placer l'instruction d'include pour Factory.
#include "nsIGenericFactory.h" - Inclure l'en-tête de votre fichier de fonctions.
#include "Zool.h - Définissez un constructeur pour votre composant avec cette
macro-instruction:
NS_GENERIC_FACTORY_CONSTRUCTOR(MyComponent) - Ajouter le code suivant qui va définir le nom de classe,
l'identificateur de contrat et le GUID.
static nsModuleComponentInfo components[] = { { ZOOL _CLASSNAME, ZOOL _CID, ZOOL _CONTRACTID, ZoolConstructor, } };
- Pour exporter l'information à Gecko, ajouter:
NS_IMPL_NSGETMODULE("ZoolModule", components)
Création du projet pour Windows
Cela peut se faire avec l'interface graphique, ou un makefile.
- Créer un projet de type multithreaded DLL .
- Exclure l'utilisation des MFC.
- Exclure les exceptions.
- Définir deux variables:
- #XPCOM_GLUE
#MOZILLA_STRICT_API - Ajouter ces répertoires include aux chemins:
- c:\gecko-sdk\embedstring\include
- c:\gecko-sdk\xpcom\include
- c:\gecko-sdk\nspr\include
- c:\gecko-sdk\string\include - Ajouter quelques librairies:
embedstring.lib, xpcomglue.lib, nspr4.lib, plc4.lib, plds4.lib
Eventuellement des versions plus récentes.