Subversion Repositories Applications.papyrus

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

// summary:
//              These functions are used to query or set the focus and selection.
//
//              Also, they trace when widgets become actived/deactivated,
//              so that the widget can fire _onFocus/_onBlur events.
//              "Active" here means something similar to "focused", but
//              "focus" isn't quite the right word because we keep track of
//              a whole stack of "active" widgets.  Example:  Combobutton --> Menu -->
//              MenuItem.   The onBlur event for Combobutton doesn't fire due to focusing
//              on the Menu or a MenuItem, since they are considered part of the
//              Combobutton widget.  It only happens when focus is shifted
//              somewhere completely different.

dojo.mixin(dijit,
{
        // _curFocus: DomNode
        //              Currently focused item on screen
        _curFocus: null,

        // _prevFocus: DomNode
        //              Previously focused item on screen
        _prevFocus: null,

        isCollapsed: function(){
                // summary: tests whether the current selection is empty
                var _window = dojo.global;
                var _document = dojo.doc;
                if(_document.selection){ // IE
                        return !_document.selection.createRange().text; // Boolean
                }else if(_window.getSelection){
                        var selection = _window.getSelection();
                        if(dojo.isString(selection)){ // Safari
                                return !selection; // Boolean
                        }else{ // Mozilla/W3
                                return selection.isCollapsed || !selection.toString(); // Boolean
                        }
                }
        },

        getBookmark: function(){
                // summary: Retrieves a bookmark that can be used with moveToBookmark to return to the same range
                var bookmark, selection = dojo.doc.selection;
                if(selection){ // IE
                        var range = selection.createRange();
                        if(selection.type.toUpperCase()=='CONTROL'){
                                bookmark = range.length ? dojo._toArray(range) : null;
                        }else{
                                bookmark = range.getBookmark();
                        }
                }else{
                        if(dojo.global.getSelection){
                                selection = dojo.global.getSelection();
                                if(selection){
                                        var range = selection.getRangeAt(0);
                                        bookmark = range.cloneRange();
                                }
                        }else{
                                console.debug("No idea how to store the current selection for this browser!");
                        }
                }
                return bookmark; // Array
        },

        moveToBookmark: function(/*Object*/bookmark){
                // summary: Moves current selection to a bookmark
                // bookmark: this should be a returned object from dojo.html.selection.getBookmark()
                var _document = dojo.doc;
                if(_document.selection){ // IE
                        var range;
                        if(dojo.isArray(bookmark)){
                                range = _document.body.createControlRange();
                                dojo.forEach(bookmark, range.addElement);
                        }else{
                                range = _document.selection.createRange();
                                range.moveToBookmark(bookmark);
                        }
                        range.select();
                }else{ //Moz/W3C
                        var selection = dojo.global.getSelection && dojo.global.getSelection();
                        if(selection && selection.removeAllRanges){
                                selection.removeAllRanges();
                                selection.addRange(bookmark);
                        }else{
                                console.debug("No idea how to restore selection for this browser!");
                        }
                }
        },

        getFocus: function(/*Widget*/menu, /*Window*/ openedForWindow){
                // summary:
                //      Returns the current focus and selection.
                //      Called when a popup appears (either a top level menu or a dialog),
                //      or when a toolbar/menubar receives focus
                //
                // menu:
                //      the menu that's being opened
                //
                // openedForWindow:
                //      iframe in which menu was opened
                //
                // returns:
                //      a handle to restore focus/selection

                return {
                        // Node to return focus to
                        node: menu && dojo.isDescendant(dijit._curFocus, menu.domNode) ? dijit._prevFocus : dijit._curFocus,

                        // Previously selected text
                        bookmark:
                                !dojo.withGlobal(openedForWindow||dojo.global, dijit.isCollapsed) ?
                                dojo.withGlobal(openedForWindow||dojo.global, dijit.getBookmark) :
                                null,

                        openedForWindow: openedForWindow
                }; // Object
        },

        focus: function(/*Object || DomNode */ handle){
                // summary:
                //              Sets the focused node and the selection according to argument.
                //              To set focus to an iframe's content, pass in the iframe itself.
                // handle:
                //              object returned by get(), or a DomNode

                if(!handle){ return; }

                var node = "node" in handle ? handle.node : handle,             // because handle is either DomNode or a composite object
                        bookmark = handle.bookmark,
                        openedForWindow = handle.openedForWindow;

                // Set the focus
                // Note that for iframe's we need to use the <iframe> to follow the parentNode chain,
                // but we need to set focus to iframe.contentWindow
                if(node){
                        var focusNode = (node.tagName.toLowerCase()=="iframe") ? node.contentWindow : node;
                        if(focusNode && focusNode.focus){
                                try{
                                        // Gecko throws sometimes if setting focus is impossible,
                                        // node not displayed or something like that
                                        focusNode.focus();
                                }catch(e){/*quiet*/}
                        }                       
                        dijit._onFocusNode(node);
                }

                // set the selection
                // do not need to restore if current selection is not empty
                // (use keyboard to select a menu item)
                if(bookmark && dojo.withGlobal(openedForWindow||dojo.global, dijit.isCollapsed)){
                        if(openedForWindow){
                                openedForWindow.focus();
                        }
                        try{
                                dojo.withGlobal(openedForWindow||dojo.global, moveToBookmark, null, [bookmark]);
                        }catch(e){
                                /*squelch IE internal error, see http://trac.dojotoolkit.org/ticket/1984 */
                        }
                }
        },

        // List of currently active widgets (focused widget and it's ancestors)
        _activeStack: [],

        registerWin: function(/*Window?*/targetWindow){
                // summary:
                //              Registers listeners on the specified window (either the main
                //              window or an iframe) to detect when the user has clicked somewhere.
                //              Anyone that creates an iframe should call this function.

                if(!targetWindow){
                        targetWindow = window;
                }

                dojo.connect(targetWindow.document, "onmousedown", null, function(evt){
                        dijit._justMouseDowned = true;
                        setTimeout(function(){ dijit._justMouseDowned = false; }, 0);
                        dijit._onTouchNode(evt.target||evt.srcElement);
                });
                //dojo.connect(targetWindow, "onscroll", ???);

                // Listen for blur and focus events on targetWindow's body
                var body = targetWindow.document.body || targetWindow.document.getElementsByTagName("body")[0];
                if(body){
                        if(dojo.isIE){
                                body.attachEvent('onactivate', function(evt){
                                        if(evt.srcElement.tagName.toLowerCase() != "body"){
                                                dijit._onFocusNode(evt.srcElement);
                                        }
                                });
                                body.attachEvent('ondeactivate', function(evt){ dijit._onBlurNode(evt.srcElement); });
                        }else{
                                body.addEventListener('focus', function(evt){ dijit._onFocusNode(evt.target); }, true);
                                body.addEventListener('blur', function(evt){ dijit._onBlurNode(evt.target); }, true);
                        }
                }
                body = null;    // prevent memory leak (apparent circular reference via closure)
        },

        _onBlurNode: function(/*DomNode*/ node){
                // summary:
                //              Called when focus leaves a node.
                //              Usually ignored, _unless_ it *isn't* follwed by touching another node,
                //              which indicates that we tabbed off the last field on the page,
                //              in which case every widget is marked inactive
                dijit._prevFocus = dijit._curFocus;
                dijit._curFocus = null;

                var w = dijit.getEnclosingWidget(node);
                if (w && w._setStateClass){
                        w._focused = false;
                        w._setStateClass();
                }
                if(dijit._justMouseDowned){
                        // the mouse down caused a new widget to be marked as active; this blur event
                        // is coming late, so ignore it.
                        return;
                }

                // if the blur event isn't followed by a focus event then mark all widgets as inactive.
                if(dijit._clearActiveWidgetsTimer){
                        clearTimeout(dijit._clearActiveWidgetsTimer);
                }
                dijit._clearActiveWidgetsTimer = setTimeout(function(){
                        delete dijit._clearActiveWidgetsTimer; dijit._setStack([]); }, 100);
        },

        _onTouchNode: function(/*DomNode*/ node){
                // summary
                //              Callback when node is focused or mouse-downed

                // ignore the recent blurNode event
                if(dijit._clearActiveWidgetsTimer){
                        clearTimeout(dijit._clearActiveWidgetsTimer);
                        delete dijit._clearActiveWidgetsTimer;
                }

                // compute stack of active widgets (ex: ComboButton --> Menu --> MenuItem)
                var newStack=[];
                try{
                        while(node){
                                if(node.dijitPopupParent){
                                        node=dijit.byId(node.dijitPopupParent).domNode;
                                }else if(node.tagName && node.tagName.toLowerCase()=="body"){
                                        // is this the root of the document or just the root of an iframe?
                                        if(node===dojo.body()){
                                                // node is the root of the main document
                                                break;
                                        }
                                        // otherwise, find the iframe this node refers to (can't access it via parentNode,
                                        // need to do this trick instead) and continue tracing up the document
                                        node=dojo.query("iframe").filter(function(iframe){ return iframe.contentDocument.body===node; })[0];
                                }else{
                                        var id = node.getAttribute && node.getAttribute("widgetId");
                                        if(id){
                                                newStack.unshift(id);
                                        }
                                        node=node.parentNode;
                                }
                        }
                }catch(e){ /* squelch */ }

                dijit._setStack(newStack);
        },

        _onFocusNode: function(/*DomNode*/ node){
                // summary
                //              Callback when node is focused
                if(node && node.tagName && node.tagName.toLowerCase() == "body"){
                        return;
                }
                dijit._onTouchNode(node);
                if(node==dijit._curFocus){ return; }
                dijit._prevFocus = dijit._curFocus;
                dijit._curFocus = node;
                dojo.publish("focusNode", [node]);

                // handle focus/blur styling
                var w = dijit.getEnclosingWidget(node);
                if (w && w._setStateClass){
                        w._focused = true;
                        w._setStateClass();
                }
        },

        _setStack: function(newStack){
                // summary
                //      The stack of active widgets has changed.  Send out appropriate events and record new stack

                var oldStack = dijit._activeStack;              
                dijit._activeStack = newStack;

                // compare old stack to new stack to see how many elements they have in common
                for(var nCommon=0; nCommon<Math.min(oldStack.length, newStack.length); nCommon++){
                        if(oldStack[nCommon] != newStack[nCommon]){
                                break;
                        }
                }

                // for all elements that have gone out of focus, send blur event
                for(var i=oldStack.length-1; i>=nCommon; i--){
                        var widget = dijit.byId(oldStack[i]);
                        if(widget){
                                dojo.publish("widgetBlur", [widget]);
                                if(widget._onBlur){
                                        widget._onBlur();
                                }
                        }
                }

                // for all element that have come into focus, send focus event
                for(var i=nCommon; i<newStack.length; i++){
                        var widget = dijit.byId(newStack[i]);
                        if(widget){
                                dojo.publish("widgetFocus", [widget]);
                                if(widget._onFocus){
                                        widget._onFocus();
                                }
                        }
                }
        }
});

// register top window and all the iframes it contains
dojo.addOnLoad(dijit.registerWin);

}