• Home
• org.primefaces
• primefaces
• 7.0
• source code
• 0-jquery.layout.js

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

META-INF.resources.primefaces.layout.0-jquery.layout.js Maven / Gradle / Ivy

/**
 * @preserve
 * jquery.layout 1.5.12
 * $Date: 2017-11-29 08:00:00 (Sat, 29 November 2017) $
 * $Rev: 1.0512 $
 *
 * Copyright (c) 2014 Kevin Dalman (https://github.com/allpro/layout)
 * Based on work by Fabrizio Balliano (http://www.fabrizioballiano.net)
 *
 * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
 * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
 *
 * SEE: https://github.com/allpro/layout/blob/master/LICENSE.txt
 *
 * Changelog: http://layout.jquery-dev.com/changelog.cfm
 *
 * Docs: http://layout.jquery-dev.com/documentation.html
 * Tips: http://layout.jquery-dev.com/tips.html
 * Help: http://groups.google.com/group/jquery-ui-layout
 *
 * History
 * 2016/28/10 - Added responsiveness - marc magon
 */

/* JavaDoc Info: http://code.google.com/closure/compiler/docs/js-for-compiler.html
 * {!Object} non-nullable type (never NULL)
 * {?string} nullable type (sometimes NULL) - default for {Object}
 * {number=} optional parameter
 * {*}   ALL types
 */

// NOTE: For best readability, view with a fixed-width font and tabs equal to 4-chars

(function ($) {
// alias Math methods - used a lot!
    var min = Math.min, max = Math.max, round = Math.floor, isStr = function (v) {
        return $.type(v) === "string";
    }

    /**
     * @param {!Object}   Instance
     * @param {Array.} a_fn
     */
    , runPluginCallbacks = function (Instance, a_fn) {
        if ($.isArray(a_fn))
            for (var i = 0, c = a_fn.length; i < c; i++) {
                var fn = a_fn[i];
                try {
                    if (isStr(fn)) // 'name' of a function
                        fn = eval(fn);
                    if ($.isFunction(fn))
                        g(fn)(Instance);
                } catch (ex) {
                }
            }
        function g(f) {
            return f;
        }
        ; // compiler hack
    }
    ;

    /*
     * GENERIC $.layout METHODS - used by all layouts
     */
    $.layout = {
        version: "1.5.12"
        , revision: 1.0512 // eg: ver 1.4.4 = rev 1.0404 - major(n+).minor(nn)+patch(nn+)

                // $.layout.browser REPLACES $.browser
        , browser: {} // set below

        // *PREDEFINED* EFFECTS & DEFAULTS
        // MUST list effect here - OR MUST set an fxSettings option (can be an empty hash: {})
        , effects: {
            // Pane Open/Close Animations
            slide: {
                all: {duration: "fast"} // eg: duration: 1000, easing: "easeOutBounce"
                , north: {direction: "up"}
                , south: {direction: "down"}
                , east: {direction: "right"}
                , west: {direction: "left"}
            }
            , drop: {
                all: {duration: "slow"}
                , north: {direction: "up"}
                , south: {direction: "down"}
                , east: {direction: "right"}
                , west: {direction: "left"}
            }
            , scale: {
                all: {duration: "fast"}
            }
            // these are not recommended, but can be used
            , blind: {}
            , clip: {}
            , explode: {}
            , fade: {}
            , fold: {}
            , puff: {}

            // Pane Resize Animations
            , size: {
                all: {easing: "swing"}
            }
        }

        // INTERNAL CONFIG DATA - DO NOT CHANGE THIS!
        , config: {
            optionRootKeys: "effects,panes,north,south,west,east,center".split(",")
            , allPanes: "north,south,west,east,center".split(",")
            , borderPanes: "north,south,west,east".split(",")
            , oppositeEdge: {
                north: "south"
                , south: "north"
                , east: "west"
                , west: "east"
            }
            // offscreen data
            , offscreenCSS: {left: "-99999px", right: "auto"} // used by hide/close if useOffscreenClose=true
            , offscreenReset: "offscreenReset" // key used for data
                    // CSS used in multiple places
            , hidden: {visibility: "hidden"}
            , visible: {visibility: "visible"}
            // layout element settings
            , resizers: {
                cssReq: {
                    position: "absolute"
                    , padding: 0
                    , margin: 0
                    , fontSize: "1px"
                    , textAlign: "left" // to counter-act "center" alignment!
                    , overflow: "hidden" // prevent toggler-button from overflowing
                            // SEE $.layout.defaults.zIndexes.resizer_normal
                }
                , cssDemo: {// DEMO CSS - applied if: options.PANE.applyDemoStyles=true
                    background: "#DDD"
                    , border: "none"
                }
            }
            , togglers: {
                cssReq: {
                    position: "absolute"
                    , display: "block"
                    , padding: 0
                    , margin: 0
                    , overflow: "hidden"
                    , textAlign: "center"
                    , fontSize: "1px"
                    , cursor: "pointer"
                    , zIndex: 1
                }
                , cssDemo: {// DEMO CSS - applied if: options.PANE.applyDemoStyles=true
                    background: "#AAA"
                }
            }
            , content: {
                cssReq: {
                    position: "relative" /* contain floated or positioned elements */
                }
                , cssDemo: {// DEMO CSS - applied if: options.PANE.applyDemoStyles=true
                    overflow: "auto"
                    , padding: "10px"
                }
                , cssDemoPane: {// DEMO CSS - REMOVE scrolling from 'pane' when it has a content-div
                    overflow: "hidden"
                    , padding: 0
                }
            }
            , panes: {// defaults for ALL panes - overridden by 'per-pane settings' below
                cssReq: {
                    position: "absolute"
                    , margin: 0
                            // $.layout.defaults.zIndexes.pane_normal
                }
                , cssDemo: {// DEMO CSS - applied if: options.PANE.applyDemoStyles=true
                    padding: "10px"
                    , background: "#FFF"
                    , border: "1px solid #BBB"
                    , overflow: "auto"
                }
            }
            , north: {
                side: "top"
                , sizeType: "Height"
                , dir: "horz"
                , cssReq: {
                    top: 0
                    , bottom: "auto"
                    , left: 0
                    , right: 0
                    , width: "auto"
                            // height:  DYNAMIC
                }
            }
            , south: {
                side: "bottom"
                , sizeType: "Height"
                , dir: "horz"
                , cssReq: {
                    top: "auto"
                    , bottom: 0
                    , left: 0
                    , right: 0
                    , width: "auto"
                            // height:  DYNAMIC
                }
            }
            , east: {
                side: "right"
                , sizeType: "Width"
                , dir: "vert"
                , cssReq: {
                    left: "auto"
                    , right: 0
                    , top: "auto" // DYNAMIC
                    , bottom: "auto" // DYNAMIC
                    , height: "auto"
                            // width:   DYNAMIC
                }
            }
            , west: {
                side: "left"
                , sizeType: "Width"
                , dir: "vert"
                , cssReq: {
                    left: 0
                    , right: "auto"
                    , top: "auto" // DYNAMIC
                    , bottom: "auto" // DYNAMIC
                    , height: "auto"
                            // width:   DYNAMIC
                }
            }
            , center: {
                dir: "center"
                , cssReq: {
                    left: "auto" // DYNAMIC
                    , right: "auto" // DYNAMIC
                    , top: "auto" // DYNAMIC
                    , bottom: "auto" // DYNAMIC
                    , height: "auto"
                    , width: "auto"
                }
            }
        }

        // CALLBACK FUNCTION NAMESPACE - used to store reusable callback functions
        , callbacks: {}

        , getParentPaneElem: function (el) {
            // must pass either a container or pane element
            var $el = $(el)
                    , layout = $el.data("layout") || $el.data("parentLayout");
            if (layout) {
                var $cont = layout.container;
                // see if this container is directly-nested inside an outer-pane
                if ($cont.data("layoutPane"))
                    return $cont;
                var $pane = $cont.closest("." + $.layout.defaults.panes.paneClass);
                // if a pane was found, return it
                if ($pane.data("layoutPane"))
                    return $pane;
            }
            return null;
        }

        , getParentPaneInstance: function (el) {
            // must pass either a container or pane element
            var $pane = $.layout.getParentPaneElem(el);
            return $pane ? $pane.data("layoutPane") : null;
        }

        , getParentLayoutInstance: function (el) {
            // must pass either a container or pane element
            var $pane = $.layout.getParentPaneElem(el);
            return $pane ? $pane.data("parentLayout") : null;
        }

        , getEventObject: function (evt) {
            return typeof evt === "object" && evt.stopPropagation ? evt : null;
        }
        , parsePaneName: function (evt_or_pane) {
            var evt = $.layout.getEventObject(evt_or_pane)
                    , pane = evt_or_pane;
            if (evt) {
                // ALWAYS stop propagation of events triggered in Layout!
                evt.stopPropagation();
                pane = $(this).data("layoutEdge");
            }
            if (pane && !/^(west|east|north|south|center)$/.test(pane)) {
                $.layout.msg('LAYOUT ERROR - Invalid pane-name: "' + pane + '"');
                pane = "error";
            }
            return pane;
        }


        // LAYOUT-PLUGIN REGISTRATION
        // more plugins can added beyond this default list
        , plugins: {
            draggable: !!$.fn.draggable // resizing
            , effects: {
                core: !!$.effects  // animimations (specific effects tested by initOptions)
                , slide: $.effects && ($.effects.slide || ($.effects.effect && $.effects.effect.slide)) // default effect
            }
        }

// arrays of plugin or other methods to be triggered for events in *each layout* - will be passed 'Instance'
        , onCreate: [] // runs when layout is just starting to be created - right after options are set
        , onLoad: [] // runs after layout container and global events init, but before initPanes is called
        , onReady: [] // runs after initialization *completes* - ie, after initPanes completes successfully
        , onDestroy: [] // runs after layout is destroyed
        , onUnload: [] // runs after layout is destroyed OR when page unloads
        , afterOpen: [] // runs after setAsOpen() completes
        , afterClose: [] // runs after setAsClosed() completes

                /*
                 * GENERIC UTILITY METHODS
                 */

                // calculate and return the scrollbar width, as an integer
        , scrollbarWidth: function () {
            return window.scrollbarWidth || $.layout.getScrollbarSize('width');
        }
        , scrollbarHeight: function () {
            return window.scrollbarHeight || $.layout.getScrollbarSize('height');
        }
        , getScrollbarSize: function (dim) {
            var $c = $('
').appendTo("body")
                    , d = {width: $c.outerWidth - $c[0].clientWidth, height: 100 - $c[0].clientHeight};
            $c.remove();
            window.scrollbarWidth = d.width;
            window.scrollbarHeight = d.height;
            return dim.match(/^(width|height)$/) ? d[dim] : d;
        }


        , disableTextSelection: function () {
            var $d = $(document)
                    , s = 'textSelectionDisabled'
                    , x = 'textSelectionInitialized'
                    ;
            if ($.fn.disableSelection) {
                if (!$d.data(x)) // document hasn't been initialized yet
                    $d.on('mouseup', $.layout.enableTextSelection).data(x, true);
                if (!$d.data(s))
                    $d.disableSelection().data(s, true);
            }
        }
        , enableTextSelection: function () {
            var $d = $(document)
                    , s = 'textSelectionDisabled';
            if ($.fn.enableSelection && $d.data(s))
                $d.enableSelection().data(s, false);
        }


        /**
         * Returns hash container 'display' and 'visibility'
         *
         * @see $.swap() - swaps CSS, runs callback, resets CSS
         * @param  {!Object}  $E    jQuery element
         * @param  {boolean=} [force=false] Run even if display != none
         * @return {!Object}      Returns current style props, if applicable
         */
        , showInvisibly: function ($E, force) {
            if ($E && $E.length && (force || $E.css("display") === "none")) { // only if not *already hidden*
                var s = $E[0].style
                        // save ONLY the 'style' props because that is what we must restore
                        , CSS = {display: s.display || '', visibility: s.visibility || ''};
                // show element 'invisibly' so can be measured
                $E.css({display: "block", visibility: "hidden"});
                return CSS;
            }
            return {};
        }

        /**
         * Returns data for setting size of an element (container or a pane).
         *
         * @see  _create(), onWindowResize() for container, plus others for pane
         * @return JSON  Returns a hash of all dimensions: top, bottom, left, right, outerWidth, innerHeight, etc
         */
        , getElementDimensions: function ($E, inset) {
            var
                    // dimensions hash - start with current data IF passed
                    d = {css: {}, inset: {}}
            , x = d.css   // CSS hash
                    , i = {bottom: 0} // TEMP insets (bottom = complier hack)
            , N = $.layout.cssNum
                    , R = Math.round
                    , off = $E.offset()
                    , b, p, ei   // TEMP border, padding
                    ;
            d.offsetLeft = off.left;
            d.offsetTop = off.top;

            if (!inset)
                inset = {}; // simplify logic below

            $.each("Left,Right,Top,Bottom".split(","), function (idx, e) { // e = edge
                b = x["border" + e] = $.layout.borderWidth($E, e);
                p = x["padding" + e] = $.layout.cssNum($E, "padding" + e);
                ei = e.toLowerCase();
                d.inset[ei] = inset[ei] >= 0 ? inset[ei] : p; // any missing insetX value = paddingX
                i[ei] = d.inset[ei] + b; // total offset of content from outer side
            });

            x.width = R($E.width());
            x.height = R($E.height());
            x.top = N($E, "top", true);
            x.bottom = N($E, "bottom", true);
            x.left = N($E, "left", true);
            x.right = N($E, "right", true);

            d.outerWidth = R($E.outerWidth());
            d.outerHeight = R($E.outerHeight());
            // calc the TRUE inner-dimensions, even in quirks-mode!
            d.innerWidth = max(0, d.outerWidth - i.left - i.right);
            d.innerHeight = max(0, d.outerHeight - i.top - i.bottom);
            // layoutWidth/Height is used in calcs for manual resizing
            // layoutW/H only differs from innerW/H when in quirks-mode - then is like outerW/H
            d.layoutWidth = R($E.innerWidth());
            d.layoutHeight = R($E.innerHeight());

            //if ($E.prop('tagName') === 'BODY') { debugData( d, $E.prop('tagName') ); } // DEBUG

            //d.visible = $E.is(":visible");// && x.width > 0 && x.height > 0;

            return d;
        }

        , getElementStyles: function ($E, list) {
            var
                    CSS = {}
            , style = $E[0].style
                    , props = list.split(",")
                    , sides = "Top,Bottom,Left,Right".split(",")
                    , attrs = "Color,Style,Width".split(",")
                    , p, s, a, i, j, k
                    ;
            for (i = 0; i < props.length; i++) {
                p = props[i];
                if (p.match(/(border|padding|margin)$/))
                    for (j = 0; j < 4; j++) {
                        s = sides[j];
                        if (p === "border")
                            for (k = 0; k < 3; k++) {
                                a = attrs[k];
                                CSS[p + s + a] = style[p + s + a];
                            }
                        else
                            CSS[p + s] = style[p + s];
                    }
                else
                    CSS[p] = style[p];
            }
            ;
            return CSS
        }

        /**
         * Return the innerWidth for the current browser/doctype
         *
         * @see  initPanes(), sizeMidPanes(), initHandles(), sizeHandles()
         * @param  {Array.