Changeset 6496


Ignore:
Timestamp:
02/25/2011 02:08:00 PM (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