ckeditor 3.6.1 → 3.6.2

data/test/tmp/public/javascripts/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/test/tmp/public/javascripts/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/test/tmp/public/javascripts/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.
+ * });
+ */