KWFrame.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999, 2000 Reginald Stadlbauer <reggie@kde.org>
   Copyright (C) 2000-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 frame_h
#define frame_h
 
#include "defs.h"
#include <KoRect.h>
#include <tqbrush.h>
#include "KoBorder.h"
#include <tqptrlist.h>
 
class KWCanvas;
class KWDocument;
class KWFrame;
class KWFrameList;
class KWFrameSet;
class KWViewMode;
 
class KoGenStyle;
class KoGenStyles;
class KoOasisContext;
class KoStyleStack;
class KoXmlWriter;
 
class TQDomElement;

class ZOrderedFrameList : public TQPtrList<KWFrame>
{
protected:
    virtual int compareItems(TQPtrCollection::Item a, TQPtrCollection::Item b);
};
 

class KWFrame : public KoRect
{
public:
    enum RunAround { RA_NO = 0, RA_BOUNDINGRECT = 1, RA_SKIP = 2 };

    enum RunAroundSide { RA_BIGGEST = 0, RA_LEFT = 1, RA_RIGHT = 2 };

    KWFrame(KWFrameSet *fs, double left, double top, double width, double height,
            RunAround ra = RA_BOUNDINGRECT);
    KWFrame(KWFrame * frame);
    virtual ~KWFrame();
 
    double runAroundLeft() const { return m_runAroundLeft; }
    double runAroundRight() const { return m_runAroundRight; }
    double runAroundTop() const { return m_runAroundTop; }
    double runAroundBottom() const { return m_runAroundBottom; }
 
    void setRunAroundGap( double left, double right, double top, double bottom ) {
        m_runAroundLeft = left;
        m_runAroundRight = right;
        m_runAroundTop = top;
        m_runAroundBottom = bottom;
    }
 
    RunAround runAround()const { return m_runAround; }
    void setRunAround( RunAround _ra ) { m_runAround = _ra; }
 
    RunAroundSide runAroundSide() const { return m_runAroundSide; }
    void setRunAroundSide( RunAroundSide rs ) { m_runAroundSide = rs; }

    enum FrameBehavior { AutoExtendFrame=0 , AutoCreateNewFrame=1, Ignore=2 };
 
    FrameBehavior frameBehavior()const { return m_frameBehavior; }
    void setFrameBehavior( FrameBehavior fb ) { m_frameBehavior = fb; }
 
    /* Frame duplication properties */

    enum SheetSide { AnySide=0, OddSide=1, EvenSide=2};
    SheetSide sheetSide()const { return m_sheetSide; }
    void setSheetSide( SheetSide ss ) { m_sheetSide = ss; }

    enum NewFrameBehavior { Reconnect=0, NoFollowup=1, Copy=2 };
    NewFrameBehavior newFrameBehavior()const { return m_newFrameBehavior; }
    void setNewFrameBehavior( NewFrameBehavior nfb ) { m_newFrameBehavior = nfb; }

    bool isCopy()const { return m_bCopy; }
    void setCopy( bool copy ) { m_bCopy = copy; }

    KWFrameSet *frameSet() const { return m_frameSet; }
    void setFrameSet( KWFrameSet *fs ) { m_frameSet = fs; }

    int pageNumber() const;
    int pageNumber( KWDocument* doc ) const;

    void setZOrder( int z ) { m_zOrder = z; }
    int zOrder() const { return m_zOrder; }

    static bool compareFrameZOrder(KWFrame *f1, KWFrame *f2);
 
    KWFrameList* frameStack() { return m_frameStack; }
    void setFrameStack(KWFrameList *fl) { m_frameStack = fl; }

    const KoBorder &leftBorder() const { return m_borderLeft; }
    const KoBorder &rightBorder() const { return m_borderRight; }
    const KoBorder &topBorder() const { return m_borderTop; }
    const KoBorder &bottomBorder() const { return m_borderBottom; }
 
 
    void setLeftBorder( KoBorder _brd ) { m_borderLeft = _brd; }
    void setRightBorder( KoBorder _brd ) { m_borderRight = _brd; }
    void setTopBorder( KoBorder _brd ) { m_borderTop = _brd; }
    void setBottomBorder( KoBorder _brd ) { m_borderBottom = _brd; }

    TQRect outerRect( KWViewMode* viewMode ) const;

    KoRect outerKoRect() const;

    KoRect runAroundRect() const;

    const KoRect& rect() const { return *this; }

    void frameBordersChanged();
    void updateRulerHandles();
 
    TQBrush backgroundColor() const { return m_backgroundColor; }
    void setBackgroundColor( const TQBrush &_color );
    bool isTransparent() const { return m_backgroundColor.style() != TQt::SolidPattern; }
 
    KoRect innerRect() const;
 
    double innerWidth() const;
    double innerHeight() const;
 

    void setInternalY( double y ) { m_internalY = y; }
    double internalY() const { return m_internalY; }

    void setPaddingLeft( double b ) { m_paddingLeft = b; }
    void setPaddingRight( double b ) { m_paddingRight = b; }
    void setPaddingTop( double b ) { m_paddingTop = b; }
    void setPaddingBottom( double b ) { m_paddingBottom = b; }

    double paddingLeft() const { return m_paddingLeft; }
    double paddingRight() const { return m_paddingRight; }
    double paddingTop() const { return m_paddingTop; }
    double paddingBottom() const { return m_paddingBottom; }
 
    void setFramePadding( double _left, double _top, double right, double bottom);
    KWFrame *getCopy();
 
    void copySettings(KWFrame *frm);

    void save( TQDomElement &frameElem );
    void load( TQDomElement &frameElem, KWFrameSet* frameSet, int syntaxVersion );
    void loadCommonOasisProperties( KoOasisContext& context, KWFrameSet* frameSet, const char* typeProperties );
    void loadBorderProperties( KoStyleStack& styleStack );
 
    TQString saveOasisFrameStyle( KoGenStyles& mainStyles ) const;
    void startOasisFrame( KoXmlWriter &xmlWriter, KoGenStyles& mainStyles, const TQString& name,
                          const TQString& lastFrameName = TQString() ) const;
    void saveBorderProperties( KoGenStyle& frameStyle ) const;
    void saveMarginProperties( KoGenStyle& frameStyle ) const;
    void saveMarginAttributes( KoXmlWriter &writer ) const;

    void setMinimumFrameHeight(double h) { m_minFrameHeight = h; }
    double minimumFrameHeight(void)const {return m_minFrameHeight;}

    bool frameAtPos( const TQPoint& nPoint, bool borderOfFrameOnly=false ) const;

    void setDrawFootNoteLine( bool b ) { m_drawFootNoteLine = b; }
    bool drawFootNoteLine()const { return m_drawFootNoteLine; }
 
private:
    SheetSide m_sheetSide : 2;
    RunAround m_runAround : 2;
    RunAroundSide m_runAroundSide : 2;
    FrameBehavior m_frameBehavior : 2;
    NewFrameBehavior m_newFrameBehavior : 2;
    bool m_bCopy;
    bool m_drawFootNoteLine;
 
    double m_runAroundLeft, m_runAroundRight, m_runAroundTop, m_runAroundBottom;
    double m_paddingLeft, m_paddingRight, m_paddingTop, m_paddingBottom;
    double m_minFrameHeight;
 
    double m_internalY;
    int m_zOrder;
 
    TQBrush m_backgroundColor;
    KoBorder m_borderLeft, m_borderRight, m_borderTop, m_borderBottom;

    KWFrameList *m_frameStack;
    KWFrameSet *m_frameSet;

    KWFrame &operator=( const KWFrame &_frame );
    KWFrame ( const KWFrame &_frame );
};
 
#endif