var tree = fluid.explode(hash, basepath)

var hash = {sku: "thing1", description: "explodes"}

    [{ID: "sku",
     value: "thing1",
     valuebinding: "1.sku"},
    {ID: "description",
     value: "explodes",
     valuebinding: "1.description"}
     ]

explodeSelectionToInputs

A common markup representation is of a UISelect component as a series of named radio-buttons or checkboxes, in successive rows of a table (in comparison to its natural HTML representation as a <select> tag). This framework function automates the work of generating the additional component tree material to back this representation:

var tree = fluid.explodeSelectionToInputs(optionlist, opts)

The opts structure has the following keys, all of which must be supplied:

Following rendering, the returned subtree needs to be added to the same container as the parent UISelect control by the user - for example, here is a compact call showing compound copying, explosion and addition, where selection_tree directly holds the UISelect control:

var tree = {children: [fluid.copy(selection_tree)].concat(
    fluid.explodeSelectionToInputs(selection_tree.optionlist, explode_options("radio")))};

The explode_options function sourcing the options could have been implemented as:

var explode_options = function(type) {
    return {
    selectID: "select",
    rowID: type + "-row:",
    inputID: type,
    labelID: "label"
    };
};

selfRender

var templates = fluid.selfRender(node, tree, options);

Return: the original parsed template.

A simple driver for single node self-templating. Treats the markup for a node as a template, parses it into a template structure, renders it using the supplied component tree and options, then replaces the markup in the node with the rendered markup, and finally performs any required data binding. The parsed template is returned for use with a further call to fluid.reRender().

Parameters

node

Either a raw DOM node in the current document, or else a JQuery object representing one. The markup in this node will be used as the template for rendering, and the node will be replaced with the rendered output.

tree

A Javascript Object representing a component tree. See Renderer Component Trees for more information.

options

A JavaScript object used to configure the details of the rendering process. Unlike options for most Fluid components, this structure sometimes has a bi-directional aspect - it can be used for returning information about the rendering process back to the client, as well as for receiving it. Here is a list of the supported fields and types within the Renderer options:

reRender

var templates = fluid.reRender(templates, node, tree, options);

Return: the original parsed template.

fluid.reRender() is identical to fluid.selfRender(), except that it uses the supplied templates (the first parameter) as the template instead of the node parameter. This is useful for re-rendering a template that has been previously rendered.

The options for fluid.reRender() are identical to those of fluid.selfRender().

Other Important Renderer Functions

fetchResources

fluid.fetchResources(resourceSpecs, callback)

fluid.fetchResources automates the likely tedious work of performing multiple back-to-back AJAX requests for resource (be they markup, JSON or otherwise) and collecting the responses. It operates on a basic resourcesSpecs structure which is a hash of objects with a particular layout. The keys in resourceSpecs represent a unique key to represent each resource specification. On conclusion of all of the fetches, the function callback will be called with the now filled-in resourceSpecs structure as argument. The fields in a resourcesSpec entry are as follows:

The filled-in resourceSpecs structure is suitable for passing directly as the argument to the low-level function fluid.parseTemplates.

parseJavaProperties

  var messageSource = fluid.parseJavaProperties(text)

The Java Properties File Format is a well-specified and common but rather baroque format for storing messages used to internationalise an application. A good tool chain exists for this structure although its main deficiency is that it is not directly Unicode-ready. An application without a legacy background might want to consider encoding the same information directly in a JSON structure. This call converts a textual representation of a .properties file in this format into the equivalent JSON structure, with a key for each property key, and a value consisting of the properly unescaped message format. The resultant structure is a suitable argument for the fluid.messageLocator function to create an active message locator.

fluid.parseTemplates

The driver for parsing a multiple template set:

  var templates = fluid.parseTemplates(resourceSpec, templateList, opts)

Parses a set of textual representations of templates into a complex binary form, suitable for rapid rendering against a component tree. This is part of the low-level functionality which is packaged by high-level calls such as fluid.selfRender.

renderTemplates

The driver for rendering a template set against a component tree:

var markup = fluid.renderTemplates(templates, tree, options, fossilsIn);