esp-ckeditor 0.1.0

data/app/assets/javascripts/esp-ckeditor/_source/core/focusmanager.js

@@ -0,0 +1,152 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.focusManager} class, which is used
+ *    to handle the focus on editor instances..
+ */
+
+/**
+ * Creates a focusManager class instance.
+ * @class Manages the focus activity in an editor instance. This class is to be
+ * used mainly by UI elements coders when adding interface elements that need
+ * to set the focus state of the editor.
+ * @param {CKEDITOR.editor} editor The editor instance.
+ * @example
+ * var focusManager = <b>new CKEDITOR.focusManager( editor )</b>;
+ * focusManager.focus();
+ */
+CKEDITOR.focusManager = function( editor )
+{
+  if ( editor.focusManager )
+    return editor.focusManager;
+
+  /**
+   * Indicates that the editor instance has focus.
+   * @type Boolean
+   * @example
+   * alert( CKEDITOR.instances.editor1.focusManager.hasFocus );  // e.g "true"
+   */
+  this.hasFocus = false;
+
+  /**
+   * Object used to hold private stuff.
+   * @private
+   */
+  this._ =
+  {
+    editor : editor
+  };
+
+  return this;
+};
+
+CKEDITOR.focusManager.prototype =
+{
+  /**
+   * Used to indicate that the editor instance has the focus.<br />
+   * <br />
+   * Note that this function will not explicitelly set the focus in the
+   * editor (for example, making the caret blinking on it). Use
+   * {@link CKEDITOR.editor#focus} for it instead.
+   * @example
+   * var editor = CKEDITOR.instances.editor1;
+   * <b>editor.focusManager.focus()</b>;
+   */
+  focus : function()
+  {
+    if ( this._.timer )
+      clearTimeout( this._.timer );
+
+    if ( !this.hasFocus )
+    {
+      // If another editor has the current focus, we first "blur" it. In
+      // this way the events happen in a more logical sequence, like:
+      //    "focus 1" > "blur 1" > "focus 2"
+      // ... instead of:
+      //    "focus 1" > "focus 2" > "blur 1"
+      if ( CKEDITOR.currentInstance )
+        CKEDITOR.currentInstance.focusManager.forceBlur();
+
+      var editor = this._.editor;
+
+      editor.container.getChild( 1 ).addClass( 'cke_focus' );
+
+      this.hasFocus = true;
+      editor.fire( 'focus' );
+    }
+  },
+
+  /**
+   * Used to indicate that the editor instance has lost the focus.<br />
+   * <br />
+   * Note that this functions acts asynchronously with a delay of 100ms to
+   * avoid subsequent blur/focus effects. If you want the "blur" to happen
+   * immediately, use the {@link #forceBlur} function instead.
+   * @example
+   * var editor = CKEDITOR.instances.editor1;
+   * <b>editor.focusManager.blur()</b>;
+   */
+  blur : function()
+  {
+    var focusManager = this;
+
+    if ( focusManager._.timer )
+      clearTimeout( focusManager._.timer );
+
+    focusManager._.timer = setTimeout(
+      function()
+      {
+        delete focusManager._.timer;
+        focusManager.forceBlur();
+      }
+      , 100 );
+  },
+
+  /**
+   * Used to indicate that the editor instance has lost the focus. Unlike
+   * {@link #blur}, this function is synchronous, marking the instance as
+   * "blured" immediately.
+   * @example
+   * var editor = CKEDITOR.instances.editor1;
+   * <b>editor.focusManager.forceBlur()</b>;
+   */
+  forceBlur : function()
+  {
+    if ( this.hasFocus )
+    {
+      var editor = this._.editor;
+
+      editor.container.getChild( 1 ).removeClass( 'cke_focus' );
+
+      this.hasFocus = false;
+      editor.fire( 'blur' );
+    }
+  }
+};
+
+/**
+ * Fired when the editor instance receives the input focus.
+ * @name CKEDITOR.editor#focus
+ * @event
+ * @param {CKEDITOR.editor} editor The editor instance.
+ * @example
+ * editor.on( 'focus', function( e )
+ *     {
+ *         alert( 'The editor named ' + e.editor.name + ' is now focused' );
+ *     });
+ */
+
+/**
+ * Fired when the editor instance loses the input focus.
+ * @name CKEDITOR.editor#blur
+ * @event
+ * @param {CKEDITOR.editor} editor The editor instance.
+ * @example
+ * editor.on( 'blur', function( e )
+ *     {
+ *         alert( 'The editor named ' + e.editor.name + ' lost the focus' );
+ *     });
+ */

data/app/assets/javascripts/esp-ckeditor/_source/core/htmlparser/basicwriter.js

@@ -0,0 +1,145 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+CKEDITOR.htmlParser.basicWriter = CKEDITOR.tools.createClass(
+{
+  $ : function()
+  {
+    this._ =
+    {
+      output : []
+    };
+  },
+
+  proto :
+  {
+    /**
+     * Writes the tag opening part for a opener tag.
+     * @param {String} tagName The element name for this tag.
+     * @param {Object} attributes The attributes defined for this tag. The
+     *    attributes could be used to inspect the tag.
+     * @example
+     * // Writes "<p".
+     * writer.openTag( 'p', { class : 'MyClass', id : 'MyId' } );
+     */
+    openTag : function( tagName, attributes )
+    {
+      this._.output.push( '<', tagName );
+    },
+
+    /**
+     * Writes the tag closing part for a opener tag.
+     * @param {String} tagName The element name for this tag.
+     * @param {Boolean} isSelfClose Indicates that this is a self-closing tag,
+     *    like "br" or "img".
+     * @example
+     * // Writes "&gt;".
+     * writer.openTagClose( 'p', false );
+     * @example
+     * // Writes " /&gt;".
+     * writer.openTagClose( 'br', true );
+     */
+    openTagClose : function( tagName, isSelfClose )
+    {
+      if ( isSelfClose )
+        this._.output.push( ' />' );
+      else
+        this._.output.push( '>' );
+    },
+
+    /**
+     * Writes an attribute. This function should be called after opening the
+     * tag with {@link #openTagClose}.
+     * @param {String} attName The attribute name.
+     * @param {String} attValue The attribute value.
+     * @example
+     * // Writes ' class="MyClass"'.
+     * writer.attribute( 'class', 'MyClass' );
+     */
+    attribute : function( attName, attValue )
+    {
+      // Browsers don't always escape special character in attribute values. (#4683, #4719).
+      if ( typeof attValue == 'string' )
+        attValue = CKEDITOR.tools.htmlEncodeAttr( attValue );
+
+      this._.output.push( ' ', attName, '="', attValue, '"' );
+    },
+
+    /**
+     * Writes a closer tag.
+     * @param {String} tagName The element name for this tag.
+     * @example
+     * // Writes "&lt;/p&gt;".
+     * writer.closeTag( 'p' );
+     */
+    closeTag : function( tagName )
+    {
+      this._.output.push( '</', tagName, '>' );
+    },
+
+    /**
+     * Writes text.
+     * @param {String} text The text value
+     * @example
+     * // Writes "Hello Word".
+     * writer.text( 'Hello Word' );
+     */
+    text : function( text )
+    {
+      this._.output.push( text );
+    },
+
+    /**
+     * Writes a comment.
+     * @param {String} comment The comment text.
+     * @example
+     * // Writes "&lt;!-- My comment --&gt;".
+     * writer.comment( ' My comment ' );
+     */
+    comment : function( comment )
+    {
+      this._.output.push( '<!--', comment, '-->' );
+    },
+
+    /**
+     * Writes any kind of data to the ouput.
+     * @example
+     * writer.write( 'This is an &lt;b&gt;example&lt;/b&gt;.' );
+     */
+    write : function( data )
+    {
+      this._.output.push( data );
+    },
+
+    /**
+     * Empties the current output buffer.
+     * @example
+     * writer.reset();
+     */
+    reset : function()
+    {
+      this._.output = [];
+      this._.indent = false;
+    },
+
+    /**
+     * Empties the current output buffer.
+     * @param {Boolean} reset Indicates that the {@link reset} function is to
+     *    be automatically called after retrieving the HTML.
+     * @returns {String} The HTML written to the writer so far.
+     * @example
+     * var html = writer.getHtml();
+     */
+    getHtml : function( reset )
+    {
+      var html = this._.output.join( '' );
+
+      if ( reset )
+        this.reset();
+
+      return html;
+    }
+  }
+});

data/app/assets/javascripts/esp-ckeditor/_source/core/htmlparser/cdata.js

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+
+  /**
+   * A lightweight representation of HTML text.
+   * @constructor
+   * @example
+   */
+  CKEDITOR.htmlParser.cdata = function( value )
+  {
+    /**
+     * The CDATA value.
+     * @type String
+     * @example
+     */
+    this.value = value;
+  };
+
+  CKEDITOR.htmlParser.cdata.prototype =
+  {
+    /**
+     * CDATA has the same type as {@link CKEDITOR.htmlParser.text} This is
+     * a constant value set to {@link CKEDITOR.NODE_TEXT}.
+     * @type Number
+     * @example
+     */
+    type : CKEDITOR.NODE_TEXT,
+
+    /**
+     * Writes write the CDATA with no special manipulations.
+     * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+     */
+    writeHtml : function( writer )
+    {
+      writer.write( this.value );
+    }
+  };
+})();

data/app/assets/javascripts/esp-ckeditor/_source/core/htmlparser/comment.js

@@ -0,0 +1,60 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * A lightweight representation of an HTML comment.
+ * @constructor
+ * @example
+ */
+CKEDITOR.htmlParser.comment = function( value )
+{
+  /**
+   * The comment text.
+   * @type String
+   * @example
+   */
+  this.value = value;
+
+  /** @private */
+  this._ =
+  {
+    isBlockLike : false
+  };
+};
+
+CKEDITOR.htmlParser.comment.prototype =
+{
+  /**
+   * The node type. This is a constant value set to {@link CKEDITOR.NODE_COMMENT}.
+   * @type Number
+   * @example
+   */
+  type : CKEDITOR.NODE_COMMENT,
+
+  /**
+   * Writes the HTML representation of this comment to a CKEDITOR.htmlWriter.
+   * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+   * @example
+   */
+  writeHtml : function( writer, filter )
+  {
+    var comment = this.value;
+
+    if ( filter )
+    {
+      if ( !( comment = filter.onComment( comment, this ) ) )
+        return;
+
+      if ( typeof comment != 'string' )
+      {
+        comment.parent = this.parent;
+        comment.writeHtml( writer, filter );
+        return;
+      }
+    }
+
+    writer.comment( comment );
+  }
+};

data/app/assets/javascripts/esp-ckeditor/_source/core/htmlparser/element.js

@@ -0,0 +1,308 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * A lightweight representation of an HTML element.
+ * @param {String} name The element name.
+ * @param {Object} attributes And object holding all attributes defined for
+ *    this element.
+ * @constructor
+ * @example
+ */
+CKEDITOR.htmlParser.element = function( name, attributes )
+{
+  /**
+   * The element name.
+   * @type String
+   * @example
+   */
+  this.name = name;
+
+  /**
+   * Holds the attributes defined for this element.
+   * @type Object
+   * @example
+   */
+  this.attributes = attributes || ( attributes = {} );
+
+  /**
+   * The nodes that are direct children of this element.
+   * @type Array
+   * @example
+   */
+  this.children = [];
+
+  var tagName = attributes[ 'data-cke-real-element-type' ] || name || '';
+
+  // Reveal the real semantic of our internal custom tag name (#6639).
+  var internalTag = tagName.match( /^cke:(.*)/ );
+    internalTag && ( tagName = internalTag[ 1 ] );
+
+  var dtd      = CKEDITOR.dtd,
+    isBlockLike  = !!( dtd.$nonBodyContent[ tagName ]
+        || dtd.$block[ tagName ]
+        || dtd.$listItem[ tagName ]
+        || dtd.$tableContent[ tagName ]
+        || dtd.$nonEditable[ tagName ]
+        || tagName == 'br' ),
+    isEmpty = !!dtd.$empty[ name ];
+
+  this.isEmpty  = isEmpty;
+  this.isUnknown  = !dtd[ name ];
+
+  /** @private */
+  this._ =
+  {
+    isBlockLike : isBlockLike,
+    hasInlineStarted : isEmpty || !isBlockLike
+  };
+};
+
+/**
+ *  Object presentation of  CSS style declaration text.
+ *  @param {CKEDITOR.htmlParser.element|String} elementOrStyleText A html parser element or the inline style text.
+ */
+CKEDITOR.htmlParser.cssStyle = function()
+{
+   var styleText,
+    arg = arguments[ 0 ],
+    rules = {};
+
+  styleText = arg instanceof CKEDITOR.htmlParser.element ? arg.attributes.style : arg;
+
+  // html-encoded quote might be introduced by 'font-family'
+  // from MS-Word which confused the following regexp. e.g.
+  //'font-family: "Lucida, Console"'
+  ( styleText || '' )
+    .replace( /"/g, '"' )
+    .replace( /\s*([^ :;]+)\s*:\s*([^;]+)\s*(?=;|$)/g,
+      function( match, name, value )
+      {
+        name == 'font-family' && ( value = value.replace( /["']/g, '' ) );
+        rules[ name.toLowerCase() ] = value;
+      });
+
+  return {
+
+    rules : rules,
+
+    /**
+     *  Apply the styles onto the specified element or object.
+     * @param {CKEDITOR.htmlParser.element|CKEDITOR.dom.element|Object} obj
+     */
+    populate : function( obj )
+    {
+      var style = this.toString();
+      if ( style )
+      {
+        obj instanceof CKEDITOR.dom.element ?
+          obj.setAttribute( 'style', style ) :
+          obj instanceof CKEDITOR.htmlParser.element ?
+            obj.attributes.style = style :
+            obj.style = style;
+      }
+    },
+
+    toString : function()
+    {
+      var output = [];
+      for ( var i in rules )
+        rules[ i ] && output.push( i, ':', rules[ i ], ';' );
+      return output.join( '' );
+    }
+  };
+};
+
+(function()
+{
+  // Used to sort attribute entries in an array, where the first element of
+  // each object is the attribute name.
+  var sortAttribs = function( a, b )
+  {
+    a = a[0];
+    b = b[0];
+    return a < b ? -1 : a > b ? 1 : 0;
+  };
+
+  CKEDITOR.htmlParser.element.prototype =
+  {
+    /**
+     * The node type. This is a constant value set to {@link CKEDITOR.NODE_ELEMENT}.
+     * @type Number
+     * @example
+     */
+    type : CKEDITOR.NODE_ELEMENT,
+
+    /**
+     * Adds a node to the element children list.
+     * @param {Object} node The node to be added. It can be any of of the
+     *    following types: {@link CKEDITOR.htmlParser.element},
+     *    {@link CKEDITOR.htmlParser.text} and
+     *    {@link CKEDITOR.htmlParser.comment}.
+     * @function
+     * @example
+     */
+    add : CKEDITOR.htmlParser.fragment.prototype.add,
+
+    /**
+     * Clone this element.
+     * @returns {CKEDITOR.htmlParser.element} The element clone.
+     * @example
+     */
+    clone : function()
+    {
+      return new CKEDITOR.htmlParser.element( this.name, this.attributes );
+    },
+
+    /**
+     * Writes the element HTML to a CKEDITOR.htmlWriter.
+     * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+     * @example
+     */
+    writeHtml : function( writer, filter )
+    {
+      var attributes = this.attributes;
+
+      // Ignore cke: prefixes when writing HTML.
+      var element = this,
+        writeName = element.name,
+        a, newAttrName, value;
+
+      var isChildrenFiltered;
+
+      /**
+       * Providing an option for bottom-up filtering order ( element
+       * children to be pre-filtered before the element itself ).
+       */
+      element.filterChildren = function()
+      {
+        if ( !isChildrenFiltered )
+        {
+          var writer = new CKEDITOR.htmlParser.basicWriter();
+          CKEDITOR.htmlParser.fragment.prototype.writeChildrenHtml.call( element, writer, filter );
+          element.children = new CKEDITOR.htmlParser.fragment.fromHtml( writer.getHtml(), 0, element.clone() ).children;
+          isChildrenFiltered = 1;
+        }
+      };
+
+      if ( filter )
+      {
+        while ( true )
+        {
+          if ( !( writeName = filter.onElementName( writeName ) ) )
+            return;
+
+          element.name = writeName;
+
+          if ( !( element = filter.onElement( element ) ) )
+            return;
+
+          element.parent = this.parent;
+
+          if ( element.name == writeName )
+            break;
+
+          // If the element has been replaced with something of a
+          // different type, then make the replacement write itself.
+          if ( element.type != CKEDITOR.NODE_ELEMENT )
+          {
+            element.writeHtml( writer, filter );
+            return;
+          }
+
+          writeName = element.name;
+
+          // This indicate that the element has been dropped by
+          // filter but not the children.
+          if ( !writeName )
+          {
+            // Fix broken parent refs.
+            for ( var c = 0, length = this.children.length ; c < length ; c++ )
+              this.children[ c ].parent = element.parent;
+
+            this.writeChildrenHtml.call( element, writer, isChildrenFiltered ? null : filter );
+            return;
+          }
+        }
+
+        // The element may have been changed, so update the local
+        // references.
+        attributes = element.attributes;
+      }
+
+      // Open element tag.
+      writer.openTag( writeName, attributes );
+
+      // Copy all attributes to an array.
+      var attribsArray = [];
+      // Iterate over the attributes twice since filters may alter
+      // other attributes.
+      for ( var i = 0 ; i < 2; i++ )
+      {
+        for ( a in attributes )
+        {
+          newAttrName = a;
+          value = attributes[ a ];
+          if ( i == 1 )
+            attribsArray.push( [ a, value ] );
+          else if ( filter )
+          {
+            while ( true )
+            {
+              if ( !( newAttrName = filter.onAttributeName( a ) ) )
+              {
+                delete attributes[ a ];
+                break;
+              }
+              else if ( newAttrName != a )
+              {
+                delete attributes[ a ];
+                a = newAttrName;
+                continue;
+              }
+              else
+                break;
+            }
+            if ( newAttrName )
+            {
+              if ( ( value = filter.onAttribute( element, newAttrName, value ) ) === false )
+                delete attributes[ newAttrName ];
+              else
+                attributes [ newAttrName ] = value;
+            }
+          }
+        }
+      }
+      // Sort the attributes by name.
+      if ( writer.sortAttributes )
+        attribsArray.sort( sortAttribs );
+
+      // Send the attributes.
+      var len = attribsArray.length;
+      for ( i = 0 ; i < len ; i++ )
+      {
+        var attrib = attribsArray[ i ];
+        writer.attribute( attrib[0], attrib[1] );
+      }
+
+      // Close the tag.
+      writer.openTagClose( writeName, element.isEmpty );
+
+      if ( !element.isEmpty )
+      {
+        this.writeChildrenHtml.call( element, writer, isChildrenFiltered ? null : filter );
+        // Close the element.
+        writer.closeTag( writeName );
+      }
+    },
+
+    writeChildrenHtml : function( writer, filter )
+    {
+      // Send children.
+      CKEDITOR.htmlParser.fragment.prototype.writeChildrenHtml.apply( this, arguments );
+
+    }
+  };
+})();