/**

 * Functions dedicated to widgets.

 *

 *  :copyright: 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

/**

 * .. function:: buildWidget(wdgnode)

 *

 * this function takes a DOM node defining a widget and

        var wdg = new wdgclass(wdgnode);

/**

 * .. function:: buildWidgets(root)

 *

 * This function is called on load and is in charge to build

        if (this.getAttribute('cubicweb:loadtype') == 'auto') {

            buildWidget(this);

        }

jQuery(document).ready(function() {

    buildWidgets();

});

function postJSON(url, data, callback) {

    return jQuery.post(url, data, callback, 'json');

}

function getJSON(url, data, callback) {

    return jQuery.get(url, data, callback, 'json');

}

        var multi = node.getAttribute('cubicweb:multi') || "no";

        options = options || {};

        options.multiple = (multi == "yes") ? true: false;

        var dataurl = node.getAttribute('cubicweb:dataurl');

        if (options.method == 'get') {

            method = function(url, data, callback) {

                // We can't rely on jQuery.getJSON because the server

                // might set the Content-Type's response header to 'text/plain'

                jQuery.get(url, data, function(response) {

                    callback(cw.evalJSON(response));

                });

            };

        }

        var self = this; // closure

        method(dataurl, null, function(data) {

            // in case we received a list of couple, we assume that the first

            // element is the real value to be sent, and the second one is the

            // value to be displayed

            if (data.length && data[0].length == 2) {

                options.formatItem = function(row) {

                    return row[1];

                };

                self.hideRealValue(node);

                self.setCurrentValue(node, data);

            }

            jQuery(node).autocomplete(data, options);

        });

        var hidden = INPUT({

            'type': "hidden",

            'name': node.name,

            'value': node.value

        });

        node.parentNode.appendChild(hidden);

        // remove 'name' attribute from visible input so that it is not submitted

        // and set correct value in the corresponding hidden field

        jQuery(node).removeAttr('name').bind('result', function(_, row, _) {

            hidden.value = row[0];

        });

        // called when the data is loaded to reset the correct displayed

        // value in the visible input field (typically replacing an eid

        // by a displayable value)

        var curvalue = node.value;

        if (!node.value) {

            return;

        }

        for (var i = 0, length = data.length; i < length; i++) {

            var row = data[i];

            if (row[0] == curvalue) {

                node.value = row[1];

                return;

            }

        }

    __init__: function(node) {

        Widgets.SuggestField.__init__(this, node, {

            method: 'get'

        });

    __init__: function(node) {

        Widgets.SuggestField.__init__(this, node, {

            mustMatch: true

        });

        var self = this;

        var multi = "no";

        options = options || {};

        options.max = 50;

        options.delay = 50;

        options.cacheLength = 0;

        options.mustMatch = true;

        var initialvalue = cw.evalJSON(node.getAttribute('cubicweb:initialvalue') || 'null');

        options = jQuery.extend({

            dataType: 'json',

            multiple: (multi == "yes") ? true: false,

            parse: this.parseResult

        },

        options);

        var hidden = INPUT({

            'type': "hidden",

            'name': node.name,

            'value': initialvalue

        });

        jQuery(node).bind('result', {

            hinput: hidden,

            input: node

        },

        self.hideRealValue).removeAttr('name').autocomplete(dataurl, options);

        if (!value) {

            value = "";

        }

        for (var i = 0; i < data.length; i++) {

            var value = '' + data[i][0]; // a string is required later by jquery.autocomplete.js

            var label = data[i][1];

            parsed[parsed.length] = {

                data: [label],

                value: value,

                result: label

            };

/**

 * .. class:: Widgets.SuggestForm

 *

    __init__: function(inputid, initfunc, varargs, validatefunc, options) {

        this.validatefunc = validatefunc || noop;

        this.sgfield = new Widgets.BaseSuggestField(inputid, initfunc, varargs, options);

        this.oklabel = options.oklabel || 'ok';

        this.cancellabel = options.cancellabel || 'cancel';

        bindMethods(this);

        connect(this.sgfield, 'validate', this, this.entryValidated);

    show: function(parentnode) {

        var sgnode = this.sgfield.builddom();

        var buttons = DIV({

            'class': "sgformbuttons"

        },

        [A({

            'href': "javascript: noop();",

            'onclick': this.onValidateClicked

        },

        this.oklabel), ' / ', A({

            'href': "javascript: noop();",

            'onclick': this.destroy

        },

        escapeHTML(this.cancellabel))]);

        var formnode = DIV({

            'class': "sgform"

        },

        [sgnode, buttons]);

        appendChildNodes(parentnode, formnode);

        this.sgfield.textinput.focus();

        this.formnode = formnode;

        return formnode;

    destroy: function() {

        signal(this, 'destroy');

        this.sgfield.destroy();

        removeElement(this.formnode);

    onValidateClicked: function() {

        this.validatefunc(this, this.sgfield.taglist());

    entryValidated: function(sgfield, taglist) {

        this.validatefunc(this, taglist);

/**

 * .. function:: toggleTree(event)

 *

 * called when the use clicks on a tree node

        linode.loadxhtml(url, {

            callback: function(domnode) {

                linode.removeAttr('cubicweb:loadurl');

                jQuery(domnode).treeview({

                    toggle: toggleTree,

                    prerendered: true

                });

                return null;

            }

        },

        'post', 'append');

/**

 * .. class:: Widgets.TimelineWidget

 *

 * widget based on SIMILE's timeline widget

    __init__: function(wdgnode) {

        var tldiv = DIV({

            id: "tl",

            style: 'height: 200px; border: 1px solid #ccc;'

        });

        wdgnode.appendChild(tldiv);

        var tlunit = wdgnode.getAttribute('cubicweb:tlunit') || 'YEAR';

        var eventSource = new Timeline.DefaultEventSource();

        var bandData = {

            eventPainter: Timeline.CubicWebEventPainter,

            eventSource: eventSource,

            width: "100%",

            intervalUnit: Timeline.DateTime[tlunit.toUpperCase()],

            intervalPixels: 100

        };

        var bandInfos = [Timeline.createBandInfo(bandData)];

        var tl = Timeline.create(tldiv, bandInfos);

        var loadurl = wdgnode.getAttribute('cubicweb:loadurl');

        Timeline.loadJSON(loadurl, function(json, url) {

            eventSource.loadJSON(json, url);

        });

    __init__: function(wdgnode) {

        this.variables = jQuery(wdgnode).attr('cubicweb:variables').split(',');

        this.options = {

            name: wdgnode.getAttribute('cubicweb:inputid'),

            rows: wdgnode.getAttribute('cubicweb:rows') || 40,

            cols: wdgnode.getAttribute('cubicweb:cols') || 80

        };

        // this.variableRegexp = /%\((\w+)\)s/;

        this.errorField = DIV({

            'class': "errorMessage"

        });

        this.textField = TEXTAREA(this.options);

        jQuery(this.textField).bind('keyup', {

            'self': this

        },

        this.highlightInvalidVariables);

        jQuery('#substitutions').prepend(this.errorField);

        jQuery('#substitutions .errorMessage').hide();

        wdgnode.appendChild(this.textField);

    highlightInvalidVariables: function(event) {

        var self = event.data.self;

        var text = self.textField.value;

        var unknownVariables = [];

        var it = 0;

        var group = null;

        var variableRegexp = /%\((\w+)\)s/g;

        // emulates rgx.findAll()

        while (group = variableRegexp.exec(text)) {