esp-ckeditor 0.1.0

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

@@ -0,0 +1,83 @@
+/*
+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.pluginDefinition} class, which
+ *    contains the defintion of a plugin. This file is for documentation
+ *    purposes only.
+ */
+
+/**
+ * (Virtual Class) Do not call this constructor. This class is not really part
+ *    of the API. It just illustrates the features of plugin objects to be
+ *    passed to the {@link CKEDITOR.plugins.add} function.
+ * @name CKEDITOR.pluginDefinition
+ * @constructor
+ * @example
+ */
+
+/**
+ * A list of plugins that are required by this plugin. Note that this property
+ * doesn't guarantee the loading order of the plugins.
+ * @name CKEDITOR.pluginDefinition.prototype.requires
+ * @type Array
+ * @example
+ * CKEDITOR.plugins.add( 'sample',
+ * {
+ *     requires : [ 'button', 'selection' ]
+ * });
+ */
+
+/**
+ * A list of language files available for this plugin. These files are stored inside
+ * the "lang" directory, which is inside the plugin directory, follow the name
+ * pattern of "langCode.js", and contain a language definition created with {@link CKEDITOR.pluginDefinition#setLang}.
+ * While the plugin is being loaded, the editor checks this list to see if
+ * a language file of the current editor language ({@link CKEDITOR.editor#langCode})
+ * is available, and if so, loads it. Otherwise, the file represented by the first list item
+ * in the list is loaded.
+ * @name CKEDITOR.pluginDefinition.prototype.lang
+ * @type Array
+ * @example
+ * CKEDITOR.plugins.add( 'sample',
+ * {
+ *     lang : [ 'en', 'fr' ]
+ * });
+ */
+
+ /**
+ * Function called on initialization of every editor instance created in the
+ * page before the init() call task. The beforeInit function will be called for
+ * all plugins, after that the init function is called for all of them. This
+ * feature makes it possible to initialize things that could be used in the
+ * init function of other plugins.
+ * @name CKEDITOR.pluginDefinition.prototype.beforeInit
+ * @function
+ * @param {CKEDITOR.editor} editor The editor instance being initialized.
+ * @example
+ * CKEDITOR.plugins.add( 'sample',
+ * {
+ *     beforeInit : function( editor )
+ *     {
+ *         alert( 'Editor "' + editor.name + '" is to be initialized!' );
+ *     }
+ * });
+ */
+
+ /**
+ * Function called on initialization of every editor instance created in the
+ * page.
+ * @name CKEDITOR.pluginDefinition.prototype.init
+ * @function
+ * @param {CKEDITOR.editor} editor The editor instance being initialized.
+ * @example
+ * CKEDITOR.plugins.add( 'sample',
+ * {
+ *     init : function( editor )
+ *     {
+ *         alert( 'Editor "' + editor.name + '" is being initialized!' );
+ *     }
+ * });
+ */

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

@@ -0,0 +1,103 @@
+/*
+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.plugins} object, which is used to
+ *    manage plugins registration and loading.
+ */
+
+/**
+ * Manages plugins registration and loading.
+ * @namespace
+ * @augments CKEDITOR.resourceManager
+ * @example
+ */
+CKEDITOR.plugins = new CKEDITOR.resourceManager(
+  '_source/' +  // @Packager.RemoveLine
+  'plugins/', 'plugin' );
+
+// PACKAGER_RENAME( CKEDITOR.plugins )
+
+CKEDITOR.plugins.load = CKEDITOR.tools.override( CKEDITOR.plugins.load, function( originalLoad )
+  {
+    return function( name, callback, scope )
+    {
+      var allPlugins = {};
+
+      var loadPlugins = function( names )
+      {
+        originalLoad.call( this, names, function( plugins )
+          {
+            CKEDITOR.tools.extend( allPlugins, plugins );
+
+            var requiredPlugins = [];
+            for ( var pluginName in plugins )
+            {
+              var plugin = plugins[ pluginName ],
+                requires = plugin && plugin.requires;
+
+              if ( requires )
+              {
+                for ( var i = 0 ; i < requires.length ; i++ )
+                {
+                  if ( !allPlugins[ requires[ i ] ] )
+                    requiredPlugins.push( requires[ i ] );
+                }
+              }
+            }
+
+            if ( requiredPlugins.length )
+              loadPlugins.call( this, requiredPlugins );
+            else
+            {
+              // Call the "onLoad" function for all plugins.
+              for ( pluginName in allPlugins )
+              {
+                plugin = allPlugins[ pluginName ];
+                if ( plugin.onLoad && !plugin.onLoad._called )
+                {
+                  plugin.onLoad();
+                  plugin.onLoad._called = 1;
+                }
+              }
+
+              // Call the callback.
+              if ( callback )
+                callback.call( scope || window, allPlugins );
+            }
+          }
+          , this);
+
+      };
+
+      loadPlugins.call( this, name );
+    };
+  });
+
+/**
+ * Loads a specific language file, or auto detect it. A callback is
+ * then called when the file gets loaded.
+ * @param {String} pluginName The name of the plugin to which the provided translation
+ *     should be attached.
+ * @param {String} languageCode The code of the language translation provided.
+ * @param {Object} languageEntries An object that contains pairs of label and
+ *    the respective translation.
+ * @example
+ * CKEDITOR.plugins.setLang( 'myPlugin', 'en', {
+ *   title : 'My plugin',
+ *   selectOption : 'Please select an option'
+ * } );
+ */
+CKEDITOR.plugins.setLang = function( pluginName, languageCode, languageEntries )
+{
+  var plugin = this.get( pluginName ),
+    pluginLangEntries = plugin.langEntries || ( plugin.langEntries = {} ),
+    pluginLang = plugin.lang || ( plugin.lang = [] );
+
+  if ( CKEDITOR.tools.indexOf( pluginLang, languageCode ) == -1 )
+    pluginLang.push( languageCode );
+
+  pluginLangEntries[ languageCode ] = languageEntries;
+};

data/app/assets/javascripts/esp-ckeditor/_source/core/resourcemanager.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 Defines the {@link CKEDITOR.resourceManager} class, which is
+ *    the base for resource managers, like plugins and themes.
+ */
+
+ /**
+ * Base class for resource managers, like plugins and themes. This class is not
+ * intended to be used out of the CKEditor core code.
+ * @param {String} basePath The path for the resources folder.
+ * @param {String} fileName The name used for resource files.
+ * @namespace
+ * @example
+ */
+CKEDITOR.resourceManager = function( basePath, fileName )
+{
+  /**
+   * The base directory containing all resources.
+   * @name CKEDITOR.resourceManager.prototype.basePath
+   * @type String
+   * @example
+   */
+  this.basePath = basePath;
+
+  /**
+   * The name used for resource files.
+   * @name CKEDITOR.resourceManager.prototype.fileName
+   * @type String
+   * @example
+   */
+  this.fileName = fileName;
+
+  /**
+   * Contains references to all resources that have already been registered
+   * with {@link #add}.
+   * @name CKEDITOR.resourceManager.prototype.registered
+   * @type Object
+   * @example
+   */
+  this.registered = {};
+
+  /**
+   * Contains references to all resources that have already been loaded
+   * with {@link #load}.
+   * @name CKEDITOR.resourceManager.prototype.loaded
+   * @type Object
+   * @example
+   */
+  this.loaded = {};
+
+  /**
+   * Contains references to all resources that have already been registered
+   * with {@link #addExternal}.
+   * @name CKEDITOR.resourceManager.prototype.externals
+   * @type Object
+   * @example
+   */
+  this.externals = {};
+
+  /**
+   * @private
+   */
+  this._ =
+  {
+    // List of callbacks waiting for plugins to be loaded.
+    waitingList : {}
+  };
+};
+
+CKEDITOR.resourceManager.prototype =
+{
+  /**
+   * Registers a resource.
+   * @param {String} name The resource name.
+   * @param {Object} [definition] The resource definition.
+   * @example
+   * CKEDITOR.plugins.add( 'sample', { ... plugin definition ... } );
+   * @see CKEDITOR.pluginDefinition
+   */
+  add : function( name, definition )
+  {
+    if ( this.registered[ name ] )
+      throw '[CKEDITOR.resourceManager.add] The resource name "' + name + '" is already registered.';
+
+    CKEDITOR.fire( name + CKEDITOR.tools.capitalize( this.fileName ) + 'Ready',
+        this.registered[ name ] = definition || {} );
+  },
+
+  /**
+   * Gets the definition of a specific resource.
+   * @param {String} name The resource name.
+   * @type Object
+   * @example
+   * var definition = <b>CKEDITOR.plugins.get( 'sample' )</b>;
+   */
+  get : function( name )
+  {
+    return this.registered[ name ] || null;
+  },
+
+  /**
+   * Get the folder path for a specific loaded resource.
+   * @param {String} name The resource name.
+   * @type String
+   * @example
+   * alert( <b>CKEDITOR.plugins.getPath( 'sample' )</b> );  // "&lt;editor path&gt;/plugins/sample/"
+   */
+  getPath : function( name )
+  {
+    var external = this.externals[ name ];
+    return CKEDITOR.getUrl( ( external && external.dir ) || this.basePath + name + '/' );
+  },
+
+  /**
+   * Get the file path for a specific loaded resource.
+   * @param {String} name The resource name.
+   * @type String
+   * @example
+   * alert( <b>CKEDITOR.plugins.getFilePath( 'sample' )</b> );  // "&lt;editor path&gt;/plugins/sample/plugin.js"
+   */
+  getFilePath : function( name )
+  {
+    var external = this.externals[ name ];
+    return CKEDITOR.getUrl(
+        this.getPath( name ) +
+        ( ( external && ( typeof external.file == 'string' ) ) ? external.file : this.fileName + '.js' ) );
+  },
+
+  /**
+   * Registers one or more resources to be loaded from an external path
+   * instead of the core base path.
+   * @param {String} names The resource names, separated by commas.
+   * @param {String} path The path of the folder containing the resource.
+   * @param {String} [fileName] The resource file name. If not provided, the
+   *    default name is used; If provided with a empty string, will implicitly indicates that {@param path}
+   *     is already the full path.
+   * @example
+   * // Loads a plugin from '/myplugin/samples/plugin.js'.
+   * CKEDITOR.plugins.addExternal( 'sample', '/myplugins/sample/' );
+   * @example
+   * // Loads a plugin from '/myplugin/samples/my_plugin.js'.
+   * CKEDITOR.plugins.addExternal( 'sample', '/myplugins/sample/', 'my_plugin.js' );
+   * @example
+   * // Loads a plugin from '/myplugin/samples/my_plugin.js'.
+   * CKEDITOR.plugins.addExternal( 'sample', '/myplugins/sample/my_plugin.js', '' );
+   */
+  addExternal : function( names, path, fileName )
+  {
+    names = names.split( ',' );
+    for ( var i = 0 ; i < names.length ; i++ )
+    {
+      var name = names[ i ];
+
+      this.externals[ name ] =
+      {
+        dir : path,
+        file : fileName
+      };
+    }
+  },
+
+  /**
+   * Loads one or more resources.
+   * @param {String|Array} name The name of the resource to load. It may be a
+   *    string with a single resource name, or an array with several names.
+   * @param {Function} callback A function to be called when all resources
+   *    are loaded. The callback will receive an array containing all
+   *    loaded names.
+   * @param {Object} [scope] The scope object to be used for the callback
+   *    call.
+   * @example
+   * <b>CKEDITOR.plugins.load</b>( 'myplugin', function( plugins )
+   *     {
+   *         alert( plugins['myplugin'] );  // "object"
+   *     });
+   */
+  load : function( names, callback, scope )
+  {
+    // Ensure that we have an array of names.
+    if ( !CKEDITOR.tools.isArray( names ) )
+      names = names ? [ names ] : [];
+
+    var loaded = this.loaded,
+      registered = this.registered,
+      urls = [],
+      urlsNames = {},
+      resources = {};
+
+    // Loop through all names.
+    for ( var i = 0 ; i < names.length ; i++ )
+    {
+      var name = names[ i ];
+
+      if ( !name )
+        continue;
+
+      // If not available yet.
+      if ( !loaded[ name ] && !registered[ name ] )
+      {
+        var url = this.getFilePath( name );
+        urls.push( url );
+        if ( !( url in urlsNames ) )
+          urlsNames[ url ] = [];
+        urlsNames[ url ].push( name );
+      }
+      else
+        resources[ name ] = this.get( name );
+    }
+
+    CKEDITOR.scriptLoader.load( urls, function( completed, failed )
+      {
+        if ( failed.length )
+        {
+          throw '[CKEDITOR.resourceManager.load] Resource name "' + urlsNames[ failed[ 0 ] ].join( ',' )
+            + '" was not found at "' + failed[ 0 ] + '".';
+        }
+
+        for ( var i = 0 ; i < completed.length ; i++ )
+        {
+          var nameList = urlsNames[ completed[ i ] ];
+          for ( var j = 0 ; j < nameList.length ; j++ )
+          {
+            var name = nameList[ j ];
+            resources[ name ] = this.get( name );
+
+            loaded[ name ] = 1;
+          }
+        }
+
+        callback.call( scope, resources );
+      }
+      , this);
+  }
+};

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

@@ -0,0 +1,180 @@
+/*
+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.scriptLoader} object, used to load scripts
+ *    asynchronously.
+ */
+
+/**
+ * Load scripts asynchronously.
+ * @namespace
+ * @example
+ */
+CKEDITOR.scriptLoader = (function()
+{
+  var uniqueScripts = {},
+    waitingList = {};
+
+  return /** @lends CKEDITOR.scriptLoader */ {
+    /**
+     * Loads one or more external script checking if not already loaded
+     * previously by this function.
+     * @param {String|Array} scriptUrl One or more URLs pointing to the
+     *    scripts to be loaded.
+     * @param {Function} [callback] A function to be called when the script
+     *    is loaded and executed. If a string is passed to "scriptUrl", a
+     *    boolean parameter is passed to the callback, indicating the
+     *    success of the load. If an array is passed instead, two array
+     *    parameters are passed to the callback; the first contains the
+     *    URLs that have been properly loaded, and the second the failed
+     *    ones.
+     * @param {Object} [scope] The scope ("this" reference) to be used for
+     *    the callback call. Default to {@link CKEDITOR}.
+     * @param {Boolean} [showBusy] Changes the cursor of the document while
++     *    the script is loaded.
+     * @example
+     * CKEDITOR.scriptLoader.load( '/myscript.js' );
+     * @example
+     * CKEDITOR.scriptLoader.load( '/myscript.js', function( success )
+     *     {
+     *         // Alerts "true" if the script has been properly loaded.
+     *         // HTTP error 404 should return "false".
+     *         alert( success );
+     *     });
+     * @example
+     * CKEDITOR.scriptLoader.load( [ '/myscript1.js', '/myscript2.js' ], function( completed, failed )
+     *     {
+     *         alert( 'Number of scripts loaded: ' + completed.length );
+     *         alert( 'Number of failures: ' + failed.length );
+     *     });
+     */
+    load : function( scriptUrl, callback, scope, showBusy )
+    {
+      var isString = ( typeof scriptUrl == 'string' );
+
+      if ( isString )
+        scriptUrl = [ scriptUrl ];
+
+      if ( !scope )
+        scope = CKEDITOR;
+
+      var scriptCount = scriptUrl.length,
+        completed = [],
+        failed = [];
+
+      var doCallback = function( success )
+      {
+        if ( callback )
+        {
+          if ( isString )
+            callback.call( scope, success );
+          else
+            callback.call( scope, completed, failed );
+        }
+      };
+
+      if ( scriptCount === 0 )
+      {
+        doCallback( true );
+        return;
+      }
+
+      var checkLoaded = function( url, success )
+      {
+        ( success ? completed : failed ).push( url );
+
+        if ( --scriptCount <= 0 )
+        {
+          showBusy && CKEDITOR.document.getDocumentElement().removeStyle( 'cursor' );
+          doCallback( success );
+        }
+      };
+
+      var onLoad = function( url, success )
+      {
+        // Mark this script as loaded.
+        uniqueScripts[ url ] = 1;
+
+        // Get the list of callback checks waiting for this file.
+        var waitingInfo = waitingList[ url ];
+        delete waitingList[ url ];
+
+        // Check all callbacks waiting for this file.
+        for ( var i = 0 ; i < waitingInfo.length ; i++ )
+          waitingInfo[ i ]( url, success );
+      };
+
+      var loadScript = function( url )
+      {
+        if ( uniqueScripts[ url ] )
+        {
+          checkLoaded( url, true );
+          return;
+        }
+
+        var waitingInfo = waitingList[ url ] || ( waitingList[ url ] = [] );
+        waitingInfo.push( checkLoaded );
+
+        // Load it only for the first request.
+        if ( waitingInfo.length > 1 )
+          return;
+
+        // Create the <script> element.
+        var script = new CKEDITOR.dom.element( 'script' );
+        script.setAttributes( {
+          type : 'text/javascript',
+          src : url } );
+
+        if ( callback )
+        {
+          if ( CKEDITOR.env.ie )
+          {
+            // FIXME: For IE, we are not able to return false on error (like 404).
+
+            /** @ignore */
+            script.$.onreadystatechange = function ()
+            {
+              if ( script.$.readyState == 'loaded' || script.$.readyState == 'complete' )
+              {
+                script.$.onreadystatechange = null;
+                onLoad( url, true );
+              }
+            };
+          }
+          else
+          {
+            /** @ignore */
+            script.$.onload = function()
+            {
+              // Some browsers, such as Safari, may call the onLoad function
+              // immediately. Which will break the loading sequence. (#3661)
+              setTimeout( function() { onLoad( url, true ); }, 0 );
+            };
+
+            // FIXME: Opera and Safari will not fire onerror.
+
+            /** @ignore */
+            script.$.onerror = function()
+            {
+              onLoad( url, false );
+            };
+          }
+        }
+
+        // Append it to <head>.
+        script.appendTo( CKEDITOR.document.getHead() );
+
+        CKEDITOR.fire( 'download', url );    // @Packager.RemoveLine
+      };
+
+      showBusy && CKEDITOR.document.getDocumentElement().setStyle( 'cursor', 'wait' );
+      for ( var i = 0 ; i < scriptCount ; i++ )
+      {
+        loadScript( scriptUrl[ i ] );
+      }
+    }
+  };
+})();