kspread_doc.h

/* This file is part of the KDE project
   Copyright (C) 2004 Ariya Hidayat <ariya@kde.org>
             (C) 2002-2003 Norbert Andres <nandres@web.de>
             (C) 2000-2005 Laurent Montel <montel@kde.org>
             (C) 2002 John Dailey <dailey@vt.edu>
             (C) 2002 Phillip Mueller <philipp.mueller@gmx.de>
             (C) 2000 Werner Trobin <trobin@kde.org>
             (C) 1999-2000 Simon Hausmann <hausmann@kde.org>
             (C) 1999 David Faure <faure@kde.org>
             (C) 1998-2000 Torben Weis <weis@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 KSPREAD_DOC
#define KSPREAD_DOC
 
#include <tqmap.h>
#include <tqobject.h>
#include <tqpainter.h>
#include <tqrect.h>
#include <tqstring.h>
#include <tqvaluelist.h>
 
#include <kcompletion.h>
 
#include <KoDocument.h>
#include <KoZoomHandler.h>
 
#include "kspread_global.h"
 
class KCommand;
 
class KoCommandHistory;
class KoGenStyles;
class KoOasisSettings;
class KoPicture;
class KoPictureCollection;
class KoPictureKey;
class KoStore;
class KoXmlWriter;
 
class DCOPObject;
class TQDomDocument;
class KSpellConfig;
 
#define MIME_TYPE "application/x-kspread"
 
namespace KSpread
{
class Damage;
class ValueParser;
class ValueConverter;
class ValueFormatter;
class ValueCalc;
class Sheet;
class Doc;
class View;
class Map;
class Region;
class StyleManager;
class UndoAction;
class KSPLoadingInfo;
class EmbeddedObject;
 
struct Reference
{
    TQString sheet_name;
    TQString ref_name;
    TQRect rect;
};
 
class Plugin
{
 public:
  Plugin() {}
  virtual ~Plugin() {}
  virtual TQDomElement saveXML( TQDomDocument & doc ) const = 0;
};

class KSPREAD_EXPORT Doc : public KoDocument, public KoZoomHandler
{
  TQ_OBJECT
  
  TQ_PROPERTY( bool getShowRowHeader READ getShowRowHeader )
  TQ_PROPERTY( bool getShowColHeader READ getShowColHeader )
  TQ_PROPERTY( double getIndentValue READ getIndentValue WRITE setIndentValue )
  TQ_PROPERTY( bool getShowMessageError READ getShowMessageError WRITE setShowMessageError)
  TQ_PROPERTY( bool dontCheckUpperWord READ dontCheckUpperWord WRITE setDontCheckUpperWord)
  TQ_PROPERTY( bool dontCheckTitleCase READ dontCheckTitleCase WRITE setDontCheckTitleCase)
 
  TQ_PROPERTY( int syntaxVersion READ syntaxVersion )
  TQ_PROPERTY( bool showVerticalScrollBar READ showVerticalScrollBar WRITE setShowVerticalScrollBar )
  TQ_PROPERTY( bool showHorizontalScrollBar READ showHorizontalScrollBar WRITE setShowHorizontalScrollBar )
  TQ_PROPERTY( bool showColumnHeader READ showColumnHeader WRITE setShowColumnHeader )
  TQ_PROPERTY( bool showRowHeader READ showRowHeader WRITE setShowRowHeader )
  TQ_PROPERTY( bool showStatusBar READ showStatusBar WRITE setShowStatusBar )
  TQ_PROPERTY( bool showFormulaBar READ showFormulaBar WRITE setShowFormulaBar )
  TQ_PROPERTY( bool showTabBar READ showTabBar WRITE setShowTabBar )
  TQ_PROPERTY( int undoRedoLimit READ undoRedoLimit WRITE setUndoRedoLimit )
 
public:

  Doc( TQWidget *parentWidget = 0, const char *widgetName = 0, TQObject* parent = 0,
  const char* name = 0, bool singleViewMode = false );

  ~Doc();

  enum { STYLE_PAGE = 20,
         STYLE_COLUMN_USER,    
         STYLE_COLUMN_AUTO,    
         STYLE_ROW_USER,       
         STYLE_ROW_AUTO,       
         STYLE_CELL_USER,
         STYLE_CELL_AUTO,
         STYLE_PAGEMASTER,
         STYLE_NUMERIC_NUMBER };

  static TQValueList<Doc*> documents();

  virtual TQCString mimeType() const { return MIME_TYPE; }
 
  TDELocale *locale () const;
  Map *map () const;
  StyleManager *styleManager () const;
  ValueParser *parser () const;
  ValueFormatter *formatter () const;
  ValueConverter *converter () const;
  ValueCalc *calc () const;

  void addCommand( KCommand* command );
 
  /*
   * Adds an undo object. This is the same as addCommand, except
   * that it accepts Undo instance. Once every undo object
   * is converted to KCommand, this function will be obsoleted.
   */
  void addCommand( UndoAction* command );

  void undo();

  void redo();

  void undoLock();

  void undoUnlock();

  bool undoLocked() const;

  KoCommandHistory* commandHistory();

  TQString unitName() const;

  int syntaxVersion( ) const;

  void setShowVerticalScrollBar( bool b );

  bool showVerticalScrollBar() const;

  bool getShowVerticalScrollBar() const { return showVerticalScrollBar(); }

  void setShowHorizontalScrollBar( bool b );

  bool showHorizontalScrollBar() const;

  bool getShowHorizontalScrollBar() const { return showHorizontalScrollBar(); }

  void setShowColumnHeader( bool b );

  bool showColumnHeader() const;

  void setShowColHeader( bool b ){ setShowColumnHeader( b ) ; }

  bool getShowColHeader() const { return showColumnHeader(); }

  void setShowRowHeader( bool b );

  bool showRowHeader() const;

  bool getShowRowHeader() const { return showRowHeader(); }

  void setGridColor( const TQColor& color );

  TQColor gridColor() const;

  void setIndentValue( double val );

  double indentValue() const;

  double getIndentValue() const { return indentValue(); }

  void setShowStatusBar( bool b );

  bool showStatusBar() const;

  bool getShowStatusBar() const { return showStatusBar(); }

  void setShowTabBar( bool b );

  bool showTabBar() const;

  bool getShowTabBar() const { return showTabBar(); }

  void setShowFormulaBar( bool b );

  bool showFormulaBar() const;

  bool getShowFormulaBar() const { return showFormulaBar(); }

  void setShowMessageError( bool b );

  bool showMessageError() const;

  bool getShowMessageError() const{ return showMessageError(); }

 
  TDEGlobalSettings::Completion completionMode( )const ;
  void setCompletionMode( TDEGlobalSettings::Completion _complMode);
 
  KSpread::MoveTo getMoveToValue()const;
  void setMoveToValue(KSpread::MoveTo _moveTo) ;

  void setTypeOfCalc( MethodOfCalc _calc);
  MethodOfCalc getTypeOfCalc() const;
 

  void setKSpellConfig(KSpellConfig _tdespell);
  KSpellConfig * getKSpellConfig();
 
  bool dontCheckUpperWord() const;
  void setDontCheckUpperWord(bool _b);
 
  bool dontCheckTitleCase() const;
  void setDontCheckTitleCase(bool _b);
 
  TQColor pageBorderColor() const;
  void changePageBorderColor( const TQColor  & _color);
 
  virtual bool completeSaving( KoStore* _store );
 
  virtual TQDomDocument saveXML();
 
  enum SaveFlag { SaveAll, SaveSelected }; // kpresenter and kword have have SavePage too
 
  bool savingWholeDocument();

  bool saveOasisHelper( KoStore* store, KoXmlWriter* manifestWriter, SaveFlag saveFlag,
                        TQString* plainText = 0, KoPicture* picture = 0 );
 
  virtual bool saveOasis( KoStore* store, KoXmlWriter* manifestWriter );
  void saveOasisDocumentStyles( KoStore* store, KoGenStyles& mainStyles ) const;
  virtual int supportedSpecialFormats() const;
 
  virtual bool loadXML( TQIODevice *, const TQDomDocument& doc );
  virtual bool loadOasis( const TQDomDocument& doc, KoOasisStyles& oasisStyles, const TQDomDocument& settings, KoStore* );
  virtual bool loadChildren( KoStore* _store );
  TQDomElement saveAreaName( TQDomDocument& doc ) ;
    void saveOasisAreaName( KoXmlWriter & xmlWriter );
 
  void loadAreaName( const TQDomElement& element );
  void loadOasisAreaName( const TQDomElement& element );
  void loadOasisCellValidation( const TQDomElement&body );
 
  virtual void addView( KoView *_view );
 
  virtual bool initDoc(InitDocFlags flags, TQWidget* parentWidget=0);

  virtual void setZoomAndResolution( int zoom, int dpiX, int dpiY );

  void newZoomAndResolution( bool updateViews, bool forPrint );
 
  // virtual void printMap( TQPainter & _painter );
 
  void enableUndo( bool _b );
  void enableRedo( bool _b );

  bool isLoading() const;

  void doNotPaint(bool status);
 
  virtual void paintContent( TQPainter & painter, const TQRect & rect, bool transparent = false,
                             double zoomX = 1.0, double zoomY = 1.0 );
  void paintContent( TQPainter & painter, const TQRect & rect, bool transparent,
                     Sheet * sheet, bool drawCursor = true );
 
  bool docData( TQString const & xmlTag, TQDomElement & data );
  void deregisterPlugin( Plugin * plugin );
  void registerPlugin( Plugin * plugin );

  void paintCellRegions(TQPainter& painter, const TQRect &viewRect,
                        View* view,
                        TQValueList<TQRect> cellRegions,
                        const Sheet* sheet, bool drawCursor);
 
  virtual DCOPObject* dcopObject();
 
  void addAreaName(const TQRect &_rect,const TQString & name,const TQString & sheetName);
  const TQValueList<Reference>  & listArea();
  void removeArea( const TQString &name);
  TDECompletion & completion();
  void addStringCompletion(const TQString & stringCompletion);
 
  void changeAreaSheetName(const TQString & oldName,const TQString &sheetName);
 
 
  TQRect getRectArea(const TQString &  _sheetName);

  void insertObject( EmbeddedObject * obj );
  TQPtrList<EmbeddedObject>& embeddedObjects();
  KoPictureCollection *pictureCollection();
 
  void initConfig();
  void saveConfig();
  void refreshLocale();

  void emitBeginOperation(bool waitCursor);

  virtual void emitBeginOperation();

  virtual void emitEndOperation();

  void emitEndOperation( const Region& region );
 
  bool delayCalculation() const;
 
 
  void updateBorderButton();
 
  void insertSheet( Sheet * sheet );
  void takeSheet( Sheet * sheet );
 
  // The user-chosen global unit
 
  static TQString getAttribute(const TQDomElement &element, const char *attributeName, const TQString &defaultValue)
  {
    return element.attribute( attributeName, defaultValue );
  }
 
  static int getAttribute(const TQDomElement &element, const char *attributeName, int defaultValue)
  {
    TQString value;
    if ( ( value = element.attribute( attributeName ) ) != TQString() )
    return value.toInt();
    else
    return defaultValue;
  }
 
  static double getAttribute(const TQDomElement &element, const char *attributeName, double defaultValue)
  {
    TQString value;
      if ( ( value = element.attribute( attributeName ) ) != TQString() )
    return value.toDouble();
      else
    return defaultValue;
  }
 
    void addIgnoreWordAll( const TQString & word);
    void clearIgnoreWordAll( );
    void addIgnoreWordAllList( const TQStringList & _lst);
    TQStringList spellListIgnoreAll() const ;
 
    void setDisplaySheet(Sheet *_Sheet );
    Sheet * displaySheet() const;

    KSPLoadingInfo* loadingInfo() const;

    void deleteLoadingInfo();
 
  void increaseNumOperation();
  void decreaseNumOperation();
 
  void addDamage( Damage* damage );
 
/* Function specific when we load config from file */
  void loadConfigFromFile();
  bool configLoadFromFile() const;
 
  // repaint (update) all views
  void repaint( const TQRect& );
  void repaint( EmbeddedObject* );
  void repaint( const KoRect& );
 
  virtual void addShell( KoMainWindow *shell );
 
  int undoRedoLimit() const;
  void setUndoRedoLimit(int _val);
 
public slots:
 
  //void newView(); obsloete (Werner)
 
  void refreshInterface();
 
  void flushDamages();
 
signals:
  // Document signals
  void sig_updateView();
  void sig_refreshView();
  void sig_refreshLocale();
 
  void sig_addAreaName( const TQString & );
  void sig_removeAreaName( const TQString & );
 
  void damagesFlushed( const TQValueList<Damage*>& damages );
 
protected slots:
  void commandExecuted();
  void documentRestored();
 
  virtual void openTemplate( const TQString& file );
  virtual void initEmpty();
 
protected:
  KoView* createViewInstance( TQWidget* parent, const char* name );
 
  void makeUsedPixmapList();
  void insertPixmapKey( KoPictureKey key );

  virtual bool completeLoading( KoStore* );

  virtual bool saveChildren( KoStore* _store );
 
  class SavedDocParts : public TQMap<TQString, TQDomElement> {};
  SavedDocParts m_savedDocParts;
 
private:
  class Private;
  Private* d;
 
  // don't allow copy or assignment
  Doc( const Doc& );
  Doc& operator=( const Doc& );
 
  /* helper functions for painting */

  void paintUpdates();
 
  void PaintRegion(TQPainter& painter, const KoRect &viewRegion,
                   View* view, const TQRect &paintRegion,
                   const Sheet* sheet);
 
  void loadPaper( TQDomElement const & paper );
 
    void saveOasisSettings( KoXmlWriter &settingsWriter );
    void loadOasisSettings( const TQDomDocument&settingsDoc );
    void loadOasisIgnoreList( const KoOasisSettings& settings );
    KSPLoadingInfo *m_loadingInfo;
};
 
} // namespace KSpread
 
#endif /* KSPREAD_DOC */