2 * @preserve jquery.layout 1.3.0 - Release Candidate 30.51
\r
3 * $Date: 2012-05-12 08:00:00 (Sat, 12 May 2012) $
\r
6 * Copyright (c) 2012
\r
7 * Fabrizio Balliano (http://www.fabrizioballiano.net)
\r
8 * Kevin Dalman (http://allpro.net)
\r
10 * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
\r
11 * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
\r
13 * Changelog: http://layout.jquery-dev.net/changelog.cfm#1.3.0.rc30.5
\r
15 * Docs: http://layout.jquery-dev.net/documentation.html
\r
16 * Tips: http://layout.jquery-dev.net/tips.html
\r
17 * Help: http://groups.google.com/group/jquery-ui-layout
\r
20 /* JavaDoc Info: http://code.google.com/closure/compiler/docs/js-for-compiler.html
\r
21 * {!Object} non-nullable type (never NULL)
\r
22 * {?string} nullable type (sometimes NULL) - default for {Object}
\r
23 * {number=} optional parameter
\r
27 // NOTE: For best readability, view with a fixed-width font and tabs equal to 4-chars
\r
31 // alias Math methods - used a lot!
\r
34 , round = Math.floor
\r
36 function isStr (v) { return $.type(v) === "string"; }
\r
38 function runPluginCallbacks (Instance, a_fn) {
\r
39 if ($.isArray(a_fn))
\r
40 for (var i=0, c=a_fn.length; i<c; i++) {
\r
43 if (isStr(fn)) // 'name' of a function
\r
45 if ($.isFunction(fn))
\r
54 * GENERIC $.layout METHODS - used by all layouts
\r
58 version: "1.3.rc30.51"
\r
59 , revision: 0.033005 // 1.3.0 final = 1.0300 - major(n+).minor(nn)+patch(nn+)
\r
61 // LANGUAGE CUSTOMIZATION
\r
63 // Tips and messages for resizers, togglers, custom buttons, etc.
\r
64 Open: "Open" // eg: "Open Pane"
\r
67 , Slide: "Slide Open"
\r
70 , noRoomToOpenTip: "Not enough room to show this pane."
\r
71 , minSizeWarning: "Panel has reached its minimum size"
\r
72 , maxSizeWarning: "Panel has reached its maximum size"
\r
73 // Developer error messages
\r
74 , pane: "pane" // description of "layout pane element"
\r
75 , selector: "selector" // description of "jQuery-selector"
\r
76 , errButton: "Error Adding Button \n\nInvalid "
\r
77 , errContainerMissing: "UI Layout Initialization Error\n\nThe specified layout-container does not exist."
\r
78 , errCenterPaneMissing: "UI Layout Initialization Error\n\nThe center-pane element does not exist.\n\nThe center-pane is a required element."
\r
79 , errContainerHeight: "UI Layout Initialization Warning\n\nThe layout-container \"CONTAINER\" has no height.\n\nTherefore the layout is 0-height and hence 'invisible'!"
\r
82 // can update code here if $.browser is phased out
\r
84 mozilla: !!$.browser.mozilla
\r
85 , webkit: !!$.browser.webkit || !!$.browser.safari // webkit = jQ 1.4
\r
86 , msie: !!$.browser.msie
\r
87 , isIE6: !!$.browser.msie && $.browser.version == 6
\r
88 , version: $.browser.version // not used in Layout core, but may be used by plugins
\r
91 // *PREDEFINED* EFFECTS & DEFAULTS
\r
92 // MUST list effect here - OR MUST set an fxSettings option (can be an empty hash: {})
\r
95 // Pane Open/Close Animations
\r
97 all: { duration: "fast" } // eg: duration: 1000, easing: "easeOutBounce"
\r
98 , north: { direction: "up" }
\r
99 , south: { direction: "down" }
\r
100 , east: { direction: "right"}
\r
101 , west: { direction: "left" }
\r
104 all: { duration: "slow" }
\r
105 , north: { direction: "up" }
\r
106 , south: { direction: "down" }
\r
107 , east: { direction: "right"}
\r
108 , west: { direction: "left" }
\r
111 all: { duration: "fast" }
\r
113 // these are not recommended, but can be used
\r
121 // Pane Resize Animations
\r
123 all: { easing: "swing" }
\r
127 // INTERNAL CONFIG DATA - DO NOT CHANGE THIS!
\r
129 optionRootKeys: "effects,panes,north,south,west,east,center".split(",")
\r
130 , allPanes: "north,south,west,east,center".split(",")
\r
131 , borderPanes: "north,south,west,east".split(",")
\r
139 , offscreenCSS: { left: "-99999px", right: "auto" } // used by hide/close if useOffscreenClose=true
\r
140 , offscreenReset: "offscreenReset" // key used for data
\r
141 // CSS used in multiple places
\r
142 , hidden: { visibility: "hidden" }
\r
143 , visible: { visibility: "visible" }
\r
144 // layout element settings
\r
147 position: "absolute"
\r
151 , textAlign: "left" // to counter-act "center" alignment!
\r
152 , overflow: "hidden" // prevent toggler-button from overflowing
\r
153 // SEE $.layout.defaults.zIndexes.resizer_normal
\r
155 , cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
\r
162 position: "absolute"
\r
166 , overflow: "hidden"
\r
167 , textAlign: "center"
\r
169 , cursor: "pointer"
\r
172 , cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
\r
178 position: "relative" /* contain floated or positioned elements */
\r
180 , cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
\r
184 , cssDemoPane: { // DEMO CSS - REMOVE scrolling from 'pane' when it has a content-div
\r
189 , panes: { // defaults for ALL panes - overridden by 'per-pane settings' below
\r
191 position: "absolute"
\r
193 // $.layout.defaults.zIndexes.pane_normal
\r
195 , cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
\r
197 , background: "#FFF"
\r
198 , border: "1px solid #BBB"
\r
204 , sizeType: "Height"
\r
217 , sizeType: "Height"
\r
230 , sizeType: "Width"
\r
235 , top: "auto" // DYNAMIC
\r
236 , bottom: "auto" // DYNAMIC
\r
243 , sizeType: "Width"
\r
248 , top: "auto" // DYNAMIC
\r
249 , bottom: "auto" // DYNAMIC
\r
257 left: "auto" // DYNAMIC
\r
258 , right: "auto" // DYNAMIC
\r
259 , top: "auto" // DYNAMIC
\r
260 , bottom: "auto" // DYNAMIC
\r
267 // CALLBACK FUNCTION NAMESPACE - used to store reusable callback functions
\r
270 , getParentPaneElem: function (el) {
\r
271 // must pass either a container or pane element
\r
273 , layout = $el.data("layout") || $el.data("parentLayout");
\r
275 var $cont = layout.container;
\r
276 // see if this container is directly-nested inside an outer-pane
\r
277 if ($cont.data("layoutPane")) return $cont;
\r
278 var $pane = $cont.closest("."+ $.layout.defaults.panes.paneClass);
\r
279 // if a pane was found, return it
\r
280 if ($pane.data("layoutPane")) return $pane;
\r
285 , getParentPaneInstance: function (el) {
\r
286 // must pass either a container or pane element
\r
287 var $pane = $.layout.getParentPaneElem(el);
\r
288 return $pane ? $pane.data("layoutPane") : null;
\r
291 , getParentLayoutInstance: function (el) {
\r
292 // must pass either a container or pane element
\r
293 var $pane = $.layout.getParentPaneElem(el);
\r
294 return $pane ? $pane.data("parentLayout") : null;
\r
297 , getEventObject: function (evt) {
\r
298 return typeof evt === "object" && evt.stopPropagation ? evt : null;
\r
300 , parsePaneName: function (evt_or_pane) {
\r
301 // getEventObject() automatically calls .stopPropagation(), WHICH MUST BE DONE!
\r
302 var evt = $.layout.getEventObject( evt_or_pane );
\r
304 // ALWAYS stop propagation of events triggered in Layout!
\r
305 evt.stopPropagation();
\r
306 return $(this).data("layoutEdge");
\r
309 return evt_or_pane;
\r
313 // LAYOUT-PLUGIN REGISTRATION
\r
314 // more plugins can added beyond this default list
\r
316 draggable: !!$.fn.draggable // resizing
\r
318 core: !!$.effects // animimations (specific effects tested by initOptions)
\r
319 , slide: $.effects && $.effects.slide // default effect
\r
323 // arrays of plugin or other methods to be triggered for events in *each layout* - will be passed 'Instance'
\r
324 , onCreate: [] // runs when layout is just starting to be created - right after options are set
\r
325 , onLoad: [] // runs after layout container and global events init, but before initPanes is called
\r
326 , onReady: [] // runs after initialization *completes* - ie, after initPanes completes successfully
\r
327 , onDestroy: [] // runs after layout is destroyed
\r
328 , onUnload: [] // runs after layout is destroyed OR when page unloads
\r
329 , afterOpen: [] // runs after setAsOpen() completes
\r
330 , afterClose: [] // runs after setAsClosed() completes
\r
333 * GENERIC UTILITY METHODS
\r
336 // calculate and return the scrollbar width, as an integer
\r
337 , scrollbarWidth: function () { return window.scrollbarWidth || $.layout.getScrollbarSize('width'); }
\r
338 , scrollbarHeight: function () { return window.scrollbarHeight || $.layout.getScrollbarSize('height'); }
\r
339 , getScrollbarSize: function (dim) {
\r
340 var $c = $('<div style="position: absolute; top: -10000px; left: -10000px; width: 100px; height: 100px; overflow: scroll;"></div>').appendTo("body");
\r
341 var d = { width: $c.width() - $c[0].clientWidth, height: $c.height() - $c[0].clientHeight };
\r
343 window.scrollbarWidth = d.width;
\r
344 window.scrollbarHeight = d.height;
\r
345 return dim.match(/^(width|height)$/) ? d[dim] : d;
\r
350 * Returns hash container 'display' and 'visibility'
\r
352 * @see $.swap() - swaps CSS, runs callback, resets CSS
\r
354 , showInvisibly: function ($E, force) {
\r
355 if (!$E) return {};
\r
356 if (!$E.jquery) $E = $($E);
\r
358 display: $E.css('display')
\r
359 , visibility: $E.css('visibility')
\r
361 if (force || CSS.display === "none") { // only if not *already hidden*
\r
362 $E.css({ display: "block", visibility: "hidden" }); // show element 'invisibly' so can be measured
\r
369 * Returns data for setting size of an element (container or a pane).
\r
371 * @see _create(), onWindowResize() for container, plus others for pane
\r
372 * @return JSON Returns a hash of all dimensions: top, bottom, left, right, outerWidth, innerHeight, etc
\r
374 , getElementDimensions: function ($E) {
\r
376 d = {} // dimensions hash
\r
377 , x = d.css = {} // CSS hash
\r
378 , i = {} // TEMP insets
\r
379 , b, p // TEMP border, padding
\r
380 , N = $.layout.cssNum
\r
381 , off = $E.offset()
\r
383 d.offsetLeft = off.left;
\r
384 d.offsetTop = off.top;
\r
386 $.each("Left,Right,Top,Bottom".split(","), function (idx, e) { // e = edge
\r
387 b = x["border" + e] = $.layout.borderWidth($E, e);
\r
388 p = x["padding"+ e] = $.layout.cssNum($E, "padding"+e);
\r
389 i[e] = b + p; // total offset of content from outer side
\r
393 d.offsetWidth = $E.innerWidth(); // offsetWidth is used in calc when doing manual resize
\r
394 d.offsetHeight = $E.innerHeight(); // ditto
\r
395 d.outerWidth = $E.outerWidth();
\r
396 d.outerHeight = $E.outerHeight();
\r
397 d.innerWidth = max(0, d.outerWidth - i.Left - i.Right);
\r
398 d.innerHeight = max(0, d.outerHeight - i.Top - i.Bottom);
\r
400 x.width = $E.width();
\r
401 x.height = $E.height();
\r
402 x.top = N($E,"top",true);
\r
403 x.bottom = N($E,"bottom",true);
\r
404 x.left = N($E,"left",true);
\r
405 x.right = N($E,"right",true);
\r
407 //d.visible = $E.is(":visible");// && x.width > 0 && x.height > 0;
\r
412 , getElementCSS: function ($E, list) {
\r
415 , style = $E[0].style
\r
416 , props = list.split(",")
\r
417 , sides = "Top,Bottom,Left,Right".split(",")
\r
418 , attrs = "Color,Style,Width".split(",")
\r
421 for (i=0; i < props.length; i++) {
\r
423 if (p.match(/(border|padding|margin)$/))
\r
424 for (j=0; j < 4; j++) {
\r
426 if (p === "border")
\r
427 for (k=0; k < 3; k++) {
\r
429 CSS[p+s+a] = style[p+s+a];
\r
432 CSS[p+s] = style[p+s];
\r
441 * Return the innerWidth for the current browser/doctype
\r
443 * @see initPanes(), sizeMidPanes(), initHandles(), sizeHandles()
\r
444 * @param {Array.<Object>} $E Must pass a jQuery object - first element is processed
\r
445 * @param {number=} outerWidth (optional) Can pass a width, allowing calculations BEFORE element is resized
\r
446 * @return {number} Returns the innerWidth of the elem by subtracting padding and borders
\r
448 , cssWidth: function ($E, outerWidth) {
\r
450 b = $.layout.borderWidth
\r
451 , n = $.layout.cssNum
\r
453 // a 'calculated' outerHeight can be passed so borders and/or padding are removed if needed
\r
454 if (outerWidth <= 0) return 0;
\r
456 if (!$.support.boxModel) return outerWidth;
\r
458 // strip border and padding from outerWidth to get CSS Width
\r
462 - n($E, "paddingLeft")
\r
463 - n($E, "paddingRight")
\r
470 * Return the innerHeight for the current browser/doctype
\r
472 * @see initPanes(), sizeMidPanes(), initHandles(), sizeHandles()
\r
473 * @param {Array.<Object>} $E Must pass a jQuery object - first element is processed
\r
474 * @param {number=} outerHeight (optional) Can pass a width, allowing calculations BEFORE element is resized
\r
475 * @return {number} Returns the innerHeight of the elem by subtracting padding and borders
\r
477 , cssHeight: function ($E, outerHeight) {
\r
479 b = $.layout.borderWidth
\r
480 , n = $.layout.cssNum
\r
482 // a 'calculated' outerHeight can be passed so borders and/or padding are removed if needed
\r
483 if (outerHeight <= 0) return 0;
\r
485 if (!$.support.boxModel) return outerHeight;
\r
487 // strip border and padding from outerHeight to get CSS Height
\r
488 var H = outerHeight
\r
491 - n($E, "paddingTop")
\r
492 - n($E, "paddingBottom")
\r
499 * Returns the 'current CSS numeric value' for a CSS property - 0 if property does not exist
\r
501 * @see Called by many methods
\r
502 * @param {Array.<Object>} $E Must pass a jQuery object - first element is processed
\r
503 * @param {string} prop The name of the CSS property, eg: top, width, etc.
\r
504 * @param {boolean=} [allowAuto=false] true = return 'auto' if that is value; false = return 0
\r
505 * @return {(string|number)} Usually used to get an integer value for position (top, left) or size (height, width)
\r
507 , cssNum: function ($E, prop, allowAuto) {
\r
508 if (!$E.jquery) $E = $($E);
\r
509 var CSS = $.layout.showInvisibly($E)
\r
510 , p = $.curCSS($E[0], prop, true)
\r
511 , v = allowAuto && p=="auto" ? p : (parseInt(p, 10) || 0);
\r
512 $E.css( CSS ); // RESET
\r
516 , borderWidth: function (el, side) {
\r
517 if (el.jquery) el = el[0];
\r
518 var b = "border"+ side.substr(0,1).toUpperCase() + side.substr(1); // left => Left
\r
519 return $.curCSS(el, b+"Style", true) === "none" ? 0 : (parseInt($.curCSS(el, b+"Width", true), 10) || 0);
\r
523 * Mouse-tracking utility - FUTURE REFERENCE
\r
525 * init: if (!window.mouse) {
\r
526 * window.mouse = { x: 0, y: 0 };
\r
527 * $(document).mousemove( $.layout.trackMouse );
\r
530 * @param {Object} evt
\r
532 , trackMouse: function (evt) {
\r
533 window.mouse = { x: evt.clientX, y: evt.clientY };
\r
538 * SUBROUTINE for preventPrematureSlideClose option
\r
540 * @param {Object} evt
\r
541 * @param {Object=} el
\r
543 , isMouseOverElem: function (evt, el) {
\r
549 , R = L + $E.outerWidth()
\r
550 , B = T + $E.outerHeight()
\r
551 , x = evt.pageX // evt.clientX ?
\r
552 , y = evt.pageY // evt.clientY ?
\r
554 // if X & Y are < 0, probably means is over an open SELECT
\r
555 return ($.layout.browser.msie && x < 0 && y < 0) || ((x >= L && x <= R) && (y >= T && y <= B));
\r
559 * Message/Logging Utility
\r
561 * @example $.layout.msg("My message"); // log text
\r
562 * @example $.layout.msg("My message", true); // alert text
\r
563 * @example $.layout.msg({ foo: "bar" }, "Title"); // log hash-data, with custom title
\r
564 * @example $.layout.msg({ foo: "bar" }, true, "Title", { sort: false }); -OR-
\r
565 * @example $.layout.msg({ foo: "bar" }, "Title", { sort: false, display: true }); // alert hash-data
\r
567 * @param {(Object|string)} info String message OR Hash/Array
\r
568 * @param {(Boolean|string|Object)=} [popup=false] True means alert-box - can be skipped
\r
569 * @param {(Object|string)=} [debugTitle=""] Title for Hash data - can be skipped
\r
570 * @param {Object=} [debutOpts={}] Extra options for debug output
\r
572 , msg: function (info, popup, debugTitle, debugOpts) {
\r
573 if ($.isPlainObject(info) && window.debugData) {
\r
574 if (typeof popup === "string") {
\r
575 debugOpts = debugTitle;
\r
576 debugTitle = popup;
\r
578 else if (typeof debugTitle === "object") {
\r
579 debugOpts = debugTitle;
\r
582 var t = debugTitle || "log( <object> )"
\r
583 , o = $.extend({ sort: false, returnHTML: false, display: false }, debugOpts);
\r
584 if (popup === true || o.display)
\r
585 debugData( info, t, o );
\r
586 else if (window.console)
\r
587 console.log(debugData( info, t, o ));
\r
591 else if (window.console)
\r
594 var id = "#layoutLogger"
\r
598 $l.children("ul").append('<li style="padding: 4px 10px; margin: 0; border-top: 1px solid #CCC;">'+ info.replace(/\</g,"<").replace(/\>/g,">") +'</li>');
\r
601 function createLog () {
\r
602 var pos = $.support.fixedPosition ? 'fixed' : 'absolute'
\r
603 , $e = $('<div id="layoutLogger" style="position: '+ pos +'; top: 5px; z-index: 999999; max-width: 25%; overflow: hidden; border: 1px solid #000; border-radius: 5px; background: #FBFBFB; box-shadow: 0 2px 10px rgba(0,0,0,0.3);">'
\r
604 + '<div style="font-size: 13px; font-weight: bold; padding: 5px 10px; background: #F6F6F6; border-radius: 5px 5px 0 0; cursor: move;">'
\r
605 + '<span style="float: right; padding-left: 7px; cursor: pointer;" title="Remove Console" onclick="$(this).closest(\'#layoutLogger\').remove()">X</span>Layout console.log</div>'
\r
606 + '<ul style="font-size: 13px; font-weight: none; list-style: none; margin: 0; padding: 0 0 2px;"></ul>'
\r
608 ).appendTo("body");
\r
609 $e.css('left', $(window).width() - $e.outerWidth() - 5)
\r
610 if ($.ui.draggable) $e.draggable({ handle: ':first-child' });
\r
617 var lang = $.layout.language; // alias used in defaults...
\r
619 // DEFAULT OPTIONS - CHANGE IF DESIRED
\r
620 $.layout.defaults = {
\r
622 * LAYOUT & LAYOUT-CONTAINER OPTIONS
\r
623 * - none of these options are applicable to individual panes
\r
625 name: "" // Not required, but useful for buttons and used for the state-cookie
\r
626 , containerSelector: "" // ONLY used when specifying a childOptions - to find container-element that is NOT directly-nested
\r
627 , containerClass: "ui-layout-container" // layout-container element
\r
628 , scrollToBookmarkOnLoad: true // after creating a layout, scroll to bookmark in URL (.../page.htm#myBookmark)
\r
629 , resizeWithWindow: true // bind thisLayout.resizeAll() to the window.resize event
\r
630 , resizeWithWindowDelay: 200 // delay calling resizeAll because makes window resizing very jerky
\r
631 , resizeWithWindowMaxDelay: 0 // 0 = none - force resize every XX ms while window is being resized
\r
632 , onresizeall_start: null // CALLBACK when resizeAll() STARTS - NOT pane-specific
\r
633 , onresizeall_end: null // CALLBACK when resizeAll() ENDS - NOT pane-specific
\r
634 , onload_start: null // CALLBACK when Layout inits - after options initialized, but before elements
\r
635 , onload_end: null // CALLBACK when Layout inits - after EVERYTHING has been initialized
\r
636 , onunload_start: null // CALLBACK when Layout is destroyed OR onWindowUnload
\r
637 , onunload_end: null // CALLBACK when Layout is destroyed OR onWindowUnload
\r
638 , autoBindCustomButtons: false // search for buttons with ui-layout-button class and auto-bind them
\r
639 , initPanes: true // false = DO NOT initialize the panes onLoad - will init later
\r
640 , showErrorMessages: true // enables fatal error messages to warn developers of common errors
\r
641 , showDebugMessages: false // display console-and-alert debug msgs - IF this Layout version _has_ debugging code!
\r
642 // Changing this zIndex value will cause other zIndex values to automatically change
\r
643 , zIndex: null // the PANE zIndex - resizers and masks will be +1
\r
644 // DO NOT CHANGE the zIndex values below unless you clearly understand their relationships
\r
645 , zIndexes: { // set _default_ z-index values here...
\r
646 pane_normal: 0 // normal z-index for panes
\r
647 , content_mask: 1 // applied to overlays used to mask content INSIDE panes during resizing
\r
648 , resizer_normal: 2 // normal z-index for resizer-bars
\r
649 , pane_sliding: 100 // applied to *BOTH* the pane and its resizer when a pane is 'slid open'
\r
650 , pane_animate: 1000 // applied to the pane when being animated - not applied to the resizer
\r
651 , resizer_drag: 10000 // applied to the CLONED resizer-bar when being 'dragged'
\r
654 * PANE DEFAULT SETTINGS
\r
655 * - settings under the 'panes' key become the default settings for *all panes*
\r
656 * - ALL pane-options can also be set specifically for each panes, which will override these 'default values'
\r
658 , panes: { // default options for 'all panes' - will be overridden by 'per-pane settings'
\r
659 applyDemoStyles: false // NOTE: renamed from applyDefaultStyles for clarity
\r
660 , closable: true // pane can open & close
\r
661 , resizable: true // when open, pane can be resized
\r
662 , slidable: true // when closed, pane can 'slide open' over other panes - closes on mouse-out
\r
663 , initClosed: false // true = init pane as 'closed'
\r
664 , initHidden: false // true = init pane as 'hidden' - no resizer-bar/spacing
\r
666 //, paneSelector: "" // MUST be pane-specific - jQuery selector for pane
\r
667 , contentSelector: ".ui-layout-content" // INNER div/element to auto-size so only it scrolls, not the entire pane!
\r
668 , contentIgnoreSelector: ".ui-layout-ignore" // element(s) to 'ignore' when measuring 'content'
\r
669 , findNestedContent: false // true = $P.find(contentSelector), false = $P.children(contentSelector)
\r
670 // GENERIC ROOT-CLASSES - for auto-generated classNames
\r
671 , paneClass: "ui-layout-pane" // Layout Pane
\r
672 , resizerClass: "ui-layout-resizer" // Resizer Bar
\r
673 , togglerClass: "ui-layout-toggler" // Toggler Button
\r
674 , buttonClass: "ui-layout-button" // CUSTOM Buttons - eg: '[ui-layout-button]-toggle/-open/-close/-pin'
\r
675 // ELEMENT SIZE & SPACING
\r
676 //, size: 100 // MUST be pane-specific -initial size of pane
\r
677 , minSize: 0 // when manually resizing a pane
\r
678 , maxSize: 0 // ditto, 0 = no limit
\r
679 , spacing_open: 6 // space between pane and adjacent panes - when pane is 'open'
\r
680 , spacing_closed: 6 // ditto - when pane is 'closed'
\r
681 , togglerLength_open: 50 // Length = WIDTH of toggler button on north/south sides - HEIGHT on east/west sides
\r
682 , togglerLength_closed: 50 // 100% OR -1 means 'full height/width of resizer bar' - 0 means 'hidden'
\r
683 , togglerAlign_open: "center" // top/left, bottom/right, center, OR...
\r
684 , togglerAlign_closed: "center" // 1 => nn = offset from top/left, -1 => -nn == offset from bottom/right
\r
685 , togglerTip_open: lang.Close // Toggler tool-tip (title)
\r
686 , togglerTip_closed: lang.Open // ditto
\r
687 , togglerContent_open: "" // text or HTML to put INSIDE the toggler
\r
688 , togglerContent_closed: "" // ditto
\r
689 // RESIZING OPTIONS
\r
690 , resizerDblClickToggle: true //
\r
691 , autoResize: true // IF size is 'auto' or a percentage, then recalc 'pixel size' whenever the layout resizes
\r
692 , autoReopen: true // IF a pane was auto-closed due to noRoom, reopen it when there is room? False = leave it closed
\r
693 , resizerDragOpacity: 1 // option for ui.draggable
\r
694 //, resizerCursor: "" // MUST be pane-specific - cursor when over resizer-bar
\r
695 , maskContents: false // true = add DIV-mask over-or-inside this pane so can 'drag' over IFRAMES
\r
696 , maskObjects: false // true = add IFRAME-mask over-or-inside this pane to cover objects/applets - content-mask will overlay this mask
\r
697 , maskZindex: null // will override zIndexes.content_mask if specified - not applicable to iframe-panes
\r
698 , resizingGrid: false // grid size that the resizers will snap-to during resizing, eg: [20,20]
\r
699 , livePaneResizing: false // true = LIVE Resizing as resizer is dragged
\r
700 , liveContentResizing: false // true = re-measure header/footer heights as resizer is dragged
\r
701 , liveResizingTolerance: 1 // how many px change before pane resizes, to control performance
\r
702 // TIPS & MESSAGES - also see lang object
\r
703 , noRoomToOpenTip: lang.noRoomToOpenTip
\r
704 , resizerTip: lang.Resize // Resizer tool-tip (title)
\r
705 , sliderTip: lang.Slide // resizer-bar triggers 'sliding' when pane is closed
\r
706 , sliderCursor: "pointer" // cursor when resizer-bar will trigger 'sliding'
\r
707 , slideTrigger_open: "click" // click, dblclick, mouseenter
\r
708 , slideTrigger_close: "mouseleave"// click, mouseleave
\r
709 , slideDelay_open: 300 // applies only for mouseenter event - 0 = instant open
\r
710 , slideDelay_close: 300 // applies only for mouseleave event (300ms is the minimum!)
\r
711 , hideTogglerOnSlide: false // when pane is slid-open, should the toggler show?
\r
712 , preventQuickSlideClose: $.layout.browser.webkit // Chrome triggers slideClosed as it is opening
\r
713 , preventPrematureSlideClose: false // handle incorrect mouseleave trigger, like when over a SELECT-list in IE
\r
715 , showOverflowOnHover: false // will bind allowOverflow() utility to pane.onMouseOver
\r
716 , enableCursorHotkey: true // enabled 'cursor' hotkeys
\r
717 //, customHotkey: "" // MUST be pane-specific - EITHER a charCode OR a character
\r
718 , customHotkeyModifier: "SHIFT" // either 'SHIFT', 'CTRL' or 'CTRL+SHIFT' - NOT 'ALT'
\r
720 // NOTE: fxSss_open, fxSss_close & fxSss_size options (eg: fxName_open) are auto-generated if not passed
\r
721 , fxName: "slide" // ('none' or blank), slide, drop, scale -- only relevant to 'open' & 'close', NOT 'size'
\r
722 , fxSpeed: null // slow, normal, fast, 200, nnn - if passed, will OVERRIDE fxSettings.duration
\r
723 , fxSettings: {} // can be passed, eg: { easing: "easeOutBounce", duration: 1500 }
\r
724 , fxOpacityFix: true // tries to fix opacity in IE to restore anti-aliasing after animation
\r
725 , animatePaneSizing: false // true = animate resizing after dragging resizer-bar OR sizePane() is called
\r
726 /* NOTE: Action-specific FX options are auto-generated from the options above if not specifically set:
\r
727 fxName_open: "slide" // 'Open' pane animation
\r
728 fnName_close: "slide" // 'Close' pane animation
\r
729 fxName_size: "slide" // 'Size' pane animation - when animatePaneSizing = true
\r
731 fxSpeed_close: null
\r
733 fxSettings_open: {}
\r
734 fxSettings_close: {}
\r
735 fxSettings_size: {}
\r
737 // CHILD/NESTED LAYOUTS
\r
738 , childOptions: null // Layout-options for nested/child layout - even {} is valid as options
\r
739 , initChildLayout: true // true = child layout will be created as soon as _this_ layout completes initialization
\r
740 , destroyChildLayout: true // true = destroy child-layout if this pane is destroyed
\r
741 , resizeChildLayout: true // true = trigger child-layout.resizeAll() when this pane is resized
\r
743 , triggerEventsOnLoad: false // true = trigger onopen OR onclose callbacks when layout initializes
\r
744 , triggerEventsDuringLiveResize: true // true = trigger onresize callback REPEATEDLY if livePaneResizing==true
\r
745 , onshow_start: null // CALLBACK when pane STARTS to Show - BEFORE onopen/onhide_start
\r
746 , onshow_end: null // CALLBACK when pane ENDS being Shown - AFTER onopen/onhide_end
\r
747 , onhide_start: null // CALLBACK when pane STARTS to Close - BEFORE onclose_start
\r
748 , onhide_end: null // CALLBACK when pane ENDS being Closed - AFTER onclose_end
\r
749 , onopen_start: null // CALLBACK when pane STARTS to Open
\r
750 , onopen_end: null // CALLBACK when pane ENDS being Opened
\r
751 , onclose_start: null // CALLBACK when pane STARTS to Close
\r
752 , onclose_end: null // CALLBACK when pane ENDS being Closed
\r
753 , onresize_start: null // CALLBACK when pane STARTS being Resized ***FOR ANY REASON***
\r
754 , onresize_end: null // CALLBACK when pane ENDS being Resized ***FOR ANY REASON***
\r
755 , onsizecontent_start: null // CALLBACK when sizing of content-element STARTS
\r
756 , onsizecontent_end: null // CALLBACK when sizing of content-element ENDS
\r
757 , onswap_start: null // CALLBACK when pane STARTS to Swap
\r
758 , onswap_end: null // CALLBACK when pane ENDS being Swapped
\r
759 , ondrag_start: null // CALLBACK when pane STARTS being ***MANUALLY*** Resized
\r
760 , ondrag_end: null // CALLBACK when pane ENDS being ***MANUALLY*** Resized
\r
763 * PANE-SPECIFIC SETTINGS
\r
764 * - options listed below MUST be specified per-pane - they CANNOT be set under 'panes'
\r
765 * - all options under the 'panes' key can also be set specifically for any pane
\r
766 * - most options under the 'panes' key apply only to 'border-panes' - NOT the the center-pane
\r
769 paneSelector: ".ui-layout-north"
\r
770 , size: "auto" // eg: "auto", "30%", .30, 200
\r
771 , resizerCursor: "n-resize" // custom = url(myCursor.cur)
\r
772 , customHotkey: "" // EITHER a charCode (43) OR a character ("o")
\r
775 paneSelector: ".ui-layout-south"
\r
777 , resizerCursor: "s-resize"
\r
781 paneSelector: ".ui-layout-east"
\r
783 , resizerCursor: "e-resize"
\r
787 paneSelector: ".ui-layout-west"
\r
789 , resizerCursor: "w-resize"
\r
793 paneSelector: ".ui-layout-center"
\r
799 $.layout.optionsMap = {
\r
800 // layout/global options - NOT pane-options
\r
801 layout: ("stateManagement,effects,zIndexes,"
\r
802 + "name,zIndex,scrollToBookmarkOnLoad,showErrorMessages,"
\r
803 + "resizeWithWindow,resizeWithWindowDelay,resizeWithWindowMaxDelay,"
\r
804 + "onresizeall,onresizeall_start,onresizeall_end,onload,onunload,autoBindCustomButtons").split(",")
\r
805 // borderPanes: [ ALL options that are NOT specified as 'layout' ]
\r
806 // default.panes options that apply to the center-pane (most options apply _only_ to border-panes)
\r
807 , center: ("paneClass,contentSelector,contentIgnoreSelector,findNestedContent,applyDemoStyles,triggerEventsOnLoad,"
\r
808 + "showOverflowOnHover,maskContents,maskObjects,liveContentResizing,"
\r
809 + "childOptions,initChildLayout,resizeChildLayout,destroyChildLayout,"
\r
810 + "onresize,onresize_start,onresize_end,onsizecontent,onsizecontent_start,onsizecontent_end").split(",")
\r
811 // options that MUST be specifically set 'per-pane' - CANNOT set in the panes (defaults) key
\r
812 , noDefault: ("paneSelector,resizerCursor,customHotkey").split(",")
\r
816 * Processes options passed in converts flat-format data into subkey (JSON) format
\r
817 * In flat-format, subkeys are _currently_ separated with 2 underscores, like north__optName
\r
818 * Plugins may also call this method so they can transform their own data
\r
820 * @param {!Object} hash Data/options passed by user - may be a single level or nested levels
\r
821 * @return {Object} Returns hash of minWidth & minHeight
\r
823 $.layout.transformData = function (hash) {
\r
824 var json = { panes: {}, center: {} } // init return object
\r
825 , data, branch, optKey, keys, key, val, i, c;
\r
827 if (typeof hash !== "object") return json; // no options passed
\r
829 // convert all 'flat-keys' to 'sub-key' format
\r
830 for (optKey in hash) {
\r
832 data = $.layout.optionsMap.layout;
\r
833 val = hash[ optKey ];
\r
834 keys = optKey.split("__"); // eg: west__size or north__fxSettings__duration
\r
835 c = keys.length - 1;
\r
836 // convert underscore-delimited to subkeys
\r
837 for (i=0; i <= c; i++) {
\r
841 else if (!branch[key])
\r
842 branch[key] = {}; // create the subkey
\r
843 // recurse to sub-key for next loop - if not done
\r
844 branch = branch[key];
\r
851 // INTERNAL CONFIG DATA - DO NOT CHANGE THIS!
\r
852 $.layout.backwardCompatibility = {
\r
853 // data used by renameOldOptions()
\r
855 // OLD Option Name: NEW Option Name
\r
856 applyDefaultStyles: "applyDemoStyles"
\r
857 , resizeNestedLayout: "resizeChildLayout"
\r
858 , resizeWhileDragging: "livePaneResizing"
\r
859 , resizeContentWhileDragging: "liveContentResizing"
\r
860 , triggerEventsWhileDragging: "triggerEventsDuringLiveResize"
\r
861 , maskIframesOnResize: "maskContents"
\r
862 , useStateCookie: "stateManagement.enabled"
\r
863 , "cookie.autoLoad": "stateManagement.autoLoad"
\r
864 , "cookie.autoSave": "stateManagement.autoSave"
\r
865 , "cookie.keys": "stateManagement.stateKeys"
\r
866 , "cookie.name": "stateManagement.cookie.name"
\r
867 , "cookie.domain": "stateManagement.cookie.domain"
\r
868 , "cookie.path": "stateManagement.cookie.path"
\r
869 , "cookie.expires": "stateManagement.cookie.expires"
\r
870 , "cookie.secure": "stateManagement.cookie.secure"
\r
873 * @param {Object} opts
\r
875 , renameOptions: function (opts) {
\r
876 var map = $.layout.backwardCompatibility.map
\r
877 , oldData, newData, value
\r
879 for (var itemPath in map) {
\r
880 oldData = getBranch( itemPath );
\r
881 value = oldData.branch[ oldData.key ]
\r
882 if (value !== undefined) {
\r
883 newData = getBranch( map[itemPath], true )
\r
884 newData.branch[ newData.key ] = value;
\r
885 delete oldData.branch[ oldData.key ];
\r
890 * @param {string} path
\r
891 * @param {boolean=} [create=false] Create path if does not exist
\r
893 function getBranch (path, create) {
\r
894 var a = path.split(".") // split keys into array
\r
896 , D = { branch: opts, key: a[c] } // init branch at top & set key (last item)
\r
898 for (; i<c; i++) { // skip the last key (data)
\r
900 if (D.branch[ k ] == undefined) { // child-key does not exist
\r
902 D.branch = D.branch[ k ] = {}; // create child-branch
\r
904 else // can't go any farther
\r
905 D.branch = {}; // branch is undefined
\r
908 D.branch = D.branch[ k ]; // get child-branch
\r
914 * @param {Object} opts
\r
916 , renameAllOptions: function (opts) {
\r
917 var ren = $.layout.backwardCompatibility.renameOptions;
\r
918 // rename root (layout) options
\r
920 // rename 'defaults' to 'panes'
\r
921 if (opts.defaults) {
\r
922 if (typeof opts.panes !== "object")
\r
924 $.extend(true, opts.panes, opts.defaults);
\r
925 delete opts.defaults;
\r
927 // rename options in the the options.panes key
\r
928 if (opts.panes) ren( opts.panes );
\r
929 // rename options inside *each pane key*, eg: options.west
\r
930 $.each($.layout.config.allPanes, function (i, pane) {
\r
931 if (opts[pane]) ren( opts[pane] );
\r
939 /* ============================================================
\r
940 * BEGIN WIDGET: $( selector ).layout( {options} );
\r
941 * ============================================================
\r
943 $.fn.layout = function (opts) {
\r
946 // local aliases to global data
\r
947 browser = $.layout.browser
\r
948 , lang = $.layout.language // internal alias
\r
949 , _c = $.layout.config
\r
951 // local aliases to utlity methods
\r
952 , cssW = $.layout.cssWidth
\r
953 , cssH = $.layout.cssHeight
\r
954 , elDims = $.layout.getElementDimensions
\r
955 , elCSS = $.layout.getElementCSS
\r
956 , evtObj = $.layout.getEventObject
\r
957 , evtPane = $.layout.parsePaneName
\r
960 * options - populated by initOptions()
\r
962 , options = $.extend(true, {}, $.layout.defaults)
\r
963 , effects = options.effects = $.extend(true, {}, $.layout.effects)
\r
966 * layout-state object
\r
969 // generate unique ID to use for event.namespace so can unbind only events added by 'this layout'
\r
970 id: "layout"+ $.now() // code uses alias: sID
\r
971 , initialized: false
\r
972 , container: {} // init all keys
\r
981 * parent/child-layout pointers
\r
983 //, hasParentLayout = false - exists ONLY inside Instance so can be set externally
\r
993 * ###########################
\r
994 * INTERNAL HELPER FUNCTIONS
\r
995 * ###########################
\r
999 * Manages all internal timers
\r
1003 , set: function (s, fn, ms) { timer.clear(s); timer.data[s] = setTimeout(fn, ms); }
\r
1004 , clear: function (s) { var t=timer.data; if (t[s]) {clearTimeout(t[s]); delete t[s];} }
\r
1007 , _log = function (msg, popup) {
\r
1008 $.layout.msg( options.name +' / '+ msg, (popup && options.showErrorMessages) );
\r
1012 * Executes a Callback function after a trigger event, like resize, open or close
\r
1014 * @param {string} evtName Name of the layout callback, eg "onresize_start"
\r
1015 * @param {?string} pane This is passed only so we can pass the 'pane object' to the callback
\r
1016 * @param {?boolean} skipBoundEvents Accepts a function name, OR a comma-delimited array: [0]=function name, [1]=argument
\r
1018 , _runCallbacks = function (evtName, pane, skipBoundEvents) {
\r
1019 var o = pane ? options[pane] : options
\r
1020 // names like onopen and onopen_end separate are interchangeable in options...
\r
1021 , lng = evtName + (evtName.match(/_/) ? "" : "_end")
\r
1022 , shrt = lng.match(/_end$/) ? lng.substr(0, lng.length - 4) : ""
\r
1024 , retVal = "NC" // NC = No Callback
\r
1030 // first trigger the callback set in the options
\r
1033 // convert function name (string) to function object
\r
1034 if (isStr( fn )) {
\r
1035 if (fn.match(/,/)) {
\r
1036 // function name cannot contain a comma,
\r
1037 // so must be a function name AND a parameter to pass
\r
1038 args = fn.split(",")
\r
1039 , fn = eval(args[0]);
\r
1041 else // just the name of an external function?
\r
1044 // execute the callback, if exists
\r
1045 if ($.isFunction( fn )) {
\r
1047 retVal = fn(args[1]); // pass the argument parsed from 'list'
\r
1048 else if (pane && $Ps[pane])
\r
1049 // pass data: pane-name, pane-element, pane-state, pane-options, and layout-name
\r
1050 retVal = fn( pane, $Ps[pane], state[pane], options[pane], options.name );
\r
1051 else // must be a layout/container callback - pass suitable info
\r
1052 retVal = fn( Instance, state, options, options.name );
\r
1058 // trigger additional events bound directly to the pane
\r
1059 if (!skipBoundEvents && retVal !== false) {
\r
1060 if (pane) { // PANE events can be bound to each pane-elements
\r
1061 $Ps[pane].triggerHandler('layoutpane'+ lng, [ pane, $Ps[pane], state[pane], options[pane], options.name ]);
\r
1063 $Ps[pane].triggerHandler('layoutpane'+ shrt, [ pane, $Ps[pane], state[pane], options[pane], options.name ]);
\r
1065 else // LAYOUT events can be bound to the container-element
\r
1066 $N.triggerHandler('layout'+ lng, [ pane, $Ps[pane], state[pane], options[pane], options.name ]);
\r
1069 // ALWAYS resizeChildLayout after a resize event - even during initialization
\r
1070 if (evtName === "onresize_end" || evtName === "onsizecontent_end")
\r
1071 resizeChildLayout(pane);
\r
1078 * cure iframe display issues in IE & other browsers
\r
1080 , _fixIframe = function (pane) {
\r
1081 if (browser.mozilla) return; // skip FireFox - it auto-refreshes iframes onShow
\r
1082 var $P = $Ps[pane];
\r
1083 // if the 'pane' is an iframe, do it
\r
1084 if (state[pane].tagName === "IFRAME")
\r
1085 $P.css(_c.hidden).css(_c.visible);
\r
1086 else // ditto for any iframes INSIDE the pane
\r
1087 $P.find('IFRAME').css(_c.hidden).css(_c.visible);
\r
1091 * @param {string} pane Can accept ONLY a 'pane' (east, west, etc)
\r
1092 * @param {number=} outerSize (optional) Can pass a width, allowing calculations BEFORE element is resized
\r
1093 * @return {number} Returns the innerHeight/Width of el by subtracting padding and borders
\r
1095 , cssSize = function (pane, outerSize) {
\r
1096 var fn = _c[pane].dir=="horz" ? cssH : cssW;
\r
1097 return fn($Ps[pane], outerSize);
\r
1101 * @param {string} pane Can accept ONLY a 'pane' (east, west, etc)
\r
1102 * @return {Object} Returns hash of minWidth & minHeight
\r
1104 , cssMinDims = function (pane) {
\r
1105 // minWidth/Height means CSS width/height = 1px
\r
1106 var $P = $Ps[pane]
\r
1107 , dir = _c[pane].dir
\r
1109 minWidth: 1001 - cssW($P, 1000)
\r
1110 , minHeight: 1001 - cssH($P, 1000)
\r
1113 if (dir === "horz") d.minSize = d.minHeight;
\r
1114 if (dir === "vert") d.minSize = d.minWidth;
\r
1118 // TODO: see if these methods can be made more useful...
\r
1119 // TODO: *maybe* return cssW/H from these so caller can use this info
\r
1122 * @param {(string|!Object)} el
\r
1123 * @param {number=} outerWidth
\r
1124 * @param {boolean=} [autoHide=false]
\r
1126 , setOuterWidth = function (el, outerWidth, autoHide) {
\r
1128 if (isStr(el)) $E = $Ps[el]; // west
\r
1129 else if (!el.jquery) $E = $(el);
\r
1130 w = cssW($E, outerWidth);
\r
1131 $E.css({ width: w });
\r
1133 if (autoHide && $E.data('autoHidden') && $E.innerHeight() > 0) {
\r
1134 $E.show().data('autoHidden', false);
\r
1135 if (!browser.mozilla) // FireFox refreshes iframes - IE does not
\r
1136 // make hidden, then visible to 'refresh' display after animation
\r
1137 $E.css(_c.hidden).css(_c.visible);
\r
1140 else if (autoHide && !$E.data('autoHidden'))
\r
1141 $E.hide().data('autoHidden', true);
\r
1145 * @param {(string|!Object)} el
\r
1146 * @param {number=} outerHeight
\r
1147 * @param {boolean=} [autoHide=false]
\r
1149 , setOuterHeight = function (el, outerHeight, autoHide) {
\r
1151 if (isStr(el)) $E = $Ps[el]; // west
\r
1152 else if (!el.jquery) $E = $(el);
\r
1153 h = cssH($E, outerHeight);
\r
1154 $E.css({ height: h, visibility: "visible" }); // may have been 'hidden' by sizeContent
\r
1155 if (h > 0 && $E.innerWidth() > 0) {
\r
1156 if (autoHide && $E.data('autoHidden')) {
\r
1157 $E.show().data('autoHidden', false);
\r
1158 if (!browser.mozilla) // FireFox refreshes iframes - IE does not
\r
1159 $E.css(_c.hidden).css(_c.visible);
\r
1162 else if (autoHide && !$E.data('autoHidden'))
\r
1163 $E.hide().data('autoHidden', true);
\r
1167 * @param {(string|!Object)} el
\r
1168 * @param {number=} outerSize
\r
1169 * @param {boolean=} [autoHide=false]
\r
1171 , setOuterSize = function (el, outerSize, autoHide) {
\r
1172 if (_c[pane].dir=="horz") // pane = north or south
\r
1173 setOuterHeight(el, outerSize, autoHide);
\r
1174 else // pane = east or west
\r
1175 setOuterWidth(el, outerSize, autoHide);
\r
1180 * Converts any 'size' params to a pixel/integer size, if not already
\r
1181 * If 'auto' or a decimal/percentage is passed as 'size', a pixel-size is calculated
\r
1184 * @param {string} pane
\r
1185 * @param {(string|number)=} size
\r
1186 * @param {string=} [dir]
\r
1187 * @return {number}
\r
1189 , _parseSize = function (pane, size, dir) {
\r
1190 if (!dir) dir = _c[pane].dir;
\r
1192 if (isStr(size) && size.match(/%/))
\r
1193 size = (size === '100%') ? -1 : parseInt(size, 10) / 100; // convert % to decimal
\r
1197 else if (size >= 1)
\r
1198 return parseInt(size, 10);
\r
1200 var o = options, avail = 0;
\r
1201 if (dir=="horz") // north or south or center.minHeight
\r
1202 avail = sC.innerHeight - ($Ps.north ? o.north.spacing_open : 0) - ($Ps.south ? o.south.spacing_open : 0);
\r
1203 else if (dir=="vert") // east or west or center.minWidth
\r
1204 avail = sC.innerWidth - ($Ps.west ? o.west.spacing_open : 0) - ($Ps.east ? o.east.spacing_open : 0);
\r
1206 if (size === -1) // -1 == 100%
\r
1208 else if (size > 0) // percentage, eg: .25
\r
1209 return round(avail * size);
\r
1210 else if (pane=="center")
\r
1212 else { // size < 0 || size=='auto' || size==Missing || size==Invalid
\r
1213 // auto-size the pane
\r
1214 var dim = (dir === "horz" ? "height" : "width")
\r
1216 , $C = dim === 'height' ? $Cs[pane] : false
\r
1217 , vis = $.layout.showInvisibly($P) // show pane invisibly if hidden
\r
1218 , szP = $P.css(dim) // SAVE current pane size
\r
1219 , szC = $C ? $C.css(dim) : 0 // SAVE current content size
\r
1221 $P.css(dim, "auto");
\r
1222 if ($C) $C.css(dim, "auto");
\r
1223 size = (dim === "height") ? $P.outerHeight() : $P.outerWidth(); // MEASURE
\r
1224 $P.css(dim, szP).css(vis); // RESET size & visibility
\r
1225 if ($C) $C.css(dim, szC);
\r
1231 * Calculates current 'size' (outer-width or outer-height) of a border-pane - optionally with 'pane-spacing' added
\r
1233 * @param {(string|!Object)} pane
\r
1234 * @param {boolean=} [inclSpace=false]
\r
1235 * @return {number} Returns EITHER Width for east/west panes OR Height for north/south panes - adjusted for boxModel & browser
\r
1237 , getPaneSize = function (pane, inclSpace) {
\r
1240 , o = options[pane]
\r
1242 , oSp = (inclSpace ? o.spacing_open : 0)
\r
1243 , cSp = (inclSpace ? o.spacing_closed : 0)
\r
1245 if (!$P || s.isHidden)
\r
1247 else if (s.isClosed || (s.isSliding && inclSpace))
\r
1249 else if (_c[pane].dir === "horz")
\r
1250 return $P.outerHeight() + oSp;
\r
1251 else // dir === "vert"
\r
1252 return $P.outerWidth() + oSp;
\r
1256 * Calculate min/max pane dimensions and limits for resizing
\r
1258 * @param {string} pane
\r
1259 * @param {boolean=} [slide=false]
\r
1261 , setSizeLimits = function (pane, slide) {
\r
1262 if (!isInitialized()) return;
\r
1268 , side = c.side.toLowerCase()
\r
1269 , type = c.sizeType.toLowerCase()
\r
1270 , isSliding = (slide != undefined ? slide : s.isSliding) // only open() passes 'slide' param
\r
1272 , paneSpacing = o.spacing_open
\r
1273 // measure the pane on the *opposite side* from this pane
\r
1274 , altPane = _c.oppositeEdge[pane]
\r
1275 , altS = state[altPane]
\r
1276 , $altP = $Ps[altPane]
\r
1277 , altPaneSize = (!$altP || altS.isVisible===false || altS.isSliding ? 0 : (dir=="horz" ? $altP.outerHeight() : $altP.outerWidth()))
\r
1278 , altPaneSpacing = ((!$altP || altS.isHidden ? 0 : options[altPane][ altS.isClosed !== false ? "spacing_closed" : "spacing_open" ]) || 0)
\r
1279 // limitSize prevents this pane from 'overlapping' opposite pane
\r
1280 , containerSize = (dir=="horz" ? sC.innerHeight : sC.innerWidth)
\r
1281 , minCenterDims = cssMinDims("center")
\r
1282 , minCenterSize = dir=="horz" ? max(options.center.minHeight, minCenterDims.minHeight) : max(options.center.minWidth, minCenterDims.minWidth)
\r
1283 // if pane is 'sliding', then ignore center and alt-pane sizes - because 'overlays' them
\r
1284 , limitSize = (containerSize - paneSpacing - (isSliding ? 0 : (_parseSize("center", minCenterSize, dir) + altPaneSize + altPaneSpacing)))
\r
1285 , minSize = s.minSize = max( _parseSize(pane, o.minSize), cssMinDims(pane).minSize )
\r
1286 , maxSize = s.maxSize = min( (o.maxSize ? _parseSize(pane, o.maxSize) : 100000), limitSize )
\r
1287 , r = s.resizerPosition = {} // used to set resizing limits
\r
1288 , top = sC.insetTop
\r
1289 , left = sC.insetLeft
\r
1290 , W = sC.innerWidth
\r
1291 , H = sC.innerHeight
\r
1292 , rW = o.spacing_open // subtract resizer-width to get top/left position for south/east
\r
1295 case "north": r.min = top + minSize;
\r
1296 r.max = top + maxSize;
\r
1298 case "west": r.min = left + minSize;
\r
1299 r.max = left + maxSize;
\r
1301 case "south": r.min = top + H - maxSize - rW;
\r
1302 r.max = top + H - minSize - rW;
\r
1304 case "east": r.min = left + W - maxSize - rW;
\r
1305 r.max = left + W - minSize - rW;
\r
1311 * Returns data for setting the size/position of center pane. Also used to set Height for east/west panes
\r
1313 * @return JSON Returns a hash of all dimensions: top, bottom, left, right, (outer) width and (outer) height
\r
1315 , calcNewCenterPaneDims = function () {
\r
1317 top: getPaneSize("north", true) // true = include 'spacing' value for pane
\r
1318 , bottom: getPaneSize("south", true)
\r
1319 , left: getPaneSize("west", true)
\r
1320 , right: getPaneSize("east", true)
\r
1325 // NOTE: sC = state.container
\r
1326 // calc center-pane outer dimensions
\r
1327 d.width = sC.innerWidth - d.left - d.right; // outerWidth
\r
1328 d.height = sC.innerHeight - d.bottom - d.top; // outerHeight
\r
1329 // add the 'container border/padding' to get final positions relative to the container
\r
1330 d.top += sC.insetTop;
\r
1331 d.bottom += sC.insetBottom;
\r
1332 d.left += sC.insetLeft;
\r
1333 d.right += sC.insetRight;
\r
1340 * @param {!Object} el
\r
1341 * @param {boolean=} [allStates=false]
\r
1343 , getHoverClasses = function (el, allStates) {
\r
1346 , type = $El.data("layoutRole")
\r
1347 , pane = $El.data("layoutEdge")
\r
1348 , o = options[pane]
\r
1349 , root = o[type +"Class"]
\r
1350 , _pane = "-"+ pane // eg: "-west"
\r
1352 , _closed = "-closed"
\r
1353 , _slide = "-sliding"
\r
1354 , _hover = "-hover " // NOTE the trailing space
\r
1355 , _state = $El.hasClass(root+_closed) ? _closed : _open
\r
1356 , _alt = _state === _closed ? _open : _closed
\r
1357 , classes = (root+_hover) + (root+_pane+_hover) + (root+_state+_hover) + (root+_pane+_state+_hover)
\r
1359 if (allStates) // when 'removing' classes, also remove alternate-state classes
\r
1360 classes += (root+_alt+_hover) + (root+_pane+_alt+_hover);
\r
1362 if (type=="resizer" && $El.hasClass(root+_slide))
\r
1363 classes += (root+_slide+_hover) + (root+_pane+_slide+_hover);
\r
1365 return $.trim(classes);
\r
1367 , addHover = function (evt, el) {
\r
1368 var $E = $(el || this);
\r
1369 if (evt && $E.data("layoutRole") === "toggler")
\r
1370 evt.stopPropagation(); // prevent triggering 'slide' on Resizer-bar
\r
1371 $E.addClass( getHoverClasses($E) );
\r
1373 , removeHover = function (evt, el) {
\r
1374 var $E = $(el || this);
\r
1375 $E.removeClass( getHoverClasses($E, true) );
\r
1378 , onResizerEnter = function (evt) { // ALSO called by toggler.mouseenter
\r
1379 if ($.fn.disableSelection)
\r
1380 $("body").disableSelection();
\r
1382 , onResizerLeave = function (evt, el) {
\r
1384 e = el || this // el is only passed when called by the timer
\r
1385 , pane = $(e).data("layoutEdge")
\r
1386 , name = pane +"ResizerLeave"
\r
1388 timer.clear(pane+"_openSlider"); // cancel slideOpen timer, if set
\r
1389 timer.clear(name); // cancel enableSelection timer - may re/set below
\r
1390 // this method calls itself on a timer because it needs to allow
\r
1391 // enough time for dragging to kick-in and set the isResizing flag
\r
1392 // dragging has a 100ms delay set, so this delay must be >100
\r
1393 if (!el) // 1st call - mouseleave event
\r
1394 timer.set(name, function(){ onResizerLeave(evt, e); }, 200);
\r
1395 // if user is resizing, then dragStop will enableSelection(), so can skip it here
\r
1396 else if (!state[pane].isResizing && $.fn.enableSelection) // 2nd call - by timer
\r
1397 $("body").enableSelection();
\r
1401 * ###########################
\r
1402 * INITIALIZATION METHODS
\r
1403 * ###########################
\r
1407 * Initialize the layout - called automatically whenever an instance of layout is created
\r
1409 * @see none - triggered onInit
\r
1410 * @return mixed true = fully initialized | false = panes not initialized (yet) | 'cancel' = abort
\r
1412 , _create = function () {
\r
1413 // initialize config/options
\r
1417 // TEMP state so isInitialized returns true during init process
\r
1418 state.creatingLayout = true;
\r
1420 // init plugins for this layout, if there are any (eg: stateManagement)
\r
1421 runPluginCallbacks( Instance, $.layout.onCreate );
\r
1423 // options & state have been initialized, so now run beforeLoad callback
\r
1424 // onload will CANCEL layout creation if it returns false
\r
1425 if (false === _runCallbacks("onload_start"))
\r
1428 // initialize the container element
\r
1431 // bind hotkey function - keyDown - if required
\r
1434 // bind window.onunload
\r
1435 $(window).bind("unload."+ sID, unload);
\r
1437 // init plugins for this layout, if there are any (eg: customButtons)
\r
1438 runPluginCallbacks( Instance, $.layout.onLoad );
\r
1440 // if layout elements are hidden, then layout WILL NOT complete initialization!
\r
1441 // initLayoutElements will set initialized=true and run the onload callback IF successful
\r
1442 if (o.initPanes) _initLayoutElements();
\r
1444 delete state.creatingLayout;
\r
1446 return state.initialized;
\r
1450 * Initialize the layout IF not already
\r
1452 * @see All methods in Instance run this test
\r
1453 * @return boolean true = layoutElements have been initialized | false = panes are not initialized (yet)
\r
1455 , isInitialized = function () {
\r
1456 if (state.initialized || state.creatingLayout) return true; // already initialized
\r
1457 else return _initLayoutElements(); // try to init panes NOW
\r
1461 * Initialize the layout - called automatically whenever an instance of layout is created
\r
1463 * @see _create() & isInitialized
\r
1464 * @return An object pointer to the instance created
\r
1466 , _initLayoutElements = function (retry) {
\r
1467 // initialize config/options
\r
1470 // CANNOT init panes inside a hidden container!
\r
1471 if (!$N.is(":visible")) {
\r
1472 // handle Chrome bug where popup window 'has no height'
\r
1473 // if layout is BODY element, try again in 50ms
\r
1474 // SEE: http://layout.jquery-dev.net/samples/test_popup_window.html
\r
1475 if ( !retry && browser.webkit && $N[0].tagName === "BODY" )
\r
1476 setTimeout(function(){ _initLayoutElements(true); }, 50);
\r
1480 // a center pane is required, so make sure it exists
\r
1481 if (!getPane("center").length) {
\r
1482 if (options.showErrorMessages)
\r
1483 _log( lang.errCenterPaneMissing, true );
\r
1487 // TEMP state so isInitialized returns true during init process
\r
1488 state.creatingLayout = true;
\r
1490 // update Container dims
\r
1491 $.extend(sC, elDims( $N ));
\r
1493 // initialize all layout elements
\r
1494 initPanes(); // size & position panes - calls initHandles() - which calls initResizable()
\r
1496 if (o.scrollToBookmarkOnLoad) {
\r
1497 var l = self.location;
\r
1498 if (l.hash) l.replace( l.hash ); // scrollTo Bookmark
\r
1501 // check to see if this layout 'nested' inside a pane
\r
1502 if (Instance.hasParentLayout)
\r
1503 o.resizeWithWindow = false;
\r
1504 // bind resizeAll() for 'this layout instance' to window.resize event
\r
1505 else if (o.resizeWithWindow)
\r
1506 $(window).bind("resize."+ sID, windowResize);
\r
1508 delete state.creatingLayout;
\r
1509 state.initialized = true;
\r
1511 // init plugins for this layout, if there are any
\r
1512 runPluginCallbacks( Instance, $.layout.onReady );
\r
1514 // now run the onload callback, if exists
\r
1515 _runCallbacks("onload_end");
\r
1517 return true; // elements initialized successfully
\r
1521 * Initialize nested layouts - called when _initLayoutElements completes
\r
1523 * NOT CURRENTLY USED
\r
1525 * @see _initLayoutElements
\r
1526 * @return An object pointer to the instance created
\r
1528 , _initChildLayouts = function () {
\r
1529 $.each(_c.allPanes, function (idx, pane) {
\r
1530 if (options[pane].initChildLayout)
\r
1531 createChildLayout( pane );
\r
1536 * Initialize nested layouts for a specific pane - can optionally pass layout-options
\r
1538 * @see _initChildLayouts
\r
1539 * @param {string} pane The pane being opened, ie: north, south, east, or west
\r
1540 * @param {Object=} [opts] Layout-options - if passed, will OVERRRIDE options[pane].childOptions
\r
1541 * @return An object pointer to the layout instance created - or null
\r
1543 , createChildLayout = function (evt_or_pane, opts) {
\r
1544 var pane = evtPane.call(this, evt_or_pane)
\r
1549 var $C = $Cs[pane]
\r
1550 , o = opts || options[pane].childOptions
\r
1552 // determine which element is supposed to be the 'child container'
\r
1553 // if pane has a 'containerSelector' OR a 'content-div', use those instead of the pane
\r
1554 , $Cont = o.containerSelector ? $P.find( o.containerSelector ) : ($C || $P)
\r
1555 , containerFound = $Cont.length
\r
1556 // see if a child-layout ALREADY exists on this element
\r
1557 , child = containerFound ? (C[pane] = $Cont.data(d) || null) : null
\r
1559 // if no layout exists, but childOptions are set, try to create the layout now
\r
1560 if (!child && containerFound && o)
\r
1561 child = C[pane] = $Cont.eq(0).layout(o) || null;
\r
1563 child.hasParentLayout = true; // set parent-flag in child
\r
1565 Instance[pane].child = C[pane]; // ALWAYS set pane-object pointer, even if null
\r
1568 , windowResize = function () {
\r
1569 var delay = Number(options.resizeWithWindowDelay);
\r
1570 if (delay < 10) delay = 100; // MUST have a delay!
\r
1571 // resizing uses a delay-loop because the resize event fires repeatly - except in FF, but delay anyway
\r
1572 timer.clear("winResize"); // if already running
\r
1573 timer.set("winResize", function(){
\r
1574 timer.clear("winResize");
\r
1575 timer.clear("winResizeRepeater");
\r
1576 var dims = elDims( $N );
\r
1577 // only trigger resizeAll() if container has changed size
\r
1578 if (dims.innerWidth !== sC.innerWidth || dims.innerHeight !== sC.innerHeight)
\r
1581 // ALSO set fixed-delay timer, if not already running
\r
1582 if (!timer.data["winResizeRepeater"]) setWindowResizeRepeater();
\r
1585 , setWindowResizeRepeater = function () {
\r
1586 var delay = Number(options.resizeWithWindowMaxDelay);
\r
1588 timer.set("winResizeRepeater", function(){ setWindowResizeRepeater(); resizeAll(); }, delay);
\r
1591 , unload = function () {
\r
1594 _runCallbacks("onunload_start");
\r
1596 // trigger plugin callabacks for this layout (eg: stateManagement)
\r
1597 runPluginCallbacks( Instance, $.layout.onUnload );
\r
1599 _runCallbacks("onunload_end");
\r
1603 * Validate and initialize container CSS and events
\r
1607 , _initContainer = function () {
\r
1610 , tag = sC.tagName = N.tagName
\r
1611 , id = sC.id = N.id
\r
1612 , cls = sC.className = N.className
\r
1615 , fullPage= (tag === "BODY")
\r
1616 , props = "overflow,position,margin,padding,border"
\r
1617 , css = "layoutCSS"
\r
1619 , hid = "hidden" // used A LOT!
\r
1620 // see if this container is a 'pane' inside an outer-layout
\r
1621 , parent = $N.data("parentLayout") // parent-layout Instance
\r
1622 , pane = $N.data("layoutEdge") // pane-name in parent-layout
\r
1623 , isChild = parent && pane
\r
1625 // sC -> state.container
\r
1626 sC.selector = $N.selector.split(".slice")[0];
\r
1627 sC.ref = (o.name ? o.name +' layout / ' : '') + tag + (id ? "#"+id : cls ? '.['+cls+']' : ''); // used in messages
\r
1631 , layoutContainer: sID // FLAG to indicate this is a layout-container - contains unique internal ID
\r
1633 .addClass(o.containerClass)
\r
1635 var layoutMethods = {
\r
1638 , resizeAll: 'resizeAll'
\r
1639 , resize: 'resizeAll'
\r
1642 // loop hash and bind all methods - include layoutID namespacing
\r
1643 for (name in layoutMethods) {
\r
1644 $N.bind("layout"+ name.toLowerCase() +"."+ sID, Instance[ layoutMethods[name] || name ]);
\r
1647 // if this container is another layout's 'pane', then set child/parent pointers
\r
1649 // update parent flag
\r
1650 Instance.hasParentLayout = true;
\r
1651 // set pointers to THIS child-layout (Instance) in parent-layout
\r
1652 // NOTE: parent.PANE.child is an ALIAS to parent.children.PANE
\r
1653 parent[pane].child = parent.children[pane] = $N.data("layout");
\r
1656 // SAVE original container CSS for use in destroy()
\r
1657 if (!$N.data(css)) {
\r
1658 // handle props like overflow different for BODY & HTML - has 'system default' values
\r
1660 CSS = $.extend( elCSS($N, props), {
\r
1661 height: $N.css("height")
\r
1662 , overflow: $N.css("overflow")
\r
1663 , overflowX: $N.css("overflowX")
\r
1664 , overflowY: $N.css("overflowY")
\r
1666 // ALSO SAVE <HTML> CSS
\r
1667 var $H = $("html");
\r
1669 height: "auto" // FF would return a fixed px-size!
\r
1670 , overflow: $H.css("overflow")
\r
1671 , overflowX: $H.css("overflowX")
\r
1672 , overflowY: $H.css("overflowY")
\r
1675 else // handle props normally for non-body elements
\r
1676 CSS = elCSS($N, props+",top,bottom,left,right,width,height,overflow,overflowX,overflowY");
\r
1678 $N.data(css, CSS);
\r
1681 try { // format html/body if this is a full page layout
\r
1690 position: "relative"
\r
1696 , padding: 0 // TODO: test whether body-padding could be handled?
\r
1697 , border: "none" // a body-border creates problems because it cannot be measured!
\r
1700 // set current layout-container dimensions
\r
1701 $.extend(sC, elDims( $N ));
\r
1703 else { // set required CSS for overflow and position
\r
1704 // ENSURE container will not 'scroll'
\r
1705 CSS = { overflow: hid, overflowX: hid, overflowY: hid }
\r
1707 p = $N.css("position")
\r
1708 , h = $N.css("height")
\r
1710 // if this is a NESTED layout, then container/outer-pane ALREADY has position and height
\r
1712 if (!p || !p.match(/fixed|absolute|relative/))
\r
1713 CSS.position = "relative"; // container MUST have a 'position'
\r
1715 if (!h || h=="auto")
\r
1716 CSS.height = "100%"; // container MUST have a 'height'
\r
1721 // set current layout-container dimensions
\r
1722 if ( $N.is(":visible") ) {
\r
1723 $.extend(sC, elDims( $N ));
\r
1724 if (o.showErrorMessages && sC.innerHeight < 1)
\r
1725 _log( lang.errContainerHeight.replace(/CONTAINER/, sC.ref), true );
\r
1732 * Bind layout hotkeys - if options enabled
\r
1734 * @see _create() and addPane()
\r
1735 * @param {string=} [panes=""] The edge(s) to process
\r
1737 , initHotkeys = function (panes) {
\r
1738 panes = panes ? panes.split(",") : _c.borderPanes;
\r
1739 // bind keyDown to capture hotkeys, if option enabled for ANY pane
\r
1740 $.each(panes, function (i, pane) {
\r
1741 var o = options[pane];
\r
1742 if (o.enableCursorHotkey || o.customHotkey) {
\r
1743 $(document).bind("keydown."+ sID, keyDown); // only need to bind this ONCE
\r
1744 return false; // BREAK - binding was done
\r
1750 * Build final OPTIONS data
\r
1754 , initOptions = function () {
\r
1755 var data, d, pane, key, val, i, c, o;
\r
1757 // reprocess user's layout-options to have correct options sub-key structure
\r
1758 opts = $.layout.transformData( opts ); // panes = default subkey
\r
1760 // auto-rename old options for backward compatibility
\r
1761 opts = $.layout.backwardCompatibility.renameAllOptions( opts );
\r
1763 // if user-options has 'panes' key (pane-defaults), process it...
\r
1764 if (!$.isEmptyObject(opts.panes)) {
\r
1765 // REMOVE any pane-defaults that MUST be set per-pane
\r
1766 data = $.layout.optionsMap.noDefault;
\r
1767 for (i=0, c=data.length; i<c; i++) {
\r
1769 delete opts.panes[key]; // OK if does not exist
\r
1771 // REMOVE any layout-options specified under opts.panes
\r
1772 data = $.layout.optionsMap.layout;
\r
1773 for (i=0, c=data.length; i<c; i++) {
\r
1775 delete opts.panes[key]; // OK if does not exist
\r
1779 // MOVE any NON-layout-options to opts.panes
\r
1780 data = $.layout.optionsMap.layout;
\r
1781 var rootKeys = $.layout.config.optionRootKeys;
\r
1782 for (key in opts) {
\r
1784 if ($.inArray(key, rootKeys) < 0 && $.inArray(key, data) < 0) {
\r
1785 if (!opts.panes[key])
\r
1786 opts.panes[key] = $.isPlainObject(val) ? $.extend(true, {}, val) : val;
\r
1791 // START by updating ALL options from opts
\r
1792 $.extend(true, options, opts);
\r
1794 // CREATE final options (and config) for EACH pane
\r
1795 $.each(_c.allPanes, function (i, pane) {
\r
1797 // apply 'pane-defaults' to CONFIG.[PANE]
\r
1798 _c[pane] = $.extend( true, {}, _c.panes, _c[pane] );
\r
1800 d = options.panes;
\r
1801 o = options[pane];
\r
1803 // center-pane uses SOME keys in defaults.panes branch
\r
1804 if (pane === 'center') {
\r
1805 // ONLY copy keys from opts.panes listed in: $.layout.optionsMap.center
\r
1806 data = $.layout.optionsMap.center; // list of 'center-pane keys'
\r
1807 for (i=0, c=data.length; i<c; i++) { // loop the list...
\r
1809 // only need to use pane-default if pane-specific value not set
\r
1810 if (!opts.center[key] && (opts.panes[key] || !o[key]))
\r
1811 o[key] = d[key]; // pane-default
\r
1815 // border-panes use ALL keys in defaults.panes branch
\r
1816 o = options[pane] = $.extend({}, d, o); // re-apply pane-specific opts AFTER pane-defaults
\r
1817 createFxOptions( pane );
\r
1818 // ensure all border-pane-specific base-classes exist
\r
1819 if (!o.resizerClass) o.resizerClass = "ui-layout-resizer";
\r
1820 if (!o.togglerClass) o.togglerClass = "ui-layout-toggler";
\r
1822 // ensure we have base pane-class (ALL panes)
\r
1823 if (!o.paneClass) o.paneClass = "ui-layout-pane";
\r
1826 // update options.zIndexes if a zIndex-option specified
\r
1827 var zo = opts.zIndex
\r
1828 , z = options.zIndexes;
\r
1830 z.pane_normal = zo;
\r
1831 z.content_mask = max(zo+1, z.content_mask); // MIN = +1
\r
1832 z.resizer_normal = max(zo+2, z.resizer_normal); // MIN = +2
\r
1835 function createFxOptions ( pane ) {
\r
1836 var o = options[pane]
\r
1837 , d = options.panes;
\r
1838 // ensure fxSettings key to avoid errors
\r
1839 if (!o.fxSettings) o.fxSettings = {};
\r
1840 if (!d.fxSettings) d.fxSettings = {};
\r
1842 $.each(["_open","_close","_size"], function (i,n) {
\r
1844 sName = "fxName"+ n
\r
1845 , sSpeed = "fxSpeed"+ n
\r
1846 , sSettings = "fxSettings"+ n
\r
1847 // recalculate fxName according to specificity rules
\r
1848 , fxName = o[sName] =
\r
1849 o[sName] // options.west.fxName_open
\r
1850 || d[sName] // options.panes.fxName_open
\r
1851 || o.fxName // options.west.fxName
\r
1852 || d.fxName // options.panes.fxName
\r
1853 || "none" // MEANS $.layout.defaults.panes.fxName == "" || false || null || 0
\r
1855 // validate fxName to ensure is valid effect - MUST have effect-config data in options.effects
\r
1856 if (fxName === "none" || !$.effects || !$.effects[fxName] || !options.effects[fxName])
\r
1857 fxName = o[sName] = "none"; // effect not loaded OR unrecognized fxName
\r
1859 // set vars for effects subkeys to simplify logic
\r
1860 var fx = options.effects[fxName] || {} // effects.slide
\r
1861 , fx_all = fx.all || null // effects.slide.all
\r
1862 , fx_pane = fx[pane] || null // effects.slide.west
\r
1864 // create fxSpeed[_open|_close|_size]
\r
1866 o[sSpeed] // options.west.fxSpeed_open
\r
1867 || d[sSpeed] // options.west.fxSpeed_open
\r
1868 || o.fxSpeed // options.west.fxSpeed
\r
1869 || d.fxSpeed // options.panes.fxSpeed
\r
1870 || null // DEFAULT - let fxSetting.duration control speed
\r
1872 // create fxSettings[_open|_close|_size]
\r
1873 o[sSettings] = $.extend(
\r
1875 , fx_all // effects.slide.all
\r
1876 , fx_pane // effects.slide.west
\r
1877 , d.fxSettings // options.panes.fxSettings
\r
1878 , o.fxSettings // options.west.fxSettings
\r
1879 , d[sSettings] // options.panes.fxSettings_open
\r
1880 , o[sSettings] // options.west.fxSettings_open
\r
1884 // DONE creating action-specific-settings for this pane,
\r
1885 // so DELETE generic options - are no longer meaningful
\r
1888 delete o.fxSettings;
\r
1891 // DELETE 'panes' key now that we are done - values were copied to EACH pane
\r
1892 delete options.panes;
\r
1896 * Initialize module objects, styling, size and position for all panes
\r
1898 * @see _initElements()
\r
1899 * @param {string} pane The pane to process
\r
1901 , getPane = function (pane) {
\r
1902 var sel = options[pane].paneSelector
\r
1903 if (sel.substr(0,1)==="#") // ID selector
\r
1904 // NOTE: elements selected 'by ID' DO NOT have to be 'children'
\r
1905 return $N.find(sel).eq(0);
\r
1906 else { // class or other selector
\r
1907 var $P = $N.children(sel).eq(0);
\r
1908 // look for the pane nested inside a 'form' element
\r
1909 return $P.length ? $P : $N.children("form:first").children(sel).eq(0);
\r
1913 , initPanes = function () {
\r
1914 // NOTE: do north & south FIRST so we can measure their height - do center LAST
\r
1915 $.each(_c.allPanes, function (idx, pane) {
\r
1916 addPane( pane, true );
\r
1919 // init the pane-handles NOW in case we have to hide or close the pane below
\r
1922 // now that all panes have been initialized and initially-sized,
\r
1923 // make sure there is really enough space available for each pane
\r
1924 $.each(_c.borderPanes, function (i, pane) {
\r
1925 if ($Ps[pane] && state[pane].isVisible) { // pane is OPEN
\r
1926 setSizeLimits(pane);
\r
1927 makePaneFit(pane); // pane may be Closed, Hidden or Resized by makePaneFit()
\r
1930 // size center-pane AGAIN in case we 'closed' a border-pane in loop above
\r
1931 sizeMidPanes("center");
\r
1933 // Chrome/Webkit sometimes fires callbacks BEFORE it completes resizing!
\r
1934 // Before RC30.3, there was a 10ms delay here, but that caused layout
\r
1935 // to load asynchrously, which is BAD, so try skipping delay for now
\r
1937 // process pane contents and callbacks, and init/resize child-layout if exists
\r
1938 $.each(_c.allPanes, function (i, pane) {
\r
1939 var o = options[pane];
\r
1941 if (state[pane].isVisible) { // pane is OPEN
\r
1942 sizeContent(pane);
\r
1943 // trigger pane.onResize if triggerEventsOnLoad = true
\r
1944 if (o.triggerEventsOnLoad)
\r
1945 _runCallbacks("onresize_end", pane);
\r
1946 else // automatic if onresize called, otherwise call it specifically
\r
1947 // resize child - IF inner-layout already exists (created before this layout)
\r
1948 resizeChildLayout(pane);
\r
1950 // init childLayout - even if pane is not visible
\r
1951 if (o.initChildLayout && o.childOptions)
\r
1952 createChildLayout(pane);
\r
1958 * Add a pane to the layout - subroutine of initPanes()
\r
1960 * @see initPanes()
\r
1961 * @param {string} pane The pane to process
\r
1962 * @param {boolean=} [force=false] Size content after init
\r
1964 , addPane = function (pane, force) {
\r
1965 if (!force && !isInitialized()) return;
\r
1972 , spacing = o.spacing_open || 0
\r
1973 , isCenter = (pane === "center")
\r
1976 , size, minSize, maxSize
\r
1978 // if pane-pointer already exists, remove the old one first
\r
1980 removePane( pane, false, true, false );
\r
1982 $Cs[pane] = false; // init
\r
1984 $P = $Ps[pane] = getPane(pane);
\r
1986 $Ps[pane] = false; // logic
\r
1990 // SAVE original Pane CSS
\r
1991 if (!$P.data("layoutCSS")) {
\r
1992 var props = "position,top,left,bottom,right,width,height,overflow,zIndex,display,backgroundColor,padding,margin,border";
\r
1993 $P.data("layoutCSS", elCSS($P, props));
\r
1996 // create alias for pane data in Instance - initHandles will add more
\r
1997 Instance[pane] = { name: pane, pane: $Ps[pane], content: $Cs[pane], options: options[pane], state: state[pane], child: children[pane] };
\r
1999 // add classes, attributes & events
\r
2001 parentLayout: Instance // pointer to Layout Instance
\r
2002 , layoutPane: Instance[pane] // NEW pointer to pane-alias-object
\r
2003 , layoutEdge: pane
\r
2004 , layoutRole: "pane"
\r
2006 .css(c.cssReq).css("zIndex", options.zIndexes.pane_normal)
\r
2007 .css(o.applyDemoStyles ? c.cssDemo : {}) // demo styles
\r
2008 .addClass( o.paneClass +" "+ o.paneClass+"-"+pane ) // default = "ui-layout-pane ui-layout-pane-west" - may be a dupe of 'paneSelector'
\r
2009 .bind("mouseenter."+ sID, addHover )
\r
2010 .bind("mouseleave."+ sID, removeHover )
\r
2012 var paneMethods = {
\r
2021 , size: 'manualSizePane'
\r
2022 , sizePane: 'manualSizePane'
\r
2025 , enableClosable: ''
\r
2026 , disableClosable: ''
\r
2027 , enableSlideable: ''
\r
2028 , disableSlideable: ''
\r
2029 , enableResizable: ''
\r
2030 , disableResizable: ''
\r
2031 , swapPanes: 'swapPanes'
\r
2032 , swap: 'swapPanes'
\r
2033 , move: 'swapPanes'
\r
2034 , removePane: 'removePane'
\r
2035 , remove: 'removePane'
\r
2036 , createChildLayout: ''
\r
2037 , resizeChildLayout: ''
\r
2038 , resizeAll: 'resizeAll'
\r
2039 , resizeLayout: 'resizeAll'
\r
2042 // loop hash and bind all methods - include layoutID namespacing
\r
2043 for (name in paneMethods) {
\r
2044 $P.bind("layoutpane"+ name.toLowerCase() +"."+ sID, Instance[ paneMethods[name] || name ]);
\r
2047 // see if this pane has a 'scrolling-content element'
\r
2048 initContent(pane, false); // false = do NOT sizeContent() - called later
\r
2051 // call _parseSize AFTER applying pane classes & styles - but before making visible (if hidden)
\r
2052 // if o.size is auto or not valid, then MEASURE the pane and use that as its 'size'
\r
2053 size = s.size = _parseSize(pane, o.size);
\r
2054 minSize = _parseSize(pane,o.minSize) || 1;
\r
2055 maxSize = _parseSize(pane,o.maxSize) || 100000;
\r
2056 if (size > 0) size = max(min(size, maxSize), minSize);
\r
2058 // state for border-panes
\r
2059 s.isClosed = false; // true = pane is closed
\r
2060 s.isSliding = false; // true = pane is currently open by 'sliding' over adjacent panes
\r
2061 s.isResizing= false; // true = pane is in process of being resized
\r
2062 s.isHidden = false; // true = pane is hidden - no spacing, resizer or toggler is visible!
\r
2064 // array for 'pin buttons' whose classNames are auto-updated on pane-open/-close
\r
2065 if (!s.pins) s.pins = [];
\r
2067 // states common to ALL panes
\r
2068 s.tagName = $P[0].tagName;
\r
2069 s.edge = pane; // useful if pane is (or about to be) 'swapped' - easy find out where it is (or is going)
\r
2070 s.noRoom = false; // true = pane 'automatically' hidden due to insufficient room - will unhide automatically
\r
2071 s.isVisible = true; // false = pane is invisible - closed OR hidden - simplify logic
\r
2073 // set css-position to account for container borders & padding
\r
2075 case "north": CSS.top = sC.insetTop;
\r
2076 CSS.left = sC.insetLeft;
\r
2077 CSS.right = sC.insetRight;
\r
2079 case "south": CSS.bottom = sC.insetBottom;
\r
2080 CSS.left = sC.insetLeft;
\r
2081 CSS.right = sC.insetRight;
\r
2083 case "west": CSS.left = sC.insetLeft; // top, bottom & height set by sizeMidPanes()
\r
2085 case "east": CSS.right = sC.insetRight; // ditto
\r
2087 case "center": // top, left, width & height set by sizeMidPanes()
\r
2090 if (dir === "horz") // north or south pane
\r
2091 CSS.height = cssH($P, size);
\r
2092 else if (dir === "vert") // east or west pane
\r
2093 CSS.width = cssW($P, size);
\r
2094 //else if (isCenter) {}
\r
2096 $P.css(CSS); // apply size -- top, bottom & height will be set by sizeMidPanes
\r
2097 if (dir != "horz") sizeMidPanes(pane, true); // true = skipCallback
\r
2099 // close or hide the pane if specified in settings
\r
2100 if (o.initClosed && o.closable && !o.initHidden)
\r
2101 close(pane, true, true); // true, true = force, noAnimation
\r
2102 else if (o.initHidden || o.initClosed)
\r
2103 hide(pane); // will be completely invisible - no resizer or spacing
\r
2104 else if (!s.noRoom)
\r
2105 // make the pane visible - in case was initially hidden
\r
2106 $P.css("display","block");
\r
2107 // ELSE setAsOpen() - called later by initHandles()
\r
2109 // RESET visibility now - pane will appear IF display:block
\r
2110 $P.css("visibility","visible");
\r
2112 // check option for auto-handling of pop-ups & drop-downs
\r
2113 if (o.showOverflowOnHover)
\r
2114 $P.hover( allowOverflow, resetOverflow );
\r
2116 // if manually adding a pane AFTER layout initialization, then...
\r
2117 if (state.initialized) {
\r
2118 initHandles( pane );
\r
2119 initHotkeys( pane );
\r
2120 resizeAll(); // will sizeContent if pane is visible
\r
2121 if (s.isVisible) { // pane is OPEN
\r
2122 if (o.triggerEventsOnLoad)
\r
2123 _runCallbacks("onresize_end", pane);
\r
2124 else // automatic if onresize called, otherwise call it specifically
\r
2125 // resize child - IF inner-layout already exists (created before this layout)
\r
2126 resizeChildLayout(pane); // a previously existing childLayout
\r
2128 if (o.initChildLayout && o.childOptions)
\r
2129 createChildLayout(pane);
\r
2134 * Initialize module objects, styling, size and position for all resize bars and toggler buttons
\r
2137 * @param {string=} [panes=""] The edge(s) to process
\r
2139 , initHandles = function (panes) {
\r
2140 panes = panes ? panes.split(",") : _c.borderPanes;
\r
2142 // create toggler DIVs for each pane, and set object pointers for them, eg: $R.north = north toggler DIV
\r
2143 $.each(panes, function (i, pane) {
\r
2144 var $P = $Ps[pane];
\r
2145 $Rs[pane] = false; // INIT
\r
2146 $Ts[pane] = false;
\r
2147 if (!$P) return; // pane does not exist - skip
\r
2153 , rClass = o.resizerClass
\r
2154 , tClass = o.togglerClass
\r
2155 , side = c.side.toLowerCase()
\r
2156 , spacing = (s.isVisible ? o.spacing_open : o.spacing_closed)
\r
2157 , _pane = "-"+ pane // used for classNames
\r
2158 , _state = (s.isVisible ? "-open" : "-closed") // used for classNames
\r
2159 , I = Instance[pane]
\r
2160 // INIT RESIZER BAR
\r
2161 , $R = I.resizer = $Rs[pane] = $("<div></div>")
\r
2162 // INIT TOGGLER BUTTON
\r
2163 , $T = I.toggler = (o.closable ? $Ts[pane] = $("<div></div>") : false)
\r
2166 //if (s.isVisible && o.resizable) ... handled by initResizable
\r
2167 if (!s.isVisible && o.slidable)
\r
2168 $R.attr("title", o.sliderTip).css("cursor", o.sliderCursor);
\r
2170 $R // if paneSelector is an ID, then create a matching ID for the resizer, eg: "#paneLeft" => "paneLeft-resizer"
\r
2171 .attr("id", (o.paneSelector.substr(0,1)=="#" ? o.paneSelector.substr(1) + "-resizer" : ""))
\r
2173 parentLayout: Instance
\r
2174 , layoutPane: Instance[pane] // NEW pointer to pane-alias-object
\r
2175 , layoutEdge: pane
\r
2176 , layoutRole: "resizer"
\r
2178 .css(_c.resizers.cssReq).css("zIndex", options.zIndexes.resizer_normal)
\r
2179 .css(o.applyDemoStyles ? _c.resizers.cssDemo : {}) // add demo styles
\r
2180 .addClass(rClass +" "+ rClass+_pane)
\r
2181 .hover(addHover, removeHover) // ALWAYS add hover-classes, even if resizing is not enabled - handle with CSS instead
\r
2182 .hover(onResizerEnter, onResizerLeave) // ALWAYS NEED resizer.mouseleave to balance toggler.mouseenter
\r
2183 .appendTo($N) // append DIV to container
\r
2187 $T // if paneSelector is an ID, then create a matching ID for the resizer, eg: "#paneLeft" => "#paneLeft-toggler"
\r
2188 .attr("id", (o.paneSelector.substr(0,1)=="#" ? o.paneSelector.substr(1) + "-toggler" : ""))
\r
2190 parentLayout: Instance
\r
2191 , layoutPane: Instance[pane] // NEW pointer to pane-alias-object
\r
2192 , layoutEdge: pane
\r
2193 , layoutRole: "toggler"
\r
2195 .css(_c.togglers.cssReq) // add base/required styles
\r
2196 .css(o.applyDemoStyles ? _c.togglers.cssDemo : {}) // add demo styles
\r
2197 .addClass(tClass +" "+ tClass+_pane)
\r
2198 .hover(addHover, removeHover) // ALWAYS add hover-classes, even if toggling is not enabled - handle with CSS instead
\r
2199 .bind("mouseenter", onResizerEnter) // NEED toggler.mouseenter because mouseenter MAY NOT fire on resizer
\r
2200 .appendTo($R) // append SPAN to resizer DIV
\r
2202 // ADD INNER-SPANS TO TOGGLER
\r
2203 if (o.togglerContent_open) // ui-layout-open
\r
2204 $("<span>"+ o.togglerContent_open +"</span>")
\r
2207 , layoutRole: "togglerContent"
\r
2209 .data("layoutRole", "togglerContent")
\r
2210 .data("layoutEdge", pane)
\r
2211 .addClass("content content-open")
\r
2212 .css("display","none")
\r
2214 //.hover( addHover, removeHover ) // use ui-layout-toggler-west-hover .content-open instead!
\r
2216 if (o.togglerContent_closed) // ui-layout-closed
\r
2217 $("<span>"+ o.togglerContent_closed +"</span>")
\r
2220 , layoutRole: "togglerContent"
\r
2222 .addClass("content content-closed")
\r
2223 .css("display","none")
\r
2225 //.hover( addHover, removeHover ) // use ui-layout-toggler-west-hover .content-closed instead!
\r
2227 // ADD TOGGLER.click/.hover
\r
2228 enableClosable(pane);
\r
2231 // add Draggable events
\r
2232 initResizable(pane);
\r
2234 // ADD CLASSNAMES & SLIDE-BINDINGS - eg: class="resizer resizer-west resizer-open"
\r
2236 setAsOpen(pane); // onOpen will be called, but NOT onResize
\r
2238 setAsClosed(pane); // onClose will be called
\r
2239 bindStartSlidingEvent(pane, true); // will enable events IF option is set
\r
2244 // SET ALL HANDLE DIMENSIONS
\r
2250 * Initialize scrolling ui-layout-content div - if exists
\r
2252 * @see initPane() - or externally after an Ajax injection
\r
2253 * @param {string} [pane] The pane to process
\r
2254 * @param {boolean=} [resize=true] Size content after init
\r
2256 , initContent = function (pane, resize) {
\r
2257 if (!isInitialized()) return;
\r
2260 , sel = o.contentSelector
\r
2261 , I = Instance[pane]
\r
2265 if (sel) $C = I.content = $Cs[pane] = (o.findNestedContent)
\r
2266 ? $P.find(sel).eq(0) // match 1-element only
\r
2267 : $P.children(sel).eq(0)
\r
2269 if ($C && $C.length) {
\r
2270 $C.data("layoutRole", "content");
\r
2271 // SAVE original Pane CSS
\r
2272 if (!$C.data("layoutCSS"))
\r
2273 $C.data("layoutCSS", elCSS($C, "height"));
\r
2274 $C.css( _c.content.cssReq );
\r
2275 if (o.applyDemoStyles) {
\r
2276 $C.css( _c.content.cssDemo ); // add padding & overflow: auto to content-div
\r
2277 $P.css( _c.content.cssDemoPane ); // REMOVE padding/scrolling from pane
\r
2279 state[pane].content = {}; // init content state
\r
2280 if (resize !== false) sizeContent(pane);
\r
2281 // sizeContent() is called AFTER init of all elements
\r
2284 I.content = $Cs[pane] = false;
\r
2289 * Add resize-bars to all panes that specify it in options
\r
2290 * -dependancy: $.fn.resizable - will skip if not found
\r
2293 * @param {string=} [panes=""] The edge(s) to process
\r
2295 , initResizable = function (panes) {
\r
2296 var draggingAvailable = $.layout.plugins.draggable
\r
2297 , side // set in start()
\r
2299 panes = panes ? panes.split(",") : _c.borderPanes;
\r
2301 $.each(panes, function (idx, pane) {
\r
2302 var o = options[pane];
\r
2303 if (!draggingAvailable || !$Ps[pane] || !o.resizable) {
\r
2304 o.resizable = false;
\r
2305 return true; // skip to next
\r
2308 var s = state[pane]
\r
2309 , z = options.zIndexes
\r
2311 , side = c.dir=="horz" ? "top" : "left"
\r
2312 , opEdge = _c.oppositeEdge[pane]
\r
2313 , masks = pane +",center,"+ opEdge + (c.dir=="horz" ? ",west,east" : "")
\r
2316 , base = o.resizerClass
\r
2317 , lastPos = 0 // used when live-resizing
\r
2318 , r, live // set in start because may change
\r
2319 // 'drag' classes are applied to the ORIGINAL resizer-bar while dragging is in process
\r
2320 , resizerClass = base+"-drag" // resizer-drag
\r
2321 , resizerPaneClass = base+"-"+pane+"-drag" // resizer-north-drag
\r
2322 // 'helper' class is applied to the CLONED resizer-bar while it is being dragged
\r
2323 , helperClass = base+"-dragging" // resizer-dragging
\r
2324 , helperPaneClass = base+"-"+pane+"-dragging" // resizer-north-dragging
\r
2325 , helperLimitClass = base+"-dragging-limit" // resizer-drag
\r
2326 , helperPaneLimitClass = base+"-"+pane+"-dragging-limit" // resizer-north-drag
\r
2327 , helperClassesSet = false // logic var
\r
2331 $R.attr("title", o.resizerTip)
\r
2332 .css("cursor", o.resizerCursor); // n-resize, s-resize, etc
\r
2335 containment: $N[0] // limit resizing to layout container
\r
2336 , axis: (c.dir=="horz" ? "y" : "x") // limit resizing to horz or vert axis
\r
2339 , grid: o.resizingGrid
\r
2340 // basic format for helper - style it using class: .ui-draggable-dragging
\r
2342 , opacity: o.resizerDragOpacity
\r
2343 , addClasses: false // avoid ui-state-disabled class when disabled
\r
2344 //, iframeFix: o.draggableIframeFix // TODO: consider using when bug is fixed
\r
2345 , zIndex: z.resizer_drag
\r
2347 , start: function (e, ui) {
\r
2348 // REFRESH options & state pointers in case we used swapPanes
\r
2349 o = options[pane];
\r
2351 // re-read options
\r
2352 live = o.livePaneResizing;
\r
2354 // ondrag_start callback - will CANCEL hide if returns false
\r
2355 // TODO: dragging CANNOT be cancelled like this, so see if there is a way?
\r
2356 if (false === _runCallbacks("ondrag_start", pane)) return false;
\r
2358 s.isResizing = true; // prevent pane from closing while resizing
\r
2359 timer.clear(pane+"_closeSlider"); // just in case already triggered
\r
2361 // SET RESIZER LIMITS - used in drag()
\r
2362 setSizeLimits(pane); // update pane/resizer state
\r
2363 r = s.resizerPosition;
\r
2364 lastPos = ui.position[ side ]
\r
2366 $R.addClass( resizerClass +" "+ resizerPaneClass ); // add drag classes
\r
2367 helperClassesSet = false; // reset logic var - see drag()
\r
2369 // DISABLE TEXT SELECTION (probably already done by resizer.mouseOver)
\r
2370 $('body').disableSelection();
\r
2372 // MASK PANES CONTAINING IFRAMES, APPLETS OR OTHER TROUBLESOME ELEMENTS
\r
2373 showMasks( masks );
\r
2376 , drag: function (e, ui) {
\r
2377 if (!helperClassesSet) { // can only add classes after clone has been added to the DOM
\r
2378 //$(".ui-draggable-dragging")
\r
2380 .addClass( helperClass +" "+ helperPaneClass ) // add helper classes
\r
2381 .css({ right: "auto", bottom: "auto" }) // fix dir="rtl" issue
\r
2382 .children().css("visibility","hidden") // hide toggler inside dragged resizer-bar
\r
2384 helperClassesSet = true;
\r
2385 // draggable bug!? RE-SET zIndex to prevent E/W resize-bar showing through N/S pane!
\r
2386 if (s.isSliding) $Ps[pane].css("zIndex", z.pane_sliding);
\r
2388 // CONTAIN RESIZER-BAR TO RESIZING LIMITS
\r
2390 if (ui.position[side] < r.min) {
\r
2391 ui.position[side] = r.min;
\r
2394 else if (ui.position[side] > r.max) {
\r
2395 ui.position[side] = r.max;
\r
2398 // ADD/REMOVE dragging-limit CLASS
\r
2400 ui.helper.addClass( helperLimitClass +" "+ helperPaneLimitClass ); // at dragging-limit
\r
2401 window.defaultStatus = (limit>0 && pane.match(/north|west/)) || (limit<0 && pane.match(/south|east/)) ? lang.maxSizeWarning : lang.minSizeWarning;
\r
2404 ui.helper.removeClass( helperLimitClass +" "+ helperPaneLimitClass ); // not at dragging-limit
\r
2405 window.defaultStatus = "";
\r
2407 // DYNAMICALLY RESIZE PANES IF OPTION ENABLED
\r
2408 // won't trigger unless resizer has actually moved!
\r
2409 if (live && Math.abs(ui.position[side] - lastPos) >= o.liveResizingTolerance) {
\r
2410 lastPos = ui.position[side];
\r
2411 resizePanes(e, ui, pane)
\r
2415 , stop: function (e, ui) {
\r
2416 $('body').enableSelection(); // RE-ENABLE TEXT SELECTION
\r
2417 window.defaultStatus = ""; // clear 'resizing limit' message from statusbar
\r
2418 $R.removeClass( resizerClass +" "+ resizerPaneClass ); // remove drag classes from Resizer
\r
2419 s.isResizing = false;
\r
2420 resizePanes(e, ui, pane, true, masks); // true = resizingDone
\r
2429 * Sub-routine called from stop() - and drag() if livePaneResizing
\r
2431 * @param {!Object} evt
\r
2432 * @param {!Object} ui
\r
2433 * @param {string} pane
\r
2434 * @param {boolean=} [resizingDone=false]
\r
2436 var resizePanes = function (evt, ui, pane, resizingDone, masks) {
\r
2437 var dragPos = ui.position
\r
2439 , o = options[pane]
\r
2444 case "north": resizerPos = dragPos.top; break;
\r
2445 case "west": resizerPos = dragPos.left; break;
\r
2446 case "south": resizerPos = sC.offsetHeight - dragPos.top - o.spacing_open; break;
\r
2447 case "east": resizerPos = sC.offsetWidth - dragPos.left - o.spacing_open; break;
\r
2449 // remove container margin from resizer position to get the pane size
\r
2450 var newSize = resizerPos - sC["inset"+ c.side];
\r
2452 // Disable OR Resize Mask(s) created in drag.start
\r
2453 if (!resizingDone) {
\r
2454 // ensure we meet liveResizingTolerance criteria
\r
2455 if (Math.abs(newSize - s.size) < o.liveResizingTolerance)
\r
2456 return; // SKIP resize this time
\r
2457 // resize the pane
\r
2458 manualSizePane(pane, newSize, false, true); // true = noAnimation
\r
2459 sizeMasks(); // resize all visible masks
\r
2461 else { // resizingDone
\r
2462 // ondrag_end callback
\r
2463 if (false !== _runCallbacks("ondrag_end", pane))
\r
2464 manualSizePane(pane, newSize, false, true); // true = noAnimation
\r
2465 hideMasks(); // hide all masks, which include panes with 'content/iframe-masks'
\r
2466 if (s.isSliding && masks) // RE-SHOW only 'object-masks' so objects won't show through sliding pane
\r
2467 showMasks( masks, true ); // true = onlyForObjects
\r
2475 * Needed to overlay a DIV over an IFRAME-pane because mask CANNOT be *inside* the pane
\r
2476 * Called when mask created, and during livePaneResizing
\r
2478 , sizeMask = function () {
\r
2480 , pane = $M.data("layoutMask") // eg: "west"
\r
2483 // only masks over an IFRAME-pane need manual resizing
\r
2484 if (s.tagName == "IFRAME" && s.isVisible) // no need to mask closed/hidden panes
\r
2487 , left: s.offsetLeft
\r
2488 , width: s.outerWidth
\r
2489 , height: s.outerHeight
\r
2492 var $P = $Ps[pane];
\r
2493 $M.css( $P.position() ).css({ width: $P[0].offsetWidth, height: $P[0].offsetHeight });
\r
2496 , sizeMasks = function () {
\r
2497 $Ms.each( sizeMask ); // resize all 'visible' masks
\r
2500 , showMasks = function (panes, onlyForObjects) {
\r
2501 var a = panes ? panes.split(",") : $.layout.config.allPanes
\r
2502 , z = options.zIndexes
\r
2504 $.each(a, function(i,p){
\r
2507 if (s.isVisible && ( (!onlyForObjects && o.maskContents) || o.maskObjects )) {
\r
2508 getMasks(p).each(function(){
\r
2509 sizeMask.call(this);
\r
2510 this.style.zIndex = s.isSliding ? z.pane_sliding+1 : z.pane_normal+1
\r
2511 this.style.display = "block";
\r
2517 , hideMasks = function () {
\r
2518 // ensure no pane is resizing - could be a timing issue
\r
2520 $.each( $.layout.config.borderPanes, function(i,p){
\r
2521 if (state[p].isResizing) {
\r
2523 return false; // BREAK
\r
2527 $Ms.hide(); // hide ALL masks
\r
2530 , getMasks = function (pane) {
\r
2531 var $Masks = $([])
\r
2532 , $M, i = 0, c = $Ms.length
\r
2534 for (; i<c; i++) {
\r
2536 if ($M.data("layoutMask") === pane)
\r
2537 $Masks = $Masks.add( $M );
\r
2539 if ($Masks.length)
\r
2542 return createMasks(pane);
\r
2548 * Generates both DIV (ALWAYS used) and IFRAME (optional) elements as masks
\r
2549 * An IFRAME mask is created *under* the DIV when maskObjects=true, because a DIV cannot mask an applet
\r
2551 , createMasks = function (pane) {
\r
2555 , o = options[pane]
\r
2556 , z = options.zIndexes
\r
2557 //, objMask = o.maskObjects && s.tagName != "IFRAME" // check for option
\r
2559 , isIframe, el, $M, css, i
\r
2561 if (!o.maskContents && !o.maskObjects) return $Masks;
\r
2562 // if o.maskObjects=true, then loop TWICE to create BOTH kinds of mask, else only create a DIV
\r
2563 for (i=0; i < (o.maskObjects ? 2 : 1); i++) {
\r
2564 isIframe = o.maskObjects && i==0;
\r
2565 el = document.createElement( isIframe ? "iframe" : "div" );
\r
2566 $M = $(el).data("layoutMask", pane); // add data to relate mask to pane
\r
2567 el.className = "ui-layout-mask ui-layout-mask-"+ pane; // for user styling
\r
2569 // styles common to both DIVs and IFRAMES
\r
2570 css.display = "block";
\r
2571 css.position = "absolute";
\r
2572 if (isIframe) { // IFRAME-only props
\r
2573 el.frameborder = 0;
\r
2574 el.src = "about:blank";
\r
2576 css.filter = "Alpha(Opacity='0')";
\r
2579 // if pane is an IFRAME, then must mask the pane itself
\r
2580 if (s.tagName == "IFRAME") {
\r
2581 // NOTE sizing done by a subroutine so can be called during live-resizing
\r
2582 css.zIndex = z.pane_normal+1; // 1-higher than pane
\r
2583 $N.append( el ); // append to LAYOUT CONTAINER
\r
2585 // otherwise put masks *inside the pane* to mask its contents
\r
2587 $M.addClass("ui-layout-mask-inside-pane");
\r
2588 css.zIndex = o.maskZindex || z.content_mask; // usually 1, but customizable
\r
2591 css.width = "100%";
\r
2592 css.height = "100%";
\r
2593 $P.append( el ); // append INSIDE pane element
\r
2595 // add to return object
\r
2596 $Masks = $Masks.add( el );
\r
2597 // add Mask to cached array so can be resized & reused
\r
2598 $Ms = $Ms.add( el );
\r
2605 * Destroy this layout and reset all elements
\r
2607 * @param {boolean=} [destroyChildren=false] Destory Child-Layouts first?
\r
2609 , destroy = function (destroyChildren) {
\r
2610 // UNBIND layout events and remove global object
\r
2611 $(window).unbind("."+ sID); // resize & unload
\r
2612 $(document).unbind("."+ sID); // keyDown (hotkeys)
\r
2614 // need to look for parent layout BEFORE we remove the container data, else skips a level
\r
2615 //var parentPane = Instance.hasParentLayout ? $.layout.getParentPaneInstance( $N ) : null;
\r
2617 // reset layout-container
\r
2619 .removeData("layout")
\r
2620 .removeData("layoutContainer")
\r
2621 .removeClass(options.containerClass)
\r
2622 .unbind("."+ sID) // remove ALL Layout events
\r
2625 // remove all mask elements that have been created
\r
2628 // loop all panes to remove layout classes, attributes and bindings
\r
2629 $.each(_c.allPanes, function (i, pane) {
\r
2630 removePane( pane, false, true, destroyChildren ); // true = skipResize
\r
2633 // do NOT reset container CSS if is a 'pane' (or 'content') in an outer-layout - ie, THIS layout is 'nested'
\r
2634 var css = "layoutCSS";
\r
2635 if ($N.data(css) && !$N.data("layoutRole")) // RESET CSS
\r
2636 $N.css( $N.data(css) ).removeData(css);
\r
2638 // for full-page layouts, also reset the <HTML> CSS
\r
2639 if (sC.tagName === "BODY" && ($N = $("html")).data(css)) // RESET <HTML> CSS
\r
2640 $N.css( $N.data(css) ).removeData(css);
\r
2642 // trigger plugins for this layout, if there are any
\r
2643 runPluginCallbacks( Instance, $.layout.onDestroy );
\r
2645 // trigger state-management and onunload callback
\r
2648 // clear the Instance of everything except for container & options (so could recreate)
\r
2649 // RE-CREATE: myLayout = myLayout.container.layout( myLayout.options );
\r
2650 for (n in Instance)
\r
2651 if (!n.match(/^(container|options)$/)) delete Instance[ n ];
\r
2652 // add a 'destroyed' flag to make it easy to check
\r
2653 Instance.destroyed = true;
\r
2655 // if this is a child layout, CLEAR the child-pointer in the parent
\r
2656 /* for now the pointer REMAINS, but with only container, options and destroyed keys
\r
2658 var layout = parentPane.pane.data("parentLayout");
\r
2659 parentPane.child = layout.children[ parentPane.name ] = null;
\r
2663 return Instance; // for coding convenience
\r
2667 * Remove a pane from the layout - subroutine of destroy()
\r
2670 * @param {string} pane The pane to process
\r
2671 * @param {boolean=} [remove=false] Remove the DOM element?
\r
2672 * @param {boolean=} [skipResize=false] Skip calling resizeAll()?
\r
2674 , removePane = function (evt_or_pane, remove, skipResize, destroyChild) {
\r
2675 if (!isInitialized()) return;
\r
2676 var pane = evtPane.call(this, evt_or_pane)
\r
2682 //alert( '$P.length = '+ $P.length );
\r
2683 // NOTE: elements can still exist even after remove()
\r
2684 // so check for missing data(), which is cleared by removed()
\r
2685 if ($P && $.isEmptyObject( $P.data() )) $P = false;
\r
2686 if ($C && $.isEmptyObject( $C.data() )) $C = false;
\r
2687 if ($R && $.isEmptyObject( $R.data() )) $R = false;
\r
2688 if ($T && $.isEmptyObject( $T.data() )) $T = false;
\r
2690 if ($P) $P.stop(true, true);
\r
2692 // check for a child layout
\r
2693 var o = options[pane]
\r
2696 , css = "layoutCSS"
\r
2697 , child = children[pane] || ($P ? $P.data(d) : 0) || ($C ? $C.data(d) : 0) || null
\r
2698 , destroy = destroyChild !== undefined ? destroyChild : o.destroyChildLayout
\r
2701 // FIRST destroy the child-layout(s)
\r
2702 if (destroy && child && !child.destroyed) {
\r
2703 child.destroy(true); // tell child-layout to destroy ALL its child-layouts too
\r
2704 if (child.destroyed) // destroy was successful
\r
2705 child = null; // clear pointer for logic below
\r
2708 if ($P && remove && !child)
\r
2710 else if ($P && $P[0]) {
\r
2711 // create list of ALL pane-classes that need to be removed
\r
2712 var root = o.paneClass // default="ui-layout-pane"
\r
2713 , pRoot = root +"-"+ pane // eg: "ui-layout-pane-west"
\r
2715 , _sliding= "-sliding"
\r
2716 , _closed = "-closed"
\r
2717 , classes = [ root, root+_open, root+_closed, root+_sliding, // generic classes
\r
2718 pRoot, pRoot+_open, pRoot+_closed, pRoot+_sliding ] // pane-specific classes
\r
2720 $.merge(classes, getHoverClasses($P, true)); // ADD hover-classes
\r
2721 // remove all Layout classes from pane-element
\r
2722 $P .removeClass( classes.join(" ") ) // remove ALL pane-classes
\r
2723 .removeData("parentLayout")
\r
2724 .removeData("layoutPane")
\r
2725 .removeData("layoutRole")
\r
2726 .removeData("layoutEdge")
\r
2727 .removeData("autoHidden") // in case set
\r
2728 .unbind("."+ sID) // remove ALL Layout events
\r
2729 // TODO: remove these extra unbind commands when jQuery is fixed
\r
2730 //.unbind("mouseenter"+ sID)
\r
2731 //.unbind("mouseleave"+ sID)
\r
2733 // do NOT reset CSS if this pane/content is STILL the container of a nested layout!
\r
2734 // the nested layout will reset its 'container' CSS when/if it is destroyed
\r
2735 if ($C && $C.data(d)) {
\r
2736 // a content-div may not have a specific width, so give it one to contain the Layout
\r
2737 $C.width( $C.width() );
\r
2738 child.resizeAll(); // now resize the Layout
\r
2741 $C.css( $C.data(css) ).removeData(css).removeData("layoutRole");
\r
2742 // remove pane AFTER content in case there was a nested layout
\r
2744 $P.css( $P.data(css) ).removeData(css);
\r
2747 // REMOVE pane resizer and toggler elements
\r
2748 if ($T) $T.remove();
\r
2749 if ($R) $R.remove();
\r
2751 // CLEAR all pointers and state data
\r
2752 Instance[pane] = $Ps[pane] = $Cs[pane] = $Rs[pane] = $Ts[pane] = children[pane] = false;
\r
2753 s = { removed: true };
\r
2761 * ###########################
\r
2763 * ###########################
\r
2766 , _hidePane = function (pane) {
\r
2767 var $P = $Ps[pane]
\r
2768 , o = options[pane]
\r
2771 if (o.useOffscreenClose) {
\r
2772 if (!$P.data(_c.offscreenReset))
\r
2773 $P.data(_c.offscreenReset, { left: s.left, right: s.right });
\r
2774 $P.css( _c.offscreenCSS );
\r
2777 $P.hide().removeData(_c.offscreenReset);
\r
2780 , _showPane = function (pane) {
\r
2781 var $P = $Ps[pane]
\r
2782 , o = options[pane]
\r
2783 , off = _c.offscreenCSS
\r
2784 , old = $P.data(_c.offscreenReset)
\r
2787 $P .show() // ALWAYS show, just in case
\r
2788 .removeData(_c.offscreenReset);
\r
2789 if (o.useOffscreenClose && old) {
\r
2790 if (s.left == off.left)
\r
2791 s.left = old.left;
\r
2792 if (s.right == off.right)
\r
2793 s.right = old.right;
\r
2799 * Completely 'hides' a pane, including its spacing - as if it does not exist
\r
2800 * The pane is not actually 'removed' from the source, so can use 'show' to un-hide it
\r
2802 * @param {string} pane The pane being hidden, ie: north, south, east, or west
\r
2803 * @param {boolean=} [noAnimation=false]
\r
2805 , hide = function (evt_or_pane, noAnimation) {
\r
2806 if (!isInitialized()) return;
\r
2807 var pane = evtPane.call(this, evt_or_pane)
\r
2808 , o = options[pane]
\r
2813 if (!$P || s.isHidden) return; // pane does not exist OR is already hidden
\r
2815 // onhide_start callback - will CANCEL hide if returns false
\r
2816 if (state.initialized && false === _runCallbacks("onhide_start", pane)) return;
\r
2818 s.isSliding = false; // just in case
\r
2820 // now hide the elements
\r
2821 if ($R) $R.hide(); // hide resizer-bar
\r
2822 if (!state.initialized || s.isClosed) {
\r
2823 s.isClosed = true; // to trigger open-animation on show()
\r
2824 s.isHidden = true;
\r
2825 s.isVisible = false;
\r
2826 if (!state.initialized)
\r
2827 _hidePane(pane); // no animation when loading page
\r
2828 sizeMidPanes(_c[pane].dir === "horz" ? "" : "center");
\r
2829 if (state.initialized || o.triggerEventsOnLoad)
\r
2830 _runCallbacks("onhide_end", pane);
\r
2833 s.isHiding = true; // used by onclose
\r
2834 close(pane, false, noAnimation); // adjust all panes to fit
\r
2839 * Show a hidden pane - show as 'closed' by default unless openPane = true
\r
2841 * @param {string} pane The pane being opened, ie: north, south, east, or west
\r
2842 * @param {boolean=} [openPane=false]
\r
2843 * @param {boolean=} [noAnimation=false]
\r
2844 * @param {boolean=} [noAlert=false]
\r
2846 , show = function (evt_or_pane, openPane, noAnimation, noAlert) {
\r
2847 if (!isInitialized()) return;
\r
2848 var pane = evtPane.call(this, evt_or_pane)
\r
2849 , o = options[pane]
\r
2854 if (!$P || !s.isHidden) return; // pane does not exist OR is not hidden
\r
2856 // onshow_start callback - will CANCEL show if returns false
\r
2857 if (false === _runCallbacks("onshow_start", pane)) return;
\r
2859 s.isSliding = false; // just in case
\r
2860 s.isShowing = true; // used by onopen/onclose
\r
2861 //s.isHidden = false; - will be set by open/close - if not cancelled
\r
2863 // now show the elements
\r
2864 //if ($R) $R.show(); - will be shown by open/close
\r
2865 if (openPane === false)
\r
2866 close(pane, true); // true = force
\r
2868 open(pane, false, noAnimation, noAlert); // adjust all panes to fit
\r
2873 * Toggles a pane open/closed by calling either open or close
\r
2875 * @param {string} pane The pane being toggled, ie: north, south, east, or west
\r
2876 * @param {boolean=} [slide=false]
\r
2878 , toggle = function (evt_or_pane, slide) {
\r
2879 if (!isInitialized()) return;
\r
2880 var evt = evtObj(evt_or_pane)
\r
2881 , pane = evtPane.call(this, evt_or_pane)
\r
2884 if (evt) // called from to $R.dblclick OR triggerPaneEvent
\r
2885 evt.stopImmediatePropagation();
\r
2887 show(pane); // will call 'open' after unhiding it
\r
2888 else if (s.isClosed)
\r
2889 open(pane, !!slide);
\r
2896 * Utility method used during init or other auto-processes
\r
2898 * @param {string} pane The pane being closed
\r
2899 * @param {boolean=} [setHandles=false]
\r
2901 , _closePane = function (pane, setHandles) {
\r
2907 s.isClosed = true;
\r
2908 s.isVisible = false;
\r
2909 // UNUSED: if (setHandles) setAsClosed(pane, true); // true = force
\r
2913 * Close the specified pane (animation optional), and resize all other panes as needed
\r
2915 * @param {string} pane The pane being closed, ie: north, south, east, or west
\r
2916 * @param {boolean=} [force=false]
\r
2917 * @param {boolean=} [noAnimation=false]
\r
2918 * @param {boolean=} [skipCallback=false]
\r
2920 , close = function (evt_or_pane, force, noAnimation, skipCallback) {
\r
2921 var pane = evtPane.call(this, evt_or_pane);
\r
2922 // if pane has been initialized, but NOT the complete layout, close pane instantly
\r
2923 if (!state.initialized && $Ps[pane]) {
\r
2924 _closePane(pane); // INIT pane as closed
\r
2927 if (!isInitialized()) return;
\r
2933 , o = options[pane]
\r
2936 , doFX, isShowing, isHiding, wasSliding;
\r
2938 // QUEUE in case another action/animation is in progress
\r
2939 $N.queue(function( queueNext ){
\r
2942 || (!o.closable && !s.isShowing && !s.isHiding) // invalid request // (!o.resizable && !o.closable) ???
\r
2943 || (!force && s.isClosed && !s.isShowing) // already closed
\r
2944 ) return queueNext();
\r
2946 // onclose_start callback - will CANCEL hide if returns false
\r
2947 // SKIP if just 'showing' a hidden pane as 'closed'
\r
2948 var abort = !s.isShowing && false === _runCallbacks("onclose_start", pane);
\r
2950 // transfer logic vars to temp vars
\r
2951 isShowing = s.isShowing;
\r
2952 isHiding = s.isHiding;
\r
2953 wasSliding = s.isSliding;
\r
2954 // now clear the logic vars (REQUIRED before aborting)
\r
2955 delete s.isShowing;
\r
2956 delete s.isHiding;
\r
2958 if (abort) return queueNext();
\r
2960 doFX = !noAnimation && !s.isClosed && (o.fxName_close != "none");
\r
2961 s.isMoving = true;
\r
2962 s.isClosed = true;
\r
2963 s.isVisible = false;
\r
2964 // update isHidden BEFORE sizing panes
\r
2965 if (isHiding) s.isHidden = true;
\r
2966 else if (isShowing) s.isHidden = false;
\r
2968 if (s.isSliding) // pane is being closed, so UNBIND trigger events
\r
2969 bindStopSlidingEvents(pane, false); // will set isSliding=false
\r
2970 else // resize panes adjacent to this one
\r
2971 sizeMidPanes(_c[pane].dir === "horz" ? "" : "center", false); // false = NOT skipCallback
\r
2973 // if this pane has a resizer bar, move it NOW - before animation
\r
2974 setAsClosed(pane);
\r
2977 if (doFX) { // animate the close
\r
2978 // mask panes with objects
\r
2979 var masks = "center"+ (c.dir=="horz" ? ",west,east" : "");
\r
2980 showMasks( masks, true ); // true = ONLY mask panes with maskObjects=true
\r
2981 lockPaneForFX(pane, true); // need to set left/top so animation will work
\r
2982 $P.hide( o.fxName_close, o.fxSettings_close, o.fxSpeed_close, function () {
\r
2983 lockPaneForFX(pane, false); // undo
\r
2984 if (s.isClosed) close_2();
\r
2988 else { // hide the pane without animation
\r
2996 function close_2 () {
\r
2997 s.isMoving = false;
\r
2998 bindStartSlidingEvent(pane, true); // will enable if o.slidable = true
\r
3000 // if opposite-pane was autoClosed, see if it can be autoOpened now
\r
3001 var altPane = _c.oppositeEdge[pane];
\r
3002 if (state[ altPane ].noRoom) {
\r
3003 setSizeLimits( altPane );
\r
3004 makePaneFit( altPane );
\r
3007 // hide any masks shown while closing
\r
3010 if (!skipCallback && (state.initialized || o.triggerEventsOnLoad)) {
\r
3011 // onclose callback - UNLESS just 'showing' a hidden pane as 'closed'
\r
3012 if (!isShowing) _runCallbacks("onclose_end", pane);
\r
3013 // onhide OR onshow callback
\r
3014 if (isShowing) _runCallbacks("onshow_end", pane);
\r
3015 if (isHiding) _runCallbacks("onhide_end", pane);
\r
3021 * @param {string} pane The pane just closed, ie: north, south, east, or west
\r
3023 , setAsClosed = function (pane) {
\r
3028 , o = options[pane]
\r
3030 , side = _c[pane].side.toLowerCase()
\r
3031 , inset = "inset"+ _c[pane].side
\r
3032 , rClass = o.resizerClass
\r
3033 , tClass = o.togglerClass
\r
3034 , _pane = "-"+ pane // used for classNames
\r
3036 , _sliding= "-sliding"
\r
3037 , _closed = "-closed"
\r
3040 .css(side, sC[inset]) // move the resizer
\r
3041 .removeClass( rClass+_open +" "+ rClass+_pane+_open )
\r
3042 .removeClass( rClass+_sliding +" "+ rClass+_pane+_sliding )
\r
3043 .addClass( rClass+_closed +" "+ rClass+_pane+_closed )
\r
3044 .unbind("dblclick."+ sID)
\r
3046 // DISABLE 'resizing' when closed - do this BEFORE bindStartSlidingEvent?
\r
3047 if (o.resizable && $.layout.plugins.draggable)
\r
3049 .draggable("disable")
\r
3050 .removeClass("ui-state-disabled") // do NOT apply disabled styling - not suitable here
\r
3051 .css("cursor", "default")
\r
3055 // if pane has a toggler button, adjust that too
\r
3058 .removeClass( tClass+_open +" "+ tClass+_pane+_open )
\r
3059 .addClass( tClass+_closed +" "+ tClass+_pane+_closed )
\r
3060 .attr("title", o.togglerTip_closed) // may be blank
\r
3062 // toggler-content - if exists
\r
3063 $T.children(".content-open").hide();
\r
3064 $T.children(".content-closed").css("display","block");
\r
3067 // sync any 'pin buttons'
\r
3068 syncPinBtns(pane, false);
\r
3070 if (state.initialized) {
\r
3071 // resize 'length' and position togglers for adjacent panes
\r
3077 * Open the specified pane (animation optional), and resize all other panes as needed
\r
3079 * @param {string} pane The pane being opened, ie: north, south, east, or west
\r
3080 * @param {boolean=} [slide=false]
\r
3081 * @param {boolean=} [noAnimation=false]
\r
3082 * @param {boolean=} [noAlert=false]
\r
3084 , open = function (evt_or_pane, slide, noAnimation, noAlert) {
\r
3085 if (!isInitialized()) return;
\r
3086 var pane = evtPane.call(this, evt_or_pane)
\r
3090 , o = options[pane]
\r
3095 // QUEUE in case another action/animation is in progress
\r
3096 $N.queue(function( queueNext ){
\r
3099 || (!o.resizable && !o.closable && !s.isShowing) // invalid request
\r
3100 || (s.isVisible && !s.isSliding) // already open
\r
3101 ) return queueNext();
\r
3103 // pane can ALSO be unhidden by just calling show(), so handle this scenario
\r
3104 if (s.isHidden && !s.isShowing) {
\r
3105 queueNext(); // call before show() because it needs the queue free
\r
3110 if (o.autoResize && s.size != o.size) // resize pane to original size set in options
\r
3111 sizePane(pane, o.size, true, true, true); // true=skipCallback/forceResize/noAnimation
\r
3113 // make sure there is enough space available to open the pane
\r
3114 setSizeLimits(pane, slide);
\r
3116 // onopen_start callback - will CANCEL open if returns false
\r
3117 var cbReturn = _runCallbacks("onopen_start", pane);
\r
3119 if (cbReturn === "abort")
\r
3120 return queueNext();
\r
3122 // update pane-state again in case options were changed in onopen_start
\r
3123 if (cbReturn !== "NC") // NC = "No Callback"
\r
3124 setSizeLimits(pane, slide);
\r
3126 if (s.minSize > s.maxSize) { // INSUFFICIENT ROOM FOR PANE TO OPEN!
\r
3127 syncPinBtns(pane, false); // make sure pin-buttons are reset
\r
3128 if (!noAlert && o.noRoomToOpenTip)
\r
3129 alert(o.noRoomToOpenTip);
\r
3130 return queueNext(); // ABORT
\r
3133 if (slide) // START Sliding - will set isSliding=true
\r
3134 bindStopSlidingEvents(pane, true); // BIND trigger events to close sliding-pane
\r
3135 else if (s.isSliding) // PIN PANE (stop sliding) - open pane 'normally' instead
\r
3136 bindStopSlidingEvents(pane, false); // UNBIND trigger events - will set isSliding=false
\r
3137 else if (o.slidable)
\r
3138 bindStartSlidingEvent(pane, false); // UNBIND trigger events
\r
3140 s.noRoom = false; // will be reset by makePaneFit if 'noRoom'
\r
3141 makePaneFit(pane);
\r
3143 // transfer logic var to temp var
\r
3144 isShowing = s.isShowing;
\r
3145 // now clear the logic var
\r
3146 delete s.isShowing;
\r
3148 doFX = !noAnimation && s.isClosed && (o.fxName_open != "none");
\r
3149 s.isMoving = true;
\r
3150 s.isVisible = true;
\r
3151 s.isClosed = false;
\r
3152 // update isHidden BEFORE sizing panes - WHY??? Old?
\r
3153 if (isShowing) s.isHidden = false;
\r
3155 if (doFX) { // ANIMATE
\r
3156 // mask panes with objects
\r
3157 var masks = "center"+ (c.dir=="horz" ? ",west,east" : "");
\r
3158 if (s.isSliding) masks += ","+ _c.oppositeEdge[pane];
\r
3159 showMasks( masks, true ); // true = ONLY mask panes with maskObjects=true
\r
3160 lockPaneForFX(pane, true); // need to set left/top so animation will work
\r
3161 $P.show( o.fxName_open, o.fxSettings_open, o.fxSpeed_open, function() {
\r
3162 lockPaneForFX(pane, false); // undo
\r
3163 if (s.isVisible) open_2(); // continue
\r
3167 else { // no animation
\r
3168 _showPane(pane);// just show pane and...
\r
3169 open_2(); // continue
\r
3175 function open_2 () {
\r
3176 s.isMoving = false;
\r
3178 // cure iframe display issues
\r
3181 // NOTE: if isSliding, then other panes are NOT 'resized'
\r
3182 if (!s.isSliding) { // resize all panes adjacent to this one
\r
3183 hideMasks(); // remove any masks shown while opening
\r
3184 sizeMidPanes(_c[pane].dir=="vert" ? "center" : "", false); // false = NOT skipCallback
\r
3187 // set classes, position handles and execute callbacks...
\r
3194 * @param {string} pane The pane just opened, ie: north, south, east, or west
\r
3195 * @param {boolean=} [skipCallback=false]
\r
3197 , setAsOpen = function (pane, skipCallback) {
\r
3202 , o = options[pane]
\r
3204 , side = _c[pane].side.toLowerCase()
\r
3205 , inset = "inset"+ _c[pane].side
\r
3206 , rClass = o.resizerClass
\r
3207 , tClass = o.togglerClass
\r
3208 , _pane = "-"+ pane // used for classNames
\r
3210 , _closed = "-closed"
\r
3211 , _sliding= "-sliding"
\r
3214 .css(side, sC[inset] + getPaneSize(pane)) // move the resizer
\r
3215 .removeClass( rClass+_closed +" "+ rClass+_pane+_closed )
\r
3216 .addClass( rClass+_open +" "+ rClass+_pane+_open )
\r
3219 $R.addClass( rClass+_sliding +" "+ rClass+_pane+_sliding )
\r
3220 else // in case 'was sliding'
\r
3221 $R.removeClass( rClass+_sliding +" "+ rClass+_pane+_sliding )
\r
3223 if (o.resizerDblClickToggle)
\r
3224 $R.bind("dblclick", toggle );
\r
3225 removeHover( 0, $R ); // remove hover classes
\r
3226 if (o.resizable && $.layout.plugins.draggable)
\r
3227 $R .draggable("enable")
\r
3228 .css("cursor", o.resizerCursor)
\r
3229 .attr("title", o.resizerTip);
\r
3230 else if (!s.isSliding)
\r
3231 $R.css("cursor", "default"); // n-resize, s-resize, etc
\r
3233 // if pane also has a toggler button, adjust that too
\r
3235 $T .removeClass( tClass+_closed +" "+ tClass+_pane+_closed )
\r
3236 .addClass( tClass+_open +" "+ tClass+_pane+_open )
\r
3237 .attr("title", o.togglerTip_open); // may be blank
\r
3238 removeHover( 0, $T ); // remove hover classes
\r
3239 // toggler-content - if exists
\r
3240 $T.children(".content-closed").hide();
\r
3241 $T.children(".content-open").css("display","block");
\r
3244 // sync any 'pin buttons'
\r
3245 syncPinBtns(pane, !s.isSliding);
\r
3247 // update pane-state dimensions - BEFORE resizing content
\r
3248 $.extend(s, elDims($P));
\r
3250 if (state.initialized) {
\r
3251 // resize resizer & toggler sizes for all panes
\r
3253 // resize content every time pane opens - to be sure
\r
3254 sizeContent(pane, true); // true = remeasure headers/footers, even if 'pane.isMoving'
\r
3257 if (!skipCallback && (state.initialized || o.triggerEventsOnLoad) && $P.is(":visible")) {
\r
3258 // onopen callback
\r
3259 _runCallbacks("onopen_end", pane);
\r
3260 // onshow callback - TODO: should this be here?
\r
3261 if (s.isShowing) _runCallbacks("onshow_end", pane);
\r
3263 // ALSO call onresize because layout-size *may* have changed while pane was closed
\r
3264 if (state.initialized)
\r
3265 _runCallbacks("onresize_end", pane);
\r
3268 // TODO: Somehow sizePane("north") is being called after this point???
\r
3273 * slideOpen / slideClose / slideToggle
\r
3275 * Pass-though methods for sliding
\r
3277 , slideOpen = function (evt_or_pane) {
\r
3278 if (!isInitialized()) return;
\r
3279 var evt = evtObj(evt_or_pane)
\r
3280 , pane = evtPane.call(this, evt_or_pane)
\r
3282 , delay = options[pane].slideDelay_open
\r
3284 // prevent event from triggering on NEW resizer binding created below
\r
3285 if (evt) evt.stopImmediatePropagation();
\r
3287 if (s.isClosed && evt && evt.type === "mouseenter" && delay > 0)
\r
3288 // trigger = mouseenter - use a delay
\r
3289 timer.set(pane+"_openSlider", open_NOW, delay);
\r
3291 open_NOW(); // will unbind events if is already open
\r
3294 * SUBROUTINE for timed open
\r
3296 function open_NOW () {
\r
3297 if (!s.isClosed) // skip if no longer closed!
\r
3298 bindStopSlidingEvents(pane, true); // BIND trigger events to close sliding-pane
\r
3299 else if (!s.isMoving)
\r
3300 open(pane, true); // true = slide - open() will handle binding
\r
3304 , slideClose = function (evt_or_pane) {
\r
3305 if (!isInitialized()) return;
\r
3306 var evt = evtObj(evt_or_pane)
\r
3307 , pane = evtPane.call(this, evt_or_pane)
\r
3308 , o = options[pane]
\r
3310 , delay = s.isMoving ? 1000 : 300 // MINIMUM delay - option may override
\r
3312 if (s.isClosed || s.isResizing)
\r
3313 return; // skip if already closed OR in process of resizing
\r
3314 else if (o.slideTrigger_close === "click")
\r
3315 close_NOW(); // close immediately onClick
\r
3316 else if (o.preventQuickSlideClose && s.isMoving)
\r
3317 return; // handle Chrome quick-close on slide-open
\r
3318 else if (o.preventPrematureSlideClose && evt && $.layout.isMouseOverElem(evt, $Ps[pane]))
\r
3319 return; // handle incorrect mouseleave trigger, like when over a SELECT-list in IE
\r
3320 else if (evt) // trigger = mouseleave - use a delay
\r
3321 // 1 sec delay if 'opening', else .3 sec
\r
3322 timer.set(pane+"_closeSlider", close_NOW, max(o.slideDelay_close, delay));
\r
3323 else // called programically
\r
3327 * SUBROUTINE for timed close
\r
3329 function close_NOW () {
\r
3330 if (s.isClosed) // skip 'close' if already closed!
\r
3331 bindStopSlidingEvents(pane, false); // UNBIND trigger events - TODO: is this needed here?
\r
3332 else if (!s.isMoving)
\r
3333 close(pane); // close will handle unbinding
\r
3338 * @param {string} pane The pane being opened, ie: north, south, east, or west
\r
3340 , slideToggle = function (evt_or_pane) {
\r
3341 var pane = evtPane.call(this, evt_or_pane);
\r
3342 toggle(pane, true);
\r
3347 * Must set left/top on East/South panes so animation will work properly
\r
3349 * @param {string} pane The pane to lock, 'east' or 'south' - any other is ignored!
\r
3350 * @param {boolean} doLock true = set left/top, false = remove
\r
3352 , lockPaneForFX = function (pane, doLock) {
\r
3353 var $P = $Ps[pane]
\r
3355 , o = options[pane]
\r
3356 , z = options.zIndexes
\r
3359 $P.css({ zIndex: z.pane_animate }); // overlay all elements during animation
\r
3360 if (pane=="south")
\r
3361 $P.css({ top: sC.insetTop + sC.innerHeight - $P.outerHeight() });
\r
3362 else if (pane=="east")
\r
3363 $P.css({ left: sC.insetLeft + sC.innerWidth - $P.outerWidth() });
\r
3365 else { // animation DONE - RESET CSS
\r
3366 // TODO: see if this can be deleted. It causes a quick-close when sliding in Chrome
\r
3367 $P.css({ zIndex: (s.isSliding ? z.pane_sliding : z.pane_normal) });
\r
3368 if (pane=="south")
\r
3369 $P.css({ top: "auto" });
\r
3370 // if pane is positioned 'off-screen', then DO NOT screw with it!
\r
3371 else if (pane=="east" && !$P.css("left").match(/\-99999/))
\r
3372 $P.css({ left: "auto" });
\r
3373 // fix anti-aliasing in IE - only needed for animations that change opacity
\r
3374 if (browser.msie && o.fxOpacityFix && o.fxName_open != "slide" && $P.css("filter") && $P.css("opacity") == 1)
\r
3375 $P[0].style.removeAttribute('filter');
\r
3381 * Toggle sliding functionality of a specific pane on/off by adding removing 'slide open' trigger
\r
3383 * @see open(), close()
\r
3384 * @param {string} pane The pane to enable/disable, 'north', 'south', etc.
\r
3385 * @param {boolean} enable Enable or Disable sliding?
\r
3387 , bindStartSlidingEvent = function (pane, enable) {
\r
3388 var o = options[pane]
\r
3391 , evtName = o.slideTrigger_open.toLowerCase()
\r
3393 if (!$R || (enable && !o.slidable)) return;
\r
3395 // make sure we have a valid event
\r
3396 if (evtName.match(/mouseover/))
\r
3397 evtName = o.slideTrigger_open = "mouseenter";
\r
3398 else if (!evtName.match(/click|dblclick|mouseenter/))
\r
3399 evtName = o.slideTrigger_open = "click";
\r
3402 // add or remove event
\r
3403 [enable ? "bind" : "unbind"](evtName +'.'+ sID, slideOpen)
\r
3404 // set the appropriate cursor & title/tip
\r
3405 .css("cursor", enable ? o.sliderCursor : "default")
\r
3406 .attr("title", enable ? o.sliderTip : "")
\r
3411 * Add or remove 'mouseleave' events to 'slide close' when pane is 'sliding' open or closed
\r
3412 * Also increases zIndex when pane is sliding open
\r
3413 * See bindStartSlidingEvent for code to control 'slide open'
\r
3415 * @see slideOpen(), slideClose()
\r
3416 * @param {string} pane The pane to process, 'north', 'south', etc.
\r
3417 * @param {boolean} enable Enable or Disable events?
\r
3419 , bindStopSlidingEvents = function (pane, enable) {
\r
3420 var o = options[pane]
\r
3423 , z = options.zIndexes
\r
3424 , evtName = o.slideTrigger_close.toLowerCase()
\r
3425 , action = (enable ? "bind" : "unbind")
\r
3429 s.isSliding = enable; // logic
\r
3430 timer.clear(pane+"_closeSlider"); // just in case
\r
3432 // remove 'slideOpen' event from resizer
\r
3433 // ALSO will raise the zIndex of the pane & resizer
\r
3434 if (enable) bindStartSlidingEvent(pane, false);
\r
3436 // RE/SET zIndex - increases when pane is sliding-open, resets to normal when not
\r
3437 $P.css("zIndex", enable ? z.pane_sliding : z.pane_normal);
\r
3438 $R.css("zIndex", enable ? z.pane_sliding+2 : z.resizer_normal); // NOTE: mask = pane_sliding+1
\r
3440 // make sure we have a valid event
\r
3441 if (!evtName.match(/click|mouseleave/))
\r
3442 evtName = o.slideTrigger_close = "mouseleave"; // also catches 'mouseout'
\r
3444 // add/remove slide triggers
\r
3445 $R[action](evtName, slideClose); // base event on resize
\r
3446 // need extra events for mouseleave
\r
3447 if (evtName === "mouseleave") {
\r
3448 // also close on pane.mouseleave
\r
3449 $P[action]("mouseleave."+ sID, slideClose);
\r
3450 // cancel timer when mouse moves between 'pane' and 'resizer'
\r
3451 $R[action]("mouseenter."+ sID, cancelMouseOut);
\r
3452 $P[action]("mouseenter."+ sID, cancelMouseOut);
\r
3456 timer.clear(pane+"_closeSlider");
\r
3457 else if (evtName === "click" && !o.resizable) {
\r
3458 // IF pane is not resizable (which already has a cursor and tip)
\r
3459 // then set the a cursor & title/tip on resizer when sliding
\r
3460 $R.css("cursor", enable ? o.sliderCursor : "default");
\r
3461 $R.attr("title", enable ? o.togglerTip_open : ""); // use Toggler-tip, eg: "Close Pane"
\r
3464 // SUBROUTINE for mouseleave timer clearing
\r
3465 function cancelMouseOut (evt) {
\r
3466 timer.clear(pane+"_closeSlider");
\r
3467 evt.stopPropagation();
\r
3473 * Hides/closes a pane if there is insufficient room - reverses this when there is room again
\r
3474 * MUST have already called setSizeLimits() before calling this method
\r
3476 * @param {string} pane The pane being resized
\r
3477 * @param {boolean=} [isOpening=false] Called from onOpen?
\r
3478 * @param {boolean=} [skipCallback=false] Should the onresize callback be run?
\r
3479 * @param {boolean=} [force=false]
\r
3481 , makePaneFit = function (pane, isOpening, skipCallback, force) {
\r
3488 , isSidePane = c.dir==="vert"
\r
3491 // special handling for center & east/west panes
\r
3492 if (pane === "center" || (isSidePane && s.noVerticalRoom)) {
\r
3493 // see if there is enough room to display the pane
\r
3494 // ERROR: hasRoom = s.minHeight <= s.maxHeight && (isSidePane || s.minWidth <= s.maxWidth);
\r
3495 hasRoom = (s.maxHeight >= 0);
\r
3496 if (hasRoom && s.noRoom) { // previously hidden due to noRoom, so show now
\r
3498 if ($R) $R.show();
\r
3499 s.isVisible = true;
\r
3501 if (isSidePane) s.noVerticalRoom = false;
\r
3504 else if (!hasRoom && !s.noRoom) { // not currently hidden, so hide now
\r
3506 if ($R) $R.hide();
\r
3507 s.isVisible = false;
\r
3512 // see if there is enough room to fit the border-pane
\r
3513 if (pane === "center") {
\r
3514 // ignore center in this block
\r
3516 else if (s.minSize <= s.maxSize) { // pane CAN fit
\r
3518 if (s.size > s.maxSize) // pane is too big - shrink it
\r
3519 sizePane(pane, s.maxSize, skipCallback, force, true); // true = noAnimation
\r
3520 else if (s.size < s.minSize) // pane is too small - enlarge it
\r
3521 sizePane(pane, s.minSize, skipCallback, force, true);
\r
3522 // need s.isVisible because new pseudoClose method keeps pane visible, but off-screen
\r
3523 else if ($R && s.isVisible && $P.is(":visible")) {
\r
3524 // make sure resizer-bar is positioned correctly
\r
3525 // handles situation where nested layout was 'hidden' when initialized
\r
3526 var side = c.side.toLowerCase()
\r
3527 , pos = s.size + sC["inset"+ c.side]
\r
3529 if ($.layout.cssNum($R, side) != pos) $R.css( side, pos );
\r
3532 // if was previously hidden due to noRoom, then RESET because NOW there is room
\r
3534 // s.noRoom state will be set by open or show
\r
3535 if (s.wasOpen && o.closable) {
\r
3537 open(pane, false, true, true); // true = noAnimation, true = noAlert
\r
3538 else // leave the pane closed, so just update state
\r
3542 show(pane, s.wasOpen, true, true); // true = noAnimation, true = noAlert
\r
3545 else { // !hasRoom - pane CANNOT fit
\r
3546 if (!s.noRoom) { // pane not set as noRoom yet, so hide or close it now...
\r
3547 s.noRoom = true; // update state
\r
3548 s.wasOpen = !s.isClosed && !s.isSliding;
\r
3549 if (s.isClosed){} // SKIP
\r
3550 else if (o.closable) // 'close' if possible
\r
3551 close(pane, true, true); // true = force, true = noAnimation
\r
3552 else // 'hide' pane if cannot just be closed
\r
3553 hide(pane, true); // true = noAnimation
\r
3560 * sizePane / manualSizePane
\r
3561 * sizePane is called only by internal methods whenever a pane needs to be resized
\r
3562 * manualSizePane is an exposed flow-through method allowing extra code when pane is 'manually resized'
\r
3564 * @param {string} pane The pane being resized
\r
3565 * @param {number} size The *desired* new size for this pane - will be validated
\r
3566 * @param {boolean=} [skipCallback=false] Should the onresize callback be run?
\r
3567 * @param {boolean=} [noAnimation=false]
\r
3569 , manualSizePane = function (evt_or_pane, size, skipCallback, noAnimation) {
\r
3570 if (!isInitialized()) return;
\r
3571 var pane = evtPane.call(this, evt_or_pane)
\r
3572 , o = options[pane]
\r
3574 // if resizing callbacks have been delayed and resizing is now DONE, force resizing to complete...
\r
3575 , forceResize = o.livePaneResizing && !s.isResizing
\r
3577 // ANY call to manualSizePane disables autoResize - ie, percentage sizing
\r
3578 o.autoResize = false;
\r
3579 // flow-through...
\r
3580 sizePane(pane, size, skipCallback, forceResize, noAnimation); // will animate resize if option enabled
\r
3584 * @param {string} pane The pane being resized
\r
3585 * @param {number} size The *desired* new size for this pane - will be validated
\r
3586 * @param {boolean=} [skipCallback=false] Should the onresize callback be run?
\r
3587 * @param {boolean=} [force=false] Force resizing even if does not seem necessary
\r
3588 * @param {boolean=} [noAnimation=false]
\r
3590 , sizePane = function (evt_or_pane, size, skipCallback, force, noAnimation) {
\r
3591 if (!isInitialized()) return;
\r
3592 var pane = evtPane.call(this, evt_or_pane) // probably NEVER called from event?
\r
3593 , o = options[pane]
\r
3597 , side = _c[pane].side.toLowerCase()
\r
3598 , dimName = _c[pane].sizeType.toLowerCase()
\r
3599 , inset = "inset"+ _c[pane].side
\r
3600 , skipResizeWhileDragging = s.isResizing && !o.triggerEventsDuringLiveResize
\r
3601 , doFX = noAnimation !== true && o.animatePaneSizing
\r
3602 , oldSize, newSize
\r
3604 // QUEUE in case another action/animation is in progress
\r
3605 $N.queue(function( queueNext ){
\r
3606 // calculate 'current' min/max sizes
\r
3607 setSizeLimits(pane); // update pane-state
\r
3609 size = _parseSize(pane, size); // handle percentages & auto
\r
3610 size = max(size, _parseSize(pane, o.minSize));
\r
3611 size = min(size, s.maxSize);
\r
3612 if (size < s.minSize) { // not enough room for pane!
\r
3613 queueNext(); // call before makePaneFit() because it needs the queue free
\r
3614 makePaneFit(pane, false, skipCallback); // will hide or close pane
\r
3618 // IF newSize is same as oldSize, then nothing to do - abort
\r
3619 if (!force && size === oldSize)
\r
3620 return queueNext();
\r
3622 // onresize_start callback CANNOT cancel resizing because this would break the layout!
\r
3623 if (!skipCallback && state.initialized && s.isVisible)
\r
3624 _runCallbacks("onresize_start", pane);
\r
3626 // resize the pane, and make sure its visible
\r
3627 newSize = cssSize(pane, size);
\r
3629 if (doFX && $P.is(":visible")) { // ANIMATE
\r
3630 var fx = $.layout.effects.size[pane] || $.layout.effects.size.all
\r
3631 , easing = o.fxSettings_size.easing || fx.easing
\r
3632 , z = options.zIndexes
\r
3634 props[ dimName ] = newSize +'px';
\r
3635 s.isMoving = true;
\r
3636 // overlay all elements during animation
\r
3637 $P.css({ zIndex: z.pane_animate })
\r
3638 .show().animate( props, o.fxSpeed_size, easing, function(){
\r
3639 // reset zIndex after animation
\r
3640 $P.css({ zIndex: (s.isSliding ? z.pane_sliding : z.pane_normal) });
\r
3641 s.isMoving = false;
\r
3642 sizePane_2(); // continue
\r
3646 else { // no animation
\r
3647 $P.css( dimName, newSize ); // resize pane
\r
3648 // if pane is visible, then
\r
3649 if ($P.is(":visible"))
\r
3650 sizePane_2(); // continue
\r
3652 // pane is NOT VISIBLE, so just update state data...
\r
3653 // when pane is *next opened*, it will have the new size
\r
3654 s.size = size; // update state.size
\r
3655 $.extend(s, elDims($P)); // update state dimensions
\r
3663 function sizePane_2 () {
\r
3664 /* Panes are sometimes not sized precisely in some browsers!?
\r
3665 * This code will resize the pane up to 3 times to nudge the pane to the correct size
\r
3667 var actual = dimName==='width' ? $P.outerWidth() : $P.outerHeight()
\r
3673 , correct: (size === actual)
\r
3675 , cssSize: newSize
\r
3677 , lastTry = tries[0]
\r
3678 , msg = 'Inaccurate size after resizing the '+ pane +'-pane.'
\r
3680 while ( !lastTry.correct ) {
\r
3681 thisTry = { pane: pane, count: lastTry.count+1, target: size };
\r
3683 if (lastTry.actual > size)
\r
3684 thisTry.attempt = max(0, lastTry.attempt - (lastTry.actual - size));
\r
3685 else // lastTry.actual < size
\r
3686 thisTry.attempt = max(0, lastTry.attempt + (size - lastTry.actual));
\r
3688 thisTry.cssSize = cssSize(pane, thisTry.attempt);
\r
3689 $P.css( dimName, thisTry.cssSize );
\r
3691 thisTry.actual = dimName=='width' ? $P.outerWidth() : $P.outerHeight();
\r
3692 thisTry.correct = (size === thisTry.actual);
\r
3694 // if showDebugMessages, log attempts and alert the user of this *non-fatal error*
\r
3695 if (options.showDebugMessages) {
\r
3696 if ( tries.length === 1) {
\r
3698 _log(lastTry, false);
\r
3700 _log(thisTry, false);
\r
3703 // after 4 tries, is as close as its gonna get!
\r
3704 if (tries.length > 3) break;
\r
3706 tries.push( thisTry );
\r
3707 lastTry = tries[ tries.length - 1 ];
\r
3709 // END TESTING CODE
\r
3711 // update pane-state dimensions
\r
3713 $.extend(s, elDims($P));
\r
3715 if (s.isVisible && $P.is(":visible")) {
\r
3716 // reposition the resizer-bar
\r
3717 if ($R) $R.css( side, size + sC[inset] );
\r
3718 // resize the content-div
\r
3719 sizeContent(pane);
\r
3722 if (!skipCallback && !skipResizeWhileDragging && state.initialized && s.isVisible)
\r
3723 _runCallbacks("onresize_end", pane);
\r
3725 // resize all the adjacent panes, and adjust their toggler buttons
\r
3726 // when skipCallback passed, it means the controlling method will handle 'other panes'
\r
3727 if (!skipCallback) {
\r
3728 // also no callback if live-resize is in progress and NOT triggerEventsDuringLiveResize
\r
3729 if (!s.isSliding) sizeMidPanes(_c[pane].dir=="horz" ? "" : "center", skipResizeWhileDragging, force);
\r
3733 // if opposite-pane was autoClosed, see if it can be autoOpened now
\r
3734 var altPane = _c.oppositeEdge[pane];
\r
3735 if (size < oldSize && state[ altPane ].noRoom) {
\r
3736 setSizeLimits( altPane );
\r
3737 makePaneFit( altPane, false, skipCallback );
\r
3740 // DEBUG - ALERT user/developer so they know there was a sizing problem
\r
3741 if (options.showDebugMessages && tries.length > 1)
\r
3742 _log(msg +'\nSee the Error Console for details.', true);
\r
3747 * @see initPanes(), sizePane(), resizeAll(), open(), close(), hide()
\r
3748 * @param {string} panes The pane(s) being resized, comma-delmited string
\r
3749 * @param {boolean=} [skipCallback=false] Should the onresize callback be run?
\r
3750 * @param {boolean=} [force=false]
\r
3752 , sizeMidPanes = function (panes, skipCallback, force) {
\r
3753 panes = (panes ? panes : "east,west,center").split(",");
\r
3755 $.each(panes, function (i, pane) {
\r
3756 if (!$Ps[pane]) return; // NO PANE - skip
\r
3762 , isCenter= (pane=="center")
\r
3765 , newCenter = calcNewCenterPaneDims()
\r
3767 // update pane-state dimensions
\r
3768 $.extend(s, elDims($P));
\r
3770 if (pane === "center") {
\r
3771 if (!force && s.isVisible && newCenter.width === s.outerWidth && newCenter.height === s.outerHeight)
\r
3772 return true; // SKIP - pane already the correct size
\r
3773 // set state for makePaneFit() logic
\r
3774 $.extend(s, cssMinDims(pane), {
\r
3775 maxWidth: newCenter.width
\r
3776 , maxHeight: newCenter.height
\r
3779 // convert OUTER width/height to CSS width/height
\r
3780 CSS.width = cssW($P, CSS.width);
\r
3781 // NEW - allow pane to extend 'below' visible area rather than hide it
\r
3782 CSS.height = cssH($P, CSS.height);
\r
3783 hasRoom = CSS.width >= 0 && CSS.height >= 0; // height >= 0 = ALWAYS TRUE NOW
\r
3784 // during layout init, try to shrink east/west panes to make room for center
\r
3785 if (!state.initialized && o.minWidth > s.outerWidth) {
\r
3787 reqPx = o.minWidth - s.outerWidth
\r
3788 , minE = options.east.minSize || 0
\r
3789 , minW = options.west.minSize || 0
\r
3790 , sizeE = state.east.size
\r
3791 , sizeW = state.west.size
\r
3795 if (reqPx > 0 && state.east.isVisible && sizeE > minE) {
\r
3796 newE = max( sizeE-minE, sizeE-reqPx );
\r
3797 reqPx -= sizeE-newE;
\r
3799 if (reqPx > 0 && state.west.isVisible && sizeW > minW) {
\r
3800 newW = max( sizeW-minW, sizeW-reqPx );
\r
3801 reqPx -= sizeW-newW;
\r
3803 // IF we found enough extra space, then resize the border panes as calculated
\r
3804 if (reqPx === 0) {
\r
3805 if (sizeE != minE)
\r
3806 sizePane('east', newE, true, force, true); // true = skipCallback/noAnimation - initPanes will handle when done
\r
3807 if (sizeW != minW)
\r
3808 sizePane('west', newW, true, force, true);
\r
3809 // now start over!
\r
3810 sizeMidPanes('center', skipCallback, force);
\r
3811 return; // abort this loop
\r
3815 else { // for east and west, set only the height, which is same as center height
\r
3816 // set state.min/maxWidth/Height for makePaneFit() logic
\r
3817 if (s.isVisible && !s.noVerticalRoom)
\r
3818 $.extend(s, elDims($P), cssMinDims(pane))
\r
3819 if (!force && !s.noVerticalRoom && newCenter.height === s.outerHeight)
\r
3820 return true; // SKIP - pane already the correct size
\r
3821 // east/west have same top, bottom & height as center
\r
3822 CSS.top = newCenter.top;
\r
3823 CSS.bottom = newCenter.bottom;
\r
3824 // NEW - allow pane to extend 'below' visible area rather than hide it
\r
3825 CSS.height = cssH($P, newCenter.height);
\r
3826 s.maxHeight = CSS.height;
\r
3827 hasRoom = (s.maxHeight >= 0); // ALWAYS TRUE NOW
\r
3828 if (!hasRoom) s.noVerticalRoom = true; // makePaneFit() logic
\r
3832 // resizeAll passes skipCallback because it triggers callbacks after ALL panes are resized
\r
3833 if (!skipCallback && state.initialized)
\r
3834 _runCallbacks("onresize_start", pane);
\r
3836 $P.css(CSS); // apply the CSS to pane
\r
3837 sizeHandles(pane); // also update resizer length
\r
3838 if (s.noRoom && !s.isClosed && !s.isHidden)
\r
3839 makePaneFit(pane); // will re-open/show auto-closed/hidden pane
\r
3840 if (s.isVisible) {
\r
3841 $.extend(s, elDims($P)); // update pane dimensions
\r
3842 if (state.initialized) sizeContent(pane); // also resize the contents, if exists
\r
3845 else if (!s.noRoom && s.isVisible) // no room for pane
\r
3846 makePaneFit(pane); // will hide or close pane
\r
3849 return true; // DONE - next pane
\r
3852 * Extra CSS for IE6 or IE7 in Quirks-mode - add 'width' to NORTH/SOUTH panes
\r
3853 * Normally these panes have only 'left' & 'right' positions so pane auto-sizes
\r
3854 * ALSO required when pane is an IFRAME because will NOT default to 'full width'
\r
3856 if (pane === "center") { // finished processing midPanes
\r
3857 var b = $.layout.browser;
\r
3858 var fix = b.isIE6 || (b.msie && !$.support.boxModel);
\r
3859 if ($Ps.north && (fix || state.north.tagName=="IFRAME"))
\r
3860 $Ps.north.css("width", cssW($Ps.north, sC.innerWidth));
\r
3861 if ($Ps.south && (fix || state.south.tagName=="IFRAME"))
\r
3862 $Ps.south.css("width", cssW($Ps.south, sC.innerWidth));
\r
3865 // resizeAll passes skipCallback because it triggers callbacks after ALL panes are resized
\r
3866 if (!skipCallback && state.initialized)
\r
3867 _runCallbacks("onresize_end", pane);
\r
3873 * @see window.onresize(), callbacks or custom code
\r
3875 , resizeAll = function () {
\r
3876 if (!state.initialized) {
\r
3877 _initLayoutElements();
\r
3878 return; // no need to resize since we just initialized!
\r
3880 var oldW = sC.innerWidth
\r
3881 , oldH = sC.innerHeight
\r
3883 // cannot size layout when 'container' is hidden or collapsed
\r
3884 if (!$N.is(":visible:") ) return;
\r
3885 $.extend( state.container, elDims( $N ) ); // UPDATE container dimensions
\r
3886 if (!sC.outerHeight) return;
\r
3888 // onresizeall_start will CANCEL resizing if returns false
\r
3889 // state.container has already been set, so user can access this info for calcuations
\r
3890 if (false === _runCallbacks("onresizeall_start")) return false;
\r
3892 var // see if container is now 'smaller' than before
\r
3893 shrunkH = (sC.innerHeight < oldH)
\r
3894 , shrunkW = (sC.innerWidth < oldW)
\r
3897 // NOTE special order for sizing: S-N-E-W
\r
3898 $.each(["south","north","east","west"], function (i, pane) {
\r
3899 if (!$Ps[pane]) return; // no pane - SKIP
\r
3901 o = options[pane];
\r
3902 dir = _c[pane].dir;
\r
3904 if (o.autoResize && s.size != o.size) // resize pane to original size set in options
\r
3905 sizePane(pane, o.size, true, true, true); // true=skipCallback/forceResize/noAnimation
\r
3907 setSizeLimits(pane);
\r
3908 makePaneFit(pane, false, true, true); // true=skipCallback/forceResize
\r
3912 sizeMidPanes("", true, true); // true=skipCallback, true=forceResize
\r
3913 sizeHandles(); // reposition the toggler elements
\r
3915 // trigger all individual pane callbacks AFTER layout has finished resizing
\r
3916 o = options; // reuse alias
\r
3917 $.each(_c.allPanes, function (i, pane) {
\r
3919 if (!$P) return; // SKIP
\r
3920 if (state[pane].isVisible) // undefined for non-existent panes
\r
3921 _runCallbacks("onresize_end", pane); // callback - if exists
\r
3924 _runCallbacks("onresizeall_end");
\r
3925 //_triggerLayoutEvent(pane, 'resizeall');
\r
3929 * Whenever a pane resizes or opens that has a nested layout, trigger resizeAll
\r
3931 * @param {string} pane The pane just resized or opened
\r
3933 , resizeChildLayout = function (evt_or_pane) {
\r
3934 var pane = evtPane.call(this, evt_or_pane);
\r
3935 if (!options[pane].resizeChildLayout) return;
\r
3936 var $P = $Ps[pane]
\r
3939 , P = Instance[pane]
\r
3940 , L = children[pane]
\r
3942 // user may have manually set EITHER instance pointer, so handle that
\r
3943 if (P.child && !L) {
\r
3944 // have to reverse the pointers!
\r
3945 var el = P.child.container;
\r
3946 L = children[pane] = (el ? el.data(d) : 0) || null; // set pointer _directly_ to layout instance
\r
3949 // if a layout-pointer exists, see if child has been destroyed
\r
3950 if (L && L.destroyed)
\r
3951 L = children[pane] = null; // clear child pointers
\r
3952 // no child layout pointer is set - see if there is a child layout NOW
\r
3953 if (!L) L = children[pane] = $P.data(d) || ($C ? $C.data(d) : 0) || null; // set/update child pointers
\r
3955 // ALWAYS refresh the pane.child alias
\r
3956 P.child = children[pane];
\r
3958 if (L) L.resizeAll();
\r
3963 * IF pane has a content-div, then resize all elements inside pane to fit pane-height
\r
3965 * @param {string=} [panes=""] The pane(s) being resized
\r
3966 * @param {boolean=} [remeasure=false] Should the content (header/footer) be remeasured?
\r
3968 , sizeContent = function (evt_or_panes, remeasure) {
\r
3969 if (!isInitialized()) return;
\r
3971 var panes = evtPane.call(this, evt_or_panes);
\r
3972 panes = panes ? panes.split(",") : _c.allPanes;
\r
3974 $.each(panes, function (idx, pane) {
\r
3978 , o = options[pane]
\r
3980 , m = s.content // m = measurements
\r
3982 if (!$P || !$C || !$P.is(":visible")) return true; // NOT VISIBLE - skip
\r
3984 // if content-element was REMOVED, update OR remove the pointer
\r
3986 initContent(pane, false); // false = do NOT sizeContent() - already there!
\r
3987 if (!$C) return; // no replacement element found - pointer have been removed
\r
3990 // onsizecontent_start will CANCEL resizing if returns false
\r
3991 if (false === _runCallbacks("onsizecontent_start", pane)) return;
\r
3993 // skip re-measuring offsets if live-resizing
\r
3994 if ((!s.isMoving && !s.isResizing) || o.liveContentResizing || remeasure || m.top == undefined) {
\r
3996 // if any footers are below pane-bottom, they may not measure correctly,
\r
3997 // so allow pane overflow and re-measure
\r
3998 if (m.hiddenFooters > 0 && $P.css("overflow") === "hidden") {
\r
3999 $P.css("overflow", "visible");
\r
4000 _measure(); // remeasure while overflowing
\r
4001 $P.css("overflow", "hidden");
\r
4004 // NOTE: spaceAbove/Below *includes* the pane paddingTop/Bottom, but not pane.borders
\r
4005 var newH = s.innerHeight - (m.spaceAbove - s.css.paddingTop) - (m.spaceBelow - s.css.paddingBottom);
\r
4007 if (!$C.is(":visible") || m.height != newH) {
\r
4008 // size the Content element to fit new pane-size - will autoHide if not enough room
\r
4009 setOuterHeight($C, newH, true); // true=autoHide
\r
4010 m.height = newH; // save new height
\r
4013 if (state.initialized)
\r
4014 _runCallbacks("onsizecontent_end", pane);
\r
4016 function _below ($E) {
\r
4017 return max(s.css.paddingBottom, (parseInt($E.css("marginBottom"), 10) || 0));
\r
4020 function _measure () {
\r
4022 ignore = options[pane].contentIgnoreSelector
\r
4023 , $Fs = $C.nextAll().not(ignore || ':lt(0)') // not :lt(0) = ALL
\r
4024 , $Fs_vis = $Fs.filter(':visible')
\r
4025 , $F = $Fs_vis.filter(':last')
\r
4028 top: $C[0].offsetTop
\r
4029 , height: $C.outerHeight()
\r
4030 , numFooters: $Fs.length
\r
4031 , hiddenFooters: $Fs.length - $Fs_vis.length
\r
4032 , spaceBelow: 0 // correct if no content footer ($E)
\r
4034 m.spaceAbove = m.top; // just for state - not used in calc
\r
4035 m.bottom = m.top + m.height;
\r
4037 //spaceBelow = (LastFooter.top + LastFooter.height) [footerBottom] - Content.bottom + max(LastFooter.marginBottom, pane.paddingBotom)
\r
4038 m.spaceBelow = ($F[0].offsetTop + $F.outerHeight()) - m.bottom + _below($F);
\r
4039 else // no footer - check marginBottom on Content element itself
\r
4040 m.spaceBelow = _below($C);
\r
4047 * Called every time a pane is opened, closed, or resized to slide the togglers to 'center' and adjust their length if necessary
\r
4049 * @see initHandles(), open(), close(), resizeAll()
\r
4050 * @param {string=} [panes=""] The pane(s) being resized
\r
4052 , sizeHandles = function (evt_or_panes) {
\r
4053 var panes = evtPane.call(this, evt_or_panes)
\r
4054 panes = panes ? panes.split(",") : _c.borderPanes;
\r
4056 $.each(panes, function (i, pane) {
\r
4065 if (!$P || !$R) return;
\r
4068 dir = _c[pane].dir
\r
4069 , _state = (s.isClosed ? "_closed" : "_open")
\r
4070 , spacing = o["spacing"+ _state]
\r
4071 , togAlign = o["togglerAlign"+ _state]
\r
4072 , togLen = o["togglerLength"+ _state]
\r
4079 if (spacing === 0) {
\r
4083 else if (!s.noRoom && !s.isHidden) // skip if resizer was hidden for any reason
\r
4084 $R.show(); // in case was previously hidden
\r
4086 // Resizer Bar is ALWAYS same width/height of pane it is attached to
\r
4087 if (dir === "horz") { // north/south
\r
4088 //paneLen = $P.outerWidth(); // s.outerWidth ||
\r
4089 paneLen = sC.innerWidth; // handle offscreen-panes
\r
4090 s.resizerLength = paneLen;
\r
4091 left = $.layout.cssNum($P, "left")
\r
4093 width: cssW($R, paneLen) // account for borders & padding
\r
4094 , height: cssH($R, spacing) // ditto
\r
4095 , left: left > -9999 ? left : sC.insetLeft // handle offscreen-panes
\r
4098 else { // east/west
\r
4099 paneLen = $P.outerHeight(); // s.outerHeight ||
\r
4100 s.resizerLength = paneLen;
\r
4102 height: cssH($R, paneLen) // account for borders & padding
\r
4103 , width: cssW($R, spacing) // ditto
\r
4104 , top: sC.insetTop + getPaneSize("north", true) // TODO: what if no North pane?
\r
4105 //, top: $.layout.cssNum($Ps["center"], "top")
\r
4109 // remove hover classes
\r
4110 removeHover( o, $R );
\r
4113 if (togLen === 0 || (s.isSliding && o.hideTogglerOnSlide)) {
\r
4114 $T.hide(); // always HIDE the toggler when 'sliding'
\r
4118 $T.show(); // in case was previously hidden
\r
4120 if (!(togLen > 0) || togLen === "100%" || togLen > paneLen) {
\r
4124 else { // calculate 'offset' based on options.PANE.togglerAlign_open/closed
\r
4125 if (isStr(togAlign)) {
\r
4126 switch (togAlign) {
\r
4128 case "left": offset = 0;
\r
4131 case "right": offset = paneLen - togLen;
\r
4135 default: offset = round((paneLen - togLen) / 2); // 'default' catches typos
\r
4138 else { // togAlign = number
\r
4139 var x = parseInt(togAlign, 10); //
\r
4140 if (togAlign >= 0) offset = x;
\r
4141 else offset = paneLen - togLen + x; // NOTE: x is negative!
\r
4145 if (dir === "horz") { // north/south
\r
4146 var width = cssW($T, togLen);
\r
4148 width: width // account for borders & padding
\r
4149 , height: cssH($T, spacing) // ditto
\r
4150 , left: offset // TODO: VERIFY that toggler positions correctly for ALL values
\r
4153 // CENTER the toggler content SPAN
\r
4154 $T.children(".content").each(function(){
\r
4156 $TC.css("marginLeft", round((width-$TC.outerWidth())/2)); // could be negative
\r
4159 else { // east/west
\r
4160 var height = cssH($T, togLen);
\r
4162 height: height // account for borders & padding
\r
4163 , width: cssW($T, spacing) // ditto
\r
4164 , top: offset // POSITION the toggler
\r
4167 // CENTER the toggler content SPAN
\r
4168 $T.children(".content").each(function(){
\r
4170 $TC.css("marginTop", round((height-$TC.outerHeight())/2)); // could be negative
\r
4174 // remove ALL hover classes
\r
4175 removeHover( 0, $T );
\r
4178 // DONE measuring and sizing this resizer/toggler, so can be 'hidden' now
\r
4179 if (!state.initialized && (o.initHidden || s.noRoom)) {
\r
4181 if ($T) $T.hide();
\r
4188 * @param {string} pane
\r
4190 , enableClosable = function (evt_or_pane) {
\r
4191 if (!isInitialized()) return;
\r
4192 var pane = evtPane.call(this, evt_or_pane)
\r
4194 , o = options[pane]
\r
4197 o.closable = true;
\r
4198 $T .bind("click."+ sID, function(evt){ evt.stopPropagation(); toggle(pane); })
\r
4199 .css("visibility", "visible")
\r
4200 .css("cursor", "pointer")
\r
4201 .attr("title", state[pane].isClosed ? o.togglerTip_closed : o.togglerTip_open) // may be blank
\r
4205 * @param {string} pane
\r
4206 * @param {boolean=} [hide=false]
\r
4208 , disableClosable = function (evt_or_pane, hide) {
\r
4209 if (!isInitialized()) return;
\r
4210 var pane = evtPane.call(this, evt_or_pane)
\r
4214 options[pane].closable = false;
\r
4215 // is closable is disable, then pane MUST be open!
\r
4216 if (state[pane].isClosed) open(pane, false, true);
\r
4217 $T .unbind("."+ sID)
\r
4218 .css("visibility", hide ? "hidden" : "visible") // instead of hide(), which creates logic issues
\r
4219 .css("cursor", "default")
\r
4220 .attr("title", "");
\r
4225 * @param {string} pane
\r
4227 , enableSlidable = function (evt_or_pane) {
\r
4228 if (!isInitialized()) return;
\r
4229 var pane = evtPane.call(this, evt_or_pane)
\r
4232 if (!$R || !$R.data('draggable')) return;
\r
4233 options[pane].slidable = true;
\r
4235 bindStartSlidingEvent(pane, true);
\r
4238 * @param {string} pane
\r
4240 , disableSlidable = function (evt_or_pane) {
\r
4241 if (!isInitialized()) return;
\r
4242 var pane = evtPane.call(this, evt_or_pane)
\r
4246 options[pane].slidable = false;
\r
4247 if (state[pane].isSliding)
\r
4248 close(pane, false, true);
\r
4250 bindStartSlidingEvent(pane, false);
\r
4251 $R .css("cursor", "default")
\r
4252 .attr("title", "");
\r
4253 removeHover(null, $R[0]); // in case currently hovered
\r
4259 * @param {string} pane
\r
4261 , enableResizable = function (evt_or_pane) {
\r
4262 if (!isInitialized()) return;
\r
4263 var pane = evtPane.call(this, evt_or_pane)
\r
4265 , o = options[pane]
\r
4267 if (!$R || !$R.data('draggable')) return;
\r
4268 o.resizable = true;
\r
4269 $R.draggable("enable");
\r
4270 if (!state[pane].isClosed)
\r
4271 $R .css("cursor", o.resizerCursor)
\r
4272 .attr("title", o.resizerTip);
\r
4275 * @param {string} pane
\r
4277 , disableResizable = function (evt_or_pane) {
\r
4278 if (!isInitialized()) return;
\r
4279 var pane = evtPane.call(this, evt_or_pane)
\r
4282 if (!$R || !$R.data('draggable')) return;
\r
4283 options[pane].resizable = false;
\r
4284 $R .draggable("disable")
\r
4285 .css("cursor", "default")
\r
4286 .attr("title", "");
\r
4287 removeHover(null, $R[0]); // in case currently hovered
\r
4292 * Move a pane from source-side (eg, west) to target-side (eg, east)
\r
4293 * If pane exists on target-side, move that to source-side, ie, 'swap' the panes
\r
4295 * @param {string} pane1 The pane/edge being swapped
\r
4296 * @param {string} pane2 ditto
\r
4298 , swapPanes = function (evt_or_pane1, pane2) {
\r
4299 if (!isInitialized()) return;
\r
4300 var pane1 = evtPane.call(this, evt_or_pane1);
\r
4301 // change state.edge NOW so callbacks can know where pane is headed...
\r
4302 state[pane1].edge = pane2;
\r
4303 state[pane2].edge = pane1;
\r
4304 // run these even if NOT state.initialized
\r
4305 if (false === _runCallbacks("onswap_start", pane1)
\r
4306 || false === _runCallbacks("onswap_start", pane2)
\r
4308 state[pane1].edge = pane1; // reset
\r
4309 state[pane2].edge = pane2;
\r
4314 oPane1 = copy( pane1 )
\r
4315 , oPane2 = copy( pane2 )
\r
4318 sizes[pane1] = oPane1 ? oPane1.state.size : 0;
\r
4319 sizes[pane2] = oPane2 ? oPane2.state.size : 0;
\r
4321 // clear pointers & state
\r
4322 $Ps[pane1] = false;
\r
4323 $Ps[pane2] = false;
\r
4324 state[pane1] = {};
\r
4325 state[pane2] = {};
\r
4327 // ALWAYS remove the resizer & toggler elements
\r
4328 if ($Ts[pane1]) $Ts[pane1].remove();
\r
4329 if ($Ts[pane2]) $Ts[pane2].remove();
\r
4330 if ($Rs[pane1]) $Rs[pane1].remove();
\r
4331 if ($Rs[pane2]) $Rs[pane2].remove();
\r
4332 $Rs[pane1] = $Rs[pane2] = $Ts[pane1] = $Ts[pane2] = false;
\r
4334 // transfer element pointers and data to NEW Layout keys
\r
4335 move( oPane1, pane2 );
\r
4336 move( oPane2, pane1 );
\r
4338 // cleanup objects
\r
4339 oPane1 = oPane2 = sizes = null;
\r
4341 // make panes 'visible' again
\r
4342 if ($Ps[pane1]) $Ps[pane1].css(_c.visible);
\r
4343 if ($Ps[pane2]) $Ps[pane2].css(_c.visible);
\r
4345 // fix any size discrepancies caused by swap
\r
4348 // run these even if NOT state.initialized
\r
4349 _runCallbacks("onswap_end", pane1);
\r
4350 _runCallbacks("onswap_end", pane2);
\r
4354 function copy (n) { // n = pane
\r
4359 return !$P ? false : {
\r
4361 , P: $P ? $P[0] : false
\r
4362 , C: $C ? $C[0] : false
\r
4363 , state: $.extend(true, {}, state[n])
\r
4364 , options: $.extend(true, {}, options[n])
\r
4368 function move (oPane, pane) {
\r
4369 if (!oPane) return;
\r
4373 , oldPane = oPane.pane
\r
4375 , side = c.side.toLowerCase()
\r
4376 , inset = "inset"+ c.side
\r
4377 // save pane-options that should be retained
\r
4378 , s = $.extend({}, state[pane])
\r
4379 , o = options[pane]
\r
4380 // RETAIN side-specific FX Settings - more below
\r
4381 , fx = { resizerCursor: o.resizerCursor }
\r
4384 $.each("fxName,fxSpeed,fxSettings".split(","), function (i, k) {
\r
4385 fx[k +"_open"] = o[k +"_open"];
\r
4386 fx[k +"_close"] = o[k +"_close"];
\r
4387 fx[k +"_size"] = o[k +"_size"];
\r
4390 // update object pointers and attributes
\r
4393 layoutPane: Instance[pane] // NEW pointer to pane-alias-object
\r
4394 , layoutEdge: pane
\r
4399 $Cs[pane] = C ? $(C) : false;
\r
4401 // set options and state
\r
4402 options[pane] = $.extend({}, oPane.options, fx);
\r
4403 state[pane] = $.extend({}, oPane.state);
\r
4405 // change classNames on the pane, eg: ui-layout-pane-east ==> ui-layout-pane-west
\r
4406 re = new RegExp(o.paneClass +"-"+ oldPane, "g");
\r
4407 P.className = P.className.replace(re, o.paneClass +"-"+ pane);
\r
4409 // ALWAYS regenerate the resizer & toggler elements
\r
4410 initHandles(pane); // create the required resizer & toggler
\r
4412 // if moving to different orientation, then keep 'target' pane size
\r
4413 if (c.dir != _c[oldPane].dir) {
\r
4414 size = sizes[pane] || 0;
\r
4415 setSizeLimits(pane); // update pane-state
\r
4416 size = max(size, state[pane].minSize);
\r
4417 // use manualSizePane to disable autoResize - not useful after panes are swapped
\r
4418 manualSizePane(pane, size, true, true); // true/true = skipCallback/noAnimation
\r
4420 else // move the resizer here
\r
4421 $Rs[pane].css(side, sC[inset] + (state[pane].isVisible ? getPaneSize(pane) : 0));
\r
4424 // ADD CLASSNAMES & SLIDE-BINDINGS
\r
4425 if (oPane.state.isVisible && !s.isVisible)
\r
4426 setAsOpen(pane, true); // true = skipCallback
\r
4428 setAsClosed(pane);
\r
4429 bindStartSlidingEvent(pane, true); // will enable events IF option is set
\r
4432 // DESTROY the object
\r
4439 * INTERNAL method to sync pin-buttons when pane is opened or closed
\r
4440 * Unpinned means the pane is 'sliding' - ie, over-top of the adjacent panes
\r
4442 * @see open(), setAsOpen(), setAsClosed()
\r
4443 * @param {string} pane These are the params returned to callbacks by layout()
\r
4444 * @param {boolean} doPin True means set the pin 'down', False means 'up'
\r
4446 , syncPinBtns = function (pane, doPin) {
\r
4447 if ($.layout.plugins.buttons)
\r
4448 $.each(state[pane].pins, function (i, selector) {
\r
4449 $.layout.buttons.setPinState(Instance, $(selector), pane, doPin);
\r
4453 ; // END var DECLARATIONS
\r
4456 * Capture keys when enableCursorHotkey - toggle pane if hotkey pressed
\r
4458 * @see document.keydown()
\r
4460 function keyDown (evt) {
\r
4461 if (!evt) return true;
\r
4462 var code = evt.keyCode;
\r
4463 if (code < 33) return true; // ignore special keys: ENTER, TAB, etc
\r
4467 38: "north" // Up Cursor - $.ui.keyCode.UP
\r
4468 , 40: "south" // Down Cursor - $.ui.keyCode.DOWN
\r
4469 , 37: "west" // Left Cursor - $.ui.keyCode.LEFT
\r
4470 , 39: "east" // Right Cursor - $.ui.keyCode.RIGHT
\r
4472 , ALT = evt.altKey // no worky!
\r
4473 , SHIFT = evt.shiftKey
\r
4474 , CTRL = evt.ctrlKey
\r
4475 , CURSOR = (CTRL && code >= 37 && code <= 40)
\r
4479 if (CURSOR && options[PANE[code]].enableCursorHotkey) // valid cursor-hotkey
\r
4480 pane = PANE[code];
\r
4481 else if (CTRL || SHIFT) // check to see if this matches a custom-hotkey
\r
4482 $.each(_c.borderPanes, function (i, p) { // loop each pane to check its hotkey
\r
4484 k = o.customHotkey;
\r
4485 m = o.customHotkeyModifier; // if missing or invalid, treated as "CTRL+SHIFT"
\r
4486 if ((SHIFT && m=="SHIFT") || (CTRL && m=="CTRL") || (CTRL && SHIFT)) { // Modifier matches
\r
4487 if (k && code === (isNaN(k) || k <= 9 ? k.toUpperCase().charCodeAt(0) : k)) { // Key matches
\r
4489 return false; // BREAK
\r
4495 if (!pane || !$Ps[pane] || !options[pane].closable || state[pane].isHidden)
\r
4500 evt.stopPropagation();
\r
4501 evt.returnValue = false; // CANCEL key
\r
4507 * ######################################
\r
4509 * called externally or by initButtons
\r
4510 * ######################################
\r
4514 * Change/reset a pane overflow setting & zIndex to allow popups/drop-downs to work
\r
4516 * @param {Object=} [el] (optional) Can also be 'bound' to a click, mouseOver, or other event
\r
4518 function allowOverflow (el) {
\r
4519 if (!isInitialized()) return;
\r
4520 if (this && this.tagName) el = this; // BOUND to element
\r
4524 else if ($(el).data("layoutRole"))
\r
4527 $(el).parents().each(function(){
\r
4528 if ($(this).data("layoutRole")) {
\r
4530 return false; // BREAK
\r
4533 if (!$P || !$P.length) return; // INVALID
\r
4536 pane = $P.data("layoutEdge")
\r
4540 // if pane is already raised, then reset it before doing it again!
\r
4541 // this would happen if allowOverflow is attached to BOTH the pane and an element
\r
4543 resetOverflow(pane); // reset previous CSS before continuing
\r
4545 // if pane is raised by sliding or resizing, or its closed, then abort
\r
4546 if (s.isSliding || s.isResizing || s.isClosed) {
\r
4547 s.cssSaved = false;
\r
4552 newCSS = { zIndex: (options.zIndexes.resizer_normal + 1) }
\r
4554 , of = $P.css("overflow")
\r
4555 , ofX = $P.css("overflowX")
\r
4556 , ofY = $P.css("overflowY")
\r
4558 // determine which, if any, overflow settings need to be changed
\r
4559 if (of != "visible") {
\r
4560 curCSS.overflow = of;
\r
4561 newCSS.overflow = "visible";
\r
4563 if (ofX && !ofX.match(/visible|auto/)) {
\r
4564 curCSS.overflowX = ofX;
\r
4565 newCSS.overflowX = "visible";
\r
4567 if (ofY && !ofY.match(/visible|auto/)) {
\r
4568 curCSS.overflowY = ofX;
\r
4569 newCSS.overflowY = "visible";
\r
4572 // save the current overflow settings - even if blank!
\r
4573 s.cssSaved = curCSS;
\r
4575 // apply new CSS to raise zIndex and, if necessary, make overflow 'visible'
\r
4578 // make sure the zIndex of all other panes is normal
\r
4579 $.each(_c.allPanes, function(i, p) {
\r
4580 if (p != pane) resetOverflow(p);
\r
4585 * @param {Object=} [el] (optional) Can also be 'bound' to a click, mouseOver, or other event
\r
4587 function resetOverflow (el) {
\r
4588 if (!isInitialized()) return;
\r
4589 if (this && this.tagName) el = this; // BOUND to element
\r
4593 else if ($(el).data("layoutRole"))
\r
4596 $(el).parents().each(function(){
\r
4597 if ($(this).data("layoutRole")) {
\r
4599 return false; // BREAK
\r
4602 if (!$P || !$P.length) return; // INVALID
\r
4605 pane = $P.data("layoutEdge")
\r
4607 , CSS = s.cssSaved || {}
\r
4609 // reset the zIndex
\r
4610 if (!s.isSliding && !s.isResizing)
\r
4611 $P.css("zIndex", options.zIndexes.pane_normal);
\r
4613 // reset Overflow - if necessary
\r
4617 s.cssSaved = false;
\r
4621 * #####################
\r
4622 * CREATE/RETURN LAYOUT
\r
4623 * #####################
\r
4626 // validate that container exists
\r
4627 var $N = $(this).eq(0); // FIRST matching Container element
\r
4629 if (options.showErrorMessages)
\r
4630 _log( lang.errContainerMissing, true );
\r
4634 // Users retrieve Instance of a layout with: $N.layout() OR $N.data("layout")
\r
4635 // return the Instance-pointer if layout has already been initialized
\r
4636 if ($N.data("layoutContainer") && $N.data("layout"))
\r
4637 return $N.data("layout"); // cached pointer
\r
4639 // init global vars
\r
4641 $Ps = {} // Panes x5 - set in initPanes()
\r
4642 , $Cs = {} // Content x5 - set in initPanes()
\r
4643 , $Rs = {} // Resizers x4 - set in initHandles()
\r
4644 , $Ts = {} // Togglers x4 - set in initHandles()
\r
4645 , $Ms = $([]) // Masks - up to 2 masks per pane (IFRAME + DIV)
\r
4646 // aliases for code brevity
\r
4647 , sC = state.container // alias for easy access to 'container dimensions'
\r
4648 , sID = state.id // alias for unique layout ID/namespace - eg: "layout435"
\r
4651 // create Instance object to expose data & option Properties, and primary action Methods
\r
4654 options: options // property - options hash
\r
4655 , state: state // property - dimensions hash
\r
4656 // object pointers
\r
4657 , container: $N // property - object pointers for layout container
\r
4658 , panes: $Ps // property - object pointers for ALL Panes: panes.north, panes.center
\r
4659 , contents: $Cs // property - object pointers for ALL Content: contents.north, contents.center
\r
4660 , resizers: $Rs // property - object pointers for ALL Resizers, eg: resizers.north
\r
4661 , togglers: $Ts // property - object pointers for ALL Togglers, eg: togglers.north
\r
4662 // border-pane open/close
\r
4663 , hide: hide // method - ditto
\r
4664 , show: show // method - ditto
\r
4665 , toggle: toggle // method - pass a 'pane' ("north", "west", etc)
\r
4666 , open: open // method - ditto
\r
4667 , close: close // method - ditto
\r
4668 , slideOpen: slideOpen // method - ditto
\r
4669 , slideClose: slideClose // method - ditto
\r
4670 , slideToggle: slideToggle // method - ditto
\r
4672 , setSizeLimits: setSizeLimits // method - pass a 'pane' - update state min/max data
\r
4673 , _sizePane: sizePane // method -intended for user by plugins only!
\r
4674 , sizePane: manualSizePane // method - pass a 'pane' AND an 'outer-size' in pixels or percent, or 'auto'
\r
4675 , sizeContent: sizeContent // method - pass a 'pane'
\r
4676 , swapPanes: swapPanes // method - pass TWO 'panes' - will swap them
\r
4677 // pane element methods
\r
4678 , initContent: initContent // method - ditto
\r
4679 , addPane: addPane // method - pass a 'pane'
\r
4680 , removePane: removePane // method - pass a 'pane' to remove from layout, add 'true' to delete the pane-elem
\r
4681 , createChildLayout: createChildLayout// method - pass a 'pane' and (optional) layout-options (OVERRIDES options[pane].childOptions
\r
4682 // special pane option setting
\r
4683 , enableClosable: enableClosable // method - pass a 'pane'
\r
4684 , disableClosable: disableClosable // method - ditto
\r
4685 , enableSlidable: enableSlidable // method - ditto
\r
4686 , disableSlidable: disableSlidable // method - ditto
\r
4687 , enableResizable: enableResizable // method - ditto
\r
4688 , disableResizable: disableResizable// method - ditto
\r
4689 // utility methods for panes
\r
4690 , allowOverflow: allowOverflow // utility - pass calling element (this)
\r
4691 , resetOverflow: resetOverflow // utility - ditto
\r
4693 , destroy: destroy // method - no parameters
\r
4694 , initPanes: isInitialized // method - no parameters
\r
4695 , resizeAll: resizeAll // method - no parameters
\r
4696 // callback triggering
\r
4697 , runCallbacks: _runCallbacks // method - pass evtName & pane (if a pane-event), eg: trigger("onopen", "west")
\r
4698 // alias collections of options, state and children - created in addPane and extended elsewhere
\r
4699 , hasParentLayout: false // set by initContainer()
\r
4700 , children: children // pointers to child-layouts, eg: Instance.children["west"]
\r
4701 , north: false // alias group: { name: pane, pane: $Ps[pane], options: options[pane], state: state[pane], child: children[pane] }
\r
4702 , south: false // ditto
\r
4703 , west: false // ditto
\r
4704 , east: false // ditto
\r
4705 , center: false // ditto
\r
4708 // create the border layout NOW
\r
4709 if (_create() === 'cancel') // onload_start callback returned false to CANCEL layout creation
\r
4711 else // true OR false -- if layout-elements did NOT init (hidden or do not exist), can auto-init later
\r
4712 return Instance; // return the Instance object
\r
4720 * jquery.layout.state 1.0
\r
4721 * $Date: 2011-07-16 08:00:00 (Sat, 16 July 2011) $
\r
4723 * Copyright (c) 2010
\r
4724 * Kevin Dalman (http://allpro.net)
\r
4726 * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
\r
4727 * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
\r
4729 * @dependancies: UI Layout 1.3.0.rc30.1 or higher
\r
4730 * @dependancies: $.ui.cookie (above)
\r
4732 * @support: http://groups.google.com/group/jquery-ui-layout
\r
4735 * State-management options stored in options.stateManagement, which includes a .cookie hash
\r
4736 * Default options saves ALL KEYS for ALL PANES, ie: pane.size, pane.isClosed, pane.isHidden
\r
4738 * // STATE/COOKIE OPTIONS
\r
4739 * @example $(el).layout({
\r
4740 stateManagement: {
\r
4742 , stateKeys: "east.size,west.size,east.isClosed,west.isClosed"
\r
4743 , cookie: { name: "appLayout", path: "/" }
\r
4746 * @example $(el).layout({ stateManagement__enabled: true }) // enable auto-state-management using cookies
\r
4747 * @example $(el).layout({ stateManagement__cookie: { name: "appLayout", path: "/" } })
\r
4748 * @example $(el).layout({ stateManagement__cookie__name: "appLayout", stateManagement__cookie__path: "/" })
\r
4750 * // STATE/COOKIE METHODS
\r
4751 * @example myLayout.saveCookie( "west.isClosed,north.size,south.isHidden", {expires: 7} );
\r
4752 * @example myLayout.loadCookie();
\r
4753 * @example myLayout.deleteCookie();
\r
4754 * @example var JSON = myLayout.readState(); // CURRENT Layout State
\r
4755 * @example var JSON = myLayout.readCookie(); // SAVED Layout State (from cookie)
\r
4756 * @example var JSON = myLayout.state.stateData; // LAST LOADED Layout State (cookie saved in layout.state hash)
\r
4758 * CUSTOM STATE-MANAGEMENT (eg, saved in a database)
\r
4759 * @example var JSON = myLayout.readState( "west.isClosed,north.size,south.isHidden" );
\r
4760 * @example myLayout.loadState( JSON );
\r
4764 * UI COOKIE UTILITY
\r
4766 * A $.cookie OR $.ui.cookie namespace *should be standard*, but until then...
\r
4767 * This creates $.ui.cookie so Layout does not need the cookie.jquery.js plugin
\r
4768 * NOTE: This utility is REQUIRED by the layout.state plugin
\r
4770 * Cookie methods in Layout are created as part of State Management
\r
4772 if (!$.ui) $.ui = {};
\r
4775 // cookieEnabled is not in DOM specs, but DOES works in all browsers,including IE6
\r
4776 acceptsCookies: !!navigator.cookieEnabled
\r
4778 , read: function (name) {
\r
4780 c = document.cookie
\r
4781 , cs = c ? c.split(';') : []
\r
4782 , pair // loop var
\r
4784 for (var i=0, n=cs.length; i < n; i++) {
\r
4785 pair = $.trim(cs[i]).split('='); // name=value pair
\r
4786 if (pair[0] == name) // found the layout cookie
\r
4787 return decodeURIComponent(pair[1]);
\r
4793 , write: function (name, val, cookieOpts) {
\r
4798 , o = cookieOpts || {}
\r
4801 if (x && x.toUTCString)
\r
4803 else if (x === null || typeof x === 'number') {
\r
4804 date = new Date();
\r
4806 date.setDate(date.getDate() + x);
\r
4808 date.setFullYear(1970);
\r
4812 if (date) params += ';expires='+ date.toUTCString();
\r
4813 if (o.path) params += ';path='+ o.path;
\r
4814 if (o.domain) params += ';domain='+ o.domain;
\r
4815 if (o.secure) params += ';secure';
\r
4816 document.cookie = name +'='+ (clear ? "" : encodeURIComponent( val )) + params; // write or clear cookie
\r
4819 , clear: function (name) {
\r
4820 $.ui.cookie.write(name, '', {expires: -1});
\r
4824 // if cookie.jquery.js is not loaded, create an alias to replicate it
\r
4825 // this may be useful to other plugins or code dependent on that plugin
\r
4826 if (!$.cookie) $.cookie = function (k, v, o) {
\r
4827 var C = $.ui.cookie;
\r
4830 else if (v === undefined)
\r
4837 // tell Layout that the state plugin is available
\r
4838 $.layout.plugins.stateManagement = true;
\r
4840 // Add State-Management options to layout.defaults
\r
4841 $.layout.config.optionRootKeys.push("stateManagement");
\r
4842 $.layout.defaults.stateManagement = {
\r
4843 enabled: false // true = enable state-management, even if not using cookies
\r
4844 , autoSave: true // Save a state-cookie when page exits?
\r
4845 , autoLoad: true // Load the state-cookie when Layout inits?
\r
4846 // List state-data to save - must be pane-specific
\r
4847 , stateKeys: "north.size,south.size,east.size,west.size,"+
\r
4848 "north.isClosed,south.isClosed,east.isClosed,west.isClosed,"+
\r
4849 "north.isHidden,south.isHidden,east.isHidden,west.isHidden"
\r
4851 name: "" // If not specified, will use Layout.name, else just "Layout"
\r
4852 , domain: "" // blank = current domain
\r
4853 , path: "" // blank = current page, '/' = entire website
\r
4854 , expires: "" // 'days' to keep cookie - leave blank for 'session cookie'
\r
4858 // Set stateManagement as a layout-option, NOT a pane-option
\r
4859 $.layout.optionsMap.layout.push("stateManagement");
\r
4862 * State Management methods
\r
4864 $.layout.state = {
\r
4867 * Get the current layout state and save it to a cookie
\r
4869 * myLayout.saveCookie( keys, cookieOpts )
\r
4871 * @param {Object} inst
\r
4872 * @param {(string|Array)=} keys
\r
4873 * @param {Object=} opts
\r
4875 saveCookie: function (inst, keys, cookieOpts) {
\r
4876 var o = inst.options
\r
4877 , oS = o.stateManagement
\r
4878 , oC = $.extend(true, {}, oS.cookie, cookieOpts || null)
\r
4879 , data = inst.state.stateData = inst.readState( keys || oS.stateKeys ) // read current panes-state
\r
4881 $.ui.cookie.write( oC.name || o.name || "Layout", $.layout.state.encodeJSON(data), oC );
\r
4882 return $.extend(true, {}, data); // return COPY of state.stateData data
\r
4886 * Remove the state cookie
\r
4888 * @param {Object} inst
\r
4890 , deleteCookie: function (inst) {
\r
4891 var o = inst.options;
\r
4892 $.ui.cookie.clear( o.stateManagement.cookie.name || o.name || "Layout" );
\r
4896 * Read & return data from the cookie - as JSON
\r
4898 * @param {Object} inst
\r
4900 , readCookie: function (inst) {
\r
4901 var o = inst.options;
\r
4902 var c = $.ui.cookie.read( o.stateManagement.cookie.name || o.name || "Layout" );
\r
4903 // convert cookie string back to a hash and return it
\r
4904 return c ? $.layout.state.decodeJSON(c) : {};
\r
4908 * Get data from the cookie and USE IT to loadState
\r
4910 * @param {Object} inst
\r
4912 , loadCookie: function (inst) {
\r
4913 var c = $.layout.state.readCookie(inst); // READ the cookie
\r
4915 inst.state.stateData = $.extend(true, {}, c); // SET state.stateData
\r
4916 inst.loadState(c); // LOAD the retrieved state
\r
4922 * Update layout options from the cookie, if one exists
\r
4924 * @param {Object} inst
\r
4925 * @param {Object=} stateData
\r
4926 * @param {boolean=} animate
\r
4928 , loadState: function (inst, stateData, animate) {
\r
4929 stateData = $.layout.transformData( stateData ); // panes = default subkey
\r
4930 if ($.isEmptyObject( stateData )) return;
\r
4931 $.extend(true, inst.options, stateData); // update layout options
\r
4932 // if layout has already been initialized, then UPDATE layout state
\r
4933 if (inst.state.initialized) {
\r
4934 var pane, vis, o, s, h, c
\r
4935 , noAnimate = (animate===false)
\r
4937 $.each($.layout.config.borderPanes, function (idx, pane) {
\r
4938 state = inst.state[pane];
\r
4939 o = stateData[ pane ];
\r
4940 if (typeof o != 'object') return; // no key, continue
\r
4944 vis = state.isVisible;
\r
4945 // resize BEFORE opening
\r
4947 inst.sizePane(pane, s, false, false);
\r
4948 if (h === true) inst.hide(pane, noAnimate);
\r
4949 else if (c === false) inst.open (pane, false, noAnimate);
\r
4950 else if (c === true) inst.close(pane, false, noAnimate);
\r
4951 else if (h === false) inst.show (pane, false, noAnimate);
\r
4952 // resize AFTER any other actions
\r
4954 inst.sizePane(pane, s, false, noAnimate); // animate resize if option passed
\r
4960 * Get the *current layout state* and return it as a hash
\r
4962 * @param {Object=} inst
\r
4963 * @param {(string|Array)=} keys
\r
4965 , readState: function (inst, keys) {
\r
4968 , alt = { isClosed: 'initClosed', isHidden: 'initHidden' }
\r
4969 , state = inst.state
\r
4970 , panes = $.layout.config.allPanes
\r
4971 , pair, pane, key, val
\r
4973 if (!keys) keys = inst.options.stateManagement.stateKeys; // if called by user
\r
4974 if ($.isArray(keys)) keys = keys.join(",");
\r
4975 // convert keys to an array and change delimiters from '__' to '.'
\r
4976 keys = keys.replace(/__/g, ".").split(',');
\r
4977 // loop keys and create a data hash
\r
4978 for (var i=0, n=keys.length; i < n; i++) {
\r
4979 pair = keys[i].split(".");
\r
4982 if ($.inArray(pane, panes) < 0) continue; // bad pane!
\r
4983 val = state[ pane ][ key ];
\r
4984 if (val == undefined) continue;
\r
4985 if (key=="isClosed" && state[pane]["isSliding"])
\r
4986 val = true; // if sliding, then *really* isClosed
\r
4987 ( data[pane] || (data[pane]={}) )[ alt[key] ? alt[key] : key ] = val;
\r
4993 * Stringify a JSON hash so can save in a cookie or db-field
\r
4995 , encodeJSON: function (JSON) {
\r
4996 return parse(JSON);
\r
4997 function parse (h) {
\r
4998 var D=[], i=0, k, v, t; // k = key, v = value
\r
5002 if (t == 'string') // STRING - add quotes
\r
5004 else if (t == 'object') // SUB-KEY - recurse into it
\r
5006 D[i++] = '"'+ k +'":'+ v;
\r
5008 return '{'+ D.join(',') +'}';
\r
5013 * Convert stringified JSON back to a hash object
\r
5014 * @see $.parseJSON(), adding in jQuery 1.4.1
\r
5016 , decodeJSON: function (str) {
\r
5017 try { return $.parseJSON ? $.parseJSON(str) : window["eval"]("("+ str +")") || {}; }
\r
5018 catch (e) { return {}; }
\r
5022 , _create: function (inst) {
\r
5023 var _ = $.layout.state;
\r
5024 // ADD State-Management plugin methods to inst
\r
5026 // readCookie - update options from cookie - returns hash of cookie data
\r
5027 readCookie: function () { return _.readCookie(inst); }
\r
5029 , deleteCookie: function () { _.deleteCookie(inst); }
\r
5030 // saveCookie - optionally pass keys-list and cookie-options (hash)
\r
5031 , saveCookie: function (keys, cookieOpts) { return _.saveCookie(inst, keys, cookieOpts); }
\r
5032 // loadCookie - readCookie and use to loadState() - returns hash of cookie data
\r
5033 , loadCookie: function () { return _.loadCookie(inst); }
\r
5034 // loadState - pass a hash of state to use to update options
\r
5035 , loadState: function (stateData, animate) { _.loadState(inst, stateData, animate); }
\r
5036 // readState - returns hash of current layout-state
\r
5037 , readState: function (keys) { return _.readState(inst, keys); }
\r
5038 // add JSON utility methods too...
\r
5039 , encodeJSON: _.encodeJSON
\r
5040 , decodeJSON: _.decodeJSON
\r
5043 // init state.stateData key, even if plugin is initially disabled
\r
5044 inst.state.stateData = {};
\r
5046 // read and load cookie-data per options
\r
5047 var oS = inst.options.stateManagement;
\r
5049 if (oS.autoLoad) // update the options from the cookie
\r
5050 inst.loadCookie();
\r
5051 else // don't modify options - just store cookie data in state.stateData
\r
5052 inst.state.stateData = inst.readCookie();
\r
5056 , _unload: function (inst) {
\r
5057 var oS = inst.options.stateManagement;
\r
5059 if (oS.autoSave) // save a state-cookie automatically
\r
5060 inst.saveCookie();
\r
5061 else // don't save a cookie, but do store state-data in state.stateData key
\r
5062 inst.state.stateData = inst.readState();
\r
5068 // add state initialization method to Layout's onCreate array of functions
\r
5069 $.layout.onCreate.push( $.layout.state._create );
\r
5070 $.layout.onUnload.push( $.layout.state._unload );
\r
5076 * jquery.layout.buttons 1.0
\r
5077 * $Date: 2011-07-16 08:00:00 (Sat, 16 July 2011) $
\r
5079 * Copyright (c) 2010
\r
5080 * Kevin Dalman (http://allpro.net)
\r
5082 * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
\r
5083 * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
\r
5085 * @dependancies: UI Layout 1.3.0.rc30.1 or higher
\r
5087 * @support: http://groups.google.com/group/jquery-ui-layout
\r
5089 * Docs: [ to come ]
\r
5090 * Tips: [ to come ]
\r
5093 // tell Layout that the state plugin is available
\r
5094 $.layout.plugins.buttons = true;
\r
5096 // Add buttons options to layout.defaults
\r
5097 $.layout.defaults.autoBindCustomButtons = false;
\r
5098 // Specify autoBindCustomButtons as a layout-option, NOT a pane-option
\r
5099 $.layout.optionsMap.layout.push("autoBindCustomButtons");
\r
5101 var lang = $.layout.language;
\r
5106 $.layout.buttons = {
\r
5109 * Searches for .ui-layout-button-xxx elements and auto-binds them as layout-buttons
\r
5113 * @param {Object} inst Layout Instance object
\r
5115 init: function (inst) {
\r
5116 var pre = "ui-layout-button-"
\r
5117 , layout = inst.options.name || ""
\r
5119 $.each("toggle,open,close,pin,toggle-slide,open-slide".split(","), function (i, action) {
\r
5120 $.each($.layout.config.borderPanes, function (ii, pane) {
\r
5121 $("."+pre+action+"-"+pane).each(function(){
\r
5122 // if button was previously 'bound', data.layoutName was set, but is blank if layout has no 'name'
\r
5123 name = $(this).data("layoutName") || $(this).attr("layoutName");
\r
5124 if (name == undefined || name === layout)
\r
5125 inst.bindButton(this, action, pane);
\r
5132 * Helper function to validate params received by addButton utilities
\r
5134 * Two classes are added to the element, based on the buttonClass...
\r
5135 * The type of button is appended to create the 2nd className:
\r
5136 * - ui-layout-button-pin // action btnClass
\r
5137 * - ui-layout-button-pin-west // action btnClass + pane
\r
5138 * - ui-layout-button-toggle
\r
5139 * - ui-layout-button-open
\r
5140 * - ui-layout-button-close
\r
5142 * @param {Object} inst Layout Instance object
\r
5143 * @param {(string|!Object)} selector jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
\r
5144 * @param {string} pane Name of the pane the button is for: 'north', 'south', etc.
\r
5146 * @return {Array.<Object>} If both params valid, the element matching 'selector' in a jQuery wrapper - otherwise returns null
\r
5148 , get: function (inst, selector, pane, action) {
\r
5149 var $E = $(selector)
\r
5150 , o = inst.options
\r
5151 , err = o.showErrorMessages
\r
5153 if (!$E.length) { // element not found
\r
5154 if (err) $.layout.msg(lang.errButton + lang.selector +": "+ selector, true);
\r
5156 else if ($.inArray(pane, $.layout.config.borderPanes) < 0) { // invalid 'pane' sepecified
\r
5157 if (err) $.layout.msg(lang.errButton + lang.pane +": "+ pane, true);
\r
5158 $E = $(""); // NO BUTTON
\r
5161 var btn = o[pane].buttonClass +"-"+ action;
\r
5162 $E .addClass( btn +" "+ btn +"-"+ pane )
\r
5163 .data("layoutName", o.name); // add layout identifier - even if blank!
\r
5170 * NEW syntax for binding layout-buttons - will eventually replace addToggle, addOpen, etc.
\r
5172 * @param {Object} inst Layout Instance object
\r
5173 * @param {(string|!Object)} selector jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
\r
5174 * @param {string} action
\r
5175 * @param {string} pane
\r
5177 , bind: function (inst, selector, action, pane) {
\r
5178 var _ = $.layout.buttons;
\r
5179 switch (action.toLowerCase()) {
\r
5180 case "toggle": _.addToggle (inst, selector, pane); break;
\r
5181 case "open": _.addOpen (inst, selector, pane); break;
\r
5182 case "close": _.addClose (inst, selector, pane); break;
\r
5183 case "pin": _.addPin (inst, selector, pane); break;
\r
5184 case "toggle-slide": _.addToggle (inst, selector, pane, true); break;
\r
5185 case "open-slide": _.addOpen (inst, selector, pane, true); break;
\r
5191 * Add a custom Toggler button for a pane
\r
5193 * @param {Object} inst Layout Instance object
\r
5194 * @param {(string|!Object)} selector jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
\r
5195 * @param {string} pane Name of the pane the button is for: 'north', 'south', etc.
\r
5196 * @param {boolean=} slide true = slide-open, false = pin-open
\r
5198 , addToggle: function (inst, selector, pane, slide) {
\r
5199 $.layout.buttons.get(inst, selector, pane, "toggle")
\r
5200 .click(function(evt){
\r
5201 inst.toggle(pane, !!slide);
\r
5202 evt.stopPropagation();
\r
5208 * Add a custom Open button for a pane
\r
5210 * @param {Object} inst Layout Instance object
\r
5211 * @param {(string|!Object)} selector jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
\r
5212 * @param {string} pane Name of the pane the button is for: 'north', 'south', etc.
\r
5213 * @param {boolean=} slide true = slide-open, false = pin-open
\r
5215 , addOpen: function (inst, selector, pane, slide) {
\r
5216 $.layout.buttons.get(inst, selector, pane, "open")
\r
5217 .attr("title", lang.Open)
\r
5218 .click(function (evt) {
\r
5219 inst.open(pane, !!slide);
\r
5220 evt.stopPropagation();
\r
5226 * Add a custom Close button for a pane
\r
5228 * @param {Object} inst Layout Instance object
\r
5229 * @param {(string|!Object)} selector jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
\r
5230 * @param {string} pane Name of the pane the button is for: 'north', 'south', etc.
\r
5232 , addClose: function (inst, selector, pane) {
\r
5233 $.layout.buttons.get(inst, selector, pane, "close")
\r
5234 .attr("title", lang.Close)
\r
5235 .click(function (evt) {
\r
5237 evt.stopPropagation();
\r
5243 * Add a custom Pin button for a pane
\r
5245 * Four classes are added to the element, based on the paneClass for the associated pane...
\r
5246 * Assuming the default paneClass and the pin is 'up', these classes are added for a west-pane pin:
\r
5247 * - ui-layout-pane-pin
\r
5248 * - ui-layout-pane-west-pin
\r
5249 * - ui-layout-pane-pin-up
\r
5250 * - ui-layout-pane-west-pin-up
\r
5252 * @param {Object} inst Layout Instance object
\r
5253 * @param {(string|!Object)} selector jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
\r
5254 * @param {string} pane Name of the pane the pin is for: 'north', 'south', etc.
\r
5256 , addPin: function (inst, selector, pane) {
\r
5257 var _ = $.layout.buttons
\r
5258 , $E = _.get(inst, selector, pane, "pin");
\r
5260 var s = inst.state[pane];
\r
5261 $E.click(function (evt) {
\r
5262 _.setPinState(inst, $(this), pane, (s.isSliding || s.isClosed));
\r
5263 if (s.isSliding || s.isClosed) inst.open( pane ); // change from sliding to open
\r
5264 else inst.close( pane ); // slide-closed
\r
5265 evt.stopPropagation();
\r
5267 // add up/down pin attributes and classes
\r
5268 _.setPinState(inst, $E, pane, (!s.isClosed && !s.isSliding));
\r
5269 // add this pin to the pane data so we can 'sync it' automatically
\r
5270 // PANE.pins key is an array so we can store multiple pins for each pane
\r
5271 s.pins.push( selector ); // just save the selector string
\r
5277 * Change the class of the pin button to make it look 'up' or 'down'
\r
5279 * @see addPin(), syncPins()
\r
5281 * @param {Object} inst Layout Instance object
\r
5282 * @param {Array.<Object>} $Pin The pin-span element in a jQuery wrapper
\r
5283 * @param {string} pane These are the params returned to callbacks by layout()
\r
5284 * @param {boolean} doPin true = set the pin 'down', false = set it 'up'
\r
5286 , setPinState: function (inst, $Pin, pane, doPin) {
\r
5287 var updown = $Pin.attr("pin");
\r
5288 if (updown && doPin === (updown=="down")) return; // already in correct state
\r
5290 pin = inst.options[pane].buttonClass +"-pin"
\r
5291 , side = pin +"-"+ pane
\r
5292 , UP = pin +"-up "+ side +"-up"
\r
5293 , DN = pin +"-down "+side +"-down"
\r
5296 .attr("pin", doPin ? "down" : "up") // logic
\r
5297 .attr("title", doPin ? lang.Unpin : lang.Pin)
\r
5298 .removeClass( doPin ? UP : DN )
\r
5299 .addClass( doPin ? DN : UP )
\r
5304 * INTERNAL function to sync 'pin buttons' when pane is opened or closed
\r
5305 * Unpinned means the pane is 'sliding' - ie, over-top of the adjacent panes
\r
5307 * @see open(), close()
\r
5309 * @param {Object} inst Layout Instance object
\r
5310 * @param {string} pane These are the params returned to callbacks by layout()
\r
5311 * @param {boolean} doPin True means set the pin 'down', False means 'up'
\r
5313 , syncPinBtns: function (inst, pane, doPin) {
\r
5314 // REAL METHOD IS _INSIDE_ LAYOUT - THIS IS HERE JUST FOR REFERENCE
\r
5315 $.each(state[pane].pins, function (i, selector) {
\r
5316 $.layout.buttons.setPinState(inst, $(selector), pane, doPin);
\r
5321 , _load: function (inst) {
\r
5322 var _ = $.layout.buttons;
\r
5323 // ADD Button methods to Layout Instance
\r
5324 // Note: sel = jQuery Selector string
\r
5326 bindButton: function (sel, action, pane) { return _.bind(inst, sel, action, pane); }
\r
5327 // DEPRECATED METHODS
\r
5328 , addToggleBtn: function (sel, pane, slide) { return _.addToggle(inst, sel, pane, slide); }
\r
5329 , addOpenBtn: function (sel, pane, slide) { return _.addOpen(inst, sel, pane, slide); }
\r
5330 , addCloseBtn: function (sel, pane) { return _.addClose(inst, sel, pane); }
\r
5331 , addPinBtn: function (sel, pane) { return _.addPin(inst, sel, pane); }
\r
5334 // init state array to hold pin-buttons
\r
5335 for (var i=0; i<4; i++) {
\r
5336 var pane = $.layout.config.borderPanes[i];
\r
5337 inst.state[pane].pins = [];
\r
5340 // auto-init buttons onLoad if option is enabled
\r
5341 if ( inst.options.autoBindCustomButtons )
\r
5345 , _unload: function (inst) {
\r
5346 // TODO: unbind all buttons???
\r
5351 // add initialization method to Layout's onLoad array of functions
\r
5352 $.layout.onLoad.push( $.layout.buttons._load );
\r
5353 //$.layout.onUnload.push( $.layout.buttons._unload );
\r
5358 * jquery.layout.browserZoom 1.0
\r
5359 * $Date: 2011-12-29 08:00:00 (Thu, 29 Dec 2011) $
\r
5361 * Copyright (c) 2012
\r
5362 * Kevin Dalman (http://allpro.net)
\r
5364 * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
\r
5365 * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
\r
5367 * @dependancies: UI Layout 1.3.0.rc30.1 or higher
\r
5369 * @support: http://groups.google.com/group/jquery-ui-layout
\r
5371 * @todo: Extend logic to handle other problematic zooming in browsers
\r
5372 * @todo: Add hotkey/mousewheel bindings to _instantly_ respond to these zoom event
\r
5375 // tell Layout that the plugin is available
\r
5376 $.layout.plugins.browserZoom = true;
\r
5378 $.layout.defaults.browserZoomCheckInterval = 1000;
\r
5379 $.layout.optionsMap.layout.push("browserZoomCheckInterval");
\r
5382 * browserZoom methods
\r
5384 $.layout.browserZoom = {
\r
5386 _init: function (inst) {
\r
5387 // abort if browser does not need this check
\r
5388 if ($.layout.browserZoom.ratio() !== false)
\r
5389 $.layout.browserZoom._setTimer(inst);
\r
5392 , _setTimer: function (inst) {
\r
5393 // abort if layout destroyed or browser does not need this check
\r
5394 if (inst.destroyed) return;
\r
5395 var o = inst.options
\r
5397 // don't need check if inst has parentLayout, but check occassionally in case parent destroyed!
\r
5398 // MINIMUM 100ms interval, for performance
\r
5399 , ms = inst.hasParentLayout ? 5000 : Math.max( o.browserZoomCheckInterval, 100 )
\r
5402 setTimeout(function(){
\r
5403 if (inst.destroyed || !o.resizeWithWindow) return;
\r
5404 var d = $.layout.browserZoom.ratio();
\r
5405 if (d !== s.browserZoom) {
\r
5406 s.browserZoom = d;
\r
5409 // set a NEW timeout
\r
5410 $.layout.browserZoom._setTimer(inst);
\r
5415 , ratio: function () {
\r
5419 , dE = d.documentElement || d.body
\r
5420 , b = $.layout.browser
\r
5424 // we can ignore all browsers that fire window.resize event onZoom
\r
5425 if ((b.msie && v > 8)
\r
5427 ) return false; // don't need to track zoom
\r
5430 return calc(s.deviceXDPI, s.systemXDPI);
\r
5431 // everything below is just for future reference!
\r
5432 if (b.webkit && (r = d.body.getBoundingClientRect))
\r
5433 return calc((r.left - r.right), d.body.offsetWidth);
\r
5434 if (b.webkit && (sW = w.outerWidth))
\r
5435 return calc(sW, w.innerWidth);
\r
5436 if ((sW = s.width) && (cW = dE.clientWidth))
\r
5437 return calc(sW, cW);
\r
5438 return false; // no match, so cannot - or don't need to - track zoom
\r
5440 function calc (x,y) { return (parseInt(x,10) / parseInt(y,10) * 100).toFixed(); }
\r
5444 // add initialization method to Layout's onLoad array of functions
\r
5445 $.layout.onReady.push( $.layout.browserZoom._init );
\r
projects / helm.git / blob