_source/core/dom/node.js

   1 /*\r
   2 Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.\r
   3 For licensing, see LICENSE.html or http://ckeditor.com/license\r
   4 */\r
   5 \r
   6 /**\r
   7  * @fileOverview Defines the {@link CKEDITOR.dom.node} class, which is the base\r
   8  *              class for classes that represent DOM nodes.\r
   9  */\r
  10 \r
  11 /**\r
  12  * Base class for classes representing DOM nodes. This constructor may return\r
  13  * and instance of classes that inherits this class, like\r
  14  * {@link CKEDITOR.dom.element} or {@link CKEDITOR.dom.text}.\r
  15  * @augments CKEDITOR.dom.domObject\r
  16  * @param {Object} domNode A native DOM node.\r
  17  * @constructor\r
  18  * @see CKEDITOR.dom.element\r
  19  * @see CKEDITOR.dom.text\r
  20  * @example\r
  21  */\r
  22 CKEDITOR.dom.node = function( domNode )\r
  23 {\r
  24         if ( domNode )\r
  25         {\r
  26                 switch ( domNode.nodeType )\r
  27                 {\r
  28                         case CKEDITOR.NODE_ELEMENT :\r
  29                                 return new CKEDITOR.dom.element( domNode );\r
  30 \r
  31                         case CKEDITOR.NODE_TEXT :\r
  32                                 return new CKEDITOR.dom.text( domNode );\r
  33                 }\r
  34 \r
  35                 // Call the base constructor.\r
  36                 CKEDITOR.dom.domObject.call( this, domNode );\r
  37         }\r
  38 \r
  39         return this;\r
  40 };\r
  41 \r
  42 CKEDITOR.dom.node.prototype = new CKEDITOR.dom.domObject();\r
  43 \r
  44 /**\r
  45  * Element node type.\r
  46  * @constant\r
  47  * @example\r
  48  */\r
  49 CKEDITOR.NODE_ELEMENT = 1;\r
  50 \r
  51 /**\r
  52  * Text node type.\r
  53  * @constant\r
  54  * @example\r
  55  */\r
  56 CKEDITOR.NODE_TEXT = 3;\r
  57 \r
  58 /**\r
  59  * Comment node type.\r
  60  * @constant\r
  61  * @example\r
  62  */\r
  63 CKEDITOR.NODE_COMMENT = 8;\r
  64 \r
  65 CKEDITOR.NODE_DOCUMENT_FRAGMENT = 11;\r
  66 \r
  67 CKEDITOR.POSITION_IDENTICAL = 0;\r
  68 CKEDITOR.POSITION_DISCONNECTED = 1;\r
  69 CKEDITOR.POSITION_FOLLOWING = 2;\r
  70 CKEDITOR.POSITION_PRECEDING = 4;\r
  71 CKEDITOR.POSITION_IS_CONTAINED = 8;\r
  72 CKEDITOR.POSITION_CONTAINS = 16;\r
  73 \r
  74 CKEDITOR.tools.extend( CKEDITOR.dom.node.prototype,\r
  75         /** @lends CKEDITOR.dom.node.prototype */\r
  76         {\r
  77                 /**\r
  78                  * Makes this node child of another element.\r
  79                  * @param {CKEDITOR.dom.element} element The target element to which append\r
  80                  *              this node.\r
  81                  * @returns {CKEDITOR.dom.element} The target element.\r
  82                  * @example\r
  83                  * var p = new CKEDITOR.dom.element( 'p' );\r
  84                  * var strong = new CKEDITOR.dom.element( 'strong' );\r
  85                  * strong.appendTo( p );\r
  86                  *\r
  87                  * // result: "&lt;p&gt;&lt;strong&gt;&lt;/strong&gt;&lt;/p&gt;"\r
  88                  */\r
  89                 appendTo : function( element, toStart )\r
  90                 {\r
  91                         element.append( this, toStart );\r
  92                         return element;\r
  93                 },\r
  94 \r
  95                 clone : function( includeChildren, cloneId )\r
  96                 {\r
  97                         var $clone = this.$.cloneNode( includeChildren );\r
  98 \r
  99                         if ( !cloneId )\r
 100                         {\r
 101                                 var removeIds = function( node )\r
 102                                 {\r
 103                                         if ( node.nodeType != CKEDITOR.NODE_ELEMENT )\r
 104                                                 return;\r
 105 \r
 106                                         node.removeAttribute( 'id', false ) ;\r
 107                                         node.removeAttribute( '_cke_expando', false ) ;\r
 108 \r
 109                                         var childs = node.childNodes;\r
 110                                         for ( var i=0 ; i < childs.length ; i++ )\r
 111                                                 removeIds( childs[ i ] );\r
 112                                 };\r
 113 \r
 114                                 // The "id" attribute should never be cloned to avoid duplication.\r
 115                                 removeIds( $clone );\r
 116                         }\r
 117 \r
 118                         return new CKEDITOR.dom.node( $clone );\r
 119                 },\r
 120 \r
 121                 hasPrevious : function()\r
 122                 {\r
 123                         return !!this.$.previousSibling;\r
 124                 },\r
 125 \r
 126                 hasNext : function()\r
 127                 {\r
 128                         return !!this.$.nextSibling;\r
 129                 },\r
 130 \r
 131                 /**\r
 132                  * Inserts this element after a node.\r
 133                  * @param {CKEDITOR.dom.node} node The that will preceed this element.\r
 134                  * @returns {CKEDITOR.dom.node} The node preceeding this one after\r
 135                  *              insertion.\r
 136                  * @example\r
 137                  * var em = new CKEDITOR.dom.element( 'em' );\r
 138                  * var strong = new CKEDITOR.dom.element( 'strong' );\r
 139                  * strong.insertAfter( em );\r
 140                  *\r
 141                  * // result: "&lt;em&gt;&lt;/em&gt;&lt;strong&gt;&lt;/strong&gt;"\r
 142                  */\r
 143                 insertAfter : function( node )\r
 144                 {\r
 145                         node.$.parentNode.insertBefore( this.$, node.$.nextSibling );\r
 146                         return node;\r
 147                 },\r
 148 \r
 149                 /**\r
 150                  * Inserts this element before a node.\r
 151                  * @param {CKEDITOR.dom.node} node The that will be after this element.\r
 152                  * @returns {CKEDITOR.dom.node} The node being inserted.\r
 153                  * @example\r
 154                  * var em = new CKEDITOR.dom.element( 'em' );\r
 155                  * var strong = new CKEDITOR.dom.element( 'strong' );\r
 156                  * strong.insertBefore( em );\r
 157                  *\r
 158                  * // result: "&lt;strong&gt;&lt;/strong&gt;&lt;em&gt;&lt;/em&gt;"\r
 159                  */\r
 160                 insertBefore : function( node )\r
 161                 {\r
 162                         node.$.parentNode.insertBefore( this.$, node.$ );\r
 163                         return node;\r
 164                 },\r
 165 \r
 166                 insertBeforeMe : function( node )\r
 167                 {\r
 168                         this.$.parentNode.insertBefore( node.$, this.$ );\r
 169                         return node;\r
 170                 },\r
 171 \r
 172                 /**\r
 173                  * Retrieves a uniquely identifiable tree address for this node.\r
 174                  * The tree address returns is an array of integers, with each integer\r
 175                  * indicating a child index of a DOM node, starting from\r
 176                  * document.documentElement.\r
 177                  *\r
 178                  * For example, assuming <body> is the second child from <html> (<head>\r
 179                  * being the first), and we'd like to address the third child under the\r
 180                  * fourth child of body, the tree address returned would be:\r
 181                  * [1, 3, 2]\r
 182                  *\r
 183                  * The tree address cannot be used for finding back the DOM tree node once\r
 184                  * the DOM tree structure has been modified.\r
 185                  */\r
 186                 getAddress : function( normalized )\r
 187                 {\r
 188                         var address = [];\r
 189                         var $documentElement = this.getDocument().$.documentElement;\r
 190                         var node = this.$;\r
 191 \r
 192                         while ( node && node != $documentElement )\r
 193                         {\r
 194                                 var parentNode = node.parentNode;\r
 195                                 var currentIndex = -1;\r
 196 \r
 197                                 for ( var i = 0 ; i < parentNode.childNodes.length ; i++ )\r
 198                                 {\r
 199                                         var candidate = parentNode.childNodes[i];\r
 200 \r
 201                                         if ( normalized &&\r
 202                                                         candidate.nodeType == 3 &&\r
 203                                                         candidate.previousSibling &&\r
 204                                                         candidate.previousSibling.nodeType == 3 )\r
 205                                         {\r
 206                                                 continue;\r
 207                                         }\r
 208 \r
 209                                         currentIndex++;\r
 210 \r
 211                                         if ( candidate == node )\r
 212                                                 break;\r
 213                                 }\r
 214 \r
 215                                 address.unshift( currentIndex );\r
 216 \r
 217                                 node = node.parentNode;\r
 218                         }\r
 219 \r
 220                         return address;\r
 221                 },\r
 222 \r
 223                 /**\r
 224                  * Gets the document containing this element.\r
 225                  * @returns {CKEDITOR.dom.document} The document.\r
 226                  * @example\r
 227                  * var element = CKEDITOR.document.getById( 'example' );\r
 228                  * alert( <b>element.getDocument().equals( CKEDITOR.document )</b> );  // "true"\r
 229                  */\r
 230                 getDocument : function()\r
 231                 {\r
 232                         var document = new CKEDITOR.dom.document( this.$.ownerDocument || this.$.parentNode.ownerDocument );\r
 233 \r
 234                         return (\r
 235                         /** @ignore */\r
 236                         this.getDocument = function()\r
 237                                 {\r
 238                                         return document;\r
 239                                 })();\r
 240                 },\r
 241 \r
 242                 getIndex : function()\r
 243                 {\r
 244                         var $ = this.$;\r
 245 \r
 246                         var currentNode = $.parentNode && $.parentNode.firstChild;\r
 247                         var currentIndex = -1;\r
 248 \r
 249                         while ( currentNode )\r
 250                         {\r
 251                                 currentIndex++;\r
 252 \r
 253                                 if ( currentNode == $ )\r
 254                                         return currentIndex;\r
 255 \r
 256                                 currentNode = currentNode.nextSibling;\r
 257                         }\r
 258 \r
 259                         return -1;\r
 260                 },\r
 261 \r
 262                 getNextSourceNode : function( startFromSibling, nodeType, guard )\r
 263                 {\r
 264                         // If "guard" is a node, transform it in a function.\r
 265                         if ( guard && !guard.call )\r
 266                         {\r
 267                                 var guardNode = guard;\r
 268                                 guard = function( node )\r
 269                                 {\r
 270                                         return !node.equals( guardNode );\r
 271                                 };\r
 272                         }\r
 273 \r
 274                         var node = ( !startFromSibling && this.getFirst && this.getFirst() ),\r
 275                                 parent;\r
 276 \r
 277                         // Guarding when we're skipping the current element( no children or 'startFromSibling' ).\r
 278                         // send the 'moving out' signal even we don't actually dive into.\r
 279                         if ( !node )\r
 280                         {\r
 281                                 if ( this.type == CKEDITOR.NODE_ELEMENT && guard && guard( this, true ) === false )\r
 282                                         return null;\r
 283                                 node = this.getNext();\r
 284                         }\r
 285 \r
 286                         while ( !node && ( parent = ( parent || this ).getParent() ) )\r
 287                         {\r
 288                                 // The guard check sends the "true" paramenter to indicate that\r
 289                                 // we are moving "out" of the element.\r
 290                                 if ( guard && guard( parent, true ) === false )\r
 291                                         return null;\r
 292 \r
 293                                 node = parent.getNext();\r
 294                         }\r
 295 \r
 296                         if ( !node )\r
 297                                 return null;\r
 298 \r
 299                         if ( guard && guard( node ) === false )\r
 300                                 return null;\r
 301 \r
 302                         if ( nodeType && nodeType != node.type )\r
 303                                 return node.getNextSourceNode( false, nodeType, guard );\r
 304 \r
 305                         return node;\r
 306                 },\r
 307 \r
 308                 getPreviousSourceNode : function( startFromSibling, nodeType, guard )\r
 309                 {\r
 310                         if ( guard && !guard.call )\r
 311                         {\r
 312                                 var guardNode = guard;\r
 313                                 guard = function( node )\r
 314                                 {\r
 315                                         return !node.equals( guardNode );\r
 316                                 };\r
 317                         }\r
 318 \r
 319                         var node = ( !startFromSibling && this.getLast && this.getLast() ),\r
 320                                 parent;\r
 321 \r
 322                         // Guarding when we're skipping the current element( no children or 'startFromSibling' ).\r
 323                         // send the 'moving out' signal even we don't actually dive into.\r
 324                         if ( !node )\r
 325                         {\r
 326                                 if ( this.type == CKEDITOR.NODE_ELEMENT && guard && guard( this, true ) === false )\r
 327                                         return null;\r
 328                                 node = this.getPrevious();\r
 329                         }\r
 330 \r
 331                         while ( !node && ( parent = ( parent || this ).getParent() ) )\r
 332                         {\r
 333                                 // The guard check sends the "true" paramenter to indicate that\r
 334                                 // we are moving "out" of the element.\r
 335                                 if ( guard && guard( parent, true ) === false )\r
 336                                         return null;\r
 337 \r
 338                                 node = parent.getPrevious();\r
 339                         }\r
 340 \r
 341                         if ( !node )\r
 342                                 return null;\r
 343 \r
 344                         if ( guard && guard( node ) === false )\r
 345                                 return null;\r
 346 \r
 347                         if ( nodeType && node.type != nodeType )\r
 348                                 return node.getPreviousSourceNode( false, nodeType, guard );\r
 349 \r
 350                         return node;\r
 351                 },\r
 352 \r
 353                 getPrevious : function( evaluator )\r
 354                 {\r
 355                         var previous = this.$, retval;\r
 356                         do\r
 357                         {\r
 358                                 previous = previous.previousSibling;\r
 359                                 retval = previous && new CKEDITOR.dom.node( previous );\r
 360                         }\r
 361                         while ( retval && evaluator && !evaluator( retval ) )\r
 362                         return retval;\r
 363                 },\r
 364 \r
 365                 /**\r
 366                  * Gets the node that follows this element in its parent's child list.\r
 367                  * @param {Function} evaluator Filtering the result node.\r
 368                  * @returns {CKEDITOR.dom.node} The next node or null if not available.\r
 369                  * @example\r
 370                  * var element = CKEDITOR.dom.element.createFromHtml( '&lt;div&gt;&lt;b&gt;Example&lt;/b&gt; &lt;i&gt;next&lt;/i&gt;&lt;/div&gt;' );\r
 371                  * var first = <b>element.getFirst().getNext()</b>;\r
 372                  * alert( first.getName() );  // "i"\r
 373                  */\r
 374                 getNext : function( evaluator )\r
 375                 {\r
 376                         var next = this.$, retval;\r
 377                         do\r
 378                         {\r
 379                                 next = next.nextSibling;\r
 380                                 retval = next && new CKEDITOR.dom.node( next );\r
 381                         }\r
 382                         while ( retval && evaluator && !evaluator( retval ) )\r
 383                         return retval;\r
 384                 },\r
 385 \r
 386                 /**\r
 387                  * Gets the parent element for this node.\r
 388                  * @returns {CKEDITOR.dom.element} The parent element.\r
 389                  * @example\r
 390                  * var node = editor.document.getBody().getFirst();\r
 391                  * var parent = node.<b>getParent()</b>;\r
 392                  * alert( node.getName() );  // "body"\r
 393                  */\r
 394                 getParent : function()\r
 395                 {\r
 396                         var parent = this.$.parentNode;\r
 397                         return ( parent && parent.nodeType == 1 ) ? new CKEDITOR.dom.node( parent ) : null;\r
 398                 },\r
 399 \r
 400                 getParents : function( closerFirst )\r
 401                 {\r
 402                         var node = this;\r
 403                         var parents = [];\r
 404 \r
 405                         do\r
 406                         {\r
 407                                 parents[  closerFirst ? 'push' : 'unshift' ]( node );\r
 408                         }\r
 409                         while ( ( node = node.getParent() ) )\r
 410 \r
 411                         return parents;\r
 412                 },\r
 413 \r
 414                 getCommonAncestor : function( node )\r
 415                 {\r
 416                         if ( node.equals( this ) )\r
 417                                 return this;\r
 418 \r
 419                         if ( node.contains && node.contains( this ) )\r
 420                                 return node;\r
 421 \r
 422                         var start = this.contains ? this : this.getParent();\r
 423 \r
 424                         do\r
 425                         {\r
 426                                 if ( start.contains( node ) )\r
 427                                         return start;\r
 428                         }\r
 429                         while ( ( start = start.getParent() ) );\r
 430 \r
 431                         return null;\r
 432                 },\r
 433 \r
 434                 getPosition : function( otherNode )\r
 435                 {\r
 436                         var $ = this.$;\r
 437                         var $other = otherNode.$;\r
 438 \r
 439                         if ( $.compareDocumentPosition )\r
 440                                 return $.compareDocumentPosition( $other );\r
 441 \r
 442                         // IE and Safari have no support for compareDocumentPosition.\r
 443 \r
 444                         if ( $ == $other )\r
 445                                 return CKEDITOR.POSITION_IDENTICAL;\r
 446 \r
 447                         // Only element nodes support contains and sourceIndex.\r
 448                         if ( this.type == CKEDITOR.NODE_ELEMENT && otherNode.type == CKEDITOR.NODE_ELEMENT )\r
 449                         {\r
 450                                 if ( $.contains )\r
 451                                 {\r
 452                                         if ( $.contains( $other ) )\r
 453                                                 return CKEDITOR.POSITION_CONTAINS + CKEDITOR.POSITION_PRECEDING;\r
 454 \r
 455                                         if ( $other.contains( $ ) )\r
 456                                                 return CKEDITOR.POSITION_IS_CONTAINED + CKEDITOR.POSITION_FOLLOWING;\r
 457                                 }\r
 458 \r
 459                                 if ( 'sourceIndex' in $ )\r
 460                                 {\r
 461                                         return ( $.sourceIndex < 0 || $other.sourceIndex < 0 ) ? CKEDITOR.POSITION_DISCONNECTED :\r
 462                                                 ( $.sourceIndex < $other.sourceIndex ) ? CKEDITOR.POSITION_PRECEDING :\r
 463                                                 CKEDITOR.POSITION_FOLLOWING;\r
 464                                 }\r
 465                         }\r
 466 \r
 467                         // For nodes that don't support compareDocumentPosition, contains\r
 468                         // or sourceIndex, their "address" is compared.\r
 469 \r
 470                         var addressOfThis = this.getAddress(),\r
 471                                 addressOfOther = otherNode.getAddress(),\r
 472                                 minLevel = Math.min( addressOfThis.length, addressOfOther.length );\r
 473 \r
 474                                 // Determinate preceed/follow relationship.\r
 475                                 for ( var i = 0 ; i <= minLevel - 1 ; i++ )\r
 476                                 {\r
 477                                         if ( addressOfThis[ i ] != addressOfOther[ i ] )\r
 478                                         {\r
 479                                                 if ( i < minLevel )\r
 480                                                 {\r
 481                                                         return addressOfThis[ i ] < addressOfOther[ i ] ?\r
 482                                                             CKEDITOR.POSITION_PRECEDING : CKEDITOR.POSITION_FOLLOWING;\r
 483                                                 }\r
 484                                                 break;\r
 485                                         }\r
 486                                 }\r
 487 \r
 488                                 // Determinate contains/contained relationship.\r
 489                                 return ( addressOfThis.length < addressOfOther.length ) ?\r
 490                                                         CKEDITOR.POSITION_CONTAINS + CKEDITOR.POSITION_PRECEDING :\r
 491                                                         CKEDITOR.POSITION_IS_CONTAINED + CKEDITOR.POSITION_FOLLOWING;\r
 492                 },\r
 493 \r
 494                 /**\r
 495                  * Gets the closes ancestor node of a specified node name.\r
 496                  * @param {String} name Node name of ancestor node.\r
 497                  * @param {Boolean} includeSelf (Optional) Whether to include the current\r
 498                  * node in the calculation or not.\r
 499                  * @returns {CKEDITOR.dom.node} Ancestor node.\r
 500                  */\r
 501                 getAscendant : function( name, includeSelf )\r
 502                 {\r
 503                         var $ = this.$;\r
 504 \r
 505                         if ( !includeSelf )\r
 506                                 $ = $.parentNode;\r
 507 \r
 508                         while ( $ )\r
 509                         {\r
 510                                 if ( $.nodeName && $.nodeName.toLowerCase() == name )\r
 511                                         return new CKEDITOR.dom.node( $ );\r
 512 \r
 513                                 $ = $.parentNode;\r
 514                         }\r
 515                         return null;\r
 516                 },\r
 517 \r
 518                 hasAscendant : function( name, includeSelf )\r
 519                 {\r
 520                         var $ = this.$;\r
 521 \r
 522                         if ( !includeSelf )\r
 523                                 $ = $.parentNode;\r
 524 \r
 525                         while ( $ )\r
 526                         {\r
 527                                 if ( $.nodeName && $.nodeName.toLowerCase() == name )\r
 528                                         return true;\r
 529 \r
 530                                 $ = $.parentNode;\r
 531                         }\r
 532                         return false;\r
 533                 },\r
 534 \r
 535                 move : function( target, toStart )\r
 536                 {\r
 537                         target.append( this.remove(), toStart );\r
 538                 },\r
 539 \r
 540                 /**\r
 541                  * Removes this node from the document DOM.\r
 542                  * @param {Boolean} [preserveChildren] Indicates that the children\r
 543                  *              elements must remain in the document, removing only the outer\r
 544                  *              tags.\r
 545                  * @example\r
 546                  * var element = CKEDITOR.dom.element.getById( 'MyElement' );\r
 547                  * <b>element.remove()</b>;\r
 548                  */\r
 549                 remove : function( preserveChildren )\r
 550                 {\r
 551                         var $ = this.$;\r
 552                         var parent = $.parentNode;\r
 553 \r
 554                         if ( parent )\r
 555                         {\r
 556                                 if ( preserveChildren )\r
 557                                 {\r
 558                                         // Move all children before the node.\r
 559                                         for ( var child ; ( child = $.firstChild ) ; )\r
 560                                         {\r
 561                                                 parent.insertBefore( $.removeChild( child ), $ );\r
 562                                         }\r
 563                                 }\r
 564 \r
 565                                 parent.removeChild( $ );\r
 566                         }\r
 567 \r
 568                         return this;\r
 569                 },\r
 570 \r
 571                 replace : function( nodeToReplace )\r
 572                 {\r
 573                         this.insertBefore( nodeToReplace );\r
 574                         nodeToReplace.remove();\r
 575                 },\r
 576 \r
 577                 trim : function()\r
 578                 {\r
 579                         this.ltrim();\r
 580                         this.rtrim();\r
 581                 },\r
 582 \r
 583                 ltrim : function()\r
 584                 {\r
 585                         var child;\r
 586                         while ( this.getFirst && ( child = this.getFirst() ) )\r
 587                         {\r
 588                                 if ( child.type == CKEDITOR.NODE_TEXT )\r
 589                                 {\r
 590                                         var trimmed = CKEDITOR.tools.ltrim( child.getText() ),\r
 591                                                 originalLength = child.getLength();\r
 592 \r
 593                                         if ( !trimmed )\r
 594                                         {\r
 595                                                 child.remove();\r
 596                                                 continue;\r
 597                                         }\r
 598                                         else if ( trimmed.length < originalLength )\r
 599                                         {\r
 600                                                 child.split( originalLength - trimmed.length );\r
 601 \r
 602                                                 // IE BUG: child.remove() may raise JavaScript errors here. (#81)\r
 603                                                 this.$.removeChild( this.$.firstChild );\r
 604                                         }\r
 605                                 }\r
 606                                 break;\r
 607                         }\r
 608                 },\r
 609 \r
 610                 rtrim : function()\r
 611                 {\r
 612                         var child;\r
 613                         while ( this.getLast && ( child = this.getLast() ) )\r
 614                         {\r
 615                                 if ( child.type == CKEDITOR.NODE_TEXT )\r
 616                                 {\r
 617                                         var trimmed = CKEDITOR.tools.rtrim( child.getText() ),\r
 618                                                 originalLength = child.getLength();\r
 619 \r
 620                                         if ( !trimmed )\r
 621                                         {\r
 622                                                 child.remove();\r
 623                                                 continue;\r
 624                                         }\r
 625                                         else if ( trimmed.length < originalLength )\r
 626                                         {\r
 627                                                 child.split( trimmed.length );\r
 628 \r
 629                                                 // IE BUG: child.getNext().remove() may raise JavaScript errors here.\r
 630                                                 // (#81)\r
 631                                                 this.$.lastChild.parentNode.removeChild( this.$.lastChild );\r
 632                                         }\r
 633                                 }\r
 634                                 break;\r
 635                         }\r
 636 \r
 637                         if ( !CKEDITOR.env.ie && !CKEDITOR.env.opera )\r
 638                         {\r
 639                                 child = this.$.lastChild;\r
 640 \r
 641                                 if ( child && child.type == 1 && child.nodeName.toLowerCase() == 'br' )\r
 642                                 {\r
 643                                         // Use "eChildNode.parentNode" instead of "node" to avoid IE bug (#324).\r
 644                                         child.parentNode.removeChild( child ) ;\r
 645                                 }\r
 646                         }\r
 647                 }\r
 648         }\r
 649 );\r