You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/kword/KWTableFrameSet.cpp

2944 lines
106 KiB

/*
Copyright (C) 2001, S.R.Haque (srhaque@iee.org).
This file is part of the KDE project
Copyright (C) 2005 Thomas Zander <zander@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
DESCRIPTION
This file implements KWord tables.
*/
// ### TODO : multi page tables
#include "KWTableFrameSet.h"
#include "KWDocument.h"
#include "KWAnchor.h"
#include "KWCanvas.h"
#include "KWCommand.h"
#include "KWViewMode.h"
#include "KWView.h"
#include "KWordFrameSetIface.h"
#include "KWordTableFrameSetIface.h"
#include "KWFrameList.h"
#include "KWPageManager.h"
#include "KWPage.h"
#include "KWOasisSaver.h"
#include <KoOasisContext.h>
#include <KoXmlWriter.h>
#include <KoDom.h>
#include <KoXmlNS.h>
#include <KoTextObject.h> // for customItemChar !
#include <KoTextParag.h>
#include <kmessagebox.h>
#include <kdebug.h>
#include <klocale.h>
#include <dcopobject.h>
#include <tqapplication.h>
#include <tqpopupmenu.h>
#include <tqclipboard.h>
KWTableFrameSet::KWTableFrameSet( KWDocument *doc, const TQString & name ) :
KWFrameSet( doc )
{
m_rows = m_cols = m_nr_cells = 0;
m_name = TQString();
m_active = true;
m_frames.setAutoDelete(false);
if ( name.isEmpty() )
m_name = doc->generateFramesetName( i18n( "Table %1" ) );
else
m_name = name;
}
KWTableFrameSet::~KWTableFrameSet()
{
m_doc = 0L;
}
KWordFrameSetIface* KWTableFrameSet::dcopObject()
{
if ( !m_dcop )
m_dcop = new KWordTableFrameSetIface( this );
return m_dcop;
}
KWFrameSetEdit * KWTableFrameSet::createFrameSetEdit( KWCanvas * canvas )
{
return new KWTableFrameSetEdit( this, canvas );
}
void KWTableFrameSet::updateFrames( int flags )
{
for(TableIter c(this); c; ++c)
c.current()->updateFrames( flags );
if ( isFloating() ) {
KWAnchor * anchor = findAnchor( 0 );
if ( anchor )
anchor->resize();
}
KWFrameSet::updateFrames( flags );
}
void KWTableFrameSet::moveFloatingFrame( int /*frameNum TODO */, const KoPoint &position )
{
// TODO multi-page case
double dx = position.x() - m_colPositions[0];
double dy = position.y() - m_rowPositions[0];
KWTableFrameSet::Cell *daCell = cell(0,0);
Q_ASSERT(daCell);
if (! daCell) return; //hack to work around https://bugs.kde.org/show_bug.cgi?id=67216
int oldPageNumber = daCell->frame(0)->pageNumber();
// TODO multi-page case
moveBy( dx, dy );
if ( dx || dy ) {
updateFrames();
cell(0,0)->frame(0)->frameStack()->updateAfterMove( oldPageNumber );
}
}
KoSize KWTableFrameSet::floatingFrameSize( int /*frameNum*/ )
{
return boundingRect().size();
}
KCommand * KWTableFrameSet::anchoredObjectCreateCommand( int /*frameNum*/ )
{
return new KWCreateTableCommand( i18n("Create Table"), this );
}
KCommand * KWTableFrameSet::anchoredObjectDeleteCommand( int /*frameNum*/ )
{
return new KWDeleteTableCommand( i18n("Delete Table"), this );
}
KWAnchor * KWTableFrameSet::createAnchor( KoTextDocument *txt, int frameNum )
{
//kdDebug(32004) << "KWTableFrameSet::createAnchor" << endl;
return new KWAnchor( txt, this, frameNum );
}
void KWTableFrameSet::createAnchors( KoTextParag * parag, int index, bool placeHolderExists /*= false */ /*only used when loading*/,
bool tqrepaint )
{
//kdDebug(32004) << "KWTableFrameSet::createAnchors" << endl;
// TODO make one rect per page, and create one anchor per page
// Anchor this frame, after the previous one
KWAnchor * anchor = createAnchor( m_anchorTextFs->textDocument(), 0 );
if ( !placeHolderExists )
parag->insert( index, KoTextObject::customItemChar() );
parag->setCustomItem( index, anchor, 0 );
kdDebug(32004) << "KWTableFrameSet::createAnchors setting anchor" << endl;
parag->setChanged( true );
if ( tqrepaint )
emit repaintChanged( m_anchorTextFs );
}
void KWTableFrameSet::deleteAnchors()
{
KWAnchor * anchor = findAnchor( 0 );
kdDebug(32004) << "KWTableFrameSet::deleteAnchors anchor=" << anchor << endl;
deleteAnchor( anchor );
}
void KWTableFrameSet::addCell( Cell* daCell ) // called add but also used to 'update'
{
m_rows = kMax( daCell->rowAfter(), m_rows );
m_cols = kMax( daCell->columnAfter(), m_cols );
if ( m_rowArray.size() < daCell->rowAfter() )
m_rowArray.resize( daCell->rowAfter() );
for ( uint row = daCell->firstRow() ;row < daCell->rowAfter(); ++row )
{
if ( !m_rowArray[ row ] )
m_rowArray.insert( row, new Row );
m_rowArray[ row ]->addCell( daCell );
}
}
void KWTableFrameSet::removeCell( Cell* daCell )
{
for ( uint row = daCell->firstRow() ; row < daCell->rowAfter(); ++row )
m_rowArray[ row ]->removeCell( daCell );
}
void KWTableFrameSet::insertRowVector(uint index, Row *r)
{
if(m_rowArray.size() < m_rowArray.count() + 1)
m_rowArray.resize(m_rowArray.count() + 1);
for(uint i = m_rowArray.count(); i > index; i--)
m_rowArray.insert(i, m_rowArray[i-1]);
m_rowArray.insert(index, r);
}
/*
* Inserts a new (empty) element into each row vector.
* Elements in a row vector after index are moved back.
*/
void KWTableFrameSet::insertEmptyColumn(uint index)
{
for(uint i = 0; i < m_rowArray.count(); ++i) {
Row *r = m_rowArray[i];
if(r->m_cellArray.size() < m_cols + 1)
r->m_cellArray.resize(m_cols + 1);
for(int j = m_cols - 1; j >= (int)index; --j)
r->m_cellArray.insert(j + 1, r->m_cellArray[j]);
r->m_cellArray.insert(index, 0);
}
}
KWTableFrameSet::Row*
KWTableFrameSet::removeRowVector(uint index)
{
Q_ASSERT(index < m_rowArray.count() );
Row *ret = m_rowArray.at(index);
Row *r;
for(uint i = index; i < m_rowArray.size() - 1; ++i){
r = m_rowArray.at(i+1);
m_rowArray.remove(i+1);
m_rowArray.insert(i,r);
}
return ret;
}
KoRect KWTableFrameSet::boundingRect() {
KoRect outerRect(m_colPositions[0], // left
m_rowPositions[0], // top
m_colPositions.last()-m_colPositions[0], // width
m_rowPositions.last()-m_rowPositions[0]);// height
// Add 1 'pixel' (at current zoom level) like KWFrame::outerKoRect(),
// to avoid that the bottom line disappears due to rounding problems
// (i.e. that it doesn't fit in the calculated paragraph height in pixels,
// which depends on the paragraph's Y position)
// Better have one pixel too much (caret looks too big by one pixel)
// than one missing (bottom line of cell not painted)
outerRect.rRight() += m_doc->zoomItX( 1 ) / m_doc->zoomedResolutionX();
outerRect.rBottom() += m_doc->zoomItY( 1 ) / m_doc->zoomedResolutionY();
return outerRect;
}
double KWTableFrameSet::topWithoutBorder()
{
double top = 0.0;
for (uint i = 0; i < getColumns(); i++)
{
KWTableFrameSet::Cell *daCell = cell( 0, i );
top = kMax( top, m_rowPositions[0] + daCell->topBorder() );
}
return top;
}
double KWTableFrameSet::leftWithoutBorder()
{
double left = 0.0;
for (uint i=0; i < getRows(); i++)
{
KWTableFrameSet::Cell *daCell = cell( i, 0 );
left = kMax( left, m_colPositions[0] + daCell->leftBorder() );
}
return left;
}
/* returns the cell that occupies row, col. */
KWTableFrameSet::Cell *KWTableFrameSet::cell( unsigned int row, unsigned int col ) const
{
if ( row < m_rowArray.size() && col < m_rowArray[row]->size() ) {
Cell* cell = (*m_rowArray[row])[col];
if ( cell )
return cell;
}
// kdWarning() << name() << " cell " << row << "," << col << " => returning 0!" << kdBacktrace( 3 ) << endl;
//#ifndef NDEBUG
// validate();
// printArrayDebug();
//#endif
return 0L;
}
KWTableFrameSet::Cell *KWTableFrameSet::cellByPos( double x, double y ) const
{
KWFrame *f = frameAtPos(x,y);
if(f) return static_cast<KWTableFrameSet::Cell *> (f->frameSet());
return 0L;
}
void KWTableFrameSet::recalcCols(unsigned int col,unsigned int row) {
if(col >= getColumns())
col = getColumns()-1;
if(row >= getRows())
row = getRows()-1;
Cell *activeCell = cell(row,col);
Q_ASSERT( activeCell );
if ( !activeCell )
return;
double difference = 0;
if(activeCell->frame(0)->left() - activeCell->leftBorder() != m_colPositions[activeCell->firstColumn()]) {
// left border moved.
col = activeCell->firstRow();
difference = 0-(activeCell->frame(0)->left() - activeCell->leftBorder() - m_colPositions[activeCell->firstColumn()]);
}
if(activeCell->frame(0)->right() - activeCell->rightBorder() !=
m_colPositions[activeCell->lastColumn()]) { // right border moved
col = activeCell->columnAfter();
double difference2 = activeCell->frame(0)->right() + activeCell->rightBorder() - m_colPositions[activeCell->columnAfter()];
double moved=difference2+difference;
if(moved > -0.01 && moved < 0.01) { // we were simply moved.
col=0;
difference = difference2;
} else if(difference2!=0)
difference = difference2;
}
m_redrawFromCol=getColumns(); // possible reposition col starting with this one, done in recalcRows
if(difference!=0) {
double last=col==0?0:m_colPositions[col-1];
for(unsigned int i=col; i < m_colPositions.count(); i++) {
double &colPos = m_colPositions[i];
colPos = colPos + difference;
if(colPos-last < s_minFrameWidth) { // Never make it smaller then allowed!
difference += s_minFrameWidth - colPos;
colPos = s_minFrameWidth + last;
}
last=colPos;
}
m_redrawFromCol=col;
if(col>0) m_redrawFromCol--;
//if(activeCell) activeCell->frame(0)->setMinimumFrameHeight(0);
}
updateFrames();
//kdDebug(32004) << "end KWTableFrameSet::recalcCols" << endl;
}
// Step through the whole table and recalculate the position and size
// of each cell.
void KWTableFrameSet::recalcRows(unsigned int col, unsigned int row) {
kdDebug(32004) << name() << " KWTableFrameSet::recalcRows ("<< col <<"," << row << ")" << endl;
//for(unsigned int i=0; i < m_rowPositions.count() ; i++) kdDebug(32004) << "row: " << i << " = " << m_rowPositions[i] << endl;
Cell *activeCell = cell(row,col);
Q_ASSERT( activeCell );
if ( !activeCell ) // #122807
return;
double difference = 0;
if(activeCell->frame(0)->height() != activeCell->frame(0)->minimumFrameHeight() &&
activeCell->type() == FT_TEXT) {
// when the amount of text changed and the frame has to be rescaled we are also called.
// lets check the minimum size for all the cells in this row.
// Take a square of table cells which depend on each others height. It is always the full
// width of the table and the height is determined by joined cells, the minimum is one row.
double minHeightOtherCols=0; // The minimum height which the whole square of table cells can take
double minHeightActiveRow=0; // The minimum height our cell can get because of cells in his row
double minHeightMyCol=0; // The minimum height our column can get in the whole square
unsigned int rowSpan = activeCell->rowSpan();
unsigned int startRow = activeCell->firstRow();
for (uint colCount = 0; colCount < getColumns(); ++colCount )
{
// for each column
unsigned int rowCount=startRow;
double thisColHeight=0; // the total height of this column
double thisColActiveRow=0; // the total height of all cells in this col, completely in the
// row of the activeCell
do { // for each row (under startRow)
Cell *thisCell=cell(rowCount,colCount);
if ( !thisCell )
break; // ###
if(thisCell->firstRow() < startRow) { // above -> set startRow and restart
rowSpan += startRow - thisCell->firstRow();
startRow = thisCell->firstRow();
break;
}
if(thisCell->rowAfter() > startRow + rowSpan) {
rowSpan = thisCell->rowAfter() - startRow;
break;
}
thisColHeight+=thisCell->frame(0)->minimumFrameHeight();
thisColHeight+=thisCell->topBorder();
thisColHeight+=thisCell->bottomBorder();
if(thisCell->firstRow() >= activeCell->firstRow() && thisCell->rowAfter() <= activeCell->rowAfter())
thisColActiveRow+=thisCell->frame(0)->minimumFrameHeight();
rowCount += thisCell->rowSpan();
} while (rowCount < rowSpan+startRow);
if(colCount >= activeCell->firstColumn() &&
colCount < activeCell->columnAfter() )
minHeightMyCol = thisColHeight;
else {
minHeightOtherCols = kMax(minHeightOtherCols, thisColHeight);
minHeightActiveRow = kMax(minHeightActiveRow, thisColActiveRow);
}
} // for each column
bool bottomRow = (startRow+rowSpan == activeCell->rowAfter());
if(!bottomRow) {
Cell *bottomCell=cell(startRow+rowSpan-1, activeCell->firstColumn());
bottomCell->frame(0)->setHeight(bottomCell->frame(0)->minimumFrameHeight() +
minHeightOtherCols - minHeightMyCol);
// ### RECURSE ###
recalcRows(bottomCell->firstColumn(), bottomCell->firstRow());
}
if(activeCell->frame(0)->minimumFrameHeight() > activeCell->frame(0)->height()) { // wants to grow
activeCell->frame(0)->setHeight(activeCell->frame(0)->minimumFrameHeight());
//kdDebug(32004) << activeCell->name() << " grew to its minheight: " << activeCell->frame(0)->minimumFrameHeight() << endl;
} else { // wants to shrink
double newHeight=kMax(activeCell->frame(0)->minimumFrameHeight(),minHeightActiveRow);
if(bottomRow) // I'm a strech cell
newHeight=kMax(newHeight, minHeightOtherCols - (minHeightMyCol - activeCell->frame(0)->minimumFrameHeight()));
activeCell->frame(0)->setHeight(newHeight);
//kdDebug(32004) << activeCell->name() << " shrunk to: " << newHeight << endl;
}
}
if(activeCell->frame(0)->top() - activeCell->topBorder() != getPositionOfRow(activeCell->firstRow())) {
// top moved.
row = activeCell->firstRow();
difference = 0 - (activeCell->frame(0)->top() - activeCell->topBorder() - getPositionOfRow(row));
}
if(activeCell->frame(0)->bottom() + activeCell->bottomBorder() !=
getPositionOfRow(activeCell->rowAfter())) { // bottom moved
row = activeCell->rowAfter();
double difference2 = activeCell->frame(0)->bottom() + activeCell->bottomBorder() - getPositionOfRow(row);
double moved=difference2+difference;
if(moved > -0.01 && moved < 0.01) { // we were simply moved.
row=0;
difference = difference2;
} else if( difference2!=0)
difference = difference2;
}
unsigned int fromRow = m_rows; // possible reposition rows starting with this one, default to no repositioning
unsigned int untilRow=0; // possible reposition rows ending with this one
if( TQABS( difference ) > 1E-10 ) { // means "difference != 0.0"
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
TQValueList<double>::iterator j = m_rowPositions.begin();
double last=0.0;
int lineNumber=-1;
while(j != m_rowPositions.end()) {
lineNumber++;
if(pageBound!=m_pageBoundaries.end()) {
if((int)*pageBound == lineNumber) { // next page
if(lineNumber >= (int)row) { // then delete line j
TQValueList<double>::iterator nextJ = j;
++nextJ;
difference -= *(nextJ)-*(j);
kdDebug(32004) << "Deleting line with old pos: " << *j << endl;
j=m_rowPositions.remove(j);
j--;
TQValueList<unsigned int>::iterator tmp = pageBound;
++pageBound;
m_pageBoundaries.remove(tmp);
j++;
continue;
}
++pageBound;
lineNumber--;
}
}
if(lineNumber >= (int)row) { // below changed row
if(*(j)-last < s_minFrameHeight) // Never make it smaller then allowed!
difference += s_minFrameHeight - *(j) + last;
last=*(j);
kdDebug(32004) << "moving " << *(j) << " by " << difference << "; to " << (*j) + difference << endl;
(*j) += difference; // move line.
}
j++;
}
fromRow=row;
if(row>0) fromRow--;
} else {
row=0;
}
#if 0
{ TQValueList<unsigned int>::iterator pb = m_pageBoundaries.begin();
unsigned int i=0;
double last=0;
do {
double cur=m_rowPositions[i];
if(pb!=m_pageBoundaries.end() && *(pb)==i) {
kdDebug(32004) << "line: " << i << ": " << cur << " *" << (last>cur?" (ALERT)":"") << endl;
++pb;
} else
kdDebug(32004) << "line: " << i << ": " << cur << (last>cur?" (ALERT)":"") << endl;
last=cur;
i++;
} while( i<m_rowPositions.count());
}
#endif
#if 0 // def SUPPORT_MULTI_PAGE_TABLES
//double pageHeight = m_doc->ptPaperHeight() - m_doc->ptBottomBorder() - m_doc->ptTopBorder();
unsigned int pageNumber=cell(0,0)->frame(0)->pageNumber() +1;
unsigned int lineNumber=1;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
TQValueList<double>::iterator j = m_rowPositions.begin();
double diff=0.0;
double pageBottom = pageNumber * m_doc->ptPaperHeight() - m_doc->ptBottomBorder();
// kdDebug(32004) << "pageBottom; " << pageBottom << endl;
while(++j!=m_rowPositions.end()) { // stuff for multipage tables.
if(pageBound!=m_pageBoundaries.end() && *pageBound == lineNumber ) {
if(*j > pageNumber * m_doc->ptPaperHeight() - m_doc->ptBottomBorder() ) { // next page marker exists, and is accurate...
pageNumber++;
pageBottom = pageNumber * m_doc->ptPaperHeight() - m_doc->ptBottomBorder();
// kdDebug(32004) << "pageBottom; " << pageBottom << endl;
untilRow=kMax(untilRow, *pageBound);
pageBound++;
}
}
//kdDebug() << "checking; " << lineNumber << ", " << (*j) << endl;
if((*j) + diff > pageBottom) { // a row falls off the page.
//kdDebug(32004) << "row falls off of page"<< endl;
untilRow = m_rows;
bool hugeRow = false;
unsigned int breakRow = lineNumber-1;
// find out of no cells are spanning multiple rows meaning we have to break higher.
#if 0
// ### TODO: I did not get a chance do debug this yet! TZ.
for(int i=0; i < getColumns() ; i++) {
kdDebug() << "i: " << i<< endl;
Cell *c= cell(breakRow, i);
kdDebug() << "c: " << c->firstRow() << "," << c->m_col << " w: " << c->columnSpan() << ", h: " << c->rowSpan() << endl;
if(c->firstRow() < breakRow) {
breakRow = c->firstRow();
i=-1;
}
}
kdDebug() << "breakRow: " << breakRow<< endl;
fromRow=kMin(fromRow, breakRow);
if(breakRow < lineNumber+1) {
for(unsigned int i=lineNumber+1; i > breakRow;i--)
kdDebug() << "j--";
for(unsigned int i=lineNumber+1; i > breakRow;i--)
--j;
lineNumber=breakRow+1;
}
// find out if the next row (the new one on the page) does not contain cells higher then page.
for(unsigned int i=0; i < getColumns() ; i++) {
if(cell(breakRow+1,i) && cell(breakRow+1,i)->frame(0)->height() > pageHeight)
hugeRow=true;
}
//if((*pageBound) != breakRow) { // I think that this has to be that way
// voeg top in in rowPositions
#endif
double topOfPage = m_doc->ptPaperHeight() * pageNumber + m_doc->ptTopBorder();
TQValueList<double>::iterator tmp = m_rowPositions.at(breakRow);
diff += topOfPage - (*tmp); // diff between bottom of last row on page and top of new page
//kdDebug() << "diff += " << topOfPage << " - " << (*tmp) << ". diff += " << topOfPage - (*tmp) <<" ="<< diff << endl;
lineNumber++;
m_rowPositions.insert(j, topOfPage);
// insert new pageBound. It points to last LINE on previous page
pageBound = m_pageBoundaries.insert(pageBound, breakRow);
//kdDebug(32004) << "inserting new pageBound: " << breakRow << " at " << m_rowPositions[breakRow] << endl;
pageBound++;
if(!hugeRow) {
// add header-rij toe. (en zet bool) TODO
//j++;
//lineNumber++;
// m_hasTmpHeaders = true;
}
pageNumber++;
pageBottom = pageNumber * m_doc->ptPaperHeight() - m_doc->ptBottomBorder();
//kdDebug(32004) << " pageBottom: " << pageBottom << " pageNumber=" << pageNumber << endl;
if((int)pageNumber > m_doc->numPages()) {
int num = m_doc->appendPage();
kdDebug(32004) << "Have appended page: " << num << " (one page mode!)" << endl;
m_doc->afterInsertPage( num );
}
}
//if(diff > 0) kdDebug(32004) << " adding " << diff << ", line " << lineNumber << " " << *(j) <<" -> " << *(j)+diff << endl;
if(diff > 0)
(*j) = (*j) + diff;
lineNumber++;
#if 0 // def SUPPORT_MULTI_PAGE_TABLES
// Note: produces much ouput!
int i = 1; // DEBUG
for ( TQValueList<double>::iterator itDebug = m_rowPositions.begin(); itDebug != m_rowPositions.end(); ++itDebug, ++i )
{
kdDebug(32004) << "m_rowPosition[" << i << "]= " << (*itDebug) << endl;
}
#endif
}
#endif
#if 0
{ TQValueList<unsigned int>::iterator pb = m_pageBoundaries.begin();
unsigned int i=0;
double last=0;
do {
double cur=m_rowPositions[i];
if(pb!=m_pageBoundaries.end() && *(pb)==i) {
kdDebug(32004) << "line: " << i << ": " << cur << " *" << (last>cur?" (ALERT)":"") << endl;
++pb;
} else
kdDebug(32004) << "line: " << i << ": " << cur << (last>cur?" (ALERT)":"") << endl;
last=cur;
i++;
} while( i<m_rowPositions.count());
}
#endif
//for (unsigned int i=0; i < getRows(); kdDebug(32004)<<" pos of row["<<i<<"] = "<<getPositionOfRow(i)<<"/"<<getPositionOfRow(i,true)<<endl,i++);
//kdDebug () << "Repositioning from row : " << fromRow << " until: " << untilRow << endl;
//kdDebug () << "Repositioning from col > " << redrawFromCol << endl;
// do positioning.
//Cell *cell;
//bool setMinFrameSize= activeCell->frame(0)->isSelected();
#if 0 // def SUPPORT_MULTI_PAGE_TABLES
for(TableIter cell(this); cell; ++cell) {
if((cell->rowAfter() > fromRow && cell->firstRow() < untilRow) || cell->columnAfter() > m_redrawFromCol)
position(cell, (cell==activeCell && cell->frame(0)->isSelected()));
}
m_redrawFromCol = getColumns();
// check if any rowPosition entries are unused
// first create a hash of all row entries
TQMap<unsigned int,int> rows; // rownr, count
unsigned int top=m_rowPositions.count() - m_pageBoundaries.count()-1;
for(unsigned int i=0; i < top; rows[i++]=0);
// fill hash with data
for(TableIter i(this); i; ++i) {
rows[i->firstRow()] += 1;
}
// check if some entries have stayed unused.
unsigned int counter=top;
int adjustment=m_pageBoundaries.count()-1;
do {
counter--;
if(adjustment >= 0 && counter == m_pageBoundaries[adjustment])
adjustment--;
if(rows[counter]==0) {
kdDebug() << k_funcinfo << "no rows at counter=" << counter << " -> erasing" << endl;
m_rows--;
m_rowPositions.erase(m_rowPositions.at(counter+(adjustment>0?adjustment:0)));
for (TableIter cell(this); cell; ++cell) {
if(cell->firstRow() < counter && cell->rowAfter() > counter)
cell->setRowSpan(cell->rowSpan()-1);
if(cell->firstRow() > counter)
cell->setFirstRow(cell->firstRow()-1);
}
if(adjustment >= -1) {
pageBound = m_pageBoundaries.at(adjustment+1);
while(pageBound!=m_pageBoundaries.end()) {
(*pageBound)= (*pageBound)-1;
pageBound++;
}
}
}
} while(counter!=0);
#endif
m_redrawFromCol = 0;
for (TableIter cell(this); cell; ++cell) {
if((cell->rowAfter() > fromRow && cell->firstRow() < untilRow)
|| cell->columnAfter() > m_redrawFromCol)
position(cell);
}
m_redrawFromCol = getColumns();
kdDebug(32004) << name() << " KWTableFrameSet::recalcRows done" << endl;
updateFrames();
}
int KWTableFrameSet::columnEdgeAt( double x ) const
{
// We compare x with the middle of columns (left+right/2),
// to find which column x is closest to.
// m_colPositions is sorted, so we can remember the last column we looked at.
double lastMiddlePos = 0;
for ( uint i = 0; i < m_colPositions.count() - 1; i++ ) {
double middlePos = ( m_colPositions[i] + m_colPositions[i+1] ) / 2;
Q_ASSERT( lastMiddlePos < middlePos );
if ( x > lastMiddlePos && x <= middlePos )
return i;
lastMiddlePos = middlePos;
}
return m_colPositions.count() - 1;
}
int KWTableFrameSet::rowEdgeAt( double y ) const
{
double lastMiddlePos = 0;
for ( uint i = 0; i < m_rowPositions.count() - 1; i++ ) {
double middlePos = ( m_rowPositions[i] + m_rowPositions[i+1] ) / 2;
Q_ASSERT( lastMiddlePos < middlePos );
if ( y > lastMiddlePos && y <= middlePos )
return i;
lastMiddlePos = middlePos;
}
return m_rowPositions.count() - 1;
}
double KWTableFrameSet::columnSize( unsigned int col )
{
return m_colPositions[ col ];
}
double KWTableFrameSet::rowSize( unsigned int row )
{
return m_rowPositions[ row ];
}
void KWTableFrameSet::resizeColumn( unsigned int col, double x )
{
kdDebug() << k_funcinfo << col << "," << x << endl;
if ((col != 0) && (x - m_colPositions[ col-1 ] < s_minFrameWidth))
m_colPositions[ col ] = m_colPositions[ col-1 ] + s_minFrameWidth;
else
if ((col != getColumns()) && (m_colPositions[ col + 1 ] - x < s_minFrameWidth))
m_colPositions[col] = m_colPositions[ col + 1 ] - s_minFrameWidth;
else
m_colPositions[ col ] = x;
// move all cells right of 'col'
for (TableIter cell(this); cell; ++cell) {
if ( cell->columnAfter() >= col ) {
position(cell);
}
}
recalcCols( col-1, 0 );
}
void KWTableFrameSet::resizeRow( unsigned int row, double y )
{
kdDebug() << k_funcinfo << row << "," << y << endl;
double difference = m_rowPositions[row];
if ((row != 0) && (y - m_rowPositions[ row-1 ] < s_minFrameHeight))
m_rowPositions[ row ] = m_rowPositions[ row-1 ] + s_minFrameHeight;
else
if ((row != getRows()) && (m_rowPositions[ row + 1 ] - y < s_minFrameHeight))
m_rowPositions[row] = m_rowPositions[ row + 1 ] - s_minFrameHeight;
else
m_rowPositions[ row ] = y;
difference = m_rowPositions[row] - difference;
//move all rows under 'row'
if (row != 0)
for (unsigned int i=row+1; i<= getRows(); i++)
m_rowPositions[i] = m_rowPositions[i] + difference;
// move all cells under 'row'
for (TableIter cell(this); cell; ++cell) {
if ( cell->rowAfter() >= row ) {
position(cell);
}
}
recalcRows( 0, row-1 );
}
void KWTableFrameSet::resizeWidth( double width ) {
Q_ASSERT(width != 0);
Q_ASSERT(boundingRect().width() != 0);
kdDebug() << "bounding width before resize " << boundingRect().width() << endl;
double growth = width / boundingRect().width();
// since we move all the columns, we also move the 1st one,
// depending where it is on the page.
// just compensate by substracting that offset.
double moveOffset = m_colPositions[0] * growth - m_colPositions[0];
for (uint i=0; i<m_colPositions.count(); i++) {
m_colPositions[i] = m_colPositions[i] * growth - moveOffset;
}
finalize();
kdDebug() << "bounding width after resize" << boundingRect().width() << endl;
Q_ASSERT(boundingRect().width() - width < 0.01);
}
void KWTableFrameSet::setBoundingRect( KoRect rect, CellSize widthMode, CellSize heightMode ) {
// Column positions..
m_colPositions.clear();
unsigned int cols=0;
for (TableIter c(this); c; ++c)
cols = kMax(cols, c.current()->columnAfter());
double colWidth = rect.width() / cols;
if ( widthMode == TblAuto ) {
KWPage *page = pageManager()->page(rect);
rect.setLeft( page->leftMargin() );
colWidth = (page->width() - page->leftMargin() - page->rightMargin()) / cols;
}
for(unsigned int i=0; i <= cols;i++) {
m_colPositions.append(rect.x() + colWidth * i);
}
// Row positions..
m_rowPositions.clear();
m_pageBoundaries.clear();
double rowHeight = 0;
if( heightMode != TblAuto )
rowHeight = rect.height() / m_rows;
rowHeight=kMax(rowHeight, 22.0); // m_doc->getDefaultParagLayout()->getFormat().ptFontSize()) // TODO use table style font-size
for(unsigned int i=0; i <= m_rows;i++) {
m_rowPositions.append(rect.y() + rowHeight * i);
}
double oneMm = MM_TO_POINT( 1.0 );
for (TableIter cell(this); cell; ++cell) {
KWFrame *frame = cell->frame(0);
frame->setPaddingLeft( oneMm );
frame->setPaddingRight( oneMm );
frame->setPaddingTop( oneMm );
frame->setPaddingBottom( oneMm );
frame->setNewFrameBehavior( KWFrame::NoFollowup );
position(cell, true);
}
}
void KWTableFrameSet::position( Cell *theCell, bool setMinFrameHeight ) {
if(!theCell->frame(0)) { // sanity check.
kdDebug(32004) << "errorous table cell!! row:" << theCell->firstRow()
<< ", col: " << theCell->firstColumn() << endl;
return;
}
double x = *m_colPositions.at(theCell->firstColumn());
double y = getPositionOfRow(theCell->firstRow());
double width = (*m_colPositions.at(theCell->columnAfter())) - x;
double height = getPositionOfRow(theCell->lastRow(), true) - y;
#if 0
if(theCell->m_col==0) {
kdDebug(32004) << "row " << theCell->firstRow() << " has top: "
<< y << ", and bottom: " << y + height << endl;
}
#endif
// Now take the border sizes and make the cell smaller so it still fits inside the grid.
KWFrame *theFrame = theCell->frame(0);
x+=theCell->leftBorder();
width-=theCell->leftBorder();
width-=theCell->rightBorder();
y+=theCell->topBorder();
height-=theCell->topBorder();
height-=theCell->bottomBorder();
theFrame->setRect( x,y,width,height);
if( setMinFrameHeight )
theFrame->setMinimumFrameHeight(height);
if(!theCell->isVisible())
theCell->setVisible(true);
}
double KWTableFrameSet::getPositionOfRow( unsigned int row, bool bottom ) {
unsigned int adjustment=0;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
while(pageBound != m_pageBoundaries.end() && (*pageBound) <= row + adjustment) {
adjustment++;
pageBound++;
}
if(m_rowPositions.count() < row+adjustment+(bottom?1:0)) // Requested row does not exist.
return 0;
return m_rowPositions[row+adjustment+(bottom?1:0)];
}
void KWTableFrameSet::moveBy( double dx, double dy ) {
bool redraw=false;
kdDebug(32004) << "KWTableFrameSet(" << name() << ")::moveBy(" << dx<<","<<dy<<")\n";
//for(unsigned int i=0; i < m_rowPositions.count() ; kdDebug(32004) << "row " << i << ": " << m_rowPositions[i++] << endl);
if(!(dy > -0.001 && dy < 0.001)) {
redraw=true;
TQValueList<double>::iterator row = m_rowPositions.begin();
while(row != m_rowPositions.end()) {
(*row)= (*row)+dy;
row++;
}
}
if(!(dx > -0.001 && dx < 0.001)) {
redraw=true;
TQValueList<double>::iterator col = m_colPositions.begin();
while(col != m_colPositions.end()) {
(*col)= (*col)+dx;
col++;
}
}
if(redraw) {
for(TableIter cell(this);cell;++cell)
position(cell);
}
}
/* Delete all cells that are completely in this row. */
void KWTableFrameSet::deleteRow( unsigned int row, RemovedRow &rr, bool _recalc)
{
Q_ASSERT(row < m_rowArray.size());
const unsigned int rowspan=1;
double height= getPositionOfRow(row+rowspan-1,true) - getPositionOfRow(row);
TQValueList<double>::iterator tmp = m_rowPositions.at(row+rowspan);
tmp=m_rowPositions.erase(tmp);
while(tmp!=m_rowPositions.end()) {
(*tmp)= (*tmp)-height;
tmp++;
}
rr.m_index = row;
rr.m_rowHeight = height;
rr.m_row = m_rowArray[row];
// move/delete cells.
for ( TableIter cell(this); cell; ++cell ) {
if ( row >= cell->firstRow() && row < cell->rowAfter()) { // cell is indeed in row
if(cell->rowSpan() == 1) { // cell is wholly contained within row
m_frames.remove( cell->frame(0) );
} else { // make cell span rowspan less rows
cell->setRowSpan(cell->rowSpan()-rowspan);
position(cell);
}
} else if ( cell->firstRow() > row ) {
// move cell up
cell->setFirstRow( cell->firstRow() - rowspan );
position(cell);
}
}
removeRowVector(row);
m_rows -= rowspan;
m_rowArray.resize( m_rows );
validate();
if ( _recalc )
recalcRows( 0, row-1 );
}
void KWTableFrameSet::reInsertRow(RemovedRow &rr)
{
uint row = rr.index();
Row *r = rr.row();
uint rlen = r->count();
// adjust cell positions & sizes
for(MarkedIterator cell(this); cell; ++cell) {
if ( cell->firstRow() < row && cell->lastRow() >= row ){ // cell is indeed in row
cell->setRowSpan(cell->rowSpan() + 1);
}
else if(r->m_cellArray[cell->firstColumn()] == cell.current()) {
cell->setRowSpan(cell->rowSpan() + 1);
}
else if ( cell->firstRow() >= row ) {
// move cell down
cell->setFirstRow( cell->firstRow() + 1);
}
}
// put back m_frames that were removed
for(uint i = 0; i < rlen; i++){
if( m_frames.findRef((*r)[i]->frame(0)) == -1 )
m_frames.append( (*r)[i]->frame(0) );
}
// adjust row positions (ignores page boundaries!)a
if(row == m_rows) { //reinserting at bottom of table
double d = m_rowPositions.last() + rr.height();
m_rowPositions.append(d);
}
else {
TQValueList<double>::iterator top = m_rowPositions.at(row);
TQValueList<double>::iterator i = m_rowPositions.at(row+1);
i = m_rowPositions.insert(i, *top + rr.height());
i++;
for(; i != m_rowPositions.end(); ++i) {
*i = *i+ rr.height();
}
}
// reinsert row into array
m_rows++;
insertRowVector(rr.index(), rr.takeRow());
// don't actually have to visit all the cells, this could be optimised
for(TableIter i(this); i ; ++i)
position(i.current());
validate();
}
void KWTableFrameSet::insertNewRow( uint idx, bool recalc, bool _removeable)
{
(void) _removeable; // unused parameter
unsigned int copyFromRow = idx==0?0:idx-1;
if(idx==0)
copyFromRow=1;
Row *copyRow = m_rowArray[copyFromRow];
uint new_rows = m_rows + 1;
// What height to use for the new row
double height = getPositionOfRow(copyFromRow,true) - getPositionOfRow(copyFromRow);
// Calculate offset in TQValueList because of page breaks.
unsigned int adjustment=0;
unsigned int untilRow=m_rows;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
while(pageBound != m_pageBoundaries.end() && (*pageBound) <= idx) {
// Find out how many pages we already had.
adjustment++;
pageBound++;
}
// Move all rows down from newRow to bottom of page
TQValueList<double>::iterator tmp = m_rowPositions.at(idx);
double newPos = *tmp + height;
tmp++;
m_rowPositions.insert(tmp, newPos);
for(unsigned int i=idx+adjustment+2; i < m_rowPositions.count(); i++) {
double &rowPos = m_rowPositions[i];
kdDebug(32004) << "adjusting " << rowPos << " -> " << rowPos + height << endl;
rowPos = rowPos + height;
if(*pageBound == i) {
untilRow= *pageBound;
break; // stop at pageBreak.
}
}
for ( MarkedIterator cells(this); cells; ++cells) {
if ( cells->firstRow() >= idx ) { // move all cells beneath the new row.
cells->setFirstRow(cells->firstRow()+1);
}
}
insertRowVector(idx, new Row);
unsigned int i = 0;
while(i < getColumns()) {
if(idx != 0 && (idx != m_rows)) {
Cell *c = cell(idx - 1, i);
if( c == cell(idx + 1, i) ) {
m_rowArray[idx]->addCell(c);
c->setRowSpan(c->rowSpan() + 1);
i += c->columnSpan();
continue; // don't need to make a new cell
}
}
KWFrame *theFrame = new KWFrame(copyRow->m_cellArray[i]->frame(0));
Cell *newCell=new Cell( this, idx, i, TQString() );
newCell->setColumnSpan( cell(copyFromRow,i)->columnSpan() );
addCell(newCell);
newCell->addFrame( theFrame, false );
position(newCell);
i += newCell->columnSpan();
}
// Position all changed cells.
m_rows = new_rows;
validate();
if ( recalc )
finalize();
}
void KWTableFrameSet::deleteColumn(uint col, RemovedColumn &rc)
{
// keep these values in case we have to put it back
if(!rc.m_initialized) {
rc.m_index = col;
rc.m_width = m_colPositions[col+1] - m_colPositions[col];
}
// move the colomn positions
TQValueList<double>::iterator tmp = m_colPositions.at(col+1);
tmp = m_colPositions.erase(tmp);
while(tmp != m_colPositions.end()) {
(*tmp) = (*tmp) - rc.m_width;
tmp++;
}
// remove cells that are wholy in this column,
// otherwise reduce rowspan. pointers to all cells
// are kept in the RemovedColumn
CheckedIter iter(this);
for(uint i = 0; i < m_rows; ++i) {
Cell *daCell = cell(i, col);
if(!rc.m_initialized) {
rc.m_column.append(daCell);
rc.m_removed.append(daCell->columnSpan() == 1);
}
if(daCell->columnSpan() == 1) { // lets remove it
if(daCell->firstRow() == i) {
m_frames.remove( daCell->frame(0) );
m_nr_cells--;
}
m_rowArray[i]->m_cellArray.insert(col, 0);
}
else { // make cell span 1 less column
if(daCell->firstRow() == i) {
daCell->setColumnSpan( daCell->columnSpan() - 1 );
position(daCell);
}
}
}
// adjust cells in a later column
for(; iter; ++iter) {
if (iter->firstColumn() > col ) {
iter->setFirstColumn( iter->firstColumn() - 1);
position(iter.current());
}
}
// move pointers in 2d array back one column to occupy
// removed column
for(uint i = 0; i < m_rows; i++) {
for(uint j = col + 1; j < m_cols; j++)
m_rowArray[i]->m_cellArray.insert(j-1, m_rowArray[i]->m_cellArray[j]);
}
m_cols--;
rc.m_initialized = true;
validate();
recalcCols( col, 0 );
recalcRows( col, 0 );
}
void KWTableFrameSet::reInsertColumn(RemovedColumn &rc)
{
TQValueList<double>::iterator tmp = m_colPositions.at(rc.m_index);
tmp = m_colPositions.insert(tmp, *tmp);
tmp++;
while(tmp != m_colPositions.end()) {
(*tmp) = (*tmp) + rc.m_width;
tmp++;
}
// if a cell starts after the column we are inserting, it
// must be moved to the right, except if it is going to
// occury the reinserted column also.
for ( MarkedIterator cells(this); cells ; ++cells ) {
if ( cells->firstColumn() >= rc.m_index &&
(rc.m_column.at(cells->firstRow()) != cells.current())) {
cells->setFirstColumn(cells->firstColumn() + 1);
}
}
insertEmptyColumn(rc.m_index);
m_cols++;
for(uint i = 0; i < m_rows; ++i) {
bool removed = rc.m_removed[i];
Cell *daCell = rc.m_column.at(i);
if(i == daCell->firstRow()) {
if(removed) {
daCell->setColumnSpan(1);
m_frames.append(daCell->frame(0));
m_nr_cells++;
}
else {
daCell->setColumnSpan(daCell->columnSpan() + 1);
}
addCell(daCell);
}
}
validate();
finalize();
}
void KWTableFrameSet::insertNewColumn( uint idx, double width)
{
TQValueList<double>::iterator tmp = m_colPositions.at(idx);
tmp = m_colPositions.insert(tmp, *tmp);
tmp++;
while(tmp!=m_colPositions.end()) {
(*tmp)= (*tmp)+width;
tmp++;
}
for ( MarkedIterator cells(this); cells ; ++cells ) {
if ( cells->firstColumn() >= idx) { // move all cells right of the new col.
cells->setFirstColumn(cells->firstColumn() + 1);
}
}
insertEmptyColumn(idx);
m_cols++;
uint copyCol = (idx == 0) ? 1 : idx - 1 ;
// make the new cells
// note that the loop counter is mucked with in the loop!
for( unsigned int i = 0; i < getRows(); i++ ) {
// can't break a cell in half, so if there is the same cell
// on both sides of inserted column, it occupies the new
// column as well
if(idx != 0 && (idx != m_cols -1)) {
Cell *c = cell(i, idx - 1);
if( c == cell(i, idx + 1) ) {
// m_rowArray[i]->m_cellArray.insert(idx, c);
c->setColumnSpan(c->columnSpan() + 1);
addCell(c);
i += c->rowSpan() - 1;
continue; // don't need to make a new cell
}
}
Cell *newCell = new Cell( this, i, idx, TQString() );
KWFrame *theFrame = new KWFrame(cell(i, copyCol)->frame(0));
newCell->addFrame( theFrame, false );
position(newCell);
m_nr_cells++;
}
validate();
finalize();
}
void KWTableFrameSet::ungroup()
{
// m_cells.setAutoDelete( false );
// m_cells.clear();
m_nr_cells = 0;
m_active = false;
}
void KWTableFrameSet::group()
{
// m_cells.setAutoDelete( true );
// m_cells.clear();
m_nr_cells = 0;
m_active = true;
}
KCommand *KWTableFrameSet::joinCells(unsigned int colBegin,unsigned int rowBegin, unsigned int colEnd,unsigned int rowEnd) {
Cell *firstCell = cell(rowBegin, colBegin);
// if just one cell selected for joining; exit.
if(rowBegin == rowEnd && colBegin == colEnd || cell(rowBegin,colBegin) == cell(rowEnd,colEnd))
return 0L;
TQPtrList<KWFrameSet> listFrameSet;
TQPtrList<KWFrame> listCopyFrame;
// do the actual merge.
for(unsigned int i=colBegin; i<=colEnd;i++) {
for(unsigned int j=rowBegin; j<=rowEnd;j++) {
Cell *daCell = cell(j,i);
if(daCell && daCell!=firstCell) {
listFrameSet.append(daCell);
KWFrame* frame = daCell->frame(0);
Q_ASSERT(frame);
if(! frame) continue; // see bug #132642
listCopyFrame.append(frame->getCopy());
daCell->deleteFrame(frame);
}
}
}
Q_ASSERT(firstCell);
// update firstcell properties to reflect the merge
firstCell->setColumnSpan(colEnd-colBegin+1);
firstCell->setRowSpan(rowEnd-rowBegin+1);
addCell(firstCell);
position(firstCell);
validate();
m_doc->updateAllFrames(); // TODO: only fs->updateFrames() & m_doc->updateFramesOnTopOrBelow(pageNum)
m_doc->repaintAllViews();
return new KWJoinCellCommand( i18n("Join Cells"), this,colBegin,rowBegin, colEnd,rowEnd,listFrameSet,listCopyFrame);
}
KCommand *KWTableFrameSet::splitCell(unsigned int intoRows, unsigned int intoCols, unsigned int col, unsigned int row, TQPtrList<KWFrameSet> listFrameSet, TQPtrList<KWFrame>listFrame) {
if(intoRows < 1 || intoCols < 1)
return 0L;
kdDebug(32004) << "KWTableFrameSet::splitCell" << endl;
Cell *daCell=cell(row,col);
int rowsDiff = intoRows - daCell->rowSpan();
int colsDiff = ((int) intoCols) - daCell->columnSpan();
if(rowsDiff >0) {
unsigned int adjustment=0;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
while(pageBound != m_pageBoundaries.end() && (*pageBound) <= row) {
adjustment++;
pageBound++;
}
double height = (m_rowPositions[row+adjustment+1] - m_rowPositions[row+adjustment])/intoRows;
TQValueList<double>::iterator iRow = m_rowPositions.at(adjustment+row);
for (int i=0; i < rowsDiff; i++) {
double newPos = *iRow + height;
iRow++;
iRow=m_rowPositions.insert(iRow, newPos);
}
// insert more rows into m_rowArray
for(int i = 0; i < rowsDiff; ++i) {
insertRowVector(row+i+1, new Row);
m_rows++;
}
// m_rows += rowsDiff;
//for(unsigned int i=0; i < m_rowPositions.count() ; ++i)
// kdDebug(32004) << "row " << i << ": " << m_rowPositions[i] << endl);
}
if(colsDiff >0) {
double width = (m_colPositions[col+1] - m_colPositions[col])/intoCols;
TQValueList<double>::iterator iCol = m_colPositions.at(col);
for (int i=0; i < colsDiff; i++) {
double newPos = *iCol + width;
iCol++;
iCol=m_colPositions.insert(iCol, newPos);
}
for(int i = 0; i < colsDiff; i++) {
insertEmptyColumn(col+i+1);
m_cols++;
}
//for(unsigned int i=0; i < m_colPositions.count(); ++i)
// kdDebug(32004) << "col " << i << ": " << m_colPositions[i] << endl);
//m_cols += colsDiff;
}
// adjust cellspan and rowspan on other cells.
for (CheckedIter i(this); i ; ++i) {
if(daCell == i) continue;
if(rowsDiff>0) {
if(row >= i->firstRow()&& row < i->firstRow()+ i->rowSpan())
i->setRowSpan(i->rowSpan() + rowsDiff);
if(i->firstRow() > row) {
i->setFirstRow(i->firstRow() + rowsDiff);
// theCell->frame(0)->setTop(theCell->frame(0)->top()+extraHeight);
}
}
if(colsDiff>0) {
if(col >= i->firstColumn() && col < i->columnAfter())
i->setColumnSpan(i->columnSpan() + colsDiff);
if(i->firstColumn() > col)
i->setFirstColumn(i->firstColumn() + colsDiff);
}
/*if(extraHeight != 0 && theCell->firstRow()== row) {
theCell->frame(0)->setHeight(theCell->frame(0)->height()+extraHeight);
} */
if ( rowsDiff > 0 || colsDiff > 0 ) // something changed?
addCell( i ); // update arrays
}
int i=0;
KWFrame *firstFrame = daCell->frame(0);
// create new cells
for (unsigned int y = 0; y < intoRows; y++) {
for (unsigned int x = 0; x < intoCols; x++){
if(x==0 && y==0)
continue; // the orig cell takes this spot.
Cell *lastFrameSet=0L;
if(listFrameSet.isEmpty())
lastFrameSet = new Cell( this, y + row, x + col );
else
lastFrameSet = static_cast<KWTableFrameSet::Cell*> (listFrameSet.at(i));
lastFrameSet->setGroupManager(this);
KWFrame *theFrame=0L;
if(listFrame.isEmpty())
{
theFrame=firstFrame->getCopy();
theFrame->setRunAround( KWFrame::RA_NO );
theFrame->setFrameBehavior(KWFrame::AutoExtendFrame);
theFrame->setNewFrameBehavior(KWFrame::NoFollowup);
lastFrameSet->addFrame( theFrame,false );
}
else
lastFrameSet->addFrame( listFrame.at(i)->getCopy(),false );
i++;
// if the orig cell spans more rows/cols than it is split into, make first col/row wider.
if(rowsDiff <0 && y==0)
lastFrameSet->setRowSpan(lastFrameSet->rowSpan() - rowsDiff);
if(colsDiff <0 && x==0)
lastFrameSet->setColumnSpan(lastFrameSet->columnSpan() - colsDiff);
addCell( lastFrameSet );
position(lastFrameSet);
}
}
// set new row and col-span. Use intermediate ints otherwise we get strange results as the
// intermediate result could be negative (which goes wrong with unsigned ints)
int r = (daCell->rowSpan() +1) - intoRows;
if(r < 1) r=1;
daCell->setRowSpan(r);
int c = (daCell->columnSpan() + 1) - intoCols;
if(c < 1) c=1;
daCell->setColumnSpan(c);
position(daCell);
addCell(daCell);
validate();
finalize();
return new KWSplitCellCommand(i18n("Split Cells"),this,col,row,intoCols, intoRows);
}
void KWTableFrameSet::viewFormatting( TQPainter &/*painter*/, int )
{
}
void KWTableFrameSet::validate()
{
for(CheckedIter cells(this); cells; ++cells) {
if(cells->columnSpan() == 0 || cells->rowSpan() == 0) {
kdDebug(32004) << " KWTableFrameSet::validate(): zero dimension" << endl;
kdDebug(32004) << cells->firstRow() << " " << cells->firstColumn() << " " << cells->rowSpan()
<< " " << cells->columnSpan() << endl;
}
for(uint i = cells->firstRow(); i < cells->rowAfter(); ++i) {
for(uint j = cells->firstColumn(); j < cells->columnAfter(); ++j) {
if( cell(i,j) != cells.current() ) {
TQString str = TQString("| 0x%1 ").tqarg( (unsigned long)cells.current(), 0, 16 );
kdDebug(32004) << " KWTableFrameSet::validate() failed " << endl;
kdDebug(32004) << "at row: "<< i << " col: "<< j << " cell: "<< str << endl;
kdDebug(32004) << cells->firstRow() << " " << cells->firstColumn() << " " << cells->rowSpan()
<< " " << cells->columnSpan() << endl;
//printArrayDebug();
}
}
}
}
}
void KWTableFrameSet::createEmptyRegion( const TQRect & crect, TQRegion & emptyRegion, KWViewMode *viewMode )
{
// Avoid iterating over all cells if we are out of view
if ( !viewMode->normalToView( m_doc->zoomRect( boundingRect() ) ).intersects( crect ) )
return;
TQRect outerRect( viewMode->normalToView( m_doc->zoomRect( boundingRect() )));
outerRect &= crect;
if ( !outerRect.isEmpty() )
emptyRegion = emptyRegion.subtract( outerRect );
TQPtrListIterator<KWFrame> frameIt = frameIterator();
for ( ; frameIt.current(); ++frameIt )
{
TQRect outerRect( viewMode->normalToView( frameIt.current()->outerRect(viewMode) ) );
//kdDebug(32004) << "KWTableFrameSet::createEmptyRegion outerRect=" << DEBUGRECT( outerRect )
// << " crect=" << DEBUGRECT( crect ) << endl;
outerRect &= crect;
if ( !outerRect.isEmpty() )
emptyRegion = emptyRegion.subtract( outerRect );
}
}
void KWTableFrameSet::drawBorders( TQPainter& painter, const TQRect &crect, KWViewMode *viewMode ) {
/* Draw the borders on top of the lines stores in the m_rowPositions and m_colPositions arrays.
* check the relevant cells for borders and thus line thickness.
* We move the outer lines (on row==0 and col==0 plus on col=getColumns() etc) a bit so they will stay
* inside the boundary of the table!
*/
painter.save();
TQPen previewLinePen( TQApplication::palette().color( TQPalette::Active, TQColorGroup::Mid ) );
TQColor defaultBorderColor = KoTextFormat::defaultTextColor( &painter );
const int minborder = 1;
bool drawPreviewLines = viewMode && viewMode->drawFrameBorders();
// *** draw horizontal lines *** //
unsigned int row=0;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
for (unsigned int i=0 ; i < m_rowPositions.count() ; i++) {
//kdDebug(32004) << "Horizontal line code. i: " << i << endl;
bool bottom=false;
if( (pageBound!=m_pageBoundaries.end() && (*pageBound) == row)
|| i == m_rowPositions.count()-1)
bottom=true; // at end of page or end of table draw bottom border of cell.
const KoBorder *border=0;
double startPos =0;
for(unsigned int col=0; col <= getColumns();) {
//kdDebug(32004) << "bottom=" << bottom << " row=" << row << " col=" << col << endl;
Cell *daCell = col < getColumns() ? cell(bottom?row-1:row, col) : 0;
//if(daCell) kdDebug(32004) << "cell (" << daCell->firstRow()<< "," << daCell->firstColumn() << ")" << endl;
//else kdDebug(32004) << "cell: " << daCell << endl;
if(daCell && daCell->firstRow() != (bottom?row-1:row))
daCell=0;
if(startPos!=0 && (!daCell || col == getColumns() || (
bottom && daCell->frame(0)->bottomBorder()!=*border ||
!bottom && daCell->frame(0)->topBorder()!=*border
))) {
if(border->width() > 0 || drawPreviewLines) {
double y = m_rowPositions[i];
if(row==0)
y+=border->width() / 2; // move slightly down.
else if (row == getRows())
y-=border->width() / 2; // move slightly up.
int ypix = m_doc->zoomItY(y);
double offset=0.0;
if(border->width() > 0 && col!=getColumns()) { // offset border when not at right most cell.
if(daCell) offset=daCell->leftBorder();
if ( row > 0 ) {
Cell *c = cell(row-1, col);
if(c) offset=kMax(offset, c->leftBorder());
}
}
double x = m_colPositions[col] + offset;
TQPoint topLeft = viewMode->normalToView(TQPoint(m_doc->zoomItX(startPos), ypix));
TQPoint bottomRight = viewMode->normalToView(TQPoint(m_doc->zoomItX(x), ypix));
TQRect line = TQRect(topLeft, bottomRight);
if(crect.intersects( line )) {
//if(border->width() <= 0) kdDebug(32004) << "preview line" << endl;
if(border->width() <= 0)
painter.setPen( previewLinePen );
else {
int borderWidth = KoBorder::zoomWidthY( border->width(), m_doc, minborder );
painter.setPen( KoBorder::borderPen( *border, borderWidth, defaultBorderColor ) );
}
//kdDebug(32004) << "Paint: painter.drawHorizontalLine(" << line.left() << "," << line.top() << "," << line.right() << "," << line.bottom() << ")\n";
painter.drawLine( line.left(), line.top(), line.right(), line.bottom());
}
}
// reset startPos
startPos = 0;
}
if(daCell && startPos==0) {
if(bottom)
border=&(daCell->frame(0)->bottomBorder());
else
border=&(daCell->frame(0)->topBorder());
if(col==0) // left most cell
startPos = m_colPositions[col];
else {
double offset=0.0;
if(border->width() > 0) { // move line to the left a bit to compensate for the left border
if(daCell) offset=daCell->leftBorder();
if ( row > 0 ) {
Cell *c = cell(row-1, col);
if(c) offset=kMax(offset, c->leftBorder());
}
}
startPos = m_colPositions[col] - offset;
}
}
col += daCell ? daCell->columnSpan() : 1;
}
if(pageBound!=m_pageBoundaries.end() && (*pageBound) == row)
pageBound++;
else
row++;
}
// *** draw vertical lines *** //
for (unsigned int col=0 ; col < m_colPositions.count(); col++) {
//kdDebug(32004) << "Vertical line code. col: " << col << endl;
bool right = false;
if(col == m_colPositions.count()-1)
right = true; // draw right border of cell.
int cellColumn = right?col-1:col; // the column we'll be looking for in the loop below
Q_ASSERT( cellColumn >= 0 );
const KoBorder *border = 0;
int startRow = -1;
for(unsigned int row=0; row <= getRows();) {
//kdDebug(32004) << "row=" << row << " cellColumn=" << cellColumn << endl;
Cell *daCell = row < getRows() ? cell(row, cellColumn) : 0;
//kdDebug(32004) << "Drawing vert. Line for cell row: " << row << " col: " << cellColumn << endl;
if(daCell && daCell->firstColumn() != (uint)cellColumn)
daCell=0;
#if 0
kdDebug() << "Condition: startRow:" << (startRow!=-1) << endl;
if ( startRow != -1 ) {
Q_ASSERT( border );
kdDebug() << "Other conditions: cell:" << !daCell << endl;
kdDebug() << " or last row:" << ( row == ( int )getRows() ) << endl;
if ( daCell )
kdDebug() << "Different border:" <<
( ( right && daCell->frame(0)->rightBorder() != *border) ||
( !right && daCell->frame(0)->leftBorder() != *border) )
<< endl;
}
#endif
// be sure that the right border of the table is drawn even for joined cells
if ( !daCell && startRow == -1 && cellColumn == ((int)m_colPositions.count()-2 ) && right )
{
// find the joined cell
int col = cellColumn;
while ( !daCell && col>0 )
{
col--;
daCell = cell(row, col);
}
if ( daCell && daCell->isJoinedCell() && ( (int)daCell->columnSpan() + col -1 ) == cellColumn )
{
border = &(daCell->frame(0)->rightBorder());
startRow = row;
}
else
daCell = 0;
}
// Draw when something changed (different kind of border) or we're at the end
// This code could be rewritten in a more TQRT-like way
// (iterate and compare with next, instead of the startRow/cell/border hack...)
if(startRow != -1 &&
(!daCell || row == getRows() ||
( right && daCell->frame(0)->rightBorder() != *border) ||
( !right && daCell->frame(0)->leftBorder() != *border) )
) {
if(border->width() > 0 || drawPreviewLines) {
double x = m_colPositions[col];
if(col==0) {
x+=border->width() / 2;
} else if(col==getColumns()) {
x-=border->width() / 2;
}
int xpix = m_doc->zoomItX(x);
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
unsigned int topRow=startRow;
//kdDebug(32004) << "Drawing from topRow=" << topRow << endl;
do { // draw minimum of one line per page.
while( pageBound != m_pageBoundaries.end() && *(pageBound) < topRow )
pageBound++;
unsigned int bottomRow;
if(pageBound == m_pageBoundaries.end())
bottomRow = m_rowPositions.count()-1;
else
bottomRow = *(pageBound++);
//kdDebug(32004) << "from: " << topRow << " to: " << kMin((uint)row, bottomRow) << endl;
//kdDebug(32004) << "from: " << m_rowPositions[topRow] << " to: " << m_rowPositions[kMin((uint)row, bottomRow)] << endl;
double offset=0.0;
if(border->width() > 0) {
//kdDebug(32004) << "looking at topRow=" << topRow << " col=" << col << endl;
Cell *c=cell(topRow,col);
if(c) offset=c->topBorder();
if ( col > 0 ) {
c=cell(topRow,col-1);
if(c) offset=kMax(offset,c->topBorder());
}
if(topRow==0) offset=0.0;
}
double top=m_rowPositions[topRow]-offset;
unsigned int toRow=kMin((uint)row,bottomRow);
offset=0.0;
if(border->width() > 0 && toRow!=bottomRow) {
if(daCell) offset=daCell->topBorder();
Cell *c=cell(toRow,col-1);
if(c) offset=kMax(offset,c->topBorder());
}
double bottom=m_rowPositions[toRow] + offset;
TQPoint topLeft = viewMode->normalToView(TQPoint(xpix, m_doc->zoomItY(top)));
TQPoint bottomRight = viewMode->normalToView(TQPoint(xpix, m_doc->zoomItY(bottom)));
TQRect line = TQRect(topLeft, bottomRight);
if(crect.intersects( line )) {
if(border->width() <= 0)
painter.setPen( previewLinePen );
else {
int borderWidth = KoBorder::zoomWidthX( border->width(), m_doc, minborder );
painter.setPen(KoBorder::borderPen( *border, borderWidth, defaultBorderColor ));
}
//kdDebug(32004) << "drawBorders(): painter.drawVerticalLine(" << line.left() << "," << line.top() << "," << line.right() << "," << line.bottom() << ")\n";
painter.drawLine( line.left(), line.top(), line.right(), line.bottom());
}
topRow=bottomRow+1;
} while(topRow < (uint)row && topRow != m_rowPositions.count());
} // end "if border to be drawn"
// reset startRow
startRow = -1;
}
if(daCell && startRow == -1) {
startRow = row;
if(right)
border = &(daCell->frame(0)->rightBorder());
else
border = &(daCell->frame(0)->leftBorder());
//kdDebug(32004) << "startRow set to " << row << endl;
}
row += daCell ? daCell->rowSpan() : 1;
//kdDebug(32004) << "End of loop, row=" << row << endl;
}
}
#if 0
if(drawPreviewLines) {
TQPen minsizeLinePen( red );
painter.setPen( minsizeLinePen );
for ( unsigned int i = 0; i < m_cells.count(); i++ ) {
Cell *daCell = m_cells.at( i );
double y = daCell->frame(0)->top() + daCell->frame(0)->minimumFrameHeight() + 1.5;
if(y >= daCell->frame(0)->bottom()) continue;
int ypix=m_doc->zoomItY(y);
TQPoint topLeft = viewMode->normalToView(TQPoint(m_doc->zoomItX(daCell->frame(0)->left()), ypix));
TQPoint bottomRight = viewMode->normalToView(TQPoint(m_doc->zoomItX(daCell->frame(0)->right()), ypix));
TQRect line = TQRect(topLeft, bottomRight);
if(crect.intersects( line )) {
painter.drawLine( line.left(), line.top(), line.right(), line.bottom());
}
}
}
#endif
painter.restore();
}
void KWTableFrameSet::drawContents( TQPainter * painter, const TQRect & crect,
const TQColorGroup & cg, bool onlyChanged, bool resetChanged,
KWFrameSetEdit * edit, KWViewMode * viewMode,
KWFrameViewManager *fvm )
{
for (TableIter cells(this) ; cells ; ++cells)
{
if (edit)
{
KWTableFrameSetEdit * tableEdit = static_cast<KWTableFrameSetEdit *>(edit);
if ( tableEdit->currentCell() && ((Cell*) cells) == tableEdit->currentCell()->frameSet() )
{
cells->drawContents( painter, crect, cg, onlyChanged, resetChanged, tableEdit->currentCell(), viewMode, fvm );
continue;
}
}
cells->drawContents( painter, crect, cg, onlyChanged, resetChanged, 0L, viewMode, fvm );
}
drawBorders( *painter, crect, viewMode );
//kdDebug(32004) << "drawContents()" << endl;
}
// Called by KWAnchor for inline tables
// TODO: for non-inline ones we need a text-box around us...
// Well, even for inline-as-char ones.... Currently being debated with OASIS.
void KWTableFrameSet::saveOasis( KoXmlWriter& writer, KoSavingContext& context, bool ) const
{
writer.startElement( "table:table" );
writer.addAttribute( "table:name", name() );
KoGenStyle tableStyle( KWDocument::STYLE_TABLE, "table" );
tableStyle.addProperty( "table:align", "margins" );
tableStyle.addPropertyPt( "style:width", m_colPositions.last()-m_colPositions[0] );
const TQString tableStyleName = context.mainStyles().lookup( tableStyle, "table" );
writer.addAttribute( "table:style-name", tableStyleName );
// ### to minimize the XML, we could use table:number-columns-repeated here
// when a number of consecutive columns have the exact same style.
for ( uint colNr = 0; colNr < getColumns(); ++colNr )
{
writer.startElement( "table:table-column" );
KoGenStyle columnStyle( KWDocument::STYLE_TABLE_COLUMN, "table-column" );
columnStyle.addPropertyPt( "style:column-width", m_colPositions[colNr+1] - m_colPositions[colNr] );
const TQString colStyleName = context.mainStyles().lookup( columnStyle, "col" );
writer.addAttribute( "table:style-name", colStyleName );
writer.endElement(); // table:table-column
}
// TODO table-header-rows once supported
for ( uint row = 0; row < getRows(); ++row )
{
writer.startElement( "table:table-row" );
KoGenStyle rowStyle( KWDocument::STYLE_TABLE_ROW, "table-row" );
rowStyle.addPropertyPt( "table:row-height", m_rowPositions[row+1] - m_rowPositions[row] );
// TODO is min-row-height or use-optimal-row-height necessary?
const TQString rowStyleName = context.mainStyles().lookup( rowStyle, "row" );
writer.addAttribute( "table:style-name", rowStyleName );
for ( uint col = 0; col < getColumns(); ++col )
{
Cell* daCell = cell(row, col);
Q_ASSERT( daCell );
if ( !daCell )
continue;
if ( daCell->isFirstGridPosnFast( row, col ) )
{
writer.startElement( "table:table-cell" );
// Style: background, border, padding.
KoGenStyle cellStyle( KWDocument::STYLE_TABLE_CELL_AUTO, "table-cell" );
daCell->frame( 0 )->saveBorderProperties( cellStyle );
const TQString colStyleName = context.mainStyles().lookup( cellStyle, "cell" );
writer.addAttribute( "table:style-name", colStyleName );
// Attributes
if ( daCell->columnSpan() > 1 )
writer.addAttribute( "table:number-columns-spanned", daCell->columnSpan() );
if ( daCell->rowSpan() > 1 )
writer.addAttribute( "table:number-row-spanned", daCell->rowSpan() );
// Content
daCell->saveOasisContent( writer, context );
writer.endElement(); // table:table-cell
}
else
{
// Empty element for the covered cell
writer.startElement( "table:covered-table-cell" );
writer.endElement();
}
}
writer.endElement(); // table:table-row
}
writer.endElement(); // table:table
}
void KWTableFrameSet::loadOasis( const TQDomElement& tableTag, KoOasisContext& context )
{
// Left position of each column. The last one defined is the right position of the last cell/column.
TQMemArray<double> columnLefts(4);
uint maxColumns = columnLefts.size() - 1;
uint col = 0;
columnLefts[0] = 0.0; // Initialize left of first cell
TQDomElement elem;
forEachElement( elem, tableTag )
{
if ( elem.localName() == "table-column" && elem.namespaceURI() == KoXmlNS::table )
{
uint repeat = elem.attributeNS( KoXmlNS::table, "number-columns-repeated", "1").toUInt(); // Default 1 time
if (!repeat)
repeat=1; // At least one column defined!
KoStyleStack& styleStack = context.styleStack();
styleStack.setTypeProperties( "table-column" );
styleStack.save();
context.fillStyleStack( elem, KoXmlNS::table, "style-name", "table-column" );
TQString strWidth = styleStack.attributeNS( KoXmlNS::style, "column-width" );
double width = KoUnit::parseValue( strWidth );
if ( width < 1.0 ) // Something is wrong with the width
{
kdWarning(32004) << "Table column width ridiculous, assuming 1 inch!" << endl;
width = 72.0;
}
else
kdDebug(32004) << "- style width " << width << endl;
for ( uint j = 0; j < repeat; ++j )
{
++col;
if ( col >= maxColumns )
{
// We need more columns
maxColumns += 4;
columnLefts.resize( maxColumns+1, TQGArray::SpeedOptim );
}
columnLefts[col] = width + columnLefts[col-1];
kdDebug(32004) << "Cell column " << col-1 << " left " << columnLefts[col-1] << " right " << columnLefts[col] << endl;
}
styleStack.restore();
}
}
uint row = 0;
uint column = 0;
parseInsideOfTable( tableTag, context, columnLefts, row, column, 0 );
}
void KWTableFrameSet::parseInsideOfTable( const TQDomElement& tqparent, KoOasisContext& context,
const TQMemArray<double> & columnLefts, uint& row, uint& column,
double currentRowHeight )
{
kdDebug(32004) << "parseInsideOfTable" << endl;
KoStyleStack& styleStack = context.styleStack();
TQDomElement e;
forEachElement( e, tqparent )
{
const TQString localName = e.localName();
const TQString ns = e.namespaceURI();
if ( ns != KoXmlNS::table ) {
kdWarning(32004) << "Skipping element " << e.tagName() << " (in parseInsideOfTable)" << endl;
continue;
}
styleStack.save();
if ( localName == "table-cell" )
{
loadOasisCell( e, context, columnLefts, row, column, currentRowHeight );
++column;
}
else if ( localName == "covered-table-cell" )
{
++column;
}
else if ( localName == "table-row" )
{
context.fillStyleStack( e, KoXmlNS::table, "style-name", "table-row" );
context.styleStack().setTypeProperties( "table-row" );
// Load row height in case it was set - note that it might not be set (e.g. OOo)
double rowHeight = styleStack.attributeNS( KoXmlNS::table, "row-height" ).toDouble();
column = 0;
parseInsideOfTable( e, context, columnLefts, row, column, rowHeight );
++row;
}
else if ( localName == "table-header-rows" ) // ###TODO
{
// TODO: do we need to fillStyleStack?
parseInsideOfTable( e, context, columnLefts, row, column, currentRowHeight );
}
else if ( localName == "table-column" )
{
// Already treated in loadOasis, we do not need to do anything here!
}
// TODO sub-table [ add to stack and expand at end of table loading ]
else
{
kdWarning(32004) << "Skipping element " << localName << " (in parseInsideOfTable)" << endl;
}
styleStack.restore();
}
}
void KWTableFrameSet::loadOasisCell( const TQDomElement& element, KoOasisContext& context,
const TQMemArray<double> & columnLefts, uint row, uint column,
double currentRowHeight )
{
//kdDebug(32004) << k_funcinfo << element.localName() << " " << row << "," << column << endl;
KoStyleStack& styleStack = context.styleStack();
uint rowSpan = element.attributeNS( KoXmlNS::table, "number-rows-spanned", TQString() ).toUInt();
if ( rowSpan == 0 )
rowSpan = 1;
uint colSpan = element.attributeNS( KoXmlNS::table, "number-columns-spanned", TQString() ).toUInt();
if ( colSpan == 0 )
colSpan = 1;
// m_rowPositions / m_colPositions could be TQMemArrays, or TQValueVectors...
while(m_rowPositions.count() <= row + rowSpan + m_pageBoundaries.count()) {
m_rowPositions.append(0);
}
while(m_colPositions.count() <= column + colSpan) {
m_colPositions.append(0);
}
Cell *daCell = new Cell( this, row, column, TQString() /*unused*/ );
daCell->setRowSpan( rowSpan );
daCell->setColumnSpan( colSpan );
addCell( daCell ); // rowSpan/colSpan have changed -> update array
double width = columnLefts[ TQMIN( column+colSpan, columnLefts.size()-1 ) ] - columnLefts[column];
double height = currentRowHeight > 0 ? currentRowHeight : 20;
KWFrame* frame = new KWFrame( daCell, columnLefts[column], 0, width, height );
if ( currentRowHeight > 0 )
frame->setMinimumFrameHeight( height ); // ensure that text formatting won't resize it down
frame->setRunAround( KWFrame::RA_NO );
frame->setFrameBehavior( KWFrame::AutoExtendFrame );
frame->setNewFrameBehavior( KWFrame::NoFollowup );
daCell->addFrame( frame, false );
context.fillStyleStack( element, KoXmlNS::table, "style-name", "table-cell" );
styleStack.setTypeProperties( "table-cell" );
daCell->frame( 0 )->loadBorderProperties( styleStack );
daCell->loadOasisContent( element, context );
afterLoadingCell( daCell );
}
// Old XML
TQDomElement KWTableFrameSet::save( TQDomElement &parentElem, bool saveFrames ) {
// When saving to a file, we don't have anything specific to the frameset to save.
// Save the cells only.
for (TableIter cells(this) ; cells ; ++cells)
cells->save(parentElem, saveFrames);
return TQDomElement(); // No englobing element for tables...
}
// Old XML
TQDomElement KWTableFrameSet::toXML( TQDomElement &parentElem, bool saveFrames )
{
TQDomElement framesetElem = parentElem.ownerDocument().createElement( "FRAMESET" );
parentElem.appendChild( framesetElem );
KWFrameSet::saveCommon( framesetElem, false ); // Save the frameset attributes
// Save the cells
save( framesetElem, saveFrames );
return framesetElem;
}
// Old XML
void KWTableFrameSet::fromXML( TQDomElement &framesetElem, bool loadFrames, bool useNames )
{
KWFrameSet::load( framesetElem, false ); // Load the frameset attributes
// Load the cells
TQDomElement cellElem = framesetElem.firstChild().toElement();
for ( ; !cellElem.isNull() ; cellElem = cellElem.nextSibling().toElement() )
{
if ( cellElem.tagName() == "FRAMESET" )
loadCell( cellElem, loadFrames, useNames );
}
}
// Old XML
KWTableFrameSet::Cell* KWTableFrameSet::loadCell( TQDomElement &framesetElem, bool loadFrames, bool useNames )
{
int _row = KWDocument::getAttribute( framesetElem, "row", 0 );
if(_row <0) _row =0;
unsigned int row=_row;
int _col = KWDocument::getAttribute( framesetElem, "col", 0 );
if(_col <0) _col =0;
int _rows = KWDocument::getAttribute( framesetElem, "rows", 1 );
if(_rows <0) _rows = 1;
int _cols = KWDocument::getAttribute( framesetElem, "cols", 1 );
if(_cols <0) _cols = 1;
// m_rowPositions / m_colPositions could be TQMemArrays, or TQValueVectors...
while(m_rowPositions.count() <= static_cast<unsigned int>(row + _rows + m_pageBoundaries.count())) {
m_rowPositions.append(0);
}
while(m_colPositions.count() <= static_cast<unsigned int>(_col + _cols)) {
m_colPositions.append(0);
}
Cell *daCell = new Cell( this, row, _col, TQString() /*unused*/ );
TQString autoName = daCell->name();
//kdDebug(32004) << "KWTableFrameSet::loadCell autoName=" << autoName << endl;
daCell->load( framesetElem, loadFrames );
daCell->setRowSpan(_rows);
daCell->setColumnSpan(_cols);
addCell( daCell ); // rowSpan/colSpan have changed -> update array
afterLoadingCell( daCell );
if ( !useNames )
daCell->setName( autoName );
return daCell;
}
// Shared between old xml and oasis
void KWTableFrameSet::afterLoadingCell( Cell* daCell )
{
uint row = daCell->firstRow();
uint col = daCell->firstColumn();
uint rowSpan = daCell->rowSpan();
uint colSpan = daCell->columnSpan();
if(m_pageBoundaries.count() > 0) {
unsigned int adjustment=0;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
while(pageBound != m_pageBoundaries.end() && (*pageBound) <= row + adjustment) {
adjustment++;
pageBound++;
}
row+=adjustment;
}
kdDebug(32004) << "loading cell (" << row << "," << col << ")\n";
if(daCell->frame(0)) {
daCell->frame(0)->setMinimumFrameHeight(daCell->frame(0)->height()); // TODO run the formatter over the text here
TQValueList<double>::iterator tmp = m_colPositions.at(col);
if(*tmp == 0) (*tmp) = daCell->frame(0)->left();
else (*tmp) = (daCell->frame(0)->left() + *tmp) / 2;
tmp = m_colPositions.at(col+colSpan);
if(*tmp == 0) (*tmp) = daCell->frame(0)->right();
else (*tmp) = (daCell->frame(0)->right() + *tmp) / 2;
tmp = m_rowPositions.at(row);
if(*tmp == 0)
(*tmp) = daCell->frame(0)->top();
else {
if (static_cast<int>(*tmp/m_doc->pageLayout().ptHeight) < static_cast<int>(daCell->frame(0)->top()/m_doc->pageLayout().ptHeight)) {
kdDebug(32004) << "This cell is on a new page" << endl;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
while(pageBound != m_pageBoundaries.end() && (*pageBound) < row) ++pageBound;
if(*pageBound!=row) {
m_pageBoundaries.insert(pageBound,row++);
++tmp;
m_rowPositions.insert(tmp,daCell->frame(0)->top());
}
} else
(*tmp) = (daCell->frame(0)->top() + *tmp) / 2;
}
tmp = m_rowPositions.at( row + rowSpan );
if(*tmp == 0)
(*tmp) = daCell->frame(0)->bottom();
else { // untested...
if (static_cast<int>(*tmp/m_doc->pageLayout().ptHeight) > static_cast<int>(daCell->frame(0)->top()/m_doc->pageLayout().ptHeight)) {
kdDebug(32004) << "next cell is on a new page" << endl;
TQValueList<unsigned int>::iterator pageBound = m_pageBoundaries.begin();
while(pageBound != m_pageBoundaries.end() && (*pageBound) < row) ++pageBound;
if(*pageBound!=row) {
m_pageBoundaries.insert(pageBound,row++);
m_rowPositions.insert(tmp,daCell->frame(0)->bottom());
}
} else
(*tmp) = (daCell->frame(0)->bottom() + *tmp) / 2;
}
}
if ( m_rowPositions.count() != m_rows + 1 ) {
kdDebug() << name() << " loadCell: m_rowPositions=" << m_rowPositions.count() << " m_rows= " << m_rows << endl;
}
}
int KWTableFrameSet::paragraphs()
{
int paragraphs = 0;
for (TableIter cells(this) ; cells ; ++cells)
paragraphs += cells->paragraphs();
return paragraphs;
}
int KWTableFrameSet::paragraphsSelected()
{
int paragraphs = 0;
for (TableIter cells(this) ; cells ; ++cells)
paragraphs += cells->paragraphsSelected();
return paragraphs;
}
bool KWTableFrameSet::statistics( TQProgressDialog *progress, ulong & charsWithSpace, ulong & charsWithoutSpace, ulong & words,
ulong & sentences, ulong & syllables, ulong & lines, bool selected )
{
for (TableIter cells(this) ; cells ; ++cells)
if( ! cells->statistics( progress, charsWithSpace, charsWithoutSpace, words, sentences, syllables, lines, selected ) )
{
return false;
}
return true;
}
void KWTableFrameSet::finalize( ) {
kdDebug(32004) << "KWTableFrameSet::finalize" << endl;
for (TableIter cells(this) ; cells ; ++cells)
{
position( cells );
cells->finalize();
}
recalcCols(0, 0);
recalcRows(0, 0);
KWFrameSet::finalize();
}
void KWTableFrameSet::tqlayout()
{
for (TableIter cells(this) ; cells ; ++cells)
cells->tqlayout();
}
void KWTableFrameSet::tqinvalidate()
{
for (TableIter cells(this) ; cells ; ++cells)
cells->tqinvalidate();
}
void KWTableFrameSet::setVisible( bool v )
{
for (TableIter cells(this) ; cells ; ++cells)
cells->setVisible( v );
KWFrameSet::setVisible( v );
}
bool KWTableFrameSet::canRemovePage( int num ) {
/* This one is a lot simpler then the one it overrides, we simply don't have
to check if the frame contains something, the simple existence of a frame
is enough
*/
TQPtrListIterator<KWFrame> frameIt( frameIterator() );
for ( ; frameIt.current(); ++frameIt ) {
if ( frameIt.current()->pageNumber() == num ) {
return false;
}
}
return true;
}
void KWTableFrameSet::addTextFrameSets( TQPtrList<KWTextFrameSet> & lst, bool onlyReadWrite )
{
for (TableIter cells(this) ; cells ; ++cells)
if (!cells->textObject()->protectContent() || onlyReadWrite )
lst.append(cells);
}
KWTextFrameSet* KWTableFrameSet::nextTextObject( KWFrameSet *obj )
{
bool found = false;
KWTableFrameSet::Cell *tmp = dynamic_cast<KWTableFrameSet::Cell *>(obj);
// make sure we have this cell
if ( tmp ) {
for(TableIter i(this); i; ++i) {
if(i.current() == tmp) {
found = true;
break;
}
}
}
TableIter iter(this);
if(found)
iter.goToCell(tmp);
for(; iter; ++iter) {
KWTextFrameSet *newFrm = iter->nextTextObject( obj );
if(newFrm && newFrm->textObject()->needSpellCheck())
return newFrm;
}
return 0L;
}
void KWTableFrameSet::setZOrder()
{
for( TableIter cells(this) ; cells ; ++cells ) {
cells->setZOrder();
}
}
// TODO provide toPlainText() (reimplemented from KWFrameSet)
TQByteArray KWTableFrameSet::convertTableToText() // should be const, but TableIter doesn't allow it
{
KWOasisSaver oasisSaver( m_doc );
for (TableIter cells(this); cells; ++cells)
{
cells->textObject()->saveOasisContent( oasisSaver.bodyWriter(), oasisSaver.savingContext() );
}
if ( !oasisSaver.finish() )
return TQByteArray();
return oasisSaver.data();
}
#ifndef NDEBUG
void KWTableFrameSet::printDebug( KWFrame * theFrame )
{
KWTableFrameSet::Cell *daCell = dynamic_cast<KWTableFrameSet::Cell *>( theFrame->frameSet() );
Q_ASSERT( daCell );
if ( daCell ) {
kdDebug(32004) << " | |- row :" << daCell->firstRow() << endl;
kdDebug(32004) << " | |- col :" << daCell->firstColumn() << endl;
kdDebug(32004) << " | |- rows:" << daCell->rowSpan() << endl;
kdDebug(32004) << " | +- cols:" << daCell->columnSpan() << endl;
}
}
void KWTableFrameSet::printArrayDebug() {
kdDebug(32004) << " | Row/Cell arrays" << endl;
Q_ASSERT( m_rows == m_rowArray.size() );
for ( unsigned int row = 0; row < m_rows; ++row ) {
TQString str = TQString( " | Row %1: " ).tqarg( row );
for ( unsigned int col = 0; col < getColumns(); ++col )
str += TQString("| 0x%1 ").tqarg( (unsigned long)(*m_rowArray[row])[col], 0, 16 );
kdDebug(32004) << str<< " |" << endl;
}
}
void KWTableFrameSet::printDebug() {
kdDebug(32004) << " | Table size (" << m_rows << "x" << getColumns() << ")" << endl;
kdDebug(32004) << " | col " << 0 << ": " << m_colPositions[0] << endl;
for(unsigned int i=1;i<m_colPositions.count(); ++i)
kdDebug(32004) << " | | " << i << ": " << m_colPositions[i] << endl;
kdDebug(32004) << " | row " << 0 << ": " << m_rowPositions[0] << endl;
for(unsigned int i=1;i<m_rowPositions.count(); ++i)
kdDebug(32004) << " | | " << i << ": " << m_rowPositions[i] << endl;
printArrayDebug();
KWFrameSet::printDebug();
}
#endif
// ===
KWTableFrameSet::Cell::Cell( KWTableFrameSet *table, unsigned int row, unsigned int col, const TQString &/*name*/ ) :
KWTextFrameSet( table->m_doc,
// Generate frameset name from table_name+row+col
i18n("Hello dear translator :), 1 is the table name, 2 and 3 are row and column", "%1 Cell %2,%3")
.tqarg( table->name() ).tqarg(row).tqarg(col) )
{
m_row = row;
m_col = col;
m_rows = 1;
m_cols = 1;
m_isJoinedCell = false;
setGroupManager( table );
table->addCell( this );
}
KWTableFrameSet::Cell::Cell( KWTableFrameSet *table, const Cell &original ) :
KWTextFrameSet( table->m_doc, original.m_name+'_' )
{
m_row = original.m_row;
m_col = original.m_col;
m_rows = original.m_rows;
m_cols = original.m_cols;
m_isJoinedCell = original.m_isJoinedCell;
setGroupManager( table );
table->addCell( this );
}
KWTableFrameSet::Cell::~Cell()
{
}
bool KWTableFrameSet::Cell::isAboveOrLeftOf( unsigned row, unsigned col ) const
{
return ( m_row < row ) || ( ( m_row == row ) && ( m_col < col ) );
}
bool KWTableFrameSet::Cell::containsCell( unsigned row, unsigned col ) const
{
return ( m_row <= row &&
m_col <= col &&
rowAfter() > row &&
columnAfter() > col );
}
void KWTableFrameSet::Cell::addFrame(KWFrame *_frame, bool recalc) {
if(groupmanager())
groupmanager()->addFrame(_frame, recalc);
KWTextFrameSet::addFrame(_frame, recalc);
}
void KWTableFrameSet::Cell::frameDeleted( KWFrame* frm, bool recalc )
{
if(groupmanager())
groupmanager()->deleteFrame( frm, false, recalc );
}
double KWTableFrameSet::Cell::leftBorder() {
double b = frame(0)->leftBorder().width();
if(b==0.0)
return 0.0;
if(m_col==0) // left most cell
return b;
return (b / 2);
}
double KWTableFrameSet::Cell::rightBorder() {
double b=frame(0)->rightBorder().width();
if(b==0.0)
return 0.0;
if(m_col+m_cols==m_groupmanager->getColumns()) // right most cell
return b;
return (b / 2);
}
double KWTableFrameSet::Cell::topBorder() {
double b = frame(0)->topBorder().width();
if(b==0.0)
return 0.0;
if(m_row==0) // top most cell
return b;
return (b / 2);
}
double KWTableFrameSet::Cell::bottomBorder() {
double b = frame(0)->bottomBorder().width();
if(b==0.0)
return 0.0;
if(rowAfter() == m_groupmanager->m_rows) // bottom most cell
return b;
return (b / 2);
}
void KWTableFrameSet::Cell::setLeftBorder(KoBorder newBorder) {
KWFrame *f = frame(0);
double diff = f->leftBorder().width() - newBorder.width();
f->setLeftBorder(newBorder);
if((diff > 0.01 || diff < -0.01) && m_col!=0) {
diff = diff / 2; // if not outer edge only use halve
m_groupmanager->cell(m_row, m_col-1)->setRightBorder(newBorder);
}
f->setLeft(f->left() - diff);
}
void KWTableFrameSet::Cell::setRightBorder(KoBorder newBorder) {
KWFrame *f = frame(0);
double diff = f->rightBorder().width() - newBorder.width();
f->setRightBorder(newBorder);
if((diff > 0.01 || diff < -0.01) && m_col+m_cols!=m_groupmanager->getColumns()) {
diff = diff / 2; // if not outer edge only use halve
m_groupmanager->cell(m_row, m_col+1)->setLeftBorder(newBorder);
}
f->setRight(f->right() + diff);
}
void KWTableFrameSet::Cell::setTopBorder(KoBorder newBorder) {
KWFrame *f = frame(0);
double diff = f->topBorder().width() - newBorder.width();
f->setTopBorder(newBorder);
if((diff > 0.01 || diff < -0.01) && m_row!=0) {
diff = diff / 2; // if not outer edge only use halve
m_groupmanager->cell(m_row-1, m_col)->setBottomBorder(newBorder);
}
f->setTop(f->top() - diff);
}
void KWTableFrameSet::Cell::setBottomBorder(KoBorder newBorder) {
KWFrame *f = frame(0);
double diff = f->bottomBorder().width() - newBorder.width();
f->setBottomBorder(newBorder);
if((diff > 0.01 || diff < -0.01) && rowAfter() != m_groupmanager->m_rows) {
diff = diff / 2; // if not outer edge only use halve
m_groupmanager->cell(m_row+1, m_col)->setTopBorder(newBorder);
}
f->setBottom(f->bottom() + diff);
}
void KWTableFrameSet::Cell::setZOrder()
{
TQPtrListIterator<KWFrame> frameIt = frameIterator();
for ( ; frameIt.current(); ++frameIt )
{
(*frameIt)->setZOrder( kWordDocument()->maxZOrder( (*frameIt)->pageNumber() ) + 1 );
}
}
void KWTableFrameSet::Cell::drawContents( TQPainter * painter, const TQRect & crect,
const TQColorGroup & cg, bool onlyChanged, bool resetChanged,
KWFrameSetEdit * edit, KWViewMode * viewMode, KWFrameViewManager *fvm )
{
bool printing = painter->device()->devType() == TQInternal::Printer;
bool drawPreviewLines = viewMode && viewMode->drawFrameBorders();
TQRect cellRect = crect;
if(!printing && drawPreviewLines) {
// Make sure the clipping is changed so the preview lines (frame borders) are not overwritten.
TQRect zoomedRect( m_doc->zoomRect(*frame(0)) );
TQRect innerFrameRect( viewMode->normalToView( zoomedRect ) );
innerFrameRect.addCoords(1, 1, -1, -1); // move and shrink
cellRect = innerFrameRect.intersect(crect);
}
KWTextFrameSet::drawContents(painter, cellRect, cg, onlyChanged, resetChanged, edit, viewMode, fvm);
}
KWTableFrameSetEdit::~KWTableFrameSetEdit()
{
if ( m_currentCell )
m_currentCell->terminate();
delete m_currentCell;
}
void KWTableFrameSetEdit::mousePressEvent( TQMouseEvent * e, const TQPoint & nPoint, const KoPoint & dPoint )
{
setCurrentCell( dPoint );
if ( m_currentCell )
m_currentCell->mousePressEvent( e, nPoint, dPoint );
}
void KWTableFrameSetEdit::setCurrentCell( const KoPoint & dPoint )
{
KWFrameSet *fs = tableFrameSet()->cellByPos( dPoint.x(), dPoint.y() );
KWTextFrameSet *textframeSet = dynamic_cast<KWTextFrameSet *>(fs);
if ( textframeSet&& textframeSet->protectContent() && !tableFrameSet()->kWordDocument()->cursorInProtectedArea())
return;
if ( fs && ( !m_currentCell || fs != m_currentCell->frameSet() ) )
setCurrentCell( fs );
}
void KWTableFrameSetEdit::setCurrentCell( KWFrameSet * fs, bool eraseSelection )
{
bool oldProtectContent = false;
KWTextFrameSet *textframeSet=0L;
if ( m_currentCell )
textframeSet = dynamic_cast<KWTextFrameSet *>(m_currentCell->frameSet());
if ( textframeSet )
oldProtectContent = textframeSet->protectContent();
if ( m_currentCell )
{
m_currentCell->terminate(eraseSelection);
delete m_currentCell;
}
m_currentCell = fs->createFrameSetEdit( m_canvas );
textframeSet = dynamic_cast<KWTextFrameSet *>(m_currentCell->frameSet());
if ( textframeSet )
{
if ( oldProtectContent != textframeSet->protectContent())
{
m_canvas->kWordDocument()->updateTextFrameSetEdit();
}
}
m_currentFrame = fs->frame( 0 );
KWTextFrameSetEdit *textframeSetEdit = dynamic_cast<KWTextFrameSetEdit *>(m_currentCell);
if ( textframeSetEdit )
{
textframeSetEdit->ensureCursorVisible();
//refresh koruler
m_canvas->gui()->getView()->slotUpdateRuler();
}
}
KWFrameSetEdit* KWTableFrameSetEdit::currentTextEdit()
{
return m_currentCell;
}
void KWTableFrameSetEdit::keyPressEvent( TQKeyEvent * e )
{
// This method handles the up/left/down/right navigation keys in tables
if ( !m_currentCell )
return;
KWTableFrameSet::Cell *cell = static_cast<KWTableFrameSet::Cell *>(m_currentCell->frameSet());
KWTextFrameSet *textframeSet = dynamic_cast<KWTextFrameSet *>(m_currentCell->frameSet());
bool moveToOtherCell = true;
if(textframeSet)
{
// don't move to an adjacent cell when we are selecting text
KoTextDocument * textdoc = textframeSet->textDocument();
if(textdoc->hasSelection( KoTextDocument::Standard ))
moveToOtherCell=false;
}
KWTableFrameSet::Cell *fs = 0L;
bool tab=false; // No tab key pressed
if(moveToOtherCell)
{
switch( e->key() ) {
case TQt::Key_Up:
{
if(!(static_cast<KWTextFrameSetEdit *>(m_currentCell))->cursor()->parag()->prev())
{
KWTableFrameSet* tableFrame=tableFrameSet();
int row = cell->firstRow() - 1;
int col = cell->firstColumn();
if (row < 0) { // Wrap at top of table
col--; // Goes to column on the left
row = tableFrame->getRows() - 1;
}
if (col < 0) { // It was the first column
// Maybe exit the table instead?
col = tableFrame->getColumns() - 1;
row = tableFrame->getRows() - 1;
}
fs=tableFrame->cell(row,col);
// Not needed. cell gives us the right one already
//if (fs && fs->firstRow() != static_cast<unsigned int>(row)) { // Merged cell
// fs=tableFrame->cell( row - fs->rowSpan() + 1, col );
//}
}
}
break;
case TQt::Key_Down:
{
if(!(static_cast<KWTextFrameSetEdit *>(m_currentCell))->cursor()->parag()->next())
{
KWTableFrameSet* tableFrame=tableFrameSet();
unsigned int row = cell->rowAfter();
unsigned int col = cell->firstColumn();
if(row >= tableFrame->getRows()) { // Wrap at bottom of table
row=0;
col++; // Go to next column
}
if(col >= tableFrame->getColumns()) { // It was the last one
// Maybe exit the table instead?
col=0;
row=0;
}
fs=tableFrame->cell(row,col);
Q_ASSERT( fs );
Q_ASSERT( fs->firstRow() == row ); // We can't end up in the middle of a merged cell here.
}
}
break;
case TQt::Key_Backtab:
tab=true;
if (e->state() & TQt::ControlButton)
break; // Break if tab was pressed with Control (in *any* key combination)
// Do not break
case TQt::Key_Left:
{
KoTextCursor *cur = (static_cast<KWTextFrameSetEdit *>(m_currentCell))->cursor();
if ( tab || (!cur->parag()->prev()&&cur->index()==0) )
{
KWTableFrameSet* tableFrame=tableFrameSet();
int row=cell->firstRow();
int col=cell->firstColumn() - 1;
if(col < 0) { // Wrap at first column
col = (int)tableFrame->getColumns()-1;
row--; // Go up
}
if(row < 0) { // It was the first row
// Maybe exit the table instead?
col = (int)tableFrame->getColumns()-1;
row = (int)tableFrame->getRows()-1;
}
fs=tableFrame->cell(row,col);
// Not needed. cell gives us the right one already
//if(fs && (int)fs->m_col != col) { // Merged cell
// fs=tableFrame->cell( row, col - fs->columnSpan() + 1 );
//}
}
}
break;
case TQt::Key_Tab:
tab=true;
if (e->state() & TQt::ControlButton)
break; // Break if tab was pressed with Control (in *any* key combination)
// Do not break
case TQt::Key_Right:
{
KoTextCursor *cur = (static_cast<KWTextFrameSetEdit *>(m_currentCell))->cursor();
if( tab || (!cur->parag()->next()&&cur->index()==cur->parag()->string()->length()-1) )
{
KWTableFrameSet* tableFrame=tableFrameSet();
unsigned int row = cell->firstRow();
unsigned int col = cell->columnAfter();
if(col >= tableFrame->getColumns()) { // Wrap after last column
col = 0;
row++; // Go down one row
}
if(row >= tableFrame->getRows()) { // It was the last row
// Maybe exit the table instead?
col = 0;
row = 0;
}
fs=tableFrame->cell(row,col);
Q_ASSERT( fs );
Q_ASSERT( fs->firstRow() == row ); // We can't end up in the middle of a merged cell here.
}
}
break;
}
}
if ( fs )
{
//don't switch to a protected cell protected when cursor in protected areas was disabled.
if ( fs->textObject()->protectContent() && !tableFrameSet()->kWordDocument()->cursorInProtectedArea())
return;
setCurrentCell( fs );
}
else if ( textframeSet )
{
if ( !textframeSet->textObject()->protectContent() )
{
if (tab && (e->state() & TQt::ControlButton) )
{
TQKeyEvent event(TQEvent::KeyPress, TQt::Key_Tab, 9, 0, TQChar(9));
m_currentCell->keyPressEvent( &event );
}
else
m_currentCell->keyPressEvent( e );
}
else if(e->text().length() > 0)
KMessageBox::information(0L, i18n("Read-only content cannot be changed. No modifications will be accepted."));
}
}
void KWTableFrameSetEdit::keyReleaseEvent( TQKeyEvent * e )
{
if ( m_currentCell )
m_currentCell->keyReleaseEvent( e );
}
void KWTableFrameSetEdit::imStartEvent( TQIMEvent* e )
{
if ( m_currentCell )
m_currentCell->imStartEvent( e );
}
void KWTableFrameSetEdit::imComposeEvent( TQIMEvent* e )
{
if ( m_currentCell )
m_currentCell->imComposeEvent( e );
}
void KWTableFrameSetEdit::imEndEvent( TQIMEvent* e )
{
if ( m_currentCell )
m_currentCell->imEndEvent( e );
}
void KWTableFrameSetEdit::dragMoveEvent( TQDragMoveEvent * e, const TQPoint &n, const KoPoint &d )
{
kdDebug(32004)<<"m_currentCell :"<<m_currentCell<<endl;
if ( m_currentCell )
{
KWFrameSet *fs = tableFrameSet()->cellByPos( d.x(), d.y() );
kdDebug(32004)<<"fs :"<<fs <<endl;
if(fs && fs != m_currentCell->frameSet())
setCurrentCell(fs, false);
if(m_currentCell)
m_currentCell->dragMoveEvent( e, n, d );
}
else
{
setCurrentCell( d );
kdDebug(32004)<<"after m_currentCell :"<<m_currentCell<<endl;
if(m_currentCell)
m_currentCell->dragMoveEvent( e, n, d );
}
}
void KWTableFrameSet::Row::addCell( Cell *cell )
{
if ( m_cellArray.size() < cell->columnAfter())
m_cellArray.resize( cell->columnAfter() );
for ( uint col = cell->firstColumn() ; col < cell->columnAfter(); ++col )
m_cellArray.insert( col, cell );
}
void KWTableFrameSet::Row::removeCell( Cell* cell )
{
for ( uint col = cell->firstColumn() ; col < cell->columnAfter(); ++col )
m_cellArray.remove( col );
}
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::VISIT_CELL>::operator++()
{
if(!m_cell) return 0;
Cell *ret = m_cell;
do{
// check for end of row first
if(m_table->cell(m_row,m_col)->lastColumn() >= m_limit[RIGHT] ) {
// now check for end of column
if (m_row >= m_limit[LOW]){
// at end of traversal
m_cell = 0;
break;
}
else {
// goto first grid position in next row
m_row += 1;
m_col = m_limit[LEFT];
}
}
else {
// goto next cell in row
m_col = m_table->cell(m_row, m_col)->columnAfter();
}
m_cell = m_table->cell(m_row,m_col);
} while( m_cell && !m_cell->isFirstGridPosnFast(m_row,m_col) );
return ret;
}
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::VISIT_GRID>::operator++()
{
if(!m_cell) return 0;
Cell *ret = m_cell;
// check for end of row
if(m_col == m_limit[RIGHT]) {
if(m_row == m_limit[LOW]) { // end of traversal
m_row = 0;
m_col = 0;
m_cell = 0;
}
else { // go to next row
m_row += 1;
m_col = m_limit[LEFT];
m_cell = m_table->cell(m_row, m_col);
}
}
else { // move to next cell in row
m_col += 1;
m_cell = m_table->cell(m_row, m_col);
}
return ret;
}
KWTableFrameSet::MarkedIterator::MarkedIterator(KWTableFrameSet *table) :
GridIter(table)
{
// clear all the cell marks
for(GridIter cell(table); cell; ++cell)
cell->clearMark();
if ( current() ) {
// kdDebug() << "MarkedIterator: visit: "
// << TQString("| 0x%1 ").tqarg((unsigned long)current(), 0, 16) << endl;
current()->setMark();
}
}
KWTableFrameSet::Cell *
KWTableFrameSet::MarkedIterator::operator++()
{
Cell *ret = GridIter::operator++();
while ( current() && current()->marked() ) {
GridIter::operator++();
}
if ( current() ) {
// kdDebug() << "MarkedIterator: visit: "
// << TQString("| 0x%1 ").tqarg((unsigned long)current(), 0, 16) << endl;
current()->setMark();
}
return ret;
}
template<>
KWTableFrameSet::TableIterator<KWTableFrameSet::CHECKED>::TableIterator(KWTableFrameSet *table):
m_table(table)
{
Q_ASSERT(m_table);
set_limits(0, (int)m_table->getColumns() - 1, 0, (int)m_table->getRows() - 1);
Cell *c = 0;
for(uint i = m_limit[HIGH]; i <= m_limit[LOW]; ++i)
for(uint j = m_limit[LEFT]; j <= m_limit[RIGHT]; ++j) {
c = m_table->cell(i,j);
if(c) c->clearMark();
}
toFirstCell();
}
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::CHECKED>::operator++ ()
{
Cell *ret = m_cell;
if(!ret) return 0;
ret->setMark();
m_cell = 0;
uint i = m_row; uint j = m_col;
for(; i <= m_limit[LOW]; ++i) {
for(j = 0; j <= m_limit[RIGHT]; ++j) {
m_cell = m_table->cell(i,j);
if( m_cell && !m_cell->marked() ){
m_row = i; m_col = j;
goto out;
}
else if(i == m_limit[LOW] && j == m_limit[RIGHT]){
m_cell = 0;
goto out;
}
}
}
out:
return ret;
}
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::CHECKED>::toFirstCell ()
{
m_cell = 0;
for(uint i = m_limit[HIGH]; i <= m_limit[LOW]; ++i)
for(uint j = m_limit[LEFT]; j <= m_limit[RIGHT]; ++j) {
m_cell = m_table->cell(i,j);
if(m_cell) {
m_row = i; m_col = j;
goto out;
}
}
out:
return m_cell;
}
RemovedRow::RemovedRow() :
m_row(0), m_index(0), m_rowHeight(0.0)
{
}
RemovedRow::~RemovedRow()
{
// free cells as well ???
delete m_row;
}
KWTableFrameSet::Row *RemovedRow::takeRow()
{
Q_ASSERT(m_row);
KWTableFrameSet::Row *ret = m_row;
m_row = 0;
return ret;
}
RemovedColumn::RemovedColumn()
: m_column(), m_removed(), m_index(0), m_width(0), m_initialized(false){ }
#include "KWTableFrameSet.moc"