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