Subversion Repositories Applications.papyrus

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;
        }
});

}