diff options
Diffstat (limited to 'files/fr/mozilla/tech')
8 files changed, 1253 insertions, 0 deletions
diff --git a/files/fr/mozilla/tech/index.html b/files/fr/mozilla/tech/index.html new file mode 100644 index 0000000000..c624ad5a70 --- /dev/null +++ b/files/fr/mozilla/tech/index.html @@ -0,0 +1,13 @@ +--- +title: Technologies de Mozilla +slug: Mozilla/Tech +tags: + - Mozilla + - Reference + - Régionalisation + - XUL +translation_of: Mozilla/Tech +--- +<p>Mozilla a plusieurs technologies utilisées en composantes de ses projets. Celles-ci sont documentées ici.</p> + +<p>{{LandingPageListSubpages}}</p> diff --git a/files/fr/mozilla/tech/visualisation_et_recherche_du_code_source_mozilla_en_ligne/index.html b/files/fr/mozilla/tech/visualisation_et_recherche_du_code_source_mozilla_en_ligne/index.html new file mode 100644 index 0000000000..bdbde7f35c --- /dev/null +++ b/files/fr/mozilla/tech/visualisation_et_recherche_du_code_source_mozilla_en_ligne/index.html @@ -0,0 +1,37 @@ +--- +title: Visualisation et recherche du code source Mozilla en ligne +slug: Mozilla/Tech/Visualisation_et_recherche_du_code_source_Mozilla_en_ligne +tags: + - Developper avec Mozilla + - Mozilla Code source +translation_of: Mozilla/Tech/Viewing_and_searching_Mozilla_source_code_online +--- +<p><span id="result_box" lang="fr"><span class="hps">Le code source pour</span> <span class="hps">tous les projets</span> <span class="hps">de Mozilla</span> <span class="hps">hébergés</span> <span class="hps">dans</span> <span class="hps">le dépôt Mercurial</span> <span class="hps">et</span> <span class="hps">CVS</span> <span class="hps">peut être recherché</span> <span class="hps">et</span> <span class="hps">consulté en ligne</span> <span class="hps">à l'aide de</span> </span><a class="external external-icon" href="http://dxr.mozilla.org">DXR</a>.<span lang="fr"> C'<span class="hps">est</span> <span class="hps">une variante</span> <span class="hps">renforcée et</span> <span class="hps">améliorée de l'outil</span> <span class="hps">original </span><span class="hps">Linux Cross</span> <span class="hps">Reference</span><span>.</span></span></p> + +<p><span lang="fr"><span class="hps">Ne téléchargez pas</span> <span class="hps">le code source</span> <span class="hps">en parcourant toutes les pages du site </span><span class="hps">DXR</span><span> ;</span> <span class="hps">téléchargez plutôt</span> <a href="https://developer.mozilla.org/fr/docs/T%C3%A9l%C3%A9chargement_du_code_source_de_Mozilla">une archive</a> <span class="hps">ou</span> <span class="hps">utilisez</span> <a href="/fr/docs/Code_source_de_Mozilla_(Mercurial)">Mercurial</a> <span class="hps">ou <a href="/fr/docs/Code_source_de_Mozilla_(CVS)">CVS</a></span> à la <span class="hps">place.</span><br> + <br> + <span class="hps">DXR<span> </span>indexe</span> <span class="hps">plusieurs</span> <span class="hps">branches CVS</span> <span class="hps">et modules</span><span>;</span> <span class="hps">la racine</span> <span class="hps">MXR</span> la <span class="hps">plus intéressant</span> <span class="hps">pour un</span> <span class="hps">contributeur</span> <span class="hps">Mozilla</span> <span class="hps">est</span> </span><a class="external external-icon" href="http://dxr.mozilla.org/comm-central/">comm-central</a>,<span lang="fr"> <span class="hps">qui contient le</span> <span class="hps">dernier code source</span> <span class="hps">pour la plupart des</span> <span class="hps">produits Mozilla</span> <span class="atn hps">(</span><span>y compris</span> <span class="hps">Firefox</span><span>,</span> <span class="hps">Thunderbird</span><span>,</span> <span class="hps">SeaMonkey</span><span>,</span> <span class="hps">Sunbird</span> <span class="hps">/</span> <span class="hps">Lightning</span> <span class="hps">Chatzilla</span><span>,</span> <span class="hps">DOM</span> Inspector <span class="hps">et</span> <span class="hps">Venkman JavaScript</span> <span class="hps">debugger</span><span>) et est</span> <span class="hps">fréquemment mise à jour</span><span class="hps">.</span></span></p> + +<p><span class="short_text" id="result_box" lang="fr"><span class="hps">Certaines</span> <span class="hps">autres</span> <span class="hps">racines</span> <span class="hps">d'intérêt MXR</span></span><span class="short_text" lang="fr"><span class="hps"> sont:</span></span></p> + +<ul> + <li><a class="link-https" href="https://hg.mozilla.org/mozilla-central/">"mozilla-central"</a> <span id="result_box" lang="fr"><span title='"mozilla-central" contains current Firefox and Gecko development.'>contient le développement actuel de Firefox et Gecko. </span><span title="Releases branch off of this repository.">mets a disposition la branche de sortie de ce </span></span>dépôt<span lang="fr"><span title="Releases branch off of this repository.">. </span><span title='Also known as "Trunk" . + '>Aussi connu comme «Trunk».</span></span></li> + <li><a class="external" href="http://dxr.mozilla.org/comm-central/">"comm-central"</a> <span id="result_box" lang="fr"><span title='"comm-central" contains current Thunderbird, SeaMonkey and Calendar development.'>contient le développement </span></span><span lang="fr"><span title='"comm-central" contains current Thunderbird, SeaMonkey and Calendar development.'> actuelle de Thunderbird, SeaMonkey et de Calendar. </span><span title="Also contains a mirror of mozilla-central.">Il contient également une copie de mozilla-central. </span></span><span id="result_box" lang="fr"><span title="Releases branch off of this repository.">mets </span></span><span lang="fr"><span class="hps">à </span><span title="Releases branch off of this repository.">disposition la branche de sortie de ce </span></span>dépôt<span lang="fr"><span title="Releases branch off of this repository.">.</span></span></li> + <li><a class="link-https" href="https://hg.mozilla.org/releases/mozilla-1.9.1/">"mozilla-1.9.1"</a> <span id="result_box" lang="fr"><span title='"mozilla-1.9.1" contains Branch development on Firefox 3.5 and Gecko 1.9.1. + '>contient la branche de développement sur Firefox 3.5 et Gecko 1.9.1 .</span></span></li> + <li><a class="link-https" href="https://hg.mozilla.org/releases/comm-1.9.1/">"comm-1.9.1"</a> <span id="result_box" lang="fr"><span title='"mozilla-1.9.1" contains Branch development on Firefox 3.5 and Gecko 1.9.1. + '>contient la branche de développement pour</span></span> Thunderbird 3, SeaMonkey 2 et Sunbird 1 avec Gecko 1.9.1. <span id="result_box" lang="fr"><span title="Also contains a mirror of mozilla-1.9.1. + ">Il contient également une partie de</span></span> mozilla-1.9.1.</li> + <li><a class="external" href="http://mxr.mozilla.org/seamonkey/">"mozilla root '</a> <span id="result_box" lang="fr"><span class="hps">contient</span> <span class="hps">le code</span> <span class="hps">de 1,9</span> <span class="hps">branche,</span> <span class="atn hps">comme "</span><span>SeaMonkey</span><span>"</span><span>, mais</span> indexe <span class="hps">une</span> <span class="hps">plus grande</span> <span class="hps">partie du</span> </span>dépôt<span lang="fr"><span class="hps"> et</span> <span class="hps">est mis à jour</span> <span class="hps">moins souvent</span><span>.</span></span></li> + <li><a class="external" href="http://mxr.mozilla.org/mozilla1.8/">Mozilla 1.8 root</a> <span id="result_box" lang="fr"><span class="hps">contient</span> <span class="hps">Firefox</span><span>,</span> <span class="hps">Thunderbird</span> <span class="hps">2.0.0.x</span><span>,</span> <span class="hps">et</span> <span class="hps">SeaMonkey</span></span> 1.1.x</li> + <li><a class="external" href="http://mxr.mozilla.org/mozilla1.8.0/">Mozilla 1.8.0 root</a> <span id="result_box" lang="fr"><span class="hps">contient</span> <span class="hps">Firefox</span><span>,</span> <span class="hps">Thunderbird</span> <span class="hps">1.5.0.x</span><span>,</span> <span class="hps">SeaMonkey</span></span> <span id="result_box" lang="fr"><span class="hps">1.0.x</span> </span></li> + <li><a class="external" href="http://mxr.mozilla.org/aviary101branch/">Aviary 1.0.1 root</a> <span id="result_box" lang="fr"><span class="hps">Firefox et Thunderbird</span> <span class="hps">1.0.0.x</span></span></li> + <li><a class="external" href="http://mxr.mozilla.org/mozilla1.7/">Mozilla 1.7 root</a> <span id="result_box" lang="fr"><span class="hps">contient</span> <span class="hps">Mozilla</span> <span class="hps">Suite</span> <span class="hps">1.7.x</span></span></li> +</ul> + +<p><a href="/en/Mozilla_Source_Code_Directory_Structure" title="en/Mozilla_Source_Code_Directory_Structure">Mozilla Source Code Directory Structure</a> <sup>(page en Anglais) </sup><span id="result_box" lang="fr"><span class="hps">contient une courte</span> <span class="hps">description du code</span> <span class="hps">dans chaque</span> <span class="hps">répertoire source</span> <span class="hps">de l'arbre</span><span>.</span></span></p> + +<h3 id="Resources" name="Resources">Ressources</h3> + +<p><a href="/en/CVS_Tags" title="en/CVS_Tags">CVS Tags</a></p> diff --git a/files/fr/mozilla/tech/xpcom/guide/creating_components/an_overview_of_xpcom/index.html b/files/fr/mozilla/tech/xpcom/guide/creating_components/an_overview_of_xpcom/index.html new file mode 100644 index 0000000000..35e8dd51a0 --- /dev/null +++ b/files/fr/mozilla/tech/xpcom/guide/creating_components/an_overview_of_xpcom/index.html @@ -0,0 +1,504 @@ +--- +title: Un aperçu de XPCOM +slug: Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM +translation_of: Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM +--- +<p></p><div class="prevnext" style="text-align: right;"> + <p><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" style="float: left;">« Précédent</a><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components">Suivant »</a></p> +</div><p></p> + +<p>Cette section est présentée comme un tutoriel sur la création de composants XPCOM, mais elle couvre tous les principaux aspects, les concepts et la terminologie du modèle de composant XPCOM tout au long de sa conception.</p> + +<p>Ce chapitre fournit un rapide tour d'horizons sur XPCOM - une introduction aux concepts de base, des technologies XPCOM et du développement de composants. Les paragraphes de ce chapitre présentent des concepts de haut niveaux, de sorte que nous puissions les approfondir et de les utiliser avec plus de familiarité dans le tutoriel lui-même, qui décrit la création d'un composant Mozilla appelé <strong>WebLock</strong> .</p> + +<h3 id="La_solution_XPCOM">La solution XPCOM</h3> + +<p>Le Cross Platform Component Object Module (XPCOM) est un cadre qui permet aux développeurs de fractionner un projets monolithiques en morceaux modulaires. Ces morceaux, appelés <em>composants</em> , sont ensuite assemblés de nouveau ensemble à l'exécution.</p> + +<p>Le but de XPCOM est de mettre au point les différentes parties de logiciel en les construisant indépendamment les uns des autres. Afin de permettre l'interopérabilité entre les composants d'une application, XPCOM sépare la <em>mise en œuvre</em> d'un composant de l'<a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM#Interfaces">Interface</a> . Mais XPCOM fournit également plusieurs outils et bibliothèques qui permettent le chargement et la manipulation de ces composants, des services qui aident le développeur à écrire du code modulaire multi-plateforme, et le soutien des versions, de sorte que les composants peuvent être remplacés ou mis à niveau sans casser ou avoir à recréer l'application . En utilisant XPCOM, les développeurs créent des composants qui peuvent être réutilisés dans différentes applications ou qui peut être remplacé pour changer la fonctionnalité des applications existantes.</p> + +<p>XPCOM soutient non seulement le développement de composant logiciels, il fournit également une grande partie des fonctionnalité de la plate-forme de développement fournit, tels que:</p> + +<ul> + <li>la gestion de composant</li> + <li>le fichier abstrait</li> + <li>l'objet message</li> + <li>la gestion de la mémoire</li> +</ul> + +<p>Nous allons décrire les éléments ci-dessus en détail dans les chapitres à venir, mais pour l'instant, il peut être utile de penser à XPCOM en tant que <em>plate-forme pour le développement de composants</em> , dans lequel des caractéristiques telles que celles énumérées ci-dessus sont fournis.</p> + +<h3 id="Gecko">Gecko</h3> + +<p>Bien qu'il soit à certains égards structurellement similaires à Microsoft COM, XPCOM est conçu pour être utilisé principalement au niveau de l'application. L'utilisation la plus importante de XPCOM est dans <em>Gecko</em> , open source, conforme aux standards, navigateur Web intégrable et boîte à outils pour la création de navigateurs Web et autres applications.</p> + +<p>XPCOM est le moyen d'accéder aux fonctionnalités de la bibliothèque Gecko pour l'utilisation ou l'extension de Gecko. Ce livre met l'accent sur l'extension mais les explications de ce livre seront important pour le développeurs d'application Gecko embarquées.</p> + +<p>Gecko est utilisé dans de nombreuses applications internet, la plupart des navigateurs et notamment Mozilla Firefox.</p> + +<h3 id="Composants">Composants</h3> + +<p>XPCOM vous permet de briser les gros projets logiciels en petits morceaux connus en tant que composants. Ils sont généralement contenus dans des bibliothèques binaires réutilisables (<abbr>DLL</abbr> sur Windows, <abbr>DSO</abbr> sur Unix), qui peuvent comprendre un ou plusieurs composants. Lorsque deux ou plusieurs composants connexes sont regroupées dans une bibliothèque binaire, la bibliothèque est appelée <em>module</em>.</p> + +<p>Modulaire, la programmation à base de composants logiciels rend plus facile le développement et la maintenance:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Avantage</td> + <td class="header">Description</td> + </tr> + <tr> + <td>Réutilisation</td> + <td>Code modulaire peut être réutilisé dans d'autres applications et d'autres contextes.</td> + </tr> + <tr> + <td>Mises à jour</td> + <td>Vous pouvez mettre à jour les composants sans avoir à recompiler l'application entière.</td> + </tr> + <tr> + <td>Performance</td> + <td>Lorsque le code est modulaire, les modules qui ne sont pas nécessaires immédiatement peuvent être chargées partiellement, ou pas chargés du tout, ce qui peut améliorer les performances de votre application.</td> + </tr> + <tr> + <td>Maintenance</td> + <td>Même lorsque un composant est obsolète, la conception de votre application modulaire vous permet plus facilement de maintenir les parties de l'application que vous intéressent.</td> + </tr> + </tbody> +</table> + +<p>Mozilla a plus de quatre millions de lignes de code, et pas une seule personne ne comprend l'ensemble du code source. La meilleure façon d'aborder un projet de cette taille est de le diviser en modules. La bibliothèque de réseau, par exemple, est constitué de composants pour chacun des protocoles, HTTP, FTP, et d'autres, qui sont groupés et liés dans une seule bibliothèque. Cette bibliothèque est le module de gestion de réseau, également appelé "necko."</p> + +<p>Mais il n'est pas toujours souhaitable de diviser les choses. Le composant <abbr>HTTP</abbr> de Gecko n'expose pas les classes privés qu'elle utilise comme des composants séparés. Les objets interne au composante reste interne, et ne soit pas manipulables par XPCOM.</p> + +<h3 id="Interfaces">Interfaces</h3> + +<p>Comment segmenter du code? L'idée de base est d'identifier les segments fonctionnellement liés et comprendre comment ils communiquent entre eux. Les canaux de communication entre les différentes composants forment ces limites, et lorsque ces limites sont formalisées on parle d'<em>interfaces</em> .</p> + +<p>Les interfaces ne sont pas une idée nouvelle en programmation. Nous avons tous l'habitude interfacer depuis notre premier programme "HelloWorld", où est l'interface entre le code que nous avons écrit - le code d'application - et le code d'impression. Le code d'application utilisé une interface à partir d'une bibliothèque, <code>stdio</code> , et imprime la texte "hello world" sur l'écran. La différence ici est que l'application "HelloWorld" dans XPCOM trouve cette fonctionnalité d'affichage à l'exécution et n'a pas à connaître <code>stdio</code> quand il est compilé.</p> + +<p>Interfaces permettent aux développeurs d' <em>encapsuler</em> la mise en œuvre et de fonctionnement interne de leur logiciel, et permettent aux clients d'ignorer la façon dont les choses sont faites, il suffit d'utiliser ce logiciel.</p> + +<div class="side-note"> +<h4 id="Interfaces_et_programmation_par_contrat">Interfaces et programmation par contrat</h4> + +<p>Une interface forme un accord contractuel entre les composants et les clients. Il n'y a pas de code qui oblige ces accords, mais les ignorer peut être fatal. Dans la programmation à base de composants, un composant garantit que les interfaces qu'il fournit seront <em>immuable</em> - qu'ils vont offrir le même accès aux mêmes méthodes à travers différentes versions du composante - l'établissement d'un contrat avec les logiciels clients qui l'utilisent. À cet égard, la programmation basé sur l'interface est souvent désigné comme <em>la programmation par contrat</em> .</p> +</div> + +<h4 id="Interfaces_et_Encapsulation">Interfaces et Encapsulation</h4> + +<p>Aux limites des composants, l'abstraction est crucial pour la maintenabilité du logiciel et la réutilisabilité. Considérons, par exemple, une classe mal encapsulé. L'utilisation d'une méthode d'initialisation publique librement disponibles, comme l'exemple ci-dessous, peut causer des problèmes.</p> + +<h4 id="SomeClass_Class_Initialization">SomeClass Class Initialization</h4> + +<pre>class SomeClass{ + public: + // Constructeur + SomeClass(); + // Destructeur virtuel + virtual ~SomeClass(); + // method init + void Init(); + void DoSomethingUseful(); +}; +</pre> + +<p>Pour que ce système fonctionne correctement, l'utilisateur de cette classe doit porter une attention particulière à tout ce que le créateur de cette classe a établi. C'est l'accord contractuel avec cette classe non encapsulé: un ensemble de règles qui définissent quand chaque méthode peut être appelée et ce qu'elle est censé faire. Une règle peut spécifier que <code>DoSomethingUseful</code> ne peut être appelé après un appel à <code>init ()</code> . La méthode <code>DoSomethingUseful</code> peut veiller à ce que la condition soit satisfaite.</p> + +<p>En plus du code correctement commenté pour les règles d'utilisation de <code>Init()</code> , le développeur peut prendre quelques mesures pour que ce contrat soit plus clair. Tout d'abord, le constructeur d'un objet peut être encapsulé, et une <em>classe virtuelle</em><code> DoSomethingUseful</code> peut être mis à disposition. De cette façon, le constructeur et l'initialisation peuvent être complètement cachés des utilisateurs de la classe. Dans cette situation, "semi-encapsulé", la seule partie de la classe qui est exposé est une liste bien définie des méthodes appelables (i.e, l'interface). Une fois que la classe est encapsulé, la seule interface que le client verra est la suivante:</p> + +<h4 id="Encapsulation_de_SomeInterface">Encapsulation de SomeInterface</h4> + +<pre>class SomeInterface{ + public: + virtual void DoSomethingUseful() = 0; +}; +</pre> + +<p>La mise en œuvre peut alors dériver de cette classe par l'utilisation de la méthode virtuelle. Les utilisateurs de ce code peuvent ensuite créer l'objet (voir <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM#Factories">utilisation</a> ) et encapsuler aussi la mise en œuvre. Avec XPCOM, les usagers sont ignorant du fonctionnement du composants et comptent sur l'interface pour donner accès aux fonctionnalités nécessaires.</p> + +<h4 id="L'interface_de_base_nsISupports">L'interface de base <code>nsISupports</code></h4> + +<p>Les deux fondamentaux de la programmation composant sont basé sur<em> component lifetime</em>(durée de vie), appelé aussi <em>object ownership</em>, et <em>interface querying</em>, sois l'identification des interfaces d'un composant prises en charge lors de l'exécution. Ce chapitre présente la mère de toutes les interfaces XPCOM - <code>nsISupports</code> , qui fournit les solutions à ces deux problèmes pour les développeurs XPCOM.</p> + +<h4 id="Object_Ownership">Object Ownership</h4> + +<p>Avec XPCOM, parce que les composants peuvent mettre en œuvre un certain nombre d'interfaces, ils doivent être <em>référencés</em> . Quand un composant est créé, un entier interne au composant est incrémenté - connu comme compteur de référence. Au cours de la vie du composant, le compteur de référence augmente et diminue. Lorsque le composant n'a plus d'utilité, le compteur de références atteint zéro, et le composant est détruit.</p> + +<p>Lorsque les clients utilisent des interfaces de façon responsable, cela peut être un processus très simple. XPCOM dispose d'outils pour rendre encore cela plus facile. Il peut soulever des problèmes réels de maintenance lorsque, par exemple, un client utilise une interface et oublie de decrémenter le nombre de références. Lorsque cela se produit, les interfaces ne peuvent jamais être libérés et provoqueront des fuites de mémoire. Le système de comptage de référence est, comme beaucoup de choses dans XPCOM, un contrat entre les clients et les implémentations. Il fonctionne quand les utilisateur le respecte, mais quand ils ne le font pas, les choses peuvent aller mal. C'est le rôle de la fonction qui crée le pointeur d'interface pour ajouter la référence initiale, ou <em>owning reference</em>, d'éviter ces problemes.</p> + +<div class="side-note"> +<h4 id="Pointeurs_avec_XPCOM">Pointeurs avec XPCOM</h4> + +<p>Dans XPCOM, <em>les pointeurs</em> se réfèrent à l'interface pointeurs. La différence est subtile, puisque les pointeurs d'interface et les pointeurs réguliers sont tout simplement deux adresses dans la mémoire. Mais un pointeur d'interface est connu pour mettre en œuvre l'interface de base nsISupports, et peut donc être utilisé pour appeler des méthodes telles que <code>AddRef</code>, <code>Release,</code> ou<code> QueryInterface</code>.</p> +</div> + +<p><code>nsISupports</code>, illustré ci-dessous, fournit les fonctionnalités de base pour faire face à la création d'interface et de comptage de référence. Les membres de cette interface,<code> QueryInterface</code>, <code>AddRef</code> et <code>Release</code> , fournissent les moyens de base pour obtenir la bonne interface d'un objet, incrémenter le compteur de référence, et de libérer les objets une fois qu'ils ne sont plus utilisés.</p> + +<h4 id="L'interface_nsISupports">L'interface <code>nsISupports</code></h4> + +<pre>class Sample: public nsISupports{ + private: + nsrefcnt mRefCnt; + public: + Sample(); + virtual ~Sample(); + NS_IMETHOD QueryInterface(const nsIID &aIID, void **aResult); + NS_IMETHOD_(nsrefcnt) AddRef(void); + NS_IMETHOD_(nsrefcnt) Release(void); +}; +</pre> + +<p>Les différents types utilisés de l'l'interface sont décrites dans la section <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM#XPCOM_Types">Types XPCOM</a>. La mise en œuvre complète de<code> </code><code>nsISupports</code> est indiquée ci-dessous. Voir <a class="external external-icon" href="http://www.mozilla.org/projects/xpcom/QI.html">Une implémentation de référence de QueryInterface</a> pour des informations détaillées.</p> + +<h4 id="Mise_en_œuvre_de_l'interface_nsISupports">Mise en œuvre de l'interface nsISupports</h4> + +<pre>// <code class="language-html">Initialiser le compteur de référence à 0</code> +Sample::Sample() : mRefCnt(0){ +} +Sample::~Sample(){ +} +// <code class="language-html">la mise en œuvre générique de QI</code> +NS_IMETHODIMP Sample::QueryInterface(const nsIID &aIID, + void **aResult){ + if (!aResult) { + return NS_ERROR_NULL_POINTER; + } + *aResult = NULL; + if (aIID.Equals(kISupportsIID)) { + *aResult = (void *) this; + } + if (!*aResult) { + return NS_ERROR_NO_INTERFACE; + } + // ajoute une reference + AddRef(); + return NS_OK; +} +NS_IMETHODIMP_(nsrefcnt) Sample::AddRef(){ + return ++mRefCnt; +} +NS_IMETHODIMP_(nsrefcnt) Sample::Release(){ + if (--mRefCnt == 0) { + delete this; + return 0; + } + // optional: retourn le nombre de reference + return mRefCnt; +} +</pre> + +<h4 id="Object_Interface_Discovery">Object Interface Discovery</h4> + +<p><em>Héritage</em> est un autre sujet très important dans la programmation orientée objet. L'héritage est le moyen par lequel une classe est dérivée d'une autre. Quand une classe hérite d'une autre classe, la classe hérite peut <em>remplacer</em> les comportements par défaut de la classe de base sans avoir à copier tout le code de cette classe et créer ainsi une classe plus spécifique, comme dans l'exemple suivant:</p> + +<h4 id="Héritage_de_classe_simple">Héritage de classe simple</h4> + +<pre>class Shape{ + private: + int m_x; + int m_y; + public: + virtual void Draw() = 0; + Shape(); + virtual ~Shape(); +}; +class Circle : public Shape{ + private: + int m_radius; + public: + virtual Draw(); + Circle(int x, int y, int radius); + virtual ~Circle(); +}; +</pre> + +<p><code>Circle(cercle</code>) est une classe dérivée de <code>Shape(forme)</code> . Un <code>cercle</code> est une <code>forme</code> , en d'autres termes, mais une<code> forme</code> n'est pas nécessairement un <code>cercle</code> . Dans ce cas, <code>forme</code> est la <em>classe de base</em> et <code>cercle</code> est une <em>sous-classe</em> de <code>forme</code> .</p> + +<p>Avec XPCOM, toutes les classes dérivent de l'interface <code>nsISupports</code>, de sorte que tous les objets héritent de <code>nsISupports</code>. Avec <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM#Simple_Class_Inheritance">Héritage Class simple</a> , par exemple, vous êtes en mesure de savoir si la <code>forme</code> est un <code>cercle</code> et dans ce cas de l'utiliser comme un cercle. Ces à quoi la caractéristique <code>QueryInterface</code> de <code>nsISupports</code> est destinée: elle permet aux utilisateurs de trouver et d'accéder aux différentes interfaces en fonction de leurs besoins.</p> + +<p>En C++, vous pouvez utiliser une fonctionnalité assez avancé connu sous le nom de <a href="https://fr.wikipedia.org/wiki/Dynamic_cast">dynamic_cast<></a> , qui lève une exception si l'objet <code>f</code><code>orme</code> n'est un <code>cercle</code> . Mais les exceptions levants <a href="https://fr.wikipedia.org/wiki/Run-time_type_information">RTTI(</a>Run-time type information<a href="https://fr.wikipedia.org/wiki/Run-time_type_information">)</a> ne sont pas une option en raison de la lourdeur et de la compatibilité sur de nombreuses plates-formes, XPCOM fait les choses différemment.</p> + +<div class="side-note"> +<h4 id="Exceptions_avec_XPCOM">Exceptions avec XPCOM</h4> + +<p>Les exceptions C++ ne sont pas pris en charge directement par XPCOM. Les exceptions doivent être manipulés dans le composant XPCOM, avant de franchir les frontières de l'interface. Toutes les méthodes de l'interface doivent retourner une valeur d'erreur <code>nsresult </code>(voir <a href="https://developer.mozilla.org/en-US/docs/XPCOM_API_Reference">référence de l'API XPCOM</a> pour une liste de ces codes d'erreur). Ces résultats de code d'erreur deviennent les «exceptions» que gère XPCOM.</p> +</div> + +<p>Au lieu de tirer parti de RTTI du C++, XPCOM utilise la méthode <code>QueryInterface</code> qui passe l'objet à la bonne interface, si cette interface est pris en charge.</p> + +<p>Chaque interface est pourvu d'un identifiant qui est généré à partir d'un outil nommée <a href="https://fr.wikipedia.org/wiki/Universal_Unique_Identifier">"uuidgen"</a>. Cet identifiant universel unique (UUID) est un numéro unique de 128 bits appelé <em>IID</em>. Ce n'est pas la même chose que l'ID d'un composant.</p> + +<p>Quand un client veut découvrir si un objet prend en charge une interface donnée, le client passe l'IID assignée à cette interface dans la méthode <code>QueryInterface</code> de cet objet. Si l'objet prend en charge l'interface demandée, il ajoute une référence à lui-même et repasse un pointeur sur cette interface. Si l'objet ne prend pas en charge l'interface une erreur est renvoyée.</p> + +<pre>class nsISupports { + public: + long QueryInterface(const nsIID & uuid, + void **result) = 0; + long AddRef(void) = 0; + long Release(void) = 0; +}; +</pre> + +<p>Le premier paramètre de <code>QueryInterface</code> est une référence à une classe nommée <code>nsIID</code> , qui est une encapsulation de base de l'IID. Parmi les trois méthodes sur de la classe <code>nsIID</code>, <code>Equals</code> ,<code>Parse</code> et <code>ToString</code> , <code>Equal</code> est de loin le plus important, car elle est utilisé pour comparer deux<code> nsIID</code> dans le processus d'interrogation d'interface.</p> + +<p>Lorsque vous implémentez la classe <code><a href="https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsISupports">nsISupports</a></code> (et vous le verrez dans le chapitre <a href="https://developer.mozilla.org/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier">Utilitaires XPCOM pour faciliter les choses</a> comment les macros peuvent rendre ce processus beaucoup plus facile), vous devez vous assurer que les méthodes de la classe renvoient un résultat valable lorsque le client appelle <code>QueryInterface</code> avec le <code>nsISupports</code> IID.<code> QueryInterface</code> devrait soutenir toutes les interfaces que le composant soutient.</p> + +<p>Dans les implémentations de <code>QueryInterface</code>, l'argument IID est comparer à la classe <code>nsIID</code>. Si il y a une corespondence, l'objet <code>this</code> pointeur est converti en <code>void</code>, le compteur de référence est incrémenté, et l'interface renvoyée à l'appelant. Si il n'y a pas de correspondance, la classe retourne une erreur et la valeur de sortie est <code>null</code> .</p> + +<p>Dans l'exemple ci-dessus, il est assez facile d'utiliser un C-style cast. Mais le casting peut devenir plus compliqué et vous devez d'abord passer <code>void</code> avec le type demandé, parce que vous devez retourner le pointeur d'interface dans la <abbr>table virtuelle(vtable)</abbr> correspondant à l'interface demandée. Castings peut devenir un problème quand il y a une hiérarchie d'héritage ambigu.</p> + +<h3 id="Identifiants_XPCOM">Identifiants XPCOM</h3> + +<p>En plus de l'identifiant d'interface IID discuté dans la section précédente, XPCOM utilise deux autres identificateurs très important pour distinguer les classes et les composants.</p> + +<div class="side-note"> +<h4 id="Classes_XPCOM_Identifier">Classes XPCOM Identifier</h4> + +<p>La classe <code>nsIID</code> est en fait un typedef de la classe <code>nsID</code>. Les autres typedefs de <code>nsID</code> , CID et IID, se réfèrent respectivement à des implémentations spécifiques d'une classe concrète et d'une interface spécifique.</p> + +<p>La classe <code>nsID</code> fournit des méthodes comme <code>Equals</code> pour comparer les identificateurs dans le code. Voir <a href="https://developer.mozilla.org/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Identifiers_in_XPCOM">identificateurs XPCOM</a> pour plus d'information sur <code>ns</code><code>ID</code>.</p> +</div> + +<h4 id="CID">CID</h4> + +<p>Un CID est un nombre de 128 bits qui identifie de manière unique une classe ou un composant de la même manière qu'un IID identifie de manière unique une interface. Le CID pour <code>nsISupports</code> ressemble à ceci:</p> + +<p><code>00000000-0000-0000-C000-000000000046</code></p> + +<p>La longueur d'un CID peut être lourd à traiter dans le code, de sorte que très souvent, vous verrez #defines pour les CID et les autres identifiants utilisés, comme dans cet exemple:</p> + +<pre>#define SAMPLE_CID \ +{ 0x777f7150, 0x4a2b, 0x4301, \ +{ 0xad, 0x10, 0x5e, 0xab, 0x25, 0xb3, 0x22, 0xaa}} +</pre> + +<p>Vous verrez utilisé aussi <code>NS_DEFINE_CID</code>. Cette macro déclare une constante avec la valeur du CID:</p> + +<pre>static NS_DEFINE_CID(kWebShellCID, NS_WEB_SHELL_CID); +</pre> + +<p>Un CID est parfois aussi désigné comme un <em>identificateur de classe</em> . Si la classe à laquelle un CID se réfère a plus d'une interface, il garanties que la classe implémente cette ensemble d'interfaces quand elle est publiée ou fixée.</p> + +<h4 id="Contrat_ID">Contrat ID</h4> + +<p>Un contract ID est une chaîne lisible utilisé pour accéder à un composant. Un CID ou un contract ID peuvent être utilisés pour accéder à un composant dans gestionnaire de composant. Le contract ID est utilisé pour le composant <a href="https://fr.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol#Op.C3.A9rations">LDAP Opération</a> :</p> + +<pre>"@mozilla.org/network/ldap-operation;1" +</pre> + +<p>Le format du contract ID est formé du <em>domaine</em>, du <em>module, du</em> <em>nom du composant</em> séparés par des barres obliques et du <em>numéro de version</em>.</p> + +<p>Comme un CID, un contract ID se réfère à une mise en œuvre plutôt qu'à une interface à l'instar IID. Mais un contract ID n'est pas liée à une mise en œuvre spécifique, contrairement au CID, il est donc plus général. Au lieu de cela, un contract ID spécifie seulement un ensemble donné d'interfaces qu'il met en œuvre, et un certain nombre de CID diffèrent peuvent intervenir en complément. Cette différence entre un contract ID et un CID est ce qui rend possible de remplacer des composants.</p> + +<h3 id="Utilisation">Utilisation</h3> + +<p>Une fois que le code est divisé en composants, le code client utilise habituellement l'opérateur <code>new</code> pour instancier des objets:</p> + +<pre>SomeClass* component = new SomeClass(); +</pre> + +<p>Ce modèle exige que le client connaisse le composant. Le <a href="https://fr.wikipedia.org/wiki/Fabrique_(patron_de_conception)">factory design pattern</a> peut être utilisé pour encapsuler la construction de l'objet. L'objectif du procédé est de créer un objet sans exposer les clients à la mise en œuvre et l'initialisation de cet objet. Dans l'exemple <code>SomeClass</code>, la construction et l'initialisation de <code>SomeClass</code> , qui implémente la classe abstraite <code>SomeInterface</code>, est contenu par la fonction <code>New_SomeInterface</code>:</p> + +<h4 id="Encapsuler_le_constructeur">Encapsuler le constructeur</h4> + +<pre>int New_SomeInterface(SomeInterface** ret){ +<code class="language-html"> // Créer l'objet</code> + SomeClass* out = new SomeClass(); + if (!out) return -1; +<code class="language-html"> // Initialisation de l'objet</code> + if (out->Init() == FALSE){ + delete out; + return -1; + } + // conversion de types de l'interface + *ret = static_cast<SomeInterface*>(out); + return 0; +} +</pre> + +<p>Factory est la classe qui gère effectivement la création des instances distinctes d'un composant. Dans XPCOM, les factories sont mises en œuvre par l'interface <code>nsIFactory</code>. Le modèle de conception utilise l'abstraction et encapsulalion de la construction et de l'initialisation de l'objet.</p> + +<p>L'exemple de <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM#Encapsulating_the_Constructor">l'encapsulation du constructeur</a> est une version simple et sans état de factories, mais la programmation réel est généralement plus compliquée, ou les factories ont besoin de stocker l'état. Au minimum, la factory a besoin de préserver l'information des objets qu'elle a créée. Quand une factory gère les instances d'une classe construite dans une bibliothèque dynamique partagée, par exemple, elle doit savoir quand elle peut décharger la bibliothèque. Quand la factory conserve l'état, vous pouvez demander si il y a des références et savoir si la factory a créé des objets.</p> + +<p>Un autre état utile est de savoir si oui ou non un objet est un <em>singleton</em> . Par exemple, si la factory crée un objet qui est censé être un singleton, les appels suivants doivent retourner le même objet. Bien qu'il existe des outils et de meilleures façons de gérer les singletons (dont nous parlerons lorsque nous parlons de l'<code>nsIServiceManager</code>), un développeur peut vouloir utiliser cette information pour s'assurer que seul un objet singleton peut exister quelque soit l'usage.</p> + +<p>Les exigences d'une classe factory peuvent être traitées de manière strictement fonctionnel, l'état étant détenu par des variables globales, mais il y a des avantages à utiliser des classes pour les factory. Lorsque vous utilisez une classe pour implémenter la fonctionnalité d'une factory, par exemple, vous utilisez <code>nsISupports</code>, qui vous permet de gérer la durée de vie de l'objets lui-mêmes. Ceci est important quand vous voulez regrouper des ensembles de factories et déterminer si elles peuvent être déchargées. Un autre avantage de l'utilisation de <code>nsISupports</code> est que vous pouvez supporter d'autres interfaces comme ils sont introduits. Comme nous allons le montrer lorsque nous aborderons <code>nsIClassInfo</code>, certaines factories soutiennent l'interrogation des informations sur la mise en œuvre sous-jacente, comme le langage d'écriture de l'objet dans les interfaces que l'objet prend en charge, etc. Ce genre d' "évolutivité" est un avantage clé qui est dérivé de <code>nsISupports</code>.</p> + +<h4 id="XPIDL_et_bibliothèques_de_types">XPIDL et bibliothèques de types</h4> + +<p>Un moyen facile et puissant pour définir une interface - les interfaces dans un environnement de développement multi-plateforme, doit être indépendant du langage - est d'utiliser une <a href="https://fr.wikipedia.org/wiki/Interface_description_language">interface définition langage(IDL)</a>. XPCOM utilise sa propre variante de la définition <a href="https://fr.wikipedia.org/wiki/Common_Object_Request_Broker_Architecture">CORBA</a> <a href="https://fr.wikipedia.org/wiki/Object_Management_Group">OMG</a> Interface Langage (IDL) appelé <a href="https://developer.mozilla.org/fr/docs/XPIDL">XPIDL</a>, qui vous permet de spécifier les méthodes, les attributs et les constantes d'une interface donnée, et aussi d'en définir héritage.</p> + +<p>Il y a quelques inconvénients à la définition de votre interface à l'aide XPIDL. Il n'y a pas d'héritage multiple possible. Si vous définissez une nouvelle interface, il ne peut pas provenir de plus d'une interface. Une autre limitation des interfaces dans XPIDL est que les noms de méthode doivent être uniques. Vous ne pouvez pas avoir deux méthodes avec le même nom qui prennent des paramètres différents, et la solution de contournement - avec plusieurs noms de fonction - n'est pas joli:</p> + +<pre>void FooWithInt(in int x); +void FooWithString(in string x); +void FooWithURI(in nsIURI x); +</pre> + +<p>Cependant, ces lacunes sont peu de chose en comparaison des fonctionnalités acquises en utilisant XPIDL. XPIDL vous permet de générer <em>des bibliothèques de types</em> , ou typelibs, qui sont des fichiers avec l'extension <em>.xpt</em>. La bibliothèque de types est une représentation binaire d'une ou plusieurs interfaces. Elle fournit un contrôle programmatique et l'accès à l'interface, ce qui est crucial pour les interfaces utilisées d'autre langages que C++. Lorsque les composants sont accessibles à partir d'autres langages, car ils peuvent être en XPCOM, ils utilisent la bibliothèque de type binaire pour accéder à l'interface, trouver les méthodes supportées, et les appeler. Cet aspect de XPCOM est appelé <em>XPConnect</em> . XPConnect est la couche de XPCOM qui donne accès à des composants XPCOM à partir des langages tels que JavaScript. Voir<a href="https://developer.mozilla.org/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Connecting_to_Components_from_the_Interface"> connexion à des composants de l'interface</a> pour plus d'informations à propos de XPConnect.</p> + +<p>Quand un composant est accessible à partir d'une langage autre que C ++, tels que JavaScript, son interface est dit "réfléchi" dans cette langage. Chaque interface réfléchie doit avoir une bibliothèque de type correspondant. Actuellement, vous pouvez écrire des composants en C, C++ ou JavaScript (et parfois Python ou Java, en fonction de l'état des liaisons respectives), et il y a des efforts en cours pour renforcer les liaisons XPCOM pour Ruby et Perl.</p> + +<div class="side-note"> +<p><span id="%C3%89criture_dans_d'autres_langages"><a id="%C3%89criture_dans_d'autres_langages"></a><strong>Écriture dans d'autres langages</strong></span></p> + +<div class="side-note"> +<p>Bien que vous ne disposez pas de l'accès à certains des outils que XPCOM prévoit pour C++ (comme les macros, les modèles, des pointeurs intelligents, et autres) lorsque vous créez des composants dans d'autres langages, vous pouvez être tellement à l'aise avec, que vous pouvez éviter complètement le C++ et construire, par exemple, les composants XPCOM en Python qui peuvent être utilisés à partir de JavaScript, ou vice versa.</p> + +<p>Voir les <a href="https://developer.mozilla.org/en-US/docs/Creating_XPCOM_Components/Resources">Ressources</a> pour plus d'informations à propos de Python et d'autres langages utilisables avec XPCOM.</p> +</div> + +<p>Toutes les interfaces publiques en XPCOM sont définies en utilisant la syntaxe de XPIDL. Les bibliothèques de types et les fichiers d'en-tête de C++ sont générés à partir de ces fichiers IDL, et l'outil qui génére ces fichiers est appelé le <em>compilateur xpidl</em> . La section <a href="https://developer.mozilla.org/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Defining_the_WebLock_Interface_in_XPIDL">Définir l'interface de WEBLOCK dans XPIDL</a> décrit la syntaxe de XPIDL en détail.</p> + +<h3 id="Services_de_XPCOM">Services de XPCOM</h3> + +<p>Lorsque les clients utilisent des composants, ils <em>instancient</em> généralement un nouvel objet à chaque fois qu'ils ont besoin de la fonctionnalité du composant fournit. Tel est le cas lorsque, par exemple, les clients travaillent avec des fichiers: chaque fichier séparé est représenté par un objet différent, et plusieurs objets de fichier peut être utilisé à tout moment.</p> + +<p>Mais il y a aussi une sorte d'objet connu comme <em>le service</em> , dont il n'y a toujours qu'une seule copie (même si il peut y avoir de nombreux services en cours d'exécution à un moment donné).Chaque fois qu'un client veut accéder à la fonctionnalité fournie par un service, ils parlent à la même instance de ce service. Quand un utilisateur recherche un numéro de téléphone dans une base de données de l'entreprise, par exemple, probablement cette base de données est représentée par un «objet» qui est le même pour tous les collaborateurs. Si ce n'etait pas le cas, l'application aurait besoin de garder deux copies d'une grande base de données en mémoire, pour la même chose, et il pourrait aussi y avoir des incohérences entre les documents si les copies ont divergé.</p> + +<p>La fourniture de ce point d'accès unique à la fonctionnalité est mis en oeuvre par le <a href="https://fr.wikipedia.org/wiki/Singleton_(patron_de_conception)">singleton design pattern</a>.</p> + +<p>Dans XPCOM, en plus de l'appui et de la gestion des composants, il y a un certain nombre de services qui aident les développeurs à l'écriture de composants. Ces services incluent un fichier abstrait multiplateforme qui offre un accès uniforme et puissant pour les fichiers, les services d'annuaire qui maintiennent l'emplacement application, gestion de la mémoire pour s'assurer que tout le monde utilise le même allocateur de mémoire, et un système de notification d'événement qui permet de passer des messages simples. Le tutoriel va vous montrer l'utilisation de chacun de ces composants et services, et de la <a href="https://developer.mozilla.org/en-US/docs/XPCOM_API_Reference">Référence de l'API XPCOM</a> avec une liste d'interface complète.</p> + +<h3 id="Types_XPCOM">Types XPCOM</h3> + +<p>Il existe de nombreux types déclarés et de simples macros que nous allons utiliser dans les exemples suivants. La plupart de ces types sont des applications simples. Les types les plus courants sont décrits dans les sections suivantes.</p> + +<h4 id="les_types_de_méthode">les types de méthode</h4> + +<p>Ce qui suit est un ensemble de types qui veillent à la convention d'appel correcte et de type de méthodes XPCOM de retour.</p> +</div> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>NS_IMETHOD</code></td> + <td>Type de retour de déclaration de méthode.</td> + </tr> + <tr> + <td><code>NS_IMETHODIMP</code></td> + <td>Type de retour de mise en œuvre de méthode. </td> + </tr> + <tr> + <td><code>NS_IMETHODIMP_(type)</code></td> + <td>Cas particulier de type de retour de mise en œuvre. Certaines méthodes telles que <code>AddRef</code> et <code>Release</code> ne renvoient pas le type de retour par défaut.</td> + </tr> + <tr> + <td><code>NS_IMPORT</code></td> + <td>Force la résolution de la méthode en interne par la bibliothèque partagée.</td> + </tr> + <tr> + <td><code>NS_EXPORT</code></td> + <td>Force l'exportation de la méthode par la bibliothèque partagée.</td> + </tr> + </tbody> +</table> + +<p>Référence Comptage</p> + +<p>Ces macros gérer comptage de référence.</p> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>NS_ADDREF</code></td> + <td>Appelle <code>AddRef</code> de <code>nsISupports</code>.</td> + </tr> + <tr> + <td><code>NS_IF_ADDREF</code></td> + <td>Vérifie l'etat null avant d'appeler <code>AddRef</code>.</td> + </tr> + <tr> + <td><code>NS_RELEASE</code></td> + <td>Appelle <code>Release</code> de <code>nsISupports</code>.</td> + </tr> + <tr> + <td><code>NS_IF_RELEASE</code></td> + <td>Vérifie l'etat null avant d'appeler <code>Release</code>.</td> + </tr> + </tbody> +</table> + +<p>Codes d'état</p> + +<p>Ces macros testent les codes d'état.</p> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>NS_FAILED</code></td> + <td>Retourne vrai si le code d'état passé est un échec</td> + </tr> + <tr> + <td><code>NS_SUCCEEDED</code></td> + <td>Retourne vrai est le code d'état passé est un succès.</td> + </tr> + </tbody> +</table> + +<h3 id="Variable_Mappings">Variable Mappings</h3> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>nsrefcnt</code></td> + <td>Type de comptage de référence(entier de 32 bits).</td> + </tr> + <tr> + <td><code>nsresult</code></td> + <td>Type d'erreur par défaut(entier de 32 bits).</td> + </tr> + <tr> + <td><code>nsnull</code></td> + <td>Valeur null par défaut.</td> + </tr> + </tbody> +</table> + +<h3 id="Codes_d'erreur_XPCOM_communes">Codes d'erreur XPCOM communes</h3> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>NS_ERROR_NOT_INITIALIZED</code></td> + <td>Instance non initialisée.</td> + </tr> + <tr> + <td><code>NS_ERROR_ALREADY_INITIALIZED</code></td> + <td>Instance déjà initialisée.</td> + </tr> + <tr> + <td><code>NS_ERROR_NOT_IMPLEMENTED</code></td> + <td>Méthode non implémentée</td> + </tr> + <tr> + <td><code>NS_ERROR_NO_INTERFACE</code></td> + <td>Interface non pris en charge.</td> + </tr> + <tr> + <td><code>NS_ERROR_NULL_POINTER</code></td> + <td>Pointeur valide <code>nsnull</code>.</td> + </tr> + <tr> + <td><code>NS_ERROR_FAILURE</code></td> + <td>La méthode a échoué. Erreur générique.</td> + </tr> + <tr> + <td><code>NS_ERROR_UNEXPECTED</code></td> + <td>Erreur inattendue.</td> + </tr> + <tr> + <td><code>NS_ERROR_OUT_OF_MEMORY</code></td> + <td>Allocation de mémoire échouée.</td> + </tr> + <tr> + <td><code>NS_ERROR_FACTORY_NOT_REGISTERED</code></td> + <td>Classe inconnue du registre.</td> + </tr> + </tbody> +</table> + +<p></p><div class="prevnext" style="text-align: right;"> + <p><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" style="float: left;">« Précédent</a><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components">Suivant »</a></p> +</div><p></p> diff --git a/files/fr/mozilla/tech/xpcom/guide/creating_components/index.html b/files/fr/mozilla/tech/xpcom/guide/creating_components/index.html new file mode 100644 index 0000000000..dbffe93c6e --- /dev/null +++ b/files/fr/mozilla/tech/xpcom/guide/creating_components/index.html @@ -0,0 +1,281 @@ +--- +title: Créer des composants XPCOM +slug: Mozilla/Tech/XPCOM/Guide/Creating_components +translation_of: Mozilla/Tech/XPCOM/Guide/Creating_components +--- +<p></p><div class="prevnext" style="text-align: right;"> + <p><a href="/fr/docs/Creating_XPCOM_Components/Preface">Suivant »</a></p> +</div><p></p> + +<p><span class="seoSummary">Ce guide a pour but de vous initier à Gecko, et de vous permettre de créer des composants <a href="https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/en/XPCOM">XPCOM</a> pour les applications Gecko.</span> Bien que le principal objectif soit de vous permettre d'inclure du code C++ dans des composants utilisables dans Gecko, nous espérons pouvoir vous présenter tous les outils, techniques, et technologies qui constituent XPCOM. <span id="result_box" lang="fr"><span class="hps">En conséquence</span><span>,</span> c<span class="hps">e livre</span> <span class="hps">est agencé</span> <span class="hps">de telle sorte que</span> <span class="hps">vous puissiez </span><span class="hps">suivre</span> <span class="hps">et créer</span> <span class="hps">vos propres composants</span> <span class="hps">ou</span> <span class="hps">en apprendre davantage sur</span> <span class="hps">les différents</span> <span class="hps">sujets</span> <span class="hps">XPCOM</span> <span class="hps">individuellement</span><span>, comme un </span><span class="hps">ouvrage de référence</span><span>.</span></span> Par exemple, l'introduction inclue une analyse des composants, et le premier chapitre - dans lequel vous compilerez le code de base et vous l'enregistrerez avec Mozilla - explique la relation entre les composants et les modules, les interfaces XPCOM, et le processus d'enregistrement de manière générale.</p> + +<div class="note"> +<p><strong>Remarque:</strong> De manière générale, essayez d'éviter de créer des composants XPCOM. Les add-ons devraient utiliser le nouveau <a href="/en-US/Add-ons/SDK">Add-on SDK</a> autant que possible ; cependant, il est probable que dans certains cas cela soit inévitable.</p> +</div> + +<div class="note"> +<p><strong>Remarque :</strong> Cet article décrit une méthode qui utilise <a href="https://developer.mozilla.org/en-US/docs/Mozilla/XPIDL">xpidl</a> mais vous devriez plutôt utiliser <a href="https://developer.mozilla.org/en-US/docs/Mozilla/WebIDL_bindings">webidl</a>.</p> +</div> + +<h3 id="Preface" name="Preface"><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" title="/en-US/docs/Creating_XPCOM_Components/Preface">Preface</a></h3> + +<dl> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" title="/en-US/docs/Creating_XPCOM_Components/Preface#Who_Should_Read_This_Book">Pour qui est ce tutoriel</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" title="/en-US/docs/Creating_XPCOM_Components/Preface#Organization_of_the_Tutorial">Organisation du tutoriel</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" title="/en-US/docs/Creating_XPCOM_Components/Preface#Following_Along_with_the_Examples">En Pratique</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" title="/en-US/docs/Creating_XPCOM_Components/Preface#Conventions">Conventions</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Preface" title="/en-US/docs/Creating_XPCOM_Components/Preface#Acknowledgements">Remerciements</a></dd> +</dl> + +<h3 id="An_Overview_of_XPCOM" name="An_Overview_of_XPCOM"><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM">Un aperçu de XPCOM</a></h3> + +<dl> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#The_XPCOM_Solution">Solutions XPCOM</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Gecko">Gecko</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Components">Composants</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Interfaces">Interfaces</a> + <dl> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Interfaces_and_Encapsulation">Interfaces et Encapsulation</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#The_nsISupports_Base_Interface">L'interface de base <code>nsISupports</code></a></dd> + </dl> + </dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#XPCOM_Identifiers">XPCOM Identifiers</a> + <dl> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#CID">CID</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Contract_ID">Contract ID</a></dd> + </dl> + </dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Factories">Factories</a> + <dl> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#XPIDL_and_Type_Libraries">XPIDL et bibliothèques de types</a></dd> + </dl> + </dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#XPCOM_Services">XPCOM Services</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#XPCOM_Types">XPCOM Types</a> + <dl> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Method_Types">Method Types</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Reference_Counting">Reference Counting</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Status_Codes">Status Codes</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Variable_Mappings">Variable Mappings</a></dd> + <dd><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/An_Overview_of_XPCOM#Common_XPCOM_Error_Codes">Codes d'erreur XPCOM</a></dd> + </dl> + </dd> +</dl> + +<h3 id="Using_XPCOM_Components" name="Using_XPCOM_Components"><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components">Utilisation des composants XPCOM</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Component_Examples" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Component_Examples">Exemples de composants</a> + + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Cookie_Manager" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Cookie_Manager">gestionnaire de cookies</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#The_WebBrowserFind_Component" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#The_WebBrowserFind_Component"><strong>WebBrowserFind</strong></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#The_WebLock_Component" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#The_WebLock_Component"><strong>WebLock</strong></a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Component_Use_in_Mozilla" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Component_Use_in_Mozilla">Utilisation de composant dans Mozilla</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Finding_Mozilla_Components" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Finding_Mozilla_Components">Trouver des composants Mozilla</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Using_XPCOM_Components_in_Your_Cpp" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#Using_XPCOM_Components_in_Your_Cpp">Utilisation de composants XPCOM dans votre Cpp</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#XPConnect:_Using_XPCOM_Components_From_Script" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Components#XPConnect:_Using_XPCOM_Components_From_Script">XPConnect: Utilisation de XPCOM avec un Script</a></dd> + </dl> + </dd> +</dl> + +<h3 id="Component_Internals" name="Component_Internals"><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals">Composants Internes</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Creating_Components_in_Cpp" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Creating_Components_in_Cpp">Creation de composants dans Cpp</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_Initialization" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_Initialization">XPCOM Initialization</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_Registry_Manifests" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_Registry_Manifests">XPCOM Registry Manifests</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Registration_Methods_in_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Registration_Methods_in_XPCOM">Registration Methods in XPCOM</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Autoregistration" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Autoregistration">Autoregistration</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#The_Shutdown_Process" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#The_Shutdown_Process">The Shutdown Process</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Three_Parts_of_a_XPCOM_Component_Library" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#Three_Parts_of_a_XPCOM_Component_Library">Three Parts of a XPCOM Component Library</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_Glue" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_Glue">XPCOM Glue</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#The_Glue_Library" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#The_Glue_Library">The Glue Library</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_String_Classes" title="/en-US/docs/Creating_XPCOM_Components/Component_Internals#XPCOM_String_Classes">XPCOM String Classes</a></dd> + </dl> + </dd> +</dl> + +<h3 id="Creating_the_Component_Code" name="Creating_the_Component_Code"><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code">Creating the Component Code</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#What_We.27ll_Be_Working_On" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#What_We.27ll_Be_Working_On">What We'll Be Working On</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Component_Registration" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Component_Registration">Component Registration</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#The_regxpcom_Program" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#The_regxpcom_Program">The <code>regxpcom</code> Program</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Registration_Alternatives" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Registration_Alternatives">Registration Alternatives</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Overview_of_the_WebLock_Module_Source" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Overview_of_the_WebLock_Module_Source">Overview of the <strong>WebLock</strong> Module Source</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Digging_In:_Required_Includes_and_Constants" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Digging_In:_Required_Includes_and_Constants">Digging In: Required Includes and Constants</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Identifiers_in_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Identifiers_in_XPCOM">Identifiers in XPCOM</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Coding_for_the_Registration_Process" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Coding_for_the_Registration_Process">Coding for the Registration Process</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#The_Registration_Methods" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#The_Registration_Methods">The Registration Methods</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Creating_an_Instance_of_Your_Component" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#Creating_an_Instance_of_Your_Component">Creating an Instance of Your Component</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#webLock1.cpp" title="/en-US/docs/Creating_XPCOM_Components/Creating_the_Component_Code#webLock1.cpp"><code>webLock1.cpp</code></a></dd> +</dl> + +<h3 id="Using_XPCOM_Utilities_to_Make_Things_Easier" name="Using_XPCOM_Utilities_to_Make_Things_Easier"><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier">Using XPCOM Utilities to Make Things Easier</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#XPCOM_Macros" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#XPCOM_Macros">XPCOM Macros</a> + + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Generic_XPCOM_Module_Macros" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Generic_XPCOM_Module_Macros">Generic XPCOM Module Macros</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Common_Implementation_Macros" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Common_Implementation_Macros">Common Implementation Macros</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Declaration_Macros" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Declaration_Macros">Declaration Macros</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#webLock2.cpp" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#webLock2.cpp"><code>webLock2.cpp</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#String_Classes_in_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#String_Classes_in_XPCOM">String Classes in XPCOM</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Using_Strings" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Using_Strings">Using Strings</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#nsEmbedString_and_nsEmbedCString" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#nsEmbedString_and_nsEmbedCString"><code>nsEmbedString</code> and <code>nsEmbedCString</code></a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Smart_Pointers" title="/en-US/docs/Creating_XPCOM_Components/Using_XPCOM_Utilities_to_Make_Things_Easier#Smart_Pointers">Smart Pointers</a></dd> +</dl> + +<h3 id="Starting_WebLock" name="Starting_WebLock"><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock">Starting <strong>WebLock</strong></a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Getting_Called_at_Startup" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Getting_Called_at_Startup">Getting Called at Startup</a> + + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Registering_for_Notifications" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Registering_for_Notifications">Registering for Notifications</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Getting_Access_to_the_Category_Manager" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Getting_Access_to_the_Category_Manager">Getting Access to the Category Manager</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Providing_Access_to_WebLock" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Providing_Access_to_WebLock">Providing Access to <strong>WebLock</strong></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Creating_the_WebLock_Programming_Interface" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Creating_the_WebLock_Programming_Interface">Creating the <strong>WebLock</strong> Programming Interface</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Defining_the_WebLock_Interface_in_XPIDL" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Defining_the_WebLock_Interface_in_XPIDL">Defining the <strong>WebLock</strong> Interface in XPIDL</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#The_XPIDL_Syntax" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#The_XPIDL_Syntax">The XPIDL Syntax</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Scriptable_Interfaces" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Scriptable_Interfaces">Scriptable Interfaces</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Subclassing_nsISupports" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Subclassing_nsISupports">Subclassing <code>nsISupports</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#The_Web_Locking_Interface" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#The_Web_Locking_Interface">The Web Locking Interface</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Implementing_WebLock" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Implementing_WebLock">Implementing <strong>WebLock</strong></a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Declaration_Macros" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Declaration_Macros">Declaration Macros</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Representing_Return_Values_in_XPCOM" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Representing_Return_Values_in_XPCOM">Representing Return Values in XPCOM</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#XPIDL_Code_Generation" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#XPIDL_Code_Generation">XPIDL Code Generation</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Getting_the_WebLock_Service_from_a_Client" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Getting_the_WebLock_Service_from_a_Client">Getting the <strong>WebLock</strong> Service from a Client</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Implementing_the_iWebLock_Interface" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Implementing_the_iWebLock_Interface">Implementing the <code>iWebLock</code> Interface</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#The_Directory_Service" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#The_Directory_Service">The Directory Service</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Modifying_Paths_with_nsIFile" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Modifying_Paths_with_nsIFile">Modifying Paths with <code>nsIFile</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Manipulating_Files_with_nsIFile" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Manipulating_Files_with_nsIFile">Manipulating Files with <code>nsIFile</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Using_nsILocalFile_for_Reading_Data" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Using_nsILocalFile_for_Reading_Data">Using <code>nsILocalFile</code> for Reading Data</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Processing_the_White_List_Data" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Processing_the_White_List_Data">Processing the White List Data</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#iWebLock_Method_By_Method" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#iWebLock_Method_By_Method"><code>iWebLock</code> Method By Method</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Lock_and_Unlock" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#Lock_and_Unlock"><code>Lock</code> and <code>Unlock</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#AddSite" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#AddSite"><code>AddSite</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#RemoveSite" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#RemoveSite"><code>RemoveSite</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#SetSites" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#SetSites"><code>SetSites</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#GetNext" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#GetNext"><code>GetNext</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#GetSites" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#GetSites"><code>GetSites</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#HasMoreElements" title="/en-US/docs/Creating_XPCOM_Components/Starting_WebLock#HasMoreElements"><code>HasMoreElements</code></a></dd> + </dl> + </dd> +</dl> + +<h3 id="Finishing_the_Component" name="Finishing_the_Component"><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component">Finishing the Component</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Using_Frozen_Interfaces" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Using_Frozen_Interfaces">Using Frozen Interfaces</a> + + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Copying_Interfaces_Into_Your_Build_Environment" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Copying_Interfaces_Into_Your_Build_Environment">Copying Interfaces Into Your Build Environment</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy_Interface" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy_Interface">Implementing the <code>nsIContentPolicy</code> Interface</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Receiving_Notifications" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Receiving_Notifications">Receiving Notifications</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Implementing_the_nsIContentPolicy">Implementing the <code>nsIContentPolicy</code></a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Uniform_Resource_Locators" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Uniform_Resource_Locators">Uniform Resource Locators</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Checking_the_White_List" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Checking_the_White_List">Checking the White List</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Creating_nsIURI_Objects" title="/en-US/docs/Creating_XPCOM_Components/Finishing_the_Component#Creating_nsIURI_Objects">Creating <code>nsIURI</code> Objects</a></dd> + </dl> + </dd> +</dl> + +<h3 id="Building_the_WebLock_UI" name="Building_the_WebLock_UI"><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI">Building the <strong>WebLock</strong> UI</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#User_Interface_Package_List" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#User_Interface_Package_List">User Interface Package List</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Client_Code_Overview" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Client_Code_Overview">Client Code Overview</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#XUL" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#XUL">XUL</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#The_XUL_Document" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#The_XUL_Document">The XUL Document</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#The_Locking_UI" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#The_Locking_UI">The Locking UI</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Site_Adding_UI" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Site_Adding_UI">Site Adding UI</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.xul" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.xul"><code>weblock.xul</code></a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Overlaying_New_User_Interface_Into_Mozilla" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Overlaying_New_User_Interface_Into_Mozilla">Overlaying New User Interface Into Mozilla</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#webLockOverlay.xul" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#webLockOverlay.xul"><code>webLockOverlay.xul</code></a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Other_Resources" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Other_Resources">Other Resources</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.css" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#weblock.css"><code>weblock.css</code></a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Image_Resources" title="/en-US/docs/Creating_XPCOM_Components/Building_the_WebLock_UI#Image_Resources">Image Resources</a></dd> + </dl> + </dd> +</dl> + +<h3 id="Packaging_WebLock" name="Packaging_WebLock"><a href="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock" title="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock">Packaging WebLock</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#Component_Installation_Overview" title="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#Component_Installation_Overview">Component Installation Overview</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#Archiving_Resources" title="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#Archiving_Resources">Archiving Resources</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Installation_Script" title="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Installation_Script">The <strong>WebLock</strong> Installation Script</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Trigger_Script" title="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#The_WebLock_Trigger_Script">The <strong>WebLock</strong> Trigger Script</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#Distributing_Your_Component" title="/en-US/docs/Creating_XPCOM_Components/Packaging_WebLock#Distributing_Your_Component">Distributing Your Component</a></dd> +</dl> + +<h3 id="Appendix_A_-_Setting_up_the_Gecko_SDK" name="Appendix_A_-_Setting_up_the_Gecko_SDK"><a href="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK" title="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK">Appendix A - Setting up the Gecko SDK</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Downloading_and_Setting_the_SDK" title="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Downloading_and_Setting_the_SDK">Downloading and Setting the SDK</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Building_a_Microsoft_Visual_Cpp_Project" title="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Building_a_Microsoft_Visual_Cpp_Project">Building a Microsoft Visual Cpp Project</a> + <dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Creating_a_New_Project" title="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Creating_a_New_Project">Creating a New Project</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Adding_the_Gecko_SDK_to_the_Project_Settings" title="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Adding_the_Gecko_SDK_to_the_Project_Settings">Adding the Gecko SDK to the Project Settings</a></dd> + </dl> + </dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#Building_a_Windows_Project" title="/en-US/docs/Creating XPCOM Components/Setting up the Gecko SDK#Building a Windows Project">Building a Windows Project</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#A_Makefile_for_Unix" title="/en-US/docs/Creating_XPCOM_Components/Setting_up_the_Gecko_SDK#A_Makefile_for_Unix">A Makefile for Unix</a></dd> +</dl> + +<h3 id="Appendix_B_-_Resources" name="Appendix_B_-_Resources"><a href="/en-US/docs/Creating_XPCOM_Components/Resources" title="/en-US/docs/Creating_XPCOM_Components/Resources">Appendix B - Resources</a></h3> + +<dl> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Resources#WebLock_Resources" title="/en-US/docs/Creating_XPCOM_Components/Resources#WebLock_Resources">WebLock Resources</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Resources#Gecko_Resources" title="/en-US/docs/Creating_XPCOM_Components/Resources#Gecko_Resources">Gecko Resources</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Resources#XPCOM_Resources" title="/en-US/docs/Creating_XPCOM_Components/Resources#XPCOM_Resources">XPCOM Resources</a></dd> + <dd><a href="/en-US/docs/Creating_XPCOM_Components/Resources#General_Development_Resources" title="/en-US/docs/Creating_XPCOM_Components/Resources#General_Development_Resources">General Development Resources</a></dd> +</dl> + +<p></p><div class="prevnext" style="text-align: right;"> + <p><a href="/fr/docs/Creating_XPCOM_Components/Preface">Suivant »</a></p> +</div> <p></p><div class="licenseblock"> +<p>Copyright (c) 2003 by Doug Turner and Ian Oeschger. This material may be distributed only subject to the terms and conditions set forth in the <a class="external" href="http://www.opencontent.org/openpub/" rel="noopener">Open Publication License</a>, v1.02 or later. Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.</p> +</div><p></p> + +<p></p> diff --git a/files/fr/mozilla/tech/xpcom/guide/creating_components/preface/index.html b/files/fr/mozilla/tech/xpcom/guide/creating_components/preface/index.html new file mode 100644 index 0000000000..478a139e2f --- /dev/null +++ b/files/fr/mozilla/tech/xpcom/guide/creating_components/preface/index.html @@ -0,0 +1,77 @@ +--- +title: Préface +slug: Mozilla/Tech/XPCOM/Guide/Creating_components/Preface +tags: + - Guide + - XPCOM +translation_of: Mozilla/Tech/XPCOM/Guide/Creating_components/Preface +--- +<p></p><div class="prevnext" style="text-align: right;"> + <p><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM">Suivant »</a></p> +</div><p></p> + +<p>Cette section concerne Gecko et la création de composants <a href="https://developer.mozilla.org/fr/docs/XPCOM">XPCOM</a> pour des applications basées sur Gecko. Bien que l'accent soit mis sur les mesures concrètes que vous prenez pour créer un code C ++ valide dans un composant qui peut être utilisé dans Gecko, nous espérons que ces mesures nous donneront également l'occasion de discuter de tous les outils, les techniques et les technologies qui composent XPCOM. En conséquence, le livre est agencé de telle sorte que vous puissiez suivre et créer vos propres composants et en apprendre davantage sur XPCOM, comme dans un ouvrage de référence. Par exemple, l'introduction comprend une discussion sur les composants, et le premier chapitre - dans laquelle vous compilez le code de base et l'enregistrer avec Mozilla - éclair sur la relation entre les composants et les modules, les interfaces XPCOM et le processus d'enregistrement en général.</p> + +<p>Le début de chaque chapitre fournit une liste des principaux sujets abordés. Des barres latérales sont incluses pour mettre en évidence les détails techniques. À la fin du livre, vous aurez appris comment construire un composant XPCOM et vous comprendrez sont fonctionnement dans Gecko.</p> + +<h3 id="Pour_qui_est_ce_tutoriel">Pour qui est ce tutoriel ?</h3> + +<p><a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components">La Création de composants XPCOM</a> est destinée aux développeurs C ++. Bien que vous pouvez créer des composants XPCOM en <a href="https://developer.mozilla.org/fr/docs/compiler_un_composant_xpcom_javascript">JavaScript</a> ou d'autres langages, le code de mise en œuvre des composants est écrit en C ++, et une grande partie de la discussion sur la façon de programmer un composant XPCOM utilise le C ++. Vous ne devez pas non plus être un expert C ++. Bien que les idées de base telles que l'héritage et l'encapsulation devraient vous être familiers. Leur utilisation est expliquée à chaque fois dans le tutoriel. En outre, beaucoup d'exemples sont en JavaScript, utilisé dans Mozilla pour accéder aux composants XPCOM comme des objets scriptable, votre familiarité avec ce langage est également utile.</p> + +<p>XPCOM pour Cross Platform Component Object Model est similaire à Microsoft COM. Si vous avez une expérience avec ces technologies, beaucoup d'entre elles peuvent être appliquées à XPCOM. Cependant, ce tutoriel ne suppose aucune connaissance préalable du COM - toutes les idées de base seront présentés.</p> + +<p>Ce livre fournit un tutoriel sur la construction d'un composant XPCOM contrôlant le comportement d'un navigateur. Bien que XPCOM peux être utilisé dans de nombreux environnements qui sont sans rapport avec la navigation web, le principal client de XPCOM est Gecko. Il est open source, conforme aux standards, possède un navigateur Web embarquable, où il est plus facile et plus pratique d'illustrer les fonctionnalités d'XPCOM. Une description complète de ce composant peut être trouvé dans le chapitre <a href="https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Creating_the_Component_Code#What_We.27ll_Be_Working_On">ce que nous allons faire</a> du didacticiel.</p> + +<div class="note"> +<p>Malgré ce que dit le vieux document, XPCOM ne devrait pas être utilisé pour faire des <a href="en/Plugins">plugins NPAPI </a> scriptable. A partir de Gecko 1.7.5 (Firefox 1.0) une extension spéciale NPAPI pour scriptabilité est prise en charge, voir <a href="en/Gecko_Plugin_API_Reference/Scripting_plugins">plugins Scripting</a>.</p> +</div> + +<h3 id="Organisation_du_Tutoriel">Organisation du Tutoriel</h3> + +<p>La liste suivante donne un aperçu des étapes que nous allons suivre pour construire un composant XPCOM appelé <strong>WebLock</strong>, qui prévoit une fonctionnalité de blocage de sites pour les navigateurs basés sur Gecko. Chacune de ces étapes a son propre chapitre, dans lequel un certain nombre de sujets liés à l'étape sont abordés.</p> + +<ul> + <li>Créer un module de code générique pour le composant.</li> + <li>Utilisez les macros C++, particulièrement les classes string et pointeurs intelligents, pour optimiser votre code.</li> + <li>Définir la fonctionnalité pour le composant; créer une interface <a href="https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/en/XPIDL">XPIDL</a> pour cette fonctionnalité; créer le code de mise en œuvre spécifique à l'usage de l'interface du composant <strong>WebLock</strong>.</li> + <li>Terminer la mise en œuvre du composant <strong>WebLock</strong>: <code>nsIContentPolicy</code> , fichier I/O, de verrouillage, etc.</li> + <li>Création de l'interface utilisateur pour le composant de <strong>WebLock</strong>.</li> + <li>Emballage <strong>WebLock</strong> pour la distribution et l'installation.</li> +</ul> + +<h3 id="Continuons_avec_des_exemples">Continuons avec des exemples</h3> + +<p>Il y a deux façons d'installer XPCOM sur votre machine pour que vous puissiez commencer à créer des composants. Si vous avez déjà Mozilla build ou le code source de Mozilla 1.2 ou ultérieure, vous pouvez utiliser le framework XPCOM disponible. Si non, la façon la plus simple d'obtenir et d'utiliser XPCOM est de télécharger le <a href="https://developer.mozilla.org/fr/docs/SDK_Gecko">SDK Gecko</a>, qui est un ensemble de bibliothèques et d'outils qui comporte le framework XPCOM.</p> + +<p>Que vous compiliez le code source ou utilisiez le SDK Gecko, vous pouvez construire vos propres composants en utilisant les composants existant dans Gecko. Le composant <strong>WebLock</strong> que nous décrirons dans ce tutoriel met ceci en pratique (et, nous l'espérons, de façon utile) en plus de la manipulation du navigateur. Pour que cela fonctionne, votre code source SDK Gecko ou Mozilla doit être de version 1.2 ou ultérieure (l'interface XPCOM n'a pas été entièrement fixée dans les versions antérieures).</p> + +<p>Ce livre suppose que vous utilisez SDK plutôt que de compiler le code source de Mozilla, bien que la différence entre ces deux approches soit minime. La construction, et l'obtention de l'accès à la programmation de composants Gecko est fournies en annexe à ce livre, <a href="https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Setting_up_the_Gecko_SDK">Configuration du SDK Gecko</a> .</p> + +<h3 id="Conventions">Conventions</h3> + +<p>Les conventions de formats ci-dessous sont utilisées pour désigner des types d'informations spécifiques dans le livre et rendre les choses plus faciles à analyser. Le but est d'utiliser aussi peu de formats que possible, mais de distinguer clairement les différents types d'informations.</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Format</td> + <td class="header">Description</td> + </tr> + <tr> + <td><strong>gras</strong></td> + <td><strong>noms des composants</strong> apparaissent en gras dans le texte</td> + </tr> + <tr> + <td><code>monospace</code></td> + <td><code>lignes de code</code> , <code>noms d'interface</code> et <code>membres</code> d'interfaces (par exemple, <code>createInstance()</code>) apparaissent avec cette police. Les lignes de code sont placées dans des encarts séparés. En outre, <code>les noms de fichiers</code> et de <code>répertoires</code> possèdent également cette police.</td> + </tr> + <tr> + <td><em>italique</em></td> + <td><em>les variables</em> apparaissent en italique. Les termes importants et les nouveaux concepts sont également en italique la première fois qu'ils apparaissent dans le texte. Ces termes sont expliqués soit immédiatement après leur citation, ou bien le lecteur est renvoyé à une section dans le livre où ils sont décrits en détail.</td> + </tr> + <tr> + <td>lien</td> + <td>Références à d'autres sections, figures ou tableaux et leur liens vers ces articles.</td> + </tr> + </tbody> +</table> diff --git a/files/fr/mozilla/tech/xpcom/guide/creating_components/using_xpcom_components/index.html b/files/fr/mozilla/tech/xpcom/guide/creating_components/using_xpcom_components/index.html new file mode 100644 index 0000000000..3a6b536ee6 --- /dev/null +++ b/files/fr/mozilla/tech/xpcom/guide/creating_components/using_xpcom_components/index.html @@ -0,0 +1,303 @@ +--- +title: Utilisation des composants XPCOM +slug: Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components +translation_of: Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components +--- +<p></p><div class="prevnext" style="text-align: right;"> + <p><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" style="float: left;">« Précédent</a><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Component_Internals">Suivant »</a></p> +</div> Une des meilleures façons de commencer à travailler avec XPCOM - surtout quand vous concevez l'interface d'un composant qui sera utilisé par d'autres(<a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Starting_WebLock">WebLock</a>) - est de regarder comment les clients utilisent déjà des composants XPCOM.<p></p> + +<p>Les applications sophistiqués comme le navigateur Mozilla sont des utilisateurs de modules XPCOM. En fait, la quasi-totalité des fonctionnalités associees au navigateur - la navigation, la gestion des fenêtres, la gestion des cookies, les signets, la sécurité, la recherche, de rendu et d'autres caractéristiques - sont définies par des composants XPCOM et consultée par le biais de leurs interfaces. Mozilla est <em>fait</em> de composants XPCOM.</p> + +<p>Ce chapitre montre comment Mozilla utilise certains de ces objets XPCOM, tels que le CookieManager, et explique comment l'accès au composant de Weblock sera défini.</p> + +<h3 id="Exemples_de_composants">Exemples de composants</h3> + +<p>Pour en savoir plus sur l'utilisation de composant particulier référez vous à <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Reference">API XPCOM référence</a> . Pour l'instant, ili est important de comprendre comment un composant est utilisé par le navigateur Mozilla.</p> + +<h4 id="Gestionnaire_de_Cookies">Gestionnaire de Cookies</h4> + +<p>Gestion des cookies est l'une des nombreux fonctionnalités qui est mise disposition du navigateur sous la forme de composant XPCOM et qui peut être réutilisé par les développeurs qui veulent des fonctionnalités similaires dans leurs applications. Chaque fois qu'un utilisateur accède à la boîte de dialogue de Cookie Manager pour afficher, organiser, ou supprimer les cookies qui ont été stockées sur le système, ils utilisent le composant CookieManager en coulisses. <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components#The_Cookie_Manager_Dialog">La boite de dialogue du gestionnaire de cookies</a> montre interface utilisateur qui est présenté à l'utilisateur dans Mozilla pour l'utilisation du composant CookieManager.</p> + +<p><span id="Boite_de_dialogue_du_gestionnaire_de_cookies"><a id="Boite_de_dialogue_du_gestionnaire_de_cookies"></a><strong>Boite de dialogue du gestionnaire de cookies</strong></span></p> + +<p><img alt="Image:cookie_mgr_dlog.png" class="internal" src="/@api/deki/files/625/=Cookie_mgr_dlog.png"></p> + +<p>Cette boite de dialogue est écrit en <abbr>XUL</abbr> et en JavaScript, et utilise une partie de XPCOM appelé <em>XPConnect</em> pour se connecter de manière transparente au composant CookieManager (voir <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components#Connecting_to_Components_from_the_Interface">Connexion à des interfaces de composants</a> ci-dessous). XUL expose les fonctionnalités du composant CookieManager, il est tres utilisé dans l'environement Mozilla.</p> + +<p>La fonctionnalité du composant CookieManager est disponible à travers l'interface <code>nsICookieManager</code>, ses méthodes publiques sont exposées dans le tableau ci-dessous.</p> + +<p><span id="Interface_nsICookieManager"><a id="Interface_nsICookieManager"></a><strong>Interface nsICookieManager</strong></span></p> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>removeAll</code></td> + <td>Retirez tous les cookies de la liste des cookies.</td> + </tr> + <tr> + <td><code>enumerator</code></td> + <td>Énumérer la liste des cookies.</td> + </tr> + <tr> + <td><code>remove</code></td> + <td>Retirer un cookie particulier de la liste.</td> + </tr> + </tbody> +</table> + +<p>Linterface XPCOM garanti la stabilitée, même si il y a des changements sous-jacentes. Les interfaces sont <em>publics</em> et les implémentations sont privés. Lorsque l'utilisateur sélectionne l'un des cookies affichés dans la liste, puis clique sur le bouton Supprimer, la méthode <code>Remove</code> de <code>nsICookieManager</code> est appelée. La fonction est réalisée par le composant CookieManager, et le cookie sélectionné est supprimé du disque et retiré de la liste affichée.</p> + +<p>L'extrait <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components#Getting_the_CookieManager_Component_in_JavaScript">Utiliser le composant CookieManager en JavaScript</a> montre comment <code>Remove()</code> peut être appelé à partir de JavaScript:</p> + +<p><span id="Utiliser_le_composant_CookieManager_en_JavaScript"><a id="Utiliser_le_composant_CookieManager_en_JavaScript"></a><strong>Utiliser le composant CookieManager en JavaScript</strong></span></p> + +<pre>// xpconnect to cookiemanager +// get the cookie manager component in JavaScript +var cmgr = Components.classes["@mozilla.org/cookiemanager;1"] + .getService(); +cmgr = cmgr.QueryInterface(Components.interfaces.nsICookieManager); + +// called as part of a largerDeleteAllCookies() function +function FinalizeCookieDeletions() { + for (var c=0; c<deletedCookies.length; c++) { + cmgr.remove(deletedCookies[c].host, + deletedCookies[c].name, + deletedCookies[c].path); + } + deletedCookies.length = 0; +} +</pre> + +<div class="side-note"> +<p><span id="Connexion_%C3%A0_l'interface_d'un_composant"><a id="Connexion_%C3%A0_l'interface_d'un_composant"></a><strong>Connexion à l'interface d'un composant</strong></span></p> + +<div class="side-note"> +<p>L'interface Mozilla utilise JavaScript pour accèder aux composants XPCOM par l'intermediaire de <a href="https://developer.mozilla.org/fr/docs/XPConnect">XPConnect</a>.</p> + +<p>XPConnect via <a href="https://developer.mozilla.org/fr/docs/XPIDL">XPIDL</a> est appeler à partir d'objets JavaScript, qui représentent des instances de composants comme CookieManager.</p> + +<p>XPConnect lie le code d'application de l'interface utilisateur du navigateur Mozilla(XUL basé sur Gecko), à l'environnement JavaScript(comme <a href="https://developer.mozilla.org/fr/docs/xpcshell">xpcshell</a>)..</p> +</div> + +<p>Les arrangements contractuels que permet XPCOM ouvre la voie à <em>l'interopérabilité binaire, </em>pour l'accès, l'utilisation et la réutilisation des composants XPCOM. Ils permettent d'utiliser des composants écrits dans d'autres langages tels que JavaScript, Python et autres.</p> + +<p>Dans le navigateur Mozilla, les composants sont souvant utilisés à partir de JavaScript. En fait, une recherche du code source Mozilla révèle que le composant CookieManager est appelée <em>seulement</em> à partir de JavaScript. C'est ce que nous allons faire dans ce tutoriel.</p> +</div> + +<div class="side-note"> +<p><span id="JavaScript_et_Mozilla"><a id="JavaScript_et_Mozilla"></a><strong>JavaScript et Mozilla</strong></span></p> + +<div class="side-note"> +<p>JavaScript est la <em>lingua franca</em> du navigateur Mozilla, et les liaisons entre elle et XPCOM sont forts et bien définie. <em>scriptabilité</em> , cette capacité à obtenir et utiliser des composants XPCOM à partir de JavaScript et d'autres langages pour lesquels fixations XPConnect ont été créés, est une caractéristique essentielle de XPCOM.</p> +</div> + +<h4 id="Le_composant_WebBrowserFind">Le composant <code>WebBrowserFind</code></h4> + +<p>Les composants sont utilisés partout - dans les fonctionnalités du navigateur de haut niveau tels que <code>nsWebBrowserFind</code> , qui fournit les méthodes<code> find()</code> et <code>findNext()</code> pour trouver du contenu dans les pages Web, et dans les tâches de bas niveau tels que la manipulation des données.</p> + +<p>En plus du composant CookieManager, le composant WebBrowserFind est une autre partie d'un grand ensemble d'interfaces du navigation Web que vous pouvez utiliser. Son interface <code>nsIWebBrowserFind</code> est présentée dans <a href="https://developer.mozilla.org/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Using_XPCOM_Components#The_nsIWebBrowserFind_Interface">L'interface nsIWebBrowserFind</a> .</p> +</div> + +<p><span id="Les_m%C3%A9thodes_de_nsIWebBrowserFind"><a id="Les_m%C3%A9thodes_de_nsIWebBrowserFind"></a><strong>Les méthodes de nsIWebBrowserFind</strong></span></p> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>findNext</code></td> + <td>Trouver la prochaine occurrence de la chaîne recherchée.</td> + </tr> + <tr> + <td><code>findBackwards</code></td> + <td>Attribut booléen qui ajuste <code>findNext()</code> pour rechercher vers le début du document.</td> + </tr> + <tr> + <td><code>searchFrames</code></td> + <td>Attribut booléen qui indique si la recherche s'efectue dans les sous-fenêtres du document actuel.</td> + </tr> + <tr> + <td><code>matchCase</code></td> + <td>Attribut booléen qui indique la sensibilité à la casse.</td> + </tr> + <tr> + <td><code>entireWord</code></td> + <td>Attribut booléen qui indique si le mot entier doit correspondre.</td> + </tr> + </tbody> +</table> + +<p>Quand vous utilisez l'interface d'un composant, vous pouvez demander si il suportr d'autres interfaces. Ce service, qui est défini dans <code>nsISupports</code> est mis en œuvre par tous les composants XPCOM, vous permet d'interroger et de passer d'une interface à un composant dans le cadre des <em>runtime object typing</em>. Il est géré par <code>QueryInterface</code>, qui a été introduit dans le chapitre <a class="internal" href="https://developer.mozilla.org/fr/Creating_XPCOM_Components/An_Overview_of_XPCOM">Vue d'ensemble du XPCOM</a> . L'<a href="https://developer.mozilla.org/fr/XPCOM_API_Reference">API de référence</a> XPCOM fournit une référence complète des composants XPCOM disponibles dans Mozilla.</p> + +<h4 id="The_WebLock_Component">The WebLock Component</h4> + +<p>Now it's time to look at the <strong>WebLock</strong> component as another example of XPCOM components (since you'll be creating it shortly). In object-oriented programming, it's typical to design the interface first-to define the functionality that's going to be provided in the abstract, without worrying about how this functionality will be achieved. So we'll put aside the details of the implementation until the next chapter and look at the component from the outside-at the interface to the WebLock component.</p> + +<p><span id="The_IWebLock_Interface"><a id="The_IWebLock_Interface"></a><strong>The IWebLock Interface</strong></span></p> + +<table class="standard-table"> + <tbody> + <tr> + <td><code>lock</code></td> + <td>Lock the browser to the current site (or to the whitelist of approved sites read from disk).</td> + </tr> + <tr> + <td><code>unlock</code></td> + <td>Unlock the browser for unrestricted use.</td> + </tr> + <tr> + <td><code>addSite</code></td> + <td>Add a new site to the whitelist.</td> + </tr> + <tr> + <td><code>removeSite</code></td> + <td>Remove a given site from the whitelist.</td> + </tr> + <tr> + <td><code>sites</code></td> + <td>Enumerator for the list of approved sites read in from the whitelist.</td> + </tr> + </tbody> +</table> + +<p>The WebLock component is software that implements all of these methods in the way described by the interface definition. It registers itself for use when the browser starts up, and provides a factory that creates an instance of it for use when the user or administrator clicks the weblock icon in the browser's user interface.</p> + +<h3 id="Component_Use_in_Mozilla">Component Use in Mozilla</h3> + +<p>So how are components obtained and used in Mozilla? You've seen some enticing snippets of JavaScript in earlier sections of this chapter, but we haven't explained how XPCOM makes components available in general.</p> + +<p>This section discusses practical component use in Mozilla. It's divided into three subsections: one about actually finding all these binary components in Mozilla and two others corresponding to the two main ways that clients typically access XPCOM components:</p> + +<h4 id="Finding_Mozilla_Components">Finding Mozilla Components</h4> + +<p>This book attempts to provide reference information for XPCOM components and their interfaces that are frozen as of the time of this writing. The <a class="external" href="http://www.mozilla.org/projects/embedding/">Mozilla embedding project</a> tracks the currently frozen interfaces.</p> + +<p>Mozilla also has some tools that can find and display information about the interfaces available in Gecko such as the <em>XPCOM Component Viewer</em>, described below, and <a class="external" href="http://mxr.mozilla.org/">MXR</a>, which is a web-based source code viewing tool.</p> + +<p>The challenge to making good information about XPCOM components available to prospective clients, however, is that the process of freezing the interfaces that are implemented by these components is still ongoing. The Component Viewer does not distinguish between components that are frozen and those that are not. In the source code you view in MXR, interfaces that have been frozen are marked at the top with <code>@status frozen</code>.</p> + +<h5 id="The_XPCOM_Component_Viewer">The XPCOM Component Viewer</h5> + +<p>The <a class="external" href="http://addons.mozilla.org/firefox/2230/">XPCOM Component Viewer</a> is an add-on you can install in your browser (in sandbox, not available for now).<br> + Alternatively, you can try <a class="external" href="http://xpcomviewer.mozdev.org/ ">XPCOMViewer</a>, a similar add-on.</p> + +<p><span id="XPCOM_Component_Viewer"><a id="XPCOM_Component_Viewer"></a><strong>XPCOM Component Viewer</strong></span></p> + +<p><img alt="Image:using-component-viewer.png" class="internal" src="/@api/deki/files/922/=Using-component-viewer.png"></p> + +<p>The left column shows the components - in this case a subset returned from a search on "gfx" as part of the contract ID and the right column a list of the interfaces. When you open a component on the left, you can see the interfaces it implements along with a list of the methods provided by each interface.</p> + +<p>The XPCOM Component Viewer can be extremely useful for this sort of gross interrogation, but again: it displays <em>all</em> of the components and interfaces in your build, many of which are not practical for actual reuse or stable enough to be used reliably in your own application development. Use comprehensive lists like this with caution.</p> + +<p> </p> + +<h4 id="Using_XPCOM_Components_in_Your_Cpp">Using XPCOM Components in Your Cpp</h4> + +<p>XPConnect makes it easy to acecss XPCOM components as JavaScript objects, but using XPCOM components in C++ is not much more difficult.</p> + +<p><a href="#Managing_Cookies_from_Cpp">Managing Cookies from Cpp</a> duplicates code from <a href="#Getting_the_CookieManager_Component_in_JavaScript">Getting the CookieManager Component in JavaScript</a>, but in C++ instead of JavaScript.</p> + +<p><span id="Managing_Cookies_from_Cpp"><a id="Managing_Cookies_from_Cpp"></a><strong>Managing Cookies from Cpp</strong></span></p> + +<pre>nsCOMPtr<nsIServiceManager> servMan; +nsresult rv = NS_GetServiceManager(getter_AddRefs(servMan)); +if (NS_FAILED(rv)) + return -1; + +nsCOMPtr<nsICookieManager> cookieManager; +rv = servMan->GetServiceByContractID("@<a class="linkification-ext" href="http://mozilla.org/cookiemanager">mozilla.org/cookiemanager</a>", + NS_GET_IID(nsICookieManager), + getter_AddRefs(cookieManager)); + +if (NS_FAILED(rv)) + return -1; + +PRUint32 len; +deletedCookies->GetLength(&len); + +for (int c=0; c<len; c++) + cookieManager->Remove(deletedCookies[c].host, + deletedCookies[c].name, + deletedCookies[c].path, + PR_FALSE); +</pre> + +<p>XXX: In the original document, there were only the first three parameters to the |Remove| call. I added |PR_FALSE| as a fourth parameter because the interface seems to require it: <a class="linkification-ext external" href="http://lxr.mozilla.org/mozilla/source/netwerk/cookie/public/nsICookieManager.idl#64">http://lxr.mozilla.org/mozilla/source/netwerk/cookie/public/nsICookieManager.idl#64</a> This problem also appears in the JavaScript version below, and I've added |false| as a fourth parameter there as well.</p> + +<p>If your application is written in C++, then <a href="#Managing_Cookies_from_Cpp">Managing Cookies from Cpp</a> shows the steps you take to get an XPCOM component, specify the interface on that component you want to use, and call methods on that interface.</p> + +<h4 id="XPConnect_Using_XPCOM_Components_From_Script">XPConnect: Using XPCOM Components From Script</h4> + +<p>The CookieManager component we discussed at the beginning of this chapter provides a good opportunity to talk further about using components from JavaScript. In the following code fragment from the Cookie Manager dialog in Mozilla, you can see a singleton of the CookieManager component being created with the <code>getService()</code> method and used to provide the functionality that lets users load and remove cookies from the user interface.</p> + +<p><span id="Managing_Cookies_from_JavaScript"><a id="Managing_Cookies_from_JavaScript"></a><strong>Managing Cookies from JavaScript</strong></span></p> + +<pre>var cmgr = Components.classes["@mozilla.org/cookiemanager;1"] + .getService(); +cmgr = cmgr.QueryInterface(Components.interfaces.nsICookieManager); + +function loadCookies() { + // load cookies into a table + var enumerator = cmgr.enumerator; + var count = 0; + var showPolicyField = false; + while (enumerator.hasMoreElements()) { + var nextCookie = enumerator.getNext(); + nextCookie = nextCookie.QueryInterface(Components.interfaces.nsICookie); + /* .... */ +} +function FinalizeCookieDeletions() { + for (var c=0; c<deletedCookies.length; c++) { + cmgr.remove(deletedCookies[c].host, + deletedCookies[c].name, + deletedCookies[c].path, + false); + } + deletedCookies.length = 0; +} +</pre> + +<p>XXX: In the original document, there were only the first three parameters to the |remove| call. I added |false| as a fourth parameter because the interface seems to require it: <a class="linkification-ext external" href="http://lxr.mozilla.org/mozilla/source/netwerk/cookie/public/nsICookieManager.idl#64">http://lxr.mozilla.org/mozilla/source/netwerk/cookie/public/nsICookieManager.idl#64</a> This problem also appears in the C++ version above, and I've added |PR_FALSE| as a fourth parameter there as well.</p> + +<p>Beyond the methods that are being called on the CookieManager itself (e.g., <code>cookiemanager.remove</code>, which maps to the <code>remove()</code> function in <a href="#The_nsICookieManager_Interface">The nsICookieManager Interface</a>), note the special XPConnect objects and methods that reflect the XPCOM component into JavaScript.</p> + +<p><code>Components</code> is the JavaScript object that controls the connection to components, and <code>classes</code> is an array of all of the classes you can ask for by contract ID. To instantiate an XPCOM component in JavaScript, you create a new <code>Component</code> object and pass in the contract ID for the component you want and ask for either a singleton or an instance of that component to be returned:</p> + +<pre>var cmgr = Components.classes["@mozilla.org/cookiemanager;1"] + .getService(); +</pre> + +<p>The resulting <code>cookiemanager</code> object then provides access to all of the methods for that component that have been defined in IDL and compiled into the type library. Using the CookieManager component, you could write code like this to delete all cookies from the system:</p> + +<pre>cmgr = Components.classes["@<a class="linkification-ext" href="http://mozilla.org/cookiemanager;1">mozilla.org/cookiemanager;1</a>"] + .getService(); +cmgr = cmgr.QueryInterface(Components.interfaces.nsICookieManager); + +// delete all cookies +function trashEm() { + cmgr.removeAll(); +} +</pre> + +<p>Another vital feature of the XPConnect glue this example shows is the availability of the <code>QueryInterface</code> method on all objects that are reflected into JavaScript from XPCOM. As in C++, you can use this method to ask for other interfaces that are available on the given object.</p> + +<div class="side-note"> +<p><span id="Services_Versus_Regular_Instances"><a id="Services_Versus_Regular_Instances"></a><strong>Services Versus Regular Instances</strong></span></p> + +<p>Whether to have clients use your component as an instance or a service is a design question, really, and something you should be clear about in the documentation for your component. Actually, the <code>getService()</code> method in the example here calls through to the <code>createInstance()</code> method that is also available from the Component object and caches the result, making it a singleton rather than a normal instance.</p> + +<p>The singleton design pattern that is used to create services is described in <a href="/en/Creating_XPCOM_Components/An_Overview_of_XPCOM#XPCOM_Services">XPCOM Services</a>.</p> +</div> + +<p>Remember, <code>QueryInterface</code> allows you to query an object for the interfaces it supports. In the case of the snippet in <a href="#The_nsICookieManager_Interface">The nsICookieManager Interface</a>, the <code>QueryInterface</code> method is being used to get the <code>nsICookie</code> interface from the enumerator so that, for instance, the JavaScript code can access the <code>value</code> and <code>name</code> attributes for each cookie.</p> + +<ol> + <li><div class="blockIndicator note"><strong>Note :</strong> cookie-manager-ui</div> Note that the interface is not part of the component itself. XPCOM makes it easy to use components like CookieManager from Mozilla's Cross Platform Front End (XPFE) and other user interfaces, but the component itself doesn't provide its own UI.</li> + <li><div class="blockIndicator note"><strong>Note :</strong> private-xpcom-interfaces</div> There are exceptions to this. Some XPCOM interfaces are also private and not made for general use. Private interfaces do not have the same requirements as the ones that are made available publicly in IDL.</li> + <li><div class="blockIndicator note"><strong>Note :</strong> cookie-manager-in-tutorial</div> The CookieManager component is used to persist for the web locking functionality described in this tutorial.</li> +</ol> + +<p></p><div class="prevnext" style="text-align: right;"> + <p><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/An_Overview_of_XPCOM" style="float: left;">« Précédent</a><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/Component_Internals">Suivant »</a></p> +</div> <p></p><div class="licenseblock"> +<p>Copyright (c) 2003 by Doug Turner and Ian Oeschger. This material may be distributed only subject to the terms and conditions set forth in the <a class="external" href="http://www.opencontent.org/openpub/" rel="noopener">Open Publication License</a>, v1.02 or later. Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.</p> +</div><p></p> diff --git a/files/fr/mozilla/tech/xpcom/guide/index.html b/files/fr/mozilla/tech/xpcom/guide/index.html new file mode 100644 index 0000000000..748a2784b5 --- /dev/null +++ b/files/fr/mozilla/tech/xpcom/guide/index.html @@ -0,0 +1,16 @@ +--- +title: XPCOM guide +slug: Mozilla/Tech/XPCOM/Guide +tags: + - Landing + - Mozilla + - NeedsTranslation + - TopicStub + - XPCOM +translation_of: Mozilla/Tech/XPCOM/Guide +--- +<p><span class="seoSummary">These articles provide tutorials and usage documentation for XPCOM, including how to use it in your own projects and how to build XPCOM components for your Firefox add-ons and the like.</span></p> +<p></p><div class="row topicpage-table"> + <div class="section"><dl><dl><dt class="landingPageList"><a href="/fr/docs/compiler_un_composant_xpcom_javascript">Compiler un composant XPCOM javascript</a></dt><dd class="landingPageList"></dd><dt class="landingPageList"><a href="/fr/docs/Mozilla/Tech/XPCOM/Guide/Creating_components">Créer des composants XPCOM</a></dt><dd class="landingPageList">Ce guide a pour but de vous initier à Gecko, et de vous permettre de créer des composants <a href="https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM/Guide/Creating_components/en/XPCOM">XPCOM</a> pour les applications Gecko.</dd></dl></dl></div> + <div class="section"><dl><dt></dt></dl></div> + </div><p></p> diff --git a/files/fr/mozilla/tech/xpidl/index.html b/files/fr/mozilla/tech/xpidl/index.html new file mode 100644 index 0000000000..6f7e3d2425 --- /dev/null +++ b/files/fr/mozilla/tech/xpidl/index.html @@ -0,0 +1,22 @@ +--- +title: XPIDL +slug: Mozilla/Tech/XPIDL +tags: + - XPCOM +translation_of: Mozilla/Tech/XPIDL +--- +<p><strong>XPIDL</strong> est un langage de description d'interfaces utilisé pour spécifier les classes de l'interface <a href="/fr/XPCOM" title="fr/XPCOM">XPCOM</a>.</p> +<p>Les langages de description d'interfaces (IDL) sont utilisés pour décrire des interfaces d'une manière indépendante d'un langage et d'une machine. Les IDL permettent de définir des interfaces qui peuvent alors être employées par des outils pour générer automatiquement des spécifications d'interfaces propres à un langage donné.</p> +<p>Un de ces outils est <a href="/fr/XPIDL:xpidl" title="fr/XPIDL/xpidl">xpidl</a>, utilisé pour générer des fichiers d'en-têtes C++, des informations typelib et plusieurs autres choses.</p> +<h2 id=".C3.89criture_de_fichiers_interface_XPIDL" name=".C3.89criture_de_fichiers_interface_XPIDL">Écriture de fichiers interface XPIDL</h2> +<p>XPIDL ressemble fortement à <a class="external" href="http://www.omg.org/gettingstarted/omg_idl.htm">OMG IDL</a> avec une syntaxe étendue pour traiter les IID et des types supplémentaires. Quelques exemples sont disponibles dans les répertoires <a class="external" href="http://lxr.mozilla.org/mozilla/source/xpcom/base">xpcom/base</a> et <a class="external" href="http://lxr.mozilla.org/mozilla/source/xpcom/ds">xpcom/ds</a> des sources de Mozilla.</p> +<ul> + <li><a class="external" href="http://www.mozilla.org/scriptable/xpidl/syntax.html">syntaxe XPIDL</a> (non à jour)</li> + <li><a href="/fr/XPIDL/Syntaxe" title="fr/XPIDL/Syntaxe">XPIDL:Syntaxe</a> <small>(<a href="/en/XPIDL/Syntax">en:XPIDL:Syntax</a></small>) (XPIDL <a class="external" href="http://en.wikipedia.org/wiki/Extended_Backus-Naur_form">EBNF</a>)</li> + <li><a class="external" href="http://www.mozilla.org/scriptable/xpidl/idl-authors-guide/index.html">XPIDL Author's Guide</a> (globalement à jour)</li> +</ul> +<h2 id="Ressources" name="Ressources">Ressources</h2> +<ul> + <li><a class="external" href="http://www.mozilla.org/scriptable/xpidl/notes/">Quelques notes non triées</a> dont <a class="external" href="http://www.mozilla.org/scriptable/xpidl/notes/keywords.txt">une liste de mots clés</a>.</li> + <li><a href="/fr/XPIDL/xpidl" title="fr/XPIDL/xpidl">xpidl</a> est un outil pour générer des entêtes C++, des interfaces Java, des typelibs <a href="/fr/XPConnect" title="fr/XPConnect">XPConnect</a>, et de la documentation HTML à partir de fichiers XPIDL.</li> +</ul> |