The Tor Browser: editor/libeditor/html/nsTableEditor.cpp@7e26c7da4463 (annotated)

editor/libeditor/html/nsTableEditor.cpp@7e26c7da4463 (annotated)

editor/libeditor/html/nsTableEditor.cpp

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <stdio.h>
 #include "mozilla/Assertions.h"
 #include "mozilla/dom/Selection.h"
 #include "mozilla/dom/Element.h"
 #include "nsAString.h"
 #include "nsAlgorithm.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
 #include "nsEditProperty.h"
 #include "nsEditor.h"
 #include "nsEditorUtils.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsHTMLEditUtils.h"
 #include "nsHTMLEditor.h"
 #include "nsIAtom.h"
 #include "nsIContent.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMRange.h"
 #include "nsIEditor.h"
 #include "nsIFrame.h"
 #include "nsIHTMLEditor.h"
 #include "nsINode.h"
 #include "nsIPresShell.h"
 #include "nsISupportsUtils.h"
 #include "nsITableCellLayout.h" // For efficient access to table cell
 #include "nsITableEditor.h"
 #include "nsLiteralString.h"
 #include "nsQueryFrame.h"
 #include "nsString.h"
 #include "nsTArray.h"
 #include "nsTableCellFrame.h"
 #include "nsTableOuterFrame.h"
 #include "nscore.h"
 #include <algorithm>
 using namespace mozilla;
 using namespace mozilla::dom;
 /***************************************************************************
  * stack based helper class for restoring selection after table edit
  */
 class MOZ_STACK_CLASS nsSetSelectionAfterTableEdit
 {
   private:
     nsCOMPtr<nsITableEditor> mEd;
     nsCOMPtr<nsIDOMElement> mTable;
     int32_t mCol, mRow, mDirection, mSelected;
   public:
     nsSetSelectionAfterTableEdit(nsITableEditor *aEd, nsIDOMElement* aTable,
                                  int32_t aRow, int32_t aCol, int32_t aDirection,
                                  bool aSelected) :
         mEd(do_QueryInterface(aEd))
     {
       mTable = aTable;
       mRow = aRow;
       mCol = aCol;
       mDirection = aDirection;
       mSelected = aSelected;
     }
     ~nsSetSelectionAfterTableEdit()
     {
       if (mEd)
         mEd->SetSelectionAfterTableEdit(mTable, mRow, mCol, mDirection, mSelected);
     }
     // This is needed to abort the caret reset in the destructor
     //  when one method yields control to another
     void CancelSetCaret() {mEd = nullptr; mTable = nullptr;}
 };
 // Stack-class to turn on/off selection batching for table selection
 class MOZ_STACK_CLASS nsSelectionBatcherForTable
 {
 private:
   nsCOMPtr<nsISelectionPrivate> mSelection;
 public:
   nsSelectionBatcherForTable(nsISelection *aSelection)
   {
     nsCOMPtr<nsISelection> sel(aSelection);
     mSelection = do_QueryInterface(sel);
     if (mSelection)  mSelection->StartBatchChanges();
   }
   virtual ~nsSelectionBatcherForTable()
   {
     if (mSelection) mSelection->EndBatchChanges();
   }
 };
 // Table Editing helper utilities (not exposed in IDL)
 NS_IMETHODIMP
 nsHTMLEditor::InsertCell(nsIDOMElement *aCell, int32_t aRowSpan, int32_t aColSpan,
                          bool aAfter, bool aIsHeader, nsIDOMElement **aNewCell)
 {
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   if (aNewCell) *aNewCell = nullptr;
   // And the parent and offsets needed to do an insert
   nsCOMPtr<nsIDOMNode> cellParent;
   nsresult res = aCell->GetParentNode(getter_AddRefs(cellParent));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(cellParent, NS_ERROR_NULL_POINTER);
   int32_t cellOffset = GetChildOffset(aCell, cellParent);
   nsCOMPtr<nsIDOMElement> newCell;
   if (aIsHeader)
     res = CreateElementWithDefaults(NS_LITERAL_STRING("th"), getter_AddRefs(newCell));
   else
     res = CreateElementWithDefaults(NS_LITERAL_STRING("td"), getter_AddRefs(newCell));
   if(NS_FAILED(res)) return res;
   if(!newCell) return NS_ERROR_FAILURE;
   //Optional: return new cell created
   if (aNewCell)
   {
     *aNewCell = newCell.get();
     NS_ADDREF(*aNewCell);
   }
   if( aRowSpan > 1)
   {
     // Note: Do NOT use editor transaction for this
     nsAutoString newRowSpan;
     newRowSpan.AppendInt(aRowSpan, 10);
     newCell->SetAttribute(NS_LITERAL_STRING("rowspan"), newRowSpan);
   }
   if( aColSpan > 1)
   {
     // Note: Do NOT use editor transaction for this
     nsAutoString newColSpan;
     newColSpan.AppendInt(aColSpan, 10);
     newCell->SetAttribute(NS_LITERAL_STRING("colspan"), newColSpan);
   }
   if(aAfter) cellOffset++;
   //Don't let Rules System change the selection
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   return InsertNode(newCell, cellParent, cellOffset);
 }
 NS_IMETHODIMP nsHTMLEditor::SetColSpan(nsIDOMElement *aCell, int32_t aColSpan)
 {
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   nsAutoString newSpan;
   newSpan.AppendInt(aColSpan, 10);
   return SetAttribute(aCell, NS_LITERAL_STRING("colspan"), newSpan);
 }
 NS_IMETHODIMP nsHTMLEditor::SetRowSpan(nsIDOMElement *aCell, int32_t aRowSpan)
 {
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   nsAutoString newSpan;
   newSpan.AppendInt(aRowSpan, 10);
   return SetAttribute(aCell, NS_LITERAL_STRING("rowspan"), newSpan);
 }
 /****************************************************************/
 // Table Editing interface methods
 NS_IMETHODIMP
 nsHTMLEditor::InsertTableCell(int32_t aNumber, bool aAfter)
 {
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> curCell;
   nsCOMPtr<nsIDOMNode> cellParent;
   int32_t cellOffset, startRowIndex, startColIndex;
   nsresult res = GetCellContext(nullptr,
                                 getter_AddRefs(table),
                                 getter_AddRefs(curCell),
                                 getter_AddRefs(cellParent), &cellOffset,
                                 &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if no cell found
   NS_ENSURE_TRUE(curCell, NS_EDITOR_ELEMENT_NOT_FOUND);
   // Get more data for current cell in row we are inserting at (we need COLSPAN)
   int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   res = GetCellDataAt(table, startRowIndex, startColIndex,
                       getter_AddRefs(curCell),
                       &curStartRowIndex, &curStartColIndex, &rowSpan, &colSpan,
                       &actualRowSpan, &actualColSpan, &isSelected);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(curCell, NS_ERROR_FAILURE);
   int32_t newCellIndex = aAfter ? (startColIndex+colSpan) : startColIndex;
   //We control selection resetting after the insert...
   nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, newCellIndex, ePreviousColumn, false);
   //...so suppress Rules System selection munging
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   int32_t i;
   for (i = 0; i < aNumber; i++)
   {
     nsCOMPtr<nsIDOMElement> newCell;
     res = CreateElementWithDefaults(NS_LITERAL_STRING("td"), getter_AddRefs(newCell));
     if (NS_SUCCEEDED(res) && newCell)
     {
       if (aAfter) cellOffset++;
       res = InsertNode(newCell, cellParent, cellOffset);
       if(NS_FAILED(res)) break;
     }
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetFirstRow(nsIDOMElement* aTableElement, nsIDOMNode** aRowNode)
 {
   NS_ENSURE_TRUE(aRowNode, NS_ERROR_NULL_POINTER);
   *aRowNode = nullptr;
   NS_ENSURE_TRUE(aTableElement, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMElement> tableElement;
   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), aTableElement, getter_AddRefs(tableElement));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(tableElement, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> tableChild;
   res = tableElement->GetFirstChild(getter_AddRefs(tableChild));
   NS_ENSURE_SUCCESS(res, res);
   while (tableChild)
   {
     nsCOMPtr<nsIContent> content = do_QueryInterface(tableChild);
     if (content)
     {
       nsIAtom *atom = content->Tag();
       if (atom == nsEditProperty::tr)
       {
         // Found a row directly under <table>
         *aRowNode = tableChild;
         NS_ADDREF(*aRowNode);
         return NS_OK;
       }
       // Look for row in one of the row container elements
       if (atom == nsEditProperty::tbody ||
           atom == nsEditProperty::thead ||
           atom == nsEditProperty::tfoot)
       {
         nsCOMPtr<nsIDOMNode> rowNode;
         res = tableChild->GetFirstChild(getter_AddRefs(rowNode));
         NS_ENSURE_SUCCESS(res, res);
         // We can encounter textnodes here -- must find a row
         while (rowNode && !nsHTMLEditUtils::IsTableRow(rowNode))
         {
           nsCOMPtr<nsIDOMNode> nextNode;
           res = rowNode->GetNextSibling(getter_AddRefs(nextNode));
           NS_ENSURE_SUCCESS(res, res);
           rowNode = nextNode;
         }
         if(rowNode)
         {
           *aRowNode = rowNode.get();
           NS_ADDREF(*aRowNode);
           return NS_OK;
         }
       }
     }
     // Here if table child was a CAPTION or COLGROUP
     //  or child of a row parent wasn't a row (bad HTML?),
     //  or first child was a textnode
     // Look in next table child
     nsCOMPtr<nsIDOMNode> nextChild;
     res = tableChild->GetNextSibling(getter_AddRefs(nextChild));
     NS_ENSURE_SUCCESS(res, res);
     tableChild = nextChild;
   };
   // If here, row was not found
   return NS_EDITOR_ELEMENT_NOT_FOUND;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetNextRow(nsIDOMNode* aCurrentRowNode, nsIDOMNode **aRowNode)
 {
   NS_ENSURE_TRUE(aRowNode, NS_ERROR_NULL_POINTER);
   *aRowNode = nullptr;
   NS_ENSURE_TRUE(aCurrentRowNode, NS_ERROR_NULL_POINTER);
   if (!nsHTMLEditUtils::IsTableRow(aCurrentRowNode))
     return NS_ERROR_FAILURE;
   nsCOMPtr<nsIDOMNode> nextRow;
   nsresult res = aCurrentRowNode->GetNextSibling(getter_AddRefs(nextRow));
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIDOMNode> nextNode;
   // Skip over any textnodes here
   while (nextRow && !nsHTMLEditUtils::IsTableRow(nextRow))
   {
     res = nextRow->GetNextSibling(getter_AddRefs(nextNode));
     NS_ENSURE_SUCCESS(res, res);
     nextRow = nextNode;
   }
   if(nextRow)
   {
     *aRowNode = nextRow.get();
     NS_ADDREF(*aRowNode);
     return NS_OK;
   }
   // No row found, search for rows in other table sections
   nsCOMPtr<nsIDOMNode> rowParent;
   res = aCurrentRowNode->GetParentNode(getter_AddRefs(rowParent));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(rowParent, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> parentSibling;
   res = rowParent->GetNextSibling(getter_AddRefs(parentSibling));
   NS_ENSURE_SUCCESS(res, res);
   while (parentSibling)
   {
     res = parentSibling->GetFirstChild(getter_AddRefs(nextRow));
     NS_ENSURE_SUCCESS(res, res);
     // We can encounter textnodes here -- must find a row
     while (nextRow && !nsHTMLEditUtils::IsTableRow(nextRow))
     {
       res = nextRow->GetNextSibling(getter_AddRefs(nextNode));
       NS_ENSURE_SUCCESS(res, res);
       nextRow = nextNode;
     }
     if(nextRow)
     {
       *aRowNode = nextRow.get();
       NS_ADDREF(*aRowNode);
       return NS_OK;
     }
 #ifdef DEBUG_cmanske
     printf("GetNextRow: firstChild of row's parent's sibling is not a TR!\n");
 #endif
     // We arrive here only if a table section has no children
     //  or first child of section is not a row (bad HTML or more "_moz_text" nodes!)
     // So look for another section sibling
     res = parentSibling->GetNextSibling(getter_AddRefs(nextNode));
     NS_ENSURE_SUCCESS(res, res);
     parentSibling = nextNode;
   }
   // If here, row was not found
   return NS_EDITOR_ELEMENT_NOT_FOUND;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetLastCellInRow(nsIDOMNode* aRowNode, nsIDOMNode** aCellNode)
 {
   NS_ENSURE_TRUE(aCellNode, NS_ERROR_NULL_POINTER);
   *aCellNode = nullptr;
   NS_ENSURE_TRUE(aRowNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> rowChild;
   nsresult res = aRowNode->GetLastChild(getter_AddRefs(rowChild));
   NS_ENSURE_SUCCESS(res, res);
   while (rowChild && !nsHTMLEditUtils::IsTableCell(rowChild))
   {
     // Skip over textnodes
     nsCOMPtr<nsIDOMNode> previousChild;
     res = rowChild->GetPreviousSibling(getter_AddRefs(previousChild));
     NS_ENSURE_SUCCESS(res, res);
     rowChild = previousChild;
   };
   if (rowChild)
   {
     *aCellNode = rowChild.get();
     NS_ADDREF(*aCellNode);
     return NS_OK;
   }
   // If here, cell was not found
   return NS_EDITOR_ELEMENT_NOT_FOUND;
 }
 NS_IMETHODIMP
 nsHTMLEditor::InsertTableColumn(int32_t aNumber, bool aAfter)
 {
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> curCell;
   int32_t startRowIndex, startColIndex;
   nsresult res = GetCellContext(getter_AddRefs(selection),
                                 getter_AddRefs(table),
                                 getter_AddRefs(curCell),
                                 nullptr, nullptr,
                                 &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if no cell found
   NS_ENSURE_TRUE(curCell, NS_EDITOR_ELEMENT_NOT_FOUND);
   // Get more data for current cell (we need ROWSPAN)
   int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   res = GetCellDataAt(table, startRowIndex, startColIndex,
                       getter_AddRefs(curCell),
                       &curStartRowIndex, &curStartColIndex,
                       &rowSpan, &colSpan,
                       &actualRowSpan, &actualColSpan, &isSelected);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(curCell, NS_ERROR_FAILURE);
   nsAutoEditBatch beginBatching(this);
   // Prevent auto insertion of BR in new cell until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
   // Use column after current cell if requested
   if (aAfter)
   {
     startColIndex += actualColSpan;
     //Detect when user is adding after a COLSPAN=0 case
     // Assume they want to stop the "0" behavior and
     // really add a new column. Thus we set the
     // colspan to its true value
     if (colSpan == 0)
       SetColSpan(curCell, actualColSpan);
   }
   int32_t rowCount, colCount, rowIndex;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   //We reset caret in destructor...
   nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousRow, false);
   //.. so suppress Rules System selection munging
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   // If we are inserting after all existing columns
   // Make sure table is "well formed"
   //  before appending new column
   if (startColIndex >= colCount)
     NormalizeTable(table);
   nsCOMPtr<nsIDOMNode> rowNode;
   for ( rowIndex = 0; rowIndex < rowCount; rowIndex++)
   {
 #ifdef DEBUG_cmanske
     if (rowIndex == rowCount-1)
       printf(" ***InsertTableColumn: Inserting cell at last row: %d\n", rowIndex);
 #endif
     if (startColIndex < colCount)
     {
       // We are inserting before an existing column
       res = GetCellDataAt(table, rowIndex, startColIndex,
                           getter_AddRefs(curCell),
                           &curStartRowIndex, &curStartColIndex,
                           &rowSpan, &colSpan,
                           &actualRowSpan, &actualColSpan, &isSelected);
       NS_ENSURE_SUCCESS(res, res);
       // Don't fail entire process if we fail to find a cell
       //  (may fail just in particular rows with < adequate cells per row)
       if (curCell)
       {
         if (curStartColIndex < startColIndex)
         {
           // We have a cell spanning this location
           // Simply increase its colspan to keep table rectangular
           // Note: we do nothing if colsSpan=0,
           //  since it should automatically span the new column
           if (colSpan > 0)
             SetColSpan(curCell, colSpan+aNumber);
         } else {
           // Simply set selection to the current cell
           //  so we can let InsertTableCell() do the work
           // Insert a new cell before current one
           selection->Collapse(curCell, 0);
           res = InsertTableCell(aNumber, false);
         }
       }
     } else {
       // Get current row and append new cells after last cell in row
       if(rowIndex == 0)
         res = GetFirstRow(table.get(), getter_AddRefs(rowNode));
       else
       {
         nsCOMPtr<nsIDOMNode> nextRow;
         res = GetNextRow(rowNode.get(), getter_AddRefs(nextRow));
         rowNode = nextRow;
       }
       NS_ENSURE_SUCCESS(res, res);
       if (rowNode)
       {
         nsCOMPtr<nsIDOMNode> lastCell;
         res = GetLastCellInRow(rowNode, getter_AddRefs(lastCell));
         NS_ENSURE_SUCCESS(res, res);
         NS_ENSURE_TRUE(lastCell, NS_ERROR_FAILURE);
         curCell = do_QueryInterface(lastCell);
         if (curCell)
         {
           // Simply add same number of cells to each row
           // Although tempted to check cell indexes for curCell,
           //  the effects of COLSPAN>1 in some cells makes this futile!
           // We must use NormalizeTable first to assure
           //  that there are cells in each cellmap location
           selection->Collapse(curCell, 0);
           res = InsertTableCell(aNumber, true);
         }
       }
     }
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::InsertTableRow(int32_t aNumber, bool aAfter)
 {
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> curCell;
   int32_t startRowIndex, startColIndex;
   nsresult res = GetCellContext(nullptr,
                                 getter_AddRefs(table),
                                 getter_AddRefs(curCell),
                                 nullptr, nullptr,
                                 &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if no cell found
   NS_ENSURE_TRUE(curCell, NS_EDITOR_ELEMENT_NOT_FOUND);
   // Get more data for current cell in row we are inserting at (we need COLSPAN)
   int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   res = GetCellDataAt(table, startRowIndex, startColIndex,
                       getter_AddRefs(curCell),
                       &curStartRowIndex, &curStartColIndex,
                       &rowSpan, &colSpan,
                       &actualRowSpan, &actualColSpan, &isSelected);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(curCell, NS_ERROR_FAILURE);
   int32_t rowCount, colCount;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   nsAutoEditBatch beginBatching(this);
   // Prevent auto insertion of BR in new cell until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
   if (aAfter)
   {
     // Use row after current cell
     startRowIndex += actualRowSpan;
     //Detect when user is adding after a ROWSPAN=0 case
     // Assume they want to stop the "0" behavior and
     // really add a new row. Thus we set the
     // rowspan to its true value
     if (rowSpan == 0)
       SetRowSpan(curCell, actualRowSpan);
   }
   //We control selection resetting after the insert...
   nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousColumn, false);
   //...so suppress Rules System selection munging
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   nsCOMPtr<nsIDOMElement> cellForRowParent;
   int32_t cellsInRow = 0;
   if (startRowIndex < rowCount)
   {
     // We are inserting above an existing row
     // Get each cell in the insert row to adjust for COLSPAN effects while we
     //   count how many cells are needed
     int32_t colIndex = 0;
     // This returns NS_TABLELAYOUT_CELL_NOT_FOUND when we run past end of row,
     //   which passes the NS_SUCCEEDED macro
     while ( NS_OK == GetCellDataAt(table, startRowIndex, colIndex,
                                    getter_AddRefs(curCell),
                                    &curStartRowIndex, &curStartColIndex,
                                    &rowSpan, &colSpan,
                                    &actualRowSpan, &actualColSpan,
                                    &isSelected) )
     {
       if (curCell)
       {
         if (curStartRowIndex < startRowIndex)
         {
           // We have a cell spanning this location
           // Simply increase its rowspan
           //Note that if rowSpan == 0, we do nothing,
           //  since that cell should automatically extend into the new row
           if (rowSpan > 0)
             SetRowSpan(curCell, rowSpan+aNumber);
         } else {
           // We have a cell in the insert row
           // Count the number of cells we need to add to the new row
           cellsInRow += actualColSpan;
           // Save cell we will use below
           if (!cellForRowParent)
             cellForRowParent = curCell;
         }
         // Next cell in row
         colIndex += actualColSpan;
       }
       else
         colIndex++;
     }
   } else {
     // We are adding a new row after all others
     // If it weren't for colspan=0 effect,
     // we could simply use colCount for number of new cells...
     cellsInRow = colCount;
     // ...but we must compensate for all cells with rowSpan = 0 in the last row
     int32_t lastRow = rowCount-1;
     int32_t tempColIndex = 0;
     while ( NS_OK == GetCellDataAt(table, lastRow, tempColIndex,
                                    getter_AddRefs(curCell),
                                    &curStartRowIndex, &curStartColIndex,
                                    &rowSpan, &colSpan,
                                    &actualRowSpan, &actualColSpan,
                                    &isSelected) )
     {
       if (rowSpan == 0)
         cellsInRow -= actualColSpan;
       tempColIndex += actualColSpan;
       // Save cell from the last row that we will use below
       if (!cellForRowParent && curStartRowIndex == lastRow)
         cellForRowParent = curCell;
     }
   }
   if (cellsInRow > 0)
   {
     // The row parent and offset where we will insert new row
     nsCOMPtr<nsIDOMNode> parentOfRow;
     int32_t newRowOffset;
     NS_NAMED_LITERAL_STRING(trStr, "tr");
     if (cellForRowParent)
     {
       nsCOMPtr<nsIDOMElement> parentRow;
       res = GetElementOrParentByTagName(trStr, cellForRowParent, getter_AddRefs(parentRow));
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_TRUE(parentRow, NS_ERROR_NULL_POINTER);
       parentRow->GetParentNode(getter_AddRefs(parentOfRow));
       NS_ENSURE_TRUE(parentOfRow, NS_ERROR_NULL_POINTER);
       newRowOffset = GetChildOffset(parentRow, parentOfRow);
       // Adjust for when adding past the end
       if (aAfter && startRowIndex >= rowCount)
         newRowOffset++;
     }
     else
       return NS_ERROR_FAILURE;
     for (int32_t row = 0; row < aNumber; row++)
     {
       // Create a new row
       nsCOMPtr<nsIDOMElement> newRow;
       res = CreateElementWithDefaults(trStr, getter_AddRefs(newRow));
       if (NS_SUCCEEDED(res))
       {
         NS_ENSURE_TRUE(newRow, NS_ERROR_FAILURE);
         for (int32_t i = 0; i < cellsInRow; i++)
         {
           nsCOMPtr<nsIDOMElement> newCell;
           res = CreateElementWithDefaults(NS_LITERAL_STRING("td"), getter_AddRefs(newCell));
           NS_ENSURE_SUCCESS(res, res);
           NS_ENSURE_TRUE(newCell, NS_ERROR_FAILURE);
           // Don't use transaction system yet! (not until entire row is inserted)
           nsCOMPtr<nsIDOMNode>resultNode;
           res = newRow->AppendChild(newCell, getter_AddRefs(resultNode));
           NS_ENSURE_SUCCESS(res, res);
         }
         // Use transaction system to insert the entire row+cells
         // (Note that rows are inserted at same childoffset each time)
         res = InsertNode(newRow, parentOfRow, newRowOffset);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
   }
   return res;
 }
 // Editor helper only
 // XXX Code changed for bug 217717 and now we don't need aSelection param
 //     TODO: Remove aSelection param
 NS_IMETHODIMP
 nsHTMLEditor::DeleteTable2(nsIDOMElement *aTable, nsISelection *aSelection)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
   // Select the table
   nsresult res = ClearSelection();
   if (NS_SUCCEEDED(res))
     res = AppendNodeToSelectionAsRange(aTable);
   NS_ENSURE_SUCCESS(res, res);
   return DeleteSelection(nsIEditor::eNext, nsIEditor::eStrip);
 }
 NS_IMETHODIMP
 nsHTMLEditor::DeleteTable()
 {
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   nsresult res = GetCellContext(getter_AddRefs(selection),
                                 getter_AddRefs(table),
                                 nullptr, nullptr, nullptr, nullptr, nullptr);
   NS_ENSURE_SUCCESS(res, res);
   nsAutoEditBatch beginBatching(this);
   return DeleteTable2(table, selection);
 }
 NS_IMETHODIMP
 nsHTMLEditor::DeleteTableCell(int32_t aNumber)
 {
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex;
   nsresult res = GetCellContext(getter_AddRefs(selection),
                          getter_AddRefs(table),
                          getter_AddRefs(cell),
                          nullptr, nullptr,
                          &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if we didn't find a table or cell
   NS_ENSURE_TRUE(table && cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   nsAutoEditBatch beginBatching(this);
   // Prevent rules testing until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
   nsCOMPtr<nsIDOMElement> firstCell;
   nsCOMPtr<nsIDOMRange> range;
   res = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
   NS_ENSURE_SUCCESS(res, res);
   int32_t rangeCount;
   res = selection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   if (firstCell && rangeCount > 1)
   {
     // When > 1 selected cell,
     //  ignore aNumber and use selected cells
     cell = firstCell;
     int32_t rowCount, colCount;
     res = GetTableSize(table, &rowCount, &colCount);
     NS_ENSURE_SUCCESS(res, res);
     // Get indexes -- may be different than original cell
     res = GetCellIndexes(cell, &startRowIndex, &startColIndex);
     NS_ENSURE_SUCCESS(res, res);
     // The setCaret object will call SetSelectionAfterTableEdit in its destructor
     nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousColumn, false);
     nsAutoTxnsConserveSelection dontChangeSelection(this);
     bool    checkToDeleteRow = true;
     bool    checkToDeleteColumn = true;
     while (cell)
     {
       bool deleteRow = false;
       bool deleteCol = false;
       if (checkToDeleteRow)
       {
         // Optimize to delete an entire row
         // Clear so we don't repeat AllCellsInRowSelected within the same row
         checkToDeleteRow = false;
         deleteRow = AllCellsInRowSelected(table, startRowIndex, colCount);
         if (deleteRow)
         {
           // First, find the next cell in a different row
           //   to continue after we delete this row
           int32_t nextRow = startRowIndex;
           while (nextRow == startRowIndex)
           {
             res = GetNextSelectedCell(nullptr, getter_AddRefs(cell));
             NS_ENSURE_SUCCESS(res, res);
             if (!cell) break;
             res = GetCellIndexes(cell, &nextRow, &startColIndex);
             NS_ENSURE_SUCCESS(res, res);
           }
           // Delete entire row
           res = DeleteRow(table, startRowIndex);
           NS_ENSURE_SUCCESS(res, res);
           if (cell)
           {
             // For the next cell: Subtract 1 for row we deleted
             startRowIndex = nextRow - 1;
             // Set true since we know we will look at a new row next
             checkToDeleteRow = true;
           }
         }
       }
       if (!deleteRow)
       {
         if (checkToDeleteColumn)
         {
           // Optimize to delete an entire column
           // Clear this so we don't repeat AllCellsInColSelected within the same Col
           checkToDeleteColumn = false;
           deleteCol = AllCellsInColumnSelected(table, startColIndex, colCount);
           if (deleteCol)
           {
             // First, find the next cell in a different column
             //   to continue after we delete this column
             int32_t nextCol = startColIndex;
             while (nextCol == startColIndex)
             {
               res = GetNextSelectedCell(nullptr, getter_AddRefs(cell));
               NS_ENSURE_SUCCESS(res, res);
               if (!cell) break;
               res = GetCellIndexes(cell, &startRowIndex, &nextCol);
               NS_ENSURE_SUCCESS(res, res);
             }
             // Delete entire Col
             res = DeleteColumn(table, startColIndex);
             NS_ENSURE_SUCCESS(res, res);
             if (cell)
             {
               // For the next cell, subtract 1 for col. deleted
               startColIndex = nextCol - 1;
               // Set true since we know we will look at a new column next
               checkToDeleteColumn = true;
             }
           }
         }
         if (!deleteCol)
         {
           // First get the next cell to delete
           nsCOMPtr<nsIDOMElement> nextCell;
           res = GetNextSelectedCell(getter_AddRefs(range), getter_AddRefs(nextCell));
           NS_ENSURE_SUCCESS(res, res);
           // Then delete the cell
           res = DeleteNode(cell);
           NS_ENSURE_SUCCESS(res, res);
           // The next cell to delete
           cell = nextCell;
           if (cell)
           {
             res = GetCellIndexes(cell, &startRowIndex, &startColIndex);
             NS_ENSURE_SUCCESS(res, res);
           }
         }
       }
     }
   }
   else for (int32_t i = 0; i < aNumber; i++)
   {
     res = GetCellContext(getter_AddRefs(selection),
                          getter_AddRefs(table),
                          getter_AddRefs(cell),
                          nullptr, nullptr,
                          &startRowIndex, &startColIndex);
     NS_ENSURE_SUCCESS(res, res);
     // Don't fail if no cell found
     NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
     if (1 == GetNumberOfCellsInRow(table, startRowIndex))
     {
       nsCOMPtr<nsIDOMElement> parentRow;
       res = GetElementOrParentByTagName(NS_LITERAL_STRING("tr"), cell, getter_AddRefs(parentRow));
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_TRUE(parentRow, NS_ERROR_NULL_POINTER);
       // We should delete the row instead,
       //  but first check if its the only row left
       //  so we can delete the entire table
       int32_t rowCount, colCount;
       res = GetTableSize(table, &rowCount, &colCount);
       NS_ENSURE_SUCCESS(res, res);
       if (rowCount == 1)
         return DeleteTable2(table, selection);
       // We need to call DeleteTableRow to handle cells with rowspan
       res = DeleteTableRow(1);
       NS_ENSURE_SUCCESS(res, res);
     }
     else
     {
       // More than 1 cell in the row
       // The setCaret object will call SetSelectionAfterTableEdit in its destructor
       nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousColumn, false);
       nsAutoTxnsConserveSelection dontChangeSelection(this);
       res = DeleteNode(cell);
       // If we fail, don't try to delete any more cells???
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::DeleteTableCellContents()
 {
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex;
   nsresult res;
   res = GetCellContext(getter_AddRefs(selection),
                        getter_AddRefs(table),
                        getter_AddRefs(cell),
                        nullptr, nullptr,
                        &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if no cell found
   NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   nsAutoEditBatch beginBatching(this);
   // Prevent rules testing until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
   //Don't let Rules System change the selection
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   nsCOMPtr<nsIDOMElement> firstCell;
   nsCOMPtr<nsIDOMRange> range;
   res = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
   NS_ENSURE_SUCCESS(res, res);
   if (firstCell)
   {
     cell = firstCell;
     res = GetCellIndexes(cell, &startRowIndex, &startColIndex);
     NS_ENSURE_SUCCESS(res, res);
   }
   nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousColumn, false);
   while (cell)
   {
     DeleteCellContents(cell);
     if (firstCell)
     {
       // We doing a selected cells, so do all of them
       res = GetNextSelectedCell(nullptr, getter_AddRefs(cell));
       NS_ENSURE_SUCCESS(res, res);
     }
     else
       cell = nullptr;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::DeleteCellContents(nsIDOMElement *aCell)
 {
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   // Prevent rules testing until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
   nsCOMPtr<nsIDOMNode> child;
   bool hasChild;
   aCell->HasChildNodes(&hasChild);
   while (hasChild)
   {
     aCell->GetLastChild(getter_AddRefs(child));
     nsresult res = DeleteNode(child);
     NS_ENSURE_SUCCESS(res, res);
     aCell->HasChildNodes(&hasChild);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::DeleteTableColumn(int32_t aNumber)
 {
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex, rowCount, colCount;
   nsresult res = GetCellContext(getter_AddRefs(selection),
                                 getter_AddRefs(table),
                                 getter_AddRefs(cell),
                                 nullptr, nullptr,
                                 &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if no cell found
   NS_ENSURE_TRUE(table && cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   // Shortcut the case of deleting all columns in table
   if(startColIndex == 0 && aNumber >= colCount)
     return DeleteTable2(table, selection);
   // Check for counts too high
   aNumber = std::min(aNumber,(colCount-startColIndex));
   nsAutoEditBatch beginBatching(this);
   // Prevent rules testing until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
   // Test if deletion is controlled by selected cells
   nsCOMPtr<nsIDOMElement> firstCell;
   nsCOMPtr<nsIDOMRange> range;
   res = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
   NS_ENSURE_SUCCESS(res, res);
   int32_t rangeCount;
   res = selection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   if (firstCell && rangeCount > 1)
   {
     // Fetch indexes again - may be different for selected cells
     res = GetCellIndexes(firstCell, &startRowIndex, &startColIndex);
     NS_ENSURE_SUCCESS(res, res);
   }
   //We control selection resetting after the insert...
   nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousRow, false);
   if (firstCell && rangeCount > 1)
   {
     // Use selected cells to determine what rows to delete
     cell = firstCell;
     while (cell)
     {
       if (cell != firstCell)
       {
         res = GetCellIndexes(cell, &startRowIndex, &startColIndex);
         NS_ENSURE_SUCCESS(res, res);
       }
       // Find the next cell in a different column
       // to continue after we delete this column
       int32_t nextCol = startColIndex;
       while (nextCol == startColIndex)
       {
         res = GetNextSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
         NS_ENSURE_SUCCESS(res, res);
         if (!cell) break;
         res = GetCellIndexes(cell, &startRowIndex, &nextCol);
         NS_ENSURE_SUCCESS(res, res);
       }
       res = DeleteColumn(table, startColIndex);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   else for (int32_t i = 0; i < aNumber; i++)
   {
     res = DeleteColumn(table, startColIndex);
     NS_ENSURE_SUCCESS(res, res);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::DeleteColumn(nsIDOMElement *aTable, int32_t aColIndex)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMElement> cell;
   nsCOMPtr<nsIDOMElement> cellInDeleteCol;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   int32_t rowIndex = 0;
   nsresult res = NS_OK;
   do {
     res = GetCellDataAt(aTable, rowIndex, aColIndex, getter_AddRefs(cell),
                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     NS_ENSURE_SUCCESS(res, res);
     if (cell)
     {
       // Find cells that don't start in column we are deleting
       if (startColIndex < aColIndex || colSpan > 1 || colSpan == 0)
       {
         // We have a cell spanning this location
         // Decrease its colspan to keep table rectangular,
         // but if colSpan=0, it will adjust automatically
         if (colSpan > 0)
         {
           NS_ASSERTION((colSpan > 1),"Bad COLSPAN in DeleteTableColumn");
           SetColSpan(cell, colSpan-1);
         }
         if (startColIndex == aColIndex)
         {
           // Cell is in column to be deleted, but must have colspan > 1,
           // so delete contents of cell instead of cell itself
           // (We must have reset colspan above)
           DeleteCellContents(cell);
         }
         // To next cell in column
         rowIndex += actualRowSpan;
       }
       else
       {
         // Delete the cell
         if (1 == GetNumberOfCellsInRow(aTable, rowIndex))
         {
           // Only 1 cell in row - delete the row
           nsCOMPtr<nsIDOMElement> parentRow;
           res = GetElementOrParentByTagName(NS_LITERAL_STRING("tr"), cell, getter_AddRefs(parentRow));
           NS_ENSURE_SUCCESS(res, res);
           if(!parentRow) return NS_ERROR_NULL_POINTER;
           //  But first check if its the only row left
           //  so we can delete the entire table
           //  (This should never happen but it's the safe thing to do)
           int32_t rowCount, colCount;
           res = GetTableSize(aTable, &rowCount, &colCount);
           NS_ENSURE_SUCCESS(res, res);
           if (rowCount == 1)
           {
             nsCOMPtr<nsISelection> selection;
             res = GetSelection(getter_AddRefs(selection));
             NS_ENSURE_SUCCESS(res, res);
             NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
             return DeleteTable2(aTable, selection);
           }
           // Delete the row by placing caret in cell we were to delete
           // We need to call DeleteTableRow to handle cells with rowspan
           res = DeleteRow(aTable, startRowIndex);
           NS_ENSURE_SUCCESS(res, res);
           // Note that we don't incremenet rowIndex
           // since a row was deleted and "next"
           // row now has current rowIndex
         }
         else
         {
           // A more "normal" deletion
           res = DeleteNode(cell);
           NS_ENSURE_SUCCESS(res, res);
           //Skip over any rows spanned by this cell
           rowIndex += actualRowSpan;
         }
       }
     }
   } while (cell);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::DeleteTableRow(int32_t aNumber)
 {
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex;
   int32_t rowCount, colCount;
   nsresult res =  GetCellContext(getter_AddRefs(selection),
                                  getter_AddRefs(table),
                                  getter_AddRefs(cell),
                                  nullptr, nullptr,
                                  &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if no cell found
   NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   // Shortcut the case of deleting all rows in table
   if(startRowIndex == 0 && aNumber >= rowCount)
     return DeleteTable2(table, selection);
   nsAutoEditBatch beginBatching(this);
   // Prevent rules testing until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
   nsCOMPtr<nsIDOMElement> firstCell;
   nsCOMPtr<nsIDOMRange> range;
   res = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
   NS_ENSURE_SUCCESS(res, res);
   int32_t rangeCount;
   res = selection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   if (firstCell && rangeCount > 1)
   {
     // Fetch indexes again - may be different for selected cells
     res = GetCellIndexes(firstCell, &startRowIndex, &startColIndex);
     NS_ENSURE_SUCCESS(res, res);
   }
   //We control selection resetting after the insert...
   nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousRow, false);
   // Don't change selection during deletions
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   if (firstCell && rangeCount > 1)
   {
     // Use selected cells to determine what rows to delete
     cell = firstCell;
     while (cell)
     {
       if (cell != firstCell)
       {
         res = GetCellIndexes(cell, &startRowIndex, &startColIndex);
         NS_ENSURE_SUCCESS(res, res);
       }
       // Find the next cell in a different row
       // to continue after we delete this row
       int32_t nextRow = startRowIndex;
       while (nextRow == startRowIndex)
       {
         res = GetNextSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
         NS_ENSURE_SUCCESS(res, res);
         if (!cell) break;
         res = GetCellIndexes(cell, &nextRow, &startColIndex);
         NS_ENSURE_SUCCESS(res, res);
       }
       // Delete entire row
       res = DeleteRow(table, startRowIndex);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   else
   {
     // Check for counts too high
     aNumber = std::min(aNumber,(rowCount-startRowIndex));
     for (int32_t i = 0; i < aNumber; i++)
     {
       res = DeleteRow(table, startRowIndex);
       // If failed in current row, try the next
       if (NS_FAILED(res))
         startRowIndex++;
       // Check if there's a cell in the "next" row
       res = GetCellAt(table, startRowIndex, startColIndex, getter_AddRefs(cell));
       NS_ENSURE_SUCCESS(res, res);
       if(!cell)
         break;
     }
   }
   return NS_OK;
 }
 // Helper that doesn't batch or change the selection
 NS_IMETHODIMP
 nsHTMLEditor::DeleteRow(nsIDOMElement *aTable, int32_t aRowIndex)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMElement> cell;
   nsCOMPtr<nsIDOMElement> cellInDeleteRow;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   int32_t colIndex = 0;
   nsresult res = NS_OK;
   // Prevent rules testing until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
   // The list of cells we will change rowspan in
   //  and the new rowspan values for each
   nsTArray<nsCOMPtr<nsIDOMElement> > spanCellList;
   nsTArray<int32_t> newSpanList;
   int32_t rowCount, colCount;
   res = GetTableSize(aTable, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   // Scan through cells in row to do rowspan adjustments
   // Note that after we delete row, startRowIndex will point to the
   //   cells in the next row to be deleted
   do {
     if (aRowIndex >= rowCount || colIndex >= colCount)
       break;
     res = GetCellDataAt(aTable, aRowIndex, colIndex, getter_AddRefs(cell),
                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     // We don't fail if we don't find a cell, so this must be real bad
     if(NS_FAILED(res)) return res;
     // Compensate for cells that don't start or extend below the row we are deleting
     if (cell)
     {
       if (startRowIndex < aRowIndex)
       {
         // Cell starts in row above us
         // Decrease its rowspan to keep table rectangular
         //  but we don't need to do this if rowspan=0,
         //  since it will automatically adjust
         if (rowSpan > 0)
         {
           // Build list of cells to change rowspan
           // We can't do it now since it upsets cell map,
           //  so we will do it after deleting the row
           spanCellList.AppendElement(cell);
           newSpanList.AppendElement(std::max((aRowIndex - startRowIndex), actualRowSpan-1));
         }
       }
       else
       {
         if (rowSpan > 1)
         {
           //Cell spans below row to delete,
           //  so we must insert new cells to keep rows below even
           // Note that we test "rowSpan" so we don't do this if rowSpan = 0 (automatic readjustment)
           res = SplitCellIntoRows(aTable, startRowIndex, startColIndex,
                                   aRowIndex - startRowIndex + 1, // The row above the row to insert new cell into
                                   actualRowSpan - 1, nullptr);    // Span remaining below
           NS_ENSURE_SUCCESS(res, res);
         }
         if (!cellInDeleteRow)
           cellInDeleteRow = cell; // Reference cell to find row to delete
       }
       // Skip over other columns spanned by this cell
       colIndex += actualColSpan;
     }
   } while (cell);
   // Things are messed up if we didn't find a cell in the row!
   NS_ENSURE_TRUE(cellInDeleteRow, NS_ERROR_FAILURE);
   // Delete the entire row
   nsCOMPtr<nsIDOMElement> parentRow;
   res = GetElementOrParentByTagName(NS_LITERAL_STRING("tr"), cellInDeleteRow, getter_AddRefs(parentRow));
   NS_ENSURE_SUCCESS(res, res);
   if (parentRow)
   {
     res = DeleteNode(parentRow);
     NS_ENSURE_SUCCESS(res, res);
   }
   // Now we can set new rowspans for cells stored above
   for (uint32_t i = 0, n = spanCellList.Length(); i < n; i++)
   {
     nsIDOMElement *cellPtr = spanCellList[i];
     if (cellPtr)
     {
       res = SetRowSpan(cellPtr, newSpanList[i]);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SelectTable()
 {
   nsCOMPtr<nsIDOMElement> table;
   nsresult res = NS_ERROR_FAILURE;
   res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), nullptr, getter_AddRefs(table));
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if we didn't find a table
   NS_ENSURE_TRUE(table, NS_OK);
   res = ClearSelection();
   if (NS_SUCCEEDED(res))
     res = AppendNodeToSelectionAsRange(table);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SelectTableCell()
 {
   nsCOMPtr<nsIDOMElement> cell;
   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr, getter_AddRefs(cell));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   res = ClearSelection();
   if (NS_SUCCEEDED(res))
     res = AppendNodeToSelectionAsRange(cell);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SelectBlockOfCells(nsIDOMElement *aStartCell, nsIDOMElement *aEndCell)
 {
   NS_ENSURE_TRUE(aStartCell && aEndCell, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   NS_NAMED_LITERAL_STRING(tableStr, "table");
   nsCOMPtr<nsIDOMElement> table;
   res = GetElementOrParentByTagName(tableStr, aStartCell, getter_AddRefs(table));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
   nsCOMPtr<nsIDOMElement> endTable;
   res = GetElementOrParentByTagName(tableStr, aEndCell, getter_AddRefs(endTable));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(endTable, NS_ERROR_FAILURE);
   // We can only select a block if within the same table,
   //  so do nothing if not within one table
   if (table != endTable) return NS_OK;
   int32_t startRowIndex, startColIndex, endRowIndex, endColIndex;
   // Get starting and ending cells' location in the cellmap
   res = GetCellIndexes(aStartCell, &startRowIndex, &startColIndex);
   if(NS_FAILED(res)) return res;
   res = GetCellIndexes(aEndCell, &endRowIndex, &endColIndex);
   if(NS_FAILED(res)) return res;
   // Suppress nsISelectionListener notification
   //  until all selection changes are finished
   nsSelectionBatcherForTable selectionBatcher(selection);
   // Examine all cell nodes in current selection and
   //  remove those outside the new block cell region
   int32_t minColumn = std::min(startColIndex, endColIndex);
   int32_t minRow    = std::min(startRowIndex, endRowIndex);
   int32_t maxColumn   = std::max(startColIndex, endColIndex);
   int32_t maxRow      = std::max(startRowIndex, endRowIndex);
   nsCOMPtr<nsIDOMElement> cell;
   int32_t currentRowIndex, currentColIndex;
   nsCOMPtr<nsIDOMRange> range;
   res = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
   NS_ENSURE_SUCCESS(res, res);
   if (res == NS_EDITOR_ELEMENT_NOT_FOUND) return NS_OK;
   while (cell)
   {
     res = GetCellIndexes(cell, &currentRowIndex, &currentColIndex);
     NS_ENSURE_SUCCESS(res, res);
     if (currentRowIndex < maxRow || currentRowIndex > maxRow ||
         currentColIndex < maxColumn || currentColIndex > maxColumn)
     {
       selection->RemoveRange(range);
       // Since we've removed the range, decrement pointer to next range
       mSelectedCellIndex--;
     }
     res = GetNextSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
     NS_ENSURE_SUCCESS(res, res);
   }
   int32_t rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   for (int32_t row = minRow; row <= maxRow; row++)
   {
     for(int32_t col = minColumn; col <= maxColumn; col += std::max(actualColSpan, 1))
     {
       res = GetCellDataAt(table, row, col, getter_AddRefs(cell),
                           &currentRowIndex, &currentColIndex,
                           &rowSpan, &colSpan,
                           &actualRowSpan, &actualColSpan, &isSelected);
       if (NS_FAILED(res)) break;
       // Skip cells that already selected or are spanned from previous locations
       if (!isSelected && cell && row == currentRowIndex && col == currentColIndex)
       {
         res = AppendNodeToSelectionAsRange(cell);
         if (NS_FAILED(res)) break;
       }
     }
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SelectAllTableCells()
 {
   nsCOMPtr<nsIDOMElement> cell;
   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr, getter_AddRefs(cell));
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if we didn't find a cell
   NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   nsCOMPtr<nsIDOMElement> startCell = cell;
   // Get parent table
   nsCOMPtr<nsIDOMElement> table;
   res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), cell, getter_AddRefs(table));
   NS_ENSURE_SUCCESS(res, res);
   if(!table) return NS_ERROR_NULL_POINTER;
   int32_t rowCount, colCount;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsISelection> selection;
   res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   // Suppress nsISelectionListener notification
   //  until all selection changes are finished
   nsSelectionBatcherForTable selectionBatcher(selection);
   // It is now safe to clear the selection
   // BE SURE TO RESET IT BEFORE LEAVING!
   res = ClearSelection();
   // Select all cells in the same column as current cell
   bool cellSelected = false;
   int32_t rowSpan, colSpan, actualRowSpan, actualColSpan, currentRowIndex, currentColIndex;
   bool    isSelected;
   for(int32_t row = 0; row < rowCount; row++)
   {
     for(int32_t col = 0; col < colCount; col += std::max(actualColSpan, 1))
     {
       res = GetCellDataAt(table, row, col, getter_AddRefs(cell),
                           &currentRowIndex, &currentColIndex,
                           &rowSpan, &colSpan,
                           &actualRowSpan, &actualColSpan, &isSelected);
       if (NS_FAILED(res)) break;
       // Skip cells that are spanned from previous rows or columns
       if (cell && row == currentRowIndex && col == currentColIndex)
       {
         res =  AppendNodeToSelectionAsRange(cell);
         if (NS_FAILED(res)) break;
         cellSelected = true;
       }
     }
   }
   // Safety code to select starting cell if nothing else was selected
   if (!cellSelected)
   {
     return AppendNodeToSelectionAsRange(startCell);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SelectTableRow()
 {
   nsCOMPtr<nsIDOMElement> cell;
   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr, getter_AddRefs(cell));
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if we didn't find a cell
   NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   nsCOMPtr<nsIDOMElement> startCell = cell;
   // Get table and location of cell:
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   int32_t startRowIndex, startColIndex;
   res = GetCellContext(getter_AddRefs(selection),
                        getter_AddRefs(table),
                        getter_AddRefs(cell),
                        nullptr, nullptr,
                        &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
   int32_t rowCount, colCount;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   //Note: At this point, we could get first and last cells in row,
   //  then call SelectBlockOfCells, but that would take just
   //  a little less code, so the following is more efficient
   // Suppress nsISelectionListener notification
   //  until all selection changes are finished
   nsSelectionBatcherForTable selectionBatcher(selection);
   // It is now safe to clear the selection
   // BE SURE TO RESET IT BEFORE LEAVING!
   res = ClearSelection();
   // Select all cells in the same row as current cell
   bool cellSelected = false;
   int32_t rowSpan, colSpan, actualRowSpan, actualColSpan, currentRowIndex, currentColIndex;
   bool    isSelected;
   for(int32_t col = 0; col < colCount; col += std::max(actualColSpan, 1))
   {
     res = GetCellDataAt(table, startRowIndex, col, getter_AddRefs(cell),
                         &currentRowIndex, &currentColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     if (NS_FAILED(res)) break;
     // Skip cells that are spanned from previous rows or columns
     if (cell && currentRowIndex == startRowIndex && currentColIndex == col)
     {
       res = AppendNodeToSelectionAsRange(cell);
       if (NS_FAILED(res)) break;
       cellSelected = true;
     }
   }
   // Safety code to select starting cell if nothing else was selected
   if (!cellSelected)
   {
     return AppendNodeToSelectionAsRange(startCell);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SelectTableColumn()
 {
   nsCOMPtr<nsIDOMElement> cell;
   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr, getter_AddRefs(cell));
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if we didn't find a cell
   NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   nsCOMPtr<nsIDOMElement> startCell = cell;
   // Get location of cell:
   nsCOMPtr<nsISelection> selection;
   nsCOMPtr<nsIDOMElement> table;
   int32_t startRowIndex, startColIndex;
   res = GetCellContext(getter_AddRefs(selection),
                        getter_AddRefs(table),
                        getter_AddRefs(cell),
                        nullptr, nullptr,
                        &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
   int32_t rowCount, colCount;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   // Suppress nsISelectionListener notification
   //  until all selection changes are finished
   nsSelectionBatcherForTable selectionBatcher(selection);
   // It is now safe to clear the selection
   // BE SURE TO RESET IT BEFORE LEAVING!
   res = ClearSelection();
   // Select all cells in the same column as current cell
   bool cellSelected = false;
   int32_t rowSpan, colSpan, actualRowSpan, actualColSpan, currentRowIndex, currentColIndex;
   bool    isSelected;
   for(int32_t row = 0; row < rowCount; row += std::max(actualRowSpan, 1))
   {
     res = GetCellDataAt(table, row, startColIndex, getter_AddRefs(cell),
                         &currentRowIndex, &currentColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     if (NS_FAILED(res)) break;
     // Skip cells that are spanned from previous rows or columns
     if (cell && currentRowIndex == row && currentColIndex == startColIndex)
     {
       res = AppendNodeToSelectionAsRange(cell);
       if (NS_FAILED(res)) break;
       cellSelected = true;
     }
   }
   // Safety code to select starting cell if nothing else was selected
   if (!cellSelected)
   {
     return AppendNodeToSelectionAsRange(startCell);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SplitTableCell()
 {
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex, actualRowSpan, actualColSpan;
   // Get cell, table, etc. at selection anchor node
   nsresult res = GetCellContext(nullptr,
                                 getter_AddRefs(table),
                                 getter_AddRefs(cell),
                                 nullptr, nullptr,
                                 &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   if(!table || !cell) return NS_EDITOR_ELEMENT_NOT_FOUND;
   // We need rowspan and colspan data
   res = GetCellSpansAt(table, startRowIndex, startColIndex, actualRowSpan, actualColSpan);
   NS_ENSURE_SUCCESS(res, res);
   // Must have some span to split
   if (actualRowSpan <= 1 && actualColSpan <= 1)
     return NS_OK;
   nsAutoEditBatch beginBatching(this);
   // Prevent auto insertion of BR in new cell until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
   // We reset selection
   nsSetSelectionAfterTableEdit setCaret(this, table, startRowIndex, startColIndex, ePreviousColumn, false);
   //...so suppress Rules System selection munging
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   nsCOMPtr<nsIDOMElement> newCell;
   int32_t rowIndex = startRowIndex;
   int32_t rowSpanBelow, colSpanAfter;
   // Split up cell row-wise first into rowspan=1 above, and the rest below,
   //  whittling away at the cell below until no more extra span
   for (rowSpanBelow = actualRowSpan-1; rowSpanBelow >= 0; rowSpanBelow--)
   {
     // We really split row-wise only if we had rowspan > 1
     if (rowSpanBelow > 0)
     {
       res = SplitCellIntoRows(table, rowIndex, startColIndex, 1, rowSpanBelow, getter_AddRefs(newCell));
       NS_ENSURE_SUCCESS(res, res);
       CopyCellBackgroundColor(newCell, cell);
     }
     int32_t colIndex = startColIndex;
     // Now split the cell with rowspan = 1 into cells if it has colSpan > 1
     for (colSpanAfter = actualColSpan-1; colSpanAfter > 0; colSpanAfter--)
     {
       res = SplitCellIntoColumns(table, rowIndex, colIndex, 1, colSpanAfter, getter_AddRefs(newCell));
       NS_ENSURE_SUCCESS(res, res);
       CopyCellBackgroundColor(newCell, cell);
       colIndex++;
     }
     // Point to the new cell and repeat
     rowIndex++;
   }
   return res;
 }
 nsresult
 nsHTMLEditor::CopyCellBackgroundColor(nsIDOMElement *destCell, nsIDOMElement *sourceCell)
 {
   NS_ENSURE_TRUE(destCell && sourceCell, NS_ERROR_NULL_POINTER);
   // Copy backgournd color to new cell
   NS_NAMED_LITERAL_STRING(bgcolor, "bgcolor");
   nsAutoString color;
   bool isSet;
   nsresult res = GetAttributeValue(sourceCell, bgcolor, color, &isSet);
   if (NS_SUCCEEDED(res) && isSet)
     res = SetAttribute(destCell, bgcolor, color);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SplitCellIntoColumns(nsIDOMElement *aTable, int32_t aRowIndex, int32_t aColIndex,
                                    int32_t aColSpanLeft, int32_t aColSpanRight,
                                    nsIDOMElement **aNewCell)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
   if (aNewCell) *aNewCell = nullptr;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   nsresult res = GetCellDataAt(aTable, aRowIndex, aColIndex, getter_AddRefs(cell),
                                &startRowIndex, &startColIndex,
                                &rowSpan, &colSpan,
                                &actualRowSpan, &actualColSpan, &isSelected);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(cell, NS_ERROR_NULL_POINTER);
   // We can't split!
   if (actualColSpan <= 1 || (aColSpanLeft + aColSpanRight) > actualColSpan)
     return NS_OK;
   // Reduce colspan of cell to split
   res = SetColSpan(cell, aColSpanLeft);
   NS_ENSURE_SUCCESS(res, res);
   // Insert new cell after using the remaining span
   //  and always get the new cell so we can copy the background color;
   nsCOMPtr<nsIDOMElement> newCell;
   res = InsertCell(cell, actualRowSpan, aColSpanRight, true, false, getter_AddRefs(newCell));
   NS_ENSURE_SUCCESS(res, res);
   if (newCell)
   {
     if (aNewCell)
     {
       *aNewCell = newCell.get();
       NS_ADDREF(*aNewCell);
     }
     res = CopyCellBackgroundColor(newCell, cell);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SplitCellIntoRows(nsIDOMElement *aTable, int32_t aRowIndex, int32_t aColIndex,
                                 int32_t aRowSpanAbove, int32_t aRowSpanBelow,
                                 nsIDOMElement **aNewCell)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
   if (aNewCell) *aNewCell = nullptr;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   nsresult res = GetCellDataAt(aTable, aRowIndex, aColIndex, getter_AddRefs(cell),
                                &startRowIndex, &startColIndex,
                                &rowSpan, &colSpan,
                                &actualRowSpan, &actualColSpan, &isSelected);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(cell, NS_ERROR_NULL_POINTER);
   // We can't split!
   if (actualRowSpan <= 1 || (aRowSpanAbove + aRowSpanBelow) > actualRowSpan)
     return NS_OK;
   int32_t rowCount, colCount;
   res = GetTableSize(aTable, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIDOMElement> cell2;
   nsCOMPtr<nsIDOMElement> lastCellFound;
   int32_t startRowIndex2, startColIndex2, rowSpan2, colSpan2, actualRowSpan2, actualColSpan2;
   bool    isSelected2;
   int32_t colIndex = 0;
   bool insertAfter = (startColIndex > 0);
   // This is the row we will insert new cell into
   int32_t rowBelowIndex = startRowIndex+aRowSpanAbove;
   // Find a cell to insert before or after
   do
   {
     // Search for a cell to insert before
     res = GetCellDataAt(aTable, rowBelowIndex,
                         colIndex, getter_AddRefs(cell2),
                         &startRowIndex2, &startColIndex2, &rowSpan2, &colSpan2,
                         &actualRowSpan2, &actualColSpan2, &isSelected2);
     // If we fail here, it could be because row has bad rowspan values,
     //   such as all cells having rowspan > 1 (Call FixRowSpan first!)
     if (NS_FAILED(res) || !cell) return NS_ERROR_FAILURE;
     // Skip over cells spanned from above (like the one we are splitting!)
     if (cell2 && startRowIndex2 == rowBelowIndex)
     {
       if (insertAfter)
       {
         // New cell isn't first in row,
         // so stop after we find the cell just before new cell's column
         if ((startColIndex2 + actualColSpan2) == startColIndex)
           break;
         // If cell found is AFTER desired new cell colum,
         //  we have multiple cells with rowspan > 1 that
         //  prevented us from finding a cell to insert after...
         if (startColIndex2 > startColIndex)
         {
           // ... so instead insert before the cell we found
           insertAfter = false;
           break;
         }
       }
       else
       {
         break; // Inserting before, so stop at first cell in row we want to insert into
       }
       lastCellFound = cell2;
     }
     // Skip to next available cellmap location
     colIndex += std::max(actualColSpan2, 1);
     // Done when past end of total number of columns
     if (colIndex > colCount)
         break;
   } while(true);
   if (!cell2 && lastCellFound)
   {
     // Edge case where we didn't find a cell to insert after
     //  or before because column(s) before desired column
     //  and all columns after it are spanned from above.
     //  We can insert after the last cell we found
     cell2 = lastCellFound;
     insertAfter = true; // Should always be true, but let's be sure
   }
   // Reduce rowspan of cell to split
   res = SetRowSpan(cell, aRowSpanAbove);
   NS_ENSURE_SUCCESS(res, res);
   // Insert new cell after using the remaining span
   //  and always get the new cell so we can copy the background color;
   nsCOMPtr<nsIDOMElement> newCell;
   res = InsertCell(cell2, aRowSpanBelow, actualColSpan, insertAfter, false, getter_AddRefs(newCell));
   NS_ENSURE_SUCCESS(res, res);
   if (newCell)
   {
     if (aNewCell)
     {
       *aNewCell = newCell.get();
       NS_ADDREF(*aNewCell);
     }
     res = CopyCellBackgroundColor(newCell, cell2);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SwitchTableCellHeaderType(nsIDOMElement *aSourceCell, nsIDOMElement **aNewCell)
 {
   NS_ENSURE_TRUE(aSourceCell, NS_ERROR_NULL_POINTER);
   nsAutoEditBatch beginBatching(this);
   // Prevent auto insertion of BR in new cell created by ReplaceContainer
   nsAutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
   nsCOMPtr<nsIDOMNode> newNode;
   // Save current selection to restore when done
   // This is needed so ReplaceContainer can monitor selection
   //  when replacing nodes
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   nsAutoSelectionReset selectionResetter(selection, this);
   // Set to the opposite of current type
   nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(aSourceCell);
   nsString newCellType( (atom == nsEditProperty::td) ? NS_LITERAL_STRING("th") : NS_LITERAL_STRING("td"));
   // This creates new node, moves children, copies attributes (true)
   //   and manages the selection!
   nsresult res = ReplaceContainer(aSourceCell, address_of(newNode),
                                   newCellType, nullptr, nullptr, true);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(newNode, NS_ERROR_FAILURE);
   // Return the new cell
   if (aNewCell)
   {
     nsCOMPtr<nsIDOMElement> newElement = do_QueryInterface(newNode);
     *aNewCell = newElement.get();
     NS_ADDREF(*aNewCell);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::JoinTableCells(bool aMergeNonContiguousContents)
 {
   nsCOMPtr<nsIDOMElement> table;
   nsCOMPtr<nsIDOMElement> targetCell;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   nsCOMPtr<nsIDOMElement> cell2;
   int32_t startRowIndex2, startColIndex2, rowSpan2, colSpan2, actualRowSpan2, actualColSpan2;
   bool    isSelected2;
   // Get cell, table, etc. at selection anchor node
   nsresult res = GetCellContext(nullptr,
                                 getter_AddRefs(table),
                                 getter_AddRefs(targetCell),
                                 nullptr, nullptr,
                                 &startRowIndex, &startColIndex);
   NS_ENSURE_SUCCESS(res, res);
   if(!table || !targetCell) return NS_EDITOR_ELEMENT_NOT_FOUND;
   nsAutoEditBatch beginBatching(this);
   //Don't let Rules System change the selection
   nsAutoTxnsConserveSelection dontChangeSelection(this);
   // Note: We dont' use nsSetSelectionAfterTableEdit here so the selection
   //  is retained after joining. This leaves the target cell selected
   //  as well as the "non-contiguous" cells, so user can see what happened.
   nsCOMPtr<nsIDOMElement> firstCell;
   int32_t firstRowIndex, firstColIndex;
   res = GetFirstSelectedCellInTable(&firstRowIndex, &firstColIndex, getter_AddRefs(firstCell));
   NS_ENSURE_SUCCESS(res, res);
   bool joinSelectedCells = false;
   if (firstCell)
   {
     nsCOMPtr<nsIDOMElement> secondCell;
     res = GetNextSelectedCell(nullptr, getter_AddRefs(secondCell));
     NS_ENSURE_SUCCESS(res, res);
     // If only one cell is selected, join with cell to the right
     joinSelectedCells = (secondCell != nullptr);
   }
   if (joinSelectedCells)
   {
     // We have selected cells: Join just contiguous cells
     //  and just merge contents if not contiguous
     int32_t rowCount, colCount;
     res = GetTableSize(table, &rowCount, &colCount);
     NS_ENSURE_SUCCESS(res, res);
     // Get spans for cell we will merge into
     int32_t firstRowSpan, firstColSpan;
     res = GetCellSpansAt( table, firstRowIndex, firstColIndex, firstRowSpan, firstColSpan);
     NS_ENSURE_SUCCESS(res, res);
     // This defines the last indexes along the "edges"
     //  of the contiguous block of cells, telling us
     //  that we can join adjacent cells to the block
     // Start with same as the first values,
     //  then expand as we find adjacent selected cells
     int32_t lastRowIndex = firstRowIndex;
     int32_t lastColIndex = firstColIndex;
     int32_t rowIndex, colIndex;
     // First pass: Determine boundaries of contiguous rectangular block
     //  that we will join into one cell,
     //  favoring adjacent cells in the same row
     for (rowIndex = firstRowIndex; rowIndex <= lastRowIndex; rowIndex++)
     {
       int32_t currentRowCount = rowCount;
       // Be sure each row doesn't have rowspan errors
       res = FixBadRowSpan(table, rowIndex, rowCount);
       NS_ENSURE_SUCCESS(res, res);
       // Adjust rowcount by number of rows we removed
       lastRowIndex -= (currentRowCount-rowCount);
       bool cellFoundInRow = false;
       bool lastRowIsSet = false;
       int32_t lastColInRow = 0;
       int32_t firstColInRow = firstColIndex;
       for (colIndex = firstColIndex; colIndex < colCount; colIndex += std::max(actualColSpan2, 1))
       {
         res = GetCellDataAt(table, rowIndex, colIndex, getter_AddRefs(cell2),
                             &startRowIndex2, &startColIndex2,
                             &rowSpan2, &colSpan2,
                             &actualRowSpan2, &actualColSpan2, &isSelected2);
         NS_ENSURE_SUCCESS(res, res);
         if (isSelected2)
         {
           if (!cellFoundInRow)
             // We've just found the first selected cell in this row
             firstColInRow = colIndex;
           if (rowIndex > firstRowIndex && firstColInRow != firstColIndex)
           {
             // We're in at least the second row,
             // but left boundary is "ragged" (not the same as 1st row's start)
             //Let's just end block on previous row
             // and keep previous lastColIndex
             //TODO: We could try to find the Maximum firstColInRow
             //      so our block can still extend down more rows?
             lastRowIndex = std::max(0,rowIndex - 1);
             lastRowIsSet = true;
             break;
           }
           // Save max selected column in this row, including extra colspan
           lastColInRow = colIndex + (actualColSpan2-1);
           cellFoundInRow = true;
         }
         else if (cellFoundInRow)
         {
           // No cell or not selected, but at least one cell in row was found
           if (rowIndex > (firstRowIndex+1) && colIndex <= lastColIndex)
           {
             // Cell is in a column less than current right border in
             //  the third or higher selected row, so stop block at the previous row
             lastRowIndex = std::max(0,rowIndex - 1);
             lastRowIsSet = true;
           }
           // We're done with this row
           break;
         }
       } // End of column loop
       // Done with this row
       if (cellFoundInRow)
       {
         if (rowIndex == firstRowIndex)
         {
           // First row always initializes the right boundary
           lastColIndex = lastColInRow;
         }
         // If we didn't determine last row above...
         if (!lastRowIsSet)
         {
           if (colIndex < lastColIndex)
           {
             // (don't think we ever get here?)
             // Cell is in a column less than current right boundary,
             //  so stop block at the previous row
             lastRowIndex = std::max(0,rowIndex - 1);
           }
           else
           {
             // Go on to examine next row
             lastRowIndex = rowIndex+1;
           }
         }
         // Use the minimum col we found so far for right boundary
         lastColIndex = std::min(lastColIndex, lastColInRow);
       }
       else
       {
         // No selected cells in this row -- stop at row above
         //  and leave last column at its previous value
         lastRowIndex = std::max(0,rowIndex - 1);
       }
     }
     // The list of cells we will delete after joining
     nsTArray<nsCOMPtr<nsIDOMElement> > deleteList;
     // 2nd pass: Do the joining and merging
     for (rowIndex = 0; rowIndex < rowCount; rowIndex++)
     {
       for (colIndex = 0; colIndex < colCount; colIndex += std::max(actualColSpan2, 1))
       {
         res = GetCellDataAt(table, rowIndex, colIndex, getter_AddRefs(cell2),
                             &startRowIndex2, &startColIndex2,
                             &rowSpan2, &colSpan2,
                             &actualRowSpan2, &actualColSpan2, &isSelected2);
         NS_ENSURE_SUCCESS(res, res);
         // If this is 0, we are past last cell in row, so exit the loop
         if (actualColSpan2 == 0)
           break;
         // Merge only selected cells (skip cell we're merging into, of course)
         if (isSelected2 && cell2 != firstCell)
         {
           if (rowIndex >= firstRowIndex && rowIndex <= lastRowIndex &&
               colIndex >= firstColIndex && colIndex <= lastColIndex)
           {
             // We are within the join region
             // Problem: It is very tricky to delete cells as we merge,
             //  since that will upset the cellmap
             //  Instead, build a list of cells to delete and do it later
             NS_ASSERTION(startRowIndex2 == rowIndex, "JoinTableCells: StartRowIndex is in row above");
             if (actualColSpan2 > 1)
             {
               //Check if cell "hangs" off the boundary because of colspan > 1
               //  Use split methods to chop off excess
               int32_t extraColSpan = (startColIndex2 + actualColSpan2) - (lastColIndex+1);
               if ( extraColSpan > 0)
               {
                 res = SplitCellIntoColumns(table, startRowIndex2, startColIndex2,
                                            actualColSpan2-extraColSpan, extraColSpan, nullptr);
                 NS_ENSURE_SUCCESS(res, res);
               }
             }
             res = MergeCells(firstCell, cell2, false);
             NS_ENSURE_SUCCESS(res, res);
             // Add cell to list to delete
             deleteList.AppendElement(cell2.get());
           }
           else if (aMergeNonContiguousContents)
           {
             // Cell is outside join region -- just merge the contents
             res = MergeCells(firstCell, cell2, false);
             NS_ENSURE_SUCCESS(res, res);
           }
         }
       }
     }
     // All cell contents are merged. Delete the empty cells we accumulated
     // Prevent rules testing until we're done
     nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
     for (uint32_t i = 0, n = deleteList.Length(); i < n; i++)
     {
       nsIDOMElement *elementPtr = deleteList[i];
       if (elementPtr)
       {
         nsCOMPtr<nsIDOMNode> node = do_QueryInterface(elementPtr);
         res = DeleteNode(node);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     // Cleanup selection: remove ranges where cells were deleted
     nsCOMPtr<nsISelection> selection;
     res = GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
     int32_t rangeCount;
     res = selection->GetRangeCount(&rangeCount);
     NS_ENSURE_SUCCESS(res, res);
     nsCOMPtr<nsIDOMRange> range;
     int32_t i;
     for (i = 0; i < rangeCount; i++)
     {
       res = selection->GetRangeAt(i, getter_AddRefs(range));
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
       nsCOMPtr<nsIDOMElement> deletedCell;
       res = GetCellFromRange(range, getter_AddRefs(deletedCell));
       if (!deletedCell)
       {
         selection->RemoveRange(range);
         rangeCount--;
         i--;
       }
     }
     // Set spans for the cell everthing merged into
     res = SetRowSpan(firstCell, lastRowIndex-firstRowIndex+1);
     NS_ENSURE_SUCCESS(res, res);
     res = SetColSpan(firstCell, lastColIndex-firstColIndex+1);
     NS_ENSURE_SUCCESS(res, res);
     // Fixup disturbances in table layout
     NormalizeTable(table);
   }
   else
   {
     // Joining with cell to the right -- get rowspan and colspan data of target cell
     res = GetCellDataAt(table, startRowIndex, startColIndex, getter_AddRefs(targetCell),
                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(targetCell, NS_ERROR_NULL_POINTER);
     // Get data for cell to the right
     res = GetCellDataAt(table, startRowIndex, startColIndex+actualColSpan, getter_AddRefs(cell2),
                         &startRowIndex2, &startColIndex2, &rowSpan2, &colSpan2,
                         &actualRowSpan2, &actualColSpan2, &isSelected2);
     NS_ENSURE_SUCCESS(res, res);
     if(!cell2) return NS_OK; // Don't fail if there's no cell
     // sanity check
     NS_ASSERTION((startRowIndex >= startRowIndex2),"JoinCells: startRowIndex < startRowIndex2");
     // Figure out span of merged cell starting from target's starting row
     // to handle case of merged cell starting in a row above
     int32_t spanAboveMergedCell = startRowIndex - startRowIndex2;
     int32_t effectiveRowSpan2 = actualRowSpan2 - spanAboveMergedCell;
     if (effectiveRowSpan2 > actualRowSpan)
     {
       // Cell to the right spans into row below target
       // Split off portion below target cell's bottom-most row
       res = SplitCellIntoRows(table, startRowIndex2, startColIndex2,
                               spanAboveMergedCell+actualRowSpan,
                               effectiveRowSpan2-actualRowSpan, nullptr);
       NS_ENSURE_SUCCESS(res, res);
     }
     // Move contents from cell to the right
     // Delete the cell now only if it starts in the same row
     //   and has enough row "height"
     res = MergeCells(targetCell, cell2,
                      (startRowIndex2 == startRowIndex) &&
                      (effectiveRowSpan2 >= actualRowSpan));
     NS_ENSURE_SUCCESS(res, res);
     if (effectiveRowSpan2 < actualRowSpan)
     {
       // Merged cell is "shorter"
       // (there are cells(s) below it that are row-spanned by target cell)
       // We could try splitting those cells, but that's REAL messy,
       //  so the safest thing to do is NOT really join the cells
       return NS_OK;
     }
     if( spanAboveMergedCell > 0 )
     {
       // Cell we merged started in a row above the target cell
       // Reduce rowspan to give room where target cell will extend its colspan
       res = SetRowSpan(cell2, spanAboveMergedCell);
       NS_ENSURE_SUCCESS(res, res);
     }
     // Reset target cell's colspan to encompass cell to the right
     res = SetColSpan(targetCell, actualColSpan+actualColSpan2);
     NS_ENSURE_SUCCESS(res, res);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::MergeCells(nsCOMPtr<nsIDOMElement> aTargetCell,
                          nsCOMPtr<nsIDOMElement> aCellToMerge,
                          bool aDeleteCellToMerge)
 {
   nsCOMPtr<dom::Element> targetCell = do_QueryInterface(aTargetCell);
   nsCOMPtr<dom::Element> cellToMerge = do_QueryInterface(aCellToMerge);
   NS_ENSURE_TRUE(targetCell && cellToMerge, NS_ERROR_NULL_POINTER);
   // Prevent rules testing until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
   // Don't need to merge if cell is empty
   if (!IsEmptyCell(cellToMerge)) {
     // Get index of last child in target cell
     // If we fail or don't have children,
     //  we insert at index 0
     int32_t insertIndex = 0;
     // Start inserting just after last child
     uint32_t len = targetCell->GetChildCount();
     if (len == 1 && IsEmptyCell(targetCell)) {
       // Delete the empty node
       nsIContent* cellChild = targetCell->GetFirstChild();
       nsresult res = DeleteNode(cellChild->AsDOMNode());
       NS_ENSURE_SUCCESS(res, res);
       insertIndex = 0;
     } else {
       insertIndex = (int32_t)len;
     }
     // Move the contents
     while (cellToMerge->HasChildren()) {
       nsCOMPtr<nsIDOMNode> cellChild = cellToMerge->GetLastChild()->AsDOMNode();
       nsresult res = DeleteNode(cellChild);
       NS_ENSURE_SUCCESS(res, res);
       res = InsertNode(cellChild, aTargetCell, insertIndex);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   // Delete cells whose contents were moved
   if (aDeleteCellToMerge)
     return DeleteNode(aCellToMerge);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::FixBadRowSpan(nsIDOMElement *aTable, int32_t aRowIndex, int32_t& aNewRowCount)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
   int32_t rowCount, colCount;
   nsresult res = GetTableSize(aTable, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIDOMElement>cell;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   int32_t minRowSpan = -1;
   int32_t colIndex;
   for( colIndex = 0; colIndex < colCount; colIndex += std::max(actualColSpan, 1))
   {
     res = GetCellDataAt(aTable, aRowIndex, colIndex, getter_AddRefs(cell),
                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     // NOTE: This is a *real* failure.
     // GetCellDataAt passes if cell is missing from cellmap
     if(NS_FAILED(res)) return res;
     if (!cell) break;
     if(rowSpan > 0 &&
        startRowIndex == aRowIndex &&
        (rowSpan < minRowSpan || minRowSpan == -1))
     {
       minRowSpan = rowSpan;
     }
     NS_ASSERTION((actualColSpan > 0),"ActualColSpan = 0 in FixBadRowSpan");
   }
   if(minRowSpan > 1)
   {
     // The amount to reduce everyone's rowspan
     // so at least one cell has rowspan = 1
     int32_t rowsReduced = minRowSpan - 1;
     for(colIndex = 0; colIndex < colCount; colIndex += std::max(actualColSpan, 1))
     {
       res = GetCellDataAt(aTable, aRowIndex, colIndex, getter_AddRefs(cell),
                           &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                           &actualRowSpan, &actualColSpan, &isSelected);
       if(NS_FAILED(res)) return res;
       // Fixup rowspans only for cells starting in current row
       if(cell && rowSpan > 0 &&
          startRowIndex == aRowIndex &&
          startColIndex ==  colIndex )
       {
         res = SetRowSpan(cell, rowSpan-rowsReduced);
         if(NS_FAILED(res)) return res;
       }
       NS_ASSERTION((actualColSpan > 0),"ActualColSpan = 0 in FixBadRowSpan");
     }
   }
   return GetTableSize(aTable, &aNewRowCount, &colCount);
 }
 NS_IMETHODIMP
 nsHTMLEditor::FixBadColSpan(nsIDOMElement *aTable, int32_t aColIndex, int32_t& aNewColCount)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
   int32_t rowCount, colCount;
   nsresult res = GetTableSize(aTable, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   int32_t minColSpan = -1;
   int32_t rowIndex;
   for( rowIndex = 0; rowIndex < rowCount; rowIndex += std::max(actualRowSpan, 1))
   {
     res = GetCellDataAt(aTable, rowIndex, aColIndex, getter_AddRefs(cell),
                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     // NOTE: This is a *real* failure.
     // GetCellDataAt passes if cell is missing from cellmap
     if(NS_FAILED(res)) return res;
     if (!cell) break;
     if(colSpan > 0 &&
        startColIndex == aColIndex &&
        (colSpan < minColSpan || minColSpan == -1))
     {
       minColSpan = colSpan;
     }
     NS_ASSERTION((actualRowSpan > 0),"ActualRowSpan = 0 in FixBadColSpan");
   }
   if(minColSpan > 1)
   {
     // The amount to reduce everyone's colspan
     // so at least one cell has colspan = 1
     int32_t colsReduced = minColSpan - 1;
     for(rowIndex = 0; rowIndex < rowCount; rowIndex += std::max(actualRowSpan, 1))
     {
       res = GetCellDataAt(aTable, rowIndex, aColIndex, getter_AddRefs(cell),
                           &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                           &actualRowSpan, &actualColSpan, &isSelected);
       if(NS_FAILED(res)) return res;
       // Fixup colspans only for cells starting in current column
       if(cell && colSpan > 0 &&
          startColIndex == aColIndex &&
          startRowIndex ==  rowIndex )
       {
         res = SetColSpan(cell, colSpan-colsReduced);
         if(NS_FAILED(res)) return res;
       }
       NS_ASSERTION((actualRowSpan > 0),"ActualRowSpan = 0 in FixBadColSpan");
     }
   }
   return GetTableSize(aTable, &rowCount, &aNewColCount);
 }
 NS_IMETHODIMP
 nsHTMLEditor::NormalizeTable(nsIDOMElement *aTable)
 {
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   nsCOMPtr<nsIDOMElement> table;
   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"),
                                              aTable, getter_AddRefs(table));
   NS_ENSURE_SUCCESS(res, res);
   // Don't fail if we didn't find a table
   NS_ENSURE_TRUE(table, NS_OK);
   int32_t rowCount, colCount, rowIndex, colIndex;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   // Save current selection
   nsAutoSelectionReset selectionResetter(selection, this);
   nsAutoEditBatch beginBatching(this);
   // Prevent auto insertion of BR in new cell until we're done
   nsAutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   // Scan all cells in each row to detect bad rowspan values
   for(rowIndex = 0; rowIndex < rowCount; rowIndex++)
   {
     res = FixBadRowSpan(table, rowIndex, rowCount);
     NS_ENSURE_SUCCESS(res, res);
   }
   // and same for colspans
   for(colIndex = 0; colIndex < colCount; colIndex++)
   {
     res = FixBadColSpan(table, colIndex, colCount);
     NS_ENSURE_SUCCESS(res, res);
   }
   // Fill in missing cellmap locations with empty cells
   for(rowIndex = 0; rowIndex < rowCount; rowIndex++)
   {
     nsCOMPtr<nsIDOMElement> previousCellInRow;
     for(colIndex = 0; colIndex < colCount; colIndex++)
     {
       res = GetCellDataAt(table, rowIndex, colIndex, getter_AddRefs(cell),
                           &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                           &actualRowSpan, &actualColSpan, &isSelected);
       // NOTE: This is a *real* failure.
       // GetCellDataAt passes if cell is missing from cellmap
       if(NS_FAILED(res)) return res;
       if (!cell)
       {
         //We are missing a cell at a cellmap location
 #ifdef DEBUG
         printf("NormalizeTable found missing cell at row=%d, col=%d\n", rowIndex, colIndex);
 #endif
         // Add a cell after the previous Cell in the current row
         if(previousCellInRow)
         {
           // Insert a new cell after (true), and return the new cell to us
           res = InsertCell(previousCellInRow, 1, 1, true, false, getter_AddRefs(cell));
           NS_ENSURE_SUCCESS(res, res);
           // Set this so we use returned new "cell" to set previousCellInRow below
           if(cell)
             startRowIndex = rowIndex;
         } else {
           // We don't have any cells in this row -- We are really messed up!
 #ifdef DEBUG
           printf("NormalizeTable found no cells in row=%d, col=%d\n", rowIndex, colIndex);
 #endif
           return NS_ERROR_FAILURE;
         }
       }
       // Save the last cell found in the same row we are scanning
       if(startRowIndex == rowIndex)
       {
         previousCellInRow = cell;
       }
     }
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetCellIndexes(nsIDOMElement *aCell,
                              int32_t *aRowIndex, int32_t *aColIndex)
 {
   NS_ENSURE_ARG_POINTER(aRowIndex);
   *aColIndex=0; // initialize out params
   NS_ENSURE_ARG_POINTER(aColIndex);
   *aRowIndex=0;
   nsresult res=NS_ERROR_NOT_INITIALIZED;
   if (!aCell)
   {
     // Get the selected cell or the cell enclosing the selection anchor
     nsCOMPtr<nsIDOMElement> cell;
     res = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr, getter_AddRefs(cell));
     if (NS_SUCCEEDED(res) && cell)
       aCell = cell;
     else
       return NS_ERROR_FAILURE;
   }
   NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsIContent> nodeAsContent( do_QueryInterface(aCell) );
   NS_ENSURE_TRUE(nodeAsContent, NS_ERROR_FAILURE);
   // frames are not ref counted, so don't use an nsCOMPtr
   nsIFrame *layoutObject = nodeAsContent->GetPrimaryFrame();
   NS_ENSURE_TRUE(layoutObject, NS_ERROR_FAILURE);
   nsITableCellLayout *cellLayoutObject = do_QueryFrame(layoutObject);
   NS_ENSURE_TRUE(cellLayoutObject, NS_ERROR_FAILURE);
   return cellLayoutObject->GetCellIndexes(*aRowIndex, *aColIndex);
 }
 nsTableOuterFrame*
 nsHTMLEditor::GetTableFrame(nsIDOMElement* aTable)
 {
   NS_ENSURE_TRUE(aTable, nullptr);
   nsCOMPtr<nsIContent> nodeAsContent( do_QueryInterface(aTable) );
   NS_ENSURE_TRUE(nodeAsContent, nullptr);
   return do_QueryFrame(nodeAsContent->GetPrimaryFrame());
 }
 //Return actual number of cells (a cell with colspan > 1 counts as just 1)
 int32_t nsHTMLEditor::GetNumberOfCellsInRow(nsIDOMElement* aTable, int32_t rowIndex)
 {
   int32_t cellCount = 0;
   nsCOMPtr<nsIDOMElement> cell;
   int32_t colIndex = 0;
   nsresult res;
   do {
     int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
     bool    isSelected;
     res = GetCellDataAt(aTable, rowIndex, colIndex, getter_AddRefs(cell),
                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
                         &actualRowSpan, &actualColSpan, &isSelected);
     NS_ENSURE_SUCCESS(res, 0);
     if (cell)
     {
       // Only count cells that start in row we are working with
       if (startRowIndex == rowIndex)
         cellCount++;
       //Next possible location for a cell
       colIndex += actualColSpan;
     }
     else
       colIndex++;
   } while (cell);
   return cellCount;
 }
 /* Not scriptable: For convenience in C++
    Use GetTableRowCount and GetTableColumnCount from JavaScript
 */
 NS_IMETHODIMP
 nsHTMLEditor::GetTableSize(nsIDOMElement *aTable,
                            int32_t* aRowCount, int32_t* aColCount)
 {
   NS_ENSURE_ARG_POINTER(aRowCount);
   NS_ENSURE_ARG_POINTER(aColCount);
   nsresult res;
   *aRowCount = 0;
   *aColCount = 0;
   nsCOMPtr<nsIDOMElement> table;
   // Get the selected talbe or the table enclosing the selection anchor
   res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), aTable, getter_AddRefs(table));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
   nsTableOuterFrame* tableFrame = GetTableFrame(table.get());
   NS_ENSURE_TRUE(tableFrame, NS_ERROR_FAILURE);
   *aRowCount = tableFrame->GetRowCount();
   *aColCount = tableFrame->GetColCount();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetCellDataAt(nsIDOMElement* aTable, int32_t aRowIndex,
                             int32_t aColIndex, nsIDOMElement **aCell,
                             int32_t* aStartRowIndex, int32_t* aStartColIndex,
                             int32_t* aRowSpan, int32_t* aColSpan,
                             int32_t* aActualRowSpan, int32_t* aActualColSpan,
                             bool* aIsSelected)
 {
   NS_ENSURE_ARG_POINTER(aStartRowIndex);
   NS_ENSURE_ARG_POINTER(aStartColIndex);
   NS_ENSURE_ARG_POINTER(aRowSpan);
   NS_ENSURE_ARG_POINTER(aColSpan);
   NS_ENSURE_ARG_POINTER(aActualRowSpan);
   NS_ENSURE_ARG_POINTER(aActualColSpan);
   NS_ENSURE_ARG_POINTER(aIsSelected);
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   nsresult res=NS_ERROR_FAILURE;
   *aStartRowIndex = 0;
   *aStartColIndex = 0;
   *aRowSpan = 0;
   *aColSpan = 0;
   *aActualRowSpan = 0;
   *aActualColSpan = 0;
   *aIsSelected = false;
   *aCell = nullptr;
   if (!aTable)
   {
     // Get the selected table or the table enclosing the selection anchor
     nsCOMPtr<nsIDOMElement> table;
     res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), nullptr, getter_AddRefs(table));
     NS_ENSURE_SUCCESS(res, res);
     if (table)
       aTable = table;
     else
       return NS_ERROR_FAILURE;
   }
   nsTableOuterFrame* tableFrame = GetTableFrame(aTable);
   NS_ENSURE_TRUE(tableFrame, NS_ERROR_FAILURE);
   nsTableCellFrame* cellFrame =
     tableFrame->GetCellFrameAt(aRowIndex, aColIndex);
   if (!cellFrame)
     return NS_ERROR_FAILURE;
   *aIsSelected = cellFrame->IsSelected();
   cellFrame->GetRowIndex(*aStartRowIndex);
   cellFrame->GetColIndex(*aStartColIndex);
   *aRowSpan = cellFrame->GetRowSpan();
   *aColSpan = cellFrame->GetColSpan();
   *aActualRowSpan = tableFrame->GetEffectiveRowSpanAt(aRowIndex, aColIndex);
   *aActualColSpan = tableFrame->GetEffectiveColSpanAt(aRowIndex, aColIndex);
   nsCOMPtr<nsIDOMElement> domCell = do_QueryInterface(cellFrame->GetContent());
   domCell.forget(aCell);
   return NS_OK;
 }
 // When all you want is the cell
 NS_IMETHODIMP
 nsHTMLEditor::GetCellAt(nsIDOMElement* aTable, int32_t aRowIndex, int32_t aColIndex, nsIDOMElement **aCell)
 {
   NS_ENSURE_ARG_POINTER(aCell);
   *aCell = nullptr;
   if (!aTable)
   {
     // Get the selected table or the table enclosing the selection anchor
     nsCOMPtr<nsIDOMElement> table;
     nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), nullptr, getter_AddRefs(table));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
     aTable = table;
   }
   nsTableOuterFrame* tableFrame = GetTableFrame(aTable);
   if (!tableFrame)
     return NS_ERROR_FAILURE;
   nsCOMPtr<nsIDOMElement> domCell =
     do_QueryInterface(tableFrame->GetCellAt(aRowIndex, aColIndex));
   domCell.forget(aCell);
   return NS_OK;
 }
 // When all you want are the rowspan and colspan (not exposed in nsITableEditor)
 NS_IMETHODIMP
 nsHTMLEditor::GetCellSpansAt(nsIDOMElement* aTable, int32_t aRowIndex, int32_t aColIndex,
                              int32_t& aActualRowSpan, int32_t& aActualColSpan)
 {
   nsTableOuterFrame* tableFrame = GetTableFrame(aTable);
   if (!tableFrame)
     return NS_ERROR_FAILURE;
   aActualRowSpan = tableFrame->GetEffectiveRowSpanAt(aRowIndex, aColIndex);
   aActualColSpan = tableFrame->GetEffectiveColSpanAt(aRowIndex, aColIndex);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetCellContext(nsISelection **aSelection,
                              nsIDOMElement   **aTable,
                              nsIDOMElement   **aCell,
                              nsIDOMNode      **aCellParent, int32_t *aCellOffset,
                              int32_t *aRowIndex, int32_t *aColIndex)
 {
   // Initialize return pointers
   if (aSelection) *aSelection = nullptr;
   if (aTable) *aTable = nullptr;
   if (aCell) *aCell = nullptr;
   if (aCellParent) *aCellParent = nullptr;
   if (aCellOffset) *aCellOffset = 0;
   if (aRowIndex) *aRowIndex = 0;
   if (aColIndex) *aColIndex = 0;
   nsCOMPtr <nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   if (aSelection)
   {
     *aSelection = selection.get();
     NS_ADDREF(*aSelection);
   }
   nsCOMPtr <nsIDOMElement> table;
   nsCOMPtr <nsIDOMElement> cell;
   // Caller may supply the cell...
   if (aCell && *aCell)
     cell = *aCell;
   // ...but if not supplied,
   //    get cell if it's the child of selection anchor node,
   //    or get the enclosing by a cell
   if (!cell)
   {
     // Find a selected or enclosing table element
     nsCOMPtr<nsIDOMElement> cellOrTableElement;
     int32_t selectedCount;
     nsAutoString tagName;
     res = GetSelectedOrParentTableElement(tagName, &selectedCount,
                                           getter_AddRefs(cellOrTableElement));
     NS_ENSURE_SUCCESS(res, res);
     if (tagName.EqualsLiteral("table"))
     {
       // We have a selected table, not a cell
       if (aTable)
       {
         *aTable = cellOrTableElement.get();
         NS_ADDREF(*aTable);
       }
       return NS_OK;
     }
     if (!tagName.EqualsLiteral("td"))
       return NS_EDITOR_ELEMENT_NOT_FOUND;
     // We found a cell
     cell = cellOrTableElement;
   }
   if (aCell)
   {
     *aCell = cell.get();
     NS_ADDREF(*aCell);
   }
   // Get containing table
   res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), cell, getter_AddRefs(table));
   NS_ENSURE_SUCCESS(res, res);
   // Cell must be in a table, so fail if not found
   NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
   if (aTable)
   {
     *aTable = table.get();
     NS_ADDREF(*aTable);
   }
   // Get the rest of the related data only if requested
   if (aRowIndex || aColIndex)
   {
     int32_t rowIndex, colIndex;
     // Get current cell location so we can put caret back there when done
     res = GetCellIndexes(cell, &rowIndex, &colIndex);
     if(NS_FAILED(res)) return res;
     if (aRowIndex) *aRowIndex = rowIndex;
     if (aColIndex) *aColIndex = colIndex;
   }
   if (aCellParent)
   {
     nsCOMPtr <nsIDOMNode> cellParent;
     // Get the immediate parent of the cell
     res = cell->GetParentNode(getter_AddRefs(cellParent));
     NS_ENSURE_SUCCESS(res, res);
     // Cell has to have a parent, so fail if not found
     NS_ENSURE_TRUE(cellParent, NS_ERROR_FAILURE);
     *aCellParent = cellParent.get();
     NS_ADDREF(*aCellParent);
     if (aCellOffset) {
       *aCellOffset = GetChildOffset(cell, cellParent);
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditor::GetCellFromRange(nsIDOMRange *aRange, nsIDOMElement **aCell)
 {
   // Note: this might return a node that is outside of the range.
   // Use carefully.
   NS_ENSURE_TRUE(aRange && aCell, NS_ERROR_NULL_POINTER);
   *aCell = nullptr;
   nsCOMPtr<nsIDOMNode> startParent;
   nsresult res = aRange->GetStartContainer(getter_AddRefs(startParent));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
   int32_t startOffset;
   res = aRange->GetStartOffset(&startOffset);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIDOMNode> childNode = GetChildAt(startParent, startOffset);
   // This means selection is probably at a text node (or end of doc?)
   if (!childNode) {
     return NS_ERROR_FAILURE;
   }
   nsCOMPtr<nsIDOMNode> endParent;
   res = aRange->GetEndContainer(getter_AddRefs(endParent));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
   int32_t endOffset;
   res = aRange->GetEndOffset(&endOffset);
   NS_ENSURE_SUCCESS(res, res);
   // If a cell is deleted, the range is collapse
   //   (startOffset == endOffset)
   //   so tell caller the cell wasn't found
   if (startParent == endParent &&
       endOffset == startOffset+1 &&
       nsHTMLEditUtils::IsTableCell(childNode))
   {
     // Should we also test if frame is selected? (Use GetCellDataAt())
     // (Let's not for now -- more efficient)
     nsCOMPtr<nsIDOMElement> cellElement = do_QueryInterface(childNode);
     *aCell = cellElement.get();
     NS_ADDREF(*aCell);
     return NS_OK;
   }
   return NS_EDITOR_ELEMENT_NOT_FOUND;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetFirstSelectedCell(nsIDOMRange **aRange, nsIDOMElement **aCell)
 {
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   *aCell = nullptr;
   if (aRange) *aRange = nullptr;
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   nsCOMPtr<nsIDOMRange> range;
   res = selection->GetRangeAt(0, getter_AddRefs(range));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
   mSelectedCellIndex = 0;
   res = GetCellFromRange(range, aCell);
   // Failure here probably means selection is in a text node,
   //  so there's no selected cell
   if (NS_FAILED(res)) {
     return NS_EDITOR_ELEMENT_NOT_FOUND;
   }
   // No cell means range was collapsed (cell was deleted)
   if (!*aCell) {
     return NS_EDITOR_ELEMENT_NOT_FOUND;
   }
   if (aRange)
   {
     *aRange = range.get();
     NS_ADDREF(*aRange);
   }
   // Setup for next cell
   mSelectedCellIndex = 1;
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetNextSelectedCell(nsIDOMRange **aRange, nsIDOMElement **aCell)
 {
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   *aCell = nullptr;
   if (aRange) *aRange = nullptr;
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   int32_t rangeCount;
   res = selection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   // Don't even try if index exceeds range count
   if (mSelectedCellIndex >= rangeCount)
     return NS_EDITOR_ELEMENT_NOT_FOUND;
   // Scan through ranges to find next valid selected cell
   nsCOMPtr<nsIDOMRange> range;
   for (; mSelectedCellIndex < rangeCount; mSelectedCellIndex++)
   {
     res = selection->GetRangeAt(mSelectedCellIndex, getter_AddRefs(range));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
     res = GetCellFromRange(range, aCell);
     // Failure here means the range doesn't contain a cell
     NS_ENSURE_SUCCESS(res, NS_EDITOR_ELEMENT_NOT_FOUND);
     // We found a selected cell
     if (*aCell) break;
 #ifdef DEBUG_cmanske
     else
       printf("GetNextSelectedCell: Collapsed range found\n");
 #endif
     // If we didn't find a cell, continue to next range in selection
   }
   // No cell means all remaining ranges were collapsed (cells were deleted)
   NS_ENSURE_TRUE(*aCell, NS_EDITOR_ELEMENT_NOT_FOUND);
   if (aRange)
   {
     *aRange = range.get();
     NS_ADDREF(*aRange);
   }
   // Setup for next cell
   mSelectedCellIndex++;
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetFirstSelectedCellInTable(int32_t *aRowIndex, int32_t *aColIndex, nsIDOMElement **aCell)
 {
   NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
   *aCell = nullptr;
   if (aRowIndex)
     *aRowIndex = 0;
   if (aColIndex)
     *aColIndex = 0;
   nsCOMPtr<nsIDOMElement> cell;
   nsresult res = GetFirstSelectedCell(nullptr, getter_AddRefs(cell));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(cell, NS_EDITOR_ELEMENT_NOT_FOUND);
   *aCell = cell.get();
   NS_ADDREF(*aCell);
   // Also return the row and/or column if requested
   if (aRowIndex || aColIndex)
   {
     int32_t startRowIndex, startColIndex;
     res = GetCellIndexes(cell, &startRowIndex, &startColIndex);
     if(NS_FAILED(res)) return res;
     if (aRowIndex)
       *aRowIndex = startRowIndex;
     if (aColIndex)
       *aColIndex = startColIndex;
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::SetSelectionAfterTableEdit(nsIDOMElement* aTable, int32_t aRow, int32_t aCol,
                                      int32_t aDirection, bool aSelected)
 {
   NS_ENSURE_TRUE(aTable, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsISelection>selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   if (!selection)
   {
 #ifdef DEBUG_cmanske
     printf("Selection not found after table manipulation!\n");
 #endif
     return NS_ERROR_FAILURE;
   }
   nsCOMPtr<nsIDOMElement> cell;
   bool done = false;
   do {
     res = GetCellAt(aTable, aRow, aCol, getter_AddRefs(cell));
     if (NS_SUCCEEDED(res))
     {
       if (cell)
       {
         if (aSelected)
         {
           // Reselect the cell
           return SelectElement(cell);
         }
         else
         {
           // Set the caret to deepest first child
           //   but don't go into nested tables
           // TODO: Should we really be placing the caret at the END
           //  of the cell content?
           return CollapseSelectionToDeepestNonTableFirstChild(selection, cell);
         }
       } else {
         // Setup index to find another cell in the
         //   direction requested, but move in
         //   other direction if already at beginning of row or column
         switch (aDirection)
         {
           case ePreviousColumn:
             if (aCol == 0)
             {
               if (aRow > 0)
                 aRow--;
               else
                 done = true;
             }
             else
               aCol--;
             break;
           case ePreviousRow:
             if (aRow == 0)
             {
               if (aCol > 0)
                 aCol--;
               else
                 done = true;
             }
             else
               aRow--;
             break;
           default:
             done = true;
         }
       }
     }
     else
       break;
   } while (!done);
   // We didn't find a cell
   // Set selection to just before the table
   nsCOMPtr<nsIDOMNode> tableParent;
   res = aTable->GetParentNode(getter_AddRefs(tableParent));
   if(NS_SUCCEEDED(res) && tableParent)
   {
     int32_t tableOffset = GetChildOffset(aTable, tableParent);
     return selection->Collapse(tableParent, tableOffset);
   }
   // Last resort: Set selection to start of doc
   // (it's very bad to not have a valid selection!)
   return SetSelectionAtDocumentStart(selection);
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetSelectedOrParentTableElement(nsAString& aTagName,
                                               int32_t *aSelectedCount,
                                               nsIDOMElement** aTableElement)
 {
   NS_ENSURE_ARG_POINTER(aTableElement);
   NS_ENSURE_ARG_POINTER(aSelectedCount);
   *aTableElement = nullptr;
   aTagName.Truncate();
   *aSelectedCount = 0;
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   // Try to get the first selected cell
   nsCOMPtr<nsIDOMElement> tableOrCellElement;
   res = GetFirstSelectedCell(nullptr, getter_AddRefs(tableOrCellElement));
   NS_ENSURE_SUCCESS(res, res);
   NS_NAMED_LITERAL_STRING(tdName, "td");
   if (tableOrCellElement)
   {
       // Each cell is in its own selection range,
       //  so count signals multiple-cell selection
       res = selection->GetRangeCount(aSelectedCount);
       NS_ENSURE_SUCCESS(res, res);
       aTagName = tdName;
   }
   else
   {
     nsCOMPtr<nsIDOMNode> anchorNode;
     res = selection->GetAnchorNode(getter_AddRefs(anchorNode));
     if(NS_FAILED(res)) return res;
     NS_ENSURE_TRUE(anchorNode, NS_ERROR_FAILURE);
     nsCOMPtr<nsIDOMNode> selectedNode;
     // Get child of anchor node, if exists
     bool hasChildren;
     anchorNode->HasChildNodes(&hasChildren);
     if (hasChildren)
     {
       int32_t anchorOffset;
       res = selection->GetAnchorOffset(&anchorOffset);
       NS_ENSURE_SUCCESS(res, res);
       selectedNode = GetChildAt(anchorNode, anchorOffset);
       if (!selectedNode)
       {
         selectedNode = anchorNode;
         // If anchor doesn't have a child, we can't be selecting a table element,
         //  so don't do the following:
       }
       else
       {
         nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(selectedNode);
         if (atom == nsEditProperty::td)
         {
           tableOrCellElement = do_QueryInterface(selectedNode);
           aTagName = tdName;
           // Each cell is in its own selection range,
           //  so count signals multiple-cell selection
           res = selection->GetRangeCount(aSelectedCount);
           NS_ENSURE_SUCCESS(res, res);
         }
         else if (atom == nsEditProperty::table)
         {
           tableOrCellElement = do_QueryInterface(selectedNode);
           aTagName.AssignLiteral("table");
           *aSelectedCount = 1;
         }
         else if (atom == nsEditProperty::tr)
         {
           tableOrCellElement = do_QueryInterface(selectedNode);
           aTagName.AssignLiteral("tr");
           *aSelectedCount = 1;
         }
       }
     }
     if (!tableOrCellElement)
     {
       // Didn't find a table element -- find a cell parent
       res = GetElementOrParentByTagName(tdName, anchorNode, getter_AddRefs(tableOrCellElement));
       if(NS_FAILED(res)) return res;
       if (tableOrCellElement)
         aTagName = tdName;
     }
   }
   if (tableOrCellElement)
   {
     *aTableElement = tableOrCellElement.get();
     NS_ADDREF(*aTableElement);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditor::GetSelectedCellsType(nsIDOMElement *aElement, uint32_t *aSelectionType)
 {
   NS_ENSURE_ARG_POINTER(aSelectionType);
   *aSelectionType = 0;
   // Be sure we have a table element
   //  (if aElement is null, this uses selection's anchor node)
   nsCOMPtr<nsIDOMElement> table;
   nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), aElement, getter_AddRefs(table));
   NS_ENSURE_SUCCESS(res, res);
   int32_t rowCount, colCount;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
   // Traverse all selected cells
   nsCOMPtr<nsIDOMElement> selectedCell;
   res = GetFirstSelectedCell(nullptr, getter_AddRefs(selectedCell));
   NS_ENSURE_SUCCESS(res, res);
   if (res == NS_EDITOR_ELEMENT_NOT_FOUND) return NS_OK;
   // We have at least one selected cell, so set return value
   *aSelectionType = nsISelectionPrivate::TABLESELECTION_CELL;
   // Store indexes of each row/col to avoid duplication of searches
   nsTArray<int32_t> indexArray;
   bool allCellsInRowAreSelected = false;
   bool allCellsInColAreSelected = false;
   while (NS_SUCCEEDED(res) && selectedCell)
   {
     // Get the cell's location in the cellmap
     int32_t startRowIndex, startColIndex;
     res = GetCellIndexes(selectedCell, &startRowIndex, &startColIndex);
     if(NS_FAILED(res)) return res;
     if (!indexArray.Contains(startColIndex))
     {
       indexArray.AppendElement(startColIndex);
       allCellsInRowAreSelected = AllCellsInRowSelected(table, startRowIndex, colCount);
       // We're done as soon as we fail for any row
       if (!allCellsInRowAreSelected) break;
     }
     res = GetNextSelectedCell(nullptr, getter_AddRefs(selectedCell));
   }
   if (allCellsInRowAreSelected)
   {
     *aSelectionType = nsISelectionPrivate::TABLESELECTION_ROW;
     return NS_OK;
   }
   // Test for columns
   // Empty the indexArray
   indexArray.Clear();
   // Start at first cell again
   res = GetFirstSelectedCell(nullptr, getter_AddRefs(selectedCell));
   while (NS_SUCCEEDED(res) && selectedCell)
   {
     // Get the cell's location in the cellmap
     int32_t startRowIndex, startColIndex;
     res = GetCellIndexes(selectedCell, &startRowIndex, &startColIndex);
     if(NS_FAILED(res)) return res;
     if (!indexArray.Contains(startRowIndex))
     {
       indexArray.AppendElement(startColIndex);
       allCellsInColAreSelected = AllCellsInColumnSelected(table, startColIndex, rowCount);
       // We're done as soon as we fail for any column
       if (!allCellsInRowAreSelected) break;
     }
     res = GetNextSelectedCell(nullptr, getter_AddRefs(selectedCell));
   }
   if (allCellsInColAreSelected)
     *aSelectionType = nsISelectionPrivate::TABLESELECTION_COLUMN;
   return NS_OK;
 }
 bool
 nsHTMLEditor::AllCellsInRowSelected(nsIDOMElement *aTable, int32_t aRowIndex, int32_t aNumberOfColumns)
 {
   NS_ENSURE_TRUE(aTable, false);
   int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   for( int32_t col = 0; col < aNumberOfColumns; col += std::max(actualColSpan, 1))
   {
     nsCOMPtr<nsIDOMElement> cell;
     nsresult res = GetCellDataAt(aTable, aRowIndex, col, getter_AddRefs(cell),
                                  &curStartRowIndex, &curStartColIndex,
                                  &rowSpan, &colSpan,
                                  &actualRowSpan, &actualColSpan, &isSelected);
     NS_ENSURE_SUCCESS(res, false);
     // If no cell, we may have a "ragged" right edge,
     //   so return TRUE only if we already found a cell in the row
     NS_ENSURE_TRUE(cell, (col > 0) ? true : false);
     // Return as soon as a non-selected cell is found
     NS_ENSURE_TRUE(isSelected, false);
     NS_ASSERTION((actualColSpan > 0),"ActualColSpan = 0 in AllCellsInRowSelected");
   }
   return true;
 }
 bool
 nsHTMLEditor::AllCellsInColumnSelected(nsIDOMElement *aTable, int32_t aColIndex, int32_t aNumberOfRows)
 {
   NS_ENSURE_TRUE(aTable, false);
   int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;
   for( int32_t row = 0; row < aNumberOfRows; row += std::max(actualRowSpan, 1))
   {
     nsCOMPtr<nsIDOMElement> cell;
     nsresult res = GetCellDataAt(aTable, row, aColIndex, getter_AddRefs(cell),
                                  &curStartRowIndex, &curStartColIndex,
                                  &rowSpan, &colSpan,
                                  &actualRowSpan, &actualColSpan, &isSelected);
     NS_ENSURE_SUCCESS(res, false);
     // If no cell, we must have a "ragged" right edge on the last column
     //   so return TRUE only if we already found a cell in the row
     NS_ENSURE_TRUE(cell, (row > 0) ? true : false);
     // Return as soon as a non-selected cell is found
     NS_ENSURE_TRUE(isSelected, false);
   }
   return true;
 }
 bool
 nsHTMLEditor::IsEmptyCell(dom::Element* aCell)
 {
   MOZ_ASSERT(aCell);
   // Check if target only contains empty text node or <br>
   nsCOMPtr<nsINode> cellChild = aCell->GetFirstChild();
   if (!cellChild) {
     return false;
   }
   nsCOMPtr<nsINode> nextChild = cellChild->GetNextSibling();
   if (nextChild) {
     return false;
   }
   // We insert a single break into a cell by default
   //   to have some place to locate a cursor -- it is dispensable
   if (cellChild->IsElement() && cellChild->AsElement()->IsHTML(nsGkAtoms::br)) {
     return true;
   }
   bool isEmpty;
   // Or check if no real content
   nsresult rv = IsEmptyNode(cellChild, &isEmpty, false, false);
   NS_ENSURE_SUCCESS(rv, false);
   return isEmpty;
 }

The Tor Browser / annotate

editor/libeditor/html/nsTableEditor.cpp@7e26c7da4463 (annotated)

editor/libeditor/html/nsTableEditor.cpp