KPrDocument.h

/* This file is part of the KDE project
   Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
   Copyright (C) 2005-2006 Thorsten Zachmann <zachmann@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 __kpresenter_doc_h__
#define __kpresenter_doc_h__
 
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
class KoGenStyles;
class KPrView;
class DCOPObject;
class KCommand;
class KMacroCommand;
class KoCommandHistory;
class KoTextZoomHandler;
class KoAutoFormat;
class KoVariable;
class KoVariableFormatCollection;
class KPrVariableCollection;
class KTempFile;
class KoParagStyle;
class KPrBgSpellCheck;
class KoTextParag;
class KoTextObject;
class KPrLoadingInfo;
class KPrGroupObject;
 
class KoOasisContext;
class KoOasisSettings;
class KoXmlWriter;
class TQFile;
class KoSavingContext;
 
#include <KoDocument.h>
#include <KoDocumentChild.h>
 
#include <tqptrlist.h>
#include <tqobject.h>
#include <tqstring.h>
#include <tqvaluelist.h>
#include <tqdatetime.h>
#include <tqdict.h>
#include <KoPageLayoutDia.h>
 
#include "global.h"
#include <KoStyleStack.h>
#include <KoPictureCollection.h>
#include "KPrGradientCollection.h"
#include <KoTextZoomHandler.h>
#include <KoStyleCollection.h> // for KoStyleChangeDefMap
#include <KoCommandHistory.h>
 
class KoDocumentEntry;
class KPrTextObject;
class KPrPartObject;
class KPrPage;
class KPrObject;
class KPrDocument;
 
class KoParagStyle;
class KoStyleCollection;
 
class KPrChild : public KoDocumentChild
{
public:
 
    // constructor - destructor
    KPrChild( KPrDocument *_kpr, KoDocument* _doc, const TQRect& _rect );
    KPrChild( KPrDocument *_kpr );
    ~KPrChild();
 
    // get parent
    KPrDocument* parent()const { return m_parent; }
 
    virtual KoDocument *hitTest( const TQPoint &, const TQWMatrix & );
 
protected:
    KPrDocument *m_parent;
};
 
class KPrDocument : public KoDocument
{
    TQ_OBJECT
  
    TQ_PROPERTY( int maxRecentFiles READ maxRecentFiles )
    TQ_PROPERTY( int undoRedoLimit READ undoRedoLimit WRITE setUndoRedoLimit )
    TQ_PROPERTY( double indentValue READ getIndentValue WRITE setIndentValue )
    TQ_PROPERTY( int getLeftBorder READ getLeftBorder )
    TQ_PROPERTY( int getTopBorder READ getTopBorder )
    TQ_PROPERTY( int getBottomBorder READ getBottomBorder )
    TQ_PROPERTY( int getRightBorder READ getRightBorder )
    TQ_PROPERTY( bool cursorInProtectedArea READ cursorInProtectedArea WRITE setCursorInProtectedArea )
    TQ_PROPERTY( bool insertDirectCursor READ insertDirectCursor WRITE setInsertDirectCursor )
    TQ_PROPERTY( TQString picturePath READ picturePath WRITE setPicturePath )
    TQ_PROPERTY( TQString globalLanguage READ globalLanguage WRITE setGlobalLanguage )
    TQ_PROPERTY( bool globalHyphenation READ globalHyphenation WRITE setGlobalHyphenation )
    TQ_PROPERTY( double tabStopValue READ tabStopValue WRITE setTabStopValue )
    TQ_PROPERTY( bool snapToGrid READ snapToGrid WRITE setSnapToGrid )
    TQ_PROPERTY( bool backgroundSpellCheckEnabled READ backgroundSpellCheckEnabled WRITE enableBackgroundSpellCheck )
    TQ_PROPERTY( bool spInfiniteLoop READ spInfiniteLoop WRITE setInfiniteLoop )
    TQ_PROPERTY( bool spShowEndOfPresentationSlide READ spShowEndOfPresentationSlide WRITE setShowEndOfPresentationSlide )
    TQ_PROPERTY( bool spManualSwitch READ spManualSwitch WRITE setManualSwitch )
    TQ_PROPERTY( bool presentationDuration READ presentationDuration WRITE setPresentationDuration )
    TQ_PROPERTY( TQColor gridColor READ gridColor WRITE setGridColor )
    TQ_PROPERTY( TQColor txtBackCol READ txtBackCol WRITE setTxtBackCol )
 
 
  public:
    // constructor - destructor
    KPrDocument( TQWidget *parentWidget = 0, const char *widgetName = 0, TQObject* doc = 0,
                   const char* name = 0, bool singleViewMode = false );
    ~KPrDocument();
 
    // Drawing
    virtual void paintContent( TQPainter& painter, const TQRect& rect, bool transparent = false,
                               double zoomX = 1.0, double zoomY = 1.0 );
 
    // save
    virtual TQDomDocument saveXML();
    virtual bool completeSaving( KoStore* _store );
    virtual bool saveOasis( KoStore* store, KoXmlWriter* manifestWriter );
 
    enum SaveFlag { SaveAll, SaveSelected, SavePage };
    void saveOasisDocumentStyles( KoStore* store, KoGenStyles& mainStyles, TQFile* masterStyles, 
                                  KoSavingContext & savingContext, SaveFlag saveFlag = SaveAll ) const;
    enum { STYLE_BACKGROUNDPAGE = 20, STYLE_BACKGROUNDPAGEAUTO, STYLE_GRADIENT,STYLE_OBJECTANIMATION, STYLE_STROKE, STYLE_MARKER, STYLE_PICTURE, STYLE_PRESENTATIONSTICKYOBJECT };
 
    // load
    virtual bool loadOasis( const TQDomDocument& doc, KoOasisStyles& styles, const TQDomDocument&, KoStore* store );
    /*
     * Load oasis object
     * @param pos: we use -1 for sticky page.
     */
    void loadOasisObject( KPrPage * page, TQDomNode & drawPage, KoOasisContext & context, KPrGroupObject *groupObject = 0L);
 
    virtual bool loadXML( const TQDomDocument& doc );
    virtual bool loadXML( TQIODevice *, const TQDomDocument & doc );
    virtual bool loadChildren( KoStore* _store );
 
    virtual int supportedSpecialFormats() const;
 
    virtual bool initDoc(InitDocFlags flags, TQWidget* parentWidget=0);
    virtual void setEmpty();
 
    virtual void addView( KoView *_view );
    virtual void removeView( KoView *_view );
 
    // page layout
    void setPageLayout( const KoPageLayout &);
 
    virtual TQPixmap generatePreview( const TQSize &size );
 
    virtual void addShell( KoMainWindow *shell );
 
    //header-footer
    void createHeaderFooter();
    void updateHeaderFooterPosition();
 
    const TQPtrList<KPrPage> & getPageList() const {return m_pageList;}
 
    // @return the master page
    KPrPage * masterPage() const { return m_masterPage; }
    KPrPage * activePage()const;
    // We need one that's not const, due to TQPtrList::at() not being const
    TQPtrList<KPrPage>& pageList() { return m_pageList;}
 
    void insertPixmapKey( KoPictureKey key );
 
    void insertObjectInPage(double offset, KPrObject *_obj, int pos = -1);
 
    void setGridValue( double rx, double ry, bool _replace = true );
 
    // get - set options for editmodi
    TQColor txtBackCol() const { return _txtBackCol; }
    void setTxtBackCol( const TQColor &c ) { _otxtBackCol = _txtBackCol; _txtBackCol = c; }
 
    // get - set roundedness
    unsigned int getRndX() const { return _xRnd; }
    unsigned int getRndY() const { return _yRnd; }
 
    // get values for screenpresentations
    bool spInfiniteLoop() const { return _spInfiniteLoop; }
    bool spShowEndOfPresentationSlide() const { return _spShowEndOfPresentationSlide; }
    bool spManualSwitch() const { return _spManualSwitch; }
    bool presentationDuration() const { return _showPresentationDuration; }
    void setInfiniteLoop( bool il ) { _spInfiniteLoop = il; }
    void setShowEndOfPresentationSlide( bool shw ) { _spShowEndOfPresentationSlide = shw; }
    void setManualSwitch( bool ms ) { _spManualSwitch = ms; }
    void setPresentationDuration( bool pd ) { _showPresentationDuration = pd; }
 
 
    // size of page
    TQRect getPageRect( bool decBorders = true ) const;
 
    void insertObject(KPrChild* ch ){ insertChild(ch);}
 
    void savePage( const TQString &file, int pgnum, bool ignore = false );
 
    void pastePage( const TQMimeSource * data, int pgnum );
 
    TQString templateFileName(bool chooseTemplate, const TQString &theFile );
 
    int insertNewPage( const TQString &cmdName,int _page, InsertPos _insPos, bool chooseTemplate, const TQString &theFile );
 
    void insertPage( KPrPage *page, int currentPageNum, int insertPageNum );
    void takePage( KPrPage *page, int pageNum );
    void deletePage( int _page );
    void copyPageToClipboard( int pgnum );
 
    // repaint all views
    void repaint( bool );
 
    void repaint( const TQRect& );
    void repaint( KPrObject* );
 
    // stuff for screen-presentations
    TQValueList<int> getPageEffectSteps( unsigned int );
 
    TQPen presPen() const { return _presPen; }
    void setPresPen( TQPen p ) {_presPen = p; }
 
    void restoreBackground( KPrPage * );
    KCommand * loadPastedObjs( const TQString &in, KPrPage* _page );
 
    void deSelectAllObj();
    void deSelectObj(KPrObject *obj);
    void updateHeaderFooterButton();
 
    KoPictureCollection *pictureCollection(){ return &m_pictureCollection; }
    KPrGradientCollection *gradientCollection() { return &_gradientCollection; }
 
    KoAutoFormat * getAutoFormat()const { return m_autoFormat; }
 
    void replaceObjs( bool createUndoRedo = true );
 
    int getLeftBorder() const;
    int getTopBorder() const;
    int getBottomBorder() const;
    int getRightBorder() const;
 
    void enableEmbeddedParts( bool f );
 
    KPrTextObject *header()const { return _header; }
    KPrTextObject *footer()const { return _footer; }
 
    void setHeader( bool b );
    void setFooter( bool b );
 
    void setDisplayObjectMasterPage( bool b );
    void setDisplayBackground( bool b );
 
    bool isHeader(const KPrObject *obj)const;
    bool isFooter(const KPrObject *obj)const;
    bool isHeaderFooter(const KPrObject *obj)const;
 
    // Returns true if the slide pgNum (0 based)
    bool isSlideSelected( int pgNum) ;
    // Returns the list of selected slides. Slide numbers are 0-based.
    TQValueList<int> selectedSlides();
    TQString selectedForPrinting();
 
    virtual DCOPObject* dcopObject();
 
    void initConfig();
    void saveConfig();
 
    KoStyleCollection * styleCollection()const { return m_styleColl;}
 
 
    void updateAllStyleLists();
    void applyStyleChange( KoStyleChangeDefMap changed );
    void updateStyleListOrder( const TQStringList &list );
 
    void addCommand( KCommand * cmd );
 
    KoTextZoomHandler* zoomHandler() const { return m_zoomHandler; }
    TQFont defaultFont() const { return m_defaultFont; }
    void setDefaultFont( const TQFont & newFont) {
        m_defaultFont = newFont;
    }
 
    bool showStatusBar() const { return m_bShowStatusBar;}
    void setShowStatusBar( bool _status ) { m_bShowStatusBar = _status;}
 
    bool showGrid() const { return m_bShowGrid; }
    void setShowGrid ( bool _grid ) { m_bShowGrid = _grid; }
 
    double tabStopValue() const { return m_tabStop; }
    void setTabStopValue ( double _tabStop );
 
    // in pt
    double getIndentValue()const { return m_indent; }
    void setIndentValue(double _ind) { m_indent=_ind; }
 
    int maxRecentFiles() const { return m_maxRecentFiles; }
 
    KoVariableFormatCollection *variableFormatCollection()const { return m_varFormatCollection; }
 
    void recalcVariables( int type );
 
    void recalcPageNum();
 
    KPrVariableCollection *getVariableCollection()const {return m_varColl;}
 
    void refreshMenuCustomVariable();
 
    void setShowRuler(bool _ruler){ m_bShowRuler=_ruler; }
    bool showRuler() const { return m_bShowRuler; }
 
    void reorganizeGUI();
 
    int undoRedoLimit() const;
    void setUndoRedoLimit(int _val);
 
 
    void updateRuler();
    void updateRulerPageLayout();
 
    unsigned int getPageNums() const { return m_pageList.count(); }
 
    // Tell all views to stop editing this frameset, if they were doing so
    void terminateEditing( KPrTextObject * textObj )
        { emit sig_terminateEditing( textObj ); }
    KPrPage * initialActivePage() const;
 
    KPrView *firstView() const;
 
    void displayActivePage(KPrPage * _page);
 
    void updateZoomRuler();
    void newZoomAndResolution( bool updateViews, bool forPrint );
 
    void movePageTo( int oldPos, int newPos );
 
    void updateSideBarItem( KPrPage * page );
    KPrPage * findPage(KPrObject *object);
    KPrPage * findPage(TQPtrList<KPrObject> &objects);
 
    void refreshAllNoteBar(int page, const TQString &text, KPrView *exceptView);
    void refreshAllNoteBarMasterPage(const TQString &text, KPrView *exceptView);
 
 
    bool backgroundSpellCheckEnabled() const;
    void enableBackgroundSpellCheck( bool b );
 
    void startBackgroundSpellCheck();
 
    //refresh obj when we active or disactive
    void reactivateBgSpellChecking(bool refreshTextObj=false);
    TQPtrList<KoTextObject> allTextObjects() const;
    TQValueList<KoTextObject *> visibleTextObjects( ) const;
 
    virtual TQValueList<KoTextDocument *> allTextDocuments() const;
 
    bool allowAutoFormat() const { return m_bAllowAutoFormat; }
    void setAllowAutoFormat(bool _b){ m_bAllowAutoFormat=_b; }
 
    // This setting has to be here [instead of the view] because we need to
    // format paragraphs slightly differently (to add room for the CR char)
    bool viewFormattingChars() const { return m_bViewFormattingChars; }
    void setViewFormattingChars(bool _b) { m_bViewFormattingChars=_b; }
 
 
    bool showGuideLines() const { return m_bShowGuideLines; }
    void setShowGuideLines( bool b );
 
    TQValueList<double> &horizontalGuideLines() { return m_hGuideLines; }
 
    TQValueList<double> &verticalGuideLines() { return m_vGuideLines; }
 
    void horizontalGuideLines( const TQValueList<double> &lines );
 
    void verticalGuideLines( const TQValueList<double> &lines );
 
    void addGuideLine( TQt::Orientation o, double pos );
 
    void updateGuideLineButton();
 
    void updateGridButton();
 
    double getGridX()const { return m_gridX; }
    void setGridX(double _x) { m_gridX=_x; }
 
    double getGridY()const { return m_gridY; }
    void setGridY(double _y) { m_gridY=_y; }
 
    bool snapToGrid() const { return m_bSnapToGrid; }
    void setSnapToGrid( bool _b ) { m_bSnapToGrid = _b; }
 
    TQColor gridColor() const { return m_gridColor; }
    void setGridColor( const TQColor & _col ) { m_gridColor = _col; }
 
    TQStringList spellCheckIgnoreList() const { return m_spellCheckIgnoreList; }
    void setSpellCheckIgnoreList( const TQStringList& lst );
    void addSpellCheckIgnoreWord( const TQString & );
 
    KoCommandHistory * commandHistory()const { return m_commandHistory; }
    void updateObjectStatusBarItem();
    void updateObjectSelected();
    void layout(KPrObject *kpobject);
    void layout();
    void changeBgSpellCheckingState( bool b );
 
    bool cursorInProtectedArea()const;
    void setCursorInProtectedArea( bool b );
 
    void insertFile(const TQString & file );
 
    void spellCheckParagraphDeleted( KoTextParag *_parag,  KPrTextObject *frm);
 
    void loadPictureMap ( const TQDomElement& domElement );
    void updateRulerInProtectContentMode();
    void updatePresentationButton();
    void refreshGroupButton();
 
    TQString picturePath()const { return m_picturePath; }
    void setPicturePath( const TQString & _path ) { m_picturePath = _path ; }
 
    bool insertDirectCursor() const { return m_bInsertDirectCursor; }
    void setInsertDirectCursor(bool _b);
    void updateDirectCursorButton();
 
    TQString globalLanguage()const { return m_globalLanguage; }
    void setGlobalLanguage( const TQString & _lang ){m_globalLanguage = _lang;}
 
    bool globalHyphenation() const { return m_bGlobalHyphenation; }
    void setGlobalHyphenation ( bool _hyphen ) { m_bGlobalHyphenation = _hyphen; }
 
    void addWordToDictionary( const TQString & word);
 
    void loadImagesFromStore( KoStore *_store );
    void saveEmbeddedObject(KPrPage *page, const TQPtrList<KoDocumentChild>& childList ,TQDomDocument &doc,TQDomElement &presenter );
    void insertEmbedded( KoStore *store, TQDomElement elem, KMacroCommand * macroCmd, KPrPage *page, int pos );
 
    KPrBgSpellCheck* backSpeller() const { return m_bgSpellCheck; }
 
    void setCustomSlideShows( const CustomSlideShowMap & customSlideShows );
    TQValueList <KPrPage *> customListPage( const TQStringList & lst, bool loadOasis=false );
 
 
    TQString presentationName() const { return m_presentationName; }
    void setPresentationName( const TQString &_name ) { m_presentationName = _name; }
 
    TQStringList presentationList();
    //return list of slide which be displaying:
    //return selected slide when presentation name is empty
    //otherwise return list of custom slide show
    TQValueList<int> displaySelectedSlides();
    TQValueList<int> listOfDisplaySelectedSlides( const TQValueList<KPrPage*>& lst );
    void testCustomSlideShow( const TQValueList<KPrPage *> &pages, KPrView *view );
    void clearTestCustomSlideShow();
 
    const CustomSlideShowMap & customSlideShows() { return m_customListSlideShow; }
 
public slots:
    void movePage( int from, int to );
    void copyPage( int from );
 
    void selectPage( int pgNum, bool select );
    void clipboardDataChanged();
 
    void slotRepaintChanged( KPrTextObject * );
 
    static void writeAutomaticStyles( KoXmlWriter& contentWriter, KoGenStyles& mainStyles, KoSavingContext& context, bool stylesDotXml );
 
    void slotGuideLinesChanged( KoView *view );
 
    virtual void initEmpty();
 
signals:
    void enablePaste( bool );
    void sig_refreshMenuCustomVariable();
    void pageNumChanged();
    void sig_updateRuler();
    void sig_terminateEditing( KPrTextObject * );
    void sig_updateMenuBar();
 
protected slots:
    void slotDocumentRestored();
    void slotCommandExecuted();
    void slotDocumentInfoModifed();
 
    virtual void openExistingFile( const TQString& file );
    virtual void openTemplate( const TQString& file );
 
protected:
    KoView* createViewInstance( TQWidget* parent, const char* name );
    void testAndCloseAllTextObjectProtectedContent();
    // ************ functions ************
    virtual bool saveChildren( KoStore* _store );
 
    void loadStyleTemplates( const TQDomElement &styles );
    void saveStyle( KoParagStyle *sty, TQDomElement parentElem );
 
    TQDomDocumentFragment saveBackground( TQDomDocument& );
    TQDomElement saveObjects( TQDomDocument &doc );
    TQDomElement saveTitle( TQDomDocument &doc );
    TQDomElement saveNote( TQDomDocument &doc );
    TQDomElement saveAttribute( TQDomDocument &doc );
    TQDomElement saveUsedSoundFileToXML( TQDomDocument &_doc, TQStringList _list );
    void loadTextStyle( const TQDomElement& domElement );
    void saveEmbeddedObject(KPrPage *page, KoDocumentChild *chl,TQDomDocument &doc,TQDomElement &presenter, double offset );
    void saveGuideLines( TQDomDocument &doc, TQDomElement& element );
 
    void loadBackground( const TQDomElement &element );
    void loadGuideLines( const TQDomElement &element );
    KCommand * loadObjects( const TQDomElement &element,bool paste=false );
    void loadTitle( const TQDomElement &element );
    void loadNote( const TQDomElement &element );
    void loadUsedSoundFileFromXML( const TQDomElement &element );
 
    virtual bool completeLoading( KoStore* /* _store */ );
    void makeUsedPixmapList();
    void makeUsedSoundFileList();
 
    void saveUsedSoundFileToStore( KoStore *_store, TQStringList _list );
    void loadUsedSoundFileFromStore( KoStore *_store, TQStringList _list );
    void fillStyleStack( const TQDomElement& object, KoOasisContext & context, const char* family );
    /*
     * increaseOrder = true by default, put to false when we have group of animation
     */
    int createPresentationAnimation(const TQDomElement& element, int order = 0 ,bool increaseOrder = true);
 
    void saveOasisPresentationSettings( KoXmlWriter &contentTmpWriter, TQMap<int, TQString> &page2name );
    void loadOasisPresentationSettings( TQDomNode &settingsDoc );
    void saveOasisPresentationCustomSlideShow( KoXmlWriter &contentTmpWriter, TQMap<int, TQString> &page2name );
    void loadOasisPresentationCustomSlideShow( TQDomNode &settingsDoc );
 
    void loadOasisHeaderFooter( TQDomNode & drawPage, KoOasisContext & context);
 
    void saveOasisSettings( KoXmlWriter &contentTmpWriter );
    void loadOasisSettings( const TQDomDocument&settingsDoc );
 
    void saveOasisCustomFied( KoXmlWriter &writer )const;
 
    void loadOasisIgnoreList( const KoOasisSettings& settings );
 
    //we move presSpeed to each table => compatibility with old file format
    void compatibilityFromOldFileFormat();
 
    void parseOasisGuideLines( const TQString &str );
 
    void pageOrderChanged();
    // ************ variables ************
 
    // screenpresentations
    bool _spInfiniteLoop, _spShowEndOfPresentationSlide, _spManualSwitch, _showPresentationDuration;
 
    // options
    int _xRnd, _yRnd;
 
    // options for editmode
    TQColor _txtBackCol;
    TQColor _otxtBackCol;
 
    bool _clean;
    int objStartY, objStartNum;
 
    TQPen _presPen;
 
    KoPictureCollection m_pictureCollection;
    KPrGradientCollection _gradientCollection;
 
    KPrTextObject *_header, *_footer;
 
    TQMap<KoPictureKey, TQString> m_pictureMap;
 
    CustomSlideShowMap m_customListSlideShow;
 
 
    KoPageLayout __pgLayout;
    int lastObj;
 
    TQString urlIntern;
 
    TQValueList<KoPictureKey> usedPictures;
    TQStringList usedSoundFile, haveNotOwnDiskSoundFile;
    TQPtrList<KTempFile> tmpSoundFileList;
    DCOPObject *dcop;
 
    int saveOnlyPage;
    TQString m_tempFileInClipboard;
    bool ignoreSticky;
 
    KoCommandHistory * m_commandHistory;
    KoTextZoomHandler* m_zoomHandler;
    TQFont m_defaultFont;
    KoAutoFormat * m_autoFormat;
 
    bool m_bShowRuler;
    bool m_bShowStatusBar;
    bool m_bAllowAutoFormat;
    bool m_bShowGuideLines;
    bool m_bViewFormattingChars;
 
    bool m_bShowGrid;
 
    bool m_bSnapToGrid;
    double m_indent; // in pt
 
    double m_tabStop;
    int m_maxRecentFiles;
    bool m_cursorInProtectectedArea;
    KoVariableFormatCollection *m_varFormatCollection;
    KPrVariableCollection *m_varColl;
    TQColor m_gridColor;
    bool _duplicatePage;
private:
    TQValueList<double> m_hGuideLines;
    TQValueList<double> m_vGuideLines;
 
    TQPtrList<KPrPage> m_pageList;
    TQPtrList<KPrPage> m_deletedPageList;
 
    TQStringList m_spellCheckIgnoreList; // per-document
    TQStringList m_spellCheckPersonalDict; // per-user
 
    double m_gridX;
    double m_gridY;
    double oldGridX;
    double oldGridY;
    int m_insertFilePage;
    KPrPage *m_initialActivePage;
    KPrPage *m_pageWhereLoadObject;
    KPrPage *m_masterPage;
    KPrBgSpellCheck *m_bgSpellCheck;
    KoStyleCollection *m_styleColl;
    KPrObject *bgObjSpellChecked;
    TQString m_picturePath;
    bool  m_bInsertDirectCursor;
    TQString m_globalLanguage;
    TQString m_presentationName;
    bool m_bGlobalHyphenation;
    KPrLoadingInfo *m_loadingInfo;
    TQValueList<int> *m_customListTest;
 
    int m_childCountBeforeInsert;
};
 
#endif