Ticket #4830: 4830.patch

_source/plugins/selection/plugin.js

@@ -730 +730 @@
                         if ( cache.selectedElement !== undefined )
                                 return cache.selectedElement;
 
-                        var node;
+                        var self = this;
 
-                        if ( this.getType() == CKEDITOR.SELECTION_ELEMENT )
-                        {
-                                var sel = this.getNative();
+                        var node =
+                                CKEDITOR.tools.tryThese(
+                                // Is it native IE control type selection?
+                                function()
+                                {
+                                        return self.getNative().createRange().item( 0 );
+                                },
+                                // Figure it out by checking if there's a single enclosed
+                                // node of the range.
+                                function()
+                                {
+                                        var range  = self.getRanges()[ 0 ];
+                                        range.shrink( CKEDITOR.SHRINK_ELEMENT );
 
-                                if ( CKEDITOR.env.ie )
-                                {
-                                        try
-                                        {
-                                                node = sel.createRange().item(0);
+                                        var enclosed;
+                                        if ( range.startContainer.equals( range.endContainer )
+                                                && ( range.endOffset - range.startOffset ) == 1
+                                                && styleObjectElements[ ( enclosed = range.startContainer.getChild( range.startOffset ) ).getName() ] )
+                                        {
+                                                return enclosed.$;
                                         }
-                                        catch(e) {}
-                                }
-                                else
-                                {
-                                        var range = sel.getRangeAt( 0 );
-                                        node = range.startContainer.childNodes[ range.startOffset ];
-                                }
-                        }
-
+                                        else
+                                                throw '';
+                                });
+                        
                         return cache.selectedElement = ( node ? new CKEDITOR.dom.element( node ) : null );
                 },
 

_source/core/dom/range.js

@@ -1236 +1236 @@
                 },
 
                 /**
+                 *  Descrease the range to make sure that boundaries
+                 *  always anchor beside text nodes or innermost element.
+                 * @param {Number} mode  ( CKEDITOR.SHRINK_ELEMENT | CKEDITOR.SHRINK_TEXT ) The shrinking mode.
+                 */
+                shrink : function( mode )
+                {
+                        !mode && ( mode = CKEDITOR.SHRINK_TEXT );
+
+                        // Unable to shrink a collapsed range.
+                        if( this.collapsed )
+                                return false;
+                        else
+                        {
+                                var walkerRange = this.clone();
+
+                                var startContainer = this.startContainer,
+                                        endContainer = this.endContainer,
+                                        startOffset = this.startOffset,
+                                        endOffset = this.endOffset,
+                                        collapsed = this.collapsed;
+
+                                // Whether the start/end boundary is moveable.
+                                var moveStart = 1,
+                                                moveEnd = 1;
+
+                                if ( startContainer && startContainer.type == CKEDITOR.NODE_TEXT )
+                                {
+                                        if ( !startOffset )
+                                                walkerRange.setStartBefore( startContainer );
+                                        else if ( startOffset >= startContainer.getLength( ) )
+                                                walkerRange.setStartAfter( startContainer );
+                                        else
+                                        {
+                                                // Enlarge the range properly to avoid walker making
+                                                // DOM changes caused by triming the text nodes later.
+                                                walkerRange.setStartBefore( startContainer );
+                                                moveStart = 0;
+                                        }
+                                }
+                                
+                                if ( endContainer && endContainer.type == CKEDITOR.NODE_TEXT )
+                                {
+                                        if ( !endOffset )
+                                                walkerRange.setEndBefore( endContainer );
+                                        else if ( endOffset >= endContainer.getLength( ) )
+                                                walkerRange.setEndAfter( endContainer );
+                                        else
+                                        {
+                                                walkerRange.setEndAfter( endContainer );
+                                                moveEnd = 0;
+                                        }
+                                }
+
+                                var walker = new CKEDITOR.dom.walker( walkerRange );
+
+                                walker.evaluator = function( node )
+                                {
+                                        return node.type == ( mode == CKEDITOR.SHRINK_ELEMENT ?
+                                                CKEDITOR.NODE_ELEMENT : CKEDITOR.NODE_TEXT );
+                                };
+
+                                var currentElement;
+                                walker.guard = function( node, movingOut )
+                                {
+                                        // Stop when we're shrink in element mode while encountering a text node.
+                                        if( mode == CKEDITOR.SHRINK_ELEMENT && node.type == CKEDITOR.NODE_TEXT )
+                                                return false;
+
+                                        // Stop when we've already walked "through" an element.
+                                        if ( movingOut && node.equals( currentElement ) )
+                                                return false;
+
+                                        if ( !movingOut && node.type == CKEDITOR.NODE_ELEMENT )
+                                                currentElement = node;
+                                };
+
+                                if( moveStart )
+                                {
+                                        var textStart = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastForward' : 'next']();
+                                        textStart && this.setStartBefore( textStart );
+                                }
+
+                                if( moveEnd )
+                                {
+                                        walker.reset();
+                                        var textEnd = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastBackward' : 'previous']();
+                                        textEnd && this.setEndAfter( textEnd );
+                                }
+
+                                return !!( moveStart || moveEnd );
+                        }
+                },
+
+                /**
                  * Inserts a node at the start of the range. The range will be expanded
                  * the contain the node.
                  */
@@ -1733 +1827 @@
 CKEDITOR.START = 1;
 CKEDITOR.END = 2;
 CKEDITOR.STARTEND = 3;
+
+CKEDITOR.SHRINK_ELEMENT = 1;
+CKEDITOR.SHRINK_TEXT = 2;
+

_source/core/dom/walker.js

@@ -101 +101 @@
                                                 node = null;
                                 }
                                 else
-                                        node = ( guard ( node ) === false ) ?
+                                        node = ( guard ( node, true ) === false ) ?
                                                 null : node.getPreviousSourceNode( true, type, guard );
                         }
                         else
@@ -115 +115 @@
                                                 node = null;
                                 }
                                 else
-                                        node = ( guard ( range.startContainer ) === false ) ?
+                                        node = ( guard ( range.startContainer, true ) === false ) ?
                                                 null : range.startContainer.getNextSourceNode( true, type, guard ) ;
                         }
                 }