KWDocument.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
   Copyright (C) 2002-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 kwdoc_h
#define kwdoc_h
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
class TQDragObject;
class KoSavingContext;
class KoGenStyles;
class KWDocument;
class KPrinter;
class KWTextImage;
class KWTextFrameSet;
class KWPictureFrameSet;
class KWMailMergeDataBase;
class KWFrameSet;
class KWTableFrameSet;
class KWPartFrameSet;
class KoStyleCollection;
class KoParagStyle;
class KWFrameStyle;
class KWTableStyle;
class KWTableTemplate;
#define KoParagStyle KoParagStyle
class KWFrame;
class KWViewMode;
class KMacroCommand;
class KoDocumentEntry;
class TQPainter;
class KoAutoFormat;
class KCommand;
class KoCommandHistory;
class KoVariable;
class KoVariableFormatCollection;
class KWVariableCollection;
class KoTextObject;
class KWBgSpellCheck;
class KoStyleCollection;
class KWFrameStyleCollection;
class KWTableStyleCollection;
class KWTableTemplateCollection;
class KWFootNoteVariable;
class DCOPObject;
class KWLoadingInfo;
class KoPicture;
class KoTextBookmark;
class KoTextBookmarkList;
class KoPictureCollection;
class KWDocumentChild;
class KWPageManager;
class KWPage;
 
class TQFont;
class TQStringList;
class TQRect;
 
namespace KFormula {
    class Document;
    class DocumentWrapper;
}
 
class KoTextParag;
class KoOasisSettings;
 
#include "KWAnchorPos.h" // legacy loading stuff
#include "KWView.h"
 
#include <KoDocument.h>
#include <KoTextZoomHandler.h>
#include <KoPictureKey.h>
#include <KoStyleCollection.h> // for KoStyleChangeDefMap
 
#include <tqmap.h>
#include <tqptrlist.h>
#include <tqfont.h>
#include <tqvaluevector.h>
 
/******************************************************************/
/* Class: KWDocument                                           */
/******************************************************************/
 
class KWDocument : public KoDocument, public KoTextZoomHandler
{
    TQ_OBJECT
  
    TQ_PROPERTY( double ptColumnWidth READ ptColumnWidth )
    TQ_PROPERTY( double ptColumnSpacing READ ptColumnSpacing )
    TQ_PROPERTY( double gridX READ gridX WRITE setGridX )
    TQ_PROPERTY( double gridY READ gridY WRITE setGridY )
    TQ_PROPERTY( bool snapToGrid READ snapToGrid WRITE setSnapToGrid )
    TQ_PROPERTY( double indentValue READ indentValue WRITE setIndentValue )
    TQ_PROPERTY( int nbPagePerRow READ nbPagePerRow WRITE setNbPagePerRow )
    TQ_PROPERTY( double defaultColumnSpacing READ defaultColumnSpacing WRITE setDefaultColumnSpacing )
    TQ_PROPERTY( int maxRecentFiles READ maxRecentFiles )
    TQ_PROPERTY( TQString globalLanguage READ globalLanguage WRITE setGlobalLanguage )
    TQ_PROPERTY( bool globalHyphenation READ globalHyphenation WRITE setGlobalHyphenation )
    TQ_PROPERTY( bool insertDirectCursor READ insertDirectCursor WRITE setInsertDirectCursor )
    TQ_PROPERTY( TQStringList personalExpressionPath READ personalExpressionPath WRITE setPersonalExpressionPath )
    TQ_PROPERTY( bool viewFormattingBreak READ viewFormattingBreak WRITE setViewFormattingBreak )
    TQ_PROPERTY( bool viewFormattingTabs READ viewFormattingTabs WRITE setViewFormattingTabs )
    TQ_PROPERTY( bool viewFormattingSpace READ viewFormattingSpace WRITE setViewFormattingSpace )
    TQ_PROPERTY( bool viewFormattingEndParag READ viewFormattingEndParag WRITE setViewFormattingEndParag )
    TQ_PROPERTY( bool cursorInProtectedArea READ cursorInProtectedArea WRITE setCursorInProtectedArea )
    TQ_PROPERTY( bool pgUpDownMovesCaret READ pgUpDownMovesCaret WRITE setPgUpDownMovesCaret )
    TQ_PROPERTY( bool allowAutoFormat READ allowAutoFormat WRITE setAllowAutoFormat )
    TQ_PROPERTY( int undoRedoLimit READ undoRedoLimit WRITE setUndoRedoLimit )
 
public:
    friend class KWOasisLoader;
    friend class KWStartupWidget;
 
    KWDocument( TQWidget *parentWidget = 0, const char *widname = 0, TQObject* parent = 0, const char* name = 0, bool singleViewMode = false );
    ~KWDocument();
 
    enum ProcessingType {WP = 0, DTP = 1};
 
    static const int CURRENT_SYNTAX_VERSION;
 
public:
    virtual bool initDoc(InitDocFlags flags, TQWidget* parentWidget=0);
 
    virtual bool loadOasis( const TQDomDocument& doc, KoOasisStyles& oasisStyles, const TQDomDocument& settings, KoStore* store );
 
    enum {  STYLE_FRAME_AUTO = 20, STYLE_FRAME_USER,
            STYLE_TABLE_CELL_AUTO, STYLE_TABLE_CELL_USER,
            STYLE_TABLE, STYLE_TABLE_COLUMN, STYLE_TABLE_ROW };
 
    virtual bool saveOasis( KoStore* store, KoXmlWriter* manifestWriter );
 
    virtual int supportedSpecialFormats() const;
 
    enum SaveFlag { SaveAll, SaveSelected }; // kpresenter will also have SavePage
 
    TQDragObject* dragSelected( const TQValueList<KWFrameView*> &selectedFrames);
    TQDragObject* dragSelected( TQWidget *parent, KWTextFrameSet* fs );
 
    virtual bool loadXML( TQIODevice *, const TQDomDocument & dom );
    virtual bool loadChildren( KoStore *store );
    virtual TQDomDocument saveXML();
    void processPictureRequests();
    void processAnchorRequests();
    bool processFootNoteRequests();
 
    int syntaxVersion( ) const { return m_syntaxVersion; }
 
    void progressItemLoaded();
 
    virtual void paintContent( TQPainter& painter, const TQRect& rect, bool transparent = false, double zoomX = 1.0, double zoomY = 1.0 );
 
    virtual TQPixmap generatePreview( const TQSize &size );
 
    void createEmptyRegion( const TQRect & crect, TQRegion & emptyRegion, KWViewMode * viewMode );
    void eraseEmptySpace( TQPainter * painter, const TQRegion & emptySpaceRegion, const TQBrush & brush );
 
    virtual void setEmpty();
 
    virtual void addView( KoView *view );
    virtual void removeView( KoView *view );
 
    virtual void addShell( KoMainWindow *shell );
 
    KWPartFrameSet* insertObject( const KoRect& rect, KoDocumentEntry& e, TQWidget* parentWidget );
 
    KWDocumentChild* createChildDoc( const KoRect& rect, KoDocument* childDoc );
 
    void setPageLayout( const KoPageLayout& layout, const KoColumns& cl, const KoKWHeaderFooter& hf, bool updateViews = true );
 
    void getPageLayout( KoPageLayout& layout, KoColumns& cl, KoKWHeaderFooter& hf );
 
    KWTextFrameSet * textFrameSet ( unsigned int num ) const;
    KWFrameSet *frameSet( unsigned int num )
    { return m_lstFrameSet.at( num ); }
 
    KWFrameSet * frameSetByName( const TQString & name );
 
    unsigned int frameSetCount() const
    { return m_lstFrameSet.count(); }
 
    TQString generateFramesetName( const TQString & templateName );
 
    TQPtrListIterator<KWFrameSet> framesetsIterator() const { return TQPtrListIterator<KWFrameSet>(m_lstFrameSet); }
 
    TQValueList<KoTextObject *> visibleTextObjects(KWViewMode *viewmode) const;
 
    void addFrameSet( KWFrameSet *f, bool finalize = true );
    void removeFrameSet( KWFrameSet *f );
 
    void deleteTable( KWTableFrameSet *groupManager );
    void deleteFrame( KWFrame * frame );
 
    unsigned int paperHeight(int pageNum) const;
    unsigned int paperWidth(int pageNum) const;
    unsigned int pageTop( int pgNum ) const;
    double ptColumnWidth() const;
    double ptColumnSpacing() const { return m_pageColumns.ptColumnSpacing; }
    double ptFootnoteBodySpacing() const { return m_pageHeaderFooter.ptFootNoteBodySpacing; }
 
    unsigned int numColumns() const { return m_pageColumns.columns; }
 
    void repaintAllViews( bool erase = false );
    void repaintAllViewsExcept( KWView *view, bool erase = false );
 
 
    void delayedRepaintAllViews();
 
    void delayedRecalcFrames( int fromPage );
 
    TQPixmap* doubleBufferPixmap( const TQSize& );
    void maybeDeleteDoubleBufferPixmap();
 
    void frameChanged( KWFrame * frame );
    void framesChanged( const TQPtrList<KWFrame> & frames, KWView * view = 0L );
 
    TQString uniqueFramesetName( const TQString& oldName );
    void pasteFrames( TQDomElement topElem, KMacroCommand * macroCmd, bool copyFootNote = false, bool dontCreateFootNote = false, bool selectFrames = true );
 
    void insertEmbedded( KoStore *store, TQDomElement topElem, KMacroCommand * macroCmd, double offset );
    void completePasting();
    void completeOasisPasting();
    void saveOasisDocumentStyles( KoStore* store, KoGenStyles& mainStyles, KoSavingContext& savingContext, SaveFlag saveFlag, const TQByteArray& headerFooterContent ) const;
 
    KoStyleCollection * styleCollection()const  { return m_styleColl;}
    KWFrameStyleCollection * frameStyleCollection()const  { return m_frameStyleColl;}
    KWTableStyleCollection * tableStyleCollection()const  { return m_tableStyleColl;}
    KWTableTemplateCollection * tableTemplateCollection()const  { return m_tableTemplateColl;}
 
    TQFont defaultFont() const { return m_defaultFont; }
    void setDefaultFont( const TQFont & newFont ) {
        m_defaultFont = newFont;
    }
 
    int pageCount() const;
    int startPage() const;
    int lastPage() const;
 
    KoPictureCollection *pictureCollection() { return m_pictureCollection; }
    KoVariableFormatCollection *variableFormatCollection()const { return m_varFormatCollection; }
 
    TQValueList<KWView *> getAllViews() const { return m_lstViews; }
 
    KWPage* insertPage( int afterPageNum );
    KWPage* appendPage();
    void afterInsertPage( int num );
    TQPtrList<KWFrame> framesToCopyOnNewPage( int afterPageNum ) const;
 
    void removePage( int num );
 
    void afterRemovePages();
 
    bool tryRemovingPages();
 
    ProcessingType processingType()const { return m_processingType;  }
    int frameSetNum( KWFrameSet* fs ) { return m_lstFrameSet.findRef( fs ); }
 
    void lowerMainFrames( int pageNum );
    void lowerMainFrames( int pageNum, int lowestZOrder );
 
    TQPtrList<KWTextFrameSet> allTextFramesets( bool onlyReadWrite ) const;
    int numberOfTextFrameSet( KWFrameSet* fs, bool onlyReadWrite );
    KWFrameSet * textFrameSetFromIndex( unsigned int num, bool onlyReadWrite );
 
    virtual TQValueList<KoTextDocument *> allTextDocuments() const;
 
 
    TQPtrList<KWFrame> framesInPage( int pageNum , bool sorted=true) const;
 
 
    int maxZOrder( int pageNum ) const;
 
    void updateAllFrames( int flags = 0xff /* see KWFrameSet::UpdateFramesFlags */ );
 
    // The grid is in _pt_ now
    double gridX()const { return m_gridX; }
    double gridY()const { return m_gridY; }
    void setGridX(double gridx);
    void setGridY(double gridy) { m_gridY = gridy; }
 
    void updateGridButton();
 
    bool showGrid() const { return m_bShowGrid; }
    void setShowGrid ( bool grid ) { m_bShowGrid = grid; }
 
    bool snapToGrid() const { return m_bSnapToGrid; }
    void setSnapToGrid( bool b ) { m_bSnapToGrid = b; }
 
    // Currently unused. Not sure we want to go that way, now that we have
    // paragLayoutChanged and formatChanged in applyStyleChange.
    //int applyStyleChangeMask() { return styleMask; }
    //void setApplyStyleChangeMask( int f ) { styleMask = f; }
 
    // paragLayoutChanged is a set of flags for the parag layout - see the enum in KWParagLayout
    // formatChanged is a set of flags from KoTextFormat
    // If both are -1, it means the style has been deleted.
    void applyStyleChange( KoStyleChangeDefMap changed );
    void updateAllStyleLists();
    void updateStyleListOrder( const TQStringList &list );
 
    void updateAllFrameStyleLists();
    void updateAllTableStyleLists();
 
    bool isHeaderVisible() const { return m_headerVisible; }
    bool isFooterVisible() const { return m_footerVisible; }
    void setHeaderVisible( bool h );
    void setFooterVisible( bool f );
    bool hasEndNotes() const;
 
    void recalcFrames( int fromPage = 0, int toPage = -1, uint flags = 0 );
 
    KoHFType headerType() const { return m_pageHeaderFooter.header; }
    KoHFType footerType() const { return m_pageHeaderFooter.footer; }
    const KoKWHeaderFooter& headerFooterInfo() const { return m_pageHeaderFooter; }
 
    void setFrameCoords( double x, double y, double w, double h );
 
    void addCommand( KCommand * cmd );
 
    KoCommandHistory * commandHistory() const { return m_commandHistory; }
    KoAutoFormat * autoFormat() const { return m_autoFormat; }
 
    void addTextImageRequest( KWTextImage *img );
    void addPictureRequest( KWPictureFrameSet *fs );
    void addAnchorRequest( const TQString &framesetName, const KWAnchorPosition &anchorPos );
    void addFootNoteRequest( const TQString &framesetName, KWFootNoteVariable* var );
 
    KWFrameSet *loadFrameSet( TQDomElement framesetElem, bool loadFrames = true , bool loadFootnote = true);
    void loadEmbeddedObjects( TQDomElement& word );
    void saveEmbeddedObjects( TQDomElement& parentElem, const TQPtrList<KoDocumentChild>& childList );
    void loadEmbedded( const TQDomElement &embedded );
 
    void recalcVariables( int type );
 
    KWVariableCollection *variableCollection() const { return m_varColl; }
 
    KWMailMergeDataBase *mailMergeDataBase() const { return m_slDataBase; }
    int mailMergeRecord() const;
    void setMailMergeRecord( int r );
 
    bool backgroundSpellCheckEnabled() const;
    void enableBackgroundSpellCheck( bool b );
 
    bool canRemovePage( int num );
 
    virtual void setZoomAndResolution( int zoom, int dpiX, int dpiY );
 
    void newZoomAndResolution( bool updateViews, bool forPrint );
 
    TQString viewModeType() const { return m_viewModeType; }
 
    KWViewMode* layoutViewMode() const { return m_layoutViewMode; }
 
    void switchViewMode( const TQString& newViewMode );
 
 
    static TQString getAttribute(TQDomElement &element, const char *attributeName, const TQString &defaultValue)
      {
          return element.attribute( attributeName, defaultValue );
      }
 
    static int getAttribute(TQDomElement &element, const char *attributeName, int defaultValue)
    {
        TQString value;
        if ( ( value = element.attribute( attributeName ) ) != TQString() )
            return value.toInt();
        else
            return defaultValue;
    }
 
    static double getAttribute(TQDomElement &element, const char *attributeName, double defaultValue)
    {
        TQString value;
        if ( ( value = element.attribute( attributeName ) ) != TQString() )
            return value.toDouble();
        else
            return defaultValue;
    }
 
#ifndef NDEBUG
    void printStyleDebug();
    void printDebug();
#endif
 
    void layout();
 
    // This settings has to be here [instead of KWView] because we need to
    // format paragraphs slightly differently (to add room for the CR char)
    bool viewFormattingChars() const { return m_viewFormattingChars; }
    void setViewFormattingChars(bool b) { m_viewFormattingChars=b; }
 
    bool viewFormattingEndParag() const { return m_viewFormattingEndParag; }
    void setViewFormattingEndParag(bool b) { m_viewFormattingEndParag=b; }
 
    bool viewFormattingSpace() const { return m_viewFormattingSpace; }
    void setViewFormattingSpace(bool b) { m_viewFormattingSpace=b; }
 
    bool viewFormattingTabs() const { return m_viewFormattingTabs; }
    void setViewFormattingTabs(bool b) { m_viewFormattingTabs=b; }
 
    bool viewFormattingBreak() const { return m_viewFormattingBreak; }
    void setViewFormattingBreak(bool b) { m_viewFormattingBreak=b; }
 
    // Also view properties, but stored, loaded and saved here (lacking a more global object).
    bool viewFrameBorders() const { return m_viewFrameBorders; }
    void setViewFrameBorders( bool b );
    void setShowRuler(bool ruler){ m_bShowRuler=ruler; }
    bool showRuler() const { return m_bShowRuler; }
 
    bool showStatusBar() const { return m_bShowStatusBar;}
    void setShowStatusBar( bool status ) { m_bShowStatusBar = status;}
 
    bool showScrollBar() const { return m_bShowScrollBar; }
    void setShowScrollBar( bool status ) { m_bShowScrollBar = status;}
 
    bool pgUpDownMovesCaret() const { return m_pgUpDownMovesCaret; }
    void setPgUpDownMovesCaret( bool b ) { m_pgUpDownMovesCaret = b; }
 
    bool showdocStruct() const {return  m_bShowDocStruct;}
    void setShowDocStruct(bool b){m_bShowDocStruct=b;}
 
    bool allowAutoFormat() const { return m_bAllowAutoFormat; }
    void setAllowAutoFormat(bool b){ m_bAllowAutoFormat=b; }
 
    bool insertDirectCursor() const { return m_bInsertDirectCursor; }
    void setInsertDirectCursor(bool b);
 
 
    // in pt
    double indentValue()const { return m_indent; }
    void setIndentValue(double ind) { m_indent=ind; }
 
    int nbPagePerRow() const{ return m_iNbPagePerRow; }
    void setNbPagePerRow(int nb) { m_iNbPagePerRow=nb; }
 
    int maxRecentFiles() const { return m_maxRecentFiles; }
 
 
    // in pt
    double defaultColumnSpacing()const{ return m_defaultColumnSpacing ;}
    void setDefaultColumnSpacing(double val){ m_defaultColumnSpacing=val; }
    KFormula::Document* formulaDocument( bool init = true );
 
    void reorganizeGUI();
    void terminateEditing( KWFrameSet * frameSet )
        { emit sig_terminateEditing( frameSet ); }
 
    void clearUndoRedoInfos();
 
    void refreshDocStructure(FrameSetType);
    void refreshDocStructure(int);
 
    int typeItemDocStructure(FrameSetType type);
 
    void refreshMenuExpression();
 
    void refreshMenuCustomVariable();
 
    void updateZoomRuler();
 
    void setTocPresent(bool hasToc);
    bool tocPresent(){return m_hasTOC;}
 
    TQString sectionTitle( int pageNum ) const;
 
    void updateRulerFrameStartEnd();
 
    static TQColor resolveTextColor( const TQColor & col, TQPainter * painter );
    static TQColor defaultTextColor( TQPainter * painter );
    static TQColor resolveBgColor( const TQColor & col, TQPainter * painter = 0 );
    static TQBrush resolveBgBrush( const TQBrush & brush, TQPainter * painter = 0 );
    static TQColor defaultBgColor( TQPainter * painter );
 
 
    virtual DCOPObject* dcopObject();
 
    int undoRedoLimit() const;
    void setUndoRedoLimit(int val);
 
    void updateContentsSize(){emit newContentsSize();}
 
    void refreshGUIButton();
 
    void initConfig();
    void saveConfig();
    void startBackgroundSpellCheck();
    void reactivateBgSpellChecking();
 
    void updateHeaderButton();
    void updateFooterButton();
 
    TQStringList spellCheckIgnoreList() const { return m_spellCheckIgnoreList; }
    void setSpellCheckIgnoreList( const TQStringList& lst );
    void addSpellCheckIgnoreWord( const TQString & );
 
    void updateTextFrameSetEdit();
    void changeFootNoteConfig();
    void displayFootNoteFieldCode();
 
 
    double tabStopValue() const { return m_tabStop; }
    void setTabStopValue ( double tabStop );
 
    void changeBgSpellCheckingState( bool b );
 
    // To position the cursor when opening a document
    TQString initialFrameSet() const; 
    int initialCursorParag() const;
    int initialCursorIndex() const;
    void deleteInitialEditingInfo();
 
    bool cursorInProtectedArea()const;
    void setCursorInProtectedArea( bool b );
 
    SeparatorLinePos footNoteSeparatorLinePosition()const { return m_footNoteSeparatorLinePos;}
    void setFootNoteSeparatorLinePosition(SeparatorLinePos pos) {m_footNoteSeparatorLinePos = pos;}
 
    int footNoteSeparatorLineLength() const { return m_iFootNoteSeparatorLineLength;}
    void setFootNoteSeparatorLineLength( int length){  m_iFootNoteSeparatorLineLength = length;}
 
    double footNoteSeparatorLineWidth() const { return m_footNoteSeparatorLineWidth;}
    void setFootNoteSeparatorLineWidth( double width){  m_footNoteSeparatorLineWidth=width;}
 
    SeparatorLineLineType footNoteSeparatorLineType()const { return m_footNoteSeparatorLineType;}
    void setFootNoteSeparatorLineType( SeparatorLineLineType type) {m_footNoteSeparatorLineType = type;}
 
    const KoTextBookmarkList* bookmarkList() const { return m_bookmarkList; }
    void insertBookmark( const TQString &name, KoTextParag *startparag, KoTextParag *endparag, int start, int end );
    void deleteBookmark( const TQString &name );
    void renameBookmark( const TQString &oldname, const TQString &newName );
 
    const KoTextBookmark * bookmarkByName( const TQString & name ) const;
    TQStringList listOfBookmarkName(KWViewMode * viewMode) const;
 
    void paragraphDeleted( KoTextParag *parag, KWFrameSet *frm);
    void paragraphModified(KoTextParag* parag, int /*KoTextParag::ParagModifyType*/ type, int start, int length);
 
    void initBookmarkList();
    void loadImagesFromStore( KoStore *store );
    void loadPictureMap ( TQDomElement& domElement );
 
    void testAndCloseAllFrameSetProtectedContent();
    void updateRulerInProtectContentMode();
 
    KoPageLayout pageLayout(int pageNumber = 0) const;
 
    TQStringList personalExpressionPath() const { return m_personalExpressionPath;}
    void setPersonalExpressionPath( const TQStringList & );
 
 
    void updateDirectCursorButton();
 
    TQString globalLanguage()const { return m_globalLanguage; }
    void setGlobalLanguage( const TQString & lang ){m_globalLanguage = lang;}
    void addWordToDictionary( const TQString & );
 
    bool globalHyphenation() const { return m_bGlobalHyphenation; }
    void setGlobalHyphenation ( bool hyphen );
 
    KWLoadingInfo* createLoadingInfo();
    KWLoadingInfo* loadingInfo() const { return m_loadingInfo; }
    void deleteLoadingInfo();
 
    KFormula::DocumentWrapper* formulaDocumentWrapper() { return m_formulaDocumentWrapper; }
 
    KWPageManager *pageManager() const { return m_pageManager; }
 
    KWBgSpellCheck* backSpeller() const { return m_bgSpellCheck; }
 
    bool loadOasisPageLayout( const TQString& masterPageName, KoOasisContext& context );
 
    // end of public methods
signals:
 
    void pageLayoutChanged( const KoPageLayout& );
 
    void newContentsSize();
 
    void mainTextHeightChanged();
 
    void numPagesChanged();
 
    void docStructureChanged(int);
    void sig_terminateEditing( KWFrameSet * fs );
 
    void sig_refreshMenuCustomVariable();
 
    void sigFrameSetAdded(KWFrameSet*);
    void sigFrameSetRemoved(KWFrameSet*);
 
public slots:
    void slotRepaintChanged( KWFrameSet * frameset );
    void framesChanged( const TQValueList<KWFrame*> &frames);
 
    void invalidate(const KWFrameSet *skipThisFrameSet=0);
 
    virtual void initEmpty();
 
protected slots:
    void slotRecalcFrames();
    void slotRepaintAllViews();
    void slotDocumentRestored();
    void slotCommandExecuted();
    void slotDocumentInfoModifed();
    void slotChapterParagraphFormatted( KoTextParag* parag );
    void saveDialogShown(); 
 
    virtual void openExistingFile( const TQString& file );
    virtual void openTemplate( const TQString& file );
 
private slots:
    void updateFramesChanged();
 
protected:
    void nextParagraphNeedingCheck();
    void fixZOrders();
    TQString checkSectionTitleInParag( KoTextParag* parag, KWTextFrameSet*, int pageNum ) const;
    KoView* createViewInstance( TQWidget* parent, const char* name );
 
    virtual bool completeLoading( KoStore* store );
    virtual bool completeSaving( KoStore *store );
 
    void loadFrameSets( const TQDomElement &framesets );
    void loadStyleTemplates( const TQDomElement &styles );
    void saveStyle( KoParagStyle *sty, TQDomElement parentElem );
    void saveFrameStyle( KWFrameStyle *sty, TQDomElement parentElem );
    void saveTableStyle( KWTableStyle *sty, TQDomElement parentElem );
 
    void loadFrameStyleTemplates( const TQDomElement &styles );
    void loadDefaultFrameStyleTemplates();
    void loadTableStyleTemplates( const TQDomElement &styles );
    void loadDefaultTableStyleTemplates();
    void loadDefaultTableTemplates();
    bool loadMasterPageStyle( const TQString& masterPageName, KoOasisContext& context );
 
    void saveOasisBody( KoXmlWriter& writer, KoSavingContext& context ) const;
    void saveOasisCustomFied( KoXmlWriter &writer )const;
 
    TQValueList<KoPictureKey> savePictureList();
 
    TQDragObject* dragSelectedPrivate( TQWidget *parent, const TQValueList<KWFrameView*> &selectedFrames, KWTextFrameSet* fs);
    bool saveOasisHelper( KoStore* store, KoXmlWriter* manifestWriter, SaveFlag saveFlag,
                    const TQValueList<KWFrameView*> &selectedFrames,
                    TQString* plainText = 0, KoPicture* picture = 0, KWTextFrameSet* fs = 0 );
 
    void saveOasisSettings( KoXmlWriter &settingsWriter ) const;
    void saveSelectedFrames( KoXmlWriter& bodyWriter,
                             KoSavingContext& savingContext, TQValueList<KoPictureKey>& pictureList,
                             const TQValueList<KWFrameView*> &selectedFrames, TQString* plainText ) const;
 
    // inherited from KoDocument
    TQWidget* createCustomDocumentWidget(TQWidget *parent);
 
private:
    void clear();
    void endOfLoading();
 
    class FramesChangedHandler {
        public:
            FramesChangedHandler(KWDocument *parent);
            void addFrame(KWFrame*);
            void addFrameSet(KWFrameSet*);
            void execute();
        private:
            KWDocument *m_parent;
            TQValueList<KWFrameSet*> m_frameSets;
            bool m_needLayout;
    };
 
    // Variables:
    TQValueList<KWView *> m_lstViews;
 
    KoColumns m_pageColumns;
    KoKWHeaderFooter m_pageHeaderFooter;
 
    KoPictureCollection* m_pictureCollection;
 
    TQPtrList<KWFrameSet> m_lstFrameSet;
 
    unsigned int m_itemsLoaded;
    unsigned int m_nrItemsToLoad;
 
    ProcessingType m_processingType;
    double m_gridX, m_gridY;
 
    DCOPObject *dcop;
 
    KoCommandHistory * m_commandHistory;
    KoAutoFormat * m_autoFormat;
 
    // ===== Legacy loading stuff, remove when switching to OASIS =====
    TQString m_urlIntern;
 
    TQMap<KoPictureKey, TQString> m_pictureMap;
 
    TQPtrList<KWTextImage> m_textImageRequests;
    TQPtrList<KWPictureFrameSet> m_pictureRequests;
    TQMap<TQString, KWAnchorPosition> m_anchorRequests;
    TQMap<TQString, KWFootNoteVariable *> m_footnoteVarRequests; 
    // ===== End of legacy loading stuff =====
 
    TQMap<TQString,TQString> * m_pasteFramesetsMap;
 
    KoVariableFormatCollection *m_varFormatCollection;
    KWMailMergeDataBase *m_slDataBase;
    int slRecordNum;
 
    int m_syntaxVersion;
 
    TQFont m_defaultFont;
    bool m_headerVisible, m_footerVisible;
    bool m_viewFrameBorders;
    bool m_bShowRuler;
    bool m_bShowDocStruct;
    bool m_hasTOC;
    bool m_bShowStatusBar;
    bool m_pgUpDownMovesCaret;
    bool m_repaintAllViewsPending;
    bool m_bAllowAutoFormat;
    bool m_bShowScrollBar;
    bool m_cursorInProtectectedArea;
    bool m_bInsertDirectCursor;
    bool m_bHasEndNotes;
 
    bool m_viewFormattingChars;
    bool m_viewFormattingEndParag;
    bool m_viewFormattingSpace;
    bool m_viewFormattingTabs;
    bool m_viewFormattingBreak;
 
    KFormula::DocumentWrapper* m_formulaDocumentWrapper;
 
    double m_indent; 
    double m_defaultColumnSpacing;
 
    int m_iNbPagePerRow;
    int m_maxRecentFiles;
    int m_recalcFramesPending;
 
    TQString m_viewModeType;
    KWViewMode* m_layoutViewMode;
    KWVariableCollection *m_varColl;
    KWBgSpellCheck *m_bgSpellCheck;
    KoStyleCollection *m_styleColl;
    KWFrameStyleCollection *m_frameStyleColl;
    KWTableStyleCollection *m_tableStyleColl;
    KWTableTemplateCollection *m_tableTemplateColl;
 
 
    SeparatorLinePos m_footNoteSeparatorLinePos;
    int m_iFootNoteSeparatorLineLength;
 
    double m_footNoteSeparatorLineWidth;
 
    SeparatorLineLineType m_footNoteSeparatorLineType;
 
    TQValueVector< TQString > m_sectionTitles;
 
    double m_tabStop;
    TQStringList m_spellCheckIgnoreList; // per-document
    TQStringList m_spellCheckPersonalDict; // per-user
    TQPixmap* m_bufPixmap;
 
    KWLoadingInfo* m_loadingInfo;
 
    class InitialEditing;
    InitialEditing *m_initialEditing;
 
    KoTextBookmarkList* m_bookmarkList;
 
    TQStringList m_personalExpressionPath;
    TQString m_globalLanguage;
    bool m_bGlobalHyphenation;
    bool m_bGeneratingPreview;
 
    bool m_bShowGrid;
    bool m_bSnapToGrid;
 
    KWPageManager *m_pageManager;
    FramesChangedHandler *m_framesChangedHandler;
};
 
#endif