Subversion Repositories Applications.papyrus

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

dojo._hasResource["dijit.layout._LayoutWidget"] = true;

dojo.provide("dijit.layout._LayoutWidget");

dojo.require("dijit._Widget");

dojo.require("dijit._Container");

dojo.declare("dijit.layout._LayoutWidget",

	[dijit._Widget, dijit._Container, dijit._Contained],

	{

		// summary

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

		//		Widgets which mixin this code must define layout() to lay out the children

		isLayoutContainer: true,

		postCreate: function(){

			dojo.addClass(this.domNode, "dijitContainer");

		},

		startup: function(){

			// summary:

			//		Called after all the widgets have been instantiated and their

			//		dom nodes have been inserted somewhere under document.body.

			//

			//		Widgets should override this method to do any initialization

			//		dependent on other widgets existing, and then call

			//		this superclass method to finish things off.

			//

			//		startup() in subclasses shouldn't do anything

			//		size related because the size of the widget hasn't been set yet.

			if(this._started){ return; }

			this._started=true;

			if(this.getChildren){

				dojo.forEach(this.getChildren(), function(child){ child.startup(); });

			}

			// If I am a top level widget

			if(!this.getParent || !this.getParent()){

				// Do recursive sizing and layout of all my descendants

				// (passing in no argument to resize means that it has to glean the size itself)

				this.resize();

				// since my parent isn't a layout container, and my style is width=height=100% (or something similar),

				// then I need to watch when the window resizes, and size myself accordingly

				// (passing in no argument to resize means that it has to glean the size itself)

				this.connect(window, 'onresize', function(){this.resize();});

			}

		},

		resize: function(args){

			// summary:

			//		Explicitly set this widget's size (in pixels),

			//		and then call layout() to resize contents (and maybe adjust child widgets)

			//

			// args: Object?

			//		{w: int, h: int, l: int, t: int}

			var node = this.domNode;

			// set margin box size, unless it wasn't specified, in which case use current size

			if(args){

				dojo.marginBox(node, args);

				// set offset of the node

				if(args.t){ node.style.top = args.t + "px"; }

				if(args.l){ node.style.left = args.l + "px"; }

			}

			// If either height or width wasn't specified by the user, then query node for it.

			// But note that setting the margin box and then immediately querying dimensions may return

			// inaccurate results, so try not to depend on it.

			var mb = dojo.mixin(dojo.marginBox(node), args||{});

			// Save the size of my content box.

			this._contentBox = dijit.layout.marginBox2contentBox(node, mb);

			// Callback for widget to adjust size of it's children

			this.layout();

		},

		layout: function(){

			//	summary

			//		Widgets override this method to size & position their contents/children.

			//		When this is called this._contentBox is guaranteed to be set (see resize()).

			//

			//		This is called after startup(), and also when the widget's size has been

			//		changed.

		}

	}

);

dijit.layout.marginBox2contentBox = function(/*DomNode*/ node, /*Object*/ mb){

	// summary:

	//		Given the margin-box size of a node, return it's content box size.

	//		Functions like dojo.contentBox() but is more reliable since it doesn't have

	//		to wait for the browser to compute sizes.

	var cs = dojo.getComputedStyle(node);

	var me=dojo._getMarginExtents(node, cs);

	var pb=dojo._getPadBorderExtents(node, cs);

	return {

		l: dojo._toPixelValue(node, cs.paddingLeft),

		t: dojo._toPixelValue(node, cs.paddingTop),

		w: mb.w - (me.w + pb.w),

		h: mb.h - (me.h + pb.h)

	};

};

(function(){

	var capitalize = function(word){

		return word.substring(0,1).toUpperCase() + word.substring(1);

	};

	var size = function(widget, dim){

		// size the child

		widget.resize ? widget.resize(dim) : dojo.marginBox(widget.domNode, dim);

		// record child's size, but favor our own numbers when we have them.

		// the browser lies sometimes

		dojo.mixin(widget, dojo.marginBox(widget.domNode));

		dojo.mixin(widget, dim);

	};

	dijit.layout.layoutChildren = function(/*DomNode*/ container, /*Object*/ dim, /*Object[]*/ children){

		/**

		 * summary

		 *		Layout a bunch of child dom nodes within a parent dom node

		 * container:

		 *		parent node

		 * dim:

		 *		{l, t, w, h} object specifying dimensions of container into which to place children

		 * children:

		 *		an array like [ {domNode: foo, layoutAlign: "bottom" }, {domNode: bar, layoutAlign: "client"} ]

		 */

		// copy dim because we are going to modify it

		dim = dojo.mixin({}, dim);

		dojo.addClass(container, "dijitLayoutContainer");

		// Move "client" elements to the end of the array for layout.  a11y dictates that the author

		// needs to be able to put them in the document in tab-order, but this algorithm requires that

		// client be last.

		children = dojo.filter(children, function(item){ return item.layoutAlign != "client"; })

			.concat(dojo.filter(children, function(item){ return item.layoutAlign == "client"; }));

		// set positions/sizes

		dojo.forEach(children, function(child){

			var elm = child.domNode,

				pos = child.layoutAlign;

			// set elem to upper left corner of unused space; may move it later

			var elmStyle = elm.style;

			elmStyle.left = dim.l+"px";

			elmStyle.top = dim.t+"px";

			elmStyle.bottom = elmStyle.right = "auto";

			dojo.addClass(elm, "dijitAlign" + capitalize(pos));

			// set size && adjust record of remaining space.

			// note that setting the width of a <div> may affect it's height.

			if(pos=="top" || pos=="bottom"){

				size(child, { w: dim.w });

				dim.h -= child.h;

				if(pos=="top"){

					dim.t += child.h;

				}else{

					elmStyle.top = dim.t + dim.h + "px";

				}

			}else if(pos=="left" || pos=="right"){

				size(child, { h: dim.h });

				dim.w -= child.w;

				if(pos=="left"){

					dim.l += child.w;

				}else{

					elmStyle.left = dim.l + dim.w + "px";

				}

			}else if(pos=="client"){

				size(child, dim);

			}

		});

	};

})();

}