Changeset 190 for trunk/plugins


Ignore:
Timestamp:
05/23/05 15:12:55 (14 years ago)
Author:
gogo
Message:

Copy EP from unified_backend @ revision 172
Commented yermo's debugging

File:
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/plugins/EnterParagraphs/enter-paragraphs.js

    r189 r190  
    1515*/ 
    1616 
    17 EnterParagraphs._pluginInfo =  
     17EnterParagraphs._pluginInfo = 
    1818        { 
    1919  name          : "EnterParagraphs", 
     
    8585*/ 
    8686 
    87 function EnterParagraphs(editor)  
     87function EnterParagraphs(editor) 
    8888        { 
    8989 
     
    9191 
    9292        // [STRIP 
    93         // create a ddt debug trace object. There may be multiple editors on  
     93        // create a ddt debug trace object. There may be multiple editors on 
    9494        // the page each EnterParagraphs .. to distinguish which instance 
    9595        // is generating the message we tack on the name of the textarea. 
    9696 
    97         this.ddt = new DDT( editor._textArea + ":EnterParagraphs Plugin" ); 
     97        //this.ddt = new DDT( editor._textArea + ":EnterParagraphs Plugin" ); 
    9898 
    9999        // uncomment to turn on debugging messages. 
    100   
    101         this.ddt._ddtOn(); 
    102  
    103         this.ddt._ddt( "enter-paragraphs.js","23", "EnterParagraphs(): constructor" ); 
     100 
     101        //this.ddt._ddtOn(); 
     102 
     103        //this.ddt._ddt( "enter-paragraphs.js","23", "EnterParagraphs(): constructor" ); 
    104104 
    105105        // STRIP] 
     
    110110  if (HTMLArea.is_gecko) 
    111111                { 
    112                 this.ddt._ddt( "enter-paragraphs.js","23", "EnterParagraphs(): we are gecko. Setting event handler." ); 
     112                //this.ddt._ddt( "enter-paragraphs.js","23", "EnterParagraphs(): we are gecko. Setting event handler." ); 
    113113    this.onKeyPress = this.__onKeyPress; 
    114114                } 
     
    131131*/ 
    132132 
    133 EnterParagraphs.prototype.insertAdjacentElement = function(ref,pos,el)  
    134         { 
    135  
    136         this.ddt._ddtDumpNode( "enter-paragraphs.js", "122", "insertAdjacentElement(): top with pos '" + pos + "' ref:", ref ); 
    137         this.ddt._ddtDumpNode( "enter-paragraphs.js", "122", "insertAdjacentElement(): top with el:", el ); 
    138  
    139   if ( pos == 'BeforeBegin' )  
     133EnterParagraphs.prototype.insertAdjacentElement = function(ref,pos,el) 
     134        { 
     135 
     136        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "122", "insertAdjacentElement(): top with pos '" + pos + "' ref:", ref ); 
     137        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "122", "insertAdjacentElement(): top with el:", el ); 
     138 
     139  if ( pos == 'BeforeBegin' ) 
    140140                { 
    141141                ref.parentNode.insertBefore(el,ref); 
    142142                } 
    143   else if ( pos == 'AfterEnd' )  
     143  else if ( pos == 'AfterEnd' ) 
    144144                { 
    145145                ref.nextSibling ? ref.parentNode.insertBefore(el,ref.nextSibling) : ref.parentNode.appendChild(el); 
    146146                } 
    147   else if ( pos == 'AfterBegin' && ref.firstChild )  
     147  else if ( pos == 'AfterBegin' && ref.firstChild ) 
    148148                { 
    149149                ref.insertBefore(el,ref.firstChild); 
    150150                } 
    151   else if ( pos == 'BeforeEnd' || pos == 'AfterBegin' )  
     151  else if ( pos == 'BeforeEnd' || pos == 'AfterBegin' ) 
    152152                { 
    153153                ref.appendChild(el); 
    154154                } 
    155155 
    156         this.ddt._ddtDumpNode( "enter-paragraphs.js", "122", "insertAdjacentElement(): bottom with ref:", ref ); 
     156        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "122", "insertAdjacentElement(): bottom with ref:", ref ); 
    157157 
    158158        };      // end of insertAdjacentElement() 
     
    169169*/ 
    170170 
    171 EnterParagraphs.prototype.forEachNodeUnder = function ( root, mode, direction, init )  
    172         { 
    173  
    174         this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): top mode is '" + mode + "' direction is '" + direction + "' starting with root node:", root ); 
     171EnterParagraphs.prototype.forEachNodeUnder = function ( root, mode, direction, init ) 
     172        { 
     173 
     174        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): top mode is '" + mode + "' direction is '" + direction + "' starting with root node:", root ); 
    175175 
    176176  // Identify the first and last nodes to deal with 
    177          
     177 
    178178  var start, end; 
    179179 
    180         // nodeType 11 is DOCUMENT_FRAGMENT_NODE which is a container.  
    181  
    182   if ( root.nodeType == 11 && root.firstChild )  
     180        // nodeType 11 is DOCUMENT_FRAGMENT_NODE which is a container. 
     181 
     182  if ( root.nodeType == 11 && root.firstChild ) 
    183183                { 
    184184    start = root.firstChild; 
    185185    end = root.lastChild; 
    186           }  
    187         else  
     186          } 
     187        else 
    188188                { 
    189189                start = end = root; 
    190190                } 
    191191 
    192         this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): start node is:", start ); 
    193         this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): initial end node is:", end ); 
     192        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): start node is:", start ); 
     193        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): initial end node is:", end ); 
    194194 
    195195        // traverse down the right hand side of the tree getting the last child of the last 
    196196        // child in each level until we reach bottom. 
    197   while ( end.lastChild )  
     197  while ( end.lastChild ) 
    198198                end = end.lastChild; 
    199199 
    200         this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): end node after descent is:", end ); 
     200        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "144", "forEachNodeUnder(): end node after descent is:", end ); 
    201201 
    202202  return this.forEachNode( start, end, mode, direction, init); 
     
    216216*/ 
    217217 
    218 EnterParagraphs.prototype.forEachNode = function (left_node, right_node, mode, direction, init)  
    219         { 
    220  
    221         this.ddt._ddt( "enter-paragraphs.js", "175", "forEachNode(): top - mode is:" + mode + "' direction '" + direction + "'" ); 
    222         this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): top - left node is:", left_node ); 
    223         this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): top - right node is:", right_node ); 
     218EnterParagraphs.prototype.forEachNode = function (left_node, right_node, mode, direction, init) 
     219        { 
     220 
     221        //this.ddt._ddt( "enter-paragraphs.js", "175", "forEachNode(): top - mode is:" + mode + "' direction '" + direction + "'" ); 
     222        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): top - left node is:", left_node ); 
     223        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): top - right node is:", right_node ); 
    224224 
    225225        // returns "Brother" node either left or right. 
    226226 
    227   var getSibling = function(elem, direction)  
    228                                                         {  
    229                                                         return ( direction == "ltr" ? elem.nextSibling : elem.previousSibling );  
     227  var getSibling = function(elem, direction) 
     228                                                        { 
     229                                                        return ( direction == "ltr" ? elem.nextSibling : elem.previousSibling ); 
    230230                                                        }; 
    231231 
    232   var getChild = function(elem, direction)  
    233                                                         {  
    234                                                         return ( direction == "ltr" ? elem.firstChild : elem.lastChild );  
     232  var getChild = function(elem, direction) 
     233                                                        { 
     234                                                        return ( direction == "ltr" ? elem.firstChild : elem.lastChild ); 
    235235                                                        }; 
    236236 
    237237  var walk, lookup, fnReturnVal; 
    238238 
    239         // FIXME: init is a boolean in the emptyset case and an object in  
     239        // FIXME: init is a boolean in the emptyset case and an object in 
    240240        // the cullids case. Used inconsistently. 
    241                  
     241 
    242242        var next_node = init; 
    243243 
     
    249249        // if we're going left to right that's the right_node and visa-versa. 
    250250 
    251   while ( walk != direction == "ltr" ? right_node : left_node )  
    252                 { 
    253  
    254     // on first entry, walk here is null. So this is how  
     251  while ( walk != direction == "ltr" ? right_node : left_node ) 
     252                { 
     253 
     254    // on first entry, walk here is null. So this is how 
    255255                // we prime the loop with the first node. 
    256256 
    257     if ( !walk )  
     257    if ( !walk ) 
    258258                        { 
    259259                        walk = direction == "ltr" ? left_node : right_node; 
    260260 
    261                         this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): !walk - current node is:", walk ); 
    262                         } 
    263     else  
     261                        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): !walk - current node is:", walk ); 
     262                        } 
     263    else 
    264264                        { 
    265265 
    266266                        // is there a child node? 
    267267 
    268       if ( getChild(walk,direction) )  
     268      if ( getChild(walk,direction) ) 
    269269                                { 
    270270 
     
    273273                                walk = getChild(walk,direction); 
    274274 
    275                                 this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode():descending to child node:", walk ); 
     275                                //this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode():descending to child node:", walk ); 
    276276 
    277277                                } 
    278       else  
     278      else 
    279279                                { 
    280280 
    281281                                // is there a sibling node on this level? 
    282282 
    283         if ( getSibling(walk,direction) )  
     283        if ( getSibling(walk,direction) ) 
    284284                                        { 
    285285 
     
    288288                                        walk = getSibling(walk,direction); 
    289289 
    290                                         this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): moving to sibling node:", walk ); 
     290                                        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): moving to sibling node:", walk ); 
    291291 
    292292                                        } 
    293         else  
     293        else 
    294294                                        { 
    295295          lookup = walk; 
    296296 
    297                                         // climb back up the tree until we find a level where we are not the end  
     297                                        // climb back up the tree until we find a level where we are not the end 
    298298                                        // node on the level (i.e. that we have a sibling in the direction 
    299299                                        // we are searching) or until we reach the end. 
    300300 
    301           while ( !getSibling(lookup,direction) && lookup != (direction == "ltr" ? right_node : left_node) )  
     301          while ( !getSibling(lookup,direction) && lookup != (direction == "ltr" ? right_node : left_node) ) 
    302302                                                { 
    303303                                                lookup = lookup.parentNode; 
    304304                                                } 
    305305 
    306                                         // did we find a level with a sibling?  
     306                                        // did we find a level with a sibling? 
    307307 
    308308          // walk = ( lookup.nextSibling ? lookup.nextSibling : lookup ) ; 
     
    310310          walk = ( getSibling(lookup,direction) ? getSibling(lookup,direction) : lookup ) ; 
    311311 
    312                                         this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): climbed back up (or found right node):", walk ); 
    313                                          
    314                             }    
    315                                 }        
     312                                        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): climbed back up (or found right node):", walk ); 
     313 
     314                            } 
     315                                } 
    316316 
    317317                        }       // end of else walk. 
     
    323323 
    324324                // call the requested function on the current node. Functions 
    325                 // return an array.  
     325                // return an array. 
    326326                // 
    327327                // Possible functions are _fenCullIds, _fenEmptySet 
     
    332332                // next_node can be an object (this.takenIds), a node (text, el, etc) or false. 
    333333 
    334                 this.ddt._ddt( "enter-paragraphs.js", "175", "forEachNode(): calling function" ); 
     334                //this.ddt._ddt( "enter-paragraphs.js", "175", "forEachNode(): calling function" ); 
    335335 
    336336                switch( mode ) 
     
    339339                        case "cullids": 
    340340 
    341                 fnReturnVal = this._fenCullIds(walk, next_node );        
     341                fnReturnVal = this._fenCullIds(walk, next_node ); 
    342342                                break; 
    343343 
    344344                        case "find_fill": 
    345345 
    346                 fnReturnVal = this._fenEmptySet(walk, next_node, mode, done_flag);       
     346                fnReturnVal = this._fenEmptySet(walk, next_node, mode, done_flag); 
    347347                                break; 
    348348 
    349349                        case "find_cursorpoint": 
    350350 
    351                 fnReturnVal = this._fenEmptySet(walk, next_node, mode, done_flag);       
     351                fnReturnVal = this._fenEmptySet(walk, next_node, mode, done_flag); 
    352352                                break; 
    353353 
     
    356356                // If this node wants us to return, return next_node 
    357357 
    358     if ( fnReturnVal[0] )  
    359                         { 
    360                         this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): returning node:", fnReturnVal[1] ); 
    361  
    362                         return fnReturnVal[1];                                                           
    363                         } 
    364  
    365                 // are we done with the loop?  
     358    if ( fnReturnVal[0] ) 
     359                        { 
     360                        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "175", "forEachNode(): returning node:", fnReturnVal[1] ); 
     361 
     362                        return fnReturnVal[1]; 
     363                        } 
     364 
     365                // are we done with the loop? 
    366366 
    367367                if ( done_flag ) 
     
    372372                // Otherwise, pass to the next node 
    373373 
    374     if ( fnReturnVal[1] )  
    375                         { 
    376                         next_node = fnReturnVal[1];                                                              
     374    if ( fnReturnVal[1] ) 
     375                        { 
     376                        next_node = fnReturnVal[1]; 
    377377                        } 
    378378 
    379379          }     // end of while loop 
    380380 
    381         this.ddt._ddt( "enter-paragraphs.js", "175", "forEachNode(): returning false." ); 
     381        //this.ddt._ddt( "enter-paragraphs.js", "175", "forEachNode(): returning false." ); 
    382382 
    383383  return false; 
     
    393393* @param next_node node next node to be examined. 
    394394* @param node string "find_fill" or "find_cursorpoint" 
    395 * @param last_flag boolean is this the last node?  
    396 */ 
    397  
    398 EnterParagraphs.prototype._fenEmptySet = function( node, next_node, mode, last_flag)  
    399         { 
    400  
    401         this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : top with mode '" + mode + "' and last_flag '" + last_flag + "' and node:", node ); 
     395* @param last_flag boolean is this the last node? 
     396*/ 
     397 
     398EnterParagraphs.prototype._fenEmptySet = function( node, next_node, mode, last_flag) 
     399        { 
     400 
     401        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : top with mode '" + mode + "' and last_flag '" + last_flag + "' and node:", node ); 
    402402 
    403403  // Mark this if it's the first base 
    404404 
    405   if ( !next_node && !node.firstChild )  
     405  if ( !next_node && !node.firstChild ) 
    406406                { 
    407407                next_node = node; 
     
    414414  if ( (node.nodeType == 1 && this._elemSolid.test(node.nodeName)) || 
    415415    (node.nodeType == 3 && !this._whiteSpace.test(node.nodeValue)) || 
    416     (node.nodeType != 1 && node.nodeType != 3) )  
    417                 { 
    418  
    419                 this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : found content in node:", node ); 
     416    (node.nodeType != 1 && node.nodeType != 3) ) 
     417                { 
     418 
     419                //this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : found content in node:", node ); 
    420420 
    421421                switch( mode ) 
     
    430430 
    431431                        case "find_cursorpoint": 
    432                                  
     432 
    433433                                // returns content 
    434434 
     
    445445  if ( last_flag ) 
    446446                { 
    447                 this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : return 'base' node:", next_node ); 
     447                //this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : return 'base' node:", next_node ); 
    448448 
    449449                return new Array( true, next_node ); 
    450450                } 
    451451 
    452         this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : bottom returning false and :", next_node ); 
     452        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "263", "_fenEmptySet() : bottom returning false and :", next_node ); 
    453453 
    454454  return new Array( false, next_node ); 
     
    459459 
    460460/** 
    461 * remove duplicate Id's.  
     461* remove duplicate Id's. 
    462462* 
    463463* @param ep_ref enterparagraphs reference to enterparagraphs object 
    464464*/ 
    465465 
    466 EnterParagraphs.prototype._fenCullIds = function ( ep_ref, node, pong )  
    467         { 
    468  
    469         this.ddt._ddt( "enter-paragraphs.js", "299", "_fenCullIds(): top" ); 
     466EnterParagraphs.prototype._fenCullIds = function ( ep_ref, node, pong ) 
     467        { 
     468 
     469        //this.ddt._ddt( "enter-paragraphs.js", "299", "_fenCullIds(): top" ); 
    470470 
    471471  // Check for an id, blast it if it's in the store, otherwise add it 
    472472 
    473   if ( node.id )  
    474                 { 
    475  
    476                 this.ddt._ddt( "enter-paragraphs.js", "299", "_fenCullIds(): node '" + node.nodeName + "' has an id '" + node.id + "'" ); 
     473  if ( node.id ) 
     474                { 
     475 
     476                //this.ddt._ddt( "enter-paragraphs.js", "299", "_fenCullIds(): node '" + node.nodeName + "' has an id '" + node.id + "'" ); 
    477477 
    478478                pong[node.id] ? node.id = '' : pong[node.id] = true; 
     
    489489* 
    490490* @param rng Range 
    491 * @param search_direction string "left" or "right"  
     491* @param search_direction string "left" or "right" 
    492492* 
    493493* @todo check blank node issue in roaming loop. 
    494494*/ 
    495495 
    496 EnterParagraphs.prototype.processSide = function( rng, search_direction)  
    497         { 
    498  
    499         this.ddt._ddt( "enter-paragraphs.js", "329", "processSide(): top search_direction == '" + search_direction + "'" ); 
    500  
    501   var next = function(element, search_direction)  
    502                                                         {  
    503                                                         return ( search_direction == "left" ? element.previousSibling : element.nextSibling );  
     496EnterParagraphs.prototype.processSide = function( rng, search_direction) 
     497        { 
     498 
     499        //this.ddt._ddt( "enter-paragraphs.js", "329", "processSide(): top search_direction == '" + search_direction + "'" ); 
     500 
     501  var next = function(element, search_direction) 
     502                                                        { 
     503                                                        return ( search_direction == "left" ? element.previousSibling : element.nextSibling ); 
    504504                                                        }; 
    505505 
     
    508508  var roam, start = node; 
    509509 
    510         this.ddt._ddtDumpNode( "enter-paragraphs.js", "337", "processSide(): starting with node:", node ); 
     510        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "337", "processSide(): starting with node:", node ); 
    511511 
    512512  // Never start with an element, because then the first roaming node might 
    513513  // be on the exclusion list and we wouldn't know until it was too late 
    514514 
    515   while ( start.nodeType == 1 && !this._permEmpty.test(start.nodeName) )  
     515  while ( start.nodeType == 1 && !this._permEmpty.test(start.nodeName) ) 
    516516                { 
    517517                start = ( offset ? start.lastChild : start.firstChild ); 
     
    532532                { 
    533533 
    534                 this.ddt._ddtDumpNode( "enter-paragraphs.js", "357", "processSide(): roaming loop, search_direction is '" + search_direction + "' current node is: ", roam ); 
     534                //this.ddt._ddtDumpNode( "enter-paragraphs.js", "357", "processSide(): roaming loop, search_direction is '" + search_direction + "' current node is: ", roam ); 
    535535 
    536536                // next() is an inline function defined above that returns the next node depending 
    537537                // on the direction we're searching. 
    538538 
    539     if ( next(roam,search_direction) )  
    540                         { 
    541  
    542                         this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Checking next node '" + next(roam,search_direction).NodeName + "' for _pExclusions list." ); 
     539    if ( next(roam,search_direction) ) 
     540                        { 
     541 
     542                        //this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Checking next node '" + next(roam,search_direction).NodeName + "' for _pExclusions list." ); 
    543543 
    544544      // If the next sibling's on the exclusion list, stop before it 
    545545 
    546       if ( this._pExclusions.test(next(roam,search_direction).nodeName) )  
     546      if ( this._pExclusions.test(next(roam,search_direction).nodeName) ) 
    547547                                { 
    548548 
    549                                 this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Node '" + next(roam,search_direction).NodeName + "' is on the _pExclusions list. Stopping before it." ); 
     549                                //this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Node '" + next(roam,search_direction).NodeName + "' is on the _pExclusions list. Stopping before it." ); 
    550550 
    551551        return this.processRng(rng, search_direction, roam, next(roam,search_direction), (search_direction == "left"?'AfterEnd':'BeforeBegin'), true, false); 
    552                     }  
    553                         }  
    554                 else  
    555                         { 
    556  
    557                         this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): No next node, examing parent node '" + roam.parentNode.nodeName + "' for containers or exclusions." ); 
     552                    } 
     553                        } 
     554                else 
     555                        { 
     556 
     557                        //this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): No next node, examing parent node '" + roam.parentNode.nodeName + "' for containers or exclusions." ); 
    558558 
    559559      // If our parent's on the container list, stop inside it 
    560560 
    561       if (this._pContainers.test(roam.parentNode.nodeName))  
     561      if (this._pContainers.test(roam.parentNode.nodeName)) 
    562562                                { 
    563563 
    564                                 this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is on the _pContainer list. Stopping inside it." ); 
     564                                //this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is on the _pContainer list. Stopping inside it." ); 
    565565 
    566566        return this.processRng(rng, search_direction, roam, roam.parentNode, (search_direction == "left"?'AfterBegin':'BeforeEnd'), true, false); 
    567567              } 
    568       else if (this._pExclusions.test(roam.parentNode.nodeName))  
     568      else if (this._pExclusions.test(roam.parentNode.nodeName)) 
    569569                                { 
    570570 
    571                                 this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is on the _pExclusion list." ); 
     571                                //this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is on the _pExclusion list." ); 
    572572 
    573573              // chop without wrapping 
    574574 
    575         if (this._pBreak.test(roam.parentNode.nodeName))  
     575        if (this._pBreak.test(roam.parentNode.nodeName)) 
    576576                                        { 
    577577 
    578                                         this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is on the _pBreak list." ); 
     578                                        //this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is on the _pBreak list." ); 
    579579 
    580580          return this.processRng(rng, search_direction, roam, roam.parentNode, 
    581581                            (search_direction == "left"?'AfterBegin':'BeforeEnd'), false, (search_direction == "left" ?true:false)); 
    582                 }  
    583                                 else  
     582                } 
     583                                else 
    584584                                        { 
    585585 
    586                                         this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is not on the _pBreak list." ); 
     586                                        //this.ddt._ddt( "enter-paragraphs.js", "371", "processSide(): Parent Node '" + roam.parentNode.nodeName + "' is not on the _pBreak list." ); 
    587587 
    588588                                        // the next(roam,search_direction) in this call is redundant since we know it's false 
     
    592592                                        // because it's already wrapped. 
    593593 
    594           return this.processRng(rng,  
    595                                                                                                                                 search_direction,  
     594          return this.processRng(rng, 
     595                                                                                                                                search_direction, 
    596596                                                                                                                                (roam = roam.parentNode), 
    597597                                            (next(roam,search_direction) ? next(roam,search_direction) : roam.parentNode), 
    598                                                                                       (next(roam,search_direction) ? (search_direction == "left"?'AfterEnd':'BeforeBegin') : (search_direction == "left"?'AfterBegin':'BeforeEnd')),  
    599                                                                                                                                 false,  
     598                                                                                      (next(roam,search_direction) ? (search_direction == "left"?'AfterEnd':'BeforeBegin') : (search_direction == "left"?'AfterBegin':'BeforeEnd')), 
     599                                                                                                                                false, 
    600600                                                                                                                                false); 
    601                                         }        
    602                                 }        
    603                         }        
    604                 }        
    605  
    606         this.ddt._ddt( "enter-paragraphs.js", "424", "processSide(): bottom" ); 
     601                                        } 
     602                                } 
     603                        } 
     604                } 
     605 
     606        //this.ddt._ddt( "enter-paragraphs.js", "424", "processSide(): bottom" ); 
    607607 
    608608        };      // end of processSide() 
     
    618618* @param rn Range original selected range 
    619619* @param search_direction string Direction to search in. 
    620 * @param roam node  
     620* @param roam node 
    621621* @param insertion string may be AfterBegin of BeforeEnd 
    622622* @return array 
    623623*/ 
    624624 
    625 EnterParagraphs.prototype.processRng = function(rng, search_direction, roam, neighbour, insertion, pWrap, preBr)  
    626         { 
    627  
    628         this.ddt._ddtDumpNode( "enter-paragraphs.js", "398", "processRng(): top - roam arg is:", roam ); 
    629         this.ddt._ddtDumpNode( "enter-paragraphs.js", "398", "processRng(): top - neighbor arg is:", neighbour ); 
    630  
    631         this.ddt._ddt( "enter-paragraphs.js", "398", "processRng(): top - insertion arg is: '" + insertion + "'" ); 
     625EnterParagraphs.prototype.processRng = function(rng, search_direction, roam, neighbour, insertion, pWrap, preBr) 
     626        { 
     627 
     628        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "398", "processRng(): top - roam arg is:", roam ); 
     629        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "398", "processRng(): top - neighbor arg is:", neighbour ); 
     630 
     631        //this.ddt._ddt( "enter-paragraphs.js", "398", "processRng(): top - insertion arg is: '" + insertion + "'" ); 
    632632 
    633633  var node = search_direction == "left" ? rng.startContainer : rng.endContainer; 
    634634  var offset = search_direction == "left" ? rng.startOffset : rng.endOffset; 
    635635 
    636         this.ddt._ddtDumpNode( "enter-paragraphs.js", "447", "processRng(): range start (or end) is at offset '" + offset + "' is node :", node ); 
     636        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "447", "processRng(): range start (or end) is at offset '" + offset + "' is node :", node ); 
    637637 
    638638  // Define the range to cut, and extend the selection range to the same boundary 
     
    643643  newRng.selectNode(roam); 
    644644 
    645         this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): selecting newRng is:", newRng ); 
    646         this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): selecting original rng is:", rng ); 
     645        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): selecting newRng is:", newRng ); 
     646        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): selecting original rng is:", rng ); 
    647647 
    648648        // extend the range in the given direction. 
     
    653653    rng.setStart(newRng.startContainer, newRng.startOffset); 
    654654 
    655                 this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): extending direction left - newRng is:", newRng ); 
    656                 this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): extending direction left - rng is:", rng ); 
    657  
    658           }  
     655                //this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): extending direction left - newRng is:", newRng ); 
     656                //this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): extending direction left - rng is:", rng ); 
     657 
     658          } 
    659659        else if ( search_direction == "right" ) 
    660660                { 
     
    663663                rng.setEnd(newRng.endContainer, newRng.endOffset); 
    664664 
    665                 this.ddt._ddt( "enter-paragraphs.js", "522", "processRng(): right - new range start is '" + offset + "' end offset is '" + newRng.endOffset + "'" ); 
     665                //this.ddt._ddt( "enter-paragraphs.js", "522", "processRng(): right - new range start is '" + offset + "' end offset is '" + newRng.endOffset + "'" ); 
    666666          } 
    667667 
    668         this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): rng is:", rng ); 
    669         this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): newRng is:", newRng ); 
     668        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): rng is:", rng ); 
     669        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "522", "processRng(): newRng is:", newRng ); 
    670670 
    671671  // Clone the range and remove duplicate ids it would otherwise produce 
     
    673673  var cnt = newRng.cloneContents(); 
    674674 
    675         this.ddt._ddtDumpNode( "enter-paragraphs.js", "509", "processRng(): culling duplicate ids from:", cnt ); 
     675        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "509", "processRng(): culling duplicate ids from:", cnt ); 
    676676 
    677677        // in this case "init" is an object not a boolen. 
     
    679679  this.forEachNodeUnder( cnt, "cullids", "ltr", this.takenIds, false, false); 
    680680 
    681   // Special case, for inserting paragraphs before some blocks when caret is at  
    682         // their zero offset.  
     681  // Special case, for inserting paragraphs before some blocks when caret is at 
     682        // their zero offset. 
    683683        // 
    684684        // Used to "open up space" in front of a list, table. Usefull if the list is at 
     
    690690  pify = pify ? newRng.startContainer : newRng.endContainer; 
    691691 
    692         this.ddt._ddtDumpNode( "enter-paragraphs.js", "521", "processRng(): pify is '" + pify.nodeName + "' pifyOffset is '" + pifyOffset + "':", pify ); 
    693  
    694   if ( this._pifyParent.test(pify.nodeName) && pify.parentNode.childNodes.item(0) == pify )  
    695                 { 
    696     while ( !this._pifySibling.test(pify.nodeName) )  
     692        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "521", "processRng(): pify is '" + pify.nodeName + "' pifyOffset is '" + pifyOffset + "':", pify ); 
     693 
     694  if ( this._pifyParent.test(pify.nodeName) && pify.parentNode.childNodes.item(0) == pify ) 
     695                { 
     696    while ( !this._pifySibling.test(pify.nodeName) ) 
    697697                        { 
    698698                        pify = pify.parentNode; 
     
    702702        // NODE TYPE 11 is DOCUMENT_FRAGMENT NODE 
    703703 
    704   if ( cnt.nodeType == 11 && !cnt.firstChild )  
     704  if ( cnt.nodeType == 11 && !cnt.firstChild ) 
    705705                { 
    706706                cnt.appendChild(editor._doc.createElement(pify.nodeName)); 
     
    710710        // error in forEachNode() 
    711711 
    712         this.ddt._ddt( "enter-paragraphs.js", "612", "processRng(): find_fill in cnt." ); 
     712        //this.ddt._ddt( "enter-paragraphs.js", "612", "processRng(): find_fill in cnt." ); 
    713713 
    714714  fill = this.forEachNodeUnder(cnt, "find_fill", "ltr", false ); 
    715715 
    716         this.ddt._ddtDumpNode( "enter-paragraphs.js", "612", "processRng(): fill node:" , fill ); 
    717  
    718   if ( fill &&  
     716        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "612", "processRng(): fill node:" , fill ); 
     717 
     718  if ( fill && 
    719719                                this._pifySibling.test(pify.nodeName) && 
    720                 ( (pifyOffset == 0) || ( pifyOffset == 1 && this._pifyForced.test(pify.nodeName) ) ) )  
    721                 { 
    722  
    723                 this.ddt._ddt( "enter-paragraphs.js", "544", "processRng(): pify handling. Creating p tag followed by nbsp tag" ); 
     720                ( (pifyOffset == 0) || ( pifyOffset == 1 && this._pifyForced.test(pify.nodeName) ) ) ) 
     721                { 
     722 
     723                //this.ddt._ddt( "enter-paragraphs.js", "544", "processRng(): pify handling. Creating p tag followed by nbsp tag" ); 
    724724 
    725725                roam = editor._doc.createElement( 'p' ); 
     
    733733                // after the list etc. 
    734734 
    735     if ((search_direction == "left" ) && pify.previousSibling)  
    736                         { 
    737  
    738                         this.ddt._ddt( "enter-paragraphs.js", "682", "processRng(): returning created roam AfterEnd" ); 
     735    if ((search_direction == "left" ) && pify.previousSibling) 
     736                        { 
     737 
     738                        //this.ddt._ddt( "enter-paragraphs.js", "682", "processRng(): returning created roam AfterEnd" ); 
    739739 
    740740                        return new Array(pify.previousSibling, 'AfterEnd', roam); 
    741741                        } 
    742     else if (( search_direction == "right") && pify.nextSibling)  
    743                         { 
    744  
    745                         this.ddt._ddt( "enter-paragraphs.js", "682", "processRng(): returning created roam BeforeBegin" ); 
     742    else if (( search_direction == "right") && pify.nextSibling) 
     743                        { 
     744 
     745                        //this.ddt._ddt( "enter-paragraphs.js", "682", "processRng(): returning created roam BeforeBegin" ); 
    746746 
    747747                        return new Array(pify.nextSibling, 'BeforeBegin', roam); 
    748748                        } 
    749     else  
    750                         { 
    751  
    752                         this.ddt._ddt( "enter-paragraphs.js", "682", "processRng(): returning created roam for direction '" + search_direction + "'" ); 
     749    else 
     750                        { 
     751 
     752                        //this.ddt._ddt( "enter-paragraphs.js", "682", "processRng(): returning created roam for direction '" + search_direction + "'" ); 
    753753 
    754754                        return new Array(pify.parentNode, (search_direction == "left"?'AfterBegin':'BeforeEnd'), roam); 
     
    759759  // If our cloned contents are 'content'-less, shove a break in them 
    760760 
    761   if ( fill )  
    762                 { 
    763  
    764                 // Ill-concieved?  
     761  if ( fill ) 
     762                { 
     763 
     764                // Ill-concieved? 
    765765                // 
    766766                // 3 is a TEXT node and it should be empty. 
    767                 //  
    768  
    769                 if ( fill.nodeType == 3 )  
    770                         { 
    771                         // fill = fill.parentNode;               
     767                // 
     768 
     769                if ( fill.nodeType == 3 ) 
     770                        { 
     771                        // fill = fill.parentNode; 
    772772 
    773773                        fill = editor._doc.createDocumentFragment(); 
    774774 
    775                         this.ddt._ddtDumpNode( "enter-paragraphs.js", "575", "processRng(): fill.nodeType is 3. Moving up to parent:", fill ); 
    776                         } 
    777  
    778     if ( (fill.nodeType == 1 && !this._elemSolid.test()) || fill.nodeType == 11 )  
    779                         { 
    780  
    781                         // FIXME:/CHECKME: When Xinha is switched from WYSIWYG to text mode  
     775                        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "575", "processRng(): fill.nodeType is 3. Moving up to parent:", fill ); 
     776                        } 
     777 
     778    if ( (fill.nodeType == 1 && !this._elemSolid.test()) || fill.nodeType == 11 ) 
     779                        { 
     780 
     781                        // FIXME:/CHECKME: When Xinha is switched from WYSIWYG to text mode 
    782782                        // HTMLArea.getHTMLWrapper() will strip out the trailing br. Not sure why. 
    783783 
     
    788788 
    789789                        fill.appendChild( pterminator ); 
    790                           
    791                         this.ddt._ddtDumpNode( "enter-paragraphs.js", "583", "processRng(): fill type is 1 and !elemsolid or it's type 11. Appending an nbsp tag:", fill ); 
    792  
    793                         } 
    794     else  
    795                         { 
    796  
    797                         this.ddt._ddt( "enter-paragraphs.js", "583", "processRng(): inserting a br tag before." ); 
     790 
     791                        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "583", "processRng(): fill type is 1 and !elemsolid or it's type 11. Appending an nbsp tag:", fill ); 
     792 
     793                        } 
     794    else 
     795                        { 
     796 
     797                        //this.ddt._ddt( "enter-paragraphs.js", "583", "processRng(): inserting a br tag before." ); 
    798798 
    799799                        // fill.parentNode.insertBefore(editor._doc.createElement('br'),fill); 
     
    809809        // YmL: If there was no content replace with fill 
    810810        // (previous code did not use fill and we ended up with the 
    811         // <p>test</p><p></p> because Gecko was finding two empty text nodes  
     811        // <p>test</p><p></p> because Gecko was finding two empty text nodes 
    812812        // when traversing on the right hand side of an empty document. 
    813813 
     
    815815                { 
    816816 
    817                 this.ddt._ddtDumpNode( "enter-paragraphs.js", "606", "processRng(): no content. Using fill.", fill ); 
     817                //this.ddt._ddtDumpNode( "enter-paragraphs.js", "606", "processRng(): no content. Using fill.", fill ); 
    818818 
    819819                roam = fill; 
     
    823823          // And stuff a shiny new object with whatever contents we have 
    824824 
    825                 this.ddt._ddt( "enter-paragraphs.js", "606", "processRng(): creating p tag or document fragment - pWrap is '" + pWrap + "' " ); 
    826          
     825                //this.ddt._ddt( "enter-paragraphs.js", "606", "processRng(): creating p tag or document fragment - pWrap is '" + pWrap + "' " ); 
     826 
    827827          roam = (pWrap || (cnt.nodeType == 11 && !cnt.firstChild)) ? editor._doc.createElement('p') : editor._doc.createDocumentFragment(); 
    828828          roam.appendChild(cnt); 
    829829                } 
    830830 
    831   if (preBr)  
    832                 { 
    833                 this.ddt._ddt( "enter-paragraphs.js", "767", "processRng(): appending a br based on preBr flag" ); 
     831  if (preBr) 
     832                { 
     833                //this.ddt._ddt( "enter-paragraphs.js", "767", "processRng(): appending a br based on preBr flag" ); 
    834834 
    835835                roam.appendChild(editor._doc.createElement('br')); 
    836836                } 
    837837 
    838         this.ddt._ddtDumpNode( "enter-paragraphs.js", "606", "processRng(): bottom with roam:", roam ); 
    839         this.ddt._ddtDumpNode( "enter-paragraphs.js", "606", "processRng(): bottom with neighbour:", neighbour ); 
     838        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "606", "processRng(): bottom with roam:", roam ); 
     839        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "606", "processRng(): bottom with neighbour:", neighbour ); 
    840840 
    841841  // Return the nearest relative, relative insertion point and fragment to insert 
     
    852852* there is no good way to "get out of" ordered or unordered lists from Javascript. 
    853853* We have to pass the onKeyPress 13 event to the browser so it can take care of 
    854 * getting us "out of" the list.  
    855 * 
    856 * The Gecko engine does a good job of handling all the normal <li> cases except the "press  
     854* getting us "out of" the list. 
     855* 
     856* The Gecko engine does a good job of handling all the normal <li> cases except the "press 
    857857* enter at the first position" where we want a <p>&nbsp</p> inserted before the list. The 
    858858* built-in behavior is to open up a <li> before the current entry (not good). 
    859 *  
     859* 
    860860* @param rng Range range. 
    861861*/ 
     
    864864        { 
    865865 
    866         this.ddt._ddtDumpNode( "enter-paragraphs.js", "863", "isNormaListItem(): checking rng for list end:", rng ); 
     866        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "863", "isNormaListItem(): checking rng for list end:", rng ); 
    867867 
    868868        var node, listNode; 
     
    874874                { 
    875875 
    876                 this.ddt._ddt( "enter-paragraphs.js", "863", "isNormaListItem(): node is a list item"); 
     876                //this.ddt._ddt( "enter-paragraphs.js", "863", "isNormaListItem(): node is a list item"); 
    877877 
    878878                // are we a list item? 
     
    885885                { 
    886886 
    887                 this.ddt._ddt( "enter-paragraphs.js", "863", "isNormaListItem(): parent is a list item"); 
    888                          
     887                //this.ddt._ddt( "enter-paragraphs.js", "863", "isNormaListItem(): parent is a list item"); 
     888 
    889889                // our parent is a list item. 
    890890 
     
    894894        else 
    895895                { 
    896                 this.ddt._ddt( "enter-paragraphs.js", "863", "isNormaListItem(): not list item"); 
     896                //this.ddt._ddt( "enter-paragraphs.js", "863", "isNormaListItem(): not list item"); 
    897897 
    898898                // neither we nor our parent are a list item. this is not a normal 
     
    902902                } 
    903903 
    904         // at this point we have a listNode. Is it the first list item?  
     904        // at this point we have a listNode. Is it the first list item? 
    905905 
    906906        if ( ! listNode.previousSibling ) 
    907907                { 
    908                 this.ddt._ddt( "enter-paragraphs.js", "839", "isNormaListItem(): we are the first li." ); 
    909  
    910                 // are we on the first character of the first li?  
     908                //this.ddt._ddt( "enter-paragraphs.js", "839", "isNormaListItem(): we are the first li." ); 
     909 
     910                // are we on the first character of the first li? 
    911911 
    912912                if ( rng.startOffset == 0 ) 
    913913                        { 
    914                         this.ddt._ddt( "enter-paragraphs.js", "839", "isNormaListItem(): we are on the first character." ); 
     914                        //this.ddt._ddt( "enter-paragraphs.js", "839", "isNormaListItem(): we are on the first character." ); 
    915915 
    916916                        return false; 
     
    918918                } 
    919919 
    920         this.ddt._ddt( "enter-paragraphs.js", "839", "isNormaListItem(): this is a normal list item case." ); 
     920        //this.ddt._ddt( "enter-paragraphs.js", "839", "isNormaListItem(): this is a normal list item case." ); 
    921921        return true; 
    922922 
     
    924924 
    925925// ---------------------------------------------------------------------------------- 
    926 /**                                                       
     926/** 
    927927* Called when a key is pressed in the editor 
    928928*/ 
    929929 
    930 EnterParagraphs.prototype.__onKeyPress = function(ev)  
    931         { 
    932  
    933         this.ddt._ddt( "enter-paragraphs.js", "517", "__onKeyPress(): top with keyCode '" + ev.keyCode + "'" ); 
     930EnterParagraphs.prototype.__onKeyPress = function(ev) 
     931        { 
     932 
     933        //this.ddt._ddt( "enter-paragraphs.js", "517", "__onKeyPress(): top with keyCode '" + ev.keyCode + "'" ); 
    934934 
    935935  // If they've hit enter and shift is not pressed, handle it 
     
    937937  if (ev.keyCode == 13 && !ev.shiftKey && this.editor._iframe.contentWindow.getSelection) 
    938938                { 
    939                 this.ddt._ddt( "enter-paragraphs.js", "517", "__onKeyPress(): calling handleEnter" ); 
     939                //this.ddt._ddt( "enter-paragraphs.js", "517", "__onKeyPress(): calling handleEnter" ); 
    940940 
    941941    return this.handleEnter(ev); 
    942942                } 
    943943 
    944         this.ddt._ddt( "enter-paragraphs.js", "517", "__onKeyPress(): bottom" ); 
     944        //this.ddt._ddt( "enter-paragraphs.js", "517", "__onKeyPress(): bottom" ); 
    945945 
    946946        };      // end of _onKeyPress() 
     
    952952*/ 
    953953 
    954 EnterParagraphs.prototype.handleEnter = function(ev)  
    955         { 
    956  
    957         this.ddt._ddt( "enter-paragraphs.js", "537", "handleEnter(): top" ); 
     954EnterParagraphs.prototype.handleEnter = function(ev) 
     955        { 
     956 
     957        //this.ddt._ddt( "enter-paragraphs.js", "537", "handleEnter(): top" ); 
    958958 
    959959        var cursorNode; 
     
    964964  var rng = this.editor._createRange(sel); 
    965965 
    966         this.ddt._ddtDumpNode( "enter-paragraphs.js", "757", "handleEnter(): initial range is: ", rng ); 
     966        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "757", "handleEnter(): initial range is: ", rng ); 
    967967 
    968968        // if we are at the end of a list and the node is empty let the browser handle 
     
    971971        if ( this.isNormalListItem(rng) ) 
    972972                { 
    973                 this.ddt._ddt( "enter-paragraphs.js", "757", "handleEnter(): we are at the end of a list with a blank item. Letting the browser handle it." ); 
     973                //this.ddt._ddt( "enter-paragraphs.js", "757", "handleEnter(): we are at the end of a list with a blank item. Letting the browser handle it." ); 
    974974                return true; 
    975975                } 
    976976 
    977         // as far as I can tell this isn't actually used.  
     977        // as far as I can tell this isn't actually used. 
    978978 
    979979  this.takenIds = new Object(); 
     
    986986        // [2] roam 
    987987 
    988         this.ddt._ddt( "enter-paragraphs.js", "537", "handleEnter(): calling processSide on left side." ); 
     988        //this.ddt._ddt( "enter-paragraphs.js", "537", "handleEnter(): calling processSide on left side." ); 
    989989 
    990990  var pStart = this.processSide(rng, "left"); 
    991991 
    992         this.ddt._ddtDumpNode( "enter-paragraphs.js", "757", "handleEnter(): after processing left side range is: ", rng ); 
    993  
    994         this.ddt._ddt( "enter-paragraphs.js", "537", "handleEnter(): calling processSide on right side." ); 
     992        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "757", "handleEnter(): after processing left side range is: ", rng ); 
     993 
     994        //this.ddt._ddt( "enter-paragraphs.js", "537", "handleEnter(): calling processSide on right side." ); 
    995995 
    996996        var pEnd = this.processSide(rng, "right"); 
     
    10091009        // we'll use this to position the cursor. 
    10101010 
    1011         this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): looking for cursor position" ); 
     1011        //this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): looking for cursor position" ); 
    10121012 
    10131013  var holdEnd = this.forEachNodeUnder( cursorNode, "find_cursorpoint", "ltr", false, true); 
     
    10201020  // Insert our carefully chosen document fragments 
    10211021 
    1022   if ( pStart )  
    1023                 { 
    1024  
    1025                 this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): inserting pEnd" ); 
     1022  if ( pStart ) 
     1023                { 
     1024 
     1025                //this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): inserting pEnd" ); 
    10261026 
    10271027                this.insertAdjacentElement(pStart[0], pStart[1], pStart[2]); 
    10281028                } 
    10291029 
    1030   if ( pEnd && pEnd.nodeType != 1)  
    1031                 { 
    1032  
    1033                 this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): inserting pEnd" ); 
     1030  if ( pEnd && pEnd.nodeType != 1) 
     1031                { 
     1032 
     1033                //this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): inserting pEnd" ); 
    10341034 
    10351035                this.insertAdjacentElement(pEnd[0], pEnd[1], pEnd[2]); 
     
    10381038  // Move the caret in front of the first good text element 
    10391039 
    1040   if ((holdEnd) && (this._permEmpty.test(holdEnd.nodeName) ))  
    1041                 { 
    1042  
    1043                 this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): looping to find cursor element." ); 
     1040  if ((holdEnd) && (this._permEmpty.test(holdEnd.nodeName) )) 
     1041                { 
     1042 
     1043                //this.ddt._ddt( "enter-paragraphs.js", "712", "handleEnter(): looping to find cursor element." ); 
    10441044 
    10451045    var prodigal = 0; 
    1046     while ( holdEnd.parentNode.childNodes.item(prodigal) != holdEnd )  
     1046    while ( holdEnd.parentNode.childNodes.item(prodigal) != holdEnd ) 
    10471047                        { 
    10481048                        prodigal++; 
     
    10511051    sel.collapse( holdEnd.parentNode, prodigal); 
    10521052          } 
    1053   else  
     1053  else 
    10541054                { 
    10551055 
    10561056                // holdEnd might be false. 
    10571057 
    1058                 try  
     1058                try 
    10591059                        { 
    10601060                        sel.collapse(holdEnd, 0); 
    10611061 
    1062                         this.ddt._ddtDumpNode( "enter-paragraphs.js", "1057", "handleEnter(): scrolling to element:", holdEnd ); 
    1063  
    1064                         // interestingly, scrollToElement() scroll so the top if holdEnd is a text node.  
    1065                          
     1062                        //this.ddt._ddtDumpNode( "enter-paragraphs.js", "1057", "handleEnter(): scrolling to element:", holdEnd ); 
     1063 
     1064                        // interestingly, scrollToElement() scroll so the top if holdEnd is a text node. 
     1065 
    10661066                        if ( holdEnd.nodeType == 3 ) 
    10671067                                { 
     
    10711071                  this.editor.scrollToElement(holdEnd); 
    10721072                        } 
    1073                 catch (e)  
     1073                catch (e) 
    10741074                        { 
    10751075                        // we could try to place the cursor at the end of the document. 
    10761076                        } 
    10771077                } 
    1078          
     1078 
    10791079  this.editor.updateToolbar(); 
    10801080 
Note: See TracChangeset for help on using the changeset viewer.