|Foo bar|
The ``p`` is returned.Foo |bar|
The ``i`` is returned. */ WYMeditor.editor.prototype.selectedContainer = function () { var wym = this, selection, $anchor, $focus, $selectedContainer; if (wym.hasSelection() !== true) { return false; } selection = wym.selection(); $anchor = jQuery(selection.anchorNode); $focus = jQuery(selection.focusNode); if ($anchor[0].nodeType === WYMeditor.NODE_TYPE.TEXT) { $anchor = $anchor.parent(); } if ($focus[0].nodeType === WYMeditor.NODE_TYPE.TEXT) { $focus = $focus.parent(); } if ($anchor[0] === $focus[0]) { return $anchor[0]; } $selectedContainer = $anchor.has($focus); if ($selectedContainer.length === 0) { $selectedContainer = $focus.has($anchor); } if ($selectedContainer.length === 0) { return false; } return $selectedContainer[0]; }; // Deprecated in favor of `WYMeditor.editor.selectedContainer`. WYMeditor.editor.prototype.selected = function () { var wym = this; WYMeditor.console.warn( "The function WYMeditor.editor.selected() is " + "deprecated. Use WYMeditor.editor.selectedContainer" ); return wym.selectedContainer(); }; /** WYMeditor.editor.isBlockNode ============================= Returns true if the provided node is a block type node. Otherwise returns false. @param node The node to check. */ WYMeditor.editor.prototype.isBlockNode = function (node) { if ( node.tagName && jQuery.inArray( node.tagName.toLowerCase(), WYMeditor.BLOCKS ) > -1 ) { return true; } return false; }; /** WYMeditor.editor.isInlineNode ============================= Returns true if the provided node is an inline type node. Otherwise returns false. @param node The node to check. */ WYMeditor.editor.prototype.isInlineNode = function (node) { if ( node.nodeType === WYMeditor.NODE_TYPE.TEXT || jQuery.inArray( node.tagName.toLowerCase(), WYMeditor.INLINE_ELEMENTS ) > -1 ) { return true; } return false; }; /** WYMeditor.editor.isListNode =========================== Returns true if the provided node is a list element. Otherwise returns false. @param node The node to check. */ WYMeditor.editor.prototype.isListNode = function (node) { if ( node.tagName && jQuery.inArray( node.tagName.toLowerCase(), WYMeditor.LIST_TYPE_ELEMENTS ) > -1 ) { return true; } return false; }; /** WYMeditor.editor.unwrapIfMeaninglessSpan If the given node is a span with no useful attributes, unwrap it. For certain editing actions (mostly list indent/outdent), it's necessary to wrap content in a span element to retain grouping because it's not obvious that the content will stay together without grouping. This method detects that specific situation and then unwraps the content if the span is in fact not necessary. @param element The element. */ WYMeditor.editor.prototype.unwrapIfMeaninglessSpan = function (element) { var $element = jQuery(element), i = 0, attrName, meaninglessAttrNames = [ '_wym_visited', 'length', 'ie8_length' ]; if (!element || typeof (element.tagName) === 'undefined' || element.tagName.toLowerCase() !== 'span') { return false; } while (i < element.attributes.length) { attrName = element.attributes[i].nodeName; if (jQuery.inArray(attrName, meaninglessAttrNames) === -1) { return false; } i++; } $element.before($element.contents()); $element.remove(); return true; }; /** WYMeditor.editor.getRootContainer ================================= Get the selected root container. */ WYMeditor.editor.prototype.getRootContainer = function () { var wym = this; return jQuery(wym.selectedContainer()) .parentsOrSelf() .not('html, body, blockquote') .last()[0]; }; /** WYMeditor.editor.setRootContainer ================================= Set the selected root container. */ WYMeditor.editor.prototype.setRootContainer = function (sType) { var wym = this, container = null, aTypes, newNode, blockquote, nodes, lgt, firstNode, x; if (sType.toLowerCase() === WYMeditor.TH) { container = wym.selectedContainer(); // Find the TD or TH container switch (container.tagName.toLowerCase()) { case WYMeditor.TD: case WYMeditor.TH: break; default: aTypes = [WYMeditor.TD, WYMeditor.TH]; container = wym.findUp(wym.selectedContainer(), aTypes); break; } // If it exists, switch if (container !== null) { sType = WYMeditor.TD; if (container.tagName.toLowerCase() === WYMeditor.TD) { sType = WYMeditor.TH; } wym.restoreSelectionAfterManipulation(function () { wym.switchTo(container, sType, false); return true; }); wym.update(); wym.registerModification(); } } else { // Set the container type aTypes = [ WYMeditor.P, WYMeditor.DIV, WYMeditor.H1, WYMeditor.H2, WYMeditor.H3, WYMeditor.H4, WYMeditor.H5, WYMeditor.H6, WYMeditor.PRE, WYMeditor.BLOCKQUOTE ]; container = wym.findUp(wym.selectedContainer(), aTypes); if (container) { if (sType.toLowerCase() === WYMeditor.BLOCKQUOTE) { // Blockquotes must contain a block level element blockquote = wym.findUp( wym.selectedContainer(), WYMeditor.BLOCKQUOTE ); if (blockquote === null) { newNode = wym._doc.createElement(sType); container.parentNode.insertBefore(newNode, container); newNode.appendChild(container); wym.setCaretIn(newNode.firstChild); } else { nodes = blockquote.childNodes; lgt = nodes.length; if (lgt > 0) { firstNode = nodes.item(0); } for (x = 0; x < lgt; x += 1) { blockquote.parentNode.insertBefore( nodes.item(0), blockquote ); } blockquote.parentNode.removeChild(blockquote); if (firstNode) { wym.setCaretIn(firstNode); } } } else { // Not a blockquote wym.restoreSelectionAfterManipulation(function () { wym.switchTo(container, sType, false); return true; }); } wym.update(); wym.registerModification(); } } return false; }; /** WYMeditor.editor.isForbiddenRootContainer ========================================= Returns true if provided `tagName` is disallowed as a root container. Returns false if it is allowed. @param tagName A string of the tag name. */ WYMeditor.editor.prototype.isForbiddenRootContainer = function (tagName) { return jQuery.inArray(tagName.toLowerCase(), WYMeditor.FORBIDDEN_ROOT_CONTAINERS) > -1; }; /** WYMeditor.editor.keyCanCreateBlockElement ========================================= Determines whether the key represented by the passed keyCode can create a block element within the editor when pressed. Returns true if the key can create a block element when pressed, and returns false if otherwise. @param keyCode A numberic key code representing a key */ WYMeditor.editor.prototype.keyCanCreateBlockElement = function (keyCode) { return jQuery.inArray(keyCode, WYMeditor.POTENTIAL_BLOCK_ELEMENT_CREATION_KEYS) > -1; }; /** WYMeditor.editor.toggleClass ============================ Toggle a class on the selected element or one of its parents */ WYMeditor.editor.prototype.toggleClass = function (sClass, jqexpr) { var wym = this, $element; $element = jQuery(wym.getSelectedImage()); if ($element.length !== 1) { $element = jQuery(wym.selectedContainer()) // `.last()` is used here because the `.addBack()` from // `.parentsOrSelf` reverses the array. .parentsOrSelf(jqexpr).last(); } $element.toggleClass(sClass); if (!$element.attr(WYMeditor.CLASS)) { $element.removeAttr(wym._class); } wym.registerModification(); }; /** WYMeditor.editor.getSelectedImage ================================= If selection encompasses exactly a single image, returns that image. Otherwise returns `false`. */ WYMeditor.editor.prototype.getSelectedImage = function () { var wym = this, selectedNodes, selectedNode; if (wym.hasSelection() !== true) { return false; } if (wym.selection().isCollapsed !== false) { return false; } selectedNodes = wym._getSelectedNodes(); if (selectedNodes.length !== 1) { return false; } selectedNode = selectedNodes[0]; if ( !selectedNode.tagName || selectedNode.tagName.toLowerCase() !== "img" ) { return false; } return selectedNode; }; /** WYMeditor.editor.findUp ======================= Return the first parent or self container, based on its type `filter` is a string or an array of strings on which to filter the container */ WYMeditor.editor.prototype.findUp = function (node, filter) { if (typeof (node) === 'undefined' || node === null) { return null; } if (node.nodeName === "#text") { // For text nodes, we need to look from the nodes container object node = node.parentNode; } var tagname = node.tagName.toLowerCase(), bFound, i; if (typeof (filter) === WYMeditor.STRING) { while (tagname !== filter && tagname !== WYMeditor.BODY) { node = node.parentNode; tagname = node.tagName.toLowerCase(); } } else { bFound = false; while (!bFound && tagname !== WYMeditor.BODY) { for (i = 0; i < filter.length; i += 1) { if (tagname === filter[i]) { bFound = true; break; } } if (!bFound) { node = node.parentNode; if (node === null) { // No parentNode, so we're not going to find anything // up the ancestry chain that matches return null; } tagname = node.tagName.toLowerCase(); } } } if (tagname === WYMeditor.BODY) { return null; } return node; }; /** WYMeditor.editor.switchTo ========================= Switch the type of an element. @param element The element. @param sType A string of the desired type. For example, 'p'. @param stripAttrs a boolean that determines whether the attributes of the element will be stripped or preserved. */ WYMeditor.editor.prototype.switchTo = function ( element, sType, stripAttrs ) { var wym = this, $element = jQuery(element), newElement, i, attrs = element.attributes; if (!element.tagName) { throw "This must be an element."; } if (element.tagName.toLowerCase() === 'img') { throw "Will not change the type of an 'img' element."; } newElement = wym._doc.createElement(sType); jQuery(newElement).append(element.childNodes); $element.replaceWith(newElement); if (!stripAttrs) { for (i = 0; i < attrs.length; ++i) { newElement.setAttribute( attrs.item(i).nodeName, attrs.item(i).value ); } } return newElement; }; WYMeditor.editor.prototype.replaceStrings = function (sVal) { var wym = this, key; // Check if the language file has already been loaded // if not, get it via a synchronous ajax call if (!WYMeditor.STRINGS[wym._options.lang]) { WYMeditor.console.error( "WYMeditor: language '" + wym._options.lang + "' not found." ); WYMeditor.console.error( "Unable to perform i10n." ); return sVal; } // Replace all the strings in sVal and return it for (key in WYMeditor.STRINGS[wym._options.lang]) { if (WYMeditor.STRINGS[wym._options.lang].hasOwnProperty(key)) { sVal = WYMeditor.Helper.replaceAllInStr( sVal, wym._options.stringDelimiterLeft + key + wym._options.stringDelimiterRight, WYMeditor.STRINGS[wym._options.lang][key] ); } } return sVal; }; WYMeditor.editor.prototype._encloseString = function (sVal) { var wym = this; return wym._options.stringDelimiterLeft + sVal + wym._options.stringDelimiterRight; }; /** editor.getCurrentState ====================== Returns an object with the current state of the editor. The state includes: ``html`` The return value of ``editor.rawHtml()``. ``savedSelection`` A Rangy saved selection, if anything is selected. The ``win`` and the ``doc`` properties are deleted, instead of referencing the window object and the document object, respectively. In order to provide this as an argument to Rangy's ``restoreSelection``, these must be reassigned. It may include more things in the future. */ WYMeditor.editor.prototype.getCurrentState = function () { var wym = this, state = {}, selection, wymIframeWindow = wym._iframe.contentWindow; if (wym.hasSelection()) { selection = wym.selection(); } if ( selection && selection.anchorNode === wym.body() && selection.anchorOffset === 0 && selection.isCollapsed ) { // meaningless selection selection = false; } if (selection) { state.savedSelection = rangy.saveSelection(wymIframeWindow); } state.html = wym.rawHtml(); if (state.savedSelection) { // Selection was saved. This means that in the document, DOM elements, // which are markers for the selection, were placed, and that references // to these markers were saved in `state.savedselection`. The markers // were saved in `state.html`, along with the whole document, as HTML. // Restoring the selection removes the markers and restores the // selection to almost exactly as it was before it was saved. rangy.restoreSelection(state.savedSelection); // This is for time-travel, so selection is considered not to be // restored. The markers may be created again from the saved HTML. In // that case, leaving this value at `true` would mean that // `rangy.restoreSelection` will refuse to restore this selection. state.savedSelection.restored = false; // These refer to the window and the document and can't be processed by // the `object-history` module that is used by the `UndoRedo` module. delete state.savedSelection.win; delete state.savedSelection.doc; } return state; }; /** editor.hasSelection =================== Returns true if there is a selection. Returns false otherwise. */ WYMeditor.editor.prototype.hasSelection = function () { var wym = this; if ( // `isSelectionValid` is undocumented in current Rangy (`1.2.2`). // It seems to be required because the `rangeCount` in `IE <= 8` seems // to be misleading. rangy.isSelectionValid(wym._iframe.contentWindow) !== true ) { return false; } if (wym.selection().rangeCount === 0) { return false; } return true; }; /** editor._setSingleSelectionRange =============================== Sets the selection to the single provided Rangy range. @param range A Rangy range. */ WYMeditor.editor.prototype._setSingleSelectionRange = function (range) { var wym = this, selection; selection = wym.selection(); selection.setSingleRange(range); }; /** editor.status ============= Print the given string as a status message. */ WYMeditor.editor.prototype.status = function (sMessage) { var wym = this; // Print status message jQuery(wym._box).find(wym._options.statusSelector).html(sMessage); }; /** editor.update ============= Update the element and textarea values. */ WYMeditor.editor.prototype.update = function () { var wym = this, html; html = wym.html(); jQuery(wym.element).val(html); jQuery(wym._box).find(wym._options.htmlValSelector).not('.hasfocus').val(html); //#147 }; /** editor.prepareDocForEditing =========================== Makes some editor-only modifications to the body of the document, which are necessary for the user interface. For example, inserts `br` elements in certain places. These modifications will not show up in the HTML output. */ WYMeditor.editor.prototype.prepareDocForEditing = function () { var wym = this, $body; wym._spaceBlockingElements(); wym._fixDoubleBr(); $body = wym.$body(); if ($body.children().length === 0) { wym.$body().append('' + paragraphStrings[0] + '
', wym._doc ).appendTo(wym._doc.body); } else { // Need to build paragraphs and insert them at the end blockSplitter = 'p'; for (i = paragraphStrings.length - 1; i >= 0; i -= 1) { // Going backwards because rangy.insertNode leaves the // selection in front of the inserted node html = '<' + blockSplitter + '>' + (paragraphStrings[i].split(WYMeditor.NEWLINE).join('' + func(text) + '
'; * }); * * p('Fred, Wilma, & Pebbles'); * // => 'Fred, Wilma, & Pebbles
' */ function wrap(value, wrapper) { return createWrapper(wrapper, 16, [value]); } /*--------------------------------------------------------------------------*/ /** * Creates a function that returns `value`. * * @static * @memberOf _ * @category Utilities * @param {*} value The value to return from the new function. * @returns {Function} Returns the new function. * @example * * var object = { 'name': 'fred' }; * var getter = _.constant(object); * getter() === object; * // => true */ function constant(value) { return function() { return value; }; } /** * Produces a callback bound to an optional `thisArg`. If `func` is a property * name the created callback will return the property value for a given element. * If `func` is an object the created callback will return `true` for elements * that contain the equivalent object properties, otherwise it will return `false`. * * @static * @memberOf _ * @category Utilities * @param {*} [func=identity] The value to convert to a callback. * @param {*} [thisArg] The `this` binding of the created callback. * @param {number} [argCount] The number of arguments the callback accepts. * @returns {Function} Returns a callback function. * @example * * var characters = [ * { 'name': 'barney', 'age': 36 }, * { 'name': 'fred', 'age': 40 } * ]; * * // wrap to create custom callback shorthands * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) { * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback); * return !match ? func(callback, thisArg) : function(object) { * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3]; * }; * }); * * _.filter(characters, 'age__gt38'); * // => [{ 'name': 'fred', 'age': 40 }] */ function createCallback(func, thisArg, argCount) { var type = typeof func; if (func == null || type == 'function') { return baseCreateCallback(func, thisArg, argCount); } // handle "_.pluck" style callback shorthands if (type != 'object') { return property(func); } var props = keys(func), key = props[0], a = func[key]; // handle "_.where" style callback shorthands if (props.length == 1 && a === a && !isObject(a)) { // fast path the common case of providing an object with a single // property containing a primitive value return function(object) { var b = object[key]; return a === b && (a !== 0 || (1 / a == 1 / b)); }; } return function(object) { var length = props.length, result = false; while (length--) { if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) { break; } } return result; }; } /** * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their * corresponding HTML entities. * * @static * @memberOf _ * @category Utilities * @param {string} string The string to escape. * @returns {string} Returns the escaped string. * @example * * _.escape('Fred, Wilma, & Pebbles'); * // => 'Fred, Wilma, & Pebbles' */ function escape(string) { return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar); } /** * This method returns the first argument provided to it. * * @static * @memberOf _ * @category Utilities * @param {*} value Any value. * @returns {*} Returns `value`. * @example * * var object = { 'name': 'fred' }; * _.identity(object) === object; * // => true */ function identity(value) { return value; } /** * Adds function properties of a source object to the destination object. * If `object` is a function methods will be added to its prototype as well. * * @static * @memberOf _ * @category Utilities * @param {Function|Object} [object=lodash] object The destination object. * @param {Object} source The object of functions to add. * @param {Object} [options] The options object. * @param {boolean} [options.chain=true] Specify whether the functions added are chainable. * @example * * function capitalize(string) { * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase(); * } * * _.mixin({ 'capitalize': capitalize }); * _.capitalize('fred'); * // => 'Fred' * * _('fred').capitalize().value(); * // => 'Fred' * * _.mixin({ 'capitalize': capitalize }, { 'chain': false }); * _('fred').capitalize(); * // => 'Fred' */ function mixin(object, source, options) { var chain = true, methodNames = source && functions(source); if (!source || (!options && !methodNames.length)) { if (options == null) { options = source; } ctor = lodashWrapper; source = object; object = lodash; methodNames = functions(source); } if (options === false) { chain = false; } else if (isObject(options) && 'chain' in options) { chain = options.chain; } var ctor = object, isFunc = isFunction(ctor); forEach(methodNames, function(methodName) { var func = object[methodName] = source[methodName]; if (isFunc) { ctor.prototype[methodName] = function() { var chainAll = this.__chain__, value = this.__wrapped__, args = [value]; push.apply(args, arguments); var result = func.apply(object, args); if (chain || chainAll) { if (value === result && isObject(result)) { return this; } result = new ctor(result); result.__chain__ = chainAll; } return result; }; } }); } /** * Reverts the '_' variable to its previous value and returns a reference to * the `lodash` function. * * @static * @memberOf _ * @category Utilities * @returns {Function} Returns the `lodash` function. * @example * * var lodash = _.noConflict(); */ function noConflict() { context._ = oldDash; return this; } /** * A no-operation function. * * @static * @memberOf _ * @category Utilities * @example * * var object = { 'name': 'fred' }; * _.noop(object) === undefined; * // => true */ function noop() { // no operation performed } /** * Gets the number of milliseconds that have elapsed since the Unix epoch * (1 January 1970 00:00:00 UTC). * * @static * @memberOf _ * @category Utilities * @example * * var stamp = _.now(); * _.defer(function() { console.log(_.now() - stamp); }); * // => logs the number of milliseconds it took for the deferred function to be called */ var now = isNative(now = Date.now) && now || function() { return new Date().getTime(); }; /** * Converts the given value into an integer of the specified radix. * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the * `value` is a hexadecimal, in which case a `radix` of `16` is used. * * Note: This method avoids differences in native ES3 and ES5 `parseInt` * implementations. See http://es5.github.io/#E. * * @static * @memberOf _ * @category Utilities * @param {string} value The value to parse. * @param {number} [radix] The radix used to interpret the value to parse. * @returns {number} Returns the new integer value. * @example * * _.parseInt('08'); * // => 8 */ var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) { // Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt` return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0); }; /** * Creates a "_.pluck" style function, which returns the `key` value of a * given object. * * @static * @memberOf _ * @category Utilities * @param {string} key The name of the property to retrieve. * @returns {Function} Returns the new function. * @example * * var characters = [ * { 'name': 'fred', 'age': 40 }, * { 'name': 'barney', 'age': 36 } * ]; * * var getName = _.property('name'); * * _.map(characters, getName); * // => ['barney', 'fred'] * * _.sortBy(characters, getName); * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }] */ function property(key) { return function(object) { return object[key]; }; } /** * Produces a random number between `min` and `max` (inclusive). If only one * argument is provided a number between `0` and the given number will be * returned. If `floating` is truey or either `min` or `max` are floats a * floating-point number will be returned instead of an integer. * * @static * @memberOf _ * @category Utilities * @param {number} [min=0] The minimum possible value. * @param {number} [max=1] The maximum possible value. * @param {boolean} [floating=false] Specify returning a floating-point number. * @returns {number} Returns a random number. * @example * * _.random(0, 5); * // => an integer between 0 and 5 * * _.random(5); * // => also an integer between 0 and 5 * * _.random(5, true); * // => a floating-point number between 0 and 5 * * _.random(1.2, 5.2); * // => a floating-point number between 1.2 and 5.2 */ function random(min, max, floating) { var noMin = min == null, noMax = max == null; if (floating == null) { if (typeof min == 'boolean' && noMax) { floating = min; min = 1; } else if (!noMax && typeof max == 'boolean') { floating = max; noMax = true; } } if (noMin && noMax) { max = 1; } min = +min || 0; if (noMax) { max = min; min = 0; } else { max = +max || 0; } if (floating || min % 1 || max % 1) { var rand = nativeRandom(); return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max); } return baseRandom(min, max); } /** * Resolves the value of property `key` on `object`. If `key` is a function * it will be invoked with the `this` binding of `object` and its result returned, * else the property value is returned. If `object` is falsey then `undefined` * is returned. * * @static * @memberOf _ * @category Utilities * @param {Object} object The object to inspect. * @param {string} key The name of the property to resolve. * @returns {*} Returns the resolved value. * @example * * var object = { * 'cheese': 'crumpets', * 'stuff': function() { * return 'nonsense'; * } * }; * * _.result(object, 'cheese'); * // => 'crumpets' * * _.result(object, 'stuff'); * // => 'nonsense' */ function result(object, key) { if (object) { var value = object[key]; return isFunction(value) ? object[key]() : value; } } /** * A micro-templating method that handles arbitrary delimiters, preserves * whitespace, and correctly escapes quotes within interpolated code. * * Note: In the development build, `_.template` utilizes sourceURLs for easier * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl * * For more information on precompiling templates see: * https://lodash.com/custom-builds * * For more information on Chrome extension sandboxes see: * http://developer.chrome.com/stable/extensions/sandboxingEval.html * * @static * @memberOf _ * @category Utilities * @param {string} text The template text. * @param {Object} data The data object used to populate the text. * @param {Object} [options] The options object. * @param {RegExp} [options.escape] The "escape" delimiter. * @param {RegExp} [options.evaluate] The "evaluate" delimiter. * @param {Object} [options.imports] An object to import into the template as local variables. * @param {RegExp} [options.interpolate] The "interpolate" delimiter. * @param {string} [sourceURL] The sourceURL of the template's compiled source. * @param {string} [variable] The data object variable name. * @returns {Function|string} Returns a compiled function when no `data` object * is given, else it returns the interpolated text. * @example * * // using the "interpolate" delimiter to create a compiled template * var compiled = _.template('hello <%= name %>'); * compiled({ 'name': 'fred' }); * // => 'hello fred' * * // using the "escape" delimiter to escape HTML in data property values * _.template('<%- value %>', { 'value': '", 'Script'); }; WYMeditor.XhtmlLexer.prototype.addCssTokens = function(scope) { this.addEntryPattern("Hello world!
* this.contentTag('div', this.contentTag('p', "Hello world!"), jQuery({class : "strong"})) * # =>Hello world!
element,
for example), we need a slightly complicated approach to get the boundary's offset in IE. The facts:
- Each line break is represented as \r in the text node's data/nodeValue properties
- Each line break is represented as \r\n in the TextRange's 'text' property
- The 'text' property of the TextRange does not contain trailing line breaks
To get round the problem presented by the final fact above, we can use the fact that TextRange's
moveStart() and moveEnd() methods return the actual number of characters moved, which is not necessarily
the same as the number of characters it was instructed to move. The simplest approach is to use this to
store the characters moved when moving both the start and end of the range to the start of the document
body and subtracting the start offset from the end offset (the "move-negative-gazillion" method).
However, this is extremely slow when the document is large and the range is near the end of it. Clearly
doing the mirror image (i.e. moving the range boundaries to the end of the document) has the same
problem.
Another approach that works is to use moveStart() to move the start boundary of the range up to the end
boundary one character at a time and incrementing a counter with the value returned by the moveStart()
call. However, the check for whether the start boundary has reached the end boundary is expensive, so
this method is slow (although unlike "move-negative-gazillion" is largely unaffected by the location of
the range within the document).
The method below is a hybrid of the two methods above. It uses the fact that a string containing the
TextRange's 'text' property with each \r\n converted to a single \r character cannot be longer than the
text of the TextRange, so the start of the range is moved that length initially and then a character at
a time to make up for any trailing line breaks not contained in the 'text' property. This has good
performance in most situations compared to the previous two methods.
*/
var tempRange = workingRange.duplicate();
var rangeLength = tempRange.text.replace(/\r\n/g, "\r").length;
offset = tempRange.moveStart("character", rangeLength);
while ( (comparison = tempRange.compareEndPoints("StartToEnd", tempRange)) == -1) {
offset++;
tempRange.moveStart("character", 1);
}
} else {
offset = workingRange.text.length;
}
boundaryPosition = new DomPosition(boundaryNode, offset);
} else {
// If the boundary immediately follows a character data node and this is the end boundary, we should favour
// a position within that, and likewise for a start boundary preceding a character data node
previousNode = (isCollapsed || !isStart) && workingNode.previousSibling;
nextNode = (isCollapsed || isStart) && workingNode.nextSibling;
if (nextNode && dom.isCharacterDataNode(nextNode)) {
boundaryPosition = new DomPosition(nextNode, 0);
} else if (previousNode && dom.isCharacterDataNode(previousNode)) {
boundaryPosition = new DomPosition(previousNode, previousNode.length);
} else {
boundaryPosition = new DomPosition(containerElement, dom.getNodeIndex(workingNode));
}
}
// Clean up
workingNode.parentNode.removeChild(workingNode);
return boundaryPosition;
}
// Returns a TextRange representing the boundary of a TextRange expressed as a node and an offset within that node.
// This function started out as an optimized version of code found in Tim Cameron Ryan's IERange
// (http://code.google.com/p/ierange/)
function createBoundaryTextRange(boundaryPosition, isStart) {
var boundaryNode, boundaryParent, boundaryOffset = boundaryPosition.offset;
var doc = dom.getDocument(boundaryPosition.node);
var workingNode, childNodes, workingRange = doc.body.createTextRange();
var nodeIsDataNode = dom.isCharacterDataNode(boundaryPosition.node);
if (nodeIsDataNode) {
boundaryNode = boundaryPosition.node;
boundaryParent = boundaryNode.parentNode;
} else {
childNodes = boundaryPosition.node.childNodes;
boundaryNode = (boundaryOffset < childNodes.length) ? childNodes[boundaryOffset] : null;
boundaryParent = boundaryPosition.node;
}
// Position the range immediately before the node containing the boundary
workingNode = doc.createElement("span");
// Making the working element non-empty element persuades IE to consider the TextRange boundary to be within the
// element rather than immediately before or after it, which is what we want
workingNode.innerHTML = "&#feff;";
// insertBefore is supposed to work like appendChild if the second parameter is null. However, a bug report
// for IERange suggests that it can crash the browser: http://code.google.com/p/ierange/issues/detail?id=12
if (boundaryNode) {
boundaryParent.insertBefore(workingNode, boundaryNode);
} else {
boundaryParent.appendChild(workingNode);
}
workingRange.moveToElementText(workingNode);
workingRange.collapse(!isStart);
// Clean up
boundaryParent.removeChild(workingNode);
// Move the working range to the text offset, if required
if (nodeIsDataNode) {
workingRange[isStart ? "moveStart" : "moveEnd"]("character", boundaryOffset);
}
return workingRange;
}
/*----------------------------------------------------------------------------------------------------------------*/
if (api.features.implementsDomRange && (!api.features.implementsTextRange || !api.config.preferTextRange)) {
// This is a wrapper around the browser's native DOM Range. It has two aims:
// - Provide workarounds for specific browser bugs
// - provide convenient extensions, which are inherited from Rangy's DomRange
(function() {
var rangeProto;
var rangeProperties = DomRange.rangeProperties;
var canSetRangeStartAfterEnd;
function updateRangeProperties(range) {
var i = rangeProperties.length, prop;
while (i--) {
prop = rangeProperties[i];
range[prop] = range.nativeRange[prop];
}
}
function updateNativeRange(range, startContainer, startOffset, endContainer,endOffset) {
var startMoved = (range.startContainer !== startContainer || range.startOffset != startOffset);
var endMoved = (range.endContainer !== endContainer || range.endOffset != endOffset);
// Always set both boundaries for the benefit of IE9 (see issue 35)
if (startMoved || endMoved) {
range.setEnd(endContainer, endOffset);
range.setStart(startContainer, startOffset);
}
}
function detach(range) {
range.nativeRange.detach();
range.detached = true;
var i = rangeProperties.length, prop;
while (i--) {
prop = rangeProperties[i];
range[prop] = null;
}
}
var createBeforeAfterNodeSetter;
WrappedRange = function(range) {
if (!range) {
throw new Error("Range must be specified");
}
this.nativeRange = range;
updateRangeProperties(this);
};
DomRange.createPrototypeRange(WrappedRange, updateNativeRange, detach);
rangeProto = WrappedRange.prototype;
rangeProto.selectNode = function(node) {
this.nativeRange.selectNode(node);
updateRangeProperties(this);
};
rangeProto.deleteContents = function() {
this.nativeRange.deleteContents();
updateRangeProperties(this);
};
rangeProto.extractContents = function() {
var frag = this.nativeRange.extractContents();
updateRangeProperties(this);
return frag;
};
rangeProto.cloneContents = function() {
return this.nativeRange.cloneContents();
};
// TODO: Until I can find a way to programmatically trigger the Firefox bug (apparently long-standing, still
// present in 3.6.8) that throws "Index or size is negative or greater than the allowed amount" for
// insertNode in some circumstances, all browsers will have to use the Rangy's own implementation of
// insertNode, which works but is almost certainly slower than the native implementation.
/*
rangeProto.insertNode = function(node) {
this.nativeRange.insertNode(node);
updateRangeProperties(this);
};
*/
rangeProto.surroundContents = function(node) {
this.nativeRange.surroundContents(node);
updateRangeProperties(this);
};
rangeProto.collapse = function(isStart) {
this.nativeRange.collapse(isStart);
updateRangeProperties(this);
};
rangeProto.cloneRange = function() {
return new WrappedRange(this.nativeRange.cloneRange());
};
rangeProto.refresh = function() {
updateRangeProperties(this);
};
rangeProto.toString = function() {
return this.nativeRange.toString();
};
// Create test range and node for feature detection
var testTextNode = document.createTextNode("test");
dom.getBody(document).appendChild(testTextNode);
var range = document.createRange();
/*--------------------------------------------------------------------------------------------------------*/
// Test for Firefox 2 bug that prevents moving the start of a Range to a point after its current end and
// correct for it
range.setStart(testTextNode, 0);
range.setEnd(testTextNode, 0);
try {
range.setStart(testTextNode, 1);
canSetRangeStartAfterEnd = true;
rangeProto.setStart = function(node, offset) {
this.nativeRange.setStart(node, offset);
updateRangeProperties(this);
};
rangeProto.setEnd = function(node, offset) {
this.nativeRange.setEnd(node, offset);
updateRangeProperties(this);
};
createBeforeAfterNodeSetter = function(name) {
return function(node) {
this.nativeRange[name](node);
updateRangeProperties(this);
};
};
} catch(ex) {
canSetRangeStartAfterEnd = false;
rangeProto.setStart = function(node, offset) {
try {
this.nativeRange.setStart(node, offset);
} catch (ex) {
this.nativeRange.setEnd(node, offset);
this.nativeRange.setStart(node, offset);
}
updateRangeProperties(this);
};
rangeProto.setEnd = function(node, offset) {
try {
this.nativeRange.setEnd(node, offset);
} catch (ex) {
this.nativeRange.setStart(node, offset);
this.nativeRange.setEnd(node, offset);
}
updateRangeProperties(this);
};
createBeforeAfterNodeSetter = function(name, oppositeName) {
return function(node) {
try {
this.nativeRange[name](node);
} catch (ex) {
this.nativeRange[oppositeName](node);
this.nativeRange[name](node);
}
updateRangeProperties(this);
};
};
}
rangeProto.setStartBefore = createBeforeAfterNodeSetter("setStartBefore", "setEndBefore");
rangeProto.setStartAfter = createBeforeAfterNodeSetter("setStartAfter", "setEndAfter");
rangeProto.setEndBefore = createBeforeAfterNodeSetter("setEndBefore", "setStartBefore");
rangeProto.setEndAfter = createBeforeAfterNodeSetter("setEndAfter", "setStartAfter");
/*--------------------------------------------------------------------------------------------------------*/
// Test for and correct Firefox 2 behaviour with selectNodeContents on text nodes: it collapses the range to
// the 0th character of the text node
range.selectNodeContents(testTextNode);
if (range.startContainer == testTextNode && range.endContainer == testTextNode &&
range.startOffset == 0 && range.endOffset == testTextNode.length) {
rangeProto.selectNodeContents = function(node) {
this.nativeRange.selectNodeContents(node);
updateRangeProperties(this);
};
} else {
rangeProto.selectNodeContents = function(node) {
this.setStart(node, 0);
this.setEnd(node, DomRange.getEndOffset(node));
};
}
/*--------------------------------------------------------------------------------------------------------*/
// Test for WebKit bug that has the beahviour of compareBoundaryPoints round the wrong way for constants
// START_TO_END and END_TO_START: https://bugs.webkit.org/show_bug.cgi?id=20738
range.selectNodeContents(testTextNode);
range.setEnd(testTextNode, 3);
var range2 = document.createRange();
range2.selectNodeContents(testTextNode);
range2.setEnd(testTextNode, 4);
range2.setStart(testTextNode, 2);
if (range.compareBoundaryPoints(range.START_TO_END, range2) == -1 &
range.compareBoundaryPoints(range.END_TO_START, range2) == 1) {
// This is the wrong way round, so correct for it
rangeProto.compareBoundaryPoints = function(type, range) {
range = range.nativeRange || range;
if (type == range.START_TO_END) {
type = range.END_TO_START;
} else if (type == range.END_TO_START) {
type = range.START_TO_END;
}
return this.nativeRange.compareBoundaryPoints(type, range);
};
} else {
rangeProto.compareBoundaryPoints = function(type, range) {
return this.nativeRange.compareBoundaryPoints(type, range.nativeRange || range);
};
}
/*--------------------------------------------------------------------------------------------------------*/
// Test for existence of createContextualFragment and delegate to it if it exists
if (api.util.isHostMethod(range, "createContextualFragment")) {
rangeProto.createContextualFragment = function(fragmentStr) {
return this.nativeRange.createContextualFragment(fragmentStr);
};
}
/*--------------------------------------------------------------------------------------------------------*/
// Clean up
dom.getBody(document).removeChild(testTextNode);
range.detach();
range2.detach();
})();
api.createNativeRange = function(doc) {
doc = doc || document;
return doc.createRange();
};
} else if (api.features.implementsTextRange) {
// This is a wrapper around a TextRange, providing full DOM Range functionality using rangy's DomRange as a
// prototype
WrappedRange = function(textRange) {
this.textRange = textRange;
this.refresh();
};
WrappedRange.prototype = new DomRange(document);
WrappedRange.prototype.refresh = function() {
var start, end;
// TextRange's parentElement() method cannot be trusted. getTextRangeContainerElement() works around that.
var rangeContainerElement = getTextRangeContainerElement(this.textRange);
if (textRangeIsCollapsed(this.textRange)) {
end = start = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true, true);
} else {
start = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true, false);
end = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, false, false);
}
this.setStart(start.node, start.offset);
this.setEnd(end.node, end.offset);
};
DomRange.copyComparisonConstants(WrappedRange);
// Add WrappedRange as the Range property of the global object to allow expression like Range.END_TO_END to work
var globalObj = (function() { return this; })();
if (typeof globalObj.Range == "undefined") {
globalObj.Range = WrappedRange;
}
api.createNativeRange = function(doc) {
doc = doc || document;
return doc.body.createTextRange();
};
}
if (api.features.implementsTextRange) {
WrappedRange.rangeToTextRange = function(range) {
if (range.collapsed) {
var tr = createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);
return tr;
//return createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);
} else {
var startRange = createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);
var endRange = createBoundaryTextRange(new DomPosition(range.endContainer, range.endOffset), false);
var textRange = dom.getDocument(range.startContainer).body.createTextRange();
textRange.setEndPoint("StartToStart", startRange);
textRange.setEndPoint("EndToEnd", endRange);
return textRange;
}
};
}
WrappedRange.prototype.getName = function() {
return "WrappedRange";
};
api.WrappedRange = WrappedRange;
api.createRange = function(doc) {
doc = doc || document;
return new WrappedRange(api.createNativeRange(doc));
};
api.createRangyRange = function(doc) {
doc = doc || document;
return new DomRange(doc);
};
api.createIframeRange = function(iframeEl) {
return api.createRange(dom.getIframeDocument(iframeEl));
};
api.createIframeRangyRange = function(iframeEl) {
return api.createRangyRange(dom.getIframeDocument(iframeEl));
};
api.addCreateMissingNativeApiListener(function(win) {
var doc = win.document;
if (typeof doc.createRange == "undefined") {
doc.createRange = function() {
return api.createRange(this);
};
}
doc = win = null;
});
});rangy.createModule("WrappedSelection", function(api, module) {
// This will create a selection object wrapper that follows the Selection object found in the WHATWG draft DOM Range
// spec (http://html5.org/specs/dom-range.html)
api.requireModules( ["DomUtil", "DomRange", "WrappedRange"] );
api.config.checkSelectionRanges = true;
var BOOLEAN = "boolean",
windowPropertyName = "_rangySelection",
dom = api.dom,
util = api.util,
DomRange = api.DomRange,
WrappedRange = api.WrappedRange,
DOMException = api.DOMException,
DomPosition = dom.DomPosition,
getSelection,
selectionIsCollapsed,
CONTROL = "Control";
function getWinSelection(winParam) {
return (winParam || window).getSelection();
}
function getDocSelection(winParam) {
return (winParam || window).document.selection;
}
// Test for the Range/TextRange and Selection features required
// Test for ability to retrieve selection
var implementsWinGetSelection = api.util.isHostMethod(window, "getSelection"),
implementsDocSelection = api.util.isHostObject(document, "selection");
var useDocumentSelection = implementsDocSelection && (!implementsWinGetSelection || api.config.preferTextRange);
if (useDocumentSelection) {
getSelection = getDocSelection;
api.isSelectionValid = function(winParam) {
var doc = (winParam || window).document, nativeSel = doc.selection;
// Check whether the selection TextRange is actually contained within the correct document
return (nativeSel.type != "None" || dom.getDocument(nativeSel.createRange().parentElement()) == doc);
};
} else if (implementsWinGetSelection) {
getSelection = getWinSelection;
api.isSelectionValid = function() {
return true;
};
} else {
module.fail("Neither document.selection or window.getSelection() detected.");
}
api.getNativeSelection = getSelection;
var testSelection = getSelection();
var testRange = api.createNativeRange(document);
var body = dom.getBody(document);
// Obtaining a range from a selection
var selectionHasAnchorAndFocus = util.areHostObjects(testSelection, ["anchorNode", "focusNode"] &&
util.areHostProperties(testSelection, ["anchorOffset", "focusOffset"]));
api.features.selectionHasAnchorAndFocus = selectionHasAnchorAndFocus;
// Test for existence of native selection extend() method
var selectionHasExtend = util.isHostMethod(testSelection, "extend");
api.features.selectionHasExtend = selectionHasExtend;
// Test if rangeCount exists
var selectionHasRangeCount = (typeof testSelection.rangeCount == "number");
api.features.selectionHasRangeCount = selectionHasRangeCount;
var selectionSupportsMultipleRanges = false;
var collapsedNonEditableSelectionsSupported = true;
if (util.areHostMethods(testSelection, ["addRange", "getRangeAt", "removeAllRanges"]) &&
typeof testSelection.rangeCount == "number" && api.features.implementsDomRange) {
(function() {
var iframe = document.createElement("iframe");
body.appendChild(iframe);
var iframeDoc = dom.getIframeDocument(iframe);
iframeDoc.open();
iframeDoc.write("12");
iframeDoc.close();
var sel = dom.getIframeWindow(iframe).getSelection();
var docEl = iframeDoc.documentElement;
var iframeBody = docEl.lastChild, textNode = iframeBody.firstChild;
// Test whether the native selection will allow a collapsed selection within a non-editable element
var r1 = iframeDoc.createRange();
r1.setStart(textNode, 1);
r1.collapse(true);
sel.addRange(r1);
collapsedNonEditableSelectionsSupported = (sel.rangeCount == 1);
sel.removeAllRanges();
// Test whether the native selection is capable of supporting multiple ranges
var r2 = r1.cloneRange();
r1.setStart(textNode, 0);
r2.setEnd(textNode, 2);
sel.addRange(r1);
sel.addRange(r2);
selectionSupportsMultipleRanges = (sel.rangeCount == 2);
// Clean up
r1.detach();
r2.detach();
body.removeChild(iframe);
})();
}
api.features.selectionSupportsMultipleRanges = selectionSupportsMultipleRanges;
api.features.collapsedNonEditableSelectionsSupported = collapsedNonEditableSelectionsSupported;
// ControlRanges
var implementsControlRange = false, testControlRange;
if (body && util.isHostMethod(body, "createControlRange")) {
testControlRange = body.createControlRange();
if (util.areHostProperties(testControlRange, ["item", "add"])) {
implementsControlRange = true;
}
}
api.features.implementsControlRange = implementsControlRange;
// Selection collapsedness
if (selectionHasAnchorAndFocus) {
selectionIsCollapsed = function(sel) {
return sel.anchorNode === sel.focusNode && sel.anchorOffset === sel.focusOffset;
};
} else {
selectionIsCollapsed = function(sel) {
return sel.rangeCount ? sel.getRangeAt(sel.rangeCount - 1).collapsed : false;
};
}
function updateAnchorAndFocusFromRange(sel, range, backwards) {
var anchorPrefix = backwards ? "end" : "start", focusPrefix = backwards ? "start" : "end";
sel.anchorNode = range[anchorPrefix + "Container"];
sel.anchorOffset = range[anchorPrefix + "Offset"];
sel.focusNode = range[focusPrefix + "Container"];
sel.focusOffset = range[focusPrefix + "Offset"];
}
function updateAnchorAndFocusFromNativeSelection(sel) {
var nativeSel = sel.nativeSelection;
sel.anchorNode = nativeSel.anchorNode;
sel.anchorOffset = nativeSel.anchorOffset;
sel.focusNode = nativeSel.focusNode;
sel.focusOffset = nativeSel.focusOffset;
}
function updateEmptySelection(sel) {
sel.anchorNode = sel.focusNode = null;
sel.anchorOffset = sel.focusOffset = 0;
sel.rangeCount = 0;
sel.isCollapsed = true;
sel._ranges.length = 0;
}
function getNativeRange(range) {
var nativeRange;
if (range instanceof DomRange) {
nativeRange = range._selectionNativeRange;
if (!nativeRange) {
nativeRange = api.createNativeRange(dom.getDocument(range.startContainer));
nativeRange.setEnd(range.endContainer, range.endOffset);
nativeRange.setStart(range.startContainer, range.startOffset);
range._selectionNativeRange = nativeRange;
range.attachListener("detach", function() {
this._selectionNativeRange = null;
});
}
} else if (range instanceof WrappedRange) {
nativeRange = range.nativeRange;
} else if (api.features.implementsDomRange && (range instanceof dom.getWindow(range.startContainer).Range)) {
nativeRange = range;
}
return nativeRange;
}
function rangeContainsSingleElement(rangeNodes) {
if (!rangeNodes.length || rangeNodes[0].nodeType != 1) {
return false;
}
for (var i = 1, len = rangeNodes.length; i < len; ++i) {
if (!dom.isAncestorOf(rangeNodes[0], rangeNodes[i])) {
return false;
}
}
return true;
}
function getSingleElementFromRange(range) {
var nodes = range.getNodes();
if (!rangeContainsSingleElement(nodes)) {
throw new Error("getSingleElementFromRange: range " + range.inspect() + " did not consist of a single element");
}
return nodes[0];
}
function isTextRange(range) {
return !!range && typeof range.text != "undefined";
}
function updateFromTextRange(sel, range) {
// Create a Range from the selected TextRange
var wrappedRange = new WrappedRange(range);
sel._ranges = [wrappedRange];
updateAnchorAndFocusFromRange(sel, wrappedRange, false);
sel.rangeCount = 1;
sel.isCollapsed = wrappedRange.collapsed;
}
function updateControlSelection(sel) {
// Update the wrapped selection based on what's now in the native selection
sel._ranges.length = 0;
if (sel.docSelection.type == "None") {
updateEmptySelection(sel);
} else {
var controlRange = sel.docSelection.createRange();
if (isTextRange(controlRange)) {
// This case (where the selection type is "Control" and calling createRange() on the selection returns
// a TextRange) can happen in IE 9. It happens, for example, when all elements in the selected
// ControlRange have been removed from the ControlRange and removed from the document.
updateFromTextRange(sel, controlRange);
} else {
sel.rangeCount = controlRange.length;
var range, doc = dom.getDocument(controlRange.item(0));
for (var i = 0; i < sel.rangeCount; ++i) {
range = api.createRange(doc);
range.selectNode(controlRange.item(i));
sel._ranges.push(range);
}
sel.isCollapsed = sel.rangeCount == 1 && sel._ranges[0].collapsed;
updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);
}
}
}
function addRangeToControlSelection(sel, range) {
var controlRange = sel.docSelection.createRange();
var rangeElement = getSingleElementFromRange(range);
// Create a new ControlRange containing all the elements in the selected ControlRange plus the element
// contained by the supplied range
var doc = dom.getDocument(controlRange.item(0));
var newControlRange = dom.getBody(doc).createControlRange();
for (var i = 0, len = controlRange.length; i < len; ++i) {
newControlRange.add(controlRange.item(i));
}
try {
newControlRange.add(rangeElement);
} catch (ex) {
throw new Error("addRange(): Element within the specified Range could not be added to control selection (does it have layout?)");
}
newControlRange.select();
// Update the wrapped selection based on what's now in the native selection
updateControlSelection(sel);
}
var getSelectionRangeAt;
if (util.isHostMethod(testSelection, "getRangeAt")) {
getSelectionRangeAt = function(sel, index) {
try {
return sel.getRangeAt(index);
} catch(ex) {
return null;
}
};
} else if (selectionHasAnchorAndFocus) {
getSelectionRangeAt = function(sel) {
var doc = dom.getDocument(sel.anchorNode);
var range = api.createRange(doc);
range.setStart(sel.anchorNode, sel.anchorOffset);
range.setEnd(sel.focusNode, sel.focusOffset);
// Handle the case when the selection was selected backwards (from the end to the start in the
// document)
if (range.collapsed !== this.isCollapsed) {
range.setStart(sel.focusNode, sel.focusOffset);
range.setEnd(sel.anchorNode, sel.anchorOffset);
}
return range;
};
}
/**
* @constructor
*/
function WrappedSelection(selection, docSelection, win) {
this.nativeSelection = selection;
this.docSelection = docSelection;
this._ranges = [];
this.win = win;
this.refresh();
}
api.getSelection = function(win) {
win = win || window;
var sel = win[windowPropertyName];
var nativeSel = getSelection(win), docSel = implementsDocSelection ? getDocSelection(win) : null;
if (sel) {
sel.nativeSelection = nativeSel;
sel.docSelection = docSel;
sel.refresh(win);
} else {
sel = new WrappedSelection(nativeSel, docSel, win);
win[windowPropertyName] = sel;
}
return sel;
};
api.getIframeSelection = function(iframeEl) {
return api.getSelection(dom.getIframeWindow(iframeEl));
};
var selProto = WrappedSelection.prototype;
function createControlSelection(sel, ranges) {
// Ensure that the selection becomes of type "Control"
var doc = dom.getDocument(ranges[0].startContainer);
var controlRange = dom.getBody(doc).createControlRange();
for (var i = 0, el; i < rangeCount; ++i) {
el = getSingleElementFromRange(ranges[i]);
try {
controlRange.add(el);
} catch (ex) {
throw new Error("setRanges(): Element within the one of the specified Ranges could not be added to control selection (does it have layout?)");
}
}
controlRange.select();
// Update the wrapped selection based on what's now in the native selection
updateControlSelection(sel);
}
// Selecting a range
if (!useDocumentSelection && selectionHasAnchorAndFocus && util.areHostMethods(testSelection, ["removeAllRanges", "addRange"])) {
selProto.removeAllRanges = function() {
this.nativeSelection.removeAllRanges();
updateEmptySelection(this);
};
var addRangeBackwards = function(sel, range) {
var doc = DomRange.getRangeDocument(range);
var endRange = api.createRange(doc);
endRange.collapseToPoint(range.endContainer, range.endOffset);
sel.nativeSelection.addRange(getNativeRange(endRange));
sel.nativeSelection.extend(range.startContainer, range.startOffset);
sel.refresh();
};
if (selectionHasRangeCount) {
selProto.addRange = function(range, backwards) {
if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {
addRangeToControlSelection(this, range);
} else {
if (backwards && selectionHasExtend) {
addRangeBackwards(this, range);
} else {
var previousRangeCount;
if (selectionSupportsMultipleRanges) {
previousRangeCount = this.rangeCount;
} else {
this.removeAllRanges();
previousRangeCount = 0;
}
this.nativeSelection.addRange(getNativeRange(range));
// Check whether adding the range was successful
this.rangeCount = this.nativeSelection.rangeCount;
if (this.rangeCount == previousRangeCount + 1) {
// The range was added successfully
// Check whether the range that we added to the selection is reflected in the last range extracted from
// the selection
if (api.config.checkSelectionRanges) {
var nativeRange = getSelectionRangeAt(this.nativeSelection, this.rangeCount - 1);
if (nativeRange && !DomRange.rangesEqual(nativeRange, range)) {
// Happens in WebKit with, for example, a selection placed at the start of a text node
range = new WrappedRange(nativeRange);
}
}
this._ranges[this.rangeCount - 1] = range;
updateAnchorAndFocusFromRange(this, range, selectionIsBackwards(this.nativeSelection));
this.isCollapsed = selectionIsCollapsed(this);
} else {
// The range was not added successfully. The simplest thing is to refresh
this.refresh();
}
}
}
};
} else {
selProto.addRange = function(range, backwards) {
if (backwards && selectionHasExtend) {
addRangeBackwards(this, range);
} else {
this.nativeSelection.addRange(getNativeRange(range));
this.refresh();
}
};
}
selProto.setRanges = function(ranges) {
if (implementsControlRange && ranges.length > 1) {
createControlSelection(this, ranges);
} else {
this.removeAllRanges();
for (var i = 0, len = ranges.length; i < len; ++i) {
this.addRange(ranges[i]);
}
}
};
} else if (util.isHostMethod(testSelection, "empty") && util.isHostMethod(testRange, "select") &&
implementsControlRange && useDocumentSelection) {
selProto.removeAllRanges = function() {
// Added try/catch as fix for issue #21
try {
this.docSelection.empty();
// Check for empty() not working (issue #24)
if (this.docSelection.type != "None") {
// Work around failure to empty a control selection by instead selecting a TextRange and then
// calling empty()
var doc;
if (this.anchorNode) {
doc = dom.getDocument(this.anchorNode);
} else if (this.docSelection.type == CONTROL) {
var controlRange = this.docSelection.createRange();
if (controlRange.length) {
doc = dom.getDocument(controlRange.item(0)).body.createTextRange();
}
}
if (doc) {
var textRange = doc.body.createTextRange();
textRange.select();
this.docSelection.empty();
}
}
} catch(ex) {}
updateEmptySelection(this);
};
selProto.addRange = function(range) {
if (this.docSelection.type == CONTROL) {
addRangeToControlSelection(this, range);
} else {
WrappedRange.rangeToTextRange(range).select();
this._ranges[0] = range;
this.rangeCount = 1;
this.isCollapsed = this._ranges[0].collapsed;
updateAnchorAndFocusFromRange(this, range, false);
}
};
selProto.setRanges = function(ranges) {
this.removeAllRanges();
var rangeCount = ranges.length;
if (rangeCount > 1) {
createControlSelection(this, ranges);
} else if (rangeCount) {
this.addRange(ranges[0]);
}
};
} else {
module.fail("No means of selecting a Range or TextRange was found");
return false;
}
selProto.getRangeAt = function(index) {
if (index < 0 || index >= this.rangeCount) {
throw new DOMException("INDEX_SIZE_ERR");
} else {
return this._ranges[index];
}
};
var refreshSelection;
if (useDocumentSelection) {
refreshSelection = function(sel) {
var range;
if (api.isSelectionValid(sel.win)) {
range = sel.docSelection.createRange();
} else {
range = dom.getBody(sel.win.document).createTextRange();
range.collapse(true);
}
if (sel.docSelection.type == CONTROL) {
updateControlSelection(sel);
} else if (isTextRange(range)) {
updateFromTextRange(sel, range);
} else {
updateEmptySelection(sel);
}
};
} else if (util.isHostMethod(testSelection, "getRangeAt") && typeof testSelection.rangeCount == "number") {
refreshSelection = function(sel) {
if (implementsControlRange && implementsDocSelection && sel.docSelection.type == CONTROL) {
updateControlSelection(sel);
} else {
sel._ranges.length = sel.rangeCount = sel.nativeSelection.rangeCount;
if (sel.rangeCount) {
for (var i = 0, len = sel.rangeCount; i < len; ++i) {
sel._ranges[i] = new api.WrappedRange(sel.nativeSelection.getRangeAt(i));
}
updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], selectionIsBackwards(sel.nativeSelection));
sel.isCollapsed = selectionIsCollapsed(sel);
} else {
updateEmptySelection(sel);
}
}
};
} else if (selectionHasAnchorAndFocus && typeof testSelection.isCollapsed == BOOLEAN && typeof testRange.collapsed == BOOLEAN && api.features.implementsDomRange) {
refreshSelection = function(sel) {
var range, nativeSel = sel.nativeSelection;
if (nativeSel.anchorNode) {
range = getSelectionRangeAt(nativeSel, 0);
sel._ranges = [range];
sel.rangeCount = 1;
updateAnchorAndFocusFromNativeSelection(sel);
sel.isCollapsed = selectionIsCollapsed(sel);
} else {
updateEmptySelection(sel);
}
};
} else {
module.fail("No means of obtaining a Range or TextRange from the user's selection was found");
return false;
}
selProto.refresh = function(checkForChanges) {
var oldRanges = checkForChanges ? this._ranges.slice(0) : null;
refreshSelection(this);
if (checkForChanges) {
var i = oldRanges.length;
if (i != this._ranges.length) {
return false;
}
while (i--) {
if (!DomRange.rangesEqual(oldRanges[i], this._ranges[i])) {
return false;
}
}
return true;
}
};
// Removal of a single range
var removeRangeManually = function(sel, range) {
var ranges = sel.getAllRanges(), removed = false;
sel.removeAllRanges();
for (var i = 0, len = ranges.length; i < len; ++i) {
if (removed || range !== ranges[i]) {
sel.addRange(ranges[i]);
} else {
// According to the draft WHATWG Range spec, the same range may be added to the selection multiple
// times. removeRange should only remove the first instance, so the following ensures only the first
// instance is removed
removed = true;
}
}
if (!sel.rangeCount) {
updateEmptySelection(sel);
}
};
if (implementsControlRange) {
selProto.removeRange = function(range) {
if (this.docSelection.type == CONTROL) {
var controlRange = this.docSelection.createRange();
var rangeElement = getSingleElementFromRange(range);
// Create a new ControlRange containing all the elements in the selected ControlRange minus the
// element contained by the supplied range
var doc = dom.getDocument(controlRange.item(0));
var newControlRange = dom.getBody(doc).createControlRange();
var el, removed = false;
for (var i = 0, len = controlRange.length; i < len; ++i) {
el = controlRange.item(i);
if (el !== rangeElement || removed) {
newControlRange.add(controlRange.item(i));
} else {
removed = true;
}
}
newControlRange.select();
// Update the wrapped selection based on what's now in the native selection
updateControlSelection(this);
} else {
removeRangeManually(this, range);
}
};
} else {
selProto.removeRange = function(range) {
removeRangeManually(this, range);
};
}
// Detecting if a selection is backwards
var selectionIsBackwards;
if (!useDocumentSelection && selectionHasAnchorAndFocus && api.features.implementsDomRange) {
selectionIsBackwards = function(sel) {
var backwards = false;
if (sel.anchorNode) {
backwards = (dom.comparePoints(sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset) == 1);
}
return backwards;
};
selProto.isBackwards = function() {
return selectionIsBackwards(this);
};
} else {
selectionIsBackwards = selProto.isBackwards = function() {
return false;
};
}
// Selection text
// This is conformant to the new WHATWG DOM Range draft spec but differs from WebKit and Mozilla's implementation
selProto.toString = function() {
var rangeTexts = [];
for (var i = 0, len = this.rangeCount; i < len; ++i) {
rangeTexts[i] = "" + this._ranges[i];
}
return rangeTexts.join("");
};
function assertNodeInSameDocument(sel, node) {
if (sel.anchorNode && (dom.getDocument(sel.anchorNode) !== dom.getDocument(node))) {
throw new DOMException("WRONG_DOCUMENT_ERR");
}
}
// No current browsers conform fully to the HTML 5 draft spec for this method, so Rangy's own method is always used
selProto.collapse = function(node, offset) {
assertNodeInSameDocument(this, node);
var range = api.createRange(dom.getDocument(node));
range.collapseToPoint(node, offset);
this.removeAllRanges();
this.addRange(range);
this.isCollapsed = true;
};
selProto.collapseToStart = function() {
if (this.rangeCount) {
var range = this._ranges[0];
this.collapse(range.startContainer, range.startOffset);
} else {
throw new DOMException("INVALID_STATE_ERR");
}
};
selProto.collapseToEnd = function() {
if (this.rangeCount) {
var range = this._ranges[this.rangeCount - 1];
this.collapse(range.endContainer, range.endOffset);
} else {
throw new DOMException("INVALID_STATE_ERR");
}
};
// The HTML 5 spec is very specific on how selectAllChildren should be implemented so the native implementation is
// never used by Rangy.
selProto.selectAllChildren = function(node) {
assertNodeInSameDocument(this, node);
var range = api.createRange(dom.getDocument(node));
range.selectNodeContents(node);
this.removeAllRanges();
this.addRange(range);
};
selProto.deleteFromDocument = function() {
// Sepcial behaviour required for Control selections
if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {
var controlRange = this.docSelection.createRange();
var element;
while (controlRange.length) {
element = controlRange.item(0);
controlRange.remove(element);
element.parentNode.removeChild(element);
}
this.refresh();
} else if (this.rangeCount) {
var ranges = this.getAllRanges();
this.removeAllRanges();
for (var i = 0, len = ranges.length; i < len; ++i) {
ranges[i].deleteContents();
}
// The HTML5 spec says nothing about what the selection should contain after calling deleteContents on each
// range. Firefox moves the selection to where the final selected range was, so we emulate that
this.addRange(ranges[len - 1]);
}
};
// The following are non-standard extensions
selProto.getAllRanges = function() {
return this._ranges.slice(0);
};
selProto.setSingleRange = function(range) {
this.setRanges( [range] );
};
selProto.containsNode = function(node, allowPartial) {
for (var i = 0, len = this._ranges.length; i < len; ++i) {
if (this._ranges[i].containsNode(node, allowPartial)) {
return true;
}
}
return false;
};
selProto.toHtml = function() {
var html = "";
if (this.rangeCount) {
var container = DomRange.getRangeDocument(this._ranges[0]).createElement("div");
for (var i = 0, len = this._ranges.length; i < len; ++i) {
container.appendChild(this._ranges[i].cloneContents());
}
html = container.innerHTML;
}
return html;
};
function inspect(sel) {
var rangeInspects = [];
var anchor = new DomPosition(sel.anchorNode, sel.anchorOffset);
var focus = new DomPosition(sel.focusNode, sel.focusOffset);
var name = (typeof sel.getName == "function") ? sel.getName() : "Selection";
if (typeof sel.rangeCount != "undefined") {
for (var i = 0, len = sel.rangeCount; i < len; ++i) {
rangeInspects[i] = DomRange.inspect(sel.getRangeAt(i));
}
}
return "[" + name + "(Ranges: " + rangeInspects.join(", ") +
")(anchor: " + anchor.inspect() + ", focus: " + focus.inspect() + "]";
}
selProto.getName = function() {
return "WrappedSelection";
};
selProto.inspect = function() {
return inspect(this);
};
selProto.detach = function() {
this.win[windowPropertyName] = null;
this.win = this.anchorNode = this.focusNode = null;
};
WrappedSelection.inspect = inspect;
api.Selection = WrappedSelection;
api.selectionPrototype = selProto;
api.addCreateMissingNativeApiListener(function(win) {
if (typeof win.getSelection == "undefined") {
win.getSelection = function() {
return api.getSelection(this);
};
}
win = null;
});
});
/**
* @license Selection save and restore module for Rangy.
* Saves and restores user selections using marker invisible elements in the DOM.
*
* Part of Rangy, a cross-browser JavaScript range and selection library
* http://code.google.com/p/rangy/
*
* Depends on Rangy core.
*
* Copyright 2011, Tim Down
* Licensed under the MIT license.
* Version: 1.2.2
* Build date: 13 November 2011
*/
rangy.createModule("SaveRestore", function(api, module) {
api.requireModules( ["DomUtil", "DomRange", "WrappedRange"] );
var dom = api.dom;
var markerTextChar = "\ufeff";
function gEBI(id, doc) {
return (doc || document).getElementById(id);
}
function insertRangeBoundaryMarker(range, atStart) {
var markerId = "selectionBoundary_" + (+new Date()) + "_" + ("" + Math.random()).slice(2);
var markerEl;
var doc = dom.getDocument(range.startContainer);
// Clone the Range and collapse to the appropriate boundary point
var boundaryRange = range.cloneRange();
boundaryRange.collapse(atStart);
// Create the marker element containing a single invisible character using DOM methods and insert it
markerEl = doc.createElement("span");
markerEl.id = markerId;
markerEl.style.lineHeight = "0";
markerEl.style.display = "none";
markerEl.className = "rangySelectionBoundary";
markerEl.appendChild(doc.createTextNode(markerTextChar));
boundaryRange.insertNode(markerEl);
boundaryRange.detach();
return markerEl;
}
function setRangeBoundary(doc, range, markerId, atStart) {
var markerEl = gEBI(markerId, doc);
if (markerEl) {
range[atStart ? "setStartBefore" : "setEndBefore"](markerEl);
markerEl.parentNode.removeChild(markerEl);
} else {
module.warn("Marker element has been removed. Cannot restore selection.");
}
}
function compareRanges(r1, r2) {
return r2.compareBoundaryPoints(r1.START_TO_START, r1);
}
function saveSelection(win) {
win = win || window;
var doc = win.document;
if (!api.isSelectionValid(win)) {
module.warn("Cannot save selection. This usually happens when the selection is collapsed and the selection document has lost focus.");
return;
}
var sel = api.getSelection(win);
var ranges = sel.getAllRanges();
var rangeInfos = [], startEl, endEl, range;
// Order the ranges by position within the DOM, latest first
ranges.sort(compareRanges);
for (var i = 0, len = ranges.length; i < len; ++i) {
range = ranges[i];
if (range.collapsed) {
endEl = insertRangeBoundaryMarker(range, false);
rangeInfos.push({
markerId: endEl.id,
collapsed: true
});
} else {
endEl = insertRangeBoundaryMarker(range, false);
startEl = insertRangeBoundaryMarker(range, true);
rangeInfos[i] = {
startMarkerId: startEl.id,
endMarkerId: endEl.id,
collapsed: false,
backwards: ranges.length == 1 && sel.isBackwards()
};
}
}
// Now that all the markers are in place and DOM manipulation over, adjust each range's boundaries to lie
// between its markers
for (i = len - 1; i >= 0; --i) {
range = ranges[i];
if (range.collapsed) {
range.collapseBefore(gEBI(rangeInfos[i].markerId, doc));
} else {
range.setEndBefore(gEBI(rangeInfos[i].endMarkerId, doc));
range.setStartAfter(gEBI(rangeInfos[i].startMarkerId, doc));
}
}
// Ensure current selection is unaffected
sel.setRanges(ranges);
return {
win: win,
doc: doc,
rangeInfos: rangeInfos,
restored: false
};
}
function restoreSelection(savedSelection, preserveDirection) {
if (!savedSelection.restored) {
var rangeInfos = savedSelection.rangeInfos;
var sel = api.getSelection(savedSelection.win);
var ranges = [];
// Ranges are in reverse order of appearance in the DOM. We want to restore earliest first to avoid
// normalization affecting previously restored ranges.
for (var len = rangeInfos.length, i = len - 1, rangeInfo, range; i >= 0; --i) {
rangeInfo = rangeInfos[i];
range = api.createRange(savedSelection.doc);
if (rangeInfo.collapsed) {
var markerEl = gEBI(rangeInfo.markerId, savedSelection.doc);
if (markerEl) {
markerEl.style.display = "inline";
var previousNode = markerEl.previousSibling;
// Workaround for issue 17
if (previousNode && previousNode.nodeType == 3) {
markerEl.parentNode.removeChild(markerEl);
range.collapseToPoint(previousNode, previousNode.length);
} else {
range.collapseBefore(markerEl);
markerEl.parentNode.removeChild(markerEl);
}
} else {
module.warn("Marker element has been removed. Cannot restore selection.");
}
} else {
setRangeBoundary(savedSelection.doc, range, rangeInfo.startMarkerId, true);
setRangeBoundary(savedSelection.doc, range, rangeInfo.endMarkerId, false);
}
// Normalizing range boundaries is only viable if the selection contains only one range. For example,
// if the selection contained two ranges that were both contained within the same single text node,
// both would alter the same text node when restoring and break the other range.
if (len == 1) {
range.normalizeBoundaries();
}
ranges[i] = range;
}
if (len == 1 && preserveDirection && api.features.selectionHasExtend && rangeInfos[0].backwards) {
sel.removeAllRanges();
sel.addRange(ranges[0], true);
} else {
sel.setRanges(ranges);
}
savedSelection.restored = true;
}
}
function removeMarkerElement(doc, markerId) {
var markerEl = gEBI(markerId, doc);
if (markerEl) {
markerEl.parentNode.removeChild(markerEl);
}
}
function removeMarkers(savedSelection) {
var rangeInfos = savedSelection.rangeInfos;
for (var i = 0, len = rangeInfos.length, rangeInfo; i < len; ++i) {
rangeInfo = rangeInfos[i];
if (rangeInfo.collapsed) {
removeMarkerElement(savedSelection.doc, rangeInfo.markerId);
} else {
removeMarkerElement(savedSelection.doc, rangeInfo.startMarkerId);
removeMarkerElement(savedSelection.doc, rangeInfo.endMarkerId);
}
}
}
api.saveSelection = saveSelection;
api.restoreSelection = restoreSelection;
api.removeMarkerElement = removeMarkerElement;
api.removeMarkers = removeMarkers;
});
/* globals -$ */
"use strict";
WYMeditor.SKINS.compact = {
init: function(wym) {
// Move the containers panel to the top area
jQuery(wym._options.containersSelector + ', ' +
wym._options.classesSelector, wym._box)
.appendTo( jQuery("div.wym_area_top", wym._box) )
.addClass("wym_dropdown")
.css({"margin-right": "10px", "width": "120px", "float": "left"});
// Render following sections as buttons
jQuery(wym._options.toolsSelector, wym._box)
.addClass("wym_buttons")
.css({"margin-right": "10px", "float": "left"});
// Make hover work under IE < 7
jQuery(".wym_section", wym._box).hover(function(){
jQuery(this).addClass("hover");
},function(){
jQuery(this).removeClass("hover");
});
var postInit = wym._options.postInit;
wym._options.postInit = function(wym) {
if (postInit) {
postInit.call(wym, wym);
}
wym.$body().css('background-color', '#f0f0f0');
};
}
};
"use strict";
WYMeditor.SKINS['default'] = {
init: function (wym) {
//render following sections as panels
jQuery(wym._box).find(wym._options.classesSelector)
.addClass("wym_panel");
//render following sections as buttons
jQuery(wym._box).find(wym._options.toolsSelector)
.addClass("wym_buttons");
//render following sections as dropdown menus
jQuery(wym._box).find(wym._options.containersSelector)
.addClass("wym_dropdown")
.find(WYMeditor.H2)
.append(" >");
// auto add some margin to the main area sides if left area
// or right area are not empty (if they contain sections)
jQuery(wym._box).find("div.wym_area_right ul")
.parents("div.wym_area_right").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-right": "155px"});
jQuery(wym._box).find("div.wym_area_left ul")
.parents("div.wym_area_left").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-left": "155px"});
//make hover work under IE < 7
jQuery(wym._box).find(".wym_section").hover(
function () {
jQuery(this).addClass("hover");
},
function () {
jQuery(this).removeClass("hover");
}
);
}
};
"use strict";
WYMeditor.SKINS.legacy = {
init: function (wym) {
//render following sections as panels
jQuery(wym._box).find(wym._options.classesSelector)
.addClass("wym_panel");
//render following sections as buttons
jQuery(wym._box).find(wym._options.toolsSelector)
.addClass("wym_buttons");
//render following sections as dropdown menus
jQuery(wym._box).find(wym._options.containersSelector)
.addClass("wym_dropdown")
.find(WYMeditor.H2)
.append(" >");
// auto add some margin to the main area sides if left area
// or right area are not empty (if they contain sections)
jQuery(wym._box).find("div.wym_area_right ul")
.parents("div.wym_area_right").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-right": "155px"});
jQuery(wym._box).find("div.wym_area_left ul")
.parents("div.wym_area_left").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-left": "155px"});
//make hover work under IE < 7
jQuery(wym._box).find(".wym_section").hover(
function () {
jQuery(this).addClass("hover");
},
function () {
jQuery(this).removeClass("hover");
}
);
}
};
jQuery.fn.selectify = function() {
var $elements = this;
return $elements.each(function() {
var element = this;
jQuery(element).hover(
function() {
var element = this;
jQuery("h2", element).css("background-position", "0px -18px");
jQuery("ul", element).fadeIn("fast");
},
function() {
var element = this;
jQuery("h2", element).css("background-position", "");
jQuery("ul", element).fadeOut("fast");
}
);
});
};
WYMeditor.SKINS.minimal = {
//placeholder for the skin JS, if needed
//init the skin
//wym is the WYMeditor.editor instance
init: function(wym) {
//render following sections as dropdown menus
jQuery(wym._box).find(wym._options.toolsSelector + ', ' + wym._options.containersSelector + ', ' + wym._options.classesSelector)
.addClass("wym_dropdown")
.selectify();
}
};
/* globals -$ */
"use strict";
// Add classes to an element based on its current location relative to top and
// or bottom offsets.
// Useful for affixing an element on the page within a certain vertical range.
// Based largely off of the bootstrap affix plugin
// https://github.com/twbs/bootstrap/blob/master/js/affix.js
(function ($) {
var Affix = function (element, options) {
this.options = $.extend({}, $.fn.wymAffix.defaults, options);
this.$window = $(window);
this.$window.bind(
'scroll.affix.data-api',
$.proxy(this.checkPosition, this)
);
this.$window.bind(
'click.affix.data-api',
$.proxy(
function () {
setTimeout(
$.proxy(this.checkPosition, this),
1
);
},
this
)
);
this.$element = $(element);
this.checkPosition();
};
Affix.prototype.checkPosition = function () {
var scrollTop = this.$window.scrollTop()
, offset = this.options.offset
, offsetBottom = offset.bottom
, offsetTop = offset.top
, reset = 'affix affix-top affix-bottom'
, desiredAffixType
, isBelowTop = true
, isAboveBottom = true;
if (typeof offset !== 'object') {
offsetBottom = offsetTop = offset;
}
if (typeof offsetTop === 'function') {
offsetTop = offset.top();
}
if (typeof offsetBottom === 'function') {
offsetBottom = offset.bottom();
}
if (offsetTop !== null) {
isBelowTop = scrollTop > offsetTop;
}
if (offsetBottom !== null) {
isAboveBottom = scrollTop + this.$element.height() < offsetBottom;
}
if (isBelowTop && isAboveBottom) {
desiredAffixType = 'affix';
} else if (isAboveBottom === false) {
// We're below the bottom offset
desiredAffixType = 'affix-bottom';
} else {
desiredAffixType = 'affix-top';
}
if (this.currentAffixType === desiredAffixType) {
// We're already properly-affixed. No changes required.
return;
}
this.$element.removeClass(reset).addClass(desiredAffixType);
this.currentAffixType = desiredAffixType;
};
/* AFFIX PLUGIN DEFINITION
* ======================= */
$.fn.wymAffix = function (option) {
var $elements = this;
return $elements.each(function () {
var element = this,
$element = $(element)
, data = $element.data('affix')
, options = typeof option === 'object' && option;
if (!data) {
$element.data(
'affix',
(data = new Affix(element, options))
);
}
if (typeof option === 'string') {
data[option]();
}
});
};
$.fn.wymAffix.Constructor = Affix;
$.fn.wymAffix.defaults = {
offset: 0
};
}(jQuery));
WYMeditor.SKINS.seamless = {
OPTS: {
iframeHtml: [""
, ''
, ''
, ''
].join(""),
// After Iframe initialization, check if we're ready to perform the
// first resize every this many ms
initIframeCheckFrequency: 50,
// After load or after images are inserted, check every this many ms to
// see if they've properly set their height.
imagesLoadedCheckFrequency: 300,
// After this many ms, give up on images finishing loading. Some images
// might never load due to network connectivity or bad links.
imagesLoadedCheckTimeout: 5000
},
init: function (wym) {
var This = WYMeditor.SKINS.seamless;
// TODO: Find a unified strategy for dealing with loading polyfills
// This is a polyfill for old IE
if (!Date.now) {
Date.now = function now() {
return new Date().getTime();
};
}
wym.seamlessSkinOpts = jQuery.extend(
This.OPTS,
{
initialIframeResizeTimer: null,
resizeAfterImagesLoadTimer: null,
_imagesLoadedCheckStartedTime: 0,
minimumHeight: jQuery(wym.element).height()
}
);
This.initUIChrome(wym);
// The Iframe isn't initialized at this point, so we'll need to wait
// until it is before attempting to use it.
jQuery(wym.element).bind(
WYMeditor.EVENTS.postIframeInitialization,
This.postIframeInit
);
},
postIframeInit: function (e, wym) {
var This = WYMeditor.SKINS.seamless;
// Perform an initial resize, if necessary
This.resizeIframeOnceBodyExists(wym);
// Detect possible Block creation so that we can always keep the iframe
// properly resized and the current container in view
jQuery(wym.element).bind(
WYMeditor.EVENTS.postBlockMaybeCreated,
function () {
This.resizeAndScrollIfNeeded(wym);
}
);
},
initUIChrome: function (wym) {
// Initialize the toolbar and classes/containers selectors
// The classes and containers sections are dropdowns to the right of
// the toolbar at the top
var This = WYMeditor.SKINS.seamless,
$dropdowns = jQuery(
[
wym._options.containersSelector
, wym._options.classesSelector
].join(', '),
wym._box
),
$toolbar,
$areaTop;
$areaTop = jQuery("div.wym_area_top", wym._box);
$dropdowns.appendTo($areaTop);
$dropdowns.addClass("wym_dropdown");
// Make dropdowns also work on click, for mobile devices
jQuery(".wym_dropdown", wym._box).click(
function () {
var dropDown = this;
jQuery(dropDown).toggleClass("hover");
}
);
// The toolbar uses buttons
$toolbar = jQuery(wym._options.toolsSelector, wym._box);
$toolbar.addClass("wym_buttons");
This.affixTopControls(wym);
},
affixTopControls: function (wym) {
// Affix the top area, which contains the toolbar and containers, to
// the top of the screen so that we can see it, even if we're scrolled
// down.
var $areaTop,
$offsetWrapper,
earlyScrollPixels = 5,
usePlaceholderWidth,
$placeholder;
$areaTop = jQuery("div.wym_area_top", wym._box);
// Use a wrapper so we can keep the toolbar styling consistent
$offsetWrapper = jQuery(
''
);
$areaTop.wrap($offsetWrapper);
$offsetWrapper = $areaTop.parent();
// Add another, non-affixed wrapper to stick around and hold vertical
// space. This avoids the "jump" when the toolbar switches to being
// affixed
$offsetWrapper.wrap('');
$placeholder = $offsetWrapper.parent();
$placeholder.height($areaTop.height());
usePlaceholderWidth = function () {
// Hard-code the offsetWrapper width so that when this floats to
// the top, it doesn't expand to take up all of the room to the
// right
$offsetWrapper.width($placeholder.width());
};
usePlaceholderWidth();
jQuery(window).resize(usePlaceholderWidth);
$offsetWrapper.wymAffix({
offset: {
top: function () {
return $placeholder.offset().top - earlyScrollPixels;
},
bottom: function () {
return $placeholder.offset().top +
wym.seamlessSkinIframeHeight;
}
}
});
},
resizeIframeOnceBodyExists: function (wym) {
// In IE, the wym._doc DOMLoaded event doesn't mean the iframe will
// actually have a body. We need to wait until the body actually exists
// before trying to set the initial hight of the iframe, so we hack
// this together with setTimeout.
var This = WYMeditor.SKINS.seamless,
scrollHeightCalcFix;
if (wym.seamlessSkinOpts.initialIframeResizeTimer) {
// We're handling a timer, clear it
window.clearTimeout(
wym.seamlessSkinOpts.initialIframeResizeTimer
);
wym.seamlessSkinOpts.initialIframeResizeTimer = null;
}
if (typeof wym._doc.body === "undefined" || wym._doc.body === null) {
// Body isn't ready
wym.seamlessSkinOpts.initialIframeResizeTimer = window.setTimeout(
function () {
This.resizeIframeOnceBodyExists(wym);
},
wym.seamlessSkinOpts.initIframeCheckFrequency
);
return;
}
// The body is ready, so let's get to resizing
// For some reason, at least IE7 requires at least one access to the
// scrollHeight before it gives a real value. I was unable to find any
// kind of feature detection that would work here and the fix of adding
// an extra access here doesn't have any real negative impact on the
// other browsers, but does fix IE7's behavior.
scrollHeightCalcFix = wym._doc.body.scrollHeight;
This.resizeIframe(wym);
This.resizeIframeOnceImagesLoaded(wym);
},
resizeIframeOnceImagesLoaded: function (wym) {
// Even though the body may be "loaded" from a DOM even standpoint,
// that doesn't mean that images have yet been retrieved or that their
// heights have been determined. If an image's height pops in after
// we've calculated the iframe height, the iframe will be too short.
var This = WYMeditor.SKINS.seamless,
images,
imagesLength,
i = 0,
allImagesLoaded = true,
skinOpts = wym.seamlessSkinOpts,
timeWaited;
if (typeof skinOpts._imagesLoadedCheckStartedTime === "undefined" ||
skinOpts._imagesLoadedCheckStartedTime === 0) {
skinOpts._imagesLoadedCheckStartedTime = Date.now();
}
if (skinOpts.resizeAfterImagesLoadTimer !== null) {
// We're handling a timer, clear it
window.clearTimeout(
skinOpts.resizeAfterImagesLoadTimer
);
skinOpts.resizeAfterImagesLoadTimer = null;
}
images = wym.$body().find('img');
imagesLength = images.length;
if (imagesLength === 0) {
// No images. No need to worry about resizing based on them.
return;
}
for (i = 0; i < imagesLength; i += 1) {
if (!This._imageIsLoaded(images[i])) {
// If any image isn't loaded, we're not done
allImagesLoaded = false;
break;
}
}
// Even if all of the images haven't loaded, we can still be more
// correct by accounting for any that have.
This.resizeAndScrollIfNeeded(wym);
if (allImagesLoaded === true) {
// Clean up the timeout timer for subsequent calls
skinOpts._imagesLoadedCheckStartedTime = 0;
return;
}
timeWaited = Date.now() - skinOpts._imagesLoadedCheckStartedTime;
if (timeWaited > skinOpts.imagesLoadedCheckTimeout) {
// Clean up the timeout timer for subsequent calls
skinOpts._imagesLoadedCheckStartedTime = 0;
// We've waited long enough. The images might never load.
// Don't set another timer.
return;
}
// Let's check again in after a delay
skinOpts.resizeAfterImagesLoadTimer = window.setTimeout(
function () {
This.resizeIframeOnceImagesLoaded(wym);
},
skinOpts.imagesLoadedCheckFrequency
);
},
_imageIsLoaded: function (img) {
if (img.complete !== true) {
return false;
}
if (typeof img.naturalWidth !== "undefined" &&
img.naturalWidth === 0) {
return false;
}
return true;
},
_getIframeHeightStrategy: function (wym) {
// For some browsers (IE8+ and FF), the scrollHeight of the body
// doesn't seem to include the top and bottom margins of the body
// relative to the HTML. This leaves the editing "window" smaller
// than required, which results in weird overlaps at the start/end.
// For those browsers, the HTML element's scrollHeight is more
// reliable.
// Let's detect which kind of browser we're dealing with one time
// so we can just do the right thing in the future.
var bodyScrollHeight,
$htmlElement,
htmlElementHeight,
htmlElementScrollHeight,
heightStrategy;
$htmlElement = jQuery(wym._doc).children().eq(0);
bodyScrollHeight = wym._doc.body.scrollHeight;
htmlElementHeight = $htmlElement.height();
htmlElementScrollHeight = $htmlElement[0].scrollHeight;
if (WYMeditor.isInternetExplorerPre11()) {
// The htmlElementScrollHeight is fairly reliable,
// but doesn't shrink when content is removed.
heightStrategy = function (wym) {
var $htmlElement = jQuery(wym._doc).children().eq(0),
htmlElementScrollHeight = $htmlElement[0].scrollHeight;
// Without the 10px reduction in height, every possible action
// adds 10 pixels of height.
// TODO: Figure out why this happens and if we can make the
// 10px number not magic (actually derived from a
// margin/padding etc).
return htmlElementScrollHeight - 10;
};
return heightStrategy;
} else if (htmlElementHeight >= bodyScrollHeight) {
// Well-behaving browsers like FF and Chrome let us rely on the
// HTML element's jQuery height() in every case. Hooray!
heightStrategy = function (wym) {
var $htmlElement = jQuery(wym._doc).children().eq(0),
htmlElementHeight = $htmlElement.height();
return htmlElementHeight;
};
return heightStrategy;
} else if (bodyScrollHeight > htmlElementScrollHeight) {
// This is probably IE7, where the only thing reliable is the
// bodyScrollHeight
heightStrategy = function (wym) {
return wym._doc.body.scrollHeight;
};
return heightStrategy;
} else {
throw new Error('unsupported browser');
}
},
resizeIframe: function (wym) {
var This = WYMeditor.SKINS.seamless,
desiredHeight,
$iframe = jQuery(wym._iframe),
currentHeight = $iframe.height();
if (typeof WYMeditor.IFRAME_HEIGHT_GETTER === "undefined") {
WYMeditor.IFRAME_HEIGHT_GETTER = This._getIframeHeightStrategy(
wym
);
}
desiredHeight = WYMeditor.IFRAME_HEIGHT_GETTER(wym);
// Don't let the height drop below the WYMeditor textarea. This allows
// folks to use their favorite height-setting method on the textarea,
// without needing to pass options on to WYMeditor.
if (desiredHeight < wym.seamlessSkinOpts.minimumHeight) {
desiredHeight = wym.seamlessSkinOpts.minimumHeight;
}
if (currentHeight !== desiredHeight) {
$iframe.height(desiredHeight);
wym.seamlessSkinIframeHeight = desiredHeight;
return true;
}
return false;
},
scrollIfNeeded: function (wym) {
var iframeOffset = jQuery(wym._iframe).offset(),
iframeOffsetTop = iframeOffset.top,
$container = jQuery(wym.selectedContainer()),
containerOffset = $container.offset(),
viewportLowestY,
containerLowestY,
newScrollTop,
extraScroll = 20,
scrollDiff,
$window = jQuery(window),
$body = jQuery(document.body);
if ($container.length === 0) {
// With nothing selected, there's no need to scroll
return;
}
containerLowestY = iframeOffsetTop + containerOffset.top;
containerLowestY += $container.outerHeight();
viewportLowestY = $window.scrollTop() + $window.height();
scrollDiff = containerLowestY - viewportLowestY;
if (scrollDiff > 0) {
// Part of our selected container isn't
// visible, so we need to scroll down.
newScrollTop = $body.scrollTop() + scrollDiff + extraScroll;
$body.scrollTop(newScrollTop);
}
},
resizeAndScrollIfNeeded: function (wym) {
// Scroll the page so that our current selection
// within the iframe is actually in view.
var This = WYMeditor.SKINS.seamless,
resizeOccurred = This.resizeIframe(wym);
if (resizeOccurred !== true) {
return;
}
This.scrollIfNeeded(wym);
}
};
/* This file is part of the Silver skin for WYMeditor by Scott Edwin Lewis */
jQuery.fn.selectify = function() {
var $elements = this;
return $elements.each(function() {
var element = this;
jQuery(element).hover(
function() {
var element = this;
jQuery("h2", element).css("background-position", "0px -18px");
jQuery("ul", element).fadeIn("fast");
},
function() {
var element = this;
jQuery("h2", element).css("background-position", "");
jQuery("ul", element).fadeOut("fast");
}
);
});
};
WYMeditor.SKINS.silver = {
init: function(wym) {
//add some elements to improve the rendering
jQuery(wym._box)
.append('')
.wrapInner('');
//render following sections as panels
jQuery(wym._box).find(wym._options.classesSelector)
.addClass("wym_panel");
//render following sections as buttons
jQuery(wym._box).find(wym._options.toolsSelector)
.addClass("wym_buttons");
//render following sections as dropdown menus
jQuery(wym._box).find(wym._options.containersSelector)
.addClass("wym_dropdown")
.selectify();
// auto add some margin to the main area sides if left area
// or right area are not empty (if they contain sections)
jQuery(wym._box).find("div.wym_area_right ul")
.parents("div.wym_area_right").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-right": "155px"});
jQuery(wym._box).find("div.wym_area_left ul")
.parents("div.wym_area_left").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-left": "155px"});
//make hover work under IE < 7
jQuery(wym._box).find(".wym_section").hover(function(){
var section = this;
jQuery(section).addClass("hover");
},function(){
var section = this;
jQuery(section).removeClass("hover");
});
}
};
WYMeditor.SKINS.twopanels = {
init: function(wym) {
//move the containers panel to the left area
jQuery(wym._box).find(wym._options.containersSelector)
.appendTo("div.wym_area_left");
//render following sections as panels
jQuery(wym._box).find(wym._options.classesSelector + ', ' +
wym._options.containersSelector)
.addClass("wym_panel");
//render following sections as buttons
jQuery(wym._box).find(wym._options.toolsSelector)
.addClass("wym_buttons");
// auto add some margin to the main area sides if left area
// or right area are not empty (if they contain sections)
jQuery(wym._box).find("div.wym_area_right ul")
.parents("div.wym_area_right").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-right": "155px"});
jQuery(wym._box).find("div.wym_area_left ul")
.parents("div.wym_area_left").show()
.parents(wym._options.boxSelector)
.find("div.wym_area_main")
.css({"margin-left": "115px"});
//make hover work under IE < 7
jQuery(wym._box).find(".wym_section").hover(function(){
jQuery(this).addClass("hover");
},function(){
jQuery(this).removeClass("hover");
});
}
};