Subversion Repositories Applications.papyrus

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

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

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

// ported from dojo.html.util

dijit.getViewport = function(){

	//	summary

	//	Returns the dimensions and scroll position of the viewable area of a browser window

	var _window = dojo.global;

	var _document = dojo.doc;

	// get viewport size

	var w = 0, h = 0;

	if(dojo.isMozilla){

		// mozilla

		// _window.innerHeight includes the height taken by the scroll bar

		// clientHeight is ideal but has DTD issues:

		// #4539: FF reverses the roles of body.clientHeight/Width and documentElement.clientHeight/Width based on the DTD!

		// check DTD to see whether body or documentElement returns the viewport dimensions using this algorithm:

		var minw, minh, maxw, maxh;

		if(_document.body.clientWidth>_document.documentElement.clientWidth){

			minw = _document.documentElement.clientWidth;

			maxw = _document.body.clientWidth;

		}else{

			maxw = _document.documentElement.clientWidth;

			minw = _document.body.clientWidth;

		}

		if(_document.body.clientHeight>_document.documentElement.clientHeight){

			minh = _document.documentElement.clientHeight;

			maxh = _document.body.clientHeight;

		}else{

			maxh = _document.documentElement.clientHeight;

			minh = _document.body.clientHeight;

		}

		w = (maxw > _window.innerWidth) ? minw : maxw;

		h = (maxh > _window.innerHeight) ? minh : maxh;

	}else if(!dojo.isOpera && _window.innerWidth){

		//in opera9, dojo.body().clientWidth should be used, instead

		//of window.innerWidth/document.documentElement.clientWidth

		//so we have to check whether it is opera

		w = _window.innerWidth;

		h = _window.innerHeight;

	}else if(dojo.isIE && _document.documentElement && _document.documentElement.clientHeight){

		w = _document.documentElement.clientWidth;

		h = _document.documentElement.clientHeight;

	}else if(dojo.body().clientWidth){

		// IE5, Opera

		w = dojo.body().clientWidth;

		h = dojo.body().clientHeight;

	}

	// get scroll position

	var scroll = dojo._docScroll();

	return { w: w, h: h, l: scroll.x, t: scroll.y };	//	object

};

dijit.placeOnScreen = function(

	/* DomNode */	node,

	/* Object */		pos,

	/* Object */		corners,

	/* boolean? */		tryOnly){

	//	summary:

	//		Keeps 'node' in the visible area of the screen while trying to

	//		place closest to pos.x, pos.y. The input coordinates are

	//		expected to be the desired document position.

	//

	//		Set which corner(s) you want to bind to, such as

	//

	//			placeOnScreen(node, {x: 10, y: 20}, ["TR", "BL"])

	//

	//		The desired x/y will be treated as the topleft(TL)/topright(TR) or

	//		BottomLeft(BL)/BottomRight(BR) corner of the node. Each corner is tested

	//		and if a perfect match is found, it will be used. Otherwise, it goes through

	//		all of the specified corners, and choose the most appropriate one.

	//

	//		NOTE: node is assumed to be absolutely or relatively positioned.

	var choices = dojo.map(corners, function(corner){ return { corner: corner, pos: pos }; });

	return dijit._place(node, choices);

}

dijit._place = function(/*DomNode*/ node, /* Array */ choices, /* Function */ layoutNode){

	// summary:

	//		Given a list of spots to put node, put it at the first spot where it fits,

	//		of if it doesn't fit anywhere then the place with the least overflow

	// choices: Array

	//		Array of elements like: {corner: 'TL', pos: {x: 10, y: 20} }

	//		Above example says to put the top-left corner of the node at (10,20)

	//	layoutNode: Function(node, orient)

	//		for things like tooltip, they are displayed differently (and have different dimensions)

	//		based on their orientation relative to the parent.   This adjusts the popup based on orientation.

	// get {x: 10, y: 10, w: 100, h:100} type obj representing position of

	// viewport over document

	var view = dijit.getViewport();

	// This won't work if the node is inside a <div style="position: relative">,

	// so reattach it to document.body.   (Otherwise, the positioning will be wrong

	// and also it might get cutoff)

	if(!node.parentNode || String(node.parentNode.tagName).toLowerCase() != "body"){

		dojo.body().appendChild(node);

	}

	var best=null;

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

		var corner = choices[i].corner;

		var pos = choices[i].pos;

		// configure node to be displayed in given position relative to button

		// (need to do this in order to get an accurate size for the node, because

		// a tooltips size changes based on position, due to triangle)

		if(layoutNode){

			layoutNode(corner);

		}

		// get node's size

		var oldDisplay = node.style.display;

		var oldVis = node.style.visibility;

		node.style.visibility = "hidden";

		node.style.display = "";

		var mb = dojo.marginBox(node);

		node.style.display = oldDisplay;

		node.style.visibility = oldVis;

		// coordinates and size of node with specified corner placed at pos,

		// and clipped by viewport

		var startX = (corner.charAt(1)=='L' ? pos.x : Math.max(view.l, pos.x - mb.w)),

			startY = (corner.charAt(0)=='T' ? pos.y : Math.max(view.t, pos.y -  mb.h)),

			endX = (corner.charAt(1)=='L' ? Math.min(view.l+view.w, startX+mb.w) : pos.x),

			endY = (corner.charAt(0)=='T' ? Math.min(view.t+view.h, startY+mb.h) : pos.y),

			width = endX-startX,

			height = endY-startY,

			overflow = (mb.w-width) + (mb.h-height);

		if(best==null || overflow<best.overflow){

			best = {

				corner: corner,

				aroundCorner: choices[i].aroundCorner,

				x: startX,

				y: startY,

				w: width,

				h: height,

				overflow: overflow

			};

		}

		if(overflow==0){

			break;

		}

	}

	node.style.left = best.x + "px";

	node.style.top = best.y + "px";

	return best;

}

dijit.placeOnScreenAroundElement = function(

	/* DomNode */		node,

	/* DomNode */		aroundNode,

	/* Object */		aroundCorners,

	/* Function */		layoutNode){

	//	summary

	//	Like placeOnScreen, except it accepts aroundNode instead of x,y

	//	and attempts to place node around it.  Uses margin box dimensions.

	//

	//	aroundCorners

	//		specify Which corner of aroundNode should be

	//		used to place the node => which corner(s) of node to use (see the

	//		corners parameter in dijit.placeOnScreen)

	//		e.g. {'TL': 'BL', 'BL': 'TL'}

	//

	//	layoutNode: Function(node, orient)

	//		for things like tooltip, they are displayed differently (and have different dimensions)

	//		based on their orientation relative to the parent.   This adjusts the popup based on orientation.

	// get coordinates of aroundNode

	aroundNode = dojo.byId(aroundNode);

	var oldDisplay = aroundNode.style.display;

	aroundNode.style.display="";

	// #3172: use the slightly tighter border box instead of marginBox

	var aroundNodeW = aroundNode.offsetWidth; //mb.w;

	var aroundNodeH = aroundNode.offsetHeight; //mb.h;

	var aroundNodePos = dojo.coords(aroundNode, true);

	aroundNode.style.display=oldDisplay;

	// Generate list of possible positions for node

	var choices = [];

	for(var nodeCorner in aroundCorners){

		choices.push( {

			aroundCorner: nodeCorner,

			corner: aroundCorners[nodeCorner],

			pos: {

				x: aroundNodePos.x + (nodeCorner.charAt(1)=='L' ? 0 : aroundNodeW),

				y: aroundNodePos.y + (nodeCorner.charAt(0)=='T' ? 0 : aroundNodeH)

			}

		});

	}

	return dijit._place(node, choices, layoutNode);

}

}