X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Ftiny_mce%2Fplugins%2Ftable%2Feditor_plugin_src.js;h=ccfe808f683cb339b17d6f0c7b6924a52674b59a;hb=b05f4eef4014db3885787ef15107cba93c932ac9;hp=fe77639098846ac3e2745c6d6520d50ba7737dc8;hpb=3cedf3f420a1c9316773aa7423689a4f501a3bf8;p=citadel.git diff --git a/webcit/tiny_mce/plugins/table/editor_plugin_src.js b/webcit/tiny_mce/plugins/table/editor_plugin_src.js index fe7763909..ccfe808f6 100644 --- a/webcit/tiny_mce/plugins/table/editor_plugin_src.js +++ b/webcit/tiny_mce/plugins/table/editor_plugin_src.js @@ -1,1041 +1,1364 @@ -/* Import plugin specific language pack */ -tinyMCE.importPluginLanguagePack('table', 'en,ar,cs,da,de,el,es,fi,fr_ca,hu,it,ja,ko,nl,nb,pl,pt,pt_br,sv,tw,zh_cn,fr,de,he,nb,ru,ru_KOI8-R,ru_UTF-8,nn,cy,is,zh_tw,zh_tw_utf8,sk'); - -function TinyMCE_table_getInfo() { - return { - longname : 'Tables', - author : 'Moxiecode Systems', - authorurl : 'http://tinymce.moxiecode.com', - infourl : 'http://tinymce.moxiecode.com/tinymce/docs/plugin_table.html', - version : tinyMCE.majorVersion + "." + tinyMCE.minorVersion - }; -}; - -function TinyMCE_table_initInstance(inst) { - if (tinyMCE.isGecko) { - var doc = inst.getDoc(); - tinyMCE.addEvent(doc, "mouseup", TinyMCE_table_mouseDownHandler); - } - - inst.tableRowClipboard = null; -} - -function TinyMCE_table_mouseDownHandler(e) { - var elm = tinyMCE.isMSIE ? event.srcElement : e.target; - var focusElm = tinyMCE.selectedInstance.getFocusElement(); - - // If press on special Mozilla create TD/TR thingie - if (elm.nodeName == "BODY" && (focusElm.nodeName == "TD" || focusElm.nodeName == "TH" || (focusElm.parentNode && focusElm.parentNode.nodeName == "TD") ||(focusElm.parentNode && focusElm.parentNode.nodeName == "TH") )) { - window.setTimeout(function() { - var tableElm = tinyMCE.getParentElement(focusElm, "table"); - tinyMCE.handleVisualAid(tableElm, true, tinyMCE.settings['visual'], tinyMCE.selectedInstance); - }, 10); - } -} - -/** - * Returns the HTML contents of the table control. - */ -function TinyMCE_table_getControlHTML(control_name) { - var controls = new Array( - ['table', 'table.gif', '{$lang_table_desc}', 'mceInsertTable', true], - ['delete_col', 'table_delete_col.gif', '{$lang_table_delete_col_desc}', 'mceTableDeleteCol'], - ['delete_row', 'table_delete_row.gif', '{$lang_table_delete_row_desc}', 'mceTableDeleteRow'], - ['col_after', 'table_insert_col_after.gif', '{$lang_table_col_after_desc}', 'mceTableInsertColAfter'], - ['col_before', 'table_insert_col_before.gif', '{$lang_table_col_before_desc}', 'mceTableInsertColBefore'], - ['row_after', 'table_insert_row_after.gif', '{$lang_table_row_after_desc}', 'mceTableInsertRowAfter'], - ['row_before', 'table_insert_row_before.gif', '{$lang_table_row_before_desc}', 'mceTableInsertRowBefore'], - ['row_props', 'table_row_props.gif', '{$lang_table_row_desc}', 'mceTableRowProps', true], - ['cell_props', 'table_cell_props.gif', '{$lang_table_cell_desc}', 'mceTableCellProps', true], - ['split_cells', 'table_split_cells.gif', '{$lang_table_split_cells_desc}', 'mceTableSplitCells', true], - ['merge_cells', 'table_merge_cells.gif', '{$lang_table_merge_cells_desc}', 'mceTableMergeCells', true]); - - // Render table control - for (var i=0; i 4 ? but[4] : false) + (but.length > 5 ? ', \'' + but[5] + '\'' : '') + ');return false;'; - - if (but[0] == control_name && (tinyMCE.isMSIE || !tinyMCE.settings['button_tile_map'])) - return ''; - else if (but[0] == control_name) - return ''; - } - - // Special tablecontrols - if (control_name == "tablecontrols") { - var html = ""; - - html += tinyMCE.getControlHTML("table"); - html += tinyMCE.getControlHTML("separator"); - html += tinyMCE.getControlHTML("row_props"); - html += tinyMCE.getControlHTML("cell_props"); - html += tinyMCE.getControlHTML("separator"); - html += tinyMCE.getControlHTML("row_before"); - html += tinyMCE.getControlHTML("row_after"); - html += tinyMCE.getControlHTML("delete_row"); - html += tinyMCE.getControlHTML("separator"); - html += tinyMCE.getControlHTML("col_before"); - html += tinyMCE.getControlHTML("col_after"); - html += tinyMCE.getControlHTML("delete_col"); - html += tinyMCE.getControlHTML("separator"); - html += tinyMCE.getControlHTML("split_cells"); - html += tinyMCE.getControlHTML("merge_cells"); - - return html; - } - - return ""; -} - -/** - * Executes the table commands. - */ -function TinyMCE_table_execCommand(editor_id, element, command, user_interface, value) { - // Is table command - switch (command) { - case "mceInsertTable": - case "mceTableRowProps": - case "mceTableCellProps": - case "mceTableSplitCells": - case "mceTableMergeCells": - case "mceTableInsertRowBefore": - case "mceTableInsertRowAfter": - case "mceTableDeleteRow": - case "mceTableInsertColBefore": - case "mceTableInsertColAfter": - case "mceTableDeleteCol": - case "mceTableCutRow": - case "mceTableCopyRow": - case "mceTablePasteRowBefore": - case "mceTablePasteRowAfter": - case "mceTableDelete": - var inst = tinyMCE.getInstanceById(editor_id); - - inst.execCommand('mceBeginUndoLevel'); - TinyMCE_table_doExecCommand(editor_id, element, command, user_interface, value); - inst.execCommand('mceEndUndoLevel'); - - return true; - } - - // Pass to next handler in chain - return false; -} - -/** - * Executes the table commands. - */ -function TinyMCE_table_doExecCommand(editor_id, element, command, user_interface, value) { - var inst = tinyMCE.getInstanceById(editor_id); - var focusElm = inst.getFocusElement(); - var trElm = tinyMCE.getParentElement(focusElm, "tr"); - var tdElm = tinyMCE.getParentElement(focusElm, "td,th"); - var tableElm = tinyMCE.getParentElement(focusElm, "table"); - var doc = inst.contentWindow.document; - var tableBorder = tableElm ? tableElm.getAttribute("border") : ""; - - // Get first TD if no TD found - if (trElm && tdElm == null) - tdElm = trElm.cells[0]; - - // ------- Inner functions --------- - function inArray(ar, v) { - for (var i=0; i 0 && inArray(ar[i], v)) - return true; - - // Found value - if (ar[i] == v) - return true; - } - - return false; - } - - function makeTD() { - var newTD = doc.createElement("td"); - newTD.innerHTML = " "; - } - - function getColRowSpan(td) { - var colspan = tinyMCE.getAttrib(td, "colspan"); - var rowspan = tinyMCE.getAttrib(td, "rowspan"); - - colspan = colspan == "" ? 1 : parseInt(colspan); - rowspan = rowspan == "" ? 1 : parseInt(rowspan); - - return {colspan : colspan, rowspan : rowspan}; - } - - function getCellPos(grid, td) { - for (var y=0; y 1) { // Remove due to colspan - for (var i=x; i 1) - td.rowSpan = sd.rowspan + 1; - - lastElm = td; - } - - deleteMarked(tableElm); - } - } - - function prevElm(node, name) { - while ((node = node.previousSibling) != null) { - if (node.nodeName == name) - return node; - } - - return null; - } - - function nextElm(node, names) { - var namesAr = names.split(','); - - while ((node = node.nextSibling) != null) { - for (var i=0; i 1) { - do { - var nexttd = nextElm(td, "TD,TH"); - - if (td._delete) - td.parentNode.removeChild(td); - } while ((td = nexttd) != null); - } - } while ((tr = next) != null); - } - - function addRows(td_elm, tr_elm, rowspan) { - // Add rows - td_elm.rowSpan = 1; - var trNext = nextElm(tr_elm, "TR"); - for (var i=1; i 1) { - var newTD = cells[x].cloneNode(true); - var sd = getColRowSpan(cells[x]); - - newTD.rowSpan = sd.rowspan - 1; - - var nextTD = nextTR.cells[x]; - - if (nextTD == null) - nextTR.appendChild(newTD); - else - nextTR.insertBefore(newTD, nextTD); - } - } - - // Delete cells - var lastTDElm = null; - for (var x=0; tdElm = getCell(grid, cpos.rowindex, x); x++) { - if (tdElm != lastTDElm) { - var sd = getColRowSpan(tdElm); - - if (sd.rowspan > 1) { - tdElm.rowSpan = sd.rowspan - 1; - } else { - trElm = tdElm.parentNode; - - if (trElm.parentNode) - trElm._delete = true; - } - - lastTDElm = tdElm; - } - } - - deleteMarked(tableElm); - - cpos.rowindex--; - if (cpos.rowindex < 0) - cpos.rowindex = 0; - - inst.selectNode(getCell(grid, cpos.rowindex, 0), true, true); - break; - - case "mceTableInsertColBefore": - if (!trElm || !tdElm) - return true; - - var grid = getTableGrid(tableElm); - var cpos = getCellPos(grid, tdElm); - var lastTDElm = null; - - for (var y=0; tdElm = getCell(grid, y, cpos.cellindex); y++) { - if (tdElm != lastTDElm) { - var sd = getColRowSpan(tdElm); - - if (sd['colspan'] == 1) { - var newTD = doc.createElement(tdElm.nodeName); - - newTD.innerHTML = " "; - newTD.rowSpan = tdElm.rowSpan; - - tdElm.parentNode.insertBefore(newTD, tdElm); - } else - tdElm.colSpan++; - - lastTDElm = tdElm; - } - } - break; - - case "mceTableInsertColAfter": - if (!trElm || !tdElm) - return true; - - var grid = getTableGrid(tableElm); - var cpos = getCellPos(grid, tdElm); - var lastTDElm = null; - - for (var y=0; tdElm = getCell(grid, y, cpos.cellindex); y++) { - if (tdElm != lastTDElm) { - var sd = getColRowSpan(tdElm); - - if (sd['colspan'] == 1) { - var newTD = doc.createElement(tdElm.nodeName); - - newTD.innerHTML = " "; - newTD.rowSpan = tdElm.rowSpan; - - var nextTD = nextElm(tdElm, "TD,TH"); - if (nextTD == null) - tdElm.parentNode.appendChild(newTD); - else - nextTD.parentNode.insertBefore(newTD, nextTD); - } else - tdElm.colSpan++; - - lastTDElm = tdElm; - } - } - break; - - case "mceTableDeleteCol": - if (!trElm || !tdElm) - return true; - - var grid = getTableGrid(tableElm); - var cpos = getCellPos(grid, tdElm); - var lastTDElm = null; - - // Only one col, remove whole table - if (grid.length > 1 && grid[0].length <= 1) { - tableElm.parentNode.removeChild(tableElm); - return true; - } - - // Delete cells - for (var y=0; tdElm = getCell(grid, y, cpos.cellindex); y++) { - if (tdElm != lastTDElm) { - var sd = getColRowSpan(tdElm); - - if (sd['colspan'] > 1) - tdElm.colSpan = sd['colspan'] - 1; - else { - if (tdElm.parentNode) - tdElm.parentNode.removeChild(tdElm); - } - - lastTDElm = tdElm; - } - } - - cpos.cellindex--; - if (cpos.cellindex < 0) - cpos.cellindex = 0; - - inst.selectNode(getCell(grid, 0, cpos.cellindex), true, true); - break; - - case "mceTableSplitCells": - if (!trElm || !tdElm) - return true; - - var spandata = getColRowSpan(tdElm); - - var colspan = spandata["colspan"]; - var rowspan = spandata["rowspan"]; - - // Needs splitting - if (colspan > 1 || rowspan > 1) { - // Generate cols - tdElm.colSpan = 1; - for (var i=1; i 1) - addRows(newTD, trElm, rowspan); - } - - addRows(tdElm, trElm, rowspan); - } - - // Apply visual aids - tableElm = tinyMCE.getParentElement(inst.getFocusElement(), "table"); - break; - - case "mceTableMergeCells": - var rows = new Array(); - var sel = inst.getSel(); - var grid = getTableGrid(tableElm); - - if (tinyMCE.isMSIE || sel.rangeCount == 1) { - if (user_interface) { - // Setup template - var template = new Array(); - var sp = getColRowSpan(tdElm); - - template['file'] = '../../plugins/table/merge_cells.htm'; - template['width'] = 250; - template['height'] = 105 + (tinyMCE.isNS7 ? 25 : 0); - - // Language specific width and height addons - template['width'] += tinyMCE.getLang('lang_table_merge_cells_delta_width', 0); - template['height'] += tinyMCE.getLang('lang_table_merge_cells_delta_height', 0); - - // Open window - tinyMCE.openWindow(template, {editor_id : inst.editorId, inline : "yes", action : "update", numcols : sp.colspan, numrows : sp.rowspan}); - - return true; - } else { - var numRows = parseInt(value['numrows']); - var numCols = parseInt(value['numcols']); - var cpos = getCellPos(grid, tdElm); - - if (("" + numRows) == "NaN") - numRows = 1; - - if (("" + numCols) == "NaN") - numCols = 1; - - // Get rows and cells - var tRows = tableElm.rows; - for (var y=cpos.rowindex; y 0) - rows[rows.length] = rowCells; - } - - //return true; - } - } else { - var cells = new Array(); - var sel = inst.getSel(); - var lastTR = null; - var curRow = null; - var x1 = -1, y1 = -1, x2, y2; - - // Only one cell selected, whats the point? - if (sel.rangeCount < 2) - return true; - - // Get all selected cells - for (var i=0; i 0) - rows[rows.length] = rowCells; - } - - // Find selected cells in grid and box - var curRow = new Array(); - var lastTR = null; - for (var y=0; y colSpan) - colSpan = rowColSpan; - - lastRowSpan = -1; - } - - // Validate vertical and get total rowspan - var lastColSpan = -1; - for (var x=0; x rowSpan) - rowSpan = colRowSpan; - - lastColSpan = -1; - } - - // Setup td - tdElm = rows[0][0]; - tdElm.rowSpan = rowSpan; - tdElm.colSpan = colSpan; - - // Merge cells - for (var y=0; y 0)) - tdElm.innerHTML += html; - - // Not current cell - if (rows[y][x] != tdElm && !rows[y][x]._deleted) { - var cpos = getCellPos(grid, rows[y][x]); - var tr = rows[y][x].parentNode; - - tr.removeChild(rows[y][x]); - rows[y][x]._deleted = true; - - // Empty TR, remove it - if (!tr.hasChildNodes()) { - tr.parentNode.removeChild(tr); - - var lastCell = null; - for (var x=0; cellElm = getCell(grid, cpos.rowindex, x); x++) { - if (cellElm != lastCell && cellElm.rowSpan > 1) - cellElm.rowSpan--; - - lastCell = cellElm; - } - - if (tdElm.rowSpan > 1) - tdElm.rowSpan--; - } - } - } - } - - break; - } - - tableElm = tinyMCE.getParentElement(inst.getFocusElement(), "table"); - tinyMCE.handleVisualAid(tableElm, true, tinyMCE.settings['visual'], tinyMCE.selectedInstance); - tinyMCE.triggerNodeChange(); - inst.repaint(); - } - - return true; - } - - // Pass to next handler in chain - return false; -} - -function TinyMCE_table_handleNodeChange(editor_id, node, undo_index, undo_levels, visual_aid, any_selection) { - var colspan = "1", rowspan = "1"; - - var inst = tinyMCE.getInstanceById(editor_id); - - // Reset table controls - tinyMCE.switchClassSticky(editor_id + '_table', 'mceButtonNormal'); - tinyMCE.switchClassSticky(editor_id + '_row_props', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_cell_props', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_row_before', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_row_after', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_delete_row', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_col_before', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_col_after', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_delete_col', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_split_cells', 'mceButtonDisabled', true); - tinyMCE.switchClassSticky(editor_id + '_merge_cells', 'mceButtonDisabled', true); - - // Within a tr element - if (tinyMCE.getParentElement(node, "tr")) - tinyMCE.switchClassSticky(editor_id + '_row_props', 'mceButtonSelected', false); - - // Within a td element - if (tdElm = tinyMCE.getParentElement(node, "td,th")) { - tinyMCE.switchClassSticky(editor_id + '_cell_props', 'mceButtonSelected', false); - tinyMCE.switchClassSticky(editor_id + '_row_before', 'mceButtonNormal', false); - tinyMCE.switchClassSticky(editor_id + '_row_after', 'mceButtonNormal', false); - tinyMCE.switchClassSticky(editor_id + '_delete_row', 'mceButtonNormal', false); - tinyMCE.switchClassSticky(editor_id + '_col_before', 'mceButtonNormal', false); - tinyMCE.switchClassSticky(editor_id + '_col_after', 'mceButtonNormal', false); - tinyMCE.switchClassSticky(editor_id + '_delete_col', 'mceButtonNormal', false); - - colspan = tinyMCE.getAttrib(tdElm, "colspan"); - rowspan = tinyMCE.getAttrib(tdElm, "rowspan"); - - colspan = colspan == "" ? "1" : colspan; - rowspan = rowspan == "" ? "1" : rowspan; - - if (colspan != "1" || rowspan != "1") - tinyMCE.switchClassSticky(editor_id + '_split_cells', 'mceButtonNormal', false); - } - - // Within table - if (tinyMCE.getParentElement(node, "table")) { - tinyMCE.switchClassSticky(editor_id + '_table', 'mceButtonSelected'); - tinyMCE.switchClassSticky(editor_id + '_merge_cells', 'mceButtonNormal', false); - } -} +/** + * editor_plugin_src.js + * + * Copyright 2009, Moxiecode Systems AB + * Released under LGPL License. + * + * License: http://tinymce.moxiecode.com/license + * Contributing: http://tinymce.moxiecode.com/contributing + */ + +(function(tinymce) { + var each = tinymce.each; + + // Checks if the selection/caret is at the start of the specified block element + function isAtStart(rng, par) { + var doc = par.ownerDocument, rng2 = doc.createRange(), elm; + + rng2.setStartBefore(par); + rng2.setEnd(rng.endContainer, rng.endOffset); + + elm = doc.createElement('body'); + elm.appendChild(rng2.cloneContents()); + + // Check for text characters of other elements that should be treated as content + return elm.innerHTML.replace(/<(br|img|object|embed|input|textarea)[^>]*>/gi, '-').replace(/<[^>]+>/g, '').length == 0; + }; + + function getSpanVal(td, name) { + return parseInt(td.getAttribute(name) || 1); + } + + /** + * Table Grid class. + */ + function TableGrid(table, dom, selection) { + var grid, startPos, endPos, selectedCell; + + buildGrid(); + selectedCell = dom.getParent(selection.getStart(), 'th,td'); + if (selectedCell) { + startPos = getPos(selectedCell); + endPos = findEndPos(); + selectedCell = getCell(startPos.x, startPos.y); + } + + function cloneNode(node, children) { + node = node.cloneNode(children); + node.removeAttribute('id'); + + return node; + } + + function buildGrid() { + var startY = 0; + + grid = []; + + each(['thead', 'tbody', 'tfoot'], function(part) { + var rows = dom.select('> ' + part + ' tr', table); + + each(rows, function(tr, y) { + y += startY; + + each(dom.select('> td, > th', tr), function(td, x) { + var x2, y2, rowspan, colspan; + + // Skip over existing cells produced by rowspan + if (grid[y]) { + while (grid[y][x]) + x++; + } + + // Get col/rowspan from cell + rowspan = getSpanVal(td, 'rowspan'); + colspan = getSpanVal(td, 'colspan'); + + // Fill out rowspan/colspan right and down + for (y2 = y; y2 < y + rowspan; y2++) { + if (!grid[y2]) + grid[y2] = []; + + for (x2 = x; x2 < x + colspan; x2++) { + grid[y2][x2] = { + part : part, + real : y2 == y && x2 == x, + elm : td, + rowspan : rowspan, + colspan : colspan + }; + } + } + }); + }); + + startY += rows.length; + }); + }; + + function getCell(x, y) { + var row; + + row = grid[y]; + if (row) + return row[x]; + }; + + function setSpanVal(td, name, val) { + if (td) { + val = parseInt(val); + + if (val === 1) + td.removeAttribute(name, 1); + else + td.setAttribute(name, val, 1); + } + } + + function isCellSelected(cell) { + return cell && (dom.hasClass(cell.elm, 'mceSelected') || cell == selectedCell); + }; + + function getSelectedRows() { + var rows = []; + + each(table.rows, function(row) { + each(row.cells, function(cell) { + if (dom.hasClass(cell, 'mceSelected') || cell == selectedCell.elm) { + rows.push(row); + return false; + } + }); + }); + + return rows; + }; + + function deleteTable() { + var rng = dom.createRng(); + + rng.setStartAfter(table); + rng.setEndAfter(table); + + selection.setRng(rng); + + dom.remove(table); + }; + + function cloneCell(cell) { + var formatNode; + + // Clone formats + tinymce.walk(cell, function(node) { + var curNode; + + if (node.nodeType == 3) { + each(dom.getParents(node.parentNode, null, cell).reverse(), function(node) { + node = cloneNode(node, false); + + if (!formatNode) + formatNode = curNode = node; + else if (curNode) + curNode.appendChild(node); + + curNode = node; + }); + + // Add something to the inner node + if (curNode) + curNode.innerHTML = tinymce.isIE ? ' ' : '
'; + + return false; + } + }, 'childNodes'); + + cell = cloneNode(cell, false); + setSpanVal(cell, 'rowSpan', 1); + setSpanVal(cell, 'colSpan', 1); + + if (formatNode) { + cell.appendChild(formatNode); + } else { + if (!tinymce.isIE) + cell.innerHTML = '
'; + } + + return cell; + }; + + function cleanup() { + var rng = dom.createRng(); + + // Empty rows + each(dom.select('tr', table), function(tr) { + if (tr.cells.length == 0) + dom.remove(tr); + }); + + // Empty table + if (dom.select('tr', table).length == 0) { + rng.setStartAfter(table); + rng.setEndAfter(table); + selection.setRng(rng); + dom.remove(table); + return; + } + + // Empty header/body/footer + each(dom.select('thead,tbody,tfoot', table), function(part) { + if (part.rows.length == 0) + dom.remove(part); + }); + + // Restore selection to start position if it still exists + buildGrid(); + + // Restore the selection to the closest table position + row = grid[Math.min(grid.length - 1, startPos.y)]; + if (row) { + selection.select(row[Math.min(row.length - 1, startPos.x)].elm, true); + selection.collapse(true); + } + }; + + function fillLeftDown(x, y, rows, cols) { + var tr, x2, r, c, cell; + + tr = grid[y][x].elm.parentNode; + for (r = 1; r <= rows; r++) { + tr = dom.getNext(tr, 'tr'); + + if (tr) { + // Loop left to find real cell + for (x2 = x; x2 >= 0; x2--) { + cell = grid[y + r][x2].elm; + + if (cell.parentNode == tr) { + // Append clones after + for (c = 1; c <= cols; c++) + dom.insertAfter(cloneCell(cell), cell); + + break; + } + } + + if (x2 == -1) { + // Insert nodes before first cell + for (c = 1; c <= cols; c++) + tr.insertBefore(cloneCell(tr.cells[0]), tr.cells[0]); + } + } + } + }; + + function split() { + each(grid, function(row, y) { + each(row, function(cell, x) { + var colSpan, rowSpan, newCell, i; + + if (isCellSelected(cell)) { + cell = cell.elm; + colSpan = getSpanVal(cell, 'colspan'); + rowSpan = getSpanVal(cell, 'rowspan'); + + if (colSpan > 1 || rowSpan > 1) { + setSpanVal(cell, 'rowSpan', 1); + setSpanVal(cell, 'colSpan', 1); + + // Insert cells right + for (i = 0; i < colSpan - 1; i++) + dom.insertAfter(cloneCell(cell), cell); + + fillLeftDown(x, y, rowSpan - 1, colSpan); + } + } + }); + }); + }; + + function merge(cell, cols, rows) { + var startX, startY, endX, endY, x, y, startCell, endCell, cell, children, count; + + // Use specified cell and cols/rows + if (cell) { + pos = getPos(cell); + startX = pos.x; + startY = pos.y; + endX = startX + (cols - 1); + endY = startY + (rows - 1); + } else { + // Use selection + startX = startPos.x; + startY = startPos.y; + endX = endPos.x; + endY = endPos.y; + } + + // Find start/end cells + startCell = getCell(startX, startY); + endCell = getCell(endX, endY); + + // Check if the cells exists and if they are of the same part for example tbody = tbody + if (startCell && endCell && startCell.part == endCell.part) { + // Split and rebuild grid + split(); + buildGrid(); + + // Set row/col span to start cell + startCell = getCell(startX, startY).elm; + setSpanVal(startCell, 'colSpan', (endX - startX) + 1); + setSpanVal(startCell, 'rowSpan', (endY - startY) + 1); + + // Remove other cells and add it's contents to the start cell + for (y = startY; y <= endY; y++) { + for (x = startX; x <= endX; x++) { + if (!grid[y] || !grid[y][x]) + continue; + + cell = grid[y][x].elm; + + if (cell != startCell) { + // Move children to startCell + children = tinymce.grep(cell.childNodes); + each(children, function(node) { + startCell.appendChild(node); + }); + + // Remove bogus nodes if there is children in the target cell + if (children.length) { + children = tinymce.grep(startCell.childNodes); + count = 0; + each(children, function(node) { + if (node.nodeName == 'BR' && dom.getAttrib(node, 'data-mce-bogus') && count++ < children.length - 1) + startCell.removeChild(node); + }); + } + + // Remove cell + dom.remove(cell); + } + } + } + + // Remove empty rows etc and restore caret location + cleanup(); + } + }; + + function insertRow(before) { + var posY, cell, lastCell, x, rowElm, newRow, newCell, otherCell, rowSpan; + + // Find first/last row + each(grid, function(row, y) { + each(row, function(cell, x) { + if (isCellSelected(cell)) { + cell = cell.elm; + rowElm = cell.parentNode; + newRow = cloneNode(rowElm, false); + posY = y; + + if (before) + return false; + } + }); + + if (before) + return !posY; + }); + + for (x = 0; x < grid[0].length; x++) { + // Cell not found could be because of an invalid table structure + if (!grid[posY][x]) + continue; + + cell = grid[posY][x].elm; + + if (cell != lastCell) { + if (!before) { + rowSpan = getSpanVal(cell, 'rowspan'); + if (rowSpan > 1) { + setSpanVal(cell, 'rowSpan', rowSpan + 1); + continue; + } + } else { + // Check if cell above can be expanded + if (posY > 0 && grid[posY - 1][x]) { + otherCell = grid[posY - 1][x].elm; + rowSpan = getSpanVal(otherCell, 'rowSpan'); + if (rowSpan > 1) { + setSpanVal(otherCell, 'rowSpan', rowSpan + 1); + continue; + } + } + } + + // Insert new cell into new row + newCell = cloneCell(cell); + setSpanVal(newCell, 'colSpan', cell.colSpan); + + newRow.appendChild(newCell); + + lastCell = cell; + } + } + + if (newRow.hasChildNodes()) { + if (!before) + dom.insertAfter(newRow, rowElm); + else + rowElm.parentNode.insertBefore(newRow, rowElm); + } + }; + + function insertCol(before) { + var posX, lastCell; + + // Find first/last column + each(grid, function(row, y) { + each(row, function(cell, x) { + if (isCellSelected(cell)) { + posX = x; + + if (before) + return false; + } + }); + + if (before) + return !posX; + }); + + each(grid, function(row, y) { + var cell, rowSpan, colSpan; + + if (!row[posX]) + return; + + cell = row[posX].elm; + if (cell != lastCell) { + colSpan = getSpanVal(cell, 'colspan'); + rowSpan = getSpanVal(cell, 'rowspan'); + + if (colSpan == 1) { + if (!before) { + dom.insertAfter(cloneCell(cell), cell); + fillLeftDown(posX, y, rowSpan - 1, colSpan); + } else { + cell.parentNode.insertBefore(cloneCell(cell), cell); + fillLeftDown(posX, y, rowSpan - 1, colSpan); + } + } else + setSpanVal(cell, 'colSpan', cell.colSpan + 1); + + lastCell = cell; + } + }); + }; + + function deleteCols() { + var cols = []; + + // Get selected column indexes + each(grid, function(row, y) { + each(row, function(cell, x) { + if (isCellSelected(cell) && tinymce.inArray(cols, x) === -1) { + each(grid, function(row) { + var cell = row[x].elm, colSpan; + + colSpan = getSpanVal(cell, 'colSpan'); + + if (colSpan > 1) + setSpanVal(cell, 'colSpan', colSpan - 1); + else + dom.remove(cell); + }); + + cols.push(x); + } + }); + }); + + cleanup(); + }; + + function deleteRows() { + var rows; + + function deleteRow(tr) { + var nextTr, pos, lastCell; + + nextTr = dom.getNext(tr, 'tr'); + + // Move down row spanned cells + each(tr.cells, function(cell) { + var rowSpan = getSpanVal(cell, 'rowSpan'); + + if (rowSpan > 1) { + setSpanVal(cell, 'rowSpan', rowSpan - 1); + pos = getPos(cell); + fillLeftDown(pos.x, pos.y, 1, 1); + } + }); + + // Delete cells + pos = getPos(tr.cells[0]); + each(grid[pos.y], function(cell) { + var rowSpan; + + cell = cell.elm; + + if (cell != lastCell) { + rowSpan = getSpanVal(cell, 'rowSpan'); + + if (rowSpan <= 1) + dom.remove(cell); + else + setSpanVal(cell, 'rowSpan', rowSpan - 1); + + lastCell = cell; + } + }); + }; + + // Get selected rows and move selection out of scope + rows = getSelectedRows(); + + // Delete all selected rows + each(rows.reverse(), function(tr) { + deleteRow(tr); + }); + + cleanup(); + }; + + function cutRows() { + var rows = getSelectedRows(); + + dom.remove(rows); + cleanup(); + + return rows; + }; + + function copyRows() { + var rows = getSelectedRows(); + + each(rows, function(row, i) { + rows[i] = cloneNode(row, true); + }); + + return rows; + }; + + function pasteRows(rows, before) { + var selectedRows = getSelectedRows(), + targetRow = selectedRows[before ? 0 : selectedRows.length - 1], + targetCellCount = targetRow.cells.length; + + // Calc target cell count + each(grid, function(row) { + var match; + + targetCellCount = 0; + each(row, function(cell, x) { + if (cell.real) + targetCellCount += cell.colspan; + + if (cell.elm.parentNode == targetRow) + match = 1; + }); + + if (match) + return false; + }); + + if (!before) + rows.reverse(); + + each(rows, function(row) { + var cellCount = row.cells.length, cell; + + // Remove col/rowspans + for (i = 0; i < cellCount; i++) { + cell = row.cells[i]; + setSpanVal(cell, 'colSpan', 1); + setSpanVal(cell, 'rowSpan', 1); + } + + // Needs more cells + for (i = cellCount; i < targetCellCount; i++) + row.appendChild(cloneCell(row.cells[cellCount - 1])); + + // Needs less cells + for (i = targetCellCount; i < cellCount; i++) + dom.remove(row.cells[i]); + + // Add before/after + if (before) + targetRow.parentNode.insertBefore(row, targetRow); + else + dom.insertAfter(row, targetRow); + }); + }; + + function getPos(target) { + var pos; + + each(grid, function(row, y) { + each(row, function(cell, x) { + if (cell.elm == target) { + pos = {x : x, y : y}; + return false; + } + }); + + return !pos; + }); + + return pos; + }; + + function setStartCell(cell) { + startPos = getPos(cell); + }; + + function findEndPos() { + var pos, maxX, maxY; + + maxX = maxY = 0; + + each(grid, function(row, y) { + each(row, function(cell, x) { + var colSpan, rowSpan; + + if (isCellSelected(cell)) { + cell = grid[y][x]; + + if (x > maxX) + maxX = x; + + if (y > maxY) + maxY = y; + + if (cell.real) { + colSpan = cell.colspan - 1; + rowSpan = cell.rowspan - 1; + + if (colSpan) { + if (x + colSpan > maxX) + maxX = x + colSpan; + } + + if (rowSpan) { + if (y + rowSpan > maxY) + maxY = y + rowSpan; + } + } + } + }); + }); + + return {x : maxX, y : maxY}; + }; + + function setEndCell(cell) { + var startX, startY, endX, endY, maxX, maxY, colSpan, rowSpan; + + endPos = getPos(cell); + + if (startPos && endPos) { + // Get start/end positions + startX = Math.min(startPos.x, endPos.x); + startY = Math.min(startPos.y, endPos.y); + endX = Math.max(startPos.x, endPos.x); + endY = Math.max(startPos.y, endPos.y); + + // Expand end positon to include spans + maxX = endX; + maxY = endY; + + // Expand startX + for (y = startY; y <= maxY; y++) { + cell = grid[y][startX]; + + if (!cell.real) { + if (startX - (cell.colspan - 1) < startX) + startX -= cell.colspan - 1; + } + } + + // Expand startY + for (x = startX; x <= maxX; x++) { + cell = grid[startY][x]; + + if (!cell.real) { + if (startY - (cell.rowspan - 1) < startY) + startY -= cell.rowspan - 1; + } + } + + // Find max X, Y + for (y = startY; y <= endY; y++) { + for (x = startX; x <= endX; x++) { + cell = grid[y][x]; + + if (cell.real) { + colSpan = cell.colspan - 1; + rowSpan = cell.rowspan - 1; + + if (colSpan) { + if (x + colSpan > maxX) + maxX = x + colSpan; + } + + if (rowSpan) { + if (y + rowSpan > maxY) + maxY = y + rowSpan; + } + } + } + } + + // Remove current selection + dom.removeClass(dom.select('td.mceSelected,th.mceSelected'), 'mceSelected'); + + // Add new selection + for (y = startY; y <= maxY; y++) { + for (x = startX; x <= maxX; x++) { + if (grid[y][x]) + dom.addClass(grid[y][x].elm, 'mceSelected'); + } + } + } + }; + + // Expose to public + tinymce.extend(this, { + deleteTable : deleteTable, + split : split, + merge : merge, + insertRow : insertRow, + insertCol : insertCol, + deleteCols : deleteCols, + deleteRows : deleteRows, + cutRows : cutRows, + copyRows : copyRows, + pasteRows : pasteRows, + getPos : getPos, + setStartCell : setStartCell, + setEndCell : setEndCell + }); + }; + + tinymce.create('tinymce.plugins.TablePlugin', { + init : function(ed, url) { + var winMan, clipboardRows, hasCellSelection = true; // Might be selected cells on reload + + function createTableGrid(node) { + var selection = ed.selection, tblElm = ed.dom.getParent(node || selection.getNode(), 'table'); + + if (tblElm) + return new TableGrid(tblElm, ed.dom, selection); + }; + + function cleanup() { + // Restore selection possibilities + ed.getBody().style.webkitUserSelect = ''; + + if (hasCellSelection) { + ed.dom.removeClass(ed.dom.select('td.mceSelected,th.mceSelected'), 'mceSelected'); + hasCellSelection = false; + } + }; + + // Register buttons + each([ + ['table', 'table.desc', 'mceInsertTable', true], + ['delete_table', 'table.del', 'mceTableDelete'], + ['delete_col', 'table.delete_col_desc', 'mceTableDeleteCol'], + ['delete_row', 'table.delete_row_desc', 'mceTableDeleteRow'], + ['col_after', 'table.col_after_desc', 'mceTableInsertColAfter'], + ['col_before', 'table.col_before_desc', 'mceTableInsertColBefore'], + ['row_after', 'table.row_after_desc', 'mceTableInsertRowAfter'], + ['row_before', 'table.row_before_desc', 'mceTableInsertRowBefore'], + ['row_props', 'table.row_desc', 'mceTableRowProps', true], + ['cell_props', 'table.cell_desc', 'mceTableCellProps', true], + ['split_cells', 'table.split_cells_desc', 'mceTableSplitCells', true], + ['merge_cells', 'table.merge_cells_desc', 'mceTableMergeCells', true] + ], function(c) { + ed.addButton(c[0], {title : c[1], cmd : c[2], ui : c[3]}); + }); + + // Select whole table is a table border is clicked + if (!tinymce.isIE) { + ed.onClick.add(function(ed, e) { + e = e.target; + + if (e.nodeName === 'TABLE') { + ed.selection.select(e); + ed.nodeChanged(); + } + }); + } + + ed.onPreProcess.add(function(ed, args) { + var nodes, i, node, dom = ed.dom, value; + + nodes = dom.select('table', args.node); + i = nodes.length; + while (i--) { + node = nodes[i]; + dom.setAttrib(node, 'data-mce-style', ''); + + if ((value = dom.getAttrib(node, 'width'))) { + dom.setStyle(node, 'width', value); + dom.setAttrib(node, 'width', ''); + } + + if ((value = dom.getAttrib(node, 'height'))) { + dom.setStyle(node, 'height', value); + dom.setAttrib(node, 'height', ''); + } + } + }); + + // Handle node change updates + ed.onNodeChange.add(function(ed, cm, n) { + var p; + + n = ed.selection.getStart(); + p = ed.dom.getParent(n, 'td,th,caption'); + cm.setActive('table', n.nodeName === 'TABLE' || !!p); + + // Disable table tools if we are in caption + if (p && p.nodeName === 'CAPTION') + p = 0; + + cm.setDisabled('delete_table', !p); + cm.setDisabled('delete_col', !p); + cm.setDisabled('delete_table', !p); + cm.setDisabled('delete_row', !p); + cm.setDisabled('col_after', !p); + cm.setDisabled('col_before', !p); + cm.setDisabled('row_after', !p); + cm.setDisabled('row_before', !p); + cm.setDisabled('row_props', !p); + cm.setDisabled('cell_props', !p); + cm.setDisabled('split_cells', !p); + cm.setDisabled('merge_cells', !p); + }); + + ed.onInit.add(function(ed) { + var startTable, startCell, dom = ed.dom, tableGrid; + + winMan = ed.windowManager; + + // Add cell selection logic + ed.onMouseDown.add(function(ed, e) { + if (e.button != 2) { + cleanup(); + + startCell = dom.getParent(e.target, 'td,th'); + startTable = dom.getParent(startCell, 'table'); + } + }); + + dom.bind(ed.getDoc(), 'mouseover', function(e) { + var sel, table, target = e.target; + + if (startCell && (tableGrid || target != startCell) && (target.nodeName == 'TD' || target.nodeName == 'TH')) { + table = dom.getParent(target, 'table'); + if (table == startTable) { + if (!tableGrid) { + tableGrid = createTableGrid(table); + tableGrid.setStartCell(startCell); + + ed.getBody().style.webkitUserSelect = 'none'; + } + + tableGrid.setEndCell(target); + hasCellSelection = true; + } + + // Remove current selection + sel = ed.selection.getSel(); + + try { + if (sel.removeAllRanges) + sel.removeAllRanges(); + else + sel.empty(); + } catch (ex) { + // IE9 might throw errors here + } + + e.preventDefault(); + } + }); + + ed.onMouseUp.add(function(ed, e) { + var rng, sel = ed.selection, selectedCells, nativeSel = sel.getSel(), walker, node, lastNode, endNode; + + // Move selection to startCell + if (startCell) { + if (tableGrid) + ed.getBody().style.webkitUserSelect = ''; + + function setPoint(node, start) { + var walker = new tinymce.dom.TreeWalker(node, node); + + do { + // Text node + if (node.nodeType == 3 && tinymce.trim(node.nodeValue).length != 0) { + if (start) + rng.setStart(node, 0); + else + rng.setEnd(node, node.nodeValue.length); + + return; + } + + // BR element + if (node.nodeName == 'BR') { + if (start) + rng.setStartBefore(node); + else + rng.setEndBefore(node); + + return; + } + } while (node = (start ? walker.next() : walker.prev())); + } + + // Try to expand text selection as much as we can only Gecko supports cell selection + selectedCells = dom.select('td.mceSelected,th.mceSelected'); + if (selectedCells.length > 0) { + rng = dom.createRng(); + node = selectedCells[0]; + endNode = selectedCells[selectedCells.length - 1]; + rng.setStartBefore(node); + rng.setEndAfter(node); + + setPoint(node, 1); + walker = new tinymce.dom.TreeWalker(node, dom.getParent(selectedCells[0], 'table')); + + do { + if (node.nodeName == 'TD' || node.nodeName == 'TH') { + if (!dom.hasClass(node, 'mceSelected')) + break; + + lastNode = node; + } + } while (node = walker.next()); + + setPoint(lastNode); + + sel.setRng(rng); + } + + ed.nodeChanged(); + startCell = tableGrid = startTable = null; + } + }); + + ed.onKeyUp.add(function(ed, e) { + cleanup(); + }); + + ed.onKeyDown.add(function (ed, e) { + fixTableCellSelection(ed); + }); + + ed.onMouseDown.add(function (ed, e) { + if (e.button != 2) { + fixTableCellSelection(ed); + } + }); + function tableCellSelected(ed, rng, n, currentCell) { + // The decision of when a table cell is selected is somewhat involved. The fact that this code is + // required is actually a pointer to the root cause of this bug. A cell is selected when the start + // and end offsets are 0, the start container is a text, and the selection node is either a TR (most cases) + // or the parent of the table (in the case of the selection containing the last cell of a table). + var TEXT_NODE = 3, table = ed.dom.getParent(rng.startContainer, 'TABLE'), + tableParent, allOfCellSelected, tableCellSelection; + if (table) + tableParent = table.parentNode; + allOfCellSelected =rng.startContainer.nodeType == TEXT_NODE && + rng.startOffset == 0 && + rng.endOffset == 0 && + currentCell && + (n.nodeName=="TR" || n==tableParent); + tableCellSelection = (n.nodeName=="TD"||n.nodeName=="TH")&& !currentCell; + return allOfCellSelected || tableCellSelection; + // return false; + } + + // this nasty hack is here to work around some WebKit selection bugs. + function fixTableCellSelection(ed) { + if (!tinymce.isWebKit) + return; + + var rng = ed.selection.getRng(); + var n = ed.selection.getNode(); + var currentCell = ed.dom.getParent(rng.startContainer, 'TD'); + + if (!tableCellSelected(ed, rng, n, currentCell)) + return; + if (!currentCell) { + currentCell=n; + } + + // Get the very last node inside the table cell + var end = currentCell.lastChild; + while (end.lastChild) + end = end.lastChild; + + // Select the entire table cell. Nothing outside of the table cell should be selected. + rng.setEnd(end, end.nodeValue.length); + ed.selection.setRng(rng); + } + ed.plugins.table.fixTableCellSelection=fixTableCellSelection; + + // Add context menu + if (ed && ed.plugins.contextmenu) { + ed.plugins.contextmenu.onContextMenu.add(function(th, m, e) { + var sm, se = ed.selection, el = se.getNode() || ed.getBody(); + + if (ed.dom.getParent(e, 'td') || ed.dom.getParent(e, 'th') || ed.dom.select('td.mceSelected,th.mceSelected').length) { + m.removeAll(); + + if (el.nodeName == 'A' && !ed.dom.getAttrib(el, 'name')) { + m.add({title : 'advanced.link_desc', icon : 'link', cmd : ed.plugins.advlink ? 'mceAdvLink' : 'mceLink', ui : true}); + m.add({title : 'advanced.unlink_desc', icon : 'unlink', cmd : 'UnLink'}); + m.addSeparator(); + } + + if (el.nodeName == 'IMG' && el.className.indexOf('mceItem') == -1) { + m.add({title : 'advanced.image_desc', icon : 'image', cmd : ed.plugins.advimage ? 'mceAdvImage' : 'mceImage', ui : true}); + m.addSeparator(); + } + + m.add({title : 'table.desc', icon : 'table', cmd : 'mceInsertTable', value : {action : 'insert'}}); + m.add({title : 'table.props_desc', icon : 'table_props', cmd : 'mceInsertTable'}); + m.add({title : 'table.del', icon : 'delete_table', cmd : 'mceTableDelete'}); + m.addSeparator(); + + // Cell menu + sm = m.addMenu({title : 'table.cell'}); + sm.add({title : 'table.cell_desc', icon : 'cell_props', cmd : 'mceTableCellProps'}); + sm.add({title : 'table.split_cells_desc', icon : 'split_cells', cmd : 'mceTableSplitCells'}); + sm.add({title : 'table.merge_cells_desc', icon : 'merge_cells', cmd : 'mceTableMergeCells'}); + + // Row menu + sm = m.addMenu({title : 'table.row'}); + sm.add({title : 'table.row_desc', icon : 'row_props', cmd : 'mceTableRowProps'}); + sm.add({title : 'table.row_before_desc', icon : 'row_before', cmd : 'mceTableInsertRowBefore'}); + sm.add({title : 'table.row_after_desc', icon : 'row_after', cmd : 'mceTableInsertRowAfter'}); + sm.add({title : 'table.delete_row_desc', icon : 'delete_row', cmd : 'mceTableDeleteRow'}); + sm.addSeparator(); + sm.add({title : 'table.cut_row_desc', icon : 'cut', cmd : 'mceTableCutRow'}); + sm.add({title : 'table.copy_row_desc', icon : 'copy', cmd : 'mceTableCopyRow'}); + sm.add({title : 'table.paste_row_before_desc', icon : 'paste', cmd : 'mceTablePasteRowBefore'}).setDisabled(!clipboardRows); + sm.add({title : 'table.paste_row_after_desc', icon : 'paste', cmd : 'mceTablePasteRowAfter'}).setDisabled(!clipboardRows); + + // Column menu + sm = m.addMenu({title : 'table.col'}); + sm.add({title : 'table.col_before_desc', icon : 'col_before', cmd : 'mceTableInsertColBefore'}); + sm.add({title : 'table.col_after_desc', icon : 'col_after', cmd : 'mceTableInsertColAfter'}); + sm.add({title : 'table.delete_col_desc', icon : 'delete_col', cmd : 'mceTableDeleteCol'}); + } else + m.add({title : 'table.desc', icon : 'table', cmd : 'mceInsertTable'}); + }); + } + + // Fix to allow navigating up and down in a table in WebKit browsers. + if (tinymce.isWebKit) { + function moveSelection(ed, e) { + + function moveCursorToStartOfElement(n) { + ed.selection.setCursorLocation(n, 0); + } + + function getSibling(event, element) { + return event.keyCode == UP_ARROW ? element.previousSibling : element.nextSibling; + } + + function getNextRow(e, row) { + var sibling = getSibling(e, row); + return sibling !== null && sibling.tagName === 'TR' ? sibling : null; + } + + function getTable(ed, currentRow) { + return ed.dom.getParent(currentRow, 'table'); + } + + function getTableSibling(currentRow) { + var table = getTable(ed, currentRow); + return getSibling(e, table); + } + + function isVerticalMovement(event) { + return event.keyCode == UP_ARROW || event.keyCode == DOWN_ARROW; + } + + function isInTable(ed) { + var node = ed.selection.getNode(); + var currentRow = ed.dom.getParent(node, 'tr'); + return currentRow !== null; + } + + function columnIndex(column) { + var colIndex = 0; + var c = column; + while (c.previousSibling) { + c = c.previousSibling; + colIndex = colIndex + getSpanVal(c, "colspan"); + } + return colIndex; + } + + function findColumn(rowElement, columnIndex) { + var c = 0; + var r = 0; + each(rowElement.children, function(cell, i) { + c = c + getSpanVal(cell, "colspan"); + r = i; + if (c > columnIndex) + return false; + }); + return r; + } + + function moveCursorToRow(ed, node, row) { + var srcColumnIndex = columnIndex(ed.dom.getParent(node, 'td,th')); + var tgtColumnIndex = findColumn(row, srcColumnIndex) + var tgtNode = row.childNodes[tgtColumnIndex]; + moveCursorToStartOfElement(tgtNode); + } + + function escapeTable(currentRow, e) { + var tableSiblingElement = getTableSibling(currentRow); + if (tableSiblingElement !== null) { + moveCursorToStartOfElement(tableSiblingElement); + return tinymce.dom.Event.cancel(e); + } else { + var element = e.keyCode == UP_ARROW ? currentRow.firstChild : currentRow.lastChild; + // rely on default behaviour to escape table after we are in the last cell of the last row + moveCursorToStartOfElement(element); + return true; + } + } + + var UP_ARROW = 38; + var DOWN_ARROW = 40; + + if (isVerticalMovement(e) && isInTable(ed)) { + var node = ed.selection.getNode(); + var currentRow = ed.dom.getParent(node, 'tr'); + var nextRow = getNextRow(e, currentRow); + + // If we're at the first or last row in the table, we should move the caret outside of the table + if (nextRow == null) { + return escapeTable(currentRow, e); + } else { + moveCursorToRow(ed, node, nextRow); + tinymce.dom.Event.cancel(e); + return true; + } + } + } + + ed.onKeyDown.add(moveSelection); + } + + // Fixes an issue on Gecko where it's impossible to place the caret behind a table + // This fix will force a paragraph element after the table but only when the forced_root_block setting is enabled + if (!tinymce.isIE) { + function fixTableCaretPos() { + var last; + + // Skip empty text nodes form the end + for (last = ed.getBody().lastChild; last && last.nodeType == 3 && !last.nodeValue.length; last = last.previousSibling) ; + + if (last && last.nodeName == 'TABLE') + ed.dom.add(ed.getBody(), 'p', null, '
'); + }; + + // Fixes an bug where it's impossible to place the caret before a table in Gecko + // this fix solves it by detecting when the caret is at the beginning of such a table + // and then manually moves the caret infront of the table + if (tinymce.isGecko) { + ed.onKeyDown.add(function(ed, e) { + var rng, table, dom = ed.dom; + + // On gecko it's not possible to place the caret before a table + if (e.keyCode == 37 || e.keyCode == 38) { + rng = ed.selection.getRng(); + table = dom.getParent(rng.startContainer, 'table'); + + if (table && ed.getBody().firstChild == table) { + if (isAtStart(rng, table)) { + rng = dom.createRng(); + + rng.setStartBefore(table); + rng.setEndBefore(table); + + ed.selection.setRng(rng); + + e.preventDefault(); + } + } + } + }); + } + + ed.onKeyUp.add(fixTableCaretPos); + ed.onSetContent.add(fixTableCaretPos); + ed.onVisualAid.add(fixTableCaretPos); + + ed.onPreProcess.add(function(ed, o) { + var last = o.node.lastChild; + + if (last && last.childNodes.length == 1 && last.firstChild.nodeName == 'BR') + ed.dom.remove(last); + }); + + fixTableCaretPos(); + ed.startContent = ed.getContent({format : 'raw'}); + } + }); + + // Register action commands + each({ + mceTableSplitCells : function(grid) { + grid.split(); + }, + + mceTableMergeCells : function(grid) { + var rowSpan, colSpan, cell; + + cell = ed.dom.getParent(ed.selection.getNode(), 'th,td'); + if (cell) { + rowSpan = cell.rowSpan; + colSpan = cell.colSpan; + } + + if (!ed.dom.select('td.mceSelected,th.mceSelected').length) { + winMan.open({ + url : url + '/merge_cells.htm', + width : 240 + parseInt(ed.getLang('table.merge_cells_delta_width', 0)), + height : 110 + parseInt(ed.getLang('table.merge_cells_delta_height', 0)), + inline : 1 + }, { + rows : rowSpan, + cols : colSpan, + onaction : function(data) { + grid.merge(cell, data.cols, data.rows); + }, + plugin_url : url + }); + } else + grid.merge(); + }, + + mceTableInsertRowBefore : function(grid) { + grid.insertRow(true); + }, + + mceTableInsertRowAfter : function(grid) { + grid.insertRow(); + }, + + mceTableInsertColBefore : function(grid) { + grid.insertCol(true); + }, + + mceTableInsertColAfter : function(grid) { + grid.insertCol(); + }, + + mceTableDeleteCol : function(grid) { + grid.deleteCols(); + }, + + mceTableDeleteRow : function(grid) { + grid.deleteRows(); + }, + + mceTableCutRow : function(grid) { + clipboardRows = grid.cutRows(); + }, + + mceTableCopyRow : function(grid) { + clipboardRows = grid.copyRows(); + }, + + mceTablePasteRowBefore : function(grid) { + grid.pasteRows(clipboardRows, true); + }, + + mceTablePasteRowAfter : function(grid) { + grid.pasteRows(clipboardRows); + }, + + mceTableDelete : function(grid) { + grid.deleteTable(); + } + }, function(func, name) { + ed.addCommand(name, function() { + var grid = createTableGrid(); + + if (grid) { + func(grid); + ed.execCommand('mceRepaint'); + cleanup(); + } + }); + }); + + // Register dialog commands + each({ + mceInsertTable : function(val) { + winMan.open({ + url : url + '/table.htm', + width : 400 + parseInt(ed.getLang('table.table_delta_width', 0)), + height : 320 + parseInt(ed.getLang('table.table_delta_height', 0)), + inline : 1 + }, { + plugin_url : url, + action : val ? val.action : 0 + }); + }, + + mceTableRowProps : function() { + winMan.open({ + url : url + '/row.htm', + width : 400 + parseInt(ed.getLang('table.rowprops_delta_width', 0)), + height : 295 + parseInt(ed.getLang('table.rowprops_delta_height', 0)), + inline : 1 + }, { + plugin_url : url + }); + }, + + mceTableCellProps : function() { + winMan.open({ + url : url + '/cell.htm', + width : 400 + parseInt(ed.getLang('table.cellprops_delta_width', 0)), + height : 295 + parseInt(ed.getLang('table.cellprops_delta_height', 0)), + inline : 1 + }, { + plugin_url : url + }); + } + }, function(func, name) { + ed.addCommand(name, function(ui, val) { + func(val); + }); + }); + } + }); + + // Register plugin + tinymce.PluginManager.add('table', tinymce.plugins.TablePlugin); +})(tinymce);