[perso/Immae/Projets/packagist/connexionswing-ckeditor-component.git] / sources / plugins / undo / plugin.js

/**\r
 * @license Copyright (c) 2003-2016, CKSource - Frederico Knabben. All rights reserved.\r
 * For licensing, see LICENSE.md or http://ckeditor.com/license\r
 */\r
\r
/**\r
 * @fileOverview Undo/Redo system for saving a shapshot for document modification\r
 *		and other recordable changes.\r
 */\r
\r
'use strict';\r
\r
( function() {\r
	var keystrokes = [\r
			CKEDITOR.CTRL + 90 /*Z*/,\r
			CKEDITOR.CTRL + 89 /*Y*/,\r
			CKEDITOR.CTRL + CKEDITOR.SHIFT + 90 /*Z*/\r
		],\r
		backspaceOrDelete = { 8: 1, 46: 1 };\r
\r
	CKEDITOR.plugins.add( 'undo', {\r
		// jscs:disable maximumLineLength\r
		lang: 'af,ar,bg,bn,bs,ca,cs,cy,da,de,de-ch,el,en,en-au,en-ca,en-gb,eo,es,et,eu,fa,fi,fo,fr,fr-ca,gl,gu,he,hi,hr,hu,id,is,it,ja,ka,km,ko,ku,lt,lv,mk,mn,ms,nb,nl,no,pl,pt,pt-br,ro,ru,si,sk,sl,sq,sr,sr-latn,sv,th,tr,tt,ug,uk,vi,zh,zh-cn', // %REMOVE_LINE_CORE%\r
		// jscs:enable maximumLineLength\r
		icons: 'redo,redo-rtl,undo,undo-rtl', // %REMOVE_LINE_CORE%\r
		hidpi: true, // %REMOVE_LINE_CORE%\r
		init: function( editor ) {\r
			var undoManager = editor.undoManager = new UndoManager( editor ),\r
				editingHandler = undoManager.editingHandler = new NativeEditingHandler( undoManager );\r
\r
			var undoCommand = editor.addCommand( 'undo', {\r
				exec: function() {\r
					if ( undoManager.undo() ) {\r
						editor.selectionChange();\r
						this.fire( 'afterUndo' );\r
					}\r
				},\r
				startDisabled: true,\r
				canUndo: false\r
			} );\r
\r
			var redoCommand = editor.addCommand( 'redo', {\r
				exec: function() {\r
					if ( undoManager.redo() ) {\r
						editor.selectionChange();\r
						this.fire( 'afterRedo' );\r
					}\r
				},\r
				startDisabled: true,\r
				canUndo: false\r
			} );\r
\r
			editor.setKeystroke( [\r
				[ keystrokes[ 0 ], 'undo' ],\r
				[ keystrokes[ 1 ], 'redo' ],\r
				[ keystrokes[ 2 ], 'redo' ]\r
			] );\r
\r
			undoManager.onChange = function() {\r
				undoCommand.setState( undoManager.undoable() ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );\r
				redoCommand.setState( undoManager.redoable() ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED );\r
			};\r
\r
			function recordCommand( event ) {\r
				// If the command hasn't been marked to not support undo.\r
				if ( undoManager.enabled && event.data.command.canUndo !== false )\r
					undoManager.save();\r
			}\r
\r
			// We'll save snapshots before and after executing a command.\r
			editor.on( 'beforeCommandExec', recordCommand );\r
			editor.on( 'afterCommandExec', recordCommand );\r
\r
			// Save snapshots before doing custom changes.\r
			editor.on( 'saveSnapshot', function( evt ) {\r
				undoManager.save( evt.data && evt.data.contentOnly );\r
			} );\r
\r
			// Event manager listeners should be attached on contentDom.\r
			editor.on( 'contentDom', editingHandler.attachListeners, editingHandler );\r
\r
			editor.on( 'instanceReady', function() {\r
				// Saves initial snapshot.\r
				editor.fire( 'saveSnapshot' );\r
			} );\r
\r
			// Always save an undo snapshot - the previous mode might have\r
			// changed editor contents.\r
			editor.on( 'beforeModeUnload', function() {\r
				editor.mode == 'wysiwyg' && undoManager.save( true );\r
			} );\r
\r
			function toggleUndoManager() {\r
				undoManager.enabled = editor.readOnly ? false : editor.mode == 'wysiwyg';\r
				undoManager.onChange();\r
			}\r
\r
			// Make the undo manager available only in wysiwyg mode.\r
			editor.on( 'mode', toggleUndoManager );\r
\r
			// Disable undo manager when in read-only mode.\r
			editor.on( 'readOnly', toggleUndoManager );\r
\r
			if ( editor.ui.addButton ) {\r
				editor.ui.addButton( 'Undo', {\r
					label: editor.lang.undo.undo,\r
					command: 'undo',\r
					toolbar: 'undo,10'\r
				} );\r
\r
				editor.ui.addButton( 'Redo', {\r
					label: editor.lang.undo.redo,\r
					command: 'redo',\r
					toolbar: 'undo,20'\r
				} );\r
			}\r
\r
			/**\r
			 * Resets the undo stack.\r
			 *\r
			 * @member CKEDITOR.editor\r
			 */\r
			editor.resetUndo = function() {\r
				// Reset the undo stack.\r
				undoManager.reset();\r
\r
				// Create the first image.\r
				editor.fire( 'saveSnapshot' );\r
			};\r
\r
			/**\r
			 * Amends the top of the undo stack (last undo image) with the current DOM changes.\r
			 *\r
			 *		function() {\r
			 *			editor.fire( 'saveSnapshot' );\r
			 *			editor.document.body.append(...);\r
			 *			// Makes new changes following the last undo snapshot a part of it.\r
			 *			editor.fire( 'updateSnapshot' );\r
			 *			..\r
			 *		}\r
			 *\r
			 * @event updateSnapshot\r
			 * @member CKEDITOR.editor\r
			 * @param {CKEDITOR.editor} editor This editor instance.\r
			 */\r
			editor.on( 'updateSnapshot', function() {\r
				if ( undoManager.currentImage )\r
					undoManager.update();\r
			} );\r
\r
			/**\r
			 * Locks the undo manager to prevent any save/update operations.\r
			 *\r
			 * It is convenient to lock the undo manager before performing DOM operations\r
			 * that should not be recored (e.g. auto paragraphing).\r
			 *\r
			 * See {@link CKEDITOR.plugins.undo.UndoManager#lock} for more details.\r
			 *\r
			 * **Note:** In order to unlock the undo manager, {@link #unlockSnapshot} has to be fired\r
			 * the same number of times that `lockSnapshot` has been fired.\r
			 *\r
			 * @since 4.0\r
			 * @event lockSnapshot\r
			 * @member CKEDITOR.editor\r
			 * @param {CKEDITOR.editor} editor This editor instance.\r
			 * @param data\r
			 * @param {Boolean} [data.dontUpdate] When set to `true`, the last snapshot will not be updated\r
			 * with the current content and selection. Read more in the {@link CKEDITOR.plugins.undo.UndoManager#lock} method.\r
			 * @param {Boolean} [data.forceUpdate] When set to `true`, the last snapshot will always be updated\r
			 * with the current content and selection. Read more in the {@link CKEDITOR.plugins.undo.UndoManager#lock} method.\r
			 */\r
			editor.on( 'lockSnapshot', function( evt ) {\r
				var data = evt.data;\r
				undoManager.lock( data && data.dontUpdate, data && data.forceUpdate );\r
			} );\r
\r
			/**\r
			 * Unlocks the undo manager and updates the latest snapshot.\r
			 *\r
			 * @since 4.0\r
			 * @event unlockSnapshot\r
			 * @member CKEDITOR.editor\r
			 * @param {CKEDITOR.editor} editor This editor instance.\r
			 */\r
			editor.on( 'unlockSnapshot', undoManager.unlock, undoManager );\r
		}\r
	} );\r
\r
	CKEDITOR.plugins.undo = {};\r
\r
	/**\r
	 * Main logic for the Redo/Undo feature.\r
	 *\r
	 * @private\r
	 * @class CKEDITOR.plugins.undo.UndoManager\r
	 * @constructor Creates an UndoManager class instance.\r
	 * @param {CKEDITOR.editor} editor\r
	 */\r
	var UndoManager = CKEDITOR.plugins.undo.UndoManager = function( editor ) {\r
		/**\r
		 * An array storing the number of key presses, count in a row. Use {@link #keyGroups} members as index.\r
		 *\r
		 * **Note:** The keystroke count will be reset after reaching the limit of characters per snapshot.\r
		 *\r
		 * @since 4.4.4\r
		 */\r
		this.strokesRecorded = [ 0, 0 ];\r
\r
		/**\r
		 * When the `locked` property is not `null`, the undo manager is locked, so\r
		 * operations like `save` or `update` are forbidden.\r
		 *\r
		 * The manager can be locked and unlocked by the {@link #lock} and {@link #unlock}\r
		 * methods, respectively.\r
		 *\r
		 * @readonly\r
		 * @property {Object} [locked=null]\r
		 */\r
		this.locked = null;\r
\r
		/**\r
		 * Contains the previously processed key group, based on {@link #keyGroups}.\r
		 * `-1` means an unknown group.\r
		 *\r
		 * @since 4.4.4\r
		 * @readonly\r
		 * @property {Number} [previousKeyGroup=-1]\r
		 */\r
		this.previousKeyGroup = -1;\r
\r
		/**\r
		 * The maximum number of snapshots in the stack. Configurable via {@link CKEDITOR.config#undoStackSize}.\r
		 *\r
		 * @readonly\r
		 * @property {Number} [limit]\r
		 */\r
		this.limit = editor.config.undoStackSize || 20;\r
\r
		/**\r
		 * The maximum number of characters typed/deleted in one undo step.\r
		 *\r
		 * @since 4.4.5\r
		 * @readonly\r
		 */\r
		this.strokesLimit = 25;\r
\r
		this.editor = editor;\r
\r
		// Reset the undo stack.\r
		this.reset();\r
	};\r
\r
	UndoManager.prototype = {\r
		/**\r
		 * Handles keystroke support for the undo manager. It is called on `keyup` event for\r
		 * keystrokes that can change the editor content.\r
		 *\r
		 * @param {Number} keyCode The key code.\r
		 * @param {Boolean} [strokesPerSnapshotExceeded] When set to `true`, the method will\r
		 * behave as if the strokes limit was exceeded regardless of the {@link #strokesRecorded} value.\r
		 */\r
		type: function( keyCode, strokesPerSnapshotExceeded ) {\r
			var keyGroup = UndoManager.getKeyGroup( keyCode ),\r
				// Count of keystrokes in current a row.\r
				// Note if strokesPerSnapshotExceeded will be exceeded, it'll be restarted.\r
				strokesRecorded = this.strokesRecorded[ keyGroup ] + 1;\r
\r
			strokesPerSnapshotExceeded =\r
				( strokesPerSnapshotExceeded || strokesRecorded >= this.strokesLimit );\r
\r
			if ( !this.typing )\r
				onTypingStart( this );\r
\r
			if ( strokesPerSnapshotExceeded ) {\r
				// Reset the count of strokes, so it'll be later assigned to this.strokesRecorded.\r
				strokesRecorded = 0;\r
\r
				this.editor.fire( 'saveSnapshot' );\r
			} else {\r
				// Fire change event.\r
				this.editor.fire( 'change' );\r
			}\r
\r
			// Store recorded strokes count.\r
			this.strokesRecorded[ keyGroup ] = strokesRecorded;\r
			// This prop will tell in next itaration what kind of group was processed previously.\r
			this.previousKeyGroup = keyGroup;\r
		},\r
\r
		/**\r
		 * Whether the new `keyCode` belongs to a different group than the previous one ({@link #previousKeyGroup}).\r
		 *\r
		 * @since 4.4.5\r
		 * @param {Number} keyCode\r
		 * @returns {Boolean}\r
		 */\r
		keyGroupChanged: function( keyCode ) {\r
			return UndoManager.getKeyGroup( keyCode ) != this.previousKeyGroup;\r
		},\r
\r
		/**\r
		 * Resets the undo stack.\r
		 */\r
		reset: function() {\r
			// Stack for all the undo and redo snapshots, they're always created/removed\r
			// in consistency.\r
			this.snapshots = [];\r
\r
			// Current snapshot history index.\r
			this.index = -1;\r
\r
			this.currentImage = null;\r
\r
			this.hasUndo = false;\r
			this.hasRedo = false;\r
			this.locked = null;\r
\r
			this.resetType();\r
		},\r
\r
		/**\r
		 * Resets all typing variables.\r
		 *\r
		 * @see #type\r
		 */\r
		resetType: function() {\r
			this.strokesRecorded = [ 0, 0 ];\r
			this.typing = false;\r
			this.previousKeyGroup = -1;\r
		},\r
\r
		/**\r
		 * Refreshes the state of the {@link CKEDITOR.plugins.undo.UndoManager undo manager}\r
		 * as well as the state of the `undo` and `redo` commands.\r
		 */\r
		refreshState: function() {\r
			// These lines can be handled within onChange() too.\r
			this.hasUndo = !!this.getNextImage( true );\r
			this.hasRedo = !!this.getNextImage( false );\r
			// Reset typing\r
			this.resetType();\r
			this.onChange();\r
		},\r
\r
		/**\r
		 * Saves a snapshot of the document image for later retrieval.\r
		 *\r
		 * @param {Boolean} onContentOnly If set to `true`, the snapshot will be saved only if the content has changed.\r
		 * @param {CKEDITOR.plugins.undo.Image} image An optional image to save. If skipped, current editor will be used.\r
		 * @param {Boolean} [autoFireChange=true] If set to `false`, will not trigger the {@link CKEDITOR.editor#change} event to editor.\r
		 */\r
		save: function( onContentOnly, image, autoFireChange ) {\r
			var editor = this.editor;\r
			// Do not change snapshots stack when locked, editor is not ready,\r
			// editable is not ready or when editor is in mode difference than 'wysiwyg'.\r
			if ( this.locked || editor.status != 'ready' || editor.mode != 'wysiwyg' )\r
				return false;\r
\r
			var editable = editor.editable();\r
			if ( !editable || editable.status != 'ready' )\r
				return false;\r
\r
			var snapshots = this.snapshots;\r
\r
			// Get a content image.\r
			if ( !image )\r
				image = new Image( editor );\r
\r
			// Do nothing if it was not possible to retrieve an image.\r
			if ( image.contents === false )\r
				return false;\r
\r
			// Check if this is a duplicate. In such case, do nothing.\r
			if ( this.currentImage ) {\r
				if ( image.equalsContent( this.currentImage ) ) {\r
					if ( onContentOnly )\r
						return false;\r
\r
					if ( image.equalsSelection( this.currentImage ) )\r
						return false;\r
				} else if ( autoFireChange !== false ) {\r
					editor.fire( 'change' );\r
				}\r
			}\r
\r
			// Drop future snapshots.\r
			snapshots.splice( this.index + 1, snapshots.length - this.index - 1 );\r
\r
			// If we have reached the limit, remove the oldest one.\r
			if ( snapshots.length == this.limit )\r
				snapshots.shift();\r
\r
			// Add the new image, updating the current index.\r
			this.index = snapshots.push( image ) - 1;\r
\r
			this.currentImage = image;\r
\r
			if ( autoFireChange !== false )\r
				this.refreshState();\r
			return true;\r
		},\r
\r
		/**\r
		 * Sets editor content/selection to the one stored in `image`.\r
		 *\r
		 * @param {CKEDITOR.plugins.undo.Image} image\r
		 */\r
		restoreImage: function( image ) {\r
			// Bring editor focused to restore selection.\r
			var editor = this.editor,\r
				sel;\r
\r
			if ( image.bookmarks ) {\r
				editor.focus();\r
				// Retrieve the selection beforehand. (#8324)\r
				sel = editor.getSelection();\r
			}\r
\r
			// Start transaction - do not allow any mutations to the\r
			// snapshots stack done when selecting bookmarks (much probably\r
			// by selectionChange listener).\r
			this.locked = { level: 999 };\r
\r
			this.editor.loadSnapshot( image.contents );\r
\r
			if ( image.bookmarks )\r
				sel.selectBookmarks( image.bookmarks );\r
			else if ( CKEDITOR.env.ie ) {\r
				// IE BUG: If I don't set the selection to *somewhere* after setting\r
				// document contents, then IE would create an empty paragraph at the bottom\r
				// the next time the document is modified.\r
				var $range = this.editor.document.getBody().$.createTextRange();\r
				$range.collapse( true );\r
				$range.select();\r
			}\r
\r
			this.locked = null;\r
\r
			this.index = image.index;\r
			this.currentImage = this.snapshots[ this.index ];\r
\r
			// Update current image with the actual editor\r
			// content, since actualy content may differ from\r
			// the original snapshot due to dom change. (#4622)\r
			this.update();\r
			this.refreshState();\r
\r
			editor.fire( 'change' );\r
		},\r
\r
		/**\r
		 * Gets the closest available image.\r
		 *\r
		 * @param {Boolean} isUndo If `true`, it will return the previous image.\r
		 * @returns {CKEDITOR.plugins.undo.Image} Next image or `null`.\r
		 */\r
		getNextImage: function( isUndo ) {\r
			var snapshots = this.snapshots,\r
				currentImage = this.currentImage,\r
				image, i;\r
\r
			if ( currentImage ) {\r
				if ( isUndo ) {\r
					for ( i = this.index - 1; i >= 0; i-- ) {\r
						image = snapshots[ i ];\r
						if ( !currentImage.equalsContent( image ) ) {\r
							image.index = i;\r
							return image;\r
						}\r
					}\r
				} else {\r
					for ( i = this.index + 1; i < snapshots.length; i++ ) {\r
						image = snapshots[ i ];\r
						if ( !currentImage.equalsContent( image ) ) {\r
							image.index = i;\r
							return image;\r
						}\r
					}\r
				}\r
			}\r
\r
			return null;\r
		},\r
\r
		/**\r
		 * Checks the current redo state.\r
		 *\r
		 * @returns {Boolean} Whether the document has a previous state to retrieve.\r
		 */\r
		redoable: function() {\r
			return this.enabled && this.hasRedo;\r
		},\r
\r
		/**\r
		 * Checks the current undo state.\r
		 *\r
		 * @returns {Boolean} Whether the document has a future state to restore.\r
		 */\r
		undoable: function() {\r
			return this.enabled && this.hasUndo;\r
		},\r
\r
		/**\r
		 * Performs an undo operation on current index.\r
		 */\r
		undo: function() {\r
			if ( this.undoable() ) {\r
				this.save( true );\r
\r
				var image = this.getNextImage( true );\r
				if ( image )\r
					return this.restoreImage( image ), true;\r
			}\r
\r
			return false;\r
		},\r
\r
		/**\r
		 * Performs a redo operation on current index.\r
		 */\r
		redo: function() {\r
			if ( this.redoable() ) {\r
				// Try to save. If no changes have been made, the redo stack\r
				// will not change, so it will still be redoable.\r
				this.save( true );\r
\r
				// If instead we had changes, we can't redo anymore.\r
				if ( this.redoable() ) {\r
					var image = this.getNextImage( false );\r
					if ( image )\r
						return this.restoreImage( image ), true;\r
				}\r
			}\r
\r
			return false;\r
		},\r
\r
		/**\r
		 * Updates the last snapshot of the undo stack with the current editor content.\r
		 *\r
		 * @param {CKEDITOR.plugins.undo.Image} [newImage] The image which will replace the current one.\r
		 * If it is not set, it defaults to the image taken from the editor.\r
		 */\r
		update: function( newImage ) {\r
			// Do not change snapshots stack is locked.\r
			if ( this.locked )\r
				return;\r
\r
			if ( !newImage )\r
				newImage = new Image( this.editor );\r
\r
			var i = this.index,\r
				snapshots = this.snapshots;\r
\r
			// Find all previous snapshots made for the same content (which differ\r
			// only by selection) and replace all of them with the current image.\r
			while ( i > 0 && this.currentImage.equalsContent( snapshots[ i - 1 ] ) )\r
				i -= 1;\r
\r
			snapshots.splice( i, this.index - i + 1, newImage );\r
			this.index = i;\r
			this.currentImage = newImage;\r
		},\r
\r
		/**\r
		 * Amends the last snapshot and changes its selection (only in case when content\r
		 * is equal between these two).\r
		 *\r
		 * @since 4.4.4\r
		 * @param {CKEDITOR.plugins.undo.Image} newSnapshot New snapshot with new selection.\r
		 * @returns {Boolean} Returns `true` if selection was amended.\r
		 */\r
		updateSelection: function( newSnapshot ) {\r
			if ( !this.snapshots.length )\r
				return false;\r
\r
			var snapshots = this.snapshots,\r
				lastImage = snapshots[ snapshots.length - 1 ];\r
\r
			if ( lastImage.equalsContent( newSnapshot ) ) {\r
				if ( !lastImage.equalsSelection( newSnapshot ) ) {\r
					snapshots[ snapshots.length - 1 ] = newSnapshot;\r
					this.currentImage = newSnapshot;\r
					return true;\r
				}\r
			}\r
\r
			return false;\r
		},\r
\r
		/**\r
		 * Locks the snapshot stack to prevent any save/update operations and when necessary,\r
		 * updates the tip of the snapshot stack with the DOM changes introduced during the\r
		 * locked period, after the {@link #unlock} method is called.\r
		 *\r
		 * It is mainly used to ensure any DOM operations that should not be recorded\r
		 * (e.g. auto paragraphing) are not added to the stack.\r
		 *\r
		 * **Note:** For every `lock` call you must call {@link #unlock} once to unlock the undo manager.\r
		 *\r
		 * @since 4.0\r
		 * @param {Boolean} [dontUpdate] When set to `true`, the last snapshot will not be updated\r
		 * with current content and selection. By default, if undo manager was up to date when the lock started,\r
		 * the last snapshot will be updated to the current state when unlocking. This means that all changes\r
		 * done during the lock will be merged into the previous snapshot or the next one. Use this option to gain\r
		 * more control over this behavior. For example, it is possible to group changes done during the lock into\r
		 * a separate snapshot.\r
		 * @param {Boolean} [forceUpdate] When set to `true`, the last snapshot will always be updated with the\r
		 * current content and selection regardless of the current state of the undo manager.\r
		 * When not set, the last snapshot will be updated only if the undo manager was up to date when locking.\r
		 * Additionally, this option makes it possible to lock the snapshot when the editor is not in the `wysiwyg` mode,\r
		 * because when it is passed, the snapshots will not need to be compared.\r
		 */\r
		lock: function( dontUpdate, forceUpdate ) {\r
			if ( !this.locked ) {\r
				if ( dontUpdate )\r
					this.locked = { level: 1 };\r
				else {\r
					var update = null;\r
\r
					if ( forceUpdate )\r
						update = true;\r
					else {\r
						// Make a contents image. Don't include bookmarks, because:\r
						// * we don't compare them,\r
						// * there's a chance that DOM has been changed since\r
						// locked (e.g. fake) selection was made, so createBookmark2 could fail.\r
						// http://dev.ckeditor.com/ticket/11027#comment:3\r
						var imageBefore = new Image( this.editor, true );\r
\r
						// If current editor content matches the tip of snapshot stack,\r
						// the stack tip must be updated by unlock, to include any changes made\r
						// during this period.\r
						if ( this.currentImage && this.currentImage.equalsContent( imageBefore ) )\r
							update = imageBefore;\r
					}\r
\r
					this.locked = { update: update, level: 1 };\r
				}\r
\r
			// Increase the level of lock.\r
			} else {\r
				this.locked.level++;\r
			}\r
		},\r
\r
		/**\r
		 * Unlocks the snapshot stack and checks to amend the last snapshot.\r
		 *\r
		 * See {@link #lock} for more details.\r
		 *\r
		 * @since 4.0\r
		 */\r
		unlock: function() {\r
			if ( this.locked ) {\r
				// Decrease level of lock and check if equals 0, what means that undoM is completely unlocked.\r
				if ( !--this.locked.level ) {\r
					var update = this.locked.update;\r
\r
					this.locked = null;\r
\r
					// forceUpdate was passed to lock().\r
					if ( update === true )\r
						this.update();\r
					// update is instance of Image.\r
					else if ( update ) {\r
						var newImage = new Image( this.editor, true );\r
\r
						if ( !update.equalsContent( newImage ) )\r
							this.update();\r
					}\r
				}\r
			}\r
		}\r
	};\r
\r
	/**\r
	 * Codes for navigation keys like *Arrows*, *Page Up/Down*, etc.\r
	 * Used by the {@link #isNavigationKey} method.\r
	 *\r
	 * @since 4.4.5\r
	 * @readonly\r
	 * @static\r
	 */\r
	UndoManager.navigationKeyCodes = {\r
		37: 1, 38: 1, 39: 1, 40: 1, // Arrows.\r
		36: 1, 35: 1, // Home, End.\r
		33: 1, 34: 1 // PgUp, PgDn.\r
	};\r
\r
	/**\r
	 * Key groups identifier mapping. Used for accessing members in\r
	 * {@link #strokesRecorded}.\r
	 *\r
	 * * `FUNCTIONAL` &ndash; identifier for the *Backspace* / *Delete* key.\r
	 * * `PRINTABLE` &ndash; identifier for printable keys.\r
	 *\r
	 * Example usage:\r
	 *\r
	 *		undoManager.strokesRecorded[ undoManager.keyGroups.FUNCTIONAL ];\r
	 *\r
	 * @since 4.4.5\r
	 * @readonly\r
	 * @static\r
	 */\r
	UndoManager.keyGroups = {\r
		PRINTABLE: 0,\r
		FUNCTIONAL: 1\r
	};\r
\r
	/**\r
	 * Checks whether a key is one of navigation keys (*Arrows*, *Page Up/Down*, etc.).\r
	 * See also the {@link #navigationKeyCodes} property.\r
	 *\r
	 * @since 4.4.5\r
	 * @static\r
	 * @param {Number} keyCode\r
	 * @returns {Boolean}\r
	 */\r
	UndoManager.isNavigationKey = function( keyCode ) {\r
		return !!UndoManager.navigationKeyCodes[ keyCode ];\r
	};\r
\r
	/**\r
	 * Returns the group to which the passed `keyCode` belongs.\r
	 *\r
	 * @since 4.4.5\r
	 * @static\r
	 * @param {Number} keyCode\r
	 * @returns {Number}\r
	 */\r
	UndoManager.getKeyGroup = function( keyCode ) {\r
		var keyGroups = UndoManager.keyGroups;\r
\r
		return backspaceOrDelete[ keyCode ] ? keyGroups.FUNCTIONAL : keyGroups.PRINTABLE;\r
	};\r
\r
	/**\r
	 * @since 4.4.5\r
	 * @static\r
	 * @param {Number} keyGroup\r
	 * @returns {Number}\r
	 */\r
	UndoManager.getOppositeKeyGroup = function( keyGroup ) {\r
		var keyGroups = UndoManager.keyGroups;\r
		return ( keyGroup == keyGroups.FUNCTIONAL ? keyGroups.PRINTABLE : keyGroups.FUNCTIONAL );\r
	};\r
\r
	/**\r
	 * Whether we need to use a workaround for functional (*Backspace*, *Delete*) keys not firing\r
	 * the `keypress` event in Internet Explorer in this environment and for the specified `keyCode`.\r
	 *\r
	 * @since 4.4.5\r
	 * @static\r
	 * @param {Number} keyCode\r
	 * @returns {Boolean}\r
	 */\r
	UndoManager.ieFunctionalKeysBug = function( keyCode ) {\r
		return CKEDITOR.env.ie && UndoManager.getKeyGroup( keyCode ) == UndoManager.keyGroups.FUNCTIONAL;\r
	};\r
\r
	// Helper method called when undoManager.typing val was changed to true.\r
	function onTypingStart( undoManager ) {\r
		// It's safe to now indicate typing state.\r
		undoManager.typing = true;\r
\r
		// Manually mark snapshot as available.\r
		undoManager.hasUndo = true;\r
		undoManager.hasRedo = false;\r
\r
		undoManager.onChange();\r
	}\r
\r
	/**\r
	 * Contains a snapshot of the editor content and selection at a given point in time.\r
	 *\r
	 * @private\r
	 * @class CKEDITOR.plugins.undo.Image\r
	 * @constructor Creates an Image class instance.\r
	 * @param {CKEDITOR.editor} editor The editor instance on which the image is created.\r
	 * @param {Boolean} [contentsOnly] If set to `true`, the image will only contain content without the selection.\r
	 */\r
	var Image = CKEDITOR.plugins.undo.Image = function( editor, contentsOnly ) {\r
			this.editor = editor;\r
\r
			editor.fire( 'beforeUndoImage' );\r
\r
			var contents = editor.getSnapshot();\r
\r
			// In IE, we need to remove the expando attributes.\r
			if ( CKEDITOR.env.ie && contents )\r
				contents = contents.replace( /\s+data-cke-expando=".*?"/g, '' );\r
\r
			this.contents = contents;\r
\r
			if ( !contentsOnly ) {\r
				var selection = contents && editor.getSelection();\r
				this.bookmarks = selection && selection.createBookmarks2( true );\r
			}\r
\r
			editor.fire( 'afterUndoImage' );\r
		};\r
\r
	// Attributes that browser may changing them when setting via innerHTML.\r
	var protectedAttrs = /\b(?:href|src|name)="[^"]*?"/gi;\r
\r
	Image.prototype = {\r
		/**\r
		 * @param {CKEDITOR.plugins.undo.Image} otherImage Image to compare to.\r
		 * @returns {Boolean} Returns `true` if content in `otherImage` is the same.\r
		 */\r
		equalsContent: function( otherImage ) {\r
			var thisContents = this.contents,\r
				otherContents = otherImage.contents;\r
\r
			// For IE7 and IE QM: Comparing only the protected attribute values but not the original ones.(#4522)\r
			if ( CKEDITOR.env.ie && ( CKEDITOR.env.ie7Compat || CKEDITOR.env.quirks ) ) {\r
				thisContents = thisContents.replace( protectedAttrs, '' );\r
				otherContents = otherContents.replace( protectedAttrs, '' );\r
			}\r
\r
			if ( thisContents != otherContents )\r
				return false;\r
\r
			return true;\r
		},\r
\r
		/**\r
		 * @param {CKEDITOR.plugins.undo.Image} otherImage Image to compare to.\r
		 * @returns {Boolean} Returns `true` if selection in `otherImage` is the same.\r
		 */\r
		equalsSelection: function( otherImage ) {\r
			var bookmarksA = this.bookmarks,\r
				bookmarksB = otherImage.bookmarks;\r
\r
			if ( bookmarksA || bookmarksB ) {\r
				if ( !bookmarksA || !bookmarksB || bookmarksA.length != bookmarksB.length )\r
					return false;\r
\r
				for ( var i = 0; i < bookmarksA.length; i++ ) {\r
					var bookmarkA = bookmarksA[ i ],\r
						bookmarkB = bookmarksB[ i ];\r
\r
					if ( bookmarkA.startOffset != bookmarkB.startOffset || bookmarkA.endOffset != bookmarkB.endOffset ||\r
						!CKEDITOR.tools.arrayCompare( bookmarkA.start, bookmarkB.start ) ||\r
						!CKEDITOR.tools.arrayCompare( bookmarkA.end, bookmarkB.end ) ) {\r
						return false;\r
					}\r
				}\r
			}\r
\r
			return true;\r
		}\r
\r
		/**\r
		 * Editor content.\r
		 *\r
		 * @readonly\r
		 * @property {String} contents\r
		 */\r
\r
		/**\r
		 * Bookmarks representing the selection in an image.\r
		 *\r
		 * @readonly\r
		 * @property {Object[]} bookmarks Array of bookmark2 objects, see {@link CKEDITOR.dom.range#createBookmark2} for definition.\r
		 */\r
	};\r
\r
	/**\r
	 * A class encapsulating all native event listeners which have to be used in\r
	 * order to handle undo manager integration for native editing actions (excluding drag and drop and paste support\r
	 * handled by the Clipboard plugin).\r
	 *\r
	 * @since 4.4.4\r
	 * @private\r
	 * @class CKEDITOR.plugins.undo.NativeEditingHandler\r
	 * @member CKEDITOR.plugins.undo Undo manager owning the handler.\r
	 * @constructor\r
	 * @param {CKEDITOR.plugins.undo.UndoManager} undoManager\r
	 */\r
	var NativeEditingHandler = CKEDITOR.plugins.undo.NativeEditingHandler = function( undoManager ) {\r
		// We'll use keyboard + input events to determine if snapshot should be created.\r
		// Since `input` event is fired before `keyup`. We can tell in `keyup` event if input occured.\r
		// That will tell us if any printable data was inserted.\r
		// On `input` event we'll increase input fired counter for proper key code.\r
		// Eventually it might be canceled by paste/drop using `ignoreInputEvent` flag.\r
		// Order of events can be found in http://www.w3.org/TR/DOM-Level-3-Events/\r
\r
		/**\r
		 * An undo manager instance owning the editing handler.\r
		 *\r
		 * @property {CKEDITOR.plugins.undo.UndoManager} undoManager\r
		 */\r
		this.undoManager = undoManager;\r
\r
		/**\r
		 * See {@link #ignoreInputEventListener}.\r
		 *\r
		 * @since 4.4.5\r
		 * @private\r
		 */\r
		this.ignoreInputEvent = false;\r
\r
		/**\r
		 * A stack of pressed keys.\r
		 *\r
		 * @since 4.4.5\r
		 * @property {CKEDITOR.plugins.undo.KeyEventsStack} keyEventsStack\r
		 */\r
		this.keyEventsStack = new KeyEventsStack();\r
\r
		/**\r
		 * An image of the editor during the `keydown` event (therefore without DOM modification).\r
		 *\r
		 * @property {CKEDITOR.plugins.undo.Image} lastKeydownImage\r
		 */\r
		this.lastKeydownImage = null;\r
	};\r
\r
	NativeEditingHandler.prototype = {\r
		/**\r
		 * The `keydown` event listener.\r
		 *\r
		 * @param {CKEDITOR.dom.event} evt\r
		 */\r
		onKeydown: function( evt ) {\r
			var keyCode = evt.data.getKey();\r
\r
			// The composition is in progress - ignore the key. (#12597)\r
			if ( keyCode === 229 ) {\r
				return;\r
			}\r
\r
			// Block undo/redo keystrokes when at the bottom/top of the undo stack (#11126 and #11677).\r
			if ( CKEDITOR.tools.indexOf( keystrokes, evt.data.getKeystroke() ) > -1 ) {\r
				evt.data.preventDefault();\r
				return;\r
			}\r
\r
			// Cleaning tab functional keys.\r
			this.keyEventsStack.cleanUp( evt );\r
\r
			var undoManager = this.undoManager;\r
\r
			// Gets last record for provided keyCode. If not found will create one.\r
			var last = this.keyEventsStack.getLast( keyCode );\r
			if ( !last ) {\r
				this.keyEventsStack.push( keyCode );\r
			}\r
\r
			// We need to store an image which will be used in case of key group\r
			// change.\r
			this.lastKeydownImage = new Image( undoManager.editor );\r
\r
			if ( UndoManager.isNavigationKey( keyCode ) || this.undoManager.keyGroupChanged( keyCode ) ) {\r
				if ( undoManager.strokesRecorded[ 0 ] || undoManager.strokesRecorded[ 1 ] ) {\r
					// We already have image, so we'd like to reuse it.\r
\r
					// #12300\r
					undoManager.save( false, this.lastKeydownImage, false );\r
					undoManager.resetType();\r
				}\r
			}\r
		},\r
\r
		/**\r
		 * The `input` event listener.\r
		 */\r
		onInput: function() {\r
			// Input event is ignored if paste/drop event were fired before.\r
			if ( this.ignoreInputEvent ) {\r
				// Reset flag - ignore only once.\r
				this.ignoreInputEvent = false;\r
				return;\r
			}\r
\r
			var lastInput = this.keyEventsStack.getLast();\r
			// Nothing in key events stack, but input event called. Interesting...\r
			// That's because on Android order of events is buggy and also keyCode is set to 0.\r
			if ( !lastInput ) {\r
				lastInput = this.keyEventsStack.push( 0 );\r
			}\r
\r
			// Increment inputs counter for provided key code.\r
			this.keyEventsStack.increment( lastInput.keyCode );\r
\r
			// Exceeded limit.\r
			if ( this.keyEventsStack.getTotalInputs() >= this.undoManager.strokesLimit ) {\r
				this.undoManager.type( lastInput.keyCode, true );\r
				this.keyEventsStack.resetInputs();\r
			}\r
		},\r
\r
		/**\r
		 * The `keyup` event listener.\r
		 *\r
		 * @param {CKEDITOR.dom.event} evt\r
		 */\r
		onKeyup: function( evt ) {\r
			var undoManager = this.undoManager,\r
				keyCode = evt.data.getKey(),\r
				totalInputs = this.keyEventsStack.getTotalInputs();\r
\r
			// Remove record from stack for provided key code.\r
			this.keyEventsStack.remove( keyCode );\r
\r
			// Second part of the workaround for IEs functional keys bug. We need to check whether something has really\r
			// changed because we blindly mocked the keypress event.\r
			// Also we need to be aware that lastKeydownImage might not be available (#12327).\r
			if ( UndoManager.ieFunctionalKeysBug( keyCode ) && this.lastKeydownImage &&\r
				this.lastKeydownImage.equalsContent( new Image( undoManager.editor, true ) ) ) {\r
				return;\r
			}\r
\r
			if ( totalInputs > 0 ) {\r
				undoManager.type( keyCode );\r
			} else if ( UndoManager.isNavigationKey( keyCode ) ) {\r
				// Note content snapshot has been checked in keydown.\r
				this.onNavigationKey( true );\r
			}\r
		},\r
\r
		/**\r
		 * Method called for navigation change. At first it will check if current content does not differ\r
		 * from the last saved snapshot.\r
		 *\r
		 * * If the content is different, the method creates a standard, extra snapshot.\r
		 * * If the content is not different, the method will compare the selection, and will\r
		 * amend the last snapshot selection if it changed.\r
		 *\r
		 * @param {Boolean} skipContentCompare If set to `true`, it will not compare content, and only do a selection check.\r
		 */\r
		onNavigationKey: function( skipContentCompare ) {\r
			var undoManager = this.undoManager;\r
\r
			// We attempt to save content snapshot, if content didn't change, we'll\r
			// only amend selection.\r
			if ( skipContentCompare || !undoManager.save( true, null, false ) )\r
				undoManager.updateSelection( new Image( undoManager.editor ) );\r
\r
			undoManager.resetType();\r
		},\r
\r
		/**\r
		 * Makes the next `input` event to be ignored.\r
		 */\r
		ignoreInputEventListener: function() {\r
			this.ignoreInputEvent = true;\r
		},\r
\r
		/**\r
		 * Attaches editable listeners required to provide the undo functionality.\r
		 */\r
		attachListeners: function() {\r
			var editor = this.undoManager.editor,\r
				editable = editor.editable(),\r
				that = this;\r
\r
			// We'll create a snapshot here (before DOM modification), because we'll\r
			// need unmodified content when we got keygroup toggled in keyup.\r
			editable.attachListener( editable, 'keydown', function( evt ) {\r
				that.onKeydown( evt );\r
\r
				// On IE keypress isn't fired for functional (backspace/delete) keys.\r
				// Let's pretend that something's changed.\r
				if ( UndoManager.ieFunctionalKeysBug( evt.data.getKey() ) ) {\r
					that.onInput();\r
				}\r
			}, null, null, 999 );\r
\r
			// Only IE can't use input event, because it's not fired in contenteditable.\r
			editable.attachListener( editable, ( CKEDITOR.env.ie ? 'keypress' : 'input' ), that.onInput, that, null, 999 );\r
\r
			// Keyup executes main snapshot logic.\r
			editable.attachListener( editable, 'keyup', that.onKeyup, that, null, 999 );\r
\r
			// On paste and drop we need to ignore input event.\r
			// It would result with calling undoManager.type() on any following key.\r
			editable.attachListener( editable, 'paste', that.ignoreInputEventListener, that, null, 999 );\r
			editable.attachListener( editable, 'drop', that.ignoreInputEventListener, that, null, 999 );\r
\r
			// Click should create a snapshot if needed, but shouldn't cause change event.\r
			// Don't pass onNavigationKey directly as a listener because it accepts one argument which\r
			// will conflict with evt passed to listener.\r
			// #12324 comment:4\r
			editable.attachListener( editable.isInline() ? editable : editor.document.getDocumentElement(), 'click', function() {\r
				that.onNavigationKey();\r
			}, null, null, 999 );\r
\r
			// When pressing `Tab` key while editable is focused, `keyup` event is not fired.\r
			// Which means that record for `tab` key stays in key events stack.\r
			// We assume that when editor is blurred `tab` key is already up.\r
			editable.attachListener( this.undoManager.editor, 'blur', function() {\r
				that.keyEventsStack.remove( 9 /*Tab*/ );\r
			}, null, null, 999 );\r
		}\r
	};\r
\r
	/**\r
	 * This class represents a stack of pressed keys and stores information\r
	 * about how many `input` events each key press has caused.\r
	 *\r
	 * @since 4.4.5\r
	 * @private\r
	 * @class CKEDITOR.plugins.undo.KeyEventsStack\r
	 * @constructor\r
	 */\r
	var KeyEventsStack = CKEDITOR.plugins.undo.KeyEventsStack = function() {\r
		/**\r
		 * @readonly\r
		 */\r
		this.stack = [];\r
	};\r
\r
	KeyEventsStack.prototype = {\r
		/**\r
		 * Pushes a literal object with two keys: `keyCode` and `inputs` (whose initial value is set to `0`) to stack.\r
		 * It is intended to be called on the `keydown` event.\r
		 *\r
		 * @param {Number} keyCode\r
		 */\r
		push: function( keyCode ) {\r
			var length = this.stack.push( { keyCode: keyCode, inputs: 0 } );\r
			return this.stack[ length - 1 ];\r
		},\r
\r
		/**\r
		 * Returns the index of the last registered `keyCode` in the stack.\r
		 * If no `keyCode` is provided, then the function will return the index of the last item.\r
		 * If an item is not found, it will return `-1`.\r
		 *\r
		 * @param {Number} [keyCode]\r
		 * @returns {Number}\r
		 */\r
		getLastIndex: function( keyCode ) {\r
			if ( typeof keyCode != 'number' ) {\r
				return this.stack.length - 1; // Last index or -1.\r
			} else {\r
				var i = this.stack.length;\r
				while ( i-- ) {\r
					if ( this.stack[ i ].keyCode == keyCode ) {\r
						return i;\r
					}\r
				}\r
				return -1;\r
			}\r
		},\r
\r
		/**\r
		 * Returns the last key recorded in the stack. If `keyCode` is provided, then it will return\r
		 * the  last record for this `keyCode`.\r
		 *\r
		 * @param {Number} [keyCode]\r
		 * @returns {Object} Last matching record or `null`.\r
		 */\r
		getLast: function( keyCode ) {\r
			var index = this.getLastIndex( keyCode );\r
			if ( index != -1 ) {\r
				return this.stack[ index ];\r
			} else {\r
				return null;\r
			}\r
		},\r
\r
		/**\r
		 * Increments registered input events for stack record for a given `keyCode`.\r
		 *\r
		 * @param {Number} keyCode\r
		 */\r
		increment: function( keyCode ) {\r
			var found = this.getLast( keyCode );\r
			if ( !found ) { // %REMOVE_LINE%\r
				throw new Error( 'Trying to increment, but could not found by keyCode: ' + keyCode + '.' ); // %REMOVE_LINE%\r
			} // %REMOVE_LINE%\r
\r
			found.inputs++;\r
		},\r
\r
		/**\r
		 * Removes the last record from the stack for the provided `keyCode`.\r
		 *\r
		 * @param {Number} keyCode\r
		 */\r
		remove: function( keyCode ) {\r
			var index = this.getLastIndex( keyCode );\r
\r
			if ( index != -1 ) {\r
				this.stack.splice( index, 1 );\r
			}\r
		},\r
\r
		/**\r
		 * Resets the `inputs` value to `0` for a given `keyCode` or in entire stack if a\r
		 * `keyCode` is not specified.\r
		 *\r
		 * @param {Number} [keyCode]\r
		 */\r
		resetInputs: function( keyCode ) {\r
			if ( typeof keyCode == 'number' ) {\r
				var last = this.getLast( keyCode );\r
\r
				if ( !last ) { // %REMOVE_LINE%\r
					throw new Error( 'Trying to reset inputs count, but could not found by keyCode: ' + keyCode + '.' ); // %REMOVE_LINE%\r
				} // %REMOVE_LINE%\r
\r
				last.inputs = 0;\r
			} else {\r
				var i = this.stack.length;\r
				while ( i-- ) {\r
					this.stack[ i ].inputs = 0;\r
				}\r
			}\r
		},\r
\r
		/**\r
		 * Sums up inputs number for each key code and returns it.\r
		 *\r
		 * @returns {Number}\r
		 */\r
		getTotalInputs: function() {\r
			var i = this.stack.length,\r
				total = 0;\r
\r
			while ( i-- ) {\r
				total += this.stack[ i ].inputs;\r
			}\r
			return total;\r
		},\r
\r
		/**\r
		 * Cleans the stack based on a provided `keydown` event object. The rationale behind this method\r
		 * is that some keystrokes cause the `keydown` event to be fired in the editor, but not the `keyup` event.\r
		 * For instance, *Alt+Tab* will fire `keydown`, but since the editor is blurred by it, then there is\r
		 * no `keyup`, so the keystroke is not removed from the stack.\r
		 *\r
		 * @param {CKEDITOR.dom.event} event\r
		 */\r
		cleanUp: function( event ) {\r
			var nativeEvent = event.data.$;\r
\r
			if ( !( nativeEvent.ctrlKey || nativeEvent.metaKey ) ) {\r
				this.remove( 17 );\r
			}\r
			if ( !nativeEvent.shiftKey ) {\r
				this.remove( 16 );\r
			}\r
			if ( !nativeEvent.altKey ) {\r
				this.remove( 18 );\r
			}\r
		}\r
	};\r
} )();\r
\r
/**\r
 * The number of undo steps to be saved. The higher value is set, the more\r
 * memory is used for it.\r
 *\r
 *		config.undoStackSize = 50;\r
 *\r
 * @cfg {Number} [undoStackSize=20]\r
 * @member CKEDITOR.config\r
 */\r
\r
/**\r
 * Fired when the editor is about to save an undo snapshot. This event can be\r
 * fired by plugins and customizations to make the editor save undo snapshots.\r
 *\r
 * @event saveSnapshot\r
 * @member CKEDITOR.editor\r
 * @param {CKEDITOR.editor} editor This editor instance.\r
 */\r
\r
/**\r
 * Fired before an undo image is to be created. An *undo image* represents the\r
 * editor state at some point. It is saved into the undo store, so the editor is\r
 * able to recover the editor state on undo and redo operations.\r
 *\r
 * @since 3.5.3\r
 * @event beforeUndoImage\r
 * @member CKEDITOR.editor\r
 * @param {CKEDITOR.editor} editor This editor instance.\r
 * @see CKEDITOR.editor#afterUndoImage\r
 */\r
\r
/**\r
 * Fired after an undo image is created. An *undo image* represents the\r
 * editor state at some point. It is saved into the undo store, so the editor is\r
 * able to recover the editor state on undo and redo operations.\r
 *\r
 * @since 3.5.3\r
 * @event afterUndoImage\r
 * @member CKEDITOR.editor\r
 * @param {CKEDITOR.editor} editor This editor instance.\r
 * @see CKEDITOR.editor#beforeUndoImage\r
 */\r
\r
/**\r
 * Fired when the content of the editor is changed.\r
 *\r
 * Due to performance reasons, it is not verified if the content really changed.\r
 * The editor instead watches several editing actions that usually result in\r
 * changes. This event may thus in some cases be fired when no changes happen\r
 * or may even get fired twice.\r
 *\r
 * If it is important not to get the `change` event fired too often, you should compare the\r
 * previous and the current editor content inside the event listener. It is\r
 * not recommended to do that on every `change` event.\r
 *\r
 * Please note that the `change` event is only fired in the {@link #property-mode wysiwyg mode}.\r
 * In order to implement similar functionality in the source mode, you can listen for example to the {@link #key}\r
 * event or the native [`input`](https://developer.mozilla.org/en-US/docs/Web/Reference/Events/input)\r
 * event (not supported by Internet Explorer 8).\r
 *\r
 *		editor.on( 'mode', function() {\r
 *			if ( this.mode == 'source' ) {\r
 *				var editable = editor.editable();\r
 *				editable.attachListener( editable, 'input', function() {\r
 *					// Handle changes made in the source mode.\r
 *				} );\r
 *			}\r
 *		} );\r
 *\r
 * @since 4.2\r
 * @event change\r
 * @member CKEDITOR.editor\r
 * @param {CKEDITOR.editor} editor This editor instance.\r
 */\r