path: root/lib/kformula/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 <qdom.h>
#include <qobject.h>
#include <qptrlist.h>
#include <qstring.h>
#include <qstringlist.h>

#include <kaction.h>
#include <kcommand.h>
#include <kconfig.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;


/**
 * small utility class representing a sortable (by x,y position) list
 * of formulas you can use sort() and inSort(item)
 **/
class FormulaList: public QPtrList<Container>
{
protected:
    virtual int compareItems( QPtrCollection::Item a, QPtrCollection::Item b );
};


/**
 * A document that can contain a lot of formulas (container).
 *
 * The relationship between the document and its formulas is an
 * open one. The document sure owns the formulas and when it
 * vanishes the formulas will be destroyed, too. But the user
 * will most often work with those formulas directly and not
 * bother to ask the document. It's legal to directly create
 * or destroy a Container object.
 */
class KOFORMULA_EXPORT Document : public QObject {
    Q_OBJECT

    friend class DocumentWrapper;
    friend class Container;

public:

    /**
     * Creates a formula document.
     */
    Document( QObject *parent=0, const char *name=0,
              const QStringList &args=QStringList() );
    ~Document();

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

    /**
     * Registers a new formula to be part of this document. Each formula
     * must be part of exactly one document.
     */
    virtual void registerFormula( Container*, int pos=-1 );

    /**
     * Removes a formula from this document. The formula will stay
     * alive and might be registered again.
     */
    virtual void unregisterFormula( Container* );

    /**
     * Triggers the evaluation of the whole document. This obviously
     * required evaluation support.
     */
    virtual void evaluateFormulas() {}
    virtual void enableEvaluation( bool ) {}

    /**
     * Load a kformula DomDocument with all its formulas.
     * This must only be called on a virgin document.
     */
    bool loadXML( const QDomDocument& doc );

    /**
     * Load a OASIS content.xml DomDocument
     * @since 1.4
     */
    bool loadOasis( const QDomDocument& doc );
    
    /**
     * Load the document settings.
     */
    bool loadDocumentPart( QDomElement node );

    /**
     * Save the document with all its formulae.
     */
    QDomDocument saveXML();

    /**
     * Save the document settings.
     */
    QDomElement saveDocumentPart( QDomDocument& doc );


    /**
     * @returns the documents context style.
     */
    ContextStyle& getContextStyle( bool edit=false );

    /**
     * Change the zoom factor to @p z (e.g. 150 for 150%)
     * and/or change the resolution, given in DPI.
     * Uses the KoTextZoomHandler.
     */
    void setZoomAndResolution( int zoom, int dpiX, int dpiY );

    void newZoomAndResolution( bool updateViews, bool forPrint );

    /**
     * Sets the zoom by hand. This is to be used in <code>paintContent</code>.
     */
    void setZoomAndResolution( int zoom, double zoomX, double zoomY,
                               bool updateViews=false, bool forPrint=false );

    double getXResolution() const;
    double getYResolution() const;

    /**
     * Sets a new formula.
     */
    void activate(Container* formula);

    /**
     * Enables our action according to enabled.
     */
    void setEnabled( bool enabled );

    /**
     * @returns our undo stack so the formulas can use it.
     */
    KoCommandHistory* getHistory() const;

    /**
     * @returns the documents symbol table
     */
    const SymbolTable& getSymbolTable() const;

    /**
     * Gets called when the configuration changed.
     * (Maybe we can find a better solution.)
     */
    void updateConfig();

    /**
     * Return a kformula DomDocument.
     */
    static QDomDocument createDomDocument();

    /**
     * Create a MathML Dom Document, deprecates KFO Dom Document for internal layout
     * TODO: Shouldn't this go to KoDocument ?
     */
    QDomDocument createMathMLDomDocument();

    /**
     * Set formula creation strategy: old KFormula or MathML/ODF.
     * This tells which tags are valid during formula constructions
     *
     * @param strategy -- "Ordinary" for old Kformula, "Oasis" for MathML/ODF
     */
    void setCreationStrategy( QString strategy );

public:

    /**
     * @returns an iterator for the collection of formulas.
     */
    QPtrListIterator<Container> formulas();

    SymbolType leftBracketChar();
    SymbolType rightBracketChar();

    DocumentWrapper* wrapper() { return m_wrapper; }

protected:

    /**
     * @returns the internal position of this formula or -1 if it
     * doesn't belong to us.
     */
    int formulaPos( Container* formula );

    /**
     * @returns the formula at position pos.
     */
    Container* formulaAt( uint pos );

    /**
     * @returns the number of formulas in this document.
     */
    int formulaCount();

    /**
     * Sorts the list of formulas according to their screen positions.
     */
    void sortFormulaList();

private:

    /**
     * Return the formula with the given number or create a new one
     * if there is no such formula.
     */
    Container* newFormula( uint number );

    /**
     * @returns whether we have a formula that can get requests.
     */
    bool hasFormula();

    /**
     * recalc all formulae.
     */
    void recalc();

    void introduceWrapper( DocumentWrapper* wrapper, bool init );

    /**
     * The Wrapper we belong to.
     */
    DocumentWrapper* m_wrapper;

    /**
     * The active formula.
     */
    Container* m_formula;

    /**
     * The documents context style. This is the place where all
     * the user configurable informations are stored.
     */
    ContextStyle* m_contextStyle;

    /**
     * All formulae that belong to this document.
     */
    FormulaList formulae;

	/**
	 * Creation strategy to use in this document.
	 */
	ElementCreationStrategy* creationStrategy;
};



/**
 * A Wrapper that constracts the actions and must be given a real
 * document to work with.
 */
class KOFORMULA_EXPORT DocumentWrapper : public QObject {
    Q_OBJECT

public:

    DocumentWrapper( KConfig* config,
                     KActionCollection* collection,
                     KoCommandHistory* history = 0 );
    ~DocumentWrapper();

    KConfig* config() { return m_config; }
    KoCommandHistory* history() { return m_history; }

    /**
     * @return the document we are using.
     */
    Document* document() const { return m_document; }

    /**
     * Enables our action according to enabled.
     */
    void setEnabled( bool enabled );

    /**
     * Inserts the document we are wrapping. This must be called once
     * before the wrapper can be used.
     */
    void document( Document* document, bool init = true );

    KAction* getAddNegThinSpaceAction()  { return m_addNegThinSpaceAction; }
    KAction* getAddThinSpaceAction()     { return m_addThinSpaceAction; }
    KAction* getAddMediumSpaceAction()   { return m_addMediumSpaceAction; }
    KAction* getAddThickSpaceAction()    { return m_addThickSpaceAction; }
    KAction* getAddQuadSpaceAction()     { return m_addQuadSpaceAction; }
    KAction* getAddBracketAction()       { return m_addBracketAction; }
    KAction* getAddSBracketAction()      { return m_addSBracketAction;}
    KAction* getAddCBracketAction()      { return m_addCBracketAction;}
    KAction* getAddAbsAction()           { return m_addAbsAction;}
    KAction* getAddFractionAction()      { return m_addFractionAction; }
    KAction* getAddRootAction()          { return m_addRootAction; }
    KAction* getAddSumAction()           { return m_addSumAction; }
    KAction* getAddProductAction()       { return m_addProductAction; }
    KAction* getAddIntegralAction()      { return m_addIntegralAction; }
    KAction* getAddMatrixAction()        { return m_addMatrixAction; }
    KAction* getAddOneByTwoMatrixAction(){ return m_addOneByTwoMatrixAction; }
    KAction* getAddUpperLeftAction()     { return m_addUpperLeftAction; }
    KAction* getAddLowerLeftAction()     { return m_addLowerLeftAction; }
    KAction* getAddUpperRightAction()    { return m_addUpperRightAction; }
    KAction* getAddLowerRightAction()    { return m_addLowerRightAction; }
    KAction* getAddGenericUpperAction()  { return m_addGenericUpperAction; }
    KAction* getAddGenericLowerAction()  { return m_addGenericLowerAction; }
    KAction* getAddOverlineAction()      { return m_addOverlineAction; }
    KAction* getAddUnderlineAction()     { return m_addUnderlineAction; }
    KAction* getAddMultilineAction()     { return m_addMultilineAction; }
    KAction* getRemoveEnclosingAction()  { return m_removeEnclosingAction; }
    KAction* getMakeGreekAction()        { return m_makeGreekAction; }
    KAction* getInsertSymbolAction()     { return m_insertSymbolAction; }

    KAction* getAppendColumnAction()     { return m_appendColumnAction; }
    KAction* getInsertColumnAction()     { return m_insertColumnAction; }
    KAction* getRemoveColumnAction()     { return m_removeColumnAction; }
    KAction* getAppendRowAction()        { return m_appendRowAction; }
    KAction* getInsertRowAction()        { return m_insertRowAction; }
    KAction* getRemoveRowAction()        { return m_removeRowAction; }

    void enableMatrixActions(bool);
    KSelectAction* getLeftBracketAction()  { return m_leftBracket; }
    KSelectAction* getRightBracketAction() { return m_rightBracket; }
    SymbolAction* getSymbolNamesAction()  { return m_symbolNamesAction; }
    KToggleAction* getSyntaxHighlightingAction()
        { return m_syntaxHighlightingAction; }
    KToggleAction* getFormatBoldAction()   { return m_formatBoldAction; }
    KToggleAction* getFormatItalicAction() { return m_formatItalicAction; }

    KSelectAction* getFontFamilyAction() { return m_fontFamily; }
    KSelectAction* 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( QString 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( KActionCollection* collection );
    void initSymbolNamesAction();
    void setCommandStack( KoCommandHistory* history );

    bool hasFormula() { return m_document->hasFormula(); }
    Container* formula() { return m_document->m_formula; }

    Document* m_document;

    KAction* m_addNegThinSpaceAction;
    KAction* m_addThinSpaceAction;
    KAction* m_addMediumSpaceAction;
    KAction* m_addThickSpaceAction;
    KAction* m_addQuadSpaceAction;
    KAction* m_addBracketAction;
    KAction* m_addSBracketAction;
    KAction* m_addCBracketAction;
    KAction* m_addAbsAction;
    KAction* m_addFractionAction;
    KAction* m_addRootAction;
    KAction* m_addSumAction;
    KAction* m_addProductAction;
    KAction* m_addIntegralAction;
    KAction* m_addMatrixAction;
    KAction* m_addOneByTwoMatrixAction;
    KAction* m_addUpperLeftAction;
    KAction* m_addLowerLeftAction;
    KAction* m_addUpperRightAction;
    KAction* m_addLowerRightAction;
    KAction* m_addGenericUpperAction;
    KAction* m_addGenericLowerAction;
    KAction* m_addOverlineAction;
    KAction* m_addUnderlineAction;
    KAction* m_addMultilineAction;
    KAction* m_removeEnclosingAction;
    KAction* m_makeGreekAction;
    KAction* m_insertSymbolAction;

    KAction* m_appendColumnAction;
    KAction* m_insertColumnAction;
    KAction* m_removeColumnAction;
    KAction* m_appendRowAction;
    KAction* m_insertRowAction;
    KAction* m_removeRowAction;

    KToggleAction* m_syntaxHighlightingAction;
    KToggleAction* m_formatBoldAction;
    KToggleAction* m_formatItalicAction;

    KSelectAction* m_leftBracket;
    KSelectAction* m_rightBracket;
    SymbolAction* m_symbolNamesAction;

    KSelectAction* m_fontFamily;
    KSelectAction* m_tokenElement;

    SymbolType m_leftBracketChar;
    SymbolType m_rightBracketChar;
    QString m_selectedName;

    KConfig* m_config;
    KoCommandHistory* m_history;

    /**
     * Tells whether we are responsible to remove our history.
     */
    bool m_ownHistory;

    bool m_hasActions;
};


KFORMULA_NAMESPACE_END

#endif // KFORMULADOCUMENT_H