Ticket #4650: 4650_2.patch

_source/plugins/link/plugin.js

@@ -98 +98 @@
                 // If the "contextmenu" plugin is loaded, register the listeners.
                 if ( editor.contextMenu )
                 {
-                        editor.contextMenu.addListener( function( element, selection )
+                        editor.contextMenu.addListener( function( startElement, selection )
                                 {
+                                        var element = selection.getSelectedElement();
+                                        
                                         if ( !element )
                                                 return null;
 

_source/plugins/selection/plugin.js

@@ -625 +625 @@
                                                 {
                                                         range.optimize();
 
-                                                        // Decrease the range content to exclude particial
-                                                        // selected node on the start which doesn't have
-                                                        // visual impact. ( #3231 )
-                                                        while( true )
-                                                        {
-                                                                var startContainer = range.startContainer,
-                                                                        startOffset = range.startOffset;
-                                                                // Limit the fix only to non-block elements.(#3950)
-                                                                if ( startOffset == ( startContainer.getChildCount ?
-                                                                         startContainer.getChildCount() : startContainer.getLength() )
-                                                                         && !startContainer.isBlockBoundary() )
-                                                                        range.setStartAfter( startContainer );
-                                                                else break;
-                                                        }
-
                                                         node = range.startContainer;
 
                                                         if ( node.type != CKEDITOR.NODE_ELEMENT )
@@ -695 +680 @@
                         if ( cache.selectedElement !== undefined )
                                 return cache.selectedElement;
 
-                        var node;
+                        var node,
+                        type = this.getType();
 
-                        if ( this.getType() == CKEDITOR.SELECTION_ELEMENT )
+                        if ( type == CKEDITOR.SELECTION_ELEMENT )
                         {
                                 var sel = this.getNative();
 
@@ -714 +700 @@
                                         var range = sel.getRangeAt( 0 );
                                         node = range.startContainer.childNodes[ range.startOffset ];
                                 }
+
+                                node = new CKEDITOR.dom.element( node );
                         }
+                        // Somtimes browser lies on selection type (e.g. text[<img />]), figure it
+                        // out by further checking the range. 
+                        else if ( type == CKEDITOR.SELECTION_TEXT )
+                        {
+                                var range = this.getRanges()[ 0 ];
+                                range.optimize();
+                                var selectedStartNode = range.getTouchedStartNode(),
+                                        selectedEndNode = range.getTouchedEndNode();
 
-                        return cache.selectedElement = ( node ? new CKEDITOR.dom.element( node ) : null );
+                                if ( selectedStartNode.equals( selectedEndNode ) )
+                                        node = selectedEndNode;
+                        }
+
+                        return ( cache.selectedElement = node && node.type == CKEDITOR.NODE_ELEMENT  ? node : null );
                 },
 
                 lock : function()
                 {
                         // Call all cacheable function.
-                        this.getRanges();
-                        this.getStartElement();
                         this.getSelectedElement();
+                        this.getStartElement();
+                        this.getRanges();
 
                         // The native selection is not available when locked.
                         this._.cache.nativeSel = {};

_source/core/dom/range.js

@@ -666 +666 @@
                 },
 
                 /**
-                 * Transforms the startContainer and endContainer properties from text
-                 * nodes to element nodes, whenever possible. This is actually possible
-                 * if either of the boundary containers point to a text node, and its
-                 * offset is set to zero, or after the last char in the node.
+                 * Perform structural changes to the range which don't have visual impacts..
+                 * <ul>
+                 * <li>Transforms the  start/end containers from text nodes to element nodes,
+                 * whenever possible. This will happen if either of the boundary containers
+                 * point to a text node, and its offset is set to zero, or after the last char in the node.</li>
+                 * <li>Shrink either the start boundary which is at the end of  any inline elements,
+                 * or the end boundary which is at the front of  line elements, by moving
+                 * range container out of them util any block-level element are met.</li>
                  */
                 optimize : function()
                 {
@@ -682 +686 @@
                                         this.setStartBefore( container );
                                 else if ( offset >= container.getLength() )
                                         this.setStartAfter( container );
+
+                                this.optimize();
                         }
+                        else
+                        {
+                                // Decrease the range content to exclude particial
+                                // selected node on the start which doesn't have
+                                // visual impact. ( #3231 )
+                                while( true )
+                                {
+                                        // Limit the fix only to non-block elements.(#3950)
+                                        if ( offset == container.getChildCount()
+                                                 && !container.isBlockBoundary() )
+                                                this.setStartAfter( container );
+                                        else break;
 
+                                        container = this.startContainer;
+                                        offset = this.startOffset;
+                                }
+                        }
+
                         container = this.endContainer;
                         offset = this.endOffset;
 
@@ -693 +716 @@
                                         this.setEndBefore( container );
                                 else if ( offset >= container.getLength() )
                                         this.setEndAfter( container );
+
+                                this.optimize();
                         }
+                        else
+                        {
+                                while( true )
+                                {
+                                        if ( offset == 0
+                                                 && !container.isBlockBoundary() )
+                                                this.setStartBefore( container );
+                                        else break;
+
+                                        container = this.startContainer;
+                                        offset = this.startOffset;
+                                }
+                        }
                 },
 
                 /**