esp-ckeditor 0.1.0

data/app/assets/javascripts/esp-ckeditor/_source/plugins/domiterator/plugin.js

@@ -0,0 +1,361 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @file DOM iterator, which iterates over list items, lines and paragraphs.
+ */
+
+CKEDITOR.plugins.add( 'domiterator' );
+
+(function()
+{
+  /**
+   * @name CKEDITOR.dom.iterator
+   */
+  function iterator( range )
+  {
+    if ( arguments.length < 1 )
+      return;
+
+    this.range = range;
+    this.forceBrBreak = 0;
+
+    // Whether include <br>s into the enlarged range.(#3730).
+    this.enlargeBr = 1;
+    this.enforceRealBlocks = 0;
+
+    this._ || ( this._ = {} );
+  }
+
+  var beginWhitespaceRegex = /^[\r\n\t ]+$/,
+    // Ignore bookmark nodes.(#3783)
+    bookmarkGuard = CKEDITOR.dom.walker.bookmark( false, true ),
+    whitespacesGuard = CKEDITOR.dom.walker.whitespaces( true ),
+    skipGuard = function( node ) { return bookmarkGuard( node ) && whitespacesGuard( node ); };
+
+  // Get a reference for the next element, bookmark nodes are skipped.
+  function getNextSourceNode( node, startFromSibling, lastNode )
+  {
+    var next = node.getNextSourceNode( startFromSibling, null, lastNode );
+    while ( !bookmarkGuard( next ) )
+      next = next.getNextSourceNode( startFromSibling, null, lastNode );
+    return next;
+  }
+
+  iterator.prototype = {
+    getNextParagraph : function( blockTag )
+    {
+      // The block element to be returned.
+      var block;
+
+      // The range object used to identify the paragraph contents.
+      var range;
+
+      // Indicats that the current element in the loop is the last one.
+      var isLast;
+
+      // Indicate at least one of the range boundaries is inside a preformat block.
+      var touchPre;
+
+      // Instructs to cleanup remaining BRs.
+      var removePreviousBr, removeLastBr;
+
+      // This is the first iteration. Let's initialize it.
+      if ( !this._.lastNode )
+      {
+        range = this.range.clone();
+
+        // Shrink the range to exclude harmful "noises" (#4087, #4450, #5435).
+        range.shrink( CKEDITOR.NODE_ELEMENT, true );
+
+        touchPre = range.endContainer.hasAscendant( 'pre', true )
+          || range.startContainer.hasAscendant( 'pre', true );
+
+        range.enlarge( this.forceBrBreak && !touchPre || !this.enlargeBr ?
+                 CKEDITOR.ENLARGE_LIST_ITEM_CONTENTS : CKEDITOR.ENLARGE_BLOCK_CONTENTS );
+
+        var walker = new CKEDITOR.dom.walker( range ),
+          ignoreBookmarkTextEvaluator = CKEDITOR.dom.walker.bookmark( true, true );
+        // Avoid anchor inside bookmark inner text.
+        walker.evaluator = ignoreBookmarkTextEvaluator;
+        this._.nextNode = walker.next();
+        // TODO: It's better to have walker.reset() used here.
+        walker = new CKEDITOR.dom.walker( range );
+        walker.evaluator = ignoreBookmarkTextEvaluator;
+        var lastNode = walker.previous();
+        this._.lastNode = lastNode.getNextSourceNode( true );
+
+        // We may have an empty text node at the end of block due to [3770].
+        // If that node is the lastNode, it would cause our logic to leak to the
+        // next block.(#3887)
+        if ( this._.lastNode &&
+            this._.lastNode.type == CKEDITOR.NODE_TEXT &&
+            !CKEDITOR.tools.trim( this._.lastNode.getText() ) &&
+            this._.lastNode.getParent().isBlockBoundary() )
+        {
+          var testRange = new CKEDITOR.dom.range( range.document );
+          testRange.moveToPosition( this._.lastNode, CKEDITOR.POSITION_AFTER_END );
+          if ( testRange.checkEndOfBlock() )
+          {
+            var path = new CKEDITOR.dom.elementPath( testRange.endContainer );
+            var lastBlock = path.block || path.blockLimit;
+            this._.lastNode = lastBlock.getNextSourceNode( true );
+          }
+        }
+
+        // Probably the document end is reached, we need a marker node.
+        if ( !this._.lastNode )
+        {
+          this._.lastNode = this._.docEndMarker = range.document.createText( '' );
+          this._.lastNode.insertAfter( lastNode );
+        }
+
+        // Let's reuse this variable.
+        range = null;
+      }
+
+      var currentNode = this._.nextNode;
+      lastNode = this._.lastNode;
+
+      this._.nextNode = null;
+      while ( currentNode )
+      {
+        // closeRange indicates that a paragraph boundary has been found,
+        // so the range can be closed.
+        var closeRange = 0,
+          parentPre = currentNode.hasAscendant( 'pre' );
+
+        // includeNode indicates that the current node is good to be part
+        // of the range. By default, any non-element node is ok for it.
+        var includeNode = ( currentNode.type != CKEDITOR.NODE_ELEMENT ),
+          continueFromSibling = 0;
+
+        // If it is an element node, let's check if it can be part of the
+        // range.
+        if ( !includeNode )
+        {
+          var nodeName = currentNode.getName();
+
+          if ( currentNode.isBlockBoundary( this.forceBrBreak &&
+              !parentPre && { br : 1 } ) )
+          {
+            // <br> boundaries must be part of the range. It will
+            // happen only if ForceBrBreak.
+            if ( nodeName == 'br' )
+              includeNode = 1;
+            else if ( !range && !currentNode.getChildCount() && nodeName != 'hr' )
+            {
+              // If we have found an empty block, and haven't started
+              // the range yet, it means we must return this block.
+              block = currentNode;
+              isLast = currentNode.equals( lastNode );
+              break;
+            }
+
+            // The range must finish right before the boundary,
+            // including possibly skipped empty spaces. (#1603)
+            if ( range )
+            {
+              range.setEndAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
+
+              // The found boundary must be set as the next one at this
+              // point. (#1717)
+              if ( nodeName != 'br' )
+                this._.nextNode = currentNode;
+            }
+
+            closeRange = 1;
+          }
+          else
+          {
+            // If we have child nodes, let's check them.
+            if ( currentNode.getFirst() )
+            {
+              // If we don't have a range yet, let's start it.
+              if ( !range )
+              {
+                range = new CKEDITOR.dom.range( this.range.document );
+                range.setStartAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
+              }
+
+              currentNode = currentNode.getFirst();
+              continue;
+            }
+            includeNode = 1;
+          }
+        }
+        else if ( currentNode.type == CKEDITOR.NODE_TEXT )
+        {
+          // Ignore normal whitespaces (i.e. not including &nbsp; or
+          // other unicode whitespaces) before/after a block node.
+          if ( beginWhitespaceRegex.test( currentNode.getText() ) )
+            includeNode = 0;
+        }
+
+        // The current node is good to be part of the range and we are
+        // starting a new range, initialize it first.
+        if ( includeNode && !range )
+        {
+          range = new CKEDITOR.dom.range( this.range.document );
+          range.setStartAt( currentNode, CKEDITOR.POSITION_BEFORE_START );
+        }
+
+        // The last node has been found.
+        isLast = ( ( !closeRange || includeNode ) && currentNode.equals( lastNode ) );
+
+        // If we are in an element boundary, let's check if it is time
+        // to close the range, otherwise we include the parent within it.
+        if ( range && !closeRange )
+        {
+          while ( !currentNode.getNext( skipGuard ) && !isLast )
+          {
+            var parentNode = currentNode.getParent();
+
+            if ( parentNode.isBlockBoundary( this.forceBrBreak
+                && !parentPre && { br : 1 } ) )
+            {
+              closeRange = 1;
+              includeNode = 0;
+              isLast = isLast || ( parentNode.equals( lastNode) );
+              // Make sure range includes bookmarks at the end of the block. (#7359)
+              range.setEndAt( parentNode, CKEDITOR.POSITION_BEFORE_END );
+              break;
+            }
+
+            currentNode = parentNode;
+            includeNode = 1;
+            isLast = ( currentNode.equals( lastNode ) );
+            continueFromSibling = 1;
+          }
+        }
+
+        // Now finally include the node.
+        if ( includeNode )
+          range.setEndAt( currentNode, CKEDITOR.POSITION_AFTER_END );
+
+        currentNode = getNextSourceNode ( currentNode, continueFromSibling, lastNode );
+        isLast = !currentNode;
+
+        // We have found a block boundary. Let's close the range and move out of the
+        // loop.
+        if ( isLast || ( closeRange && range ) )
+            break;
+      }
+
+      // Now, based on the processed range, look for (or create) the block to be returned.
+      if ( !block )
+      {
+        // If no range has been found, this is the end.
+        if ( !range )
+        {
+          this._.docEndMarker && this._.docEndMarker.remove();
+          this._.nextNode = null;
+          return null;
+        }
+
+        var startPath = new CKEDITOR.dom.elementPath( range.startContainer );
+        var startBlockLimit = startPath.blockLimit,
+          checkLimits = { div : 1, th : 1, td : 1 };
+        block = startPath.block;
+
+        if ( !block
+            && !this.enforceRealBlocks
+            && checkLimits[ startBlockLimit.getName() ]
+            && range.checkStartOfBlock()
+            && range.checkEndOfBlock() )
+          block = startBlockLimit;
+        else if ( !block || ( this.enforceRealBlocks && block.getName() == 'li' ) )
+        {
+          // Create the fixed block.
+          block = this.range.document.createElement( blockTag || 'p' );
+
+            // Move the contents of the temporary range to the fixed block.
+            range.extractContents().appendTo( block );
+            block.trim();
+
+            // Insert the fixed block into the DOM.
+            range.insertNode( block );
+
+            removePreviousBr = removeLastBr = true;
+          }
+        else if ( block.getName() != 'li' )
+        {
+          // If the range doesn't includes the entire contents of the
+          // block, we must split it, isolating the range in a dedicated
+          // block.
+          if ( !range.checkStartOfBlock() || !range.checkEndOfBlock() )
+          {
+            // The resulting block will be a clone of the current one.
+            block = block.clone( false );
+
+            // Extract the range contents, moving it to the new block.
+            range.extractContents().appendTo( block );
+            block.trim();
+
+            // Split the block. At this point, the range will be in the
+            // right position for our intents.
+            var splitInfo = range.splitBlock();
+
+            removePreviousBr = !splitInfo.wasStartOfBlock;
+            removeLastBr = !splitInfo.wasEndOfBlock;
+
+            // Insert the new block into the DOM.
+            range.insertNode( block );
+          }
+        }
+        else if ( !isLast )
+        {
+          // LIs are returned as is, with all their children (due to the
+          // nested lists). But, the next node is the node right after
+          // the current range, which could be an <li> child (nested
+          // lists) or the next sibling <li>.
+
+          this._.nextNode = ( block.equals( lastNode ) ? null : getNextSourceNode( range.getBoundaryNodes().endNode, 1, lastNode ) );
+        }
+      }
+
+      if ( removePreviousBr )
+      {
+        var previousSibling = block.getPrevious();
+        if ( previousSibling && previousSibling.type == CKEDITOR.NODE_ELEMENT )
+        {
+          if ( previousSibling.getName() == 'br' )
+            previousSibling.remove();
+          else if ( previousSibling.getLast() && previousSibling.getLast().$.nodeName.toLowerCase() == 'br' )
+            previousSibling.getLast().remove();
+        }
+      }
+
+      if ( removeLastBr )
+      {
+        var lastChild = block.getLast();
+        if ( lastChild && lastChild.type == CKEDITOR.NODE_ELEMENT && lastChild.getName() == 'br' )
+        {
+          // Take care not to remove the block expanding <br> in non-IE browsers.
+          if ( CKEDITOR.env.ie
+             || lastChild.getPrevious( bookmarkGuard )
+             || lastChild.getNext( bookmarkGuard ) )
+            lastChild.remove();
+        }
+      }
+
+      // Get a reference for the next element. This is important because the
+      // above block can be removed or changed, so we can rely on it for the
+      // next interation.
+      if ( !this._.nextNode )
+      {
+        this._.nextNode = ( isLast || block.equals( lastNode ) ) ? null :
+          getNextSourceNode( block, 1, lastNode );
+      }
+
+      return block;
+    }
+  };
+
+  CKEDITOR.dom.range.prototype.createIterator = function()
+  {
+    return new iterator( this );
+  };
+})();

data/app/assets/javascripts/esp-ckeditor/_source/plugins/editingblock/plugin.js

@@ -0,0 +1,278 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview The default editing block plugin, which holds the editing area
+ *    and source view.
+ */
+
+(function()
+{
+  // This is a semaphore used to avoid recursive calls between
+  // the following data handling functions.
+  var isHandlingData;
+
+  CKEDITOR.plugins.add( 'editingblock',
+  {
+    init : function( editor )
+    {
+      if ( !editor.config.editingBlock )
+        return;
+
+      editor.on( 'themeSpace', function( event )
+        {
+          if ( event.data.space == 'contents' )
+            event.data.html += '<br>';
+        });
+
+      editor.on( 'themeLoaded', function()
+        {
+          editor.fireOnce( 'editingBlockReady' );
+        });
+
+      editor.on( 'uiReady', function()
+        {
+          editor.setMode( editor.config.startupMode );
+        });
+
+      editor.on( 'afterSetData', function()
+        {
+          if ( !isHandlingData )
+          {
+            function setData()
+            {
+              isHandlingData = true;
+              editor.getMode().loadData( editor.getData() );
+              isHandlingData = false;
+            }
+
+            if ( editor.mode )
+              setData();
+            else
+            {
+              editor.on( 'mode', function()
+                {
+                  if ( editor.mode )
+                  {
+                    setData();
+                    editor.removeListener( 'mode', arguments.callee );
+                  }
+                });
+            }
+          }
+        });
+
+      editor.on( 'beforeGetData', function()
+        {
+          if ( !isHandlingData && editor.mode )
+          {
+            isHandlingData = true;
+            editor.setData( editor.getMode().getData(), null, 1 );
+            isHandlingData = false;
+          }
+        });
+
+      editor.on( 'getSnapshot', function( event )
+        {
+          if ( editor.mode )
+            event.data = editor.getMode().getSnapshotData();
+        });
+
+      editor.on( 'loadSnapshot', function( event )
+        {
+          if ( editor.mode )
+            editor.getMode().loadSnapshotData( event.data );
+        });
+
+      // For the first "mode" call, we'll also fire the "instanceReady"
+      // event.
+      editor.on( 'mode', function( event )
+        {
+          // Do that once only.
+          event.removeListener();
+
+          // Redirect the focus into editor for webkit. (#5713)
+          CKEDITOR.env.webkit && editor.container.on( 'focus', function()
+            {
+              editor.focus();
+            });
+
+          if ( editor.config.startupFocus )
+            editor.focus();
+
+          // Fire instanceReady for both the editor and CKEDITOR, but
+          // defer this until the whole execution has completed
+          // to guarantee the editor is fully responsible.
+          setTimeout( function(){
+            editor.fireOnce( 'instanceReady' );
+            CKEDITOR.fire( 'instanceReady', null, editor );
+          }, 0 );
+        });
+
+      editor.on( 'destroy', function ()
+      {
+        // ->    currentMode.unload( holderElement );
+        if ( this.mode )
+          this._.modes[ this.mode ].unload( this.getThemeSpace( 'contents' ) );
+      });
+    }
+  });
+
+  /**
+   * The current editing mode. An editing mode is basically a viewport for
+   * editing or content viewing. By default the possible values for this
+   * property are "wysiwyg" and "source".
+   * @type String
+   * @example
+   * alert( CKEDITOR.instances.editor1.mode );  // "wysiwyg" (e.g.)
+   */
+  CKEDITOR.editor.prototype.mode = '';
+
+  /**
+   * Registers an editing mode. This function is to be used mainly by plugins.
+   * @param {String} mode The mode name.
+   * @param {Object} modeEditor The mode editor definition.
+   * @example
+   */
+  CKEDITOR.editor.prototype.addMode = function( mode, modeEditor )
+  {
+    modeEditor.name = mode;
+    ( this._.modes || ( this._.modes = {} ) )[ mode ] = modeEditor;
+  };
+
+  /**
+   * Sets the current editing mode in this editor instance.
+   * @param {String} mode A registered mode name.
+   * @example
+   * // Switch to "source" view.
+   * CKEDITOR.instances.editor1.setMode( 'source' );
+   */
+  CKEDITOR.editor.prototype.setMode = function( mode )
+  {
+    this.fire( 'beforeSetMode', { newMode : mode } );
+
+    var data,
+      holderElement = this.getThemeSpace( 'contents' ),
+      isDirty = this.checkDirty();
+
+    // Unload the previous mode.
+    if ( this.mode )
+    {
+      if ( mode == this.mode )
+        return;
+
+      this._.previousMode = this.mode;
+
+      this.fire( 'beforeModeUnload' );
+
+      var currentMode = this.getMode();
+      data = currentMode.getData();
+      currentMode.unload( holderElement );
+      this.mode = '';
+    }
+
+    holderElement.setHtml( '' );
+
+    // Load required mode.
+    var modeEditor = this.getMode( mode );
+    if ( !modeEditor )
+      throw '[CKEDITOR.editor.setMode] Unknown mode "' + mode + '".';
+
+    if ( !isDirty )
+    {
+      this.on( 'mode', function()
+        {
+          this.resetDirty();
+          this.removeListener( 'mode', arguments.callee );
+        });
+    }
+
+    modeEditor.load( holderElement, ( typeof data ) != 'string'  ? this.getData() : data );
+  };
+
+  /**
+   * Gets the current or any of the objects that represent the editing
+   * area modes. The two most common editing modes are "wysiwyg" and "source".
+   * @param {String} [mode] The mode to be retrieved. If not specified, the
+   *    current one is returned.
+   */
+  CKEDITOR.editor.prototype.getMode = function( mode )
+  {
+    return this._.modes && this._.modes[ mode || this.mode ];
+  };
+
+  /**
+   * Moves the selection focus to the editing are space in the editor.
+   */
+  CKEDITOR.editor.prototype.focus = function()
+  {
+    this.forceNextSelectionCheck();
+    var mode = this.getMode();
+    if ( mode )
+      mode.focus();
+  };
+})();
+
+/**
+ * The mode to load at the editor startup. It depends on the plugins
+ * loaded. By default, the "wysiwyg" and "source" modes are available.
+ * @type String
+ * @default 'wysiwyg'
+ * @example
+ * config.startupMode = 'source';
+ */
+CKEDITOR.config.startupMode = 'wysiwyg';
+
+/**
+ * Sets whether the editor should have the focus when the page loads.
+ * @name CKEDITOR.config.startupFocus
+ * @type Boolean
+ * @default false
+ * @example
+ * config.startupFocus = true;
+ */
+
+/**
+ * Whether to render or not the editing block area in the editor interface.
+ * @type Boolean
+ * @default true
+ * @example
+ * config.editingBlock = false;
+ */
+CKEDITOR.config.editingBlock = true;
+
+/**
+ * Fired when a CKEDITOR instance is created, fully initialized and ready for interaction.
+ * @name CKEDITOR#instanceReady
+ * @event
+ * @param {CKEDITOR.editor} editor The editor instance that has been created.
+ */
+
+/**
+ * Fired when the CKEDITOR instance is created, fully initialized and ready for interaction.
+ * @name CKEDITOR.editor#instanceReady
+ * @event
+ */
+
+/**
+ * Fired before changing the editing mode. See also CKEDITOR.editor#beforeSetMode and CKEDITOR.editor#mode
+ * @name CKEDITOR.editor#beforeModeUnload
+ * @event
+ */
+
+ /**
+ * Fired before the editor mode is set. See also CKEDITOR.editor#mode and CKEDITOR.editor#beforeModeUnload
+ * @name CKEDITOR.editor#beforeSetMode
+ * @event
+ * @since 3.5.3
+ * @param {String} newMode The name of the mode which is about to be set.
+ */
+
+/**
+ * Fired after setting the editing mode. See also CKEDITOR.editor#beforeSetMode and CKEDITOR.editor#beforeModeUnload
+ * @name CKEDITOR.editor#mode
+ * @event
+ * @param {String} previousMode The previous mode of the editor.
+ */