basicelement.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 BASICELEMENT_H
#define BASICELEMENT_H
 
// TQt Include
#include <tqdom.h>
#include <tqptrlist.h>
#include <tqstring.h>
 
// KDE Include
 
// Formula include
#include "contextstyle.h"
#include "kformuladefs.h"
 
class TQKeyEvent;
 
class KCommand;
 
KFORMULA_NAMESPACE_BEGIN
 
class ComplexElement;
class Container;
class ElementType;
class ElementVisitor;
class FontCommand;
class FormulaCursor;
class FormulaElement;
class SequenceElement;
class StyleElement;
 

class BasicElement
{
    friend class SequenceElement;
    friend class SequenceParser;
 
    BasicElement& operator= ( const BasicElement& ) { return *this; }
public:
 
    /*
     * Each element might contain children. Each child needs
     * its own unique number. It is not guaranteed, however,
     * that the number stays the same all the time.
     * (The SequenceElement's children are simply counted.)
     */
 
    BasicElement(BasicElement* parent = 0);
    virtual ~BasicElement();
 
    // deep copy
    BasicElement( const BasicElement& );
 
    virtual BasicElement* clone() = 0;

    virtual bool accept( ElementVisitor* ) = 0;

    virtual bool readOnly( const BasicElement* child ) const;

    virtual FormulaElement* formula();

    virtual const FormulaElement* formula() const { return parent->formula(); }

    virtual TQChar getCharacter() const { return TQChar::null; }

    virtual TokenType getTokenType() const { return ELEMENT; }

    virtual bool isInvisible() const { return false; }

    virtual BasicElement* goToPos( FormulaCursor*, bool& handled,
                                   const LuPixelPoint& point, const LuPixelPoint& parentOrigin );

    LuPixelPoint widgetPos();
 
 
    // drawing
    //
    // Drawing depends on a context which knows the required properties like
    // fonts, spaces and such.
    // It is essential to calculate elements size with the same context
    // before you draw.

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

    virtual void draw( TQPainter& painter, const LuPixelRect& r,
                       const ContextStyle& context,
                       ContextStyle::TextStyle tstyle,
                       ContextStyle::IndexStyle istyle,
                       StyleAttributes& style,
                       const LuPixelPoint& parentOrigin ) = 0;
 

    virtual void dispatchFontCommand( FontCommand* /*cmd*/ ) {}
 
    // navigation
    //
    // The elements are responsible to handle cursor movement themselves.
    // To do this they need to know the direction the cursor moves and
    // the element it comes from.
    //
    // The cursor might be in normal or in selection mode.

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

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

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

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

    virtual void moveHome(FormulaCursor*) {}

    virtual void moveEnd(FormulaCursor*) {}

    virtual void goInside(FormulaCursor* cursor);

    virtual void entered( SequenceElement* /*child*/ );
 
    // children

    //virtual void removeChild(FormulaCursor* cursor, BasicElement* child) {}
 
 
    // main child
    //
    // If an element has children one has to become the main one.
 
    virtual SequenceElement* getMainChild() { return 0; }
    //virtual void setMainChild(SequenceElement*) {}
 
 
    // editing
    //
    // Insert and remove children.

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

    virtual void remove(FormulaCursor*, TQPtrList<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*/ ) {}
 

    virtual KCommand* buildCommand( Container*, Request* ) { return 0; }

    virtual KCommand* input( Container*, TQKeyEvent* ) { return 0; }
 
    // basic support
 
    const BasicElement* getParent() const { return parent; }
    BasicElement* getParent() { return parent; }
    void setParent(BasicElement* p) { parent = p; }
 
    luPixel getX() const { return m_x; }
    luPixel getY() const { return m_y; }
 
    void setX( luPixel x ) { m_x = x; }
    void setY( luPixel y ) { m_y = y; }
 
    //TQSize getSize() { return size; }
 
    luPixel getWidth() const { return m_width; }
    luPixel getHeight() const { return m_height; }
 
    void setWidth( luPixel width )   { m_width = width; }
    void setHeight( luPixel height ) { m_height = height; }
 
    luPixel getBaseline() const { return m_baseline; }
    void setBaseline( luPixel line ) { m_baseline = line; }
 
    luPixel axis( const ContextStyle& style,
                  ContextStyle::TextStyle tstyle,
                  double factor ) const {
        return getBaseline() - style.axisHeight( tstyle, factor ); }

    TQDomElement getElementDom( TQDomDocument& doc);

    virtual void writeMathML( TQDomDocument& doc, TQDomNode& parent, bool oasisFormat = false ) const ;

    bool buildFromDom(TQDomElement element);

    int buildFromMathMLDom( TQDomElement element );
 
    // debug
    static int getEvilDestructionCount() { return evilDestructionCount; }

    ElementType* getElementType() const { return elementType; }

    virtual void setElementType(ElementType* t) { elementType = t; }
 
    virtual void setStyle(StyleElement*) {}
 
    virtual TQString getElementName() const { return ""; };
protected:
 
    //Save/load support

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

    virtual void writeDom(TQDomElement element);
 
    virtual void writeMathMLAttributes( TQDomElement& /*element*/ ) const {};
    virtual void writeMathMLContent( TQDomDocument& /*doc*/, 
                                     TQDomElement& /*element*/,
                                     bool /*oasisFormat*/ ) const {};

    virtual bool readAttributesFromDom(TQDomElement element);

    virtual bool readContentFromDom(TQDomNode& node);

    bool buildChild( SequenceElement* child, TQDomNode node, TQString name );
 

    virtual bool readAttributesFromMathMLDom(const TQDomElement& element);

    virtual int readContentFromMathMLDom(TQDomNode& node);
 

    virtual TQString toLatex();
 
    virtual TQString formulaString() { return ""; }

    double getSize( const TQString& str, SizeType* st );
 
    SizeType getSpace( const TQString& str );
 
private:

    double str2size( const TQString& str, SizeType* st, uint index, SizeType type );

    BasicElement* parent;

    //TQSize size;
    luPixel m_width;
    luPixel m_height;

    //KoPoint position;
    luPixel m_x;
    luPixel m_y;

    luPixel m_baseline;

    //luPixel m_axis;

    ElementType* elementType;
 
    // debug
    static int evilDestructionCount;
};
 
KFORMULA_NAMESPACE_END
 
#endif // BASICELEMENT_H