spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/tinymce/classes/ui/FilePicker.js

@@ -0,0 +1,85 @@
+/**
+ * FilePicker.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/*global tinymce:true */
+
+/**
+ * This class creates a file picker control.
+ *
+ * @class tinymce.ui.FilePicker
+ * @extends tinymce.ui.ComboBox
+ */
+define("tinymce/ui/FilePicker", [
+	"tinymce/ui/ComboBox",
+	"tinymce/util/Tools"
+], function(ComboBox, Tools) {
+	"use strict";
+
+	return ComboBox.extend({
+		/**
+		 * Constructs a new control instance with the specified settings.
+		 *
+		 * @constructor
+		 * @param {Object} settings Name/value object with settings.
+		 */
+		init: function(settings) {
+			var self = this, editor = tinymce.activeEditor, editorSettings = editor.settings;
+			var actionCallback, fileBrowserCallback, fileBrowserCallbackTypes;
+
+			settings.spellcheck = false;
+
+			fileBrowserCallbackTypes = editorSettings.file_picker_types || editorSettings.file_browser_callback_types;
+			if (fileBrowserCallbackTypes) {
+				fileBrowserCallbackTypes = Tools.makeMap(fileBrowserCallbackTypes, /[, ]/);
+			}
+
+			if (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[settings.filetype]) {
+				fileBrowserCallback = editorSettings.file_picker_callback;
+				if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[settings.filetype])) {
+					actionCallback = function() {
+						var meta = self.fire('beforecall').meta;
+
+						meta = Tools.extend({filetype: settings.filetype}, meta);
+
+						// file_picker_callback(callback, currentValue, metaData)
+						fileBrowserCallback.call(
+							editor,
+							function(value, meta) {
+								self.value(value).fire('change', {meta: meta});
+							},
+							self.value(),
+							meta
+						);
+					};
+				} else {
+					// Legacy callback: file_picker_callback(id, currentValue, filetype, window)
+					fileBrowserCallback = editorSettings.file_browser_callback;
+					if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[settings.filetype])) {
+						actionCallback = function() {
+							fileBrowserCallback(
+								self.getEl('inp').id,
+								self.value(),
+								settings.filetype,
+								window
+							);
+						};
+					}
+				}
+			}
+
+			if (actionCallback) {
+				settings.icon = 'browse';
+				settings.onaction = actionCallback;
+			}
+
+			self._super(settings);
+		}
+	});
+});

data/apps/core/components/public/js/tinymce/classes/ui/FitLayout.js

@@ -0,0 +1,48 @@
+/**
+ * FitLayout.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This layout manager will resize the control to be the size of it's parent container.
+ * In other words width: 100% and height: 100%.
+ *
+ * @-x-less FitLayout.less
+ * @class tinymce.ui.FitLayout
+ * @extends tinymce.ui.AbsoluteLayout
+ */
+define("tinymce/ui/FitLayout", [
+	"tinymce/ui/AbsoluteLayout"
+], function(AbsoluteLayout) {
+	"use strict";
+
+	return AbsoluteLayout.extend({
+		/**
+		 * Recalculates the positions of the controls in the specified container.
+		 *
+		 * @method recalc
+		 * @param {tinymce.ui.Container} container Container instance to recalc.
+		 */
+		recalc: function(container) {
+			var contLayoutRect = container.layoutRect(), paddingBox = container.paddingBox;
+
+			container.items().filter(':visible').each(function(ctrl) {
+				ctrl.layoutRect({
+					x: paddingBox.left,
+					y: paddingBox.top,
+					w: contLayoutRect.innerW - paddingBox.right - paddingBox.left,
+					h: contLayoutRect.innerH - paddingBox.top - paddingBox.bottom
+				});
+
+				if (ctrl.recalc) {
+					ctrl.recalc();
+				}
+			});
+		}
+	});
+});

data/apps/core/components/public/js/tinymce/classes/ui/FlexLayout.js

@@ -0,0 +1,246 @@
+/**
+ * FlexLayout.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This layout manager works similar to the CSS flex box.
+ *
+ * @setting {String} direction row|row-reverse|column|column-reverse
+ * @setting {Number} flex A positive-number to flex by.
+ * @setting {String} align start|end|center|stretch
+ * @setting {String} pack start|end|justify
+ *
+ * @class tinymce.ui.FlexLayout
+ * @extends tinymce.ui.AbsoluteLayout
+ */
+define("tinymce/ui/FlexLayout", [
+	"tinymce/ui/AbsoluteLayout"
+], function(AbsoluteLayout) {
+	"use strict";
+
+	return AbsoluteLayout.extend({
+		/**
+		 * Recalculates the positions of the controls in the specified container.
+		 *
+		 * @method recalc
+		 * @param {tinymce.ui.Container} container Container instance to recalc.
+		 */
+		recalc: function(container) {
+			// A ton of variables, needs to be in the same scope for performance
+			var i, l, items, contLayoutRect, contPaddingBox, contSettings, align, pack, spacing, totalFlex, availableSpace, direction;
+			var ctrl, ctrlLayoutRect, ctrlSettings, flex, maxSizeItems = [], size, maxSize, ratio, rect, pos, maxAlignEndPos;
+			var sizeName, minSizeName, posName, maxSizeName, beforeName, innerSizeName, deltaSizeName, contentSizeName;
+			var alignAxisName, alignInnerSizeName, alignSizeName, alignMinSizeName, alignBeforeName, alignAfterName;
+			var alignDeltaSizeName, alignContentSizeName;
+			var max = Math.max, min = Math.min;
+
+			// Get container items, properties and settings
+			items = container.items().filter(':visible');
+			contLayoutRect = container.layoutRect();
+			contPaddingBox = container.paddingBox;
+			contSettings = container.settings;
+			direction = container.isRtl() ? (contSettings.direction || 'row-reversed') : contSettings.direction;
+			align = contSettings.align;
+			pack = container.isRtl() ? (contSettings.pack || 'end') : contSettings.pack;
+			spacing = contSettings.spacing || 0;
+
+			if (direction == "row-reversed" || direction == "column-reverse") {
+				items = items.set(items.toArray().reverse());
+				direction = direction.split('-')[0];
+			}
+
+			// Setup axis variable name for row/column direction since the calculations is the same
+			if (direction == "column") {
+				posName = "y";
+				sizeName = "h";
+				minSizeName = "minH";
+				maxSizeName = "maxH";
+				innerSizeName = "innerH";
+				beforeName = 'top';
+				deltaSizeName = "deltaH";
+				contentSizeName = "contentH";
+
+				alignBeforeName = "left";
+				alignSizeName = "w";
+				alignAxisName = "x";
+				alignInnerSizeName = "innerW";
+				alignMinSizeName = "minW";
+				alignAfterName = "right";
+				alignDeltaSizeName = "deltaW";
+				alignContentSizeName = "contentW";
+			} else {
+				posName = "x";
+				sizeName = "w";
+				minSizeName = "minW";
+				maxSizeName = "maxW";
+				innerSizeName = "innerW";
+				beforeName = 'left';
+				deltaSizeName = "deltaW";
+				contentSizeName = "contentW";
+
+				alignBeforeName = "top";
+				alignSizeName = "h";
+				alignAxisName = "y";
+				alignInnerSizeName = "innerH";
+				alignMinSizeName = "minH";
+				alignAfterName = "bottom";
+				alignDeltaSizeName = "deltaH";
+				alignContentSizeName = "contentH";
+			}
+
+			// Figure out total flex, availableSpace and collect any max size elements
+			availableSpace = contLayoutRect[innerSizeName] - contPaddingBox[beforeName] - contPaddingBox[beforeName];
+			maxAlignEndPos = totalFlex = 0;
+			for (i = 0, l = items.length; i < l; i++) {
+				ctrl = items[i];
+				ctrlLayoutRect = ctrl.layoutRect();
+				ctrlSettings = ctrl.settings;
+				flex = ctrlSettings.flex;
+				availableSpace -= (i < l - 1 ? spacing : 0);
+
+				if (flex > 0) {
+					totalFlex += flex;
+
+					// Flexed item has a max size then we need to check if we will hit that size
+					if (ctrlLayoutRect[maxSizeName]) {
+						maxSizeItems.push(ctrl);
+					}
+
+					ctrlLayoutRect.flex = flex;
+				}
+
+				availableSpace -= ctrlLayoutRect[minSizeName];
+
+				// Calculate the align end position to be used to check for overflow/underflow
+				size = contPaddingBox[alignBeforeName] + ctrlLayoutRect[alignMinSizeName] + contPaddingBox[alignAfterName];
+				if (size > maxAlignEndPos) {
+					maxAlignEndPos = size;
+				}
+			}
+
+			// Calculate minW/minH
+			rect = {};
+			if (availableSpace < 0) {
+				rect[minSizeName] = contLayoutRect[minSizeName] - availableSpace + contLayoutRect[deltaSizeName];
+			} else {
+				rect[minSizeName] = contLayoutRect[innerSizeName] - availableSpace + contLayoutRect[deltaSizeName];
+			}
+
+			rect[alignMinSizeName] = maxAlignEndPos + contLayoutRect[alignDeltaSizeName];
+
+			rect[contentSizeName] = contLayoutRect[innerSizeName] - availableSpace;
+			rect[alignContentSizeName] = maxAlignEndPos;
+			rect.minW = min(rect.minW, contLayoutRect.maxW);
+			rect.minH = min(rect.minH, contLayoutRect.maxH);
+			rect.minW = max(rect.minW, contLayoutRect.startMinWidth);
+			rect.minH = max(rect.minH, contLayoutRect.startMinHeight);
+
+			// Resize container container if minSize was changed
+			if (contLayoutRect.autoResize && (rect.minW != contLayoutRect.minW || rect.minH != contLayoutRect.minH)) {
+				rect.w = rect.minW;
+				rect.h = rect.minH;
+
+				container.layoutRect(rect);
+				this.recalc(container);
+
+				// Forced recalc for example if items are hidden/shown
+				if (container._lastRect === null) {
+					var parentCtrl = container.parent();
+					if (parentCtrl) {
+						parentCtrl._lastRect = null;
+						parentCtrl.recalc();
+					}
+				}
+
+				return;
+			}
+
+			// Handle max size elements, check if they will become to wide with current options
+			ratio = availableSpace / totalFlex;
+			for (i = 0, l = maxSizeItems.length; i < l; i++) {
+				ctrl = maxSizeItems[i];
+				ctrlLayoutRect = ctrl.layoutRect();
+				maxSize = ctrlLayoutRect[maxSizeName];
+				size = ctrlLayoutRect[minSizeName] + ctrlLayoutRect.flex * ratio;
+
+				if (size > maxSize) {
+					availableSpace -= (ctrlLayoutRect[maxSizeName] - ctrlLayoutRect[minSizeName]);
+					totalFlex -= ctrlLayoutRect.flex;
+					ctrlLayoutRect.flex = 0;
+					ctrlLayoutRect.maxFlexSize = maxSize;
+				} else {
+					ctrlLayoutRect.maxFlexSize = 0;
+				}
+			}
+
+			// Setup new ratio, target layout rect, start position
+			ratio = availableSpace / totalFlex;
+			pos = contPaddingBox[beforeName];
+			rect = {};
+
+			// Handle pack setting moves the start position to end, center
+			if (totalFlex === 0) {
+				if (pack == "end") {
+					pos = availableSpace + contPaddingBox[beforeName];
+				} else if (pack == "center") {
+					pos = Math.round(
+						(contLayoutRect[innerSizeName] / 2) - ((contLayoutRect[innerSizeName] - availableSpace) / 2)
+					) + contPaddingBox[beforeName];
+
+					if (pos < 0) {
+						pos = contPaddingBox[beforeName];
+					}
+				} else if (pack == "justify") {
+					pos = contPaddingBox[beforeName];
+					spacing = Math.floor(availableSpace / (items.length - 1));
+				}
+			}
+
+			// Default aligning (start) the other ones needs to be calculated while doing the layout
+			rect[alignAxisName] = contPaddingBox[alignBeforeName];
+
+			// Start laying out controls
+			for (i = 0, l = items.length; i < l; i++) {
+				ctrl = items[i];
+				ctrlLayoutRect = ctrl.layoutRect();
+				size = ctrlLayoutRect.maxFlexSize || ctrlLayoutRect[minSizeName];
+
+				// Align the control on the other axis
+				if (align === "center") {
+					rect[alignAxisName] = Math.round((contLayoutRect[alignInnerSizeName] / 2) - (ctrlLayoutRect[alignSizeName] / 2));
+				} else if (align === "stretch") {
+					rect[alignSizeName] = max(
+						ctrlLayoutRect[alignMinSizeName] || 0,
+						contLayoutRect[alignInnerSizeName] - contPaddingBox[alignBeforeName] - contPaddingBox[alignAfterName]
+					);
+					rect[alignAxisName] = contPaddingBox[alignBeforeName];
+				} else if (align === "end") {
+					rect[alignAxisName] = contLayoutRect[alignInnerSizeName] - ctrlLayoutRect[alignSizeName] - contPaddingBox.top;
+				}
+
+				// Calculate new size based on flex
+				if (ctrlLayoutRect.flex > 0) {
+					size += ctrlLayoutRect.flex * ratio;
+				}
+
+				rect[sizeName] = size;
+				rect[posName] = pos;
+				ctrl.layoutRect(rect);
+
+				// Recalculate containers
+				if (ctrl.recalc) {
+					ctrl.recalc();
+				}
+
+				// Move x/y position
+				pos += size + spacing;
+			}
+		}
+	});
+});

data/apps/core/components/public/js/tinymce/classes/ui/FloatPanel.js

@@ -0,0 +1,409 @@
+/**
+ * FloatPanel.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class creates a floating panel.
+ *
+ * @-x-less FloatPanel.less
+ * @class tinymce.ui.FloatPanel
+ * @extends tinymce.ui.Panel
+ * @mixes tinymce.ui.Movable
+ * @mixes tinymce.ui.Resizable
+ */
+define("tinymce/ui/FloatPanel", [
+	"tinymce/ui/Panel",
+	"tinymce/ui/Movable",
+	"tinymce/ui/Resizable",
+	"tinymce/ui/DomUtils",
+	"tinymce/dom/DomQuery",
+	"tinymce/util/Delay"
+], function(Panel, Movable, Resizable, DomUtils, $, Delay) {
+	"use strict";
+
+	var documentClickHandler, documentScrollHandler, windowResizeHandler, visiblePanels = [];
+	var zOrder = [], hasModal;
+
+	function isChildOf(ctrl, parent) {
+		while (ctrl) {
+			if (ctrl == parent) {
+				return true;
+			}
+
+			ctrl = ctrl.parent();
+		}
+	}
+
+	function skipOrHidePanels(e) {
+		// Hide any float panel when a click/focus out is out side that float panel and the
+		// float panels direct parent for example a click on a menu button
+		var i = visiblePanels.length;
+
+		while (i--) {
+			var panel = visiblePanels[i], clickCtrl = panel.getParentCtrl(e.target);
+
+			if (panel.settings.autohide) {
+				if (clickCtrl) {
+					if (isChildOf(clickCtrl, panel) || panel.parent() === clickCtrl) {
+						continue;
+					}
+				}
+
+				e = panel.fire('autohide', {target: e.target});
+				if (!e.isDefaultPrevented()) {
+					panel.hide();
+				}
+			}
+		}
+	}
+
+	function bindDocumentClickHandler() {
+
+		if (!documentClickHandler) {
+			documentClickHandler = function(e) {
+				// Gecko fires click event and in the wrong order on Mac so lets normalize
+				if (e.button == 2) {
+					return;
+				}
+
+				skipOrHidePanels(e);
+			};
+
+			$(document).on('click touchstart', documentClickHandler);
+		}
+	}
+
+	function bindDocumentScrollHandler() {
+		if (!documentScrollHandler) {
+			documentScrollHandler = function() {
+				var i;
+
+				i = visiblePanels.length;
+				while (i--) {
+					repositionPanel(visiblePanels[i]);
+				}
+			};
+
+			$(window).on('scroll', documentScrollHandler);
+		}
+	}
+
+	function bindWindowResizeHandler() {
+		if (!windowResizeHandler) {
+			var docElm = document.documentElement, clientWidth = docElm.clientWidth, clientHeight = docElm.clientHeight;
+
+			windowResizeHandler = function() {
+				// Workaround for #7065 IE 7 fires resize events event though the window wasn't resized
+				if (!document.all || clientWidth != docElm.clientWidth || clientHeight != docElm.clientHeight) {
+					clientWidth = docElm.clientWidth;
+					clientHeight = docElm.clientHeight;
+					FloatPanel.hideAll();
+				}
+			};
+
+			$(window).on('resize', windowResizeHandler);
+		}
+	}
+
+	/**
+	 * Repositions the panel to the top of page if the panel is outside of the visual viewport. It will
+	 * also reposition all child panels of the current panel.
+	 */
+	function repositionPanel(panel) {
+		var scrollY = DomUtils.getViewPort().y;
+
+		function toggleFixedChildPanels(fixed, deltaY) {
+			var parent;
+
+			for (var i = 0; i < visiblePanels.length; i++) {
+				if (visiblePanels[i] != panel) {
+					parent = visiblePanels[i].parent();
+
+					while (parent && (parent = parent.parent())) {
+						if (parent == panel) {
+							visiblePanels[i].fixed(fixed).moveBy(0, deltaY).repaint();
+						}
+					}
+				}
+			}
+		}
+
+		if (panel.settings.autofix) {
+			if (!panel.state.get('fixed')) {
+				panel._autoFixY = panel.layoutRect().y;
+
+				if (panel._autoFixY < scrollY) {
+					panel.fixed(true).layoutRect({y: 0}).repaint();
+					toggleFixedChildPanels(true, scrollY - panel._autoFixY);
+				}
+			} else {
+				if (panel._autoFixY > scrollY) {
+					panel.fixed(false).layoutRect({y: panel._autoFixY}).repaint();
+					toggleFixedChildPanels(false, panel._autoFixY - scrollY);
+				}
+			}
+		}
+	}
+
+	function addRemove(add, ctrl) {
+		var i, zIndex = FloatPanel.zIndex || 0xFFFF, topModal;
+
+		if (add) {
+			zOrder.push(ctrl);
+		} else {
+			i = zOrder.length;
+
+			while (i--) {
+				if (zOrder[i] === ctrl) {
+					zOrder.splice(i, 1);
+				}
+			}
+		}
+
+		if (zOrder.length) {
+			for (i = 0; i < zOrder.length; i++) {
+				if (zOrder[i].modal) {
+					zIndex++;
+					topModal = zOrder[i];
+				}
+
+				zOrder[i].getEl().style.zIndex = zIndex;
+				zOrder[i].zIndex = zIndex;
+				zIndex++;
+			}
+		}
+
+		var modalBlockEl = $('#' + ctrl.classPrefix + 'modal-block', ctrl.getContainerElm())[0];
+
+		if (topModal) {
+			$(modalBlockEl).css('z-index', topModal.zIndex - 1);
+		} else if (modalBlockEl) {
+			modalBlockEl.parentNode.removeChild(modalBlockEl);
+			hasModal = false;
+		}
+
+		FloatPanel.currentZIndex = zIndex;
+	}
+
+	var FloatPanel = Panel.extend({
+		Mixins: [Movable, Resizable],
+
+		/**
+		 * Constructs a new control instance with the specified settings.
+		 *
+		 * @constructor
+		 * @param {Object} settings Name/value object with settings.
+		 * @setting {Boolean} autohide Automatically hide the panel.
+		 */
+		init: function(settings) {
+			var self = this;
+
+			self._super(settings);
+			self._eventsRoot = self;
+
+			self.classes.add('floatpanel');
+
+			// Hide floatpanes on click out side the root button
+			if (settings.autohide) {
+				bindDocumentClickHandler();
+				bindWindowResizeHandler();
+				visiblePanels.push(self);
+			}
+
+			if (settings.autofix) {
+				bindDocumentScrollHandler();
+
+				self.on('move', function() {
+					repositionPanel(this);
+				});
+			}
+
+			self.on('postrender show', function(e) {
+				if (e.control == self) {
+					var $modalBlockEl, prefix = self.classPrefix;
+
+					if (self.modal && !hasModal) {
+						$modalBlockEl = $('#' + prefix + 'modal-block', self.getContainerElm());
+						if (!$modalBlockEl[0]) {
+							$modalBlockEl = $(
+								'<div id="' + prefix + 'modal-block" class="' + prefix + 'reset ' + prefix + 'fade"></div>'
+							).appendTo(self.getContainerElm());
+						}
+
+						Delay.setTimeout(function() {
+							$modalBlockEl.addClass(prefix + 'in');
+							$(self.getEl()).addClass(prefix + 'in');
+						});
+
+						hasModal = true;
+					}
+
+					addRemove(true, self);
+				}
+			});
+
+			self.on('show', function() {
+				self.parents().each(function(ctrl) {
+					if (ctrl.state.get('fixed')) {
+						self.fixed(true);
+						return false;
+					}
+				});
+			});
+
+			if (settings.popover) {
+				self._preBodyHtml = '<div class="' + self.classPrefix + 'arrow"></div>';
+				self.classes.add('popover').add('bottom').add(self.isRtl() ? 'end' : 'start');
+			}
+		},
+
+		fixed: function(state) {
+			var self = this;
+
+			if (self.state.get('fixed') != state) {
+				if (self.state.get('rendered')) {
+					var viewport = DomUtils.getViewPort();
+
+					if (state) {
+						self.layoutRect().y -= viewport.y;
+					} else {
+						self.layoutRect().y += viewport.y;
+					}
+				}
+
+				self.classes.toggle('fixed', state);
+				self.state.set('fixed', state);
+			}
+
+			return self;
+		},
+
+		/**
+		 * Shows the current float panel.
+		 *
+		 * @method show
+		 * @return {tinymce.ui.FloatPanel} Current floatpanel instance.
+		 */
+		show: function() {
+			var self = this, i, state = self._super();
+
+			i = visiblePanels.length;
+			while (i--) {
+				if (visiblePanels[i] === self) {
+					break;
+				}
+			}
+
+			if (i === -1) {
+				visiblePanels.push(self);
+			}
+
+			return state;
+		},
+
+		/**
+		 * Hides the current float panel.
+		 *
+		 * @method hide
+		 * @return {tinymce.ui.FloatPanel} Current floatpanel instance.
+		 */
+		hide: function() {
+			removeVisiblePanel(this);
+			addRemove(false, this);
+
+			return this._super();
+		},
+
+		/**
+		 * Hide all visible float panels with he autohide setting enabled. This is for
+		 * manually hiding floating menus or panels.
+		 *
+		 * @method hideAll
+		 */
+		hideAll: function() {
+			FloatPanel.hideAll();
+		},
+
+		/**
+		 * Closes the float panel. This will remove the float panel from page and fire the close event.
+		 *
+		 * @method close
+		 */
+		close: function() {
+			var self = this;
+
+			if (!self.fire('close').isDefaultPrevented()) {
+				self.remove();
+				addRemove(false, self);
+			}
+
+			return self;
+		},
+
+		/**
+		 * Removes the float panel from page.
+		 *
+		 * @method remove
+		 */
+		remove: function() {
+			removeVisiblePanel(this);
+			this._super();
+		},
+
+		postRender: function() {
+			var self = this;
+
+			if (self.settings.bodyRole) {
+				this.getEl('body').setAttribute('role', self.settings.bodyRole);
+			}
+
+			return self._super();
+		}
+	});
+
+	/**
+	 * Hide all visible float panels with he autohide setting enabled. This is for
+	 * manually hiding floating menus or panels.
+	 *
+	 * @static
+	 * @method hideAll
+	 */
+	FloatPanel.hideAll = function() {
+		var i = visiblePanels.length;
+
+		while (i--) {
+			var panel = visiblePanels[i];
+
+			if (panel && panel.settings.autohide) {
+				panel.hide();
+				visiblePanels.splice(i, 1);
+			}
+		}
+	};
+
+	function removeVisiblePanel(panel) {
+		var i;
+
+		i = visiblePanels.length;
+		while (i--) {
+			if (visiblePanels[i] === panel) {
+				visiblePanels.splice(i, 1);
+			}
+		}
+
+		i = zOrder.length;
+		while (i--) {
+			if (zOrder[i] === panel) {
+				zOrder.splice(i, 1);
+			}
+		}
+	}
+
+	return FloatPanel;
+});