kformulacontainer.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 KFORMULACONTAINER_H
#define KFORMULACONTAINER_H
 
#include <tqclipboard.h>
#include <tqdom.h>
#include <tqimage.h>
#include <tqptrlist.h>
#include <tqobject.h>
#include <tqptrstack.h>
#include <tqstring.h>
 
#include <kcommand.h>
//#include <KoCommandHistory.h>
#include "KoCommandHistory.h"
#include "kformuladefs.h"
 
class TQColorGroup;
class TQKeyEvent;
class TQPainter;
 
class KCommand;
class KPrinter;
 
KFORMULA_NAMESPACE_BEGIN
 
class BasicElement;
class Document;
class FormulaCursor;
class FormulaElement;
class IndexElement;
class PlainCommand;
class SymbolTable;
 

class FormulaDocument {
    // not allowed
    FormulaDocument( const FormulaDocument& ) {}
    FormulaDocument& operator=( const FormulaDocument& ) { return *this; }
public:
 
    FormulaDocument() {}
    virtual ~FormulaDocument() {}
 
    virtual void elementRemoval(BasicElement* /*child*/) {}
    virtual void changed() {}
    virtual void cursorHasMoved( FormulaCursor* ) {}
    virtual void moveOutLeft( FormulaCursor* ) {}
    virtual void moveOutRight( FormulaCursor* ) {}
    virtual void moveOutAbove( FormulaCursor* ) {}
    virtual void moveOutBelow( FormulaCursor* ) {}
    virtual void tell( const TQString& /*msg*/ ) {}
    virtual void insertFormula( FormulaCursor* ) {}
    virtual void removeFormula( FormulaCursor* ) {}
    virtual void baseSizeChanged( int, bool ) {}
    virtual const SymbolTable& getSymbolTable() const = 0;
};
 

class KOFORMULA_EXPORT Container : public TQObject, public FormulaDocument {
    friend class MimeSource;
    TQ_OBJECT
  
 
    // no copying
    Container( const Container& );
    Container& operator= ( const Container& );
 
public:
 
    enum ViewActions { EXIT_LEFT, EXIT_RIGHT,
                       EXIT_ABOVE, EXIT_BELOW,
                       INSERT_FORMULA, REMOVE_FORMULA };

    Container( Document* doc, int pos, bool registerMe=true );
    ~Container();

    void initialize();

    FormulaCursor* createCursor();

    void elementRemoval(BasicElement* child);

    void changed();

    void cursorHasMoved( FormulaCursor* );

    void moveOutLeft( FormulaCursor* );
    void moveOutRight( FormulaCursor* );
    void moveOutAbove( FormulaCursor* );
    void moveOutBelow( FormulaCursor* );
    void tell( const TQString& msg );
    void removeFormula( FormulaCursor* );

    void registerFormula( int pos=-1 );
    void unregisterFormula();

    void baseSizeChanged( int size, bool owned );

    void draw( TQPainter& painter, const TQRect& r,
               const TQColorGroup& cg, bool edit=false );

    void draw( TQPainter& painter, const TQRect& r, bool edit=false );

    void save( TQDomElement &root );

    void saveMathML( TQTextStream& stream, bool oasisFormat = false );

    bool loadMathML( const TQDomDocument &doc, bool oasisFormat = false );

    bool loadMathML( const TQDomElement &doc, bool oasisFormat = false );

    bool load( const TQDomElement &fe );

    TQString texString();
 
    TQString formulaString();

    void print(KPrinter& printer);

    TQImage drawImage( int width, int height );

    FormulaCursor* activeCursor();
    const FormulaCursor* activeCursor() const;

    void setActiveCursor(FormulaCursor* cursor);

    TQRect boundingRect() const;

    TQRect coveredRect();
 
    double width() const;
    double height() const;

    double baseline() const;

    void moveTo( int x, int y );

    virtual double getDocumentX() const { return -1; }
    virtual double getDocumentY() const { return -1; }
    virtual void setDocumentPosition( double /*x*/, double /*y*/ ) {}

    virtual void startEvaluation() {}

    void testDirty();

    virtual void recalc();

    bool isEmpty();

    virtual Document* document() const;
 
    virtual const SymbolTable& getSymbolTable() const;
 
    int fontSize() const;

    void setFontSize( int pointSize, bool forPrint = false );
 
    void setFontSizeDirect( int pointSize );

    void updateMatrixActions();
 
signals:

    void cursorMoved(FormulaCursor* cursor);

    void leaveFormula( Container* formula, FormulaCursor* cursor, int cmd );

    void formulaChanged( int width, int height );
    void formulaChanged( double width, double height );

    void statusMsg( const TQString& msg );

    void errorMsg( const TQString& );

    void elementWillVanish(BasicElement* element);

    void formulaLoaded(FormulaElement*);

    void baseSizeChanged( int );
 
public:

    void input( TQKeyEvent* event );
 
    void performRequest( Request* request );
 
    // There are a lot of thing we can do with the formula.

    void paste();

    void paste( const TQDomDocument& document, TQString desc );

    void copy();

    void cut();
 
protected:
 
    KoCommandHistory* getHistory() const;

    FormulaElement* rootElement() const;

    virtual FormulaElement* createMainSequence();
 
    void emitErrorMsg( const TQString& );
 
private:

    void execute(KCommand *command);

    void checkCursor();

    bool hasValidCursor() const;
 
    struct Container_Impl;
    Container_Impl* impl;
 
    // debug
    friend class TestFormulaCursor;
    friend class TestFormulaElement;
    friend class TestIndexElement;
    friend class TestCommands;
};
 
KFORMULA_NAMESPACE_END
 
#endif // KFORMULACONTAINER_H