').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);
},
onPublicError: function(ev, errorObj) {
///
Event handler for when a tree node fails an ajax call
this._debug("onPublicError");
var errorNode = this._actionNode.jsNode;
// reload parent
this.reloadActionNode(false, true, null);
if (this._isDebug) {
alert('There was an error processing the request\n' +
'=========================================\n\n' +
'Error Message:\n ' +
errorObj.get_message() + '\n\n' +
'Technical information:\n ' +
'=========================================\n\n' +
'Status Code: ' + errorObj.get_statusCode() + '\n\n' +
'Exception Type: ' + errorObj.get_exceptionType() + '\n\n' +
'Timed Out: ' + errorObj.get_timedOut() + '\n\n' +
'Full Stacktrace:\n' + errorObj.get_stackTrace());
} else {
this._opts.appActions.showSpeachBubble("error", "Error handling action", errorObj.get_message());
}
},
_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, supressChildReload, newId) {
///
/// 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 parameter is only used when we don't have a real unique ID for a node, for example for a file. If a filename changes we don't know what the new one is since we are syncing the tree to the old original path. Once we retrieve the results the sync the tree we need to find the result by it's new id and update the node.
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);
//we need to change the id if the newId parameter is set
if (newId) {
this._actionNode.nodeId = newId;
}
if (supressChildReload === undefined) {
this.reloadActionNode(false, true, null);
} else {
this.reloadActionNode(false, supressChildReload, 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);