KWFrameSet.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999, 2000 Reginald Stadlbauer <reggie@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_set_h
#define frame_set_h
 
#include "KWFrame.h"
#include <tqptrvector.h>
#include <tqptrlist.h>
#include "tqdom.h"
 
class KWAnchor;
class KWFrame;
class KWFrameSetEdit;
class KWPageManager;
class KWTableFrameSet;
class KWTextFrameSet;
class KWTextFrameSetEdit;
class KWTextParag;
class KWView;
class KWordFrameSetIface;
class KWFrameViewManager;
 
class KoSavingContext;
class KoTextDocument;
class KoTextFormat;
class KoTextParag;
class KoXmlWriter;
 
class KCommand;
class TQPoint;
class TQProgressDialog;
 
 
class KWFrameSet : public TQObject
{
    TQ_OBJECT
  
public:
    KWFrameSet( KWDocument *doc );
    virtual ~KWFrameSet();
 
    virtual KWordFrameSetIface* dcopObject();
 
    virtual FrameSetType type() const { return FT_BASE; }
 
    virtual void addTextFrameSets( TQPtrList<KWTextFrameSet> & /*lst*/, bool /*onlyReadWrite*/ = false ) {};
    virtual bool ownLine() const { return false;}
 
    enum Info { FI_BODY = 0, FI_FIRST_HEADER = 1, FI_EVEN_HEADER = 2, FI_ODD_HEADER = 3,
                FI_FIRST_FOOTER = 4, FI_EVEN_FOOTER = 5, FI_ODD_FOOTER = 6,
                FI_FOOTNOTE = 7 };
    Info frameSetInfo()const { return m_info; }
    void setFrameSetInfo( Info fi ) { m_info = fi; }
 
    bool isAHeader() const;
    bool isAFooter() const;
    bool isHeaderOrFooter() const { return isAHeader() || isAFooter(); }
    bool isFootEndNote() const;
    const char* headerFooterTag() const; // for OASIS saving
 
    virtual bool isFootNote() const { return false; }
    virtual bool isEndNote() const { return false; }
 
    bool isMainFrameset() const;
    bool isMoveable() const;
 
    // frame management
    virtual void addFrame( KWFrame *_frame, bool recalc = true );
 
    virtual void deleteFrame( unsigned int num, bool remove = true, bool recalc = true );
 
    void deleteFrame( KWFrame *frm, bool remove = true, bool recalc = true ); // calls the virtual one
 
    virtual void frameDeleted( KWFrame* /*frm*/, bool /*recalc*/ ) {}
 
    void deleteAllFrames();
    void deleteAllCopies(); 
 
    KWFrame *frameAtPos( double _x, double _y ) const;
 
    bool isFrameAtPos( const KWFrame* frame, const TQPoint& nPoint, bool borderOfFrameOnly=false ) const;
 
    KWFrame *frame( unsigned int _num ) const;
 
    static KWFrame * settingsFrame( const KWFrame* frame );
 
    const TQPtrList<KWFrame> &frameIterator() const { return m_frames; }
    int frameFromPtr( KWFrame *frame );
    unsigned int frameCount() const { return m_frames.count(); }
 
    bool isDeleted() const { return m_frames.isEmpty(); }
 
    virtual KWFrameSetEdit * createFrameSetEdit( KWCanvas * ) { return 0; }
 
    virtual void createEmptyRegion( const TQRect & crect, TQRegion & emptyRegion, KWViewMode *viewMode );
 
    virtual void drawContents( TQPainter *painter, const TQRect &crect,
                               const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
                               KWFrameSetEdit *edit, KWViewMode *viewMode,
                               KWFrameViewManager *frameViewManager );
 
    void drawFrameAndBorders( KWFrame *frame,
                              TQPainter *painter, const TQRect &crect,
                              const TQColorGroup &cg, bool, bool,
                              KWFrameSetEdit *edit, KWViewMode *viewMode,
                              KWFrame *settingsFrame, bool drawUnderlyingFrames );
 
    void drawFrameBorder( TQPainter *painter, KWFrame *frame, KWFrame *settingsFrame,
                          const TQRect &crect, KWViewMode *viewMode );
 
    virtual void drawFrame( KWFrame *frame, TQPainter *painter, const TQRect &fcrect, const TQRect &crect,
                            const TQPoint& translationOffset,
                            KWFrame *settingsFrame, const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
                            KWFrameSetEdit *edit, KWViewMode *viewMode, bool drawUnderlyingFrames );
 
    virtual void drawFrameContents( KWFrame * frame, TQPainter *painter, const TQRect& fcrect,
                                    const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
                                    KWFrameSetEdit * edit, KWViewMode *viewMode );
 
    virtual void drawPadding( KWFrame *frame, TQPainter *p, const TQRect &fcrect, const TQColorGroup &cg, KWViewMode *viewMode);
 
    enum UpdateFramesFlags {
        UpdateFramesInPage = 1,
        SortFrames = 2 
        // next one is 4, not 3 ;)
    };
    virtual void updateFrames( int flags = 0xff );
 
    const TQPtrList<KWFrame> & framesInPage( int pageNum ) const;
 
    bool hasFramesInPageArray() const { return !m_framesInPage.isEmpty(); }
 
    virtual void layout() {}
    virtual void invalidate() {}
 
    virtual TQDomElement save( TQDomElement &parentElem, bool saveFrames = true ) = 0;
    virtual TQDomElement toXML( TQDomElement &parentElem, bool saveFrames = true )
    { return save( parentElem, saveFrames ); }
    virtual void saveOasis( KoXmlWriter& writer, KoSavingContext& context, bool saveFrames ) const = 0;
    virtual bool canBeSavedAsInlineCharacter() const { return true; }
 
    virtual void load( TQDomElement &framesetElem, bool loadFrames = true );
    KWFrame* loadOasisFrame( const TQDomElement& tag, KoOasisContext& context );
    virtual void fromXML( TQDomElement &framesetElem, bool loadFrames = true, bool /*useNames*/ = true )
    { load( framesetElem, loadFrames ); }
 
    virtual TQString toPlainText() const { return TQString(); }
 
    //virtual void preparePrinting( TQPainter *, TQProgressDialog *, int & ) { }
 
    virtual void finalize();
 
    virtual int paragraphs() { return 0; }
    virtual int paragraphsSelected() { return 0; }
    virtual bool statistics( TQProgressDialog * /*progress*/,  ulong & /*charsWithSpace*/, ulong & /*charsWithoutSpace*/, ulong & /*words*/,
                             ulong & /*sentences*/, ulong & /*syllables*/, ulong & /*lines*/,  bool /*process only selected */ ) { return true; }
 
    KWDocument* kWordDocument() const { return m_doc; }
 
    virtual bool canRemovePage( int num );
 
    //Note: none of those floating-frameset methods creates undo/redo
    //They are _called_ by the undo/redo commands.
 
    void setFloating();
    void setAnchored( KWTextFrameSet* textfs, KoTextParag* parag, int index, bool placeHolderExists = false, bool repaint = true );
    void setAnchored( KWTextFrameSet* textfs, int paragId, int index, bool placeHolderExists = false, bool repaint = true );
    void setAnchored( KWTextFrameSet* textfs );
    void setFixed();
    bool isFloating() const { return m_anchorTextFs; }
    KWTextFrameSet * anchorFrameset() const { return m_anchorTextFs; }
    void setAnchorFrameset(KWTextFrameSet * textfs) { m_anchorTextFs = textfs; }
    KWAnchor * findAnchor( int frameNum );
    virtual void setAnchorFormat( KoTextFormat* /*format*/, int /*frameNum*/ ) {}
 
    virtual KWAnchor * createAnchor( KoTextDocument *txt, int frameNum );
 
    virtual void moveFloatingFrame( int frameNum, const KoPoint &position );
    virtual KoSize floatingFrameSize( int frameNum = 0 );
    KoRect floatingFrameRect( int frameNum = 0 );
    virtual int floatingFrameBaseline( int /*frameNum*/ ) { return -1; }
    virtual KCommand * anchoredObjectCreateCommand( int frameNum );
    virtual KCommand * anchoredObjectDeleteCommand( int frameNum );
 
    void setGroupManager( KWTableFrameSet *gm ) { m_groupmanager = gm; }
    KWTableFrameSet *groupmanager()const { return m_groupmanager; }
 
    bool isProtectSize()const { return m_protectSize; }
    void setProtectSize( bool _b);
 
    bool isVisible( KWViewMode* viewMode = 0L ) const;
 
    virtual void setVisible( bool v );
 
    TQString name() const { return m_name; }
    void setName( const TQString &name );
 
    void setFrameBehavior( KWFrame::FrameBehavior fb );
 
    void setNewFrameBehavior( KWFrame::NewFrameBehavior nfb );
 
#ifndef NDEBUG
    virtual void printDebug();
    virtual void printDebug( KWFrame * );
#endif
 
    virtual KWTextFrameSet* nextTextObject( KWFrameSet * ) { return 0L;}
 
    bool isPaintedBy( KWFrameSet* fs ) const;
 
    virtual void setZOrder();
 
    virtual void setProtectContent ( bool protect ) = 0;
    virtual bool protectContent() const = 0;
 
    void setPageManager(KWPageManager *pm) { m_pageManager = pm; }
    KWPageManager* pageManager() const { return m_pageManager; }
 
signals:
 
    void repaintChanged( KWFrameSet * frameset );
 
    void sigFrameAdded(KWFrame*);
    void sigFrameRemoved(KWFrame*);
 
    void sigNameChanged(KWFrameSet*);
 
protected:
 
    void saveCommon( TQDomElement &parentElem, bool saveFrames );
 
    TQRegion frameClipRegion( TQPainter * painter, KWFrame *frame, const TQRect & crect,
                             KWViewMode * viewMode );
 
    void deleteAnchor( KWAnchor * anchor );
    virtual void deleteAnchors();
    virtual void createAnchors( KoTextParag * parag, int index, bool placeHolderExists = false, bool repaint = true );
 
 
    KWDocument *m_doc;            // Document
    TQPtrList<KWFrame> m_frames;        // Our frames
 
    // Cached info for optimization
    TQPtrVector< TQPtrList<KWFrame> > m_framesInPage;
    int m_firstPage;
    TQPtrList<KWFrame> m_emptyList; // ## make static pointer to save memory ?
 
    Info m_info;
    KWTableFrameSet *m_groupmanager;
    bool m_visible;
    bool m_protectSize;
    TQString m_name;
    KWTextFrameSet * m_anchorTextFs;
    KWordFrameSetIface *m_dcop;
    KWPageManager *m_pageManager;
};
 
#endif