').append($(obj).clone()).remove().html();
},
onDestroy: function(TREE_OBJ) {
///
/// When the tree is destroyed we need to ensure that all of the events both
/// live and bind are gone. For some reason the jstree unbinding doesn't seem to do it's job
/// so instead we need to clear all of the events ourselves
///
this._debug("onDestroy: " + TREE_OBJ.container.attr("id"));
TREE_OBJ.container
.unbind("contextmenu")
.unbind("click")
.unbind("dblclick")
.unbind("mouseover")
.unbind("mousedown")
.unbind("mouseup");
$("a", TREE_OBJ.container.get(0))
.die("contextmenu")
.die("click")
.die("dblclick")
.die("mouseover")
.die("mousedown");
//also need to kill the custom selector we've fixed in jstree source
$("#" + TREE_OBJ.container.attr("id") + " li").die("click");
$("li", TREE_OBJ.container.get(0))
.die("click");
},
onError: function(ERR, TREE_OBJ) {
this._debug("ERROR!!!!! " + ERR);
},
_debug: function(strMsg) {
if (this._isDebug && Sys && Sys.Debug) {
Sys.Debug.trace("UmbracoTree: " + strMsg);
}
},
_configureNodes: function(nodes, reconfigure) {
///
/// Ensures the node is configured properly after it's loaded via ajax.
/// This includes setting overlays and ensuring the correct icon paths are used.
/// This also ensures that the correct markup is rendered for the tree (i.e. inserts html nodes for text, etc...)
///
var _this = this;
//don't process the nodes that have already been loaded, unless reconfigure is true
if (!reconfigure) {
nodes = nodes.not("li[class*='loaded']");
}
this._debug("_configureNodes: " + nodes.length);
var rxInput = new RegExp("\\boverlay-\\w+\\b", "gi");
nodes.each(function() {
//if it is checkbox tree (not standard), don't worry about overlays and remove the default icon.
if (_this._opts.treeMode != "standard") {
$(this).children("a:first").css("background", "");
return;
}
//remove all overlays if reconfiguring
$(this).children("div").remove();
var m = $(this).attr("class").match(rxInput);
if (m != null) {
for (i = 0; i < m.length; i++) {
_this._debug("_configureNodes: adding overlay: " + m[i] + " for node: " + $(this).attr("id"));
$(this).children("a:first").before("
");
}
}
//create a div for the text
var a = $(this).children("a");
var ins = a.children("ins");
ins.remove(); //need to remove before you do a .text() otherwise whitespace is included
var txt = $("
" + a.text() + "
");
//check if it's not a sprite, if not then move the ins node just after the anchor, otherwise remove
if (a.hasClass("noSpr")) {
a.attr("style", ins.attr("style"));
}
else {
}
a.html(txt);
//add the loaded class to each element so we know not to process it again
$(this).addClass("loaded");
});
},
getNodeDef: function(NODE) {
///
Converts a jquery node with metadata to a NodeDefinition
//get our meta data stored with our node
var nodedata = $(NODE).children("a").metadata({ type: 'attr', name: 'umb:nodedata' });
this._debug("getNodeDef: " + $(NODE).attr("id") + ", " + nodedata.nodeType + ", " + nodedata.source);
var def = new Umbraco.Controls.NodeDefinition();
def.updateDefinition(this._tree, $(NODE), $(NODE).attr("id"), $(NODE).find("a > div").html(), nodedata.nodeType, nodedata.source, nodedata.menu, $(NODE).attr("umb:type"));
return def;
},
_updateRecycleBin: function() {
///
Generally used for when a node is deleted. This will set the actionNode to the recycle bin node and force a refresh of it's children
this._debug("_updateRecycleBin BinId: " + this._opts.recycleBinId);
var rNode = this.findNode(this._opts.recycleBinId, true);
if (rNode) {
this._actionNode = this.getNodeDef(rNode);
var _this = this;
this.reloadActionNode(true, true, function(success) {
if (success) {
_this.findNode(_this._opts.recycleBinId, true).effect("highlight", {}, 1000);
}
});
}
},
_ensureContext: function() {
///
/// ensure that the tree object always has the correct context.
/// this is a fix for the TinyMCE dialog window, as it tends to lose object context for some wacky reason
/// when ajax calls are made. Works fine in all other instances.
///
this._tree.container = this._getContainer();
},
_loadChildNodes: function(liNode, callback) {
///
jsTree won't allow you to open a node that doesn't explitly have childen, this will force it to try
///
a jquery object for the current li node
this._debug("_loadChildNodes: " + liNode.attr("id"));
liNode.removeClass("leaf");
var _this = this;
//close branch will actually cause a select to happen so we'll intercept the select callback and then reset it once complete
//if we don't wan the event to fire, we'll set the callback to a null method and set it back after we call the select_branch method
this._tree.settings.callback.onselect = function() { };
this._tree.close_branch(liNode, true);
this._tree.settings.callback.onselect = function(N, T) { _this.onSelect(N, T) };
liNode.children("ul:eq(0)").remove();
this._tree.open_branch(liNode, false, callback);
},
_syncTree: function(path, forceReload, numPaths, numAsync) {
///
/// This is the internal method that will recursively search for the nodes to sync. If an invalid path is
/// passed to this method, it will raise an event which can be handled.
///
///
The path of the node to find
///
If true, will ensure that the node to be synced is synced with data from the server
///
the number of id's deep to search starting from the end of the path. Used in recursion.
///
the number of async calls made so far to sync. Used in recursion and used to determine if the found node has been loaded by ajax.
this._debug("_syncTree");
var paths = path.split(",");
var found = null;
var foundIndex = null;
if (numPaths == null) numPaths = (paths.length - 0);
for (var i = 0; i < numPaths; i++) {
foundIndex = paths.length - (1 + i);
found = this.findNode(paths[foundIndex]);
this._debug("_syncTree: finding... " + paths[foundIndex] + " found? " + found);
if (found) break;
}
//if no node has been found at all in the entire path, then bubble an error event
if (!found) {
this._debug("no node found in path: " + path + " : " + numPaths);
this._isSyncing = false; //reset flag
this._raiseEvent("syncNotFound", [path]);
return;
}
//if the found node was not the end of the path, we need to load them in recursively.
if (found.attr("id") != paths[paths.length - 1]) {
var _this = this;
this._loadChildNodes(found, function(NODE, TREE_OBJ) {
//check if the next node to be found is in the children, if it is not, there's a problem bubble an event!
var pathsToSearch = paths.length - (Number(foundIndex) + 1);
if (_this.findNode(paths[foundIndex + 1])) {
_this._syncTree(path, forceReload, pathsToSearch, (numAsync == null ? numAsync == 1 : ++numAsync));
}
else {
_this._debug("node not found in children: " + path + " : " + numPaths);
this._isSyncing = false; //reset flag
_this._raiseEvent("syncNotFound", [path]);
}
});
}
else {
//only force the reload of this nodes data if forceReload is specified and the node has not already come from the server
var doReload = (forceReload && (numAsync == null || numAsync < 1));
this._debug("_syncTree: found! numAsync: " + numAsync + ", forceReload: " + forceReload + ", doReload: " + doReload);
if (doReload) {
this._actionNode = this.getNodeDef(found);
this.reloadActionNode(false, true, null);
}
else {
//we have found our node, select it but supress the selecting event
if (found.attr("id") != "-1") this.selectNode(found, true);
this._configureNodes(found, doReload);
}
this._isSyncing = false; //reset flag
//bubble event
this._raiseEvent("syncFound", [found]);
}
},
_getUrlParams: function(nodeSource) {
///
This converts Url query string params to json
var p = {};
if (nodeSource) {
var urlSplit = nodeSource.split("?");
if (urlSplit.length > 1) {
var sp = urlSplit[1].split("&");
for (var i = 0; i < sp.length; i++) {
var e = sp[i].split("=");
p[e[0]] = e[1];
}
p["rnd2"] = Umbraco.Utils.generateRandom();
}
}
return p;
},
_getUrl: function(nodeSource) {
///
Returns the json service url
if (nodeSource == null || nodeSource == "") {
return this._opts.dataUrl;
}
var params = nodeSource.split("?")[1];
return this._opts.dataUrl + "?" + params + "&rnd2=" + Umbraco.Utils.generateRandom();
},
_getContainer: function() {
return $("#" + this._containerId, this._context);
},
_getInitOptions: function(initData) {
///
return the initialization objects for the tree
this._debug("_getInitOptions");
var _this = this;
var options = {
data: {
type: "json",
async: true,
opts: {
static: initData == null ? null : initData,
method: "POST",
url: _this._opts.serviceUrl,
outer_attrib: ["id", "umb:type", "class", "rel"],
inner_attrib: ["umb:nodedata", "href", "class", "style"]
}
},
ui: {
dots: false,
rtl: false,
animation: false,
hover_mode: true,
theme_path: false,
theme_name: "umbraco"
},
langs: {
new_node: "New folder",
loading: "
" + (this._tree.settings.lang.loading || "Loading ...") + "
"
},
callback: {
//ensures that the node id isn't appended to the async url
beforedata: function(N, T) { return _this.onBeforeRequest(N, T); },
//wrapped functions maintain scope in callback
beforeopen: function(N, T) { _this.onBeforeOpen(N, T); },
onselect: function(N, T) { _this.onSelect(N, T); },
onchange: function(N, T) { _this.onChange(N, T); },
ondata: function(D, T) { return _this.onJSONData(D, T); },
onload: function(T) { if (initData == null) _this.onLoad(T); },
onparse: function(S, T) { return _this.onParse(S, T); },
error: function(E, T) { _this.onError(E, T); },
ondestroy: function(T) { _this.onDestroy(T); }
},
plugins: {
//UmbracoContext comes before context menu so that the events fire first
UmbracoContext: {
fullMenu: _this._opts.jsonFullMenu,
onBeforeContext: function(N, T, E) { return _this.onBeforeContext(N, T, E); }
},
contextmenu: {}
}
};
if (this._opts.treeMode != "standard") {
options.plugins.checkbox = { three_state: false }
}
//if there's no service URL, then disable ajax requests
if (this._opts.serviceUrl == "" || this._opts.dataUrl == "") {
options.data.async = false;
options.data.opts.static = {};
}
//set global ajax settings:
$.ajaxSetup({
contentType: "application/json; charset=utf-8"
});
this._debug("_getInitOptions. Async enabled = " + options.data.async);
return options;
}
};
}
// instance manager
Umbraco.Controls.UmbracoTree.cntr = 0;
Umbraco.Controls.UmbracoTree.inst = {};
})(jQuery);