KWViewMode.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 kwviewmode_h
#define kwviewmode_h
 
#include <tqrect.h>
class KWDocument;
class TQPainter;
class TQRegion;
class KWTextFrameSet;
class KWFrameSet;
class KWCanvas;
class KoRuler;
class KoPageLayout;
class KWPage;

class KWViewMode
{
protected:
    KWViewMode( KWDocument * doc, KWCanvas* canvas, bool drawFrameBorders )
        : m_doc( doc ), m_canvas( canvas ), m_drawFrameBorders( drawFrameBorders )
    {}
public:
    virtual ~KWViewMode() {}

    virtual TQPoint normalToView( const TQPoint & nPoint ) = 0;

    TQRect normalToView( const TQRect & nRect )
    { return TQRect( normalToView( nRect.topLeft() ), nRect.size() ); }

    virtual TQPoint viewToNormal( const TQPoint & vPoint ) = 0;

    TQRect viewToNormal( const TQRect & nRect )
    { return TQRect( viewToNormal( nRect.topLeft() ), viewToNormal( nRect.bottomRight() ) ); }

    virtual TQRect viewPageRect( int pgNum ) = 0;

    virtual TQSize contentsSize() = 0;

    virtual TQSize availableSizeForText( KWTextFrameSet* textfs );

    virtual TQPoint pageCorner();
    virtual TQRect rulerFrameRect();
    virtual void setPageLayout( KoRuler* hRuler, KoRuler* vRuler, const KoPageLayout& layout );
 
    virtual void drawPageBorders( TQPainter * painter, const TQRect & crect, const TQRegion & emptySpaceRegion ) = 0;

    virtual void setPagesPerRow(int) {}
    virtual int pagesPerRow() { return 0; }

    virtual bool drawSelections() { return true; }

    virtual bool drawFrameBackground() { return true; }

    bool drawFrameBorders() const { return m_drawFrameBorders; }
    void setDrawFrameBorders(bool b)  { m_drawFrameBorders = b; }

    virtual bool isFrameSetVisible( const KWFrameSet* /*frameset*/ ) { return true; }

    // TODO: maybe this should be more fine-grained.
    virtual bool shouldFormatVertically() { return true; }

    virtual bool shouldAdjustMargins() { return true; }

    virtual bool hasFrames() { return true; }

    virtual bool hasPages() { return true; }

    virtual const TQString type() const = 0;

    virtual bool isTextModeFrameset(KWFrameSet *) const { return false; }
 
    static KWViewMode *create( const TQString& viewModeType, KWDocument* doc, KWCanvas* canvas );
 
    KWCanvas * canvas() const { return m_canvas; }
 
protected:
    void drawOnePageBorder( TQPainter * painter, const TQRect & crect, const TQRect & pageRect,
                            const TQRegion & emptySpaceRegion );
    TQRect drawRightShadow( TQPainter * painter, const TQRect & crect, const TQRect & pageRect, int topOffset );
    TQRect drawBottomShadow( TQPainter * painter, const TQRect & crect, const TQRect & pageRect, int leftOffset );
    static const unsigned short s_shadowOffset;
 
    KWDocument * m_doc;
    KWCanvas * m_canvas;
    bool m_drawFrameBorders;
};

class KWViewModeNormal : public KWViewMode
{
public:
    KWViewModeNormal( KWDocument * doc, KWCanvas* canvas, bool drawFrameBorders )
        : KWViewMode( doc, canvas, drawFrameBorders ) {}
    virtual ~KWViewModeNormal() {}
 
    virtual TQPoint normalToView( const TQPoint & nPoint );
    virtual TQPoint viewToNormal( const TQPoint & vPoint );
    virtual TQRect viewPageRect( int pgNum );
    virtual TQSize contentsSize();
 
    virtual const TQString type() const { return "ModeNormal"; }
 
    virtual void drawPageBorders( TQPainter * painter, const TQRect & crect, const TQRegion & emptySpaceRegion );
 
protected:
    virtual int xOffset(KWPage *page, int canvasWidth = -1);
};

class KWViewModePrint : public KWViewModeNormal // we inherit the "normal" viewmode
{
public:
    KWViewModePrint( KWDocument * doc, KWCanvas* canvas )
        : KWViewModeNormal( doc, canvas, false /*drawFrameBorders*/ ) {}
    virtual ~KWViewModePrint() {}
    virtual bool drawSelections() { return false; }
protected:
    virtual int xOffset(KWPage *page, int canvasWidth = -1);
};

class KWViewModeEmbedded : public KWViewMode
{
public:
    KWViewModeEmbedded ( KWDocument * doc, KWCanvas* canvas )
        : KWViewMode( doc, canvas, false /*drawFrameBorders*/ ),
          mDrawFrameBackground( true ),
          mDrawSelections( true )
    {}
    virtual ~ KWViewModeEmbedded() {}
 
    void setDrawFrameBackground( bool b ) { mDrawFrameBackground = b; }
    void setDrawSelections( bool b ) { mDrawSelections = b; }
 
    // This view mode is very easy to implement ;-P
    virtual TQPoint normalToView( const TQPoint & nPoint ) { return nPoint; }
    virtual TQPoint viewToNormal( const TQPoint & vPoint ) { return vPoint; }
    virtual TQRect viewPageRect( int pgNum );
    virtual TQSize contentsSize() { return TQSize(); }
    virtual bool hasPages() { return false; }
 
    virtual void drawPageBorders( TQPainter *, const TQRect &, const TQRegion & ){}
    virtual bool drawSelections() { return mDrawSelections; }
 
    virtual const TQString type() const { return "ModeEmbedded"; }
    virtual bool drawFrameBackground() { return mDrawFrameBackground; }
 
private:
    bool mDrawFrameBackground;
    bool mDrawSelections;
};
 

class KWViewModePreview : public KWViewMode
{
public:
    KWViewModePreview( KWDocument * doc, KWCanvas* canvas, bool drawFrameBorders, int _nbPagePerRow );
    virtual ~KWViewModePreview() {}
 
    virtual TQPoint normalToView( const TQPoint & nPoint );
    virtual TQPoint viewToNormal( const TQPoint & vPoint );
    virtual TQRect viewPageRect( int pgNum );
    virtual TQSize contentsSize();
    virtual void drawPageBorders( TQPainter * painter, const TQRect & crect, const TQRegion & emptySpaceRegion );
 
    virtual void setPagesPerRow(int _nb) {m_pagesPerRow=_nb;}
    virtual int pagesPerRow() {return m_pagesPerRow;}
    virtual const TQString type() const { return "ModePreview"; }
 
    int numRows() const;
 
//protected:
    int leftSpacing();
    int topSpacing();
 
private:
    int m_pagesPerRow;
    int m_spacing;
};

class KWViewModeText : public KWViewMode
{
public:
 
    KWViewModeText( KWDocument * doc, KWCanvas* canvas, KWTextFrameSet* fs );
    virtual ~KWViewModeText() {}
 
    KWTextFrameSet *textFrameSet() const;
    static KWTextFrameSet *determineTextFrameSet( KWDocument* doc );
 
    virtual TQPoint normalToView( const TQPoint & nPoint );
    virtual TQPoint viewToNormal( const TQPoint & vPoint );
    virtual TQSize contentsSize();
    virtual TQRect viewPageRect( int ) { return TQRect(); }
    virtual TQSize availableSizeForText( KWTextFrameSet* textfs );
    // There is no page concept. Keep everything relative to (0,0)
    virtual TQPoint pageCorner() { return TQPoint( 0, 0 ); }
    virtual TQRect rulerFrameRect();
    virtual void setPageLayout( KoRuler* hRuler, KoRuler* vRuler, const KoPageLayout& layout );
 
    virtual void drawPageBorders( TQPainter * painter, const TQRect & crect, const TQRegion & emptySpaceRegion );
    virtual const TQString type() const { return "ModeText"; }
    virtual bool shouldFormatVertically() { return false; }
    virtual bool shouldAdjustMargins() { return false; }
    virtual bool hasFrames() { return false; }
    virtual bool hasPages() { return false; }
 
    virtual bool isFrameSetVisible( const KWFrameSet* fs );
 
    virtual bool isTextModeFrameset(KWFrameSet *fs) const;

    static const int OFFSET = 10;
 
 
private:
    mutable KWTextFrameSet *m_textFrameSet;
};
 
#endif