KWCanvas.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
   Copyright (C) 2002-2006 David Faure <faure@kde.org>
   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.
*/
 
#ifndef KWCANVAS_H
#define KWCANVAS_H
 
#include <kprinter.h>
#include <KoRect.h>
#include <tqscrollview.h>
#include <tqstylesheet.h>
#include <KoRichText.h>
#include <KoQueryTrader.h>
#include <KoPicture.h>
 
#include "KWTextParag.h"
#include "KWFrame.h"
#include "KWVariable.h"
#include "KWCommand.h"
 
class KWTextFrameSetEdit;
class KWDocument;
class KWFrame;
class KWFrameSet;
class KWFrameSetEdit;
class KWTableFrameSet;
class KWFrameMoveCommand;
class KWViewMode;
class KWFrameViewManager;
class KWGUI;
class KWTableTemplate;
class KoTextParag;
class TQTimer;
class InteractionPolicy;
class KWFrameView;

class KWCanvas : public TQScrollView
{
    TQ_OBJECT
  
 
public:
    KWCanvas(const TQString& viewMode, TQWidget *parent, KWDocument *d, KWGUI *lGui);
    virtual ~KWCanvas();
 
    KWDocument * kWordDocument() const { return m_doc; }
    KWGUI * gui() const { return m_gui; }
    KWFrameViewManager* frameViewManager() { return m_frameViewManager; }
    KWFrameSetEdit *currentFrameSetEdit() const { return m_currentFrameSetEdit; }
 
    void switchViewMode( const TQString& newViewMode );
    KWViewMode *viewMode() const { return m_viewMode; }
 
    void repaintAll( bool erase = false );
    void repaintChanged( KWFrameSet * fs, bool resetChanged );

    void viewportResizeEvent( TQResizeEvent * );
 
    void print( TQPainter *painter, KPrinter *printer );
    bool eventFilter( TQObject *o, TQEvent *e );
    bool focusNextPrevChild( bool next);
 
    void setFrameBackgroundColor( const TQBrush &backColor );
 
    void editFrameProperties();
    void editFrameProperties( KWFrameSet * frameset );
 
    void pasteFrames();
 
    // Mouse press
    void mpCreate( const TQPoint& normalPoint, bool noGrid );
    void mpCreatePixmap( const TQPoint& normalPoint, bool noGrid  );
    // Mouse move
    void mmCreate( const TQPoint& normalPoint, bool noGrid );
    // Mouse release
    void mrEditFrame();
    void mrCreateText();
    void mrCreatePixmap();
    void mrCreatePart();
    void mrCreateFormula();
    void mrCreateTable();
 
    enum MouseMode {
        MM_EDIT = 0,
        MM_CREATE_TEXT = 2,
        MM_CREATE_PIX = 3,
        MM_CREATE_TABLE = 5,
        MM_CREATE_FORMULA = 6,
        MM_CREATE_PART = 7
    };
    void setMouseMode( MouseMode _mm );
    MouseMode mouseMode()const { return m_mouseMode; }
 
    // makes the user draw the rect for inserting the picture
    void insertPicture( const KoPicture& newPicture, TQSize pixmapSize, bool _keepRatio );
    void insertPart( const KoDocumentEntry &entry );
    void pasteImage( TQMimeSource *e, const KoPoint &docPoint );
    // insert a (non-inline) picture at the given position; used by dnd and dcop
    void insertPictureDirect( const KoPicture& picture, const KoPoint& pos, const TQSize& sz = TQSize() );
 
    void updateCurrentFormat();
 
    void updateFrameFormat();
 
    // Table creation support - methods used by KWView to reuse the last settings
    unsigned int tableRows() const { return m_table.rows; }
    void setTableRows( unsigned int rows ) { m_table.rows=rows; }
    unsigned int tableCols() const { return m_table.cols; }
    void setTableCols( unsigned int cols ) { m_table.cols=cols; }
    int tableWidthMode()const { return m_table.width; }
    int tableHeightMode()const { return m_table.height; }
    bool tableIsFloating()const { return m_table.floating; }
    int tableFormat()const { return m_table.format;}
 
    void setTableFormat(int _nb){ m_table.format=_nb;}
 
    TQString tableTemplateName()const { return m_table.tableTemplateName;}
    void setTableTemplateName(const TQString &_name) { m_table.tableTemplateName=_name;}
 
    void setPictureInline( bool _inline) { m_picture.pictureInline = _inline;}
    bool pictureInline() const { return m_picture.pictureInline; }
 
    void setPictureKeepRatio( bool _keep) { m_picture.keepRatio = _keep;}
    bool pictureKeepRatio() const { return m_picture.keepRatio; }
 
    void createTable( unsigned int rows, unsigned int cols,
                      int /*KWTableFrameSet::CellSize*/ wid, int /*KWTableFrameSet::CellSize*/ hei,
                      bool isFloating,
                      KWTableTemplate *tt=0L, int format=31 );

    KWTableFrameSet *getCurrentTable()const { return m_currentTable; }
    int currentTableRow() const;
    int currentTableCol() const;
 
    //move canvas to show point dPoint (in doc coordinates)
    void scrollToOffset( const KoPoint & dPoint );
 
    //for KWTextFrameSetEdit
    void dragStarted() { m_mousePressed = false; }
 
    void setXimPosition( int x, int y, int w, int h );
 
    void updateRulerOffsets( int cx = -1, int cy = -1 );
 
    void inlinePictureStarted();
 
    void ensureCursorVisible();
 
    void editFrameSet( KWFrameSet * frameSet, bool onlyText = false );
    void editTextFrameSet( KWFrameSet * fs, KoTextParag* parag, int index );
    bool checkCurrentEdit( KWFrameSet * fs, bool onlyText = false);
 
 
    NoteType footNoteType()const{return m_footEndNote.noteType;}
    KWFootNoteVariable::Numbering numberingFootNoteType() const { return m_footEndNote.numberingType;}
 
    void setFootNoteType( NoteType _type ) { m_footEndNote.noteType = _type; }
    void setNumberingFootNoteType(KWFootNoteVariable::Numbering _type) { m_footEndNote.numberingType = _type; }
 
    void tableSelectCell(KWTableFrameSet *table, KWFrameSet *cell);
    void selectAllFrames( bool select );
 
    KCommand * createTextBox(const KoRect & rect );
 
    // Called by KWTextFrameSetEdit when pgup/pgdown can't go further
    // or directly called by pgup/pgdown if not using 'moves caret' feature.
    void viewportScroll( bool up );

    void resetStatusBarText();

    KoPoint caretPos();
    void applyGrid( KoPoint &p );
 
    bool overwriteMode() const { return m_overwriteMode; }
 
    // Returns the current text edit object, or 0 if
    // - no frame is being edited
    // - a non-text frame is being edited
    KWTextFrameSetEdit* currentTextEdit() const;
 
    bool insertInlinePicture();
 
protected:
    void drawGrid( TQPainter &p, const TQRect& rect );

    virtual void drawContents( TQPainter *p, int cx, int cy, int cw, int ch );
    void drawDocument( TQPainter *painter, const TQRect &crect, KWViewMode* viewMode );
    void drawPageBorders( TQPainter * painter, const TQRect & crect, const TQRegion & emptySpaceRegion );
 
    virtual void keyPressEvent( TQKeyEvent *e );
    virtual void contentsMousePressEvent( TQMouseEvent *e );
    virtual void contentsMouseMoveEvent( TQMouseEvent *e );
    virtual void contentsMouseReleaseEvent( TQMouseEvent *e );
    virtual void contentsMouseDoubleClickEvent( TQMouseEvent *e );
    virtual void contentsDragEnterEvent( TQDragEnterEvent *e );
    virtual void contentsDragMoveEvent( TQDragMoveEvent *e );
    virtual void contentsDragLeaveEvent( TQDragLeaveEvent *e );
    virtual void contentsDropEvent( TQDropEvent *e );
    virtual void resizeEvent( TQResizeEvent *e );
 
    KWTableFrameSet * createTable(); // uses m_insRect and m_table to create the table
 
    void terminateCurrentEdit();
    bool insertInlineTable();
 
signals:
    // Emitted when the current frameset edit changes
    void currentFrameSetEditChanged();
    // Emitted by the current frameset edit when its selection changes
    void selectionChanged( bool hasSelection );
    // Emitted when Mouse Mode changed
    void currentMouseModeChanged(int newMouseMode);
    // Emitted when frames have been selected or unselected (to disable/enable the UI in kwview)
    void frameSelectedChanged();
    // Emitted when the document structure has changed
    // ### DF: IMHO this should be only emitted by KWDocument (e.g. addFrameSet)
    void docStructChanged(int _type);
    // Emitted when the insert key is pressed
    void overwriteModeChanged( bool m_overwriteMode );
 
    void viewTransformationsChanged();
 
    void updateRuler();
 
private slots:
    void slotContentsMoving( int, int );
    void slotNewContentsSize();
    void slotMainTextHeightChanged();
    void doAutoScroll();
 
    //Terminate editing this frameset, if we were editing it.
    void terminateEditing( KWFrameSet *fs );
 
private:
    void drawFrameSet( KWFrameSet * frameset, TQPainter * painter,
                       const TQRect & crect, bool onlyChanged, bool resetChanged, KWViewMode* viewMode );
 
    void drawMovingRect( TQPainter & p );
    void deleteMovingRect();
    void applyAspectRatio( double ratio, KoRect& insRect );
 
#ifndef NDEBUG
    void printRTDebug( int );
#endif
 
    KWFrameViewManager *m_frameViewManager;
    KWDocument *m_doc;
    KWFrameSetEdit *m_currentFrameSetEdit;
    KWGUI *m_gui;
    TQTimer *m_scrollTimer;
    bool m_mousePressed;
    bool m_printing;
    bool m_imageDrag;
 
    //define type of frame (for set inline frame)
    bool m_frameInline;
    FrameSetType m_frameInlineType;
 
    // Warning: the viewmode is stored here for good design ;)
    // but it's owned by the document, since we currently have one viewmode for all views.
    KWViewMode *m_viewMode;
 
    // Frame stuff
    MouseMode m_mouseMode;
    MouseMeaning m_mouseMeaning; // set by mousePress, used by mouseMove
    KoRect m_resizedFrameInitialSize; // when resizing a frame
    double m_resizedFrameInitialMinHeight; // when resizing a frame
    KoRect m_insRect;  
    bool m_deleteMovingRect;
    KoPicture m_kopicture; // The picture
    TQSize m_pixmapSize; // size when inserting a picture (not necessarily the size of the picture)
    bool m_keepRatio;//when inserting a picture
    KoDocumentEntry m_partEntry; // when inserting a part
    int m_rowColResized; // when resizing a row or column
    bool m_temporaryStatusBarTextShown; // Indicates if the temporary is shown
    double m_previousTableSize; //previous column or row size before resizing it
    KoPoint m_lastCaretPos; // position of caret when editing stopped in document coordinates
    bool m_overwriteMode;
 
    // Table creation support.
    // Having this as a member variable allows to remember and reuse the last settings
    struct
    {
        unsigned int cols;
        unsigned int rows;
        int format;
        int /*KWTableFrameSet::CellSize*/ width;
        int /*KWTableFrameSet::CellSize*/ height;
        bool floating;
        TQString tableTemplateName;
        KWTableTemplate *tt;
    } m_table;
    KWTableFrameSet *m_currentTable;
    InteractionPolicy *m_interactionPolicy;
 
    struct
    {
        NoteType noteType;
        KWFootNoteVariable::Numbering numberingType;
    } m_footEndNote;
 
    struct
    {
        bool pictureInline;
        bool keepRatio;
    }m_picture;
};

class InteractionPolicy {
    public:
        virtual void handleMouseMove(TQt::ButtonState keyState, const KoPoint &point) = 0;
        virtual KCommand* createCommand() = 0;
        void cancelInteraction();
        virtual void finishInteraction() = 0;

        static InteractionPolicy* createPolicy(KWCanvas *parent, MouseMeaning meaning, KoPoint &point, TQt::ButtonState buttonState, TQt::ButtonState keyState);
 
        void hadDragEvents() { m_gotDragEvents = true; }
        bool gotDragEvents() { return m_gotDragEvents; }
 
    protected:
        InteractionPolicy(KWCanvas *parent, bool doInit = true, bool includeInlineFrames = false);
 
        TQValueList<FrameIndex> m_indexFrame;
        KWCanvas *m_parent;
        TQValueList<KWFrame*> m_frames;
 
    private:
        void init();
        bool m_gotDragEvents;
};

class FrameResizePolicy : public InteractionPolicy {
    public:
        FrameResizePolicy(KWCanvas *parent, MouseMeaning meaning, KoPoint &point);
        void handleMouseMove(TQt::ButtonState keyState, const KoPoint &point);
        KCommand *createCommand();
        void finishInteraction();
 
    private:
        TQValueList<FrameResizeStruct> m_frameResize;
        bool m_top, m_bottom, m_left, m_right;
        KoRect m_boundingRect;
        KoPoint m_hotSpot;
};

class FrameMovePolicy : public InteractionPolicy {
    public:
        FrameMovePolicy(KWCanvas *parent, KoPoint &point);
        void handleMouseMove(TQt::ButtonState keyState, const KoPoint &point);
        KCommand *createCommand();
        void finishInteraction();
    private:
        TQValueList<FrameMoveStruct> m_frameMove;
        KoPoint m_hotSpot;
        KoPoint m_startPoint;
        KoRect m_boundingRect;
};

class FrameSelectPolicy : public InteractionPolicy {
    public:
        FrameSelectPolicy(KWCanvas *parent, MouseMeaning meaning, KoPoint &point, TQt::ButtonState state, TQt::ButtonState keyState);
        void handleMouseMove(TQt::ButtonState keyState, const KoPoint &point);
        KCommand *createCommand();
        void finishInteraction();
        bool isValid() { return m_validSelection; }
 
    private:
        bool m_validSelection;
};
 
#endif