` tag ### Root Nodes For many reasons, Owl QWeb templates should have a single root node. More precisely, the result of a template rendering should have a single root node: ```xml

foo

bar

foo

bar ``` Extra root nodes will actually be ignored (even though they will be rendered in memory). Note: this does not apply to subtemplates (see the `t-call` directive). In that case, they will be inlined in the main template, and can actually have many root nodes. ### Expression Evaluation QWeb expressions are strings that will be processed at compile time. Each variable in the javascript expression will be replaced with a lookup in the context (so, the component). For example, `a + b.c(d)` will be converted into: ```js context["a"] + context["b"].c(context["d"]); ``` It is useful to explain the various rules that apply on these expressions: 1. it should be a simple expression which returns a value. It cannot be a statement. ```xml

``` is valid, but the following is not valid: ```xml

NOT valid

``` 2. it can use anything in the rendering context (typically, the component): ```xml

Happy bithday!

``` is valid, and will read the `user` object from the context, and call the `today` function. 3. it can use a few special operators to avoid using symbols such as `<`, `>`, `&` or `|`. This is useful to make sure that we still write valid XML. | Word | replaced with | | ----- | ------------- | | `and` | `&&` | | `or` | `\|\|` | | `gt` | `>` | | `gte` | `>=` | | `lt` | `<` | | `lte` | `<=` | So, one can write this: ```xml

``` ### Static Html Nodes Normal, regular html nodes are rendered into themselves: ```xml

hello

``` ### Outputting Data The `t-esc` directive is necessary whenever you want to add a dynamic text expression in a template. The text is escaped to avoid security issues. ```xml

``` rendered with the value `value` set to `42` in the rendering context yields: ```html

``` The `t-raw` directive is almost the same as `t-esc`, but without the escaping. This is mostly useful to inject a raw html string somewhere. Obviously, this is unsafe to do in general, and should only be used for strings known to be safe. ```xml

``` rendered with the value `value` set to `foo` in the rendering context yields: ```html

foo

``` Note that since the content of the expression is not known beforehand, the `t-raw` directive has to parse the html (and convert it to a virtual dom structure) for each rendering. So, it will be much slower than a regular template. It is therefore advised to limit the use of `t-raw` whenever possible. ### Setting Variables QWeb allows creating variables from within the template, to memoize a computation (to use it multiple times), give a piece of data a clearer name, ... This is done via the `t-set` directive, which takes the name of the variable to create. The value to set can be provided in two ways: 1. a `t-value` attribute containing an expression, and the result of its evaluation will be set: ```xml ``` will print `3`. Note that the evaluation is done at rendering time, not at compilte time. 2. if there is no `t-value` attribute, the node’s body is saved and its value is set as the variable’s value: ```xml

``` will generate `<li>ok</li>` (the content is escaped as we used the `t-esc` directive) The `t-set` directive acts like a regular variable in most programming language. It is lexically scoped (inner nodes are sub scopes), can be shadowed, ... ### Conditionals The `t-if` directive is useful to conditionally render something. It evaluates the expression given as attribute value, and then acts accordingly. ```xml

``` The element is rendered if the condition (evaluated with the current rendering context) is true: ```xml

``` but if the condition is false it is removed from the result: ```xml

``` The conditional rendering applies to the bearer of the directive, which does not have to be ``: ```xml

``` will give the same results as the previous example. Extra conditional branching directives `t-elif` and `t-else` are also available: ```xml

Happy bithday!

Welcome master!

Welcome!

``` ### Dynamic Attributes One can use the `t-att-` directive to add dynamic attributes. Its main use is to evaluate an expression (at rendering time) and bind an attribute to its result: For example, if we have `id` set to 32 in the rendering context, ```xml

``` If an expression evaluates to a falsy value, it will not be set at all: ```xml

``` It is sometimes convenient to format an attribute with string interpolation. In that case, the `t-attf-` directive can be used. It is useful when we need to mix literal and dynamic elements, such as css classes. ```xml

``` If we need completely dynamic attribute names, then there is an additional directive: `t-att`, which takes either an object (with keys mapping to their values) or a pair `[key, value]`. For example: ```xml

``` ### Loops QWeb has an iteration directive `t-foreach` which take an expression returning the collection to iterate on, and a second parameter `t-as` providing the name to use for the current item of the iteration: ```xml

``` will be rendered as: ```xml

``` Like conditions, `t-foreach` applies to the element bearing the directive’s attribute, and ```xml

``` is equivalent to the previous example. `t-foreach` can iterate on an array (the current item will be the current value) or an object (the current item will be the current key). In addition to the name passed via t-as, `t-foreach` provides a few other variables for various data points (note: `$as` will be replaced with the name passed to `t-as`): - `$as_value`: the current iteration value, identical to `$as` for lists and integers, but for objects, it provides the value (where `$as` provides the key) - `$as_index`: the current iteration index (the first item of the iteration has index 0) - `$as_first`: whether the current item is the first of the iteration (equivalent to `$as_index == 0`) - `$as_last`: whether the current item is the last of the iteration (equivalent to `$as_index + 1 == $as_size`), requires the iteratee’s size be available These extra variables provided and all new variables created into the `t-foreach` are only available in the scope of the `t-foreach`. If the variable exists outside the context of the `t-foreach`, the value is copied at the end of the foreach into the global context. ```xml

``` Owl QWeb is used as the template engine for components. Components are frequently updated, and reuse as much of the previous DOM as possible. Loops offer a specific problem for this usecase: how does the template engine know if two rows have been swapped, or if the content of these rows was changed? To help Owl with that, there is an additional directive: [`t-key`](component.md#t-key-directive). ```xml

``` If there is no `t-key` directive, Owl will use the index as a default key. ### Rendering Sub Templates QWeb templates can be used for top level rendering, but they can also be used from within another template (to avoid duplication or give names to parts of templates), using the `t-call` directive: ```xml

``` will be rendered as `

owl

`. This example shows that the sub template is rendered with the execution context of the parent. The sub template is actually inlined in the main template, but in a sub scope: variables defined in the sub template do not escape. Sometimes, one might want to pass information to the sub template. In that case, the content of the body of the `t-call` directive is available as a special magic variable `0`: ```xml This template was called with content:

content

``` will result in : ```xml

This template was called with content: content

``` ### Translations If properly setup, Owl QWeb engine can translate all rendered templates. To do so, it needs a translate function, which takes a string and returns a string. For example: ```js const translations = { hello: "bonjour", yes: "oui", no: "non" }; const translateFn = str => translations[str] || str; const qweb = new QWeb({ translateFn }); ``` Once setup, all rendered templates will be translated using `translateFn`: - each text node will be replaced with its translation, - each of the following attribute values will be translated as well: `title`, `placeholder`, `label` and `alt`, - translating text nodes can be disabled with the special attribute `t-translation`, if its value is `off`. So, with the above `translateFn`, the following templates: ```xml

hello

Are you sure?

``` will be rendered as: ```xml

bonjour

hello

Are you sure?

``` Note that the translation is done during the compilation of the template, not when it is rendered. ### Debugging The javascript QWeb implementation provides two useful debugging directives: `t-debug` adds a debugger statement during template rendering: ```xml ``` will stop execution if the browser dev tools are open. `t-log` takes an expression parameter, evaluates the expression during rendering and logs its result with console.log: ```xml ``` will print 42 to the console.