KPrCanvas.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
   Copyright (C) 2002-2005 Thorsten Zachmann <zachmann@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 __KPRCANVAS__
#define __KPRCANVAS__
 
#include <tqwidget.h>
#include <tqptrlist.h>
#include <tqpicture.h>
#include <tqvaluelist.h>
#include <tqpixmap.h>
#include <tqpointarray.h>
#include <tqvaluevector.h>
#include <tqtimer.h>
 
#include <KoGuides.h>
#include <KoRuler.h>
#include <KoQueryTrader.h>
#include "KoPointArray.h"
#include "global.h"
#include <KoRect.h>
#include <KoTextFormat.h>
#include "presstep.h"
 
class KURL;
class KoTextFormatInterface;
class KPrView;
class KPrDocument;
class TQPainter;
class KTextEdit;
class KPrTextObject;
class KPrObject;
class TDEPopupMenu;
class TQResizeEvent;
class TQPaintEvent;
class TQDragEnterEvent;
class TQDragMoveEvent;
class TQDropEvent;
class TQFocusEvent;
class TQMouseEvent;
class TQWheelEvent;
class TQKeyEvent;
class KPrPixmapObject;
class KPrBackGround;
class TQRect;
class TQSize;
class TQPoint;
class KPrSoundPlayer;
class KoTextObject;
class KoParagCounter;
class KPrPage;
class KPrinter;
class KPrTextView;
class KPrPartObject;
class KCommand;
class KPrEffectHandler;
class KPrPageEffects;
class KPrCanvas : public TQWidget
{
    TQ_OBJECT
  
 
public:

    KPrCanvas( TQWidget *parent=0,const char *name=0,KPrView *_view=0 );
    ~KPrCanvas();
 
    KPrView * getView()const { return m_view; }
 
    // The equivalent of contentsX() and contentsY() for a TQScrollView
    // The Canvas is a widget, not a scrollview (because we handle the scrollbars ourselves,
    // to have the "goto page" buttons at the bottom of the scrollbars etc.)
    int diffx() const { return m_xOffset; }
    int diffy() const { return m_yOffset; }
    void setDiffX( int _diffX ) { m_xOffset = _diffX; }
    void setDiffY( int _diffY ) { m_yOffset = _diffY; }
    void scrollX( int x );
    void scrollY( int y );
 
    // public functions
    void selectAllObj();
    void deSelectAllObj();
    void selectObj( KPrObject* );
    void deSelectObj( KPrObject* );
    void setTextFormat(const KoTextFormat &format, int flags);
 
    void setTextColor( const TQColor & );
    void setTextBackgroundColor( const TQColor & );
    void setTextAlign( int );
    void setTextDepthPlus();
    void setTextDepthMinus();
    void setNewRightIndent(double _rightIndent);
    void setNewLeftIndent(double _leftIndent);
    void setNewFirstIndent(double _firstIndent);
    //void setTextCounter(KoParagCounter counter);
    void setTabList( const KoTabulatorList & tabList );
    void setTextBold( bool b );
    void setTextItalic( bool b );
    void setTextUnderline( bool b );
    void setTextStrikeOut( bool b );
    void setTextFamily( const TQString &f );
    void setTextPointSize( int s );
    void setTextSubScript( bool b );
    void setTextSuperScript( bool b );
    void setTextDefaultFormat( );
    void setIncreaseFontSize();
    void setDecreaseFontSize();
    KPrTextObject* kpTxtObj() const;

    void startScreenPresentation( double zoomX, double zoomY, int curPgNum = -1);
    void stopScreenPresentation();

    bool pNext( bool gotoNextPage = false );

    bool pPrev( bool gotoPreviousPage = false );

    unsigned int presPage() const { return m_step.m_pageNumber + 1; }
    int presStep() const { return m_step.m_step; }
    int numPresSteps() const { return m_pageEffectSteps.count(); }
    int numPresPages() const { return m_presentationSlides.count(); }
 
    bool canAssignEffect( TQPtrList<KPrObject> &objs ) const;
 
    void print( TQPainter*, KPrinter*, float, float );
 
 
    void setPartEntry( KoDocumentEntry& _e )
        { partEntry = _e; }
    void setToolEditMode( ToolEditMode _m, bool updateView = true );
    void setAutoForm( const TQString &_autoform )
        { autoform = _autoform; }

    void drawPageInPix( TQPixmap&, int pgnum, int zoom,
                        bool forceRealVariableValue = false,
                        int forceWidth  = 0,
                        int forceHeight = 0 );

    bool exportPage( int nPage, int nWidth, int nHeight,
                     const KURL& fileURL,
                     const char* format,
                     int quality = -1 );
 
    void gotoPage( int pg );

    void presGotoFirstPage();
 
    KPrPage* activePage() const;
 
    bool oneObjectTextExist() const;
    bool oneObjectTextSelected() const;
    bool isOneObjectSelected() const;
    TQPtrList<KPrTextObject> selectedTextObjs() const;
    TQPtrList<KoTextFormatInterface> applicableTextInterfaces() const;
    TQPtrList<KPrTextObject> applicableTextObjects() const;
 
    void setMouseSelectedObject(bool b);
 
    bool haveASelectedPartObj() const;
    bool haveASelectedGroupObj() const;
    bool haveASelectedPixmapObj() const;
 
    KPrTextView *currentTextObjectView() const { return m_currentTextObjectView; }
 
    TQPtrList<KPrObject> objectList() const;
 
    // get - set data
    const TQPtrList<KPrObject> & getObjectList() const;
 
    void playSound( const TQString &soundFileName );
    void stopSound();

    void dragStarted() { mousePressed = false; }
 
    void setXimPosition( int x, int y, int w, int h, TQFont *f );
    void createEditing( KPrTextObject *textObj );
 

    void insertLine( const KoPoint &startPoint, const KoPoint &endPoint );
    
    void insertRect( const KoRect &rect);

    void insertEllipse( const KoRect &rect );

    void insertPie( const KoRect &rect );

    KPrTextObject* insertTextObject( const KoRect &rect );

    void insertPicture( const KoRect &rect );
    void changePicture( const KURL & url, TQWidget *window );
 
    int numberOfObjectSelected() const;
    KPrObject *getSelectedObj() const;
    KPrPixmapObject *getSelectedImage() const;
 
    bool getEditMode() const { return editMode; }
 
    void ungroupObjects();
    void groupObjects();
 
    unsigned int objNums() const;
 
    void ensureVisible( int x, int y, int xmargin, int ymargin );

    KoRect objectRect( bool all ) const;
 
    void scrollTopLeftPoint( const TQPoint & pos );
 
    void textContentsToHeight();
    void textObjectToContents();
 
    void flipObject( bool _horizontal );
 
    void lowerObjs( bool backward );
    void raiseObjs( bool forward );

    void alignObjects( AlignType at );
 
    bool canMoveOneObject()const;
    TQPtrList<KPrTextObject> listOfTextObjs() const;
 
    TQPixmap getPicturePixmap() const;
    void closeObject(bool _close);
    void layout();
    void alignVertical(VerticalAlignmentType _type );
    void savePicture();
 
    void dropImage( TQMimeSource * data, bool resizeImageToOriginalSize = false , int posX = 10, int posY=10 );
    KoGuides & guideLines() { return m_gl; }

    void objectPopup( KPrObject *object, const TQPoint &point );
 
public slots:
    // use repaint = false when the KPrCanvas is destroyed to avaid a possible crash
    void exitEditMode( bool repaint = true );
 
    void clipCut();
    void clipCopy();
    void clipPaste();
    void deleteObjs();
    void copyObjs();
    void copyOasisObjs();
 
    void chPic();
    void picViewOriginalSize();
    void picViewOrig640x480();
    void picViewOrig800x600();
    void picViewOrig1024x768();
    void picViewOrig1280x1024();
    void picViewOrig1600x1200();
    void picViewOrigFactor();
    void setActivePage( KPrPage* active );

    void setPaintGuides( bool state );
 
signals:
 
    // signals to notify of changes
    void fontChanged( const TQFont & );
    void colorChanged( const TQColor & );
    void alignChanged( int );
    void stopAutomaticPresentation();
    void restartPresentation();
    void objectSelectedChanged();
    void objectSizeChanged();
    void currentObjectEditChanged();
 
    void selectionChanged( bool hasSelection );
    void sigMouseWheelEvent( TQWheelEvent * );
 
protected:
    struct PicCache
    {
        TQPicture pic;
        int num;
        int subPresStep;
    };
 
    // functions for displaying
    virtual void paintEvent( TQPaintEvent* );

    void drawBackground( TQPainter* painter, const TQRect& rect, KPrPage * page, bool edit = false ) const;

    void drawAllObjectsInPage( TQPainter *painter, const TQPtrList<KPrObject> & obj, int pageNum ) const;

    void drawObjectsPres( TQPainter *painter, const TQPtrList<KPrObject> &_objects, PresStep step ) const;

    void drawObjectsEdit( TQPainter *painter, const KoRect &rect, const TQPtrList<KPrObject> &_objects,
                          SelectionMode selectionMode, int page ) const;

    void drawObjects( TQPainter *painter, const TQPtrList<KPrObject> &objects, SelectionMode selectionMode,
                      bool contour, KPrTextView * textView, int pageNum ) const;

    void drawEditPage( TQPainter *painter, const TQRect &_rect,
                       KPrPage *page, SelectionMode selectionMode ) const;

    void drawPresPage( TQPainter *painter, const TQRect &_rect, PresStep step ) const;

    void drawGrid(TQPainter *painter, const TQRect &rect2) const;

    bool finishObjectEffects();
 
    bool finishPageEffect( bool cancel = false );
 
    void drawCurrentPageInPix( TQPixmap& ) const;
    virtual void mousePressEvent( TQMouseEvent *e );
    virtual void mouseReleaseEvent( TQMouseEvent *e );
    virtual void mouseMoveEvent( TQMouseEvent *e );
    virtual void mouseDoubleClickEvent( TQMouseEvent *e );
    virtual void wheelEvent( TQWheelEvent *e );
    virtual void resizeEvent( TQResizeEvent *e );
    virtual bool close( bool alsoDelete );
    KPrObject *getObjectAt( const KoPoint &pos, bool withoutProtected = false );
    virtual void focusInEvent( TQFocusEvent* ) {}
    virtual void focusOutEvent( TQFocusEvent* ) {}
    virtual void enterEvent( TQEvent *e );
    virtual void leaveEvent( TQEvent *e );
    virtual void dragEnterEvent( TQDragEnterEvent *e );
    virtual void dragMoveEvent( TQDragMoveEvent *e );
    virtual void dropEvent( TQDropEvent *e );
    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 );
 
    void eraseEmptySpace( TQPainter * painter, const TQRegion & emptySpaceRegion, const TQBrush & brush ) const;

    void setupMenus();
 
    unsigned int currPgNum() const;
    TQColor txtBackCol() const;
    bool spInfiniteLoop() const;
    bool spShowEndOfPresentationSlide() const;
    bool spManualSwitch() const;
    TQRect getPageRect( bool decBorders = true ) const;
    unsigned int pageNums() const;
 
    void _repaint( bool erase=true );
    void _repaint( const TQRect &r );
    void _repaint( KPrObject *o );

    void printPage( TQPainter*, PresStep step, KPrinter *printer, int rows, int cols );

    void doObjEffects( bool isAllreadyPainted = false );

    KPrPartObject *insertObject( const KoRect &rect );

    void insertAutoform( const KoRect &rect );
    void insertFreehand( const KoPointArray &_pointArray );
    void insertPolyline( const KoPointArray &_pointArray );
    void insertCubicBezierCurve( const KoPointArray &_pointArray );
    void insertPolygon( const KoPointArray &_pointArray );
    void insertClosedLine( const KoPointArray &_pointArray );
 
    void selectNext();
    void selectPrev();
 
    void scalePixmapToBeOrigIn( const KoSize &currentSize, const KoSize &pgSize,
                                const TQSize &presSize, KPrPixmapObject *obj );
    bool getPixmapOrigAndCurrentSize( KPrPixmapObject *&obj, KoSize *origSize, KoSize *currentSize );
    void setTextBackground( KPrTextObject *obj );
    virtual bool eventFilter( TQObject *o, TQEvent *e );
    virtual bool focusNextPrevChild( bool );
 
    void endDrawPolyline();
 
    void drawCubicBezierCurve( TQPainter &p, KoPointArray &points );
    //void drawCubicBezierCurve( int _dx, int _dy );
    void endDrawCubicBezierCurve();

    void redrawCubicBezierCurve( TQPainter &p );
 
 
#ifndef NDEBUG
    void printRTDebug( int info );
#endif
 
    KoRect getAlignBoundingRect() const;
 
private:
    void picViewOrigHelper(int x, int y);

    void moveObjectsByKey( int x, int y );

    void moveObjectsByMouse( KoPoint &pos, bool keepXorYunchanged );
 
    //---- stuff needed for resizing ----
    void resizeObject( ModifyType _modType, const KoPoint & point, bool keepRatio, bool scaleAroundCenter );
    void finishResizeObject( const TQString &name, bool layout = true );

    void raiseObject( KPrObject *object );
    void lowerObject();
    const TQPtrList<KPrObject> displayObjectList() const; 

    bool m_setPageTimer;

    void drawPolygon( TQPainter &p, const KoRect &rect );

    void drawPieObject( TQPainter *p,  const KoRect &rect );
 
    TQPoint limitOfPoint(const TQPoint& _point) const;

    bool objectIsAHeaderFooterHidden(KPrObject *obj) const;
 
    KPrTextObject* textUnderMouse( const TQPoint & point );
    bool checkCurrentTextEdit( KPrTextObject * textObj );

    KoPoint snapPoint( KoPoint &pos, bool repaintSnapping = true );

    KoPoint diffGrid( KoRect &rect, double diffx, double diffy );
 
    void recalcAutoGuides( );

    KoPointArray getObjectPoints( const KoPointArray &pointArray );
 

    void updateInsertRect( const KoPoint &point, TQt::ButtonState state );

    void popupContextMenu();
 
private slots:
    void toFontChanged( const TQFont &font ) { emit fontChanged( font ); }
    void toColorChanged( const TQColor &color ) { emit colorChanged( color ); }
    void toAlignChanged( int a ) { emit alignChanged( a ); }
    void setDrawingMode();
    void setSwitchingMode( bool continueTimer = true );
    void slotGotoPage();
    void slotExitPres();
    void terminateEditing( KPrTextObject * );

    void slotDoEffect();
 
    void slotDoPageEffect();

    void slotAutoScroll(const TQPoint &scrollDist);

    void speakTextUnderMouse(TQWidget* w, const TQPoint& p, uint flags);
 
private:
    static const int MOUSE_SNAP_DISTANCE;
    static const int KEY_SNAP_DISTANCE;
    // variables
    TDEPopupMenu *m_presMenu;
    bool showingLastSlide;
    bool mousePressed;
    bool drawContour;
    ModifyType modType;

    KPrObject * m_editObject;
 
    bool fillBlack;
    KPrView *m_view;
    bool editMode, goingBack;
    bool m_drawMode;
    bool m_drawLineInDrawMode;

    TQValueVector<TQPointArray> m_drawModeLines;

    int m_drawModeLineIndex;
 
    bool mouseSelectedObject;
    PresStep m_step;
    float _presFakt;
    int m_showOnlyPage; // 1-based (-1 = all)
    TQValueList<int> m_pageEffectSteps;
    TQValueList<int> m_presentationSlides;
    TQValueList<int>::Iterator m_presentationSlidesIterator;
    KPrEffectHandler *m_effectHandler;
 
    KPrPageEffects *m_pageEffect;

    TQTimer m_effectTimer;
 
    TQTimer m_pageEffectTimer;

    int PM_DM;
    int delPageId;
    bool drawRubber;
    KoRect m_rubber;
 
    //---- stuff needed for resizing ----
    KPrObject *m_resizeObject;
    KoRect m_rectBeforeResize;
    double m_ratio;
    bool m_isResizing;
 
    //---- stuff needed for moving ----
    bool m_isMoving;
    KoPoint m_moveStartPoint;
 
    //---- stuff needed for rotating ----
    KPrObject *m_rotateObject;
    KoPoint m_rotateCenter;
    KoPoint m_rotateStart;
    double m_angleBeforeRotate;
 
    ToolEditMode toolEditMode;
    KoRect m_insertRect;
    KoDocumentEntry partEntry;
    TQString autoform;
    TQPixmap buffer;
 
    KPrTextView *m_currentTextObjectView;
 
    KPrSoundPlayer *soundPlayer;
 
    KoPointArray m_pointArray, m_oldCubicBezierPointArray;
    TQPoint m_dragStartPoint, m_dragEndPoint, m_dragSymmetricEndPoint;
    KoPoint m_startPoint;
    KoPoint m_endPoint;
    KoPoint m_symmetricEndPoint;
    KoPoint m_CubicBezierSecondPoint, m_CubicBezierThirdPoint;
    int m_indexPointArray;
    bool m_drawPolyline;
    bool m_drawCubicBezierCurve;
    bool m_drawLineWithCubicBezierCurve;
    bool m_zoomRubberDraw;
 
    KPrPage *m_activePage;
    int m_xOffset, m_yOffset;
    int m_xOffsetSaved, m_yOffsetSaved; // saved when going fullscreen

    KoPoint m_moveStartPosMouse;
    KoPoint m_moveSnapDiff;
    bool m_disableSnapping;
    KoPoint m_origMousePos;
    KoPoint m_moveStartPosKey; 
 
    KPrPage * m_activePageBeforePresentation;
    int m_zoomBeforePresentation;
 
    bool m_keyPressEvent;
    bool m_drawSymetricObject;

    KoGuides m_gl;
    bool m_paintGuides;

    KPrObject * m_objectDisplayAbove;

    KPrTextObject *m_prevSpokenTO;
};
 
#endif // __KPRCANVAS__