Neil's Place

July 31, 2005

8:23 PM How Templates Work XXXI - Tree Builder Features

Besides the label of a cell, there are several other cell properties you can set when using the tree builder. The supported properties are: label, mode, properties, src and value. The label attribute is used to set the label for a cell. The mode is used for progress meter columns. It may be set to either 'normal' for a normal progress meter or 'undetermined' for an undetermined progress meter. The value attribute is used to set the current progress value for normal progress meters. The value attribute may also be used for checkbox columns by setting it to either true or false. Whether a cell is a normal labeled value, a progress meter or a checkbox is determined by the type attribute on the column the cell is in.

For cells in normal columns, you can use the value attribute to store some other value and you can use the view's getCellValue method to retrieve it. Naturally, this will retrieve the value after any variables have been substituted. Besides the attributes mentioned above, any other attributes specified on the tree rows and cells are ignored. Since no elements are generated, you won't be able to retrieve the values for them either. Thus, the value attribute may be useful to associate an additional value with a row since it will be easier to retrieve.

The src attribute may be used to set an image to appear in a cell. For example:

<tree id="photosList" flex="1" datasources="template-guide-photos5.rdf"
      ref="http://www.xulplanet.com/rdf/myphotos" flags="dont-build-content">
  <treecols>
    <treecol id="photo" label="Photo" flex="1"/>
  </treecols>
  <template>
    <treechildren>
      <treeitem uri="rdf:*">
        <treerow>
          <treecell src="rdf:*"/>
        </treerow>
      </treeitem>
    </treechildren>
  </template>
</tree>

This tree displays each photo in the tree cells. In this case, the member resource is used since that holds the photo's URL, however it could be any other variable, a static value, or a combination of both.

Of course, we can't really see the photos, since the tree's rows are too small. Normally, you wouldn't put photos in a tree like this; instead the images would be used for icons. However, you could use a stylesheet to change the default height of the tree rows. You cannot make each row a different height, but you can change the height of all rows with some CSS:

treechildren::-moz-tree-row {
  height: 150px;
}

Since no elements are constructed by the tree builder, you cannot use the style or class attributes to change the style of a cell (This is the case with all trees). You must use syntax like that above to change the appearance. In the example above, it changes the height of a row to 150 pixels. You may want to change the syntax to refer to a specific <treechildren> element rather than all of them. Once the row height is changed, we can see the entirety of the photos.

Since we need to use special CSS for trees, the properties attribute on a cell becomes useful. It can be used to define extra properties that can be refered to in a stylesheet. For example, if the properties attribute was set to the value "?creator", you could style the photos created by different people differently. You can also use static values in addition to variables in the properties attribute. For instance, consider the following CSS:

treechildren::-moz-tree-cell(Dave) {
  background-color: lightgreen;
}

This would set the background colour of a cell to green for any cell with the "Dave" property. You can also use the properties attribute on the <treerow> to change the style for an entire row. This example sets the country associated with a photo as a property of a tree's rows. We can use that property to change the appearance of each row.

<rule>
  <conditions>
    <content uri="?start"/>
    <member container="?start" child="?photo"/>
    <triple subject="?photo"
            predicate="http://www.xulplanet.com/rdf/country"
            object="?country"/>
    <triple subject="?country"
            predicate="http://purl.org/dc/elements/1.1/title"
            object="?countrytitle"/>
  </conditions>
  <action>
    <treechildren>
      <treeitem uri="?photo">
        <treerow properties="?countrytitle">
          <treecell src="?photo" label="Cat"/>
        </treerow>
      </treeitem>
    </treechildren>
  </action>
</rule>

You might use the following CSS to change the border around rows with a particular country:

treechildren::-moz-tree-row(Netherlands) {
  border: green 1px solid;
}

The result of this example is a tree where one row has a green border around it.

Comments ( 0 )

July 27, 2005

7:21 PM How Templates Work XXX - Building Trees

The most common element to use with a template is the tree. You can use a template with a tree just like any other template. However, since templates are often used with trees, especially with large amounts of data, the template system supports a special builder just for creating trees. Rather than generate content for each row in the tree, the results are just stored in a list inside the builder. This means that DOM nodes are not constructed for any of the items. This is much more efficient as creating a lot of DOM nodes would add a lot of additional overhead. This performance advantage is possible since trees can only display text so the builder only has a few pieces of information to keep track of.

To use the tree builder, you need to add a flags attribute to the root node:

<tree datasources="template-guide-streets.rdf"
      ref="http://www.xulplanet.com/rdf/myneighbourhood"
      flags="dont-build-content">

The "dont-build-content" flag is descriptive in that it doesn't cause any content to be built. However, what it really does is use a subtype of the main builder specific to trees, called the tree builder. Without this flag, the template will be handled using the other type of builder, which is called a content builder, as it generates content. Note that while a tree builder can only be used with trees, a content builder can be used with any type of content. You can also choose to use the content builder for a tree, if you wish. There may be uses for this, especially for small amounts of data. However, you will find that the content builder will be slower as the amount of data to display gets larger.

Apart from the flags attribute, the template syntax is exactly the same for the tree builder as with the content builder. One thing though is that the tree builder requires a very specific form to the action body, specifically, the action body should be a single treeitem with its row and cells. Here is an example:

<tree id="photosList" flex="1" datasources="template-guide-photos5.rdf"
      ref="http://www.xulplanet.com/rdf/myphotos" flags="dont-build-content">
  <treecols>
    <treecol id="name" label="Name" flex="1"/>
    <treecol id="date" label="Date" flex="1"/>
  </treecols>
  <template>
    <treechildren>
      <treeitem uri="rdf:*">
        <treerow>
          <treecell label="rdf:http://purl.org/dc/elements/1.1/title"/>
          <treecell label="rdf:http://purl.org/dc/elements/1.1/date"/>
        </treerow>
      </treeitem>
    </treechildren>
  </template>
</tree>

The tree columns are declared as static content since we only want to declare them once. This template uses the simple rule syntax, although the extended syntax could also be used. The uri attribute must be declared on the <treeitem> element set to either "rdf:*" for the simple syntax or the member variable for the extended syntax. The remaining tags are like the syntax of a tree with a single row. This row will be used as the template data by the tree builder. Instead of generating content, the builder will use the cell attributes to determine what to display. The tree builder implements the nsITreeView interface so it becomes the tree's view. (That is, the tree's view and the tree's builder are the same object.) When the tree is displayed, it asks the view for the contents of each cell. The builder looks at the label for the corresponding cell, translates any variables or predicates into values, and returns the value.

In the example above, the first cell should display the title. The builder doesn't compute any labels until the view asks for them. When the view does request a label for the first cell, the builder looks up the "http://purl.org/dc/elements/1.1/title" predicate for the row in question and returns it.

The content builder will generate the content in the template body and do substitution of the RDF predicates right away. However, it will generate the same result on screen to the user as with the tree builder. Compare the example with a tree builder and the same example using a content builder.

Comments ( 0 )

July 23, 2005

10:42 PM How Templates Work XXIX - Using Multiple Rules to Generate More Results

One interesting technique is to use several rules to combine two sets of unrelated data together. To do this, we create one rule to generate one set of results and a second rule to generate another set of results. If a result from the second rule wasn't also matched by the first rule, it will have content created for it. Recall that when the member resource for a rule matches several rules, only the earliest rule that matches will have content generated for it. If resources don't overlap, we can generate content for two different parts of the RDF data. This technique isn't commonly used. Usually, all of the rules will be similar but just have different filters to match based on different criteria.

If we add the following data about people to the neighbourhood datasource:

  <rdf:Description rdf:about="http://www.xulplanet.com/rdf/myneighbourhood">
    <r:people>
      <rdf:Seq>
        <rdf:li rdf:resource="http://www.xulplanet.com/rdf/person/1"/>
        <rdf:li rdf:resource="http://www.xulplanet.com/rdf/person/2"/>
      </rdf:Seq>
    </r:people>
  </rdf:Description>
  <rdf:Description rdf:about="http://www.xulplanet.com/rdf/person/1"
                   dc:title="Nathan"/>
  <rdf:Description rdf:about="http://www.xulplanet.com/rdf/person/2"
                   dc:title="Karen"/>

We can then use two rules to generate results from different parts of the datasource. The first rule will match the streets as before, but the second rule will generate a result for each person. A header class is used to distinguish the content, although you could use exactly the same content if you wish.

<template>
  <rule>
    <conditions>
      <content uri="?start"/>
      <member container="?start" child="?item"/>
    </conditions>
    <bindings>
      <binding subject="?item" predicate="http://purl.org/dc/elements/1.1/title" object="?title"/>
    </bindings>
    <action>
      <label uri="?item" value="?title" class="header"/>
    </action>
  </rule>
  <rule>
    <conditions>
      <content uri="?start"/>
      <triple subject="?start" predicate="http://www.xulplanet.com/rdf/people" object="?people"/>
      <member container="?people" child="?item"/>
    </conditions>
    <bindings>
      <binding subject="?item" predicate="http://purl.org/dc/elements/1.1/title" object="?title"/>
    </bindings>
    <action>
      <label uri="?item" value="?title"/>
    </action>
  </rule>
</template>

You can view the example.

Comments ( 2 )

July 21, 2005

6:34 PM How Templates Work XXVIII - Parent Conditions

Sometimes you want to simply generate one block of content at the top level and different content at the recurisive level. For example, the bookmarks toolbar in Firefox displays buttons at the first level, but menus and submenus for content below that. The entire bookmarks toolbar is generated by a XUL template.

Templates have a means of allowing a rule to match only if the generated content would be inserted inside an element with a particular tag name. For instance, if the container was a <vbox>, a rule could be created that would only match a <vbox> element. This is useful for recursive templates, since the inner iterations may use different content. It's most useful to distinguish between the outer and inner levels during template generation. For the bookmarks toolbar, the outer content is inserted into an <hbox>, but at lower levels, the content will be inserted into a <menu>

In case you aren't clear, the tag that must match for the outer iteration is the root element, the one with the datasources attribute on it. For inner iterations, it will be the element with the uri attribute from the previous iteration.

To do this kind of matching for the simple template syntax, you place a parent attribute on the rule, set to the tag to match. For instance, we might use the following:

<vbox datasources="template-guide-streets.rdf"
            ref="http://www.xulplanet.com/rdf/myneighbourhood">
  <template>
    <rule parent="vbox">
      <groupbox uri="rdf:*">
        <caption label="rdf:http://purl.org/dc/elements/1.1/title"/>
      </groupbox>
    </rule>
    <rule>
      <label uri="rdf:*" value="rdf:http://www.xulplanet.com/rdf/address"/>
    </rule>
  </template>
</vbox>

On the first pass, the container where generated content would be inserted is a <vbox>, so the first rule will match and a captioned <groupbox> will be created. On the next pass, the parent container will be the element with the uri attribute from the previous pass, in this case, the <groupbox> The first rule will not match in this case, but the second rule will match and a label will be created. The result can be seen in you try the example.

A tag test can also be used with the extended syntax, although the syntax for using it is different. Instead of placing a parent attribute on the <rule>, you place a tag attribute on the <content> tag in the conditions. For instance, the equivalent tag test using the extended syntax for the previous example is the following:

<content uri="?start" tag="vbox">

This example generates the same output content as when using the simple template syntax.

As we've seen in the past few examples, there are many different ways of structuring the two rules to match differently at different levels. General triple tests, tests on an RDF type, container tests and parent tag tests all provide a wide variety of ways to match in very specific ways. Of course, in the simple examples we've been using, the advantages of one kind of condition test over another are not obvious. In more complex examples however, you will see the benefit of one test over others depending on the structure of the data and the UI that you wish to create. By combining the different types of conditions together, more complex interfaces can be created just with templates.

Comments ( 0 )

July 18, 2005

8:18 PM XUL Tutorial Now Part of the Mozilla Developer Documentation

In case you haven't noticed, the XUL tutorial is now available as part of the Mozilla Developer Documentation site. An advantage of this is that errors can be corrected quickly and by anyone who spots them. The user notes created by users haven't been transfered though. I'm not sure if that's a good thing or not.

The user notes include a number of useful tips that people have written relating to a particular page. Currently the user notes aren't posted until I actually read them. This is a good thing since half of the notes are either questions (which I usually just ignore), or are misleading or incorrect. On one hand, I don't want to discourage someone by not accepting a comment they've made, but on the other hand, I feel that if a comment is misleading or uses, for example, some code that is a bad way of doing something, I don't want to post it, since the point of the user notes is to improve the documentation.

Anyway, I think there are plans on posting some other XULPlanet stuff, and I also plan on posting the template guide I've been writing on here. The Aaron countdown timer seems to have disappeared recently perhaps indicating his return a few days early so maybe the App tutorial or Prefbar will get updated also.

In other news, I've been hacking a bit at templates using XML data. Here's the first ever image of a XUL template fed with only XML input. It doesn't look very exciting but that's because the excitment is in disguise. Vlad's just reviewed the main part of the code for this, so we could very well see this stuff early in the 1.9 timeframe.

Comments ( 3 )


7:52 PM How Templates Work XXVII - Container Tests

The simple rule syntax supports two special conditional tests that are commonly used with multiple rules. The first of these tests can be used to test if an element is a container or not. To use this test, place an iscontainer attribute on a <rule>. The iscontainer attribute should be set to true if you only want to match containers, and false if you only want to match non-containers. A container is an RDF container such as a Seq.

The iscontainer attribute makes it easier to handle recursive content since you can have one rule for all containers and another rule for all non-containers. You don't need to match by type or some other predicate. This allows you to recurse down to larger levels without needing additional rules. It is commonly used with menus, and we can rewrite the previous example using the iscontainer attribute instead.

<button label="Houses in my Neighbourhood" type="menu"
        datasources="template-guide-streets.rdf"
        ref="http://www.xulplanet.com/rdf/myneighbourhood">
  <template>
    <rule iscontainer="true">
      <menupopup>
        <menu uri="rdf:*" label="rdf:http://purl.org/dc/elements/1.1/title"/>
      </menupopup>
    </rule>
    <rule>
      <menupopup>
        <menuitem uri="rdf:*" label="rdf:http://www.xulplanet.com/rdf/address"/>
      </menupopup>
    </rule>
  </template>
</button>

The only difference in the code in this example is that the order of the rules has been switched around, the condition check for house has been removed and the iscontainer attribute has been added. Since the iscontainer attribute is set to true, the rule will match as long as the member value or child of the starting node is an RDF container. We could also have left the rules in the original order and set the iscontainer on the first rule to false. The only thing we need to make sure is that the rules are in the proper order, so that the right data will be matched by the right rule. Remember, the more specific rules should go before less specific rules.

Note that leaving out the iscontainer attribute is not the same as setting it to either true or false. If you don't use the iscontainer attribute, the rule will match regardless of whether the node is a container or not.

The iscontainer attribute will also match containers appropriately if you have used the containment attribute in the template to change the predicates that indicate containership. If the node has one of the predicates listed in the containment attribute pointing out of it, it will also be considered to be a container. For instance, we might add the following to the previous example:

<button label="Houses in my Neighbourhood" type="menu"
        datasources="template-guide-streets.rdf"
        containment="http://www.xulplanet.com/rdf/address"
        ref="http://www.xulplanet.com/rdf/myneighbourhood">

The houses do have a value for the "http://www.xulplanet.com/rdf/address" predicate, so they will also be considered to be containers as well, resulting in another level of menus. Of course, we will need to update the predicates and labels to retrieve the right data. But this example demonstrates that something different is indeed happening.

The second special condition attribute tests for empty containers. This invloves setting the isempty attribute on a rule to either true or false. Setting it to true will match all empty containers, that is, containers with no children. Setting it to false will match all containers that have at least one child. Leaving out the isempty attribute will match anything. This condition test is commonly used to display the generated content differently for empty and non-empty containers.

You will commonly use the two attributes iscontainer and isempty together in different combinations to create the effect you need. Typically, this will mean one rule for a container with children, a second rule for empty containers, and a third rule for non-containers. Considering the case of bookmarks, the first two rules would match folders, while the third rule would match bookmarks. Naturally, the emptiness test does not apply to nodes that are not containers.

Note that both the iscontainer and isempty attributes are only available for rules that use the simple syntax.

Comments ( 0 )

July 16, 2005

7:29 PM How Templates Work XXVI - Generating a Recursive Menu

When creating recursive menus, you will need to use multiple rules, since leaf items will need to be created differently than non-leaf items. Leaf items will need to use a <menuitem> element whereas non-leaf items will need to use a <menu> element. This will involve at least two rules, although you might use other rules if you had other differences to handle.

<button label="Houses in my Neighbourhood" type="menu"
        datasources="template-guide-streets.rdf"
        ref="http://www.xulplanet.com/rdf/myneighbourhood"
        xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <template>
    <rule rdf:type="http://www.xulplanet.com/rdf/House">
      <menupopup>
        <menuitem uri="rdf:*" label="rdf:http://www.xulplanet.com/rdf/address"/>
      </menupopup>
    </rule>
    <rule>
      <menupopup>
        <menu uri="rdf:*" label="rdf:http://purl.org/dc/elements/1.1/title"/>
      </menupopup>
    </rule>
  </template>
</button>

The first rule matches all houses, while the second rule is used for streets. The content generated for each rule differs in only two ways. First, the menu tag is different (menuitem versus menu), and the label is taken from a different RDF predicate. In the first pass, the second rule matches the streets, so a <menupopup> and <menu> element are created. The uri attribute is on the <menu> element since we don't want to repeat the popup for every result. After the first pass, the content will be equivalent to the following (ignoring the template related content):

<button label="Houses in my Neighbourhood" type="menu">
  <menupopup>
    <menu uri="http://www.xulplanet.com/rdf/marion" label="Marion Street"/>
    <menu uri="http://www.xulplanet.com/rdf/garden" label="Garden Avenue"/>
  </menupopup>
</button>

The inner pass through the data handles the houses. The houses match the first rule so a <menupopup> and <menuitem> element are generated and inserted inside the street content (the <menu> element). Again, the popup is only created once since the uri attribute is on the <menuitem> element. The effect is a menu with a submenu. There's nothing special about the way menus are handled -- the builder follows the same method for any type of content. However, the nature of menus can make this tricky to follow. Here is the result of the above example after both levels have been handled.

<button label="Houses in my Neighbourhood" type="menu">
  <menupopup>
    <menu uri="http://www.xulplanet.com/rdf/marion" label="Marion Street">
      <menupopup>
        <menuitem uri="http://www.xulplanet.com/rdf/garden/16" label="16"/>
        <menuitem uri="http://www.xulplanet.com/rdf/garden/18" label="18"/>
      </menupopup>
    </menu>
    <menu uri="http://www.xulplanet.com/rdf/garden" label="Garden Avenue">
      <menupopup>
        <menuitem uri="http://www.xulplanet.com/rdf/garden/25" label="25"/>
        <menuitem uri="http://www.xulplanet.com/rdf/garden/37" label="37"/>
      </menupopup>
    </menu>
  </menupopup>
</button>

Comments ( 0 )

July 15, 2005

11:51 PM How Templates Work XXV - Multiple Rules with Recursion

You may recall that templates generate content recursively. After the data is generated, each result is used as the new reference point for a nested iteration of the template. This is usually used to generate content in a tree or menu. The inner iteration uses the same rules as the outer iteration. However, it is quite possible that you would like child or leaf nodes to appear differently than the parent nodes. Multiple rules are useful in this situation. In this case, one rule would be used to match the outer data and another rule would be used to match the inner data. The builder will apply all rules in both cases, however, if the rules are created correctly, there will only be matches for the rules that you want.

For instance, we might have a datasource which represents the houses in a neighbourhood. The top node contains several children, one for each street. Each street also contains children, one for each house. Naturally, you would want the streets to be displayed in a different manner to the houses. The recursive nature of templates can be used for this example. The outer pass will start at the top node and generate the content for each street. The next pass will use a street as the starting point and generate the content for each house. We could go further and generate data for each room in each house by adding more rules.

Here is an example which shows some sample neighbourhood data.

<hbox datasources="template-guide-streets.rdf"
      ref="http://www.xulplanet.com/rdf/myneighbourhood"
      xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <template>
    <rule rdf:type="http://www.xulplanet.com/rdf/House">
      <vbox uri="rdf:*" class="box-padded">
        <label value="Address: rdf:http://www.xulplanet.com/rdf/address"/>
        <label value="Floors: rdf:http://www.xulplanet.com/rdf/floors"/>
      </vbox>
    </rule>
    <rule>
      <groupbox uri="rdf:*" class="box-padded">
        <caption label="rdf:http://purl.org/dc/elements/1.1/title"/>
      </groupbox>
    </rule>
  </template>
</hbox>

The first rule matches only those items that have an RDF type of "http://www.xulplanet.com/rdf/House". The second rule doesn't have any condition filter so will match any result. The starting point indicated by the ref attribute is "http://www.xulplanet.com/rdf/myneighbourhood". In the RDF data, this is an RDF Bag with two children. Since the simple rule syntax is used in both rules, the builder will iterate over the children to generate results. At this pass, both of the children of "http://www.xulplanet.com/rdf/myneighbourhood" are streets and not houses so neither child will match the first rule. However, both children will match the second rule. Thus, two matches will be created using the second rule. The second rule creates a <groupbox> with a <caption>. If you look at image of the example, you will note that two groupboxes have been created.

The builder then recurses, using the previous result as the new starting point. For the first street, this new starting point will be "http://www.xulplanet.com/rdf/marion". The builder reapplies the rules starting from this new location in the RDF graph. The new node is an RDF Seq with children so the simple rules can generate some results. However, these results are houses, so the first rule will match. The second rule, since it has no conditions, will also match, but since the first rule takes priority, these rules would never apply. The effect is that the content for the first rule would be used for each house. This content is inserted inside the outer content generated for the street. This means that the <vbox> and the two labels will be placed inside the <groupbox> generated from the previous pass.

We could be more specific and specify a type in the datasource for the streets as well. This wouldn't affect the output in this example, but it may be more optimal in more complex templates to be as specific as possible when creating conditions. If there were other types of buildings on a particular street, we might add an additional rule for this. For instance, we might add another rule after the first:

<rule rdf:type="http://www.xulplanet.com/rdf/Store">
  <vbox uri="rdf:*" class="box-padded">
    <label value="Address: rdf:http://www.xulplanet.com/rdf/address"/>
    <label value="Sells: rdf:http://www.xulplanet.com/rdf/sells"/>
  </vbox>
</rule>

This rule is similar to the first rule, however is matches only those items that have an RDF type of "http://www.xulplanet.com/rdf/Store".

Comments ( 0 )