Lines Matching refs:pane
285 , pane = evt_or_pane;
289 pane = $(this).data("layoutEdge");
291 if (pane && !/^(west|east|north|south|center)$/.test(pane)) {
292 $.layout.msg('LAYOUT ERROR - Invalid pane-name: "'+ pane +'"');
293 pane = "error";
295 return pane;
701 pane: "pane" // description of "layout pane element" - used only in error messages property in $.layout.defaults.errors
1015 $.each($.layout.config.allPanes, function (i, pane) { argument
1016 if (opts[pane]) ren( opts[pane] );
1122 , _runCallbacks = function (evtName, pane, skipBoundEvents) { argument
1123 var hasPane = pane && isStr(pane)
1124 , s = hasPane ? state[pane] : state
1125 , o = hasPane ? options[pane] : options
1133 , $P = hasPane ? $Ps[pane] : 0
1137 if ( !hasPane && $.type(pane) === "boolean" ) {
1138 skipBoundEvents = pane; // allow pane param to be skipped for Layout callback
1139 pane = "";
1162 retVal = g(fn)( pane, $Ps[pane], s, o, lName );
1168 _log( options.errors.callbackError.replace(/EVENT/, $.trim((pane || "") +" "+ lng)), false );
1177 o = options[pane];
1178 s = state[pane];
1179 $P.triggerHandler("layoutpane"+ lng, [ pane, $P, s, o, lName ]);
1181 $P.triggerHandler("layoutpane"+ shrt, [ pane, $P, s, o, lName ]);
1193 resizeChildren(pane+"", true); // compiler hack -force string
1204 , _fixIframe = function (pane) { argument
1206 var $P = $Ps[pane];
1208 if (state[pane].tagName === "IFRAME")
1219 , cssSize = function (pane, outerSize) { argument
1220 var fn = _c[pane].dir=="horz" ? cssH : cssW;
1221 return fn($Ps[pane], outerSize);
1228 , cssMinDims = function (pane) { argument
1230 var $P = $Ps[pane]
1231 , dir = _c[pane].dir
1301 , _parseSize = function (pane, size, dir) { argument
1302 if (!dir) dir = _c[pane].dir;
1322 else if (pane=="center")
1327 , $P = $Ps[pane]
1328 , $C = dim === 'height' ? $Cs[pane] : false
1349 , getPaneSize = function (pane, inclSpace) { argument
1351 $P = $Ps[pane]
1352 , o = options[pane]
1353 , s = state[pane]
1361 else if (_c[pane].dir === "horz")
1373 , setSizeLimits = function (pane, slide) { argument
1376 o = options[pane]
1377 , s = state[pane]
1378 , c = _c[pane]
1382 , $P = $Ps[pane]
1385 , altPane = _c.oppositeEdge[pane]
1396 , minSize = s.minSize = max( _parseSize(pane, o.minSize), cssMinDims(pane).minSize )
1397 , maxSize = s.maxSize = min( (o.maxSize ? _parseSize(pane, o.maxSize) : 100000), limitSize )
1405 switch (pane) {
1458 , pane = $El.data("layoutEdge")
1459 , o = options[pane]
1461 , _pane = "-"+ pane // eg: "-west"
1490 var pane = $(this).data("layoutEdge")
1491 , s = state[pane]
1499 showMasks( pane, { resizing: true });
1503 , pane = $(e).data("layoutEdge")
1504 , name = pane +"ResizerLeave"
1507 timer.clear(pane+"_openSlider"); // cancel slideOpen timer, if set
1646 var pane = evtPane.call(this, evt_or_pane)
1647 , $P = $Ps[pane]
1650 var $C = $Cs[pane]
1651 , s = state[pane]
1652 , o = options[pane]
1680 if ( sm.includeChildren && state.stateData[pane] ) {
1682 var paneChildren = state.stateData[pane].children || {}
1701 refreshChildren( pane, child );
1727 , refreshChildren = function (pane, newChild) { argument
1728 var $P = $Ps[pane]
1729 , pC = children[pane]
1730 , s = state[pane]
1740 pC = children[pane] = null; // clear children hash
1758 if (!pC) pC = children[pane] = {}; // create an empty children hash
1763 Instance[pane].children = children[pane];
1767 createChildren(pane); // MAY create a child and re-call this method
1826 , pane = $N.data("layoutEdge") // pane-name in parent-layout
1827 , isChild = parent && pane
1840 pane = $parent.data("layoutEdge");
1841 isChild = parent && pane;
1866 parent.refreshChildren( pane, Instance );
1998 $.each(panes, function (i, pane) { argument
1999 var o = options[pane];
2013 var data, d, pane, key, val, i, c, o;
2053 $.each(_c.allPanes, function (i, pane) { argument
2056 _c[pane] = $.extend(true, {}, _c.panes, _c[pane]);
2059 o = options[pane];
2062 if (pane === 'center') {
2074 o = options[pane] = $.extend(true, {}, d, o); // re-apply pane-specific opts AFTER pane-defaults
2075 createFxOptions( pane );
2097 function createFxOptions ( pane ) { argument
2098 var o = options[pane]
2125 , fx_pane = fx[pane] || null // effects.slide.west
2162 , getPane = function (pane) { argument
2163 var sel = options[pane].paneSelector
2182 $.each(_c.allPanes, function (idx, pane) { argument
2183 addPane( pane, true );
2191 $.each(_c.borderPanes, function (i, pane) { argument
2192 if ($Ps[pane] && state[pane].isVisible) { // pane is OPEN
2193 setSizeLimits(pane);
2194 makePaneFit(pane); // pane may be Closed, Hidden or Resized by makePaneFit()
2205 $.each(_c.allPanes, function (idx, pane) { argument
2206 afterInitPane(pane);
2217 , addPane = function (pane, force) { argument
2220 o = options[pane]
2221 , s = state[pane]
2222 , c = _c[pane]
2226 , isCenter = (pane === "center")
2228 , $P = $Ps[pane]
2233 removePane( pane, false, true, false );
2235 $Cs[pane] = false; // init
2237 $P = $Ps[pane] = getPane(pane);
2239 $Ps[pane] = false; // logic
2250 Instance[pane] = {
2251 name: pane
2252 , pane: $Ps[pane] property in Instance
2253 , content: $Cs[pane]
2254 , options: options[pane]
2255 , state: state[pane]
2256 , children: children[pane]
2262 , layoutPane: Instance[pane] // NEW pointer to pane-alias-object
2263 , layoutEdge: pane
2268 ….addClass( o.paneClass +" "+ o.paneClass+"-"+pane ) // default = "ui-layout-pane ui-layout-pane-we…
2308 initContent(pane, false); // false = do NOT sizeContent() - called later
2313 size = s.size = _parseSize(pane, o.size);
2314 minSize = _parseSize(pane,o.minSize) || 1;
2315 maxSize = _parseSize(pane,o.maxSize) || 100000;
2330 …s.edge = pane; // useful if pane is (or about to be) 'swapped' - easy find out where it is (or i…
2335 setPanePosition( pane );
2345 if (dir != "horz") sizeMidPanes(pane, true); // true = skipCallback
2349 initHandles( pane );
2350 initHotkeys( pane );
2355 close(pane, true, true); // true, true = force, noAnimation
2357 hide(pane); // will be completely invisible - no resizer or spacing
2372 afterInitPane( pane );
2376 , afterInitPane = function (pane) { argument
2377 var $P = $Ps[pane]
2378 , s = state[pane]
2379 , o = options[pane]
2385 refreshChildren( pane, $P.data("layout") );
2392 sizeContent(pane);
2395 _runCallbacks("onresize_end", pane);
2398 resizeChildren(pane, true); // a previously existing childLayout
2403 createChildren(pane);
2413 $.each(panes, function (i, pane) { argument
2414 var $P = $Ps[pane]
2415 , $R = $Rs[pane]
2416 , o = options[pane]
2417 , s = state[pane]
2418 , side = _c[pane].side
2424 switch (pane) {
2446 $R.css(side, sC.inset[side] + getPaneSize(pane));
2460 $.each(panes, function (i, pane) { argument
2461 var $P = $Ps[pane];
2462 $Rs[pane] = false; // INIT
2463 $Ts[pane] = false;
2466 var o = options[pane]
2467 , s = state[pane]
2468 , c = _c[pane]
2473 , _pane = "-"+ pane // used for classNames
2475 , I = Instance[pane]
2477 , $R = I.resizer = $Rs[pane] = $("<div></div>")
2479 , $T = I.toggler = (o.closable ? $Ts[pane] = $("<div></div>") : false)
2490 , layoutPane: Instance[pane] // NEW pointer to pane-alias-object
2491 , layoutEdge: pane
2513 , layoutPane: Instance[pane] // NEW pointer to pane-alias-object
2514 , layoutEdge: pane
2528 layoutEdge: pane
2532 .data("layoutEdge", pane)
2541 layoutEdge: pane
2550 enableClosable(pane);
2554 initResizable(pane);
2558 setAsOpen(pane); // onOpen will be called, but NOT onResize
2560 setAsClosed(pane); // onClose will be called
2561 bindStartSlidingEvents(pane, true); // will enable events IF option is set
2578 , initContent = function (pane, resize) { argument
2581 o = options[pane]
2583 , I = Instance[pane]
2584 , $P = $Ps[pane]
2587 if (sel) $C = I.content = $Cs[pane] = (o.findNestedContent)
2605 state[pane].content = {}; // init content state
2606 if (resize !== false) sizeContent(pane);
2610 I.content = $Cs[pane] = false;
2627 $.each(panes, function (idx, pane) { argument
2628 var o = options[pane];
2629 if (!draggingAvailable || !$Ps[pane] || !o.resizable) {
2634 var s = state[pane]
2636 , c = _c[pane]
2638 , $P = $Ps[pane]
2639 , $R = $Rs[pane]
2645 , resizerPaneClass = base+"-"+pane+"-drag" // resizer-north-drag
2648 , helperPaneClass = base+"-"+pane+"-dragging" // resizer-north-dragging
2650 , helperPaneLimitClass = base+"-"+pane+"-dragging-limit" // resizer-north-drag
2673 o = options[pane];
2674 s = state[pane];
2680 if (false === _runCallbacks("ondrag_start", pane)) return false;
2683 state.paneResizing = pane; // easy to see if ANY pane is resizing
2684 timer.clear(pane+"_closeSlider"); // just in case already triggered
2687 setSizeLimits(pane); // update pane/resizer state
2695 showMasks( pane, { resizing: true });
2708 if (s.isSliding) $Ps[pane].css("zIndex", z.pane_sliding);
2723 …window.defaultStatus = (limit>0 && pane.match(/(north|west)/)) || (limit<0 && pane.match(/(south|e…
2733 resizePanes(e, ui, pane)
2743 resizePanes(e, ui, pane, true); // true = resizingDone
2759 var resizePanes = function (evt, ui, pane, resizingDone) { argument
2761 , c = _c[pane]
2762 , o = options[pane]
2763 , s = state[pane]
2766 switch (pane) {
2781 manualSizePane(pane, newSize, false, true); // true = noAnimation
2786 if (false !== _runCallbacks("ondrag_end", pane))
2787 manualSizePane(pane, newSize, false, true); // true = noAnimation
2790 showMasks( pane, { resizing: true });
2803 , pane = $M.data("layoutMask") // eg: "west"
2804 , s = state[pane]
2827 , showMasks = function (pane, args) { argument
2828 var c = _c[pane]
2835 , sliding: state[pane].isSliding
2840 panes.push( pane );
2842 panes.push( _c.oppositeEdge[pane] ); // ADD the oppositeEdge-pane
2887 , getMasks = function (pane) { argument
2893 if ($M.data("layoutMask") === pane)
2899 return createMasks(pane);
2910 , createMasks = function (pane) { argument
2912 $P = $Ps[pane]
2913 , s = state[pane]
2914 , o = options[pane]
2923 $M = $(el).data("layoutMask", pane); // add data to relate mask to pane
2924 el.className = "ui-layout-mask ui-layout-mask-"+ pane; // for user styling
2996 $.each(_c.allPanes, function (i, pane) { argument
2997 removePane( pane, false, true, destroyChildren ); // true = skipResize
3046 var pane = evtPane.call(this, evt_or_pane)
3047 , $P = $Ps[pane]
3048 , $C = $Cs[pane]
3049 , $R = $Rs[pane]
3050 , $T = $Ts[pane]
3061 var o = options[pane]
3062 , s = state[pane]
3065 , pC = children[pane]
3079 pC = children[pane] = null; // clear children hash
3090 , pRoot = root +"-"+ pane // eg: "ui-layout-pane-west"
3131 Instance[pane] = $Ps[pane] = $Cs[pane] = $Rs[pane] = $Ts[pane] = false;
3148 , _hidePane = function (pane) { argument
3149 var $P = $Ps[pane]
3150 , o = options[pane]
3165 , _showPane = function (pane) { argument
3166 var $P = $Ps[pane]
3167 , o = options[pane]
3192 var pane = evtPane.call(this, evt_or_pane)
3193 , o = options[pane]
3194 , s = state[pane]
3195 , $P = $Ps[pane]
3196 , $R = $Rs[pane]
3198 if (pane === "center" || !$P || s.isHidden) return; // pane does not exist OR is already hidden
3201 if (state.initialized && false === _runCallbacks("onhide_start", pane)) return;
3204 delete state.panesSliding[pane];
3213 _hidePane(pane); // no animation when loading page
3214 sizeMidPanes(_c[pane].dir === "horz" ? "" : "center");
3216 _runCallbacks("onhide_end", pane);
3220 close(pane, false, noAnimation); // adjust all panes to fit
3234 var pane = evtPane.call(this, evt_or_pane)
3235 , o = options[pane]
3236 , s = state[pane]
3237 , $P = $Ps[pane]
3238 , $R = $Rs[pane]
3240 if (pane === "center" || !$P || !s.isHidden) return; // pane does not exist OR is not hidden
3243 if (false === _runCallbacks("onshow_start", pane)) return;
3248 delete state.panesSliding[pane];
3253 close(pane, true); // true = force
3255 open(pane, false, noAnimation, noAlert); // adjust all panes to fit
3268 , pane = evtPane.call(this, evt_or_pane)
3269 , s = state[pane]
3274 show(pane); // will call 'open' after unhiding it
3276 open(pane, !!slide);
3278 close(pane);
3288 , _closePane = function (pane, setHandles) { argument
3290 $P = $Ps[pane]
3291 , s = state[pane]
3293 _hidePane(pane);
3296 if (setHandles) setAsClosed(pane);
3308 var pane = evtPane.call(this, evt_or_pane);
3309 if (pane === "center") return; // validate
3311 if (!state.initialized && $Ps[pane]) {
3312 _closePane(pane, true); // INIT pane as closed
3318 $P = $Ps[pane]
3319 , $R = $Rs[pane]
3320 , $T = $Ts[pane]
3321 , o = options[pane]
3322 , s = state[pane]
3323 , c = _c[pane]
3336 var abort = !s.isShowing && false === _runCallbacks("onclose_start", pane);
3357 bindStopSlidingEvents(pane, false); // will set isSliding=false
3359 sizeMidPanes(_c[pane].dir === "horz" ? "" : "center", false); // false = NOT skipCallback
3362 setAsClosed(pane);
3366 lockPaneForFX(pane, true); // need to set left/top so animation will work
3368 lockPaneForFX(pane, false); // undo
3374 _hidePane(pane);
3383 bindStartSlidingEvents(pane, true); // will enable if o.slidable = true
3386 var altPane = _c.oppositeEdge[pane];
3394 if (!isShowing) _runCallbacks("onclose_end", pane);
3396 if (isShowing) _runCallbacks("onshow_end", pane);
3397 if (isHiding) _runCallbacks("onhide_end", pane);
3405 , setAsClosed = function (pane) { argument
3406 if (!$Rs[pane]) return; // handles not initialized yet!
3408 $P = $Ps[pane]
3409 , $R = $Rs[pane]
3410 , $T = $Ts[pane]
3411 , o = options[pane]
3412 , s = state[pane]
3413 , side = _c[pane].side
3416 , _pane = "-"+ pane // used for classNames
3452 syncPinBtns(pane, false);
3470 var pane = evtPane.call(this, evt_or_pane)
3471 , $P = $Ps[pane]
3472 , $R = $Rs[pane]
3473 , $T = $Ts[pane]
3474 , o = options[pane]
3475 , s = state[pane]
3476 , c = _c[pane]
3479 if (pane === "center") return; // validate
3491 show(pane, true);
3496 sizePane(pane, o.size, true, true, true); // true=skipCallback/noAnimation/forceResize
3499 setSizeLimits(pane, slide);
3502 var cbReturn = _runCallbacks("onopen_start", pane);
3509 setSizeLimits(pane, slide);
3512 syncPinBtns(pane, false); // make sure pin-buttons are reset
3519 bindStopSlidingEvents(pane, true); // BIND trigger events to close sliding-pane
3521 bindStopSlidingEvents(pane, false); // UNBIND trigger events - will set isSliding=false
3523 bindStartSlidingEvents(pane, false); // UNBIND trigger events
3526 makePaneFit(pane);
3542 lockPaneForFX(pane, true); // need to set left/top so animation will work
3544 lockPaneForFX(pane, false); // undo
3550 _showPane(pane);// just show pane and...
3561 _fixIframe(pane);
3565 sizeMidPanes(_c[pane].dir=="vert" ? "center" : "", false); // false = NOT skipCallback
3569 setAsOpen(pane);
3578 , setAsOpen = function (pane, skipCallback) { argument
3580 $P = $Ps[pane]
3581 , $R = $Rs[pane]
3582 , $T = $Ts[pane]
3583 , o = options[pane]
3584 , s = state[pane]
3585 , side = _c[pane].side
3588 , _pane = "-"+ pane // used for classNames
3594 .css(side, sC.inset[side] + getPaneSize(pane)) // move the resizer
3623 syncPinBtns(pane, !s.isSliding);
3632 sizeContent(pane, true); // true = remeasure headers/footers, even if 'pane.isMoving'
3637 _runCallbacks("onopen_end", pane);
3639 if (s.isShowing) _runCallbacks("onshow_end", pane);
3643 _runCallbacks("onresize_end", pane);
3658 , pane = evtPane.call(this, evt_or_pane)
3659 , s = state[pane]
3660 , delay = options[pane].slideDelay_open
3662 if (pane === "center") return; // validate
3668 timer.set(pane+"_openSlider", open_NOW, delay);
3677 bindStopSlidingEvents(pane, true); // BIND trigger events to close sliding-pane
3679 open(pane, true); // true = slide - open() will handle binding
3686 , pane = evtPane.call(this, evt_or_pane)
3687 , o = options[pane]
3688 , s = state[pane]
3691 if (pane === "center") return; // validate
3698 else if (o.preventPrematureSlideClose && evt && $.layout.isMouseOverElem(evt, $Ps[pane]))
3702 timer.set(pane+"_closeSlider", close_NOW, max(o.slideDelay_close, delay));
3711 bindStopSlidingEvents(pane, false); // UNBIND trigger events - TODO: is this needed here?
3713 close(pane); // close will handle unbinding
3721 var pane = evtPane.call(this, evt_or_pane);
3722 toggle(pane, true);
3732 , lockPaneForFX = function (pane, doLock) { argument
3733 var $P = $Ps[pane]
3734 , s = state[pane]
3735 , o = options[pane]
3739 showMasks( pane, { animation: true, objectsOnly: true });
3741 if (pane=="south")
3743 else if (pane=="east")
3749 if (pane=="south")
3752 else if (pane=="east" && !$P.css("left").match(/\-99999/))
3768 , bindStartSlidingEvents = function (pane, enable) { argument
3769 var o = options[pane]
3770 , $P = $Ps[pane]
3771 , $R = $Rs[pane]
3805 , bindStopSlidingEvents = function (pane, enable) { argument
3806 var o = options[pane]
3807 , s = state[pane]
3808 , c = _c[pane]
3812 , $P = $Ps[pane]
3813 , $R = $Rs[pane]
3815 timer.clear(pane+"_closeSlider"); // just in case
3819 state.panesSliding[pane] = true;
3822 bindStartSlidingEvents(pane, false);
3826 delete state.panesSliding[pane];
3849 timer.clear(pane+"_closeSlider");
3859 timer.clear(pane+"_closeSlider");
3874 , makePaneFit = function (pane, isOpening, skipCallback, force) { argument
3875 var o = options[pane]
3876 , s = state[pane]
3877 , c = _c[pane]
3878 , $P = $Ps[pane]
3879 , $R = $Rs[pane]
3884 if (pane === "center" || (isSidePane && s.noVerticalRoom)) {
3889 _showPane(pane);
3894 _fixIframe(pane);
3897 _hidePane(pane);
3905 if (pane === "center") {
3911 sizePane(pane, s.maxSize, skipCallback, true, force); // true = noAnimation
3913 sizePane(pane, s.minSize, skipCallback, true, force); // true = noAnimation
3927 open(pane, false, true, true); // true = noAnimation, true = noAlert
3932 show(pane, s.wasOpen, true, true); // true = noAnimation, true = noAlert
3941 close(pane, true, true); // true = force, true = noAnimation
3943 hide(pane, true); // true = noAnimation
3960 var pane = evtPane.call(this, evt_or_pane)
3961 , o = options[pane]
3962 , s = state[pane]
3966 if (pane === "center") return; // validate
3970 …sizePane(pane, size, skipCallback, noAnimation, forceResize); // will animate resize if option ena…
3984 var pane = evtPane.call(this, evt_or_pane) // probably NEVER called from event?
3985 , o = options[pane]
3986 , s = state[pane]
3987 , $P = $Ps[pane]
3988 , $R = $Rs[pane]
3989 , side = _c[pane].side
3990 , dimName = _c[pane].sizeType.toLowerCase()
3995 if (pane === "center") return; // validate
3999 setSizeLimits(pane); // update pane-state
4001 size = _parseSize(pane, size); // handle percentages & auto
4002 size = max(size, _parseSize(pane, o.minSize));
4006 makePaneFit(pane, false, skipCallback); // will hide or close pane
4018 _runCallbacks("onresize_start", pane);
4021 newSize = cssSize(pane, size);
4024 var fx = $.layout.effects.size[pane] || $.layout.effects.size.all
4065 pane: pane
4075 , msg = 'Inaccurate size after resizing the '+ pane +'-pane.'
4078 thisTry = { pane: pane, count: lastTry.count+1, target: size }; property in sizePane_2.thisTry
4085 thisTry.cssSize = cssSize(pane, thisTry.attempt);
4113 sizeContent(pane);
4117 _runCallbacks("onresize_end", pane);
4123 …if (!s.isSliding) sizeMidPanes(_c[pane].dir=="horz" ? "" : "center", skipResizeWhileDragging, forc…
4128 var altPane = _c.oppositeEdge[pane];
4149 $.each(panes, function (i, pane) { argument
4150 if (!$Ps[pane]) return; // NO PANE - skip
4152 o = options[pane]
4153 , s = state[pane]
4154 , $P = $Ps[pane]
4155 , $R = $Rs[pane]
4156 , isCenter= (pane=="center")
4168 if (pane === "center") {
4174 $.extend(s, cssMinDims(pane), {
4222 $.extend(s, elDims($P), cssMinDims(pane))
4241 _runCallbacks("onresize_start", pane);
4244 if (pane !== "center")
4245 sizeHandles(pane); // also update resizer length
4247 makePaneFit(pane); // will re-open/show auto-closed/hidden pane
4250 if (state.initialized) sizeContent(pane); // also resize the contents, if exists
4254 makePaneFit(pane); // will hide or close pane
4273 if (pane === "center") { // finished processing midPanes
4283 _runCallbacks("onresize_end", pane);
4330 $.each(["south","north","east","west"], function (i, pane) { argument
4331 if (!$Ps[pane]) return; // no pane - SKIP
4332 o = options[pane];
4333 s = state[pane];
4335 sizePane(pane, o.size, true, true, true); // true=skipCallback/noAnimation/forceResize
4337 setSizeLimits(pane);
4338 makePaneFit(pane, false, true, true); // true=skipCallback/forceResize
4346 $.each(_c.allPanes, function (i, pane) { argument
4347 $P = $Ps[pane];
4349 if (state[pane].isVisible) // undefined for non-existent panes
4350 _runCallbacks("onresize_end", pane); // callback - if exists
4363 var pane = evtPane.call(this, evt_or_pane);
4365 if (!options[pane].resizeChildren) return;
4368 if (!skipRefresh) refreshChildren( pane );
4369 var pC = children[pane];
4390 $.each(panes, function (idx, pane) { argument
4392 $P = $Ps[pane]
4393 , $C = $Cs[pane]
4394 , o = options[pane]
4395 , s = state[pane]
4402 initContent(pane, false); // false = do NOT sizeContent() - already there!
4407 if (false === _runCallbacks("onsizecontent_start", pane)) return;
4430 _runCallbacks("onsizecontent_end", pane);
4438 ignore = options[pane].contentIgnoreSelector
4472 $.each(panes, function (i, pane) { argument
4474 o = options[pane]
4475 , s = state[pane]
4476 , $P = $Ps[pane]
4477 , $R = $Rs[pane]
4478 , $T = $Ts[pane]
4484 dir = _c[pane].dir
4608 var pane = evtPane.call(this, evt_or_pane)
4609 , $T = $Ts[pane]
4610 , o = options[pane]
4614 $T .bind("click."+ sID, function(evt){ evt.stopPropagation(); toggle(pane); })
4617 .attr("title", state[pane].isClosed ? o.tips.Open : o.tips.Close) // may be blank
4626 var pane = evtPane.call(this, evt_or_pane)
4627 , $T = $Ts[pane]
4630 options[pane].closable = false;
4632 if (state[pane].isClosed) open(pane, false, true);
4645 var pane = evtPane.call(this, evt_or_pane)
4646 , $R = $Rs[pane]
4649 options[pane].slidable = true;
4650 if (state[pane].isClosed)
4651 bindStartSlidingEvents(pane, true);
4658 var pane = evtPane.call(this, evt_or_pane)
4659 , $R = $Rs[pane]
4662 options[pane].slidable = false;
4663 if (state[pane].isSliding)
4664 close(pane, false, true);
4666 bindStartSlidingEvents(pane, false);
4679 var pane = evtPane.call(this, evt_or_pane)
4680 , $R = $Rs[pane]
4681 , o = options[pane]
4686 if (!state[pane].isClosed)
4695 var pane = evtPane.call(this, evt_or_pane)
4696 , $R = $Rs[pane]
4699 options[pane].resizable = false;
4776 pane: n
4784 function move (oPane, pane) { argument
4789 , oldPane = oPane.pane
4790 , c = _c[pane]
4792 , s = $.extend(true, {}, state[pane])
4793 , o = options[pane]
4805 $Ps[pane] = $(P)
4807 layoutPane: Instance[pane] // NEW pointer to pane-alias-object
4808 , layoutEdge: pane
4813 $Cs[pane] = C ? $(C) : false;
4816 options[pane] = $.extend(true, {}, oPane.options, fx);
4817 state[pane] = $.extend(true, {}, oPane.state);
4821 P.className = P.className.replace(re, o.paneClass +"-"+ pane);
4824 initHandles(pane); // create the required resizer & toggler
4828 size = sizes[pane] || 0;
4829 setSizeLimits(pane); // update pane-state
4830 size = max(size, state[pane].minSize);
4832 manualSizePane(pane, size, true, true); // true/true = skipCallback/noAnimation
4835 $Rs[pane].css(c.side, sC.inset[c.side] + (state[pane].isVisible ? getPaneSize(pane) : 0));
4840 setAsOpen(pane, true); // true = skipCallback
4842 setAsClosed(pane);
4843 bindStartSlidingEvents(pane, true); // will enable events IF option is set
4860 , syncPinBtns = function (pane, doPin) { argument
4862 $.each(state[pane].pins, function (i, selector) {
4863 $.layout.buttons.setPinState(Instance, $(selector), pane, doPin);
4890 , o, k, m, pane
4894 pane = PANE[code];
4902 pane = p;
4909 if (!pane || !$Ps[pane] || !options[pane].closable || state[pane].isHidden)
4912 toggle(pane);
4950 pane = $P.data("layoutEdge")
4951 , s = state[pane]
4957 resetOverflow(pane); // reset previous CSS before continuing
4994 if (p != pane) resetOverflow(p);
5019 pane = $P.data("layoutEdge")
5020 , s = state[pane]
5380 $.each($.layout.config.allPanes, function (idx, pane) { argument
5381 if (o[pane]) delete o[pane].children;
5393 $.each($.layout.config.borderPanes, function (idx, pane) { argument
5394 o = data[ pane ];
5401 state = inst.state[pane];
5409 inst._sizePane(pane, s, false, false, false); // false=skipCallback/noAnimation/forceResize
5411 if (h === true) inst.hide(pane, noAnimate);
5412 else if (c === true) inst.close(pane, false, noAnimate);
5413 else if (c === false) inst.open (pane, false, noAnimate);
5414 else if (h === false) inst.show (pane, false, noAnimate);
5417 inst._sizePane(pane, s, false, false, noAnimate); // animate resize if option passed
5425 $.each(inst.children, function (pane, paneChildren) { argument
5426 paneStateChildren = data[pane] ? data[pane].children : 0;
5457 , pair, pane, key, val variable
5466 pane = pair[0];
5468 if ($.inArray(pane, panes) < 0) continue; // bad pane!
5469 val = state[ pane ][ key ];
5471 if (key=="isClosed" && state[pane]["isSliding"])
5473 ( data[pane] || (data[pane]={}) )[ alt[key] ? alt[key] : key ] = val;
5478 $.each(panes, function (idx, pane) { argument
5479 pC = inst.children[pane];
5480 ps = state.stateData[pane];
5483 branch = data[pane] || (data[pane] = {});
5663 $.each($.layout.buttons.config.borderPanes.split(","), function (ii, pane) { argument
5664 $("."+pre+action+"-"+pane).each(function(){
5668 inst.bindButton(this, action, pane);
5688 , get: function (inst, selector, pane, action) {
5696 else if ($.layout.buttons.config.borderPanes.indexOf(pane) === -1) { // invalid 'pane' sepecified
5697 if (err) alert(lang.errButton + lang.pane +": "+ pane);
5701 var btn = o[pane].buttonClass +"-"+ action;
5702 $E .addClass( btn +" "+ btn +"-"+ pane )
5716 , bind: function (inst, sel, action, pane) {
5719 case "toggle": _.addToggle (inst, sel, pane); break;
5720 case "open": _.addOpen (inst, sel, pane); break;
5721 case "close": _.addClose (inst, sel, pane); break;
5722 case "pin": _.addPin (inst, sel, pane); break;
5723 case "toggle-slide": _.addToggle (inst, sel, pane, true); break;
5724 case "open-slide": _.addOpen (inst, sel, pane, true); break;
5736 , addToggle: function (inst, selector, pane, slide) {
5737 $.layout.buttons.get(inst, selector, pane, "toggle")
5739 inst.toggle(pane, !!slide);
5752 , addOpen: function (inst, selector, pane, slide) {
5753 $.layout.buttons.get(inst, selector, pane, "open")
5756 inst.open(pane, !!slide);
5768 , addClose: function (inst, selector, pane) {
5769 $.layout.buttons.get(inst, selector, pane, "close")
5772 inst.close(pane);
5791 , addPin: function (inst, selector, pane) {
5792 var $E = $.layout.buttons.get(inst, selector, pane, "pin");
5794 var s = inst.state[pane];
5796 $.layout.buttons.setPinState(inst, $(this), pane, (s.isSliding || s.isClosed));
5797 if (s.isSliding || s.isClosed) inst.open( pane ); // change from sliding to open
5798 else inst.close( pane ); // slide-closed
5802 $.layout.buttons.setPinState(inst, $E, pane, (!s.isClosed && !s.isSliding));
5818 , setPinState: function (inst, $Pin, pane, doPin) {
5822 pin = inst.options[pane].buttonClass +"-pin"
5823 , side = pin +"-"+ pane
5843 , syncPinBtns: function (inst, pane, doPin) {
5845 $.each(state[pane].pins, function (i, selector) {
5846 $.layout.buttons.setPinState(inst, $(selector), pane, doPin);
5854 …bindButton: function (selector, action, pane) { return $.layout.buttons.bind(inst, selector, acti… argument
5856 …, addToggleBtn: function (selector, pane, slide) { return $.layout.buttons.addToggle(inst, selecto… argument
5857 …, addOpenBtn: function (selector, pane, slide) { return $.layout.buttons.addOpen(inst, selector, … argument
5858 …, addCloseBtn: function (selector, pane) { return $.layout.buttons.addClose(inst, selector, pane);… argument
5859 , addPinBtn: function (selector, pane) { return $.layout.buttons.addPin(inst, selector, pane); } argument
5864 var pane = $.layout.buttons.config.borderPanes[i]; variable
5865 inst.state[pane].pins = [];
6022 , pane = $el.data('layoutEdge')
6024 , dist = state[pane].size