F:/KPlato/koffice/libs/kformula/BasicElement.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 BASICELEMENT_H
#define BASICELEMENT_H

#include <QHash>
#include <QString>
#include <QVariant>


#include <QList>
#include <QDomElement>
#include <QDomDocument>

#include "contextstyle.h"
#include "kformuladefs.h"

class KoXmlWriter;

namespace KFormula {

class FontCommand;
class FormulaCursor;
class FormulaElement;
class SequenceElement;

enum ElementType {
    Basic,
    Sequence,
    Fraction,
    Matrix,
    MatrixRow,
    MatrixEntry,
    UnderOver,
    MultiScript
};


class BasicElement {
public:
    /*
     * The standard constructor
     * @param parent pointer to the BasicElement's parent
     */
    BasicElement( BasicElement* parent = 0 );

    virtual ~BasicElement();

    BasicElement* childElementAt( const QPointF& p );

    virtual const QList<BasicElement*> childElements();

    virtual void insertChild( FormulaCursor* cursor, BasicElement* child );
   
    virtual void removeChild( BasicElement* element );

    virtual void paint( QPainter& painter ) const;

    virtual void calculateSize();
    
    virtual void moveLeft( FormulaCursor* cursor, BasicElement* from );

    virtual void moveRight( FormulaCursor* cursor, BasicElement* from );

    virtual void moveUp( FormulaCursor* cursor, BasicElement* from );

    virtual void moveDown( FormulaCursor* cursor, BasicElement* from );

    virtual void moveHome( FormulaCursor* cursor );

    virtual void moveEnd( FormulaCursor* cursor );

    ElementType elementType() const;
    
    double height() const;

    double width() const;

    double baseLine() const;

    QPointF origin() const;

    const QRectF& boundingRect() const;

    void setWidth( double width );

    void setHeight( double height );
    
    void setBaseLine( double baseLine );

    void setOrigin( QPointF origin );

    void setParentElement( BasicElement* parent );

    BasicElement* parentElement() const;

    QString inheritAttribute( const QString& attribute ) const;
    
    virtual void readMathML( const QDomElement& element );

    virtual void writeMathML( KoXmlWriter* writer, bool oasisFormat = false );





    virtual bool readOnly( const BasicElement* child ) const;

    virtual QChar getCharacter() const { return QChar::Null; }

    virtual TokenType getTokenType() const { return ELEMENT; }


    LuPixelPoint widgetPos();

    virtual void calcSizes(const ContextStyle& context, ContextStyle::TextStyle tstyle, ContextStyle::IndexStyle istyle);

    virtual void draw( QPainter& painter, const LuPixelRect& r,
                       const ContextStyle& context,
                       ContextStyle::TextStyle tstyle,
                       ContextStyle::IndexStyle istyle,
                       const LuPixelPoint& parentOrigin );


    virtual void dispatchFontCommand( FontCommand* /*cmd*/ ) {}
    
    virtual void goInside(FormulaCursor* cursor);

    virtual SequenceElement* getMainChild() { return 0; }

    virtual void insert(FormulaCursor*, QList<BasicElement*>&, Direction) {}

    virtual void remove(FormulaCursor*, QList<BasicElement*>&, Direction) {}

    virtual void normalize(FormulaCursor*, Direction);

    virtual bool isSenseless() { return false; }

    virtual BasicElement* getChild(FormulaCursor*, Direction = beforeCursor) { return 0; }

    virtual void selectChild(FormulaCursor*, BasicElement*) {}

    virtual void childWillVanish(FormulaCursor*, BasicElement*) {}

    virtual void registerTab( BasicElement* /*tab*/ ) {}

    // basic support

    const BasicElement* getParent() const { return m_parentElement; }
    BasicElement* getParent() { return m_parentElement; }
    void setParent(BasicElement* p) { m_parentElement = p; }
    double getX() const;
    double getY() const;
    void setX( double x );
    void setY( double y );
    double getWidth() const;
    double getHeight() const;
    luPixel getBaseline() const { return m_baseLine; }
    void setBaseline( luPixel line ) { m_baseLine = line; }

    luPixel axis( const ContextStyle& style, ContextStyle::TextStyle tstyle ) const {
        return getBaseline() - style.axisHeight( tstyle ); }

    QDomElement getElementDom( QDomDocument& doc);

    bool buildFromDom(QDomElement element);



protected:
    void readMathMLAttributes( const QDomElement& element );

    void writeMathMLAttributes( KoXmlWriter* writer );



    virtual QString getTagName() const { return "BASIC"; }

    virtual void writeDom(QDomElement element);

    virtual bool readAttributesFromDom(QDomElement element);

    virtual bool readContentFromDom(QDomNode& node);

    bool buildChild( SequenceElement* child, QDomNode node, const QString & name );

private:
    BasicElement* m_parentElement;

    QHash<QString,QString> m_attributes;

    ElementType m_elementType;
    
    QRectF m_boundingRect;
   
    double m_baseLine;
};

} // namespace KFormula

#endif // BASICELEMENT_H

---