spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/tinymce/classes/fmt/Hooks.js

@@ -0,0 +1,66 @@
+/**
+ * Hooks.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2016 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Internal class for overriding formatting.
+ *
+ * @private
+ * @class tinymce.fmt.Hooks
+ */
+define("tinymce/fmt/Hooks", [
+	"tinymce/util/Arr",
+	"tinymce/dom/NodeType",
+	"tinymce/dom/DomQuery"
+], function(Arr, NodeType, $) {
+	var postProcessHooks = [], filter = Arr.filter, each = Arr.each;
+
+	function addPostProcessHook(name, hook) {
+		var hooks = postProcessHooks[name];
+
+		if (!hooks) {
+			postProcessHooks[name] = hooks = [];
+		}
+
+		postProcessHooks[name].push(hook);
+	}
+
+	function postProcess(name, editor) {
+		each(postProcessHooks[name], function(hook) {
+			hook(editor);
+		});
+	}
+
+	addPostProcessHook("pre", function(editor) {
+		var rng = editor.selection.getRng(), isPre, blocks;
+
+		function hasPreSibling(pre) {
+			return isPre(pre.previousSibling) && Arr.indexOf(blocks, pre.previousSibling) != -1;
+		}
+
+		function joinPre(pre1, pre2) {
+			$(pre2).remove();
+			$(pre1).append('<br><br>').append(pre2.childNodes);
+		}
+
+		isPre = NodeType.matchNodeNames('pre');
+
+		if (!rng.collapsed) {
+			blocks = editor.selection.getSelectedBlocks();
+
+			each(filter(filter(blocks, isPre), hasPreSibling), function(pre) {
+				joinPre(pre.previousSibling, pre);
+			});
+		}
+	});
+
+	return {
+		postProcess: postProcess
+	};
+});

data/apps/core/components/public/js/tinymce/classes/fmt/Preview.js

@@ -0,0 +1,151 @@
+/**
+ * Preview.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
+ */
+
+/**
+ * Internal class for generating previews styles for formats.
+ *
+ * Example:
+ *  Preview.getCssText(editor, 'bold');
+ *
+ * @private
+ * @class tinymce.fmt.Preview
+ */
+define("tinymce/fmt/Preview", [
+	"tinymce/util/Tools"
+], function(Tools) {
+	var each = Tools.each;
+
+	function getCssText(editor, format) {
+		var name, previewElm, dom = editor.dom;
+		var previewCss = '', parentFontSize, previewStyles;
+
+		previewStyles = editor.settings.preview_styles;
+
+		// No preview forced
+		if (previewStyles === false) {
+			return '';
+		}
+
+		// Default preview
+		if (!previewStyles) {
+			previewStyles = 'font-family font-size font-weight font-style text-decoration ' +
+				'text-transform color background-color border border-radius outline text-shadow';
+		}
+
+		// Removes any variables since these can't be previewed
+		function removeVars(val) {
+			return val.replace(/%(\w+)/g, '');
+		}
+
+		// Create block/inline element to use for preview
+		if (typeof format == "string") {
+			format = editor.formatter.get(format);
+			if (!format) {
+				return;
+			}
+
+			format = format[0];
+		}
+
+		name = format.block || format.inline || 'span';
+		previewElm = dom.create(name);
+
+		// Add format styles to preview element
+		each(format.styles, function(value, name) {
+			value = removeVars(value);
+
+			if (value) {
+				dom.setStyle(previewElm, name, value);
+			}
+		});
+
+		// Add attributes to preview element
+		each(format.attributes, function(value, name) {
+			value = removeVars(value);
+
+			if (value) {
+				dom.setAttrib(previewElm, name, value);
+			}
+		});
+
+		// Add classes to preview element
+		each(format.classes, function(value) {
+			value = removeVars(value);
+
+			if (!dom.hasClass(previewElm, value)) {
+				dom.addClass(previewElm, value);
+			}
+		});
+
+		editor.fire('PreviewFormats');
+
+		// Add the previewElm outside the visual area
+		dom.setStyles(previewElm, {position: 'absolute', left: -0xFFFF});
+		editor.getBody().appendChild(previewElm);
+
+		// Get parent container font size so we can compute px values out of em/% for older IE:s
+		parentFontSize = dom.getStyle(editor.getBody(), 'fontSize', true);
+		parentFontSize = /px$/.test(parentFontSize) ? parseInt(parentFontSize, 10) : 0;
+
+		each(previewStyles.split(' '), function(name) {
+			var value = dom.getStyle(previewElm, name, true);
+
+			// If background is transparent then check if the body has a background color we can use
+			if (name == 'background-color' && /transparent|rgba\s*\([^)]+,\s*0\)/.test(value)) {
+				value = dom.getStyle(editor.getBody(), name, true);
+
+				// Ignore white since it's the default color, not the nicest fix
+				// TODO: Fix this by detecting runtime style
+				if (dom.toHex(value).toLowerCase() == '#ffffff') {
+					return;
+				}
+			}
+
+			if (name == 'color') {
+				// Ignore black since it's the default color, not the nicest fix
+				// TODO: Fix this by detecting runtime style
+				if (dom.toHex(value).toLowerCase() == '#000000') {
+					return;
+				}
+			}
+
+			// Old IE won't calculate the font size so we need to do that manually
+			if (name == 'font-size') {
+				if (/em|%$/.test(value)) {
+					if (parentFontSize === 0) {
+						return;
+					}
+
+					// Convert font size from em/% to px
+					value = parseFloat(value, 10) / (/%$/.test(value) ? 100 : 1);
+					value = (value * parentFontSize) + 'px';
+				}
+			}
+
+			if (name == "border" && value) {
+				previewCss += 'padding:0 2px;';
+			}
+
+			previewCss += name + ':' + value + ';';
+		});
+
+		editor.fire('AfterPreviewFormats');
+
+		//previewCss += 'line-height:normal';
+
+		dom.remove(previewElm);
+
+		return previewCss;
+	}
+
+	return {
+		getCssText: getCssText
+	};
+});

data/apps/core/components/public/js/tinymce/classes/geom/ClientRect.js

@@ -0,0 +1,136 @@
+/**
+ * ClientRect.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
+ */
+
+/**
+ * Utility functions for working with client rects.
+ *
+ * @private
+ * @class tinymce.geom.ClientRect
+ */
+define("tinymce/geom/ClientRect", [], function() {
+	var round = Math.round;
+
+	function clone(rect) {
+		if (!rect) {
+			return {left: 0, top: 0, bottom: 0, right: 0, width: 0, height: 0};
+		}
+
+		return {
+			left: round(rect.left),
+			top: round(rect.top),
+			bottom: round(rect.bottom),
+			right: round(rect.right),
+			width: round(rect.width),
+			height: round(rect.height)
+		};
+	}
+
+	function collapse(clientRect, toStart) {
+		clientRect = clone(clientRect);
+
+		if (toStart) {
+			clientRect.right = clientRect.left;
+		} else {
+			clientRect.left = clientRect.left + clientRect.width;
+			clientRect.right = clientRect.left;
+		}
+
+		clientRect.width = 0;
+
+		return clientRect;
+	}
+
+	function isEqual(rect1, rect2) {
+		return (
+			rect1.left === rect2.left &&
+			rect1.top === rect2.top &&
+			rect1.bottom === rect2.bottom &&
+			rect1.right === rect2.right
+		);
+	}
+
+	function isValidOverflow(overflowY, clientRect1, clientRect2) {
+		return overflowY >= 0 && overflowY <= Math.min(clientRect1.height, clientRect2.height) / 2;
+
+	}
+
+	function isAbove(clientRect1, clientRect2) {
+		if (clientRect1.bottom < clientRect2.top) {
+			return true;
+		}
+
+		if (clientRect1.top > clientRect2.bottom) {
+			return false;
+		}
+
+		return isValidOverflow(clientRect2.top - clientRect1.bottom, clientRect1, clientRect2);
+	}
+
+	function isBelow(clientRect1, clientRect2) {
+		if (clientRect1.top > clientRect2.bottom) {
+			return true;
+		}
+
+		if (clientRect1.bottom < clientRect2.top) {
+			return false;
+		}
+
+		return isValidOverflow(clientRect2.bottom - clientRect1.top, clientRect1, clientRect2);
+	}
+
+	function isLeft(clientRect1, clientRect2) {
+		return clientRect1.left < clientRect2.left;
+	}
+
+	function isRight(clientRect1, clientRect2) {
+		return clientRect1.right > clientRect2.right;
+	}
+
+	function compare(clientRect1, clientRect2) {
+		if (isAbove(clientRect1, clientRect2)) {
+			return -1;
+		}
+
+		if (isBelow(clientRect1, clientRect2)) {
+			return 1;
+		}
+
+		if (isLeft(clientRect1, clientRect2)) {
+			return -1;
+		}
+
+		if (isRight(clientRect1, clientRect2)) {
+			return 1;
+		}
+
+		return 0;
+	}
+
+	function containsXY(clientRect, clientX, clientY) {
+		return (
+			clientX >= clientRect.left &&
+			clientX <= clientRect.right &&
+			clientY >= clientRect.top &&
+			clientY <= clientRect.bottom
+		);
+	}
+
+	return {
+		clone: clone,
+		collapse: collapse,
+		isEqual: isEqual,
+		isAbove: isAbove,
+		isBelow: isBelow,
+		isLeft: isLeft,
+		isRight: isRight,
+		compare: compare,
+		containsXY: containsXY
+	};
+});

data/apps/core/components/public/js/tinymce/classes/geom/Rect.js

@@ -0,0 +1,214 @@
+/**
+ * Rect.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
+ */
+
+/**
+ * Contains various tools for rect/position calculation.
+ *
+ * @class tinymce.geom.Rect
+ */
+define("tinymce/geom/Rect", [
+], function() {
+	"use strict";
+
+	var min = Math.min, max = Math.max, round = Math.round;
+
+	/**
+	 * Returns the rect positioned based on the relative position name
+	 * to the target rect.
+	 *
+	 * @method relativePosition
+	 * @param {Rect} rect Source rect to modify into a new rect.
+	 * @param {Rect} targetRect Rect to move relative to based on the rel option.
+	 * @param {String} rel Relative position. For example: tr-bl.
+	 */
+	function relativePosition(rect, targetRect, rel) {
+		var x, y, w, h, targetW, targetH;
+
+		x = targetRect.x;
+		y = targetRect.y;
+		w = rect.w;
+		h = rect.h;
+		targetW = targetRect.w;
+		targetH = targetRect.h;
+
+		rel = (rel || '').split('');
+
+		if (rel[0] === 'b') {
+			y += targetH;
+		}
+
+		if (rel[1] === 'r') {
+			x += targetW;
+		}
+
+		if (rel[0] === 'c') {
+			y += round(targetH / 2);
+		}
+
+		if (rel[1] === 'c') {
+			x += round(targetW / 2);
+		}
+
+		if (rel[3] === 'b') {
+			y -= h;
+		}
+
+		if (rel[4] === 'r') {
+			x -= w;
+		}
+
+		if (rel[3] === 'c') {
+			y -= round(h / 2);
+		}
+
+		if (rel[4] === 'c') {
+			x -= round(w / 2);
+		}
+
+		return create(x, y, w, h);
+	}
+
+	/**
+	 * Tests various positions to get the most suitable one.
+	 *
+	 * @method findBestRelativePosition
+	 * @param {Rect} rect Rect to use as source.
+	 * @param {Rect} targetRect Rect to move relative to.
+	 * @param {Rect} constrainRect Rect to constrain within.
+	 * @param {Array} rels Array of relative positions to test against.
+	 */
+	function findBestRelativePosition(rect, targetRect, constrainRect, rels) {
+		var pos, i;
+
+		for (i = 0; i < rels.length; i++) {
+			pos = relativePosition(rect, targetRect, rels[i]);
+
+			if (pos.x >= constrainRect.x && pos.x + pos.w <= constrainRect.w + constrainRect.x &&
+				pos.y >= constrainRect.y && pos.y + pos.h <= constrainRect.h + constrainRect.y) {
+				return rels[i];
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Inflates the rect in all directions.
+	 *
+	 * @method inflate
+	 * @param {Rect} rect Rect to expand.
+	 * @param {Number} w Relative width to expand by.
+	 * @param {Number} h Relative height to expand by.
+	 * @return {Rect} New expanded rect.
+	 */
+	function inflate(rect, w, h) {
+		return create(rect.x - w, rect.y - h, rect.w + w * 2, rect.h + h * 2);
+	}
+
+	/**
+	 * Returns the intersection of the specified rectangles.
+	 *
+	 * @method intersect
+	 * @param {Rect} rect The first rectangle to compare.
+	 * @param {Rect} cropRect The second rectangle to compare.
+	 * @return {Rect} The intersection of the two rectangles or null if they don't intersect.
+	 */
+	function intersect(rect, cropRect) {
+		var x1, y1, x2, y2;
+
+		x1 = max(rect.x, cropRect.x);
+		y1 = max(rect.y, cropRect.y);
+		x2 = min(rect.x + rect.w, cropRect.x + cropRect.w);
+		y2 = min(rect.y + rect.h, cropRect.y + cropRect.h);
+
+		if (x2 - x1 < 0 || y2 - y1 < 0) {
+			return null;
+		}
+
+		return create(x1, y1, x2 - x1, y2 - y1);
+	}
+
+	/**
+	 * Returns a rect clamped within the specified clamp rect. This forces the
+	 * rect to be inside the clamp rect.
+	 *
+	 * @method clamp
+	 * @param {Rect} rect Rectangle to force within clamp rect.
+	 * @param {Rect} clampRect Rectable to force within.
+	 * @param {Boolean} fixedSize True/false if size should be fixed.
+	 * @return {Rect} Clamped rect.
+	 */
+	function clamp(rect, clampRect, fixedSize) {
+		var underflowX1, underflowY1, overflowX2, overflowY2,
+			x1, y1, x2, y2, cx2, cy2;
+
+		x1 = rect.x;
+		y1 = rect.y;
+		x2 = rect.x + rect.w;
+		y2 = rect.y + rect.h;
+		cx2 = clampRect.x + clampRect.w;
+		cy2 = clampRect.y + clampRect.h;
+
+		underflowX1 = max(0, clampRect.x - x1);
+		underflowY1 = max(0, clampRect.y - y1);
+		overflowX2 = max(0, x2 - cx2);
+		overflowY2 = max(0, y2 - cy2);
+
+		x1 += underflowX1;
+		y1 += underflowY1;
+
+		if (fixedSize) {
+			x2 += underflowX1;
+			y2 += underflowY1;
+			x1 -= overflowX2;
+			y1 -= overflowY2;
+		}
+
+		x2 -= overflowX2;
+		y2 -= overflowY2;
+
+		return create(x1, y1, x2 - x1, y2 - y1);
+	}
+
+	/**
+	 * Creates a new rectangle object.
+	 *
+	 * @method create
+	 * @param {Number} x Rectangle x location.
+	 * @param {Number} y Rectangle y location.
+	 * @param {Number} w Rectangle width.
+	 * @param {Number} h Rectangle height.
+	 * @return {Rect} New rectangle object.
+	 */
+	function create(x, y, w, h) {
+		return {x: x, y: y, w: w, h: h};
+	}
+
+	/**
+	 * Creates a new rectangle object form a clientRects object.
+	 *
+	 * @method fromClientRect
+	 * @param {ClientRect} clientRect DOM ClientRect object.
+	 * @return {Rect} New rectangle object.
+	 */
+	function fromClientRect(clientRect) {
+		return create(clientRect.left, clientRect.top, clientRect.width, clientRect.height);
+	}
+
+	return {
+		inflate: inflate,
+		relativePosition: relativePosition,
+		findBestRelativePosition: findBestRelativePosition,
+		intersect: intersect,
+		clamp: clamp,
+		create: create,
+		fromClientRect: fromClientRect
+	};
+});