[2862] | 1 | /*
|
---|
| 2 | Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
---|
| 3 | For licensing, see LICENSE.html or http://ckeditor.com/license
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | (function()
|
---|
| 7 | {
|
---|
| 8 | function removeRawAttribute( $node, attr )
|
---|
| 9 | {
|
---|
| 10 | if ( CKEDITOR.env.ie )
|
---|
| 11 | $node.removeAttribute( attr );
|
---|
| 12 | else
|
---|
| 13 | delete $node[ attr ];
|
---|
| 14 | }
|
---|
| 15 |
|
---|
| 16 | var cellNodeRegex = /^(?:td|th)$/;
|
---|
| 17 |
|
---|
| 18 | function getSelectedCells( selection )
|
---|
| 19 | {
|
---|
| 20 | // Walker will try to split text nodes, which will make the current selection
|
---|
| 21 | // invalid. So save bookmarks before doing anything.
|
---|
| 22 | var bookmarks = selection.createBookmarks();
|
---|
| 23 |
|
---|
| 24 | var ranges = selection.getRanges();
|
---|
| 25 | var retval = [];
|
---|
| 26 | var database = {};
|
---|
| 27 |
|
---|
| 28 | function moveOutOfCellGuard( node )
|
---|
| 29 | {
|
---|
| 30 | // Apply to the first cell only.
|
---|
| 31 | if ( retval.length > 0 )
|
---|
| 32 | return;
|
---|
| 33 |
|
---|
| 34 | // If we are exiting from the first </td>, then the td should definitely be
|
---|
| 35 | // included.
|
---|
| 36 | if ( node.type == CKEDITOR.NODE_ELEMENT && cellNodeRegex.test( node.getName() )
|
---|
| 37 | && !node.getCustomData( 'selected_cell' ) )
|
---|
| 38 | {
|
---|
| 39 | CKEDITOR.dom.element.setMarker( database, node, 'selected_cell', true );
|
---|
| 40 | retval.push( node );
|
---|
| 41 | }
|
---|
| 42 | }
|
---|
| 43 |
|
---|
| 44 | for ( var i = 0 ; i < ranges.length ; i++ )
|
---|
| 45 | {
|
---|
| 46 | var range = ranges[ i ];
|
---|
| 47 |
|
---|
| 48 | if ( range.collapsed )
|
---|
| 49 | {
|
---|
| 50 | // Walker does not handle collapsed ranges yet - fall back to old API.
|
---|
| 51 | var startNode = range.getCommonAncestor();
|
---|
| 52 | var nearestCell = startNode.getAscendant( 'td', true ) || startNode.getAscendant( 'th', true );
|
---|
| 53 | if ( nearestCell )
|
---|
| 54 | retval.push( nearestCell );
|
---|
| 55 | }
|
---|
| 56 | else
|
---|
| 57 | {
|
---|
| 58 | var walker = new CKEDITOR.dom.walker( range );
|
---|
| 59 | var node;
|
---|
| 60 | walker.guard = moveOutOfCellGuard;
|
---|
| 61 |
|
---|
| 62 | while ( ( node = walker.next() ) )
|
---|
| 63 | {
|
---|
| 64 | // If may be possible for us to have a range like this:
|
---|
| 65 | // <td>^1</td><td>^2</td>
|
---|
| 66 | // The 2nd td shouldn't be included.
|
---|
| 67 | //
|
---|
| 68 | // So we have to take care to include a td we've entered only when we've
|
---|
| 69 | // walked into its children.
|
---|
| 70 |
|
---|
| 71 | var parent = node.getParent();
|
---|
| 72 | if ( parent && cellNodeRegex.test( parent.getName() ) && !parent.getCustomData( 'selected_cell' ) )
|
---|
| 73 | {
|
---|
| 74 | CKEDITOR.dom.element.setMarker( database, parent, 'selected_cell', true );
|
---|
| 75 | retval.push( parent );
|
---|
| 76 | }
|
---|
| 77 | }
|
---|
| 78 | }
|
---|
| 79 | }
|
---|
| 80 |
|
---|
| 81 | CKEDITOR.dom.element.clearAllMarkers( database );
|
---|
| 82 |
|
---|
| 83 | // Restore selection position.
|
---|
| 84 | selection.selectBookmarks( bookmarks );
|
---|
| 85 |
|
---|
| 86 | return retval;
|
---|
| 87 | }
|
---|
| 88 |
|
---|
| 89 | function getFocusedCell( cellsToDelete ) {
|
---|
| 90 | var i = 0,
|
---|
| 91 | last = cellsToDelete.length - 1,
|
---|
| 92 | database = {},
|
---|
| 93 | cell,focusedCell,
|
---|
| 94 | tr;
|
---|
| 95 |
|
---|
| 96 | while ( ( cell = cellsToDelete[ i++ ] ) )
|
---|
| 97 | CKEDITOR.dom.element.setMarker( database, cell, 'delete_cell', true );
|
---|
| 98 |
|
---|
| 99 | // 1.first we check left or right side focusable cell row by row;
|
---|
| 100 | i = 0;
|
---|
| 101 | while ( ( cell = cellsToDelete[ i++ ] ) )
|
---|
| 102 | {
|
---|
| 103 | if ( ( focusedCell = cell.getPrevious() ) && !focusedCell.getCustomData( 'delete_cell' )
|
---|
| 104 | || ( focusedCell = cell.getNext() ) && !focusedCell.getCustomData( 'delete_cell' ) )
|
---|
| 105 | {
|
---|
| 106 | CKEDITOR.dom.element.clearAllMarkers( database );
|
---|
| 107 | return focusedCell;
|
---|
| 108 | }
|
---|
| 109 | }
|
---|
| 110 |
|
---|
| 111 | CKEDITOR.dom.element.clearAllMarkers( database );
|
---|
| 112 |
|
---|
| 113 | // 2. then we check the toppest row (outside the selection area square) focusable cell
|
---|
| 114 | tr = cellsToDelete[ 0 ].getParent();
|
---|
| 115 | if ( ( tr = tr.getPrevious() ) )
|
---|
| 116 | return tr.getLast();
|
---|
| 117 |
|
---|
| 118 | // 3. last we check the lowerest row focusable cell
|
---|
| 119 | tr = cellsToDelete[ last ].getParent();
|
---|
| 120 | if ( ( tr = tr.getNext() ) )
|
---|
| 121 | return tr.getChild( 0 );
|
---|
| 122 |
|
---|
| 123 | return null;
|
---|
| 124 | }
|
---|
| 125 |
|
---|
| 126 | function clearRow( $tr )
|
---|
| 127 | {
|
---|
| 128 | // Get the array of row's cells.
|
---|
| 129 | var $cells = $tr.cells;
|
---|
| 130 |
|
---|
| 131 | // Empty all cells.
|
---|
| 132 | for ( var i = 0 ; i < $cells.length ; i++ )
|
---|
| 133 | {
|
---|
| 134 | $cells[ i ].innerHTML = '';
|
---|
| 135 |
|
---|
| 136 | if ( !CKEDITOR.env.ie )
|
---|
| 137 | ( new CKEDITOR.dom.element( $cells[ i ] ) ).appendBogus();
|
---|
| 138 | }
|
---|
| 139 | }
|
---|
| 140 |
|
---|
| 141 | function insertRow( selection, insertBefore )
|
---|
| 142 | {
|
---|
| 143 | // Get the row where the selection is placed in.
|
---|
| 144 | var row = selection.getStartElement().getAscendant( 'tr' );
|
---|
| 145 | if ( !row )
|
---|
| 146 | return;
|
---|
| 147 |
|
---|
| 148 | // Create a clone of the row.
|
---|
| 149 | var newRow = row.clone( true );
|
---|
| 150 |
|
---|
| 151 | // Insert the new row before of it.
|
---|
| 152 | newRow.insertBefore( row );
|
---|
| 153 |
|
---|
| 154 | // Clean one of the rows to produce the illusion of inserting an empty row
|
---|
| 155 | // before or after.
|
---|
| 156 | clearRow( insertBefore ? newRow.$ : row.$ );
|
---|
| 157 | }
|
---|
| 158 |
|
---|
| 159 | function deleteRows( selectionOrRow )
|
---|
| 160 | {
|
---|
| 161 | if ( selectionOrRow instanceof CKEDITOR.dom.selection )
|
---|
| 162 | {
|
---|
| 163 | var cells = getSelectedCells( selectionOrRow ),
|
---|
| 164 | cellsCount = cells.length,
|
---|
| 165 | rowsToDelete = [],
|
---|
| 166 | cursorPosition,
|
---|
| 167 | previousRowIndex,
|
---|
| 168 | nextRowIndex;
|
---|
| 169 |
|
---|
| 170 | // Queue up the rows - it's possible and likely that we have duplicates.
|
---|
| 171 | for ( var i = 0 ; i < cellsCount ; i++ )
|
---|
| 172 | {
|
---|
| 173 | var row = cells[ i ].getParent(),
|
---|
| 174 | rowIndex = row.$.rowIndex;
|
---|
| 175 |
|
---|
| 176 | !i && ( previousRowIndex = rowIndex - 1 );
|
---|
| 177 | rowsToDelete[ rowIndex ] = row;
|
---|
| 178 | i == cellsCount - 1 && ( nextRowIndex = rowIndex + 1 );
|
---|
| 179 | }
|
---|
| 180 |
|
---|
| 181 | var table = row.getAscendant( 'table' ),
|
---|
| 182 | rows = table.$.rows,
|
---|
| 183 | rowCount = rows.length;
|
---|
| 184 |
|
---|
| 185 | // Where to put the cursor after rows been deleted?
|
---|
| 186 | // 1. Into next sibling row if any;
|
---|
| 187 | // 2. Into previous sibling row if any;
|
---|
| 188 | // 3. Into table's parent element if it's the very last row.
|
---|
| 189 | cursorPosition = new CKEDITOR.dom.element(
|
---|
| 190 | nextRowIndex < rowCount && table.$.rows[ nextRowIndex ] ||
|
---|
| 191 | previousRowIndex > 0 && table.$.rows[ previousRowIndex ] ||
|
---|
| 192 | table.$.parentNode );
|
---|
| 193 |
|
---|
| 194 | for ( i = rowsToDelete.length ; i >= 0 ; i-- )
|
---|
| 195 | {
|
---|
| 196 | if ( rowsToDelete[ i ] )
|
---|
| 197 | deleteRows( rowsToDelete[ i ] );
|
---|
| 198 | }
|
---|
| 199 |
|
---|
| 200 | return cursorPosition;
|
---|
| 201 | }
|
---|
| 202 | else if ( selectionOrRow instanceof CKEDITOR.dom.element )
|
---|
| 203 | {
|
---|
| 204 | table = selectionOrRow.getAscendant( 'table' );
|
---|
| 205 |
|
---|
| 206 | if ( table.$.rows.length == 1 )
|
---|
| 207 | table.remove();
|
---|
| 208 | else
|
---|
| 209 | selectionOrRow.remove();
|
---|
| 210 | }
|
---|
| 211 |
|
---|
| 212 | return 0;
|
---|
| 213 | }
|
---|
| 214 |
|
---|
| 215 | function insertColumn( selection, insertBefore )
|
---|
| 216 | {
|
---|
| 217 | // Get the cell where the selection is placed in.
|
---|
| 218 | var startElement = selection.getStartElement();
|
---|
| 219 | var cell = startElement.getAscendant( 'td', true ) || startElement.getAscendant( 'th', true );
|
---|
| 220 |
|
---|
| 221 | if ( !cell )
|
---|
| 222 | return;
|
---|
| 223 |
|
---|
| 224 | // Get the cell's table.
|
---|
| 225 | var table = cell.getAscendant( 'table' );
|
---|
| 226 | var cellIndex = cell.$.cellIndex;
|
---|
| 227 |
|
---|
| 228 | // Loop through all rows available in the table.
|
---|
| 229 | for ( var i = 0 ; i < table.$.rows.length ; i++ )
|
---|
| 230 | {
|
---|
| 231 | var $row = table.$.rows[ i ];
|
---|
| 232 |
|
---|
| 233 | // If the row doesn't have enough cells, ignore it.
|
---|
| 234 | if ( $row.cells.length < ( cellIndex + 1 ) )
|
---|
| 235 | continue;
|
---|
| 236 |
|
---|
| 237 | cell = new CKEDITOR.dom.element( $row.cells[ cellIndex ].cloneNode( false ) );
|
---|
| 238 |
|
---|
| 239 | if ( !CKEDITOR.env.ie )
|
---|
| 240 | cell.appendBogus();
|
---|
| 241 |
|
---|
| 242 | // Get back the currently selected cell.
|
---|
| 243 | var baseCell = new CKEDITOR.dom.element( $row.cells[ cellIndex ] );
|
---|
| 244 | if ( insertBefore )
|
---|
| 245 | cell.insertBefore( baseCell );
|
---|
| 246 | else
|
---|
| 247 | cell.insertAfter( baseCell );
|
---|
| 248 | }
|
---|
| 249 | }
|
---|
| 250 |
|
---|
| 251 | function deleteColumns( selectionOrCell )
|
---|
| 252 | {
|
---|
| 253 | if ( selectionOrCell instanceof CKEDITOR.dom.selection )
|
---|
| 254 | {
|
---|
| 255 | var colsToDelete = getSelectedCells( selectionOrCell );
|
---|
| 256 | for ( var i = colsToDelete.length ; i >= 0 ; i-- )
|
---|
| 257 | {
|
---|
| 258 | if ( colsToDelete[ i ] )
|
---|
| 259 | deleteColumns( colsToDelete[ i ] );
|
---|
| 260 | }
|
---|
| 261 | }
|
---|
| 262 | else if ( selectionOrCell instanceof CKEDITOR.dom.element )
|
---|
| 263 | {
|
---|
| 264 | // Get the cell's table.
|
---|
| 265 | var table = selectionOrCell.getAscendant( 'table' );
|
---|
| 266 |
|
---|
| 267 | // Get the cell index.
|
---|
| 268 | var cellIndex = selectionOrCell.$.cellIndex;
|
---|
| 269 |
|
---|
| 270 | /*
|
---|
| 271 | * Loop through all rows from down to up, coz it's possible that some rows
|
---|
| 272 | * will be deleted.
|
---|
| 273 | */
|
---|
| 274 | for ( i = table.$.rows.length - 1 ; i >= 0 ; i-- )
|
---|
| 275 | {
|
---|
| 276 | // Get the row.
|
---|
| 277 | var row = new CKEDITOR.dom.element( table.$.rows[ i ] );
|
---|
| 278 |
|
---|
| 279 | // If the cell to be removed is the first one and the row has just one cell.
|
---|
| 280 | if ( !cellIndex && row.$.cells.length == 1 )
|
---|
| 281 | {
|
---|
| 282 | deleteRows( row );
|
---|
| 283 | continue;
|
---|
| 284 | }
|
---|
| 285 |
|
---|
| 286 | // Else, just delete the cell.
|
---|
| 287 | if ( row.$.cells[ cellIndex ] )
|
---|
| 288 | row.$.removeChild( row.$.cells[ cellIndex ] );
|
---|
| 289 | }
|
---|
| 290 | }
|
---|
| 291 | }
|
---|
| 292 |
|
---|
| 293 | function insertCell( selection, insertBefore )
|
---|
| 294 | {
|
---|
| 295 | var startElement = selection.getStartElement();
|
---|
| 296 | var cell = startElement.getAscendant( 'td', true ) || startElement.getAscendant( 'th', true );
|
---|
| 297 |
|
---|
| 298 | if ( !cell )
|
---|
| 299 | return;
|
---|
| 300 |
|
---|
| 301 | // Create the new cell element to be added.
|
---|
| 302 | var newCell = cell.clone();
|
---|
| 303 | if ( !CKEDITOR.env.ie )
|
---|
| 304 | newCell.appendBogus();
|
---|
| 305 |
|
---|
| 306 | if ( insertBefore )
|
---|
| 307 | newCell.insertBefore( cell );
|
---|
| 308 | else
|
---|
| 309 | newCell.insertAfter( cell );
|
---|
| 310 | }
|
---|
| 311 |
|
---|
| 312 | function deleteCells( selectionOrCell )
|
---|
| 313 | {
|
---|
| 314 | if ( selectionOrCell instanceof CKEDITOR.dom.selection )
|
---|
| 315 | {
|
---|
| 316 | var cellsToDelete = getSelectedCells( selectionOrCell );
|
---|
| 317 | var table = cellsToDelete[ 0 ] && cellsToDelete[ 0 ].getAscendant( 'table' );
|
---|
| 318 | var cellToFocus = getFocusedCell( cellsToDelete );
|
---|
| 319 |
|
---|
| 320 | for ( var i = cellsToDelete.length - 1 ; i >= 0 ; i-- )
|
---|
| 321 | deleteCells( cellsToDelete[ i ] );
|
---|
| 322 |
|
---|
| 323 | if ( cellToFocus )
|
---|
| 324 | placeCursorInCell( cellToFocus, true );
|
---|
| 325 | else if ( table )
|
---|
| 326 | table.remove();
|
---|
| 327 | }
|
---|
| 328 | else if ( selectionOrCell instanceof CKEDITOR.dom.element )
|
---|
| 329 | {
|
---|
| 330 | var tr = selectionOrCell.getParent();
|
---|
| 331 | if ( tr.getChildCount() == 1 )
|
---|
| 332 | tr.remove();
|
---|
| 333 | else
|
---|
| 334 | selectionOrCell.remove();
|
---|
| 335 | }
|
---|
| 336 | }
|
---|
| 337 |
|
---|
| 338 | // Remove filler at end and empty spaces around the cell content.
|
---|
| 339 | function trimCell( cell )
|
---|
| 340 | {
|
---|
| 341 | var bogus = cell.getBogus();
|
---|
| 342 | bogus && bogus.remove();
|
---|
| 343 | cell.trim();
|
---|
| 344 | }
|
---|
| 345 |
|
---|
| 346 | function placeCursorInCell( cell, placeAtEnd )
|
---|
| 347 | {
|
---|
| 348 | var range = new CKEDITOR.dom.range( cell.getDocument() );
|
---|
| 349 | if ( !range[ 'moveToElementEdit' + ( placeAtEnd ? 'End' : 'Start' ) ]( cell ) )
|
---|
| 350 | {
|
---|
| 351 | range.selectNodeContents( cell );
|
---|
| 352 | range.collapse( placeAtEnd ? false : true );
|
---|
| 353 | }
|
---|
| 354 | range.select( true );
|
---|
| 355 | }
|
---|
| 356 |
|
---|
| 357 | function buildTableMap( table )
|
---|
| 358 | {
|
---|
| 359 |
|
---|
| 360 | var aRows = table.$.rows ;
|
---|
| 361 |
|
---|
| 362 | // Row and Column counters.
|
---|
| 363 | var r = -1 ;
|
---|
| 364 |
|
---|
| 365 | var aMap = [];
|
---|
| 366 |
|
---|
| 367 | for ( var i = 0 ; i < aRows.length ; i++ )
|
---|
| 368 | {
|
---|
| 369 | r++ ;
|
---|
| 370 | !aMap[r] && ( aMap[r] = [] );
|
---|
| 371 |
|
---|
| 372 | var c = -1 ;
|
---|
| 373 |
|
---|
| 374 | for ( var j = 0 ; j < aRows[i].cells.length ; j++ )
|
---|
| 375 | {
|
---|
| 376 | var oCell = aRows[i].cells[j] ;
|
---|
| 377 |
|
---|
| 378 | c++ ;
|
---|
| 379 | while ( aMap[r][c] )
|
---|
| 380 | c++ ;
|
---|
| 381 |
|
---|
| 382 | var iColSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ;
|
---|
| 383 | var iRowSpan = isNaN( oCell.rowSpan ) ? 1 : oCell.rowSpan ;
|
---|
| 384 |
|
---|
| 385 | for ( var rs = 0 ; rs < iRowSpan ; rs++ )
|
---|
| 386 | {
|
---|
| 387 | if ( !aMap[r + rs] )
|
---|
| 388 | aMap[r + rs] = new Array() ;
|
---|
| 389 |
|
---|
| 390 | for ( var cs = 0 ; cs < iColSpan ; cs++ )
|
---|
| 391 | {
|
---|
| 392 | aMap[r + rs][c + cs] = aRows[i].cells[j] ;
|
---|
| 393 | }
|
---|
| 394 | }
|
---|
| 395 |
|
---|
| 396 | c += iColSpan - 1 ;
|
---|
| 397 | }
|
---|
| 398 | }
|
---|
| 399 | return aMap ;
|
---|
| 400 | }
|
---|
| 401 |
|
---|
| 402 | function cellInRow( tableMap, rowIndex, cell )
|
---|
| 403 | {
|
---|
| 404 | var oRow = tableMap[ rowIndex ];
|
---|
| 405 | if ( typeof cell == 'undefined' )
|
---|
| 406 | return oRow;
|
---|
| 407 |
|
---|
| 408 | for ( var c = 0 ; oRow && c < oRow.length ; c++ )
|
---|
| 409 | {
|
---|
| 410 | if ( cell.is && oRow[c] == cell.$ )
|
---|
| 411 | return c;
|
---|
| 412 | else if ( c == cell )
|
---|
| 413 | return new CKEDITOR.dom.element( oRow[ c ] );
|
---|
| 414 | }
|
---|
| 415 | return cell.is ? -1 : null;
|
---|
| 416 | }
|
---|
| 417 |
|
---|
| 418 | function cellInCol( tableMap, colIndex, cell )
|
---|
| 419 | {
|
---|
| 420 | var oCol = [];
|
---|
| 421 | for ( var r = 0; r < tableMap.length; r++ )
|
---|
| 422 | {
|
---|
| 423 | var row = tableMap[ r ];
|
---|
| 424 | if ( typeof cell == 'undefined' )
|
---|
| 425 | oCol.push( row[ colIndex ] );
|
---|
| 426 | else if ( cell.is && row[ colIndex ] == cell.$ )
|
---|
| 427 | return r;
|
---|
| 428 | else if ( r == cell )
|
---|
| 429 | return new CKEDITOR.dom.element( row[ colIndex ] );
|
---|
| 430 | }
|
---|
| 431 |
|
---|
| 432 | return ( typeof cell == 'undefined' )? oCol : cell.is ? -1 : null;
|
---|
| 433 | }
|
---|
| 434 |
|
---|
| 435 | function mergeCells( selection, mergeDirection, isDetect )
|
---|
| 436 | {
|
---|
| 437 | var cells = getSelectedCells( selection );
|
---|
| 438 |
|
---|
| 439 | // Invalid merge request if:
|
---|
| 440 | // 1. In batch mode despite that less than two selected.
|
---|
| 441 | // 2. In solo mode while not exactly only one selected.
|
---|
| 442 | // 3. Cells distributed in different table groups (e.g. from both thead and tbody).
|
---|
| 443 | var commonAncestor;
|
---|
| 444 | if ( ( mergeDirection ? cells.length != 1 : cells.length < 2 )
|
---|
| 445 | || ( commonAncestor = selection.getCommonAncestor() )
|
---|
| 446 | && commonAncestor.type == CKEDITOR.NODE_ELEMENT
|
---|
| 447 | && commonAncestor.is( 'table' ) )
|
---|
| 448 | {
|
---|
| 449 | return false;
|
---|
| 450 | }
|
---|
| 451 |
|
---|
| 452 | var cell,
|
---|
| 453 | firstCell = cells[ 0 ],
|
---|
| 454 | table = firstCell.getAscendant( 'table' ),
|
---|
| 455 | map = buildTableMap( table ),
|
---|
| 456 | mapHeight = map.length,
|
---|
| 457 | mapWidth = map[ 0 ].length,
|
---|
| 458 | startRow = firstCell.getParent().$.rowIndex,
|
---|
| 459 | startColumn = cellInRow( map, startRow, firstCell );
|
---|
| 460 |
|
---|
| 461 | if ( mergeDirection )
|
---|
| 462 | {
|
---|
| 463 | var targetCell;
|
---|
| 464 | try
|
---|
| 465 | {
|
---|
| 466 | targetCell =
|
---|
| 467 | map[ mergeDirection == 'up' ?
|
---|
| 468 | ( startRow - 1 ):
|
---|
| 469 | mergeDirection == 'down' ? ( startRow + 1 ) : startRow ] [
|
---|
| 470 | mergeDirection == 'left' ?
|
---|
| 471 | ( startColumn - 1 ):
|
---|
| 472 | mergeDirection == 'right' ? ( startColumn + 1 ) : startColumn ];
|
---|
| 473 |
|
---|
| 474 | }
|
---|
| 475 | catch( er )
|
---|
| 476 | {
|
---|
| 477 | return false;
|
---|
| 478 | }
|
---|
| 479 |
|
---|
| 480 | // 1. No cell could be merged.
|
---|
| 481 | // 2. Same cell actually.
|
---|
| 482 | if ( !targetCell || firstCell.$ == targetCell )
|
---|
| 483 | return false;
|
---|
| 484 |
|
---|
| 485 | // Sort in map order regardless of the DOM sequence.
|
---|
| 486 | cells[ ( mergeDirection == 'up' || mergeDirection == 'left' ) ?
|
---|
| 487 | 'unshift' : 'push' ]( new CKEDITOR.dom.element( targetCell ) );
|
---|
| 488 | }
|
---|
| 489 |
|
---|
| 490 | // Start from here are merging way ignorance (merge up/right, batch merge).
|
---|
| 491 | var doc = firstCell.getDocument(),
|
---|
| 492 | lastRowIndex = startRow,
|
---|
| 493 | totalRowSpan = 0,
|
---|
| 494 | totalColSpan = 0,
|
---|
| 495 | // Use a documentFragment as buffer when appending cell contents.
|
---|
| 496 | frag = !isDetect && new CKEDITOR.dom.documentFragment( doc ),
|
---|
| 497 | dimension = 0;
|
---|
| 498 |
|
---|
| 499 | for ( var i = 0; i < cells.length; i++ )
|
---|
| 500 | {
|
---|
| 501 | cell = cells[ i ];
|
---|
| 502 |
|
---|
| 503 | var tr = cell.getParent(),
|
---|
| 504 | cellFirstChild = cell.getFirst(),
|
---|
| 505 | colSpan = cell.$.colSpan,
|
---|
| 506 | rowSpan = cell.$.rowSpan,
|
---|
| 507 | rowIndex = tr.$.rowIndex,
|
---|
| 508 | colIndex = cellInRow( map, rowIndex, cell );
|
---|
| 509 |
|
---|
| 510 | // Accumulated the actual places taken by all selected cells.
|
---|
| 511 | dimension += colSpan * rowSpan;
|
---|
| 512 | // Accumulated the maximum virtual spans from column and row.
|
---|
| 513 | totalColSpan = Math.max( totalColSpan, colIndex - startColumn + colSpan ) ;
|
---|
| 514 | totalRowSpan = Math.max( totalRowSpan, rowIndex - startRow + rowSpan );
|
---|
| 515 |
|
---|
| 516 | if ( !isDetect )
|
---|
| 517 | {
|
---|
| 518 | // Trim all cell fillers and check to remove empty cells.
|
---|
| 519 | if ( trimCell( cell ), cell.getChildren().count() )
|
---|
| 520 | {
|
---|
| 521 | // Merge vertically cells as two separated paragraphs.
|
---|
| 522 | if ( rowIndex != lastRowIndex
|
---|
| 523 | && cellFirstChild
|
---|
| 524 | && !( cellFirstChild.isBlockBoundary
|
---|
| 525 | && cellFirstChild.isBlockBoundary( { br : 1 } ) ) )
|
---|
| 526 | {
|
---|
| 527 | var last = frag.getLast( CKEDITOR.dom.walker.whitespaces( true ) );
|
---|
| 528 | if ( last && !( last.is && last.is( 'br' ) ) )
|
---|
| 529 | frag.append( new CKEDITOR.dom.element( 'br' ) );
|
---|
| 530 | }
|
---|
| 531 |
|
---|
| 532 | cell.moveChildren( frag );
|
---|
| 533 | }
|
---|
| 534 | i ? cell.remove() : cell.setHtml( '' );
|
---|
| 535 | }
|
---|
| 536 | lastRowIndex = rowIndex;
|
---|
| 537 | }
|
---|
| 538 |
|
---|
| 539 | if ( !isDetect )
|
---|
| 540 | {
|
---|
| 541 | frag.moveChildren( firstCell );
|
---|
| 542 |
|
---|
| 543 | if ( !CKEDITOR.env.ie )
|
---|
| 544 | firstCell.appendBogus();
|
---|
| 545 |
|
---|
| 546 | if ( totalColSpan >= mapWidth )
|
---|
| 547 | firstCell.removeAttribute( 'rowSpan' );
|
---|
| 548 | else
|
---|
| 549 | firstCell.$.rowSpan = totalRowSpan;
|
---|
| 550 |
|
---|
| 551 | if ( totalRowSpan >= mapHeight )
|
---|
| 552 | firstCell.removeAttribute( 'colSpan' );
|
---|
| 553 | else
|
---|
| 554 | firstCell.$.colSpan = totalColSpan;
|
---|
| 555 |
|
---|
| 556 | // Swip empty <tr> left at the end of table due to the merging.
|
---|
| 557 | var trs = new CKEDITOR.dom.nodeList( table.$.rows ),
|
---|
| 558 | count = trs.count();
|
---|
| 559 |
|
---|
| 560 | for ( i = count - 1; i >= 0; i-- )
|
---|
| 561 | {
|
---|
| 562 | var tailTr = trs.getItem( i );
|
---|
| 563 | if ( !tailTr.$.cells.length )
|
---|
| 564 | {
|
---|
| 565 | tailTr.remove();
|
---|
| 566 | count++;
|
---|
| 567 | continue;
|
---|
| 568 | }
|
---|
| 569 | }
|
---|
| 570 |
|
---|
| 571 | return firstCell;
|
---|
| 572 | }
|
---|
| 573 | // Be able to merge cells only if actual dimension of selected
|
---|
| 574 | // cells equals to the caculated rectangle.
|
---|
| 575 | else
|
---|
| 576 | return ( totalRowSpan * totalColSpan ) == dimension;
|
---|
| 577 | }
|
---|
| 578 |
|
---|
| 579 | function verticalSplitCell ( selection, isDetect )
|
---|
| 580 | {
|
---|
| 581 | var cells = getSelectedCells( selection );
|
---|
| 582 | if ( cells.length > 1 )
|
---|
| 583 | return false;
|
---|
| 584 | else if ( isDetect )
|
---|
| 585 | return true;
|
---|
| 586 |
|
---|
| 587 | var cell = cells[ 0 ],
|
---|
| 588 | tr = cell.getParent(),
|
---|
| 589 | table = tr.getAscendant( 'table' ),
|
---|
| 590 | map = buildTableMap( table ),
|
---|
| 591 | rowIndex = tr.$.rowIndex,
|
---|
| 592 | colIndex = cellInRow( map, rowIndex, cell ),
|
---|
| 593 | rowSpan = cell.$.rowSpan,
|
---|
| 594 | newCell,
|
---|
| 595 | newRowSpan,
|
---|
| 596 | newCellRowSpan,
|
---|
| 597 | newRowIndex;
|
---|
| 598 |
|
---|
| 599 | if ( rowSpan > 1 )
|
---|
| 600 | {
|
---|
| 601 | newRowSpan = Math.ceil( rowSpan / 2 );
|
---|
| 602 | newCellRowSpan = Math.floor( rowSpan / 2 );
|
---|
| 603 | newRowIndex = rowIndex + newRowSpan;
|
---|
| 604 | var newCellTr = new CKEDITOR.dom.element( table.$.rows[ newRowIndex ] ),
|
---|
| 605 | newCellRow = cellInRow( map, newRowIndex ),
|
---|
| 606 | candidateCell;
|
---|
| 607 |
|
---|
| 608 | newCell = cell.clone();
|
---|
| 609 |
|
---|
| 610 | // Figure out where to insert the new cell by checking the vitual row.
|
---|
| 611 | for ( var c = 0; c < newCellRow.length; c++ )
|
---|
| 612 | {
|
---|
| 613 | candidateCell = newCellRow[ c ];
|
---|
| 614 | // Catch first cell actually following the column.
|
---|
| 615 | if ( candidateCell.parentNode == newCellTr.$
|
---|
| 616 | && c > colIndex )
|
---|
| 617 | {
|
---|
| 618 | newCell.insertBefore( new CKEDITOR.dom.element( candidateCell ) );
|
---|
| 619 | break;
|
---|
| 620 | }
|
---|
| 621 | else
|
---|
| 622 | candidateCell = null;
|
---|
| 623 | }
|
---|
| 624 |
|
---|
| 625 | // The destination row is empty, append at will.
|
---|
| 626 | if ( !candidateCell )
|
---|
| 627 | newCellTr.append( newCell, true );
|
---|
| 628 | }
|
---|
| 629 | else
|
---|
| 630 | {
|
---|
| 631 | newCellRowSpan = newRowSpan = 1;
|
---|
| 632 |
|
---|
| 633 | newCellTr = tr.clone();
|
---|
| 634 | newCellTr.insertAfter( tr );
|
---|
| 635 | newCellTr.append( newCell = cell.clone() );
|
---|
| 636 |
|
---|
| 637 | var cellsInSameRow = cellInRow( map, rowIndex );
|
---|
| 638 | for ( var i = 0; i < cellsInSameRow.length; i++ )
|
---|
| 639 | cellsInSameRow[ i ].rowSpan++;
|
---|
| 640 | }
|
---|
| 641 |
|
---|
| 642 | if ( !CKEDITOR.env.ie )
|
---|
| 643 | newCell.appendBogus();
|
---|
| 644 |
|
---|
| 645 | cell.$.rowSpan = newRowSpan;
|
---|
| 646 | newCell.$.rowSpan = newCellRowSpan;
|
---|
| 647 | if ( newRowSpan == 1 )
|
---|
| 648 | cell.removeAttribute( 'rowSpan' );
|
---|
| 649 | if ( newCellRowSpan == 1 )
|
---|
| 650 | newCell.removeAttribute( 'rowSpan' );
|
---|
| 651 |
|
---|
| 652 | return newCell;
|
---|
| 653 | }
|
---|
| 654 |
|
---|
| 655 | function horizontalSplitCell( selection, isDetect )
|
---|
| 656 | {
|
---|
| 657 | var cells = getSelectedCells( selection );
|
---|
| 658 | if ( cells.length > 1 )
|
---|
| 659 | return false;
|
---|
| 660 | else if ( isDetect )
|
---|
| 661 | return true;
|
---|
| 662 |
|
---|
| 663 | var cell = cells[ 0 ],
|
---|
| 664 | tr = cell.getParent(),
|
---|
| 665 | table = tr.getAscendant( 'table' ),
|
---|
| 666 | map = buildTableMap( table ),
|
---|
| 667 | rowIndex = tr.$.rowIndex,
|
---|
| 668 | colIndex = cellInRow( map, rowIndex, cell ),
|
---|
| 669 | colSpan = cell.$.colSpan,
|
---|
| 670 | newCell,
|
---|
| 671 | newColSpan,
|
---|
| 672 | newCellColSpan;
|
---|
| 673 |
|
---|
| 674 | if ( colSpan > 1 )
|
---|
| 675 | {
|
---|
| 676 | newColSpan = Math.ceil( colSpan / 2 );
|
---|
| 677 | newCellColSpan = Math.floor( colSpan / 2 );
|
---|
| 678 | }
|
---|
| 679 | else
|
---|
| 680 | {
|
---|
| 681 | newCellColSpan = newColSpan = 1;
|
---|
| 682 | var cellsInSameCol = cellInCol( map, colIndex );
|
---|
| 683 | for ( var i = 0; i < cellsInSameCol.length; i++ )
|
---|
| 684 | cellsInSameCol[ i ].colSpan++;
|
---|
| 685 | }
|
---|
| 686 | newCell = cell.clone();
|
---|
| 687 | newCell.insertAfter( cell );
|
---|
| 688 | if ( !CKEDITOR.env.ie )
|
---|
| 689 | newCell.appendBogus();
|
---|
| 690 |
|
---|
| 691 | cell.$.colSpan = newColSpan;
|
---|
| 692 | newCell.$.colSpan = newCellColSpan;
|
---|
| 693 | if ( newColSpan == 1 )
|
---|
| 694 | cell.removeAttribute( 'colSpan' );
|
---|
| 695 | if ( newCellColSpan == 1 )
|
---|
| 696 | newCell.removeAttribute( 'colSpan' );
|
---|
| 697 |
|
---|
| 698 | return newCell;
|
---|
| 699 | }
|
---|
| 700 | // Context menu on table caption incorrect (#3834)
|
---|
| 701 | var contextMenuTags = { thead : 1, tbody : 1, tfoot : 1, td : 1, tr : 1, th : 1 };
|
---|
| 702 |
|
---|
| 703 | CKEDITOR.plugins.tabletools =
|
---|
| 704 | {
|
---|
| 705 | init : function( editor )
|
---|
| 706 | {
|
---|
| 707 | var lang = editor.lang.table;
|
---|
| 708 |
|
---|
| 709 | editor.addCommand( 'cellProperties', new CKEDITOR.dialogCommand( 'cellProperties' ) );
|
---|
| 710 | CKEDITOR.dialog.add( 'cellProperties', this.path + 'dialogs/tableCell.js' );
|
---|
| 711 |
|
---|
| 712 | editor.addCommand( 'tableDelete',
|
---|
| 713 | {
|
---|
| 714 | exec : function( editor )
|
---|
| 715 | {
|
---|
| 716 | var selection = editor.getSelection();
|
---|
| 717 | var startElement = selection && selection.getStartElement();
|
---|
| 718 | var table = startElement && startElement.getAscendant( 'table', true );
|
---|
| 719 |
|
---|
| 720 | if ( !table )
|
---|
| 721 | return;
|
---|
| 722 |
|
---|
| 723 | // Maintain the selection point at where the table was deleted.
|
---|
| 724 | selection.selectElement( table );
|
---|
| 725 | var range = selection.getRanges()[0];
|
---|
| 726 | range.collapse();
|
---|
| 727 | selection.selectRanges( [ range ] );
|
---|
| 728 |
|
---|
| 729 | // If the table's parent has only one child, remove it as well.
|
---|
| 730 | if ( table.getParent().getChildCount() == 1 )
|
---|
| 731 | table.getParent().remove();
|
---|
| 732 | else
|
---|
| 733 | table.remove();
|
---|
| 734 | }
|
---|
| 735 | } );
|
---|
| 736 |
|
---|
| 737 | editor.addCommand( 'rowDelete',
|
---|
| 738 | {
|
---|
| 739 | exec : function( editor )
|
---|
| 740 | {
|
---|
| 741 | var selection = editor.getSelection();
|
---|
| 742 | placeCursorInCell( deleteRows( selection ) );
|
---|
| 743 | }
|
---|
| 744 | } );
|
---|
| 745 |
|
---|
| 746 | editor.addCommand( 'rowInsertBefore',
|
---|
| 747 | {
|
---|
| 748 | exec : function( editor )
|
---|
| 749 | {
|
---|
| 750 | var selection = editor.getSelection();
|
---|
| 751 | insertRow( selection, true );
|
---|
| 752 | }
|
---|
| 753 | } );
|
---|
| 754 |
|
---|
| 755 | editor.addCommand( 'rowInsertAfter',
|
---|
| 756 | {
|
---|
| 757 | exec : function( editor )
|
---|
| 758 | {
|
---|
| 759 | var selection = editor.getSelection();
|
---|
| 760 | insertRow( selection );
|
---|
| 761 | }
|
---|
| 762 | } );
|
---|
| 763 |
|
---|
| 764 | editor.addCommand( 'columnDelete',
|
---|
| 765 | {
|
---|
| 766 | exec : function( editor )
|
---|
| 767 | {
|
---|
| 768 | var selection = editor.getSelection();
|
---|
| 769 | deleteColumns( selection );
|
---|
| 770 | }
|
---|
| 771 | } );
|
---|
| 772 |
|
---|
| 773 | editor.addCommand( 'columnInsertBefore',
|
---|
| 774 | {
|
---|
| 775 | exec : function( editor )
|
---|
| 776 | {
|
---|
| 777 | var selection = editor.getSelection();
|
---|
| 778 | insertColumn( selection, true );
|
---|
| 779 | }
|
---|
| 780 | } );
|
---|
| 781 |
|
---|
| 782 | editor.addCommand( 'columnInsertAfter',
|
---|
| 783 | {
|
---|
| 784 | exec : function( editor )
|
---|
| 785 | {
|
---|
| 786 | var selection = editor.getSelection();
|
---|
| 787 | insertColumn( selection );
|
---|
| 788 | }
|
---|
| 789 | } );
|
---|
| 790 |
|
---|
| 791 | editor.addCommand( 'cellDelete',
|
---|
| 792 | {
|
---|
| 793 | exec : function( editor )
|
---|
| 794 | {
|
---|
| 795 | var selection = editor.getSelection();
|
---|
| 796 | deleteCells( selection );
|
---|
| 797 | }
|
---|
| 798 | } );
|
---|
| 799 |
|
---|
| 800 | editor.addCommand( 'cellMerge',
|
---|
| 801 | {
|
---|
| 802 | exec : function( editor )
|
---|
| 803 | {
|
---|
| 804 | placeCursorInCell( mergeCells( editor.getSelection() ), true );
|
---|
| 805 | }
|
---|
| 806 | } );
|
---|
| 807 |
|
---|
| 808 | editor.addCommand( 'cellMergeRight',
|
---|
| 809 | {
|
---|
| 810 | exec : function( editor )
|
---|
| 811 | {
|
---|
| 812 | placeCursorInCell( mergeCells( editor.getSelection(), 'right' ), true );
|
---|
| 813 | }
|
---|
| 814 | } );
|
---|
| 815 |
|
---|
| 816 | editor.addCommand( 'cellMergeDown',
|
---|
| 817 | {
|
---|
| 818 | exec : function( editor )
|
---|
| 819 | {
|
---|
| 820 | placeCursorInCell( mergeCells( editor.getSelection(), 'down' ), true );
|
---|
| 821 | }
|
---|
| 822 | } );
|
---|
| 823 |
|
---|
| 824 | editor.addCommand( 'cellVerticalSplit',
|
---|
| 825 | {
|
---|
| 826 | exec : function( editor )
|
---|
| 827 | {
|
---|
| 828 | placeCursorInCell( verticalSplitCell( editor.getSelection() ) );
|
---|
| 829 | }
|
---|
| 830 | } );
|
---|
| 831 |
|
---|
| 832 | editor.addCommand( 'cellHorizontalSplit',
|
---|
| 833 | {
|
---|
| 834 | exec : function( editor )
|
---|
| 835 | {
|
---|
| 836 | placeCursorInCell( horizontalSplitCell( editor.getSelection() ) );
|
---|
| 837 | }
|
---|
| 838 | } );
|
---|
| 839 |
|
---|
| 840 | editor.addCommand( 'cellInsertBefore',
|
---|
| 841 | {
|
---|
| 842 | exec : function( editor )
|
---|
| 843 | {
|
---|
| 844 | var selection = editor.getSelection();
|
---|
| 845 | insertCell( selection, true );
|
---|
| 846 | }
|
---|
| 847 | } );
|
---|
| 848 |
|
---|
| 849 | editor.addCommand( 'cellInsertAfter',
|
---|
| 850 | {
|
---|
| 851 | exec : function( editor )
|
---|
| 852 | {
|
---|
| 853 | var selection = editor.getSelection();
|
---|
| 854 | insertCell( selection );
|
---|
| 855 | }
|
---|
| 856 | } );
|
---|
| 857 |
|
---|
| 858 | // If the "menu" plugin is loaded, register the menu items.
|
---|
| 859 | if ( editor.addMenuItems )
|
---|
| 860 | {
|
---|
| 861 | editor.addMenuItems(
|
---|
| 862 | {
|
---|
| 863 | tablecell :
|
---|
| 864 | {
|
---|
| 865 | label : lang.cell.menu,
|
---|
| 866 | group : 'tablecell',
|
---|
| 867 | order : 1,
|
---|
| 868 | getItems : function()
|
---|
| 869 | {
|
---|
| 870 | var selection = editor.getSelection(),
|
---|
| 871 | cells = getSelectedCells( selection );
|
---|
| 872 | return {
|
---|
| 873 | tablecell_insertBefore : CKEDITOR.TRISTATE_OFF,
|
---|
| 874 | tablecell_insertAfter : CKEDITOR.TRISTATE_OFF,
|
---|
| 875 | tablecell_delete : CKEDITOR.TRISTATE_OFF,
|
---|
| 876 | tablecell_merge : mergeCells( selection, null, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
|
---|
| 877 | tablecell_merge_right : mergeCells( selection, 'right', true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
|
---|
| 878 | tablecell_merge_down : mergeCells( selection, 'down', true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
|
---|
| 879 | tablecell_split_vertical : verticalSplitCell( selection, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
|
---|
| 880 | tablecell_split_horizontal : horizontalSplitCell( selection, true ) ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED,
|
---|
| 881 | tablecell_properties : cells.length > 0 ? CKEDITOR.TRISTATE_OFF : CKEDITOR.TRISTATE_DISABLED
|
---|
| 882 | };
|
---|
| 883 | }
|
---|
| 884 | },
|
---|
| 885 |
|
---|
| 886 | tablecell_insertBefore :
|
---|
| 887 | {
|
---|
| 888 | label : lang.cell.insertBefore,
|
---|
| 889 | group : 'tablecell',
|
---|
| 890 | command : 'cellInsertBefore',
|
---|
| 891 | order : 5
|
---|
| 892 | },
|
---|
| 893 |
|
---|
| 894 | tablecell_insertAfter :
|
---|
| 895 | {
|
---|
| 896 | label : lang.cell.insertAfter,
|
---|
| 897 | group : 'tablecell',
|
---|
| 898 | command : 'cellInsertAfter',
|
---|
| 899 | order : 10
|
---|
| 900 | },
|
---|
| 901 |
|
---|
| 902 | tablecell_delete :
|
---|
| 903 | {
|
---|
| 904 | label : lang.cell.deleteCell,
|
---|
| 905 | group : 'tablecell',
|
---|
| 906 | command : 'cellDelete',
|
---|
| 907 | order : 15
|
---|
| 908 | },
|
---|
| 909 |
|
---|
| 910 | tablecell_merge :
|
---|
| 911 | {
|
---|
| 912 | label : lang.cell.merge,
|
---|
| 913 | group : 'tablecell',
|
---|
| 914 | command : 'cellMerge',
|
---|
| 915 | order : 16
|
---|
| 916 | },
|
---|
| 917 |
|
---|
| 918 | tablecell_merge_right :
|
---|
| 919 | {
|
---|
| 920 | label : lang.cell.mergeRight,
|
---|
| 921 | group : 'tablecell',
|
---|
| 922 | command : 'cellMergeRight',
|
---|
| 923 | order : 17
|
---|
| 924 | },
|
---|
| 925 |
|
---|
| 926 | tablecell_merge_down :
|
---|
| 927 | {
|
---|
| 928 | label : lang.cell.mergeDown,
|
---|
| 929 | group : 'tablecell',
|
---|
| 930 | command : 'cellMergeDown',
|
---|
| 931 | order : 18
|
---|
| 932 | },
|
---|
| 933 |
|
---|
| 934 | tablecell_split_horizontal :
|
---|
| 935 | {
|
---|
| 936 | label : lang.cell.splitHorizontal,
|
---|
| 937 | group : 'tablecell',
|
---|
| 938 | command : 'cellHorizontalSplit',
|
---|
| 939 | order : 19
|
---|
| 940 | },
|
---|
| 941 |
|
---|
| 942 | tablecell_split_vertical :
|
---|
| 943 | {
|
---|
| 944 | label : lang.cell.splitVertical,
|
---|
| 945 | group : 'tablecell',
|
---|
| 946 | command : 'cellVerticalSplit',
|
---|
| 947 | order : 20
|
---|
| 948 | },
|
---|
| 949 |
|
---|
| 950 | tablecell_properties :
|
---|
| 951 | {
|
---|
| 952 | label : lang.cell.title,
|
---|
| 953 | group : 'tablecellproperties',
|
---|
| 954 | command : 'cellProperties',
|
---|
| 955 | order : 21
|
---|
| 956 | },
|
---|
| 957 |
|
---|
| 958 | tablerow :
|
---|
| 959 | {
|
---|
| 960 | label : lang.row.menu,
|
---|
| 961 | group : 'tablerow',
|
---|
| 962 | order : 1,
|
---|
| 963 | getItems : function()
|
---|
| 964 | {
|
---|
| 965 | return {
|
---|
| 966 | tablerow_insertBefore : CKEDITOR.TRISTATE_OFF,
|
---|
| 967 | tablerow_insertAfter : CKEDITOR.TRISTATE_OFF,
|
---|
| 968 | tablerow_delete : CKEDITOR.TRISTATE_OFF
|
---|
| 969 | };
|
---|
| 970 | }
|
---|
| 971 | },
|
---|
| 972 |
|
---|
| 973 | tablerow_insertBefore :
|
---|
| 974 | {
|
---|
| 975 | label : lang.row.insertBefore,
|
---|
| 976 | group : 'tablerow',
|
---|
| 977 | command : 'rowInsertBefore',
|
---|
| 978 | order : 5
|
---|
| 979 | },
|
---|
| 980 |
|
---|
| 981 | tablerow_insertAfter :
|
---|
| 982 | {
|
---|
| 983 | label : lang.row.insertAfter,
|
---|
| 984 | group : 'tablerow',
|
---|
| 985 | command : 'rowInsertAfter',
|
---|
| 986 | order : 10
|
---|
| 987 | },
|
---|
| 988 |
|
---|
| 989 | tablerow_delete :
|
---|
| 990 | {
|
---|
| 991 | label : lang.row.deleteRow,
|
---|
| 992 | group : 'tablerow',
|
---|
| 993 | command : 'rowDelete',
|
---|
| 994 | order : 15
|
---|
| 995 | },
|
---|
| 996 |
|
---|
| 997 | tablecolumn :
|
---|
| 998 | {
|
---|
| 999 | label : lang.column.menu,
|
---|
| 1000 | group : 'tablecolumn',
|
---|
| 1001 | order : 1,
|
---|
| 1002 | getItems : function()
|
---|
| 1003 | {
|
---|
| 1004 | return {
|
---|
| 1005 | tablecolumn_insertBefore : CKEDITOR.TRISTATE_OFF,
|
---|
| 1006 | tablecolumn_insertAfter : CKEDITOR.TRISTATE_OFF,
|
---|
| 1007 | tablecolumn_delete : CKEDITOR.TRISTATE_OFF
|
---|
| 1008 | };
|
---|
| 1009 | }
|
---|
| 1010 | },
|
---|
| 1011 |
|
---|
| 1012 | tablecolumn_insertBefore :
|
---|
| 1013 | {
|
---|
| 1014 | label : lang.column.insertBefore,
|
---|
| 1015 | group : 'tablecolumn',
|
---|
| 1016 | command : 'columnInsertBefore',
|
---|
| 1017 | order : 5
|
---|
| 1018 | },
|
---|
| 1019 |
|
---|
| 1020 | tablecolumn_insertAfter :
|
---|
| 1021 | {
|
---|
| 1022 | label : lang.column.insertAfter,
|
---|
| 1023 | group : 'tablecolumn',
|
---|
| 1024 | command : 'columnInsertAfter',
|
---|
| 1025 | order : 10
|
---|
| 1026 | },
|
---|
| 1027 |
|
---|
| 1028 | tablecolumn_delete :
|
---|
| 1029 | {
|
---|
| 1030 | label : lang.column.deleteColumn,
|
---|
| 1031 | group : 'tablecolumn',
|
---|
| 1032 | command : 'columnDelete',
|
---|
| 1033 | order : 15
|
---|
| 1034 | }
|
---|
| 1035 | });
|
---|
| 1036 | }
|
---|
| 1037 |
|
---|
| 1038 | // If the "contextmenu" plugin is laoded, register the listeners.
|
---|
| 1039 | if ( editor.contextMenu )
|
---|
| 1040 | {
|
---|
| 1041 | editor.contextMenu.addListener( function( element, selection )
|
---|
| 1042 | {
|
---|
| 1043 | if ( !element )
|
---|
| 1044 | return null;
|
---|
| 1045 |
|
---|
| 1046 | while ( element )
|
---|
| 1047 | {
|
---|
| 1048 | if ( element.getName() in contextMenuTags )
|
---|
| 1049 | {
|
---|
| 1050 | return {
|
---|
| 1051 | tablecell : CKEDITOR.TRISTATE_OFF,
|
---|
| 1052 | tablerow : CKEDITOR.TRISTATE_OFF,
|
---|
| 1053 | tablecolumn : CKEDITOR.TRISTATE_OFF
|
---|
| 1054 | };
|
---|
| 1055 | }
|
---|
| 1056 | element = element.getParent();
|
---|
| 1057 | }
|
---|
| 1058 |
|
---|
| 1059 | return null;
|
---|
| 1060 | } );
|
---|
| 1061 | }
|
---|
| 1062 | },
|
---|
| 1063 |
|
---|
| 1064 | getSelectedCells : getSelectedCells
|
---|
| 1065 |
|
---|
| 1066 | };
|
---|
| 1067 | CKEDITOR.plugins.add( 'tabletools', CKEDITOR.plugins.tabletools );
|
---|
| 1068 | })();
|
---|