Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dijit._base.focus"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dijit._base.focus"] = true;

dojo.provide("dijit._base.focus");

// summary:

//		These functions are used to query or set the focus and selection.

//

//		Also, they trace when widgets become actived/deactivated,

//		so that the widget can fire _onFocus/_onBlur events.

//		"Active" here means something similar to "focused", but

//		"focus" isn't quite the right word because we keep track of

//		a whole stack of "active" widgets.  Example:  Combobutton --> Menu -->

//		MenuItem.   The onBlur event for Combobutton doesn't fire due to focusing

//		on the Menu or a MenuItem, since they are considered part of the

//		Combobutton widget.  It only happens when focus is shifted

//		somewhere completely different.

dojo.mixin(dijit,

{

	// _curFocus: DomNode

	//		Currently focused item on screen

	_curFocus: null,

	// _prevFocus: DomNode

	//		Previously focused item on screen

	_prevFocus: null,

	isCollapsed: function(){

		// summary: tests whether the current selection is empty

		var _window = dojo.global;

		var _document = dojo.doc;

		if(_document.selection){ // IE

			return !_document.selection.createRange().text; // Boolean

		}else if(_window.getSelection){

			var selection = _window.getSelection();

			if(dojo.isString(selection)){ // Safari

				return !selection; // Boolean

			}else{ // Mozilla/W3

				return selection.isCollapsed || !selection.toString(); // Boolean

			}

		}

	},

	getBookmark: function(){

		// summary: Retrieves a bookmark that can be used with moveToBookmark to return to the same range

		var bookmark, selection = dojo.doc.selection;

		if(selection){ // IE

			var range = selection.createRange();

			if(selection.type.toUpperCase()=='CONTROL'){

				bookmark = range.length ? dojo._toArray(range) : null;

			}else{

				bookmark = range.getBookmark();

			}

		}else{

			if(dojo.global.getSelection){

				selection = dojo.global.getSelection();

				if(selection){

					var range = selection.getRangeAt(0);

					bookmark = range.cloneRange();

				}

			}else{

				console.debug("No idea how to store the current selection for this browser!");

			}

		}

		return bookmark; // Array

	},

	moveToBookmark: function(/*Object*/bookmark){

		// summary: Moves current selection to a bookmark

		// bookmark: this should be a returned object from dojo.html.selection.getBookmark()

		var _document = dojo.doc;

		if(_document.selection){ // IE

			var range;

			if(dojo.isArray(bookmark)){

				range = _document.body.createControlRange();

				dojo.forEach(bookmark, range.addElement);

			}else{

				range = _document.selection.createRange();

				range.moveToBookmark(bookmark);

			}

			range.select();

		}else{ //Moz/W3C

			var selection = dojo.global.getSelection && dojo.global.getSelection();

			if(selection && selection.removeAllRanges){

				selection.removeAllRanges();

				selection.addRange(bookmark);

			}else{

				console.debug("No idea how to restore selection for this browser!");

			}

		}

	},

	getFocus: function(/*Widget*/menu, /*Window*/ openedForWindow){

		// summary:

		//	Returns the current focus and selection.

		//	Called when a popup appears (either a top level menu or a dialog),

		//	or when a toolbar/menubar receives focus

		//

		// menu:

		//	the menu that's being opened

		//

		// openedForWindow:

		//	iframe in which menu was opened

		//

		// returns:

		//	a handle to restore focus/selection

		return {

			// Node to return focus to

			node: menu && dojo.isDescendant(dijit._curFocus, menu.domNode) ? dijit._prevFocus : dijit._curFocus,

			// Previously selected text

			bookmark:

				!dojo.withGlobal(openedForWindow||dojo.global, dijit.isCollapsed) ?

				dojo.withGlobal(openedForWindow||dojo.global, dijit.getBookmark) :

				null,

			openedForWindow: openedForWindow

		}; // Object

	},

	focus: function(/*Object || DomNode */ handle){

		// summary:

		//		Sets the focused node and the selection according to argument.

		//		To set focus to an iframe's content, pass in the iframe itself.

		// handle:

		//		object returned by get(), or a DomNode

		if(!handle){ return; }

		var node = "node" in handle ? handle.node : handle,		// because handle is either DomNode or a composite object

			bookmark = handle.bookmark,

			openedForWindow = handle.openedForWindow;

		// Set the focus

		// Note that for iframe's we need to use the <iframe> to follow the parentNode chain,

		// but we need to set focus to iframe.contentWindow

		if(node){

			var focusNode = (node.tagName.toLowerCase()=="iframe") ? node.contentWindow : node;

			if(focusNode && focusNode.focus){

				try{

					// Gecko throws sometimes if setting focus is impossible,

					// node not displayed or something like that

					focusNode.focus();

				}catch(e){/*quiet*/}

			}

			dijit._onFocusNode(node);

		}

		// set the selection

		// do not need to restore if current selection is not empty

		// (use keyboard to select a menu item)

		if(bookmark && dojo.withGlobal(openedForWindow||dojo.global, dijit.isCollapsed)){

			if(openedForWindow){

				openedForWindow.focus();

			}

			try{

				dojo.withGlobal(openedForWindow||dojo.global, moveToBookmark, null, [bookmark]);

			}catch(e){

				/*squelch IE internal error, see http://trac.dojotoolkit.org/ticket/1984 */

			}

		}

	},

	// List of currently active widgets (focused widget and it's ancestors)

	_activeStack: [],

	registerWin: function(/*Window?*/targetWindow){

		// summary:

		//		Registers listeners on the specified window (either the main

		//		window or an iframe) to detect when the user has clicked somewhere.

		//		Anyone that creates an iframe should call this function.

		if(!targetWindow){

			targetWindow = window;

		}

		dojo.connect(targetWindow.document, "onmousedown", null, function(evt){

			dijit._justMouseDowned = true;

			setTimeout(function(){ dijit._justMouseDowned = false; }, 0);

			dijit._onTouchNode(evt.target||evt.srcElement);

		});

		//dojo.connect(targetWindow, "onscroll", ???);

		// Listen for blur and focus events on targetWindow's body

		var body = targetWindow.document.body || targetWindow.document.getElementsByTagName("body")[0];

		if(body){

			if(dojo.isIE){

				body.attachEvent('onactivate', function(evt){

					if(evt.srcElement.tagName.toLowerCase() != "body"){

						dijit._onFocusNode(evt.srcElement);

					}

				});

				body.attachEvent('ondeactivate', function(evt){ dijit._onBlurNode(evt.srcElement); });

			}else{

				body.addEventListener('focus', function(evt){ dijit._onFocusNode(evt.target); }, true);

				body.addEventListener('blur', function(evt){ dijit._onBlurNode(evt.target); }, true);

			}

		}

		body = null;	// prevent memory leak (apparent circular reference via closure)

	},

	_onBlurNode: function(/*DomNode*/ node){

		// summary:

		// 		Called when focus leaves a node.

		//		Usually ignored, _unless_ it *isn't* follwed by touching another node,

		//		which indicates that we tabbed off the last field on the page,

		//		in which case every widget is marked inactive

		dijit._prevFocus = dijit._curFocus;

		dijit._curFocus = null;

		var w = dijit.getEnclosingWidget(node);

		if (w && w._setStateClass){

			w._focused = false;

			w._setStateClass();

		}

		if(dijit._justMouseDowned){

			// the mouse down caused a new widget to be marked as active; this blur event

			// is coming late, so ignore it.

			return;

		}

		// if the blur event isn't followed by a focus event then mark all widgets as inactive.

		if(dijit._clearActiveWidgetsTimer){

			clearTimeout(dijit._clearActiveWidgetsTimer);

		}

		dijit._clearActiveWidgetsTimer = setTimeout(function(){

			delete dijit._clearActiveWidgetsTimer; dijit._setStack([]); }, 100);

	},

	_onTouchNode: function(/*DomNode*/ node){

		// summary

		//		Callback when node is focused or mouse-downed

		// ignore the recent blurNode event

		if(dijit._clearActiveWidgetsTimer){

			clearTimeout(dijit._clearActiveWidgetsTimer);

			delete dijit._clearActiveWidgetsTimer;

		}

		// compute stack of active widgets (ex: ComboButton --> Menu --> MenuItem)

		var newStack=[];

		try{

			while(node){

				if(node.dijitPopupParent){

					node=dijit.byId(node.dijitPopupParent).domNode;

				}else if(node.tagName && node.tagName.toLowerCase()=="body"){

					// is this the root of the document or just the root of an iframe?

					if(node===dojo.body()){

						// node is the root of the main document

						break;

					}

					// otherwise, find the iframe this node refers to (can't access it via parentNode,

					// need to do this trick instead) and continue tracing up the document

					node=dojo.query("iframe").filter(function(iframe){ return iframe.contentDocument.body===node; })[0];

				}else{

					var id = node.getAttribute && node.getAttribute("widgetId");

					if(id){

						newStack.unshift(id);

					}

					node=node.parentNode;

				}

			}

		}catch(e){ /* squelch */ }

		dijit._setStack(newStack);

	},

	_onFocusNode: function(/*DomNode*/ node){

		// summary

		//		Callback when node is focused

		if(node && node.tagName && node.tagName.toLowerCase() == "body"){

			return;

		}

		dijit._onTouchNode(node);

		if(node==dijit._curFocus){ return; }

		dijit._prevFocus = dijit._curFocus;

		dijit._curFocus = node;

		dojo.publish("focusNode", [node]);

		// handle focus/blur styling

		var w = dijit.getEnclosingWidget(node);

		if (w && w._setStateClass){

			w._focused = true;

			w._setStateClass();

		}

	},

	_setStack: function(newStack){

		// summary

		//	The stack of active widgets has changed.  Send out appropriate events and record new stack

		var oldStack = dijit._activeStack;

		dijit._activeStack = newStack;

		// compare old stack to new stack to see how many elements they have in common

		for(var nCommon=0; nCommon<Math.min(oldStack.length, newStack.length); nCommon++){

			if(oldStack[nCommon] != newStack[nCommon]){

				break;

			}

		}

		// for all elements that have gone out of focus, send blur event

		for(var i=oldStack.length-1; i>=nCommon; i--){

			var widget = dijit.byId(oldStack[i]);

			if(widget){

				dojo.publish("widgetBlur", [widget]);

				if(widget._onBlur){

					widget._onBlur();

				}

			}

		}

		// for all element that have come into focus, send focus event

		for(var i=nCommon; i<newStack.length; i++){

			var widget = dijit.byId(newStack[i]);

			if(widget){

				dojo.publish("widgetFocus", [widget]);

				if(widget._onFocus){

					widget._onFocus();

				}

			}

		}

	}

});

// register top window and all the iframes it contains

dojo.addOnLoad(dijit.registerWin);

}