Ticket #2976: 2976.patch

_source/plugins/styles/plugin.js

@@ -512 +512 @@
                 var bookmark = range.createBookmark( true ),
                         startNode = range.document.getById( bookmark.startNode );
 
-                if ( range.collapsed )
+
+                var endNode = range.document.getById( bookmark.endNode ),
+                        me = this;
+
+                /*
+                 * Find out the style ancestor that needs to be broken down at startNode
+                 * and endNode.
+                 */
+                function breakNodes()
                 {
-                        /*
-                         * If the range is collapsed, try to remove the style from all ancestor
-                         * elements, until a block boundary is reached.
-                         */
-                        var startPath = new CKEDITOR.dom.elementPath( startNode.getParent() );
-                        for ( var i = 0, element ; i < startPath.elements.length && ( element = startPath.elements[i] ) ; i++ )
+                        var startPath = new CKEDITOR.dom.elementPath( startNode.getParent() ),
+                                endPath = endNode?
+                                        new CKEDITOR.dom.elementPath( endNode.getParent() ) : null,
+                                breakStart = null,
+                                breakEnd = null;
+                        for ( var i = 0 ; i < startPath.elements.length ; i++ )
                         {
+                                var element = startPath.elements[ i ];
+
                                 if ( element == startPath.block || element == startPath.blockLimit )
                                         break;
 
-                                if ( this.checkElementRemovable( element ) )
-                                {
-                                        /*
-                                         * Before removing the style node, there may be a sibling to the style node
-                                         * that's exactly the same to the one to be removed. To the user, it makes
-                                         * no difference that they're separate entities in the DOM tree. So, merge
-                                         * them before removal.
-                                         */
-                                        mergeSiblings( element );
-                                        removeFromElement( this, element );
-                                }
+                                if ( me.checkElementRemovable( element ) )
+                                        breakStart = element;
                         }
-                }
-                else
-                {
-                        /*
-                         * Now our range isn't collapsed. Lets walk from the start node to the end
-                         * node via DFS and remove the styles one-by-one.
-                         */
-                        var endNode = range.document.getById( bookmark.endNode ),
-                                me = this;
-
-                        /*
-                         * Find out the style ancestor that needs to be broken down at startNode
-                         * and endNode.
-                         */
-                        function breakNodes()
+                        
+                        for ( i = 0 ; endPath && ( i < endPath.elements.length ) ; i++ )
                         {
-                                var startPath = new CKEDITOR.dom.elementPath( startNode.getParent() ),
-                                        endPath = new CKEDITOR.dom.elementPath( endNode.getParent() ),
-                                        breakStart = null,
-                                        breakEnd = null;
-                                for ( var i = 0 ; i < startPath.elements.length ; i++ )
-                                {
-                                        var element = startPath.elements[ i ];
+                                element = endPath.elements[ i ];
 
-                                        if ( element == startPath.block || element == startPath.blockLimit )
-                                                break;
-
-                                        if ( me.checkElementRemovable( element ) )
-                                                breakStart = element;
-                                }
-                                for ( i = 0 ; i < endPath.elements.length ; i++ )
-                                {
-                                        element = endPath.elements[ i ];
+                                if ( element == endPath.block || element == endPath.blockLimit )
+                                        break;
 
-                                        if ( element == endPath.block || element == endPath.blockLimit )
-                                                break;
+                                if ( me.checkElementRemovable( element ) )
+                                        breakEnd = element;
+                        }
 
-                                        if ( me.checkElementRemovable( element ) )
-                                                breakEnd = element;
+                        if ( breakEnd )
+                                endNode.breakParent( breakEnd );
+                        if ( breakStart )
+                        {
+                                startNode.breakParent( breakStart );
+                                // Here it's necessary to repair the broken node if nothing inputed.
+                                if ( range.collapsed )
+                                {
+                                        var checkingNode = startNode.getNext();
+                                        
+                                        // Merge the broken nodes once after selection change OR before switch mode.
+                                        function fixBroken( ev ){
+                                                var sel = ev.editor.getSelection();
+                                                sel.lock();
+                                                mergeElements( checkingNode, checkingNode.getPrevious() );
+                                                sel.unlock();
+                                                ev.removeListener();
+                                        }
+                                        setTimeout( function(){
+                                                var editor = CKEDITOR.currentInstance; 
+                                                editor.on( 'selectionChange', fixBroken );
+                                                editor.on( 'unloadMode', fixBroken );
+                                        }, 100 );
                                 }
-
-                                if ( breakEnd )
-                                        endNode.breakParent( breakEnd );
-                                if ( breakStart )
-                                        startNode.breakParent( breakStart );
                         }
-                        breakNodes();
+                }
+                breakNodes();
 
-                        // Now, do the DFS walk.
-                        var currentNode = startNode.getNext();
-                        while ( !currentNode.equals( endNode ) )
+                // If the range is not collapsed, DFS walk forward to remove any conflicting styles.
+                var currentNode = startNode.getNext();
+                while ( endNode && !currentNode.equals( endNode ) )
+                {
+                        /*
+                         * Need to get the next node first because removeFromElement() can remove
+                         * the current node from DOM tree.
+                         */
+                        var nextNode = currentNode.getNextSourceNode();
+                        if ( currentNode.type == CKEDITOR.NODE_ELEMENT && this.checkElementRemovable( currentNode ) )
                         {
+                                // Remove style from element or overriding element.
+                                if( currentNode.getName() == this.element )
+                                        removeFromElement( this, currentNode );
+                                else    
+                                        removeOverrides( currentNode, getOverrides( this )[ currentNode.getName() ] );
+
                                 /*
-                                 * Need to get the next node first because removeFromElement() can remove
-                                 * the current node from DOM tree.
+                                 * removeFromElement() may have merged the next node with something before
+                                 * the startNode via mergeSiblings(). In that case, the nextNode would
+                                 * contain startNode and we'll have to call breakNodes() again and also
+                                 * reassign the nextNode to something after startNode.
                                  */
-                                var nextNode = currentNode.getNextSourceNode();
-                                if ( currentNode.type == CKEDITOR.NODE_ELEMENT && this.checkElementRemovable( currentNode ) )
+                                if ( nextNode.type == CKEDITOR.NODE_ELEMENT && nextNode.contains( startNode ) )
                                 {
-                                        // Remove style from element or overriding element.
-                                        if( currentNode.getName() == this.element )
-                                                removeFromElement( this, currentNode );
-                                        else    
-                                                removeOverrides( currentNode, getOverrides( this )[ currentNode.getName() ] );
-
-                                        /*
-                                         * removeFromElement() may have merged the next node with something before
-                                         * the startNode via mergeSiblings(). In that case, the nextNode would
-                                         * contain startNode and we'll have to call breakNodes() again and also
-                                         * reassign the nextNode to something after startNode.
-                                         */
-                                        if ( nextNode.type == CKEDITOR.NODE_ELEMENT && nextNode.contains( startNode ) )
-                                        {
-                                                breakNodes();
-                                                nextNode = startNode.getNext();
-                                        }
+                                        breakNodes();
+                                        nextNode = startNode.getNext();
                                 }
-                                currentNode = nextNode;
                         }
+                        currentNode = nextNode;
                 }
-
+        
                 range.moveToBookmark( bookmark );
         }
 

_source/plugins/editingblock/plugin.js

@@ -166 +166 @@
                                 return;
 
                         var currentMode = getMode( this );
+                        this.fire( 'unloadMode', currentMode );
                         data = currentMode.getData();
                         currentMode.unload( holderElement );
                         this.mode = '';