Mini Shell
/**
* Class Applier module for Rangy.
* Adds, removes and toggles classes on Ranges and Selections
*
* Part of Rangy, a cross-browser JavaScript range and selection library
* http://code.google.com/p/rangy/
*
* Depends on Rangy core.
*
* Copyright 2013, Tim Down
* Licensed under the MIT license.
* Version: 1.3alpha.804
* Build date: 8 December 2013
*/
rangy.createModule("ClassApplier", ["WrappedSelection"], function(api, module) {
var dom = api.dom;
var DomPosition = dom.DomPosition;
var contains = dom.arrayContains;
var defaultTagName = "span";
function each(obj, func) {
for (var i in obj) {
if (obj.hasOwnProperty(i)) {
if (func(i, obj[i]) === false) {
return false;
}
}
}
return true;
}
function trim(str) {
return str.replace(/^\s\s*/, "").replace(/\s\s*$/, "");
}
function hasClass(el, cssClass) {
return el.className && new RegExp("(?:^|\\s)" + cssClass + "(?:\\s|$)").test(el.className);
}
function addClass(el, cssClass) {
if (el.className) {
if (!hasClass(el, cssClass)) {
el.className += " " + cssClass;
}
} else {
el.className = cssClass;
}
}
var removeClass = (function() {
function replacer(matched, whiteSpaceBefore, whiteSpaceAfter) {
return (whiteSpaceBefore && whiteSpaceAfter) ? " " : "";
}
return function(el, cssClass) {
if (el.className) {
el.className = el.className.replace(new RegExp("(^|\\s)" + cssClass + "(\\s|$)"), replacer);
}
};
})();
function sortClassName(className) {
return className.split(/\s+/).sort().join(" ");
}
function getSortedClassName(el) {
return sortClassName(el.className);
}
function haveSameClasses(el1, el2) {
return getSortedClassName(el1) == getSortedClassName(el2);
}
function movePosition(position, oldParent, oldIndex, newParent, newIndex) {
var node = position.node, offset = position.offset;
var newNode = node, newOffset = offset;
if (node == newParent && offset > newIndex) {
++newOffset;
}
if (node == oldParent && (offset == oldIndex || offset == oldIndex + 1)) {
newNode = newParent;
newOffset += newIndex - oldIndex;
}
if (node == oldParent && offset > oldIndex + 1) {
--newOffset;
}
position.node = newNode;
position.offset = newOffset;
}
function movePositionWhenRemovingNode(position, parentNode, index) {
if (position.node == parentNode && position.offset > index) {
--position.offset;
}
}
function movePreservingPositions(node, newParent, newIndex, positionsToPreserve) {
// For convenience, allow newIndex to be -1 to mean "insert at the end".
if (newIndex == -1) {
newIndex = newParent.childNodes.length;
}
var oldParent = node.parentNode;
var oldIndex = dom.getNodeIndex(node);
for (var i = 0, position; position = positionsToPreserve[i++]; ) {
movePosition(position, oldParent, oldIndex, newParent, newIndex);
}
// Now actually move the node.
if (newParent.childNodes.length == newIndex) {
newParent.appendChild(node);
} else {
newParent.insertBefore(node, newParent.childNodes[newIndex]);
}
}
function removePreservingPositions(node, positionsToPreserve) {
var oldParent = node.parentNode;
var oldIndex = dom.getNodeIndex(node);
for (var i = 0, position; position = positionsToPreserve[i++]; ) {
movePositionWhenRemovingNode(position, oldParent, oldIndex);
}
node.parentNode.removeChild(node);
}
function moveChildrenPreservingPositions(node, newParent, newIndex, removeNode, positionsToPreserve) {
var child, children = [];
while ( (child = node.firstChild) ) {
movePreservingPositions(child, newParent, newIndex++, positionsToPreserve);
children.push(child);
}
if (removeNode) {
node.parentNode.removeChild(node);
}
return children;
}
function replaceWithOwnChildrenPreservingPositions(element, positionsToPreserve) {
return moveChildrenPreservingPositions(element, element.parentNode, dom.getNodeIndex(element), true, positionsToPreserve);
}
function rangeSelectsAnyText(range, textNode) {
var textNodeRange = range.cloneRange();
textNodeRange.selectNodeContents(textNode);
var intersectionRange = textNodeRange.intersection(range);
var text = intersectionRange ? intersectionRange.toString() : "";
textNodeRange.detach();
return text != "";
}
function getEffectiveTextNodes(range) {
var nodes = range.getNodes([3]);
// Optimization as per issue 145
// Remove non-intersecting text nodes from the start of the range
var start = 0, node;
while ( (node = nodes[start]) && !rangeSelectsAnyText(range, node) ) {
++start;
}
// Remove non-intersecting text nodes from the start of the range
var end = nodes.length - 1;
while ( (node = nodes[end]) && !rangeSelectsAnyText(range, node) ) {
--end;
}
return nodes.slice(start, end + 1);
}
function elementsHaveSameNonClassAttributes(el1, el2) {
if (el1.attributes.length != el2.attributes.length) return false;
for (var i = 0, len = el1.attributes.length, attr1, attr2, name; i < len; ++i) {
attr1 = el1.attributes[i];
name = attr1.name;
if (name != "class") {
attr2 = el2.attributes.getNamedItem(name);
if ( (attr1 === null) != (attr2 === null) ) return false;
if (attr1.specified != attr2.specified) return false;
if (attr1.specified && attr1.nodeValue !== attr2.nodeValue) return false;
}
}
return true;
}
function elementHasNonClassAttributes(el, exceptions) {
for (var i = 0, len = el.attributes.length, attrName; i < len; ++i) {
attrName = el.attributes[i].name;
if ( !(exceptions && contains(exceptions, attrName)) && el.attributes[i].specified && attrName != "class") {
return true;
}
}
return false;
}
function elementHasProperties(el, props) {
each(props, function(p, propValue) {
if (typeof propValue == "object") {
if (!elementHasProperties(el[p], propValue)) {
return false;
}
} else if (el[p] !== propValue) {
return false;
}
});
return true;
}
var getComputedStyleProperty = dom.getComputedStyleProperty;
var isEditableElement = (function() {
var testEl = document.createElement("div");
return typeof testEl.isContentEditable == "boolean" ?
function (node) {
return node && node.nodeType == 1 && node.isContentEditable;
} :
function (node) {
if (!node || node.nodeType != 1 || node.contentEditable == "false") {
return false;
}
return node.contentEditable == "true" || isEditableElement(node.parentNode);
};
})();
function isEditingHost(node) {
var parent;
return node && node.nodeType == 1
&& (( (parent = node.parentNode) && parent.nodeType == 9 && parent.designMode == "on")
|| (isEditableElement(node) && !isEditableElement(node.parentNode)));
}
function isEditable(node) {
return (isEditableElement(node) || (node.nodeType != 1 && isEditableElement(node.parentNode))) && !isEditingHost(node);
}
var inlineDisplayRegex = /^inline(-block|-table)?$/i;
function isNonInlineElement(node) {
return node && node.nodeType == 1 && !inlineDisplayRegex.test(getComputedStyleProperty(node, "display"));
}
// White space characters as defined by HTML 4 (http://www.w3.org/TR/html401/struct/text.html)
var htmlNonWhiteSpaceRegex = /[^\r\n\t\f \u200B]/;
function isUnrenderedWhiteSpaceNode(node) {
if (node.data.length == 0) {
return true;
}
if (htmlNonWhiteSpaceRegex.test(node.data)) {
return false;
}
var cssWhiteSpace = getComputedStyleProperty(node.parentNode, "whiteSpace");
switch (cssWhiteSpace) {
case "pre":
case "pre-wrap":
case "-moz-pre-wrap":
return false;
case "pre-line":
if (/[\r\n]/.test(node.data)) {
return false;
}
}
// We now have a whitespace-only text node that may be rendered depending on its context. If it is adjacent to a
// non-inline element, it will not be rendered. This seems to be a good enough definition.
return isNonInlineElement(node.previousSibling) || isNonInlineElement(node.nextSibling);
}
function getRangeBoundaries(ranges) {
var positions = [], i, range;
for (i = 0; range = ranges[i++]; ) {
positions.push(
new DomPosition(range.startContainer, range.startOffset),
new DomPosition(range.endContainer, range.endOffset)
);
}
return positions;
}
function updateRangesFromBoundaries(ranges, positions) {
for (var i = 0, range, start, end, len = ranges.length; i < len; ++i) {
range = ranges[i];
start = positions[i * 2];
end = positions[i * 2 + 1];
range.setStartAndEnd(start.node, start.offset, end.node, end.offset);
}
}
function isSplitPoint(node, offset) {
if (dom.isCharacterDataNode(node)) {
if (offset == 0) {
return !!node.previousSibling;
} else if (offset == node.length) {
return !!node.nextSibling;
} else {
return true;
}
}
return offset > 0 && offset < node.childNodes.length;
}
function splitNodeAt(node, descendantNode, descendantOffset, positionsToPreserve) {
var newNode, parentNode;
var splitAtStart = (descendantOffset == 0);
if (dom.isAncestorOf(descendantNode, node)) {
return node;
}
if (dom.isCharacterDataNode(descendantNode)) {
var descendantIndex = dom.getNodeIndex(descendantNode);
if (descendantOffset == 0) {
descendantOffset = descendantIndex;
} else if (descendantOffset == descendantNode.length) {
descendantOffset = descendantIndex + 1;
} else {
throw module.createError("splitNodeAt() should not be called with offset in the middle of a data node ("
+ descendantOffset + " in " + descendantNode.data);
}
descendantNode = descendantNode.parentNode;
}
if (isSplitPoint(descendantNode, descendantOffset)) {
// descendantNode is now guaranteed not to be a text or other character node
newNode = descendantNode.cloneNode(false);
parentNode = descendantNode.parentNode;
if (newNode.id) {
newNode.removeAttribute("id");
}
var child, newChildIndex = 0;
while ( (child = descendantNode.childNodes[descendantOffset]) ) {
movePreservingPositions(child, newNode, newChildIndex++, positionsToPreserve);
}
movePreservingPositions(newNode, parentNode, dom.getNodeIndex(descendantNode) + 1, positionsToPreserve);
return (descendantNode == node) ? newNode : splitNodeAt(node, parentNode, dom.getNodeIndex(newNode), positionsToPreserve);
} else if (node != descendantNode) {
newNode = descendantNode.parentNode;
// Work out a new split point in the parent node
var newNodeIndex = dom.getNodeIndex(descendantNode);
if (!splitAtStart) {
newNodeIndex++;
}
return splitNodeAt(node, newNode, newNodeIndex, positionsToPreserve);
}
return node;
}
function areElementsMergeable(el1, el2) {
return el1.tagName == el2.tagName
&& haveSameClasses(el1, el2)
&& elementsHaveSameNonClassAttributes(el1, el2)
&& getComputedStyleProperty(el1, "display") == "inline"
&& getComputedStyleProperty(el2, "display") == "inline";
}
function createAdjacentMergeableTextNodeGetter(forward) {
var siblingPropName = forward ? "nextSibling" : "previousSibling";
return function(textNode, checkParentElement) {
var el = textNode.parentNode;
var adjacentNode = textNode[siblingPropName];
if (adjacentNode) {
// Can merge if the node's previous/next sibling is a text node
if (adjacentNode && adjacentNode.nodeType == 3) {
return adjacentNode;
}
} else if (checkParentElement) {
// Compare text node parent element with its sibling
adjacentNode = el[siblingPropName];
if (adjacentNode && adjacentNode.nodeType == 1 && areElementsMergeable(el, adjacentNode)) {
var adjacentNodeChild = adjacentNode[forward ? "firstChild" : "lastChild"];
if (adjacentNodeChild && adjacentNodeChild.nodeType == 3) {
return adjacentNodeChild;
}
}
}
return null;
};
}
var getPreviousMergeableTextNode = createAdjacentMergeableTextNodeGetter(false),
getNextMergeableTextNode = createAdjacentMergeableTextNodeGetter(true);
function Merge(firstNode) {
this.isElementMerge = (firstNode.nodeType == 1);
this.textNodes = [];
var firstTextNode = this.isElementMerge ? firstNode.lastChild : firstNode;
if (firstTextNode) {
this.textNodes[0] = firstTextNode;
}
}
Merge.prototype = {
doMerge: function(positionsToPreserve) {
var textNodes = this.textNodes;
var firstTextNode = textNodes[0];
if (textNodes.length > 1) {
var textParts = [], combinedTextLength = 0, textNode, parent;
for (var i = 0, len = textNodes.length, j, position; i < len; ++i) {
textNode = textNodes[i];
parent = textNode.parentNode;
if (i > 0) {
parent.removeChild(textNode);
if (!parent.hasChildNodes()) {
parent.parentNode.removeChild(parent);
}
if (positionsToPreserve) {
for (j = 0; position = positionsToPreserve[j++]; ) {
// Handle case where position is inside the text node being merged into a preceding node
if (position.node == textNode) {
position.node = firstTextNode;
position.offset += combinedTextLength;
}
}
}
}
textParts[i] = textNode.data;
combinedTextLength += textNode.data.length;
}
firstTextNode.data = textParts.join("");
}
return firstTextNode.data;
},
getLength: function() {
var i = this.textNodes.length, len = 0;
while (i--) {
len += this.textNodes[i].length;
}
return len;
},
toString: function() {
var textParts = [];
for (var i = 0, len = this.textNodes.length; i < len; ++i) {
textParts[i] = "'" + this.textNodes[i].data + "'";
}
return "[Merge(" + textParts.join(",") + ")]";
}
};
var optionProperties = ["elementTagName", "ignoreWhiteSpace", "applyToEditableOnly", "useExistingElements",
"removeEmptyElements", "onElementCreate"];
// TODO: Populate this with every attribute name that corresponds to a property with a different name. Really??
var attrNamesForProperties = {};
function ClassApplier(cssClass, options, tagNames) {
var normalize, i, len, propName, applier = this;
applier.cssClass = cssClass;
var elementPropertiesFromOptions = null, elementAttributes = {};
// Initialize from options object
if (typeof options == "object" && options !== null) {
tagNames = options.tagNames;
elementPropertiesFromOptions = options.elementProperties;
elementAttributes = options.elementAttributes;
for (i = 0; propName = optionProperties[i++]; ) {
if (options.hasOwnProperty(propName)) {
applier[propName] = options[propName];
}
}
normalize = options.normalize;
} else {
normalize = options;
}
// Backward compatibility: the second parameter can also be a Boolean indicating to normalize after unapplying
applier.normalize = (typeof normalize == "undefined") ? true : normalize;
// Initialize element properties and attribute exceptions
applier.attrExceptions = [];
var el = document.createElement(applier.elementTagName);
applier.elementProperties = applier.copyPropertiesToElement(elementPropertiesFromOptions, el, true);
each(elementAttributes, function(attrName) {
applier.attrExceptions.push(attrName);
});
applier.elementAttributes = elementAttributes;
applier.elementSortedClassName = applier.elementProperties.hasOwnProperty("className") ?
applier.elementProperties.className : cssClass;
// Initialize tag names
applier.applyToAnyTagName = false;
var type = typeof tagNames;
if (type == "string") {
if (tagNames == "*") {
applier.applyToAnyTagName = true;
} else {
applier.tagNames = trim(tagNames.toLowerCase()).split(/\s*,\s*/);
}
} else if (type == "object" && typeof tagNames.length == "number") {
applier.tagNames = [];
for (i = 0, len = tagNames.length; i < len; ++i) {
if (tagNames[i] == "*") {
applier.applyToAnyTagName = true;
} else {
applier.tagNames.push(tagNames[i].toLowerCase());
}
}
} else {
applier.tagNames = [applier.elementTagName];
}
}
ClassApplier.prototype = {
elementTagName: defaultTagName,
elementProperties: {},
elementAttributes: {},
ignoreWhiteSpace: true,
applyToEditableOnly: false,
useExistingElements: true,
removeEmptyElements: true,
onElementCreate: null,
copyPropertiesToElement: function(props, el, createCopy) {
var s, elStyle, elProps = {}, elPropsStyle, propValue, elPropValue, attrName;
for (var p in props) {
if (props.hasOwnProperty(p)) {
propValue = props[p];
elPropValue = el[p];
// Special case for class. The copied properties object has the applier's CSS class as well as its
// own to simplify checks when removing styling elements
if (p == "className") {
addClass(el, propValue);
addClass(el, this.cssClass);
el[p] = sortClassName(el[p]);
if (createCopy) {
elProps[p] = el[p];
}
}
// Special case for style
else if (p == "style") {
elStyle = elPropValue;
if (createCopy) {
elProps[p] = elPropsStyle = {};
}
for (s in props[p]) {
elStyle[s] = propValue[s];
if (createCopy) {
elPropsStyle[s] = elStyle[s];
}
}
this.attrExceptions.push(p);
} else {
el[p] = propValue;
// Copy the property back from the dummy element so that later comparisons to check whether
// elements may be removed are checking against the right value. For example, the href property
// of an element returns a fully qualified URL even if it was previously assigned a relative
// URL.
if (createCopy) {
elProps[p] = el[p];
// Not all properties map to identically-named attributes
attrName = attrNamesForProperties.hasOwnProperty(p) ? attrNamesForProperties[p] : p;
this.attrExceptions.push(attrName);
}
}
}
}
return createCopy ? elProps : "";
},
copyAttributesToElement: function(attrs, el) {
for (var attrName in attrs) {
if (attrs.hasOwnProperty(attrName)) {
el.setAttribute(attrName, attrs[attrName]);
}
}
},
hasClass: function(node) {
return node.nodeType == 1 &&
contains(this.tagNames, node.tagName.toLowerCase()) &&
hasClass(node, this.cssClass);
},
getSelfOrAncestorWithClass: function(node) {
while (node) {
if (this.hasClass(node)) {
return node;
}
node = node.parentNode;
}
return null;
},
isModifiable: function(node) {
return !this.applyToEditableOnly || isEditable(node);
},
// White space adjacent to an unwrappable node can be ignored for wrapping
isIgnorableWhiteSpaceNode: function(node) {
return this.ignoreWhiteSpace && node && node.nodeType == 3 && isUnrenderedWhiteSpaceNode(node);
},
// Normalizes nodes after applying a CSS class to a Range.
postApply: function(textNodes, range, positionsToPreserve, isUndo) {
var firstNode = textNodes[0], lastNode = textNodes[textNodes.length - 1];
var merges = [], currentMerge;
var rangeStartNode = firstNode, rangeEndNode = lastNode;
var rangeStartOffset = 0, rangeEndOffset = lastNode.length;
var textNode, precedingTextNode;
// Check for every required merge and create a Merge object for each
for (var i = 0, len = textNodes.length; i < len; ++i) {
textNode = textNodes[i];
precedingTextNode = getPreviousMergeableTextNode(textNode, !isUndo);
if (precedingTextNode) {
if (!currentMerge) {
currentMerge = new Merge(precedingTextNode);
merges.push(currentMerge);
}
currentMerge.textNodes.push(textNode);
if (textNode === firstNode) {
rangeStartNode = currentMerge.textNodes[0];
rangeStartOffset = rangeStartNode.length;
}
if (textNode === lastNode) {
rangeEndNode = currentMerge.textNodes[0];
rangeEndOffset = currentMerge.getLength();
}
} else {
currentMerge = null;
}
}
// Test whether the first node after the range needs merging
var nextTextNode = getNextMergeableTextNode(lastNode, !isUndo);
if (nextTextNode) {
if (!currentMerge) {
currentMerge = new Merge(lastNode);
merges.push(currentMerge);
}
currentMerge.textNodes.push(nextTextNode);
}
// Apply the merges
if (merges.length) {
for (i = 0, len = merges.length; i < len; ++i) {
merges[i].doMerge(positionsToPreserve);
}
// Set the range boundaries
range.setStartAndEnd(rangeStartNode, rangeStartOffset, rangeEndNode, rangeEndOffset);
}
},
createContainer: function(doc) {
var el = doc.createElement(this.elementTagName);
this.copyPropertiesToElement(this.elementProperties, el, false);
this.copyAttributesToElement(this.elementAttributes, el);
addClass(el, this.cssClass);
if (this.onElementCreate) {
this.onElementCreate(el, this);
}
return el;
},
applyToTextNode: function(textNode, positionsToPreserve) {
var parent = textNode.parentNode;
if (parent.childNodes.length == 1 &&
this.useExistingElements &&
contains(this.tagNames, parent.tagName.toLowerCase()) &&
elementHasProperties(parent, this.elementProperties)) {
addClass(parent, this.cssClass);
} else {
var el = this.createContainer(dom.getDocument(textNode));
textNode.parentNode.insertBefore(el, textNode);
el.appendChild(textNode);
}
},
isRemovable: function(el) {
return el.tagName.toLowerCase() == this.elementTagName
&& getSortedClassName(el) == this.elementSortedClassName
&& elementHasProperties(el, this.elementProperties)
&& !elementHasNonClassAttributes(el, this.attrExceptions)
&& this.isModifiable(el);
},
isEmptyContainer: function(el) {
var childNodeCount = el.childNodes.length;
return el.nodeType == 1
&& this.isRemovable(el)
&& (childNodeCount == 0 || (childNodeCount == 1 && this.isEmptyContainer(el.firstChild)));
},
removeEmptyContainers: function(range) {
var applier = this;
var nodesToRemove = range.getNodes([1], function(el) {
return applier.isEmptyContainer(el);
});
var rangesToPreserve = [range]
var positionsToPreserve = getRangeBoundaries(rangesToPreserve);
for (var i = 0, node; node = nodesToRemove[i++]; ) {
removePreservingPositions(node, positionsToPreserve);
}
// Update the range from the preserved boundary positions
updateRangesFromBoundaries(rangesToPreserve, positionsToPreserve);
},
undoToTextNode: function(textNode, range, ancestorWithClass, positionsToPreserve) {
if (!range.containsNode(ancestorWithClass)) {
// Split out the portion of the ancestor from which we can remove the CSS class
//var parent = ancestorWithClass.parentNode, index = dom.getNodeIndex(ancestorWithClass);
var ancestorRange = range.cloneRange();
ancestorRange.selectNode(ancestorWithClass);
if (ancestorRange.isPointInRange(range.endContainer, range.endOffset)) {
splitNodeAt(ancestorWithClass, range.endContainer, range.endOffset, positionsToPreserve);
range.setEndAfter(ancestorWithClass);
}
if (ancestorRange.isPointInRange(range.startContainer, range.startOffset)) {
ancestorWithClass = splitNodeAt(ancestorWithClass, range.startContainer, range.startOffset, positionsToPreserve);
}
}
if (this.isRemovable(ancestorWithClass)) {
replaceWithOwnChildrenPreservingPositions(ancestorWithClass, positionsToPreserve);
} else {
removeClass(ancestorWithClass, this.cssClass);
}
},
applyToRange: function(range, rangesToPreserve) {
rangesToPreserve = rangesToPreserve || [];
// Create an array of range boundaries to preserve
var positionsToPreserve = getRangeBoundaries(rangesToPreserve || []);
range.splitBoundariesPreservingPositions(positionsToPreserve);
// Tidy up the DOM by removing empty containers
if (this.removeEmptyElements) {
this.removeEmptyContainers(range);
}
var textNodes = getEffectiveTextNodes(range);
if (textNodes.length) {
for (var i = 0, textNode; textNode = textNodes[i++]; ) {
if (!this.isIgnorableWhiteSpaceNode(textNode) && !this.getSelfOrAncestorWithClass(textNode)
&& this.isModifiable(textNode)) {
this.applyToTextNode(textNode, positionsToPreserve);
}
}
textNode = textNodes[textNodes.length - 1];
range.setStartAndEnd(textNodes[0], 0, textNode, textNode.length);
if (this.normalize) {
this.postApply(textNodes, range, positionsToPreserve, false);
}
// Update the ranges from the preserved boundary positions
updateRangesFromBoundaries(rangesToPreserve, positionsToPreserve);
}
},
applyToRanges: function(ranges) {
var i = ranges.length;
while (i--) {
this.applyToRange(ranges[i], ranges);
}
return ranges;
},
applyToSelection: function(win) {
var sel = api.getSelection(win);
sel.setRanges( this.applyToRanges(sel.getAllRanges()) );
},
undoToRange: function(range, rangesToPreserve) {
// Create an array of range boundaries to preserve
rangesToPreserve = rangesToPreserve || [];
var positionsToPreserve = getRangeBoundaries(rangesToPreserve);
range.splitBoundariesPreservingPositions(positionsToPreserve);
// Tidy up the DOM by removing empty containers
if (this.removeEmptyElements) {
this.removeEmptyContainers(range, positionsToPreserve);
}
var textNodes = getEffectiveTextNodes(range);
var textNode, ancestorWithClass;
var lastTextNode = textNodes[textNodes.length - 1];
if (textNodes.length) {
for (var i = 0, len = textNodes.length; i < len; ++i) {
textNode = textNodes[i];
ancestorWithClass = this.getSelfOrAncestorWithClass(textNode);
if (ancestorWithClass && this.isModifiable(textNode)) {
this.undoToTextNode(textNode, range, ancestorWithClass, positionsToPreserve);
}
// Ensure the range is still valid
range.setStartAndEnd(textNodes[0], 0, lastTextNode, lastTextNode.length);
}
if (this.normalize) {
this.postApply(textNodes, range, positionsToPreserve, true);
}
// Update the ranges from the preserved boundary positions
updateRangesFromBoundaries(rangesToPreserve, positionsToPreserve);
}
},
undoToRanges: function(ranges) {
// Get ranges returned in document order
var i = ranges.length;
while (i--) {
this.undoToRange(ranges[i], ranges);
}
return ranges;
},
undoToSelection: function(win) {
var sel = api.getSelection(win);
var ranges = api.getSelection(win).getAllRanges();
this.undoToRanges(ranges);
sel.setRanges(ranges);
},
/*
getTextSelectedByRange: function(textNode, range) {
var textRange = range.cloneRange();
textRange.selectNodeContents(textNode);
var intersectionRange = textRange.intersection(range);
var text = intersectionRange ? intersectionRange.toString() : "";
textRange.detach();
return text;
},
*/
isAppliedToRange: function(range) {
if (range.collapsed || range.toString() == "") {
return !!this.getSelfOrAncestorWithClass(range.commonAncestorContainer);
} else {
var textNodes = range.getNodes( [3] );
if (textNodes.length)
for (var i = 0, textNode; textNode = textNodes[i++]; ) {
if (!this.isIgnorableWhiteSpaceNode(textNode) && rangeSelectsAnyText(range, textNode)
&& this.isModifiable(textNode) && !this.getSelfOrAncestorWithClass(textNode)) {
return false;
}
}
return true;
}
},
isAppliedToRanges: function(ranges) {
var i = ranges.length;
if (i == 0) {
return false;
}
while (i--) {
if (!this.isAppliedToRange(ranges[i])) {
return false;
}
}
return true;
},
isAppliedToSelection: function(win) {
var sel = api.getSelection(win);
return this.isAppliedToRanges(sel.getAllRanges());
},
toggleRange: function(range) {
if (this.isAppliedToRange(range)) {
this.undoToRange(range);
} else {
this.applyToRange(range);
}
},
/*
toggleRanges: function(ranges) {
if (this.isAppliedToRanges(ranges)) {
this.undoToRanges(ranges);
} else {
this.applyToRanges(ranges);
}
},
*/
toggleSelection: function(win) {
if (this.isAppliedToSelection(win)) {
this.undoToSelection(win);
} else {
this.applyToSelection(win);
}
},
getElementsWithClassIntersectingRange: function(range) {
var elements = [];
var applier = this;
range.getNodes([3], function(textNode) {
var el = applier.getSelfOrAncestorWithClass(textNode);
if (el && !contains(elements, el)) {
elements.push(el);
}
});
return elements;
},
/*
getElementsWithClassIntersectingSelection: function(win) {
var sel = api.getSelection(win);
var elements = [];
var applier = this;
sel.eachRange(function(range) {
var rangeElements = applier.getElementsWithClassIntersectingRange(range);
for (var i = 0, el; el = rangeElements[i++]; ) {
if (!contains(elements, el)) {
elements.push(el);
}
}
});
return elements;
},
*/
detach: function() {}
};
function createClassApplier(cssClass, options, tagNames) {
return new ClassApplier(cssClass, options, tagNames);
}
ClassApplier.util = {
hasClass: hasClass,
addClass: addClass,
removeClass: removeClass,
hasSameClasses: haveSameClasses,
replaceWithOwnChildren: replaceWithOwnChildrenPreservingPositions,
elementsHaveSameNonClassAttributes: elementsHaveSameNonClassAttributes,
elementHasNonClassAttributes: elementHasNonClassAttributes,
splitNodeAt: splitNodeAt,
isEditableElement: isEditableElement,
isEditingHost: isEditingHost,
isEditable: isEditable
};
api.CssClassApplier = api.ClassApplier = ClassApplier;
api.createCssClassApplier = api.createClassApplier = createClassApplier;
});
Zerion Mini Shell 1.0