diff options
Diffstat (limited to 'files/fr/archive/mozilla/firefox')
4 files changed, 515 insertions, 0 deletions
diff --git a/files/fr/archive/mozilla/firefox/index.html b/files/fr/archive/mozilla/firefox/index.html new file mode 100644 index 0000000000..9e61c718ff --- /dev/null +++ b/files/fr/archive/mozilla/firefox/index.html @@ -0,0 +1,8 @@ +--- +title: Firefox +slug: Archive/Mozilla/Firefox +translation_of: Archive/Mozilla/Firefox +--- +<p>In progress. Out-of-date information about the Firefox project.</p> + +<p></p> diff --git a/files/fr/archive/mozilla/firefox/les_états_de_contenu_et_le_système_de_style/index.html b/files/fr/archive/mozilla/firefox/les_états_de_contenu_et_le_système_de_style/index.html new file mode 100644 index 0000000000..9d070c55b1 --- /dev/null +++ b/files/fr/archive/mozilla/firefox/les_états_de_contenu_et_le_système_de_style/index.html @@ -0,0 +1,26 @@ +--- +title: Les états de contenu et le système de style +slug: Archive/Mozilla/Firefox/Les_états_de_contenu_et_le_système_de_style +tags: + - Développement_de_Mozilla +translation_of: Archive/Mozilla/Firefox/Content_states_and_the_style_system +--- +<p> +Les états de contenu sont ce que Gecko utilise pour mettre en œuvre les différentes règles CSS dépendant de l'état du contenu (comme par exemple <code>:hover</code>, <code>:active</code>, <code>:focus</code>, <code>target</code>, <code>:checked</code>). Nous nous concentrerons sur la description de la façon dont les changements dans ces états de contenus sont manipulés. +</p><p>Généralement, quand l'état de contenu d'un nœud change, le style doit être résolu à nouveau (recalculé) pour ce nœud et tous ses descendants. C'est une opération coûteuse cependant, c'est pourquoi le système de style essaie de minimiser le nombre de styles qu'il doit recalculer. À cette fin, quand une notification <a href="https://dxr.mozilla.org/mozilla-central/source/content/base/public/nsIDocumentObserver.h" rel="custom"><code>ContentStatesChanged</code></a><sup>(en)</sup> est acheminée pour un nœud de contenu, la première chose qui est faite est de vérifier si ce changement dans les états de contenu <em>pourrait</em> affecter certains styles. +</p><p>Ceci est réalisé en parcourant la liste de tous les <a class="external" href="http://www.w3.org/TR/CSS21/selector.html#q2"><sup>(en) </sup>sélecteurs simples CSS2.1</a> dans toutes les feuilles de style appliquées à la page qui ont une pseudo-classe de dépendance d'état faisant partie du sélecteur. Cette liste est créée durant l'analyse des feuilles de style impliquées. Pour chaque sélecteur de cette liste, on vérifie s'il a pu cesser correspondre au nœud ou commencer à le faire. Si c'est le cas, le style pourrait dépendre de l'état qui a changé et ce style doit donc être recalculé. +</p><p>Pour déterminer si le sélecteur pourrait avoir arrêté ou commencé à correspondre au nœud, on vérifie en fait s'il correspond à la règle selon laquelle toutes les pseudo-classes dépendantes de l'état correspondant aux états qui ont changé doivent être traitées comme concordantes avec le nœud (le fait qu'elles concordent, et leur éventuelle inversion). Ceci est nécessaire pour obtenir à la fois les sélecteurs qui se sont mis à concorder et ceux qui ne concordent plus. +</p><p>Par exemple, supposons que nous avons les sélecteurs suivants : +</p> +<pre class="eval"> a:hover + a:not(:hover) + div:hover +</pre> +<p>et que l'état <code>hover</code> sur certains nœuds change. On essaie alors d'appliquer au nœud ces sélecteurs, en supposant qu'à la fois <code>:hover</code> et <code>:not(:hover)</code> correspondent au nœud. L'effet sera donc identique à essayer d'appliquer à chaque nœud les sélecteurs : +</p> +<pre class="eval"> a + a + div +</pre> +<p>Le code qui met en œuvre ce procédé est dans la <a href="http://mxr.mozilla.org/mozilla-central/search?string=PRBool+SelectorMatches%28"><code>méthode SelectorMatches</code></a><sup>(en)</sup>, à qui est passée la liste des états qui ont changé dans le paramètre <code>aStateMask</code>. +</p> diff --git a/files/fr/archive/mozilla/firefox/soap_dans_les_navigateurs_gecko/index.html b/files/fr/archive/mozilla/firefox/soap_dans_les_navigateurs_gecko/index.html new file mode 100644 index 0000000000..34537b58ef --- /dev/null +++ b/files/fr/archive/mozilla/firefox/soap_dans_les_navigateurs_gecko/index.html @@ -0,0 +1,284 @@ +--- +title: SOAP dans les navigateurs Gecko +slug: Archive/Mozilla/Firefox/SOAP_dans_les_navigateurs_Gecko +tags: + - SOAP + - Services_Web_XML +translation_of: Archive/Mozilla/Firefox/SOAP_in_Gecko-based_Browsers +--- +<p>Cet article décrit comment accéder à un service Web en utilisant SOAP et des fonctions JavaScript disponibles dans les navigateurs Gecko récents.</p> + +<h3 id="Introduction" name="Introduction">Introduction</h3> + +<p><em>Simple Object Access Protocol</em>(<a class="external" href="http://www.w3.org/TR/SOAP/">SOAP</a>) est la base de conception des services Web. C'est un protocole XML utilisé pour communiquer et interopérer avec les services Web. Avec Mozilla 1.0 (sur lequel est basé Netscape 7.0x) et Firefox, il est maintenant possible pour le navigateur de communiquer directement avec les services Web en utilisant son implémentation SOAP de bas niveau à l'aide de JavaScript.</p> + +<p>L'interface JavaScript de Gecko pour l'établissement des appels SOAP est une API de bas niveau qui requiert la construction de l'enveloppe SOAP en utilisant plusieurs objets JavaScript spécifiques à SOAP. Ce document couvre les opérations SOAP de base. Pour des informations plus détaillées sur l'API de bas niveau de SOAP dans Gecko, voir <a class="external" href="http://lxr.mozilla.org/mozilla/source/extensions/webservices/docs/Soap_Scripts_in_Mozilla.html">SOAP Scripts in Mozilla</a>.</p> + +<p>L'utilisation de JavaScript pour les communications avec les services Web est sujette aux mêmes politiques de sécurité que tous les autres scripts en terme d'accès inter-domaines. Par conséquent accéder à des services Web situés sur des serveurs autres que celui où est exécuté le JavaScript constitue une violation de la politique inter-domaines. Ce document montrera comment détourner temporairement ces règles pour la conduite de tests.</p> + +<h3 id="Param.C3.A9trer_un_appel_SOAP" name="Param.C3.A9trer_un_appel_SOAP">Paramétrer un appel SOAP</h3> + +<p>L'objet le plus basique est <code>SOAPCall</code>, il est utilisé pour initier et invoquer un appel SOAP.</p> + +<p>Figure 1 : paramétrage de base et invocation d'un appel SOAP</p> + +<pre>var mySOAPCall = new SOAPCall(); +mySOAPCall.transportURI = "http-based service URI" + +var parameters = new Array(); +mySOAPCall.encode(SOAPCall.VERSION_1_1, + // method + "method", "namespaceURI", + // header block + 0, null, + // parameter + parameters.length, parameters); + +var response = mySOAPCall.invoke(); +</pre> + +<p>Un objet <code>SOAPCall</code> à un membre appelé <code>transportURI</code>, qui est l'URI de l'emplacement où il doit envoyer l'appel SOAP. La méthode <code>encode()</code> requiert le nom de la méthode à appeler depuis le service Web, son <code>namespaceURI</code>, le nombre de <code>SOAPParameters</code> passé, et un tableau de <code>SOAPParameters</code> qui contient tous les paramètres. Tous ces paramètres peuvent sont regroupés dans le fichier WSDL du service Web, qui sera abordé dans les exemples suivants.</p> + +<p>Les paramètres SOAP sont créés à l'aide de l'objet <code>SOAPParameter</code>. Ce sont des paires nom/valeur qui sont passées au service Web.</p> + +<p>Figure 2 : Création d'un paramètre SOAP</p> + +<pre>var param = new SOAPParameter(); +param.name = "translationmode"; +param.value = "en_fr"; +</pre> + +<h3 id="Traitement_d.27une_r.C3.A9ponse" name="Traitement_d.27une_r.C3.A9ponse">Traitement d'une réponse</h3> + +<p>Une fois que <code>invoke()</code> a été appelé, Gecko génère l'enveloppe SOAP et l'envoie à l'URI spécifiée. Comme la requête est synchrone, la réponse sera la valeur retournée par <code>invoke()</code>.</p> + +<p>Figure 3 : Traitement d'une réponse à un appel SOAP</p> + +<pre>var returnObject = mySOAPCall.invoke(); + +if(returnObject.fault){ + alert("An error occured: " + returnObject.fault.faultString); +} else { + var response = new Array(); + response = returnObject.getParameters(false, {}); + alert("Return value: " + response[0].value); +} +</pre> + +<p>La valeur retournée par <code>invoke()</code> est stockée et examinée pour un membre <code>fault</code>. Si il existe, une erreur se produit du côté du service Web, et le message d'erreur est stocké dans <code>fault.faultString</code>. Si <code>fault</code> n'existe pas, nous appelons la fonction <code>getParameters()</code> sur l'objet retourné pour récupérer les <code>SOAPParameters</code> retournés.</p> + +<h3 id="Exemple" name="Exemple">Exemple</h3> + +<p>L'exemple utilise un service Web existant, Babelfish, fournit par <a class="external" href="http://www.xmethods.net/">xmethods.net</a>. Le service Web Babelfish permet des traductions dans de nombreuses langues. Il prend deux paramètres en entrée : une chaîne au format « originalLanguage_resultLanguage » et le texte à traduire. Le fichier WSDL du service Web Babelfish est disponible <a class="external" href="http://www.xmethods.net/sd/2001/BabelFishService.wsdl">à cette adresse</a> et contient toutes les informations nécessaires au paramétrage d'un appel SOAP de bas niveau vers le service Web.</p> + +<p>La première étape est de déterminer l'emplacement du service Web, qui sera la valeur du membre <code>transportURI</code> de <code>SOAPCall</code>. Elle peut être trouvée dans l'élément <code>service</code> de WSDL, et plus spécifiquement dans l'attribut <code>location</code> de <code>soap:address</code>.</p> + +<p>Figure 4 : Détermination de l'emplacement d'un service Web depuis son WSDL</p> + +<pre class="eval"><strong>WSDL:</strong> + <service name="BabelFishService"> + <documentation> + Traduit des textes dans de nombreuses langues. + </documentation> + <port name="BabelFishPort" binding="tns:BabelFishBinding"> + <span style="color: green;"><soap:address location="<span class="nowiki">http://services.xmethods.net:80/perl/soaplite.cgi</span>"/></span> + </port> + <service> + +<strong>JavaScript:</strong> + var babelFishCall = new SOAPCall(); + babelFishCall.transportURI = "<span class="nowiki">http://services.xmethods.net:80/perl/soaplite.cgi</span>"; + ... +</pre> + +<p>L'étape suivante est plus complexe : déterminer exactement quels paramètres le service Web attend qu'on lui envoie. Le service Web Babelfish ne possède qu'une méthode, « BabelFish », qui est représentée dans le WSDL entre la balise <code>operation</code>, qui est un enfant de l'élément <code>portType</code>. Chaque <code>operation</code> WSDL possède deux enfants : les éléments d'entrée et de sortie, qui peuvent contenir les types attendus. Les types sont définis dans les éléments <code>message</code>, au nombre de deux : <code>BabelFishRequest</code>, qui est ce qu'on passe au service Web, et <code>BabelFishResponse</code>, le type de retour.</p> + +<p>BabelFish attend l'opération deux dans les paramètres <code>translationmode</code> et <code>sourcedata</code>. L'exemple de la figure 5 va traduire la chaîne « I am » d'anglais en français.</p> + +<p>Figure 5 : Définir les paramètres nécessaires</p> + +<pre class="eval"><strong>WSDL:</strong> + <message <span style="color: blue;">name="BabelFishRequest"></span> + <span style="color: green;"><part name="translationmode" type="xsd:string"/></span> + <span style="color: green;"><part name="sourcedata" type="xsd:string"/></span> + </message> + + <message name="BabelFishResponse"> + <part name="return" type="xsd:string"/> + </message> + + <portType name="BabelFishPortType"> + <operation name="BabelFish"> + <span style="color: green;"><input message="tns:BabelFishRequest"/></span> + <output message="tns:BabelFishResponse"/> + </operation> + </portType> + +<strong>JavaScript:</strong> + // SOAP parameters + var param1 = new SOAPParameter(); + param1.value = "en_fr"; + param1.name = "translationmode"; + + var param2 = new SOAPParameter(); + param2.value = "I am"; + + param2.name = "sourcedate"; + + // combine the 2 params into an array + var myParamArray = [param1,param2]; +</pre> + +<p>Ensuite, il faut définir et invoquer l'objet <code>SOAPCall</code>. « BabelFish » est la méthode que notre exemple veut utiliser pour le service Web. Le prochain paramètre est l'espace de nommage attendu qui doit être passé au service Web pour la méthode BabelFish.</p> + +<p>Ceci peut être trouvé dans le l'élément WSDL <code>binding</code>. L'élément <code>binding</code> possède un enfant <code>operation</code> pour la méthode BabelFish. L'espace de nommage voulu est la valeur de l'attribut <code>namespace</code> de <code>soap:body</code> qui se trouve dans l'élément <code>input</code>.</p> + +<p>Figure 6 : Définir la méthode d'encodage</p> + +<pre class="eval"><strong>WSDL:</strong> + <binding name="BabelFishBinding" type="tns:BabelFishPortType"> + <soap:binding style="rpc" transport="<span class="nowiki">http://schemas.xmlsoap.org/soap/http</span>"/> + <operation name="BabelFish"> + <soap:operation soapAction="urn:xmethodsBabelFish#BabelFish"/> + <input> + <span style="color: green;"><soap:body use="encoded" namespace="urn:xmethodsBabelFish" + encodingStyle="<span class="nowiki">http://schemas.xmlsoap.org/soap/encoding/</span>"/></span> + </input> + ... + </operation> + </binding> + +<strong>JavaScript:</strong> + babelFishCall.encode(0, "BabelFish", "urn:xmethodsBabelFish", 0, null, myParamArray.length, myParamArray); + + var translation = babelFishCall.invoke(); +</pre> + +<p>Comme on l'a vu à la figure 5, la réponse de la méthode BabelFish ("BabelFishResponse") est un paramètre, à savoir une chaîne. Après avoir vérifier que <code>fault</code> n'a pas été retourné, la méthode <code>getParameters()</code> de l'objet retourné est utilisée pour récupérer un tableau de SOAPResponses. Comme on n'attend qu'un seul paramètre en retour -- le texte traduit -- la méthode <code>alert()</code> est utilisée pour afficher la traduction.</p> + +<p>Figure 7 : Traitement de la réponse</p> + +<pre class="eval"><strong>JavaScript:</strong> + if(translation.fault){ + // erreur retournée par le service Web + alert(translation.fault.faultString); + } else { + // nous attendons un seul SOAPParameter en retour - la chaîne traduite. + var response = new Array(); + response = translation.getParameters(false, {}); + alert("Translation: " + response[0].value); + } +</pre> + +<p>Comme indiqué dans l'introduction, les appels SOAP obéissent à une politique d'accès inter-domaines des scripts. Il existe deux façons de contourner cette politique de sécurité pour conduire des tests :</p> + +<ol> + <li> + <p>Exécutez le script depuis votre disque local.</p> + + <p>Enregistrez localement le code sur votre disque dur.</p> + + <p>Le modèle de sécurité inter-domaines ne concerne pas les codes exécutés depuis un disque local.</p> + </li> + <li> + <p>Activer l'accès inter-domaine</p> + + <p>Vous pouvez contourner la vérification inter-domaine en définissant une préférence comme expliqué dans l'article <a href="fr/Bypassing_Security_Restrictions_and_Signing_Code">contournement des restrictions de sécurité et signature de code (à traduire)</a> et en ajoutant une commande JavaScript pour demander une dérogation à la vérification inter-domaine.</p> + + <p>Après avoir contourner la vérification, démarrez le navigateur et chargez cette <a class="external" href="http://developer.mozilla.org/samples/soap/example-crossdomain.html">page exemple modifiée</a>. Il vous sera demandé (dans une boîte de dialogue) l'autorisation de désactiver l'inter-domaine (pour cette session) de la fonction générant l'appel SOAP. Le seul changement est l'ajout de <code>netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");</code> à la fonction qui génère l'appel SOAP.</p> + </li> +</ol> + +<p>Figure 8 : Code final - <a class="external" href="http://developer.mozilla.org/samples/soap/example.html">Exemple local (en)</a>, <a class="external" href="http://developer.mozilla.org/samples/soap/example-crossdomain.html">Exemple inter-domaine (en)</a></p> + +<pre class="eval"><strong>JavaScript:</strong> + var babelFishCall = new SOAPCall(); + babelFishCall.transportURI = "<span class="nowiki">http://services.xmethods.net:80/perl/soaplite.cgi</span>"; + + // paramètres SOAP + var param1 = new SOAPParameter(); + param1.value = "en_fr"; + param1.name = "translationmode"; + + var param2 = new SOAPParameter(); + param2.value = "I am"; + param2.name = "sourcedate"; + + // combinaison des 2 paramètres dans un tableau + var myParamArray = [param1,param2]; + + babelFishCall.encode(0, "BabelFish", "urn:xmethodsBabelFish", 0, null, myParamArray.length, myParamArray); + + var translation = babelFishCall.invoke(); + + if(translation.fault){ + // erreur retournée par le service Web + alert(translation.fault.faultString); + } else { + // nous attendons un seul SOAPParameter en retour - la chaîne traduite. + var response = new Array(); + response = translation.getParameters(false, {}); + alert("Translation: " + response[0].value); + } +</pre> + +<h3 id="Chemin_de_l.27enveloppe_Soap" name="Chemin_de_l.27enveloppe_Soap">Chemin de l'enveloppe Soap</h3> + +<p>Voici un<em>HTTP dump</em> (utilisant l'outil multiplate-forme <a class="external" href="http://www.ethereal.com/">Ethereal</a>) de ce qui a été vraiment envoyé et reçu lorsque l'exemple a été exécuté :</p> + +<p>Figure 9 : HTTP Dumps</p> + +<pre class="eval"><strong>Sent:</strong> +POST /perl/soaplite.cgi HTTP/1.1 +Host: services.xmethods.net:80 +... +Content-Type: text/xml +Content-Length: 516 + +<env:Envelope xmlns:env="<span class="nowiki">http://schemas.xmlsoap.org/soap/envelope/</span>" + xmlns:enc="<span class="nowiki">http://schemas.xmlsoap.org/soap/encoding/</span>" + env:encodingStyle="<span class="nowiki">http://schemas.xmlsoap.org/soap/encoding/</span>" + xmlns:xs="<span class="nowiki">http://www.w3.org/1999/XMLSchema</span>" + xmlns:xsi="<span class="nowiki">http://www.w3.org/1999/XMLSchema-instance</span>"> + <env:Header/> + <env:Body> + <a0:BabelFish xmlns:a0="<span style="color: green;">urn:xmethodsBabelFish</span>"> + <span style="color: green;"><a0:translationmode xsi:type="xs:string">en_fr</a0:translationmode></span> + <span style="color: green;"><a0:sourcedata xsi:type="xs:string">I am</a0:sourcedata></span> + </a0:BabelFish> + </env:Body> +</env:Envelope> + + +<strong>Recieved:</strong> +HTTP/1.1 200 OK +Date: Tue, 11 Mar 2003 20:28:11 GMT +Server: Apache/1.3& (Unix) Enhydra-Director/3 PHP/4.0.6 DAV/1.0.3 AuthNuSphere/1.0.0 +SOAPServer: SOAP::Lite/Perl/0.52 +Content-Length: 532 + +... +Content-Type: text/xml; charset=utf-8 + +<?xml version="1.0" encoding="UTF-8"?> +<SOAP-ENV:Envelope xmlns:SOAP-ENC="<span class="nowiki">http://schemas.xmlsoap.org/soap/encoding/</span>" + SOAP-ENV:encodingStyle="<span class="nowiki">http://schemas.xmlsoap.org/soap/encoding/</span>" + xmlns:SOAP-ENV="<span class="nowiki">http://schemas.xmlsoap.org/soap/envelope/</span>" + xmlns:xsi="<span class="nowiki">http://www.w3.org/1999/XMLSchema-instance</span>" + xmlns:xsd="<span class="nowiki">http://www.w3.org/1999/XMLSchema</span>"> + <SOAP-ENV:Body> + <namesp1:BabelFishResponse xmlns:namesp1="urn:xmethodsBabelFish"> + <span style="color: green;"><return xsi:type="xsd:string">je suis</return></span> + </namesp1:BabelFishResponse> + </SOAP-ENV:Body> +</SOAP-ENV:Envelope> +</pre> + +<h3 id="Ressources" name="Ressources">Ressources</h3> + +<p><a class="external" href="http://lxr.mozilla.org/mozilla/source/extensions/webservices/docs/Soap_Scripts_in_Mozilla.html">SOAP Scripts in Mozilla (en)</a> par Ray Whitmer<br> + <a class="external" href="http://www.oreillynet.com/lpt/a/2677">Using the Mozilla SOAP API (en)</a> par Scott Andrew LePera et Apple Developer Connection.<br> + <a class="external" href="http://www.w3.org/TR/soap12-part1/">The Latest w3.org SOAP Specification (en)</a><br> + <a class="external" href="http://www.onlamp.com/lpt/a/5981">Calling SOAP Servers from JS in Mozilla (en)</a>, article de OnLamp.com par Zachary Kessin<br> + <a class="external" href="http://www.xulplanet.com/references/objref/SOAPCall.html">SOAPCall documentation on XULPlanet.com (en)</a><br> + <a class="external" href="http://www.xulplanet.com/references/objref/SOAPResponse.html">SOAPResponse documentation on XULPlanet.com (en)</a></p> diff --git a/files/fr/archive/mozilla/firefox/utilisation_de_microformats/index.html b/files/fr/archive/mozilla/firefox/utilisation_de_microformats/index.html new file mode 100644 index 0000000000..f45f86c6b4 --- /dev/null +++ b/files/fr/archive/mozilla/firefox/utilisation_de_microformats/index.html @@ -0,0 +1,197 @@ +--- +title: Utilisation de microformats +slug: Archive/Mozilla/Firefox/Utilisation_de_microformats +tags: + - Firefox 3 + - Microformats +translation_of: Archive/Mozilla/Firefox/Using_microformats +--- +<div></div> + +<p>Les microformats permettent aux sites Web de fournir des données sémantiques au navigateur afin que celui-ci puisse présenter un résumé des informations présentes sur une page sans avoir à connaître de manière particulière d'analyser son contenu. Firefox 3 implémente un objet global <code>Microformats</code> permettant d'accéder aux microformats. Cet objet et l'API associée facilitent la recherche et la lecture de microformats.</p> + +<h2 id="Chargement_de_l.27API_des_microformats" name="Chargement_de_l.27API_des_microformats">Chargement de l'API des microformats</h2> + +<p>L'objet <code>Microformats</code> est créé à l'aide du nouveau chargeur de scripts JavaScript ajouté à Firefox 3. Pour utiliser l'API, il faut d'abord charger cet objet :</p> + +<pre>Components.utils.import("resource://gre/modules/Microformats.js"); +</pre> + +<p>Une fois l'API des microformats chargée, il est possible de gérer des microformats à l'aide des méthodes listées ici. Pour plus d'information sur l'analyse de microformats, consultez <a href="/fr/docs/Analyse_de_microformats_en_JavaScript">Analyse de microformats en JavaScript</a>.</p> + +<h2 id="Microformats_pr.C3.A9d.C3.A9finis" name="Microformats_pr.C3.A9d.C3.A9finis">Microformats prédéfinis</h2> + +<p>Firefox 3 fournit des définitions implémentant divers microformats répandus :</p> + +<dl> + <dt><code><a href="/fr/docs/Le_microformat_adr">adr</a></code></dt> + <dd>Représente une adresse (comme une adresse de destination ou une adresse postale).</dd> + <dt><code><a href="/fr/docs/Le_microformat_geo">geo</a></code></dt> + <dd>Représente un emplacement géographique en utilisant sa latitude et sa longitude.</dd> + <dt><code><a href="/fr/docs/Le_microformat_hCard">hCard</a></code></dt> + <dd>Représente les informations de contact d'une personne.</dd> + <dt><code><a href="/fr/docs/Le_microformat_hCalendar">hCalendar</a></code></dt> + <dd>Représente une entrée de rendez-vous d'un agenda.</dd> + <dt><code><a href="/fr/docs/Le_microformat_tag">tag</a></code></dt> + <dd>Utilisé pour ajouter des balises à d'autres microformats.</dd> +</dl> + +<h2 id="M.C3.A9thodes" name="M.C3.A9thodes">Méthodes</h2> + +<h3 id="add.28.29" name="add.28.29">add()</h3> + +<p>Ajoute un nouveau microformat au module des microformats.</p> + +<p></p><div class="note"><strong>Note :</strong> Si un microformat du nom spécifié existe déjà, il sera remplacé par le nouveau.</div><p></p> + +<pre>add(nom, définition); +</pre> + +<h5 id="add-Param.C3.A8tres" name="add-Param.C3.A8tres">Paramètres</h5> + +<dl> + <dt><code>nom</code></dt> + <dd>Le nom du microformat à ajouter au module des microformats.</dd> + <dt><code>définition</code></dt> + <dd>Une structure JavaScript décrivant le microformat. Consultez <a href="/fr/docs/Description_de_microformats_en_JavaScript">Description de microformats en JavaScript</a> pour plus de détails.</dd> +</dl> + +<h3 id="count.28.29" name="count.28.29">count()</h3> + +<p>Compte le nombre de microformats dans un document qui correspondent à des critères spécifiés.</p> + +<pre>nbMicroformats = Microformats.count(nom, élémentRacine, options); +</pre> + +<h5 id="count-Param.C3.A8tres_2" name="count-Param.C3.A8tres_2">Paramètres</h5> + +<dl> + <dt><code>nom</code></dt> + <dd>Le nom du microformat à compter.</dd> + <dt><code>élémentRacine</code></dt> + <dd>Obligatoire. L'élément DOM où doit commencer la recherche. Pour rechercher dans le document entier, utiliser <code>content.document</code>.</dd> + <dt><code>options</code></dt> + <dd>Facultatif. Si ce paramètre est fourni, il s'agit d'un objet JavaScript contenant une série de drapeaux parmi les suivants : + <dl> + <dt><code>recurseExternalFrames</code></dt> + <dd>Si à <code>true</code>, les cadres enfants font partie de la recherche. La valeur par défaut est <code>true</code>.</dd> + <dt><code>showHidden</code></dt> + <dd>Si à <code>true</code>, les microformats cachés seront ajoutés ; autrement ils sont ignorés. La valeur par défaut est <code>false</code>.</dd> + <dt><code>debug</code></dt> + <dd>Spécifiez <code>true</code> si le mode debug est utilisé ; sinon indiquez <code>false</code>. La valeur par défaut est <code>false</code>.</dd> + </dl> + </dd> +</dl> + +<h5 id="count-Valeur_de_retour" name="count-Valeur_de_retour">Valeur de retour</h5> + +<p>Une valeur entière indiquant le nombre de microformats correspondant aux critères spécifiés.</p> + +<h3 id="debug.28.29" name="debug.28.29">debug()</h3> + +<p>Renvoie une chaîne qui décrit un objet de microformat.</p> + +<p></p><div class="note"><strong>Note :</strong> Il est possible d'appeler simplement <code>debug()</code> sur un objet de microformat : <code>objetMicroformat.debug()</code> au lieu d'utiliser cette méthode, si cela vous convient mieux.</div><p></p> + +<pre>dumpString = debug(objetMicroformat); +</pre> + +<h5 id="debug-Param.C3.A8tres" name="debug-Param.C3.A8tres">Paramètres</h5> + +<dl> + <dt><code>objetMicroformat</code></dt> + <dd>L'objet de microformat à afficher.</dd> +</dl> + +<h5 id="debug-Valeur_de_retour_2" name="debug-Valeur_de_retour_2">Valeur de retour</h5> + +<p>Une chaîne décrivant le contenu de l'objet de microformat spécifié.</p> + +<h3 id="get.28.29" name="get.28.29">get()</h3> + +<p>Renvoie un tableau d'objets de microformat correspondant aux critères spécifiés.</p> + +<pre>microformats = Microformats.get(nom, élémentRacine, options, tableauCible); +</pre> + +<h5 id="get-Param.C3.A8tres" name="get-Param.C3.A8tres">Paramètres</h5> + +<dl> + <dt><code>nom</code></dt> + <dd>Le nom du microformat recherché.</dd> + <dt><code>élémentRacine</code></dt> + <dd>Obligatoire. L'élément DOM d'où sera lancée la recherche. Pour rechercher dans le document entier, indiquer <code>content.document</code>.</dd> + <dt><code>options</code></dt> + <dd>Facultatif. Si fourni, il s'agit d'un objet JavaScript contenant une série éventuellement vide des drapeaux suivants : + <dl> + <dt><code>recurseExternalFrames</code></dt> + <dd>Si défini à <code>true</code>, les cadres enfants référençant du contenu externe feront partie de la recherche. La valeur par défaut est <code>true</code>.</dd> + <dt><code>showHidden</code></dt> + <dd>Si défini à <code>true</code>, les microformats masqués seront ajoutés ; dans le cas contraire ils seront ignorés. La valeur par défaut est <code>false</code>.</dd> + <dt><code>debug</code></dt> + <dd>Indique d'utiliser le mode<em>debug</em> si à <code>true</code>. La valeur par défaut est <code>false</code>.</dd> + </dl> + </dd> + <dt><code>tableauCible</code></dt> + <dd>Facultatif. Si fourni, il s'agir d'un tableau d'objets microformat auquel ajouter les résultats de la recherche.</dd> +</dl> + +<h5 id="get-Valeur_de_retour" name="get-Valeur_de_retour">Valeur de retour</h5> + +<p>Un nouveau tableau d'objets microformat correspondant aux critères de recherche, ou le tableau spécifié par le paramètre <code>microformats</code> auquel les nouveaux objets microformat trouvés auront été ajoutés.</p> + +<h3 id="getNamesFromNode.28.29" name="getNamesFromNode.28.29">getNamesFromNode()</h3> + +<p>Renvoie une liste de noms de microformats séparés par des espaces qui correspondent au nœud de microformat spécifié.</p> + +<pre>liste = Microformats.getNamesFromNode(nœud); +</pre> + +<h5 id="getNamesFromNode-Param.C3.A8tres" name="getNamesFromNode-Param.C3.A8tres">Paramètres</h5> + +<dl> + <dt><code>nœud</code></dt> + <dd>Le nœud pour lequel une liste de noms de microformats doit être obtenue.</dd> +</dl> + +<h5 id="getNamesFromNode-Valeur_de_retour" name="getNamesFromNode-Valeur_de_retour">Valeur de retour</h5> + +<p>Si le <code>nœud</code> spécifié est un microformat, le résultat est une chaîne listant tous les noms de microformats, séparés par des espaces, qui correspondent à ce nœud. Si le nœud n'est pas un microformat, rien ne sera renvoyé.</p> + +<h3 id="getParent.28.29" name="getParent.28.29">getParent()</h3> + +<p>Renvoie le nœud parent du microformat ou enfant de microformat spécifié.</p> + +<pre>nœudParent = Microformats.getParent(nœud); +</pre> + +<h5 id="getParent-Param.C3.A8tres" name="getParent-Param.C3.A8tres">Paramètres</h5> + +<dl> + <dt><code>nœud</code></dt> + <dd>Le nœud dont le parent doit être retrouvé.</dd> +</dl> + +<h5 id="getParent-Valeur_de_retour" name="getParent-Valeur_de_retour">Valeur de retour</h5> + +<p>Le parent du nœud spécifié. Ne renvoie rien si le <code>nœud</code> spécifié n'est pas un microformat ou l'enfant d'un microformat.</p> + +<h3 id="isMicroformat.28.29" name="isMicroformat.28.29">isMicroformat()</h3> + +<p>Détermine si le nœud DOM spécifié est un microformat.</p> + +<pre>valeur = Microformats.isMicroformat(nœud); +</pre> + +<h5 id="isMicroformat-Param.C3.A8tres" name="isMicroformat-Param.C3.A8tres">Paramètres</h5> + +<dl> + <dt><code>nœud</code></dt> + <dd>Le nœud DOM dont on veut savoir s'il est un microformat.</dd> +</dl> + +<h5 id="isMicroformat-Valeur_de_retour" name="isMicroformat-Valeur_de_retour">Valeur de retour</h5> + +<p><code>true</code> si le nœud est un microformat, <code>false</code> sinon.</p> + +<p></p><div class="note"><strong>Note :</strong> Cette méthode ne renvoie<em>pas</em> <code>true</code> si le nœud est l'enfant d'un microformat.</div><p></p> |