You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
506 lines
23 KiB
506 lines
23 KiB
/* 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
|
|
* Base type, a frameset holds content as well as frames to show that
|
|
* content.
|
|
* The different types of content are implemented in the different
|
|
* types of frameSet implementations (see below)
|
|
* @see KWTextFrameSet, KWPartFrameSet, KWPictureFrameSet,
|
|
* KWFormulaFrameSet, KWTableFrameSet
|
|
*/
|
|
class KWFrameSet : public TQObject
|
|
{
|
|
Q_OBJECT
|
|
TQ_OBJECT
|
|
public:
|
|
/// constructor
|
|
KWFrameSet( KWDocument *doc );
|
|
/// destructor
|
|
virtual ~KWFrameSet();
|
|
|
|
virtual KWordFrameSetIface* dcopObject();
|
|
|
|
/** The type of frameset. Use this to differentiate between different instantiations of
|
|
* the framesets. Each implementation will return a different frameType.
|
|
*/
|
|
virtual FrameSetType type() const { return FT_BASE; }
|
|
|
|
virtual void addTextFrameSets( TQPtrList<KWTextFrameSet> & /*lst*/, bool /*onlyReadWrite*/ = false ) {};
|
|
virtual bool ownLine() const { return FALSE;}
|
|
|
|
/** The different types of textFramesets (that TEXT is important here!)
|
|
* FI_BODY = normal text frames.<br>
|
|
* FI_FIRST_HEADER = Header on page 1<br>
|
|
* FI_EVEN_HEADER = header on any even page<br>
|
|
* FI_ODD_HEADER = header on any odd page (can be including page 1)<br>
|
|
* FI_FIRST_FOOTER = footer on page 1<br>
|
|
* FI_EVEN_FOOTER = footer on any even page<br>
|
|
* FI_ODD_FOOTER = footer on any odd page (can be including page 1)<br>
|
|
* FI_FOOTNOTE = a footnote frame.
|
|
*/
|
|
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 };
|
|
/** Returns the type of TextFrameSet this is */
|
|
Info frameSetInfo()const { return m_info; }
|
|
/** Set the type of TextFrameSet this is */
|
|
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 );
|
|
|
|
/** Delete a frame from the set of frames this frameSet has.
|
|
* @param num The frameNumber to be removed.
|
|
* @param remove passing true means that there can not be an undo of the action.
|
|
* @param recalc do an updateFrames()
|
|
*/
|
|
virtual void deleteFrame( unsigned int num, bool remove = true, bool recalc = true );
|
|
|
|
/** Delete a frame from the set of frames this frameSet has.
|
|
* @param frm The frame that should be deleted
|
|
* @param remove passing true means that there can not be an undo of the action.
|
|
* @param recalc do an updateFrames()
|
|
*/
|
|
void deleteFrame( KWFrame *frm, bool remove = true, bool recalc = true ); // calls the virtual one
|
|
|
|
/// Called by deleteFrame when it really deletes a frame (remove=true), to remove it from the table too
|
|
virtual void frameDeleted( KWFrame* /*frm*/, bool /*recalc*/ ) {}
|
|
|
|
void deleteAllFrames();
|
|
void deleteAllCopies(); /// \note for headers/footers only
|
|
|
|
/** retrieve frame from x and y coords (unzoomed coords) */
|
|
KWFrame *frameAtPos( double _x, double _y ) const;
|
|
|
|
/** Return if the point is on the frame.
|
|
* @param nPoint the point in normal coordinates.
|
|
* @param borderOfFrameOnly when true an additional check is done if the point
|
|
* is on the border.
|
|
* @param frame the frame to check inside of
|
|
*/
|
|
bool isFrameAtPos( const KWFrame* frame, const TQPoint& nPoint, bool borderOfFrameOnly=false ) const;
|
|
|
|
/** get a frame by number */
|
|
KWFrame *frame( unsigned int _num ) const;
|
|
|
|
/**
|
|
* Returns the original frame that the param frame is a copy off, or the frame itself.
|
|
* For changing a frame that is a copy of another (as found in KWFrame::isCopy()) you
|
|
* need a so called settings frame, or original frame. This method can savely be called
|
|
* on any frame to make sure you are dealing with the original frame.
|
|
* @param frame the frame to find the settings frame for.
|
|
* @return the frame itself if its not a copy, or the original frame if it is one.
|
|
*/
|
|
static KWFrame * settingsFrame( const KWFrame* frame );
|
|
|
|
/** Iterator over the child frames */
|
|
const TQPtrList<KWFrame> &frameIterator() const { return m_frames; }
|
|
/** Get frame number */
|
|
int frameFromPtr( KWFrame *frame );
|
|
/** Get number of child frames */
|
|
unsigned int frameCount() const { return m_frames.count(); }
|
|
|
|
/** True if the frameset was deleted (but not destroyed, since it's in the undo/redo) */
|
|
bool isDeleted() const { return m_frames.isEmpty(); }
|
|
|
|
/** Create a framesetedit object to edit this frameset in @p canvas */
|
|
virtual KWFrameSetEdit * createFrameSetEdit( KWCanvas * ) { return 0; }
|
|
|
|
/**
|
|
* Let the caller know which parts of @p emptyRegion we do not claim, and thus the caller is
|
|
* free to paint on without interfering with later paints from us.
|
|
* For painting all frames of all framesets the painter needs to find out what area we
|
|
* will fill with a background color and possibly paint over.
|
|
* What this method does is fill an TQRegion with all the areas we are going to fill, which
|
|
* typically means we will paint the background of a frame there.
|
|
* @param emptyRegion The region is modified to subtract the areas painted, thus
|
|
* allowing the caller to determine which areas remain to be painted.
|
|
* Framesets that can be transparent should reimplement this and make it a no-op,
|
|
* so that the background is painted below the transparent frame.
|
|
* @param crect the cliprect; only parts inside this rect are of interrest to us
|
|
* @param viewMode For coordinate conversion, always set.
|
|
*/
|
|
virtual void createEmptyRegion( const TQRect & crect, TQRegion & emptyRegion, KWViewMode *viewMode );
|
|
|
|
/**
|
|
* Paint this frameset
|
|
* @param painter The painter in which to draw the contents of the frameset
|
|
* @param crect The rectangle (in scrollview "contents coordinates", i.e. "view coords")
|
|
* to be painted
|
|
* @param cg The colorgroup from which to get the colors
|
|
* @param onlyChanged If true, only redraw what has changed (see KWCanvas::repaintChanged)
|
|
* @param resetChanged If true, set the changed flag to false after drawing.
|
|
* @param edit If set, this frameset is being edited, so a cursor is needed.
|
|
* @param viewMode For coordinate conversion, always set.
|
|
* @param frameViewManager the frameViewManager;
|
|
*
|
|
* The way this "onlyChanged/resetChanged" works is: when something changes,
|
|
* all views are asked to redraw themselves with onlyChanged=true.
|
|
* But all views except the last one shouldn't reset the changed flag to false,
|
|
* otherwise the other views wouldn't tqrepaint anything.
|
|
* So resetChanged is called with "false" for all views except the last one,
|
|
* and with "true" for the last one, so that it resets the flag.
|
|
*
|
|
* Framesets shouldn't reimplement this one in theory [but KWTableFrameSet has to].
|
|
*/
|
|
virtual void drawContents( TQPainter *painter, const TQRect &crect,
|
|
const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
|
|
KWFrameSetEdit *edit, KWViewMode *viewMode,
|
|
KWFrameViewManager *frameViewManager );
|
|
|
|
/**
|
|
* This one is called by drawContents for each frame.
|
|
* It sets up clip rect and painter translation, and calls drawFrame, drawFrameBorder and drawMargins
|
|
*
|
|
* @param drawUnderlyingFrames if the frame implements it, then it should draw underlying frames.
|
|
* This is set to false by the default drawFrame implementation, so that the frames under a
|
|
* transparent frame are simply drawn, without transparency handling (nor their own
|
|
* double-buffering).
|
|
* @param frame the frame to draw
|
|
* @param painter the painter to draw to
|
|
* @param settingsFrame The frame from which we take the settings (usually @p frame, but not with Copy behaviour)
|
|
* @param cg The colorgroup from which to get the colors
|
|
* @param edit If set, this frameset is being edited, so a cursor is needed.
|
|
* @param viewMode For coordinate conversion, always set.
|
|
* @param crect rectangle to be repainted, in view coordinates. Includes padding.
|
|
*/
|
|
void drawFrameAndBorders( KWFrame *frame,
|
|
TQPainter *painter, const TQRect &crect,
|
|
const TQColorGroup &cg, bool, bool,
|
|
KWFrameSetEdit *edit, KWViewMode *viewMode,
|
|
KWFrame *settingsFrame, bool drawUnderlyingFrames );
|
|
|
|
/**
|
|
* Paint the borders for one frame of this frameset.
|
|
* @param painter The painter in which to draw the contents of the frameset
|
|
* @param frame The frame to be drawn
|
|
* @param settingsFrame The frame from which we take the settings (usually @p frame, but not with Copy behaviour)
|
|
* @param crect The rectangle (in "contents coordinates") to be painted
|
|
* @param viewMode For coordinate conversion, always set.
|
|
*/
|
|
void drawFrameBorder( TQPainter *painter, KWFrame *frame, KWFrame *settingsFrame,
|
|
const TQRect &crect, KWViewMode *viewMode );
|
|
|
|
/**
|
|
* Draw a particular frame of this frameset.
|
|
* This is called by drawContents and is what framesets must reimplement.
|
|
* @param fcrect rectangle to be repainted, in the _frame_'s coordinate system, in pixels.
|
|
* Doesn't include padding.
|
|
*
|
|
* @param crect rectangle to be repainted, in view coordinates. Includes padding.
|
|
* Default implementation does double-buffering and calls drawFrameContents.
|
|
* @param frame the frame to draw
|
|
* @param painter the painter to draw to
|
|
* @param settingsFrame The frame from which we take the settings (usually @p frame, but not with Copy behaviour)
|
|
* @param cg The colorgroup from which to get the colors
|
|
* @param onlyChanged If true, only redraw what has changed (see KWCanvas::repaintChanged)
|
|
* @param resetChanged If true, set the changed flag to false after drawing.
|
|
* @param edit If set, this frameset is being edited, so a cursor is needed.
|
|
* @param viewMode For coordinate conversion, always set.
|
|
* @param drawUnderlyingFrames if the frame implements it, then it should draw underlying frames.
|
|
* @param translationOffset offset this method will translate the paiter before doing its work.
|
|
*/
|
|
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 );
|
|
|
|
/**
|
|
* Implement this one instead of drawFrame to benefit from double-buffering
|
|
* AND transparency handling (painting frames below this one) automatically.
|
|
* You MUST reimplement one or the other, or you'll get infinite recursion ;)
|
|
*
|
|
* In this method, the painter has been translated to the frame's coordinate system
|
|
* @param fcrect rectangle to be repainted, in the _frame_'s coordinate system, in pixels.
|
|
* Doesn't include padding.
|
|
* @param frame the frame to draw
|
|
* @param painter the painter to draw to
|
|
* @param cg The colorgroup from which to get the colors
|
|
* @param onlyChanged If true, only redraw what has changed (see KWCanvas::repaintChanged)
|
|
* @param resetChanged If true, set the changed flag to false after drawing.
|
|
* @param edit If set, this frameset is being edited, so a cursor is needed.
|
|
* @param viewMode For coordinate conversion, always set.
|
|
*/
|
|
virtual void drawFrameContents( KWFrame * frame, TQPainter *painter, const TQRect& fcrect,
|
|
const TQColorGroup &cg, bool onlyChanged, bool resetChanged,
|
|
KWFrameSetEdit * edit, KWViewMode *viewMode );
|
|
|
|
/**
|
|
* Draw the padding area inside of a specific frame of this frameSet
|
|
*/
|
|
virtual void drawPadding( KWFrame *frame, TQPainter *p, const TQRect &fcrect, const TQColorGroup &cg, KWViewMode *viewMode);
|
|
|
|
enum UpdateFramesFlags {
|
|
UpdateFramesInPage = 1,
|
|
SortFrames = 2 ///< kwtextframeset only
|
|
// next one is 4, not 3 ;)
|
|
};
|
|
/**
|
|
* Called when our frames change, or when another frameset's frames change.
|
|
* Framesets can reimplement it, but should always call the tqparent method.
|
|
*/
|
|
virtual void updateFrames( int flags = 0xff );
|
|
|
|
/** Return list of frames in page @p pageNum.
|
|
* This is fast since it uses the m_framesInPage array.*/
|
|
const TQPtrList<KWFrame> & framesInPage( int pageNum ) const;
|
|
|
|
/** Allows to detect that updateFrames() hasn't been called yet (e.g. on loading) */
|
|
bool hasFramesInPageArray() const { return !m_framesInPage.isEmpty(); }
|
|
|
|
/** retqlayout text in frames, so that it flows correctly around other frames */
|
|
virtual void tqlayout() {}
|
|
virtual void tqinvalidate() {}
|
|
|
|
/// save to XML - when saving
|
|
virtual TQDomElement save( TQDomElement &parentElem, bool saveFrames = true ) = 0;
|
|
/// save to XML - when copying to clipboard
|
|
virtual TQDomElement toXML( TQDomElement &parentElem, bool saveFrames = true )
|
|
{ return save( parentElem, saveFrames ); }
|
|
/// Save to OASIS format
|
|
virtual void saveOasis( KoXmlWriter& writer, KoSavingContext& context, bool saveFrames ) const = 0;
|
|
/// If the frameset is inline, is it ok to save it inside an oasis <text:p>?
|
|
/// If not, KWAnchor will create a textbox around it.
|
|
virtual bool canBeSavedAsInlineCharacter() const { return true; }
|
|
|
|
/// load from XML - when loading
|
|
virtual void load( TQDomElement &framesetElem, bool loadFrames = true );
|
|
KWFrame* loadOasisFrame( const TQDomElement& tag, KoOasisContext& context );
|
|
/// load from XML - when pasting from clipboard
|
|
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 & ) { }
|
|
|
|
/** Called once the frameset has been completely loaded or constructed.
|
|
* The default implementation calls updateFrames() and zoom(). Call the tqparent :) */
|
|
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; }
|
|
|
|
/// Return true if page @p num can be removed, as far as this frameset is concerned
|
|
virtual bool canRemovePage( int num );
|
|
|
|
//Note: none of those floating-frameset methods creates undo/redo
|
|
//They are _called_ by the undo/redo commands.
|
|
|
|
/// Make this frameset floating (anchored), as close to its current position as possible.
|
|
void setFloating();
|
|
/**
|
|
* Make this frameset anchored, with the anchor at @p paragId,@p index in the text frameset @p textfs.
|
|
* Also used during OASIS loading (placeHolderExists=true)
|
|
*/
|
|
void setAnchored( KWTextFrameSet* textfs, KoTextParag* parag, int index, bool placeHolderExists = false, bool tqrepaint = true );
|
|
/** Make this frameset floating, with the anchor at @p paragId,@p index in the text frameset @p textfs.
|
|
* \deprecated
|
|
*/
|
|
void setAnchored( KWTextFrameSet* textfs, int paragId, int index, bool placeHolderExists = false, bool tqrepaint = true );
|
|
/** Note that this frameset has been made floating already, and store anchor position */
|
|
void setAnchored( KWTextFrameSet* textfs );
|
|
/// Make this frameset fixed, i.e. not anchored
|
|
void setFixed();
|
|
/// Return true if this frameset is floating (inline), false if it's fixed
|
|
bool isFloating() const { return m_anchorTextFs; }
|
|
/// Return the frameset in which our anchor is - assuming isFloating()
|
|
KWTextFrameSet * anchorFrameset() const { return m_anchorTextFs; }
|
|
/// Sets the frameset in which we are about to become inline. Used for OASIS loading.
|
|
void setAnchorFrameset(KWTextFrameSet * textfs) { m_anchorTextFs = textfs; }
|
|
/// Return the anchor object for this frame number
|
|
KWAnchor * findAnchor( int frameNum );
|
|
/// Tell this frame the format of it's anchor
|
|
virtual void setAnchorFormat( KoTextFormat* /*format*/, int /*frameNum*/ ) {}
|
|
|
|
/// Create an anchor for the floating frame identified by frameNum
|
|
virtual KWAnchor * createAnchor( KoTextDocument *txt, int frameNum );
|
|
|
|
/** Move the frame frameNum to the given position - this is called when
|
|
the frame is anchored and the anchor moves (see KWAnchor). */
|
|
virtual void moveFloatingFrame( int frameNum, const KoPoint &position );
|
|
/** Get the size of the "floating frame" identified by frameNum.
|
|
By default a real frame but not for tables. */
|
|
virtual KoSize floatingFrameSize( int frameNum = 0 );
|
|
/** Get the rect of the "floating frame" identified by frameNum,
|
|
in coordinates RELATIVE TO THE PARENT FRAMESET.
|
|
This is especially important for multi-tqparent inline frames. */
|
|
KoRect floatingFrameRect( int frameNum = 0 );
|
|
/** Get the 'baseline' to use for the "floating frame" identified by frameNum.
|
|
-1 means same as the height (usual case) */
|
|
virtual int floatingFrameBaseline( int /*frameNum*/ ) { return -1; }
|
|
/// Store command for creating an anchored object
|
|
virtual KCommand * anchoredObjectCreateCommand( int frameNum );
|
|
/// Store command for deleting an anchored object
|
|
virtual KCommand * anchoredObjectDeleteCommand( int frameNum );
|
|
|
|
/** make this frameset part of a groupmanager
|
|
* @see KWTableFrameSet
|
|
*/
|
|
void setGroupManager( KWTableFrameSet *gm ) { m_groupmanager = gm; }
|
|
/** returns the groupManager this frameset belongs to. A Groupmanager is better known as a table */
|
|
KWTableFrameSet *groupmanager()const { return m_groupmanager; }
|
|
|
|
bool isProtectSize()const { return m_protectSize; }
|
|
void setProtectSize( bool _b);
|
|
|
|
/**
|
|
* Returns true if the frameset is visible.
|
|
* A frameset is visible if setVisible(false) wasn't called,
|
|
* but also, for a header frameset, if m_doc->isHeaderVisible is true, etc.
|
|
* For an "even pages header" frameset, the corresponding headerType setting
|
|
* must be selected (i.e. different headers for even and odd pages).
|
|
* @param viewMode pass the current viewmode when using this method for any visual
|
|
* stuff (drawing, handling input etc.). Frameset visibility depends on the viewmode.
|
|
*/
|
|
bool isVisible( KWViewMode* viewMode = 0L ) const;
|
|
|
|
/// set the visibility of the frameset.
|
|
virtual void setVisible( bool v );
|
|
|
|
/// get/set frameset name. For tables in particular, this _must_ be unique
|
|
TQString name() const { return m_name; }
|
|
void setName( const TQString &name );
|
|
|
|
/// set frameBehavior on all frames, see KWFrame for specifics
|
|
void setFrameBehavior( KWFrame::FrameBehavior fb );
|
|
|
|
/// set newFrameBehavior on all frames, see KWFrame for specifics
|
|
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;
|
|
|
|
/// set z-order for all frames
|
|
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:
|
|
|
|
/// Emitted when something has changed in this frameset,
|
|
/// so that all views tqrepaint it. KWDocument connects to it,
|
|
/// and KWCanvas connects to KWDocument.
|
|
void repaintChanged( KWFrameSet * frameset );
|
|
|
|
void sigFrameAdded(KWFrame*);
|
|
void sigFrameRemoved(KWFrame*);
|
|
|
|
void sigNameChanged(KWFrameSet*);
|
|
|
|
protected:
|
|
|
|
/// save the common attributes for the frameset
|
|
void saveCommon( TQDomElement &parentElem, bool saveFrames );
|
|
|
|
/**Determine the clipping rectangle for drawing the contents of @p frame with @p painter
|
|
* in the rectangle delimited by @p crect.
|
|
* This determines where to clip the painter to draw the contents of a given frame
|
|
*/
|
|
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 tqrepaint = true );
|
|
|
|
|
|
KWDocument *m_doc; // Document
|
|
TQPtrList<KWFrame> m_frames; // Our frames
|
|
|
|
// Cached info for optimization
|
|
/// This array provides a direct access to the frames on page N
|
|
TQPtrVector< TQPtrList<KWFrame> > m_framesInPage;
|
|
/// always equal to m_framesInPage[0].first()->pageNumber() :)
|
|
int m_firstPage;
|
|
/// always empty, for convenience in @ref framesInPage
|
|
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
|