ckeditor-rails 0.0.1

data/vendor/assets/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/vendor/assets/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/vendor/assets/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/vendor/assets/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 ] );
+			}
+		}
+	};
+})();