dijit-rails 0.11.0 → 0.14.0

data/vendor/assets/javascripts/dijit/nls/zh/common.js.uncompressed.js

@@ -1,8 +0,0 @@
-define(
-"dijit/nls/zh/common", ({
-	buttonOk: "确定",
-	buttonCancel: "取消",
-	buttonSave: "保存",
-	itemClose: "关闭"
-})
-);

data/vendor/assets/javascripts/dijit/nls/zh/loading.js.uncompressed.js

@@ -1,6 +0,0 @@
-define(
-"dijit/nls/zh/loading", ({
-	loadingState: "正在加载...",
-	errorState: "对不起，发生了错误"
-})
-);

data/vendor/assets/javascripts/dijit/place.js.uncompressed.js

@@ -1,367 +0,0 @@
-define("dijit/place", [
-	"dojo/_base/array", // array.forEach array.map array.some
-	"dojo/dom-geometry", // domGeometry.position
-	"dojo/dom-style", // domStyle.getComputedStyle
-	"dojo/_base/kernel", // kernel.deprecated
-	"dojo/_base/window", // win.body
-	"dojo/window", // winUtils.getBox
-	"./main"	// dijit (defining dijit.place to match API doc)
-], function(array, domGeometry, domStyle, kernel, win, winUtils, dijit){
-
-	// module:
-	//		dijit/place
-
-
-	function _place(/*DomNode*/ node, choices, layoutNode, aroundNodeCoords){
-		// 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, aroundNodeCorner, nodeCorner, size)
-		//		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.
-		//		It also passes in the available size for the popup, which is useful for tooltips to
-		//		tell them that their width is limited to a certain amount.	 layoutNode() may return a value expressing
-		//		how much the popup had to be modified to fit into the available space.	 This is used to determine
-		//		what the best placement is.
-		// aroundNodeCoords: Object
-		//		Size of aroundNode, ex: {w: 200, h: 50}
-
-		// get {x: 10, y: 10, w: 100, h:100} type obj representing position of
-		// viewport over document
-		var view = winUtils.getBox(node.ownerDocument);
-
-		// This won't work if the node is inside a <div style="position: relative">,
-		// so reattach it to win.doc.body.	 (Otherwise, the positioning will be wrong
-		// and also it might get cutoff)
-		if(!node.parentNode || String(node.parentNode.tagName).toLowerCase() != "body"){
-			win.body(node.ownerDocument).appendChild(node);
-		}
-
-		var best = null;
-		array.some(choices, function(choice){
-			var corner = choice.corner;
-			var pos = choice.pos;
-			var overflow = 0;
-
-			// calculate amount of space available given specified position of node
-			var spaceAvailable = {
-				w: {
-					'L': view.l + view.w - pos.x,
-					'R': pos.x - view.l,
-					'M': view.w
-				   }[corner.charAt(1)],
-				h: {
-					'T': view.t + view.h - pos.y,
-					'B': pos.y - view.t,
-					'M': view.h
-				   }[corner.charAt(0)]
-			};
-
-			// Clear left/right position settings set earlier so they don't interfere with calculations,
-			// specifically when layoutNode() (a.k.a. Tooltip.orient()) measures natural width of Tooltip
-			var s = node.style;
-			s.left = s.right = "auto";
-
-			// 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 tooltip's size changes based on position, due to triangle)
-			if(layoutNode){
-				var res = layoutNode(node, choice.aroundCorner, corner, spaceAvailable, aroundNodeCoords);
-				overflow = typeof res == "undefined" ? 0 : res;
-			}
-
-			// get node's size
-			var style = node.style;
-			var oldDisplay = style.display;
-			var oldVis = style.visibility;
-			if(style.display == "none"){
-				style.visibility = "hidden";
-				style.display = "";
-			}
-			var bb = domGeometry.position(node);
-			style.display = oldDisplay;
-			style.visibility = oldVis;
-
-			// coordinates and size of node with specified corner placed at pos,
-			// and clipped by viewport
-			var
-				startXpos = {
-					'L': pos.x,
-					'R': pos.x - bb.w,
-					'M': Math.max(view.l, Math.min(view.l + view.w, pos.x + (bb.w >> 1)) - bb.w) // M orientation is more flexible
-				}[corner.charAt(1)],
-				startYpos = {
-					'T': pos.y,
-					'B': pos.y - bb.h,
-					'M': Math.max(view.t, Math.min(view.t + view.h, pos.y + (bb.h >> 1)) - bb.h)
-				}[corner.charAt(0)],
-				startX = Math.max(view.l, startXpos),
-				startY = Math.max(view.t, startYpos),
-				endX = Math.min(view.l + view.w, startXpos + bb.w),
-				endY = Math.min(view.t + view.h, startYpos + bb.h),
-				width = endX - startX,
-				height = endY - startY;
-
-			overflow += (bb.w - width) + (bb.h - height);
-
-			if(best == null || overflow < best.overflow){
-				best = {
-					corner: corner,
-					aroundCorner: choice.aroundCorner,
-					x: startX,
-					y: startY,
-					w: width,
-					h: height,
-					overflow: overflow,
-					spaceAvailable: spaceAvailable
-				};
-			}
-
-			return !overflow;
-		});
-
-		// In case the best position is not the last one we checked, need to call
-		// layoutNode() again.
-		if(best.overflow && layoutNode){
-			layoutNode(node, best.aroundCorner, best.corner, best.spaceAvailable, aroundNodeCoords);
-		}
-
-		// And then position the node.  Do this last, after the layoutNode() above
-		// has sized the node, due to browser quirks when the viewport is scrolled
-		// (specifically that a Tooltip will shrink to fit as though the window was
-		// scrolled to the left).
-		//
-		// In RTL mode, set style.right rather than style.left so in the common case,
-		// window resizes move the popup along with the aroundNode.
-		var l = domGeometry.isBodyLtr(node.ownerDocument),
-			s = node.style;
-		s.top = best.y + "px";
-		s[l ? "left" : "right"] = (l ? best.x : view.w - best.x - best.w) + "px";
-		s[l ? "right" : "left"] = "auto";	// needed for FF or else tooltip goes to far left
-
-		return best;
-	}
-
-	var place = {
-		// summary:
-		//		Code to place a DOMNode relative to another DOMNode.
-		//		Load using require(["dijit/place"], function(place){ ... }).
-
-		at: function(node, pos, corners, padding){
-			// summary:
-			//		Positions one of the node's corners at specified position
-			//		such that node is fully visible in viewport.
-			// description:
-			//		NOTE: node is assumed to be absolutely or relatively positioned.
-			// node: DOMNode
-			//		The node to position
-			// pos: dijit/place.__Position
-			//		Object like {x: 10, y: 20}
-			// corners: String[]
-			//		Array of Strings representing order to try corners in, like ["TR", "BL"].
-			//		Possible values are:
-			//
-			//		- "BL" - bottom left
-			//		- "BR" - bottom right
-			//		- "TL" - top left
-			//		- "TR" - top right
-			// padding: dijit/place.__Position?
-			//		optional param to set padding, to put some buffer around the element you want to position.
-			// example:
-			//		Try to place node's top right corner at (10,20).
-			//		If that makes node go (partially) off screen, then try placing
-			//		bottom left corner at (10,20).
-			//	|	place(node, {x: 10, y: 20}, ["TR", "BL"])
-			var choices = array.map(corners, function(corner){
-				var c = { corner: corner, pos: {x:pos.x,y:pos.y} };
-				if(padding){
-					c.pos.x += corner.charAt(1) == 'L' ? padding.x : -padding.x;
-					c.pos.y += corner.charAt(0) == 'T' ? padding.y : -padding.y;
-				}
-				return c;
-			});
-
-			return _place(node, choices);
-		},
-
-		around: function(
-			/*DomNode*/		node,
-			/*DomNode|dijit/place.__Rectangle*/ anchor,
-			/*String[]*/	positions,
-			/*Boolean*/		leftToRight,
-			/*Function?*/	layoutNode){
-
-			// summary:
-			//		Position node adjacent or kitty-corner to anchor
-			//		such that it's fully visible in viewport.
-			// description:
-			//		Place node such that corner of node touches a corner of
-			//		aroundNode, and that node is fully visible.
-			// anchor:
-			//		Either a DOMNode or a rectangle (object with x, y, width, height).
-			// positions:
-			//		Ordered list of positions to try matching up.
-			//
-			//		- before: places drop down to the left of the anchor node/widget, or to the right in the case
-			//			of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down
-			//			with the top of the anchor, or the bottom of the drop down with bottom of the anchor.
-			//		- after: places drop down to the right of the anchor node/widget, or to the left in the case
-			//			of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down
-			//			with the top of the anchor, or the bottom of the drop down with bottom of the anchor.
-			//		- before-centered: centers drop down to the left of the anchor node/widget, or to the right
-			//			 in the case of RTL scripts like Hebrew and Arabic
-			//		- after-centered: centers drop down to the right of the anchor node/widget, or to the left
-			//			 in the case of RTL scripts like Hebrew and Arabic
-			//		- above-centered: drop down is centered above anchor node
-			//		- above: drop down goes above anchor node, left sides aligned
-			//		- above-alt: drop down goes above anchor node, right sides aligned
-			//		- below-centered: drop down is centered above anchor node
-			//		- below: drop down goes below anchor node
-			//		- below-alt: drop down goes below anchor node, right sides aligned
-			// layoutNode: Function(node, aroundNodeCorner, nodeCorner)
-			//		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.
-			// leftToRight:
-			//		True if widget is LTR, false if widget is RTL.   Affects the behavior of "above" and "below"
-			//		positions slightly.
-			// example:
-			//	|	placeAroundNode(node, aroundNode, {'BL':'TL', 'TR':'BR'});
-			//		This will try to position node such that node's top-left corner is at the same position
-			//		as the bottom left corner of the aroundNode (ie, put node below
-			//		aroundNode, with left edges aligned).	If that fails it will try to put
-			//		the bottom-right corner of node where the top right corner of aroundNode is
-			//		(ie, put node above aroundNode, with right edges aligned)
-			//
-
-			// if around is a DOMNode (or DOMNode id), convert to coordinates
-			var aroundNodePos = (typeof anchor == "string" || "offsetWidth" in anchor)
-				? domGeometry.position(anchor, true)
-				: anchor;
-
-			// Compute position and size of visible part of anchor (it may be partially hidden by ancestor nodes w/scrollbars)
-			if(anchor.parentNode){
-				// ignore nodes between position:relative and position:absolute
-				var sawPosAbsolute = domStyle.getComputedStyle(anchor).position == "absolute";
-				var parent = anchor.parentNode;
-				while(parent && parent.nodeType == 1 && parent.nodeName != "BODY"){  //ignoring the body will help performance
-					var parentPos = domGeometry.position(parent, true),
-						pcs = domStyle.getComputedStyle(parent);
-					if(/relative|absolute/.test(pcs.position)){
-						sawPosAbsolute = false;
-					}
-					if(!sawPosAbsolute && /hidden|auto|scroll/.test(pcs.overflow)){
-						var bottomYCoord = Math.min(aroundNodePos.y + aroundNodePos.h, parentPos.y + parentPos.h);
-						var rightXCoord = Math.min(aroundNodePos.x + aroundNodePos.w, parentPos.x + parentPos.w);
-						aroundNodePos.x = Math.max(aroundNodePos.x, parentPos.x);
-						aroundNodePos.y = Math.max(aroundNodePos.y, parentPos.y);
-						aroundNodePos.h = bottomYCoord - aroundNodePos.y;
-						aroundNodePos.w = rightXCoord - aroundNodePos.x;
-					}
-					if(pcs.position == "absolute"){
-						sawPosAbsolute = true;
-					}
-					parent = parent.parentNode;
-				}
-			}			
-
-			var x = aroundNodePos.x,
-				y = aroundNodePos.y,
-				width = "w" in aroundNodePos ? aroundNodePos.w : (aroundNodePos.w = aroundNodePos.width),
-				height = "h" in aroundNodePos ? aroundNodePos.h : (kernel.deprecated("place.around: dijit/place.__Rectangle: { x:"+x+", y:"+y+", height:"+aroundNodePos.height+", width:"+width+" } has been deprecated.  Please use { x:"+x+", y:"+y+", h:"+aroundNodePos.height+", w:"+width+" }", "", "2.0"), aroundNodePos.h = aroundNodePos.height);
-
-			// Convert positions arguments into choices argument for _place()
-			var choices = [];
-			function push(aroundCorner, corner){
-				choices.push({
-					aroundCorner: aroundCorner,
-					corner: corner,
-					pos: {
-						x: {
-							'L': x,
-							'R': x + width,
-							'M': x + (width >> 1)
-						   }[aroundCorner.charAt(1)],
-						y: {
-							'T': y,
-							'B': y + height,
-							'M': y + (height >> 1)
-						   }[aroundCorner.charAt(0)]
-					}
-				})
-			}
-			array.forEach(positions, function(pos){
-				var ltr =  leftToRight;
-				switch(pos){
-					case "above-centered":
-						push("TM", "BM");
-						break;
-					case "below-centered":
-						push("BM", "TM");
-						break;
-					case "after-centered":
-						ltr = !ltr;
-						// fall through
-					case "before-centered":
-						push(ltr ? "ML" : "MR", ltr ? "MR" : "ML");
-						break;
-					case "after":
-						ltr = !ltr;
-						// fall through
-					case "before":
-						push(ltr ? "TL" : "TR", ltr ? "TR" : "TL");
-						push(ltr ? "BL" : "BR", ltr ? "BR" : "BL");
-						break;
-					case "below-alt":
-						ltr = !ltr;
-						// fall through
-					case "below":
-						// first try to align left borders, next try to align right borders (or reverse for RTL mode)
-						push(ltr ? "BL" : "BR", ltr ? "TL" : "TR");
-						push(ltr ? "BR" : "BL", ltr ? "TR" : "TL");
-						break;
-					case "above-alt":
-						ltr = !ltr;
-						// fall through
-					case "above":
-						// first try to align left borders, next try to align right borders (or reverse for RTL mode)
-						push(ltr ? "TL" : "TR", ltr ? "BL" : "BR");
-						push(ltr ? "TR" : "TL", ltr ? "BR" : "BL");
-						break;
-					default:
-						// To assist dijit/_base/place, accept arguments of type {aroundCorner: "BL", corner: "TL"}.
-						// Not meant to be used directly.
-						push(pos.aroundCorner, pos.corner);
-				}
-			});
-
-			var position = _place(node, choices, layoutNode, {w: width, h: height});
-			position.aroundNodePos = aroundNodePos;
-
-			return position;
-		}
-	};
-
-	/*=====
-	place.__Position = {
-		// x: Integer
-		//		horizontal coordinate in pixels, relative to document body
-		// y: Integer
-		//		vertical coordinate in pixels, relative to document body
-	};
-	place.__Rectangle = {
-		// x: Integer
-		//		horizontal offset in pixels, relative to document body
-		// y: Integer
-		//		vertical offset in pixels, relative to document body
-		// w: Integer
-		//		width in pixels.   Can also be specified as "width" for backwards-compatibility.
-		// h: Integer
-		//		height in pixels.   Can also be specified as "height" for backwards-compatibility.
-	};
-	=====*/
-
-	return dijit.place = place;	// setting dijit.place for back-compat, remove for 2.0
-});

data/vendor/assets/javascripts/dijit/popup.js.uncompressed.js

@@ -1,318 +0,0 @@
-define("dijit/popup", [
-	"dojo/_base/array", // array.forEach array.some
-	"dojo/aspect",
-	"dojo/_base/connect",	// connect._keypress
-	"dojo/_base/declare", // declare
-	"dojo/dom", // dom.isDescendant
-	"dojo/dom-attr", // domAttr.set
-	"dojo/dom-construct", // domConstruct.create domConstruct.destroy
-	"dojo/dom-geometry", // domGeometry.isBodyLtr
-	"dojo/dom-style", // domStyle.set
-	"dojo/_base/event", // event.stop
-	"dojo/keys",
-	"dojo/_base/lang", // lang.hitch
-	"dojo/on",
-	"dojo/sniff", // has("ie") has("mozilla")
-	"./place",
-	"./BackgroundIframe",
-	"./main"	// dijit (defining dijit.popup to match API doc)
-], function(array, aspect, connect, declare, dom, domAttr, domConstruct, domGeometry, domStyle, event, keys, lang, on, has,
-			place, BackgroundIframe, dijit){
-
-	// module:
-	//		dijit/popup
-
-	/*=====
-	var __OpenArgs = {
-		// popup: Widget
-		//		widget to display
-		// parent: Widget
-		//		the button etc. that is displaying this popup
-		// around: DomNode
-		//		DOM node (typically a button); place popup relative to this node.  (Specify this *or* "x" and "y" parameters.)
-		// x: Integer
-		//		Absolute horizontal position (in pixels) to place node at.  (Specify this *or* "around" parameter.)
-		// y: Integer
-		//		Absolute vertical position (in pixels) to place node at.  (Specify this *or* "around" parameter.)
-		// orient: Object|String
-		//		When the around parameter is specified, orient should be a list of positions to try, ex:
-		//	|	[ "below", "above" ]
-		//		For backwards compatibility it can also be an (ordered) hash of tuples of the form
-		//		(around-node-corner, popup-node-corner), ex:
-		//	|	{ "BL": "TL", "TL": "BL" }
-		//		where BL means "bottom left" and "TL" means "top left", etc.
-		//
-		//		dijit/popup.open() tries to position the popup according to each specified position, in order,
-		//		until the popup appears fully within the viewport.
-		//
-		//		The default value is ["below", "above"]
-		//
-		//		When an (x,y) position is specified rather than an around node, orient is either
-		//		"R" or "L".  R (for right) means that it tries to put the popup to the right of the mouse,
-		//		specifically positioning the popup's top-right corner at the mouse position, and if that doesn't
-		//		fit in the viewport, then it tries, in order, the bottom-right corner, the top left corner,
-		//		and the top-right corner.
-		// onCancel: Function
-		//		callback when user has canceled the popup by:
-		//
-		//		1. hitting ESC or
-		//		2. by using the popup widget's proprietary cancel mechanism (like a cancel button in a dialog);
-		//		   i.e. whenever popupWidget.onCancel() is called, args.onCancel is called
-		// onClose: Function
-		//		callback whenever this popup is closed
-		// onExecute: Function
-		//		callback when user "executed" on the popup/sub-popup by selecting a menu choice, etc. (top menu only)
-		// padding: place.__Position
-		//		adding a buffer around the opening position. This is only useful when around is not set.
-	};
-	=====*/
-
-	function destroyWrapper(){
-		// summary:
-		//		Function to destroy wrapper when popup widget is destroyed.
-		//		Left in this scope to avoid memory leak on IE8 on refresh page, see #15206.
-		if(this._popupWrapper){
-			domConstruct.destroy(this._popupWrapper);
-			delete this._popupWrapper;
-		}
-	}
-
-	var PopupManager = declare(null, {
-		// summary:
-		//		Used to show drop downs (ex: the select list of a ComboBox)
-		//		or popups (ex: right-click context menus).
-
-		// _stack: dijit/_WidgetBase[]
-		//		Stack of currently popped up widgets.
-		//		(someone opened _stack[0], and then it opened _stack[1], etc.)
-		_stack: [],
-
-		// _beginZIndex: Number
-		//		Z-index of the first popup.   (If first popup opens other
-		//		popups they get a higher z-index.)
-		_beginZIndex: 1000,
-
-		_idGen: 1,
-
-		_createWrapper: function(/*Widget*/ widget){
-			// summary:
-			//		Initialization for widgets that will be used as popups.
-			//		Puts widget inside a wrapper DIV (if not already in one),
-			//		and returns pointer to that wrapper DIV.
-
-			var wrapper = widget._popupWrapper,
-				node = widget.domNode;
-
-			if(!wrapper){
-				// Create wrapper <div> for when this widget [in the future] will be used as a popup.
-				// This is done early because of IE bugs where creating/moving DOM nodes causes focus
-				// to go wonky, see tests/robot/Toolbar.html to reproduce
-				wrapper = domConstruct.create("div", {
-					"class":"dijitPopup",
-					style:{ display: "none"},
-					role: "presentation"
-				}, widget.ownerDocumentBody);
-				wrapper.appendChild(node);
-
-				var s = node.style;
-				s.display = "";
-				s.visibility = "";
-				s.position = "";
-				s.top = "0px";
-
-				widget._popupWrapper = wrapper;
-				aspect.after(widget, "destroy", destroyWrapper, true);
-			}
-
-			return wrapper;
-		},
-
-		moveOffScreen: function(/*Widget*/ widget){
-			// summary:
-			//		Moves the popup widget off-screen.
-			//		Do not use this method to hide popups when not in use, because
-			//		that will create an accessibility issue: the offscreen popup is
-			//		still in the tabbing order.
-
-			// Create wrapper if not already there
-			var wrapper = this._createWrapper(widget);
-
-			domStyle.set(wrapper, {
-				visibility: "hidden",
-				top: "-9999px",		// prevent transient scrollbar causing misalign (#5776), and initial flash in upper left (#10111)
-				display: ""
-			});
-		},
-
-		hide: function(/*Widget*/ widget){
-			// summary:
-			//		Hide this popup widget (until it is ready to be shown).
-			//		Initialization for widgets that will be used as popups
-			//
-			//		Also puts widget inside a wrapper DIV (if not already in one)
-			//
-			//		If popup widget needs to layout it should
-			//		do so when it is made visible, and popup._onShow() is called.
-
-			// Create wrapper if not already there
-			var wrapper = this._createWrapper(widget);
-
-			domStyle.set(wrapper, "display", "none");
-		},
-
-		getTopPopup: function(){
-			// summary:
-			//		Compute the closest ancestor popup that's *not* a child of another popup.
-			//		Ex: For a TooltipDialog with a button that spawns a tree of menus, find the popup of the button.
-			var stack = this._stack;
-			for(var pi=stack.length-1; pi > 0 && stack[pi].parent === stack[pi-1].widget; pi--){
-				/* do nothing, just trying to get right value for pi */
-			}
-			return stack[pi];
-		},
-
-		open: function(/*__OpenArgs*/ args){
-			// summary:
-			//		Popup the widget at the specified position
-			//
-			// example:
-			//		opening at the mouse position
-			//		|		popup.open({popup: menuWidget, x: evt.pageX, y: evt.pageY});
-			//
-			// example:
-			//		opening the widget as a dropdown
-			//		|		popup.open({parent: this, popup: menuWidget, around: this.domNode, onClose: function(){...}});
-			//
-			//		Note that whatever widget called dijit/popup.open() should also listen to its own _onBlur callback
-			//		(fired from _base/focus.js) to know that focus has moved somewhere else and thus the popup should be closed.
-
-			var stack = this._stack,
-				widget = args.popup,
-				orient = args.orient || ["below", "below-alt", "above", "above-alt"],
-				ltr = args.parent ? args.parent.isLeftToRight() : domGeometry.isBodyLtr(widget.ownerDocument),
-				around = args.around,
-				id = (args.around && args.around.id) ? (args.around.id+"_dropdown") : ("popup_"+this._idGen++);
-
-			// If we are opening a new popup that isn't a child of a currently opened popup, then
-			// close currently opened popup(s).   This should happen automatically when the old popups
-			// gets the _onBlur() event, except that the _onBlur() event isn't reliable on IE, see [22198].
-			while(stack.length && (!args.parent || !dom.isDescendant(args.parent.domNode, stack[stack.length-1].widget.domNode))){
-				this.close(stack[stack.length-1].widget);
-			}
-
-			// Get pointer to popup wrapper, and create wrapper if it doesn't exist
-			var wrapper = this._createWrapper(widget);
-
-
-			domAttr.set(wrapper, {
-				id: id,
-				style: {
-					zIndex: this._beginZIndex + stack.length
-				},
-				"class": "dijitPopup " + (widget.baseClass || widget["class"] || "").split(" ")[0] +"Popup",
-				dijitPopupParent: args.parent ? args.parent.id : ""
-			});
-
-			if(has("ie") || has("mozilla")){
-				if(!widget.bgIframe){
-					// setting widget.bgIframe triggers cleanup in _Widget.destroy()
-					widget.bgIframe = new BackgroundIframe(wrapper);
-				}
-			}
-
-			// position the wrapper node and make it visible
-			var best = around ?
-				place.around(wrapper, around, orient, ltr, widget.orient ? lang.hitch(widget, "orient") : null) :
-				place.at(wrapper, args, orient == 'R' ? ['TR','BR','TL','BL'] : ['TL','BL','TR','BR'], args.padding);
-
-			wrapper.style.display = "";
-			wrapper.style.visibility = "visible";
-			widget.domNode.style.visibility = "visible";	// counteract effects from _HasDropDown
-
-			var handlers = [];
-
-			// provide default escape and tab key handling
-			// (this will work for any widget, not just menu)
-			handlers.push(on(wrapper, connect._keypress, lang.hitch(this, function(evt){
-				if(evt.charOrCode == keys.ESCAPE && args.onCancel){
-					event.stop(evt);
-					args.onCancel();
-				}else if(evt.charOrCode === keys.TAB){
-					event.stop(evt);
-					var topPopup = this.getTopPopup();
-					if(topPopup && topPopup.onCancel){
-						topPopup.onCancel();
-					}
-				}
-			})));
-
-			// watch for cancel/execute events on the popup and notify the caller
-			// (for a menu, "execute" means clicking an item)
-			if(widget.onCancel && args.onCancel){
-				handlers.push(widget.on("cancel", args.onCancel));
-			}
-
-			handlers.push(widget.on(widget.onExecute ? "execute" : "change", lang.hitch(this, function(){
-				var topPopup = this.getTopPopup();
-				if(topPopup && topPopup.onExecute){
-					topPopup.onExecute();
-				}
-			})));
-
-			stack.push({
-				widget: widget,
-				parent: args.parent,
-				onExecute: args.onExecute,
-				onCancel: args.onCancel,
-				onClose: args.onClose,
-				handlers: handlers
-			});
-
-			if(widget.onOpen){
-				// TODO: in 2.0 standardize onShow() (used by StackContainer) and onOpen() (used here)
-				widget.onOpen(best);
-			}
-
-			return best;
-		},
-
-		close: function(/*Widget?*/ popup){
-			// summary:
-			//		Close specified popup and any popups that it parented.
-			//		If no popup is specified, closes all popups.
-
-			var stack = this._stack;
-
-			// Basically work backwards from the top of the stack closing popups
-			// until we hit the specified popup, but IIRC there was some issue where closing
-			// a popup would cause others to close too.  Thus if we are trying to close B in [A,B,C]
-			// closing C might close B indirectly and then the while() condition will run where stack==[A]...
-			// so the while condition is constructed defensively.
-			while((popup && array.some(stack, function(elem){return elem.widget == popup;})) ||
-				(!popup && stack.length)){
-				var top = stack.pop(),
-					widget = top.widget,
-					onClose = top.onClose;
-
-				if(widget.onClose){
-					// TODO: in 2.0 standardize onHide() (used by StackContainer) and onClose() (used here)
-					widget.onClose();
-				}
-
-				var h;
-				while(h = top.handlers.pop()){ h.remove(); }
-
-				// Hide the widget and it's wrapper unless it has already been destroyed in above onClose() etc.
-				if(widget && widget.domNode){
-					this.hide(widget);
-				}
-
-				if(onClose){
-					onClose();
-				}
-			}
-		}
-	});
-
-	return (dijit.popup = new PopupManager());
-});