Index: _source/plugins/styles/plugin.js
===================================================================
--- _source/plugins/styles/plugin.js	(revision 3488)
+++ _source/plugins/styles/plugin.js	(working copy)
@@ -519,109 +519,101 @@
 		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 ( element == endPath.block || element == endPath.blockLimit )
+					break;
 
-					if ( me.checkElementRemovable( element ) )
-						breakStart = element;
-				}
-				for ( i = 0 ; i < endPath.elements.length ; i++ )
-				{
-					element = endPath.elements[ i ];
+				if ( me.checkElementRemovable( element ) )
+					breakEnd = element;
+			}
 
-					if ( element == endPath.block || element == endPath.blockLimit )
-						break;
-
-					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 );