esp-ckeditor 0.1.0

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

@@ -0,0 +1,238 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Contains the second part of the {@link CKEDITOR} object
+ *    definition, which defines the basic editor features to be available in
+ *    the root ckeditor_basic.js file.
+ */
+
+if ( CKEDITOR.status == 'unloaded' )
+{
+  (function()
+  {
+    CKEDITOR.event.implementOn( CKEDITOR );
+
+    /**
+     * Forces the full CKEditor core code, in the case only the basic code has been
+     * loaded (ckeditor_basic.js). This method self-destroys (becomes undefined) in
+     * the first call or as soon as the full code is available.
+     * @example
+     * // Check if the full core code has been loaded and load it.
+     * if ( CKEDITOR.loadFullCore )
+     *     <b>CKEDITOR.loadFullCore()</b>;
+     */
+    CKEDITOR.loadFullCore = function()
+    {
+      // If not the basic code is not ready it, just mark it to be loaded.
+      if ( CKEDITOR.status != 'basic_ready' )
+      {
+        CKEDITOR.loadFullCore._load = 1;
+        return;
+      }
+
+      // Destroy this function.
+      delete CKEDITOR.loadFullCore;
+
+      // Append the script to the head.
+      var script = document.createElement( 'script' );
+      script.type = 'text/javascript';
+      script.src = CKEDITOR.basePath + 'ckeditor.js';
+
+      document.getElementsByTagName( 'head' )[0].appendChild( script );
+    };
+
+    /**
+     * The time to wait (in seconds) to load the full editor code after the
+     * page load, if the "ckeditor_basic" file is used. If set to zero, the
+     * editor is loaded on demand, as soon as an instance is created.
+     *
+     * This value must be set on the page before the page load completion.
+     * @type Number
+     * @default 0 (zero)
+     * @example
+     * // Loads the full source after five seconds.
+     * CKEDITOR.loadFullCoreTimeout = 5;
+     */
+    CKEDITOR.loadFullCoreTimeout = 0;
+
+    /**
+     * The class name used to identify &lt;textarea&gt; elements to be replace
+     * by CKEditor instances.
+     * @type String
+     * @default 'ckeditor'
+     * @example
+     * <b>CKEDITOR.replaceClass</b> = 'rich_editor';
+     */
+    CKEDITOR.replaceClass = 'ckeditor';
+
+    /**
+     * Enables the replacement of all textareas with class name matching
+     * {@link CKEDITOR.replaceClass}.
+     * @type Boolean
+     * @default true
+     * @example
+     * // Disable the auto-replace feature.
+     * <b>CKEDITOR.replaceByClassEnabled</b> = false;
+     */
+    CKEDITOR.replaceByClassEnabled = 1;
+
+    var createInstance = function( elementOrIdOrName, config, creationFunction, data )
+    {
+      if ( CKEDITOR.env.isCompatible )
+      {
+        // Load the full core.
+        if ( CKEDITOR.loadFullCore )
+          CKEDITOR.loadFullCore();
+
+        var editor = creationFunction( elementOrIdOrName, config, data );
+        CKEDITOR.add( editor );
+        return editor;
+      }
+
+      return null;
+    };
+
+    /**
+     * Replaces a &lt;textarea&gt; or a DOM element (DIV) with a CKEditor
+     * instance. For textareas, the initial value in the editor will be the
+     * textarea value. For DOM elements, their innerHTML will be used
+     * instead. We recommend using TEXTAREA and DIV elements only.
+     * @param {Object|String} elementOrIdOrName The DOM element (textarea), its
+     *    ID or name.
+     * @param {Object} [config] The specific configurations to apply to this
+     *    editor instance. Configurations set here will override global CKEditor
+     *    settings.
+     * @returns {CKEDITOR.editor} The editor instance created.
+     * @example
+     * &lt;textarea id="myfield" name="myfield"&gt;&lt:/textarea&gt;
+     * ...
+     * <b>CKEDITOR.replace( 'myfield' )</b>;
+     * @example
+     * var textarea = document.body.appendChild( document.createElement( 'textarea' ) );
+     * <b>CKEDITOR.replace( textarea )</b>;
+     */
+    CKEDITOR.replace = function( elementOrIdOrName, config )
+    {
+      return createInstance( elementOrIdOrName, config, CKEDITOR.editor.replace );
+    };
+
+    /**
+     * Creates a new editor instance inside a specific DOM element.
+     * @param {Object|String} elementOrId The DOM element or its ID.
+     * @param {Object} [config] The specific configurations to apply to this
+     *    editor instance. Configurations set here will override global CKEditor
+     *    settings.
+     * @param {String} [data] Since 3.3. Initial value for the instance.
+     * @returns {CKEDITOR.editor} The editor instance created.
+     * @example
+     * &lt;div id="editorSpace"&gt;&lt:/div&gt;
+     * ...
+     * <b>CKEDITOR.appendTo( 'editorSpace' )</b>;
+     */
+    CKEDITOR.appendTo = function( elementOrId, config, data )
+    {
+      return createInstance( elementOrId, config, CKEDITOR.editor.appendTo, data );
+    };
+
+    // Documented at ckeditor.js.
+    CKEDITOR.add = function( editor )
+    {
+      // For now, just put the editor in the pending list. It will be
+      // processed as soon as the full code gets loaded.
+      var pending = this._.pending || ( this._.pending = [] );
+      pending.push( editor );
+    };
+
+    /**
+     * Replace all &lt;textarea&gt; elements available in the document with
+     * editor instances.
+     * @example
+     * // Replace all &lt;textarea&gt; elements in the page.
+     * CKEDITOR.replaceAll();
+     * @example
+     * // Replace all &lt;textarea class="myClassName"&gt; elements in the page.
+     * CKEDITOR.replaceAll( 'myClassName' );
+     * @example
+     * // Selectively replace &lt;textarea&gt; elements, based on custom assertions.
+     * CKEDITOR.replaceAll( function( textarea, config )
+     *     {
+     *         // Custom code to evaluate the replace, returning false
+     *         // if it must not be done.
+     *         // It also passes the "config" parameter, so the
+     *         // developer can customize the instance.
+     *     } );
+     */
+    CKEDITOR.replaceAll = function()
+    {
+      var textareas = document.getElementsByTagName( 'textarea' );
+
+      for ( var i = 0 ; i < textareas.length ; i++ )
+      {
+        var config = null,
+          textarea = textareas[i];
+
+        // The "name" and/or "id" attribute must exist.
+        if ( !textarea.name && !textarea.id )
+          continue;
+
+        if ( typeof arguments[0] == 'string' )
+        {
+          // The textarea class name could be passed as the function
+          // parameter.
+
+          var classRegex = new RegExp( '(?:^|\\s)' + arguments[0] + '(?:$|\\s)' );
+
+          if ( !classRegex.test( textarea.className ) )
+            continue;
+        }
+        else if ( typeof arguments[0] == 'function' )
+        {
+          // An assertion function could be passed as the function parameter.
+          // It must explicitly return "false" to ignore a specific <textarea>.
+          config = {};
+          if ( arguments[0]( textarea, config ) === false )
+            continue;
+        }
+
+        this.replace( textarea, config );
+      }
+    };
+
+    (function()
+    {
+      var onload = function()
+      {
+        var loadFullCore = CKEDITOR.loadFullCore,
+          loadFullCoreTimeout = CKEDITOR.loadFullCoreTimeout;
+
+        // Replace all textareas with the default class name.
+        if ( CKEDITOR.replaceByClassEnabled )
+          CKEDITOR.replaceAll( CKEDITOR.replaceClass );
+
+        CKEDITOR.status = 'basic_ready';
+
+        if ( loadFullCore && loadFullCore._load )
+          loadFullCore();
+        else if ( loadFullCoreTimeout )
+        {
+          setTimeout( function()
+            {
+              if ( CKEDITOR.loadFullCore )
+                CKEDITOR.loadFullCore();
+            }
+            , loadFullCoreTimeout * 1000 );
+        }
+      };
+
+      if ( window.addEventListener )
+        window.addEventListener( 'load', onload, false );
+      else if ( window.attachEvent )
+        window.attachEvent( 'onload', onload );
+    })();
+
+    CKEDITOR.status = 'basic_loaded';
+  })();
+}

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

@@ -0,0 +1,209 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * Creates a command class instance.
+ * @class Represents a command that can be executed on an editor instance.
+ * @param {CKEDITOR.editor} editor The editor instance this command will be
+ *    related to.
+ * @param {CKEDITOR.commandDefinition} commandDefinition The command
+ *    definition.
+ * @augments CKEDITOR.event
+ * @example
+ * var command = new CKEDITOR.command( editor,
+ *     {
+ *         exec : function( editor )
+ *         {
+ *             alert( editor.document.getBody().getHtml() );
+ *         }
+ *     });
+ */
+CKEDITOR.command = function( editor, commandDefinition )
+{
+  /**
+   * Lists UI items that are associated to this command. This list can be
+   * used to interact with the UI on command execution (by the execution code
+   * itself, for example).
+   * @type Array
+   * @example
+   * alert( 'Number of UI items associated to this command: ' + command.<b>uiItems</b>.length );
+   */
+  this.uiItems = [];
+
+  /**
+   * Executes the command.
+   * @param {Object} [data] Any data to pass to the command. Depends on the
+   *    command implementation and requirements.
+   * @returns {Boolean} A boolean indicating that the command has been
+   *      successfully executed.
+   * @example
+   * command.<b>exec()</b>;  // The command gets executed.
+   */
+  this.exec = function( data )
+  {
+    if ( this.state == CKEDITOR.TRISTATE_DISABLED )
+      return false;
+
+    if ( this.editorFocus )     // Give editor focus if necessary (#4355).
+      editor.focus();
+
+    return ( commandDefinition.exec.call( this, editor, data ) !== false );
+  };
+
+  CKEDITOR.tools.extend( this, commandDefinition,
+    // Defaults
+    /** @lends CKEDITOR.command.prototype */
+    {
+      /**
+       * The editor modes within which the command can be executed. The
+       * execution will have no action if the current mode is not listed
+       * in this property.
+       * @type Object
+       * @default { wysiwyg : 1 }
+       * @see CKEDITOR.editor.prototype.mode
+       * @example
+       * // Enable the command in both WYSIWYG and Source modes.
+       * command.<b>modes</b> = { wysiwyg : 1, source : 1 };
+       * @example
+       * // Enable the command in Source mode only.
+       * command.<b>modes</b> = { source : 1 };
+       */
+      modes : { wysiwyg : 1 },
+
+      /**
+       * Indicates that the editor will get the focus before executing
+       * the command.
+       * @type Boolean
+       * @default true
+       * @example
+       * // Do not force the editor to have focus when executing the command.
+       * command.<b>editorFocus</b> = false;
+       */
+      editorFocus : 1,
+
+      /**
+       * Indicates the editor state. Possible values are:
+       * <ul>
+       * <li>{@link CKEDITOR.TRISTATE_DISABLED}: the command is
+       *    disabled. It's execution will have no effect. Same as
+       *    {@link disable}.</li>
+       * <li>{@link CKEDITOR.TRISTATE_ON}: the command is enabled
+       *    and currently active in the editor (for context sensitive commands,
+       *    for example).</li>
+       * <li>{@link CKEDITOR.TRISTATE_OFF}: the command is enabled
+       *    and currently inactive in the editor (for context sensitive
+       *    commands, for example).</li>
+       * </ul>
+       * Do not set this property directly, using the {@link #setState}
+       * method instead.
+       * @type Number
+       * @default {@link CKEDITOR.TRISTATE_OFF}
+       * @example
+       * if ( command.<b>state</b> == CKEDITOR.TRISTATE_DISABLED )
+       *     alert( 'This command is disabled' );
+       */
+      state : CKEDITOR.TRISTATE_OFF
+    });
+
+  // Call the CKEDITOR.event constructor to initialize this instance.
+  CKEDITOR.event.call( this );
+};
+
+CKEDITOR.command.prototype =
+{
+  /**
+   * Enables the command for execution. The command state (see
+   * {@link CKEDITOR.command.prototype.state}) available before disabling it
+   * is restored.
+   * @example
+   * command.<b>enable()</b>;
+   * command.exec();    // Execute the command.
+   */
+  enable : function()
+  {
+    if ( this.state == CKEDITOR.TRISTATE_DISABLED )
+      this.setState( ( !this.preserveState || ( typeof this.previousState == 'undefined' ) ) ? CKEDITOR.TRISTATE_OFF : this.previousState );
+  },
+
+  /**
+   * Disables the command for execution. The command state (see
+   * {@link CKEDITOR.command.prototype.state}) will be set to
+   * {@link CKEDITOR.TRISTATE_DISABLED}.
+   * @example
+   * command.<b>disable()</b>;
+   * command.exec();    // "false" - Nothing happens.
+   */
+  disable : function()
+  {
+    this.setState( CKEDITOR.TRISTATE_DISABLED );
+  },
+
+  /**
+   * Sets the command state.
+   * @param {Number} newState The new state. See {@link #state}.
+   * @returns {Boolean} Returns "true" if the command state changed.
+   * @example
+   * command.<b>setState( CKEDITOR.TRISTATE_ON )</b>;
+   * command.exec();    // Execute the command.
+   * command.<b>setState( CKEDITOR.TRISTATE_DISABLED )</b>;
+   * command.exec();    // "false" - Nothing happens.
+   * command.<b>setState( CKEDITOR.TRISTATE_OFF )</b>;
+   * command.exec();    // Execute the command.
+   */
+  setState : function( newState )
+  {
+    // Do nothing if there is no state change.
+    if ( this.state == newState )
+      return false;
+
+    this.previousState = this.state;
+
+    // Set the new state.
+    this.state = newState;
+
+    // Fire the "state" event, so other parts of the code can react to the
+    // change.
+    this.fire( 'state' );
+
+    return true;
+  },
+
+  /**
+   * Toggles the on/off (active/inactive) state of the command. This is
+   * mainly used internally by context sensitive commands.
+   * @example
+   * command.<b>toggleState()</b>;
+   */
+  toggleState : function()
+  {
+    if ( this.state == CKEDITOR.TRISTATE_OFF )
+      this.setState( CKEDITOR.TRISTATE_ON );
+    else if ( this.state == CKEDITOR.TRISTATE_ON )
+      this.setState( CKEDITOR.TRISTATE_OFF );
+  }
+};
+
+CKEDITOR.event.implementOn( CKEDITOR.command.prototype, true );
+
+/**
+ * Indicates the previous command state.
+ * @name CKEDITOR.command.prototype.previousState
+ * @type Number
+ * @see #state
+ * @example
+ * alert( command.<b>previousState</b> );
+ */
+
+/**
+ * Fired when the command state changes.
+ * @name CKEDITOR.command#state
+ * @event
+ * @example
+ * command.on( <b>'state'</b> , function( e )
+ *     {
+ *         // Alerts the new state.
+ *         alert( this.state );
+ *     });
+ */

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

@@ -0,0 +1,129 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the "virtual" {@link CKEDITOR.commandDefinition} class,
+ *    which contains the defintion of a command. This file is for
+ *    documentation purposes only.
+ */
+
+/**
+ * (Virtual Class) Do not call this constructor. This class is not really part
+ * of the API.
+ * @name CKEDITOR.commandDefinition
+ * @class Virtual class that illustrates the features of command objects to be
+ *    passed to the {@link CKEDITOR.editor.prototype.addCommand} function.
+ * @example
+ */
+
+ /**
+ * The function to be fired when the commend is executed.
+ * @name CKEDITOR.commandDefinition.prototype.exec
+ * @function
+ * @param {CKEDITOR.editor} editor The editor within which run the command.
+ * @param {Object} [data] Additional data to be used to execute the command.
+ * @returns {Boolean} Whether the command has been successfully executed.
+ *    Defaults to "true", if nothing is returned.
+ * @example
+ * editorInstance.addCommand( 'sample',
+ * {
+ *     exec : function( editor )
+ *     {
+ *         alert( 'Executing a command for the editor name "' + editor.name + '"!' );
+ *     }
+ * });
+ */
+
+/**
+ * Whether the command need to be hooked into the redo/undo system.
+ * @name  CKEDITOR.commandDefinition.prototype.canUndo
+ * @type {Boolean}
+ * @default true
+ * @field
+ * @example
+ * editorInstance.addCommand( 'alertName',
+ * {
+ *     exec : function( editor )
+ *     {
+ *         alert( editor.name );
+ *     },
+ *     canUndo : false    // No support for undo/redo
+ * });
+ */
+
+/**
+ * Whether the command is asynchronous, which means that the
+ * {@link CKEDITOR.editor#event:afterCommandExec} event will be fired by the
+ * command itself manually, and that the return value of this command is not to
+ * be returned by the {@link CKEDITOR.command#exec} function.
+ * @name  CKEDITOR.commandDefinition.prototype.async
+ * @default false
+ * @type {Boolean}
+ * @example
+ * editorInstance.addCommand( 'loadOptions',
+ * {
+ *     exec : function( editor )
+ *     {
+ *         // Asynchronous operation below.
+ *         CKEDITOR.ajax.loadXml( 'data.xml', function()
+ *             {
+ *                 editor.fire( 'afterCommandExec' );
+ *             ));
+ *     },
+ *     async : true    // The command need some time to complete after exec function returns.
+ * });
+ */
+
+/**
+ * Whether the command should give focus to the editor before execution.
+ * @name  CKEDITOR.commandDefinition.prototype.editorFocus
+ * @type {Boolean}
+ * @default true
+ * @see CKEDITOR.command#editorFocus
+ * @example
+ * editorInstance.addCommand( 'maximize',
+ * {
+ *     exec : function( editor )
+ *     {
+ *         // ...
+ *     },
+ *     editorFocus : false    // The command doesn't require focusing the editing document.
+ * });
+ */
+
+
+/**
+ * Whether the command state should be set to {@link CKEDITOR.TRISTATE_DISABLED} on startup.
+ * @name  CKEDITOR.commandDefinition.prototype.startDisabled
+ * @type {Boolean}
+ * @default false
+ * @example
+ * editorInstance.addCommand( 'unlink',
+ * {
+ *     exec : function( editor )
+ *     {
+ *         // ...
+ *     },
+ *     startDisabled : true    // Command is unavailable until selection is inside a link.
+ * });
+ */
+
+/**
+ * The editor modes within which the command can be executed. The execution
+ * will have no action if the current mode is not listed in this property.
+ * @name  CKEDITOR.commandDefinition.prototype.modes
+ * @type Object
+ * @default { wysiwyg : 1 }
+ * @see CKEDITOR.command#modes
+ * @example
+ * editorInstance.addCommand( 'link',
+ * {
+ *     exec : function( editor )
+ *     {
+ *         // ...
+ *     },
+ *     modes : { wysiwyg : 1 }    // Command is available in wysiwyg mode only.
+ * });
+ */