elementtype.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 ELEMENTTYPE_H
#define ELEMENTTYPE_H
 
#include <tqfont.h>
#include <tqstring.h>
#include <tqdom.h>
 
#include "contextstyle.h"
#include "kformuladefs.h"
 
class TQPainter;
 
KFORMULA_NAMESPACE_BEGIN
 
class BasicElement;
class BracketType;
class ComplexElementType;
class InnerElementType;
class MultiElementType;
class OperatorType;
class PunctuationType;
class RelationType;
class SequenceElement;
class SequenceParser;
class TextElement;
 
 
class ElementType {
public:
    ElementType(SequenceParser* parser);
    virtual ~ElementType();
 
    virtual bool isInvisible(const TextElement&) const { return false; }
 
    virtual TQString text( SequenceElement* seq ) const;
 
    uint start() const { return from; }
 
    uint end() const { return to; }
 
    virtual luPt getSpaceBefore( const ContextStyle& context, 
                                 ContextStyle::TextStyle tstyle,
                                 double factor );
    virtual luPt getSpaceAfter( MultiElementType* type,
                                const ContextStyle& context, 
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( OperatorType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( RelationType* type,
                                const ContextStyle& context, 
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( PunctuationType* type, 
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( BracketType* type,
                                const ContextStyle& context, 
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( ComplexElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
 
    virtual TQFont getFont( const ContextStyle& context );
 
    virtual void setUpPainter( const ContextStyle& context, TQPainter& painter );
 
    // debug
    static int getEvilDestructionCount() { return evilDestructionCount; }
 
    virtual void output();
 
    void append( ElementType* );
 
    ElementType* getPrev() const { return prev; }
 
    virtual void saveMathML( SequenceElement* se, TQDomDocument& doc, TQDomElement de, bool oasisFormat = false );
 
    virtual bool multiElement() const { return false; }
 
protected:
 
    void setStart( uint start ) { from = start; }
    void setEnd( uint end ) { to = end; }
 
    luPt thinSpaceIfNotScript( const ContextStyle& context,
                               ContextStyle::TextStyle tstyle,
                               double factor );
    luPt mediumSpaceIfNotScript( const ContextStyle& context, 
                                 ContextStyle::TextStyle tstyle,
                                 double factor );
    luPt thickSpaceIfNotScript( const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
 
private:
 
    uint from;
 
    uint to;
 
    ElementType* prev;
 
    // debug
    static int evilDestructionCount;
};
 
 
class SequenceType : public ElementType {
public:
    SequenceType( SequenceParser* parser );
    ~SequenceType();
 
    virtual void output();
private:
 
    ElementType* last;
};
 
 
class MultiElementType : public ElementType {
public:
    MultiElementType( SequenceParser* parser );
 
    virtual luPt getSpaceBefore( const ContextStyle& context, 
                                 ContextStyle::TextStyle tstyle, 
                                 double factor );
    virtual luPt getSpaceAfter( OperatorType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( RelationType* type,
                                const ContextStyle& context, 
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
 
    virtual bool multiElement() const { return true; }
 
    virtual TQString text( SequenceElement* /*seq*/ ) const { return m_text; }
 
private:
 
    TQString m_text;
};
 
 
class TextType : public MultiElementType {
public:
    TextType( SequenceParser* parser );
    virtual void saveMathML( SequenceElement* se, TQDomDocument& doc, TQDomElement de, bool oasisFormat = false );
};
 
 
class NumberType : public MultiElementType {
public:
    NumberType(SequenceParser* parser);
 
    virtual TQFont getFont(const ContextStyle& context);
 
    virtual void setUpPainter(const ContextStyle& context, TQPainter& painter);
 
    virtual void saveMathML( SequenceElement* se, TQDomDocument& doc, TQDomElement de, bool oasisFormat = false );
};
 
 
class SingleElementType : public ElementType {
public:
    SingleElementType( SequenceParser* parser );
};
 
 
class NameType : public MultiElementType {
public:
    NameType( SequenceParser* parser );
 
    virtual TQFont getFont( const ContextStyle& context );
 
    virtual void saveMathML( SequenceElement* se, TQDomDocument& doc, TQDomElement de, bool oasisFormat = false );
 
private:
};
 
 
class AbstractOperatorType : public SingleElementType {
public:
    AbstractOperatorType( SequenceParser* parser );
 
    void saveMathML( SequenceElement* se, TQDomDocument& doc, TQDomElement de, bool oasisFormat = false  );
};
 
class OperatorType : public AbstractOperatorType {
public:
    OperatorType( SequenceParser* parser );
 
    virtual luPt getSpaceBefore( const ContextStyle& context,
                                 ContextStyle::TextStyle tstyle,
                                 double factor );
    virtual luPt getSpaceAfter( MultiElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( BracketType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( ComplexElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
 
    virtual TQFont getFont(const ContextStyle& context);
 
    virtual void setUpPainter(const ContextStyle& context, TQPainter& painter);
};
 
 
class RelationType : public AbstractOperatorType {
public:
    RelationType( SequenceParser* parser );
 
    virtual luPt getSpaceBefore( const ContextStyle& context,
                                 ContextStyle::TextStyle tstyle,
                                 double factor );
    virtual luPt getSpaceAfter( MultiElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( BracketType* type,
                                const ContextStyle& context, 
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( ComplexElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
 
    virtual TQFont getFont( const ContextStyle& context );
 
    virtual void setUpPainter( const ContextStyle& context, TQPainter& painter );
};
 
 
class PunctuationType : public AbstractOperatorType {
public:
    PunctuationType( SequenceParser* parser );
 
    virtual luPt getSpaceBefore( const ContextStyle& context, 
                                 ContextStyle::TextStyle tstyle, 
                                 double factor );
    virtual luPt getSpaceAfter( MultiElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( RelationType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( PunctuationType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( BracketType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( ComplexElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
 
    virtual TQFont getFont( const ContextStyle& context );
 
    virtual void setUpPainter( const ContextStyle& context, TQPainter& painter );
};
 
 
class BracketType : public SingleElementType {
public:
    BracketType( SequenceParser* parser );
 
    virtual luPt getSpaceBefore( const ContextStyle& context, 
                                 ContextStyle::TextStyle tstyle,
                                 double factor );
    virtual luPt getSpaceAfter( OperatorType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( RelationType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
};
 
 
class ComplexElementType : public SingleElementType {
public:
    ComplexElementType( SequenceParser* parser );
 
    // these spacings are equal to the ones from MultiElementType
    virtual luPt getSpaceBefore( const ContextStyle& context,
                                 ContextStyle::TextStyle tstyle,
                                 double factor );
    virtual luPt getSpaceAfter( OperatorType* type,
                                const ContextStyle& context, 
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( RelationType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
};
 
 
class InnerElementType : public SingleElementType {
public:
    InnerElementType( SequenceParser* parser );
 
    virtual luPt getSpaceBefore( const ContextStyle& context,
                                 ContextStyle::TextStyle tstyle,
                                 double factor );
    virtual luPt getSpaceAfter( MultiElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( OperatorType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( RelationType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( PunctuationType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( BracketType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( ComplexElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
    virtual luPt getSpaceAfter( InnerElementType* type,
                                const ContextStyle& context,
                                ContextStyle::TextStyle tstyle,
                                double factor );
};
 
 
KFORMULA_NAMESPACE_END
 
#endif // ELEMENTTYPE_H