Subversion Repositories Applications.papyrus

Rev

Rev 1372 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1372 Rev 1422
1 
/*
 1 
/*
2 
	Copyright (c) 2004-2006, The Dojo Foundation
 2 
	Copyright (c) 2004-2006, The Dojo Foundation
3 
	All Rights Reserved.
 3 
	All Rights Reserved.
4 
 
 4 
 
5 
	Licensed under the Academic Free License version 2.1 or above OR the
 5 
	Licensed under the Academic Free License version 2.1 or above OR the
6 
	modified BSD license. For more information on Dojo licensing, see:
 6 
	modified BSD license. For more information on Dojo licensing, see:
7 
 
 7 
 
8 
		http://dojotoolkit.org/community/licensing.shtml
 8 
		http://dojotoolkit.org/community/licensing.shtml
9 
*/
 9 
*/
- 
 
 10 
 
- 
 
 11 
 
10 
 
 12 
 
11 
dojo.provide("dojo.widget.TreeLoadingControllerV3");
 13 
dojo.provide("dojo.widget.TreeLoadingControllerV3");
12 
dojo.require("dojo.widget.TreeBasicControllerV3");
 14 
dojo.require("dojo.widget.TreeBasicControllerV3");
13 
dojo.require("dojo.event.*");
 15 
dojo.require("dojo.event.*");
14 
dojo.require("dojo.json");
 16 
dojo.require("dojo.json");
15 
dojo.require("dojo.io.*");
 17 
dojo.require("dojo.io.*");
16 
dojo.require("dojo.Deferred");
 18 
dojo.require("dojo.Deferred");
17 
dojo.require("dojo.DeferredList");
 19 
dojo.require("dojo.DeferredList");
18 
dojo.declare("dojo.Error", Error, function (message, extra) {
 20 
dojo.declare("dojo.Error", Error, function (message, extra) {
19 
	this.message = message;
 21 
	this.message = message;
20 
	this.extra = extra;
 22 
	this.extra = extra;
21 
	this.stack = (new Error()).stack;
 23 
	this.stack = (new Error()).stack;
22 
});
 24 
});
23 
dojo.declare("dojo.CommunicationError", dojo.Error, function () {
 25 
dojo.declare("dojo.CommunicationError", dojo.Error, function () {
24 
	this.name = "CommunicationError";
 26 
	this.name = "CommunicationError";
25 
});
 27 
});
26 
dojo.declare("dojo.LockedError", dojo.Error, function () {
 28 
dojo.declare("dojo.LockedError", dojo.Error, function () {
27 
	this.name = "LockedError";
 29 
	this.name = "LockedError";
28 
});
 30 
});
29 
dojo.declare("dojo.FormatError", dojo.Error, function () {
 31 
dojo.declare("dojo.FormatError", dojo.Error, function () {
30 
	this.name = "FormatError";
 32 
	this.name = "FormatError";
31 
});
 33 
});
32 
dojo.declare("dojo.RpcError", dojo.Error, function () {
 34 
dojo.declare("dojo.RpcError", dojo.Error, function () {
33 
	this.name = "RpcError";
 35 
	this.name = "RpcError";
34 
});
 36 
});
35 
dojo.widget.defineWidget("dojo.widget.TreeLoadingControllerV3", dojo.widget.TreeBasicControllerV3, {RpcUrl:"", RpcActionParam:"action", preventCache:true, checkValidRpcResponse:function (type, obj) {
 37 
dojo.widget.defineWidget("dojo.widget.TreeLoadingControllerV3", dojo.widget.TreeBasicControllerV3, {RpcUrl:"", RpcActionParam:"action", preventCache:true, checkValidRpcResponse:function (type, obj) {
36 
	if (type != "load") {
 38 
	if (type != "load") {
37 
		var extra = {};
 39 
		var extra = {};
38 
		for (var i = 1; i < arguments.length; i++) {
 40 
		for (var i = 1; i < arguments.length; i++) {
39 
			dojo.lang.mixin(extra, arguments[i]);
 41 
			dojo.lang.mixin(extra, arguments[i]);
40 
		}
 42 
		}
41 
		return new dojo.CommunicationError(obj, extra);
 43 
		return new dojo.CommunicationError(obj, extra);
42 
	}
 44 
	}
43 
	if (typeof obj != "object") {
 45 
	if (typeof obj != "object") {
44 
		return new dojo.FormatError("Wrong server answer format " + (obj && obj.toSource ? obj.toSource() : obj) + " type " + (typeof obj), obj);
 46 
		return new dojo.FormatError("Wrong server answer format " + (obj && obj.toSource ? obj.toSource() : obj) + " type " + (typeof obj), obj);
45 
	}
 47 
	}
46 
	if (!dojo.lang.isUndefined(obj.error)) {
 48 
	if (!dojo.lang.isUndefined(obj.error)) {
47 
		return new dojo.RpcError(obj.error, obj);
 49 
		return new dojo.RpcError(obj.error, obj);
48 
	}
 50 
	}
49 
	return false;
 51 
	return false;
50 
}, getDeferredBindHandler:function (deferred) {
 52 
}, getDeferredBindHandler:function (deferred) {
51 
	return dojo.lang.hitch(this, function (type, obj) {
 53 
	return dojo.lang.hitch(this, function (type, obj) {
52 
		var error = this.checkValidRpcResponse.apply(this, arguments);
 54 
		var error = this.checkValidRpcResponse.apply(this, arguments);
53 
		if (error) {
 55 
		if (error) {
54 
			deferred.errback(error);
 56 
			deferred.errback(error);
55 
			return;
 57 
			return;
56 
		}
 58 
		}
57 
		deferred.callback(obj);
 59 
		deferred.callback(obj);
58 
	});
 60 
	});
59 
}, getRpcUrl:function (action) {
 61 
}, getRpcUrl:function (action) {
60 
	if (this.RpcUrl == "local") {
 62 
	if (this.RpcUrl == "local") {
61 
		var dir = document.location.href.substr(0, document.location.href.lastIndexOf("/"));
 63 
		var dir = document.location.href.substr(0, document.location.href.lastIndexOf("/"));
62 
		var localUrl = dir + "/local/" + action;
 64 
		var localUrl = dir + "/local/" + action;
63 
		return localUrl;
 65 
		return localUrl;
64 
	}
 66 
	}
65 
	if (!this.RpcUrl) {
 67 
	if (!this.RpcUrl) {
66 
		dojo.raise("Empty RpcUrl: can't load");
 68 
		dojo.raise("Empty RpcUrl: can't load");
67 
	}
 69 
	}
68 
	var url = this.RpcUrl;
 70 
	var url = this.RpcUrl;
69 
	if (url.indexOf("/") != 0) {
 71 
	if (url.indexOf("/") != 0) {
70 
		var protocol = document.location.href.replace(/:\/\/.*/, "");
 72 
		var protocol = document.location.href.replace(/:\/\/.*/, "");
71 
		var prefix = document.location.href.substring(protocol.length + 3);
 73 
		var prefix = document.location.href.substring(protocol.length + 3);
72 
		if (prefix.lastIndexOf("/") != prefix.length - 1) {
 74 
		if (prefix.lastIndexOf("/") != prefix.length - 1) {
73 
			prefix = prefix.replace(/\/[^\/]+$/, "/");
 75 
			prefix = prefix.replace(/\/[^\/]+$/, "/");
74 
		}
 76 
		}
75 
		if (prefix.lastIndexOf("/") != prefix.length - 1) {
 77 
		if (prefix.lastIndexOf("/") != prefix.length - 1) {
76 
			prefix = prefix + "/";
 78 
			prefix = prefix + "/";
77 
		}
 79 
		}
78 
		url = protocol + "://" + prefix + url;
 80 
		url = protocol + "://" + prefix + url;
79 
	}
 81 
	}
80 
	return url + (url.indexOf("?") > -1 ? "&" : "?") + this.RpcActionParam + "=" + action;
 82 
	return url + (url.indexOf("?") > -1 ? "&" : "?") + this.RpcActionParam + "=" + action;
81 
}, loadProcessResponse:function (node, result) {
 83 
}, loadProcessResponse:function (node, result) {
82 
	if (!dojo.lang.isArray(result)) {
 84 
	if (!dojo.lang.isArray(result)) {
83 
		throw new dojo.FormatError("loadProcessResponse: Not array loaded: " + result);
 85 
		throw new dojo.FormatError("loadProcessResponse: Not array loaded: " + result);
84 
	}
 86 
	}
85 
	node.setChildren(result);
 87 
	node.setChildren(result);
86 
}, runRpc:function (kw) {
 88 
}, runRpc:function (kw) {
87 
	var _this = this;
 89 
	var _this = this;
88 
	var deferred = new dojo.Deferred();
 90 
	var deferred = new dojo.Deferred();
89 
	dojo.io.bind({url:kw.url, handle:this.getDeferredBindHandler(deferred), mimetype:"text/javascript", preventCache:this.preventCache, sync:kw.sync, content:{data:dojo.json.serialize(kw.params)}});
 91 
	dojo.io.bind({url:kw.url, handle:this.getDeferredBindHandler(deferred), mimetype:"text/javascript", preventCache:this.preventCache, sync:kw.sync, content:{data:dojo.json.serialize(kw.params)}});
90 
	return deferred;
 92 
	return deferred;
91 
}, loadRemote:function (node, sync) {
 93 
}, loadRemote:function (node, sync) {
92 
	var _this = this;
 94 
	var _this = this;
93 
	var params = {node:this.getInfo(node), tree:this.getInfo(node.tree)};
 95 
	var params = {node:this.getInfo(node), tree:this.getInfo(node.tree)};
94 
	var deferred = this.runRpc({url:this.getRpcUrl("getChildren"), sync:sync, params:params});
 96 
	var deferred = this.runRpc({url:this.getRpcUrl("getChildren"), sync:sync, params:params});
95 
	deferred.addCallback(function (res) {
 97 
	deferred.addCallback(function (res) {
96 
		return _this.loadProcessResponse(node, res);
 98 
		return _this.loadProcessResponse(node, res);
97 
	});
 99 
	});
98 
	return deferred;
 100 
	return deferred;
99 
}, batchExpandTimeout:0, recurseToLevel:function (widget, level, callFunc, callObj, skipFirst, sync) {
 101 
}, batchExpandTimeout:0, recurseToLevel:function (widget, level, callFunc, callObj, skipFirst, sync) {
100 
	if (level == 0) {
 102 
	if (level == 0) {
101 
		return;
 103 
		return;
102 
	}
 104 
	}
103 
	if (!skipFirst) {
 105 
	if (!skipFirst) {
104 
		var deferred = callFunc.call(callObj, widget, sync);
 106 
		var deferred = callFunc.call(callObj, widget, sync);
105 
	} else {
 107 
	} else {
106 
		var deferred = dojo.Deferred.prototype.makeCalled();
 108 
		var deferred = dojo.Deferred.prototype.makeCalled();
107 
	}
 109 
	}
108 
	var _this = this;
 110 
	var _this = this;
109 
	var recurseOnExpand = function () {
 111 
	var recurseOnExpand = function () {
110 
		var children = widget.children;
 112 
		var children = widget.children;
111 
		var deferreds = [];
 113 
		var deferreds = [];
112 
		for (var i = 0; i < children.length; i++) {
 114 
		for (var i = 0; i < children.length; i++) {
113 
			deferreds.push(_this.recurseToLevel(children[i], level - 1, callFunc, callObj, sync));
 115 
			deferreds.push(_this.recurseToLevel(children[i], level - 1, callFunc, callObj, sync));
114 
		}
 116 
		}
115 
		return new dojo.DeferredList(deferreds);
 117 
		return new dojo.DeferredList(deferreds);
116 
	};
 118 
	};
117 
	deferred.addCallback(recurseOnExpand);
 119 
	deferred.addCallback(recurseOnExpand);
118 
	return deferred;
 120 
	return deferred;
119 
}, expandToLevel:function (nodeOrTree, level, sync) {
 121 
}, expandToLevel:function (nodeOrTree, level, sync) {
120 
	return this.recurseToLevel(nodeOrTree, nodeOrTree.isTree ? level + 1 : level, this.expand, this, nodeOrTree.isTree, sync);
 122 
	return this.recurseToLevel(nodeOrTree, nodeOrTree.isTree ? level + 1 : level, this.expand, this, nodeOrTree.isTree, sync);
121 
}, loadToLevel:function (nodeOrTree, level, sync) {
 123 
}, loadToLevel:function (nodeOrTree, level, sync) {
122 
	return this.recurseToLevel(nodeOrTree, nodeOrTree.isTree ? level + 1 : level, this.loadIfNeeded, this, nodeOrTree.isTree, sync);
 124 
	return this.recurseToLevel(nodeOrTree, nodeOrTree.isTree ? level + 1 : level, this.loadIfNeeded, this, nodeOrTree.isTree, sync);
123 
}, loadAll:function (nodeOrTree, sync) {
 125 
}, loadAll:function (nodeOrTree, sync) {
124 
	return this.loadToLevel(nodeOrTree, Number.POSITIVE_INFINITY, sync);
 126 
	return this.loadToLevel(nodeOrTree, Number.POSITIVE_INFINITY, sync);
125 
}, expand:function (node, sync) {
 127 
}, expand:function (node, sync) {
126 
	var _this = this;
 128 
	var _this = this;
127 
	var deferred = this.startProcessing(node);
 129 
	var deferred = this.startProcessing(node);
128 
	deferred.addCallback(function () {
 130 
	deferred.addCallback(function () {
129 
		return _this.loadIfNeeded(node, sync);
 131 
		return _this.loadIfNeeded(node, sync);
130 
	});
 132 
	});
131 
	deferred.addCallback(function (res) {
 133 
	deferred.addCallback(function (res) {
132 
		dojo.widget.TreeBasicControllerV3.prototype.expand(node);
 134 
		dojo.widget.TreeBasicControllerV3.prototype.expand(node);
133 
		return res;
 135 
		return res;
134 
	});
 136 
	});
135 
	deferred.addBoth(function (res) {
 137 
	deferred.addBoth(function (res) {
136 
		_this.finishProcessing(node);
 138 
		_this.finishProcessing(node);
137 
		return res;
 139 
		return res;
138 
	});
 140 
	});
139 
	return deferred;
 141 
	return deferred;
140 
}, loadIfNeeded:function (node, sync) {
 142 
}, loadIfNeeded:function (node, sync) {
141 
	var deferred;
 143 
	var deferred;
142 
	if (node.state == node.loadStates.UNCHECKED && node.isFolder && !node.children.length) {
 144 
	if (node.state == node.loadStates.UNCHECKED && node.isFolder && !node.children.length) {
143 
		deferred = this.loadRemote(node, sync);
 145 
		deferred = this.loadRemote(node, sync);
144 
	} else {
 146 
	} else {
145 
		deferred = new dojo.Deferred();
 147 
		deferred = new dojo.Deferred();
146 
		deferred.callback();
 148 
		deferred.callback();
147 
	}
 149 
	}
148 
	return deferred;
 150 
	return deferred;
149 
}, runStages:function (check, prepare, make, finalize, expose, args) {
 151 
}, runStages:function (check, prepare, make, finalize, expose, args) {
150 
	var _this = this;
 152 
	var _this = this;
151 
	if (check && !check.apply(this, args)) {
 153 
	if (check && !check.apply(this, args)) {
152 
		return false;
 154 
		return false;
153 
	}
 155 
	}
154 
	var deferred = dojo.Deferred.prototype.makeCalled();
 156 
	var deferred = dojo.Deferred.prototype.makeCalled();
155 
	if (prepare) {
 157 
	if (prepare) {
156 
		deferred.addCallback(function () {
 158 
		deferred.addCallback(function () {
157 
			return prepare.apply(_this, args);
 159 
			return prepare.apply(_this, args);
158 
		});
 160 
		});
159 
	}
 161 
	}
160 
	if (make) {
 162 
	if (make) {
161 
		deferred.addCallback(function () {
 163 
		deferred.addCallback(function () {
162 
			var res = make.apply(_this, args);
 164 
			var res = make.apply(_this, args);
163 
			return res;
 165 
			return res;
164 
		});
 166 
		});
165 
	}
 167 
	}
166 
	if (finalize) {
 168 
	if (finalize) {
167 
		deferred.addBoth(function (res) {
 169 
		deferred.addBoth(function (res) {
168 
			finalize.apply(_this, args);
 170 
			finalize.apply(_this, args);
169 
			return res;
 171 
			return res;
170 
		});
 172 
		});
171 
	}
 173 
	}
172 
	if (expose) {
 174 
	if (expose) {
173 
		deferred.addCallback(function (res) {
 175 
		deferred.addCallback(function (res) {
174 
			expose.apply(_this, args);
 176 
			expose.apply(_this, args);
175 
			return res;
 177 
			return res;
176 
		});
 178 
		});
177 
	}
 179 
	}
178 
	return deferred;
 180 
	return deferred;
179 
}, startProcessing:function (nodesArray) {
 181 
}, startProcessing:function (nodesArray) {
180 
	var deferred = new dojo.Deferred();
 182 
	var deferred = new dojo.Deferred();
181 
	var nodes = dojo.lang.isArray(nodesArray) ? nodesArray : arguments;
 183 
	var nodes = dojo.lang.isArray(nodesArray) ? nodesArray : arguments;
182 
	for (var i = 0; i < nodes.length; i++) {
 184 
	for (var i = 0; i < nodes.length; i++) {
183 
		if (nodes[i].isLocked()) {
 185 
		if (nodes[i].isLocked()) {
184 
			deferred.errback(new dojo.LockedError("item locked " + nodes[i], nodes[i]));
 186 
			deferred.errback(new dojo.LockedError("item locked " + nodes[i], nodes[i]));
185 
			return deferred;
 187 
			return deferred;
186 
		}
 188 
		}
187 
		if (nodes[i].isTreeNode) {
 189 
		if (nodes[i].isTreeNode) {
188 
			nodes[i].markProcessing();
 190 
			nodes[i].markProcessing();
189 
		}
 191 
		}
190 
		nodes[i].lock();
 192 
		nodes[i].lock();
191 
	}
 193 
	}
192 
	deferred.callback();
 194 
	deferred.callback();
193 
	return deferred;
 195 
	return deferred;
194 
}, finishProcessing:function (nodesArray) {
 196 
}, finishProcessing:function (nodesArray) {
195 
	var nodes = dojo.lang.isArray(nodesArray) ? nodesArray : arguments;
 197 
	var nodes = dojo.lang.isArray(nodesArray) ? nodesArray : arguments;
196 
	for (var i = 0; i < nodes.length; i++) {
 198 
	for (var i = 0; i < nodes.length; i++) {
197 
		if (!nodes[i].hasLock()) {
 199 
		if (!nodes[i].hasLock()) {
198 
			continue;
 200 
			continue;
199 
		}
 201 
		}
200 
		nodes[i].unlock();
 202 
		nodes[i].unlock();
201 
		if (nodes[i].isTreeNode) {
 203 
		if (nodes[i].isTreeNode) {
202 
			nodes[i].unmarkProcessing();
 204 
			nodes[i].unmarkProcessing();
203 
		}
 205 
		}
204 
	}
 206 
	}
205 
}, refreshChildren:function (nodeOrTree, sync) {
 207 
}, refreshChildren:function (nodeOrTree, sync) {
206 
	return this.runStages(null, this.prepareRefreshChildren, this.doRefreshChildren, this.finalizeRefreshChildren, this.exposeRefreshChildren, arguments);
 208 
	return this.runStages(null, this.prepareRefreshChildren, this.doRefreshChildren, this.finalizeRefreshChildren, this.exposeRefreshChildren, arguments);
207 
}, prepareRefreshChildren:function (nodeOrTree, sync) {
 209 
}, prepareRefreshChildren:function (nodeOrTree, sync) {
208 
	var deferred = this.startProcessing(nodeOrTree);
 210 
	var deferred = this.startProcessing(nodeOrTree);
209 
	nodeOrTree.destroyChildren();
 211 
	nodeOrTree.destroyChildren();
210 
	nodeOrTree.state = nodeOrTree.loadStates.UNCHECKED;
 212 
	nodeOrTree.state = nodeOrTree.loadStates.UNCHECKED;
211 
	return deferred;
 213 
	return deferred;
212 
}, doRefreshChildren:function (nodeOrTree, sync) {
 214 
}, doRefreshChildren:function (nodeOrTree, sync) {
213 
	return this.loadRemote(nodeOrTree, sync);
 215 
	return this.loadRemote(nodeOrTree, sync);
214 
}, finalizeRefreshChildren:function (nodeOrTree, sync) {
 216 
}, finalizeRefreshChildren:function (nodeOrTree, sync) {
215 
	this.finishProcessing(nodeOrTree);
 217 
	this.finishProcessing(nodeOrTree);
216 
}, exposeRefreshChildren:function (nodeOrTree, sync) {
 218 
}, exposeRefreshChildren:function (nodeOrTree, sync) {
217 
	nodeOrTree.expand();
 219 
	nodeOrTree.expand();
218 
}, move:function (child, newParent, index) {
 220 
}, move:function (child, newParent, index) {
219 
	return this.runStages(this.canMove, this.prepareMove, this.doMove, this.finalizeMove, this.exposeMove, arguments);
 221 
	return this.runStages(this.canMove, this.prepareMove, this.doMove, this.finalizeMove, this.exposeMove, arguments);
220 
}, doMove:function (child, newParent, index) {
 222 
}, doMove:function (child, newParent, index) {
221 
	child.tree.move(child, newParent, index);
 223 
	child.tree.move(child, newParent, index);
222 
	return true;
 224 
	return true;
223 
}, prepareMove:function (child, newParent, index, sync) {
 225 
}, prepareMove:function (child, newParent, index, sync) {
224 
	var deferred = this.startProcessing(newParent);
 226 
	var deferred = this.startProcessing(newParent);
225 
	deferred.addCallback(dojo.lang.hitch(this, function () {
 227 
	deferred.addCallback(dojo.lang.hitch(this, function () {
226 
		return this.loadIfNeeded(newParent, sync);
 228 
		return this.loadIfNeeded(newParent, sync);
227 
	}));
 229 
	}));
228 
	return deferred;
 230 
	return deferred;
229 
}, finalizeMove:function (child, newParent) {
 231 
}, finalizeMove:function (child, newParent) {
230 
	this.finishProcessing(newParent);
 232 
	this.finishProcessing(newParent);
231 
}, prepareCreateChild:function (parent, index, data, sync) {
 233 
}, prepareCreateChild:function (parent, index, data, sync) {
232 
	var deferred = this.startProcessing(parent);
 234 
	var deferred = this.startProcessing(parent);
233 
	deferred.addCallback(dojo.lang.hitch(this, function () {
 235 
	deferred.addCallback(dojo.lang.hitch(this, function () {
234 
		return this.loadIfNeeded(parent, sync);
 236 
		return this.loadIfNeeded(parent, sync);
235 
	}));
 237 
	}));
236 
	return deferred;
 238 
	return deferred;
237 
}, finalizeCreateChild:function (parent) {
 239 
}, finalizeCreateChild:function (parent) {
238 
	this.finishProcessing(parent);
 240 
	this.finishProcessing(parent);
239 
}, prepareClone:function (child, newParent, index, deep, sync) {
 241 
}, prepareClone:function (child, newParent, index, deep, sync) {
240 
	var deferred = this.startProcessing(child, newParent);
 242 
	var deferred = this.startProcessing(child, newParent);
241 
	deferred.addCallback(dojo.lang.hitch(this, function () {
 243 
	deferred.addCallback(dojo.lang.hitch(this, function () {
242 
		return this.loadIfNeeded(newParent, sync);
 244 
		return this.loadIfNeeded(newParent, sync);
243 
	}));
 245 
	}));
244 
	return deferred;
 246 
	return deferred;
245 
}, finalizeClone:function (child, newParent) {
 247 
}, finalizeClone:function (child, newParent) {
246 
	this.finishProcessing(child, newParent);
 248 
	this.finishProcessing(child, newParent);
247 
}});
 249 
}});
248 
 
 250