var CustomXsl = [];
function AddCustomXsl(url) {
	CustomXsl.push(url);
}

var SKIP_MYSELF=true; // Magic constant for RefreshTabOrder and focusFirst
// Focus state
var FS_FOCUSED=true; // window manager is focused
var FS_NOTFOCUSED=false; // window manager is not focused

function ApplyInnerHTML(node, sHTML) {
	if(Prototype.Browser.IE) { // workaround innerHTML bug
		var child;
		while (child = node.firstChild) {
			node.removeChild(child);
		}
	}
	node.innerHTML = sHTML;
}

function ApplyTreeOrString(node, oSrc) {
	if (typeof(oSrc.documentElement) != 'undefined') { // document passed
		var srcNode = oSrc.documentElement;
		node.innerHTML=''; // clean target node (non-IE way, innerHTML is definitely safe here)
		if (!srcNode) return; // nothing to insert
		if (srcNode.localName == 'result') { // handle transformiix:result
			while (srcNode.childNodes.length) {
				// node will be unlinked from source document, so we will always append first child
				node.appendChild(srcNode.firstChild);
			}
		}
		else if (srcNode.nodeName == 'HTML') {
			var n;
			for (var i = 0; i < srcNode.childNodes.length; i++) {
				n = srcNode.childNodes[i];
				if (n.nodeName == 'BODY') break;
				n = null;
			}

			if (!n) return;
			node.innerHTML=n.innerHTML;
		}
		else {
			// transformation result is a single node
			node.appendChild(AdoptNode(node.ownerDocument, srcNode));
		}
	}
	else {
		ApplyInnerHTML(node, oSrc); // string
	}
}

// AWindow class
var AWindow = Class.create({
	initialize: function(oParams) {
		this.sParent_ = (oParams.sParent || ""); // parent.this()
		this.sLocalID_ = (oParams.sID || ""); // local name (in XML)
		this.sID_ = (oParams.sHTMLID || ""); // global name (in HTML)
		this.sendAllControls = oParams.SendAllControls;
		this.sInstanceID_ = (oParams.sInstanceID || ""); // identification
		this.sAction_ = (oParams.sInstanceID ? "Refresh" : "");
		this.bInline_ = oParams.bInline;

		// where to insert content (control ID)
		this.sControlID_ = (oParams.sControlID) ? oParams.sControlID : "";

		// Collection of controls
		this.oControls_ = {};
		this.aControls_ = [];

		this.oHandlers_ = {};

		// Collection of children instanceIDs
		this.oChildren = {};

		// Collection of label cells
		this.oLabelCells = {};
		GDocumentEventManager.AddTransparentControl(this.ClassName());

		//if(!sParent) this.nTabBase=1;
		//else this.nTabBase=-1;

		// widget contents initialization
		this.sValue = oParams.sValue;

		if (this.sParent_) {
			// bug was here (oParentWin was not initialized in some cases) // mvel@
			this.oParentWin = GWindowManager.GetWindow(this.sParent_);
		}

		// data
		if (!oParams.sParams) oParams.sParams = "";
		//if (oParams.sURL && oParams.sURL.indexOf('/ahtml/')) oParams.HTMLControls = [];
		if (oParams.HTMLControls) { // Server-side XSLT
			this.sXMLSource_ = oParams.sURL;
			this.sParams_ = "";
			this.NonXSLWindowInit(oParams.HTMLControls);
			return;
		}
		else if (oParams.sURL) {
			// we have real window
			var paramIdx=oParams.sURL.indexOf('?');
			if(paramIdx<0) {
				this.sXMLSource_=oParams.sURL;
				this.sParams_=oParams.sParams;
			}
			else {
				this.sXMLSource_=oParams.sURL.substr(0, paramIdx);
				this.sParams_=oParams.sURL.substr(paramIdx+1)+oParams.sParams;
			}
			this.oXML_ = null;
		} else if (oParams.oXML) {
			// XML was manually generated
			this.sParams_ = ""; // ignore all params
			this.sXMLSource_ = ""; // !!!
			this.oXML_ = oParams.oXML;
		} else {
			// Load empty window
			var node=$(this.sControlID_);
			if (!node) return; // window already died...
			if(node.JSControl && typeof(node.JSControl.Die)=="function") node.JSControl.Die();
			ApplyInnerHTML(node, "");
			delete node.JSControl;
			return;
		}

		if (this.sXMLSource_) {
			var url = this.sXMLSource_;
			if (url.indexOf('/srv/') == 0 && this.sInstanceID_) url = "/act/dynamic/";

			if (this.sAction_ || this.sInstanceID_) url += '/' + this.sAction_;
			if (this.sInstanceID_) url += '/' + this.sInstanceID_;

			new AjaxRequest("POST", url, this.sParams_, {
				onSuccess: this.LoadingCallback.bind(this),
				onException: this.ExceptionCallback.bind(this),
				timeout: oParams.timeout
			});
		} else {
			this.Load();
		}
	},
	ClassName: function() { return "AWindow"; },
	NonXSLWindowInit: function(controls) {
		for (var i = 0; i < controls.length; ++i) {
			var c = $(controls[i].id);
			this.oControls_[controls[i].id] = { node_: c };
			this.aControls_.push(c);
		}
		var n = $(this.sID_);
		n.JSControl = this;
		n.writeAttribute('instanceid', this.sInstanceID_);
		n.writeAttribute('localid', this.sLocalID_);
		n.writeAttribute('eleclass', 'wnd');

		GWindowManager.registerWindow(this.InstanceID(), this);
		if(this.oParentWin) this.oParentWin.oChildren[this.InstanceID()]=true;

		for (var i = 0; i < controls.length; ++i) {
			var id = controls[i].id;
			var n = $(id);
			if (!n) continue;

			var dh = n.readAttribute('defaulthandler');
			if (dh) AControl.AddDefaultHandler(dh, id);

			var sHandlers = n.getAttribute("handle");
			if (!sHandlers && controls[i].attributes && "handle" in controls[i].attributes) sHandlers = controls[i].attributes["handle"];
			if(sHandlers) {
				var aHandlers = sHandlers.split(' ');
				if (!this.oControls_[id]) this.oControls_[id] = new Object();

				var oCtrlInfo = this.oControls_[id];
				for (var j = 0; j < aHandlers.length; ++j) {
					var sEventName = aHandlers[j];
					if (!sEventName) continue;
					// put into control's map
					if (!oCtrlInfo.oHandlers_) oCtrlInfo.oHandlers_ = new Object();
					oCtrlInfo.oHandlers_[sEventName] = ET_REGULAR;
					// and into global map (to register handlers
					this.oHandlers_[sEventName] = true;
				}
			}
			var n = [];
			for (var a in controls[i].attributes) {
				n.push({name: a, value: controls[i].attributes[a]});
			}
			this.SetAttributes(id, {attributes: n});
		}
		this.InitDefaultSubscribers();

		for (var i = 0; i < controls.length; ++i) { //TODO: this can probably be reused
			var id = controls[i].id;
			var n = $(id);
			if (!n) continue;
			if (this.oControls_[id].dependsOn_) {
				this.Subscribe("INPUT", this.CheckDependencies.bind(this, id));
				this.Subscribe("CHANGE", this.CheckDependencies.bind(this, id));
				this.CheckDependencies(id);
			}
		}
	},
	InitDefaultSubscribers: function() {
		//LogL("CHANGE Subscribed on: ID="+this.ID());
		this.oHandlers_["CHANGE"]=true;
		for (var sKey in this.oHandlers_) {
			//LogL("GENERIC Subscribed on: "+sKey+", ID="+this.ID());
			this.Subscribe(sKey, this.ServerEventHandler, this);
		}
		this.Subscribe("CHANGE", this.OnControlChange, this);
		this.Subscribe("WM_INIT", this.OnControlChange, this);
		this.Subscribe("WM_RESTORE", this.OnRestore, this);
		this.Subscribe("WM_REFRESH", this.OnRefresh, this);
		this.Subscribe("INPUT", this.OnControlChange, this);

		this.Subscribe("WM_POPUP", this.OnWMPopup, this);
	},
	LoadingCallback: function(oAjaxRequest) {
		this.oXML_ = oAjaxRequest.XML();
		this.Load();
	},
	Load: function() {
		if (!this.oXML_.documentElement) {
			this.SetError("AWindow::Load(): XML loading failed: No document data! ");
			return;
		}
		this.sLocalID_ = this.oXML_.documentElement.getAttribute("id");
		this.sTitle_ = this.oXML_.documentElement.getAttribute("title");
		this.sInstanceID_ = this.oXML_.documentElement.getAttribute("this");

		GWindowManager.registerWindow(this.InstanceID(), this);
		if(this.oParentWin) this.oParentWin.oChildren[this.InstanceID()]=true;

		this.ProcessHTMLID();
//		alert(this.oXML_.xml);
		var oTransformDoc = GWindowManager.Transform(this.oXML_, true);
		this.InitDefaultSubscribers();
		GDocumentEventManager.Subscribe('KeyDown', this.ID()); // Shortcuts


		var ctlId = this.sControlID_;
		if (!this.sParent_) ctlId = GWindowManager.ID();

		var node = $(ctlId);
		if (!node) return; // window already died...

		if(node.JSControl && typeof(node.JSControl.Die)=="function") node.JSControl.Die();
		ApplyTreeOrString(node, oTransformDoc);
		this.HTML=node.select('div')[0];
		this.HTML.JSControl=this;
		node.JSControl=this;

		if (this.sParent_) this.registerInParentResizer();

		try {
			if(typeof(oTransformDoc)=="string") oTransformDoc.evalScripts(); // another IE bug workaroung
			else node.innerHTML.evalScripts();
		} catch (err) {
			LogL(typeof(oTransformDoc)=="string" ? oTransformDoc : node.innerHTML);
			throw err;
		}

		var oRoot = this.XML().documentElement;
		var aElements = AXML.SelectNodes(oRoot, "/ai:wnd/ai:ele|/ai:wnd/ai:ele/ai:ele", AINS);
		if (!aElements) {
			alert("DEBUG: Bad window! No elements found! XML:\r\n"+oRoot.xml);
			return;
		}

		this.orderEvents(oRoot);
		this.ProcessEvents(oRoot, "before");
		this.oShortcuts_={};
		for (var i = 0; i < aElements.length; ++i) {
			var oNode = aElements[i];
			var sID = oNode.getAttribute("id");
			var sHTMLID = oNode.getAttribute("htmlid");
			if (!sHTMLID) continue; // element is not referenced in layout

			var el = $(sHTMLID);
			if (el) {
				// this will not work on nested elements (!!!) ControlHTMLID gives wrong ID for nested elements
				var sControlID = this.ControlHTMLID(sID);
				if (!this.oControls_[sControlID]) this.oControls_[sControlID] = new Object();
				//LogL("Node registered: "+sControlID);
				this.oControls_[sControlID].node_ = el;

				var dependsOn=oNode.getAttribute("dependsOn");
				if (dependsOn!==null) { // attribute exists
					var d=dependsOn ? dependsOn.split(" ") : []; // split returns [''] on empty string
					for (var j=0; j < d.length; ++j) {
						d[j]=this.ControlHTMLID(d[j]);
					}
					// set dependsOn property for this control
					this.oControls_[sControlID].dependsOn_=d;
					this.Subscribe("INPUT", this.CheckDependencies.bind(this, sHTMLID));
					this.Subscribe("CHANGE", this.CheckDependencies.bind(this, sHTMLID));
				}
				
				var shortcut=oNode.getAttribute("shortcut");
				if(shortcut) {
					if(el.JSControl) this.oShortcuts_[shortcut]=el.JSControl;
					else {
						var ctrl=el.ancestors().detect(function(n){ return n.JSControl });
						if(ctrl) this.oShortcuts_[shortcut]=ctrl.JSControl;
					}
				}

				if(oNode.getAttribute("primary")=="yes" && el.JSControl) {
					this.oShortcuts_["Ctrl+#13"]=el.JSControl;
				}
			}

			var sClassName = oNode.getAttribute("class");
			if (sClassName == "widget") {
				var sNewSrc = oNode.getAttribute("src");
				var sValue = oNode.getAttribute("value");
				if (!sValue || oNode.getAttribute("update-value")!='yes') {
					/*if (sValue) {
						LogE("Undefining VALUE, was '"+sValue+"'");
						LogL("WindowID=$$"+this.ID()+"$$");
						LogL("Control ID=$$"+oNode.getAttribute("id")+"$$");
						LogL("Control XML="+oNode.xml);
					}*/
					sValue=undefined;
				}
				//if (sValue) LogE("LoadingCallback: "+sValue);
				if (sNewSrc) {
					GWindowManager.CreateWindow({
						sURL: sNewSrc,
						sParent: this.sInstanceID_,
						sControlID: sHTMLID,
						sValue: sValue,
						bInline: true
					});
				}
			}
			else {
				this.SetAttributes(sHTMLID, oNode);
			}
		}

		this.UpdateLayoutElements(oRoot);

		this.InitChangesTracking(oRoot);

		// filling an array for further tabstop setting
		var aLay = AXML.SelectNodes(oRoot, "/ai:wnd/ai:lay//ai:ele", AINS);
		for (var i = 0; i < aLay.length; ++i) {
			var sID = aLay[i].getAttribute("id");
			var sControlID = this.ControlHTMLID(sID);
			if(!this.oControls_[sControlID]) continue;
			var el=this.oControls_[sControlID].node_;
			if(!el) continue;
			el.position_ = this.aControls_.length;
			el.nTabBase = 0;
			this.aControls_.push(el);
		}
		if(this.oParentWin) { // Setup tab order of the window
			if (this.IsPopup) { // experimental
				GWindowManager.StoreActiveElement();
				GWindowManager.ClearTabOrder(FS_NOTFOCUSED);
				this.SetTabOrder(0);
			} else {
				this.oParentWin.RefreshTabOrder(this.sControlID_);
			}
			var win=this;
			while(win && win.bInline_) {
				win=win.oParentWin;
			}
			if(win) win.focusFirst(win.HTML, SKIP_MYSELF);
		}
		// emit creation event
		new AEvent("WM_CREATE", { wid: this.LocalID()}, this.ID());
		for (var cid in this.oControls_) {
			// TODO: verify this (last commented condition)
			if (!this.oControls_[cid] || !this.oControls_[cid].node_/* || !this.oControls_[cid].node_.JSControl*/) continue;
			new AEvent("INPUT", {}, this.oControls_[cid].node_.JSControl);
		}
		// initialize window as widget
		if (this.sValue) {
			var oValue=URLRestoreV(this.sValue);
			this.SetValue(oValue);
			this.sValue=undefined;
		}
		this.ProcessEvents(oRoot, "after");
		this.aOrderedEvents=[]; // to remove references
		// We cannot post WM_INIT from window itself, because it will be captured by 'this' window
		// but we can use widget control of the parent window as event emitter // mvel
		var widgetNode=$(this.HTML.parentNode);
		if (widgetNode && widgetNode.JSControl==this) {
			new AEvent("WM_INIT", {}, widgetNode.getAttribute('id'));
			//LogL("Widget WM_INIT: $$"+this.ID()+"$$");
		}
	},
	OnKeyDown: function(evt) {
		var letter=String.fromCharCode(evt.keyCode);
		if(evt.keyCode>=112 && evt.keyCode<=123) letter="F"+(evt.keyCode-111);
		var mod="";
		if(evt.ctrlKey) mod="Ctrl+";
		var ctrl;
		if(this.oShortcuts_[mod+letter]) ctrl=this.oShortcuts_[mod+letter];
		else if(this.oShortcuts_[mod+"#"+evt.keyCode]) ctrl=this.oShortcuts_[mod+"#"+evt.keyCode];
		if( ctrl && typeof(ctrl.Shortcut)=="function" ) {
			ctrl.Shortcut(mod+"#"+evt.keyCode);
			return true;
		}
	},
	InitChangesTracking: function(oRoot) {
		var sTrackChanges=oRoot.getAttribute("track-changes") || '';
		if (sTrackChanges=="no") return;
		if (sTrackChanges.substr(0,1)=="'") {
			// extract control id (= action name for default handler)
			this.trackChangesAction=sTrackChanges.substr(1,sTrackChanges.length-2);
		}
		var aLabels=AXML.SelectNodes(oRoot, "/ai:wnd/ai:lay//ai:cell[@labelfor]", AINS);
		for(var i=0; i<aLabels.length; ++i) {
			var sID = aLabels[i].getAttribute("id");
			var sLF = aLabels[i].getAttribute("labelfor");
			var sHLF=this.ID()+'_'+sLF;
			var eleNode=$(sHLF);
			if( !eleNode || !eleNode.JSControl ||
				typeof(eleNode.JSControl.Value)!="function" ||
				eleNode.getAttribute("track-changes")=="no" ||
				Element.select(eleNode, "[track-changes='no']").length ) continue;
			this.oLabelCells[sHLF]={
				'oNode': $(this.ID()+'_cell-'+sID),
				'bModified': false,
				'sValue': URLSerialize(eleNode.JSControl.Value())
			};
		}
		this.UpdateLayoutElements(oRoot);
	},
	OnWMPopup: function(oEvent) {
		var oData=oEvent.Data();
		if (!oData['id']) return; // not our case
		var args={
			sParent: this.InstanceID(),
			nodeID: this.ControlHTMLID(oData['id'])
		};
		if (typeof(oData['src']) != 'undefined') args.sURL=oData['src'];
		// please do not mix up args local variable (popup creation arguments)
		// and event arguments that contain control values and should be passed to window
		if (typeof(oData['args']) != 'undefined') args.sParams=URLSerializeVS(oData['args']);
		if (typeof(oData['rets']) != 'undefined') args.rets=oData['rets'];
		
		if (typeof(oData['align']) != 'undefined') args.alignID=oData['align'];
    if (typeof(oData['initial-width']) != 'undefined') args.initialWidth=parseInt(oData['initial-width']);
    if (typeof(oData['initial-height']) != 'undefined') args.initialHeight=parseInt(oData['initial-height']);
    
		oEvent.Stop();
		new APopupWindow(args);
	},
	// activates window
	Focus: function() {
		if (GWindowManager.Focused()) {
			//LogL("WM is already in focus. ");
			return;
		}
		GWindowManager.ClearTabOrder(FS_FOCUSED);
		GWindowManager.SetTabOrder(0);
		this.focusFirst(this.HTML, SKIP_MYSELF);
		//LogL("Window $$"+this.ID()+"$$ activated");
	},

	onDummySpanBlur: function() {
		var parent=this.focusSpan_.parentNode;
		parent.removeChild(this.focusSpan_);
	},
	focusFirst: function(element, bSkipMyself) {
		if (!element || element.nodeType != Node.ELEMENT_NODE || element.style.display=='none') return false;
		
		if(element.getAttribute('autofocus')=='no') {
			if(!this.focusSpan_) {
				this.focusSpan_=new Element('span', {id: 'tmp', 'style': 'width:10; height:0; outline: medium none;', tabindex: '0'});
				$(this.focusSpan_).observe('blur', this.onDummySpanBlur.bind(this));
			}
			
			this.focusSpan_.setAttribute('tabindex', element.getAttribute('tabindex'));
			var win = AControl.GetParentWindow( element );
			
			Element.insert(win.HTML, {top: this.focusSpan_});
			this.focusSpan_.focus();
			return true;
		}
//		if(!bSkipMyself && element.style.display != 'none') { // focus on window
		if (!bSkipMyself && element.tabIndex >= 0 && element.style.display != 'none') {
			if (typeof element.activate == "function") {
				element.activate();
				return true;
			} else if (typeof element.focus == "function") {
				element.focus();
				return true;
			}
		}
		for (var child = element.firstChild; child; child = child.nextSibling){
			if (this.focusFirst(child)) return true;
		}
		return false;
	},

	SetAttributes: function(sHTMLID, oNode) {
//	LogL("AControl.SetAttributes: "+sHTMLID);
		var htmlNode=$(sHTMLID);
		if(!htmlNode || !htmlNode.JSControl) return;
		var jsControl=htmlNode.JSControl;
		var count=oNode.attributes.length;
		for (var i = 0; i < count; ++i) {
			var oAttr = oNode.attributes[i];
			if (oAttr.name == "value" && jsControl.SetValue) {
				jsControl.SetValue(URLRestoreV(oAttr.value));
			}
			else if (oAttr.name=="dependsOn") {
				var dependsOn=oAttr.value;
				var d=dependsOn ? dependsOn.split(" ") : []; // split returns [''] on empty string
				for(var j=0; j<d.length; ++j) {
					d[j]=this.ControlHTMLID(d[j]);
				}
				if (!this.oControls_[sHTMLID].dependsOn_) {
					LogL("adding control on SetAttributes");
					// this control had not subscribed yet, subscribe it
					this.Subscribe("INPUT", this.CheckDependencies.bind(this, sHTMLID));
					this.Subscribe("CHANGE", this.CheckDependencies.bind(this, sHTMLID));
				}
				this.oControls_[sHTMLID].dependsOn_=d; // update dependsOn
			}
			else {
				if (jsControl.SetAttribute && oAttr.name!="id" && oAttr.name!="class" && oAttr.name!="type") {
					jsControl.SetAttribute(oAttr.name, oAttr.value);
				}
			}
		}
	},

	RegisterNewControl: function(oControl, parentNode) {
		// now used only for tree and popups registering
		var el=oControl.parentNode || parentNode;
		if(!el) return;
		var id=oControl.ID();
		if (!this.oControls_[id]) this.oControls_[id]=new Object();
		this.oControls_[id].node_=el;
		el.position_ = this.aControls_.length;
		if (parentNode) {
			var len=this.aControls_.length;
			if (len) {
				var tabIndex=this.aControls_.last().nTabBase;
				if (typeof(tabIndex)=='number') el.nTabBase=tabIndex+1;
				else el.nTabBase=0;
			}
		} else {
			el.nTabBase = 0;
		}
		this.aControls_.push(el);
	},
	registerInParentResizer: function() {
		if (!this.sParent_) return; // window has no parent
		//LogL("registerInParentResizer $$"+this.ID()+"$$, parent's InstanceID="+this.sParent_);
		var oParentWin;
		var elSelf = $(this.ID());
		if (elSelf) oParentWin = AControl.GetParentWindow( $(elSelf.parentNode) );
		// we'll fail here for popups
		if (!oParentWin) {
			oParentWin = GWindowManager.GetWindow(this.sParent_);
		}
		if (oParentWin) {
			oParentWin.RegisterResizeableChild(this.ID());
			oParentWin.registerInParentResizer(); // force chain
		} else {
			LogL("Cannot get parent window for "+this.ID());
		}
	},
	ProcessEvent: function(oEvtNode, oRoot) {
		var sType=oEvtNode.getAttribute("type");
		var oParams=new Object();
		var sArgs=oEvtNode.getAttribute("args");
		if(sArgs) {
			var aParts = sArgs.split(" ");
			for(var j = 0; j < aParts.length; ++j) {
				var p = aParts[j];
				var n = p.indexOf("=");
				if (n < 1) continue;

				var sKey = p.substring(0, n);
				var sQVal=p.substring(n+1);
				if (sQVal.substr(0,1)!="'") {
					alert("Event processing error: argument named '"+sKey+
						"' is not defined, please check '"+this.LocalID()+"' window description. ");
					continue;
				}
				var sVal=sQVal.substr(1, sQVal.length-2);
				oParams[sKey]=URLRestore('Value:' + sVal + "&&");
			}
		}
		var sEmitter=oEvtNode.getAttribute("emitter");
		if (!sEmitter) sEmitter=this.ID();
		var oData = {"args": oParams, "xml": oRoot};
		for(var a=0; a<oEvtNode.attributes.length; ++a) {
			var attr=oEvtNode.attributes[a];
			if(attr.name=="args" | attr.name=="type") continue;
			oData[attr.name]=attr.value;
		}

		new AEvent(sType, oData, sEmitter);
	},
	orderEvents: function(oRoot) {
		this.aOrderedEvents=[];
		// first of all, grab non-WE_APP_MESSAGE events
		var aEvents=AXML.SelectNodes(oRoot, "/ai:wnd/ai:e/ai:evt[@type!='WE_APP_MESSAGE']", AINS);
		if (aEvents) {
			for(var i=0; i<aEvents.length; ++i) {
				this.aOrderedEvents.push(aEvents[i]);
			}
			this.aOrderedEvents.sort(function(a, b){
				var apo=parseInt(a.getAttribute('process-order'), 10);
				if(isNaN(apo)) apo=0;
				var bpo=parseInt(b.getAttribute('process-order'), 10);
				if(isNaN(bpo)) bpo=0;
				return apo-bpo;
			});
		}
		// then grab WE_APP_MESSAGE events
		aEvents=AXML.SelectNodes(oRoot, "/ai:wnd/ai:e/ai:evt[@type='WE_APP_MESSAGE']", AINS);
		if (aEvents) {
			for(var i=0; i<aEvents.length; ++i) {
				var oEvtNode=aEvents[i];
				if(!oEvtNode.getAttribute("emitter")) oEvtNode.setAttribute("emitter", "WindowManager");
				this.aOrderedEvents.push(oEvtNode);
			}
		}
	},
	
	ProcessEvents: function(oRoot, order) {
		if(order=="before") {
			for(var i=0; i<this.aOrderedEvents.length; ++i) {
				var ord=parseInt(this.aOrderedEvents[i].getAttribute('process-order'), 10);
				if(isNaN(ord)) ord=0;
				if(ord>=0) return;
				this.ProcessEvent(this.aOrderedEvents[i], oRoot);
			}
		}
		else {
			for(var i=0; i<this.aOrderedEvents.length; ++i) {
				var ord=parseInt(this.aOrderedEvents[i].getAttribute('process-order'), 10);
				if(isNaN(ord)) ord=0;
				if(ord<0) continue;
				this.ProcessEvent(this.aOrderedEvents[i], oRoot);
			}
		}
	},

	ServerEventHandler: function(oEvent) {
		var sEventName = oEvent.Name();
		//LogL("AWindow::ServerEventHandler: "+sEventName+", emitter="+oEvent.EmitterID());
		var sControlID = oEvent.EmitterID();
		var oCtrlInfo = this.oControls_[sControlID];
		if (!oCtrlInfo) {
			// it can be event from widget
			var win=$(sControlID).JSControl || null;
			if (!win) return; // something is a miss here
			oCtrlInfo=this.oControls_[win.sControlID_];
			if (!oCtrlInfo) return;
		}
		if (!oCtrlInfo.oHandlers_) {
			// control can have no registered server handlers
			//LogL("Control "+sControlID+" has no server handler for event "+sEventName);
			return;
		}
		var nEventType = oCtrlInfo.oHandlers_[sEventName];
		if (!nEventType) {
			//LogL("Control "+sControlID+" has no server handler for event "+sEventName);
			return;
		}

		if (this.windowBusy) {
			if (nEventType & ET_IMPORTANT) { // this event handler is important, we should process in unconditionally
				//LogE("This is an important event handler");
			} else {
				oEvent.Stop();
				return;
			}
		}
		this.Busy();
		oEvent.SetType(nEventType);
		oEvent.Stop();

		this.SubscribeOnValue(this.CallServerEvent.bind(this, oEvent));
	},
	SubscribeOnValue: function(fCallback) {
		this.nControlsToWait=1;
		this.fOnReadyCallback=fCallback;
		for (var sKey in this.oControls_) {
			// enum all controls
			var oControl = this.oControls_[sKey];
			if (!oControl.bChanged_ || !oControl.node_) continue;
			var node=oControl.node_;
			if (!node.JSControl) continue;
			var jsControl=node.JSControl;
			if (jsControl == this || !jsControl.ID || !$(jsControl.ID())) continue;
			if (!jsControl.SubscribeOnValue) continue;
			++this.nControlsToWait;
			jsControl.SubscribeOnValue(this.ValueIsReady.bind(this));
		}
		this.ValueIsReady();
	},

	ValueIsReady: function(failFlag) {
		if(failFlag) {
			this.nControlsToWait=0;
			this.Free();
			return;
		}
		if( --this.nControlsToWait<=0 ) {
			this.fOnReadyCallback();
			delete this.fOnReadyCallback;
		}
	},

	CallServerEvent: function(oEvent) {
		var sControlID=oEvent.EmitterID();
		var elpControl = $(sControlID);
		var oData = this.CollectChangedData();
		var sPEventName;
		if (elpControl.readAttribute('eleclass')=='wnd') { // it's an event from widget
			var win=$(sControlID).JSControl || null;
			if (!win) {
				LogE("Cannot make server event call passed from widget "+sControlID);
				return;
			}
			elpControl=$(win.sControlID_); // switch to window' widget
		}
		var sLocalName = elpControl.readAttribute('localid');
		if (oEvent.Type() & ET_DEFAULT) sPEventName=sLocalName;
		else sPEventName = sLocalName+"_"+oEvent.Name();
		var oED=oEvent.Data();
		if (oED && typeof(oED["args"]) != 'undefined') oData["__event"]=oED["args"];
		var sData = URLSerializeVS(oData);

		var timeout=elpControl.readAttribute('timeout');
		if(timeout==undefined) timeout=30; // default timeout for method calls
		this.Update(sPEventName, sData, timeout);
	},

	SetTabOrder: function(nTabBase) {
		//LogE("AWindow:SetTabOrder("+nTabBase+") "+this.ID());
		var nTabEnd=nTabBase;

		for(var i=0; i<this.aControls_.length; ++i) {
			var oCtrl=this.aControls_[i];
			oCtrl.nTabBase=nTabEnd;
			var childWin=Element.down(oCtrl, 'DIV[instanceid]');
			if (childWin && childWin.JSControl) {
				nTabEnd=childWin.JSControl.SetTabOrder(nTabEnd);
				continue;
			}
			// non-window control
			if(oCtrl.JSControl && oCtrl.JSControl.SetTabOrder) { // Kosher control
				nTabEnd=oCtrl.JSControl.SetTabOrder(nTabEnd);
			}
			else if(oCtrl.nodeName=='INPUT') { // simple HTML control
				oCtrl.writeAttribute('tabindex', nTabEnd++);
			}
		}
		return nTabEnd;
	},

	RefreshTabOrder: function(sControlID, bSkipMyself, nTabBase) {
		//LogE("Refreshing tab order: $$"+sControlID+"$$ "+bSkipMyself);
		var oCtrlInfo=this.oControls_[sControlID];
		if (!oCtrlInfo) return; // control not found!
		var ctrl=oCtrlInfo.node_;
		var nTabEnd=ctrl.nTabBase;
		if(nTabEnd<=0) {
			if(!this.oParentWin) nTabEnd=1;
			else return;
		}
		var startIndex=ctrl.position_;
		if(bSkipMyself) {
			++startIndex;
			nTabEnd=nTabBase;
		}

		for(var i=startIndex; i<this.aControls_.length; ++i) {
			var oCtrl=this.aControls_[i];
			oCtrl.nTabBase=nTabEnd;

			if( oCtrl.select &&
				  oCtrl.select('DIV[instanceid]') &&
					oCtrl.select('DIV[instanceid]').length>0 ) { // child window
				var child=oCtrl.select('DIV[instanceid]')[0].JSControl;
				oCtrl.nTabBase=nTabEnd;
				nTabEnd=child.SetTabOrder(nTabEnd);
				continue;
			}

			if(oCtrl.JSControl && oCtrl.JSControl.SetTabOrder) nTabEnd=oCtrl.JSControl.SetTabOrder(nTabEnd);
		}
		if(this.oParentWin) this.oParentWin.RefreshTabOrder(this.sControlID_, SKIP_MYSELF, nTabEnd);
	},
	Busy: function(isBusy) {
		if(isBusy==false) return this.Free();
		if(this.HTML) this.HTML.addClassName('WidgetBusy');
		this.windowBusy=true;
		for(var cid in this.oControls_) {
			var c=this.oControls_[cid];
			if(c.node_ && c.node_.JSControl && c.node_.JSControl!=this && c.node_.JSControl.Busy) c.node_.JSControl.Busy(true);
		}
	},
	Free: function() {
		if(this.HTML) this.HTML.removeClassName('WidgetBusy');
		this.windowBusy=false;
		for(var cid in this.oControls_) {
			var c=this.oControls_[cid];
			if(c.node_ && c.node_.JSControl && c.node_.JSControl!=this && c.node_.JSControl.Busy) c.node_.JSControl.Busy(false);
		}
	},
	Refresh: function(sTimeout) {
		var sURL = this.sXMLSource_;
		if (sURL.indexOf("/srv/") == 0) sURL = "/act/dynamic/"

		sURL += "/Refresh/"+this.sInstanceID_;
		new AjaxRequest("POST", sURL, "", {
			onSuccess: this.UpdatingCallback.bind(this),
			onException: this.ExceptionCallback.bind(this),
			'timeout': parseInt(sTimeout, 10)
		});
	},

	Update: function(sEventName, sData, sTimeout) {
		var sURL = this.sXMLSource_;
		if (sURL.indexOf("/srv/") == 0) sURL = "/act/dynamic/"

		// TODO: if window not loaded, we cannot update it...
		sURL += "/"+sEventName+"/"+this.sInstanceID_;
		new AjaxRequest("POST", sURL, sData, {
			onSuccess: this.UpdatingCallback.bind(this),
			onException: this.ExceptionCallback.bind(this),
			timeout: parseInt(sTimeout, 10)
		});
	},
	ExceptionCallback: function(oAjaxRequest) {
		this.Free();
		if (window.GLoader && GLoader.CheckFatalError(oAjaxRequest.ErrorCode()) ) return;

//		var oXmlDomUpdate = oAjaxRequest.XML();
//		if(!oXmlDomUpdate) alert("Error! Wrong Ajax response. ");

		alert("`Error: `" + oAjaxRequest.Error());
	},
	UpdatingCallback: function(oAjaxRequest) { try {
// 	alert(oAjaxRequest.oTransport_.responseText)
		this.Free();
		var oXmlDomUpdate = oAjaxRequest.XML();
		var oDstRoot = (this.oXML_ ? this.oXML_.documentElement : null);

		// merge element attributes
		var oSrcRoot = oXmlDomUpdate.documentElement;
		this.ProcessID(oSrcRoot, 'update');

		var sWindowInstanceID = oSrcRoot.getAttribute("this");
		//LogL("Updating window $$"+this.ID()+"$$ ["+sWindowInstanceID+"]");
		this.orderEvents(oSrcRoot);
		this.ProcessEvents(oSrcRoot, "before");

		this.rememberPrevValues();
		var aElements = AXML.SelectNodes(oSrcRoot, "//ai:ele[not(ancestor::ai:lay)]", AINS);
		if (!aElements) {
			alert("DEBUG: Bad window! No elements found! XML:\r\n"+oSrcRoot.xml);
			return;
		}

		for (var i = 0; i < aElements.length; ++i) {
			var oSrcNode = aElements[i];
			var sID = oSrcNode.getAttribute("id");
//			LogL("node found: "+sID);

			var oDstNode = oDstRoot ? AXML.SelectNode(oDstRoot, "//ai:ele[not(ancestor::ai:lay)][@id='" + sID + "']", AINS) : null;

			var sHTMLID = (oDstNode ? oDstNode : oSrcNode).getAttribute("htmlid");
			if (!sHTMLID) continue; // element is not referenced in layout
//			LogL("node suited: "+sID);

			var sClassName = oDstNode ? oDstNode.getAttribute("class") : null;
			var isWidget=false;
			if (sClassName == "widget") {
				isWidget=true;
				var sNewSrc = oSrcNode.getAttribute("src");
				var eW=$(sHTMLID);
				var sOldSrc="";
				var w=(eW && eW.JSControl) ? eW.JSControl : null;
				if (w) {
					if (w instanceof DataPlaceholder) {
						// skip virtual widgets (bug #1504)
						isWidget=false;
					} else { 
						sOldSrc=w.XMLSource();
						var params=w.Params();
						if (params) sOldSrc+='?'+params;
					}
				}
				if (isWidget) {
					this.Busy();
					if (sNewSrc!=sOldSrc) {
						var elem = document.getElementById(sHTMLID);
						if (elem && elem.JSControl) new AEvent("WM_DESTROY", {}, elem.JSControl);
						if (sNewSrc) {
							GWindowManager.CreateWindow({
								sURL: sNewSrc,
								sParent: this.InstanceID(),
								sControlID: sHTMLID,
								bCheckChanges: true
							});
						} else {
							// TODO: destroy inner window
						}
					} else { // src was not changed, only set attributes
						if (oSrcNode.getAttribute("update-value")=='yes') {
							this.SetAttributes(sHTMLID, oSrcNode);
						}
					}
					this.Free();
				}
			}
			if (!isWidget) { // regular control
				this.SetAttributes(sHTMLID, oSrcNode);
			}
		}
		this.updateModificationStatus();
		this.UpdateLayoutElements(oSrcRoot);

		for(var cid in this.oControls_) {
			var c=this.oControls_[cid];
			var oNode=c.node_;
			if(!oNode) continue;
			var sHTMLID=oNode.getAttribute("htmlid");
			if(!sHTMLID) continue;
			if (!c.dependsOn_) continue;
			this.CheckDependencies(sHTMLID);
		}
		this.ProcessEvents(oSrcRoot, "after");
		this.aOrderedEvents=[]; // clear ordered events array to remove references
		// ------------------------------------ Exception handling block
		} catch (exc) {
			alert("AWindow:UpdatingCallback: Exception: "+exc);
		}
	},

	UpdateLayoutElements: function(xml) {
		var els = AXML.SelectNodes(xml, "/ai:wnd/ai:lay//*[name() != 'ele'][@id][@visibility or @style]", AINS);
		for (var i = 0; i < els.length; ++i) {
			var e = els[i];
			var id = e.getAttribute('id');

			var tag = e.nodeName.replace(/[^:]+:/, '');
			var node;
			if (tag == "grid") {
				node = $("gridFrame_" + id + "_" + this.InstanceID());
			}
			else {
				var uid = tag + "-" + id;
				node = $( this.ControlHTMLID(uid) );
			}

			if (!node) continue;
			var st = e.getAttribute('style');
			if (st !== null) {
				node.writeAttribute('style', st);
			}

			var visibility = e.getAttribute('visibility');
			if(!visibility) continue;
			if(visibility != 'no') node.show();
			else node.hide();
		}
	},

	CollectChangedData: function() {
		var oData = new Object();
		for (var sKey in this.oControls_) {
			// enum all controls
			var oControl = this.oControls_[sKey];
			if (oControl.bChanged_ || this.sendAllControls) {
				if (!oControl.node_) {
					LogE("CollectChangedData: Control node not found: " + sKey);
					continue;
				}
				var JSControl=oControl.node_.JSControl;
				if(!JSControl || typeof(JSControl.Value) != 'function') continue;
				oData[oControl.node_.readAttribute('localid')] = JSControl.Value();
			}
		}
		// TODO: clear controls change state
		//this.oControls_ = new Object();
		return oData;
	},
	Value: function() {
		var res={};
		for(var k in this.oControls_) {
			var node=this.oControls_[k].node_;
			if(node && node.JSControl && typeof(node.JSControl.Value)=='function') {
				var locid=node.readAttribute('localid');
				if(locid) res[locid]=node.JSControl.Value();
			}
		}
		return res;
	},
	SetValue: function(oValue) {
		for(var k in this.oControls_) {
			var node=this.oControls_[k].node_;
			if (!node) continue; // strange control...
			var jsControl=node.JSControl;
			if (!jsControl) continue; // non-kosher control
			if (typeof(jsControl.SetValue)!='function') continue; // cannot perform SetValue for this control
			var locid=node.readAttribute('localid');
			if (!locid) continue; // cannot get local ID, strange control
			if (typeof(oValue[locid]) == 'undefined') continue; // no value for this control

			jsControl.SetValue(oValue[locid]);
			//new AEvent("CHANGE", {}, jsControl);
		}
	},

	OnRefresh: function() {
		for(var sControlID in this.oLabelCells) {
			var lc=this.oLabelCells[sControlID];
			if($(sControlID)) lc.sValue=URLSerialize($(sControlID).JSControl.Value());
			lc.bModified=false;
			lc.oNode.removeClassName("Modified");
		}
		this.syncModificationStatus();
	},
	OnRestore: function(oEvent) {
//		oEvent.Stop();
		this.registerInParentResizer();
	},
	Die: function() {
		for(var ch in this.oChildren) {
			GWindowManager.GetWindow(ch).Die();
		}
		if(this.oParentWin) delete this.oParentWin.oChildren[this.InstanceID()];
		GWindowManager.DeleteWindow(this.sInstanceID_);
	},
	hasModifiedChildren: function() {
		for(var ch in this.oChildren) {
			var chWin=GWindowManager.GetWindow(ch);
			if (chWin.IsModified) return ch;
			var modCh=chWin.hasModifiedChildren();
			if (modCh) return modCh;
		}
		return '';
	},

	ProcessID: function(oRoot, mode) {
		var aElements = AXML.SelectNodes(oRoot, "/ai:wnd/ai:ele", AINS);
		for (var i = 0; i < aElements.length; ++i) {
			var oNode = aElements[i];
			if (typeof(oNode.getAttribute) == 'undefined') continue;
			var sLocalID = oNode.getAttribute("id");
			var sID = this.sID_+'_'+sLocalID;
			oNode.setAttribute("htmlid", sID);
			if (mode=='load') this.processHandlers(oNode, sID);
			this.SetChildID(sID, sLocalID, oRoot, mode);
		}
	},

	processHandlers: function(oNode, sID) {
		var sHandlers=oNode.getAttribute("handle");
		if (!sHandlers) return;
		var aHandlers=sHandlers.split(' ');
		if (!this.oControls_[sID]) this.oControls_[sID]=new Object();
		var oCtrlInfo=this.oControls_[sID];
		for (var j=0; j<aHandlers.length; ++j) {
			var sEventName=aHandlers[j];
			if (!sEventName) continue;
			var flags=ET_REGULAR;
			if (sEventName.substr(sEventName.length-1,1)=='*') {
				sEventName=sEventName.substr(0,sEventName.length-1);
				flags |= ET_IMPORTANT;
			}
			// put into control's map
			if (!oCtrlInfo.oHandlers_) oCtrlInfo.oHandlers_=new Object();
			oCtrlInfo.oHandlers_[sEventName]=flags;
			// and into global map (to register handlers
			this.oHandlers_[sEventName]=true;
		}
	},

	ProcessHTMLID: function() {
		var sGlobalPrefix = this.sControlID_;
		if (sGlobalPrefix) sGlobalPrefix += '_';
		sGlobalPrefix += this.LocalID();
		// add htmlid to window itself
		this.oXML_.documentElement.setAttribute("htmlid", sGlobalPrefix);
		this.sID_ = sGlobalPrefix;
		sGlobalPrefix += '_';
		this.oHandlers_ = new Object();

		var oRoot = this.oXML_.documentElement;
		this.ProcessID(oRoot, 'load');

		var aElements = AXML.SelectNodes(oRoot, "/ai:wnd/ai:lay//*[name() != 'ele']", AINS);
		for (var i = 0; i < aElements.length; ++i) {
			var oNode = aElements[i];
			if (typeof(oNode.getAttribute) == 'undefined') continue;
			if (oNode.localName == 't') continue;

			var sLocalID = oNode.getAttribute("id");
			var sID = sGlobalPrefix + (oNode.baseName || oNode.localName) + "-" + sLocalID;
			oNode.setAttribute("htmlid", sID);
		}
	},
	SetChildID: function(sPrefix, sParentLocalID, oRoot, mode) {
		var aElements = AXML.SelectNodes(oRoot, "//ai:ele[@htmlid='"+sPrefix+"']/ai:ele", AINS);
		for (var i = 0; i < aElements.length; ++i) {
			var oNode = aElements[i];
			if (typeof oNode.getAttribute == 'undefined') continue;
			var sLocalID = oNode.getAttribute("id");
			var sID = sPrefix+'.'+sLocalID;
			sLocalID=sParentLocalID+"."+sLocalID;
			oNode.setAttribute("htmlid", sID);
			oNode.setAttribute("id", sLocalID);
			if (mode=='load') this.processHandlers(oNode, sID);
		}
	},
	// Adds default handlers to some controls
	AddDefaultHandler: function(sEventName, sControlID) {
		//LogL('AddDefaultHandler for '+sControlID+", window.this="+this.InstanceID());
		var oCtrlInfo = this.oControls_[sControlID];
		if (!oCtrlInfo) {
			this.oControls_[sControlID] = new Object();
			oCtrlInfo = this.oControls_[sControlID];
		}
		if (!oCtrlInfo.oHandlers_) oCtrlInfo.oHandlers_ = new Object();
		if (typeof(oCtrlInfo.oHandlers_[sEventName])=='undefined') oCtrlInfo.oHandlers_[sEventName]=ET_NONE;
		oCtrlInfo.oHandlers_[sEventName] |= ET_DEFAULT; // default handler
		//LogL("ADH after addition===");
		//showObject(this.oControls_[sControlID].oHandlers_);
		//showObject(this.oControls_);

		// if this event type was not already
		if (!this.oHandlers_[sEventName]) {
			// add to subscription list
			//LogL("GENERIC Subscribed on: "+sEventName+", ID="+this.ID());
			this.Subscribe(sEventName, this.ServerEventHandler, this);
			this.oHandlers_[sEventName] = true;
		}
	},

	IsDefaultHandler: function(evtnam, ctrlid){
		if (!(ctrlid in this.oControls_)) return false;
		var handlers = this.oControls_[ctrlid].oHandlers_;
		if (!handlers) return false;
		if (!(evtnam in handlers)) return false;
		return Boolean(handlers[evtnam] & ET_DEFAULT);
	},

	CheckDependencies: function(dependentId, oEvent) {
		var cd = $(dependentId);
		if (!cd || !cd.JSControl || typeof cd.JSControl.Attribute != "function") return;
		var vis=cd.JSControl.Attribute("visibility");
		if (vis=="no") return; // do not set visibility for invisible controls
		var n=this.oControls_[dependentId];
		if (!n || !n.dependsOn_ || n.dependsOn_.length==0) return; // when dependencies is empty array, we do nothing!!!
		var dependencies=n.dependsOn_;

		var sControlID = (oEvent ? oEvent.EmitterID() : null);
		var i;
		for (i = 0; i < dependencies.length; ++i) {
			if (dependencies[i] == sControlID || !sControlID) break;
		}
//DO nothing!!!	// when dependencies is empty array, we should enable control
//		if (i != 0 && i == dependencies.length) return;

		var controls = "";
		var enabled = true;
		for (i = 0; i < dependencies.length; ++i) {
			var e=$(dependencies[i]);
			var c=(e ? e.JSControl : null);
			var v=(c ? c.Value() : null);
			if (e && (!v || v.IsNull && v.IsNull() || typeof v.IsIncorrect == "function" && v.IsIncorrect())) {
				enabled = false;
				var t=((c && typeof(c.Title)=="function") ? c.Title() : e.readAttribute("title"));
				// if nothing happens, put control ID there
				if (t===null) t=e.readAttribute("id");
				controls += (", "+t);
			}
		}

		var f = controls.substr(2);
		if(enabled && vis!="yes") {
			cd.JSControl.SetAttribute("visibility", "yes");
			if(cd.JSControl.origTitle__!==undefined) {
				cd.JSControl.SetAttribute("title", cd.JSControl.origTitle__);
				delete cd.JSControl.origTitle__;
			}
		}
		else if(!enabled) {
			if(cd.JSControl.origTitle__===undefined) cd.JSControl.origTitle__=cd.JSControl.Attribute("title");
			cd.JSControl.SetAttribute("visibility", "vo");
			cd.JSControl.SetAttribute("title", "`Please fill in the required fields: " + f + "`");
		}
		
//		cd.JSControl.SetAttribute("visibility", (enabled ? "yes" : "vo"));
//		cd.JSControl.SetAttribute("title", enabled ? "" :
//			"`Please fill in the required fields: " + f + "`");
	},

	rememberPrevValues: function() {
		for(var sControlID in this.oLabelCells) {
			var lc=this.oLabelCells[sControlID];
			if($(sControlID)) lc.sPrevValue=URLSerialize($(sControlID).JSControl.Value());
		}
	},
	updateModificationStatus: function() {
		this.IsModified=false;
		for(var sControlID in this.oLabelCells) {
			if(!$(sControlID)) continue;
			var lc=this.oLabelCells[sControlID];
			var newVal=URLSerialize($(sControlID).JSControl.Value());
			if(!lc.bModified) {
				lc.sValue=newVal;
				continue;
			}
			if(lc.sPrevValue!=newVal) {
				lc.sValue=newVal;
				lc.bModified=false;
				lc.oNode.removeClassName("Modified");
			}
			else this.IsModified=true;
			delete lc.sPrevValue;
		}
	},
	syncModificationStatus: function() {
		for(var sControlID in this.oLabelCells) {
			var lc=this.oLabelCells[sControlID];
			if(lc.bModified) {
				this.IsModified=true;
				return;
			}
		}
		this.IsModified=false;
	},
	OnControlInput: function(oEvent) {
		if(oEvent.Name() == "INPUT") oEvent.Stop();
		var sControlID=oEvent.EmitterID();

		if( (oEvent.Data() && oEvent.Data().bMutable) ||
		    AControl.GetParentWindowID(sControlID)!=this.ID() ) return;

		var lc=this.oLabelCells[sControlID];
		if(lc) {
			if(lc.sValue==URLSerialize($(sControlID).JSControl.Value())) {
				lc.oNode.removeClassName("Modified");
				lc.bModified=false;
				this.syncModificationStatus();
			}
			else {
				lc.oNode.addClassName("Modified");
				lc.bModified=true;
				this.IsModified=true;
			}
		}
	},
	OnControlChange: function(oEvent) {
//		LogE("AWindow[$$"+this.ID()+"$$]::OnControlChange: $$"+oEvent.Name()+"$$, emitter=$$"+oEvent.EmitterID()+"$$");
		var sControlID=oEvent.EmitterID();
		this.OnControlInput(oEvent);

		if(this.oControls_[sControlID]) {
			this.oControls_[sControlID].bChanged_ = true;
			this.oControls_[sControlID].node_ = $(sControlID);
		}
		else {
			var found=false;
			for(var k in this.oControls_) {
				if(sControlID.search(k+'_')==0) {
					found=true;
					this.oControls_[k].bChanged_ = true;
					break;
				}
			}
			if(!found) {
				this.oControls_[sControlID] = new Object();
				this.oControls_[sControlID].bChanged_ = true;
				this.oControls_[sControlID].node_ = $(sControlID);
			}
		}
		if(oEvent.Name() == "WM_INIT") oEvent.Stop();

		// TODO: clear changed state when posting to server
	},
	Subscribe: function(sEventName, fCallback, oThisObject) {
//		LogL("Window "+this.LocalID()+" has subscribed to event "+sEventName);
		sEventName = String(sEventName).toUpperCase();
		if (!this.oEventListeners_) this.oEventListeners_ = new Object();

		if (!this.oEventListeners_[sEventName]) {
			this.oEventListeners_[sEventName] = new Array();
		}
		this.oEventListeners_[sEventName].unshift(new AEventHandler(fCallback, oThisObject));
//		LogL("Event handler list length = "+this.oEventListeners_[sEventName].length);
//		for (var i = 0; i < this.oEventListeners_[sEventName].length; ++i) {
//			LogL(" registered callback for "+sEventName+", i="+i+", this="+this.InstanceID());
//		}
	},
	Unsubscribe: function(sEventName, fCallback, oThisObject) {
		sEventName = String(sEventName).toUpperCase();
		if (!this.oEventListeners_) this.oEventListeners_ = new Object();

		if (!this.oEventListeners_[sEventName]) {
			LogE("Event type '"+sEventName+"' is not registered");
			return;
		}

//		LogL("Unregistering handler for '"+sEventName+"'");
		var oHandler = new AEventHandler(fCallback, oThisObject);

		var bDeleted = false;
		for (var i = 0; i < this.oEventListeners_[sEventName].length; ++i) {
			if (this.oEventListeners_[sEventName][i].Compare(oHandler)) {
				this.oEventListeners_[sEventName].splice(i, 1);

//				LogL("Handler found and deleted! Size = " + this.oEventListeners_[sEventName].length);
				bDeleted = true;
				break;
			}
		}
		if (!bDeleted) LogL("WARNING: Handler not found!");
	},
	SubscribeToAllEvents: function(func, obj){
		if (!this.allevent_handlers_) this.allevent_handlers_ = new Array();
		this.allevent_handlers_.push(new AEventHandler(func, obj));
	},
	UnsubscribeFromAllEvents: function(func, obj){
		if (!this.allevent_handlers_) return;
		var handler = new AEventHandler(func, obj);
		for (var iii = 0; iii < this.allevent_handlers_.length; ++iii){
			if (this.allevent_handlers_[iii].Compare(handle)){
				this.allevent_handlers_.splice(iii, 1);
				break;
			}
		}
	},
	SaveChanges: function() {
		if (!this.trackChangesAction) return false;
		/*
			Here we assume that window with automated changes tracking
			has SimpleButton or another control with 'DoClick' function that
			performs click and raises event.
		*/
		var rName=this.ControlHTMLID(this.trackChangesAction);
		var ele=$(rName);
		if (!ele) {
			alert("Tracking-changes control "+rName+" was not found in window "+ this.ID());
			return false;
		}
		if (!ele.JSControl) {
			alert("Tracking-changes control "+rName+" is not a kosher control. ");
			return false;
		}
		var jsControl=ele.JSControl;
		if (typeof(jsControl.DoClick) != 'function') {
			alert("Cannot execute CLICK on tracking-changes control "+rName+". ");
			return false;
		}
		jsControl.DoClick();
		return true;
	},
	UpdateControls: function(sRets, oValues) {
		var aChanged=[];
		var aRets = sRets.split(' ');
		for (var i = 0; i < aRets.length; ++i) {
			var x = aRets[i].indexOf('=');
			var rName = (x >= 0 ? aRets[i].substr(0, x) : aRets[i]);
			var rVal = (x >= 0 ? aRets[i].substr(x + 1) : aRets[i]);

			if (!(rVal in oValues)) continue;
			var id = this.sID_ + '_' + rName;
			var elem = document.getElementById(id);
			if (!elem || !elem.JSControl || !elem.JSControl.SetValue) continue;
			elem.JSControl.SetValue(oValues[rVal]);
			// we should change state before emitting events
			// to ensure that any server action will pass all changed controls' values
			rName = this.ControlHTMLID(rName);
			if (rName in this.oControls_){
				this.oControls_[rName].bChanged_ = true;
				this.oControls_[rName].node_ = elem;
				aChanged.push(elem.JSControl);
			}
		}
		// we should first set all values and only then emit events
		for (var i=0; i < aChanged.length; ++i) {
			new AEvent("CHANGE", {}, aChanged[i]);
		}
	},
	RegisterResizeableChild: function(sControlID) {
		if (!this.oResizeableChildren) this.oResizeableChildren = new Object();
		this.oResizeableChildren[sControlID] = true;
		//LogL("Win[$$"+this.ID()+"$$]: Resizeable child registered: "+sControlID);
	},
	OnResize: function(evt) {
		if (!this.HTML) {
			alert('OnResize: Window HTML is not initialized');
			return;
		}
		var eG = AControl.GetBoundingFrame(this.HTML);
		// TODO: remove this popup spike
		if (!eG) eG = this.HTML.up('DIV.popupContents'); // no grid? try popup frame
		var nFullHeight = (eG ? eG.offsetHeight : document.body.clientHeight);

		// resize window grids
		//LogE("OnResize: Win[$$"+this.ID()+"$$]: Resizing window grids...");
		this.ResizeGrids(nFullHeight, eG);
		// Resize children
		if (!this.oResizeableChildren) {
			//LogL("OnResize: No children to resize.");
			return;
		}
		for (var sK in this.oResizeableChildren) {
			var elChild = $(sK);
			if (elChild === null) {
				delete this.oResizeableChildren[sK];
				//LogE("OnResize: Child $$"+sK+"$$ was garbage-collected.");
				continue;
			}
			var jsControl = elChild.JSControl;
			if (jsControl) {
				if (typeof(jsControl.OnResize) == 'function') {
					//LogL("OnResize: Win[$$"+this.ID()+"$$]: Resizing JSControl "+jsControl.ID());
					jsControl.OnResize(evt);
				} else {
					LogE("Warning: Non-kosher control subscribed! No OnResize method! "+jsControl.ID());
				}
			}
			else {
				//LogE("Child "+sK+" does not have JSControl!");
			}
		}
	},
	ResizeGrids: function(nFullHeight, eRoot) {
		var elWF = (eRoot ? eRoot : this.HTML.parentNode); // window' div or other frame
		//LogL("ROOT ID="+elWF.getAttribute('id'));
//		LogE("Win[$$"+this.ID()+"$$]: ResizeGrids... "+nFullHeight+" "+elWF.readAttribute("id"));

		var eBF;
		var aFrames=elWF.select('DIV[type="gridFrame"]');
		var prevGridsH=0;
		
		for(var i=0; i<aFrames.length; ++i) {
			var eF = aFrames[i];
			if (i == 0) eBF = AControl.GetBoundingFrame(eF);
			else if (AControl.GetBoundingFrame(eF) != eBF) {
				//LogL("S0 ["+i+"]: Current frame is NOT an immediate child! $$"+eF.getAttribute('id')+"$$");
				continue;
			}

			var eW = AControl.GetParentWindowElement(eF); // get frame's window
			//LogL("S1. Frame: "+eF.readAttribute('id')+ ": h="+eF.offsetHeight);
			//LogL("S2. Got window for frame: "+eW.readAttribute('id'));
			if (this.ID() != eW.readAttribute('id')) {
				//LogE("S3. This is not our window, skipping");
				continue; // not our window
			}

			var nHL=parseInt(eF.readAttribute('height-limit'));
			if (!nHL) {
				prevGridsH+=eF.offsetHeight;
				continue;
			}


//			var iHeight=Math.floor((nFullHeight-prevGridsH)*nHL/100.0);
			var offset=getAbsoluteOffset(eF, "offsetTop")-getAbsoluteOffset(elWF, "offsetTop");
			var iHeight=Math.floor((nFullHeight-offset)*nHL/100.0);
//LogL("S3. This is a HL frame, SETTING STYLE! "+iHeight);

			if(nHL==100) {
//			eF.setStyle({"height": iHeight+'px'});
				eF.setStyle({"height": '2000px'});
				
				var sh=elWF.scrollHeight;

				if(elWF.scrollHeight-offset>2000) {

	//				iHeight-=elWF.scrollHeight-elWF.offsetHeight;
					iHeight-=elWF.scrollHeight-offset-2000;
					eF.setStyle({"height": iHeight+'px'});
				}
			}
			eF.setStyle({"height": iHeight+'px'});

			this.ResizeGrids(iHeight, eF); // recurse into subframes
			prevGridsH+=eF.offsetHeight;
		}
		//LogL("ResizeGrids finished with level "+this.nRecurseLevel);
		//this.nRecurseLevel--;
	},
	AddCustomization: function(cust) {
		var doc = new AXML('ai:wnd', AIURI);
		var lay = doc.oXML_.createElement('ai:lay');

		doc.oXML_.documentElement.appendChild(lay);

		for (var id in cust) {
			var e = doc.oXML_.createElement('ai:' + (cust[id]._tag ||'ele'));
			e.setAttribute("id", id);

			for (var attr in cust[id]) {
				e.setAttribute(attr, String(cust[id][attr]));
			}

			lay.appendChild(e);
		}

		var oParams = {
			"window": this.XMLSource(),
			"xml": doc.oXML_.xml
		};
		new ServerCall("/srv/WWW/WWWWorker/AddCustomization", oParams, {});
	},
	AddElementCustomization: function(ecust, id, tag) {
		var cust = {};
		cust[id] = ecust;
		cust[id]._tag = tag;
		return this.AddCustomization(cust);
	},


	// various getters/setters
	InstanceID: function() { return this.sInstanceID_; },
	LocalID: function() { return this.sLocalID_; },
	ID: function() { return this.sID_; }, // ID in HTML
	Title: function() { return this.sTitle_; },
	// obtain child control HTML ID
	ControlHTMLID: function(sID) { return this.sID_ + '_' + sID.replace('.', '_'); },
	Control: function(sID) { 
		if(!this.oControls_[this.ControlHTMLID(sID)]) return undefined;
		return this.oControls_[this.ControlHTMLID(sID)].node_;
	},
	// obtain parent window instance ID
	Parent: function() { return this.sParent_; },
	XML: function() { return this.oXML_; },
	XMLSource: function() { return this.sXMLSource_; },
	Params: function() { return this.sParams_; }
});

// static event poster
AWindow.postEvent = function(oEvent) {
	var sControlID = oEvent.EmitterID();

	var sCurrentWindowID = AControl.GetParentWindowInstanceID(sControlID);
	var sEventName = oEvent.Name();
	//showObject(GWindowManager.GetWindow(sCurrentWindowID).oEventListeners_);
//	if (sEventName!='INPUT')
//	LogL("AWindow.postEvent: Name=$$"+sEventName+"$$, Emitter=$$"+sControlID+"$$, Parent=$$"+sCurrentWindowID+"$$");
	while (sCurrentWindowID) {
		var oWindow = GWindowManager.GetWindow(sCurrentWindowID);
		var listeners = [oWindow.allevent_handlers_, oWindow.oEventListeners_[sEventName]];
		var handlers = new Array();
		for (var iii = 0; iii < listeners.length; ++iii){
			if (listeners[iii] && listeners[iii].length) handlers.push.apply(handlers, listeners[iii]);
		}
		for (var iii = 0; iii < handlers.length; ++iii){
			handlers[iii].Callback().call(handlers[iii].ThisObject(), oEvent);
			if (!oEvent.Propogation()) return;
		}
		// get parent window
		if(oWindow.Parent()==sCurrentWindowID) sCurrentWindowID="";
        else sCurrentWindowID = oWindow.Parent();
	}
	GDocumentInstance.FireEvent(oEvent);
}

var AWindowManager = Class.create({
	initialize: function(container) {
		this.oWindows_ = Object();
		Event.observe(window, 'resize', this.OnResize.bind(this));
		// this.container = container || document.body;
		// if(this.container) {
		// 	this.container.writeAttribute('id', this.ID());
		// 	this.container.JSControl=this;
		// }
	},
	ID: function() { return 'WindowManager'; },
	Start: function(sEntryPoint, container) {
		this.container = container || document.body;
		//delete this.container.JSControl;
		//this.container.removeAttribute('id');

		var elWM=new Element('div', { id: this.ID() });
		$(this.container).update();
		this.container.appendChild(elWM);
		if(!sEntryPoint) { // less hardcode
			alert('AWindowManager::Start: No entry point defined. ');
			return;
		}
		this.CreateWindow({sURL: sEntryPoint});
	},

	Focus: function() {
		var eWM=$('wMain');
		if (eWM && eWM.JSControl) eWM.JSControl.Focus();
	},

	StoreActiveElement: function() {
		this.activeElement=document.activeElement ? document.activeElement : null;
	},
	ActiveElement: function() { return this.activeElement; },
	Focused: function() { return this.bFocused; },
	SetTabOrder: function(nTabBase) {
		var eWM=$('wMain');
		if (eWM && eWM.JSControl) eWM.JSControl.SetTabOrder(nTabBase);
		this.bFocused=true;
	},

	ClearTabOrder: function(bFocusedState) {
		var aTabStops=$(this.container).select('[tabindex]');
		if (!aTabStops) return;
		for (var i=0; i<aTabStops.length; ++i) {
			if(aTabStops[i].readAttribute('tabindex')==undefined) continue;
			aTabStops[i].setAttribute('tabindex', -1);
		}
		this.bFocused=bFocusedState;
		//LogE("All tabs clearing done, bFocused="+this.bFocused);
	},

	OnResize: function(evt) {
LogL("WM.OnResize "+evt);
		if (this.inOnResize) return;

		this.inOnResize = true;
		var eWM=$('wMain');
		if (eWM && eWM.JSControl) eWM.JSControl.OnResize(); // TODO: rewrite in more kosher way
		this.inOnResize = undefined;
	},

	ObserveResize: function(sElementID) {
		//LogL("WindowManager::ObserveResize $$"+sElementID+"$$.");
		var oWindow = AControl.GetParentWindow(sElementID);
		if (oWindow) oWindow.RegisterResizeableChild(sElementID);
	},

	LoadXSL: function() {
		var prefix = document.location.protocol + '//' +
			document.location.host + LocalizedSkinPrefix;
		// try {
			var t = new AXSLTemplate(LocalizedSkinPrefix + "main.xsl");
			t.FixXSLInclude(prefix, CustomXsl);
			t.Compile();
			this.oXSLDoc_ = t;
		// }
		// catch (e) {
		// 	var errText;
		// 	for(var i in e) {
		// 		errText+=(i+": "+e[i]+";\n\t");
		// 	}
		// 	alert("Failed to load \"" + LocalizedSkinPrefix + "main.xsl\":\n\t"+errText);

		// 	LogE("Failed to load \"" + LocalizedSkinPrefix + "main.xsl\": "+errText);
		// 	return null;
		// }

	},
	// retrieve window by window instance ID (this)
	GetWindow: function(sThis) {
		if (!this.oWindows_[sThis]) ThrowError("GetWindow: Window '"+sThis+"' not registered. ");
		return this.oWindows_[sThis];
	},
	// delete window by instance ID (this)
	DeleteWindow: function(sThis) {
		//LogL("Deleting window "+sThis);
		if (!this.oWindows_[sThis]) {
			alert("DEBUG: AWindowManager::DeleteWindow(): Window with InstanceID = '"+sThis+"' not found. ");
			return;
		}
		// TODO: kill children
		// this.oWindows_[sThis].DeleteChildren();
		delete this.oWindows_[sThis]; // anything else? unregister handlers, etc???
	},
	CheckChanges: function(oParams) {
		if (!oParams.bCheckChanges || !oParams.sParent) return true; // don't care about changes
		var parent = GWindowManager.GetWindow(oParams.sParent);
		var modCh=parent.hasModifiedChildren();
		if (!modCh) return true; // nothing changed
		var modWin=this.GetWindow(modCh);
		if (!modWin) return true; // should not happen
		if (modWin.SaveChanges()) return true; // don't ask when auto-save is turned on
		return (confirm("`There are unsaved data! \nAre you sure you want to leave the page? `") ? true : false);
	},
	/**
	  * Creates new window. oParams can contain following fields:
	  * @sURL: URL of XML window source
	  *  or
	  * @oXML: XML object containing source
	  * @sParent: Parent window instance ID
	  * @sControlID: Control identifier to embed in (or anchor to it)
	  * @sParams: Window initialization parameters
	  * @timeout: number of seconds to wait server reply
	  **/
	CreateWindow: function(oParams) {
		if (!this.CheckChanges(oParams)) return;
		return new AWindow(oParams);
	},
	/**
	  * Creates new window. oParams can contain following fields:
	  * @sURL: URL of XML window source
	  *  or
	  * @oXML: XML object containing source
	  * @sParent: Parent window instance ID
	  * @sControlID: Control identifier to embed in (or anchor to it)
	  * @sInstanceID: Window instance ID (it is a refreshing of an existing window)
	  * @sParams: Window initialization parameters
	  * @timeout: number of seconds to wait server reply
	  **/
	RefreshWindow: function(oParams) {
		if (!this.CheckChanges(oParams)) return;
		return new AWindow(oParams);
	},
	registerWindow: function(sInstanceID, oWindow) {
		this.oWindows_[sInstanceID] = oWindow;
	},
	// TODO: eliminate second parameter, it's a spike
	Transform: function (xXMLDoc, bReturnTree) {
		var xXMLRoot = xXMLDoc.documentElement;
		// try {
			var xsl = this.XSL();
			if (!xsl) return;
			// LogL((new XMLSerializer()).serializeToString(xXMLDoc));

			return AXML.TransformDOM(xXMLDoc, xsl, bReturnTree);
		// } catch (err) {
		// 	alert("AWindow::Transform(): XSL transformation failed! " + err.description + ", "+err.message);
		// 	return "";
		// }
	},
	SetAddress: function(src, args) {
		if (args && args.length > 0) args = '?' + args;
		while (args && args.length > 0 && args[args.length - 1] == '&') {
			args = args.substr(0, args.length - 1);
		}
		if (Prototype.Browser.IE) {
			loc = window.location;
			if (loc.protocol.length+loc.host.length+loc.pathname.length+src.length+args.length+3>350) {
				// maximum buffer length is 2083 chars (non-unicode) for IE
				args="";
			}
		}
		var upd = function() {
			window.location.hash = '#' + src + args;
		};
		upd.defer();
	},
	XSL: function() {
		if (!this.oXSLDoc_) this.LoadXSL();
		if (!this.oXSLDoc_) return;

		return this.oXSLDoc_;
	},
	OnBeforeUnload: function(evt) {
		for(var win in this.oWindows_) {
			if(this.oWindows_[win].IsModified) {
				return "`There are unsaved data on the page. `";
			}
		}
	}
});

// Document-wide DOM event manager
var DocumentEventManager = Class.create({
	initialize: function() {
		this.oSubscribers = {
			'KeyUp': [],
			'KeyDown': [],
			'KeyPress': [],
			'KeyPressDown': []
		};
		this.oTransparentControls={};
		$(document).observe('keyup', this.processEvent.bind(this, 'KeyUp'));
		$(document).observe('keydown', this.processEvent.bind(this, 'KeyDown'));
		$(document).observe('keypress', this.processEvent.bind(this, 'KeyPress'));
		BindKeyDown(document, this.processEvent.bind(this, 'KeyPressDown'));
	},
	processEvent: function(sType, event) {
		if(!(event.altKey || event.ctrlKey)) {
			var key = event.which || event.keyCode;
			if(!(key>=112 && key<=123)) switch(key) { // not F1-F12
				case Event.KEY_BACKSPACE:
				case Event.KEY_DELETE:
				case Event.KEY_DOWN:
				case Event.KEY_END:
				case Event.KEY_ESC:
				case Event.KEY_HOME:
				case Event.KEY_INSERT:
				case Event.KEY_LEFT:
				case Event.KEY_PAGEDOWN:
				case Event.KEY_PAGEUP:
				case Event.KEY_RETURN:
				case Event.KEY_RIGHT:
				case Event.KEY_TAB:
				case Event.KEY_UP:
					break;
				default:
					return;
			}
		}
		var eKD = GetKeyCode(event);
		var evt = Event.extend(event || window.event);
		var aSubscribers=this.oSubscribers[sType];
		// find nearest subscriber related to
		var emitter=evt.element();
		var newSubscribers=[];
		for (var i=0; i<aSubscribers.length; ++i) {
			// typically this array will be rather short (1 or 0 elements),
			// so loop won't hang everything
			var subs=aSubscribers[i];
			var elControl=$(subs);
			if (!elControl || !elControl.JSControl) continue;
			newSubscribers.push(subs);
		}
		this.oSubscribers[sType]=newSubscribers;
		var ss=this.findSubscribers(emitter, event.root, newSubscribers);
		if(!ss || !ss.length) return;
		var jsEmitter=this.findControl(emitter);
		for(var s=0; s<ss.length; ++s) {
			var node=$(newSubscribers[ss[s]]);;
			if(!node || !node.JSControl) continue;
			var fHandler=node.JSControl['On'+sType].bind(node.JSControl);
			if (fHandler(evt)) {
				StopEvent(evt);
				return false;
			}
		}
	},
	Subscribe: function(sType, sControlID) {
		if (!this.oSubscribers[sType]) {
			alert("DocumentEventManager: Event type "+sType+" is unknown, please verify your code. ");
			return;
		}
		var aSubscribers=this.oSubscribers[sType];
		for (var i=0; i<aSubscribers.length; ++i) {
			var subs=aSubscribers[i];
			if (subs==sControlID) return; // do not subscribe twice
		}
		aSubscribers.push(sControlID);
	},
	AddTransparentControl: function(className) {
		this.oTransparentControls[className]=true;
	},
	findControl: function(emitter) {
		for (var e=emitter; e; e=e.parentNode) {
			if (e.JSControl) return e.JSControl;
		}
		return null;
	},
	isLeftSibling: function(left, right) {
		if (!right && !left) return true;
		if (!left) return false; // right is defined
		if (!right) return true; // left is defined
		if (left==right) return true;
		var n=left;
		for (var n=left; n; n=n.nextSibling) if (n==right) return true;
		return false;
	},
	findSubscribers: function(emitter, root, aSubscribers) {
		if (!aSubscribers.length) return null; // important particular case
		var node=emitter;
		while(node) {
			if(node.subscriberIdx) {
				try {
					delete node.subscriberIdx;
				}
				catch(e) {
					if(node.removeAttribute) node.removeAttribute('subscriberIdx');
				}
			}
			node=node.parentNode;
		}
		for(var s=aSubscribers.length-1; s>=0; --s) {
			node=$(aSubscribers[s]);
			while(node) {
				if(!node.subscriberIdx) node.subscriberIdx=[];
				node.subscriberIdx.push(s);
				node=node.parentNode;
			}
		}

		var subscribersQueue=[];
		node=emitter;
		while(node && node!=root) {
			if(node.subscriberIdx!=undefined) {
				for(s=node.subscriberIdx.length-1; s>=0; --s) {
					var q=0;
					for(; q<subscribersQueue.length; ++q) {
						if(subscribersQueue[q]==node.subscriberIdx[s]) break;
					}
					if(q==subscribersQueue.length) subscribersQueue.push(node.subscriberIdx[s]);
				}
			}
			node=node.parentNode;
		}

		return subscribersQueue;
	}
}); // DocumentEventManager

var GDocumentEventManager=new DocumentEventManager();

var DocumentInstance = Class.create({
	oEventListeners_: {},
	initialize: function(){},

	Subscribe: function(sEventName, fCallback, oThisObject) {
		sEventName = String(sEventName).toUpperCase();
		if (typeof(this.oEventListeners_[sEventName]) == "undefined") this.oEventListeners_[sEventName] = new Array();
		this.oEventListeners_[sEventName].unshift(new AEventHandler(fCallback, oThisObject));
	},

	Unsubscribe: function(sEventName, fCallback, oThisObject) {
		sEventName = String(sEventName).toUpperCase();
		if (!this.oEventListeners_[sEventName]) {
			LogE("Event type '"+sEventName+"' is not registered");
			return;
		}

		var oHandler = new AEventHandler(fCallback, oThisObject);

		var bDeleted = false;
		for (var i = 0; i < this.oEventListeners_[sEventName].length; ++i) {
			if (this.oEventListeners_[sEventName][i].Compare(oHandler)) {
				this.oEventListeners_[sEventName].splice(i, 1);
				bDeleted = true;
				break;
			}
		}
		if (!bDeleted) LogL("WARNING: Handler not found!");
	},

	FireEvent: function(oEvent) {
		var sEventName=oEvent.Name();
		if (typeof(this.oEventListeners_[sEventName])=="undefined") return;
		var aListeners=this.oEventListeners_[sEventName];
		for (var i=0; i < aListeners.length; ++i) {
			var oHandler=aListeners[i];
			var fCallback=oHandler.Callback();
			var fCallbackBound=fCallback.bind(oHandler.ThisObject());
			fCallbackBound(oEvent);
		}
	},

	parse_features: function(str){
		var result = {};
		var records = String(str).split(",");
		for (var iii = 0; iii < records.length; ++iii){
			var rec = records[iii];
			var ind = rec.indexOf("=");
			if (-1 == ind) result[rec] = "yes";
			else result[rec.substr(0, ind)] = rec.substr(ind + 1);
		}
		return result;
	},

	serialize_features: function(struct){
		var arr = [];
		for (var key in struct) arr.push(key + "=" + struct[key]);
		return arr.join(",");
	},

	get_features: function(window_type, features_str){
		switch (String(window_type)){
			case "popup":
				var features = {"location": "no", "menubar": "no", "status": "no", "toolbar": "no"};
				var custom = this.parse_features(features_str);
				for (var key in custom) features[key] = custom[key];
				return this.serialize_features(features);
			case "window": return features_str || "";
			default: return "";
		}
	},

	start: function(){
		if (this.started_) return;
		this.Subscribe("WM_REDIRECT", function(aevent){
			var url = aevent.Data().src;
			var args = aevent.Data().args;
			var features = args ? this.get_features(args["type"], args["features"]) : "";
			var timer = function(){
				switch (String(args ? args["type"] : "inline")){
					case "popup":
					case "window":
						window.open(url, args["name"] || null, features, true);
						break;
					case "inline":
					default:
						window.location.href = url;
						if (url.length > 0 && "#" == url.charAt(0)) document.location.reload();
						break;
				}
			}.defer();
		}, this);
		this.Subscribe("WM_COOKIE", function(aevent){
			var name = aevent.Data().name;
			var data = aevent.Data().data;
			var path = aevent.Data().path;
			if(!path) path="/";
			document.cookie=name+"="+data+"; path="+path+";";
		}, null);
		this.started_ = true;
	}
});

var LabeledGrid = Class.create({
initialize: function(htmlid) {
	this.id = htmlid;
	this.frame = $(htmlid);
	this.collapse = $(htmlid + '_collapse');
	this.contents = $(htmlid + '_contents');
	this.label = $(htmlid + '_label');

	this.collapsed = false;
	if (this.frame && this.collapse && (this.frame.readAttribute('collapsed')=="true" || this.frame.readAttribute('collapsed')=="yes")) {
		this.OnCollapse();
	}

	if (this.collapse) this.collapse.observe('click', this.OnCollapse.bind(this));
},
OnCollapse: function(evt) {
	if (!this.collapsed) {
		this.contents.hide();
		this.collapse.addClassName('LabeledGridExpand');
		this.label.addClassName('LabeledGridCollapsed');
		this.collapsed = true;
	}
	else {
		this.contents.show();
		this.collapse.removeClassName('LabeledGridExpand');
		this.label.removeClassName('LabeledGridCollapsed');
		this.collapsed = false;
	}
//	GWindowManager.OnResize();
	if (evt) evt.stop();
}
});


var CellResizer = Class.create({
initialize: function(htmlid) {
	this.id = htmlid;
	this.cell = $(htmlid);
	this.cell.JSControl = this;
	this.prnt = this.cell.offsetParent;
	this.stubleft = $(htmlid + '-rleftstub');
	this.stubright = $(htmlid + '-rrightstub');

	this.minWidth = String(this.cell.readAttribute('min-width') || this.MinWidthDefault || '');
	this.maxWidth = String(this.cell.readAttribute('max-width') || '');
	this.width = this.cell.offsetWidth;
	this.visible = true;	

	var s = this.minWidth.replace(/%\s*$/, '');
	if (s != this.minWidth) this.minWidthMode = '%';
	this.minWidth = s.replace(/px$/, '');
	
	var s = this.maxWidth.replace(/%\s*$/, '');
	if (s != this.maxWidth) this.maxWidthMode = '%';
	this.maxWidth = s.replace(/px$/, '');
	
	var resizers = (this.cell.readAttribute('resize') || '').split(' ');
	for (var i = 0; i < resizers.length; ++i) {
		if (!resizers[i]) continue;
		if (resizers[i] == 'hidden') {
			this.visible = false;
			continue;
		}
		else if (resizers[i] == 'nohide') {
			this.nohide = true;
			continue;
		}

		$(htmlid + '-r' + resizers[i]).observe('mousedown', this.onMouseDown.bind(this, resizers[i]));
		var s = $(htmlid + '-r' + resizers[i] + 'stub');
		if (s) s.observe('mousedown', this.onMouseDown.bind(this, resizers[i]));
	}

	this.cell.setStyle({width: '1px'});
	this.validateWidth();

	AControl.GetParentWindow(this.cell).RegisterResizeableChild( this.id );
	
	this.dragUpHandler = this.onMouseUp.bind(this);
	this.dragMoveHandler = this.onMouseMove.bind(this);
},
MinWidthDefault: 35,
OnResize: function() {
	this.validateWidth();
},
validateWidth: function() {
	var minW = this.minWidth;
	var maxW = this.maxWidth;

	if (this.minWidthMode == '%') minW = minW * this.prnt.clientWidth / 100;
	if (this.maxWidthMode == '%') maxW = maxW * this.prnt.clientWidth / 100;

	this.visible = true;

	if (this.width <= minW) {
		this.width = minW;
		if (!this.nohide) this.visible = false;
	}
	else if (this.width > maxW) {
		this.width = maxW;
	}	

	this.cell.setStyle({width: this.width + 'px' });
	this.updateVisibility();
	GWindowManager.OnResize();
},
updateVisibility: function() {
	if (this.visible) {
		this.cell.show();
		if (this.stubleft) this.stubleft.hide();
		if (this.stubright) this.stubright.hide();
	}
	else {
		this.cell.hide();
		if (this.stubleft) this.stubleft.show();
		else if (this.stubright) this.stubright.show();
	}
},
onMouseUp: function(evt) {
	if (!evt.isLeftClick()) return;

	this.drag = undefined;

	$(document).stopObserving('mousemove', this.dragMoveHandler);
	$(document).stopObserving('mouseup', this.dragUpHandler);

	var w = AControl.GetParentWindow( this.cell );
	var localId = this.cell.readAttribute('localid');

	w.AddElementCustomization({ width: this.oldSize + 'px' }, localId, 'cell');
},
onMouseMove: function(evt) {
	var newX = evt.pointerX();

	this.oldSize = this.oldSize + newX - this.dragX;
	if (this.drag == 'right' || this.drag == 'left') {
		this.width = this.oldSize;
	}

	this.validateWidth();

	this.dragX = newX;
},
onMouseDown: function(mode, evt) {
	if (!evt.isLeftClick()) return;
	evt.stop();

	if (this.drag) return;
	
	this.oldSize = this.cell.offsetWidth;
	this.drag = mode;
	this.dragX = evt.pointerX();

	$(document).observe('mouseup', this.dragUpHandler)
	$(document).observe('mousemove', this.dragMoveHandler);
}
}); 

////////////////////////////////////////////////////////
/// Global Definitions
////////////////////////////////////////////////////////

var GWindowManager = new AWindowManager();
var GDocumentInstance = new DocumentInstance();
window.onbeforeunload = GWindowManager.OnBeforeUnload.bind(GWindowManager);

if (typeof AEventHandler != "undefined") GDocumentInstance.start();