KWTableFrameSet.h

#ifndef KWTABLEFRAMESET_H
#define KWTABLEFRAMESET_H
/*
    Copyright (C) 2001, S.R.Haque (srhaque@iee.org).
    This file is part of the KDE project
 
    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 defines KWord tables. A table is a KWFrameSet, thus allowing its
    internal structure to be invisible to the rest of kword. This is useful
    since the internal structure of a table is itself a series of KWFrameSets
    (one for each cell).
*/
 
#include "KWFrame.h"
#include "KWTextFrameSet.h"
 
#include <tqptrlist.h>
#include <tqvaluevector.h>
#include <tqobject.h>
#include <tqstring.h>
#include <KoRichText.h>
 
class KWDocument;
class KWTableFrameSetEdit;
class TQPainter;
class KWAnchor;
class KWordFrameSetIface;
class KWFrameViewManager;
 
class RemovedRow;
class RemovedColumn;
 
class KWTableFrameSet : public KWFrameSet
{
    TQ_OBJECT
  
public:
 
    class Cell : public KWTextFrameSet
    {
        unsigned int m_row, m_col;
        unsigned int m_rows, m_cols;
 
        bool m_isJoinedCell;
        bool m_marker;
        void calcIfJoinedCell() {
            m_isJoinedCell = ( (m_rows > 1) || (m_cols > 1) );
        }
 
    public:
        Cell( KWTableFrameSet *table, unsigned int row, unsigned int col, const TQString & name = TQString() );
        Cell( KWTableFrameSet *table, const Cell &original );
        // destructor
        virtual ~Cell();
 
        uint firstRow() const { return m_row; }
        uint firstColumn() const { return m_col; }
        uint rowSpan() const { return m_rows; }
        uint columnSpan() const { return m_cols; }
 
        uint lastRow() const { return m_row + m_rows - 1; }
        uint lastColumn() const { return m_col + m_cols - 1; }
        uint rowAfter() const { return m_row + m_rows; }
        uint columnAfter() const { return m_col + m_cols; }
 
        void setFirstRow(uint row) { m_row = row; }
        void setFirstColumn(uint col) { m_col = col; }
        void setRowSpan(uint rows) {
            m_rows = rows;
            calcIfJoinedCell();
        }
        void setColumnSpan(uint cols) {
            m_cols = cols;
            calcIfJoinedCell();
        }
 
        bool isFirstGridPosn(uint row, uint col) const {
            return (row == m_row) && (col == m_col);
        }
 
        bool isFirstGridPosnFast(uint row, uint col) const {
                if(!m_isJoinedCell) return true;
                return (row == m_row) && (col == m_col);
        }
        virtual void addFrame(KWFrame *_frame, bool recalc = true);
        virtual void frameDeleted( KWFrame* frm, bool recalc );
 
        bool isAboveOrLeftOf( unsigned row, unsigned column ) const;
        bool containsCell( unsigned row, unsigned column ) const;
 
        double leftBorder();
        double rightBorder();
        double topBorder();
        double bottomBorder();
 
        void setLeftBorder(KoBorder newBorder);
        void setRightBorder(KoBorder newBorder);
        void setTopBorder(KoBorder newBorder);
        void setBottomBorder(KoBorder newBorder);
        void setZOrder();
        bool isJoinedCell() const { return m_isJoinedCell; }
        void clearMark() { m_marker = false; }
        void setMark() { m_marker = true; }
        bool marked() const { return m_marker; }
 
        void drawContents( TQPainter *painter, const TQRect & crect,
                const TQColorGroup & cg, bool onlyChanged, bool resetChanged,
                KWFrameSetEdit * edit, KWViewMode * viewMode,
                KWFrameViewManager *frameViewManager );
 
    };
    friend class Cell;
 
    class Row {
    public:
        Cell* operator[] ( uint i ) const { return i < size() ? m_cellArray[i] : 0; }
        uint size() const { return m_cellArray.size(); }
        uint count() const { return m_cellArray.count(); }
 
        void addCell( Cell *cell );
        void removeCell( Cell* cell );
 
        TQPtrVector< Cell > m_cellArray;
 
    };
 
    enum VisitType {
        VISIT_GRID = 1,
 
        VISIT_CELL = 2,
        CHECKED = 3
    };
 
    template<int VisitStyle = VISIT_CELL>
    class TableIterator {
    public:
        TableIterator (KWTableFrameSet *table);
 
        Cell* toFirstCell ();
        void goToCell(Cell*);
 
        operator Cell* () const { return m_cell; }
        Cell * current() const;
        Cell * operator->() { return m_cell; }
        Cell * operator++ ();
 
    protected:
        KWTableFrameSet *m_table;
        void set_limits(uint left, uint right, uint high, uint low)
        {
            m_limit[LEFT] = left;
            m_limit[RIGHT] = right;
            m_limit[HIGH] = high;
            m_limit[LOW] = low;
        }
    private:
 
        Cell *m_cell;
        uint m_row;
        uint m_col;
 
        enum Direction {LEFT, RIGHT, HIGH, LOW};
        static const uint DIRECTION_SIZE = 4;
        uint m_limit[DIRECTION_SIZE];
    };
 
    typedef TableIterator<VISIT_CELL> TableIter;
    typedef TableIterator<VISIT_GRID> GridIter;
    typedef TableIterator<CHECKED> CheckedIter;
 
    class MarkedIterator : public GridIter {
    public:
        MarkedIterator(KWTableFrameSet *table);
        Cell *operator++();     // overridden from base but not virtual
 
    };
 
 
    virtual FrameSetType type() const { return FT_TABLE; }
 
    virtual KWordFrameSetIface* dcopObject();
 
    virtual void addTextFrameSets( TQPtrList<KWTextFrameSet> & lst, bool onlyReadWrite =false  );
 
    KWTableFrameSet( KWDocument *_doc, const TQString & name );
    virtual ~KWTableFrameSet();
 
    virtual KWFrameSetEdit * createFrameSetEdit( KWCanvas * canvas );
 
    virtual void createEmptyRegion( const TQRect & crect, TQRegion & emptyRegion, KWViewMode *viewMode );
    void drawBorders( TQPainter& painter, const TQRect &crect, KWViewMode *viewMode );
    virtual void drawContents( TQPainter * painter, const TQRect & crect,
                               const TQColorGroup & cg, bool onlyChanged, bool resetChanged,
                               KWFrameSetEdit *edit, KWViewMode *viewMode,
                               KWFrameViewManager *frameViewManager );
    virtual void drawFrame(KWFrame *, TQPainter *, const TQRect &, const TQRect&,
                           const TQPoint&,
                           KWFrame *, const TQColorGroup &, bool, bool,
                           KWFrameSetEdit *, KWViewMode *, bool ) {}
 
    // Frameset management
    Cell *cell( unsigned int row, unsigned int column ) const;
    Cell *cellByPos( double x, double y ) const;
 
    enum CellSize {
        TblAuto = 0,
        TblManual
    };
 
    KoRect boundingRect();
 
    void setBoundingRect( KoRect rect, CellSize widthMode, CellSize heightMode );
 
    double topWithoutBorder();
 
    double leftWithoutBorder();
 
    void resizeWidth( double width );
 
    void recalcCols(uint column, uint row);
    void recalcRows(uint column, uint row);
 
    void resizeColumn( unsigned int col, double x );
    void resizeRow( unsigned int row, double y );
 
    double columnSize( unsigned int col );
    double rowSize( unsigned int col );
 
    int columnEdgeAt( double x ) const;
    int rowEdgeAt( double y ) const;
 
    unsigned int getRows() const { return m_rows; }
    unsigned int getColumns() const { return m_cols; }
 
    unsigned int getNumCells()const { return m_nr_cells; }
 
 
    void moveBy( double dx, double dy );
 
    void insertNewRow( uint _idx, bool _recalc = true, bool _removeable = false );
    void insertNewColumn( uint _idx, double width = KWTableFrameSet::m_sDefaultColWidth);
 
    void deleteRow( uint _idx, RemovedRow &rr, bool _recalc = true);
 
    void deleteColumn( uint _idx, RemovedColumn &rc);
 
    void reInsertRow(RemovedRow &row);
    void reInsertColumn(RemovedColumn &col);
 
    void ungroup();
 
    void group();
 
    bool isActive()const { return m_active; }
 
    KCommand *joinCells(unsigned int firstColumn,unsigned int firstRow, unsigned int endColumn,unsigned int endRow);
    KCommand * splitCell(unsigned int intoRows, unsigned int intoColumns, unsigned int column,
            unsigned int row, TQPtrList<KWFrameSet> listFrameSet=TQPtrList<KWFrameSet>(),
            TQPtrList<KWFrame>listFrame=TQPtrList<KWFrame>() );
 
    void viewFormatting( TQPainter &painter, int zoom );
    void validate();
 
    virtual TQDomElement save( TQDomElement &parentElem, bool saveFrames = true );
 
    virtual void saveOasis( KoXmlWriter&, KoSavingContext&, bool saveFrames ) const;
    void loadOasis( const TQDomElement& tag, KoOasisContext& context );
    virtual bool canBeSavedAsInlineCharacter() const { return false; }
 
    Cell* loadCell( TQDomElement &frameElem, bool loadFrames = true, bool useNames = true );
 
    virtual TQDomElement toXML( TQDomElement &parentElem, bool saveFrames = true );
    virtual void fromXML( TQDomElement &framesetElem, bool loadFrames = true, bool useNames = true );
 
    virtual int paragraphs();
    virtual int paragraphsSelected();
    virtual bool statistics( TQProgressDialog *progress, ulong & charsWithSpace, ulong & charsWithoutSpace, ulong & words,
        ulong & sentences, ulong & syllables,ulong & lines, bool selected );
 
    virtual void finalize();
    virtual void invalidate();
    virtual void layout();
 
    virtual void updateFrames( int flags = 0xff );
 
    /* Overloaded methods, look for docu in kwframe.h */
    virtual void moveFloatingFrame( int frameNum, const KoPoint &position );
    virtual KoSize floatingFrameSize( int frameNum = 0 );
    virtual KCommand * anchoredObjectCreateCommand( int frameNum );
    virtual KCommand * anchoredObjectDeleteCommand( int frameNum );
    virtual KWAnchor * createAnchor( KoTextDocument *txt, int frameNum );
 
    virtual void setVisible( bool v );
    virtual bool canRemovePage( int num );
 
    void addCell( Cell *cell );
 
    void removeCell( Cell* cell );
 
    // The normal mechanism doesn't apply to tables; cells are protected individually
    // (in terms of data; the GUI has an item for protecting all cells at once)
    virtual void setProtectContent ( bool ) {}
    virtual bool protectContent() const { return false; }
 
    virtual KWTextFrameSet* nextTextObject( KWFrameSet * );
    void setZOrder();
 
    TQByteArray convertTableToText();
 
#ifndef NDEBUG
    virtual void printDebug( KWFrame * frame );
    virtual void printDebug();
    void printArrayDebug();
#endif
    static const uint m_sDefaultColWidth = 60;
protected:
    /* Overloaded methods, look for docu in kwframe.h */
    virtual void deleteAnchors();
    virtual void createAnchors( KoTextParag * parag, int index, bool placeHolderExists = false, bool repaint = true );
 
private:
    void addCellToArray( Cell* cell );
    void afterLoadingCell( Cell* cell );
    void parseInsideOfTable( const TQDomElement& parent, KoOasisContext& context,
                             const TQMemArray<double> & columnLefts, uint& row, uint& column,
                             double currentRowHeight );
    void loadOasisCell( const TQDomElement& element, KoOasisContext& context,
                        const TQMemArray<double> & columnLefts, uint row, uint column,
                        double currentRowHeight );
 
    void position(Cell *theCell, bool setMinFrameHeight=false);
 
    double getPositionOfRow(unsigned int row, bool bottom=false);
 
    void insertEmptyColumn(uint index);
    void insertRowVector(uint index, Row *row);
    Row* removeRowVector(uint index);
 
private:
    unsigned int m_rows, m_cols, m_nr_cells;
    bool m_active;
    TQPtrVector< Row > m_rowArray;
 
    TQValueList<unsigned int> m_pageBoundaries;
    unsigned int m_redrawFromCol;
    TQValueList<double> m_rowPositions, m_colPositions;
};
 
 
// all three templates specialise operator++
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::VISIT_CELL>::operator++ ();
 
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::VISIT_GRID>::operator++ ();
 
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::CHECKED>::operator++ ();
 
template<int VisitStyle>
KWTableFrameSet::TableIterator<VisitStyle>::TableIterator(KWTableFrameSet *table) :
        m_table(table)
{
        Q_ASSERT(m_table);
        set_limits(0, m_table->getColumns() - 1, 0, m_table->getRows() - 1);
        toFirstCell();
}
 
// CHECKED specialises the constructor
template<>
KWTableFrameSet::TableIterator<KWTableFrameSet::CHECKED>::TableIterator(KWTableFrameSet *table);
 
 
template<int VisitStyle>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<VisitStyle>::toFirstCell (){
        m_cell = m_table->cell(m_limit[HIGH], m_limit[LEFT]);
        Q_ASSERT(m_cell);
        if ( !m_cell )
            return 0;
        m_row = m_cell->firstRow();
        m_col = m_cell->firstColumn();
        return m_cell;
}
 
template<int VisitStyle>
void
KWTableFrameSet::TableIterator<VisitStyle>::goToCell(KWTableFrameSet::Cell *cell)
{
        m_cell = cell;
        Q_ASSERT( m_cell );
        if ( m_cell )
        {
            m_row = m_cell->firstRow();
            m_col = m_cell->firstColumn();
        }
}
 
// CHECKED specialises to first cell
template<>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<KWTableFrameSet::CHECKED>::toFirstCell ();
 
 
template<int VisitStyle>
KWTableFrameSet::Cell*
KWTableFrameSet::TableIterator<VisitStyle>::current() const {
        return m_cell;
}
 
class RemovedRow {
 
    KWTableFrameSet::Row *m_row;
    uint m_index;
    double m_rowHeight;
 
    uint index() const { return m_index; }
    double height() const { return m_rowHeight; }
    KWTableFrameSet::Row *takeRow();
    KWTableFrameSet::Row *row() { return m_row; }
 
    friend class KWTableFrameSet;
public:
    RemovedRow();
    ~RemovedRow();
};
 
class RemovedColumn {
 
    TQPtrList<KWTableFrameSet::Cell> m_column;
    TQValueList<bool> m_removed;
    uint m_index;
    double m_width;
    bool m_initialized;
 
    friend class KWTableFrameSet;
public:
    RemovedColumn();
};
 
class KWTableFrameSetEdit : public KWFrameSetEdit
{
public:
    KWTableFrameSetEdit( KWTableFrameSet * fs, KWCanvas * canvas )
        : KWFrameSetEdit( fs, canvas ), m_currentCell( 0L ) {}
    virtual ~KWTableFrameSetEdit();
 
    KWTableFrameSet * tableFrameSet() const {
        return static_cast<KWTableFrameSet *>( m_fs );
    }
 
    virtual KWFrameSetEdit* currentTextEdit();
 
    KWFrameSetEdit* currentCell() const { return m_currentCell; }
 
    // Forward all events to the current cell
    virtual void keyPressEvent( TQKeyEvent * e );
    virtual void keyReleaseEvent( TQKeyEvent * e );
    virtual void imStartEvent( TQIMEvent* e );
    virtual void imComposeEvent( TQIMEvent* e );
    virtual void imEndEvent( TQIMEvent* e );
    virtual void mousePressEvent( TQMouseEvent * e, const TQPoint &, const KoPoint & );
    virtual void mouseMoveEvent( TQMouseEvent * e, const TQPoint & n, const KoPoint & d )
    { if ( m_currentCell ) m_currentCell->mouseMoveEvent( e, n, d ); }
    virtual void mouseReleaseEvent( TQMouseEvent * e, const TQPoint & n, const KoPoint & d )
    { if ( m_currentCell ) m_currentCell->mouseReleaseEvent( e, n, d ); }
    virtual void mouseDoubleClickEvent( TQMouseEvent * e, const TQPoint & n, const KoPoint & d )
    { if ( m_currentCell ) m_currentCell->mouseDoubleClickEvent( e, n, d ); } // TODO check current cell
 
    virtual void dragEnterEvent( TQDragEnterEvent * e )
    { if ( m_currentCell ) m_currentCell->dragEnterEvent( e ); }
    virtual void dragMoveEvent( TQDragMoveEvent * e, const TQPoint &n, const KoPoint &d );
    virtual void dragLeaveEvent( TQDragLeaveEvent * e )
    { if ( m_currentCell ) m_currentCell->dragLeaveEvent( e ); }
    virtual void dropEvent( TQDropEvent * e, const TQPoint &n, const KoPoint &d, KWView* view )
    { if ( m_currentCell ) m_currentCell->dropEvent( e, n, d, view ); } // TODO check current cell
 
    virtual void focusInEvent() { if ( m_currentCell ) m_currentCell->focusInEvent(); }
    virtual void focusOutEvent() { if ( m_currentCell ) m_currentCell->focusOutEvent(); }
    virtual void copy() { if ( m_currentCell ) m_currentCell->copy(); }
    virtual void cut() { if ( m_currentCell ) m_currentCell->cut(); }
    virtual void paste() { if ( m_currentCell ) m_currentCell->paste(); }
    virtual void selectAll() { if ( m_currentCell ) m_currentCell->selectAll(); }
 
    void setCurrentCell( KWFrameSet * fs, bool eraseSelection=true );
    void setCurrentCell( const KoPoint & dPoint );
 
    void showPopup( KWFrame* frame, KWView* view, const TQPoint & _point );
 
protected:
    KWFrameSetEdit * m_currentCell;
 
};
#endif