| 89 | | function createTableMap( $refCell ) |
| 90 | | { |
| 91 | | var refCell = new CKEDITOR.dom.element( $refCell ); |
| 92 | | var $table = ( refCell.getName() == 'table' ? $refCell : refCell.getAscendant( 'table' ) ).$; |
| 93 | | var $rows = $table.rows; |
| 94 | | |
| 95 | | // Row and column counters. |
| 96 | | var r = -1; |
| 97 | | var map = []; |
| 98 | | for ( var i = 0 ; i < $rows.length ; i++ ) |
| 99 | | { |
| 100 | | r++; |
| 101 | | if ( !map[ r ] ) |
| 102 | | map[ r ] = []; |
| 103 | | |
| 104 | | var c = -1; |
| 105 | | |
| 106 | | for ( var j = 0 ; j < $rows[ i ].cells.length ; j++ ) |
| 107 | | { |
| 108 | | var $cell = $rows[ i ].cells[ j ]; |
| 109 | | |
| 110 | | c++; |
| 111 | | while ( map[ r ][ c ] ) |
| 112 | | c++; |
| 113 | | |
| 114 | | var colSpan = isNaN( $cell.colSpan ) ? 1 : $cell.colSpan; |
| 115 | | var rowSpan = isNaN( $cell.rowSpan ) ? 1 : $cell.rowSpan; |
| 116 | | |
| 117 | | for ( var rs = 0 ; rs < rowSpan ; rs++ ) |
| 118 | | { |
| 119 | | if ( !map[ r + rs ] ) |
| 120 | | map[ r + rs ] = []; |
| 121 | | |
| 122 | | for ( var cs = 0 ; cs < colSpan ; cs++ ) |
| 123 | | map [ r + rs ][ c + cs ] = $rows[ i ].cells[ j ]; |
| 124 | | } |
| 125 | | |
| 126 | | c += colSpan - 1; |
| 127 | | } |
| 128 | | } |
| 129 | | |
| 130 | | return map; |
| 131 | | } |
| 132 | | |
| 133 | | function installTableMap( tableMap, $table ) |
| 134 | | { |
| 135 | | /* |
| 136 | | * IE BUG: rowSpan is always 1 in IE if the cell isn't attached to a row. So |
| 137 | | * store is separately in another attribute. (#1917) |
| 138 | | */ |
| 139 | | var rowSpanAttr = CKEDITOR.env.ie ? '_cke_rowspan' : 'rowSpan'; |
| 140 | | |
| 141 | | /* |
| 142 | | * Disconnect all the cells in tableMap from their parents, set all colSpan |
| 143 | | * and rowSpan attributes to 1. |
| 144 | | */ |
| 145 | | for ( var i = 0 ; i < tableMap.length ; i++ ) |
| 146 | | { |
| 147 | | for ( var j = 0 ; j < tableMap[ i ].length ; j++ ) |
| 148 | | { |
| 149 | | var $cell = tableMap[ i ][ j ]; |
| 150 | | if ( $cell.parentNode ) |
| 151 | | $cell.parentNode.removeChild( $cell ); |
| 152 | | $cell.colSpan = $cell[ rowSpanAttr ] = 1; |
| 153 | | } |
| 154 | | } |
| 155 | | |
| 156 | | // Scan by rows and set colSpan. |
| 157 | | var maxCol = 0; |
| 158 | | for ( i = 0 ; i < tableMap.length ; i++ ) |
| 159 | | { |
| 160 | | for ( j = 0 ; j < tableMap[ i ].length ; j++ ) |
| 161 | | { |
| 162 | | $cell = tableMap[ i ][ j ]; |
| 163 | | if ( !$cell ) |
| 164 | | continue; |
| 165 | | if ( j > maxCol ) |
| 166 | | maxCol = j; |
| 167 | | if ( $cell[ '_cke_colScanned' ] ) |
| 168 | | continue; |
| 169 | | if ( tableMap[ i ][ j - 1 ] == $cell ) |
| 170 | | $cell.colSpan++; |
| 171 | | if ( tableMap[ i ][ j + 1 ] != $cell ) |
| 172 | | $cell[ '_cke_colScanned' ] = 1; |
| 173 | | } |
| 174 | | } |
| 175 | | |
| 176 | | // Scan by columns and set rowSpan. |
| 177 | | for ( i = 0 ; i <= maxCol ; i++ ) |
| 178 | | { |
| 179 | | for ( j = 0 ; j < tableMap.length ; j++ ) |
| 180 | | { |
| 181 | | if ( !tableMap[ j ] ) |
| 182 | | continue; |
| 183 | | $cell = tableMap[ j ][ i ]; |
| 184 | | if ( !$cell || $cell[ '_cke_rowScanned' ] ) |
| 185 | | continue; |
| 186 | | if ( tableMap[ j - 1 ] && tableMap[ j - 1 ][ i ] == $cell ) |
| 187 | | $cell[ rowSpanAttr ]++; |
| 188 | | if ( !tableMap[ j + 1 ] || tableMap[ j + 1 ][ i ] != $cell ) |
| 189 | | $cell[ '_cke_rowScanned' ] = 1; |
| 190 | | } |
| 191 | | } |
| 192 | | |
| 193 | | // Clear all temporary flags. |
| 194 | | for ( i = 0 ; i < tableMap.length ; i++ ) |
| 195 | | { |
| 196 | | for ( j = 0 ; j < tableMap[ i ].length ; j++ ) |
| 197 | | { |
| 198 | | $cell = tableMap[ i ][ j ]; |
| 199 | | removeRawAttribute( $cell, '_cke_colScanned' ); |
| 200 | | removeRawAttribute( $cell, '_cke_rowScanned' ); |
| 201 | | } |
| 202 | | } |
| 203 | | |
| 204 | | // Insert physical rows and columns to table. |
| 205 | | for ( i = 0 ; i < tableMap.length ; i++ ) |
| 206 | | { |
| 207 | | var $row = $table.ownerDocument.createElement( 'tr' ); |
| 208 | | for ( j = 0 ; j < tableMap[ i ].length ; ) |
| 209 | | { |
| 210 | | $cell = tableMap[ i ][ j ]; |
| 211 | | if ( tableMap[ i - 1 ] && tableMap[ i - 1 ][ j ] == $cell ) |
| 212 | | { |
| 213 | | j += $cell.colSpan; |
| 214 | | continue; |
| 215 | | } |
| 216 | | $row.appendChild( $cell ); |
| 217 | | if ( rowSpanAttr != 'rowSpan' ) |
| 218 | | { |
| 219 | | $cell.rowSpan = $cell[ rowSpanAttr ]; |
| 220 | | $cell.removeAttribute( rowSpanAttr ); |
| 221 | | } |
| 222 | | j += $cell.colSpan; |
| 223 | | if ( $cell.colSpan == 1 ) |
| 224 | | $cell.removeAttribute( 'colSpan' ); |
| 225 | | if ( $cell.rowSpan == 1 ) |
| 226 | | $cell.removeAttribute( 'rowSpan' ); |
| 227 | | } |
| 228 | | |
| 229 | | if ( CKEDITOR.env.ie ) |
| 230 | | $table.rows[ i ].replaceNode( $row ); |
| 231 | | else |
| 232 | | { |
| 233 | | var dest = new CKEDITOR.dom.element( $table.rows[ i ] ); |
| 234 | | var src = new CKEDITOR.dom.element( $row ); |
| 235 | | dest.setHtml( '' ); |
| 236 | | src.moveChildren( dest ); |
| 237 | | } |
| 238 | | } |
| 239 | | } |
| 240 | | |
| | 267 | function placeCursorInCell( cell ) |
| | 268 | { |
| | 269 | var range = new CKEDITOR.dom.range( cell.getDocument() ); |
| | 270 | range.selectNodeContents( cell ); |
| | 271 | range.collapse(); |
| | 272 | range.select( true ); |
| | 273 | } |
| | 274 | |
| | 275 | function buildTableMap( table ) |
| | 276 | { |
| | 277 | |
| | 278 | var aRows = table.$.rows ; |
| | 279 | |
| | 280 | // Row and Column counters. |
| | 281 | var r = -1 ; |
| | 282 | |
| | 283 | var aMap = []; |
| | 284 | |
| | 285 | for ( var i = 0 ; i < aRows.length ; i++ ) |
| | 286 | { |
| | 287 | r++ ; |
| | 288 | !aMap[r] && ( aMap[r] = [] ); |
| | 289 | |
| | 290 | var c = -1 ; |
| | 291 | |
| | 292 | for ( var j = 0 ; j < aRows[i].cells.length ; j++ ) |
| | 293 | { |
| | 294 | var oCell = aRows[i].cells[j] ; |
| | 295 | |
| | 296 | c++ ; |
| | 297 | while ( aMap[r][c] ) |
| | 298 | c++ ; |
| | 299 | |
| | 300 | var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ; |
| | 301 | var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan ; |
| | 302 | |
| | 303 | for ( var rs = 0 ; rs < iRowSpan ; rs++ ) |
| | 304 | { |
| | 305 | if ( !aMap[r + rs] ) |
| | 306 | aMap[r + rs] = new Array() ; |
| | 307 | |
| | 308 | for ( var cs = 0 ; cs < iColSpan ; cs++ ) |
| | 309 | { |
| | 310 | aMap[r + rs][c + cs] = aRows[i].cells[j] ; |
| | 311 | } |
| | 312 | } |
| | 313 | |
| | 314 | c += iColSpan - 1 ; |
| | 315 | } |
| | 316 | } |
| | 317 | return aMap ; |
| | 318 | } |
| | 319 | |
| | 320 | function cellInRow( tableMap, rowIndex, cell ) |
| | 321 | { |
| | 322 | var oRow = tableMap[ rowIndex ]; |
| | 323 | if( typeof cell == 'undefined' ) |
| | 324 | return oRow; |
| | 325 | |
| | 326 | for ( var c = 0 ; oRow && c < oRow.length ; c++ ) |
| | 327 | { |
| | 328 | if ( cell.is && oRow[c] == cell.$ ) |
| | 329 | return c; |
| | 330 | else if( c == cell ) |
| | 331 | return new CKEDITOR.dom.element( oRow[ c ] ); |
| | 332 | } |
| | 333 | return cell.is ? -1 : null; |
| | 334 | } |
| | 335 | |
| | 336 | function cellInCol( tableMap, colIndex, cell ) |
| | 337 | { |
| | 338 | var oCol = []; |
| | 339 | for ( var r = 0; r < tableMap.length; r++ ) |
| | 340 | { |
| | 341 | var row = tableMap[ r ]; |
| | 342 | if( typeof cell == 'undefined' ) |
| | 343 | oCol.push( row[ colIndex ] ); |
| | 344 | else if( cell.is && row[ colIndex ] == cell.$ ) |
| | 345 | return r; |
| | 346 | else if( r == cell ) |
| | 347 | return new CKEDITOR.dom.element( row[ colIndex ] ); |
| | 348 | } |
| | 349 | |
| | 350 | return ( typeof cell == 'undefined' )? oCol : cell.is ? -1 : null; |
| | 351 | } |
| | 352 | |
| | 353 | function mergeCells( selection, isDetect ) |
| | 354 | { |
| | 355 | var cells = getSelectedCells( selection ); |
| | 356 | if( cells.length < 2 ) |
| | 357 | return false; |
| | 358 | |
| | 359 | var cell, |
| | 360 | firstCell = cells[ 0 ], |
| | 361 | table = firstCell.getAscendant( 'table' ), |
| | 362 | doc = firstCell.getDocument(), |
| | 363 | map = buildTableMap( table ), |
| | 364 | mapHeight = map.length, |
| | 365 | mapWidth = map[ 0 ].length, |
| | 366 | startRow = firstCell.getParent().$.rowIndex, |
| | 367 | startColumn = cellInRow( map, startRow, firstCell ), |
| | 368 | lastRowIndex = startRow, |
| | 369 | totalRowSpan = 0, |
| | 370 | totalColSpan = 0, |
| | 371 | // Use a documentFragment as buffer when appending cell contents. |
| | 372 | frag = !isDetect && new CKEDITOR.dom.documentFragment( doc ), |
| | 373 | dimension = 0; |
| | 374 | |
| | 375 | for ( var i = 0; i < cells.length; i++ ) |
| | 376 | { |
| | 377 | cell = cells[ i ]; |
| | 378 | |
| | 379 | var tr = cell.getParent(), |
| | 380 | cellFirstChild = cell.getFirst(), |
| | 381 | colSpan = cell.$.colSpan, |
| | 382 | rowSpan = cell.$.rowSpan, |
| | 383 | rowIndex = tr.$.rowIndex, |
| | 384 | colIndex = cellInRow( map, rowIndex, cell ); |
| | 385 | |
| | 386 | // Accumulated the actual places taken by all selected cells. |
| | 387 | dimension += colSpan * rowSpan; |
| | 388 | // Accumulated the maximum virtual spans from column and row. |
| | 389 | totalColSpan = Math.max( totalColSpan, colIndex - startColumn + colSpan ) ; |
| | 390 | totalRowSpan = Math.max( totalRowSpan, rowIndex - startRow + rowSpan ); |
| | 391 | |
| | 392 | if ( !isDetect ) |
| | 393 | { |
| | 394 | // Create line-break on new row. |
| | 395 | if( rowIndex != lastRowIndex |
| | 396 | && cellFirstChild |
| | 397 | && !( cellFirstChild.isBlockBoundary |
| | 398 | && cellFirstChild.isBlockBoundary( { br : 1 } ) ) ) |
| | 399 | frag.append( new CKEDITOR.dom.element( 'br', doc ) ); |
| | 400 | |
| | 401 | cell.moveChildren( frag ); |
| | 402 | i && cell.remove(); |
| | 403 | } |
| | 404 | lastRowIndex = rowIndex; |
| | 405 | } |
| | 406 | |
| | 407 | if ( !isDetect ) |
| | 408 | { |
| | 409 | frag.moveChildren( firstCell ); |
| | 410 | |
| | 411 | if( totalColSpan >= mapWidth ) |
| | 412 | firstCell.removeAttribute( 'rowSpan' ); |
| | 413 | else |
| | 414 | firstCell.$.rowSpan = totalRowSpan; |
| | 415 | |
| | 416 | if( totalRowSpan >= mapHeight ) |
| | 417 | firstCell.removeAttribute( 'colSpan' ); |
| | 418 | else |
| | 419 | firstCell.$.colSpan = totalColSpan; |
| | 420 | |
| | 421 | // Swip empty <tr> left at the end of table due to the merging. |
| | 422 | var trs = new CKEDITOR.dom.nodeList( table.$.rows ), |
| | 423 | count = trs.count(); |
| | 424 | |
| | 425 | for ( var i = count - 1; i >= 0; i-- ) |
| | 426 | { |
| | 427 | var tailTr = trs.getItem( i ); |
| | 428 | if( !tailTr.$.cells.length ) |
| | 429 | { |
| | 430 | tailTr.remove(); |
| | 431 | count++; |
| | 432 | continue; |
| | 433 | } |
| | 434 | else |
| | 435 | break; |
| | 436 | } |
| | 437 | |
| | 438 | return firstCell; |
| | 439 | } |
| | 440 | // Be able to merge cells only if actual dimension of selected |
| | 441 | // cells equals to the caculated rectangle. |
| | 442 | else |
| | 443 | return ( totalRowSpan * totalColSpan ) == dimension; |
| | 444 | } |
| | 445 | |
| | 446 | function verticalSplitCell ( selection, isDetect ) |
| | 447 | { |
| | 448 | var cells = getSelectedCells( selection ); |
| | 449 | if( cells.length > 1 ) |
| | 450 | return false; |
| | 451 | else if( isDetect ) |
| | 452 | return true; |
| | 453 | |
| | 454 | var cell = cells[ 0 ], |
| | 455 | tr = cell.getParent(), |
| | 456 | table = tr.getAscendant( 'table' ), |
| | 457 | map = buildTableMap( table ), |
| | 458 | rowIndex = tr.$.rowIndex, |
| | 459 | colIndex = cellInRow( map, rowIndex, cell ), |
| | 460 | rowSpan = cell.$.rowSpan, |
| | 461 | newCell, |
| | 462 | newRowSpan, |
| | 463 | newCellRowSpan, |
| | 464 | newRowIndex; |
| | 465 | |
| | 466 | if( rowSpan > 1 ) |
| | 467 | { |
| | 468 | newRowSpan = Math.ceil( rowSpan / 2 ); |
| | 469 | newCellRowSpan = Math.floor( rowSpan / 2 ); |
| | 470 | newRowIndex = rowIndex + newRowSpan; |
| | 471 | var newCellTr = new CKEDITOR.dom.element( table.$.rows[ newRowIndex ] ), |
| | 472 | newCellRow = cellInRow( map, newRowIndex ), |
| | 473 | candidateCell; |
| | 474 | |
| | 475 | newCell = cell.clone(); |
| | 476 | |
| | 477 | // Figure out where to insert the new cell by checking the vitual row. |
| | 478 | for ( var c = 0; c < newCellRow.length; c++ ) |
| | 479 | { |
| | 480 | candidateCell = newCellRow[ c ]; |
| | 481 | // Catch first cell actually following the column. |
| | 482 | if( candidateCell.parentNode == newCellTr.$ |
| | 483 | && c > colIndex ) |
| | 484 | { |
| | 485 | newCell.insertBefore( new CKEDITOR.dom.element( candidateCell ) ); |
| | 486 | break; |
| | 487 | } |
| | 488 | else |
| | 489 | candidateCell = null; |
| | 490 | } |
| | 491 | |
| | 492 | // The destination row is empty, append at will. |
| | 493 | if( !candidateCell ) |
| | 494 | newCellTr.append( newCell, true ); |
| | 495 | } |
| | 496 | else |
| | 497 | { |
| | 498 | newCellRowSpan = newRowSpan = 1; |
| | 499 | var newCellTr = tr.clone(); |
| | 500 | newCellTr.insertAfter( tr ); |
| | 501 | newCellTr.append( newCell = cell.clone() ); |
| | 502 | var cellsInSameRow = cellInRow( map, rowIndex ); |
| | 503 | for ( var i = 0; i < cellsInSameRow.length; i++ ) |
| | 504 | cellsInSameRow[ i ].rowSpan++; |
| | 505 | } |
| | 506 | |
| | 507 | if( !CKEDITOR.env.ie ) |
| | 508 | newCell.appendBogus(); |
| | 509 | cell.$.rowSpan = newRowSpan; |
| | 510 | newCell.$.rowSpan = newCellRowSpan; |
| | 511 | if( newRowSpan == 1 ) |
| | 512 | cell.removeAttribute( 'rowSpan' ); |
| | 513 | if( newCellRowSpan == 1 ) |
| | 514 | newCell.removeAttribute( 'rowSpan' ); |
| | 515 | |
| | 516 | return newCell; |
| | 517 | } |
| | 518 | |
| | 519 | function horizontalSplitCell( selection, isDetect ) |
| | 520 | { |
| | 521 | var cells = getSelectedCells( selection ); |
| | 522 | if( cells.length > 1 ) |
| | 523 | return false; |
| | 524 | else if( isDetect ) |
| | 525 | return true; |
| | 526 | |
| | 527 | var cell = cells[ 0 ], |
| | 528 | tr = cell.getParent(), |
| | 529 | table = tr.getAscendant( 'table' ), |
| | 530 | map = buildTableMap( table ), |
| | 531 | rowIndex = tr.$.rowIndex, |
| | 532 | colIndex = cellInRow( map, rowIndex, cell ), |
| | 533 | colSpan = cell.$.colSpan, |
| | 534 | newCell, |
| | 535 | newColSpan, |
| | 536 | newCellColSpan; |
| | 537 | |
| | 538 | if( colSpan > 1 ) |
| | 539 | { |
| | 540 | newColSpan = Math.ceil( colSpan / 2 ); |
| | 541 | newCellColSpan = Math.floor( colSpan / 2 ); |
| | 542 | } |
| | 543 | else |
| | 544 | { |
| | 545 | newCellColSpan = newColSpan = 1; |
| | 546 | var cellsInSameCol = cellInCol( map, colIndex ); |
| | 547 | for ( var i = 0; i < cellsInSameCol.length; i++ ) |
| | 548 | cellsInSameCol[ i ].colSpan++; |
| | 549 | } |
| | 550 | newCell = cell.clone(); |
| | 551 | newCell.insertAfter( cell ); |
| | 552 | if( !CKEDITOR.env.ie ) |
| | 553 | newCell.appendBogus(); |
| | 554 | |
| | 555 | cell.$.colSpan = newColSpan; |
| | 556 | newCell.$.colSpan = newCellColSpan; |
| | 557 | if( newColSpan == 1 ) |
| | 558 | cell.removeAttribute( 'colSpan' ); |
| | 559 | if( newCellColSpan == 1 ) |
| | 560 | newCell.removeAttribute( 'colSpan' ); |
| | 561 | |
| | 562 | return newCell; |
| | 563 | } |
