kspread_sheet.h

/* This file is part of the KDE project
   Copyright 1998, 1999 Torben Weis <weis@kde.org>
   Copyright 1999- 2006 The KSpread Team
                        www.koffice.org/kspread
 
   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.
*/
 
#ifndef KSPREAD_SHEET
#define KSPREAD_SHEET
 
#include <tqclipboard.h>
#include <tqdragobject.h>
#include <tqintdict.h>
#include <tqmemarray.h>
#include <tqpen.h>
#include <tqptrlist.h>
#include <tqrect.h>
#include <tqwidget.h>
 
#include <KoDocument.h>
#include <KoDocumentChild.h>
#include <KoOasisSettings.h> // for KoOasisSettings::NamedMap
 
#include "kspread_autofill.h"
#include "kspread_cell.h"
#include "kspread_format.h"
#include "kspread_global.h"
#include "kspread_object.h"
 
class TQWidget;
class TQPainter;
class TQDomElement;
class DCOPObject;
class KPrinter;
class KoDocumentEntry;
class KoStyleStack;
class KoGenStyles;
class KoOasisLoadingContext;
class KoOasisSettings;
class KoOasisStyles;
class KCommand;
class KoPicture;
class KoXmlWriter;
 
namespace KoChart
{
class Part;
}
 
namespace KSpread
{
class Canvas;
class Cell;
class EmbeddedChart;
class DependencyManager;
class Doc;
class GenValidationStyles;
class Map;
class Point;
class Region;
class Selection;
class Sheet;
class SheetPrint;
class Style;
class UndoInsertRemoveAction;
class View;
class EmbeddedKOfficeObject;
class EmbeddedObject;
 
/********************************************************************
 *
 * CellBinding
 *
 ********************************************************************/
 
class CellBinding : public TQObject
{
    TQ_OBJECT
  
public:
    CellBinding( Sheet *_sheet, const TQRect& _area );
    virtual ~CellBinding();
 
    bool contains( int _x, int _y );
    virtual void cellChanged( Cell *_obj );
 
    virtual void setIgnoreChanges( bool _ignore ) { m_bIgnoreChanges = _ignore; }
 
    virtual TQRect& dataArea() { return m_rctDataArea; }
    virtual void setDataArea( const TQRect _rect ) { m_rctDataArea = _rect; }
 
    Sheet* sheet()const { return m_pSheet; }
 
signals:
    void changed( Cell *_obj );
 
protected:
    TQRect m_rctDataArea;
    Sheet *m_pSheet;
    bool m_bIgnoreChanges;
};
 
class ChartBinding : public CellBinding
{
    TQ_OBJECT
  
public:
 
    ChartBinding( Sheet *_sheet, const TQRect& _area, EmbeddedChart *_child );
    virtual ~ChartBinding();
 
    virtual void cellChanged( Cell *_obj );
 
private:
    EmbeddedChart* m_child;
};
 
/********************************************************************
 *
 * TextDrag
 *
 ********************************************************************/
 
class TextDrag : public TQTextDrag
{
    TQ_OBJECT
  
 
public:
    TextDrag( TQWidget * dragSource = 0L, const char * name = 0L );
    virtual ~TextDrag();
 
    void setPlain( TQString const & _plain ) { setText( _plain ); }
    void setKSpread( TQByteArray const & _kspread ) { m_kspread = _kspread; }
 
    virtual TQByteArray encodedData( const char * mime ) const;
    virtual const char* format( int i ) const;
 
    static bool canDecode( TQMimeSource * e );
 
    static const char * selectionMimeType();
 
protected:
    TQByteArray m_kspread;
};
 
 
/********************************************************************
 *
 * Sheet
 *
 ********************************************************************/
 
class KSPREAD_EXPORT Sheet : public TQObject
{
    friend class Cell;
 
    TQ_OBJECT
  
 
 
    TQ_PROPERTY( TQString sheetName READ sheetName )
    TQ_PROPERTY( bool autoCalc READ getAutoCalc WRITE setAutoCalc )
    TQ_PROPERTY( bool showGrid READ getShowGrid WRITE setShowGrid )
 
public:
    enum Direction { Right, Left, Up, Down };
    enum SortingOrder{ Increase, Decrease };
    enum ChangeRef { ColumnInsert, ColumnRemove, RowInsert, RowRemove };
    enum TestType { Text, Validity, Comment, ConditionalCellAttribute };
 
    enum LayoutDirection { LeftToRight, RightToLeft };
 
    Sheet ( Map* map, const TQString &sheetName, const char *_name=0L );
    ~Sheet();
 
    virtual bool isEmpty( unsigned long int x, unsigned long int y ) const;
 
    TQString sheetName() const;
 
    TQString tableName() const { return sheetName(); }
 
    bool setSheetName( const TQString& name, bool init = false, bool makeUndo=true );
 
    Map* workbook() const;
    Doc* doc() const;
 
    virtual TQDomElement saveXML( TQDomDocument& );
    virtual bool loadXML( const TQDomElement& );
 
    virtual bool loadOasis( const TQDomElement& sheet, KoOasisLoadingContext& oasisContext, TQDict<Style>& styleMap );
 
    virtual bool saveOasis( KoXmlWriter & xmlWriter, KoGenStyles &mainStyles, GenValidationStyles &valStyle, KoStore *store, KoXmlWriter* manifestWriter, int & indexObj, int &partIndexObj );
    void saveOasisHeaderFooter( KoXmlWriter &xmlWriter ) const;
 
    void loadOasisObjects( const TQDomElement& e, KoOasisLoadingContext& oasisContext );
    void loadOasisSettings( const KoOasisSettings::NamedMap &settings );
    void saveOasisSettings( KoXmlWriter &settingsWriter ) const;
    void saveOasisPrintStyleLayout( KoGenStyle &style ) const;
 
    virtual bool saveChildren( KoStore* _store, const TQString &_path );
    bool saveOasisObjects( KoStore *store, KoXmlWriter &xmlWriter, KoGenStyles& mainStyles, int & indexObj, int &partIndexObj );
    virtual bool loadChildren( KoStore* _store );
 
    bool isLoading();
 
 
    TQPtrList<EmbeddedObject> getSelectedObjects();
 
 
    KoRect getRealRect( bool all );
 
    //return command when we move object
    KCommand *moveObject(View *_view, double diffx, double diffy);
    KCommand *moveObject(View *m_view,const KoPoint &_move,bool key);
 
    void unifyObjectName( EmbeddedObject *object );
 
    LayoutDirection layoutDirection() const;
 
    void setLayoutDirection( LayoutDirection dir );
 
    bool isRightToLeft() const;
 
    void password( TQCString & passwd ) const ;
    bool isProtected() const;
    void setProtected( TQCString const & passwd );
    bool checkPassword( TQCString const & passwd ) const;
 
    void setDefaultHeight( double height );
    void setDefaultWidth( double width );
 
    const ColumnFormat* columnFormat( int _column ) const;
    ColumnFormat* columnFormat( int _column );
    ColumnFormat* nonDefaultColumnFormat( int _column, bool force_creation = true );
 
    const RowFormat* rowFormat( int _row ) const;
    RowFormat* rowFormat( int _row );
    RowFormat* nonDefaultRowFormat( int _row, bool force_creation = true );
 
    Cell* firstCell() const;
 
    RowFormat* firstRow() const;
 
    ColumnFormat* firstCol() const;
 
    Cell* cellAt( int _column, int _row ) const;
    Cell* cellAt( int _column, int _row, bool _scrollbar_update = false );
    Cell* cellAt( const TQPoint& _point, bool _scrollbar_update = false )
      { return cellAt( _point.x(), _point.y(), _scrollbar_update ); }
    Cell* visibleCellAt( int _column, int _row, bool _scrollbar_update = false );
    Cell* nonDefaultCell( int _column, int _row, bool _scrollbar_update = false, Style * _style = 0 );
    Cell* nonDefaultCell( TQPoint const & cellRef, bool scroll = false )
      { return nonDefaultCell( cellRef.x(), cellRef.y(), scroll ); }
 
    Cell* defaultCell() const;
 
    Format* defaultFormat();
    const Format* defaultFormat() const;
 
    Value value (int col, int row) const;
    Value valueRange (int col1, int row1, int col2, int row2) const;
 
    TQRect visibleRect( Canvas const * const _canvas ) const;
    int topRow( double _ypos, double &_top, const Canvas *_canvas = 0L ) const;
    int bottomRow( double _ypos, const Canvas *_canvas = 0L ) const;
    int leftColumn( double _xpos, double &_left, const Canvas *_canvas = 0L ) const;
    int rightColumn( double _xpos, const Canvas *_canvas = 0L ) const;
 
    int columnPos( int _col, const Canvas *_canvas = 0L ) const;
    double dblColumnPos( int _col, const Canvas *_canvas = 0L ) const;
    int rowPos( int _row, const Canvas *_canvas = 0L ) const;
    double dblRowPos( int _row, const Canvas *_canvas = 0L ) const;
 
    double sizeMaxX() const ;
    double sizeMaxY() const;
 
    void adjustSizeMaxX ( double _x );
 
    void adjustSizeMaxY ( double _y );
 
    void setLayoutDirtyFlag();
    void setCalcDirtyFlag();
 
  //why on earth would we want to do this?
//    void calc();
 
    void recalc( bool force );
    void recalc();
 
 
    void valueChanged (Cell *cell);
 
    TQString guessColumnTitle(TQRect& area, int col);
 
    TQString guessRowTitle(TQRect& area, int row);
 
    void setText( int row, int column, const TQString& text,
                  bool asString = false );
    void setArrayFormula (Selection *selectionInfo, const TQString &_text);
 
 
    void setSelectionFont( Selection* selectionInfo,
                           const char *_font = 0L, int _size = -1,
                           signed char _bold = -1, signed char _italic = -1,
                           signed char _underline = -1,
                           signed char _strike = -1 );
 
    void setSelectionMoneyFormat( Selection* selectionInfo, bool b );
    void setSelectionAlign( Selection* selectionInfo,
                            Format::Align _align );
    void setSelectionAlignY( Selection* selectionInfo,
                             Format::AlignY _alignY );
    void setSelectionPrecision( Selection* selectionInfo, int _delta );
    void setSelectionPercent( Selection* selectionInfo, bool b );
    void setSelectionMultiRow( Selection* selectionInfo, bool enable );
    void setSelectionStyle( Selection* selectionInfo, Style * style );
 
    void setSelectionSize( Selection* selectionInfo, int _size );
 
    void setSelectionUpperLower( Selection* selectionInfo, int _type );
 
    void setSelectionfirstLetterUpper( Selection* selectionInfo);
 
    void setSelectionVerticalText( Selection* selectionInfo, bool _b);
 
    void setSelectionComment( Selection* selectionInfo,
                              const TQString &_comment);
    void setSelectionRemoveComment(Selection* selectionInfo);
 
    void setSelectionAngle(Selection* selectionInfo, int _value );
 
    void setSelectionTextColor( Selection* selectionInfo,
                                const TQColor &tbColor );
    void setSelectionbgColor( Selection* selectionInfo,
                              const TQColor &bg_Color );
    void setSelectionBorderColor( Selection* selectionInfo,
                                  const TQColor &bd_Color );
 
    void deleteSelection( Selection* selectionInfo, bool undo = true );
 
    void copySelection( Selection* selectionInfo );
    void cutSelection( Selection* selectionInfo );
    void clearTextSelection( Selection* selectionInfo );
 
    void clearValiditySelection(Selection* selectionInfo );
 
    void clearConditionalSelection(Selection* selectionInfo );
 
    void fillSelection( Selection * selectionInfo, int direction );
 
    void setWordSpelling(Selection* selectionInfo,const TQString _listWord );
 
    TQString getWordSpelling(Selection* selectionInfo );
 
    void paste( const TQRect & pasteArea, bool makeUndo = true,
                Paste::Mode = Paste::Normal, Paste::Operation = Paste::OverWrite,
                bool insert = false, int insertTo = 0, bool pasteFC = false,
                TQClipboard::Mode clipboardMode = TQClipboard::Clipboard );
    void paste( const TQByteArray & data, const TQRect & pasteArea,
                bool makeUndo = false, Paste::Mode= Paste::Normal, Paste::Operation = Paste::OverWrite,
                bool insert = false, int insertTo = 0, bool pasteFC = false );
    void defaultSelection( Selection* selectionInfo );
 
    void pasteTextPlain( TQString &_text, TQRect pasteArea);
 
    void sortByRow( const TQRect &area, int ref_row, SortingOrder );
    void sortByRow( const TQRect &area, int key1, int key2, int key3,
                    SortingOrder order1, SortingOrder order2, SortingOrder order3,
                    TQStringList const * firstKey, bool copyFormat, bool headerRow,
                    Point const & outputPoint, bool respectCase );
    void sortByColumn( const TQRect &area, int ref_column, SortingOrder );
    void sortByColumn( const TQRect &area, int key1, int key2, int key3,
                       SortingOrder order1, SortingOrder order2, SortingOrder order3,
                       TQStringList const * firstKey, bool copyFormat, bool headerCol,
                       Point const & outputPoint, bool respectCase );
    void swapCells( int x1, int y1, int x2, int y2, bool cpFormat );
 
    void copyCells( int x1, int y1, int x2, int y2, bool cpFormat );
    void setSeries( const TQPoint &_marker, double start, double end, double step, Series mode, Series type );
 
    bool shiftRow( const TQRect &_rect, bool makeUndo=true );
    bool shiftColumn( const TQRect& rect, bool makeUndo=true );
 
    void unshiftColumn( const TQRect& rect, bool makeUndo=true );
    void unshiftRow( const TQRect& rect, bool makeUndo=true );
 
    bool insertColumn( int col, int nbCol=0, bool makeUndo=true );
    bool insertRow( int row, int nbRow=0, bool makeUndo=true );
 
    void removeColumn( int col, int nbCol=0, bool makeUndo=true );
    void removeRow( int row, int nbRow=0, bool makeUndo=true );
 
    void hideRow(const Region&);
    void emitHideRow();
    void showRow(const Region&);
 
    void hideColumn(const Region&);
    void emitHideColumn();
    void showColumn(const Region&);
 
    void adjustArea(const Region&);
    void adjustColumn(const Region&);
    void adjustRow(const Region&);
 
    void borderLeft( Selection* selectionInfo, const TQColor &_color );
    void borderTop( Selection* selectionInfo, const TQColor &_color );
    void borderOutline( Selection* selectionInfo, const TQColor &_color );
    void borderAll( Selection* selectionInfo, const TQColor &_color );
    void borderRemove( Selection* selectionInfo );
    void borderBottom( Selection* selectionInfo, const TQColor &_color );
    void borderRight( Selection* selectionInfo, const TQColor &_color );
 
    void setConditional( Selection* selectionInfo,
       TQValueList<Conditional> const & newConditions );
 
    void setValidity( Selection* selectionInfo, KSpread::Validity tmp );
 
    bool getShowGrid() const;
 
    void setShowGrid( bool _showGrid );
 
    bool getShowFormula() const;
 
    void setShowFormula(bool _showFormula);
 
    bool getShowFormulaIndicator() const;
 
    void setShowFormulaIndicator(bool _showFormulaIndicator);
 
    bool getShowCommentIndicator() const;
 
    void setShowCommentIndicator( bool b );
 
    bool getLcMode() const;
 
    void setLcMode(bool _lcMode);
 
    bool getAutoCalc() const;
 
    void setAutoCalc(bool _AutoCalc);
 
    bool getShowColumnNumber() const;
 
    void setShowColumnNumber(bool _showColumnNumber);
 
    bool getHideZero() const;
 
    void setHideZero(bool _hideZero);
 
    bool getFirstLetterUpper() const;
 
    void setFirstLetterUpper(bool _firstUpper);
 
    // TODO Stefan: remove after kspread_undo.cpp|h and commands.cpp|h are obsolete
    void changeMergedCell( int /*m_iCol*/, int /*m_iRow*/, int /*m_iExtraX*/, int /*m_iExtraY*/) {}
 
    void mergeCells( const Region& region, bool hor = false, bool ver = false );
    void dissociateCells( const Region &region );
 
    void increaseIndent( Selection* selectionInfo );
    void decreaseIndent( Selection* selectionInfo );
 
    bool areaIsEmpty(const Region& area, TestType _type = Text) ;
 
    void refreshPreference() ;
 
    void hideSheet(bool _hide);
 
    void removeSheet();
 
    TQRect selectionCellMerged(const TQRect &_sel);
    void changeNameCellRef( const TQPoint & pos, bool fullRowOrColumn,
                            ChangeRef ref, TQString tabname, int NbCol = 1,
                            UndoInsertRemoveAction * undo = 0 );
 
 
    void refreshRemoveAreaName(const TQString &_areaName);
    void refreshChangeAreaName(const TQString &_areaName);
 
 
    void refreshChart(const TQPoint & pos, bool fullRowOrColumn, ChangeRef ref);
    void refreshMergedCell();
 
    bool isHidden()const;
    void setHidden( bool hidden );
 
    TQPainter& painter();
    TQWidget* widget()const;
 
    bool isShowPageBorders() const;
 
    void setShowPageBorders( bool _b );
 
    void addCellBinding( CellBinding *_bind );
    void removeCellBinding( CellBinding *_bind );
    CellBinding* firstCellBinding();
    CellBinding* nextCellBinding();
 
    bool getCellRectangle( const TQRect &_range, TQPtrList<Cell> &_list );
 
    Sheet *findSheet( const TQString & _name );
 
    void insertCell( Cell *_cell );
    void insertColumnFormat( ColumnFormat *_l );
    void insertRowFormat( RowFormat *_l );
 
    TQDomDocument saveCellRegion(const Region&, bool copy = false, bool era = false);
 
    bool loadSelection( const TQDomDocument& doc, const TQRect &pasteArea,
                        int _xshift, int _yshift, bool makeUndo,
                        Paste::Mode = Paste::Normal, Paste::Operation = Paste::OverWrite,
                        bool insert = false, int insertTo = 0, bool paste = false );
 
    void loadSelectionUndo( const TQDomDocument & doc, const TQRect &loadArea,
                            int _xshift, int _yshift,bool insert,int insertTo);
 
    bool testAreaPasteInsert()const;
 
    void deleteCells(const Region& region);
 
 
    bool testListChoose(Selection* selectionInfo);
 
    TQString copyAsText(Selection* selection);
 
    void autofill( TQRect &src, TQRect &dest );
 
 
    bool insertChild( const KoRect& _geometry, KoDocumentEntry& );
 
    bool insertChart( const KoRect& _geometry, KoDocumentEntry&, const TQRect& _data );
 
 
    bool insertPicture( const KoPoint& point , const KURL& file );
 
    bool insertPicture( const KoPoint& point, const TQPixmap& pixmap );
 
    void changeChildGeometry( EmbeddedKOfficeObject *_child, const KoRect& _geometry );
 
    const TQColorGroup& colorGroup() { return widget()->colorGroup(); }
 
    int id() const;
 
    int maxColumn() const ;
 
    void checkRangeHBorder ( int _column );
 
    int maxRow() const ;
 
    void checkRangeVBorder ( int _row );
 
 
    void enableScrollBarUpdates( bool _enable );
 
    virtual DCOPObject* dcopObject();
 
    static Sheet* find( int _id );
 
#ifndef NDEBUG
    void printDebug();
#endif
 
    void updateCell( Cell* _cell, int _col, int _row );
 
    void updateCellArea(const Region& cellArea);
 
    void update();
 
    void updateView();
 
    void updateView( TQRect const & rect );
 
    void updateView(Region*);
 
    void refreshView(const Region& region);
 
    void emit_updateRow( RowFormat *_format, int _row, bool repaint = true );
    void emit_updateColumn( ColumnFormat *_format, int _column );
 
    const TQPen& emptyPen() const ;
    const TQBrush& emptyBrush() const;
    const TQColor& emptyColor() const;
 
    void updateLocale();
 
 
  void setRegionPaintDirty(TQRect const & range);
  void setRegionPaintDirty(Region const & region);
 
  void clearPaintDirtyData();
 
  bool cellIsPaintDirty(TQPoint const & cell) const;
 
  Cell* getFirstCellColumn(int col) const;
 
  Cell* getLastCellColumn(int col) const;
 
  Cell* getFirstCellRow(int row) const;
 
  Cell* getLastCellRow(int row) const;
 
  Cell* getNextCellUp(int col, int row) const;
 
  Cell* getNextCellDown(int col, int row) const;
 
  Cell* getNextCellLeft(int col, int row) const;
 
  Cell* getNextCellRight(int col, int row) const;
 
  SheetPrint * print() const;
 
  KSpread::DependencyManager *dependencies ();
 
  int numSelected() const;
 
//return command when we move object
//     KCommand *moveObject(KSpreadView *_view, double diffx, double diffy);
//     KCommand *moveObject(KSpreadView *m_view,const KoPoint &_move,bool key);
 
 
signals:
    void sig_refreshView();
    void sig_updateView( Sheet *_sheet );
    void sig_updateView( Sheet *_sheet, const Region& );
    void sig_updateView( EmbeddedObject *obj );
    void sig_updateHBorder( Sheet *_sheet );
    void sig_updateVBorder( Sheet *_sheet );
    void sig_updateChildGeometry( EmbeddedKOfficeObject *_child );
    void sig_maxColumn( int _max_column );
    void sig_maxRow( int _max_row );
    void sig_nameChanged( Sheet* sheet, const TQString& old_name );
    void sig_polygonInvalidated( const TQPointArray& );
 
    void sig_SheetHidden( Sheet* sheet);
    void sig_SheetShown( Sheet* sheet);
    void sig_SheetRemoved( Sheet* sheet);
    void sig_SheetActivated( Sheet* );
    void sig_RefreshView( Sheet* );
 
protected slots:
  void slotAreaModified (const TQString &name);
 
protected:
     void updateAllDependencies();
 
    void changeCellTabName( TQString const & old_name,TQString const & new_name );
 
    bool loadRowFormat( const TQDomElement& row, int &rowIndex, KoOasisLoadingContext& oasisContext, TQDict<Style>& styleMap );
 
    bool loadColumnFormat(const TQDomElement& row, const KoOasisStyles& oasisStyles, int & indexCol, const TQDict<Style>& styleMap);
    bool loadSheetStyleFormat( TQDomElement *style );
    void loadOasisMasterLayoutPage( KoStyleStack &styleStack );
 
    TQString saveOasisSheetStyleName( KoGenStyles &mainStyles );
    void saveOasisColRowCell( KoXmlWriter& xmlWriter, KoGenStyles &mainStyles, int maxCols, int maxRows, GenValidationStyles &valStyle );
    void saveOasisCells(  KoXmlWriter& xmlWriter, KoGenStyles &mainStyles, int row, int maxCols, GenValidationStyles &valStyle );
    void convertPart( const TQString & part, KoXmlWriter & writer ) const;
    void addText( const TQString & text, KoXmlWriter & writer ) const;
 
    void maxRowCols( int & maxCols, int & maxRows );
    bool compareRows( int row1, int row2, int & maxCols ) const;
 
    TQString getPart( const TQDomNode & part );
    void replaceMacro( TQString & text, const TQString & old, const TQString & newS );
 
    void insertObject( EmbeddedObject *_obj );
 
    void fillSequence( TQPtrList<Cell>& _srcList, TQPtrList<Cell>& _destList, TQPtrList<AutoFillSequence>& _seqList, bool down = true );
 
    static int s_id;
    static TQIntDict<Sheet>* s_mapSheets;
 
public:
    // see kspread_sheet.cpp for an explanation of this
    // this is for type B and also for type A (better use CellWorkerTypeA for that)
    struct CellWorker
    {
  const bool create_if_default;
  const bool emit_signal;
  const bool type_B;
 
  CellWorker( bool cid=true, bool es=true, bool tb=true ) : create_if_default( cid ), emit_signal( es ), type_B( tb ) { }
  virtual ~CellWorker() { }
 
  virtual class UndoAction* createUndoAction( Doc* doc, Sheet* sheet, const Region& region ) =0;
 
  // these are only needed for type A
  virtual bool testCondition( RowFormat* ) { return false; }
  virtual void doWork( RowFormat* ) { }
  virtual void doWork( ColumnFormat* ) { }
  virtual void prepareCell( Cell* ) { }
 
  // these are needed in all CellWorkers
  virtual bool testCondition( Cell* cell ) =0;
  virtual void doWork( Cell* cell, bool cellRegion, int x, int y ) =0;
    };
 
    // this is for type A (surprise :))
    struct CellWorkerTypeA : public CellWorker
    {
  CellWorkerTypeA( ) : CellWorker( true, true, false ) { }
  virtual TQString getUndoTitle( ) =0;
  class UndoAction* createUndoAction( Doc* doc, Sheet* sheet, const Region& region );
    };
 
protected:
    typedef enum { CompleteRows, CompleteColumns, CellRegion } SelectionType;
    SelectionType workOnCells( Selection* selectionInfo,
                               CellWorker& worker );
 
private:
    bool insertPicture( const KoPoint& point, KoPicture& picture );
 
    bool FillSequenceWithInterval (TQPtrList<Cell>& _srcList,
           TQPtrList<Cell>& _destList,
           TQPtrList<AutoFillSequence>& _seqList,
                                   bool down);
 
    void FillSequenceWithCopy (TQPtrList<Cell>& _srcList,
                               TQPtrList<Cell>& _destList,
                               bool down);
 
    void convertObscuringBorders();
    void checkCellContent(Cell * cell1, Cell * cell2, int & ret);
    int  adjustColumnHelper(Cell * c, int _col, int _row);
    void checkContentDirection( TQString const & name );
    bool objectNameExists( EmbeddedObject *object, TQPtrList<EmbeddedObject> &list );
 
    class Private;
    Private* d;
 
    // don't allow copy or assignment
    Sheet( const Sheet& );
    Sheet& operator=( const Sheet& );
};
 
} // namespace KSpread
 
#endif  // KSPREAD_SHEET