1 /**

     2  * $Id: editor_plugin_src.js 1209 2009-08-20 12:35:10Z spocke $

     3  *

     4  * @author Moxiecode

     5  * @copyright Copyright © 2004-2008, Moxiecode Systems AB, All rights reserved.

     6  */

     7 

     8 (function() {

     9 	var each = tinymce.each;

    10 

    11 	// Checks if the selection/caret is at the start of the specified block element

    12 	function isAtStart(rng, par) {

    13 		var doc = par.ownerDocument, rng2 = doc.createRange(), elm;

    14 

    15 		rng2.setStartBefore(par);

    16 		rng2.setEnd(rng.endContainer, rng.endOffset);

    17 

    18 		elm = doc.createElement('body');

    19 		elm.appendChild(rng2.cloneContents());

    20 

    21 		// Check for text characters of other elements that should be treated as content

    22 		return elm.innerHTML.replace(/<(br|img|object|embed|input|textarea)[^>]*>/gi, '-').replace(/<[^>]+>/g, '').length == 0;

    23 	};

    24 

    25 	tinymce.create('tinymce.plugins.TablePlugin', {

    26 		init : function(ed, url) {

    27 			var t = this;

    28 

    29 			t.editor = ed;

    30 			t.url = url;

    31 

    32 			// Register buttons

    33 			each([

    34 				['table', 'table.desc', 'mceInsertTable', true],

    35 				['delete_table', 'table.del', 'mceTableDelete'],

    36 				['delete_col', 'table.delete_col_desc', 'mceTableDeleteCol'],

    37 				['delete_row', 'table.delete_row_desc', 'mceTableDeleteRow'],

    38 				['col_after', 'table.col_after_desc', 'mceTableInsertColAfter'],

    39 				['col_before', 'table.col_before_desc', 'mceTableInsertColBefore'],

    40 				['row_after', 'table.row_after_desc', 'mceTableInsertRowAfter'],

    41 				['row_before', 'table.row_before_desc', 'mceTableInsertRowBefore'],

    42 				['row_props', 'table.row_desc', 'mceTableRowProps', true],

    43 				['cell_props', 'table.cell_desc', 'mceTableCellProps', true],

    44 				['split_cells', 'table.split_cells_desc', 'mceTableSplitCells', true],

    45 				['merge_cells', 'table.merge_cells_desc', 'mceTableMergeCells', true]

    46 			], function(c) {

    47 				ed.addButton(c[0], {title : c[1], cmd : c[2], ui : c[3]});

    48 			});

    49 

    50 			if (ed.getParam('inline_styles')) {

    51 				// Force move of attribs to styles in strict mode

    52 				ed.onPreProcess.add(function(ed, o) {

    53 					var dom = ed.dom;

    54 

    55 					each(dom.select('table', o.node), function(n) {

    56 						var v;

    57 

    58 						if (v = dom.getAttrib(n, 'width')) {

    59 							dom.setStyle(n, 'width', v);

    60 							dom.setAttrib(n, 'width');

    61 						}

    62 

    63 						if (v = dom.getAttrib(n, 'height')) {

    64 							dom.setStyle(n, 'height', v);

    65 							dom.setAttrib(n, 'height');

    66 						}

    67 					});

    68 				});

    69 			}

    70 

    71 			ed.onInit.add(function() {

    72 				// Fixes an issue on Gecko where it's impossible to place the caret behind a table

    73 				// This fix will force a paragraph element after the table but only when the forced_root_block setting is enabled

    74 				if (!tinymce.isIE && ed.getParam('forced_root_block')) {

    75 					function fixTableCaretPos() {

    76 						var last = ed.getBody().lastChild;

    77 

    78 						if (last && last.nodeName == 'TABLE')

    79 							ed.dom.add(ed.getBody(), 'p', null, '<br mce_bogus="1" />');

    80 					};

    81 

    82 					// Fixes an bug where it's impossible to place the caret before a table in Gecko

    83 					// this fix solves it by detecting when the caret is at the beginning of such a table

    84 					// and then manually moves the caret infront of the table

    85 					if (tinymce.isGecko) {

    86 						ed.onKeyDown.add(function(ed, e) {

    87 							var rng, table, dom = ed.dom;

    88 

    89 							// On gecko it's not possible to place the caret before a table

    90 							if (e.keyCode == 37 || e.keyCode == 38) {

    91 								rng = ed.selection.getRng();

    92 								table = dom.getParent(rng.startContainer, 'table');

    93 

    94 								if (table && ed.getBody().firstChild == table) {

    95 									if (isAtStart(rng, table)) {

    96 										rng = dom.createRng();

    97 

    98 										rng.setStartBefore(table);

    99 										rng.setEndBefore(table);

   100 

   101 										ed.selection.setRng(rng);

   102 

   103 										e.preventDefault();

   104 									}

   105 								}

   106 							}

   107 						});

   108 					}

   109 

   110 					ed.onKeyUp.add(fixTableCaretPos);

   111 					ed.onSetContent.add(fixTableCaretPos);

   112 					ed.onVisualAid.add(fixTableCaretPos);

   113 

   114 					ed.onPreProcess.add(function(ed, o) {

   115 						var last = o.node.lastChild;

   116 

   117 						if (last && last.childNodes.length == 1 && last.firstChild.nodeName == 'BR')

   118 							ed.dom.remove(last);

   119 					});

   120 

   121 					fixTableCaretPos();

   122 				}

   123 

   124 				if (ed && ed.plugins.contextmenu) {

   125 					ed.plugins.contextmenu.onContextMenu.add(function(th, m, e) {

   126 						var sm, se = ed.selection, el = se.getNode() || ed.getBody();

   127 

   128 						if (ed.dom.getParent(e, 'td') || ed.dom.getParent(e, 'th')) {

   129 							m.removeAll();

   130 

   131 							if (el.nodeName == 'A' && !ed.dom.getAttrib(el, 'name')) {

   132 								m.add({title : 'advanced.link_desc', icon : 'link', cmd : ed.plugins.advlink ? 'mceAdvLink' : 'mceLink', ui : true});

   133 								m.add({title : 'advanced.unlink_desc', icon : 'unlink', cmd : 'UnLink'});

   134 								m.addSeparator();

   135 							}

   136 

   137 							if (el.nodeName == 'IMG' && el.className.indexOf('mceItem') == -1) {

   138 								m.add({title : 'advanced.image_desc', icon : 'image', cmd : ed.plugins.advimage ? 'mceAdvImage' : 'mceImage', ui : true});

   139 								m.addSeparator();

   140 							}

   141 

   142 							m.add({title : 'table.desc', icon : 'table', cmd : 'mceInsertTable', ui : true, value : {action : 'insert'}});

   143 							m.add({title : 'table.props_desc', icon : 'table_props', cmd : 'mceInsertTable', ui : true});

   144 							m.add({title : 'table.del', icon : 'delete_table', cmd : 'mceTableDelete', ui : true});

   145 							m.addSeparator();

   146 

   147 							// Cell menu

   148 							sm = m.addMenu({title : 'table.cell'});

   149 							sm.add({title : 'table.cell_desc', icon : 'cell_props', cmd : 'mceTableCellProps', ui : true});

   150 							sm.add({title : 'table.split_cells_desc', icon : 'split_cells', cmd : 'mceTableSplitCells', ui : true});

   151 							sm.add({title : 'table.merge_cells_desc', icon : 'merge_cells', cmd : 'mceTableMergeCells', ui : true});

   152 

   153 							// Row menu

   154 							sm = m.addMenu({title : 'table.row'});

   155 							sm.add({title : 'table.row_desc', icon : 'row_props', cmd : 'mceTableRowProps', ui : true});

   156 							sm.add({title : 'table.row_before_desc', icon : 'row_before', cmd : 'mceTableInsertRowBefore'});

   157 							sm.add({title : 'table.row_after_desc', icon : 'row_after', cmd : 'mceTableInsertRowAfter'});

   158 							sm.add({title : 'table.delete_row_desc', icon : 'delete_row', cmd : 'mceTableDeleteRow'});

   159 							sm.addSeparator();

   160 							sm.add({title : 'table.cut_row_desc', icon : 'cut', cmd : 'mceTableCutRow'});

   161 							sm.add({title : 'table.copy_row_desc', icon : 'copy', cmd : 'mceTableCopyRow'});

   162 							sm.add({title : 'table.paste_row_before_desc', icon : 'paste', cmd : 'mceTablePasteRowBefore'});

   163 							sm.add({title : 'table.paste_row_after_desc', icon : 'paste', cmd : 'mceTablePasteRowAfter'});

   164 

   165 							// Column menu

   166 							sm = m.addMenu({title : 'table.col'});

   167 							sm.add({title : 'table.col_before_desc', icon : 'col_before', cmd : 'mceTableInsertColBefore'});

   168 							sm.add({title : 'table.col_after_desc', icon : 'col_after', cmd : 'mceTableInsertColAfter'});

   169 							sm.add({title : 'table.delete_col_desc', icon : 'delete_col', cmd : 'mceTableDeleteCol'});

   170 						} else

   171 							m.add({title : 'table.desc', icon : 'table', cmd : 'mceInsertTable', ui : true});

   172 					});

   173 				}

   174 			});

   175 

   176 			// Add undo level when new rows are created using the tab key

   177 			ed.onKeyDown.add(function(ed, e) {

   178 				if (e.keyCode == 9 && ed.dom.getParent(ed.selection.getNode(), 'TABLE')) {

   179 					if (!tinymce.isGecko && !tinymce.isOpera) {

   180 						tinyMCE.execInstanceCommand(ed.editorId, "mceTableMoveToNextRow", true);

   181 						return tinymce.dom.Event.cancel(e);

   182 					}

   183 

   184 					ed.undoManager.add();

   185 				}

   186 			});

   187 

   188 			// Select whole table is a table border is clicked

   189 			if (!tinymce.isIE) {

   190 				if (ed.getParam('table_selection', true)) {

   191 					ed.onClick.add(function(ed, e) {

   192 						e = e.target;

   193 

   194 						if (e.nodeName === 'TABLE')

   195 							ed.selection.select(e);

   196 					});

   197 				}

   198 			}

   199 

   200 			ed.onNodeChange.add(function(ed, cm, n) {

   201 				var p = ed.dom.getParent(n, 'td,th,caption');

   202 

   203 				cm.setActive('table', n.nodeName === 'TABLE' || !!p);

   204 				if (p && p.nodeName === 'CAPTION')

   205 					p = null;

   206 

   207 				cm.setDisabled('delete_table', !p);

   208 				cm.setDisabled('delete_col', !p);

   209 				cm.setDisabled('delete_table', !p);

   210 				cm.setDisabled('delete_row', !p);

   211 				cm.setDisabled('col_after', !p);

   212 				cm.setDisabled('col_before', !p);

   213 				cm.setDisabled('row_after', !p);

   214 				cm.setDisabled('row_before', !p);

   215 				cm.setDisabled('row_props', !p);

   216 				cm.setDisabled('cell_props', !p);

   217 				cm.setDisabled('split_cells', !p || (parseInt(ed.dom.getAttrib(p, 'colspan', '1')) < 2 && parseInt(ed.dom.getAttrib(p, 'rowspan', '1')) < 2));

   218 				cm.setDisabled('merge_cells', !p);

   219 			});

   220 

   221 			// Padd empty table cells

   222 			if (!tinymce.isIE) {

   223 				ed.onBeforeSetContent.add(function(ed, o) {

   224 					if (o.initial)

   225 						o.content = o.content.replace(/<(td|th)([^>]+|)>\s*<\/(td|th)>/g, tinymce.isOpera ? '<$1$2>&nbsp;</$1>' : '<$1$2><br mce_bogus="1" /></$1>');

   226 				});

   227 			}

   228 		},

   229 

   230 		execCommand : function(cmd, ui, val) {

   231 			var ed = this.editor, b;

   232 

   233 			// Is table command

   234 			switch (cmd) {

   235 				case "mceTableMoveToNextRow":

   236 				case "mceInsertTable":

   237 				case "mceTableRowProps":

   238 				case "mceTableCellProps":

   239 				case "mceTableSplitCells":

   240 				case "mceTableMergeCells":

   241 				case "mceTableInsertRowBefore":

   242 				case "mceTableInsertRowAfter":

   243 				case "mceTableDeleteRow":

   244 				case "mceTableInsertColBefore":

   245 				case "mceTableInsertColAfter":

   246 				case "mceTableDeleteCol":

   247 				case "mceTableCutRow":

   248 				case "mceTableCopyRow":

   249 				case "mceTablePasteRowBefore":

   250 				case "mceTablePasteRowAfter":

   251 				case "mceTableDelete":

   252 					ed.execCommand('mceBeginUndoLevel');

   253 					this._doExecCommand(cmd, ui, val);

   254 					ed.execCommand('mceEndUndoLevel');

   255 

   256 					return true;

   257 			}

   258 

   259 			// Pass to next handler in chain

   260 			return false;

   261 		},

   262 

   263 		getInfo : function() {

   264 			return {

   265 				longname : 'Tables',

   266 				author : 'Moxiecode Systems AB',

   267 				authorurl : 'http://tinymce.moxiecode.com',

   268 				infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/table',

   269 				version : tinymce.majorVersion + "." + tinymce.minorVersion

   270 			};

   271 		},

   272 

   273 		// Private plugin internal methods

   274 

   275 		/**

   276 		 * Executes the table commands.

   277 		 */

   278 		_doExecCommand : function(command, user_interface, value) {

   279 			var inst = this.editor, ed = inst, url = this.url;

   280 			var focusElm = inst.selection.getNode();

   281 			var trElm = inst.dom.getParent(focusElm, "tr");

   282 			var tdElm = inst.dom.getParent(focusElm, "td,th");

   283 			var tableElm = inst.dom.getParent(focusElm, "table");

   284 			var doc = inst.contentWindow.document;

   285 			var tableBorder = tableElm ? tableElm.getAttribute("border") : "";

   286 

   287 			// Get first TD if no TD found

   288 			if (trElm && tdElm == null)

   289 				tdElm = trElm.cells[0];

   290 

   291 			function inArray(ar, v) {

   292 				for (var i=0; i<ar.length; i++) {

   293 					// Is array

   294 					if (ar[i].length > 0 && inArray(ar[i], v))

   295 						return true;

   296 

   297 					// Found value

   298 					if (ar[i] == v)

   299 						return true;

   300 				}

   301 

   302 				return false;

   303 			}

   304 

   305 			function select(dx, dy) {

   306 				var td;

   307 

   308 				grid = getTableGrid(tableElm);

   309 				dx = dx || 0;

   310 				dy = dy || 0;

   311 				dx = Math.max(cpos.cellindex + dx, 0);

   312 				dy = Math.max(cpos.rowindex + dy, 0);

   313 

   314 				// Recalculate grid and select

   315 				inst.execCommand('mceRepaint');

   316 				td = getCell(grid, dy, dx);

   317 

   318 				if (td) {

   319 					inst.selection.select(td.firstChild || td);

   320 					inst.selection.collapse(1);

   321 				}

   322 			};

   323 

   324 			function makeTD() {

   325 				var newTD = doc.createElement("td");

   326 

   327 				if (!tinymce.isIE)

   328 					newTD.innerHTML = '<br mce_bogus="1"/>';

   329 			}

   330 

   331 			function getColRowSpan(td) {

   332 				var colspan = inst.dom.getAttrib(td, "colspan");

   333 				var rowspan = inst.dom.getAttrib(td, "rowspan");

   334 

   335 				colspan = colspan == "" ? 1 : parseInt(colspan);

   336 				rowspan = rowspan == "" ? 1 : parseInt(rowspan);

   337 

   338 				return {colspan : colspan, rowspan : rowspan};

   339 			}

   340 

   341 			function getCellPos(grid, td) {

   342 				var x, y;

   343 

   344 				for (y=0; y<grid.length; y++) {

   345 					for (x=0; x<grid[y].length; x++) {

   346 						if (grid[y][x] == td)

   347 							return {cellindex : x, rowindex : y};

   348 					}

   349 				}

   350 

   351 				return null;

   352 			}

   353 

   354 			function getCell(grid, row, col) {

   355 				if (grid[row] && grid[row][col])

   356 					return grid[row][col];

   357 

   358 				return null;

   359 			}

   360 

   361 			function getNextCell(table, cell) {

   362 				var cells = [], x = 0, i, j, cell, nextCell;

   363 

   364 				for (i = 0; i < table.rows.length; i++)

   365 					for (j = 0; j < table.rows[i].cells.length; j++, x++)

   366 						cells[x] = table.rows[i].cells[j];

   367 

   368 				for (i = 0; i < cells.length; i++)

   369 					if (cells[i] == cell)

   370 						if (nextCell = cells[i+1])

   371 							return nextCell;

   372 			}

   373 

   374 			function getTableGrid(table) {

   375 				var grid = [], rows = table.rows, x, y, td, sd, xstart, x2, y2;

   376 

   377 				for (y=0; y<rows.length; y++) {

   378 					for (x=0; x<rows[y].cells.length; x++) {

   379 						td = rows[y].cells[x];

   380 						sd = getColRowSpan(td);

   381 

   382 						// All ready filled

   383 						for (xstart = x; grid[y] && grid[y][xstart]; xstart++) ;

   384 

   385 						// Fill box

   386 						for (y2=y; y2<y+sd['rowspan']; y2++) {

   387 							if (!grid[y2])

   388 								grid[y2] = [];

   389 

   390 							for (x2=xstart; x2<xstart+sd['colspan']; x2++)

   391 								grid[y2][x2] = td;

   392 						}

   393 					}

   394 				}

   395 

   396 				return grid;

   397 			}

   398 

   399 			function trimRow(table, tr, td, new_tr) {

   400 				var grid = getTableGrid(table), cpos = getCellPos(grid, td);

   401 				var cells, lastElm;

   402 

   403 				// Time to crop away some

   404 				if (new_tr.cells.length != tr.childNodes.length) {

   405 					cells = tr.childNodes;

   406 					lastElm = null;

   407 

   408 					for (var x=0; td = getCell(grid, cpos.rowindex, x); x++) {

   409 						var remove = true;

   410 						var sd = getColRowSpan(td);

   411 

   412 						// Remove due to rowspan

   413 						if (inArray(cells, td)) {

   414 							new_tr.childNodes[x]._delete = true;

   415 						} else if ((lastElm == null || td != lastElm) && sd.colspan > 1) { // Remove due to colspan

   416 							for (var i=x; i<x+td.colSpan; i++)

   417 								new_tr.childNodes[i]._delete = true;

   418 						}

   419 

   420 						if ((lastElm == null || td != lastElm) && sd.rowspan > 1)

   421 							td.rowSpan = sd.rowspan + 1;

   422 

   423 						lastElm = td;

   424 					}

   425 

   426 					deleteMarked(tableElm);

   427 				}

   428 			}

   429 

   430 			function prevElm(node, name) {

   431 				while ((node = node.previousSibling) != null) {

   432 					if (node.nodeName == name)

   433 						return node;

   434 				}

   435 

   436 				return null;

   437 			}

   438 

   439 			function nextElm(node, names) {

   440 				var namesAr = names.split(',');

   441 

   442 				while ((node = node.nextSibling) != null) {

   443 					for (var i=0; i<namesAr.length; i++) {

   444 						if (node.nodeName.toLowerCase() == namesAr[i].toLowerCase() )

   445 							return node;

   446 					}

   447 				}

   448 

   449 				return null;

   450 			}

   451 

   452 			function deleteMarked(tbl) {

   453 				if (tbl.rows == 0)

   454 					return;

   455 

   456 				var tr = tbl.rows[0];

   457 				do {

   458 					var next = nextElm(tr, "TR");

   459 

   460 					// Delete row

   461 					if (tr._delete) {

   462 						tr.parentNode.removeChild(tr);

   463 						continue;

   464 					}

   465 

   466 					// Delete cells

   467 					var td = tr.cells[0];

   468 					if (td.cells > 1) {

   469 						do {

   470 							var nexttd = nextElm(td, "TD,TH");

   471 

   472 							if (td._delete)

   473 								td.parentNode.removeChild(td);

   474 						} while ((td = nexttd) != null);

   475 					}

   476 				} while ((tr = next) != null);

   477 			}

   478 

   479 			function addRows(td_elm, tr_elm, rowspan) {

   480 				// Add rows

   481 				td_elm.rowSpan = 1;

   482 				var trNext = nextElm(tr_elm, "TR");

   483 				for (var i=1; i<rowspan && trNext; i++) {

   484 					var newTD = doc.createElement("td");

   485 

   486 					if (!tinymce.isIE)

   487 						newTD.innerHTML = '<br mce_bogus="1"/>';

   488 

   489 					if (tinymce.isIE)

   490 						trNext.insertBefore(newTD, trNext.cells(td_elm.cellIndex));

   491 					else

   492 						trNext.insertBefore(newTD, trNext.cells[td_elm.cellIndex]);

   493 

   494 					trNext = nextElm(trNext, "TR");

   495 				}

   496 			}

   497 

   498 			function copyRow(doc, table, tr) {

   499 				var grid = getTableGrid(table);

   500 				var newTR = tr.cloneNode(false);

   501 				var cpos = getCellPos(grid, tr.cells[0]);

   502 				var lastCell = null;

   503 				var tableBorder = inst.dom.getAttrib(table, "border");

   504 				var tdElm = null;

   505 

   506 				for (var x=0; tdElm = getCell(grid, cpos.rowindex, x); x++) {

   507 					var newTD = null;

   508 

   509 					if (lastCell != tdElm) {

   510 						for (var i=0; i<tr.cells.length; i++) {

   511 							if (tdElm == tr.cells[i]) {

   512 								newTD = tdElm.cloneNode(true);

   513 								break;

   514 							}

   515 						}

   516 					}

   517 

   518 					if (newTD == null) {

   519 						newTD = doc.createElement("td");

   520 

   521 						if (!tinymce.isIE)

   522 							newTD.innerHTML = '<br mce_bogus="1"/>';

   523 					}

   524 

   525 					// Reset col/row span

   526 					newTD.colSpan = 1;

   527 					newTD.rowSpan = 1;

   528 

   529 					newTR.appendChild(newTD);

   530 

   531 					lastCell = tdElm;

   532 				}

   533 

   534 				return newTR;

   535 			}

   536 

   537 			// ---- Commands -----

   538 

   539 			// Handle commands

   540 			switch (command) {

   541 				case "mceTableMoveToNextRow":

   542 					var nextCell = getNextCell(tableElm, tdElm);

   543 

   544 					if (!nextCell) {

   545 						inst.execCommand("mceTableInsertRowAfter", tdElm);

   546 						nextCell = getNextCell(tableElm, tdElm);

   547 					}

   548 

   549 					inst.selection.select(nextCell);

   550 					inst.selection.collapse(true);

   551 

   552 					return true;

   553 

   554 				case "mceTableRowProps":

   555 					if (trElm == null)

   556 						return true;

   557 

   558 					if (user_interface) {

   559 						inst.windowManager.open({

   560 							url : url + '/row.htm',

   561 							width : 400 + parseInt(inst.getLang('table.rowprops_delta_width', 0)),

   562 							height : 295 + parseInt(inst.getLang('table.rowprops_delta_height', 0)),

   563 							inline : 1

   564 						}, {

   565 							plugin_url : url

   566 						});

   567 					}

   568 

   569 					return true;

   570 

   571 				case "mceTableCellProps":

   572 					if (tdElm == null)

   573 						return true;

   574 

   575 					if (user_interface) {

   576 						inst.windowManager.open({

   577 							url : url + '/cell.htm',

   578 							width : 400 + parseInt(inst.getLang('table.cellprops_delta_width', 0)),

   579 							height : 295 + parseInt(inst.getLang('table.cellprops_delta_height', 0)),

   580 							inline : 1

   581 						}, {

   582 							plugin_url : url

   583 						});

   584 					}

   585 

   586 					return true;

   587 

   588 				case "mceInsertTable":

   589 					if (user_interface) {

   590 						inst.windowManager.open({

   591 							url : url + '/table.htm',

   592 							width : 400 + parseInt(inst.getLang('table.table_delta_width', 0)),

   593 							height : 320 + parseInt(inst.getLang('table.table_delta_height', 0)),

   594 							inline : 1

   595 						}, {

   596 							plugin_url : url,

   597 							action : value ? value.action : 0

   598 						});

   599 					}

   600 

   601 					return true;

   602 

   603 				case "mceTableDelete":

   604 					var table = inst.dom.getParent(inst.selection.getNode(), "table");

   605 					if (table) {

   606 						table.parentNode.removeChild(table);

   607 						inst.execCommand('mceRepaint');

   608 					}

   609 					return true;

   610 

   611 				case "mceTableSplitCells":

   612 				case "mceTableMergeCells":

   613 				case "mceTableInsertRowBefore":

   614 				case "mceTableInsertRowAfter":

   615 				case "mceTableDeleteRow":

   616 				case "mceTableInsertColBefore":

   617 				case "mceTableInsertColAfter":

   618 				case "mceTableDeleteCol":

   619 				case "mceTableCutRow":

   620 				case "mceTableCopyRow":

   621 				case "mceTablePasteRowBefore":

   622 				case "mceTablePasteRowAfter":

   623 					// No table just return (invalid command)

   624 					if (!tableElm)

   625 						return true;

   626 

   627 					// Table has a tbody use that reference

   628 					// Changed logic by ApTest 2005.07.12 (www.aptest.com)

   629 					// Now lookk at the focused element and take its parentNode.  That will be a tbody or a table.

   630 					if (trElm && tableElm != trElm.parentNode)

   631 						tableElm = trElm.parentNode;

   632 

   633 					if (tableElm && trElm) {

   634 						switch (command) {

   635 							case "mceTableCutRow":

   636 								if (!trElm || !tdElm)

   637 									return true;

   638 

   639 								inst.tableRowClipboard = copyRow(doc, tableElm, trElm);

   640 								inst.execCommand("mceTableDeleteRow");

   641 								break;

   642 

   643 							case "mceTableCopyRow":

   644 								if (!trElm || !tdElm)

   645 									return true;

   646 

   647 								inst.tableRowClipboard = copyRow(doc, tableElm, trElm);

   648 								break;

   649 

   650 							case "mceTablePasteRowBefore":

   651 								if (!trElm || !tdElm)

   652 									return true;

   653 

   654 								var newTR = inst.tableRowClipboard.cloneNode(true);

   655 

   656 								var prevTR = prevElm(trElm, "TR");

   657 								if (prevTR != null)

   658 									trimRow(tableElm, prevTR, prevTR.cells[0], newTR);

   659 

   660 								trElm.parentNode.insertBefore(newTR, trElm);

   661 								break;

   662 

   663 							case "mceTablePasteRowAfter":

   664 								if (!trElm || !tdElm)

   665 									return true;

   666 								

   667 								var nextTR = nextElm(trElm, "TR");

   668 								var newTR = inst.tableRowClipboard.cloneNode(true);

   669 

   670 								trimRow(tableElm, trElm, tdElm, newTR);

   671 

   672 								if (nextTR == null)

   673 									trElm.parentNode.appendChild(newTR);

   674 								else

   675 									nextTR.parentNode.insertBefore(newTR, nextTR);

   676 

   677 								break;

   678 

   679 							case "mceTableInsertRowBefore":

   680 								if (!trElm || !tdElm)

   681 									return true;

   682 

   683 								var grid = getTableGrid(tableElm);

   684 								var cpos = getCellPos(grid, tdElm);

   685 								var newTR = doc.createElement("tr");

   686 								var lastTDElm = null;

   687 

   688 								cpos.rowindex--;

   689 								if (cpos.rowindex < 0)

   690 									cpos.rowindex = 0;

   691 

   692 								// Create cells

   693 								for (var x=0; tdElm = getCell(grid, cpos.rowindex, x); x++) {

   694 									if (tdElm != lastTDElm) {

   695 										var sd = getColRowSpan(tdElm);

   696 

   697 										if (sd['rowspan'] == 1) {

   698 											var newTD = doc.createElement("td");

   699 

   700 											if (!tinymce.isIE)

   701 												newTD.innerHTML = '<br mce_bogus="1"/>';

   702 

   703 											newTD.colSpan = tdElm.colSpan;

   704 

   705 											newTR.appendChild(newTD);

   706 										} else

   707 											tdElm.rowSpan = sd['rowspan'] + 1;

   708 

   709 										lastTDElm = tdElm;

   710 									}

   711 								}

   712 

   713 								trElm.parentNode.insertBefore(newTR, trElm);

   714 								select(0, 1);

   715 							break;

   716 

   717 							case "mceTableInsertRowAfter":

   718 								if (!trElm || !tdElm)

   719 									return true;

   720 

   721 								var grid = getTableGrid(tableElm);

   722 								var cpos = getCellPos(grid, tdElm);

   723 								var newTR = doc.createElement("tr");

   724 								var lastTDElm = null;

   725 

   726 								// Create cells

   727 								for (var x=0; tdElm = getCell(grid, cpos.rowindex, x); x++) {

   728 									if (tdElm != lastTDElm) {

   729 										var sd = getColRowSpan(tdElm);

   730 

   731 										if (sd['rowspan'] == 1) {

   732 											var newTD = doc.createElement("td");

   733 

   734 											if (!tinymce.isIE)

   735 												newTD.innerHTML = '<br mce_bogus="1"/>';

   736 

   737 											newTD.colSpan = tdElm.colSpan;

   738 

   739 											newTR.appendChild(newTD);

   740 										} else

   741 											tdElm.rowSpan = sd['rowspan'] + 1;

   742 

   743 										lastTDElm = tdElm;

   744 									}

   745 								}

   746 

   747 								if (newTR.hasChildNodes()) {

   748 									var nextTR = nextElm(trElm, "TR");

   749 									if (nextTR)

   750 										nextTR.parentNode.insertBefore(newTR, nextTR);

   751 									else

   752 										tableElm.appendChild(newTR);

   753 								}

   754 

   755 								select(0, 1);

   756 							break;

   757 

   758 							case "mceTableDeleteRow":

   759 								if (!trElm || !tdElm)

   760 									return true;

   761 

   762 								var grid = getTableGrid(tableElm);

   763 								var cpos = getCellPos(grid, tdElm);

   764 

   765 								// Only one row, remove whole table

   766 								if (grid.length == 1 && tableElm.nodeName == 'TBODY') {

   767 									inst.dom.remove(inst.dom.getParent(tableElm, "table"));

   768 									return true;

   769 								}

   770 

   771 								// Move down row spanned cells

   772 								var cells = trElm.cells;

   773 								var nextTR = nextElm(trElm, "TR");

   774 								for (var x=0; x<cells.length; x++) {

   775 									if (cells[x].rowSpan > 1) {

   776 										var newTD = cells[x].cloneNode(true);

   777 										var sd = getColRowSpan(cells[x]);

   778 

   779 										newTD.rowSpan = sd.rowspan - 1;

   780 

   781 										var nextTD = nextTR.cells[x];

   782 

   783 										if (nextTD == null)

   784 											nextTR.appendChild(newTD);

   785 										else

   786 											nextTR.insertBefore(newTD, nextTD);

   787 									}

   788 								}

   789 

   790 								// Delete cells

   791 								var lastTDElm = null;

   792 								for (var x=0; tdElm = getCell(grid, cpos.rowindex, x); x++) {

   793 									if (tdElm != lastTDElm) {

   794 										var sd = getColRowSpan(tdElm);

   795 

   796 										if (sd.rowspan > 1) {

   797 											tdElm.rowSpan = sd.rowspan - 1;

   798 										} else {

   799 											trElm = tdElm.parentNode;

   800 

   801 											if (trElm.parentNode)

   802 												trElm._delete = true;

   803 										}

   804 

   805 										lastTDElm = tdElm;

   806 									}

   807 								}

   808 

   809 								deleteMarked(tableElm);

   810 

   811 								select(0, -1);

   812 							break;

   813 

   814 							case "mceTableInsertColBefore":

   815 								if (!trElm || !tdElm)

   816 									return true;

   817 

   818 								var grid = getTableGrid(inst.dom.getParent(tableElm, "table"));

   819 								var cpos = getCellPos(grid, tdElm);

   820 								var lastTDElm = null;

   821 

   822 								for (var y=0; tdElm = getCell(grid, y, cpos.cellindex); y++) {

   823 									if (tdElm != lastTDElm) {

   824 										var sd = getColRowSpan(tdElm);

   825 

   826 										if (sd['colspan'] == 1) {

   827 											var newTD = doc.createElement(tdElm.nodeName);

   828 

   829 											if (!tinymce.isIE)

   830 												newTD.innerHTML = '<br mce_bogus="1"/>';

   831 

   832 											newTD.rowSpan = tdElm.rowSpan;

   833 

   834 											tdElm.parentNode.insertBefore(newTD, tdElm);

   835 										} else

   836 											tdElm.colSpan++;

   837 

   838 										lastTDElm = tdElm;

   839 									}

   840 								}

   841 

   842 								select();

   843 							break;

   844 

   845 							case "mceTableInsertColAfter":

   846 								if (!trElm || !tdElm)

   847 									return true;

   848 

   849 								var grid = getTableGrid(inst.dom.getParent(tableElm, "table"));

   850 								var cpos = getCellPos(grid, tdElm);

   851 								var lastTDElm = null;

   852 

   853 								for (var y=0; tdElm = getCell(grid, y, cpos.cellindex); y++) {

   854 									if (tdElm != lastTDElm) {

   855 										var sd = getColRowSpan(tdElm);

   856 

   857 										if (sd['colspan'] == 1) {

   858 											var newTD = doc.createElement(tdElm.nodeName);

   859 

   860 											if (!tinymce.isIE)

   861 												newTD.innerHTML = '<br mce_bogus="1"/>';

   862 

   863 											newTD.rowSpan = tdElm.rowSpan;

   864 

   865 											var nextTD = nextElm(tdElm, "TD,TH");

   866 											if (nextTD == null)

   867 												tdElm.parentNode.appendChild(newTD);

   868 											else

   869 												nextTD.parentNode.insertBefore(newTD, nextTD);

   870 										} else

   871 											tdElm.colSpan++;

   872 

   873 										lastTDElm = tdElm;

   874 									}

   875 								}

   876 

   877 								select(1);

   878 							break;

   879 

   880 							case "mceTableDeleteCol":

   881 								if (!trElm || !tdElm)

   882 									return true;

   883 

   884 								var grid = getTableGrid(tableElm);

   885 								var cpos = getCellPos(grid, tdElm);

   886 								var lastTDElm = null;

   887 

   888 								// Only one col, remove whole table

   889 								if ((grid.length > 1 && grid[0].length <= 1) && tableElm.nodeName == 'TBODY') {

   890 									inst.dom.remove(inst.dom.getParent(tableElm, "table"));

   891 									return true;

   892 								}

   893 

   894 								// Delete cells

   895 								for (var y=0; tdElm = getCell(grid, y, cpos.cellindex); y++) {

   896 									if (tdElm != lastTDElm) {

   897 										var sd = getColRowSpan(tdElm);

   898 

   899 										if (sd['colspan'] > 1)

   900 											tdElm.colSpan = sd['colspan'] - 1;

   901 										else {

   902 											if (tdElm.parentNode)

   903 												tdElm.parentNode.removeChild(tdElm);

   904 										}

   905 

   906 										lastTDElm = tdElm;

   907 									}

   908 								}

   909 

   910 								select(-1);

   911 							break;

   912 

   913 						case "mceTableSplitCells":

   914 							if (!trElm || !tdElm)

   915 								return true;

   916 

   917 							var spandata = getColRowSpan(tdElm);

   918 

   919 							var colspan = spandata["colspan"];

   920 							var rowspan = spandata["rowspan"];

   921 

   922 							// Needs splitting

   923 							if (colspan > 1 || rowspan > 1) {

   924 								// Generate cols

   925 								tdElm.colSpan = 1;

   926 								for (var i=1; i<colspan; i++) {

   927 									var newTD = doc.createElement("td");

   928 

   929 									if (!tinymce.isIE)

   930 										newTD.innerHTML = '<br mce_bogus="1"/>';

   931 

   932 									trElm.insertBefore(newTD, nextElm(tdElm, "TD,TH"));

   933 

   934 									if (rowspan > 1)

   935 										addRows(newTD, trElm, rowspan);

   936 								}

   937 

   938 								addRows(tdElm, trElm, rowspan);

   939 							}

   940 

   941 							// Apply visual aids

   942 							tableElm = inst.dom.getParent(inst.selection.getNode(), "table");

   943 							break;

   944 

   945 						case "mceTableMergeCells":

   946 							var rows = [];

   947 							var sel = inst.selection.getSel();

   948 							var grid = getTableGrid(tableElm);

   949 

   950 							if (tinymce.isIE || sel.rangeCount == 1) {

   951 								if (user_interface) {

   952 									// Setup template

   953 									var sp = getColRowSpan(tdElm);

   954 

   955 									inst.windowManager.open({

   956 										url : url + '/merge_cells.htm',

   957 										width : 240 + parseInt(inst.getLang('table.merge_cells_delta_width', 0)),

   958 										height : 110 + parseInt(inst.getLang('table.merge_cells_delta_height', 0)),

   959 										inline : 1

   960 									}, {

   961 										action : "update",

   962 										numcols : sp.colspan,

   963 										numrows : sp.rowspan,

   964 										plugin_url : url

   965 									});

   966 

   967 									return true;

   968 								} else {

   969 									var numRows = parseInt(value['numrows']);

   970 									var numCols = parseInt(value['numcols']);

   971 									var cpos = getCellPos(grid, tdElm);

   972 

   973 									if (("" + numRows) == "NaN")

   974 										numRows = 1;

   975 

   976 									if (("" + numCols) == "NaN")

   977 										numCols = 1;

   978 

   979 									// Get rows and cells

   980 									var tRows = tableElm.rows;

   981 									for (var y=cpos.rowindex; y<grid.length; y++) {

   982 										var rowCells = [];

   983 

   984 										for (var x=cpos.cellindex; x<grid[y].length; x++) {

   985 											var td = getCell(grid, y, x);

   986 

   987 											if (td && !inArray(rows, td) && !inArray(rowCells, td)) {

   988 												var cp = getCellPos(grid, td);

   989 

   990 												// Within range

   991 												if (cp.cellindex < cpos.cellindex+numCols && cp.rowindex < cpos.rowindex+numRows)

   992 													rowCells[rowCells.length] = td;

   993 											}

   994 										}

   995 

   996 										if (rowCells.length > 0)

   997 											rows[rows.length] = rowCells;

   998 

   999 										var td = getCell(grid, cpos.rowindex, cpos.cellindex);

  1000 										each(ed.dom.select('br', td), function(e, i) {

  1001 											if (i > 0 && ed.dom.getAttrib('mce_bogus'))

  1002 												ed.dom.remove(e);

  1003 										});

  1004 									}

  1005 

  1006 									//return true;

  1007 								}

  1008 							} else {

  1009 								var cells = [];

  1010 								var sel = inst.selection.getSel();

  1011 								var lastTR = null;

  1012 								var curRow = null;

  1013 								var x1 = -1, y1 = -1, x2, y2;

  1014 

  1015 								// Only one cell selected, whats the point?

  1016 								if (sel.rangeCount < 2)

  1017 									return true;

  1018 

  1019 								// Get all selected cells

  1020 								for (var i=0; i<sel.rangeCount; i++) {

  1021 									var rng = sel.getRangeAt(i);

  1022 									var tdElm = rng.startContainer.childNodes[rng.startOffset];

  1023 

  1024 									if (!tdElm)

  1025 										break;

  1026 

  1027 									if (tdElm.nodeName == "TD" || tdElm.nodeName == "TH")

  1028 										cells[cells.length] = tdElm;

  1029 								}

  1030 

  1031 								// Get rows and cells

  1032 								var tRows = tableElm.rows;

  1033 								for (var y=0; y<tRows.length; y++) {

  1034 									var rowCells = [];

  1035 

  1036 									for (var x=0; x<tRows[y].cells.length; x++) {

  1037 										var td = tRows[y].cells[x];

  1038 

  1039 										for (var i=0; i<cells.length; i++) {

  1040 											if (td == cells[i]) {

  1041 												rowCells[rowCells.length] = td;

  1042 											}

  1043 										}

  1044 									}

  1045 

  1046 									if (rowCells.length > 0)

  1047 										rows[rows.length] = rowCells;

  1048 								}

  1049 

  1050 								// Find selected cells in grid and box

  1051 								var curRow = [];

  1052 								var lastTR = null;

  1053 								for (var y=0; y<grid.length; y++) {

  1054 									for (var x=0; x<grid[y].length; x++) {

  1055 										grid[y][x]._selected = false;

  1056 

  1057 										for (var i=0; i<cells.length; i++) {

  1058 											if (grid[y][x] == cells[i]) {

  1059 												// Get start pos

  1060 												if (x1 == -1) {

  1061 													x1 = x;

  1062 													y1 = y;

  1063 												}

  1064 

  1065 												// Get end pos

  1066 												x2 = x;

  1067 												y2 = y;

  1068 

  1069 												grid[y][x]._selected = true;

  1070 											}

  1071 										}

  1072 									}

  1073 								}

  1074 

  1075 								// Is there gaps, if so deny

  1076 								for (var y=y1; y<=y2; y++) {

  1077 									for (var x=x1; x<=x2; x++) {

  1078 										if (!grid[y][x]._selected) {

  1079 											alert("Invalid selection for merge.");

  1080 											return true;

  1081 										}

  1082 									}

  1083 								}

  1084 							}

  1085 

  1086 							// Validate selection and get total rowspan and colspan

  1087 							var rowSpan = 1, colSpan = 1;

  1088 

  1089 							// Validate horizontal and get total colspan

  1090 							var lastRowSpan = -1;

  1091 							for (var y=0; y<rows.length; y++) {

  1092 								var rowColSpan = 0;

  1093 

  1094 								for (var x=0; x<rows[y].length; x++) {

  1095 									var sd = getColRowSpan(rows[y][x]);

  1096 

  1097 									rowColSpan += sd['colspan'];

  1098 

  1099 									if (lastRowSpan != -1 && sd['rowspan'] != lastRowSpan) {

  1100 										alert("Invalid selection for merge.");

  1101 										return true;

  1102 									}

  1103 

  1104 									lastRowSpan = sd['rowspan'];

  1105 								}

  1106 

  1107 								if (rowColSpan > colSpan)

  1108 									colSpan = rowColSpan;

  1109 

  1110 								lastRowSpan = -1;

  1111 							}

  1112 

  1113 							// Validate vertical and get total rowspan

  1114 							var lastColSpan = -1;

  1115 							for (var x=0; x<rows[0].length; x++) {

  1116 								var colRowSpan = 0;

  1117 

  1118 								for (var y=0; y<rows.length; y++) {

  1119 									var sd = getColRowSpan(rows[y][x]);

  1120 

  1121 									colRowSpan += sd['rowspan'];

  1122 

  1123 									if (lastColSpan != -1 && sd['colspan'] != lastColSpan) {

  1124 										alert("Invalid selection for merge.");

  1125 										return true;

  1126 									}

  1127 

  1128 									lastColSpan = sd['colspan'];

  1129 								}

  1130 

  1131 								if (colRowSpan > rowSpan)

  1132 									rowSpan = colRowSpan;

  1133 

  1134 								lastColSpan = -1;

  1135 							}