text: if(!dojo._hasResource["dijit.Menu"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
  dojo._hasResource["dijit.Menu"] = true;
  dojo.provide("dijit.Menu");
  
  dojo.require("dijit._Widget");
  dojo.require("dijit._Container");
  dojo.require("dijit._Templated");
  
  dojo.declare(
  	"dijit.Menu",
  	[dijit._Widget, dijit._Templated, dijit._KeyNavContainer],
  {
  	constructor: function() {
  		this._bindings = [];
  	},
  
  	templateString:
  			'<table class="dijit dijitMenu dijitReset dijitMenuTable" waiRole="menu" dojoAttachEvent="onkeypress:_onKeyPress">' +
  				'<tbody class="dijitReset" dojoAttachPoint="containerNode"></tbody>'+
  			'</table>',
  
  	// targetNodeIds: String[]
  	//	Array of dom node ids of nodes to attach to.
  	//	Fill this with nodeIds upon widget creation and it becomes context menu for those nodes.
  	targetNodeIds: [],
  
  	// contextMenuForWindow: Boolean
  	//	if true, right clicking anywhere on the window will cause this context menu to open;
  	//	if false, must specify targetNodeIds
  	contextMenuForWindow: false,
  
  	// parentMenu: Widget
  	// pointer to menu that displayed me
  	parentMenu: null,
  
  	// popupDelay: Integer
  	//	number of milliseconds before hovering (without clicking) causes the popup to automatically open
  	popupDelay: 500,
  
  	// _contextMenuWithMouse: Boolean
  	//	used to record mouse and keyboard events to determine if a context
  	//	menu is being opened with the keyboard or the mouse
  	_contextMenuWithMouse: false,
  
  	postCreate: function(){
  		if(this.contextMenuForWindow){
  			this.bindDomNode(dojo.body());
  		}else{
  			dojo.forEach(this.targetNodeIds, this.bindDomNode, this);
  		}
  		this.connectKeyNavHandlers([dojo.keys.UP_ARROW], [dojo.keys.DOWN_ARROW]);
  	},
  
  	startup: function(){
  		dojo.forEach(this.getChildren(), function(child){ child.startup(); });
  		this.startupKeyNavChildren();
  	},
  
  	onExecute: function(){
  		// summary: attach point for notification about when a menu item has been executed
  	},
  
  	onCancel: function(/*Boolean*/ closeAll){
  		// summary: attach point for notification about when the user cancels the current menu
  	},
  
  	_moveToPopup: function(/*Event*/ evt){
  		if(this.focusedChild && this.focusedChild.popup && !this.focusedChild.disabled){
  			this.focusedChild._onClick(evt);
  		}
  	},
  
  	_onKeyPress: function(/*Event*/ evt){
  		// summary
  		//	Handle keyboard based menu navigation.
  		if(evt.ctrlKey || evt.altKey){ return; }
  
  		switch(evt.keyCode){
  			case dojo.keys.RIGHT_ARROW:
  				this._moveToPopup(evt);
  				dojo.stopEvent(evt);
  				break;
  			case dojo.keys.LEFT_ARROW:
  				if(this.parentMenu){
  					this.onCancel(false);
  				}else{
  					dojo.stopEvent(evt);
  				}
  				break;
  		}
  	},
  
  	onItemHover: function(/*MenuItem*/ item){
  		this.focusChild(item);
  
  		if(this.focusedChild.popup && !this.focusedChild.disabled && !this.hover_timer){
  			this.hover_timer = setTimeout(dojo.hitch(this, "_openPopup"), this.popupDelay);
  		}
  	},
  
  	_onChildBlur: function(item){
  		// Close all popups that are open and descendants of this menu
  		dijit.popup.close(item.popup);
  		item._blur();
  		this._stopPopupTimer();
  	},
  
  	onItemUnhover: function(/*MenuItem*/ item){
  	},
  
  	_stopPopupTimer: function(){
  		if(this.hover_timer){
  			clearTimeout(this.hover_timer);
  			this.hover_timer = null;
  		}
  	},
  
  	_getTopMenu: function(){
  		for(var top=this; top.parentMenu; top=top.parentMenu);
  		return top;
  	},
  
  	onItemClick: function(/*Widget*/ item){
  		// summary: user defined function to handle clicks on an item
  		// summary: internal function for clicks
  		if(item.disabled){ return false; }
  
  		if(item.popup){
  			if(!this.is_open){
  				this._openPopup();
  			}
  		}else{
  			// before calling user defined handler, close hierarchy of menus
  			// and restore focus to place it was when menu was opened
  			this.onExecute();
  
  			// user defined handler for click
  			item.onClick();
  		}
  	},
  
  	// thanks burstlib!
  	_iframeContentWindow: function(/* HTMLIFrameElement */iframe_el) {
  		//	summary
  		//	returns the window reference of the passed iframe
  		var win = dijit.getDocumentWindow(dijit.Menu._iframeContentDocument(iframe_el)) ||
  			// Moz. TODO: is this available when defaultView isn't?
  			dijit.Menu._iframeContentDocument(iframe_el)['__parent__'] ||
  			(iframe_el.name && document.frames[iframe_el.name]) || null;
  		return win;	//	Window
  	},
  
  	_iframeContentDocument: function(/* HTMLIFrameElement */iframe_el){
  		//	summary
  		//	returns a reference to the document object inside iframe_el
  		var doc = iframe_el.contentDocument // W3
  			|| (iframe_el.contentWindow && iframe_el.contentWindow.document) // IE
  			|| (iframe_el.name && document.frames[iframe_el.name] && document.frames[iframe_el.name].document)
  			|| null;
  		return doc;	//	HTMLDocument
  	},
  
  	bindDomNode: function(/*String|DomNode*/ node){
  		// summary: attach menu to given node
  		node = dojo.byId(node);
  
  		//TODO: this is to support context popups in Editor.  Maybe this shouldn't be in dijit.Menu
  		var win = dijit.getDocumentWindow(node.ownerDocument);
  		if(node.tagName.toLowerCase()=="iframe"){
  			win = this._iframeContentWindow(node);
  			node = dojo.withGlobal(win, dojo.body);
  		}
  
  		// to capture these events at the top level,
  		// attach to document, not body
  		var cn = (node == dojo.body() ? dojo.doc : node);
  
  		node[this.id] = this._bindings.push([
  			dojo.connect(cn, "oncontextmenu", this, "_openMyself"),
  			dojo.connect(cn, "onkeydown", this, "_contextKey"),
  			dojo.connect(cn, "onmousedown", this, "_contextMouse")
  		]);
  	},
  
  	unBindDomNode: function(/*String|DomNode*/ nodeName){
  		// summary: detach menu from given node
  		var node = dojo.byId(nodeName);
  		var bid = node[this.id]-1, b = this._bindings[bid];
  		dojo.forEach(b, dojo.disconnect);
  		delete this._bindings[bid];
  	},
  
  	_contextKey: function(e){
  		this._contextMenuWithMouse = false;
  		if (e.keyCode == dojo.keys.F10) {
  			dojo.stopEvent(e);
  			if (e.shiftKey && e.type=="keydown") {
  				// FF: copying the wrong property from e will cause the system
  				// context menu to appear in spite of stopEvent. Don't know
  				// exactly which properties cause this effect.
  				var _e = { target: e.target, pageX: e.pageX, pageY: e.pageY };
  				_e.preventDefault = _e.stopPropagation = function(){};
  				// IE: without the delay, focus work in "open" causes the system
  				// context menu to appear in spite of stopEvent.
  				window.setTimeout(dojo.hitch(this, function(){ this._openMyself(_e); }), 1);
  			}
  		}
  	},
  
  	_contextMouse: function(e){
  		this._contextMenuWithMouse = true;
  	},
  
  	_openMyself: function(/*Event*/ e){
  		// summary:
  		//		Internal function for opening myself when the user
  		//		does a right-click or something similar
  
  		dojo.stopEvent(e);
  
  		// Get coordinates.
  		// if we are opening the menu with the mouse or on safari open
  		// the menu at the mouse cursor
  		// (Safari does not have a keyboard command to open the context menu
  		// and we don't currently have a reliable way to determine
  		// _contextMenuWithMouse on Safari)
  		var x,y;
  		if(dojo.isSafari || this._contextMenuWithMouse){
  			x=e.pageX;
  			y=e.pageY;
  		}else{
  			// otherwise open near e.target
  			var coords = dojo.coords(e.target, true);
  			x = coords.x + 10;
  			y = coords.y + 10;
  		}
  
  		var self=this;
  		var savedFocus = dijit.getFocus(this);
  		function closeAndRestoreFocus(){
  			// user has clicked on a menu or popup
  			dijit.focus(savedFocus);
  			dijit.popup.close(self);
  		}
  		dijit.popup.open({
  			popup: this,
  			x: x,
  			y: y,
  			onExecute: closeAndRestoreFocus,
  			onCancel: closeAndRestoreFocus,
  			orient: this.isLeftToRight() ? 'L' : 'R'
  		});
  		this.focus();
  
  		this._onBlur = function(){
  			// Usually the parent closes the child widget but if this is a context
  			// menu then there is no parent
  			dijit.popup.close(this);
  			// don't try to restore focus; user has clicked another part of the screen
  			// and set focus there
  		}
  	},
  
  	onOpen: function(/*Event*/ e){
  		// summary
  		//		Open menu relative to the mouse
  		this.isShowingNow = true;
  	},
  
  	onClose: function(){
  		// summary: callback when this menu is closed
  		this._stopPopupTimer();
  		this.parentMenu = null;
  		this.isShowingNow = false;
  		this.currentPopup = null;
  		if(this.focusedChild){
  			this._onChildBlur(this.focusedChild);
  			this.focusedChild = null;
  		}
  	},
  
  	_openPopup: function(){
  		// summary: open the popup to the side of the current menu item
  		this._stopPopupTimer();
  		var from_item = this.focusedChild;
  		var popup = from_item.popup;
  
  		if(popup.isShowingNow){ return; }
  		popup.parentMenu = this;
  		var self = this;
  		dijit.popup.open({
  			parent: this,
  			popup: popup,
  			around: from_item.arrowCell,
  			orient: this.isLeftToRight() ? {'TR': 'TL', 'TL': 'TR'} : {'TL': 'TR', 'TR': 'TL'},
  			onCancel: function(){
  				// called when the child menu is canceled
  				dijit.popup.close(popup);
  				from_item.focus();	// put focus back on my node
  				self.currentPopup = null;
  			}
  		});
  
  		this.currentPopup = popup;
  
  		if(popup.focus){
  			popup.focus();
  		}
  	}
  }
  );
  
  dojo.declare(
  	"dijit.MenuItem",
  	[dijit._Widget, dijit._Templated, dijit._Contained],
  {
  	// summary
  	//	A line item in a Menu2
  
  	// Make 3 columns
  	//   icon, label, and expand arrow (BiDi-dependent) indicating sub-menu
  	templateString:
  		 '<tr class="dijitReset dijitMenuItem"'
  		+'dojoAttachEvent="onmouseenter:_onHover,onmouseleave:_onUnhover,ondijitclick:_onClick">'
  		+'<td class="dijitReset"><div class="dijitMenuItemIcon ${iconClass}" dojoAttachPoint="iconNode" ></div></td>'
  		+'<td tabIndex="-1" class="dijitReset dijitMenuItemLabel" dojoAttachPoint="containerNode" waiRole="menuitem"></td>'
  		+'<td class="dijitReset" dojoAttachPoint="arrowCell">'
  			+'<div class="dijitMenuExpand" dojoAttachPoint="expand" style="display:none">'
  			+'<span class="dijitInline dijitArrowNode dijitMenuExpandInner">+</span>'
  			+'</div>'
  		+'</td>'
  		+'</tr>',
  
  	// label: String
  	//	menu text
  	label: '',
  
  	// iconClass: String
  	//	class to apply to div in button to make it display an icon
  	iconClass: "",
  
  	// disabled: Boolean
  	//  if true, the menu item is disabled
  	//  if false, the menu item is enabled
  	disabled: false,
  
  	postCreate: function(){
  		dojo.setSelectable(this.domNode, false);
  		this.setDisabled(this.disabled);
  		if(this.label){
  			this.containerNode.innerHTML=this.label;
  		}
  	},
  
  	_onHover: function(){
  		// summary: callback when mouse is moved onto menu item
  		this.getParent().onItemHover(this);
  	},
  
  	_onUnhover: function(){
  		// summary: callback when mouse is moved off of menu item
  		// if we are unhovering the currently selected item
  		// then unselect it
  		this.getParent().onItemUnhover(this);
  	},
  
  	_onClick: function(evt){
  		this.getParent().onItemClick(this);
  		dojo.stopEvent(evt);
  	},
  
  	onClick: function() {
  		// summary
  		//	User defined function to handle clicks
  	},
  
  	focus: function(){
  		dojo.addClass(this.domNode, 'dijitMenuItemHover');
  		try{
  			dijit.focus(this.containerNode);
  		}catch(e){
  			// this throws on IE (at least) in some scenarios
  		}
  	},
  
  	_blur: function(){
  		dojo.removeClass(this.domNode, 'dijitMenuItemHover');
  	},
  
  	setDisabled: function(/*Boolean*/ value){
  		// summary: enable or disable this menu item
  		this.disabled = value;
  		dojo[value ? "addClass" : "removeClass"](this.domNode, 'dijitMenuItemDisabled');
  		dijit.setWaiState(this.containerNode, 'disabled', value ? 'true' : 'false');
  	}
  });
  
  dojo.declare(
  	"dijit.PopupMenuItem",
  	dijit.MenuItem,
  {
  	_fillContent: function(){
  		// my inner HTML contains both the menu item text and a popup widget, like
  		// <div dojoType="dijit.PopupMenuItem">
  		//		<span>pick me</span>
  		//		<popup> ... </popup>
  		// </div>
  		// the first part holds the menu item text and the second part is the popup
  		if(this.srcNodeRef){
  			var nodes = dojo.query("*", this.srcNodeRef);
  			dijit.PopupMenuItem.superclass._fillContent.call(this, nodes[0]);
  
  			// save pointer to srcNode so we can grab the drop down widget after it's instantiated
  			this.dropDownContainer = this.srcNodeRef;
  		}
  	},
  
  	startup: function(){
  		// we didn't copy the dropdown widget from the this.srcNodeRef, so it's in no-man's
  		// land now.  move it to document.body.
  		if(!this.popup){
  			var node = dojo.query("[widgetId]", this.dropDownContainer)[0];
  			this.popup = dijit.byNode(node);
  		}
  		dojo.body().appendChild(this.popup.domNode);
  
  		this.popup.domNode.style.display="none";
  		dojo.addClass(this.expand, "dijitMenuExpandEnabled");
  		dojo.style(this.expand, "display", "");
  		dijit.setWaiState(this.containerNode, "haspopup", "true");
  	}
  });
  
  dojo.declare(
  	"dijit.MenuSeparator",
  	[dijit._Widget, dijit._Templated, dijit._Contained],
  {
  	// summary
  	//	A line between two menu items
  
  	templateString: '<tr class="dijitMenuSeparator"><td colspan=3>'
  			+'<div class="dijitMenuSeparatorTop"></div>'
  			+'<div class="dijitMenuSeparatorBottom"></div>'
  			+'</td></tr>',
  
  	postCreate: function(){
  		dojo.setSelectable(this.domNode, false);
  	},
  	
  	isFocusable: function(){
  		// summary:
  		//		over ride to always return false
  		return false;
  	}
  });
  
  }
  