rt/share/html/NoAuth/RichText/FCKeditor/editor/_source/internals/fcktablehandler.js

   1 /*\r
   2  * FCKeditor - The text editor for Internet - http://www.fckeditor.net\r
   3  * Copyright (C) 2003-2009 Frederico Caldeira Knabben\r
   4  *\r
   5  * == BEGIN LICENSE ==\r
   6  *\r
   7  * Licensed under the terms of any of the following licenses at your\r
   8  * choice:\r
   9  *\r
  10  *  - GNU General Public License Version 2 or later (the "GPL")\r
  11  *    http://www.gnu.org/licenses/gpl.html\r
  12  *\r
  13  *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")\r
  14  *    http://www.gnu.org/licenses/lgpl.html\r
  15  *\r
  16  *  - Mozilla Public License Version 1.1 or later (the "MPL")\r
  17  *    http://www.mozilla.org/MPL/MPL-1.1.html\r
  18  *\r
  19  * == END LICENSE ==\r
  20  *\r
  21  * Manage table operations.\r
  22  */\r
  23 \r
  24 var FCKTableHandler = new Object() ;\r
  25 \r
  26 FCKTableHandler.InsertRow = function( insertBefore )\r
  27 {\r
  28         // Get the row where the selection is placed in.\r
  29         var oRow = FCKSelection.MoveToAncestorNode( 'TR' ) ;\r
  30         if ( !oRow ) return ;\r
  31 \r
  32         // Create a clone of the row.\r
  33         var oNewRow = oRow.cloneNode( true ) ;\r
  34 \r
  35         // Insert the new row (copy) before of it.\r
  36         oRow.parentNode.insertBefore( oNewRow, oRow ) ;\r
  37 \r
  38         // Clean one of the rows to produce the illusion of inserting an empty row before or after.\r
  39         FCKTableHandler.ClearRow( insertBefore ? oNewRow : oRow ) ;\r
  40 }\r
  41 \r
  42 FCKTableHandler.DeleteRows = function( row )\r
  43 {\r
  44         // If no row has been passed as a parameter,\r
  45         // then get the row( s ) containing the cells where the selection is placed in.\r
  46         // If user selected multiple rows ( by selecting multiple cells ), walk\r
  47         // the selected cell list and delete the rows containing the selected cells\r
  48         if ( ! row )\r
  49         {\r
  50                 var aCells = FCKTableHandler.GetSelectedCells() ;\r
  51                 var aRowsToDelete = new Array() ;\r
  52                 //queue up the rows -- it's possible ( and likely ) that we may get duplicates\r
  53                 for ( var i = 0; i < aCells.length; i++ )\r
  54                 {\r
  55                         var oRow = aCells[i].parentNode ;\r
  56                         aRowsToDelete[oRow.rowIndex] = oRow ;\r
  57                 }\r
  58                 for ( var i = aRowsToDelete.length; i >= 0; i-- )\r
  59                 {\r
  60                         if ( aRowsToDelete[i] )\r
  61                                 FCKTableHandler.DeleteRows( aRowsToDelete[i] );\r
  62                 }\r
  63                 return ;\r
  64         }\r
  65 \r
  66         // Get the row's table.\r
  67         var oTable = FCKTools.GetElementAscensor( row, 'TABLE' ) ;\r
  68 \r
  69         // If just one row is available then delete the entire table.\r
  70         if ( oTable.rows.length == 1 )\r
  71         {\r
  72                 FCKTableHandler.DeleteTable( oTable ) ;\r
  73                 return ;\r
  74         }\r
  75 \r
  76         // Delete the row.\r
  77         row.parentNode.removeChild( row ) ;\r
  78 }\r
  79 \r
  80 FCKTableHandler.DeleteTable = function( table )\r
  81 {\r
  82         // If no table has been passed as a parameter,\r
  83         // then get the table where the selection is placed in.\r
  84         if ( !table )\r
  85         {\r
  86                 table = FCKSelection.GetSelectedElement() ;\r
  87                 if ( !table || table.tagName != 'TABLE' )\r
  88                         table = FCKSelection.MoveToAncestorNode( 'TABLE' ) ;\r
  89         }\r
  90         if ( !table ) return ;\r
  91 \r
  92         // Delete the table.\r
  93         FCKSelection.SelectNode( table ) ;\r
  94         FCKSelection.Collapse();\r
  95 \r
  96         // if the table is wrapped with a singleton <p> ( or something similar ), remove\r
  97         // the surrounding tag -- which likely won't show after deletion anyway\r
  98         if ( table.parentNode.childNodes.length == 1 )\r
  99                 table.parentNode.parentNode.removeChild( table.parentNode );\r
 100         else\r
 101                 table.parentNode.removeChild( table  ) ;\r
 102 }\r
 103 \r
 104 FCKTableHandler.InsertColumn = function( insertBefore )\r
 105 {\r
 106         // Get the cell where the selection is placed in.\r
 107         var oCell = null ;\r
 108         var nodes = this.GetSelectedCells() ;\r
 109 \r
 110         if ( nodes && nodes.length )\r
 111                 oCell = nodes[ insertBefore ? 0 : ( nodes.length - 1 ) ] ;\r
 112 \r
 113         if ( ! oCell )\r
 114                 return ;\r
 115 \r
 116         // Get the cell's table.\r
 117         var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ;\r
 118 \r
 119         var iIndex = oCell.cellIndex ;\r
 120 \r
 121         // Loop through all rows available in the table.\r
 122         for ( var i = 0 ; i < oTable.rows.length ; i++ )\r
 123         {\r
 124                 // Get the row.\r
 125                 var oRow = oTable.rows[i] ;\r
 126 \r
 127                 // If the row doesn't have enough cells, ignore it.\r
 128                 if ( oRow.cells.length < ( iIndex + 1 ) )\r
 129                         continue ;\r
 130 \r
 131                 oCell = oRow.cells[iIndex].cloneNode(false) ;\r
 132 \r
 133                 if ( FCKBrowserInfo.IsGeckoLike )\r
 134                         FCKTools.AppendBogusBr( oCell ) ;\r
 135 \r
 136                 // Get back the currently selected cell.\r
 137                 var oBaseCell = oRow.cells[iIndex] ;\r
 138 \r
 139                 oRow.insertBefore( oCell, ( insertBefore ? oBaseCell : oBaseCell.nextSibling ) ) ;\r
 140         }\r
 141 }\r
 142 \r
 143 FCKTableHandler.DeleteColumns = function( oCell )\r
 144 {\r
 145         // if user selected multiple cols ( by selecting multiple cells ), walk\r
 146         // the selected cell list and delete the rows containing the selected cells\r
 147         if ( !oCell  )\r
 148         {\r
 149                 var aColsToDelete = FCKTableHandler.GetSelectedCells();\r
 150                 for ( var i = aColsToDelete.length; i >= 0; i--  )\r
 151                 {\r
 152                         if ( aColsToDelete[i]  )\r
 153                                 FCKTableHandler.DeleteColumns( aColsToDelete[i]  );\r
 154                 }\r
 155                 return;\r
 156         }\r
 157 \r
 158         if ( !oCell ) return ;\r
 159 \r
 160         // Get the cell's table.\r
 161         var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ;\r
 162 \r
 163         // Get the cell index.\r
 164         var iIndex = oCell.cellIndex ;\r
 165 \r
 166         // Loop throw all rows (from down to up, because it's possible that some\r
 167         // rows will be deleted).\r
 168         for ( var i = oTable.rows.length - 1 ; i >= 0 ; i-- )\r
 169         {\r
 170                 // Get the row.\r
 171                 var oRow = oTable.rows[i] ;\r
 172 \r
 173                 // If the cell to be removed is the first one and the row has just one cell.\r
 174                 if ( iIndex == 0 && oRow.cells.length == 1 )\r
 175                 {\r
 176                         // Remove the entire row.\r
 177                         FCKTableHandler.DeleteRows( oRow ) ;\r
 178                         continue ;\r
 179                 }\r
 180 \r
 181                 // If the cell to be removed exists the delete it.\r
 182                 if ( oRow.cells[iIndex] )\r
 183                         oRow.removeChild( oRow.cells[iIndex] ) ;\r
 184         }\r
 185 }\r
 186 \r
 187 FCKTableHandler.InsertCell = function( cell, insertBefore )\r
 188 {\r
 189         // Get the cell where the selection is placed in.\r
 190         var oCell = null ;\r
 191         var nodes = this.GetSelectedCells() ;\r
 192         if ( nodes && nodes.length )\r
 193                 oCell = nodes[ insertBefore ? 0 : ( nodes.length - 1 ) ] ;\r
 194         if ( ! oCell )\r
 195                 return null ;\r
 196 \r
 197         // Create the new cell element to be added.\r
 198         var oNewCell = FCK.EditorDocument.createElement( 'TD' ) ;\r
 199         if ( FCKBrowserInfo.IsGeckoLike )\r
 200                 FCKTools.AppendBogusBr( oNewCell ) ;\r
 201 \r
 202         if ( !insertBefore && oCell.cellIndex == oCell.parentNode.cells.length - 1 )\r
 203                 oCell.parentNode.appendChild( oNewCell ) ;\r
 204         else\r
 205                 oCell.parentNode.insertBefore( oNewCell, insertBefore ? oCell : oCell.nextSibling ) ;\r
 206 \r
 207         return oNewCell ;\r
 208 }\r
 209 \r
 210 FCKTableHandler.DeleteCell = function( cell )\r
 211 {\r
 212         // If this is the last cell in the row.\r
 213         if ( cell.parentNode.cells.length == 1 )\r
 214         {\r
 215                 // Delete the entire row.\r
 216                 FCKTableHandler.DeleteRows( cell.parentNode ) ;\r
 217                 return ;\r
 218         }\r
 219 \r
 220         // Delete the cell from the row.\r
 221         cell.parentNode.removeChild( cell ) ;\r
 222 }\r
 223 \r
 224 FCKTableHandler.DeleteCells = function()\r
 225 {\r
 226         var aCells = FCKTableHandler.GetSelectedCells() ;\r
 227 \r
 228         for ( var i = aCells.length - 1 ; i >= 0  ; i-- )\r
 229         {\r
 230                 FCKTableHandler.DeleteCell( aCells[i] ) ;\r
 231         }\r
 232 }\r
 233 \r
 234 FCKTableHandler._MarkCells = function( cells, label )\r
 235 {\r
 236         for ( var i = 0 ; i < cells.length ; i++ )\r
 237                 cells[i][label] = true ;\r
 238 }\r
 239 \r
 240 FCKTableHandler._UnmarkCells = function( cells, label )\r
 241 {\r
 242         for ( var i = 0 ; i < cells.length ; i++ )\r
 243         {\r
 244                 FCKDomTools.ClearElementJSProperty(cells[i], label ) ;\r
 245         }\r
 246 }\r
 247 \r
 248 FCKTableHandler._ReplaceCellsByMarker = function( tableMap, marker, substitute )\r
 249 {\r
 250         for ( var i = 0 ; i < tableMap.length ; i++ )\r
 251         {\r
 252                 for ( var j = 0 ; j < tableMap[i].length ; j++ )\r
 253                 {\r
 254                         if ( tableMap[i][j][marker] )\r
 255                                 tableMap[i][j] = substitute ;\r
 256                 }\r
 257         }\r
 258 }\r
 259 \r
 260 FCKTableHandler._GetMarkerGeometry = function( tableMap, rowIdx, colIdx, markerName )\r
 261 {\r
 262         var selectionWidth = 0 ;\r
 263         var selectionHeight = 0 ;\r
 264         var cellsLeft = 0 ;\r
 265         var cellsUp = 0 ;\r
 266         for ( var i = colIdx ; tableMap[rowIdx][i] && tableMap[rowIdx][i][markerName] ; i++ )\r
 267                 selectionWidth++ ;\r
 268         for ( var i = colIdx - 1 ; tableMap[rowIdx][i] && tableMap[rowIdx][i][markerName] ; i-- )\r
 269         {\r
 270                 selectionWidth++ ;\r
 271                 cellsLeft++ ;\r
 272         }\r
 273         for ( var i = rowIdx ; tableMap[i] && tableMap[i][colIdx] && tableMap[i][colIdx][markerName] ; i++ )\r
 274                 selectionHeight++ ;\r
 275         for ( var i = rowIdx - 1 ; tableMap[i] && tableMap[i][colIdx] && tableMap[i][colIdx][markerName] ; i-- )\r
 276         {\r
 277                 selectionHeight++ ;\r
 278                 cellsUp++ ;\r
 279         }\r
 280         return { 'width' : selectionWidth, 'height' : selectionHeight, 'x' : cellsLeft, 'y' : cellsUp } ;\r
 281 }\r
 282 \r
 283 FCKTableHandler.CheckIsSelectionRectangular = function()\r
 284 {\r
 285         // If every row and column in an area on a plane are of the same width and height,\r
 286         // Then the area is a rectangle.\r
 287         var cells = FCKTableHandler.GetSelectedCells() ;\r
 288         if ( cells.length < 1 )\r
 289                 return false ;\r
 290 \r
 291         // Check if the selected cells are all in the same table section (thead, tfoot or tbody)\r
 292         for (var i = 0; i < cells.length; i++)\r
 293         {\r
 294                 if ( cells[i].parentNode.parentNode != cells[0].parentNode.parentNode )\r
 295                         return false ;\r
 296         }\r
 297 \r
 298         this._MarkCells( cells, '_CellSelected' ) ;\r
 299 \r
 300         var tableMap = this._CreateTableMap( cells[0] ) ;\r
 301         var rowIdx = cells[0].parentNode.rowIndex ;\r
 302         var colIdx = this._GetCellIndexSpan( tableMap, rowIdx, cells[0] ) ;\r
 303 \r
 304         var geometry = this._GetMarkerGeometry( tableMap, rowIdx, colIdx, '_CellSelected' ) ;\r
 305         var baseColIdx = colIdx - geometry.x ;\r
 306         var baseRowIdx = rowIdx - geometry.y ;\r
 307 \r
 308         if ( geometry.width >= geometry.height )\r
 309         {\r
 310                 for ( colIdx = baseColIdx ; colIdx < baseColIdx + geometry.width ; colIdx++ )\r
 311                 {\r
 312                         rowIdx = baseRowIdx + ( colIdx - baseColIdx ) % geometry.height ;\r
 313                         if ( ! tableMap[rowIdx] || ! tableMap[rowIdx][colIdx] )\r
 314                         {\r
 315                                 this._UnmarkCells( cells, '_CellSelected' ) ;\r
 316                                 return false ;\r
 317                         }\r
 318                         var g = this._GetMarkerGeometry( tableMap, rowIdx, colIdx, '_CellSelected' ) ;\r
 319                         if ( g.width != geometry.width || g.height != geometry.height )\r
 320                         {\r
 321                                 this._UnmarkCells( cells, '_CellSelected' ) ;\r
 322                                 return false ;\r
 323                         }\r
 324                 }\r
 325         }\r
 326         else\r
 327         {\r
 328                 for ( rowIdx = baseRowIdx ; rowIdx < baseRowIdx + geometry.height ; rowIdx++ )\r
 329                 {\r
 330                         colIdx = baseColIdx + ( rowIdx - baseRowIdx ) % geometry.width ;\r
 331                         if ( ! tableMap[rowIdx] || ! tableMap[rowIdx][colIdx] )\r
 332                         {\r
 333                                 this._UnmarkCells( cells, '_CellSelected' ) ;\r
 334                                 return false ;\r
 335                         }\r
 336                         var g = this._GetMarkerGeometry( tableMap, rowIdx, colIdx, '_CellSelected' ) ;\r
 337                         if ( g.width != geometry.width || g.height != geometry.height )\r
 338                         {\r
 339                                 this._UnmarkCells( cells, '_CellSelected' ) ;\r
 340                                 return false ;\r
 341                         }\r
 342                 }\r
 343         }\r
 344 \r
 345         this._UnmarkCells( cells, '_CellSelected' ) ;\r
 346         return true ;\r
 347 }\r
 348 \r
 349 FCKTableHandler.MergeCells = function()\r
 350 {\r
 351         // Get all selected cells.\r
 352         var cells = this.GetSelectedCells() ;\r
 353         if ( cells.length < 2 )\r
 354                 return ;\r
 355 \r
 356         // Assume the selected cells are already in a rectangular geometry.\r
 357         // Because the checking is already done by FCKTableCommand.\r
 358         var refCell = cells[0] ;\r
 359         var tableMap = this._CreateTableMap( refCell ) ;\r
 360         var rowIdx = refCell.parentNode.rowIndex ;\r
 361         var colIdx = this._GetCellIndexSpan( tableMap, rowIdx, refCell ) ;\r
 362 \r
 363         this._MarkCells( cells, '_SelectedCells' ) ;\r
 364         var selectionGeometry = this._GetMarkerGeometry( tableMap, rowIdx, colIdx, '_SelectedCells' ) ;\r
 365 \r
 366         var baseColIdx = colIdx - selectionGeometry.x ;\r
 367         var baseRowIdx = rowIdx - selectionGeometry.y ;\r
 368         var cellContents = FCKTools.GetElementDocument( refCell ).createDocumentFragment() ;\r
 369         for ( var i = 0 ; i < selectionGeometry.height ; i++ )\r
 370         {\r
 371                 var rowChildNodesCount = 0 ;\r
 372                 for ( var j = 0 ; j < selectionGeometry.width ; j++ )\r
 373                 {\r
 374                         var currentCell = tableMap[baseRowIdx + i][baseColIdx + j] ;\r
 375                         while ( currentCell.childNodes.length > 0 )\r
 376                         {\r
 377                                 var node = currentCell.removeChild( currentCell.firstChild ) ;\r
 378                                 if ( node.nodeType != 1\r
 379                                         || ( node.getAttribute( 'type', 2 ) != '_moz' && node.getAttribute( '_moz_dirty' ) != null ) )\r
 380                                 {\r
 381                                         cellContents.appendChild( node ) ;\r
 382                                         rowChildNodesCount++ ;\r
 383                                 }\r
 384                         }\r
 385                 }\r
 386                 if ( rowChildNodesCount > 0 )\r
 387                         cellContents.appendChild( FCK.EditorDocument.createElement( 'br' ) ) ;\r
 388         }\r
 389 \r
 390         this._ReplaceCellsByMarker( tableMap, '_SelectedCells', refCell ) ;\r
 391         this._UnmarkCells( cells, '_SelectedCells' ) ;\r
 392         this._InstallTableMap( tableMap, refCell.parentNode.parentNode.parentNode ) ;\r
 393         refCell.appendChild( cellContents ) ;\r
 394 \r
 395         if ( FCKBrowserInfo.IsGeckoLike && ( ! refCell.firstChild ) )\r
 396                 FCKTools.AppendBogusBr( refCell ) ;\r
 397 \r
 398         this._MoveCaretToCell( refCell, false ) ;\r
 399 }\r
 400 \r
 401 FCKTableHandler.MergeRight = function()\r
 402 {\r
 403         var target = this.GetMergeRightTarget() ;\r
 404         if ( target == null )\r
 405                 return ;\r
 406         var refCell = target.refCell ;\r
 407         var tableMap = target.tableMap ;\r
 408         var nextCell = target.nextCell ;\r
 409 \r
 410         var cellContents = FCK.EditorDocument.createDocumentFragment() ;\r
 411         while ( nextCell && nextCell.childNodes && nextCell.childNodes.length > 0 )\r
 412                 cellContents.appendChild( nextCell.removeChild( nextCell.firstChild ) ) ;\r
 413 \r
 414         nextCell.parentNode.removeChild( nextCell ) ;\r
 415         refCell.appendChild( cellContents ) ;\r
 416         this._MarkCells( [nextCell], '_Replace' ) ;\r
 417         this._ReplaceCellsByMarker( tableMap, '_Replace', refCell ) ;\r
 418         this._InstallTableMap( tableMap, refCell.parentNode.parentNode.parentNode ) ;\r
 419 \r
 420         this._MoveCaretToCell( refCell, false ) ;\r
 421 }\r
 422 \r
 423 FCKTableHandler.MergeDown = function()\r
 424 {\r
 425         var target = this.GetMergeDownTarget() ;\r
 426         if ( target == null )\r
 427                 return ;\r
 428         var refCell = target.refCell ;\r
 429         var tableMap = target.tableMap ;\r
 430         var nextCell = target.nextCell ;\r
 431 \r
 432         var cellContents = FCKTools.GetElementDocument( refCell ).createDocumentFragment() ;\r
 433         while ( nextCell && nextCell.childNodes && nextCell.childNodes.length > 0 )\r
 434                 cellContents.appendChild( nextCell.removeChild( nextCell.firstChild ) ) ;\r
 435         if ( cellContents.firstChild )\r
 436                 cellContents.insertBefore( FCK.EditorDocument.createElement( 'br' ), cellContents.firstChild ) ;\r
 437         refCell.appendChild( cellContents ) ;\r
 438         this._MarkCells( [nextCell], '_Replace' ) ;\r
 439         this._ReplaceCellsByMarker( tableMap, '_Replace', refCell ) ;\r
 440         this._InstallTableMap( tableMap, refCell.parentNode.parentNode.parentNode ) ;\r
 441 \r
 442         this._MoveCaretToCell( refCell, false ) ;\r
 443 }\r
 444 \r
 445 FCKTableHandler.HorizontalSplitCell = function()\r
 446 {\r
 447         var cells = FCKTableHandler.GetSelectedCells() ;\r
 448         if ( cells.length != 1 )\r
 449                 return ;\r
 450 \r
 451         var refCell = cells[0] ;\r
 452         var tableMap = this._CreateTableMap( refCell ) ;\r
 453         var rowIdx = refCell.parentNode.rowIndex ;\r
 454         var colIdx = FCKTableHandler._GetCellIndexSpan( tableMap, rowIdx, refCell ) ;\r
 455         var cellSpan = isNaN( refCell.colSpan ) ? 1 : refCell.colSpan ;\r
 456 \r
 457         if ( cellSpan > 1 )\r
 458         {\r
 459                 // Splitting a multi-column cell - original cell gets ceil(colSpan/2) columns,\r
 460                 // new cell gets floor(colSpan/2).\r
 461                 var newCellSpan = Math.ceil( cellSpan / 2 ) ;\r
 462                 var newCell = FCK.EditorDocument.createElement( refCell.nodeName ) ;\r
 463                 if ( FCKBrowserInfo.IsGeckoLike )\r
 464                         FCKTools.AppendBogusBr( newCell ) ;\r
 465                 var startIdx = colIdx + newCellSpan ;\r
 466                 var endIdx = colIdx + cellSpan ;\r
 467                 var rowSpan = isNaN( refCell.rowSpan ) ? 1 : refCell.rowSpan ;\r
 468                 for ( var r = rowIdx ; r < rowIdx + rowSpan ; r++ )\r
 469                 {\r
 470                         for ( var i = startIdx ; i < endIdx ; i++ )\r
 471                                 tableMap[r][i] = newCell ;\r
 472                 }\r
 473         }\r
 474         else\r
 475         {\r
 476                 // Splitting a single-column cell - add a new cell, and expand\r
 477                 // cells crossing the same column.\r
 478                 var newTableMap = [] ;\r
 479                 for ( var i = 0 ; i < tableMap.length ; i++ )\r
 480                 {\r
 481                         var newRow = tableMap[i].slice( 0, colIdx ) ;\r
 482                         if ( tableMap[i].length <= colIdx )\r
 483                         {\r
 484                                 newTableMap.push( newRow ) ;\r
 485                                 continue ;\r
 486                         }\r
 487                         if ( tableMap[i][colIdx] == refCell )\r
 488                         {\r
 489                                 newRow.push( refCell ) ;\r
 490                                 newRow.push( FCK.EditorDocument.createElement( refCell.nodeName ) ) ;\r
 491                                 if ( FCKBrowserInfo.IsGeckoLike )\r
 492                                         FCKTools.AppendBogusBr( newRow[newRow.length - 1] ) ;\r
 493                         }\r
 494                         else\r
 495                         {\r
 496                                 newRow.push( tableMap[i][colIdx] ) ;\r
 497                                 newRow.push( tableMap[i][colIdx] ) ;\r
 498                         }\r
 499                         for ( var j = colIdx + 1 ; j < tableMap[i].length ; j++ )\r
 500                                 newRow.push( tableMap[i][j] ) ;\r
 501                         newTableMap.push( newRow ) ;\r
 502                 }\r
 503                 tableMap = newTableMap ;\r
 504         }\r
 505 \r
 506         this._InstallTableMap( tableMap, refCell.parentNode.parentNode.parentNode ) ;\r
 507 }\r
 508 \r
 509 FCKTableHandler.VerticalSplitCell = function()\r
 510 {\r
 511         var cells = FCKTableHandler.GetSelectedCells() ;\r
 512         if ( cells.length != 1 )\r
 513                 return ;\r
 514 \r
 515         var currentCell = cells[0] ;\r
 516         var tableMap = this._CreateTableMap( currentCell ) ;\r
 517         var currentRowIndex = currentCell.parentNode.rowIndex ;\r
 518         var cellIndex = FCKTableHandler._GetCellIndexSpan( tableMap, currentRowIndex, currentCell ) ;\r
 519         // Save current cell colSpan\r
 520         var currentColSpan = isNaN( currentCell.colSpan ) ? 1 : currentCell.colSpan ;\r
 521         var currentRowSpan = currentCell.rowSpan ;\r
 522         if ( isNaN( currentRowSpan ) )\r
 523                 currentRowSpan = 1 ;\r
 524 \r
 525         if ( currentRowSpan > 1 )\r
 526         {\r
 527                 // 1. Set the current cell's rowSpan to 1.\r
 528                 currentCell.rowSpan = Math.ceil( currentRowSpan / 2 ) ;\r
 529 \r
 530                 // 2. Find the appropriate place to insert a new cell at the next row.\r
 531                 var newCellRowIndex = currentRowIndex + Math.ceil( currentRowSpan / 2 ) ;\r
 532                 var oRow = tableMap[newCellRowIndex] ;\r
 533                 var insertMarker = null ;\r
 534                 for ( var i = cellIndex+1 ; i < oRow.length ; i++ )\r
 535                 {\r
 536                         if ( oRow[i].parentNode.rowIndex == newCellRowIndex )\r
 537                         {\r
 538                                 insertMarker = oRow[i] ;\r
 539                                 break ;\r
 540                         }\r
 541                 }\r
 542 \r
 543                 // 3. Insert the new cell to the indicated place, with the appropriate rowSpan and colSpan, next row.\r
 544                 var newCell = FCK.EditorDocument.createElement( currentCell.nodeName ) ;\r
 545                 newCell.rowSpan = Math.floor( currentRowSpan / 2 ) ;\r
 546                 if ( currentColSpan > 1 )\r
 547                         newCell.colSpan = currentColSpan ;\r
 548                 if ( FCKBrowserInfo.IsGeckoLike )\r
 549                         FCKTools.AppendBogusBr( newCell ) ;\r
 550                 currentCell.parentNode.parentNode.parentNode.rows[newCellRowIndex].insertBefore( newCell, insertMarker ) ;\r
 551         }\r
 552         else\r
 553         {\r
 554                 // 1. Insert a new row.\r
 555                 var newSectionRowIdx = currentCell.parentNode.sectionRowIndex + 1 ;\r
 556                 var newRow = FCK.EditorDocument.createElement( 'tr' ) ;\r
 557                 var tSection = currentCell.parentNode.parentNode ;\r
 558                 if ( tSection.rows.length > newSectionRowIdx )\r
 559                         tSection.insertBefore( newRow, tSection.rows[newSectionRowIdx] ) ;\r
 560                 else\r
 561                         tSection.appendChild( newRow ) ;\r
 562 \r
 563                 // 2. +1 to rowSpan for all cells crossing currentCell's row.\r
 564                 for ( var i = 0 ; i < tableMap[currentRowIndex].length ; )\r
 565                 {\r
 566                         var colSpan = tableMap[currentRowIndex][i].colSpan ;\r
 567                         if ( isNaN( colSpan ) || colSpan < 1 )\r
 568                                 colSpan = 1 ;\r
 569                         if ( i == cellIndex )\r
 570                         {\r
 571                                 i += colSpan ;\r
 572                                 continue ;\r
 573                         }\r
 574                         var rowSpan = tableMap[currentRowIndex][i].rowSpan ;\r
 575                         if ( isNaN( rowSpan ) )\r
 576                                 rowSpan = 1 ;\r
 577                         tableMap[currentRowIndex][i].rowSpan = rowSpan + 1 ;\r
 578                         i += colSpan ;\r
 579                 }\r
 580 \r
 581                 // 3. Insert a new cell to new row. Set colSpan on the new cell.\r
 582                 var newCell = FCK.EditorDocument.createElement( currentCell.nodeName ) ;\r
 583                 if ( currentColSpan > 1 )\r
 584                         newCell.colSpan = currentColSpan ;\r
 585                 if ( FCKBrowserInfo.IsGeckoLike )\r
 586                         FCKTools.AppendBogusBr( newCell ) ;\r
 587                 newRow.appendChild( newCell ) ;\r
 588         }\r
 589 }\r
 590 \r
 591 // Get the cell index from a TableMap.\r
 592 FCKTableHandler._GetCellIndexSpan = function( tableMap, rowIndex, cell )\r
 593 {\r
 594         if ( tableMap.length < rowIndex + 1 )\r
 595                 return null ;\r
 596 \r
 597         var oRow = tableMap[ rowIndex ] ;\r
 598 \r
 599         for ( var c = 0 ; c < oRow.length ; c++ )\r
 600         {\r
 601                 if ( oRow[c] == cell )\r
 602                         return c ;\r
 603         }\r
 604 \r
 605         return null ;\r
 606 }\r
 607 \r
 608 // Get the cell location from a TableMap. Returns an array with an [x,y] location\r
 609 FCKTableHandler._GetCellLocation = function( tableMap, cell  )\r
 610 {\r
 611         for ( var i = 0 ; i < tableMap.length; i++ )\r
 612         {\r
 613                 for ( var c = 0 ; c < tableMap[i].length ; c++  )\r
 614                 {\r
 615                         if ( tableMap[i][c] == cell  ) return [i,c];\r
 616                 }\r
 617         }\r
 618         return null ;\r
 619 }\r
 620 \r
 621 // This function is quite hard to explain. It creates a matrix representing all cells in a table.\r
 622 // The difference here is that the "spanned" cells (colSpan and rowSpan) are duplicated on the matrix\r
 623 // cells that are "spanned". For example, a row with 3 cells where the second cell has colSpan=2 and rowSpan=3\r
 624 // will produce a bi-dimensional matrix with the following values (representing the cells):\r
 625 //              Cell1, Cell2, Cell2, Cell3\r
 626 //              Cell4, Cell2, Cell2, Cell5\r
 627 //              Cell6, Cell2, Cell2, Cell7\r
 628 FCKTableHandler._CreateTableMap = function( refCell )\r
 629 {\r
 630         var table = (refCell.nodeName == 'TABLE' ? refCell : refCell.parentNode.parentNode.parentNode ) ;\r
 631 \r
 632         var aRows = table.rows ;\r
 633 \r
 634         // Row and Column counters.\r
 635         var r = -1 ;\r
 636 \r
 637         var aMap = new Array() ;\r
 638 \r
 639         for ( var i = 0 ; i < aRows.length ; i++ )\r
 640         {\r
 641                 r++ ;\r
 642                 if ( !aMap[r] )\r
 643                         aMap[r] = new Array() ;\r
 644 \r
 645                 var c = -1 ;\r
 646 \r
 647                 for ( var j = 0 ; j < aRows[i].cells.length ; j++ )\r
 648                 {\r
 649                         var oCell = aRows[i].cells[j] ;\r
 650 \r
 651                         c++ ;\r
 652                         while ( aMap[r][c] )\r
 653                                 c++ ;\r
 654 \r
 655                         var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ;\r
 656                         var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan ;\r
 657 \r
 658                         for ( var rs = 0 ; rs < iRowSpan ; rs++ )\r
 659                         {\r
 660                                 if ( !aMap[r + rs] )\r
 661                                         aMap[r + rs] = new Array() ;\r
 662 \r
 663                                 for ( var cs = 0 ; cs < iColSpan ; cs++ )\r
 664                                 {\r
 665                                         aMap[r + rs][c + cs] = aRows[i].cells[j] ;\r
 666                                 }\r
 667                         }\r
 668 \r
 669                         c += iColSpan - 1 ;\r
 670                 }\r
 671         }\r
 672         return aMap ;\r
 673 }\r
 674 \r
 675 // This function is the inverse of _CreateTableMap - it takes in a table map and converts it to an HTML table.\r
 676 FCKTableHandler._InstallTableMap = function( tableMap, table )\r
 677 {\r
 678         // Workaround for #1917 : MSIE will always report a cell's rowSpan as 1 as long\r
 679         // as the cell is not attached to a row. So we'll need an alternative attribute\r
 680         // for storing the calculated rowSpan in IE.\r
 681         var rowSpanAttr = FCKBrowserInfo.IsIE ? "_fckrowspan" : "rowSpan" ;\r
 682 \r
 683         // Disconnect all the cells in tableMap from their parents, set all colSpan and rowSpan attributes to 1.\r
 684         for ( var i = 0 ; i < tableMap.length ; i++ )\r
 685         {\r
 686                 for ( var j = 0 ; j < tableMap[i].length ; j++ )\r
 687                 {\r
 688                         var cell = tableMap[i][j] ;\r
 689                         if ( cell.parentNode )\r
 690                                 cell.parentNode.removeChild( cell ) ;\r
 691                         cell.colSpan = cell[rowSpanAttr] = 1 ;\r
 692                 }\r
 693         }\r
 694 \r
 695         // Scan by rows and set colSpan.\r
 696         var maxCol = 0 ;\r
 697         for ( var i = 0 ; i < tableMap.length ; i++ )\r
 698         {\r
 699                 for ( var j = 0 ; j < tableMap[i].length ; j++ )\r
 700                 {\r
 701                         var cell = tableMap[i][j] ;\r
 702                         if ( ! cell)\r
 703                                 continue ;\r
 704                         if ( j > maxCol )\r
 705                                 maxCol = j ;\r
 706                         if ( cell._colScanned === true )\r
 707                                 continue ;\r
 708                         if ( tableMap[i][j-1] == cell )\r
 709                                 cell.colSpan++ ;\r
 710                         if ( tableMap[i][j+1] != cell )\r
 711                                 cell._colScanned = true ;\r
 712                 }\r
 713         }\r
 714 \r
 715         // Scan by columns and set rowSpan.\r
 716         for ( var i = 0 ; i <= maxCol ; i++ )\r
 717         {\r
 718                 for ( var j = 0 ; j < tableMap.length ; j++ )\r
 719                 {\r
 720                         if ( ! tableMap[j] )\r
 721                                 continue ;\r
 722                         var cell = tableMap[j][i] ;\r
 723                         if ( ! cell || cell._rowScanned === true )\r
 724                                 continue ;\r
 725                         if ( tableMap[j-1] && tableMap[j-1][i] == cell )\r
 726                                 cell[rowSpanAttr]++ ;\r
 727                         if ( ! tableMap[j+1] || tableMap[j+1][i] != cell )\r
 728                                 cell._rowScanned = true ;\r
 729                 }\r
 730         }\r
 731 \r
 732         // Clear all temporary flags.\r
 733         for ( var i = 0 ; i < tableMap.length ; i++ )\r
 734         {\r
 735                 for ( var j = 0 ; j < tableMap[i].length ; j++)\r
 736                 {\r
 737                         var cell = tableMap[i][j] ;\r
 738                         FCKDomTools.ClearElementJSProperty(cell, '_colScanned' ) ;\r
 739                         FCKDomTools.ClearElementJSProperty(cell, '_rowScanned' ) ;\r
 740                 }\r
 741         }\r
 742 \r
 743         // Insert physical rows and columns to the table.\r
 744         for ( var i = 0 ; i < tableMap.length ; i++ )\r
 745         {\r
 746                 var rowObj = FCK.EditorDocument.createElement( 'tr' ) ;\r
 747                 for ( var j = 0 ; j < tableMap[i].length ; )\r
 748                 {\r
 749                         var cell = tableMap[i][j] ;\r
 750                         if ( tableMap[i-1] && tableMap[i-1][j] == cell )\r
 751                         {\r
 752                                 j += cell.colSpan ;\r
 753                                 continue ;\r
 754                         }\r
 755                         rowObj.appendChild( cell ) ;\r
 756                         if ( rowSpanAttr != 'rowSpan' )\r
 757                         {\r
 758                                 cell.rowSpan = cell[rowSpanAttr] ;\r
 759                                 cell.removeAttribute( rowSpanAttr ) ;\r
 760                         }\r
 761                         j += cell.colSpan ;\r
 762                         if ( cell.colSpan == 1 )\r
 763                                 cell.removeAttribute( 'colspan' ) ;\r
 764                         if ( cell.rowSpan == 1 )\r
 765                                 cell.removeAttribute( 'rowspan' ) ;\r
 766                 }\r
 767                 if ( FCKBrowserInfo.IsIE )\r
 768                 {\r
 769                         table.rows[i].replaceNode( rowObj ) ;\r
 770                 }\r
 771                 else\r
 772                 {\r
 773                         table.rows[i].innerHTML = '' ;\r
 774                         FCKDomTools.MoveChildren( rowObj, table.rows[i] ) ;\r
 775                 }\r
 776         }\r
 777 }\r
 778 \r
 779 FCKTableHandler._MoveCaretToCell = function ( refCell, toStart )\r
 780 {\r
 781         var range = new FCKDomRange( FCK.EditorWindow ) ;\r
 782         range.MoveToNodeContents( refCell ) ;\r
 783         range.Collapse( toStart ) ;\r
 784         range.Select() ;\r
 785 }\r
 786 \r
 787 FCKTableHandler.ClearRow = function( tr )\r
 788 {\r
 789         // Get the array of row's cells.\r
 790         var aCells = tr.cells ;\r
 791 \r
 792         // Replace the contents of each cell with "nothing".\r
 793         for ( var i = 0 ; i < aCells.length ; i++ )\r
 794         {\r
 795                 aCells[i].innerHTML = '' ;\r
 796 \r
 797                 if ( FCKBrowserInfo.IsGeckoLike )\r
 798                         FCKTools.AppendBogusBr( aCells[i] ) ;\r
 799         }\r
 800 }\r
 801 \r
 802 FCKTableHandler.GetMergeRightTarget = function()\r
 803 {\r
 804         var cells = this.GetSelectedCells() ;\r
 805         if ( cells.length != 1 )\r
 806                 return null ;\r
 807 \r
 808         var refCell = cells[0] ;\r
 809         var tableMap = this._CreateTableMap( refCell ) ;\r
 810         var rowIdx = refCell.parentNode.rowIndex ;\r
 811         var colIdx = this._GetCellIndexSpan( tableMap, rowIdx, refCell ) ;\r
 812         var nextColIdx = colIdx + ( isNaN( refCell.colSpan ) ? 1 : refCell.colSpan ) ;\r
 813         var nextCell = tableMap[rowIdx][nextColIdx] ;\r
 814 \r
 815         if ( ! nextCell )\r
 816                 return null ;\r
 817 \r
 818         // The two cells must have the same vertical geometry, otherwise merging does not make sense.\r
 819         this._MarkCells( [refCell, nextCell], '_SizeTest' ) ;\r
 820         var refGeometry = this._GetMarkerGeometry( tableMap, rowIdx, colIdx, '_SizeTest' ) ;\r
 821         var nextGeometry = this._GetMarkerGeometry( tableMap, rowIdx, nextColIdx, '_SizeTest' ) ;\r
 822         this._UnmarkCells( [refCell, nextCell], '_SizeTest' ) ;\r
 823 \r
 824         if ( refGeometry.height != nextGeometry.height || refGeometry.y != nextGeometry.y )\r
 825                 return null ;\r
 826 \r
 827         return { 'refCell' : refCell, 'nextCell' : nextCell, 'tableMap' : tableMap } ;\r
 828 }\r
 829 \r
 830 FCKTableHandler.GetMergeDownTarget = function()\r
 831 {\r
 832         var cells = this.GetSelectedCells() ;\r
 833         if ( cells.length != 1 )\r
 834                 return null ;\r
 835 \r
 836         var refCell = cells[0] ;\r
 837         var tableMap = this._CreateTableMap( refCell ) ;\r
 838         var rowIdx = refCell.parentNode.rowIndex ;\r
 839         var colIdx = this._GetCellIndexSpan( tableMap, rowIdx, refCell ) ;\r
 840         var newRowIdx = rowIdx + ( isNaN( refCell.rowSpan ) ? 1 : refCell.rowSpan ) ;\r
 841         if ( ! tableMap[newRowIdx] )\r
 842                 return null ;\r
 843 \r
 844         var nextCell = tableMap[newRowIdx][colIdx] ;\r
 845 \r
 846         if ( ! nextCell )\r
 847                 return null ;\r
 848 \r
 849         // Check if the selected cells are both in the same table section (thead, tfoot or tbody).\r
 850         if ( refCell.parentNode.parentNode != nextCell.parentNode.parentNode )\r
 851                 return null ;\r
 852 \r
 853         // The two cells must have the same horizontal geometry, otherwise merging does not makes sense.\r
 854         this._MarkCells( [refCell, nextCell], '_SizeTest' ) ;\r
 855         var refGeometry = this._GetMarkerGeometry( tableMap, rowIdx, colIdx, '_SizeTest' ) ;\r
 856         var nextGeometry = this._GetMarkerGeometry( tableMap, newRowIdx, colIdx, '_SizeTest' ) ;\r
 857         this._UnmarkCells( [refCell, nextCell], '_SizeTest' ) ;\r
 858 \r
 859         if ( refGeometry.width != nextGeometry.width || refGeometry.x != nextGeometry.x )\r
 860                 return null ;\r
 861 \r
 862         return { 'refCell' : refCell, 'nextCell' : nextCell, 'tableMap' : tableMap } ;\r
 863 }\r