Changeset 6496


Ignore:
Timestamp:
02/25/11 14:08:00 (4 years ago)
Author:
garry.yao
Message:

#7006: Make it possible to indentation a whole table or list.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • CKEditor/branches/features/v4-domiterator/_source/plugins/indent/plugin.js

    r6473 r6496  
    1 /* 
     1/* 
    22Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved. 
    33For licensing, see LICENSE.html or http://ckeditor.com/license 
     
    1111{ 
    1212        var listNodeNames = { ol : 1, ul : 1 }, 
     13                applicable = { table:1, ul:1, ol:1, blockquote:1, div:1 }, 
    1314                isNotWhitespaces = CKEDITOR.dom.walker.whitespaces( true ), 
    1415                isNotBookmark = CKEDITOR.dom.walker.bookmark( false, true ); 
     
    7879        function isListItem( node ) 
    7980        { 
    80                 return node.type = CKEDITOR.NODE_ELEMENT && node.is( 'li' ); 
     81                return node.type == CKEDITOR.NODE_ELEMENT && node.is( 'li' ); 
    8182        } 
    8283 
     
    8687                        var self = this, database = {}; 
    8788 
    88                         function indentList( listNode ) 
    89                         { 
    90                                 // Our starting and ending points of the range might be inside some blocks under a list item... 
    91                                 // So before playing with the iterator, we need to expand the block to include the list items. 
    92                                 var startContainer = range.startContainer, 
     89                        function indentList( listNode, range ) 
     90                        { 
     91                                var startContainer, endContainer; 
     92 
     93                                if ( range ) 
     94                                { 
     95                                        startContainer = range.startContainer; 
    9396                                        endContainer = range.endContainer; 
    94                                 while ( startContainer && !startContainer.getParent().equals( listNode ) ) 
    95                                         startContainer = startContainer.getParent(); 
    96                                 while ( endContainer && !endContainer.getParent().equals( listNode ) ) 
    97                                         endContainer = endContainer.getParent(); 
     97                                        while ( startContainer && !startContainer.getParent().equals( listNode ) ) 
     98                                                startContainer = startContainer.getParent(); 
     99                                        while ( endContainer && !endContainer.getParent().equals( listNode ) ) 
     100                                                endContainer = endContainer.getParent(); 
     101                                } 
     102                                else 
     103                                { 
     104                                        startContainer = listNode.getFirst( isListItem ); 
     105                                        endContainer = listNode.getLast( isListItem ); 
     106                                } 
    98107 
    99108                                if ( !startContainer || !endContainer ) 
     
    102111                                // Now we can iterate over the individual items on the same tree depth. 
    103112                                var block = startContainer, 
    104                                         itemsToMove = [], 
    105                                         stopFlag = false; 
     113                                                itemsToMove = [], 
     114                                                stopFlag = false; 
    106115                                while ( !stopFlag ) 
    107116                                { 
     
    119128                                // ancestor node that is still a list. 
    120129                                var listParents = listNode.getParents( true ); 
    121                                 for ( var i = 0 ; i < listParents.length ; i++ ) 
     130                                for ( var i = 0; i < listParents.length; i++ ) 
    122131                                { 
    123132                                        if ( listParents[i].getName && listNodeNames[ listParents[i].getName() ] ) 
     
    128137                                } 
    129138                                var indentOffset = self.name == 'indent' ? 1 : -1, 
    130                                         startItem = itemsToMove[0], 
    131                                         lastItem = itemsToMove[ itemsToMove.length - 1 ]; 
     139                                                startItem = itemsToMove[0], 
     140                                                lastItem = itemsToMove[ itemsToMove.length - 1 ]; 
    132141 
    133142                                // Convert the list DOM tree into a one dimensional array. 
     
    144153                                } 
    145154 
    146                                 for ( i = lastItem.getCustomData( 'listarray_index' ) + 1 ; 
    147                                                 i < listArray.length && listArray[i].indent > baseIndent ; i++ ) 
     155                                for ( i = lastItem.getCustomData( 'listarray_index' ) + 1; 
     156                                      i < listArray.length && listArray[i].indent > baseIndent; i++ ) 
    148157                                        listArray[i].indent += indentOffset; 
    149158 
     
    160169                                        { 
    161170                                                var children = newList.listNode.getChildren(), 
    162                                                         pendingLis = [], 
    163                                                         count = children.count(), 
    164                                                         child; 
    165  
    166                                                 for ( i = count - 1 ; i >= 0 ; i-- ) 
     171                                                                pendingLis = [], 
     172                                                                count = children.count(), 
     173                                                                child; 
     174 
     175                                                for ( i = count - 1; i >= 0; i-- ) 
    167176                                                { 
    168                                                         if ( ( child = children.getItem( i ) ) && child.is && child.is( 'li' )  ) 
     177                                                        if ( ( child = children.getItem( i ) ) && child.is && child.is( 'li' ) ) 
    169178                                                                pendingLis.push( child ); 
    170179                                                } 
     
    178187                                if ( pendingLis && pendingLis.length ) 
    179188                                { 
    180                                         for (  i = 0; i < pendingLis.length ; i++ ) 
     189                                        for ( i = 0; i < pendingLis.length; i++ ) 
    181190                                        { 
    182191                                                var li = pendingLis[ i ], 
    183                                                         followingList = li; 
     192                                                                followingList = li; 
    184193 
    185194                                                // Nest preceding <ul>/<ol> inside current <li> if any. 
    186195                                                while ( ( followingList = followingList.getNext() ) && 
    187                                                            followingList.is && 
    188                                                            followingList.getName() in listNodeNames ) 
     196                                                                followingList.is && 
     197                                                                followingList.getName() in listNodeNames ) 
    189198                                                { 
    190199                                                        // IE requires a filler NBSP for nested list inside empty list item, 
    191200                                                        // otherwise the list item will be inaccessiable. (#4476) 
    192                                                         if ( CKEDITOR.env.ie && !li.getFirst( function( node ){ return isNotWhitespaces( node ) && isNotBookmark( node ); } ) ) 
     201                                                        if ( CKEDITOR.env.ie && !li.getFirst( function( node ) 
     202                                                                                              { 
     203                                                                                                      return isNotWhitespaces( node ) && isNotBookmark( node ); 
     204                                                                                              } ) ) 
    193205                                                                li.append( range.document.createText( '\u00a0' ) ); 
    194206 
     
    199211                                        } 
    200212                                } 
    201                         } 
    202  
    203                         function indentBlock() 
    204                         { 
    205                                 var iterator = range.createIterator(), 
    206                                         enterMode = editor.config.enterMode; 
    207                                 iterator.enforceRealBlocks = true; 
    208                                 iterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR; 
    209                                 var block; 
    210                                 while ( ( block = iterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) ) 
    211                                         indentElement( block ); 
    212213                        } 
    213214 
     
    236237 
    237238                                        if ( indentStep < 0 ) 
    238                                                 return false; 
     239                                        { 
     240                                                if ( element.getName() in listNodeNames ) 
     241                                                        indentList( element ); 
     242                                                else 
     243                                                        return false; 
     244                                        } 
    239245 
    240246                                        indentStep = Math.min( indentStep, editor.config.indentClasses.length ); 
     
    254260 
    255261                                        if ( currentOffset < 0 ) 
    256                                                 return false; 
     262                                        { 
     263                                                if ( element.getName() in listNodeNames ) 
     264                                                        indentList( element ); 
     265                                                else 
     266                                                        return false; 
     267                                        } 
    257268 
    258269                                        currentOffset = Math.max( currentOffset, 0 ); 
     
    326337                                        // Only do that for indenting or when using indent classes or when there is something to outdent. (#6141) 
    327338                                        if ( !( indentWholeList && 
    328                                                 ( self.name == 'indent' || self.useIndentClasses || parseInt( nearestListBlock.getStyle( getIndentCssProperty( nearestListBlock ) ), 10 ) ) && 
     339                                                        ( self.name == 'indent' || self.useIndentClasses || parseInt( nearestListBlock.getStyle( getIndentCssProperty( nearestListBlock ) ), 10 ) ) && 
    329340                                                        indentElement( nearestListBlock, !hasMultipleItems && firstListItem.getDirection() ) ) ) 
    330                                                                 indentList( nearestListBlock ); 
     341                                                                indentList( nearestListBlock, range ); 
    331342                                } 
    332343                                else 
    333                                         indentBlock(); 
     344                                { 
     345                                        var blockIterator = range.createIterator( applicable ), 
     346                                                enterMode = editor.config.enterMode, 
     347                                                block; 
     348 
     349                                        blockIterator.enlargeBr = enterMode != CKEDITOR.ENTER_BR; 
     350                                        while ( ( block = blockIterator.getNextParagraph( enterMode == CKEDITOR.ENTER_P ? 'p' : 'div' ) ) ) 
     351                                                indentElement( block ); 
     352                                } 
    334353                        } 
    335354 
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy