KWCommand.h

/* This file is part of the KDE project
   Copyright (C) 2001 David Faure <faure@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.
*/
 
#ifndef KWORD_COMMAND_H
#define KWORD_COMMAND_H
#include <kcommand.h>
#include <kurl.h>
#include <KoCommandHistory.h>
#include <KoPageLayout.h>
#include <KoRect.h>
#include <KoBorder.h>
#include <KoParagLayout.h>
#include <KoParagCounter.h>
#include "KWFrameStyle.h"
#include <KoTextCommand.h>
#include "KWVariable.h"
#include <KoPoint.h>
#include <KoPictureKey.h>
 
class KWFrameSet;
class KWTableStyle;
class KWTableTemplate;
class KWTableFrameSet;
class RemovedRow;
class RemovedColumn;
class KWPartFrameSet;
class KWDocument;
class KoCustomVariable;
class KoLinkVariable;
class KWFieldVariable;
class KWTimeVariable;
class KWDateVariable;
class KWPgNumVariable;
class KWFootNoteVariable;
 
// TODO: change most KNamedCommands into KCommands, removing name arguments
// and implementing name() instead (less memory used).

class KWOasisPasteCommand : public KoTextDocCommand
{
public:
    KWOasisPasteCommand( KoTextDocument *d, int parag, int idx,
                             const TQByteArray & data );
    KoTextCursor *execute( KoTextCursor *c );
    KoTextCursor *unexecute( KoTextCursor *c );
protected:
    int m_parag;
    int m_idx;
    TQByteArray m_data;
    // filled in by execute(), for unexecute()
    int m_lastParag;
    int m_lastIndex;
    KoParagLayout* m_oldParagLayout;
};
 
struct ParagBookmark {
    TQString m_bookName;
    int m_startParagIndex;
    int m_endParagIndex;
};
 
class KWTextDeleteCommand : public KoTextDeleteCommand
{
public:
    KWTextDeleteCommand( KoTextDocument *d, int i, int idx, const TQMemArray<KoTextStringChar> &str,
                         const CustomItemsMap & customItemsMap,
                         const TQValueList<KoParagLayout> & oldParagLayouts );
    KoTextCursor *execute( KoTextCursor *c );
    KoTextCursor *unexecute( KoTextCursor *c );
    void createBookmarkList();
private:
    TQValueList<ParagBookmark> m_listParagBookmark;
};
 


struct FrameIndex {
    FrameIndex() {}
    FrameIndex( KWFrame *frame );
 
    KWFrameSet * m_pFrameSet;
    unsigned int m_iFrameIndex;
};
 

class KWFrameBorderCommand : public KNamedCommand
{
public:
    //enum FrameBorderType { FBLeft=0, FBRight=1, FBTop=2, FBBottom=3};
    struct FrameBorderTypeStruct {
        KoBorder::BorderType m_EFrameType;
        KoBorder m_OldBorder;
    };
 
    KWFrameBorderCommand( const TQString &name, TQPtrList<FrameIndex> &_listFrameIndex, TQPtrList<FrameBorderTypeStruct> &_frameTypeBorder,const KoBorder & _newBorder ) ;
    ~ KWFrameBorderCommand();
 
    void execute();
    void unexecute();
 
protected:
    TQPtrList<FrameIndex> m_indexFrame;
    TQPtrList<FrameBorderTypeStruct> m_oldBorderFrameType;
    KoBorder m_newBorder;
};

class KWFrameBackGroundColorCommand : public KNamedCommand
{
public:
    KWFrameBackGroundColorCommand( const TQString &name, TQPtrList<FrameIndex> &_listFrameIndex, TQPtrList<TQBrush> &_oldBrush, const TQBrush & _newColor ) ;
    ~KWFrameBackGroundColorCommand();
 
    void execute();
    void unexecute();
 
protected:
    TQPtrList<FrameIndex> m_indexFrame;
    TQPtrList<TQBrush> m_oldBackGroundColor;
    TQBrush m_newColor;
};

class KWFrameStyleCommand : public KNamedCommand
{
public:
    KWFrameStyleCommand( const TQString &name, KWFrame *_frame, KWFrameStyle *_fs, bool _repaintViews = true );
    ~ KWFrameStyleCommand() { if (m_oldValues) delete m_oldValues; }
 
    void execute();
    void unexecute();
 
protected:
    void applyFrameStyle( KWFrameStyle * _sty );
    KWFrame *m_frame ;
    KWFrameStyle * m_fs;
    KWFrameStyle * m_oldValues;
    bool repaintViews;
};
 

class KWTableStyleCommand : public KNamedCommand
{
public:
    KWTableStyleCommand( const TQString &name, KWFrame *_frame, KWTableStyle *_ts, bool _repaintViews = true );
    ~ KWTableStyleCommand();
 
    void execute();
    void unexecute();
 
protected:
    KWFrame *m_frame ;
    KWTableStyle * m_ts;
    KWFrameStyleCommand * m_fsc;
    KCommand * m_sc;
    bool repaintViews;
};

class KWTableTemplateCommand : public KNamedCommand
{
public:
    KWTableTemplateCommand( const TQString &name, KWTableFrameSet *_table, KWTableTemplate *_tt );
    ~ KWTableTemplateCommand();
 
    void execute();
    void unexecute();
 
protected:
    KWTableFrameSet *m_table;
    KWTableTemplate * m_tt;
    KMacroCommand * m_tableCommands;
};
 
struct FrameResizeStruct {
    // Note that the new "minimum frame height" is always s2.height(),
    // since this is called when the user manually resizes a frame (not when
    // some text changes the size of a frame).
    FrameResizeStruct() { } // default constructor;
    FrameResizeStruct( const KoRect& s1, double min1, const KoRect& s2 )
        : oldRect(s1), oldMinHeight(min1),
          newRect( s2), newMinHeight(s2.height()) {
    }
    KoRect oldRect;
    double oldMinHeight;
    KoRect newRect;
    double newMinHeight;
};

class KWFrameResizeCommand : public KNamedCommand
{
public:
    KWFrameResizeCommand(const TQString &name, const TQValueList<FrameIndex> &frameIndex, const TQValueList<FrameResizeStruct> &frameResize );
    KWFrameResizeCommand(const TQString &name, FrameIndex frameIndex, const FrameResizeStruct &frameResize );
    ~KWFrameResizeCommand() {}
 
    void execute();
    void unexecute();
 
protected:
    TQValueList<FrameIndex> m_indexFrame;
    TQValueList<FrameResizeStruct> m_frameResize;
};

class KWFrameChangePictureCommand : public KNamedCommand
{
public:
    KWFrameChangePictureCommand( const TQString &name, FrameIndex _frameIndex, const KoPictureKey & _oldFile, const KoPictureKey & _newFile) ;
    ~KWFrameChangePictureCommand() {}
 
    void execute();
    void unexecute();
 
protected:
    FrameIndex m_indexFrame;
    KoPictureKey m_oldKey;
    KoPictureKey m_newKey;
};
 
struct FrameMoveStruct {
    FrameMoveStruct() {} // for TQValueList
    FrameMoveStruct( const KoPoint& p1, const KoPoint& p2 )
        : oldPos(p1), newPos(p2) {
    }
    KoPoint oldPos;
    KoPoint newPos;
};

class KWFrameMoveCommand : public KNamedCommand
{
public:
    KWFrameMoveCommand( const TQString &name,
                        const TQValueList<FrameIndex> & _frameIndex,
                        const TQValueList<FrameMoveStruct> & _frameMove );
    ~KWFrameMoveCommand() {}
 
    void execute();
    void unexecute();
    TQValueList<FrameMoveStruct> & listFrameMoved() { return m_frameMove; }
protected:
    TQValueList<FrameIndex> m_indexFrame;
    TQValueList<FrameMoveStruct> m_frameMove;
};

class KWFramePropertiesCommand : public KNamedCommand
{
public:
    KWFramePropertiesCommand( const TQString &name, KWFrame *_frameBefore,  KWFrame *_frameAfter );
    ~KWFramePropertiesCommand();
    void execute();
    void unexecute();
protected:
    FrameIndex m_frameIndex;
    KWFrame *m_frameBefore;
    KWFrame *m_frameAfter;
};
 

class KWFramePartMoveCommand : public KNamedCommand
{
public:
    KWFramePartMoveCommand( const TQString &name,FrameIndex _frameIndex,FrameResizeStruct _frameMove ) ;
    ~KWFramePartMoveCommand() {}
 
    void execute();
    void unexecute();
    FrameResizeStruct & listFrameMoved() { return m_frameMove; }
    bool frameMoved();
protected:
    FrameIndex m_indexFrame;
    FrameResizeStruct m_frameMove;
};

class KWFramePartInternalCommand : public KNamedCommand
{
public:
    KWFramePartInternalCommand( const TQString &name, KWPartFrameSet *part ) ;
    ~KWFramePartInternalCommand() {}
 
    void execute();
    void unexecute();
protected:
    KWPartFrameSet *m_part;
    KURL m_url;
};

class KWFramePartExternalCommand : public KNamedCommand
{
public:
    KWFramePartExternalCommand( const TQString &name, KWPartFrameSet *part ) ;
    ~KWFramePartExternalCommand() {}
 
    void execute();
    void unexecute();
protected:
    KWPartFrameSet *m_part;
};

class KWFrameSetInlineCommand : public KNamedCommand
{
public:
    KWFrameSetInlineCommand( const TQString &name, KWFrameSet *frameset,
                             bool value );
    ~KWFrameSetInlineCommand() {}
 
    void execute();
    void unexecute();
 
protected:
    void setValue( bool value );
 
    KWFrameSet* m_pFrameSet;
    bool m_value;
    bool m_oldValue;
};

struct KWPageLayoutStruct {
    KWPageLayoutStruct( const KoPageLayout& pgLayout, const KoColumns& cl, const KoKWHeaderFooter& hf )
        : _pgLayout(pgLayout), _cl(cl), _hf(hf) {
    }
    KoPageLayout _pgLayout;
    KoColumns _cl;
    KoKWHeaderFooter _hf;
};

class KWPageLayoutCommand : public KNamedCommand
{
public:
    KWPageLayoutCommand( const TQString &name, KWDocument *_doc, KWPageLayoutStruct &_oldLayout, KWPageLayoutStruct &_newLayout);
    ~KWPageLayoutCommand() {}
 
    void execute();
    void unexecute();
protected:
    KWDocument *m_pDoc;
    KWPageLayoutStruct m_oldLayout;
    KWPageLayoutStruct m_newLayout;
};
 

class KWDeleteFrameCommand : public KNamedCommand
{
public:
    KWDeleteFrameCommand( const TQString &name, KWFrame * frame) ;
    KWDeleteFrameCommand( const FrameIndex &frameIndex) ;
    ~KWDeleteFrameCommand();
 
    void execute();
    void unexecute();
protected:
    FrameIndex m_frameIndex;
    KWFrame *m_copyFrame;
};

class KWCreateFrameCommand : public KWDeleteFrameCommand
{
public:
    KWCreateFrameCommand( const TQString &name, KWFrame * frame);
    ~KWCreateFrameCommand() {}
 
    void execute() { KWDeleteFrameCommand::unexecute(); }
    void unexecute() { KWDeleteFrameCommand::execute(); }
};

class KWUngroupTableCommand : public KNamedCommand
{
public:
    KWUngroupTableCommand( const TQString &name, KWTableFrameSet * _table) ;
    ~KWUngroupTableCommand() {}
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
    TQPtrList<KWFrameSet> m_ListFrame;
};

class KWDeleteTableCommand : public KNamedCommand
{
public:
    KWDeleteTableCommand( const TQString &name, KWTableFrameSet * _table) ;
    ~KWDeleteTableCommand() {}
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
};
 

class KWCreateTableCommand : public KWDeleteTableCommand
{
public:
    KWCreateTableCommand( const TQString &name, KWTableFrameSet * _table)
        : KWDeleteTableCommand( name, _table ) {}
    ~KWCreateTableCommand() {}
 
    void execute() { KWDeleteTableCommand::unexecute(); }
    void unexecute() { KWDeleteTableCommand::execute(); }
};

class KWInsertColumnCommand : public KNamedCommand
{
public:
    /* for the last parameter, _maxRight, you should pass the maximum offset that the table can use at its right (normally m_maxRight - m_pTable->boundingRect().left())*/
    KWInsertColumnCommand( const TQString &name, KWTableFrameSet * _table, int _pos, double _maxRight);
    ~KWInsertColumnCommand();
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
    RemovedColumn *m_rc;
    unsigned int m_colPos;
    double m_maxRight; // this is the maximum x of the right part of the table (used so that the table does no go off the page)
    double m_oldWidth; // will be 0 after execute() if the width of the table was not changed by the operation
    bool m_inserted;
};
 

class KWInsertRowCommand : public KNamedCommand
{
public:
    KWInsertRowCommand( const TQString &name, KWTableFrameSet * _table, int _pos);
    ~KWInsertRowCommand();
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
    RemovedRow *m_rr;
    unsigned int m_rowPos;
    bool m_inserted;
};

class KWRemoveRowCommand : public KNamedCommand
{
public:
    KWRemoveRowCommand( const TQString &name, KWTableFrameSet * _table, int _pos);
    ~KWRemoveRowCommand();
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
    RemovedRow *m_rr;
    uint m_rowPos;
};

class KWRemoveColumnCommand : public KNamedCommand
{
public:
    KWRemoveColumnCommand( const TQString &name, KWTableFrameSet * _table, int _pos);
    ~KWRemoveColumnCommand();
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
    RemovedColumn *m_rc;
    uint m_colPos;
};

class KWSplitCellCommand : public KNamedCommand
{
public:
    KWSplitCellCommand( const TQString &name, KWTableFrameSet * _table,unsigned int colBegin,unsigned int rowBegin, unsigned int colEnd,unsigned int rowEnd );
    ~KWSplitCellCommand() {}
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
    unsigned int m_colBegin;
    unsigned int m_rowBegin;
    unsigned int m_colEnd;
    unsigned int m_rowEnd;
    TQPtrList<KWFrameSet> m_ListFrameSet;
};

class KWJoinCellCommand : public KNamedCommand
{
public:
    KWJoinCellCommand( const TQString &name, KWTableFrameSet * _table,unsigned int colBegin,unsigned int rowBegin, unsigned int colEnd,unsigned int rowEnd, TQPtrList<KWFrameSet> listFrameSet,TQPtrList<KWFrame> listCopyFrame);
    ~KWJoinCellCommand();
 
    void execute();
    void unexecute();
protected:
    KWTableFrameSet *m_pTable;
    unsigned int m_colBegin;
    unsigned int m_rowBegin;
    unsigned int m_colEnd;
    unsigned int m_rowEnd;
    TQPtrList<KWFrameSet> m_ListFrameSet;
    TQPtrList<KWFrame> m_copyFrame;
};

class KWChangeStartingPageCommand : public KNamedCommand
{
public:
    KWChangeStartingPageCommand( const TQString &name, KWDocument *_doc, int _oldStartingPage, int _newStartingPage);
    ~KWChangeStartingPageCommand(){}
 
    void execute();
    void unexecute();
protected:
    KWDocument *m_doc;
    int oldStartingPage;
    int newStartingPage;
};

class KWChangeVariableSettingsCommand : public KNamedCommand
{
public:
    enum VariableProperties { VS_DISPLAYLINK, VS_UNDERLINELINK, VS_DISPLAYCOMMENT, VS_DISPLAYFIELDCODE};
    KWChangeVariableSettingsCommand( const TQString &name, KWDocument *_doc, bool _oldDisplay, bool _newDisplay, VariableProperties _type);
    ~KWChangeVariableSettingsCommand(){}
 
    void execute();
    void unexecute();
protected:
    void changeValue( bool b );
    KWDocument *m_doc;
    VariableProperties type;
    bool m_bOldValue;
    bool m_bNewValue;
};
 
class KWChangeCustomVariableValue : public KNamedCommand
{
 public:
    KWChangeCustomVariableValue( const TQString &name, KWDocument *_doc,const TQString & _oldValue, const TQString & _newValue, KoCustomVariable *var);
    ~KWChangeCustomVariableValue();
    void execute();
    void unexecute();
 protected:
    KWDocument *m_doc;
    TQString newValue;
    TQString oldValue;
    KoCustomVariable *m_var;
};
 
class KWChangeVariableNoteText : public KNamedCommand
{
 public:
    KWChangeVariableNoteText( const TQString &name, KWDocument *_doc, const TQString &_oldValue,const TQString &_newValue, KoNoteVariable *var);
    ~KWChangeVariableNoteText();
    void execute();
    void unexecute();
 protected:
    KWDocument *m_doc;
    TQString newValue;
    TQString oldValue;
     KoNoteVariable *m_var;
};
 
class KWChangeLinkVariable : public KNamedCommand
{
 public:
    KWChangeLinkVariable( const TQString &name, KWDocument *_doc,const TQString & _oldHref, const TQString & _newHref, const TQString & _oldLink,const TQString &_newLink, KoLinkVariable *var);
    ~KWChangeLinkVariable(){};
    void execute();
    void unexecute();
 protected:
    KWDocument *m_doc;
    TQString oldHref;
    TQString newHref;
    TQString oldLink;
    TQString newLink;
    KoLinkVariable *m_var;
};
 
class KWHideShowHeader : public KNamedCommand
{
 public:
    KWHideShowHeader( const TQString &name, KWDocument *_doc, bool _newValue);
    ~KWHideShowHeader(){};
    void execute();
    void unexecute();
 protected:
    KWDocument *m_doc;
    bool newValue;
};
 
class KWHideShowFooter : public KNamedCommand
{
 public:
    KWHideShowFooter( const TQString &name, KWDocument *_doc, bool _newValue);
    ~KWHideShowFooter(){};
    void execute();
    void unexecute();
 protected:
    KWDocument *m_doc;
    bool newValue;
};
 
 
class KWProtectContentCommand : public KNamedCommand
{
public:
    KWProtectContentCommand( const TQString &name, KWTextFrameSet*frameset,bool protect );
    ~KWProtectContentCommand() {}
 
    void execute();
    void unexecute();
 
protected:
    KWTextFrameSet* m_pFrameSet;
    bool m_bProtect;
};
 
class KWInsertRemovePageCommand : public KCommand
{
 public:
    enum Command { Insert, Remove };
    KWInsertRemovePageCommand( KWDocument *_doc, Command cmd, int pgNum);
    ~KWInsertRemovePageCommand();
    virtual TQString name() const;
    void execute();
    void unexecute();
 protected:
    KWDocument *m_doc;
    Command m_cmd;
    int m_pgNum;
    TQValueList<KCommand*> childCommands;
 
    void doRemove(int pageNumber);
    void doInsert(int pageNumber);
 
 private:
    static bool compareIndex(const FrameIndex &index1, const FrameIndex &index2);
};
 
struct FramePaddingStruct {
    FramePaddingStruct() {}
    FramePaddingStruct( KWFrame *frame );
    FramePaddingStruct( double _left, double top, double right, double bottom );
    double topPadding;
    double bottomPadding;
    double leftPadding;
    double rightPadding;
};
 
class KWFrameChangeFramePaddingCommand :public KNamedCommand
{
public:
    KWFrameChangeFramePaddingCommand( const TQString &name, FrameIndex _frameIndex, FramePaddingStruct _framePaddingBegin, FramePaddingStruct _framePaddingEnd );
    ~KWFrameChangeFramePaddingCommand() {}
    void execute();
    void unexecute();
protected:
    FrameIndex m_indexFrame;
    FramePaddingStruct m_framePaddingBegin;
    FramePaddingStruct m_framePaddingEnd;
};
 
 
class KWChangeFootEndNoteSettingsCommand : public KNamedCommand
{
public:
    KWChangeFootEndNoteSettingsCommand( const TQString &name, KoParagCounter _oldCounter, KoParagCounter _newCounter ,bool _footNote ,KWDocument *_doc );
    ~KWChangeFootEndNoteSettingsCommand() {}
 
    void execute();
    void unexecute();
 
protected:
    void changeCounter( KoParagCounter counter);
    KoParagCounter m_oldCounter;
    KoParagCounter m_newCounter;
    bool m_footNote;
    KWDocument *m_doc;
};
 
class KWChangeTabStopValueCommand : public KNamedCommand
{
public:
    KWChangeTabStopValueCommand( const TQString &name,  double _oldValue, double _newValue, KWDocument *_doc);
 
    ~KWChangeTabStopValueCommand() {}
 
    virtual void execute();
    virtual void unexecute();
protected:
    KWDocument *m_doc;
    double m_oldValue;
    double m_newValue;
};
 
 
struct FootNoteParameter {
    FootNoteParameter() {}
    FootNoteParameter( KWFootNoteVariable *_var );
    FootNoteParameter( NoteType _noteType, KWFootNoteVariable::Numbering _numberingType, const TQString &_manualString);
    NoteType noteType;
    KWFootNoteVariable::Numbering numberingType;
    TQString manualString;
};
 
class KWChangeFootNoteParametersCommand : public KNamedCommand
{
public:
    KWChangeFootNoteParametersCommand( const TQString &name, KWFootNoteVariable * _var, FootNoteParameter _oldParameter, FootNoteParameter _newParameter, KWDocument *_doc);
 
    ~KWChangeFootNoteParametersCommand() {}
 
    virtual void execute();
    virtual void unexecute();
protected:
    void changeVariableParameter( FootNoteParameter _param );
    KWDocument *m_doc;
    KWFootNoteVariable *m_var;
    FootNoteParameter m_oldParameter;
    FootNoteParameter m_newParameter;
};
 
 
class KWChangeFootNoteLineSeparatorParametersCommand : public KNamedCommand
{
public:
    KWChangeFootNoteLineSeparatorParametersCommand( const TQString &name, SeparatorLinePos _oldValuePos, SeparatorLinePos _newValuePos, int _oldLength, int _newLength, double _oldWidth, double _newWidth,SeparatorLineLineType _oldLineType, SeparatorLineLineType _newLineType, KWDocument *_doc);
 
    ~KWChangeFootNoteLineSeparatorParametersCommand() {}
 
    virtual void execute();
    virtual void unexecute();
protected:
    void changeLineSeparatorParameter( SeparatorLinePos _pos, int length, double _width, SeparatorLineLineType _type);
    KWDocument *m_doc;
    SeparatorLinePos m_oldValuePos;
    SeparatorLinePos m_newValuePos;
    int m_oldLength;
    int m_newLength;
    double m_oldWidth;
    double m_newWidth;
    SeparatorLineLineType m_oldLineType;
    SeparatorLineLineType m_newLineType;
};
 
class KWRenameBookmarkCommand : public KNamedCommand
{
public:
    KWRenameBookmarkCommand( const TQString &name, const TQString & _oldname, const TQString & _newName, KWDocument *_doc);
 
    ~KWRenameBookmarkCommand() {}
 
    virtual void execute();
    virtual void unexecute();
protected:
    KWDocument *m_doc;
    TQString m_oldName;
    TQString m_newName;
};
 
class KWResizeColumnCommand : public KNamedCommand
{
public:
    KWResizeColumnCommand( KWTableFrameSet *table, int col, double oldSize, double newSize );
 
    ~KWResizeColumnCommand() {}
 
    virtual void execute();
    virtual void unexecute();
protected:
    KWTableFrameSet *m_table;
    double m_oldSize;
    double m_newSize;
    int m_col;
};
 
class KWResizeRowCommand : public KNamedCommand
{
  public:
    KWResizeRowCommand( KWTableFrameSet *table, int row, double oldSize, double newSize );
 
    ~KWResizeRowCommand() {}
 
    virtual void execute();
    virtual void unexecute();
  protected:
    KWTableFrameSet *m_table;
    double m_oldSize;
    double m_newSize;
    int m_row;
};
 
#endif