Ticket #1272: 1272_4.patch

_source/core/dom/text.js

@@ -67 +67 @@
                         return this.$.nodeValue;
                 },
 
+                setText : function( text )
+                {
+                        this.$.nodeValue = text;
+                },
+
                 /**
                  * Breaks this text node into two nodes at the specified offset,
                  * keeping both in the tree as siblings. This node then only contains

_source/plugins/editingblock/plugin.js

@@ -153 +153 @@
          */
         CKEDITOR.editor.prototype.setMode = function( mode )
         {
+                this.fire( 'beforeSetMode', { newMode : mode } );
+
                 var data,
                         holderElement = this.getThemeSpace( 'contents' ),
                         isDirty = this.checkDirty();

_source/plugins/selection/plugin.js

@@ -99 +99 @@
                 canUndo : false
         };
 
+        var fillingChar,
+                fillingCharReady;
+
+        // Checks if a filling char has been used, eventualy removing it (#1272).
+        function checkFillingChar()
+        {
+                if ( fillingChar )
+                {
+                        fillingCharReady && removeFillingChar();
+
+                        // Use this flag to avoid removing the filling char right after
+                        // creating it.
+                        fillingCharReady = !fillingCharReady;
+                }
+        }
+
+        function removeFillingChar()
+        {
+                if ( fillingChar )
+                {
+                        // We can't simply remove the filling node because the user
+                        // will actually enlarge it when typing, so we just remove the
+                        // invisible char from it.
+                        fillingChar.setText( fillingChar.getText().replace( /\u200B/g, '' ) );
+                        fillingChar = 0;
+                }
+        }
+
         CKEDITOR.plugins.add( 'selection',
         {
                 init : function( editor )
                 {
+                        // On WebKit only, we need a special "filling" char on some situations
+                        // (#1272). Here we set the events that should invalidate that char.
+                        if ( CKEDITOR.env.webkit )
+                        {
+                                editor.on( 'selectionChange', checkFillingChar );
+                                editor.on( 'beforeSetMode', checkFillingChar );
+                                editor.on( 'key', function( e )
+                                        {
+                                                // Remove the filling char before the left-key is
+                                                // executed, so it'll not get blocked by it.
+                                                switch ( e.data.keyCode )
+                                                {
+                                                        case 37 :       // LEFT-ARROW
+                                                        case 8 :        // BACKSPACE
+                                                                checkFillingChar();
+                                                }
+                                        });
+
+                                var fillingCharBeforeUndo;
+                                editor.on( 'beforeUndoImage', function()
+                                        {
+                                                fillingCharBeforeUndo = fillingChar && fillingChar.getText();
+                                                fillingCharBeforeUndo && fillingChar.setText( fillingCharBeforeUndo.replace( /\u200B/g, '' ) );
+                                        });
+                                editor.on( 'afterUndoImage', function()
+                                        {
+                                                fillingChar && fillingChar.setText( fillingCharBeforeUndo );
+                                        });
+                        }
+
                         editor.on( 'contentDom', function()
                                 {
                                         var doc = editor.document,
@@ -1138 +1196 @@
                                 var sel = this.getNative();
 
                                 if ( ranges.length )
+                                {
                                         sel.removeAllRanges();
+                                        // Remove any existing filling char first.
+                                        CKEDITOR.env.webkit && checkFillingChar();
+                                }
 
                                 for ( var i = 0 ; i < ranges.length ; i++ )
                                 {
@@ -1188 +1250 @@
                                                 startContainer.appendText( '' );
                                         }
 
-                                        nativeRange.setStart( startContainer.$, range.startOffset );
+                                        if ( range.collapsed && CKEDITOR.env.webkit )
+                                        {
+                                                // Append a zero-width space so WebKit will not try to
+                                                // move the selection by itself (#1272).
+                                                fillingChar = this.document.createText( '\u200B' );
+                                                range.insertNode( fillingChar ) ;
+
+                                                var next = fillingChar.getNext();
+
+                                                // If the filling char is followed by a <br>, it'll not
+                                                // blink. Let's remove it in this case.
+                                                if ( next && next.type == CKEDITOR.NODE_ELEMENT && next.getName() == 'br' )
+                                                {
+                                                        removeFillingChar();
+                                                        range.moveToPosition( next, CKEDITOR.POSITION_BEFORE_START );
+                                                }
+                                                else
+                                                        range.moveToPosition( fillingChar, CKEDITOR.POSITION_AFTER_END );
+                                        }
+
+                                        nativeRange.setStart( range.startContainer.$, range.startOffset );
                                         nativeRange.setEnd( range.endContainer.$, range.endOffset );
 
                                         // Select the range.
@@ -1376 +1458 @@
                 :
                         function()
                         {
-                                var startContainer = this.startContainer;
-
-                                // If we have a collapsed range, inside an empty element, we must add
-                                // something to it, otherwise the caret will not be visible.
-                                if ( this.collapsed && startContainer.type == CKEDITOR.NODE_ELEMENT && !startContainer.getChildCount() )
-                                        startContainer.append( new CKEDITOR.dom.text( '' ) );
-
-                                var nativeRange = this.document.$.createRange();
-                                nativeRange.setStart( startContainer.$, this.startOffset );
-
-                                try
-                                {
-                                        nativeRange.setEnd( this.endContainer.$, this.endOffset );
-                                }
-                                catch ( e )
-                                {
-                                        // There is a bug in Firefox implementation (it would be too easy
-                                        // otherwise). The new start can't be after the end (W3C says it can).
-                                        // So, let's create a new range and collapse it to the desired point.
-                                        if ( e.toString().indexOf( 'NS_ERROR_ILLEGAL_VALUE' ) >= 0 )
-                                        {
-                                                this.collapse( true );
-                                                nativeRange.setEnd( this.endContainer.$, this.endOffset );
-                                        }
-                                        else
-                                                throw( e );
-                                }
-
-                                var selection = this.document.getSelection().getNative();
-                                // getSelection() returns null in case when iframe is "display:none" in FF. (#6577)
-                                if ( selection )
-                                {
-                                        selection.removeAllRanges();
-                                        selection.addRange( nativeRange );
-                                }
+                                this.document.getSelection().selectRanges( [ this ] );
                         };
 } )();

_source/plugins/undo/plugin.js

@@ -148 +148 @@
         var Image = CKEDITOR.plugins.undo.Image = function( editor )
         {
                 this.editor = editor;
+
+                editor.fire( 'beforeUndoImage' );
+
                 var contents = editor.getSnapshot(),
                         selection       = contents && editor.getSelection();
 
@@ -156 +159 @@
 
                 this.contents   = contents;
                 this.bookmarks  = selection && selection.createBookmarks2( true );
+
+                editor.fire( 'afterUndoImage' );
         };
 
         // Attributes that browser may changing them when setting via innerHTML.