
/*
 * aciTree jQuery Plugin v4.5.0-rc.7
 * http://acoderinsights.ro
 *
 * Copyright (c) 2014 Dragos Ursu
 * Dual licensed under the MIT or GPL Version 2 licenses.
 *
 * Require jQuery Library >= v1.9.0 http://jquery.com
 * + aciPlugin >= v1.5.1 https://github.com/dragosu/jquery-aciPlugin
 */

/*
 * The aciTree core.
 *
 * A few words about how item data looks like:
 *
 * for a leaf node (a node that does not have any children):
 *
 * {
 *   id: 'some_file_ID',                // should be unique item ID
 *   label: 'This is a File Item',      // the item label (text value)
 *   inode: false,                      // FALSE means is a leaf node (can be omitted)
 *   icon: 'fileIcon',                  // CSS class name for the icon (if any), can also be an Array ['CSS class name', background-position-x, background-position-y]
 *   disabled: false,                   // TRUE means the item is disabled (can be omitted)
 *   random_prop: 'random 1'            // sample user defined property (you can have any number defined)
 * }
 *
 * for a inner node (a node that have at least a children under it):
 *
 * {
 *   id: 'some_folder_ID',              // should be unique item ID
 *   label: 'This is a Folder Item',    // the item label (text value)
 *   inode: true,                       // can also be NULL to find at runtime if its an inode (on load will be transformed in a leaf node if there aren't any children)
 *   open: false,                       // if TRUE then the node will be opened when the tree is loaded (can be omitted)
 *   icon: 'folderIcon',                // CSS class name for the icon (if any), can also be an Array ['CSS class name', background-position-x, background-position-y]
 *   disabled: false,                   // TRUE means the item is disabled (can be omitted)
 *   source: 'myDataSource',            // the data source name (if any) to read the children from, by default `aciTree.options.ajax` is used
 *   branch: [                          // a list of children
 *      { ... item data ... },
 *      { ... item data ... },
 *      ...
 *   ],
 *   random_prop: 'random 2'            // sample user defined property (you can have any number defined)
 * }
 *
 * The `branch` array can be empty, in this case the children will be loaded when the node will be opened for the first time.
 *
 * Please note that the item data should be valid (in the expected format). No checking is done and errors can appear on invalid data.
 *
 * One note about a item: a item is always the LI element with the class 'aciTreeLi'.
 * The children of a node are all added under a UL element with the class 'aciTreeUl'.
 *
 * Almost all API functions expect only one item. If you need to process more at once then you'll need to loop between all of them yourself.
 *
 * The `options` parameter for all API methods (when there is one) is a object with the properties (not all are required or used):
 *
 * {
 *   uid: string -> operation UID (defaults to `ui`)
 *   success: function (item, options) -> callback to be called on success (you can access plugin API with `this` keyword inside the callback)
 *   fail: function (item, options) -> callback to be called on fail (you can access plugin API with `this` keyword inside the callback)
 *   notify: function (item, options) -> notify callback (internal use for when already in the requested state, will call `success` by default)
 *   expand: true/false -> propagate on open/toggle
 *   collapse: true/false -> propagate on close/toggle
 *   unique: true/false -> should other branches be closed (on open/toggle) ?
 *   unanimated: true/false -> if it's TRUE then no animations are to be run (used on open/close/toggle)
 *   itemData: object[item data]/array[item data] -> used when adding/updating items
 * }
 *
 * Note: when using the API methods that support the `options` parameter, you will need to use the success/fail callbacks if you need to do
 * any processing after the API call. This because there can be async operations that will complete at a later time and the API methods will
 * exit before the job is actually completed. This will happen when items are loaded with AJAX, on animations and other delayed operations (see _queue).
 *
 */

(function($, window, undefined) {

    // default options

    var options = {
        // the AJAX options (see jQuery.ajax) where the `success` and `error` are overridden by aciTree
        ajax: {
            url: null, // URL from where to take the data, something like `path/script?nodeId=` (the node ID value will be added for each request)
            dataType: 'json'
        },
        dataSource: null, // a list of data sources to be used (each entry in `aciTree.options.ajax` format)
        rootData: null, // initial ROOT data for the Tree (if NULL then one initial AJAX request is made on init)
        queue: {
            async: 4, // the number of simultaneous async (AJAX) tasks
            interval: 50, // interval [ms] after which to insert a `delay`
            delay: 20                   // how many [ms] delay between tasks (after `interval` expiration)
        },
        loaderDelay: 500, // how many msec to wait before showing the main loader ? (on lengthy operations)
        expand: false, // if TRUE then all children of a node are expanded when the node is opened
        collapse: false, // if TRUE then all children of a node are collapsed when the node is closed
        unique: false, // if TRUE then a single tree branch will stay open, the oters are closed when a node is opened
        empty: false, // if TRUE then all children of a node are removed when the node is closed
        show: {// show node/ROOT animation (default is slideDown)
            props: {
                'height': 'show'
            },
            duration: 'medium',
            easing: 'linear'
        },
        animateRoot: true, // if the ROOT should be animated on init
        hide: {// hide node animation (default is slideUp)
            props: {
                'height': 'hide'
            },
            duration: 'medium',
            easing: 'linear'
        },
        view: {// scroll item into view animation
            duration: 'medium',
            easing: 'linear'
        },
        // called for each AJAX request when a node needs to be loaded
        // `item` is the item who will be loaded
        // `settings` is the `aciTree.options.ajax` object or an entry from `aciTree.options.dataSource`
        ajaxHook: function(item, settings) {
            // the default implementation changes the URL by adding the item ID at the end
            settings.url += (item ? this.getId(item) : '');
        },
        // called after each item is created but before is inserted into the DOM
        // `parent` is the parent item (can be empty)
        // `item` is the new created item
        // `itemData` is the object used to create the item
        // `level` is the #0 based item level
        itemHook: function(parent, item, itemData, level) {
            // there is no default implementation
        },
        // called for each item to serialize its value
        // `item` is the tree item to be serialized
        // `what` is the option telling what is being serialized
        // `value` is the current serialized value (from the `item`, value type depending of `what`)
        serialize: function(item, what, value) {
            if (typeof what == 'object') {
                return value;
            } else {
                // the default implementation uses a `|` (pipe) character to separate values
                return '|' + value;
            }
        }
    };

    // aciTree plugin core

    var aciTree_core = {
        // add extra data
        __extend: function() {
            $.extend(this._instance, {
                queue: new this._queue(this, this._instance.options.queue) // the global tree queue
            });
            $.extend(this._private, {
                locked: false, // to tell the tree state
                itemClone: {// keep a clone of the LI for faster tree item creation
                },
                // timeouts for the loader
                loaderHide: null,
                loaderInterval: null,
                // busy delay counter
                delayBusy: 0
            });
        },
        // init the treeview
        init: function(options) {
            options = this._options(options);
            // check if was init already
            if (this.wasInit()) {
                this._trigger(null, 'wasinit', options);
                this._fail(null, options);
                return;
            }
            // check if is locked
            if (this.isLocked()) {
                this._trigger(null, 'locked', options);
                this._fail(null, options);
                return;
            }
            // a way to cancel the operation
            if (!this._trigger(null, 'beforeinit', options)) {
                this._trigger(null, 'initfail', options);
                this._fail(null, options);
                return;
            }
            this._private.locked = true;
            this._instance.jQuery.addClass('aciTree' + this._instance.index).attr('role', 'tree').on('click' + this._instance.nameSpace, '.aciTreeButton', this.proxy(function(e) {
                // process click on button
                var item = this.itemFrom(e.target);
                // skip when busy
                if (!this.isBusy(item)) {
                    // tree button pressed
                    this.toggle(item, {
                        collapse: this._instance.options.collapse,
                        expand: this._instance.options.expand,
                        unique: this._instance.options.unique
                    });
                }
            })).on('mouseenter' + this._instance.nameSpace + ' mouseleave' + this._instance.nameSpace, '.aciTreePush', function(e) {
                // handle the aciTreeHover class
                var element = e.target;
                if (!domApi.hasClass(element, 'aciTreePush')) {
                    element = domApi.parentByClass(element, 'aciTreePush');
                }
                domApi.toggleClass(element, 'aciTreeHover', e.type == 'mouseenter');
            }).on('mouseenter' + this._instance.nameSpace + ' mouseleave' + this._instance.nameSpace, '.aciTreeLine', function(e) {
                // handle the aciTreeHover class
                var element = e.target;
                if (!domApi.hasClass(element, 'aciTreeLine')) {
                    element = domApi.parentByClass(element, 'aciTreeLine');
                }
                domApi.toggleClass(element, 'aciTreeHover', e.type == 'mouseenter');
            });
            this._initHook();
            // call on success
            var success = this.proxy(function() {
                // call the parent
                this._super();
                this._private.locked = false;
                this._trigger(null, 'init', options);
                this._success(null, options);
            });
            // call on fail
            var fail = this.proxy(function() {
                // call the parent
                this._super();
                this._private.locked = false;
                this._trigger(null, 'initfail', options);
                this._fail(null, options);
            });
            if (this._instance.options.rootData) {
                // the rootData was set, use it to init the tree
                this.loadFrom(null, this._inner(options, {
                    success: success,
                    fail: fail,
                    itemData: this._instance.options.rootData
                }));
            } else if (this._instance.options.ajax.url) {
                // the AJAX url was set, init with AJAX
                this.ajaxLoad(null, this._inner(options, {
                    success: success,
                    fail: fail
                }));
            } else {
                success.apply(this);
            }
        },
        _initHook: function() {
            // override this to do extra init
        },
        // check locked state
        isLocked: function() {
            return this._private.locked;
        },
        // get a formatted message
        // `raw` is the raw message text (can contain %NUMBER sequences, replaced with values from `params`)
        // `params` is a list of values to be replaced into the message (by #0 based index)
        _format: function(raw, params) {
            if (!(params instanceof Array)) {
                return raw;
            }
            var parts = raw.split(/(%[0-9]+)/gm);
            var compile = '', part, index, last = false, len;
            var test = new window.RegExp('^%[0-9]+$');
            for (var i = 0; i < parts.length; i++) {
                part = parts[i];
                len = part.length;
                if (len) {
                    if (!last && test.test(part)) {
                        index = window.parseInt(part.substr(1)) - 1;
                        if ((index >= 0) && (index < params.length)) {
                            compile += params[index];
                            continue;
                        }
                    } else {
                        last = false;
                        if (part.substr(len - 1) == '%') {
                            if (part.substr(len - 2) != '%%') {
                                last = true;
                            }
                            part = part.substr(0, len - 1);
                        }
                    }
                    compile += part;
                }
            }
            return compile;
        },
        // low level DOM functions
        _coreDOM: {
            // set as leaf node
            leaf: function(items) {
                domApi.addRemoveListClass(items.toArray(), 'aciTreeLeaf', ['aciTreeInode', 'aciTreeInodeMaybe', 'aciTreeOpen'], function(node) {
                    node.firstChild.removeAttribute('aria-expanded');
                });
            },
            // set as inner node
            inode: function(items, branch) {
                domApi.addRemoveListClass(items.toArray(), branch ? 'aciTreeInode' : 'aciTreeInodeMaybe', 'aciTreeLeaf', function(node) {
                    node.firstChild.setAttribute('aria-expanded', false);
                });
            },
            // set as open/closed
            toggle: function(items, state) {
                domApi.toggleListClass(items.toArray(), 'aciTreeOpen', state, function(node) {
                    node.firstChild.setAttribute('aria-expanded', state);
                });
            },
            // set odd/even classes
            oddEven: function(items, odd) {
                var list = items.toArray();
                for (var i = 0; i < list.length; i++) {
                    domApi.addRemoveClass(list[i], odd ? 'aciTreeOdd' : 'aciTreeEven', odd ? 'aciTreeEven' : 'aciTreeOdd');
                    odd = !odd;
                }
            }
        },
        // a small queue implementation
        // `context` the context to be used with `callback.call`
        // `options` are the queue options
        _queue: function(context, options) {
            var locked = false;
            var fifo = [], fifoAsync = [];
            var load = 0, loadAsync = 0, schedule = 0, stack = 0;
            // run the queue
            var run = function() {
                if (locked) {
                    stack--;
                    return;
                }
                var now = new window.Date().getTime();
                if (schedule > now) {
                    stack--;
                    return;
                }
                var callback, async = false;
                if (load < options.async * 2) {
                    // get the next synchronous callback
                    callback = fifo.shift();
                }
                if (!callback && (loadAsync < options.async)) {
                    // get the next async callback
                    callback = fifoAsync.shift();
                    async = true;
                }
                if (callback) {
                    // run the callback
                    if (async) {
                        loadAsync++;
                        callback.call(context, function() {
                            loadAsync--;
                        });
                        if (stack < 40) {
                            stack++;
                            run();
                        }
                    } else {
                        load++;
                        callback.call(context, function() {
                            if (now - schedule > options.interval) {
                                schedule = now + options.delay;
                            }
                            load--;
                            if (stack < 40) {
                                stack++;
                                run();
                            }
                        });
                    }
                }
                stack--;
            };
            var interval = [];
            // start the queue
            var start = function() {
                for (var i = 0; i < 4; i++) {
                    interval[i] = window.setInterval(function() {
                        if (stack < 20) {
                            stack++;
                            run();
                        }
                    }, 10);
                }
            };
            // stop the queue
            var stop = function() {
                for (var i = 0; i < interval.length; i++) {
                    window.clearInterval(interval[i]);
                }
            };
            start();
            // init the queue
            this.init = function() {
                this.destroy();
                start();
                return this;
            };
            // push `callback` function (complete) for later call
            // `async` tells if is async callback
            this.push = function(callback, async) {
                if (!locked) {
                    if (async) {
                        fifoAsync.push(callback);
                    } else {
                        fifo.push(callback);
                    }
                }
                return this;
            };
            // test if busy
            this.busy = function() {
                return (load != 0) || (loadAsync != 0) || (fifo.length != 0) || (fifoAsync.length != 0);
            };
            // destroy queue
            this.destroy = function() {
                locked = true;
                stop();
                fifo = [];
                fifoAsync = [];
                load = 0;
                loadAsync = 0;
                schedule = 0;
                stack = 0;
                locked = false;
                return this;
            };
        },
        // used with a `queue` to execute something at the end
        // `endCallback` function (complete) is the callback called at the end
        _task: function(queue, endCallback) {
            var counter = 0, finish = false;
            // push a `callback` function (complete) for later call
            this.push = function(callback, async) {
                counter++;
                queue.push(function(complete) {
                    var context = this;
                    callback.call(this, function() {
                        counter--;
                        if ((counter < 1) && !finish) {
                            finish = true;
                            endCallback.call(context, complete);
                        } else {
                            complete();
                        }
                    });
                }, async);
            };
        },
        // helper function to extend the `options` object
        // `object` the initial options object
        // _success, _fail, _notify are callbacks or string (the event name to be triggered)
        // `item` is the item to trigger events for
        _options: function(object, _success, _fail, _notify, item) {
            // options object (need to be in this form for all API functions
            // that have the `options` parameter, not all properties are required)
            var options = $.extend({
                uid: 'ui',
                success: null, // success callback
                fail: null, // fail callback
                notify: null, // notify callback (internal use for when already in the requested state)
                expand: this._instance.options.expand, // propagate (on open)
                collapse: this._instance.options.collapse, // propagate (on close)
                unique: this._instance.options.unique, // keep a single branch open (on open)
                unanimated: false, // unanimated (open/close/toggle)
                itemData: {
                } // items data (object) or a list (array) of them (used when creating branches)
            },
            object);
            var success = _success ? ((typeof _success == 'string') ? function() {
                this._trigger(item, _success, options);
            } : _success) : null;
            var fail = _fail ? ((typeof _fail == 'string') ? function() {
                this._trigger(item, _fail, options);
            } : _fail) : null;
            var notify = _notify ? ((typeof _notify == 'string') ? function() {
                this._trigger(item, _notify, options);
            } : _notify) : null;
            if (success) {
                // success callback
                if (object && object.success) {
                    options.success = function() {
                        success.apply(this, arguments);
                        object.success.apply(this, arguments);
                    };
                } else {
                    options.success = success;
                }
            }
            if (fail) {
                // fail callback
                if (object && object.fail) {
                    options.fail = function() {
                        fail.apply(this, arguments);
                        object.fail.apply(this, arguments);
                    };
                } else {
                    options.fail = fail;
                }
            }
            if (notify) {
                // notify callback
                if (object && object.notify) {
                    options.notify = function() {
                        notify.apply(this, arguments);
                        object.notify.apply(this, arguments);
                    };
                } else if (!options.notify && object && object.success) {
                    options.notify = function() {
                        notify.apply(this, arguments);
                        object.success.apply(this, arguments);
                    };
                } else {
                    options.notify = notify;
                }
            } else if (!options.notify && object && object.success) {
                // by default, run success callback
                options.notify = object.success;
            }
            return options;
        },
        // helper for passing `options` object to inner methods
        // the callbacks are removed and `override` can be used to update properties
        _inner: function(options, override) {
            // removing success/fail/notify from options
            return $.extend({
            }, options, {
                success: null,
                fail: null,
                notify: null
            },
            override);
        },
        // trigger the aciTree events on the tree container
        _trigger: function(item, eventName, options) {
            var event = $.Event('acitree');
            if (!options) {
                options = this._options();
            }
            this._instance.jQuery.trigger(event, [this, item, eventName, options]);
            return !event.isDefaultPrevented();
        },
        // call on success
        _success: function(item, options) {
            if (options && options.success) {
                options.success.call(this, item, options);
            }
        },
        // call on fail
        _fail: function(item, options) {
            if (options && options.fail) {
                options.fail.call(this, item, options);
            }
        },
        // call on notify (should be same as `success` but called when already in the requested state)
        _notify: function(item, options) {
            if (options && options.notify) {
                options.notify.call(this, item, options);
            }
        },
        // delay callback on busy item
        _delayBusy: function(item, callback) {
            if ((this._private.delayBusy < 10) && this.isBusy(item)) {
                this._private.delayBusy++;
                window.setTimeout(this.proxy(function() {
                    this._delayBusy.call(this, item, callback);
                    this._private.delayBusy--;
                }), 10);
                return;
            }
            callback.apply(this);
        },
        // return the data source for item
        // defaults to `aciTree.options.ajax` if not set on the item/his parents
        _dataSource: function(item) {
            var dataSource = this._instance.options.dataSource;
            if (dataSource) {
                var data = this.itemData(item);
                if (data && data.source && dataSource[data.source]) {
                    return dataSource[data.source];
                }
                var parent;
                do {
                    parent = this.parent(item);
                    data = this.itemData(parent);
                    if (data && data.source && dataSource[data.source]) {
                        return dataSource[data.source];
                    }
                } while (parent.length);
            }
            return this._instance.options.ajax;
        },
        // process item loading with AJAX
        // `item` can be NULL to load the ROOT
        // loaded data need to be array of item objects
        // each item can have children (defined as `itemData.branch` - array of item data objects)
        ajaxLoad: function(item, options) {
            if (item && this.isBusy(item)) {
                // delay the load if busy
                this._delayBusy(item, function() {
                    this.ajaxLoad(item, options);
                });
                return;
            }
            options = this._options(options, function() {
                this._loading(item);
                this._trigger(item, 'loaded', options);
            }, function() {
                this._loading(item);
                this._trigger(item, 'loadfail', options);
            }, function() {
                this._loading(item);
                this._trigger(item, 'wasloaded', options);
            });
            if (!item || this.isInode(item)) {
                // add the task to the queue
                this._instance.queue.push(function(complete) {
                    // a way to cancel the operation
                    if (!this._trigger(item, 'beforeload', options)) {
                        this._fail(item, options);
                        complete();
                        return;
                    }
                    this._loading(item, true);
                    if (this.wasLoad(item)) {
                        // was load already
                        this._notify(item, options);
                        complete();
                        return;
                    }
                    // ensure we work on a copy of the dataSource object
                    var settings = $.extend({
                    }, this._dataSource(item));
                    // call the `aciTree.options.ajaxHook`
                    this._instance.options.ajaxHook.call(this, item, settings);
                    // loaded data need to be array of item objects
                    settings.success = this.proxy(function(itemList) {
                        if (itemList && (itemList instanceof Array) && itemList.length) {
                            // the AJAX returned some items
                            var process = function() {
                                if (this.wasLoad(item)) {
                                    this._notify(item, options);
                                    complete();
                                } else {
                                    // create a branch from `itemList`
                                    this._createBranch(item, this._inner(options, {
                                        success: function() {
                                            this._success(item, options);
                                            complete();
                                        },
                                        fail: function() {
                                            this._fail(item, options);
                                            complete();
                                        },
                                        itemData: itemList
                                    }));
                                }
                            };
                            if (!item || this.isInode(item)) {
                                process.apply(this);
                            } else {
                                // change the item to inode, then load
                                this.setInode(item, this._inner(options, {
                                    success: process,
                                    fail: options.fail
                                }));
                            }
                        } else {
                            // the AJAX response was not just right (or not a inode)
                            var process = function() {
                                this._fail(item, options);
                                complete();
                            };
                            if (!item || this.isLeaf(item)) {
                                process.apply(this);
                            } else {
                                // change the item to leaf
                                this.setLeaf(item, this._inner(options, {
                                    success: process,
                                    fail: process
                                }));
                            }
                        }
                    });
                    settings.error = this.proxy(function() {
                        // AJAX failed
                        this._fail(item, options);
                        complete();
                    });
                    $.ajax(settings);
                }, true);
            } else {
                this._fail(item, options);
            }
        },
        // process item loading
        // `item` can be NULL to load the ROOT
        // `options.itemData` need to be array of item objects
        // each item can have children (defined as `itemData.branch` - array of item data objects)
        loadFrom: function(item, options) {
            if (item && this.isBusy(item)) {
                // delay the load if busy
                this._delayBusy(item, function() {
                    this.loadFrom(item, options);
                });
                return;
            }
            options = this._options(options, function() {
                this._loading(item);
                this._trigger(item, 'loaded', options);
            }, function() {
                this._loading(item);
                this._trigger(item, 'loadfail', options);
            }, function() {
                this._loading(item);
                this._trigger(item, 'wasloaded', options);
            });
            if (!item || this.isInode(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeload', options)) {
                    this._fail(item, options);
                    return;
                }
                this._loading(item, true);
                if (this.wasLoad(item)) {
                    // was load already
                    this._notify(item, options);
                    return;
                }
                // data need to be array of item objects
                if (options.itemData && (options.itemData instanceof Array) && options.itemData.length) {
                    // create the branch from `options.itemData`
                    var process = function() {
                        if (this.wasLoad(item)) {
                            this._notify(item, options);
                        } else {
                            this._createBranch(item, options);
                        }
                    };
                    if (!item || this.isInode(item)) {
                        process.apply(this);
                    } else {
                        // change the item to inode, then create children
                        this.setInode(item, this._inner(options, {
                            success: process,
                            fail: options.fail
                        }));
                    }
                } else {
                    // this is not a inode
                    if (!item || this.isLeaf(item)) {
                        this._fail(item, options);
                    } else {
                        // change the item to leaf
                        this.setLeaf(item, this._inner(options, {
                            success: options.fail,
                            fail: options.fail
                        }));
                    }
                }
            } else {
                this._fail(item, options);
            }
        },
        // unload item
        // `item` can be NULL to unload the entire tree
        unload: function(item, options) {
            options = this._options(options, function() {
                this._loading(item);
                this._trigger(item, 'unloaded', options);
            }, function() {
                this._loading(item);
                this._trigger(item, 'unloadfail', options);
            }, function() {
                this._loading(item);
                this._trigger(item, 'notloaded', options);
            });
            if (!item || this.isInode(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeunload', options)) {
                    this._fail(item, options);
                    return;
                }
                this._loading(item, true);
                if (!this.wasLoad(item)) {
                    // if was not loaded
                    this._notify(item, options);
                    return;
                }
                // first check each children
                var cancel = false;
                var children = this.children(item, true, true);
                children.each(this.proxy(function(element) {
                    var item = $(element);
                    if (this.isInode(item)) {
                        if (this.isOpen(item)) {
                            // a way to cancel the operation
                            if (!this._trigger(item, 'beforeclose', options)) {
                                cancel = true;
                                return false;
                            }
                        }
                        if (this.wasLoad(item)) {
                            // a way to cancel the operation
                            if (!this._trigger(item, 'beforeunload', options)) {
                                cancel = true;
                                return false;
                            }
                        }
                    }
                    // a way to cancel the operation
                    if (!this._trigger(item, 'beforeremove', options)) {
                        cancel = true;
                        return false;
                    }
                }, true));
                if (cancel) {
                    // it was canceled
                    this._fail(item, options);
                    return;
                }
                var process = function() {
                    children.each(this.proxy(function(element) {
                        // trigger the events before DOM changes
                        var item = $(element);
                        if (this.isInode(item)) {
                            if (this.isOpen(item)) {
                                this._trigger(item, 'closed', options);
                            }
                            if (this.wasLoad(item)) {
                                this._trigger(item, 'unloaded', options);
                            }
                        }
                        this._trigger(item, 'removed', options);
                    }, true));
                };
                // process the child remove
                if (item) {
                    if (this.isOpen(item)) {
                        // first close the item, then remove children
                        this.close(item, this._inner(options, {
                            success: function() {
                                process.call(this);
                                this._removeContainer(item);
                                this._success(item, options);
                            },
                            fail: options.fail
                        }));
                    } else {
                        process.call(this);
                        this._removeContainer(item);
                        this._success(item, options);
                    }
                } else {
                    // unload the ROOT
                    this._animate(item, false, !this._instance.options.animateRoot || options.unanimated, function() {
                        process.call(this);
                        this._removeContainer();
                        this._success(item, options);
                    });
                }
            } else {
                this._fail(item, options);
            }
        },
        // remove item
        remove: function(item, options) {
            if (this.isItem(item)) {
                if (this.hasSiblings(item, true)) {
                    options = this._options(options, function() {
                        if (this.isOpenPath(item)) {
                            // if the parents are opened (visible) update the item states
                            domApi.removeClass(item[0], 'aciTreeVisible');
                            this._setOddEven(item);
                        }
                        this._trigger(item, 'removed', options);
                    }, 'removefail', null, item);
                    // a way to cancel the operation
                    if (!this._trigger(item, 'beforeremove', options)) {
                        this._fail(item, options);
                        return;
                    }
                    if (this.wasLoad(item)) {
                        // unload the inode then remove
                        this.unload(item, this._inner(options, {
                            success: function() {
                                this._success(item, options);
                                this._removeItem(item);
                            },
                            fail: options.fail
                        }));
                    } else {
                        // just remove the item
                        this._success(item, options);
                        this._removeItem(item);
                    }
                } else {
                    var parent = this.parent(item);
                    if (parent.length) {
                        this.setLeaf(parent, options);
                    } else {
                        this.unload(null, options);
                    }
                }
            } else {
                this._trigger(item, 'removefail', options)
                this._fail(item, options);
            }
        },
        // open item children
        _openChildren: function(item, options) {
            if (options.expand) {
                var queue = this._instance.queue;
                // process the children inodes
                this.inodes(this.children(item)).each(function() {
                    var item = $(this);
                    // queue node opening
                    queue.push(function(complete) {
                        this.open(item, this._inner(options));
                        complete();
                    });
                });
                queue.push(function(complete) {
                    this._success(item, options);
                    complete();
                });
            } else {
                this._success(item, options);
            }
        },
        // process item open
        _openItem: function(item, options) {
            if (!options.unanimated && !this.isVisible(item)) {
                options.unanimated = true;
            }
            if (options.unique) {
                // close other opened nodes
                this.closeOthers(item);
                options.unique = false;
            }
            // open the node
            this._coreDOM.toggle(item, true);
            // (temporarily) update children states
            this._setOddEvenChildren(item);
            this._animate(item, true, options.unanimated, function() {
                this._openChildren(item, options);
            });
        },
        // open item and his children if requested
        open: function(item, options) {
            options = this._options(options, function() {
                if (this.isOpenPath(item)) {
                    // if all parents are open, update the items after
                    this._updateVisible(item);
                    this._setOddEven(item);
                }
                this._trigger(item, 'opened', options);
            }, 'openfail', 'wasopened', item);
            if (this.isInode(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeopen', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isOpen(item)) {
                    options.success = options.notify;
                    // propagate/open children (if required)
                    this._openChildren(item, options);
                } else {
                    if (this.wasLoad(item)) {
                        this._openItem(item, options);
                    } else {
                        // try to load the node, then open
                        this.ajaxLoad(item, this._inner(options, {
                            success: function() {
                                this._openItem(item, options);
                            },
                            fail: options.fail
                        }));
                    }
                }
            } else {
                this._fail(item, options);
            }
        },
        // close item children
        _closeChildren: function(item, options) {
            if (this._instance.options.empty) {
                // unload on close
                options.unanimated = true;
                this.unload(item, options);
            } else if (options.collapse) {
                var queue = this._instance.queue;
                // process the children inodes
                this.inodes(this.children(item)).each(function() {
                    var item = $(this);
                    // queue node close
                    queue.push(function(complete) {
                        this.close(item, this._inner(options, {
                            unanimated: true
                        }));
                        complete();
                    });
                });
                queue.push(function(complete) {
                    this._success(item, options);
                    complete();
                });
            } else {
                this._success(item, options);
            }
        },
        // process item close
        _closeItem: function(item, options) {
            if (!options.unanimated && !this.isVisible(item)) {
                options.unanimated = true;
            }
            // close the item
            this._coreDOM.toggle(item, false);
            this._animate(item, false, options.unanimated, function() {
                this._closeChildren(item, options);
            });
        },
        // close item and his children if requested
        close: function(item, options) {
            options = this._options(options, function() {
                if (this.isOpenPath(item)) {
                    // if all parents are open, update the items after
                    this._updateVisible(item);
                    this._setOddEven(item);
                }
                this._trigger(item, 'closed', options);
            }, 'closefail', 'wasclosed', item);
            if (this.isInode(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeclose', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isOpen(item)) {
                    this._closeItem(item, options);
                } else if (this.wasLoad(item)) {
                    options.success = options.notify;
                    // propagate/close/empty children (if required)
                    this._closeChildren(item, options);
                } else {
                    this._notify(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // update visible state
        _updateVisible: function(item) {
            if (this.isOpenPath(item)) {
                if (!this.isHidden(item)) {
                    // if open parents and not hidden
                    domApi.addClass(item[0], 'aciTreeVisible');
                    if (this.isOpen(item)) {
                        // process children
                        domApi.children(item[0], false, this.proxy(function(node) {
                            if (!domApi.hasClass(node, 'aciTreeVisible')) {
                                this._updateVisible($(node));
                            }
                        }));
                    } else {
                        // children are not visible
                        domApi.children(item[0], true, function(node) {
                            return domApi.removeClass(node, 'aciTreeVisible') ? true : null;
                        });
                    }
                }
            } else if (domApi.removeClass(item[0], 'aciTreeVisible')) {
                domApi.children(item[0], true, function(node) {
                    return domApi.removeClass(node, 'aciTreeVisible') ? true : null;
                });
            }
        },
        // keep just one branch open
        closeOthers: function(item, options) {
            options = this._options(options);
            if (this.isItem(item)) {
                var queue = this._instance.queue;
                // exclude the item and his parents
                var exclude = item.add(this.path(item)).add(this.children(item, true));
                // close all other open nodes
                this.inodes(this.children(null, true, true), true).not(exclude).each(function() {
                    var item = $(this);
                    // add node to close queue
                    queue.push(function(complete) {
                        this.close(item, this._inner(options));
                        complete();
                    });
                });
                queue.push(function(complete) {
                    this._success(item, options);
                    complete();
                });
            } else {
                this._fail(item, options);
            }
        },
        // toggle item
        toggle: function(item, options) {
            options = this._options(options, 'toggled', 'togglefail', null, item);
            if (this.isInode(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforetoggle', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isOpen(item)) {
                    this.close(item, options);
                } else {
                    this.open(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // get item path starting from the top parent (ROOT)
        // when `reverse` is TRUE returns the path in reverse order
        path: function(item, reverse) {
            if (item) {
                var parent = item[0], list = [];
                while (parent = domApi.parent(parent)) {
                    list.push(parent);
                }
                return reverse ? $(list) : $(list.reverse());
            }
            return $([]);
        },
        // test if item is in view
        // when `center` is TRUE will test if is centered in view
        isVisible: function(item, center) {
            if (item && domApi.hasClass(item[0], 'aciTreeVisible')) {
                // the item path need to be open
                var rect = this._instance.jQuery[0].getBoundingClientRect();
                var size = item[0].firstChild;
                var test = size.getBoundingClientRect();
                var height = size.offsetHeight;
                var offset = center ? (rect.bottom - rect.top) / 2 : 0;
                if ((test.bottom - height < rect.top + offset) || (test.top + height > rect.bottom - offset)) {
                    // is out of view
                    return false;
                }
                return true;
            }
            return false;
        },
        // open path to item
        openPath: function(item, options) {
            options = this._options(options);
            if (this.isItem(item)) {
                var queue = this._instance.queue;
                // process closed inodes
                this.inodes(this.path(item), false).each(function() {
                    var item = $(this);
                    // add node to open queue
                    queue.push(function(complete) {
                        this.open(item, this._inner(options));
                        complete();
                    });
                });
                queue.push(function(complete) {
                    this._success(item, options);
                    complete();
                });
            } else {
                this._fail(item, options);
            }
        },
        // test if path to item is open
        isOpenPath: function(item) {
            var parent = this.parent(item);
            return parent[0] ? this.isOpen(parent) && domApi.hasClass(parent[0], 'aciTreeVisible') : true;
        },
        // get animation speed vs. offset size
        // `speed` is the raw speed
        // `totalSize` is the available size
        // `required` is the offset used for calculations
        _speedFraction: function(speed, totalSize, required) {
            if ((required < totalSize) && totalSize) {
                var numeric = parseInt(speed);
                if (isNaN(numeric)) {
                    // predefined string values
                    switch (speed) {
                        case 'slow':
                            numeric = 600;
                            break;
                        case 'medium':
                            numeric = 400;
                            break;
                        case 'fast':
                            numeric = 200;
                            break;
                        default:
                            return speed;
                    }
                }
                return numeric * required / totalSize;
            }
            return speed;
        },
        // bring item in view
        // `options.center` says if should be centered in view
        setVisible: function(item, options) {
            options = this._options(options, 'visible', 'visiblefail', 'wasvisible', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforevisible', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isVisible(item)) {
                    // is visible already
                    this._notify(item, options);
                    return;
                }
                var process = function() {
                    // compute position with getBoundingClientRect
                    var rect = this._instance.jQuery[0].getBoundingClientRect();
                    var size = item[0].firstChild;
                    var test = size.getBoundingClientRect();
                    var height = size.offsetHeight;
                    var offset = options.center ? (rect.bottom - rect.top) / 2 : 0;
                    if (test.bottom - height < rect.top + offset) {
                        // item somewhere before the first visible
                        var diff = rect.top + offset - test.bottom + height;
                        if (!options.unanimated && this._instance.options.view) {
                            this._instance.jQuery.stop(true).animate({
                                scrollTop: this._instance.jQuery.scrollTop() - diff
                            },
                            {
                                duration: this._speedFraction(this._instance.options.view.duration, rect.bottom - rect.top, diff),
                                easing: this._instance.options.view.easing,
                                complete: this.proxy(function() {
                                    this._success(item, options);
                                })
                            });
                        } else {
                            this._instance.jQuery.stop(true)[0].scrollTop = this._instance.jQuery.scrollTop() - diff;
                            this._success(item, options);
                        }
                    } else if (test.top + height > rect.bottom - offset) {
                        // item somewhere after the last visible
                        var diff = test.top - rect.bottom + offset + height;
                        if (!options.unanimated && this._instance.options.view) {
                            this._instance.jQuery.stop(true).animate({
                                scrollTop: this._instance.jQuery.scrollTop() + diff
                            },
                            {
                                duration: this._speedFraction(this._instance.options.view.duration, rect.bottom - rect.top, diff),
                                easing: this._instance.options.view.easing,
                                complete: this.proxy(function() {
                                    this._success(item, options);
                                })
                            });
                        } else {
                            this._instance.jQuery.stop(true)[0].scrollTop = this._instance.jQuery.scrollTop() + diff;
                            this._success(item, options);
                        }
                    } else {
                        this._success(item, options);
                    }
                };
                if (this.hasParent(item)) {
                    // first we need to open the path to item
                    this.openPath(item, this._inner(options, {
                        success: process,
                        fail: options.fail
                    }));
                } else {
                    process.apply(this);
                }
            } else {
                this._fail(item, options);
            }
        },
        // test if item has parent
        hasParent: function(item) {
            return this.parent(item).length > 0;
        },
        // get item parent
        parent: function(item) {
            return item ? $(domApi.parent(item[0])) : $([]);
        },
        // get item top (ROOT) parent
        topParent: function(item) {
            return this.path(item).eq(0);
        },
        // create tree branch
        // `options.itemData` need to be in the same format as for .append
        _createBranch: function(item, options) {
            var total = 0;
            var count = function(itemList) {
                var itemData;
                for (var i = 0; i < itemList.length; i++) {
                    itemData = itemList[i];
                    if (itemData.branch && (itemData.branch instanceof Array) && itemData.branch.length) {
                        count(itemData.branch);
                    }
                }
                total++;
            };
            count(options.itemData);
            var index = 0;
            var complete = this.proxy(function() {
                index++;
                if (index >= total) {
                    this._success(item, options);
                }
            });
            var process = this.proxy(function(node, itemList) {
                if (node) {
                    // set it as a inode
                    domApi.addRemoveClass(node[0], 'aciTreeInode', 'aciTreeInodeMaybe');
                }
                // use .append to add new items
                this.append(node, this._inner(options, {
                    success: function(item, options) {
                        var itemData;
                        for (var i = 0; i < options.itemData.length; i++) {
                            itemData = options.itemData[i];
                            // children need to be array of item objects
                            if (itemData.branch && (itemData.branch instanceof Array) && itemData.branch.length) {
                                process(options.items.eq(i), itemData.branch);
                            }
                            if (itemData.open) {
                                // open the item is requuested
                                this.open(options.items.eq(i), this._inner(options, {
                                    itemData: null,
                                    items: null
                                }));
                            }
                        }
                        complete();
                    },
                    fail: options.fail,
                    itemData: itemList
                }));
            });
            process(item, options.itemData);
        },
        // get first/last items
        _getFirstLast: function(parent) {
            if (!parent) {
                parent = this._instance.jQuery;
            }
            return $(domApi.withAnyClass(domApi.children(parent[0]), ['aciTreeFirst', 'aciTreeLast']));
        },
        // update first/last items
        _setFirstLast: function(parent, clear) {
            if (clear) {
                domApi.removeListClass(clear.toArray(), ['aciTreeFirst', 'aciTreeLast']);
            }
            var first = this.first(parent);
            if (first[0]) {
                domApi.addClass(first[0], 'aciTreeFirst');
                domApi.addClass(this.last(parent)[0], 'aciTreeLast');
            }
        },
        // update odd/even state
        _setOddEven: function(items) {
            // consider only visible items
            var visible;
            if (this._instance.jQuery[0].getElementsByClassName) {
                visible = this._instance.jQuery[0].getElementsByClassName('aciTreeVisible');
                visible = visible ? window.Array.prototype.slice.call(visible) : [];
            } else {
                visible = $(domApi.children(this._instance.jQuery[0], true, function(node) {
                    return this.hasClass(node, 'aciTreeVisible') ? true : null;
                }));
            }
            var odd = true;
            if (visible.length) {
                var index = 0;
                if (items) {
                    // search the item to start with (by index)
                    items.each(function() {
                        if (visible.indexOf) {
                            var found = visible.indexOf(this);
                            if (found != -1) {
                                index = window.Math.min(found, index);
                            }
                        } else {
                            for (var i = 0; i < visible.length; i++) {
                                if (visible[i] === this) {
                                    index = window.Math.min(i, index);
                                    break;
                                }
                            }
                        }
                    });
                    index = window.Math.max(index - 1, 0);
                }
                if (index > 0) {
                    // determine with what to start with (odd/even)
                    var first = visible[index];
                    if (domApi.hasClass(first, 'aciTreOdd')) {
                        odd = false;
                    }
                    // process only after index
                    visible = visible.slice(index + 1);
                }
            }
            this._coreDOM.oddEven($(visible), odd);
        },
        // update odd/even state for direct children
        _setOddEvenChildren: function(item) {
            var odd = domApi.hasClass(item[0], 'aciTreeOdd');
            var children = this.children(item);
            this._coreDOM.oddEven(children, !odd);
        },
        // process item before inserting into the DOM
        _itemHook: function(parent, item, itemData, level) {
            if (this._instance.options.itemHook) {
                this._instance.options.itemHook.apply(this, arguments);
            }
        },
        // create item by `itemData`
        // `level` is the #0 based item level
        _createItem: function(itemData, level) {
            if (this._private.itemClone[level]) {
                var li = this._private.itemClone[level].cloneNode(true);
                var line = li.firstChild;
                var icon = line;
                for (var i = 0; i < level; i++) {
                    icon = icon.firstChild;
                }
                icon = icon.firstChild.lastChild.firstChild;
                var text = icon.nextSibling;
            } else {
                var li = window.document.createElement('LI');
                li.setAttribute('role', 'presentation');
                var line = window.document.createElement('DIV');
                li.appendChild(line);
                line.setAttribute('tabindex', -1);
                line.setAttribute('role', 'treeitem');
                line.setAttribute('aria-selected', false);
                line.className = 'aciTreeLine';
                var last = line, branch;
                for (var i = 0; i < level; i++) {
                    branch = window.document.createElement('DIV');
                    last.appendChild(branch);
                    branch.className = 'aciTreeBranch aciTreeLevel' + i;
                    last = branch;
                }
                var entry = window.document.createElement('DIV');
                last.appendChild(entry);
                entry.className = 'aciTreeEntry';
                var button = window.document.createElement('SPAN');
                entry.appendChild(button);
                button.className = 'aciTreeButton';
                var push = window.document.createElement('SPAN');
                button.appendChild(push);
                push.className = 'aciTreePush';
                push.appendChild(window.document.createElement('SPAN'));
                var item = window.document.createElement('SPAN');
                entry.appendChild(item);
                item.className = 'aciTreeItem';
                var icon = window.document.createElement('SPAN');
                item.appendChild(icon);
                var text = window.document.createElement('SPAN');
                item.appendChild(text);
                text.className = 'aciTreeText';
                this._private.itemClone[level] = li.cloneNode(true);
            }
            li.className = 'aciTreeLi' + (itemData.inode || (itemData.inode === null) ? (itemData.inode || (itemData.branch && itemData.branch.length) ? ' aciTreeInode' : ' aciTreeInodeMaybe') : ' aciTreeLeaf') + ' aciTreeLevel' + level + (itemData.disabled ? ' aciTreeDisabled' : '');
            line.setAttribute('aria-level', level + 1);
            if (itemData.inode || (itemData.inode === null)) {
                line.setAttribute('aria-expanded', false);
            }
            if (itemData.icon) {
                if (itemData.icon instanceof Array) {
                    icon.className = 'aciTreeIcon ' + itemData.icon[0];
                    icon.style.backgroundPosition = itemData.icon[1] + 'px ' + itemData.icon[2] + 'px';
                } else {
                    icon.className = 'aciTreeIcon ' + itemData.icon;
                }
            } else {
                icon.parentNode.removeChild(icon);
            }
            text.innerHTML = itemData.label;
            var $li = $(li);
            $li.data('itemData' + this._instance.nameSpace, $.extend({
            }, itemData, {
                branch: itemData.branch && itemData.branch.length
            }));
            return $li;
        },
        // remove item
        _removeItem: function(item) {
            var parent = this.parent(item);
            item.remove();
            // update sibling state
            this._setFirstLast(parent.length ? parent : null);
        },
        // create & add one or more items
        // `ul`, `before` and `after` are set depending on the caller
        // `itemData` need to be array of objects or just an object (one item)
        // `level` is the #0 based level
        // `callback` function (items) is called at the end of the operation
        _createItems: function(ul, before, after, itemData, level, callback) {
            var items = [], fragment = window.document.createDocumentFragment();
            var task = new this._task(this._instance.queue, function(complete) {
                items = $(items);
                if (items.length) {
                    // add the new items
                    if (ul) {
                        ul[0].appendChild(fragment);
                    } else if (before) {
                        before[0].parentNode.insertBefore(fragment, before[0]);
                    } else if (after) {
                        after[0].parentNode.insertBefore(fragment, after[0].nextSibling);
                    }
                }
                callback.call(this, items);
                complete();
            });
            if (itemData) {
                this._loader(true);
                var parent;
                if (ul) {
                    parent = this.itemFrom(ul);
                } else if (before) {
                    parent = this.parent(before);
                } else if (after) {
                    parent = this.parent(after);
                }
                if (itemData instanceof Array) {
                    // this is a list of items
                    for (var i = 0; i < itemData.length; i++) {
                        (function(itemData) {
                            task.push(function(complete) {
                                var item = this._createItem(itemData, level);
                                this._itemHook(parent, item, itemData, level);
                                fragment.appendChild(item[0]);
                                items.push(item[0]);
                                complete();
                            });
                        })(itemData[i]);
                    }
                } else {
                    task.push(function(complete) {
                        // only one item
                        var item = this._createItem(itemData, level);
                        this._itemHook(parent, item, itemData, level);
                        fragment.appendChild(item[0]);
                        items.push(item[0]);
                        complete();
                    });
                }
            }
            // run at least once
            task.push(function(complete) {
                complete();
            });
        },
        // create children container
        _createContainer: function(item) {
            if (!item) {
                item = this._instance.jQuery;
            }
            // ensure we have a UL in place
            var ul = domApi.container(item[0]);
            if (!ul) {
                var ul = window.document.createElement('UL');
                ul.setAttribute('role', 'group');
                ul.className = 'aciTreeUl';
                ul.style.display = 'none';
                item[0].appendChild(ul);
            }
            return $(ul);
        },
        // remove children container
        _removeContainer: function(item) {
            if (!item) {
                item = this._instance.jQuery;
            }
            var ul = domApi.container(item[0]);
            ul.parentNode.removeChild(ul);
        },
        // append one or more items to item
        // `options.itemData` can be a item object or array of item objects
        // `options.items` will keep a list of added items
        append: function(item, options) {
            options = this._options(options, 'appended', 'appendfail', null, item);
            if (item) {
                if (this.isInode(item)) {
                    // a way to cancel the operation
                    if (!this._trigger(item, 'beforeappend', options)) {
                        this._fail(item, options);
                        return;
                    }
                    var container = this._createContainer(item);
                    var last = this.last(item);
                    this._createItems(container, null, null, options.itemData, this.level(item) + 1, function(list) {
                        if (list.length) {
                            // some items created, update states
                            domApi.addRemoveClass(item[0], 'aciTreeInode', 'aciTreeInodeMaybe');
                            this._setFirstLast(item, last);
                            if (this.isHidden(item)) {
                                domApi.addListClass(list.toArray(), 'aciTreeHidden');
                            } else if (this.isOpenPath(item) && this.isOpen(item)) {
                                domApi.addListClass(list.toArray(), 'aciTreeVisible');
                                this._setOddEven(list.first());
                            }
                            // trigger `added` for each item
                            list.each(this.proxy(function(element) {
                                this._trigger($(element), 'added', options);
                            }, true));
                        } else if (!this.hasChildren(item, true)) {
                            container.remove();
                        }
                        options.items = list;
                        this._success(item, options);
                    });
                } else {
                    this._fail(item, options);
                }
            } else {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeappend', options)) {
                    this._fail(item, options);
                    return;
                }
                var container = this._createContainer();
                var last = this.last();
                this._createItems(container, null, null, options.itemData, 0, function(list) {
                    if (list.length) {
                        // some items created, update states
                        this._setFirstLast(null, last);
                        domApi.addListClass(list.toArray(), 'aciTreeVisible');
                        this._setOddEven();
                        // trigger `added` for each item
                        list.each(this.proxy(function(element) {
                            this._trigger($(element), 'added', options);
                        }, true));
                        this._animate(null, true, !this._instance.options.animateRoot || options.unanimated);
                    } else if (!this.hasChildren(null, true)) {
                        // remove the children container
                        container.remove();
                    }
                    options.items = list;
                    this._success(item, options);
                });
            }
        },
        // insert one or more items before item
        // `options.itemData` can be a item object or array of item objects
        // `options.items` will keep a list of added items
        before: function(item, options) {
            options = this._options(options, 'before', 'beforefail', null, item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforebefore', options)) {
                    this._fail(item, options);
                    return;
                }
                var prev = this.prev(item);
                this._createItems(null, item, null, options.itemData, this.level(item), function(list) {
                    if (list.length) {
                        // some items created, update states
                        if (!prev.length) {
                            domApi.removeClass(item[0], 'aciTreeFirst');
                            domApi.addClass(list.first()[0], 'aciTreeFirst');
                        }
                        var parent = this.parent(item);
                        if (parent.length && this.isHidden(parent)) {
                            domApi.addListClass(list.toArray(), 'aciTreeHidden');
                        } else if (this.isOpenPath(item)) {
                            domApi.addListClass(list.toArray(), 'aciTreeVisible');
                            this._setOddEven(list.first());
                        }
                        // trigger `added` for each item
                        list.each(this.proxy(function(element) {
                            this._trigger($(element), 'added', options);
                        }, true));
                    }
                    options.items = list;
                    this._success(item, options);
                });
            } else {
                this._fail(item, options);
            }
        },
        // insert one or more items after item
        // `options.itemData` can be a item object or array of item objects
        // `options.items` will keep a list of added items
        after: function(item, options) {
            options = this._options(options, 'after', 'afterfail', null, item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeafter', options)) {
                    this._fail(item, options);
                    return;
                }
                var next = this.next(item);
                this._createItems(null, null, item, options.itemData, this.level(item), function(list) {
                    if (list.length) {
                        // some items created, update states
                        if (!next.length) {
                            domApi.removeClass(item[0], 'aciTreeLast');
                            domApi.addClass(list.last()[0], 'aciTreeLast');
                        }
                        var parent = this.parent(item);
                        if (parent.length && this.isHidden(parent)) {
                            domApi.addListClass(list.toArray(), 'aciTreeHidden');
                        } else if (this.isOpenPath(item)) {
                            domApi.addListClass(list.toArray(), 'aciTreeVisible');
                            this._setOddEven(list.first());
                        }
                        // trigger `added` for each item
                        list.each(this.proxy(function(element) {
                            this._trigger($(element), 'added', options);
                        }, true));
                    }
                    options.items = list;
                    this._success(item, options);
                });
            } else {
                this._fail(item, options);
            }
        },
        // get item having the element
        itemFrom: function(element) {
            if (element) {
                var item = $(element);
                if (item[0] === this._instance.jQuery[0]) {
                    return $([]);
                } else {
                    return $(domApi.parentFrom(item[0]));
                }
            }
            return $([]);
        },
        // get item children
        // if `branch` is TRUE then all children are returned
        // if `hidden` is TRUE then the hidden items will be considered too
        children: function(item, branch, hidden) {
            return $(domApi.children(item && item[0] ? item[0] : this._instance.jQuery[0], branch, hidden ? null : function(node) {
                return this.hasClass(node, 'aciTreeHidden') ? null : true;
            }));
        },
        // filter only the visible items (items with all parents opened)
        // if `view` is TRUE then only the items in view are returned
        visible: function(items, view) {
            var list = domApi.withClass(items.toArray(), 'aciTreeVisible');
            if (view) {
                var filter = [];
                for (var i = 0; i < list.length; i++) {
                    if (this.isVisible($(list[i]))) {
                        filter.push(list[i]);
                    }
                }
                return $(filter);
            }
            return $(list);
        },
        // filter only inner nodes from items
        // if `state` is set then filter only open/closed ones
        inodes: function(items, state) {
            if (state !== undefined) {
                if (state) {
                    return $(domApi.withClass(items.toArray(), 'aciTreeOpen'));
                } else {
                    return $(domApi.withAnyClass(items.toArray(), ['aciTreeInode', 'aciTreeInodeMaybe'], 'aciTreeOpen'));
                }
            }
            return $(domApi.withAnyClass(items.toArray(), ['aciTreeInode', 'aciTreeInodeMaybe']));
        },
        // filter only leaf nodes from items
        leaves: function(items) {
            return $(domApi.withClass(items.toArray(), 'aciTreeLeaf'));
        },
        // test if is a inner node
        isInode: function(item) {
            return item && domApi.hasAnyClass(item[0], ['aciTreeInode', 'aciTreeInodeMaybe']);
        },
        // test if is a leaf node
        isLeaf: function(item) {
            return item && domApi.hasClass(item[0], 'aciTreeLeaf');
        },
        // test if item was loaded
        wasLoad: function(item) {
            if (item) {
                return domApi.container(item[0]) !== null;
            }
            return domApi.container(this._instance.jQuery[0]) !== null;
        },
        // set item as inner node
        setInode: function(item, options) {
            options = this._options(options, 'inodeset', 'inodefail', 'wasinode', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeinode', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isLeaf(item)) {
                    this._coreDOM.inode(item, true);
                    this._success(item, options);
                } else {
                    this._notify(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // set item as leaf node
        setLeaf: function(item, options) {
            options = this._options(options, 'leafset', 'leaffail', 'wasleaf', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeleaf', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isInode(item)) {
                    var process = function() {
                        this._coreDOM.leaf(item);
                        this._success(item, options);
                    };
                    if (this.wasLoad(item)) {
                        // first unload the node
                        this.unload(item, this._inner(options, {
                            success: process,
                            fail: options.fail
                        }));
                    } else {
                        process.apply(this);
                    }
                } else {
                    this._notify(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // add/update item icon
        // `options.icon` can be the CSS class name or array['CSS class name', background-position-x, background-position-y]
        // `options.oldIcon` will keep the old icon
        addIcon: function(item, options) {
            options = this._options(options, 'iconadded', 'addiconfail', 'wasicon', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeaddicon', options)) {
                    this._fail(item, options);
                    return;
                }
                var data = this.itemData(item);
                // keep the old one
                options.oldIcon = data.icon;
                var parent = domApi.childrenByClass(item[0].firstChild, 'aciTreeItem');
                var found = domApi.childrenByClass(parent, 'aciTreeIcon');
                if (found && data.icon && (options.icon.toString() == data.icon.toString())) {
                    this._notify(item, options);
                } else {
                    if (!found) {
                        found = window.document.createElement('DIV');
                        parent.insertBefore(found, parent.firstChild);
                    }
                    if (options.icon instanceof Array) {
                        // icon with background-position
                        found.className = 'aciTreeIcon ' + options.icon[0];
                        found.style.backgroundPosition = options.icon[1] + 'px ' + options.icon[2] + 'px';
                    } else {
                        // only the CSS class name
                        found.className = 'aciTreeIcon ' + options.icon;
                    }
                    // remember this one
                    data.icon = options.icon;
                    this._success(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // remove item icon
        // options.oldIcon will keep the old icon
        removeIcon: function(item, options) {
            options = this._options(options, 'iconremoved', 'removeiconfail', 'noticon', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeremoveicon', options)) {
                    this._fail(item, options);
                    return;
                }
                var data = this.itemData(item);
                // keep the old one
                options.oldIcon = data.icon;
                var parent = domApi.childrenByClass(item[0].firstChild, 'aciTreeItem');
                var found = domApi.childrenByClass(parent, 'aciTreeIcon');
                if (found) {
                    parent.removeChild(found);
                    // remember was removed
                    data.icon = null;
                    this._success(item, options);
                } else {
                    this._notify(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // test if item has icon
        hasIcon: function(item) {
            return !!this.getIcon(item);
        },
        // get item icon
        getIcon: function(item) {
            var data = this.itemData(item);
            return data ? data.icon : null;
        },
        // set item label
        // `options.label` is the new label
        // `options.oldLabel` will keep the old label
        setLabel: function(item, options) {
            options = this._options(options, 'labelset', 'labelfail', 'waslabel', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforelabel', options)) {
                    this._fail(item, options);
                    return;
                }
                var data = this.itemData(item);
                // keep the old one
                options.oldLabel = data.label;
                if (options.label == options.oldLabel) {
                    this._notify(item, options);
                } else {
                    // set the label
                    domApi.childrenByClass(item[0].firstChild, 'aciTreeText').innerHTML = options.label;
                    // remember this one
                    data.label = options.label;
                    this._success(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // disable item
        disable: function(item, options) {
            options = this._options(options, 'disabled', 'disablefail', 'wasdisabled', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforedisable', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isDisabled(item)) {
                    this._notify(item, options);
                } else {
                    domApi.addClass(item[0], 'aciTreeDisabled');
                    this._success(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // test if item is disabled
        isDisabled: function(item) {
            return item && domApi.hasClass(item[0], 'aciTreeDisabled');
        },
        // test if any of parents are disabled
        isDisabledPath: function(item) {
            return domApi.withClass(this.path(item).toArray(), 'aciTreeDisabled').length > 0;
        },
        // filter only the disabled items
        disabled: function(items) {
            return $(domApi.withClass(items.toArray(), 'aciTreeDisabled'));
        },
        // enable item
        enable: function(item, options) {
            options = this._options(options, 'enabled', 'enablefail', 'wasenabled', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeenable', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isDisabled(item)) {
                    domApi.removeClass(item[0], 'aciTreeDisabled');
                    this._success(item, options);
                } else {
                    this._notify(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // test if item is enabled
        isEnabled: function(item) {
            return item && !domApi.hasClass(item[0], 'aciTreeDisabled');
        },
        // test if all parents are enabled
        isEnabledPath: function(item) {
            return domApi.withClass(this.path(item).toArray(), 'aciTreeDisabled').length == 0;
        },
        // filter only the enabled items
        enabled: function(items) {
            return $(domApi.withClass(items.toArray(), null, 'aciTreeDisabled'));
        },
        // set item as hidden
        hide: function(item, options) {
            options = this._options(options, 'hidden', 'hidefail', 'washidden', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforehide', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isHidden(item)) {
                    this._notify(item, options);
                } else {
                    domApi.addRemoveClass(item[0], 'aciTreeHidden', 'aciTreeVisible');
                    // process children
                    domApi.addRemoveClass(this.children(item, true).toArray(), 'aciTreeHidden', 'aciTreeVisible');
                    // update item states
                    var parent = this.parent(item);
                    this._setFirstLast(parent.length ? parent : null, item);
                    this._setOddEven(item);
                    this._success(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // test if item is hidden
        isHidden: function(item) {
            return item && domApi.hasClass(item[0], 'aciTreeHidden');
        },
        // test if any of parents are hidden
        isHiddenPath: function(item) {
            var parent = this.parent(item);
            return parent[0] && domApi.hasClass(parent[0], 'aciTreeHidden');
        },
        // update hidden state
        _updateHidden: function(item) {
            if (this.isHiddenPath(item)) {
                if (!this.isHidden(item)) {
                    domApi.addClass(item[0], 'aciTreeHidden');
                    this._updateVisible(item);
                }
            } else {
                this._updateVisible(item);
            }
        },
        // filter only the hidden items
        hidden: function(items) {
            return $(domApi.withClass(items.toArray(), 'aciTreeHidden'));
        },
        // show hidden item
        _showHidden: function(item) {
            var parent = null;
            this.path(item).add(item).each(this.proxy(function(element) {
                var item = $(element);
                if (this.isHidden(item)) {
                    domApi.removeClass(item[0], 'aciTreeHidden');
                    if (this.isOpenPath(item) && (!parent || this.isOpen(parent))) {
                        domApi.addClass(item[0], 'aciTreeVisible');
                    }
                    // update item states
                    this._setFirstLast(parent, this._getFirstLast(parent));
                }
                parent = item;
            }, true));
        },
        // show hidden item
        show: function(item, options) {
            options = this._options(options, 'shown', 'showfail', 'wasshown', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeshow', options)) {
                    this._fail(item, options);
                    return;
                }
                if (this.isHidden(item)) {
                    this._showHidden(item);
                    var parent = this.topParent(item);
                    // update item states
                    this._setOddEven(parent.length ? parent : item);
                    this._success(item, options);
                } else {
                    this._notify(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // test if item is open
        isOpen: function(item) {
            return item && domApi.hasClass(item[0], 'aciTreeOpen');
        },
        // test if item is closed
        isClosed: function(item) {
            return item && !domApi.hasClass(item[0], 'aciTreeOpen');
        },
        // test if item has children
        // if `hidden` is TRUE then the hidden items will be considered too
        hasChildren: function(item, hidden) {
            return this.children(item, false, hidden).length > 0;
        },
        // test if item has siblings
        // if `hidden` is TRUE then the hidden items will be considered too
        hasSiblings: function(item, hidden) {
            return this.siblings(item, hidden).length > 0;
        },
        // test if item has another before
        // if `hidden` is TRUE then the hidden items will be considered too
        hasPrev: function(item, hidden) {
            return this.prev(item, hidden).length > 0;
        },
        // test if item has another after
        // if `hidden` is TRUE then the hidden items will be considered too
        hasNext: function(item, hidden) {
            return this.next(item, hidden).length > 0;
        },
        // get item siblings
        // if `hidden` is TRUE then the hidden items will be considered too
        siblings: function(item, hidden) {
            return item ? $(domApi.children(item[0].parentNode.parentNode, false, function(node) {
                return (node != item[0]) && (hidden || !this.hasClass(node, 'aciTreeHidden'));
            })) : $([]);
        },
        // get previous item
        // if `hidden` is TRUE then the hidden items will be considered too
        prev: function(item, hidden) {
            return item ? $(domApi.prev(item[0], hidden ? null : function(node) {
                return !this.hasClass(node, 'aciTreeHidden');
            })) : $([]);
        },
        // get next item
        // if `hidden` is TRUE then the hidden items will be considered too
        next: function(item, hidden) {
            return item ? $(domApi.next(item[0], hidden ? null : function(node) {
                return !this.hasClass(node, 'aciTreeHidden');
            })) : $([]);
        },
        // get item level - starting from 0
        // return -1 for invalid items
        level: function(item) {
            var level = -1;
            if (item) {
                var node = item[0];
                while (domApi.hasClass(node, 'aciTreeLi')) {
                    node = node.parentNode.parentNode;
                    level++;
                }
            }
            return level;
        },
        // get item ID
        getId: function(item) {
            var data = this.itemData(item);
            return data ? data.id : null;
        },
        // get item data
        itemData: function(item) {
            return item ? item.data('itemData' + this._instance.nameSpace) : null;
        },
        // set item ID
        // `options.id` is the new item ID
        // `options.oldId` will keep the old ID
        setId: function(item, options) {
            options = this._options(options, 'idset', 'idfail', 'wasid', item);
            if (this.isItem(item)) {
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeid', options)) {
                    this._fail(item, options);
                    return;
                }
                var data = this.itemData(item);
                // keep the old one
                options.oldId = data.id;
                if (options.id == options.oldId) {
                    this._notify(item, options);
                } else {
                    // remember this one
                    data.id = options.id;
                    this._success(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // get item index - starting from #0
        getIndex: function(item) {
            if (item && item[0]) {
                if (window.Array.prototype.indexOf) {
                    return window.Array.prototype.indexOf.call(item[0].parentNode.childNodes, item[0]);
                } else {
                    var children = item[0].parentNode.childNodes;
                    for (var i = 0; i < children.length; i++) {
                        if (children[i] == item[0]) {
                            return i;
                        }
                    }
                }
            }
            return null;
        },
        // set item index - #0 based
        // `options.index` is the new index
        // `options.oldIndex` will keep the old index
        setIndex: function(item, options) {
            options = this._options(options, 'indexset', 'indexfail', 'wasindex', item);
            if (this.isItem(item)) {
                var oldIndex = this.getIndex(item);
                var siblings = this.siblings(item);
                if ((options.index != oldIndex) && !siblings.length) {
                    this._fail(item, options);
                    return;
                }
                // a way to cancel the operation
                if (!this._trigger(item, 'beforeindex', options)) {
                    this._fail(item, options);
                    return;
                }
                // keep the old one
                options.oldIndex = oldIndex;
                if (options.index == oldIndex) {
                    this._notify(item, options);
                } else {
                    // set the new index
                    if (options.index < 1) {
                        siblings.first().before(item);
                    } else if (options.index >= siblings.length) {
                        siblings.last().after(item);
                    } else {
                        siblings.eq(options.index).before(item);
                    }
                    var parent = this.parent(item);
                    // update item states
                    this._setFirstLast(parent.length ? parent : null, item.add([siblings[0], siblings.get(-1)]));
                    this._setOddEven(parent);
                    this._success(item, options);
                }
            } else {
                this._fail(item, options);
            }
        },
        // get item label
        getLabel: function(item) {
            var data = this.itemData(item);
            return data ? data.label : null;
        },
        // test if is valid item
        isItem: function(item) {
            return item && domApi.hasClass(item[0], 'aciTreeLi');
        },
        // item animation
        // `state` if TRUE then show, FALSE then hide
        // `unanimated` if TRUE then don't use animations
        // `callback` function () to call at the end
        _animate: function(item, state, unanimated, callback) {
            if (!item) {
                item = this._instance.jQuery;
            }
            if (!unanimated) {
                // use the defined animation props
                var setting = state ? this._instance.options.show : this._instance.options.hide;
                if (setting) {
                    var ul = domApi.container(item[0]);
                    if (ul) {
                        // animate children container
                        $(ul).stop(true, true).animate(setting.props, {
                            duration: setting.duration,
                            easing: setting.easing,
                            complete: callback ? this.proxy(callback) : null
                        });
                    } else if (callback) {
                        callback.apply(this);
                    }
                    return;
                }
            }
            // use no animation
            $(domApi.container(item[0])).stop(true, true).toggle(state);
            if (callback) {
                callback.apply(this);
            }
        },
        // get first children of item
        // if `hidden` is TRUE then the hidden items will be considered too
        first: function(item, hidden) {
            if (!item) {
                item = this._instance.jQuery;
            }
            return $(domApi.firstChild(item[0], hidden ? null : function(node) {
                return !this.hasClass(node, 'aciTreeHidden');
            }));
        },
        // test if item is the first one for his parent
        // if `hidden` is TRUE then the hidden items will be considered too
        isFirst: function(item, hidden) {
            if (item) {
                var parent = domApi.parent(item[0]);
                return this.first(parent ? $(parent) : null, hidden)[0] == item[0];
            }
            return false;
        },
        // get last children of item
        // if `hidden` is TRUE then the hidden items will be considered too
        last: function(item, hidden) {
            if (!item) {
                item = this._instance.jQuery;
            }
            return $(domApi.lastChild(item[0], hidden ? null : function(node) {
                return !this.hasClass(node, 'aciTreeHidden');
            }));
        },
        // test if item is the last one for his parent
        // if `hidden` is TRUE then the hidden items will be considered too
        isLast: function(item, hidden) {
            if (item) {
                var parent = domApi.parent(item[0]);
                return this.last(parent ? $(parent) : null, hidden)[0] == item[0];
            }
            return false;
        },
        // test if item is busy/loading
        isBusy: function(item) {
            if (item) {
                return domApi.hasClass(item[0], 'aciTreeLoad');
            } else {
                return this._instance.queue.busy();
            }
        },
        // set loading state
        _loading: function(item, state) {
            if (item) {
                domApi.toggleClass(item[0], 'aciTreeLoad', state);
                if (state) {
                    item[0].firstChild.setAttribute('aria-busy', true);
                } else {
                    item[0].firstChild.removeAttribute('aria-busy');
                }
            } else if (state) {
                this._loader(state);
            }
        },
        // show loader image
        _loader: function(show) {
            if (show || this.isBusy()) {
                if (!this._private.loaderInterval) {
                    this._private.loaderInterval = window.setInterval(this.proxy(function() {
                        this._loader();
                    }), this._instance.options.loaderDelay);
                }
                domApi.addClass(this._instance.jQuery[0], 'aciTreeLoad');
                window.clearTimeout(this._private.loaderHide);
                this._private.loaderHide = window.setTimeout(this.proxy(function() {
                    domApi.removeClass(this._instance.jQuery[0], 'aciTreeLoad');
                }), this._instance.options.loaderDelay * 2);
            }
        },
        // test if parent has children
        isChildren: function(parent, children) {
            if (!parent) {
                parent = this._instance.jQuery;
            }
            return children && (parent.has(children).length > 0);
        },
        // test if parent has immediate children
        isImmediateChildren: function(parent, children) {
            if (!parent) {
                parent = this._instance.jQuery;
            }
            return children && parent.children('.aciTreeUl').children('.aciTreeLi').is(children);
        },
        // test if items share the same parent
        sameParent: function(item1, item2) {
            if (item1 && item2) {
                var parent1 = this.parent(item1);
                var parent2 = this.parent(item2);
                return (!parent1.length && !parent2.length) || (parent1[0] == parent2[0]);
            }
            return false;
        },
        // test if items share the same top parent
        sameTopParent: function(item1, item2) {
            if (item1 && item2) {
                var parent1 = this.topParent(item1);
                var parent2 = this.topParent(item2);
                return (!parent1.length && !parent2.length) || (parent1[0] == parent2[0]);
            }
            return false;
        },
        // return the updated item data
        // `callback` function (item) called for each item
        _serialize: function(item, callback) {
            var data = this.itemData(item);
            if (this.isInode(item)) {
                data.inode = true;
                if (this.wasLoad(item)) {
                    if (data.hasOwnProperty('open')) {
                        data.open = this.isOpen(item);
                    } else if (this.isOpen(item)) {
                        data.open = true;
                    }
                    data.branch = [];
                    this.children(item, false, true).each(this.proxy(function(element) {
                        var entry = this._serialize($(element), callback);
                        if (callback) {
                            entry = callback.call(this, $(element), {
                            }, entry);
                        } else {
                            entry = this._instance.options.serialize.call(this, $(element), {
                            }, entry);
                        }
                        if (entry) {
                            data.branch.push(entry);
                        }
                    }, true));
                    if (!data.branch.length) {
                        data.branch = null;
                    }
                } else {
                    if (data.hasOwnProperty('open')) {
                        data.open = false;
                    }
                    if (data.hasOwnProperty('branch')) {
                        data.branch = null;
                    }
                }
            } else {
                if (data.hasOwnProperty('inode')) {
                    data.inode = false;
                }
                if (data.hasOwnProperty('open')) {
                    data.open = null;
                }
                if (data.hasOwnProperty('branch')) {
                    data.branch = null;
                }
            }
            if (data.hasOwnProperty('disabled')) {
                data.disabled = this.isDisabled(item);
            } else if (this.isDisabled(item)) {
                data.disabled = true;
            }
            return data;
        },
        // return serialized data
        // `callback` function (item, what, value) - see `aciTree.options.serialize`
        serialize: function(item, what, callback) {
            // override this to provide serialized data
            if (typeof what == 'object') {
                if (item) {
                    var data = this._serialize(item, callback);
                    if (callback) {
                        data = callback.call(this, item, {
                        }, data);
                    } else {
                        data = this._instance.options.serialize.call(this, item, {
                        }, data);
                    }
                    return data;
                } else {
                    var list = [];
                    this.children(null, false, true).each(this.proxy(function(element) {
                        var data = this._serialize($(element), callback);
                        if (callback) {
                            data = callback.call(this, $(element), {
                            }, data);
                        } else {
                            data = this._instance.options.serialize.call(this, $(element), {
                            }, data);
                        }
                        if (data) {
                            list.push(data);
                        }
                    }, true));
                    return list;
                }
            }
            return '';
        },
        // destroy the control
        destroy: function(options) {
            options = this._options(options);
            // check if was init
            if (!this.wasInit()) {
                this._trigger(null, 'notinit', options);
                this._fail(null, options);
                return;
            }
            // check if is locked
            if (this.isLocked()) {
                this._trigger(null, 'locked', options);
                this._fail(null, options);
                return;
            }
            // a way to cancel the operation
            if (!this._trigger(null, 'beforedestroy', options)) {
                this._trigger(null, 'destroyfail', options);
                this._fail(null, options);
                return;
            }
            this._private.locked = true;
            this._instance.jQuery.addClass('aciTreeLoad').attr('aria-busy', true);
            this._instance.queue.destroy();
            this._destroyHook(false);
            // unload the entire treeview
            this.unload(null, this._inner(options, {
                success: this.proxy(function() {
                    window.clearTimeout(this._private.loaderHide);
                    window.clearInterval(this._private.loaderInterval);
                    this._private.itemClone = {
                    };
                    this._destroyHook(true);
                    this._instance.jQuery.unbind(this._instance.nameSpace).off(this._instance.nameSpace, '.aciTreeButton').off(this._instance.nameSpace, '.aciTreeLine');
                    this._instance.jQuery.removeClass('aciTree' + this._instance.index + ' aciTreeLoad').removeAttr('role aria-busy');
                    this._private.locked = false;
                    // call the parent
                    this._super();
                    this._trigger(null, 'destroyed', options);
                    this._success(null, options);
                }),
                fail: function() {
                    this._instance.jQuery.removeClass('aciTreeLoad');
                    this._private.locked = false;
                    this._trigger(null, 'destroyfail', options);
                    this._fail(null, options);
                }
            }));
        },
        _destroyHook: function(unloaded) {
            // override this to do extra destroy before/after unload
        }

    };

    // extend the base aciPluginUi class and store into aciPluginClass.plugins
    aciPluginClass.plugins.aciTree = aciPluginClass.aciPluginUi.extend(aciTree_core, 'aciTreeCore');

    // publish the plugin & the default options
    aciPluginClass.publish('aciTree', options);

    // for internal access
    var domApi = aciPluginClass.plugins.aciTree_dom;

})(jQuery, this);
