ckeditor 3.2.4 → 3.3.2

data/generators/ckeditor_install/templates/ckeditor/_source/core/dom/walker.js

@@ -0,0 +1,445 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+	// This function is to be called under a "walker" instance scope.
+	function iterate( rtl, breakOnFalse )
+	{
+		// Return null if we have reached the end.
+		if ( this._.end )
+			return null;
+
+		var node,
+			range = this.range,
+			guard,
+			userGuard = this.guard,
+			type = this.type,
+			getSourceNodeFn = ( rtl ? 'getPreviousSourceNode' : 'getNextSourceNode' );
+
+		// This is the first call. Initialize it.
+		if ( !this._.start )
+		{
+			this._.start = 1;
+
+			// Trim text nodes and optmize the range boundaries. DOM changes
+			// may happen at this point.
+			range.trim();
+
+			// A collapsed range must return null at first call.
+			if ( range.collapsed )
+			{
+				this.end();
+				return null;
+			}
+		}
+
+		// Create the LTR guard function, if necessary.
+		if ( !rtl && !this._.guardLTR )
+		{
+			// Gets the node that stops the walker when going LTR.
+			var limitLTR = range.endContainer,
+				blockerLTR = limitLTR.getChild( range.endOffset );
+
+			this._.guardLTR = function( node, movingOut )
+			{
+				return ( ( !movingOut || !limitLTR.equals( node ) )
+					&& ( !blockerLTR || !node.equals( blockerLTR ) )
+					&& ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || node.getName() != 'body' ) );
+			};
+		}
+
+		// Create the RTL guard function, if necessary.
+		if ( rtl && !this._.guardRTL )
+		{
+			// Gets the node that stops the walker when going LTR.
+			var limitRTL = range.startContainer,
+				blockerRTL = ( range.startOffset > 0 ) && limitRTL.getChild( range.startOffset - 1 );
+
+			this._.guardRTL = function( node, movingOut )
+			{
+				return ( ( !movingOut || !limitRTL.equals( node ) )
+					&& ( !blockerRTL || !node.equals( blockerRTL ) )
+					&& ( node.type != CKEDITOR.NODE_ELEMENT || !movingOut || node.getName() != 'body' ) );
+			};
+		}
+
+		// Define which guard function to use.
+		var stopGuard = rtl ? this._.guardRTL : this._.guardLTR;
+
+		// Make the user defined guard function participate in the process,
+		// otherwise simply use the boundary guard.
+		if ( userGuard )
+		{
+			guard = function( node, movingOut )
+			{
+				if ( stopGuard( node, movingOut ) === false )
+					return false;
+
+				return userGuard( node, movingOut );
+			};
+		}
+		else
+			guard = stopGuard;
+
+		if ( this.current )
+			node = this.current[ getSourceNodeFn ]( false, type, guard );
+		else
+		{
+			// Get the first node to be returned.
+
+			if ( rtl )
+			{
+				node = range.endContainer;
+
+				if ( range.endOffset > 0 )
+				{
+					node = node.getChild( range.endOffset - 1 );
+					if ( guard( node ) === false )
+						node = null;
+				}
+				else
+					node = ( guard ( node, true ) === false ) ?
+						null : node.getPreviousSourceNode( true, type, guard );
+			}
+			else
+			{
+				node = range.startContainer;
+				node = node.getChild( range.startOffset );
+
+				if ( node )
+				{
+					if ( guard( node ) === false )
+						node = null;
+				}
+				else
+					node = ( guard ( range.startContainer, true ) === false ) ?
+						null : range.startContainer.getNextSourceNode( true, type, guard ) ;
+			}
+		}
+
+		while ( node && !this._.end )
+		{
+			this.current = node;
+
+			if ( !this.evaluator || this.evaluator( node ) !== false )
+			{
+				if ( !breakOnFalse )
+					return node;
+			}
+			else if ( breakOnFalse && this.evaluator )
+				return false;
+
+			node = node[ getSourceNodeFn ]( false, type, guard );
+		}
+
+		this.end();
+		return this.current = null;
+	}
+
+	function iterateToLast( rtl )
+	{
+		var node, last = null;
+
+		while ( ( node = iterate.call( this, rtl ) ) )
+			last = node;
+
+		return last;
+	}
+
+	CKEDITOR.dom.walker = CKEDITOR.tools.createClass(
+	{
+		/**
+		 * Utility class to "walk" the DOM inside a range boundaries. If
+		 * necessary, partially included nodes (text nodes) are broken to
+		 * reflect the boundaries limits, so DOM and range changes may happen.
+		 * Outside changes to the range may break the walker.
+		 *
+		 * The walker may return nodes that are not totaly included into the
+		 * range boundaires. Let's take the following range representation,
+		 * where the square brackets indicate the boundaries:
+		 *
+		 * [<p>Some <b>sample] text</b>
+		 *
+		 * While walking forward into the above range, the following nodes are
+		 * returned: <p>, "Some ", <b> and "sample". Going
+		 * backwards instead we have: "sample" and "Some ". So note that the
+		 * walker always returns nodes when "entering" them, but not when
+		 * "leaving" them. The guard function is instead called both when
+		 * entering and leaving nodes.
+		 *
+		 * @constructor
+		 * @param {CKEDITOR.dom.range} range The range within which walk.
+		 */
+		$ : function( range )
+		{
+			this.range = range;
+
+			/**
+			 * A function executed for every matched node, to check whether
+			 * it's to be considered into the walk or not. If not provided, all
+			 * matched nodes are considered good.
+			 * If the function returns "false" the node is ignored.
+			 * @name CKEDITOR.dom.walker.prototype.evaluator
+			 * @property
+			 * @type Function
+			 */
+			// this.evaluator = null;
+
+			/**
+			 * A function executed for every node the walk pass by to check
+			 * whether the walk is to be finished. It's called when both
+			 * entering and exiting nodes, as well as for the matched nodes.
+			 * If this function returns "false", the walking ends and no more
+			 * nodes are evaluated.
+			 * @name CKEDITOR.dom.walker.prototype.guard
+			 * @property
+			 * @type Function
+			 */
+			// this.guard = null;
+
+			/** @private */
+			this._ = {};
+		},
+
+//		statics :
+//		{
+//			/* Creates a CKEDITOR.dom.walker instance to walk inside DOM boundaries set by nodes.
+//			 * @param {CKEDITOR.dom.node} startNode The node from wich the walk
+//			 *		will start.
+//			 * @param {CKEDITOR.dom.node} [endNode] The last node to be considered
+//			 *		in the walk. No more nodes are retrieved after touching or
+//			 *		passing it. If not provided, the walker stops at the
+//			 *		<body> closing boundary.
+//			 * @returns {CKEDITOR.dom.walker} A DOM walker for the nodes between the
+//			 *		provided nodes.
+//			 */
+//			createOnNodes : function( startNode, endNode, startInclusive, endInclusive )
+//			{
+//				var range = new CKEDITOR.dom.range();
+//				if ( startNode )
+//					range.setStartAt( startNode, startInclusive ? CKEDITOR.POSITION_BEFORE_START : CKEDITOR.POSITION_AFTER_END ) ;
+//				else
+//					range.setStartAt( startNode.getDocument().getBody(), CKEDITOR.POSITION_AFTER_START ) ;
+//
+//				if ( endNode )
+//					range.setEndAt( endNode, endInclusive ? CKEDITOR.POSITION_AFTER_END : CKEDITOR.POSITION_BEFORE_START ) ;
+//				else
+//					range.setEndAt( startNode.getDocument().getBody(), CKEDITOR.POSITION_BEFORE_END ) ;
+//
+//				return new CKEDITOR.dom.walker( range );
+//			}
+//		},
+//
+		proto :
+		{
+			/**
+			 * Stop walking. No more nodes are retrieved if this function gets
+			 * called.
+			 */
+			end : function()
+			{
+				this._.end = 1;
+			},
+
+			/**
+			 * Retrieves the next node (at right).
+			 * @returns {CKEDITOR.dom.node} The next node or null if no more
+			 *		nodes are available.
+			 */
+			next : function()
+			{
+				return iterate.call( this );
+			},
+
+			/**
+			 * Retrieves the previous node (at left).
+			 * @returns {CKEDITOR.dom.node} The previous node or null if no more
+			 *		nodes are available.
+			 */
+			previous : function()
+			{
+				return iterate.call( this, true );
+			},
+
+			/**
+			 * Check all nodes at right, executing the evaluation fuction.
+			 * @returns {Boolean} "false" if the evaluator function returned
+			 *		"false" for any of the matched nodes. Otherwise "true".
+			 */
+			checkForward : function()
+			{
+				return iterate.call( this, false, true ) !== false;
+			},
+
+			/**
+			 * Check all nodes at left, executing the evaluation fuction.
+			 * @returns {Boolean} "false" if the evaluator function returned
+			 *		"false" for any of the matched nodes. Otherwise "true".
+			 */
+			checkBackward : function()
+			{
+				return iterate.call( this, true, true ) !== false;
+			},
+
+			/**
+			 * Executes a full walk forward (to the right), until no more nodes
+			 * are available, returning the last valid node.
+			 * @returns {CKEDITOR.dom.node} The last node at the right or null
+			 *		if no valid nodes are available.
+			 */
+			lastForward : function()
+			{
+				return iterateToLast.call( this );
+			},
+
+			/**
+			 * Executes a full walk backwards (to the left), until no more nodes
+			 * are available, returning the last valid node.
+			 * @returns {CKEDITOR.dom.node} The last node at the left or null
+			 *		if no valid nodes are available.
+			 */
+			lastBackward : function()
+			{
+				return iterateToLast.call( this, true );
+			},
+
+			reset : function()
+			{
+				delete this.current;
+				this._ = {};
+			}
+
+		}
+	});
+
+	/*
+	 * Anything whose display computed style is block, list-item, table,
+	 * table-row-group, table-header-group, table-footer-group, table-row,
+	 * table-column-group, table-column, table-cell, table-caption, or whose node
+	 * name is hr, br (when enterMode is br only) is a block boundary.
+	 */
+	var blockBoundaryDisplayMatch =
+	{
+		block : 1,
+		'list-item' : 1,
+		table : 1,
+		'table-row-group' : 1,
+		'table-header-group' : 1,
+		'table-footer-group' : 1,
+		'table-row' : 1,
+		'table-column-group' : 1,
+		'table-column' : 1,
+		'table-cell' : 1,
+		'table-caption' : 1
+	},
+	blockBoundaryNodeNameMatch = { hr : 1 };
+
+	CKEDITOR.dom.element.prototype.isBlockBoundary = function( customNodeNames )
+	{
+		var nodeNameMatches = CKEDITOR.tools.extend( {},
+													blockBoundaryNodeNameMatch, customNodeNames || {} );
+
+		return blockBoundaryDisplayMatch[ this.getComputedStyle( 'display' ) ] ||
+			nodeNameMatches[ this.getName() ];
+	};
+
+	CKEDITOR.dom.walker.blockBoundary = function( customNodeNames )
+	{
+		return function( node , type )
+		{
+			return ! ( node.type == CKEDITOR.NODE_ELEMENT
+						&& node.isBlockBoundary( customNodeNames ) );
+		};
+	};
+
+	CKEDITOR.dom.walker.listItemBoundary = function()
+	{
+			return this.blockBoundary( { br : 1 } );
+	};
+
+	/**
+	 * Whether the to-be-evaluated node is a bookmark node OR bookmark node
+	 * inner contents.
+	 * @param {Boolean} contentOnly Whether only test againt the text content of
+	 * bookmark node instead of the element itself(default).
+	 * @param {Boolean} isReject Whether should return 'false' for the bookmark
+	 * node instead of 'true'(default).
+	 */
+	CKEDITOR.dom.walker.bookmark = function( contentOnly, isReject )
+	{
+		function isBookmarkNode( node )
+		{
+			return ( node && node.getName
+					&& node.getName() == 'span'
+					&& node.hasAttribute('_fck_bookmark') );
+		}
+
+		return function( node )
+		{
+			var isBookmark, parent;
+			// Is bookmark inner text node?
+			isBookmark = ( node && !node.getName && ( parent = node.getParent() )
+						&& isBookmarkNode( parent ) );
+			// Is bookmark node?
+			isBookmark = contentOnly ? isBookmark : isBookmark || isBookmarkNode( node );
+			return isReject ^ isBookmark;
+		};
+	};
+
+	/**
+	 * Whether the node is a text node containing only whitespaces characters.
+	 * @param isReject
+	 */
+	CKEDITOR.dom.walker.whitespaces = function( isReject )
+	{
+		return function( node )
+		{
+			var isWhitespace = node && ( node.type == CKEDITOR.NODE_TEXT )
+							&& !CKEDITOR.tools.trim( node.getText() );
+			return isReject ^ isWhitespace;
+		};
+	};
+
+	/**
+	 * Whether the node is invisible in wysiwyg mode.
+	 * @param isReject
+	 */
+	CKEDITOR.dom.walker.invisible = function( isReject )
+	{
+		var whitespace = CKEDITOR.dom.walker.whitespaces();
+		return function( node )
+		{
+			// Nodes that take no spaces in wysiwyg:
+			// 1. White-spaces but not including NBSP;
+			// 2. Empty inline elements, e.g. <b></b> we're checking here
+			// 'offsetHeight' instead of 'offsetWidth' for properly excluding
+			// all sorts of empty paragraph, e.g. <br />.
+			var isInvisible = whitespace( node ) || node.is && !node.$.offsetHeight;
+			return isReject ^ isInvisible;
+		};
+	};
+
+	var tailNbspRegex = /^[\t\r\n ]*(?:&nbsp;|\xa0)$/,
+		isNotWhitespaces = CKEDITOR.dom.walker.whitespaces( true ),
+		isNotBookmark = CKEDITOR.dom.walker.bookmark( false, true ),
+		fillerEvaluator = function( element )
+		{
+			return isNotBookmark( element ) && isNotWhitespaces( element );
+		};
+
+	// Check if there's a filler node at the end of an element, and return it.
+	CKEDITOR.dom.element.prototype.getBogus = function ()
+	{
+		var tail = this.getLast( fillerEvaluator );
+		if ( tail && ( !CKEDITOR.env.ie ? tail.is && tail.is( 'br' )
+				: tail.getText && tailNbspRegex.test( tail.getText() ) ) )
+		{
+			return tail;
+		}
+		return false;
+	};
+
+})();

data/generators/ckeditor_install/templates/ckeditor/_source/core/editor.js

@@ -0,0 +1,759 @@
+/*
+Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * @fileOverview Defines the {@link CKEDITOR.editor} class, which represents an
+ *		editor instance.
+ */
+
+(function()
+{
+	// The counter for automatic instance names.
+	var nameCounter = 0;
+
+	var getNewName = function()
+	{
+		var name = 'editor' + ( ++nameCounter );
+		return ( CKEDITOR.instances && CKEDITOR.instances[ name ] ) ? getNewName() : name;
+	};
+
+	// ##### START: Config Privates
+
+	// These function loads custom configuration files and cache the
+	// CKEDITOR.editorConfig functions defined on them, so there is no need to
+	// download them more than once for several instances.
+	var loadConfigLoaded = {};
+	var loadConfig = function( editor )
+	{
+		var customConfig = editor.config.customConfig;
+
+		// Check if there is a custom config to load.
+		if ( !customConfig )
+			return false;
+
+		customConfig = CKEDITOR.getUrl( customConfig );
+
+		var loadedConfig = loadConfigLoaded[ customConfig ] || ( loadConfigLoaded[ customConfig ] = {} );
+
+		// If the custom config has already been downloaded, reuse it.
+		if ( loadedConfig.fn )
+		{
+			// Call the cached CKEDITOR.editorConfig defined in the custom
+			// config file for the editor instance depending on it.
+			loadedConfig.fn.call( editor, editor.config );
+
+			// If there is no other customConfig in the chain, fire the
+			// "configLoaded" event.
+			if ( CKEDITOR.getUrl( editor.config.customConfig ) == customConfig || !loadConfig( editor ) )
+				editor.fireOnce( 'customConfigLoaded' );
+		}
+		else
+		{
+			// Load the custom configuration file.
+			CKEDITOR.scriptLoader.load( customConfig, function()
+				{
+					// If the CKEDITOR.editorConfig function has been properly
+					// defined in the custom configuration file, cache it.
+					if ( CKEDITOR.editorConfig )
+						loadedConfig.fn = CKEDITOR.editorConfig;
+					else
+						loadedConfig.fn = function(){};
+
+					// Call the load config again. This time the custom
+					// config is already cached and so it will get loaded.
+					loadConfig( editor );
+				});
+		}
+
+		return true;
+	};
+
+	var initConfig = function( editor, instanceConfig )
+	{
+		// Setup the lister for the "customConfigLoaded" event.
+		editor.on( 'customConfigLoaded', function()
+			{
+				if ( instanceConfig )
+				{
+					// Register the events that may have been set at the instance
+					// configuration object.
+					if ( instanceConfig.on )
+					{
+						for ( var eventName in instanceConfig.on )
+						{
+							editor.on( eventName, instanceConfig.on[ eventName ] );
+						}
+					}
+
+					// Overwrite the settings from the in-page config.
+					CKEDITOR.tools.extend( editor.config, instanceConfig, true );
+
+					delete editor.config.on;
+				}
+
+				onConfigLoaded( editor );
+			});
+
+		// The instance config may override the customConfig setting to avoid
+		// loading the default ~/config.js file.
+		if ( instanceConfig && instanceConfig.customConfig != undefined )
+			editor.config.customConfig = instanceConfig.customConfig;
+
+		// Load configs from the custom configuration files.
+		if ( !loadConfig( editor ) )
+			editor.fireOnce( 'customConfigLoaded' );
+	};
+
+	// ##### END: Config Privates
+
+	var onConfigLoaded = function( editor )
+	{
+		// Set config related properties.
+
+		var skin = editor.config.skin.split( ',' ),
+			skinName = skin[ 0 ],
+			skinPath = CKEDITOR.getUrl( skin[ 1 ] || (
+				'_source/' +	// @Packager.RemoveLine
+				'skins/' + skinName + '/' ) );
+
+		editor.skinName = skinName;
+		editor.skinPath = skinPath;
+		editor.skinClass = 'cke_skin_' + skinName;
+
+		editor.tabIndex = editor.config.tabIndex || editor.element.getAttribute( 'tabindex' ) || 0;
+
+		// Fire the "configLoaded" event.
+		editor.fireOnce( 'configLoaded' );
+
+		// Load language file.
+		loadSkin( editor );
+	};
+
+	var loadLang = function( editor )
+	{
+		CKEDITOR.lang.load( editor.config.language, editor.config.defaultLanguage, function( languageCode, lang )
+			{
+				editor.langCode = languageCode;
+
+				// As we'll be adding plugin specific entries that could come
+				// from different language code files, we need a copy of lang,
+				// not a direct reference to it.
+				editor.lang = CKEDITOR.tools.prototypedCopy( lang );
+
+				// We're not able to support RTL in Firefox 2 at this time.
+				if ( CKEDITOR.env.gecko && CKEDITOR.env.version < 10900 && editor.lang.dir == 'rtl' )
+					editor.lang.dir = 'ltr';
+
+				var config = editor.config;
+				config.contentsLangDirection == 'ui' && ( config.contentsLangDirection = editor.lang.dir );
+
+				loadPlugins( editor );
+			});
+	};
+
+	var loadPlugins = function( editor )
+	{
+		var config			= editor.config,
+			plugins			= config.plugins,
+			extraPlugins	= config.extraPlugins,
+			removePlugins	= config.removePlugins;
+
+		if ( extraPlugins )
+		{
+			// Remove them first to avoid duplications.
+			var removeRegex = new RegExp( '(?:^|,)(?:' + extraPlugins.replace( /\s*,\s*/g, '|' ) + ')(?=,|$)' , 'g' );
+			plugins = plugins.replace( removeRegex, '' );
+
+			plugins += ',' + extraPlugins;
+		}
+
+		if ( removePlugins )
+		{
+			removeRegex = new RegExp( '(?:^|,)(?:' + removePlugins.replace( /\s*,\s*/g, '|' ) + ')(?=,|$)' , 'g' );
+			plugins = plugins.replace( removeRegex, '' );
+		}
+
+		// Load all plugins defined in the "plugins" setting.
+		CKEDITOR.plugins.load( plugins.split( ',' ), function( plugins )
+			{
+				// The list of plugins.
+				var pluginsArray = [];
+
+				// The language code to get loaded for each plugin. Null
+				// entries will be appended for plugins with no language files.
+				var languageCodes = [];
+
+				// The list of URLs to language files.
+				var languageFiles = [];
+
+				// Cache the loaded plugin names.
+				editor.plugins = plugins;
+
+				// Loop through all plugins, to build the list of language
+				// files to get loaded.
+				for ( var pluginName in plugins )
+				{
+					var plugin = plugins[ pluginName ],
+						pluginLangs = plugin.lang,
+						pluginPath = CKEDITOR.plugins.getPath( pluginName ),
+						lang = null;
+
+					// Set the plugin path in the plugin.
+					plugin.path = pluginPath;
+
+					// If the plugin has "lang".
+					if ( pluginLangs )
+					{
+						// Resolve the plugin language. If the current language
+						// is not available, get the first one (default one).
+						lang = ( CKEDITOR.tools.indexOf( pluginLangs, editor.langCode ) >= 0 ? editor.langCode : pluginLangs[ 0 ] );
+
+						if ( !plugin.lang[ lang ] )
+						{
+							// Put the language file URL into the list of files to
+							// get downloaded.
+							languageFiles.push( CKEDITOR.getUrl( pluginPath + 'lang/' + lang + '.js' ) );
+						}
+						else
+						{
+							CKEDITOR.tools.extend( editor.lang, plugin.lang[ lang ] );
+							lang = null;
+						}
+					}
+
+					// Save the language code, so we know later which
+					// language has been resolved to this plugin.
+					languageCodes.push( lang );
+
+					pluginsArray.push( plugin );
+				}
+
+				// Load all plugin specific language files in a row.
+				CKEDITOR.scriptLoader.load( languageFiles, function()
+					{
+						// Initialize all plugins that have the "beforeInit" and "init" methods defined.
+						var methods = [ 'beforeInit', 'init', 'afterInit' ];
+						for ( var m = 0 ; m < methods.length ; m++ )
+						{
+							for ( var i = 0 ; i < pluginsArray.length ; i++ )
+							{
+								var plugin = pluginsArray[ i ];
+
+								// Uses the first loop to update the language entries also.
+								if ( m === 0 && languageCodes[ i ] && plugin.lang )
+									CKEDITOR.tools.extend( editor.lang, plugin.lang[ languageCodes[ i ] ] );
+
+								// Call the plugin method (beforeInit and init).
+								if ( plugin[ methods[ m ] ] )
+									plugin[ methods[ m ] ]( editor );
+							}
+						}
+
+						// Load the editor skin.
+						editor.fire( 'pluginsLoaded' );
+						loadTheme( editor );
+					});
+			});
+	};
+
+	var loadSkin = function( editor )
+	{
+		CKEDITOR.skins.load( editor, 'editor', function()
+			{
+				loadLang( editor );
+			});
+	};
+
+	var loadTheme = function( editor )
+	{
+		var theme = editor.config.theme;
+		CKEDITOR.themes.load( theme, function()
+			{
+				var editorTheme = editor.theme = CKEDITOR.themes.get( theme );
+				editorTheme.path = CKEDITOR.themes.getPath( theme );
+				editorTheme.build( editor );
+
+				if ( editor.config.autoUpdateElement )
+					attachToForm( editor );
+			});
+	};
+
+	var attachToForm = function( editor )
+	{
+		var element = editor.element;
+
+		// If are replacing a textarea, we must
+		if ( editor.elementMode == CKEDITOR.ELEMENT_MODE_REPLACE && element.is( 'textarea' ) )
+		{
+			var form = element.$.form && new CKEDITOR.dom.element( element.$.form );
+			if ( form )
+			{
+				function onSubmit()
+				{
+					editor.updateElement();
+				}
+				form.on( 'submit',onSubmit );
+
+				// Setup the submit function because it doesn't fire the
+				// "submit" event.
+				if ( !form.$.submit.nodeName )
+				{
+					form.$.submit = CKEDITOR.tools.override( form.$.submit, function( originalSubmit )
+						{
+							return function()
+								{
+									editor.updateElement();
+
+									// For IE, the DOM submit function is not a
+									// function, so we need thid check.
+									if ( originalSubmit.apply )
+										originalSubmit.apply( this, arguments );
+									else
+										originalSubmit();
+								};
+						});
+				}
+
+				// Remove 'submit' events registered on form element before destroying.(#3988)
+				editor.on( 'destroy', function()
+				{
+					form.removeListener( 'submit', onSubmit );
+				} );
+			}
+		}
+	};
+
+	function updateCommandsMode()
+	{
+		var command,
+			commands = this._.commands,
+			mode = this.mode;
+
+		for ( var name in commands )
+		{
+			command = commands[ name ];
+			command[ command.startDisabled ? 'disable' : command.modes[ mode ] ? 'enable' : 'disable' ]();
+		}
+	}
+
+	/**
+	 * Initializes the editor instance. This function is called by the editor
+	 * contructor (editor_basic.js).
+	 * @private
+	 */
+	CKEDITOR.editor.prototype._init = function()
+		{
+			// Get the properties that have been saved in the editor_base
+			// implementation.
+			var element			= CKEDITOR.dom.element.get( this._.element ),
+				instanceConfig	= this._.instanceConfig;
+			delete this._.element;
+			delete this._.instanceConfig;
+
+			this._.commands = {};
+			this._.styles = [];
+
+			/**
+			 * The DOM element that has been replaced by this editor instance. This
+			 * element holds the editor data on load and post.
+			 * @name CKEDITOR.editor.prototype.element
+			 * @type CKEDITOR.dom.element
+			 * @example
+			 * var editor = CKEDITOR.instances.editor1;
+			 * alert( <b>editor.element</b>.getName() );  "textarea"
+			 */
+			this.element = element;
+
+			/**
+			 * The editor instance name. It hay be the replaced element id, name or
+			 * a default name using a progressive counter (editor1, editor2, ...).
+			 * @name CKEDITOR.editor.prototype.name
+			 * @type String
+			 * @example
+			 * var editor = CKEDITOR.instances.editor1;
+			 * alert( <b>editor.name</b> );  "editor1"
+			 */
+			this.name = ( element && ( this.elementMode == CKEDITOR.ELEMENT_MODE_REPLACE )
+							&& ( element.getId() || element.getNameAtt() ) )
+						|| getNewName();
+
+			if ( this.name in CKEDITOR.instances )
+				throw '[CKEDITOR.editor] The instance "' + this.name + '" already exists.';
+
+			/**
+			 * The configurations for this editor instance. It inherits all
+			 * settings defined in (@link CKEDITOR.config}, combined with settings
+			 * loaded from custom configuration files and those defined inline in
+			 * the page when creating the editor.
+			 * @name CKEDITOR.editor.prototype.config
+			 * @type Object
+			 * @example
+			 * var editor = CKEDITOR.instances.editor1;
+			 * alert( <b>editor.config.theme</b> );  "default" e.g.
+			 */
+			this.config = CKEDITOR.tools.prototypedCopy( CKEDITOR.config );
+
+			/**
+			 * Namespace containing UI features related to this editor instance.
+			 * @name CKEDITOR.editor.prototype.ui
+			 * @type CKEDITOR.ui
+			 * @example
+			 */
+			this.ui = new CKEDITOR.ui( this );
+
+			/**
+			 * Controls the focus state of this editor instance. This property
+			 * is rarely used for normal API operations. It is mainly
+			 * destinated to developer adding UI elements to the editor interface.
+			 * @name CKEDITOR.editor.prototype.focusManager
+			 * @type CKEDITOR.focusManager
+			 * @example
+			 */
+			this.focusManager = new CKEDITOR.focusManager( this );
+
+			CKEDITOR.fire( 'instanceCreated', null, this );
+
+			this.on( 'mode', updateCommandsMode, null, null, 1 );
+
+			initConfig( this, instanceConfig );
+		};
+})();
+
+CKEDITOR.tools.extend( CKEDITOR.editor.prototype,
+	/** @lends CKEDITOR.editor.prototype */
+	{
+		/**
+		 * Adds a command definition to the editor instance. Commands added with
+		 * this function can be later executed with {@link #execCommand}.
+		 * @param {String} commandName The indentifier name of the command.
+		 * @param {CKEDITOR.commandDefinition} commandDefinition The command definition.
+		 * @example
+		 * editorInstance.addCommand( 'sample',
+		 * {
+		 *     exec : function( editor )
+		 *     {
+		 *         alert( 'Executing a command for the editor name "' + editor.name + '"!' );
+		 *     }
+		 * });
+		 */
+		addCommand : function( commandName, commandDefinition )
+		{
+			return this._.commands[ commandName ] = new CKEDITOR.command( this, commandDefinition );
+		},
+
+		/**
+		 * Add a trunk of css text to the editor which will be applied to the wysiwyg editing document.
+		 * Note: This function should be called before editor is loaded to take effect.
+		 * @param css {String} CSS text.
+		 * @example
+		 * editorInstance.addCss( 'body { background-color: grey; }' );
+		 */
+		addCss : function( css )
+		{
+			this._.styles.push( css );
+		},
+
+		/**
+		 * Destroys the editor instance, releasing all resources used by it.
+		 * If the editor replaced an element, the element will be recovered.
+		 * @param {Boolean} [noUpdate] If the instance is replacing a DOM
+		 *		element, this parameter indicates whether or not to update the
+		 *		element with the instance contents.
+		 * @example
+		 * alert( CKEDITOR.instances.editor1 );  e.g "object"
+		 * <b>CKEDITOR.instances.editor1.destroy()</b>;
+		 * alert( CKEDITOR.instances.editor1 );  "undefined"
+		 */
+		destroy : function( noUpdate )
+		{
+			if ( !noUpdate )
+				this.updateElement();
+
+			if ( this.mode )
+			{
+				// ->		currentMode.unload( holderElement );
+				this._.modes[ this.mode ].unload( this.getThemeSpace( 'contents' ) );
+			}
+
+			this.theme.destroy( this );
+
+			var toolbars,
+				index = 0,
+				j,
+				items,
+				instance;
+
+			if ( this.toolbox )
+			{
+				toolbars = this.toolbox.toolbars;
+				for ( ; index < toolbars.length ; index++ )
+				{
+					items = toolbars[ index ].items;
+					for ( j = 0 ; j < items.length ; j++ )
+					{
+						instance = items[ j ];
+						if ( instance.clickFn ) CKEDITOR.tools.removeFunction( instance.clickFn );
+						if ( instance.keyDownFn ) CKEDITOR.tools.removeFunction( instance.keyDownFn );
+
+						if ( instance.index ) CKEDITOR.ui.button._.instances[ instance.index ] = null;
+					}
+				}
+			}
+
+			if ( this.contextMenu )
+				CKEDITOR.tools.removeFunction( this.contextMenu._.functionId );
+
+			if ( this._.filebrowserFn )
+				CKEDITOR.tools.removeFunction( this._.filebrowserFn );
+
+			this.fire( 'destroy' );
+			CKEDITOR.remove( this );
+			CKEDITOR.fire( 'instanceDestroyed', null, this );
+		},
+
+		/**
+		 * Executes a command.
+		 * @param {String} commandName The indentifier name of the command.
+		 * @param {Object} [data] Data to be passed to the command
+		 * @returns {Boolean} "true" if the command has been successfuly
+		 *		executed, otherwise "false".
+		 * @example
+		 * editorInstance.execCommand( 'Bold' );
+		 */
+		execCommand : function( commandName, data )
+		{
+			var command = this.getCommand( commandName );
+
+			var eventData =
+			{
+				name: commandName,
+				commandData: data,
+				command: command
+			};
+
+			if ( command && command.state != CKEDITOR.TRISTATE_DISABLED )
+			{
+				if ( this.fire( 'beforeCommandExec', eventData ) !== true )
+				{
+					eventData.returnValue = command.exec( eventData.commandData );
+
+					// Fire the 'afterCommandExec' immediately if command is synchronous.
+					if ( !command.async && this.fire( 'afterCommandExec', eventData ) !== true )
+						return eventData.returnValue;
+				}
+			}
+
+			// throw 'Unknown command name "' + commandName + '"';
+			return false;
+		},
+
+		/**
+		 * Gets one of the registered commands. Note that, after registering a
+		 * command definition with addCommand, it is transformed internally
+		 * into an instance of {@link CKEDITOR.command}, which will be then
+		 * returned by this function.
+		 * @param {String} commandName The name of the command to be returned.
+		 * This is the same used to register the command with addCommand.
+		 * @returns {CKEDITOR.command} The command object identified by the
+		 * provided name.
+		 */
+		getCommand : function( commandName )
+		{
+			return this._.commands[ commandName ];
+		},
+
+		/**
+		 * Gets the editor data. The data will be in raw format. It is the same
+		 * data that is posted by the editor.
+		 * @type String
+		 * @returns (String) The editor data.
+		 * @example
+		 * if ( CKEDITOR.instances.editor1.<b>getData()</b> == '' )
+		 *     alert( 'There is no data available' );
+		 */
+		getData : function()
+		{
+			this.fire( 'beforeGetData' );
+
+			var eventData = this._.data;
+
+			if ( typeof eventData != 'string' )
+			{
+				var element = this.element;
+				if ( element && this.elementMode == CKEDITOR.ELEMENT_MODE_REPLACE )
+					eventData = element.is( 'textarea' ) ? element.getValue() : element.getHtml();
+				else
+					eventData = '';
+			}
+
+			eventData = { dataValue : eventData };
+
+			// Fire "getData" so data manipulation may happen.
+			this.fire( 'getData', eventData );
+
+			return eventData.dataValue;
+		},
+
+		getSnapshot : function()
+		{
+			var data = this.fire( 'getSnapshot' );
+
+			if ( typeof data != 'string' )
+			{
+				var element = this.element;
+				if ( element && this.elementMode == CKEDITOR.ELEMENT_MODE_REPLACE )
+					data = element.is( 'textarea' ) ? element.getValue() : element.getHtml();
+			}
+
+			return data;
+		},
+
+		loadSnapshot : function( snapshot )
+		{
+			this.fire( 'loadSnapshot', snapshot );
+		},
+
+		/**
+		 * Sets the editor data. The data must be provided in raw format (HTML).<br />
+		 * <br />
+		 * Note that this menthod is asynchronous. The "callback" parameter must
+		 * be used if interaction with the editor is needed after setting the data.
+		 * @param {String} data HTML code to replace the curent content in the
+		 *		editor.
+		 * @param {Function} callback Function to be called after the setData
+		 *		is completed.
+		 * @example
+		 * CKEDITOR.instances.editor1.<b>setData</b>( '&lt;p&gt;This is the editor data.&lt;/p&gt;' );
+		 * @example
+		 * CKEDITOR.instances.editor1.<b>setData</b>( '&lt;p&gt;Some other editor data.&lt;/p&gt;', function()
+		 *     {
+		 *         this.checkDirty();    // true
+		 *     });
+		 */
+		setData : function( data , callback )
+		{
+			if( callback )
+			{
+				this.on( 'dataReady', function( evt )
+				{
+					evt.removeListener();
+					callback.call( evt.editor );
+				} );
+			}
+
+			// Fire "setData" so data manipulation may happen.
+			var eventData = { dataValue : data };
+			this.fire( 'setData', eventData );
+
+			this._.data = eventData.dataValue;
+
+			this.fire( 'afterSetData', eventData );
+		},
+
+		/**
+		 * Inserts HTML into the currently selected position in the editor.
+		 * @param {String} data HTML code to be inserted into the editor.
+		 * @example
+		 * CKEDITOR.instances.editor1.<b>insertHtml( '&lt;p&gt;This is a new paragraph.&lt;/p&gt;' )</b>;
+		 */
+		insertHtml : function( data )
+		{
+			this.fire( 'insertHtml', data );
+		},
+
+		/**
+		 * Inserts an element into the currently selected position in the
+		 * editor.
+		 * @param {CKEDITOR.dom.element} element The element to be inserted
+		 *		into the editor.
+		 * @example
+		 * var element = CKEDITOR.dom.element.createFromHtml( '&lt;img src="hello.png" border="0" title="Hello" /&gt;' );
+		 * CKEDITOR.instances.editor1.<b>insertElement( element )</b>;
+		 */
+		insertElement : function( element )
+		{
+			this.fire( 'insertElement', element );
+		},
+
+		checkDirty : function()
+		{
+			return ( this.mayBeDirty && this._.previousValue !== this.getSnapshot() );
+		},
+
+		resetDirty : function()
+		{
+			if ( this.mayBeDirty )
+				this._.previousValue = this.getSnapshot();
+		},
+
+		/**
+		 * Updates the &lt;textarea&gt; element that has been replaced by the editor with
+		 * the current data available in the editor.
+		 * @example
+		 * CKEDITOR.instances.editor1.updateElement();
+		 * alert( document.getElementById( 'editor1' ).value );  // The current editor data.
+		 */
+		updateElement : function()
+		{
+			var element = this.element;
+			if ( element && this.elementMode == CKEDITOR.ELEMENT_MODE_REPLACE )
+			{
+				var data = this.getData();
+
+				if ( this.config.htmlEncodeOutput )
+					data = CKEDITOR.tools.htmlEncode( data );
+
+				if ( element.is( 'textarea' ) )
+					element.setValue( data );
+				else
+					element.setHtml( data );
+			}
+		}
+	});
+
+CKEDITOR.on( 'loaded', function()
+	{
+		// Run the full initialization for pending editors.
+		var pending = CKEDITOR.editor._pending;
+		if ( pending )
+		{
+			delete CKEDITOR.editor._pending;
+
+			for ( var i = 0 ; i < pending.length ; i++ )
+				pending[ i ]._init();
+		}
+	});
+
+/**
+ * Whether escape HTML when editor update original input element.
+ * @name CKEDITOR.config.htmlEncodeOutput
+ * @since 3.1
+ * @type Boolean
+ * @default false
+ * @example
+ * config.htmlEncodeOutput = true;
+ */
+
+/**
+ * Fired when a CKEDITOR instance is created, but still before initializing it.
+ * To interact with a fully initialized instance, use the
+ * {@link CKEDITOR#instanceReady} event instead.
+ * @name CKEDITOR#instanceCreated
+ * @event
+ * @param {CKEDITOR.editor} editor The editor instance that has been created.
+ */
+
+/**
+ * Fired when a CKEDITOR instance is destroyed.
+ * @name CKEDITOR#instanceDestroyed
+ * @event
+ * @param {CKEDITOR.editor} editor The editor instance that has been destroyed.
+ */
+
+/**
+ * Fired when all plugins are loaded and initialized into the editor instance.
+ * @name CKEDITOR#pluginsLoaded
+ * @event
+ */