au.js

ZK 基础介绍 功能操作 模块 结合数据库操作

/* au.js

{{IS_NOTE
	Purpose:
		JavaScript for asynchronous updates
	Description:
		
	History:
		Fri Jun 10 15:04:31     2005, Created by tomyeh
}}IS_NOTE

Copyright (C) 2005 Potix Corporation. All Rights Reserved.

{{IS_RIGHT
	This program is distributed under GPL Version 2.0 in the hope that
	it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
if (!window.zkau) { //avoid eval twice
////
//Customization
/** Returns the background color for a list item or tree item.
 * Developer can override this method by providing a different background.
 */
if (!window.Droppable_effect) { //define it only if not customized
	window.Droppable_effect = function (e, undo) {
		if (undo)
			zk.restoreStyle(e, "backgroundColor");
		else {
			zk.backupStyle(e, "backgroundColor");
			e.style.backgroundColor = "#B8B8C0";
		}
	};
}

zkau = {};

zkau._reqs = []; //Ajax requests
zkau._respQue = []; //responses in XML
zkau._evts = {}; //(dtid, Array())
zkau._js4resps = []; //JS to eval upon response
zkau._metas = {}; //(id, meta)
zkau._drags = {}; //(id, Draggable): draggables
zkau._drops = []; //dropables
zkau._zidsp = {}; //ID spaces: {owner's uuid, {id, uuid}}
zkau._stamp = 0; //used to make a time stamp
zkau.topZIndex = 12; //topmost z-index for overlap/popup/modal
zkau.floats = []; //popup of combobox, bandbox, datebox...
zkau._onsends = []; //JS called before zkau._sendNow
zkau._seqId = 0; //starting at 0 - the same as Desktop.getResponseSequence
zkau._dtids = []; //an array of desktop IDs
zkau._spushInfo = {} //the server-push info: Map(dtid, {min, max, factor})

/** Adds a desktop. */
zkau.addDesktop = function (dtid) {
	var ds = zkau._dtids;
	for (var j = ds.length; --j >= 0;)
		if (ds[j] == dtid)
			return; //nothing to do
	ds.push(dtid);
};
/** Returns the desktop's ID.
 * @param {String or Element} n the component to look for its desktop ID.
 * @since 3.0.0
 */
zkau.dtid = function (n) {
	if (zkau._dtids.length == 1) return zkau._dtids[0];

	for (n = $e(n); n; n = $parent(n)) {
		var id = getZKAttr(n, "dtid");
		if (id) return id;
	}
	return null;
}

zk.addInit(function () {
	zk.listen(document, "keydown", zkau._onDocKeydown);
	zk.listen(document, "mousedown", zkau._onDocMousedown);
	zk.listen(document, "mouseover", zkau._onDocMouseover);
	zk.listen(document, "mouseout", zkau._onDocMouseout);

	zk.listen(document, "contextmenu", zkau._onDocCtxMnu);
	zk.listen(document, "click", zkau._onDocLClick);
	zk.listen(document, "dblclick", zkau._onDocDClick);

	zk.listen(window, "resize", zkau._onResize);

	zkau._oldUnload = window.onunload;
	window.onunload = zkau._onUnload; //unable to use zk.listen

	zkau._oldBfUnload = window.onbeforeunload;
	window.onbeforeunload = zkau._onBfUnload;
});

/** Handles onclick for button-type.
 */
zkau.onclick = function (evt) {
	if (typeof evt == 'string') {
		zkau.send({uuid: $uuid(evt), cmd: "onClick", data: null, ctl: true});
		return;
	}

	if (!evt) evt = window.event;
	var target = Event.element(evt);

	//it might be clicked on the inside element
	for (;; target = $parent(target))
		if (!target) return;
		else if (target.id) break;

	var href = getZKAttr(target, "href");
	if (href) {
		zk.go(href, false, getZKAttr(target, "target"));
		Event.stop(evt); //prevent _onDocLClick
		return; //done
	}

	zkau.send({uuid: $uuid(target.id),
		cmd: "onClick", data: zkau._getMouseData(evt, target), ctl: true});
	//Don't stop event so popup will work (bug 1734801)
};
/** Handles ondblclick for button (for non-FF).
 * Note: double clicks are handled by zkau._onDocDClick, but
 * some tags (button and checkbox) eat the event, so _onDocDClick won't
 * get the event.
 */
zkau.ondblclick = function (evt) {
	if (!evt) evt = window.event;
	var cmp = Event.element(evt);

	//it might be clicked on the inside element
	for (;; cmp = $parent(cmp))
		if (!cmp) return;
		else if (cmp.id) break;

	cmp = $outer(cmp);
	if (cmp && getZKAttr(cmp, "dbclk")) {
		zkau.send({uuid: cmp.id,
			cmd: "onDoubleClick", data: zkau._getMouseData(evt, cmp), ctl: true});
		Event.stop(evt); //just in case: prevent _onDocDClick to run again
		return false;
	}
};

/** Returns the data for onClick. */
zkau._getMouseData = function (evt, target) {
	var extra = "";
	if (evt.altKey) extra += "a";
	if (evt.ctrlKey) extra += "c";
	if (evt.shiftKey) extra += "s";

	var ofs = Position.cumulativeOffset(target);
	var x = Event.pointerX(evt) - ofs[0];
	var y = Event.pointerY(evt) - ofs[1];
	return [x, y, extra];
};

/** Asks the server to update a component (for file uploading). */
zkau.sendUpdateResult = function (uuid, updatableId) {
	zkau.send({uuid: uuid, cmd: "updateResult", data: [updatableId]}, -1);
}
/** Asks the server to remove a component. */
zkau.sendRemove = function (uuid) {
	if (!uuid) {
		zk.error(mesg.UUID_REQUIRED);
		return;
	}
	zkau.send({uuid: uuid, cmd: "remove", data: null}, 5);
};

/** Called when the response is received from zkau._reqs.
 */
zkau._onRespReady = function () {
	var que = zkau._respQue;
	while (zkau._reqs.length) {
		var req = zkau._reqs.shift();
		try {
			if (req.readyState != 4) {
				zkau._reqs.unshift(req);
				break; //we handle response sequentially
			}

			if (zk.pfmeter) zkau._pfrecv(req);

			if (zkau._revertpending) zkau._revertpending();
				//revert any pending when the first response is received

			if (req.status == 200) {
				var sid = req.responseXML.getElementsByTagName("sid");
				if (sid && sid.length) {
					sid = $int(zk.getElementValue(sid[0]));
					if (isNaN(sid) || sid < 0 || sid > 1024) sid = null; //ignore if error sid
				} else
					sid = null;

				//locate whether to insert the response by use of sid
				var ofs = que.length;
				if (sid != null)
					while (ofs > 0 && que[ofs - 1].sid != null
					&& zkau.cmprsid(sid, que[ofs - 1].sid) < 0)
						--ofs;

				var resp = {sid: sid, cmds: zkau._parseCmds(req.responseXML)};
				if (ofs == que.length) que.push(resp);
				else que.splice(ofs, 0, resp); //insert
			} else {
				var eru = zk.eru['e' + req.status];
				if (typeof eru == "string") {
					zk.go(eru);
				} else {
					if (!zkau._ignorable && !zkau._unloading)
						zk.error(mesg.FAILED_TO_RESPONSE+req.status+": "+(req.statusText!="Unknown"?req.statusText:""));
					zkau._cleanupOnFatal(zkau._ignorable);
				}
			}
		} catch (e) {
			//NOTE: if connection is off and req.status is accessed,
			//Mozilla throws exception while IE returns a value
			if (!zkau._ignorable && !zkau._unloading) {
				var msg = e.message;
				zk.error(mesg.FAILED_TO_RESPONSE+(msg.indexOf("NOT_AVAILABLE")<0?msg:""));
			}
			zkau._cleanupOnFatal(zkau._ignorable);
		}
	}

	zkau._doQueResps();
	zkau._checkProgress();
};
zkau._parseCmds = function (xml) {
	var rs = xml.getElementsByTagName("r")
	if (!rs) return null;

	var cmds = [];
	for (var j = 0; j < rs.length; ++j) {
		var cmd = rs[j].getElementsByTagName("c")[0];
		var data = rs[j].getElementsByTagName("d");

		if (!cmd) {
			zk.error(mesg.ILLEGAL_RESPONSE+"Command required");
			continue;
		}

		cmds.push(cmd = {cmd: zk.getElementValue(cmd)});

		switch (cmd.datanum = data ? data.length: 0) {
		default: //5 or more
			cmd.dt4 = zk.getElementValue(data[4]);
		case 4:
			cmd.dt3 = zk.getElementValue(data[3]);
		case 3:
			cmd.dt2 = zk.getElementValue(data[2]);
		case 2:
			cmd.dt1 = zk.getElementValue(data[1]);
		case 1:
			cmd.dt0 = zk.getElementValue(data[0]);
		case 0:
		}
	}
	return cmds;
};
/** Returns 1 if a > b, -1 if a < b, or 0 if a == b.
 * Note: range of sid is 0 ~ 1023.
 */
zkau.cmprsid = function (a, b) {
	var dt = a - b;
	return dt == 0 ? 0: (dt > 0 && dt < 512) || dt < -512 ? 1: -1
};
/** Checks whether to turn off the progress prompt.
 * @return true if the processing is done
 */
zkau._checkProgress = function () {
	if (zkau.processing())
		return false;
	zk.progressDone();
	return true;
};
/** Returns whether any request is in processing.
 * @since 3.0.0
 */
zkau.processing = function () {
	return zkau._respQue.length || zkau._reqs.length;
};

/** Returns the timeout of the specified event.
 * It is mainly used to generate the timeout argument of zkau.send.
 *
 * @param timeout if non-negative, it is used when zkau.asap is true.
 */
zkau.asapTimeout = function (cmp, evtnm, timeout) {
	return zkau.asap(cmp, evtnm) ? timeout >= 0 ? timeout: 38: -1;
};
/** Returns whether any non-deferrable listener is registered for
 * the specified event.
 */
zkau.asap = function (cmp, evtnm) {
	return getZKAttr($e(cmp), evtnm) == "true" ;
};

/** Returns the event list of the specified desktop ID.
 */
zkau._events = function (dtid) {
	var es = zkau._evts;
	if (!es[dtid])
		es[dtid] = [];
	return es[dtid];
};

/** Adds a callback to be called before sending ZK request.
 * @param func the function call
 */
zkau.addOnSend = function (func) {
	zkau._onsends.push(func);
};
zkau.removeOnSend = function (func) {
	zkau._onsends.remove(func);
};
/** Returns an array of queued events.
 * @since 3.0.0
 */
zkau.events = function (uuid) {
	return zkau._events(zkau.dtid(uuid));
};
/** Sends a request to the client and queue it to zkau._reqs.
 * @param timout milliseconds.
 * If negative, it won't be sent until next non-negative event
 */
zkau.send = function (evt, timeout) {
	if (timeout < 0) evt.implicit = true;

	if (evt.uuid) {
		zkau._send(zkau.dtid(evt.uuid), evt, timeout);
	} else if (evt.dtid) {
		zkau._send(evt.dtid, evt, timeout);
	} else {
		var ds = zkau._dtids;
		for (var j = 0; j < ds.length; ++j)
			zkau._send(ds[j], evt, timeout);
	}
};
zkau._send = function (dtid, evt, timeout) {
	if (evt.ctl) {
		var t = $now();
		if (zkau._ctl == evt.uuid && t - zkau._ctlt < 450
		&& (evt.cmd != "onDoubleClick" || zkau._ctlc != "onClick")) //Bug 1797140
			return; //to prevent key stroke are pressed twice (quickly)

		zkau._ctlt = t;
		zkau._ctl = evt.uuid;
		zkau._ctlc = evt.cmd;
	}

	zkau._events(dtid).push(evt);

	if (!timeout) timeout = 0; //we don't send immediately (Bug 1593674)
	if (timeout >= 0) setTimeout("zkau._sendNow('"+dtid+"')", timeout);
};
/** Sends a request before any pending events.
 * Note: it doesn't cause any pending events (including evt) to be sent.
 * It is designed to be called in zkau.onSend
 */
zkau.sendAhead = function (evt) {
	if (evt.uuid) {
		zkau._events(zkau.dtid(evt.uuid)).unshift(evt);
	} else if (evt.dtid) {
		zkau._events(evt.dtid).unshift(evt);
	} else {
		var ds = zkau._dtids;
		for (var j = ds.length; --j >= 0; ++j)
			zkau._events(ds[j]).unshift(evt);
	}
};
zkau._sendNow = function (dtid) {
	var es = zkau._events(dtid);
	if (es.length == 0)
		return; //nothing to do

	if (zk.loading) {
		zk.addInit(function () {zkau._sendNow(dtid);});
		return; //wait
	}

	if (!zk_action) {
		zk.error(mesg.NOT_FOUND+"zk_action");
		return;
	}

	//bug 1721809: we cannot filter out ctl even if zkau.processing

	//decide implicit and ignorable
	var implicit = true, ignorable = true;
	for (var j = es.length; --j >= 0;) {
		if (!es[j].ignorable) { //ignorable implies implicit
			ignorable = false;
			if (!es[j].implicit) {
				implicit = false;
				break;
			}
		}
	}

	//callback (fckez uses it to ensure its value is sent back correctly
	for (var j = 0; j < zkau._onsends.length; ++j) {
		try {
			zkau._onsends[j](implicit); //it might add more events
		} catch (e) {
			zk.error(e.message);
		}
	}

	//FUTURE: Consider XML (Pros: ?, Cons: larger packet)
	var content = "";
	for (var j = 0; es.length; ++j) {
		var evt = es.shift();
		content += "&cmd."+j+"="+evt.cmd+"&uuid."+j+"="+(evt.uuid?evt.uuid:'');
		if (evt.data)
			for (var k = 0; k < evt.data.length; ++k) {
				var data = evt.data[k];
				content += "&data."+j+"="
					+ (data != null ? encodeURIComponent(data): 'zk_null~q');
			}
	}

	if (!content) return; //nothing to do

	content = "dtid=" + dtid + content;
	var req;
	if (window.ActiveXObject) { //IE
		req = new ActiveXObject("Microsoft.XMLHTTP");
	} else if (window.XMLHttpRequest) { //None-IE
		req = new XMLHttpRequest();
	}

	zkau.sentTime = $now();
	var msg;
	if (req) {
		try {
			zkau._ignorable = ignorable && (zkau._ignorable || !zkau._reqs.length);

			zkau._reqs.push(req);
			req.onreadystatechange = zkau._onRespReady;

			req.open("POST", zk_action, true);
			req.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
			if (zk.pfmeter) zkau._pfsend(req, dtid);
			req.send(content);

			if (!implicit) zk.progress(zk_procto); //wait a moment to avoid annoying
			return; //success
		} catch (e) {
			try {
				if(typeof req.abort == "function") req.abort();
			} catch (e2) {
			}
			msg = e.message;
		}
	}
	if (!ignorable && !zkau._unloading)
		zk.error(mesg.FAILED_TO_SEND+zk_action+"\n"+content+(msg?"\n"+msg:""));
	zkau._cleanupOnFatal(ignorable);
};

/** Adds a script that will be evaluated when the next response is back. */
zkau.addOnResponse = function (script) {
	zkau._js4resps.push(script);
};
/** Evaluates scripts registered by addOnResponse. */
zkau._evalOnResponse = function () {
	while (zkau._js4resps.length)
		setTimeout(zkau._js4resps.shift(), 0);
};

/** Process the responses queued in zkau._respQue. */
zkau._doQueResps = function () {
	var ex;
	var que = zkau._respQue;
	for (var j = 0; que.length;) {
		if (zk.loading) {
			zk.addInit(zkau._doQueResps); //Note: when callback, zk.loading is false
			break; //wait until the loading is done
		}

		try {
			var oldSeqId = zkau._seqId;
			var resp = que.shift();
			if (resp.sid == zkau._seqId || resp.sid == null
			|| zkau._dtids.length > 1) { //unable to support seqId if multi-desktop
				//we have to inc seqId first since _doResps might throw exception
				if (resp.sid != null && ++zkau._seqId == 1024)
					zkau._seqId = 0;

				if (!zkau._doResps(resp.cmds)) {
					que.unshift(resp); //handle it later
					zkau._seqId = oldSeqId; //restore seqId
				}
			} else {
				que.unshift(resp); //undo

				setTimeout(function () {
					if (que.length && zkau._seqId == oldSeqId) { //no new processed
						zkau._seqId = que[0].sid;