Subversion Repositories Applications.papyrus

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

// ported from dojo.html.util

dijit.getViewport = function(){
        //      summary
        //      Returns the dimensions and scroll position of the viewable area of a browser window

        var _window = dojo.global;
        var _document = dojo.doc;

        // get viewport size
        var w = 0, h = 0;
        if(dojo.isMozilla){
                // mozilla
                // _window.innerHeight includes the height taken by the scroll bar
                // clientHeight is ideal but has DTD issues:
                // #4539: FF reverses the roles of body.clientHeight/Width and documentElement.clientHeight/Width based on the DTD!
                // check DTD to see whether body or documentElement returns the viewport dimensions using this algorithm:
                var minw, minh, maxw, maxh;
                if(_document.body.clientWidth>_document.documentElement.clientWidth){
                        minw = _document.documentElement.clientWidth;
                        maxw = _document.body.clientWidth;
                }else{
                        maxw = _document.documentElement.clientWidth;
                        minw = _document.body.clientWidth;
                }
                if(_document.body.clientHeight>_document.documentElement.clientHeight){
                        minh = _document.documentElement.clientHeight;
                        maxh = _document.body.clientHeight;
                }else{
                        maxh = _document.documentElement.clientHeight;
                        minh = _document.body.clientHeight;
                }
                w = (maxw > _window.innerWidth) ? minw : maxw;
                h = (maxh > _window.innerHeight) ? minh : maxh;
        }else if(!dojo.isOpera && _window.innerWidth){
                //in opera9, dojo.body().clientWidth should be used, instead
                //of window.innerWidth/document.documentElement.clientWidth
                //so we have to check whether it is opera
                w = _window.innerWidth;
                h = _window.innerHeight;
        }else if(dojo.isIE && _document.documentElement && _document.documentElement.clientHeight){
                w = _document.documentElement.clientWidth;
                h = _document.documentElement.clientHeight;
        }else if(dojo.body().clientWidth){
                // IE5, Opera
                w = dojo.body().clientWidth;
                h = dojo.body().clientHeight;
        }

        // get scroll position
        var scroll = dojo._docScroll();

        return { w: w, h: h, l: scroll.x, t: scroll.y };        //      object
};

dijit.placeOnScreen = function(
        /* DomNode */   node,
        /* Object */            pos,
        /* Object */            corners,
        /* boolean? */          tryOnly){
        //      summary:
        //              Keeps 'node' in the visible area of the screen while trying to
        //              place closest to pos.x, pos.y. The input coordinates are
        //              expected to be the desired document position.
        //
        //              Set which corner(s) you want to bind to, such as
        //              
        //                      placeOnScreen(node, {x: 10, y: 20}, ["TR", "BL"])
        //              
        //              The desired x/y will be treated as the topleft(TL)/topright(TR) or
        //              BottomLeft(BL)/BottomRight(BR) corner of the node. Each corner is tested
        //              and if a perfect match is found, it will be used. Otherwise, it goes through
        //              all of the specified corners, and choose the most appropriate one.
        //              
        //              NOTE: node is assumed to be absolutely or relatively positioned.

        var choices = dojo.map(corners, function(corner){ return { corner: corner, pos: pos }; });

        return dijit._place(node, choices);
}

dijit._place = function(/*DomNode*/ node, /* Array */ choices, /* Function */ layoutNode){
        // 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, orient)
        //              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.

        // get {x: 10, y: 10, w: 100, h:100} type obj representing position of
        // viewport over document
        var view = dijit.getViewport();

        // This won't work if the node is inside a <div style="position: relative">,
        // so reattach it to document.body.   (Otherwise, the positioning will be wrong
        // and also it might get cutoff)
        if(!node.parentNode || String(node.parentNode.tagName).toLowerCase() != "body"){
                dojo.body().appendChild(node);
        }

        var best=null;
        for(var i=0; i<choices.length; i++){
                var corner = choices[i].corner;
                var pos = choices[i].pos;

                // 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 tooltips size changes based on position, due to triangle)
                if(layoutNode){
                        layoutNode(corner);
                }

                // get node's size
                var oldDisplay = node.style.display;
                var oldVis = node.style.visibility;
                node.style.visibility = "hidden";
                node.style.display = "";
                var mb = dojo.marginBox(node);
                node.style.display = oldDisplay;
                node.style.visibility = oldVis;

                // coordinates and size of node with specified corner placed at pos,
                // and clipped by viewport
                var startX = (corner.charAt(1)=='L' ? pos.x : Math.max(view.l, pos.x - mb.w)),
                        startY = (corner.charAt(0)=='T' ? pos.y : Math.max(view.t, pos.y -  mb.h)),
                        endX = (corner.charAt(1)=='L' ? Math.min(view.l+view.w, startX+mb.w) : pos.x),
                        endY = (corner.charAt(0)=='T' ? Math.min(view.t+view.h, startY+mb.h) : pos.y),
                        width = endX-startX,
                        height = endY-startY,
                        overflow = (mb.w-width) + (mb.h-height);

                if(best==null || overflow<best.overflow){
                        best = {
                                corner: corner,
                                aroundCorner: choices[i].aroundCorner,
                                x: startX,
                                y: startY,
                                w: width,
                                h: height,
                                overflow: overflow
                        };
                }
                if(overflow==0){
                        break;
                }
        }

        node.style.left = best.x + "px";
        node.style.top = best.y + "px";
        return best;
}

dijit.placeOnScreenAroundElement = function(
        /* DomNode */           node,
        /* DomNode */           aroundNode,
        /* Object */            aroundCorners,
        /* Function */          layoutNode){

        //      summary
        //      Like placeOnScreen, except it accepts aroundNode instead of x,y
        //      and attempts to place node around it.  Uses margin box dimensions.
        //
        //      aroundCorners
        //              specify Which corner of aroundNode should be
        //              used to place the node => which corner(s) of node to use (see the
        //              corners parameter in dijit.placeOnScreen)
        //              e.g. {'TL': 'BL', 'BL': 'TL'}
        //
        //      layoutNode: Function(node, orient)
        //              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.


        // get coordinates of aroundNode
        aroundNode = dojo.byId(aroundNode);
        var oldDisplay = aroundNode.style.display;
        aroundNode.style.display="";
        // #3172: use the slightly tighter border box instead of marginBox
        var aroundNodeW = aroundNode.offsetWidth; //mb.w;
        var aroundNodeH = aroundNode.offsetHeight; //mb.h;
        var aroundNodePos = dojo.coords(aroundNode, true);
        aroundNode.style.display=oldDisplay;

        // Generate list of possible positions for node
        var choices = [];
        for(var nodeCorner in aroundCorners){
                choices.push( {
                        aroundCorner: nodeCorner,
                        corner: aroundCorners[nodeCorner],
                        pos: {
                                x: aroundNodePos.x + (nodeCorner.charAt(1)=='L' ? 0 : aroundNodeW),
                                y: aroundNodePos.y + (nodeCorner.charAt(0)=='T' ? 0 : aroundNodeH)
                        }
                });
        }

        return dijit._place(node, choices, layoutNode);
}

}