Ticket #1272: 1272_6.patch

_source/core/dom/node.js

@@ -182 +182 @@
                 },
 
                 /**
+                 * Gets the document containing this element.
+                 * @returns {CKEDITOR.dom.document} The document.
+                 * @example
+                 * var element = CKEDITOR.document.getById( 'example' );
+                 * alert( <b>element.getDocument().equals( CKEDITOR.document )</b> );  // "true"
+                 */
+                getDocument : function()
+                {
+                        return new CKEDITOR.dom.document( this.$.ownerDocument || this.$.parentNode.ownerDocument );
+                },
+
+                /**
                  * Retrieves a uniquely identifiable tree address for this node.
                  * The tree address returns is an array of integers, with each integer
                  * indicating a child index of a DOM node, starting from
@@ -204 +216 @@
                         while ( node && node != $documentElement )
                         {
                                 var parentNode = node.parentNode;
-                                var currentIndex = -1;
 
                                 if ( parentNode )
                                 {
-                                        for ( var i = 0 ; i < parentNode.childNodes.length ; i++ )
-                                        {
-                                                var candidate = parentNode.childNodes[i];
-
-                                                if ( normalized &&
-                                                                candidate.nodeType == 3 &&
-                                                                candidate.previousSibling &&
-                                                                candidate.previousSibling.nodeType == 3 )
-                                                {
-                                                        continue;
-                                                }
-
-                                                currentIndex++;
-
-                                                if ( candidate == node )
-                                                        break;
-                                        }
-
-                                        address.unshift( currentIndex );
+                                        // Get the node index. For performance, call getIndex
+                                        // directly, instead of creating a new node object.
+                                        address.unshift( this.getIndex.call( { $ : node }, normalized ) );
                                 }
 
                                 node = parentNode;
@@ -235 +230 @@
                         return address;
                 },
 
-                /**
-                 * Gets the document containing this element.
-                 * @returns {CKEDITOR.dom.document} The document.
-                 * @example
-                 * var element = CKEDITOR.document.getById( 'example' );
-                 * alert( <b>element.getDocument().equals( CKEDITOR.document )</b> );  // "true"
-                 */
-                getDocument : function()
+                getIndex : function( normalized )
                 {
-                        return new CKEDITOR.dom.document( this.$.ownerDocument || this.$.parentNode.ownerDocument );
-                },
+                        // Attention: getAddress depends on this.$
 
-                getIndex : function()
-                {
-                        var $ = this.$;
+                        var current = this.$,
+                                index = 0;
 
-                        var currentNode = $.parentNode && $.parentNode.firstChild;
-                        var currentIndex = -1;
-
-                        while ( currentNode )
+                        while ( ( current = current.previousSibling ) )
                         {
-                                currentIndex++;
+                                // When normalizing, do not count it if this is an
+                                // empty text node or if it's a text node following another one.
+                                if ( normalized && current.nodeType == 3 &&
+                                         ( !current.nodeValue.length ||
+                                           ( current.previousSibling && current.previousSibling.nodeType == 3 ) ) )
+                                {
+                                        continue;
+                                }
 
-                                if ( currentNode == $ )
-                                        return currentIndex;
-
-                                currentNode = currentNode.nextSibling;
+                                index++;
                         }
 
-                        return -1;
+                        return index;
                 },
 
                 getNextSourceNode : function( startFromSibling, nodeType, guard )

_source/core/dom/range.js

@@ -589 +589 @@
                                                 startContainer = child;
                                                 startOffset = 0;
                                         }
+
+                                        // Get the normalized offset.
+                                        if ( child && child.type == CKEDITOR.NODE_ELEMENT )
+                                                startOffset = child.getIndex( 1 );
                                 }
 
                                 // Normalize the start.
@@ -617 +621 @@
                                                         endContainer = child;
                                                         endOffset = 0;
                                                 }
+
+                                                // Get the normalized offset.
+                                                if ( child && child.type == CKEDITOR.NODE_ELEMENT )
+                                                        endOffset = child.getIndex( 1 );
                                         }
 
                                         // Normalize the end.

_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 && removeFillingChar();
+                                        fillingCharReady = 0;
+                                }
 
                                 for ( var i = 0 ; i < ranges.length ; i++ )
                                 {
@@ -1188 +1251 @@
                                                 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 +1459 @@
                 :
                         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.