From 33058f2b292b3a581333bdfb21b8f671898c5060 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:40:17 -0500 Subject: initial commit --- files/fr/archive/mozilla/xbl/index.html | 37 ++ .../r\303\251f\303\251rence_xbl_1.0/index.html" | 106 +++++ .../\303\251l\303\251ments/index.html" | 462 +++++++++++++++++++++ 3 files changed, 605 insertions(+) create mode 100644 files/fr/archive/mozilla/xbl/index.html create mode 100644 "files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/index.html" create mode 100644 "files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/\303\251l\303\251ments/index.html" (limited to 'files/fr/archive/mozilla/xbl') diff --git a/files/fr/archive/mozilla/xbl/index.html b/files/fr/archive/mozilla/xbl/index.html new file mode 100644 index 0000000000..126b055462 --- /dev/null +++ b/files/fr/archive/mozilla/xbl/index.html @@ -0,0 +1,37 @@ +--- +title: XBL +slug: Archive/Mozilla/XBL +tags: + - XBL +translation_of: Archive/Mozilla/XBL +--- +

+XML Binding Language (XBL, parfois aussi appelé langage de liaison extensible) est un langage permettant de décrire des liaisons pouvant être attachées à des éléments dans d'autres documents. L'élément auquel la liaison est attachée, appelé l'élément lié (bound element), acquiert le nouveau comportement spécifié par la liaison. +

Les liaisons peuvent contenir des gestionnaires d'évènements enregistrés sur l'élément lié, une implémentation de nouvelles méthodes et propriétés devenant accessibles depuis cet élément, et du contenu anonyme qui sera inséré par dessous l'élément lié. +

La plupart des éléments d'interface XUL sont au moins partiellement implémentés à l'aide de XBL. Vous pouvez construire vos propres éléments réutilisables à partir d'éléments XUL, HTML, SVG, et d'autres primitives à l'aide de XBL. +

+

Spécifications

+ +

Certaines des différences entre sXBL et XBL2 ont été relevées dans un article d'Anne van Kesteren (en anglais). +

Une présentation des différences entre le XBL de Mozilla et XBL2 est disponible dans ce message de Jonas Sicking (avril 2007). +

+

Voir aussi

+ +

Communauté

+ +

+

diff --git "a/files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/index.html" "b/files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/index.html" new file mode 100644 index 0000000000..19f7e528e9 --- /dev/null +++ "b/files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/index.html" @@ -0,0 +1,106 @@ +--- +title: Référence XBL 1.0 +slug: Archive/Mozilla/XBL/Référence_XBL_1.0 +tags: + - XBL +translation_of: Archive/Mozilla/XBL/XBL_1.0_Reference +--- +

+

+

Résumé

+

Ce document décrit le langage de liaison extensible (Extensible Binding Language, XBL) 1.0 tel qu'implémenté dans les navigateurs basés sur Gecko. +

XBL est un langage de balisage basé sur XML pour implémenter des composants réutilisables (liaisons ou bindings) qui peuvent être liés à des éléments d'autres documents. L'élément pour lequel une liaison a été spécifiée, appelé l'élément lié ou bound element, reçoit un nouveau comportement spécifié par la liaison. Les liaisons peuvent être liées à des éléments à l'aide de feuilles de style en cascade (CSS) ou via le DOM. Un élément peut être lié à plusieurs liaisons différentes en même temps.

Fonctionnellement, les liaisons XBL peuvent être comparées avec les fonctionnalités Behaviors et Viewlink de Microsoft, mais implémentées comme une solution XML intégrée. +

Les liaisons peuvent contenir des gestionnaires d'évènements enregistrées sur l'élément lié, une implémentation de nouvelles méthodes et propriétés qui deviennent accessibles depuis celui-ci, et du contenu anonyme à insérer autour de cet élément. +

+
+

Différents ajustements dans l'implémentation actuelle ont été faits depuis les propositions XBL plus anciennes, et tous ne sont pas encore reflétés dans ce document. Le processus de documentation est toujours en cours : gardez cela à l'esprit lorsque vous utilisez les informations fournies. +

+
+

Éléments XBL

+

Les éléments XBL 1.0 sont dans l'espace de noms http://www.mozilla.org/xbl. +

+ +

Attachement et détachement de liaisons

+ +

Interfaces DOM

+ +

Contenu anonyme

+ +

Implémentations de liaisons

+ +

Gestionnaires d'évènements

+

Exemple - Notes

+

Mis à jour et ajusté pour l'implémentation actuelle de Firefox. +

+
+

Cet exemple est destiné à montrer l'utilisation de XBL plutôt que pour être une application utile en pratique. Pour cette raison, il contient de nombreux commentaires et certains blocs qui auraient pu être évités dans une solution plus compacte mais sont utilisés ici à des fins de démonstration. +

+
+ +

Voir cet exemple +


+Téléchargement de tous les fichiers (archive .zip) need to ask to adjust the server - it gives "Access denied" for zip files (?) +

+

Références

+ +
+

Informations sur le document original

+ +
diff --git "a/files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/\303\251l\303\251ments/index.html" "b/files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/\303\251l\303\251ments/index.html" new file mode 100644 index 0000000000..fffa11dcf9 --- /dev/null +++ "b/files/fr/archive/mozilla/xbl/r\303\251f\303\251rence_xbl_1.0/\303\251l\303\251ments/index.html" @@ -0,0 +1,462 @@ +--- +title: Éléments +slug: Archive/Mozilla/XBL/Référence_XBL_1.0/Éléments +translation_of: Archive/Mozilla/XBL/XBL_1.0_Reference/Elements +--- +

bindings

+ +

Cette section est testée et ajustée selon l'implémentation courante de Firefox. Veuillez ne la modifier que si le comportement réel diffère de celui qui est décrit. Veuillez ne pas le faire seulement sur base d'une autre spécification XBL.

+ +
<!ELEMENT bindings ( binding* ) >
+
+Hiérarchie :   élément racine
+Peut contenir : <binding>
+
+ +

L'élément bindings est l'élément racine de tout document XBL. Il doit habituellement déclarer XBL en tant qu'espace de noms par défaut (à moins qu'un préfixe d'espaces de noms XBL soit utilisé) et peut également déclarer d'autres préfixes d'espace de noms utilisés dans votre liaison.

+ +

bindings contient zéro ou plus éléments binding comme enfants. Chaque élément binding enfant définit une liaison unique pouvant être attachée à des éléments dans d'autres documents.

+ +

Un élément ne peut avoir qu'une liaison attachée (explicitement ou héritée) à un moment donné. Si plusieurs liaisons sont définies, seule la dernière de la séquence sera utilisée (comme avec toute règle CSS).

+ +

helloworld.html :

+ +
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html>
+<head>
+<title>Hello world!</title>
+<style type="text/css">
+p {
+ -moz-binding: url(hello.xml#default);
+}
+#p03 {
+ -moz-binding: url(hello.xml#hello2);
+}
+</style>
+</head>
+<body>
+
+  <p>Default content</p>
+  <p>Default content</p>
+  <p id="p03">Default content</p>
+
+</body>
+</html>
+
+ +

hello.xml :

+ +
<?xml version="1.0"?>
+<bindings xmlns="http://www.mozilla.org/xbl"
+ xmlns:html="http://www.w3.org/1999/xhtml">
+  <binding id="default">
+    <content><html:b>Hello world! </html:b><children/></content>
+  </binding>
+  <binding id="hello2">
+    <content><html:b>Hello from my binding! </html:b><children/></content>
+  </binding>
+</bindings>
+
+ +

Vous pouvez voir le résultat en ouvrant helloworld.html dans Firefox. hello.xml doit se trouver dans le même répertoire que helloworld.html.

+ +

Suivant : bindings > élément binding.

+ +

Notes

+ + + +
<bindings xmlns="http://www.mozilla.org/xbl"
+ xmlns:html = "http://www.w3.org/1999/xhtml"
+ xmlns:xul  = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+ xmlns:svg  = "http://www.w3.org/2000/svg"
+ xmlns:xlink= "http://www.w3.org/1999/xlink">
+
+ +

binding

+ +
<!ENTITY % binding-content "(resources?,content?,implementation?,handlers?)">
+<!ELEMENT binding %binding-content;>
+<!ATTLIST binding
+   id                     ID             #REQUIRED
+   extends                CDATA          #IMPLIED
+   display                CDATA          #IMPLIED
+   inheritstyle           true           #IMPLIED
+>
+
+ +

L'élément binding décrit une seule liaison XBL. Une liaison XBL peut ajouter du contenu anonyme, des champs, des propriétés, des méthodes et des gestionnaires d'évènements à des éléments HTML/XML.

+ +

Une seule liaison XBL peut être attachée à un élément à l'aide de feuilles de style pour par script. (Consultez le bug 83830 pour les spécificités de <table>).

+ +

CSS :

+ +
div {
+ -moz-binding: url(myBinding.xml#default);
+}
+
+ +

DOM :

+ +
elementReference.style.MozBinding = "url(myBinding.xml#default)";
+
+ +

Dans les deux cas qui précèdent, on utilise binding avec id="default" dans un fichier myBinding.xml.

+ +

À partir de Firefox 3, il est également possible d'utiliser une URL data: pour intégrer la liaison directement :

+ +
div {
+  -moz-binding: url(data:text/xml;charset=utf-8,%3C%3Fxml%20version%3D%221.0%22%3F%3E%0A%3Cbindings%20id%3D%22xbltestBindings%22%20xmlns%3D%22http%3A//www.mozilla.org/xbl%22%3E%0A%20%20%3Cbinding%20id%3D%22xbltest%22%3E%3Ccontent%3EPASS%3C/content%3E%3C/binding%3E%0A%3C/bindings%3E%0A);
+}
+
+ +

Comme les URL data: ne gèrent pas les identifiants de fragments, la première liaison trouvée dans le XML intégré est utilisée à la place. N'oubliez pas que la liaison doit toujours avoir un ID même si on ne la référence pas. De plus, les URL data: ne sont gérées que depuis du code chrome (autrement dit, depuis l'application ou une extension).

+ +
Note : La politique de même origine est utilisée pour les sites web ; ils peuvent seulement lier des fichiers XBL du même domaine, ou dans le chrome.
+ +

Pour des raisons de clarté, voici à quoi ressemble le XML intégré dans l'exemple qui précède :

+ +
<?xml version="1.0"?>
+<bindings id="xbltestBindings" xmlns="http://www.mozilla.org/xbl">
+  <binding id="xbltest"><content>PASS</content></binding>
+</bindings>
+
+ +

La seule manière simple d'attacher des liaisons à tout ensemble d'éléments est d'utiliser des déclarations CSS. Cela permet également de rendre l'implémentation des liaisons partiellement fonctionnelle si le scripting est désactivé. Dans ce dernier cas, toutes les méthodes et tous les gestionnaires d'évènements seront bloqués, mais le contenu anonyme et les styles seront toujours utilisés. C'est pourquoi que les déclarations CSS doivent toujours être utilisées — à moins que vous deviez ajouter des liaisons en cours d'exécution à des éléments particuliers.

+ +

Un élément binding peut contenur une balise resources, une balise content, une balise implementation et une balise handlers.

+ + + +

 

+ +

content

+ +
<!ELEMENT content ANY>
+<!ATTLIST content
+   id               ID           #IMPLIED
+>
+
+ +

Une liaison peut spécifier du nouveau contenu qui sera placé à l'intérieur de l'élément lié. Bien que ce contenu soit visible à l'écran comme s'il était directement dans le fichier, il est anonyme et est invisible du DOM normal. Pour accéder à des nœuds anonymes sur un élément XBL lié, vous pouvez utiliser les fonctions getAnonymousElementByAttribute et getAnonymousNodes. Le seul élément XBL pouvant apparaître dans la balise content est l'élément children. Les attributs de l'élément <content> dans la liaison sont définis sur l'élément lié.

+ + + +

children

+ +
<!ELEMENT children EMPTY>
+<!ATTLIST children
+   id               ID                           #IMPLIED
+   includes         CDATA                        #IMPLIED
+>
+
+ +

Spécifie l'emplacement où les éventuels enfants de l'élément lié seront placés dans le contenu généré.

+ +

Normalement, si l'élément lié a son propre contenu, le contenu anonyme n'est pas généré. Cependant, avec un élément children, il est possible de fusionner le contenu de l'élément HTML/XML avec le contenu XBL.

+ +

Si la balise children a elle-même un contenu, celui-ci deviendra le contenu par défaut. Si l'élément auquel la liaison est attachée a du contenu, le contenu par défaut sera ignoré. Si l'élément n'a aucun contenu, le contenu par défaut sera ajouté.

+ + + +

implementation

+ +
<!ENTITY % implementation-content "(method|property)*">
+<!ELEMENT implementation %implementation-content;>
+<!ATTLIST implementation
+   id               ID           #IMPLIED
+   name             CDATA        #IMPLIED
+   implements       CDATA        #IMPLIED
+>
+
+ +

The implementation element describes the set of methods and properties that are attached to the bound element. Once the binding is attached, these methods and properties can be invoked directly from the bound element.

+ + + +

constructor

+ +

The code inside the constructor is called when a binding has just been attached to an element. So full access to anonymous nodes generated by the binding is already possible. The constructor tag must be placed inside the implementation tag.

+ + + +
Note: Prior to Firefox 3, the constructor could be called at a time when reflow of the document layout was locked down, so that attempting to get layout information from within the constructor could return out of date information. In Firefox 3 and later, the constructor is called when reflow can take place, which results in up-to-date information being returned. See bug 398404 for details.
+ +

destructor

+ +

The code inside the destructor is called when a binding is being removed from an element. You can use this to unload resources to free memory. However the destructor is often not called when it should, see bug 230086. The destructor tag must be placed inside the implementation tag.

+ + + +

method

+ +
<!ENTITY % method-content "(parameter*,body?)">
+<!ELEMENT method %method-content;>
+<!ATTLIST method
+   id               ID           #IMPLIED
+   name             CDATA        #REQUIRED
+   type             CDATA        #IMPLIED
+>
+
+ +

The method element is used to describe a single method of a binding implementation.

+ + + +

Example

+ +
<method name="scrollTo">
+  <parameter name="index"/>
+  <body>
+    this.setAttribute("scrollpos", index);
+  </body>
+</method>
+
+ +

parameter

+ +
<!ELEMENT parameter EMPTY>
+<!ATTLIST parameter
+   id               ID           #IMPLIED
+   name             CDATA        #REQUIRED
+>
+
+ +

The parameter element is used inside a method element. It represents a single parameter of a method.

+ + + +

body

+ +
<!ELEMENT body CDATA>
+<!ATTLIST body
+   id               ID           #IMPLIED
+>
+
+ +

The body element represents the implementation of its corresponding method. Its contents are the script that is executed when the method is invoked.

+ + + +

field

+ +
<!ELEMENT field EMPTY>
+<!ATTLIST field
+   id               ID                  #IMPLIED
+   name             CDATA               #REQUIRED
+   readonly         (true|false)        #IMPLIED
+>
+
+ +

A field is similar to a property, except that it should not have a getter or setter. It is useful as a simple holder for a value. The field element must have content which is code that determines the initial value of the field. The field tag must be inside the implementation tag.

+ + + +
Note: In Firefox 3, fields are now evaluated the first time they're accessed instead of at binding attachment time. This shouldn't cause any problems in typical use cases, but there are cases in which this will impact the behavior of your code. See bug 372769 for details.
+ +

Here are some examples of cases in which the behavior of your code may change due to this change in Firefox 3:

+ +
    +
  1. If you have two fields, one named A and one named B, and field A sets .B, the value of .B will depend on whether or not .A has already been accessed.
    2. +
  2. If a proto is inserted into the proto chain after binding instantiation, doing so may affect field values (this wasn't the case in prior versions of Firefox).
    3. +
  3. At binding attachment time, <field name="parentNode">this.parentNode</field> is undefined instead of the value of parentNode.
    4. +
  4. A field no longer changes the value of a property set on the object itself (rather than a proto) before binding attachment.
    5. +
+ +

property

+ +
<!ENTITY % property-content "(getter?,setter?)">
+<!ELEMENT property %property-content;>
+<!ATTLIST property
+   id               ID                  #IMPLIED
+   name             CDATA               #REQUIRED
+   readonly         (true|false)        #IMPLIED
+   onget            CDATA               #IMPLIED
+   onset            CDATA               #IMPLIED
+>
+
+ +

The property element represents a single property of an implementation. A property consists of a pair of getter/setter functions that can be defined using onget/onset attributes or getter/setter elements underneath the property element. Like methods, once the binding is attached, the property can be obtained directly from the bound element. The property tag must be inside the implementation tag.

+ + + +

getter

+ +
<!ELEMENT getter PCDATA>
+<!ATTLIST getter
+   id               ID                  #IMPLIED
+>
+
+ +

The getter element contains script that gets executed when a specific property gets called. The getter tag must be inside the property tag.

+ + + +

setter

+ +
<!ELEMENT setter PCDATA>
+<!ATTLIST setter
+   id               ID                  #IMPLIED
+>
+
+ +

The setter element contains script that gets executed when a specific property is being set. The setter tag must be inside the property tag.

+ + + +

handlers

+ +
<!ENTITY % handlers-content "handler*">
+<!ELEMENT handlers %handlers-content;>
+<!ATTLIST handlers
+   id               ID                  #IMPLIED
+>
+
+ +

The handlers element contains event handlers that can be attached to elements within the bound document. These handlers are installed when the binding is attached and removed when the binding is detached. The handlers tag must be inside the binding tag.

+ + + +

handler

+ +
<!ENTITY % handler-content "PCDATA">
+<!ELEMENT handler %handler-content;>
+<!ATTLIST handler
+   id               ID                                  #IMPLIED
+   event            NMREF                               #REQUIRED
+   action           CDATA                               #IMPLIED
+   phase            (capturing|bubbling|target)         #IMPLIED
+   button           (1|2|3)                             #IMPLIED
+   modifiers        CDATA                               #IMPLIED
+   keycode          CDATA                               #IMPLIED
+   key              CDATA                               #IMPLIED
+   charcode         CDATA                               #IMPLIED
+   clickcount       (1|2|3)                             #IMPLIED
+   command          ID                                  #IMPLIED
+   preventdefault   false|true                          #IMPLIED
+>
+
+ +

The handler element describes a single event handler. This handler is attached to its target at the time the binding is attached and unhooked when the binding is detached from the bound element. The script inside the handler is executed when the event handler is matched. The handler tag must be inside the handlers tag.

+ + + +

resources

+ +
<!ENTITY % resources-content "(image?,stylesheet?)">
+<!ELEMENT resources %resources-content;>
+<!ATTLIST property
+   id               ID                  #IMPLIED
+>
+
+ +

Used for inclusion of image elements, to cache them for later use, and for inclusion of stylesheet elements. The resources tag must be used directly inside the binding tag.

+ + + +

stylesheet

+ +
<!ELEMENT stylesheet EMPTY>
+<!ATTLIST stylesheet
+   id               ID                  #IMPLIED
+   src              URI                 #REQUIRED
+>
+
+ +

The stylesheet element declares a style sheet used by the binding. The style rules in the style sheet will only be applied to the binding, not to other elements in the document. The stylesheet tag must be inside the resources tag.

+ + + +

image

+ +
<!ELEMENT image EMPTY>
+<!ATTLIST image
+   id               ID                  #IMPLIED
+   src              URI                 #REQUIRED
+>
+
+ +

Declares an image resource used by the binding. The image is loaded as soon as the binding is used. You can use this to preload a number of images for later use. The image tag must be inside the resources tag.

+ + -- cgit v1.2.3-54-g00ecf