Subversion Repositories Applications.papyrus

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

dojo._hasResource["dijit._Container"] = true;

dojo.provide("dijit._Container");

dojo.declare("dijit._Contained",

	null,

	{

		// summary

		//		Mixin for widgets that are children of a container widget

		getParent: function(){

			// summary:

			//		returns the parent widget of this widget, assuming the parent

			//		implements dijit._Container

			for(var p=this.domNode.parentNode; p; p=p.parentNode){

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

				if(id){

					var parent = dijit.byId(id);

					return parent.isContainer ? parent : null;

				}

			}

			return null;

		},

		_getSibling: function(which){

			var node = this.domNode;

			do{

				node = node[which+"Sibling"];

			}while(node && node.nodeType != 1);

			if(!node){ return null; } // null

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

			return dijit.byId(id);

		},

		getPreviousSibling: function(){

			// summary:

			//		returns null if this is the first child of the parent,

			//		otherwise returns the next element sibling to the "left".

			return this._getSibling("previous");

		},

		getNextSibling: function(){

			// summary:

			//		returns null if this is the last child of the parent,

			//		otherwise returns the next element sibling to the "right".

			return this._getSibling("next");

		}

	}

);

dojo.declare("dijit._Container",

	null,

	{

		// summary

		//		Mixin for widgets that contain a list of children like SplitContainer

		isContainer: true,

		addChild: function(/*Widget*/ widget, /*int?*/ insertIndex){

			// summary:

			//		Process the given child widget, inserting it's dom node as

			//		a child of our dom node

			if(insertIndex === undefined){

				insertIndex = "last";

			}

			var refNode = this.containerNode || this.domNode;

			if(insertIndex && typeof insertIndex == "number"){

				var children = dojo.query("> [widgetid]", refNode);

				if(children && children.length >= insertIndex){

					refNode = children[insertIndex-1]; insertIndex = "after";

				}

			}

			dojo.place(widget.domNode, refNode, insertIndex);

			// If I've been started but the child widget hasn't been started,

			// start it now.  Make sure to do this after widget has been

			// inserted into the DOM tree, so it can see that it's being controlled by me,

			// so it doesn't try to size itself.

			if(this._started && !widget._started){

				widget.startup();

			}

		},

		removeChild: function(/*Widget*/ widget){

			// summary:

			//		removes the passed widget instance from this widget but does

			//		not destroy it

			var node = widget.domNode;

			node.parentNode.removeChild(node);	// detach but don't destroy

		},

		_nextElement: function(node){

			do{

				node = node.nextSibling;

			}while(node && node.nodeType != 1);

			return node;

		},

		_firstElement: function(node){

			node = node.firstChild;

			if(node && node.nodeType != 1){

				node = this._nextElement(node);

			}

			return node;

		},

		getChildren: function(){

			// summary:

			//		Returns array of children widgets

			return dojo.query("> [widgetId]", this.containerNode || this.domNode).map(dijit.byNode); // Array

		},

		hasChildren: function(){

			// summary:

			//		Returns true if widget has children

			var cn = this.containerNode || this.domNode;

			return !!this._firstElement(cn); // Boolean

		},

		_getSiblingOfChild: function(/*Widget*/ child, /*int*/ dir){

			// summary:

			//		get the next or previous widget sibling of child

			// dir:

			//		if 1, get the next sibling

			//		if -1, get the previous sibling

			var node = child.domNode;

			var which = (dir>0 ? "nextSibling" : "previousSibling");

			do{

				node = node[which];

			}while(node && (node.nodeType != 1 || !dijit.byNode(node)));

			return node ? dijit.byNode(node) : null;

		}

	}

);

dojo.declare("dijit._KeyNavContainer",

	[dijit._Container],

	{

		// summary:

		//		A _Container with keyboard navigation of its children.

		//		To use this mixin, call connectKeyNavHandlers() in

		//		postCreate() and call startupKeyNavChildren() in startup().

/*=====

		// focusedChild: Widget

		//		The currently focused child widget, or null if there isn't one

		focusedChild: null,

=====*/

		_keyNavCodes: {},

		connectKeyNavHandlers: function(/*Array*/ prevKeyCodes, /*Array*/ nextKeyCodes){

			// summary:

			//		Call in postCreate() to attach the keyboard handlers

			//		to the container.

			// preKeyCodes: Array

			//		Key codes for navigating to the previous child.

			// nextKeyCodes: Array

			//		Key codes for navigating to the next child.

			var keyCodes = this._keyNavCodes = {};

			var prev = dojo.hitch(this, this.focusPrev);

			var next = dojo.hitch(this, this.focusNext);

			dojo.forEach(prevKeyCodes, function(code){ keyCodes[code] = prev });

			dojo.forEach(nextKeyCodes, function(code){ keyCodes[code] = next });

			this.connect(this.domNode, "onkeypress", "_onContainerKeypress");

			if(dojo.isIE){

				this.connect(this.domNode, "onactivate", "_onContainerFocus");

				this.connect(this.domNode, "ondeactivate", "_onContainerBlur");

			}else{

				this.connect(this.domNode, "onfocus", "_onContainerFocus");

				this.connect(this.domNode, "onblur", "_onContainerBlur");

			}

		},

		startupKeyNavChildren: function(){

			// summary:

			//		Call in startup() to set child tabindexes to -1

			dojo.forEach(this.getChildren(), dojo.hitch(this, "_setTabIndexMinusOne"));

		},

		addChild: function(/*Widget*/ widget, /*int?*/ insertIndex){

			// summary: Add a child to our _Container

			dijit._KeyNavContainer.superclass.addChild.apply(this, arguments);

			this._setTabIndexMinusOne(widget);

		},

		focus: function(){

			// summary: Default focus() implementation: focus the first child.

			this.focusFirstChild();

		},

		focusFirstChild: function(){

			// summary: Focus the first focusable child in the container.

			this.focusChild(this._getFirstFocusableChild());

		},

		focusNext: function(){

			// summary: Focus the next widget or focal node (for widgets

			//		with multiple focal nodes) within this container.

			if(this.focusedChild && this.focusedChild.hasNextFocalNode

					&& this.focusedChild.hasNextFocalNode()){

				this.focusedChild.focusNext();

				return;

			}

			var child = this._getNextFocusableChild(this.focusedChild, 1);

			if(child.getFocalNodes){

				this.focusChild(child, child.getFocalNodes()[0]);

			}else{

				this.focusChild(child);

			}

		},

		focusPrev: function(){

			// summary: Focus the previous widget or focal node (for widgets

			//		with multiple focal nodes) within this container.

			if(this.focusedChild && this.focusedChild.hasPrevFocalNode

					&& this.focusedChild.hasPrevFocalNode()){

				this.focusedChild.focusPrev();

				return;

			}

			var child = this._getNextFocusableChild(this.focusedChild, -1);

			if(child.getFocalNodes){

				var nodes = child.getFocalNodes();

				this.focusChild(child, nodes[nodes.length-1]);

			}else{

				this.focusChild(child);

			}

		},

		focusChild: function(/*Widget*/ widget, /*Node?*/ node){

			// summary: Focus widget. Optionally focus 'node' within widget.

			if(widget){

				if(this.focusedChild && widget !== this.focusedChild){

					this._onChildBlur(this.focusedChild);

				}

				this.focusedChild = widget;

				if(node && widget.focusFocalNode){

					widget.focusFocalNode(node);

				}else{

					widget.focus();

				}

			}

		},

		_setTabIndexMinusOne: function(/*Widget*/ widget){

			if(widget.getFocalNodes){

				dojo.forEach(widget.getFocalNodes(), function(node){

					node.setAttribute("tabIndex", -1);

				});

			}else{

				(widget.focusNode || widget.domNode).setAttribute("tabIndex", -1);

			}

		},

		_onContainerFocus: function(evt){

			this.domNode.setAttribute("tabIndex", -1);

			if(evt.target === this.domNode){

				this.focusFirstChild();

			}else{

				var widget = dijit.getEnclosingWidget(evt.target);

				if(widget && widget.isFocusable()){

					this.focusedChild = widget;

				}

			}

		},

		_onContainerBlur: function(evt){

			if(this.tabIndex){

				this.domNode.setAttribute("tabIndex", this.tabIndex);

			}

		},

		_onContainerKeypress: function(evt){

			if(evt.ctrlKey || evt.altKey){ return; }

			var func = this._keyNavCodes[evt.keyCode];

			if(func){

				func();

				dojo.stopEvent(evt);

			}

		},

		_onChildBlur: function(/*Widget*/ widget){

			// summary:

			//		Called when focus leaves a child widget to go

			//		to a sibling widget.

		},

		_getFirstFocusableChild: function(){

			return this._getNextFocusableChild(null, 1);

		},

		_getNextFocusableChild: function(child, dir){

			if(child){

				child = this._getSiblingOfChild(child, dir);

			}

			var children = this.getChildren();

			for(var i=0; i < children.length; i++){

				if(!child){

					child = children[(dir>0) ? 0 : (children.length-1)];

				}

				if(child.isFocusable()){

					return child;

				}

				child = this._getSiblingOfChild(child, dir);

			}

		}

	}

);

}