Ticket #5309: 5309_5.patch

_source/plugins/htmldataprocessor/plugin.js

@@ -272 +272 @@
                 defaultHtmlFilterRules.elements[ i ] = unprotectReadyOnly;
         }
 
+        // Disallow structural blocks without sub nodes.   
+        var removeIfEmptyBlocks = { table:1, thead:1,tfoot:1,tbody:1, tr:1 },
+                        removeIfEmptyFilterRules = { elements : {} },
+                        removeIfEmtpyFilter = function( element ){ if ( !element.children.length ) return false; };
+
+        for ( i in removeIfEmptyBlocks )
+                removeIfEmptyFilterRules.elements[ i ] = removeIfEmtpyFilter;
+
         var protectAttributeRegex = /<((?:a|area|img|input)[\s\S]*?\s)((href|src|name)\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|(?:[^ "'>]+)))([^>]*)>/gi,
                 findSavedSrcRegex = /\s_cke_saved_src\s*=/;
 
@@ -411 +419 @@
 
                         dataProcessor.dataFilter.addRules( defaultDataFilterRules );
                         dataProcessor.dataFilter.addRules( defaultDataBlockFilterRules );
+                        dataProcessor.dataFilter.addRules( removeIfEmptyFilterRules );
                         dataProcessor.htmlFilter.addRules( defaultHtmlFilterRules );
                         dataProcessor.htmlFilter.addRules( defaultHtmlBlockFilterRules );
+                        dataProcessor.htmlFilter.addRules( removeIfEmptyFilterRules );
                 }
         });
 
@@ -427 +437 @@
 
         CKEDITOR.htmlDataProcessor.prototype =
         {
-                toHtml : function( data, fixForBody )
+                toHtml : function( data, fixForBody, clipboard )
                 {
                         // The source data is already HTML, but we need to clean
                         // it up and apply the filter.
@@ -473 +483 @@
 
                         // Now use our parser to make further fixes to the structure, as
                         // well as apply the filter.
-                        var fragment = CKEDITOR.htmlParser.fragment.fromHtml( data, fixForBody ),
+                        var fragment = CKEDITOR.htmlParser.fragment.fromHtml( data, fixForBody, clipboard ),
                                 writer = new CKEDITOR.htmlParser.basicWriter();
 
                         fragment.writeHtml( writer, this.dataFilter );

_source/core/htmlparser/cdata.js

@@ -38 +38 @@
                 writeHtml : function( writer )
                 {
                         writer.write( this.value );
+                },
+
+                toDom : function( doc )
+                {
+                        return new CKEDITOR.dom.text( this.value, doc );
                 }
         };
 })();

_source/core/dom/element.js

@@ -254 +254 @@
                 },
 
                 /**
+                 * Retrieve block element's filler node if existed.
+                 */
+                getBogus : function()
+                {
+                        if ( !this.isBlockBoundary() )
+                                return;
+
+                        var lastChild = this.getLast() ;
+
+                        // Ignore empty/spaces text.
+                        while ( lastChild && lastChild.type == CKEDITOR.NODE_TEXT && !CKEDITOR.tools.rtrim( lastChild.getText() ) )
+                                lastChild = lastChild.getPrevious();
+
+                        if ( lastChild &&
+                                ( CKEDITOR.env.ie && lastChild.type == CKEDITOR.NODE_TEXT && CKEDITOR.tools.trim( lastChild.getText() ).match( /^(?: |\xa0)$/ )
+                                ||      CKEDITOR.env.gecko && CKEDITOR.env.webkit && lastChild.is( 'br' ) ) )
+                        {
+                                return lastChild;
+                        }
+                },
+
+                /**
                  * Breaks one of the ancestor element in the element position, moving
                  * this element between the broken parts.
                  * @param {CKEDITOR.dom.element} parent The anscestor element to get broken.
@@ -721 +743 @@
                         var thisLength = thisAttribs.length,
                                 otherLength = otherAttribs.length;
 
-                        if ( !CKEDITOR.env.ie && thisLength != otherLength )
-                                return false;
-
                         for ( var i = 0 ; i < thisLength ; i++ )
                         {
                                 var attribute = thisAttribs[ i ];
 
+                                if ( attribute.nodeName == '_moz_dirty' )
+                                        continue;
+
                                 if ( ( !CKEDITOR.env.ie || ( attribute.specified && attribute.nodeName != '_cke_expando' ) ) && attribute.nodeValue != otherElement.getAttribute( attribute.nodeName ) )
                                         return false;
                         }

_source/core/htmlparser/fragment.js

@@ -8 +8 @@
  * @constructor
  * @example
  */
-CKEDITOR.htmlParser.fragment = function()
+CKEDITOR.htmlParser.fragment = function( clipboard )
 {
         /**
          * The nodes contained in the root of this fragment.
@@ -30 +30 @@
         /** @private */
         this._ =
         {
-                isBlockLike : true,
-                hasInlineStarted : false
+                isBlockLike : !clipboard,
+                hasInlineStarted : clipboard
         };
 };
 
@@ -58 +58 @@
          * alert( fragment.children[0].name );  "b"
          * alert( fragment.children[1].value );  " Text"
          */
-        CKEDITOR.htmlParser.fragment.fromHtml = function( fragmentHtml, fixForBody )
+        CKEDITOR.htmlParser.fragment.fromHtml = function( fragmentHtml, fixForBody, clipboard )
         {
                 var parser = new CKEDITOR.htmlParser(),
                         html = [],
-                        fragment = new CKEDITOR.htmlParser.fragment(),
+                        fragment = new CKEDITOR.htmlParser.fragment( clipboard ),
                         pendingInline = [],
                         pendingBRs = [],
                         currentNode = fragment,
@@ -205 +205 @@
                         var currentName = currentNode.name;
 
                         var currentDtd = currentName
-                                && ( CKEDITOR.dtd[ currentName ]
-                                        || ( currentNode._.isBlockLike ? CKEDITOR.dtd.div : CKEDITOR.dtd.span ) );
+                                &&  CKEDITOR.dtd[ currentName ]
+                                        || ( currentNode._.isBlockLike || currentNode instanceof CKEDITOR.htmlParser.fragment ? CKEDITOR.dtd.div : CKEDITOR.dtd.span );
 
                         // If the element cannot be child of the current element.
                         if ( currentDtd   // Fragment could receive any elements.
@@ -379 +379 @@
 
                         // Shrinking consequential spaces into one single for all elements
                         // text contents.
-                        if ( !inPre )
+                        if ( !( inPre || currentNode instanceof CKEDITOR.htmlParser.fragment && clipboard ) )
                                 text = text.replace( /[\t\r\n ]{2,}|[\t\r\n]/g, ' ' );
 
                         currentNode.add( new CKEDITOR.htmlParser.text( text ) );
@@ -485 +485 @@
                                 var writer = new CKEDITOR.htmlParser.basicWriter();
                                 this.writeChildrenHtml.call( this, writer, filter, true );
                                 var html = writer.getHtml();
-                                this.children = new CKEDITOR.htmlParser.fragment.fromHtml( html ).children;
+                                this.children = new CKEDITOR.htmlParser.fragment.fromHtml( html, false, true ).children;
                                 isChildrenFiltered = 1;
                         };
 
@@ -499 +499 @@
                 {
                         for ( var i = 0 ; i < this.children.length ; i++ )
                                 this.children[i].writeHtml( writer, filter );
+                },
+
+                toDom : function( doc )
+                {
+                        var fragment = new CKEDITOR.dom.documentFragment( doc );
+                        for ( var i = 0, count = this.children.length; i < count; i++ )
+                                fragment.append( this.children[ i ].toDom( doc ) );
+
+                        return fragment;
                 }
         };
 })();

_source/core/htmlparser/element.js

@@ -235 +235 @@
                         // Send children.
                         CKEDITOR.htmlParser.fragment.prototype.writeChildrenHtml.apply( this, arguments );
 
+                },
+
+                toDom : function( doc )
+                {
+                        var element = new CKEDITOR.dom.element( this.name, doc );
+                        element.setAttributes( this.attributes );
+
+                        for ( var i = 0, count = this.children.length; i < count; i++ )
+                                element.append( this.children[ i ].toDom() );
+
+                        return element;
                 }
         };
 })();

_source/plugins/pastefromword/filter/default.js

@@ -1112 +1112 @@
 
                 try
                 {
-                        data = dataProcessor.toHtml( data, false );
+                        data = dataProcessor.toHtml( data, false, true );
                 }
                 catch ( e )
                 {

_source/core/htmlparser/comment.js

@@ -56 +56 @@
                 }
 
                 writer.comment( comment );
+        },
+
+        toDom : function( doc )
+        {
+                return new CKEDITOR.dom.comment( this.value, doc );
         }
+
 };

_source/core/htmlparser/text.js

@@ -50 +50 @@
                                 return;
 
                         writer.text( text );
+                },
+
+                toDom : function( doc )
+                {
+                        if ( !CKEDITOR.tools.trim( this.value ) )
+                                return new CKEDITOR.dom.text( this.value );
+
+                        // DON'T use CKEDITOR.dom.text because of entities.
+                        return CKEDITOR.dom.element.createFromHtml( this.value );
                 }
         };
 })();

_source/plugins/wysiwygarea/plugin.js

@@ -32 +32 @@
                 {
                         this.focus();
 
-                        var selection = this.getSelection();
+                        var selection = this.getSelection(),
+                                start = selection.getStartElement(),
+                                data = evt.data;
+
                         if ( checkReadOnly( selection ) )
                                 return;
 
-                        var data = evt.data;
                         this.fire( 'saveSnapshot' );
 
-                        if ( this.dataProcessor )
-                                data = this.dataProcessor.toHtml( data );
-
+                        // Make use of the browser to perform "extractContent".
                         if ( CKEDITOR.env.ie )
-                        {
-                                var selIsLocked = selection.isLocked;
+                                selection.getNative().createRange().pasteHTML( '' );
+                        else
+                                this.document.$.execCommand( 'insertHtml', false, CKEDITOR.env.gecko? '<span _cke_bookmark=1></span>' : '' );
 
-                                if ( selIsLocked )
-                                        selection.unlock();
-
-                                var $sel = selection.getNative();
-
-                                // Delete control selections to avoid IE bugs on pasteHTML.
-                                if ( $sel.type == 'Control' )
-                                        $sel.clear();
-                                else if  ( selection.getType() == CKEDITOR.SELECTION_TEXT )
-                                {
-                                        // Due to IE bugs on handling contenteditable=false blocks
-                                        // (#6005), we need to make some checks and eventually
-                                        // delete the selection first.
-
-                                        var range = selection.getRanges()[0],
-                                                endContainer = range && range.endContainer;
+                        // Paste will happen on the collapsed result range.
+                        selection = this.getSelection();
+                        var range = selection.getRanges()[ 0 ],
+                                data = evt.data;
 
-                                        if ( endContainer &&
-                                                 endContainer.type == CKEDITOR.NODE_ELEMENT &&
-                                                 endContainer.getAttribute( 'contenteditable' ) == 'false' &&
-                                                 range.checkBoundaryOfElement( endContainer, CKEDITOR.END ) )
-                                        {
-                                                range.setEndAfter( range.endContainer );
-                                                range.deleteContents();
-                                        }
-                                }
+                        if ( this.dataProcessor )
+                                data = this.dataProcessor.toHtml( data, false, true );
 
-                                try
-                                {
-                                        $sel.createRange().pasteHTML( data );
-                                }
-                                catch (e) {}
+                        // Merge the fragile inline elements splited by Gecko.
+                        if ( CKEDITOR.env.gecko
+                                        && range.startContainer.type == CKEDITOR.NODE_ELEMENT
+                                        && range.startContainer.hasAttribute( '_cke_bookmark' ) )
+                        {
+                                var bookmark = range.startContainer,
+                                        previous = bookmark.getPrevious();
 
-                                if ( selIsLocked )
-                                        this.getSelection().lock();
-                        }
-                        else
-                                this.document.$.execCommand( 'inserthtml', false, data );
+                                if ( previous && previous.type == CKEDITOR.NODE_ELEMENT && previous.getName() in CKEDITOR.dtd.$inline )
+                                        previous.mergeSiblings();
 
-                        // Webkit does not scroll to the cursor position after pasting (#5558)
-                        if ( CKEDITOR.env.webkit )
-                        {
-                                this.document.$.execCommand( 'inserthtml', false, '<span id="cke_paste_marker" cke_temp="1"></span>' );
-                                var marker = this.document.getById( 'cke_paste_marker' );
-                                marker.scrollIntoView();
-                                marker.remove();
-                                marker = null;
+                                range.moveToBookmark( { startNode: bookmark } );
                         }
 
+                        // Paste and scroll to the end of content.
+                        range.pasteHtml( data );
+                        range.select( 1 );
+                        !CKEDITOR.env.ie && selection.scrollIntoView();
+
                         CKEDITOR.tools.setTimeout( function()
                                 {
                                         this.fire( 'saveSnapshot' );

_source/core/dom/range.js

@@ -320 +320 @@
                 return !whitespaceEval( node ) && !bookmarkEval( node );
         }
 
+
+        function collectValidChildren( element, parentName )
+        {
+                var next = element, isValid,
+                                candidates = [];
+
+                while ( ( next = next.getNextSourceNode( isValid, CKEDITOR.NODE_ELEMENT ) ) )
+                {
+                        if ( isValid = next.getName() in CKEDITOR.dtd[ parentName ] )
+                                candidates.push( next );
+                }
+
+                var fragment = new CKEDITOR.dom.documentFragment();
+                for ( var i = 0, count = candidates.length; i < count; i++ )
+                        fragment.append( candidates[ i ] );
+                return fragment;
+        }
+
+        var emptyspaces = CKEDITOR.dom.walker.whitespaces(),
+                        bookmarks = CKEDITOR.dom.walker.bookmark();
+
         CKEDITOR.dom.range.prototype =
         {
                 clone : function()
@@ -674 +695 @@
                 },
 
                 /**
+                 * Paste the give HTML at the start of the range, and replacing any previously selected nodes within the range.
+                 * Note: This method might alter the specified HTML to make it fit the given range context. For example, when pasting a table
+                 * when actually a table row is selected (a DTD violation), instead of inserting the table, it results in only the cells of the table
+                 * getting pasted into the row.
+                 * For predictable results, paste only well-formed HTML that fits at the given range context.
+                 * @param {String} html Valid HTML string to paste into the range.
+                 */
+                pasteHtml : function ( html )
+                {
+                        // Create a fragment of nodes without context that represents the structure to paste. (W3C Spec)
+                        var fragment = CKEDITOR.htmlParser.fragment.fromHtml( html, false, true ),
+                                        nodeList = fragment.children;
+
+                        if ( !this.collapsed )
+                        {
+                                // Avoid resulting in dummy element after the deletion.
+                                this.enlarge( CKEDITOR.NODE_ELEMENT );
+                                this.extractContents();
+                        }
+
+                        // Split up text node at position.
+                        if ( this.startContainer.type == CKEDITOR.NODE_TEXT )
+                                this.trim();
+
+                        // If we're at end of block, remove any bogus node, because:
+                        // 1. It's not needed any more due to the incomming content.
+                        // 2. It will get doubled (visible) if the to be inserted node is a bogus too.
+                        var block;
+                        if ( block = this.checkEndOfBlock() )
+                        {
+                                var bogus = block.getBogus();
+                                bogus && bogus.remove();
+                        }
+
+                        var targetNode, targetNodeOffset, targetName, path,
+                                updateTarget = CKEDITOR.tools.bind( function ()
+                                {
+                                        targetNode = this.startContainer,
+                                                        targetNodeOffset = this.startOffset,
+                                                        targetName = targetNode.getName();
+                                        path = new CKEDITOR.dom.elementPath( targetNode );
+                                }, this );
+
+                        updateTarget();
+                        for ( var i = 0, count = nodeList.length; i < count; i++ )
+                        {
+                                var node = nodeList[ i ],
+                                                nodeName = node.type == CKEDITOR.NODE_ELEMENT ? node.name : '#';
+
+                                // If  we have a list to insert, and we're actually standing inside a list item,
+                                // insert the appropriate children instead, in short, merge the lists
+                                // instead of pasting in a sublist.
+                                if ( nodeName in  CKEDITOR.dtd.$list
+                                        && path.block && path.block.getName() in CKEDITOR.dtd.$listItem )
+                                {
+                                        this.splitElement( path.block );
+                                        updateTarget();
+                                }
+
+                                // The to be inserted node fails DTD examination.
+                                while ( !CKEDITOR.dtd[ targetName ][ nodeName ] )
+                                {
+                                        // If the failure is caused by pasting table/list inside a table/list
+                                        // structure, instead of splitting up the element, just insert the
+                                        // appropriate children.
+                                        if ( nodeName == 'table' && targetName in { table:1, tfoot:1,thead:1,tbody:1,tr:1 }
+                                                || nodeName in { ul:1, ol:1, dl:1 } && targetName in { ul:1, ol:1, dl:1 } )
+                                        {
+                                                node = collectValidChildren( node.toDom(), targetName );
+                                                break;
+                                        }
+
+                                        //  Users are more likely want to paste content intead of the element, e.g. pre, headings.
+                                        if ( ( targetName == nodeName )
+                                                && ( nodeName == 'pre' || nodeName.match( /^h[1-6]$/ ) ) )
+                                        {
+                                                Array.prototype.splice.apply( nodeList, [ i, 1 ].concat( node.children ) );
+                                                node = nodeList[ i ];
+                                                break;
+                                        }
+
+                                        // Ok, it's our last option, split up or move out of current element.
+                                        this.splitElement( targetNode );
+                                        updateTarget();
+                                }
+
+                                var domNode = node.$ ? node : node.toDom();
+                                // Where to put the cursor?
+                                var anchorNode = domNode.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT ?
+                                                domNode.getLast() : domNode;
+
+                                this.insertNode( domNode );
+
+                                // Try to place cursor at the end of the last pasted node,
+                                // with the only exception that we should discontinue any pasted link,
+                                // If that fails, simply collapse by the end of  last node.
+                                if ( !( i == count - 1 && anchorNode.type == CKEDITOR.NODE_ELEMENT
+                                                && !anchorNode.is( 'a' ) && this.moveToElementEditEnd( anchorNode ) ) )
+                                        this.collapse();
+                        }
+                },
+
+                /**
                  * 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
@@ -874 +998 @@
                                                 {
                                                         // If we reached the common ancestor, mark the flag
                                                         // for it.
-                                                        if ( !commonReached && enlargeable.equals( commonAncestor ) )
+                                                        if ( !commonReached && ( enlargeable.contains( commonAncestor ) || enlargeable.equals( commonAncestor ) ) )
                                                                 commonReached = true;
 
                                                         if ( !body.contains( enlargeable ) )
@@ -1044 +1168 @@
                                         {
                                                 if ( enlargeable && !sibling )
                                                 {
-                                                        if ( !commonReached && enlargeable.equals( commonAncestor ) )
+                                                        if ( !commonReached && ( enlargeable.contains( commonAncestor ) || enlargeable.equals( commonAncestor ) ) )
                                                                 commonReached = true;
 
                                                         if ( !body.contains( enlargeable ) )
@@ -1361 +1485 @@
                         var startContainer = this.startContainer;
                         var startOffset = this.startOffset;
 
+                        var count = node.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT ?
+                                node.getChildren().count() : 1;
+
+                        var anchorNode = node.type == CKEDITOR.NODE_DOCUMENT_FRAGMENT ?
+                                node.getChildren().getItem( 0 ) : node;
+
                         var nextNode = startContainer.getChild( startOffset );
 
                         if ( nextNode )
@@ -1369 +1499 @@
                                 startContainer.append( node );
 
                         // Check if we need to update the end boundary.
-                        if ( node.getParent().equals( this.endContainer ) )
-                                this.endOffset++;
+                        if ( startContainer.equals( this.endContainer ) )
+                                this.endOffset += count;
 
                         // Expand the range to embrace the new node.
-                        this.setStartBefore( node );
+                        this.setStartBefore( anchorNode );
                 },
 
                 moveToPosition : function( node, position )
@@ -1628 +1758 @@
                         if ( !this.collapsed )
                                 return null;
 
+                        var testRange = this.clone(),
+                                        walker = new CKEDITOR.dom.walker( testRange );
+
+                        walker.evaluator = function( node )
+                        {
+                                return !!( emptyspaces( node ) || bookmarks( node ) );
+                        };
+
+                        testRange.setEndAfter( toSplit );
+                        if ( walker.checkForward() )
+                        {
+                                this.moveToPosition( toSplit, CKEDITOR.POSITION_AFTER_END );
+                                return null;
+                        }
+                        else
+                        {
+                                testRange = this.clone();
+                                testRange.setStartBefore( toSplit );
+                                walker.reset();
+                                walker.range = testRange;
+                                if ( walker.checkBackward() )
+                                {
+                                        this.moveToPosition( toSplit, CKEDITOR.POSITION_BEFORE_START );
+                                        return null;
+                                }
+                        }
+                                
                         // Extract the contents of the block from the selection point to the end
                         // of its contents.
                         this.setEndAt( toSplit, CKEDITOR.POSITION_BEFORE_END );
@@ -1736 +1893 @@
                         // Creates a range starting at the block start until the range start.
                         var walkerRange = this.clone();
                         walkerRange.collapse( false );
-                        walkerRange.setEndAt( path.block || path.blockLimit, CKEDITOR.POSITION_BEFORE_END );
+                        var pathBlock = path.block || path.blockLimit;
+                        walkerRange.setEndAt( pathBlock, CKEDITOR.POSITION_BEFORE_END );
 
                         var walker = new CKEDITOR.dom.walker( walkerRange );
                         walker.evaluator = getCheckStartEndBlockEvalFunction( false );
 
-                        return walker.checkForward();
+                        return walker.checkForward() && pathBlock;
                 },
 
                 /**