Ticket #2767: 2767.patch

_source/core/tools.js

@@ -310 +310 @@
                                 return i;
                 }
                 return -1;
+        },
+        
+        /**
+         * Find the deep-most common ancestor of a set of dom nodes.
+         * Note: This method will never failed to found DCA since 'body' tag always there.
+         * @param {Array}
+         *            nodes The target set of nodes
+         * @return {CKEDITOR.dom.node} The DCA result 
+         */
+        getDCAOfNodes : function ( nodes )
+        {
+                var range , currentDCA;
+
+                while ( nodes.length > 1 )
+                {
+                        range = new CKEDITOR.dom.range();
+                        range.startContainer = nodes[ 0 ];
+                        range.endContainer = nodes[ 1 ];
+                        currentDCA = range.getCommonAncestor( false );
+                        if ( currentDCA.getName() === 'body' )
+                                return currentDCA;
+                        else
+                                nodes.splice( 0 , 2 , [ currentDCA ] );
+                }
+                return nodes[ 0 ];
         }
 };
 

_source/core/dom/text.js

@@ -97 +97 @@
                                 return this.$.nodeValue.substr( indexA );
                         else
                                 return this.$.nodeValue.substring( indexA, indexB );
+                },
+                /**
+                 * Whether this text node contain nothing but spaces.
+                 * @return {Boolean}
+                 */
+                isEmpty : function ( )
+                {
+                        return CKEDITOR.tools.trim( this.getText() ).length === 0
                 }
         });

_source/plugins/elementspath/plugin.js

@@ -53 +53 @@
                         editor.on( 'selectionChange', function( ev )
                                 {
                                         var env = CKEDITOR.env;
-
-                                        var selection = ev.data.selection;
-
-                                        var element = selection.getStartElement(),
+                                        
+                                        //The root node of this selection
+                                        var root = ev.data.selection.getSelectionRootNode(),
                                                 html = [],
                                                 elementsList = this._.elementsPath.list = [];
 
-                                        while ( element )
+                                        while ( root )
                                         {
-                                                var index = elementsList.push( element ) - 1;
+                                                var index = elementsList.push( root ) - 1;
                                                 var name;
-                                                if ( element.getAttribute( '_cke_real_element_type' ) )
-                                                        name = element.getAttribute( '_cke_real_element_type' );
+                                                if ( root.getAttribute( '_cke_real_element_type' ) )
+                                                        name = root.getAttribute( '_cke_real_element_type' );
                                                 else
-                                                        name = element.getName();
+                                                        name = root.getName();
 
                                                 // Use this variable to add conditional stuff to the
                                                 // HTML (because we are doing it in reverse order... unshift).
@@ -99 +98 @@
                                                 if ( name == 'body' )
                                                         break;
 
-                                                element = element.getParent();
+                                                root = root.getParent();
                                         }
 
                                         getSpaceElement().setHtml( html.join('') );

_source/plugins/selection/plugin.js

@@ -21 +21 @@
                 var firstElement = sel.getStartElement();
                 var currentPath = new CKEDITOR.dom.elementPath( firstElement );
 
-                if ( !currentPath.compare( this._.selectionPreviousPath ) )
-                {
-                        this._.selectionPreviousPath = currentPath;
-                        this.fire( 'selectionChange', { selection : sel, path : currentPath, element : firstElement } );
-                }
+                this._.selectionPreviousPath = currentPath;
+                this.fire( 'selectionChange', { selection : sel, path : currentPath, element : firstElement } );
         };
 
         var checkSelectionChangeTimer;
@@ -635 +632 @@
                         }
                         this.selectRanges( ranges );
                         return this;
+                },
+                
+                /**
+                 * Get the root node of this selection, it represent the topmost node which
+                 * contain the whole range.
+                 * 
+                 * @return {CKEDITOR.dom.node} The root node of this selection
+                 */
+                getSelectionRootNode : function ( )
+                {
+                        var ranges , ancestors = [] , dca;
+                        ranges = this.getRanges();
+                        var i , l;
+
+                        if ( ranges.length == 1 && ranges[ 0 ].collapsed )
+                                return this.getStartElement();
+
+                        for ( i = 0 ; i < length ; i++ )
+                        {
+                                ancestors.push( ranges[ i ].getCommonAncestor() );
+                        }
+                        return ( dca = CKEDITOR.tools.getDCAOfNodes( ancestors ) ).type === CKEDITOR.NODE_TEXT ? dca
+                                        .getParent()
+                                        : dca;
                 }
         };
 })();

_source/plugins/styles/plugin.js

@@ -49 +49 @@
 
                                         // Check the current state for the style defined for that
                                         // callback.
-                                        var currentState = callback.style.checkActive( ev.data.path ) ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF;
+                                        var currentState = callback.style.checkSelectionStyled( ev.data.selection ) ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF;
 
                                         // If the state changed since the last check.
                                         if ( callback.state !== currentState )
@@ -152 +152 @@
                         }
                         return false;
                 },
+                
+                /**
+                 * Check whether all the ranges within the specified selection is
+                 * stained with the current style.
+                 * 
+                 * @param {CKEDITOR.dom.selection}
+                 *            selection
+                 * @return {Boolean}
+                 */
+                checkSelectionStyled : function ( selection )
+                {
+                        var i , ranges = selection.getRanges() , l = ranges.length , isStyled = true;
+                        // In search for a non-styled range
+                        for ( i = 0 ; i < l ; i++ )
+                        {
+                                if ( !this.checkRangeStyled( ranges[ i ] ) )
+                                {
+                                        isStyled = false;
+                                        break;
+                                }
+                        }
+                        // Select a collapsed range cause IE move selection to the end of
+                        // text nodes.
+                        if ( !CKEDITOR.env.ie )
+                                selection.selectRanges( ranges );
+                        return isStyled;
+                },
 
+                /**
+                 * Check whether all the text content of the specified range is stained
+                 * with the current style.
+                 * 
+                 * @param {CKEDITOR.dom.range}
+                 *            range
+                 * @return {Boolean}
+                 */
+                checkRangeStyled : function ( range )
+                {
+
+                        if ( range.collapsed )
+                                return this.checkActive( new CKEDITOR.dom.elementPath(
+                                                range.startContainer ) );
+
+                        var bookmark = range.createBookmark() , startNode = bookmark.startNode , endNode = bookmark.endNode;
+
+                        // Start from first node within range
+                        var walker = new CKEDITOR.dom.domWalker( startNode.getNextSourceNode() ) , isStyled = true , self = this;
+
+                        // DFS forward in searching for text nodes within the range.
+                        walker.forward( function ( walkerEvt )
+                        {
+                                var currentNode = walkerEvt.data.from;
+                                if ( currentNode.equals( startNode ) )
+                                        return;
+                                else if ( currentNode.equals( endNode ) )
+                                        // Stop after the end node.
+                                        this.stop();
+                                else if ( currentNode.type === CKEDITOR.NODE_TEXT
+                                                && !currentNode.isEmpty()
+                                                && !self.checkActive( new CKEDITOR.dom.elementPath(
+                                                                currentNode ) ) )
+                                // stop when we found the first non-styled non-empty text
+                                // node
+                                {
+                                        isStyled = false;
+                                        this.stop();
+                                }
+                        } );
+
+                        range.moveToBookmark( bookmark );
+                        return isStyled;
+                },
+
                 // Checks if an element, or any of its attributes, is removable by the
                 // current style definition.
                 checkElementRemovable : function( element, fullMatch )