inline_forms 0.9.25 → 1.0.0

data/public/javascripts/ckeditor/_source/core/ckeditor_basic.js

@@ -1,238 +0,0 @@
-/*
-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/public/javascripts/ckeditor/_source/core/command.js

@@ -1,209 +0,0 @@
-/*
-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/public/javascripts/ckeditor/_source/core/commanddefinition.js

@@ -1,129 +0,0 @@
-/*
-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.
- * });
- */