kformuladocument.h

/* This file is part of the KDE project
   Copyright (C) 2001 Andrea Rizzi <rizzi@kde.org>
                  Ulrich Kuettler <ulrich.kuettler@mailbox.tu-dresden.de>
 
   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 KFORMULADOCUMENT_H
#define KFORMULADOCUMENT_H
 
#include <tqdom.h>
#include <tqobject.h>
#include <tqptrlist.h>
#include <tqstring.h>
#include <tqstringlist.h>
 
#include <tdeaction.h>
#include <kcommand.h>
#include <tdeconfig.h>
#include <KoCommandHistory.h>
//#include "KoCommandHistory.h"
#include "kformuladefs.h"
 
KFORMULA_NAMESPACE_BEGIN
 
class Container;
class ContextStyle;
class SymbolAction;
class SymbolTable;
class DocumentWrapper;
class ElementCreationStrategy;
 

class FormulaList: public TQPtrList<Container>
{
protected:
    virtual int compareItems( TQPtrCollection::Item a, TQPtrCollection::Item b );
};
 

class KOFORMULA_EXPORT Document : public TQObject {
    TQ_OBJECT
  
 
    friend class DocumentWrapper;
    friend class Container;
 
public:

    Document( TQObject *parent=0, const char *name=0,
              const TQStringList &args=TQStringList() );
    ~Document();

    virtual Container* createFormula( int pos=-1, bool registerMe=true );

    virtual void registerFormula( Container*, int pos=-1 );

    virtual void unregisterFormula( Container* );

    virtual void evaluateFormulas() {}
    virtual void enableEvaluation( bool ) {}

    bool loadXML( const TQDomDocument& doc );

    bool loadOasis( const TQDomDocument& doc );
    
    bool loadDocumentPart( TQDomElement node );

    TQDomDocument saveXML();

    TQDomElement saveDocumentPart( TQDomDocument& doc );
 

    ContextStyle& getContextStyle( bool edit=false );

    void setZoomAndResolution( int zoom, int dpiX, int dpiY );
 
    void newZoomAndResolution( bool updateViews, bool forPrint );

    void setZoomAndResolution( int zoom, double zoomX, double zoomY,
                               bool updateViews=false, bool forPrint=false );
 
    double getXResolution() const;
    double getYResolution() const;

    void activate(Container* formula);

    void setEnabled( bool enabled );

    KoCommandHistory* getHistory() const;

    const SymbolTable& getSymbolTable() const;

    void updateConfig();

    static TQDomDocument createDomDocument();

    TQDomDocument createMathMLDomDocument();

    void setCreationStrategy( TQString strategy );
 
public:

    TQPtrListIterator<Container> formulas();
 
    SymbolType leftBracketChar();
    SymbolType rightBracketChar();
 
    DocumentWrapper* wrapper() { return m_wrapper; }
 
protected:

    int formulaPos( Container* formula );

    Container* formulaAt( uint pos );

    int formulaCount();

    void sortFormulaList();
 
private:

    Container* newFormula( uint number );

    bool hasFormula();

    void recalc();
 
    void introduceWrapper( DocumentWrapper* wrapper, bool init );

    DocumentWrapper* m_wrapper;

    Container* m_formula;

    ContextStyle* m_contextStyle;

    FormulaList formulae;

    ElementCreationStrategy* creationStrategy;
};
 
 

class KOFORMULA_EXPORT DocumentWrapper : public TQObject {
    TQ_OBJECT
  
 
public:
 
    DocumentWrapper( TDEConfig* config,
                     TDEActionCollection* collection,
                     KoCommandHistory* history = 0 );
    ~DocumentWrapper();
 
    TDEConfig* config() { return m_config; }
    KoCommandHistory* history() { return m_history; }

    Document* document() const { return m_document; }

    void setEnabled( bool enabled );

    void document( Document* document, bool init = true );
 
    TDEAction* getAddNegThinSpaceAction()  { return m_addNegThinSpaceAction; }
    TDEAction* getAddThinSpaceAction()     { return m_addThinSpaceAction; }
    TDEAction* getAddMediumSpaceAction()   { return m_addMediumSpaceAction; }
    TDEAction* getAddThickSpaceAction()    { return m_addThickSpaceAction; }
    TDEAction* getAddQuadSpaceAction()     { return m_addQuadSpaceAction; }
    TDEAction* getAddBracketAction()       { return m_addBracketAction; }
    TDEAction* getAddSBracketAction()      { return m_addSBracketAction;}
    TDEAction* getAddCBracketAction()      { return m_addCBracketAction;}
    TDEAction* getAddAbsAction()           { return m_addAbsAction;}
    TDEAction* getAddFractionAction()      { return m_addFractionAction; }
    TDEAction* getAddRootAction()          { return m_addRootAction; }
    TDEAction* getAddSumAction()           { return m_addSumAction; }
    TDEAction* getAddProductAction()       { return m_addProductAction; }
    TDEAction* getAddIntegralAction()      { return m_addIntegralAction; }
    TDEAction* getAddMatrixAction()        { return m_addMatrixAction; }
    TDEAction* getAddOneByTwoMatrixAction(){ return m_addOneByTwoMatrixAction; }
    TDEAction* getAddUpperLeftAction()     { return m_addUpperLeftAction; }
    TDEAction* getAddLowerLeftAction()     { return m_addLowerLeftAction; }
    TDEAction* getAddUpperRightAction()    { return m_addUpperRightAction; }
    TDEAction* getAddLowerRightAction()    { return m_addLowerRightAction; }
    TDEAction* getAddGenericUpperAction()  { return m_addGenericUpperAction; }
    TDEAction* getAddGenericLowerAction()  { return m_addGenericLowerAction; }
    TDEAction* getAddOverlineAction()      { return m_addOverlineAction; }
    TDEAction* getAddUnderlineAction()     { return m_addUnderlineAction; }
    TDEAction* getAddMultilineAction()     { return m_addMultilineAction; }
    TDEAction* getRemoveEnclosingAction()  { return m_removeEnclosingAction; }
    TDEAction* getMakeGreekAction()        { return m_makeGreekAction; }
    TDEAction* getInsertSymbolAction()     { return m_insertSymbolAction; }
 
    TDEAction* getAppendColumnAction()     { return m_appendColumnAction; }
    TDEAction* getInsertColumnAction()     { return m_insertColumnAction; }
    TDEAction* getRemoveColumnAction()     { return m_removeColumnAction; }
    TDEAction* getAppendRowAction()        { return m_appendRowAction; }
    TDEAction* getInsertRowAction()        { return m_insertRowAction; }
    TDEAction* getRemoveRowAction()        { return m_removeRowAction; }
 
    void enableMatrixActions(bool);
    TDESelectAction* getLeftBracketAction()  { return m_leftBracket; }
    TDESelectAction* getRightBracketAction() { return m_rightBracket; }
    SymbolAction* getSymbolNamesAction()  { return m_symbolNamesAction; }
    TDEToggleAction* getSyntaxHighlightingAction()
        { return m_syntaxHighlightingAction; }
    TDEToggleAction* getFormatBoldAction()   { return m_formatBoldAction; }
    TDEToggleAction* getFormatItalicAction() { return m_formatItalicAction; }
 
    TDESelectAction* getFontFamilyAction() { return m_fontFamily; }
    TDESelectAction* getTokenElementAction() { return m_tokenElement; }
 
    SymbolType leftBracketChar() const  { return m_leftBracketChar; }
    SymbolType rightBracketChar() const { return m_rightBracketChar; }
 
    void updateConfig();
 
    KoCommandHistory* getHistory() const { return m_history; }
 
    void undo();
    void redo();
 
public slots:
 
    void paste();
    void copy();
    void cut();
 
    void addNegThinSpace();
    void addThinSpace();
    void addMediumSpace();
    void addThickSpace();
    void addQuadSpace();
    void addDefaultBracket();
    void addBracket( SymbolType left, SymbolType right );
    void addParenthesis();
    void addSquareBracket();
    void addCurlyBracket();
    void addLineBracket();
    void addFraction();
    void addRoot();
    void addIntegral();
    void addProduct();
    void addSum();
    void addMatrix( uint rows=0, uint columns=0 );
    void addOneByTwoMatrix();
    void addNameSequence();
    void addLowerLeftIndex();
    void addUpperLeftIndex();
    void addLowerRightIndex();
    void addUpperRightIndex();
    void addGenericLowerIndex();
    void addGenericUpperIndex();
    void addOverline();
    void addUnderline();
    void addMultiline();
    void removeEnclosing();
    void makeGreek();
    void insertSymbol();
    void insertSymbol( TQString name );
 
    void appendColumn();
    void insertColumn();
    void removeColumn();
    void appendRow();
    void insertRow();
    void removeRow();
 
    void toggleSyntaxHighlighting();
    void textBold();
    void textItalic();
    void delimiterLeft();
    void delimiterRight();
    void symbolNames();
 
    void fontFamily();
    void tokenElement();
 
private:
 
    void createActions( TDEActionCollection* collection );
    void initSymbolNamesAction();
    void setCommandStack( KoCommandHistory* history );
 
    bool hasFormula() { return m_document->hasFormula(); }
    Container* formula() { return m_document->m_formula; }
 
    Document* m_document;
 
    TDEAction* m_addNegThinSpaceAction;
    TDEAction* m_addThinSpaceAction;
    TDEAction* m_addMediumSpaceAction;
    TDEAction* m_addThickSpaceAction;
    TDEAction* m_addQuadSpaceAction;
    TDEAction* m_addBracketAction;
    TDEAction* m_addSBracketAction;
    TDEAction* m_addCBracketAction;
    TDEAction* m_addAbsAction;
    TDEAction* m_addFractionAction;
    TDEAction* m_addRootAction;
    TDEAction* m_addSumAction;
    TDEAction* m_addProductAction;
    TDEAction* m_addIntegralAction;
    TDEAction* m_addMatrixAction;
    TDEAction* m_addOneByTwoMatrixAction;
    TDEAction* m_addUpperLeftAction;
    TDEAction* m_addLowerLeftAction;
    TDEAction* m_addUpperRightAction;
    TDEAction* m_addLowerRightAction;
    TDEAction* m_addGenericUpperAction;
    TDEAction* m_addGenericLowerAction;
    TDEAction* m_addOverlineAction;
    TDEAction* m_addUnderlineAction;
    TDEAction* m_addMultilineAction;
    TDEAction* m_removeEnclosingAction;
    TDEAction* m_makeGreekAction;
    TDEAction* m_insertSymbolAction;
 
    TDEAction* m_appendColumnAction;
    TDEAction* m_insertColumnAction;
    TDEAction* m_removeColumnAction;
    TDEAction* m_appendRowAction;
    TDEAction* m_insertRowAction;
    TDEAction* m_removeRowAction;
 
    TDEToggleAction* m_syntaxHighlightingAction;
    TDEToggleAction* m_formatBoldAction;
    TDEToggleAction* m_formatItalicAction;
 
    TDESelectAction* m_leftBracket;
    TDESelectAction* m_rightBracket;
    SymbolAction* m_symbolNamesAction;
 
    TDESelectAction* m_fontFamily;
    TDESelectAction* m_tokenElement;
 
    SymbolType m_leftBracketChar;
    SymbolType m_rightBracketChar;
    TQString m_selectedName;
 
    TDEConfig* m_config;
    KoCommandHistory* m_history;

    bool m_ownHistory;
 
    bool m_hasActions;
};
 
 
KFORMULA_NAMESPACE_END
 
#endif // KFORMULADOCUMENT_H