зеркало из https://github.com/mozilla/gecko-dev.git
414 строки
12 KiB
C++
414 строки
12 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "nsVoidArray.h"
|
|
#include "nsCellMap.h"
|
|
#include "nsTableFrame.h"
|
|
#include "nsTableCellFrame.h"
|
|
|
|
#ifdef NS_DEBUG
|
|
static PRBool gsDebug = PR_FALSE;
|
|
#else
|
|
static const PRBool gsDebug = PR_FALSE;
|
|
#endif
|
|
|
|
nsCellMap::nsCellMap(int aRowCount, int aColCount)
|
|
: mRowCount(0),
|
|
mColCount(0),
|
|
mTotalRowCount(0)
|
|
{
|
|
mRows = nsnull;
|
|
mColFrames = nsnull;
|
|
mMinColSpans = nsnull;
|
|
Reset(aRowCount, aColCount);
|
|
}
|
|
|
|
nsCellMap::~nsCellMap()
|
|
{
|
|
if (nsnull!=mRows)
|
|
{
|
|
for (int i=mTotalRowCount-1; 0<=i; i--)
|
|
{
|
|
nsVoidArray *row = (nsVoidArray *)(mRows->ElementAt(i));
|
|
for (int j=mColCount-1; 0<=j ;j--)
|
|
{
|
|
CellData* data = (CellData *)(row->ElementAt(j));
|
|
if (data != nsnull)
|
|
{
|
|
delete data;
|
|
}
|
|
}
|
|
delete row;
|
|
}
|
|
delete mRows;
|
|
}
|
|
if (nsnull != mColFrames)
|
|
delete mColFrames;
|
|
// mMinColSpans may be null, it is only set for tables that need it
|
|
if (nsnull != mMinColSpans)
|
|
delete [] mMinColSpans;
|
|
mRows = nsnull;
|
|
mColFrames = nsnull;
|
|
mMinColSpans = nsnull;
|
|
};
|
|
|
|
|
|
void nsCellMap::Reset(int aRowCount, int aColCount)
|
|
{
|
|
if (gsDebug) printf("calling Reset(%d,%d) with mRC=%d, mCC=%d, mTRC=%d\n",
|
|
aRowCount, aColCount, mRowCount, mColCount, mTotalRowCount);
|
|
if (nsnull==mColFrames)
|
|
{
|
|
mColFrames = new nsVoidArray(); // don't give the array a count, because null col frames are illegal (unlike null cell entries in a row)
|
|
}
|
|
|
|
if (nsnull==mRows)
|
|
{
|
|
mRows = new nsVoidArray(); // don't give the array a count, because null rows are illegal (unlike null cell entries in a row)
|
|
}
|
|
|
|
// void arrays force the caller to handle null padding elements themselves
|
|
// so if the number of columns has increased, we need to add extra cols to each row
|
|
PRInt32 newCols = mColCount-aColCount;
|
|
for (PRInt32 rowIndex=0; rowIndex<mRowCount; rowIndex++)
|
|
{
|
|
nsVoidArray *row = (nsVoidArray *)(mRows->ElementAt(rowIndex));
|
|
const PRInt32 colsInRow = row->Count();
|
|
if (colsInRow == aColCount)
|
|
break; // we already have enough columns in each row
|
|
for (PRInt32 colIndex = colsInRow; colIndex<aColCount; colIndex++)
|
|
row->AppendElement(nsnull);
|
|
}
|
|
|
|
// if the number of rows has increased, add the extra rows
|
|
PRInt32 newRows = aRowCount-mTotalRowCount; // (new row count) - (total row allocation)
|
|
for ( ; newRows>0; newRows--)
|
|
{
|
|
nsVoidArray *row;
|
|
if (0!=aColCount)
|
|
row = new nsVoidArray(aColCount);
|
|
else
|
|
row = new nsVoidArray();
|
|
mRows->AppendElement(row);
|
|
}
|
|
|
|
mRowCount = aRowCount;
|
|
mTotalRowCount = PR_MAX(mTotalRowCount, mRowCount);
|
|
mColCount = aColCount;
|
|
if (gsDebug) printf("leaving Reset with mRC=%d, mCC=%d, mTRC=%d\n",
|
|
mRowCount, mColCount, mTotalRowCount);
|
|
}
|
|
|
|
void nsCellMap::DumpCellMap() const
|
|
{
|
|
if (gsDebug==PR_TRUE)
|
|
{
|
|
printf("Cell Map =\n");
|
|
for (int rowIndex=0; rowIndex<mRowCount ; rowIndex++)
|
|
{
|
|
nsVoidArray *row = (nsVoidArray *)(mRows->ElementAt(rowIndex));
|
|
for (int colIndex=0; colIndex<mColCount; colIndex++)
|
|
{
|
|
CellData* data = (CellData *)(row->ElementAt(colIndex));
|
|
printf("Cell [%d,%d] = %p for index = %d\n", rowIndex, colIndex, data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsCellMap::GrowToRow(PRInt32 aRowCount)
|
|
{
|
|
Reset(aRowCount, mColCount);
|
|
}
|
|
|
|
void nsCellMap::GrowToCol(PRInt32 aColCount)
|
|
{
|
|
Reset(mRowCount, aColCount);
|
|
}
|
|
|
|
void nsCellMap::SetCellAt(CellData *aCell, int aRowIndex, int aColIndex)
|
|
{
|
|
NS_PRECONDITION(nsnull!=aCell, "bad aCell");
|
|
PRInt32 newRows = (aRowIndex+1)-mTotalRowCount; // add 1 to the "index" to get a "count"
|
|
if (0<newRows)
|
|
{
|
|
for ( ; newRows>0; newRows--)
|
|
{
|
|
nsVoidArray *row = new nsVoidArray(mColCount);
|
|
mRows->AppendElement(row);
|
|
}
|
|
mTotalRowCount = aRowIndex+1; // remember to always add 1 to an index when you want a count
|
|
}
|
|
|
|
CellData* cell = GetCellAt(aRowIndex,aColIndex);
|
|
if (cell != nsnull)
|
|
delete cell;
|
|
nsVoidArray *row = (nsVoidArray *)(mRows->ElementAt(aRowIndex));
|
|
row->ReplaceElementAt(aCell, aColIndex);
|
|
if (gsDebug) printf("leaving SetCellAt(%p,%d,%d) with mRC=%d, mCC=%d, mTRC=%d\n",
|
|
aCell, aRowIndex, aColIndex, mRowCount, mColCount, mTotalRowCount);
|
|
}
|
|
|
|
nsTableColFrame* nsCellMap::GetColumnFrame(PRInt32 aColIndex) const
|
|
{
|
|
NS_ASSERTION(nsnull!=mColFrames, "bad state");
|
|
return (nsTableColFrame *)(mColFrames->ElementAt(aColIndex));
|
|
}
|
|
|
|
|
|
void nsCellMap::SetMinColSpan(PRInt32 aColIndex, PRBool aColSpan)
|
|
{
|
|
NS_ASSERTION(aColIndex<mColCount, "bad aColIndex");
|
|
NS_ASSERTION(aColSpan>=1, "bad aColSpan");
|
|
|
|
// initialize the data structure if not already done
|
|
if (nsnull==mMinColSpans)
|
|
{
|
|
mMinColSpans = new PRInt32[mColCount];
|
|
for (PRInt32 i=0; i<mColCount; i++)
|
|
mMinColSpans[i]=1;
|
|
}
|
|
|
|
mMinColSpans[aColIndex] = aColSpan;
|
|
}
|
|
|
|
PRInt32 nsCellMap::GetMinColSpan(PRInt32 aColIndex) const
|
|
{
|
|
NS_ASSERTION(aColIndex<mColCount, "bad aColIndex");
|
|
|
|
PRInt32 result = 1; // default is 1, mMinColSpans need not be allocated for tables with no spans
|
|
if (nsnull!=mMinColSpans)
|
|
result = mMinColSpans[aColIndex];
|
|
return result;
|
|
}
|
|
|
|
/** return the index of the next column in aRowIndex that does not have a cell assigned to it */
|
|
PRInt32 nsCellMap::GetNextAvailColIndex(PRInt32 aRowIndex, PRInt32 aColIndex) const
|
|
{
|
|
PRInt32 result = 0;
|
|
if (aColIndex > mColCount)
|
|
{
|
|
result = aColIndex;
|
|
}
|
|
else
|
|
{
|
|
if (aRowIndex < mRowCount)
|
|
{
|
|
result = aColIndex;
|
|
nsVoidArray *row = (nsVoidArray *)(mRows->ElementAt(aRowIndex));
|
|
PRInt32 count = row->Count();
|
|
for (PRInt32 colIndex=aColIndex; colIndex<count; colIndex++)
|
|
{
|
|
void * data = row->ElementAt(colIndex);
|
|
if (nsnull==data)
|
|
{
|
|
result = colIndex;
|
|
break;
|
|
}
|
|
result++;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/** returns PR_TRUE if the row at aRowIndex has any cells that are the result
|
|
* of a row-spanning cell above it. So, given this table:<BR>
|
|
* <PRE>
|
|
* TABLE
|
|
* TR
|
|
* TD ROWSPAN=2
|
|
* TD
|
|
* TR
|
|
* TD
|
|
* </PRE>
|
|
* RowIsSpannedInto(0) returns PR_FALSE, and RowIsSpannedInto(1) returns PR_TRUE.
|
|
* @see RowHasSpanningCells
|
|
*/
|
|
// if computing this and related info gets expensive, we can easily
|
|
// cache it. The only thing to remember is to rebuild the cache
|
|
// whenever a row|col|cell is added/deleted, or a span attribute is changed.
|
|
PRBool nsCellMap::RowIsSpannedInto(PRInt32 aRowIndex)
|
|
{
|
|
NS_PRECONDITION (0<=aRowIndex && aRowIndex<GetRowCount(), "bad row index arg");
|
|
PRBool result = PR_FALSE;
|
|
PRInt32 colCount = GetColCount();
|
|
for (PRInt32 colIndex=0; colIndex<colCount; colIndex++)
|
|
{
|
|
CellData *cd = GetCellAt(aRowIndex, colIndex);
|
|
if (cd != nsnull)
|
|
{ // there's really a cell at (aRowIndex, colIndex)
|
|
if (nsnull==cd->mCell)
|
|
{ // the cell at (aRowIndex, colIndex) is the result of a span
|
|
nsTableCellFrame *cell = cd->mRealCell->mCell;
|
|
NS_ASSERTION(nsnull!=cell, "bad cell map state, missing real cell");
|
|
const PRInt32 realRowIndex = cell->GetRowIndex ();
|
|
if (realRowIndex!=aRowIndex)
|
|
{ // the span is caused by a rowspan
|
|
result = PR_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/** returns PR_TRUE if the row at aRowIndex has any cells that have a rowspan>1
|
|
* So, given this table:<BR>
|
|
* <PRE>
|
|
* TABLE
|
|
* TR
|
|
* TD ROWSPAN=2
|
|
* TD
|
|
* TR
|
|
* TD
|
|
* </PRE>
|
|
* RowHasSpanningCells(0) returns PR_TRUE, and RowHasSpanningCells(1) returns PR_FALSE.
|
|
* @see RowIsSpannedInto
|
|
*/
|
|
PRBool nsCellMap::RowHasSpanningCells(PRInt32 aRowIndex)
|
|
{
|
|
NS_PRECONDITION (0<=aRowIndex && aRowIndex<GetRowCount(), "bad row index arg");
|
|
PRBool result = PR_FALSE;
|
|
const PRInt32 rowCount = GetRowCount();
|
|
if (aRowIndex!=rowCount-1)
|
|
{ // aRowIndex is not the last row, so we check the next row after aRowIndex for spanners
|
|
const PRInt32 colCount = GetColCount();
|
|
for (PRInt32 colIndex=0; colIndex<colCount; colIndex++)
|
|
{
|
|
PRInt32 nextRowIndex = aRowIndex+1;
|
|
CellData *cd =GetCellAt(nextRowIndex, colIndex);
|
|
if (cd != nsnull)
|
|
{ // there's really a cell at (nextRowIndex, colIndex)
|
|
if (nsnull==cd->mCell)
|
|
{ // the cell at (nextRowIndex, colIndex) is the result of a span
|
|
nsTableCellFrame *cell = cd->mRealCell->mCell;
|
|
NS_ASSERTION(nsnull!=cell, "bad cell map state, missing real cell");
|
|
const PRInt32 realRowIndex = cell->GetRowIndex ();
|
|
if (realRowIndex!=nextRowIndex)
|
|
{ // the span is caused by a rowspan
|
|
CellData *spanningCell = GetCellAt(aRowIndex, colIndex);
|
|
if (nsnull!=spanningCell)
|
|
{ // there's really a cell at (aRowIndex, colIndex)
|
|
if (nsnull!=spanningCell->mCell)
|
|
{ // aRowIndex is where the rowspan originated
|
|
result = PR_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/** returns PR_TRUE if the col at aColIndex has any cells that are the result
|
|
* of a col-spanning cell. So, given this table:<BR>
|
|
* <PRE>
|
|
* TABLE
|
|
* TR
|
|
* TD COLSPAN=2
|
|
* TD
|
|
* TD
|
|
* </PRE>
|
|
* ColIsSpannedInto(0) returns PR_FALSE, ColIsSpannedInto(1) returns PR_TRUE,
|
|
* and ColIsSpannedInto(2) returns PR_FALSE.
|
|
* @see ColHasSpanningCells
|
|
*/
|
|
PRBool nsCellMap::ColIsSpannedInto(PRInt32 aColIndex)
|
|
{
|
|
PRInt32 colCount = GetColCount();
|
|
NS_PRECONDITION (0<=aColIndex && aColIndex<colCount, "bad col index arg");
|
|
PRBool result = PR_FALSE;
|
|
PRInt32 rowCount = GetRowCount();
|
|
for (PRInt32 rowIndex=0; rowIndex<rowCount; rowIndex++)
|
|
{
|
|
CellData *cd =GetCellAt(rowIndex, aColIndex);
|
|
if (cd != nsnull)
|
|
{ // there's really a cell at (aRowIndex, aColIndex)
|
|
if (nsnull==cd->mCell)
|
|
{ // the cell at (rowIndex, aColIndex) is the result of a span
|
|
nsTableCellFrame *cell = cd->mRealCell->mCell;
|
|
NS_ASSERTION(nsnull!=cell, "bad cell map state, missing real cell");
|
|
const PRInt32 realColIndex = cell->GetColIndex ();
|
|
if (realColIndex!=aColIndex)
|
|
{ // the span is caused by a colspan
|
|
result = PR_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/** returns PR_TRUE if the row at aColIndex has any cells that have a colspan>1
|
|
* So, given this table:<BR>
|
|
* <PRE>
|
|
* TABLE
|
|
* TR
|
|
* TD COLSPAN=2
|
|
* TD
|
|
* </PRE>
|
|
* ColHasSpanningCells(0) returns PR_TRUE, and ColHasSpanningCells(1) returns PR_FALSE.
|
|
* @see ColIsSpannedInto
|
|
*/
|
|
PRBool nsCellMap::ColHasSpanningCells(PRInt32 aColIndex)
|
|
{
|
|
PRBool result = PR_FALSE;
|
|
const PRInt32 colCount = GetColCount();
|
|
if (aColIndex<colCount-1)
|
|
{ // aColIndex is not the last col, so we check the next col after aColIndex for spanners
|
|
const PRInt32 rowCount = GetRowCount();
|
|
for (PRInt32 rowIndex=0; rowIndex<rowCount; rowIndex++)
|
|
{
|
|
PRInt32 nextColIndex = aColIndex+1;
|
|
CellData *cd =GetCellAt(rowIndex, nextColIndex);
|
|
if (cd != nsnull)
|
|
{ // there's really a cell at (rowIndex, nextColIndex)
|
|
if (nsnull==cd->mCell)
|
|
{ // the cell at (rowIndex, nextColIndex) is the result of a span
|
|
nsTableCellFrame *cell = cd->mRealCell->mCell;
|
|
NS_ASSERTION(nsnull!=cell, "bad cell map state, missing real cell");
|
|
const PRInt32 realColIndex = cell->GetColIndex ();
|
|
if (realColIndex!=nextColIndex)
|
|
{ // the span is caused by a colspan
|
|
CellData *spanningCell =GetCellAt(rowIndex, aColIndex);
|
|
if (nsnull!=spanningCell)
|
|
{ // there's really a cell at (rowIndex, aColIndex)
|
|
if (nsnull!=spanningCell->mCell)
|
|
{ // aCowIndex is where the cowspan originated
|
|
result = PR_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|