Ticket #4830: 4830.patch

File 4830.patch, 5.6 KB (added by Garry Yao, 10 years ago)
  • _source/plugins/selection/plugin.js

     
    730730                        if ( cache.selectedElement !== undefined )
    731731                                return cache.selectedElement;
    732732
    733                         var node;
     733                        var self = this;
    734734
    735                         if ( this.getType() == CKEDITOR.SELECTION_ELEMENT )
    736                         {
    737                                 var sel = this.getNative();
     735                        var node =
     736                                CKEDITOR.tools.tryThese(
     737                                // Is it native IE control type selection?
     738                                function()
     739                                {
     740                                        return self.getNative().createRange().item( 0 );
     741                                },
     742                                // Figure it out by checking if there's a single enclosed
     743                                // node of the range.
     744                                function()
     745                                {
     746                                        var range  = self.getRanges()[ 0 ];
     747                                        range.shrink( CKEDITOR.SHRINK_ELEMENT );
    738748
    739                                 if ( CKEDITOR.env.ie )
    740                                 {
    741                                         try
    742                                         {
    743                                                 node = sel.createRange().item(0);
     749                                        var enclosed;
     750                                        if ( range.startContainer.equals( range.endContainer )
     751                                                && ( range.endOffset - range.startOffset ) == 1
     752                                                && styleObjectElements[ ( enclosed = range.startContainer.getChild( range.startOffset ) ).getName() ] )
     753                                        {
     754                                                return enclosed.$;
    744755                                        }
    745                                         catch(e) {}
    746                                 }
    747                                 else
    748                                 {
    749                                         var range = sel.getRangeAt( 0 );
    750                                         node = range.startContainer.childNodes[ range.startOffset ];
    751                                 }
    752                         }
    753 
     756                                        else
     757                                                throw '';
     758                                });
     759                       
    754760                        return cache.selectedElement = ( node ? new CKEDITOR.dom.element( node ) : null );
    755761                },
    756762
  • _source/core/dom/range.js

     
    12361236                },
    12371237
    12381238                /**
     1239                 *  Descrease the range to make sure that boundaries
     1240                 *  always anchor beside text nodes or innermost element.
     1241                 * @param {Number} mode  ( CKEDITOR.SHRINK_ELEMENT | CKEDITOR.SHRINK_TEXT ) The shrinking mode.
     1242                 */
     1243                shrink : function( mode )
     1244                {
     1245                        !mode && ( mode = CKEDITOR.SHRINK_TEXT );
     1246
     1247                        // Unable to shrink a collapsed range.
     1248                        if( this.collapsed )
     1249                                return false;
     1250                        else
     1251                        {
     1252                                var walkerRange = this.clone();
     1253
     1254                                var startContainer = this.startContainer,
     1255                                        endContainer = this.endContainer,
     1256                                        startOffset = this.startOffset,
     1257                                        endOffset = this.endOffset,
     1258                                        collapsed = this.collapsed;
     1259
     1260                                // Whether the start/end boundary is moveable.
     1261                                var moveStart = 1,
     1262                                                moveEnd = 1;
     1263
     1264                                if ( startContainer && startContainer.type == CKEDITOR.NODE_TEXT )
     1265                                {
     1266                                        if ( !startOffset )
     1267                                                walkerRange.setStartBefore( startContainer );
     1268                                        else if ( startOffset >= startContainer.getLength( ) )
     1269                                                walkerRange.setStartAfter( startContainer );
     1270                                        else
     1271                                        {
     1272                                                // Enlarge the range properly to avoid walker making
     1273                                                // DOM changes caused by triming the text nodes later.
     1274                                                walkerRange.setStartBefore( startContainer );
     1275                                                moveStart = 0;
     1276                                        }
     1277                                }
     1278                               
     1279                                if ( endContainer && endContainer.type == CKEDITOR.NODE_TEXT )
     1280                                {
     1281                                        if ( !endOffset )
     1282                                                walkerRange.setEndBefore( endContainer );
     1283                                        else if ( endOffset >= endContainer.getLength( ) )
     1284                                                walkerRange.setEndAfter( endContainer );
     1285                                        else
     1286                                        {
     1287                                                walkerRange.setEndAfter( endContainer );
     1288                                                moveEnd = 0;
     1289                                        }
     1290                                }
     1291
     1292                                var walker = new CKEDITOR.dom.walker( walkerRange );
     1293
     1294                                walker.evaluator = function( node )
     1295                                {
     1296                                        return node.type == ( mode == CKEDITOR.SHRINK_ELEMENT ?
     1297                                                CKEDITOR.NODE_ELEMENT : CKEDITOR.NODE_TEXT );
     1298                                };
     1299
     1300                                var currentElement;
     1301                                walker.guard = function( node, movingOut )
     1302                                {
     1303                                        // Stop when we're shrink in element mode while encountering a text node.
     1304                                        if( mode == CKEDITOR.SHRINK_ELEMENT && node.type == CKEDITOR.NODE_TEXT )
     1305                                                return false;
     1306
     1307                                        // Stop when we've already walked "through" an element.
     1308                                        if ( movingOut && node.equals( currentElement ) )
     1309                                                return false;
     1310
     1311                                        if ( !movingOut && node.type == CKEDITOR.NODE_ELEMENT )
     1312                                                currentElement = node;
     1313                                };
     1314
     1315                                if( moveStart )
     1316                                {
     1317                                        var textStart = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastForward' : 'next']();
     1318                                        textStart && this.setStartBefore( textStart );
     1319                                }
     1320
     1321                                if( moveEnd )
     1322                                {
     1323                                        walker.reset();
     1324                                        var textEnd = walker[ mode == CKEDITOR.SHRINK_ELEMENT ? 'lastBackward' : 'previous']();
     1325                                        textEnd && this.setEndAfter( textEnd );
     1326                                }
     1327
     1328                                return !!( moveStart || moveEnd );
     1329                        }
     1330                },
     1331
     1332                /**
    12391333                 * Inserts a node at the start of the range. The range will be expanded
    12401334                 * the contain the node.
    12411335                 */
     
    17331827CKEDITOR.START = 1;
    17341828CKEDITOR.END = 2;
    17351829CKEDITOR.STARTEND = 3;
     1830
     1831CKEDITOR.SHRINK_ELEMENT = 1;
     1832CKEDITOR.SHRINK_TEXT = 2;
     1833
  • _source/core/dom/walker.js

     
    101101                                                node = null;
    102102                                }
    103103                                else
    104                                         node = ( guard ( node ) === false ) ?
     104                                        node = ( guard ( node, true ) === false ) ?
    105105                                                null : node.getPreviousSourceNode( true, type, guard );
    106106                        }
    107107                        else
     
    115115                                                node = null;
    116116                                }
    117117                                else
    118                                         node = ( guard ( range.startContainer ) === false ) ?
     118                                        node = ( guard ( range.startContainer, true ) === false ) ?
    119119                                                null : range.startContainer.getNextSourceNode( true, type, guard ) ;
    120120                        }
    121121                }
© 2003 – 2019 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy