spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/tinymce/classes/caret/FakeCaret.js

@@ -0,0 +1,192 @@
+/**
+ * FakeCaret.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 module contains logic for rendering a fake visual caret.
+ *
+ * @private
+ * @class tinymce.caret.FakeCaret
+ */
+define("tinymce/caret/FakeCaret", [
+	"tinymce/caret/CaretContainer",
+	"tinymce/caret/CaretPosition",
+	"tinymce/dom/NodeType",
+	"tinymce/dom/RangeUtils",
+	"tinymce/dom/DomQuery",
+	"tinymce/geom/ClientRect",
+	"tinymce/util/Delay"
+], function(CaretContainer, CaretPosition, NodeType, RangeUtils, $, ClientRect, Delay) {
+	var isContentEditableFalse = NodeType.isContentEditableFalse;
+
+	return function(rootNode, isBlock) {
+		var cursorInterval, $lastVisualCaret, caretContainerNode;
+
+		function getAbsoluteClientRect(node, before) {
+			var clientRect = ClientRect.collapse(node.getBoundingClientRect(), before),
+				docElm, scrollX, scrollY, margin, rootRect;
+
+			if (rootNode.tagName == 'BODY') {
+				docElm = rootNode.ownerDocument.documentElement;
+				scrollX = rootNode.scrollLeft || docElm.scrollLeft;
+				scrollY = rootNode.scrollTop || docElm.scrollTop;
+			} else {
+				rootRect = rootNode.getBoundingClientRect();
+				scrollX = rootNode.scrollLeft - rootRect.left;
+				scrollY = rootNode.scrollTop - rootRect.top;
+			}
+
+			clientRect.left += scrollX;
+			clientRect.right += scrollX;
+			clientRect.top += scrollY;
+			clientRect.bottom += scrollY;
+			clientRect.width = 1;
+
+			margin = node.offsetWidth - node.clientWidth;
+
+			if (margin > 0) {
+				if (before) {
+					margin *= -1;
+				}
+
+				clientRect.left += margin;
+				clientRect.right += margin;
+			}
+
+			return clientRect;
+		}
+
+		function trimInlineCaretContainers() {
+			var contentEditableFalseNodes, node, sibling, i, data;
+
+			contentEditableFalseNodes = $('*[contentEditable=false]', rootNode);
+			for (i = 0; i < contentEditableFalseNodes.length; i++) {
+				node = contentEditableFalseNodes[i];
+
+				sibling = node.previousSibling;
+				if (CaretContainer.endsWithCaretContainer(sibling)) {
+					data = sibling.data;
+
+					if (data.length == 1) {
+						sibling.parentNode.removeChild(sibling);
+					} else {
+						sibling.deleteData(data.length - 1, 1);
+					}
+				}
+
+				sibling = node.nextSibling;
+				if (CaretContainer.startsWithCaretContainer(sibling)) {
+					data = sibling.data;
+
+					if (data.length == 1) {
+						sibling.parentNode.removeChild(sibling);
+					} else {
+						sibling.deleteData(0, 1);
+					}
+				}
+			}
+
+			return null;
+		}
+
+		function show(before, node) {
+			var clientRect, rng, container;
+
+			hide();
+
+			if (isBlock(node)) {
+				caretContainerNode = CaretContainer.insertBlock('p', node, before);
+				clientRect = getAbsoluteClientRect(node, before);
+				$(caretContainerNode).css('top', clientRect.top);
+
+				$lastVisualCaret = $('<div class="mce-visual-caret" data-mce-bogus="all"></div>').css(clientRect).appendTo(rootNode);
+
+				if (before) {
+					$lastVisualCaret.addClass('mce-visual-caret-before');
+				}
+
+				startBlink();
+
+				rng = node.ownerDocument.createRange();
+				container = caretContainerNode.firstChild;
+				rng.setStart(container, 0);
+				rng.setEnd(container, 1);
+			} else {
+				caretContainerNode = CaretContainer.insertInline(node, before);
+				rng = node.ownerDocument.createRange();
+
+				if (isContentEditableFalse(caretContainerNode.nextSibling)) {
+					rng.setStart(caretContainerNode, 0);
+					rng.setEnd(caretContainerNode, 0);
+				} else {
+					rng.setStart(caretContainerNode, 1);
+					rng.setEnd(caretContainerNode, 1);
+				}
+
+				return rng;
+			}
+
+			return rng;
+		}
+
+		function hide() {
+			trimInlineCaretContainers();
+
+			if (caretContainerNode) {
+				CaretContainer.remove(caretContainerNode);
+				caretContainerNode = null;
+			}
+
+			if ($lastVisualCaret) {
+				$lastVisualCaret.remove();
+				$lastVisualCaret = null;
+			}
+
+			clearInterval(cursorInterval);
+		}
+
+		function startBlink() {
+			cursorInterval = Delay.setInterval(function() {
+				$('div.mce-visual-caret', rootNode).toggleClass('mce-visual-caret-hidden');
+			}, 500);
+		}
+
+		function destroy() {
+			Delay.clearInterval(cursorInterval);
+		}
+
+		function getCss() {
+			return (
+				'.mce-visual-caret {' +
+					'position: absolute;' +
+					'background-color: black;' +
+					'background-color: currentcolor;' +
+				'}' +
+				'.mce-visual-caret-hidden {' +
+					'display: none;' +
+				'}' +
+				'*[data-mce-caret] {' +
+					'position: absolute;' +
+					'left: -1000px;' +
+					'right: auto;' +
+					'top: 0;' +
+					'margin: 0;' +
+					'padding: 0;' +
+				'}'
+			);
+		}
+
+		return {
+			show: show,
+			hide: hide,
+			getCss: getCss,
+			destroy: destroy
+		};
+	};
+});

data/apps/core/components/public/js/tinymce/classes/caret/LineUtils.js

@@ -0,0 +1,135 @@
+/**
+ * LineUtils.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 lines.
+ *
+ * @private
+ * @class tinymce.caret.LineUtils
+ */
+define("tinymce/caret/LineUtils", [
+	"tinymce/util/Fun",
+	"tinymce/util/Arr",
+	"tinymce/dom/NodeType",
+	"tinymce/dom/Dimensions",
+	"tinymce/geom/ClientRect",
+	"tinymce/caret/CaretUtils",
+	"tinymce/caret/CaretCandidate"
+], function(Fun, Arr, NodeType, Dimensions, ClientRect, CaretUtils, CaretCandidate) {
+	var isContentEditableFalse = NodeType.isContentEditableFalse,
+		findNode = CaretUtils.findNode,
+		curry = Fun.curry;
+
+	function distanceToRectLeft(clientRect, clientX) {
+		return Math.abs(clientRect.left - clientX);
+	}
+
+	function distanceToRectRight(clientRect, clientX) {
+		return Math.abs(clientRect.right - clientX);
+	}
+
+	function findClosestClientRect(clientRects, clientX) {
+		function isInside(clientX, clientRect) {
+			return clientX >= clientRect.left && clientX <= clientRect.right;
+		}
+
+		return Arr.reduce(clientRects, function(oldClientRect, clientRect) {
+			var oldDistance, newDistance;
+
+			oldDistance = Math.min(distanceToRectLeft(oldClientRect, clientX), distanceToRectRight(oldClientRect, clientX));
+			newDistance = Math.min(distanceToRectLeft(clientRect, clientX), distanceToRectRight(clientRect, clientX));
+
+			if (isInside(clientX, clientRect)) {
+				return clientRect;
+			}
+
+			if (isInside(clientX, oldClientRect)) {
+				return oldClientRect;
+			}
+
+			// cE=false has higher priority
+			if (newDistance == oldDistance && isContentEditableFalse(clientRect.node)) {
+				return clientRect;
+			}
+
+			if (newDistance < oldDistance) {
+				return clientRect;
+			}
+
+			return oldClientRect;
+		});
+	}
+
+	function walkUntil(direction, rootNode, predicateFn, node) {
+		while ((node = findNode(node, direction, CaretCandidate.isEditableCaretCandidate, rootNode))) {
+			if (predicateFn(node)) {
+				return;
+			}
+		}
+	}
+
+	function findLineNodeRects(rootNode, targetNodeRect) {
+		var clientRects = [];
+
+		function collect(checkPosFn, node) {
+			var lineRects;
+
+			lineRects = Arr.filter(Dimensions.getClientRects(node), function(clientRect) {
+				return !checkPosFn(clientRect, targetNodeRect);
+			});
+
+			clientRects = clientRects.concat(lineRects);
+
+			return lineRects.length === 0;
+		}
+
+		clientRects.push(targetNodeRect);
+		walkUntil(-1, rootNode, curry(collect, ClientRect.isAbove), targetNodeRect.node);
+		walkUntil(1, rootNode, curry(collect, ClientRect.isBelow), targetNodeRect.node);
+
+		return clientRects;
+	}
+
+	function getContentEditableFalseChildren(rootNode) {
+		return Arr.filter(Arr.toArray(rootNode.getElementsByTagName('*')), isContentEditableFalse);
+	}
+
+	function caretInfo(clientRect, clientX) {
+		return {
+			node: clientRect.node,
+			before: distanceToRectLeft(clientRect, clientX) < distanceToRectRight(clientRect, clientX)
+		};
+	}
+
+	function closestCaret(rootNode, clientX, clientY) {
+		var contentEditableFalseNodeRects, closestNodeRect;
+
+		contentEditableFalseNodeRects = Dimensions.getClientRects(getContentEditableFalseChildren(rootNode));
+		contentEditableFalseNodeRects = Arr.filter(contentEditableFalseNodeRects, function(clientRect) {
+			return clientY >= clientRect.top && clientY <= clientRect.bottom;
+		});
+
+		closestNodeRect = findClosestClientRect(contentEditableFalseNodeRects, clientX);
+		if (closestNodeRect) {
+			closestNodeRect = findClosestClientRect(findLineNodeRects(rootNode, closestNodeRect), clientX);
+			if (closestNodeRect && isContentEditableFalse(closestNodeRect.node)) {
+				return caretInfo(closestNodeRect, clientX);
+			}
+		}
+
+		return null;
+	}
+
+	return {
+		findClosestClientRect: findClosestClientRect,
+		findLineNodeRects: findLineNodeRects,
+		closestCaret: closestCaret
+	};
+});

data/apps/core/components/public/js/tinymce/classes/caret/LineWalker.js

@@ -0,0 +1,166 @@
+/**
+ * LineWalker.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 module lets you walk the document line by line
+ * returing nodes and client rects for each line.
+ *
+ * @private
+ * @class tinymce.caret.LineWalker
+ */
+define("tinymce/caret/LineWalker", [
+	"tinymce/util/Fun",
+	"tinymce/util/Arr",
+	"tinymce/dom/Dimensions",
+	"tinymce/caret/CaretCandidate",
+	"tinymce/caret/CaretUtils",
+	"tinymce/caret/CaretWalker",
+	"tinymce/caret/CaretPosition",
+	"tinymce/geom/ClientRect"
+], function(Fun, Arr, Dimensions, CaretCandidate, CaretUtils, CaretWalker, CaretPosition, ClientRect) {
+	var curry = Fun.curry;
+
+	function findUntil(direction, rootNode, predicateFn, node) {
+		while ((node = CaretUtils.findNode(node, direction, CaretCandidate.isEditableCaretCandidate, rootNode))) {
+			if (predicateFn(node)) {
+				return;
+			}
+		}
+	}
+
+	function walkUntil(direction, isAboveFn, isBeflowFn, rootNode, predicateFn, caretPosition) {
+		var line = 0, node, result = [], targetClientRect;
+
+		function add(node) {
+			var i, clientRect, clientRects;
+
+			clientRects = Dimensions.getClientRects(node);
+			if (direction == -1) {
+				clientRects = clientRects.reverse();
+			}
+
+			for (i = 0; i < clientRects.length; i++) {
+				clientRect = clientRects[i];
+				if (isBeflowFn(clientRect, targetClientRect)) {
+					continue;
+				}
+
+				if (result.length > 0 && isAboveFn(clientRect, Arr.last(result))) {
+					line++;
+				}
+
+				clientRect.line = line;
+
+				if (predicateFn(clientRect)) {
+					return true;
+				}
+
+				result.push(clientRect);
+			}
+		}
+
+		targetClientRect = Arr.last(caretPosition.getClientRects());
+		if (!targetClientRect) {
+			return result;
+		}
+
+		node = caretPosition.getNode();
+		add(node);
+		findUntil(direction, rootNode, add, node);
+
+		return result;
+	}
+
+	function aboveLineNumber(lineNumber, clientRect) {
+		return clientRect.line > lineNumber;
+	}
+
+	function isLine(lineNumber, clientRect) {
+		return clientRect.line === lineNumber;
+	}
+
+	var upUntil = curry(walkUntil, -1, ClientRect.isAbove, ClientRect.isBelow);
+	var downUntil = curry(walkUntil, 1, ClientRect.isBelow, ClientRect.isAbove);
+
+	function positionsUntil(direction, rootNode, predicateFn, node) {
+		var caretWalker = new CaretWalker(rootNode), walkFn, isBelowFn, isAboveFn,
+			caretPosition, result = [], line = 0, clientRect, targetClientRect;
+
+		function getClientRect(caretPosition) {
+			if (direction == 1) {
+				return Arr.last(caretPosition.getClientRects());
+			}
+
+			return Arr.last(caretPosition.getClientRects());
+		}
+
+		if (direction == 1) {
+			walkFn = caretWalker.next;
+			isBelowFn = ClientRect.isBelow;
+			isAboveFn = ClientRect.isAbove;
+			caretPosition = CaretPosition.after(node);
+		} else {
+			walkFn = caretWalker.prev;
+			isBelowFn = ClientRect.isAbove;
+			isAboveFn = ClientRect.isBelow;
+			caretPosition = CaretPosition.before(node);
+		}
+
+		targetClientRect = getClientRect(caretPosition);
+
+		do {
+			if (!caretPosition.isVisible()) {
+				continue;
+			}
+
+			clientRect = getClientRect(caretPosition);
+
+			if (isAboveFn(clientRect, targetClientRect)) {
+				continue;
+			}
+
+			if (result.length > 0 && isBelowFn(clientRect, Arr.last(result))) {
+				line++;
+			}
+
+			clientRect = ClientRect.clone(clientRect);
+			clientRect.position = caretPosition;
+			clientRect.line = line;
+
+			if (predicateFn(clientRect)) {
+				return result;
+			}
+
+			result.push(clientRect);
+		} while ((caretPosition = walkFn(caretPosition)));
+
+		return result;
+	}
+
+	return {
+		upUntil: upUntil,
+		downUntil: downUntil,
+
+		/**
+		 * Find client rects with line and caret position until the predicate returns true.
+		 *
+		 * @method positionsUntil
+		 * @param {Number} direction Direction forward/backward 1/-1.
+		 * @param {DOMNode} rootNode Root node to walk within.
+		 * @param {function} predicateFn Gets the client rect as it's input.
+		 * @param {DOMNode} node Node to start walking from.
+		 * @return {Array} Array of client rects with line and position properties.
+		 */
+		positionsUntil: positionsUntil,
+
+		isAboveLine: curry(aboveLineNumber),
+		isLine: curry(isLine)
+	};
+});