F:/KPlato/koffice/libs/kformula/FormulaContainer.h

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2001 Andrea Rizzi <rizzi@kde.org>
                      Ulrich Kuettler <ulrich.kuettler@mailbox.tu-dresden.de>
                 2006 Martin Pfeiffer <hubipete@gmx.net>

   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 <QObject>
#include <QString>
#include <QTextStream>
#include <QKeyEvent>
#include <QDomElement>
#include "kformuladefs.h"
class QColorGroup;
class QKeyEvent;
class QPainter;


namespace KFormula {

class BasicElement;
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 QString& /*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 QObject, public FormulaDocument {
    Q_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 recalcLayout();



    
    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 QString& msg );
    void removeFormula( FormulaCursor* );

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

    void baseSizeChanged( int size, bool owned );

    void draw( QPainter& painter, const QRectF& r,
               const QPalette& palette, bool edit=false );

    void draw( QPainter& painter, const QRectF& r, bool edit=false );

    void save( QDomElement &root );

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

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

    bool loadMathML( const QDomElement &element, bool oasisFormat = false );

    bool load( const QDomElement &fe );

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

    void setActiveCursor(FormulaCursor* cursor);

    const QRectF& boundingRect() const;

    const QRectF& coveredRect() const;

//    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*/ ) {}

    void testDirty();



    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 QString& msg );

    void errorMsg( const QString& );

    void elementWillVanish(BasicElement* element);

    void formulaLoaded(FormulaElement*);

    void baseSizeChanged( int );

public:

    void input( QKeyEvent* event );

    void performRequest( Request* request );

    // There are a lot of thing we can do with the formula.

    void paste();

    void paste( const QDomDocument& document, const QString& desc );

    void copy();

    void cut();

protected:
    void emitErrorMsg( const QString& );

private:
    QList<BasicElement> m_elements;

    FormulaElement* m_formulaElement;

    void checkCursor();

    bool hasValidCursor() const;

    struct Container_Impl;
    Container_Impl* impl;
};

} // namespace KFormula

#endif // KFORMULACONTAINER_H

---