Ticket #2976: 2976.patch

File 2976.patch, 7.1 KB (added by Garry Yao, 11 years ago)
  • _source/plugins/styles/plugin.js

     
    512512                var bookmark = range.createBookmark( true ),
    513513                        startNode = range.document.getById( bookmark.startNode );
    514514
    515                 if ( range.collapsed )
     515
     516                var endNode = range.document.getById( bookmark.endNode ),
     517                        me = this;
     518
     519                /*
     520                 * Find out the style ancestor that needs to be broken down at startNode
     521                 * and endNode.
     522                 */
     523                function breakNodes()
    516524                {
    517                         /*
    518                          * If the range is collapsed, try to remove the style from all ancestor
    519                          * elements, until a block boundary is reached.
    520                          */
    521                         var startPath = new CKEDITOR.dom.elementPath( startNode.getParent() );
    522                         for ( var i = 0, element ; i < startPath.elements.length && ( element = startPath.elements[i] ) ; i++ )
     525                        var startPath = new CKEDITOR.dom.elementPath( startNode.getParent() ),
     526                                endPath = endNode?
     527                                        new CKEDITOR.dom.elementPath( endNode.getParent() ) : null,
     528                                breakStart = null,
     529                                breakEnd = null;
     530                        for ( var i = 0 ; i < startPath.elements.length ; i++ )
    523531                        {
     532                                var element = startPath.elements[ i ];
     533
    524534                                if ( element == startPath.block || element == startPath.blockLimit )
    525535                                        break;
    526536
    527                                 if ( this.checkElementRemovable( element ) )
    528                                 {
    529                                         /*
    530                                          * Before removing the style node, there may be a sibling to the style node
    531                                          * that's exactly the same to the one to be removed. To the user, it makes
    532                                          * no difference that they're separate entities in the DOM tree. So, merge
    533                                          * them before removal.
    534                                          */
    535                                         mergeSiblings( element );
    536                                         removeFromElement( this, element );
    537                                 }
     537                                if ( me.checkElementRemovable( element ) )
     538                                        breakStart = element;
    538539                        }
    539                 }
    540                 else
    541                 {
    542                         /*
    543                          * Now our range isn't collapsed. Lets walk from the start node to the end
    544                          * node via DFS and remove the styles one-by-one.
    545                          */
    546                         var endNode = range.document.getById( bookmark.endNode ),
    547                                 me = this;
    548 
    549                         /*
    550                          * Find out the style ancestor that needs to be broken down at startNode
    551                          * and endNode.
    552                          */
    553                         function breakNodes()
     540                       
     541                        for ( i = 0 ; endPath && ( i < endPath.elements.length ) ; i++ )
    554542                        {
    555                                 var startPath = new CKEDITOR.dom.elementPath( startNode.getParent() ),
    556                                         endPath = new CKEDITOR.dom.elementPath( endNode.getParent() ),
    557                                         breakStart = null,
    558                                         breakEnd = null;
    559                                 for ( var i = 0 ; i < startPath.elements.length ; i++ )
    560                                 {
    561                                         var element = startPath.elements[ i ];
     543                                element = endPath.elements[ i ];
    562544
    563                                         if ( element == startPath.block || element == startPath.blockLimit )
    564                                                 break;
    565 
    566                                         if ( me.checkElementRemovable( element ) )
    567                                                 breakStart = element;
    568                                 }
    569                                 for ( i = 0 ; i < endPath.elements.length ; i++ )
    570                                 {
    571                                         element = endPath.elements[ i ];
     545                                if ( element == endPath.block || element == endPath.blockLimit )
     546                                        break;
    572547
    573                                         if ( element == endPath.block || element == endPath.blockLimit )
    574                                                 break;
     548                                if ( me.checkElementRemovable( element ) )
     549                                        breakEnd = element;
     550                        }
    575551
    576                                         if ( me.checkElementRemovable( element ) )
    577                                                 breakEnd = element;
     552                        if ( breakEnd )
     553                                endNode.breakParent( breakEnd );
     554                        if ( breakStart )
     555                        {
     556                                startNode.breakParent( breakStart );
     557                                // Here it's necessary to repair the broken node if nothing inputed.
     558                                if ( range.collapsed )
     559                                {
     560                                        var checkingNode = startNode.getNext();
     561                                       
     562                                        // Merge the broken nodes once after selection change OR before switch mode.
     563                                        function fixBroken( ev ){
     564                                                var sel = ev.editor.getSelection();
     565                                                sel.lock();
     566                                                mergeElements( checkingNode, checkingNode.getPrevious() );
     567                                                sel.unlock();
     568                                                ev.removeListener();
     569                                        }
     570                                        setTimeout( function(){
     571                                                var editor = CKEDITOR.currentInstance;
     572                                                editor.on( 'selectionChange', fixBroken );
     573                                                editor.on( 'unloadMode', fixBroken );
     574                                        }, 100 );
    578575                                }
    579 
    580                                 if ( breakEnd )
    581                                         endNode.breakParent( breakEnd );
    582                                 if ( breakStart )
    583                                         startNode.breakParent( breakStart );
    584576                        }
    585                         breakNodes();
     577                }
     578                breakNodes();
    586579
    587                         // Now, do the DFS walk.
    588                         var currentNode = startNode.getNext();
    589                         while ( !currentNode.equals( endNode ) )
     580                // If the range is not collapsed, DFS walk forward to remove any conflicting styles.
     581                var currentNode = startNode.getNext();
     582                while ( endNode && !currentNode.equals( endNode ) )
     583                {
     584                        /*
     585                         * Need to get the next node first because removeFromElement() can remove
     586                         * the current node from DOM tree.
     587                         */
     588                        var nextNode = currentNode.getNextSourceNode();
     589                        if ( currentNode.type == CKEDITOR.NODE_ELEMENT && this.checkElementRemovable( currentNode ) )
    590590                        {
     591                                // Remove style from element or overriding element.
     592                                if( currentNode.getName() == this.element )
     593                                        removeFromElement( this, currentNode );
     594                                else   
     595                                        removeOverrides( currentNode, getOverrides( this )[ currentNode.getName() ] );
     596
    591597                                /*
    592                                  * Need to get the next node first because removeFromElement() can remove
    593                                  * the current node from DOM tree.
     598                                 * removeFromElement() may have merged the next node with something before
     599                                 * the startNode via mergeSiblings(). In that case, the nextNode would
     600                                 * contain startNode and we'll have to call breakNodes() again and also
     601                                 * reassign the nextNode to something after startNode.
    594602                                 */
    595                                 var nextNode = currentNode.getNextSourceNode();
    596                                 if ( currentNode.type == CKEDITOR.NODE_ELEMENT && this.checkElementRemovable( currentNode ) )
     603                                if ( nextNode.type == CKEDITOR.NODE_ELEMENT && nextNode.contains( startNode ) )
    597604                                {
    598                                         // Remove style from element or overriding element.
    599                                         if( currentNode.getName() == this.element )
    600                                                 removeFromElement( this, currentNode );
    601                                         else   
    602                                                 removeOverrides( currentNode, getOverrides( this )[ currentNode.getName() ] );
    603 
    604                                         /*
    605                                          * removeFromElement() may have merged the next node with something before
    606                                          * the startNode via mergeSiblings(). In that case, the nextNode would
    607                                          * contain startNode and we'll have to call breakNodes() again and also
    608                                          * reassign the nextNode to something after startNode.
    609                                          */
    610                                         if ( nextNode.type == CKEDITOR.NODE_ELEMENT && nextNode.contains( startNode ) )
    611                                         {
    612                                                 breakNodes();
    613                                                 nextNode = startNode.getNext();
    614                                         }
     605                                        breakNodes();
     606                                        nextNode = startNode.getNext();
    615607                                }
    616                                 currentNode = nextNode;
    617608                        }
     609                        currentNode = nextNode;
    618610                }
    619 
     611       
    620612                range.moveToBookmark( bookmark );
    621613        }
    622614
  • _source/plugins/editingblock/plugin.js

     
    166166                                return;
    167167
    168168                        var currentMode = getMode( this );
     169                        this.fire( 'unloadMode', currentMode );
    169170                        data = currentMode.getData();
    170171                        currentMode.unload( holderElement );
    171172                        this.mode = '';
© 2003 – 2019 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy