XBL Tutorial

Search…
XBL Tutorial
Encapsulation
The component system favors a strong encapsulation so that components can be:
developed in isolation, without knowing the details of the application using them
used without knowing the details of how they are implemented
in short: reused as much as possible!
The goal is first eased of use and transparency for the form author. This means that sometimes the component author must do a little bit more work!
The default: strong encapsulation
By default, within an <xbl:binding> element, encapsulation is strong: this means that XForms controls, models, and event handlers cannot:
see ids of the XForms document using the component
have access to the XPath context outside the component
In other words, things behave as if you were working in a new, completely separate XForms document!
If you place models within <xbl:implementation> or <xbl:template>, the same rule that applies in a top-level XForms document apply:
The default XPath context starts with the root element of the first instance of the first model.
However, if your component doesn't have a model, then the XPath context is set to an empty document node.
NOTE: In the future, this might change to being an empty sequence. For implementation-dependent reasons, for now an empty document node had to be used.
Creating a single-node binding
Orbeon Forms provides direct support for bindings with the binding mode:
1
<xbl:binding id="fr-foo" element="fr|foo" xxbl:mode="binding">
Copied!
This automatically means that the component supports all the XForms binding attributes, including ref and bind, and UI events such as xforms-enabled / xforms-disabled and others are dispatched as needed.
You can access the actual bound node via the xxf:binding() function:
1
xxf:binding('fr-foo')
Copied!
The id passed must be the id of the xbl:binding element.
For more, see The binding mode.
Adding support for a value
Some native XForms controls, like xf:input, xf:textarea, etc. support holding a value. This means in particular that the control is able to dispatch xforms-value-changed events. Some controls on the other hand, like xf:group, xf:repeat, can't hold a value and don't dispatch xforms-value-changed events.
The default for XBL components is that they don't hold a value. Use the value mode to add value behavior:
1
<xbl:binding
2
  id="fr-phone-binding"
3
  element="fr|us-phone"
4
  xxbl:mode="lhha binding value">
Copied!
The xxf:value() function allows access to the control's value from the inside, by using the binding id:
1
<xbl:binding id="fr-gaga" element="fr|gaga" xxbl:mode="binding value">
2
    <xbl:template>
3
        <xf:output id="gaga-output" value="xxf:value('fr-gaga')"/>
4
    </xbl:template>
5
</xbl:binding>
Copied!
Adding LHHA elements
Orbeon Forms provides direct support for label, help, hint and alert (LHHA):
1
<xbl:binding id="fr-foo" element="fr|foo" xxbl:mode="lhha">
Copied!
This automatically adds support for LHHA to the component:
1
<fr:foo>
2
    <xf:label>My label</xf:label>
3
    ...
4
</fr:foo>
Copied!
By default, markup is output for the LHHA elements. You can disable this with the custom-lhha mode:
1
<xbl:binding id="fr-foo" element="fr|foo" xxbl:mode="lhha custom-lhha">
Copied!
With this mode, no markup is output, and the component author can access the LHHA values with XPath functions:
1
<xf:output value="xxf:label('fr-foo')"/>
Copied!
[SINCE Orbeon Forms 4.5] When using the lhha mode, it is possible to link the label handled by the XBL engine to an internal control, so that that control and the label are linked. This is done with the xxbl:label-for attribute:
1
<xbl:binding
2
  id="fr-dropdown-select1"
3
  element="fr|dropdown-select1"
4
  xxbl:container="span"
5
  xxbl:mode="lhha binding value"
6
  xxbl:label-for="select1">
7
​
8
<xbl:template>
9
    <xf:select1
10
        appearance="minimal"
11
        ref="xxf:binding('fr-dropdown-select1')"
12
        id="select1">
13
    ...
Copied!
A basic component
You can find the component discussed in this section in the Orbeon Forms distribution:
XBL: tutorial-input.xbl​
Example: xbl-tutorial-input.xhtml​
Orbeon Forms modes make this very simple:
1
<xbl:xbl
2
    xmlns:xh="http://www.w3.org/1999/xhtml"
3
    xmlns:xf="http://www.w3.org/2002/xforms"
4
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
5
    xmlns:xxf="http://orbeon.org/oxf/xml/xforms"
6
    xmlns:fr="http://orbeon.org/oxf/xml/form-runner"
7
    xmlns:xbl="http://www.w3.org/ns/xbl"
8
    xmlns:xxbl="http://orbeon.org/oxf/xml/xbl">
9
​
10
    <xbl:binding
11
        element="fr|tutorial-input"
12
        id="fr-tutorial-input"
13
        xxbl:mode="lhha binding value">
14
        <xbl:template>
15
            <!-- Input points to the external single-node binding -->
16
            <xf:input ref="xxf:binding('fr-tutorial-input')"/>
17
        </xbl:template>
18
    </xbl:binding>
19
</xbl:xbl>
Copied!
Using local state
You can find the component discussed in this section in the Orbeon Forms distribution:
XBL: xbl/orbeon/tutorial-davinci/tutorial-davinci.xbl
Example: apps/xforms-sandbox/samples/xbl-tutorial-davinci.xhtml
Now assume you would like to write a component which stores the string of characters entered by the user but back to front, i.e. reversed. If the user types "Amelia", the string stored in the instance will be "ailemA".
How would you go about this? The binding between an XForms control and instance data is direct: the value entered by the user is stored into the instance as soon as the user moves out of the field, and you can't just write a transformation in between. So we need some intermediate state to store the value entered by the user.
To do so, we create a local instance. You can put it under the <xbl:implementation> or <xbl:template> elements in your XBL file:
1
<xf:model>
2
    <xf:instance><value/></xf:instance>
3
</xf:model>
Copied!
Here we store a single value, so we just use a single root element in the instance: <value>.
The local input field just points to the local instance instead of pointing to the external single-node binding:
1
<xf:input ref="instance()">
Copied!
So here, the input field points to the <value> element.
NOTE: You could also write ref=".", which would work because, like at the top-level of an XForms document, the default XPath context is the root element of the first instance in the first model. Using instance() is a bit more explicit.
What is needed now is, when the local value changes, to copy it to the external single-node binding. You do so with an event handler:
1
<xf:input ref="instance()">
2
    <xf:setvalue
3
        event="xforms-value-changed"
4
        ref="xxf:binding('fr-tutorial-davinci')"
5
        value="context()"/>
6
</xf:input>
Copied!
What's missing now is to reverse the value:
1
<xf:input ref="instance()">
2
    <xf:setvalue
3
        event="xforms-value-changed"
4
        ref="xxf:binding('fr-tutorial-davinci')"
5
        value="
6
            codepoints-to-string(
7
                reverse(
8
                    string-to-codepoints(
9
                       instance()
10
                    )
11
                )
12
            )
13
        "/>
14
</xf:input>
Copied!
Finally, the opposite operation is needed: when the component first comes to life, and when the external value changes, the internal value must update:
1
<xbl:handler
2
    event="xforms-enabled xforms-value-changed"
3
    ref="instance()"
4
    value="
5
        codepoints-to-string(
6
            reverse(
7
                string-to-codepoints(
8
                    xxf:binding('fr-tutorial-davinci')
9
                )
10
            )
11
        )
12
 "/>
Copied!
So here you go: you have a fully working non-trivial component:
1
<xbl:xbl
2
    xmlns:xh="http://www.w3.org/1999/xhtml"
3
    xmlns:xf="http://www.w3.org/2002/xforms"
4
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
5
    xmlns:xxf="http://orbeon.org/oxf/xml/xforms"
6
    xmlns:fr="http://orbeon.org/oxf/xml/form-runner"
7
    xmlns:xbl="http://www.w3.org/ns/xbl"
8
    xmlns:xxbl="http://orbeon.org/oxf/xml/xbl">
9
​
10
    <xbl:binding
11
        element="fr|tutorial-davinci"
12
        id="fr-tutorial-davinci"
13
        xxbl:mode="lhha binding value">
14
        <xbl:handlers>
15
            <!-- When the control comes to life or its value changes, copy
16
                 the new value to the local model after reversing it -->
17
            <xbl:handler
18
                event="xforms-enabled xforms-value-changed"
19
                ref="instance()"
20
                value="
21
                    codepoints-to-string(
22
                        reverse(
23
                            string-to-codepoints(
24
                                xxf:binding('fr-tutorial-davinci')
25
                            )
26
                        )
27
                    )
28
                "/>
29
        </xbl:handlers>
30
        <xbl:template>
31
            <!-- Local model and instance -->
32
            <xf:model>
33
                <xf:instance><value/></xf:instance>
34
            </xf:model>
35
            <!-- Input points to the internal value -->
36
            <xf:input ref="instance()">
37
                <!-- When the local value changes, copy it to the external
38
                     single-node binding after reversing it -->
39
                <xf:setvalue
40
                    event="xforms-value-changed"
41
                    ref="xxf:binding('fr-tutorial-davinci')"
42
                    value="
43
                        codepoints-to-string(
44
                            reverse(
45
                                string-to-codepoints(
46
                                    instance()
47
                                )
48
                            )
49
                        )
50
                    "/>
51
            </xf:input>
52
        </xbl:template>
53
    </xbl:binding>
54
</xbl:xbl>
Copied!
Guide
Bindings
Last modified 2yr ago
Copy link
Contents
Encapsulation
The default: strong encapsulation
Creating a single-node binding
Adding support for a value
Adding LHHA elements
A basic component
Using local state