Ticket #3188: 3188_2.patch

_source/core/htmlparser/element.js

@@ -124 +124 @@
                                         if ( !( element = filter.onElement( element ) ) )
                                                 return;
 
-                                        if ( element.name == writeName )
+                                        // Element already get serialized.
+                                        if ( typeof element == 'string')
+                                        {
+                                                writer.write( element );
+                                                return;
+                                        }
+                                        else if ( element.name == writeName )
                                                 break;
 
                                         writeName = element.name;

_source/plugins/styles/plugin.js

@@ -623 +623 @@
 
         function applyBlockStyle( range )
         {
-                // Bookmark the range so we can re-select it after processing.
-                var bookmark = range.createBookmark();
+                // Creating serialiable bookmarks to re-select ranges later.
+                var bookmark = range.createBookmark( true );
 
                 var iterator = range.createIterator();
                 iterator.enforceRealBlocks = true;
@@ -635 +635 @@
 
                 while( ( block = iterator.getNextParagraph() ) )                // Only one =
                 {
-                        // Create the new node right before the current one.
                         var newBlock = getElement( this, doc );
+                        replaceBlock( block, newBlock, doc );
+                }
 
-                        // Check if we are changing from/to <pre>.
-//                      var newBlockIsPre       = newBlock.nodeName.IEquals( 'pre' );
-//                      var blockIsPre          = block.nodeName.IEquals( 'pre' );
+                range.moveToBookmark( bookmark );
+        }
+
+        // Replace the orignal block with new one, also contains special treatment
+        // for <pre> blocks is needed, which makes it possible to switch forth and
+        // back to <p>, with format well preserved, and merging/splitting adjacent
+        // when necessary.(#3188)
+        function replaceBlock( block, newBlock, document )
+        {
+                // Create the new node right before the current one.
+                // Check if we are changing from/to <pre>.
+                var newBlockIsPre       = newBlock.is( 'pre' );
+                var blockIsPre          = block.is( 'pre' );
 
-//                      var toPre       = newBlockIsPre && !blockIsPre;
-//                      var fromPre     = !newBlockIsPre && blockIsPre;
+                var isToPre     = newBlockIsPre && !blockIsPre;
+                var isFromPre   = !newBlockIsPre && blockIsPre;
 
-                        // Move everything from the current node to the new one.
-//                      if ( toPre )
-//                              newBlock = this._ToPre( doc, block, newBlock );
-//                      else if ( fromPre )
-//                              newBlock = this._FromPre( doc, block, newBlock );
-//                      else    // Convering from a regular block to another regular block.
-                                block.moveChildren( newBlock );
+                // Move everything from the current node to the new one.
+                if ( isToPre )
+                        newBlock = toPre( block, newBlock, document );
+                else if ( isFromPre )
+                        newBlock = fromPre( block, newBlock );
 
-                        // Replace the current block.
-                        newBlock.insertBefore( block );
-                        block.remove();
-
-                        // Complete other tasks after inserting the node in the DOM.
-//                      if ( newBlockIsPre )
-//                      {
-//                              if ( previousPreBlock )
-//                                      this._CheckAndMergePre( previousPreBlock, newBlock ) ;  // Merge successive <pre> blocks.
-//                              previousPreBlock = newBlock;
-//                      }
-//                      else if ( fromPre )
-//                              this._CheckAndSplitPre( newBlock ) ;    // Split <br><br> in successive <pre>s.
-                }
+                newBlock.replace( block );
+                if ( newBlockIsPre )
+                        // Merge successive <pre> blocks.
+                        mergePre( newBlock );
+                else if ( isFromPre )
+                        // Split <br><br> in successive <pre>s.
+                        splitIntoBlocks( newBlock, document );
+                
+        };
+
+        /**
+         * Merge a <pre> block with a previous sibling if available.
+         */
+        function mergePre( preBlock )
+        {
+                var previousBlock;
+                if ( !( ( previousBlock = preBlock.getPreviousSourceNode( true, CKEDITOR.NODE_ELEMENT ) )
+                                 && previousBlock.is
+                                 && previousBlock.is( 'pre') ) )
+                        return;
+
+                // Merge the previous <pre> block contents into the current <pre>
+                // block.
+                //
+                // Another thing to be careful here is that currentBlock might contain
+                // a '\n' at the beginning, and previousBlock might contain a '\n'
+                // towards the end. These new lines are not normally displayed but they
+                // become visible after merging.
+                var mergedHtml = previousBlock.getHtml().replace( /\n$/, '' ) + '\n\n' +
+                                preBlock.getHtml().replace( /^\n/, '' ) ;
+
+                // Krugle: IE normalizes innerHTML from <pre>, breaking whitespaces.
+                if ( CKEDITOR.env.ie )
+                        preBlock.$.outerHTML = '<pre>' + mergedHtml + '</pre>';
+                else
+                        preBlock.setHtml( mergedHtml );
+
+                previousBlock.remove();
+        }
 
-                range.moveToBookmark( bookmark );
-        }
+        function splitIntoBlocks( newBlock, doc )
+        {
+                var duoBrRegex = /(:?<br\b[^>]*>)\s*(:?<br\b[^>]*>)/gi,
+                        blockName = newBlock.getName(),
+                        splitedHtml = newBlock.getOuterHtml().replace(
+                                duoBrRegex, function()
+                                        {
+                                          return '</' + blockName + '>' + '<' + blockName + '>';
+                                        }
+                                );
 
+                var temp = doc.createElement( 'div' );
+                temp.setHtml( splitedHtml );
+                temp.replace( newBlock );
+                temp.remove( true );
+        }
+
+        /**
+         * Converting from a PRE block to a non-PRE block in formatting operations.
+         */
+        function fromPre( block, newBlock )
+        {
+                var blockHtml = block.getHtml();
+
+                // Trim the first and last linebreaks immediately after and before <pre>, </pre>,
+                // if they exist.
+                // This is done because the linebreaks are not rendered.
+                blockHtml = blockHtml.replace( /(\r\n|\r)/g, '\n' ) ;
+                blockHtml = blockHtml.replace( /^[ \t]*\n/, '' ) ;
+                blockHtml = blockHtml.replace( /\n$/, '' ) ;
+
+                // 1. Convert spaces or tabs at the beginning or at the end to &nbsp;
+                blockHtml = blockHtml.replace( /^[ \t]+|[ \t]+$/g, function( match, offset, s )
+                                {
+                                        if ( match.length == 1 )        // one space, preserve it
+                                                return '&nbsp;' ;
+                                        else if ( offset == 0 )         // beginning of block
+                                                return new Array( match.length ).join( '&nbsp;' ) + ' ' ;
+                                        else                            // end of block
+                                                return ' ' + new Array( match.length ).join( '&nbsp;' ) ;
+                                } ) ;
+
+                // 2. Convert \n to <BR>.
+                // 3. Convert contiguous (i.e. non-singular) spaces or tabs to &nbsp;
+                blockHtml = blockHtml.replace( /\n/g, '<br>' ) ;
+                blockHtml = blockHtml.replace( /[ \t]{2,}/g,
+                                function ( match )
+                                {
+                                        return new Array( match.length ).join( '&nbsp;' ) + ' ' ;
+                                } ) ;
+                newBlock.setHtml( blockHtml );
+                return newBlock ;
+        }
+
+        /**
+         * Converting from a non-PRE block to a PRE block in formatting operations.
+         */
+        function toPre( block, newBlock, document )
+        {
+                // Handle converting from a regular block to a <pre> block.
+                var preHtml = CKEDITOR.tools.trim( block.getHtml() );
+
+                // 1. Delete ANSI whitespaces immediately before and after <BR> because
+                //    they are not visible.
+                // 2. Mark down any <BR /> nodes here so they can be turned into \n in
+                //    the next step and avoid being compressed.
+                preHtml = preHtml.replace( /[ \t\r\n]*(<br[^>]*>)[ \t\r\n]*/gi, '$1' );
+                // 3. Compress other ANSI whitespaces since they're only visible as one
+                //    single space previously.
+                // 4. Convert &nbsp; to spaces since &nbsp; is no longer needed in <PRE>.
+                preHtml = preHtml.replace( /([ \t\n\r]+|&nbsp;)/g, ' ' );
+                // 5. Convert any <BR /> to \n. This must not be done earlier because
+                //    the \n would then get compressed.
+                preHtml = preHtml.replace( /<br\b[^>]*>/gi, '\n' );
+
+                // Krugle: IE normalizes innerHTML to <pre>, breaking whitespaces.
+                if ( CKEDITOR.env.ie )
+                {
+                        var temp = document.createElement( 'div' );
+                        temp.append( newBlock );
+                        newBlock.$.outerHTML =  '<pre>\n' + preHtml + '</pre>';
+                        newBlock = temp.getFirst().remove();
+                }
+                else
+                        newBlock.setHtml( preHtml );
+
+                return newBlock;
+        }
+
         // Removes a style from an element itself, don't care about its subtree.
         function removeFromElement( style, element )
         {

_source/core/htmlparser/text.js

@@ -19 +18 @@
                  * @type String
                  * @example
                  */
-                this.value = value.replace( spacesRegex, ' ' );
+                this.value = value;
 
                 /** @private */
                 this._ =

_source/core/htmlparser/filter.js

@@ -87 +87 @@
                                                 if ( ret === false )
                                                         return null;
 
+                                                // Element might been transformed into text node.
+                                                if( ret && ret.type == CKEDITOR.NODE_TEXT )
+                                                        return this.onText( ret.value );
+                                                
                                                 if ( ret && ret != element )
                                                         return this.onElement( ret );
                                         }

_source/plugins/htmldataprocessor/plugin.js

@@ -43 +43 @@
 
                         elements :
                         {
+                                br : function( element )
+                                {
+                                        // Gecko had been replacing all linebreaks into <br>s, which
+                                        // are required to be restored here.
+                                        if ( element.parent.name == 'pre' )
+                                                element =  new CKEDITOR.htmlParser.text( '\n' );
+                                        return element;
+                                },
+
                                 embed : function( element )
                                 {
                                         var parent = element.parent;
@@ -129 +138 @@
         CKEDITOR.htmlDataProcessor = function()
         {
                 this.writer = new CKEDITOR.htmlWriter();
+                // Disable indentation on <pre>.
+                this.writer.setRules( 'pre',
+                {
+                  indent: false
+                } );
                 this.dataFilter = new CKEDITOR.htmlParser.filter();
                 this.htmlFilter = new CKEDITOR.htmlParser.filter();
         };