--- /dev/null
+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],
+ {
+ // summary
+ // A context menu you can assign to multiple elements
+
+ 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,
+
+ // leftClickToOpen: Boolean
+ // If true, menu will open on left click instead of right click, similiar to a file menu.
+ leftClickToOpen: 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(){
+ if(this._started){ return; }
+
+ dojo.forEach(this.getChildren(), function(child){ child.startup(); });
+ this.startupKeyNavChildren();
+
+ this.inherited(arguments);
+ },
+
+ 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){
+ // summary: Called when cursor is over a MenuItem
+ 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){
+ // summary: Close all popups that are open and descendants of this menu
+ dijit.popup.close(item.popup);
+ item._blur();
+ this._stopPopupTimer();
+ },
+
+ onItemUnhover: function(/*MenuItem*/ item){
+ // summary: Callback fires when mouse exits a MenuItem
+ },
+
+ _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, /*Event*/ evt){
+ // summary: user defined function to handle clicks on an item
+ 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(evt);
+ }
+ },
+
+ // 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 && dojo.doc.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 && dojo.doc.frames[iframe_el.name] && dojo.doc.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, (this.leftClickToOpen)?"onclick":"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);
+ if(node){
+ 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
+
+ if(this.leftClickToOpen&&e.button>0){
+ return;
+ }
+ 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(){
+ this.inherited('_onBlur', arguments);
+ // 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();
+ }
+ },
+
+ uninitialize: function(){
+ dojo.forEach(this.targetNodeIds, this.unBindDomNode, this);
+ this.inherited(arguments);
+ }
+}
+);
+
+dojo.declare("dijit.MenuItem",
+ [dijit._Widget, dijit._Templated, dijit._Contained],
+ {
+ // summary: A line item in a Menu Widget
+
+ // 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,focusNode" 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.setLabel(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, evt);
+ dojo.stopEvent(evt);
+ },
+
+ onClick: function(/*Event*/ evt){
+ // 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');
+ },
+
+ setLabel: function(/*String*/ value){
+ this.containerNode.innerHTML=this.label=value;
+ },
+
+ 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(){
+ // summary: The innerHTML contains both the menu item text and a popup widget
+ // description: the first part holds the menu item text and the second part is the popup
+ // example:
+ // | <div dojoType="dijit.PopupMenuItem">
+ // | <span>pick me</span>
+ // | <popup> ... </popup>
+ // | </div>
+ 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(){
+ if(this._started){ return; }
+ this.inherited(arguments);
+
+ // we didn't copy the dropdown widget from the this.srcNodeRef, so it's in no-man's
+ // land now. move it to dojo.doc.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");
+ },
+
+ destroyDescendants: function(){
+ if(this.popup){
+ this.popup.destroyRecursive();
+ delete this.popup;
+ }
+ this.inherited(arguments);
+ }
+});
+
+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; // Boolean
+ }
+});
+
+}
projects / eow / blobdiff