esp-ckeditor 0.1.0

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

@@ -0,0 +1,32 @@
+/*
+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.dom.comment} class, which represents
+ *    a DOM comment node.
+ */
+
+CKEDITOR.dom.comment = CKEDITOR.tools.createClass(
+{
+  base : CKEDITOR.dom.node,
+
+  $ : function( text, ownerDocument )
+  {
+    if ( typeof text == 'string' )
+      text = ( ownerDocument ? ownerDocument.$ : document ).createComment( text );
+
+    this.base( text );
+  },
+
+  proto :
+  {
+    type : CKEDITOR.NODE_COMMENT,
+
+    getOuterHtml : function()
+    {
+      return '<!--' + this.$.nodeValue + '-->';
+    }
+  }
+});

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

@@ -0,0 +1,251 @@
+/*
+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.dom.document} class, which
+ *    represents a DOM document.
+ */
+
+/**
+ * Represents a DOM document.
+ * @constructor
+ * @augments CKEDITOR.dom.domObject
+ * @param {Object} domDocument A native DOM document.
+ * @example
+ * var document = new CKEDITOR.dom.document( document );
+ */
+CKEDITOR.dom.document = function( domDocument )
+{
+  CKEDITOR.dom.domObject.call( this, domDocument );
+};
+
+// PACKAGER_RENAME( CKEDITOR.dom.document )
+
+CKEDITOR.dom.document.prototype = new CKEDITOR.dom.domObject();
+
+CKEDITOR.tools.extend( CKEDITOR.dom.document.prototype,
+  /** @lends CKEDITOR.dom.document.prototype */
+  {
+    /**
+     * Appends a CSS file to the document.
+     * @param {String} cssFileUrl The CSS file URL.
+     * @example
+     * <b>CKEDITOR.document.appendStyleSheet( '/mystyles.css' )</b>;
+     */
+    appendStyleSheet : function( cssFileUrl )
+    {
+      if ( this.$.createStyleSheet )
+        this.$.createStyleSheet( cssFileUrl );
+      else
+      {
+        var link = new CKEDITOR.dom.element( 'link' );
+        link.setAttributes(
+          {
+            rel    :'stylesheet',
+            type  : 'text/css',
+            href  : cssFileUrl
+          });
+
+        this.getHead().append( link );
+      }
+    },
+
+    appendStyleText : function( cssStyleText )
+    {
+      if ( this.$.createStyleSheet )
+      {
+        var styleSheet = this.$.createStyleSheet( "" );
+        styleSheet.cssText = cssStyleText ;
+      }
+      else
+      {
+        var style = new CKEDITOR.dom.element( 'style', this );
+        style.append( new CKEDITOR.dom.text( cssStyleText, this ) );
+        this.getHead().append( style );
+      }
+    },
+
+    createElement : function( name, attribsAndStyles )
+    {
+      var element = new CKEDITOR.dom.element( name, this );
+
+      if ( attribsAndStyles )
+      {
+        if ( attribsAndStyles.attributes )
+          element.setAttributes( attribsAndStyles.attributes );
+
+        if ( attribsAndStyles.styles )
+          element.setStyles( attribsAndStyles.styles );
+      }
+
+      return element;
+    },
+
+    createText : function( text )
+    {
+      return new CKEDITOR.dom.text( text, this );
+    },
+
+    focus : function()
+    {
+      this.getWindow().focus();
+    },
+
+    /**
+     * Gets and element based on its id.
+     * @param {String} elementId The element id.
+     * @returns {CKEDITOR.dom.element} The element instance, or null if not found.
+     * @example
+     * var element = <b>CKEDITOR.document.getById( 'myElement' )</b>;
+     * alert( element.getId() );  // "myElement"
+     */
+    getById : function( elementId )
+    {
+      var $ = this.$.getElementById( elementId );
+      return $ ? new CKEDITOR.dom.element( $ ) : null;
+    },
+
+    getByAddress : function( address, normalized )
+    {
+      var $ = this.$.documentElement;
+
+      for ( var i = 0 ; $ && i < address.length ; i++ )
+      {
+        var target = address[ i ];
+
+        if ( !normalized )
+        {
+          $ = $.childNodes[ target ];
+          continue;
+        }
+
+        var currentIndex = -1;
+
+        for (var j = 0 ; j < $.childNodes.length ; j++ )
+        {
+          var candidate = $.childNodes[ j ];
+
+          if ( normalized === true &&
+              candidate.nodeType == 3 &&
+              candidate.previousSibling &&
+              candidate.previousSibling.nodeType == 3 )
+          {
+            continue;
+          }
+
+          currentIndex++;
+
+          if ( currentIndex == target )
+          {
+            $ = candidate;
+            break;
+          }
+        }
+      }
+
+      return $ ? new CKEDITOR.dom.node( $ ) : null;
+    },
+
+    getElementsByTag : function( tagName, namespace )
+    {
+      if ( !( CKEDITOR.env.ie && ! ( document.documentMode > 8 ) ) && namespace )
+        tagName = namespace + ':' + tagName;
+      return new CKEDITOR.dom.nodeList( this.$.getElementsByTagName( tagName ) );
+    },
+
+    /**
+     * Gets the &lt;head&gt; element for this document.
+     * @returns {CKEDITOR.dom.element} The &lt;head&gt; element.
+     * @example
+     * var element = <b>CKEDITOR.document.getHead()</b>;
+     * alert( element.getName() );  // "head"
+     */
+    getHead : function()
+    {
+      var head = this.$.getElementsByTagName( 'head' )[0];
+      if ( !head )
+        head = this.getDocumentElement().append( new CKEDITOR.dom.element( 'head' ), true );
+      else
+      head = new CKEDITOR.dom.element( head );
+
+      return (
+      this.getHead = function()
+        {
+          return head;
+        })();
+    },
+
+    /**
+     * Gets the &lt;body&gt; element for this document.
+     * @returns {CKEDITOR.dom.element} The &lt;body&gt; element.
+     * @example
+     * var element = <b>CKEDITOR.document.getBody()</b>;
+     * alert( element.getName() );  // "body"
+     */
+    getBody : function()
+    {
+      var body = new CKEDITOR.dom.element( this.$.body );
+
+      return (
+      this.getBody = function()
+        {
+          return body;
+        })();
+    },
+
+    /**
+     * Gets the DOM document element for this document.
+     * @returns {CKEDITOR.dom.element} The DOM document element.
+     */
+    getDocumentElement : function()
+    {
+      var documentElement = new CKEDITOR.dom.element( this.$.documentElement );
+
+      return (
+      this.getDocumentElement = function()
+        {
+          return documentElement;
+        })();
+    },
+
+    /**
+     * Gets the window object that holds this document.
+     * @returns {CKEDITOR.dom.window} The window object.
+     */
+    getWindow : function()
+    {
+      var win = new CKEDITOR.dom.window( this.$.parentWindow || this.$.defaultView );
+
+      return (
+      this.getWindow = function()
+        {
+          return win;
+        })();
+    },
+
+    /**
+     * Defines the document contents through document.write. Note that the
+     * previous document contents will be lost (cleaned).
+     * @since 3.5
+     * @param {String} html The HTML defining the document contents.
+     * @example
+     * document.write(
+     *     '&lt;html&gt;' +
+     *         '&lt;head&gt;&lt;title&gt;Sample Doc&lt;/title&gt;&lt;/head&gt;' +
+     *         '&lt;body&gt;Document contents created by code&lt;/body&gt;' +
+     *      '&lt;/html&gt;' );
+     */
+    write : function( html )
+    {
+      // Don't leave any history log in IE. (#5657)
+      this.$.open( 'text/html', 'replace' );
+
+      // Support for custom document.domain in IE.
+      CKEDITOR.env.isCustomDomain() &&  ( this.$.domain = document.domain );
+
+      this.$.write( html );
+      this.$.close();
+    }
+  });

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

@@ -0,0 +1,49 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @class DocumentFragment is a "lightweight" or "minimal" Document object. It is
+ * commonly used to extract a portion of a document's tree or to create a new
+ * fragment of a document. Various operations may take DocumentFragment objects
+ * as arguments and results in all the child nodes of the DocumentFragment being
+ * moved to the child list of this node.
+ * @param {Object} ownerDocument
+ */
+CKEDITOR.dom.documentFragment = function( ownerDocument )
+{
+  ownerDocument = ownerDocument || CKEDITOR.document;
+  this.$ = ownerDocument.$.createDocumentFragment();
+};
+
+CKEDITOR.tools.extend( CKEDITOR.dom.documentFragment.prototype,
+  CKEDITOR.dom.element.prototype,
+  {
+    type : CKEDITOR.NODE_DOCUMENT_FRAGMENT,
+    insertAfterNode : function( node )
+    {
+      node = node.$;
+      node.parentNode.insertBefore( this.$, node.nextSibling );
+    }
+  },
+  true,
+  {
+    'append' : 1,
+    'appendBogus' : 1,
+    'getFirst' : 1,
+    'getLast' : 1,
+    'appendTo' : 1,
+    'moveChildren' : 1,
+    'insertBefore' : 1,
+    'insertAfterNode' : 1,
+    'replace' : 1,
+    'trim' : 1,
+    'type' : 1,
+    'ltrim' : 1,
+    'rtrim' : 1,
+    'getDocument' : 1,
+    'getChildCount' : 1,
+    'getChild' : 1,
+    'getChildren' : 1
+  } );

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

@@ -0,0 +1,258 @@
+/*
+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.editor} class, which is the base
+ *    for other classes representing DOM objects.
+ */
+
+/**
+ * Represents a DOM object. This class is not intended to be used directly. It
+ * serves as the base class for other classes representing specific DOM
+ * objects.
+ * @constructor
+ * @param {Object} nativeDomObject A native DOM object.
+ * @augments CKEDITOR.event
+ * @example
+ */
+CKEDITOR.dom.domObject = function( nativeDomObject )
+{
+  if ( nativeDomObject )
+  {
+    /**
+     * The native DOM object represented by this class instance.
+     * @type Object
+     * @example
+     * var element = new CKEDITOR.dom.element( 'span' );
+     * alert( element.$.nodeType );  // "1"
+     */
+    this.$ = nativeDomObject;
+  }
+};
+
+CKEDITOR.dom.domObject.prototype = (function()
+{
+  // Do not define other local variables here. We want to keep the native
+  // listener closures as clean as possible.
+
+  var getNativeListener = function( domObject, eventName )
+  {
+    return function( domEvent )
+    {
+      // In FF, when reloading the page with the editor focused, it may
+      // throw an error because the CKEDITOR global is not anymore
+      // available. So, we check it here first. (#2923)
+      if ( typeof CKEDITOR != 'undefined' )
+        domObject.fire( eventName, new CKEDITOR.dom.event( domEvent ) );
+    };
+  };
+
+  return /** @lends CKEDITOR.dom.domObject.prototype */ {
+
+    getPrivate : function()
+    {
+      var priv;
+
+      // Get the main private function from the custom data. Create it if not
+      // defined.
+      if ( !( priv = this.getCustomData( '_' ) ) )
+        this.setCustomData( '_', ( priv = {} ) );
+
+      return priv;
+    },
+
+    /** @ignore */
+    on  : function( eventName )
+    {
+      // We customize the "on" function here. The basic idea is that we'll have
+      // only one listener for a native event, which will then call all listeners
+      // set to the event.
+
+      // Get the listeners holder object.
+      var nativeListeners = this.getCustomData( '_cke_nativeListeners' );
+
+      if ( !nativeListeners )
+      {
+        nativeListeners = {};
+        this.setCustomData( '_cke_nativeListeners', nativeListeners );
+      }
+
+      // Check if we have a listener for that event.
+      if ( !nativeListeners[ eventName ] )
+      {
+        var listener = nativeListeners[ eventName ] = getNativeListener( this, eventName );
+
+        if ( this.$.attachEvent )
+          this.$.attachEvent( 'on' + eventName, listener );
+        else if ( this.$.addEventListener )
+          this.$.addEventListener( eventName, listener, !!CKEDITOR.event.useCapture );
+      }
+
+      // Call the original implementation.
+      return CKEDITOR.event.prototype.on.apply( this, arguments );
+    },
+
+    /** @ignore */
+    removeListener : function( eventName )
+    {
+      // Call the original implementation.
+      CKEDITOR.event.prototype.removeListener.apply( this, arguments );
+
+      // If we don't have listeners for this event, clean the DOM up.
+      if ( !this.hasListeners( eventName ) )
+      {
+        var nativeListeners = this.getCustomData( '_cke_nativeListeners' );
+        var listener = nativeListeners && nativeListeners[ eventName ];
+        if ( listener )
+        {
+          if ( this.$.detachEvent )
+            this.$.detachEvent( 'on' + eventName, listener );
+          else if ( this.$.removeEventListener )
+            this.$.removeEventListener( eventName, listener, false );
+
+          delete nativeListeners[ eventName ];
+        }
+      }
+    },
+
+    /**
+     * Removes any listener set on this object.
+     * To avoid memory leaks we must assure that there are no
+     * references left after the object is no longer needed.
+     */
+    removeAllListeners : function()
+    {
+      var nativeListeners = this.getCustomData( '_cke_nativeListeners' );
+      for ( var eventName in nativeListeners )
+      {
+        var listener = nativeListeners[ eventName ];
+        if ( this.$.detachEvent )
+          this.$.detachEvent( 'on' + eventName, listener );
+        else if ( this.$.removeEventListener )
+          this.$.removeEventListener( eventName, listener, false );
+
+        delete nativeListeners[ eventName ];
+      }
+    }
+  };
+})();
+
+(function( domObjectProto )
+{
+  var customData = {};
+
+  CKEDITOR.on( 'reset', function()
+    {
+      customData = {};
+    });
+
+  /**
+   * Determines whether the specified object is equal to the current object.
+   * @name CKEDITOR.dom.domObject.prototype.equals
+   * @function
+   * @param {Object} object The object to compare with the current object.
+   * @returns {Boolean} "true" if the object is equal.
+   * @example
+   * var doc = new CKEDITOR.dom.document( document );
+   * alert( doc.equals( CKEDITOR.document ) );  // "true"
+   * alert( doc == CKEDITOR.document );         // "false"
+   */
+  domObjectProto.equals = function( object )
+  {
+    return ( object && object.$ === this.$ );
+  };
+
+  /**
+   * Sets a data slot value for this object. These values are shared by all
+   * instances pointing to that same DOM object.
+   * <strong>Note:</strong> The created data slot is only guarantied to be available on this unique dom node,
+   * thus any wish to continue access it from other element clones (either created by clone node or from innerHtml)
+   * will fail, for such usage, please use {@link CKEDITOR.dom.element::setAttribute} instead.
+   * @name CKEDITOR.dom.domObject.prototype.setCustomData
+   * @function
+   * @param {String} key A key used to identify the data slot.
+   * @param {Object} value The value to set to the data slot.
+   * @returns {CKEDITOR.dom.domObject} This DOM object instance.
+   * @see CKEDITOR.dom.domObject.prototype.getCustomData
+   * @example
+   * var element = new CKEDITOR.dom.element( 'span' );
+   * element.setCustomData( 'hasCustomData', true );
+   */
+  domObjectProto.setCustomData = function( key, value )
+  {
+    var expandoNumber = this.getUniqueId(),
+      dataSlot = customData[ expandoNumber ] || ( customData[ expandoNumber ] = {} );
+
+    dataSlot[ key ] = value;
+
+    return this;
+  };
+
+  /**
+   * Gets the value set to a data slot in this object.
+   * @name CKEDITOR.dom.domObject.prototype.getCustomData
+   * @function
+   * @param {String} key The key used to identify the data slot.
+   * @returns {Object} This value set to the data slot.
+   * @see CKEDITOR.dom.domObject.prototype.setCustomData
+   * @example
+   * var element = new CKEDITOR.dom.element( 'span' );
+   * alert( element.getCustomData( 'hasCustomData' ) );  // e.g. 'true'
+   */
+  domObjectProto.getCustomData = function( key )
+  {
+    var expandoNumber = this.$[ 'data-cke-expando' ],
+      dataSlot = expandoNumber && customData[ expandoNumber ];
+
+    return dataSlot && dataSlot[ key ];
+  };
+
+  /**
+   * @name CKEDITOR.dom.domObject.prototype.removeCustomData
+   */
+  domObjectProto.removeCustomData = function( key )
+  {
+    var expandoNumber = this.$[ 'data-cke-expando' ],
+      dataSlot = expandoNumber && customData[ expandoNumber ],
+      retval = dataSlot && dataSlot[ key ];
+
+    if ( typeof retval != 'undefined' )
+      delete dataSlot[ key ];
+
+    return retval || null;
+  };
+
+  /**
+   * Removes any data stored on this object.
+   * To avoid memory leaks we must assure that there are no
+   * references left after the object is no longer needed.
+   * @name CKEDITOR.dom.domObject.prototype.clearCustomData
+   * @function
+   */
+  domObjectProto.clearCustomData = function()
+  {
+    // Clear all event listeners
+    this.removeAllListeners();
+
+    var expandoNumber = this.$[ 'data-cke-expando' ];
+    expandoNumber && delete customData[ expandoNumber ];
+  };
+
+  /**
+   * Gets an ID that can be used to identiquely identify this DOM object in
+   * the running session.
+   * @name CKEDITOR.dom.domObject.prototype.getUniqueId
+   * @function
+   * @returns {Number} A unique ID.
+   */
+  domObjectProto.getUniqueId = function()
+  {
+    return this.$[ 'data-cke-expando' ] || ( this.$[ 'data-cke-expando' ] = CKEDITOR.tools.getNextNumber() );
+  };
+
+  // Implement CKEDITOR.event.
+  CKEDITOR.event.implementOn( domObjectProto );
+
+})( CKEDITOR.dom.domObject.prototype );