Ticket #2763: 2763_4.patch

_source/plugins/editingblock/plugin.js

@@ -138 +138 @@
 
                 modeEditor.load( holderElement, data || this.getData() );
         };
-
+        
+        /**
+         * @private Get the current blockediting mode of this editor
+         * @param mode The name of the specified mode, by default the current mode.
+         * @return {Object}  The mode editor definition.
+         */
+        CKEDITOR.editor.prototype.getMode = function( mode )
+        {
+                return this._.modes && this._.modes[ mode || this.mode ];
+        };
+        
         /**
          * Moves the selection focus to the editing are space in the editor.
          */

_source/plugins/toolbar/plugin.js

@@ -210 +210 @@
                 'NewPage', '-',
                 'Bold', 'Italic', 'Underline', 'Strike', '-',
                 'Subscript', 'Superscript', '-',
+                'Undo', 'Redo', '-',
                 'SelectAll', 'RemoveFormat', '-',
                 'Smiley', 'HorizontalRule', 'SpecialChar', 'PageBreak'
         ]

_source/plugins/selection/plugin.js

@@ -618 +618 @@
                                                 sel.addRange( nativeRange );
                                         }
                                 },
-
-                createBookmarks : function()
+        /**
+                 * This method is a delegate to ceate bookmark for every ranges in this selection.
+                 * 
+                 * @see CKEDITOR.dom.range::createBookmark
+                 */
+                createBookmarks : function ( serializable )
                 {
                         var retval = [],
                                 ranges = this.getRanges();
@@ -624 +628 @@
                         var retval = [],
                                 ranges = this.getRanges();
                         for ( var i = 0 ; i < ranges.length ; i++ )
-                                retval.push( ranges[i].createBookmark() );
+                                retval.push( ranges[ i ].createBookmark( serializable ) );
                         return retval;
                 },
 

_source/plugins/undoredo/plugin.js

@@ +1 @@
+/*
+ * Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
+ * For licensing, see LICENSE.html or http://ckeditor.com/license
+ */
+
+/**
+ * @fileOverview Undo/Redo system for saving shapshot for document modification
+ *               and other recordable changes.
+ */
+CKEDITOR.plugins.add( 'undoredo' ,
+/**
+ * @implements CKEDITOR.pluginDefinition The undo/redo feature for wysiwygarea
+ *             mode
+ */
+{
+
+        requires : [ 'selection', 'wysiwygarea' ],
+        init : function ( editor )
+        {
+                        
+                var urm = new UndoRedoManager( editor );
+                function recordCommand ( evt )
+                {
+                        var event /* {FCKEDITOR.command.Event} */= evt.data;
+                        if ( event.command.supportUndoRedo !== false // ingore mode change
+                                        // command
+                                        && event.name !== 'source'
+                                        && event.name !== 'wysiwyg'
+                                        && urm.enabled )
+                        {
+                                urm.save( evt.name === 'beforeCommandExec' ? true : false );
+                        }
+                }
+
+                editor.on( 'beforeCommandExec' , recordCommand );
+                editor.on( 'afterCommandExec' , recordCommand );
+
+                // sensitive to mode change, only appliable for 'wysiwyg' mode
+                editor.on( 'mode' , function ( currentMode )
+                {
+                        urm.enabled = editor.getMode().name === 'wysiwyg';
+                } );
+
+                editor.addCommand( 'undo' ,
+                /**
+                 * @implements CKEDITOR.commandDefinition Rollback to last modification
+                 *             of this document
+                 */
+                {
+
+                        exec : function() {
+                                if (urm.undo()) {
+                                        this.fire('AfterUndo');
+                                        // TODO: fire 'selectionchange'
+                                }
+                        },
+                        supportUndoRedo : false
+                } );
+
+                editor.addCommand( 'redo' ,
+                /**
+                 * @implements CKEDITOR.commandDefinition Retrieve to next modification
+                 *             of this document
+                 */
+                {
+                        exec : function() {
+                                if (urm.redo()) {
+                                        this.fire('AfterRedo');
+                                        // TODO: fire 'selectionchange'
+                                }
+                        },
+                        supportUndoRedo : false
+                } );
+                
+                editor.ui.addButton( 'Undo',
+                        {
+                                label : editor.lang.undo,
+                                command : 'undo'
+                        });
+                editor.ui.addButton( 'Redo',
+                        {
+                                label : editor.lang.redo,
+                                command : 'redo'
+                        });
+        }
+} );
+
+/**
+ * @constructor Main logic for Redo/Undo feature
+ * @related FCKUndo in v2
+ */
+function UndoRedoManager ( editor )
+{
+
+        /**
+         * @field Whether undo system is usable decided by envoriment
+         */
+        this.enabled = false;
+
+        var UNDO_NUM_LIMIT = 20;
+
+        /**
+         * Stack for all the undo and redo snapshots, they're always created/removed
+         * in consistency.
+         * 
+         * @type {Array<DocumentImage>}
+         * 
+         */
+        var undoSnaps = [] , redoSnaps = [];
+
+        /**
+         * Current snapshot history index
+         */
+        var index = 0; // First capture start from 1
+
+        /**
+         * @constructor DocumentImage - A snapshot image which represent the current
+         *              document status.
+         */
+        function DocumentImage ( )
+        {
+
+                var bms , ranges , cWithBm , c;
+
+                c = editor.getMode( 'wysiwyg' ).getSnapshotData();
+                bms = editor.document.getSelection().createBookmarks( true );
+                ranges = editor.document.getSelection().getRanges(); // Get ranges
+                // from cache
+                cWithBm = editor.getMode( 'wysiwyg' ).getSnapshotData() // Get content along
+                // with bookmark
+                editor.document.getSelection().selectBookmarks( bms ); 
+                // restore
+                // selection by
+                // the bookmark
+                // and we
+                // also
+                // destroy the nodes in document
+                return {
+                        'content' : /** {String} original document string */
+                        c,
+                        'dirtyContent' :
+                        /**
+                         * {String} document content string with bookmarks
+                         */
+                        cWithBm,
+                        'bookmark' /** {Array<CKEDITOR.dom.range.Bookmark>} */
+                        :bms,
+                        equals :
+                        /**
+                         * Compare if two document snapshot are the same, this is only
+                         * content comparison with bookmarks striped. (
+                         * 
+                         * @img {DocumentImage} The other image to compare with
+                         */
+                        function ( img )
+                        {
+                                return this.content == img.content;
+                        }
+                }
+        }
+
+        /**
+         * @method Save a snapshot of document image for later retrieve, content
+         *         being saved as raw html string, while selection saved as a
+         *         lightweight bookmark.
+         */
+        this.save = function ( isFront )
+        {
+                var sns = isFront ? undoSnaps : redoSnaps;
+
+                if ( index == UNDO_NUM_LIMIT )
+                {
+                        sns.unshift(); // Die out earlier ones.
+                }
+
+                sns.splice( index , sns.length - index ); // Drop older snaps
+
+                var img = new DocumentImage();
+                if ( sns.length && img.equals( sns[ sns.length - 1 ] ) ) // duplicate
+                        // examination
+                        return;
+
+                sns.push( img );
+
+                if ( !isFront )
+                        index++; // increase when command has been fully recorded.
+        }
+
+        function restoreImage ( index, isUndo )
+        {
+                var img;
+                img = isUndo ? undoSnaps[ index ] : redoSnaps[ index ];
+                if ( img.content )
+                {
+                        editor.getMode( 'wysiwyg' ).loadSnapshotData( img.dirtyContent );
+                        if ( img.bookmark )
+                        {
+                                editor.document.getSelection().selectBookmarks( img.bookmark );
+                        }
+                }
+        }
+
+        /**
+         * Check the current state of redo
+         * 
+         * @return {Boolean} Whether the document has previous state to retrieve
+         */
+        this.redoAble = function ( )
+        {
+                return index < redoSnaps.length;
+        }
+
+        /**
+         * Check the current state of undo
+         * 
+         * @return {Boolean} Whether the document has future state to restore
+         */
+        this.undoAble = function ( )
+        {
+                return index > 0
+        }
+        /**
+         * Perform undo on current index.
+         * 
+         * @method
+         */
+        this.undo = function ( )
+        {
+                if ( this.undoAble() )
+                {
+                        restoreImage( --index , true ); // retrieve previous one from undo
+                        // history
+                }
+                else
+                        return false;
+        }
+
+        /**
+         * Perform redo on current index.
+         * 
+         * @method
+         */
+        this.redo = function ( )
+        {
+                if ( this.redoAble() )
+                {
+                        restoreImage( index++ , false ); // retrieve next one from redo
+                        // history
+                }
+                else
+                        return false;
+        }
+
+}

_source/core/commanddefinition.js

@@ -33 +33 @@
  *     }
  * });
  */
+ 
+/**
+ * Whether the command need to be hooked into the redo/undo system.
+ * @name  CKEDITOR.commandDefinition.supportUndoRedo
+ * @type {Boolean} If not defined or 'true' both hook into undo system, set it to 'false' explicitly  keep it out.  
+ * @field
+ * @example
+ *  editorInstance.addCommand( 'sample',
+ * {
+ *     CKEDITOR.commandDefinition.supportUndoRedo : false    //declare this command does not support undo/redo  
+ * });
+ */

_source/core/dom/range.js

@@ -409 +409 @@
                         return docFrag;
                 },
 
-                // This is an "intrusive" way to create a bookmark. It includes <span> tags
-                // in the range boundaries. The advantage of it is that it is possible to
-                // handle DOM mutations when moving back to the bookmark.
-                // Attention: the inclusion of nodes in the DOM is a design choice and
-                // should not be changed as there are other points in the code that may be
-                // using those nodes to perform operations. See GetBookmarkNode.
-                createBookmark : function()
+                /**
+                 * This is an "intrusive" way to create a bookmark. It includes <span>
+                 * tags in the range boundaries. The advantage of it is that it is
+                 * possible to handle DOM mutations when moving back to the bookmark.
+                 * Attention: the inclusion of nodes in the DOM is a design choice.
+                 * 
+                 * @param serializeable {Boolean} If set to true will record the bookmark with startNode/endNode IDs for serializing purpose.
+                 */
+                createBookmark : function(serializeable)
                 {
-                        var startNode, endNode;
+                        var startNode , endNode;
                         var clone;
 
                         startNode = this.document.createElement( 'span' );
-                        startNode.setAttribute( '_fck_bookmark', 1 );
-                        startNode.setStyle( 'display', 'none' );
+                        startNode.setAttribute( '_fck_bookmark' , 1 );
+                        startNode.setStyle( 'display' , 'none' );
 
                         // For IE, it must have something inside, otherwise it may be
                         // removed during DOM operations.
@@ -452 +454 @@
                         else
                                 this.moveToPosition( startNode, CKEDITOR.POSITION_AFTER_END );
 
+                        if ( serializeable )
+                        {
+                                startNode.setAttribute( 'id' , ( new Date() ).valueOf()
+                                                + Math.floor( Math.random() * 1000 ) + 'S' );
+                                if ( endNode )
+                                        endNode.setAttribute( 'id' , ( new Date() ).valueOf()
+                                                        + Math.floor( Math.random() * 1000 ) + 'E' );
+                        }
                         return {
-                                startNode : startNode,
-                                endNode : endNode
+                                startNode :serializeable ? startNode.getAttribute( 'id' )
+                                                : startNode,
+                                endNode :endNode ? ( serializeable ? endNode
+                                                .getAttribute( 'id' ) : endNode ) : null
                         };
                 },
 
+                /**
+                 * Move the range boundaries to where the bookmarks indicated.
+                 * 
+                 * @see CKEDITOR.dom.range::createBookmark
+                 * @param {Object} bookmark
+                 * 
+                 */
                 moveToBookmark : function( bookmark )
                 {
-                        // Set the range start at the bookmark start node position.
-                        this.setStartBefore( bookmark.startNode );
+                        var startNode = bookmark.startNode , endNode = bookmark.endNode;
+
+                        // Set the range startNodeart at the bookmark startNodeart node position.
+                        this.setStartBefore( typeof startNode === 'string' ? ( startNode = this.document
+                                        .getById( startNode ) ) : startNode );
 
                         // Remove it, because it may interfere in the setEndBefore call.
-                        bookmark.startNode.remove();
+                        startNode.remove();
 
                         // Set the range end at the bookmark end node position, or simply
                         // collapse it if it is not available.
-                        var endNode = bookmark.endNode;
                         if ( endNode )
                         {
-                                this.setEndBefore( endNode );
+                                this.setEndBefore( typeof endNode === 'string' ? 
+                                                ( endNode = this.document.getById( endNode ) )
+                                                : endNode );
                                 endNode.remove();
                         }
                         else

_source/core/editor.js

@@ -386 +386 @@
                 execCommand : function( commandName, data )
                 {
                         var command = this.getCommand( commandName );
+                        var exeResult;
+                        var commandEvent =
+
+                        /**
+                         * The event data for this command
+                         * @type FCKEDITOR.command.Event
+                         */
+                        {
+                                name :commandName,
+                                command :command
+                        };
                         if ( command && command.state != CKEDITOR.TRISTATE_DISABLED )
-                                return command.exec( this, data );
+                        {
+                                this.fire( 'beforeCommandExec' , commandEvent );
+                                exeResult = command.exec( this , data );
+                                this.fire( 'afterCommandExec' , commandEvent );
+                                return exeResult;
+                        }
 
                         // throw 'Unknown command name "' + commandName + '"';
                         return false;

_source/core/config.js

@@ -146 +146 @@
          * @example
          * config.plugins = 'basicstyles,button,htmldataprocessor,toolbar,wysiwygarea';
          */
-        plugins : 'basicstyles,button,elementspath,horizontalrule,htmldataprocessor,keystrokes,newpage,pagebreak,removeformat,smiley,sourcearea,specialchar,tab,toolbar,wysiwygarea',
+        plugins : 'basicstyles,button,elementspath,horizontalrule,htmldataprocessor,keystrokes,newpage,pagebreak,removeformat,smiley,sourcearea,specialchar,tab,toolbar,wysiwygarea,undoredo',
 
         /**
          * The theme to be used to build the UI.

_source/lang/en.js

@@ -42 +42 @@
         horizontalrule  : 'Insert Horizontal Line',
         pagebreak               : 'Insert Page Break',
         unlink                  : 'Unlink',
+        undo                    : 'Undo',
+        redo                    : 'Redo',
 
         // Common messages and labels.
         common :

_source/skins/default/toolbar.css

@@ -305 +305 @@
 {
         background-position: 0 -880px;
 }
+.cke_skin_default a.cke_button_undo .cke_icon
+{
+        background-position: 0 -208px;
+}
+.cke_skin_default a.cke_button_redo .cke_icon
+{
+        background-position: 0 -224px;
+}