sequenceelement.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 SEQUENCEELEMENT_H
#define SEQUENCEELEMENT_H
 
#include <tqptrlist.h>
#include <tqstring.h>
 
#include "basicelement.h"
 
class TQKeyEvent;
 
KFORMULA_NAMESPACE_BEGIN
 
class SymbolTable;
class ElementCreationStrategy;

class SequenceElement : public BasicElement {
    SequenceElement& operator=( const SequenceElement& ) { return *this; }
public:
 
    SequenceElement(BasicElement* parent = 0);
    ~SequenceElement();
 
    SequenceElement( const SequenceElement& );
 
    virtual SequenceElement* clone() {
        return new SequenceElement( *this );
    }
 
    virtual bool accept( ElementVisitor* visitor );

    virtual bool readOnly( const FormulaCursor* ) const;

    virtual bool isTextOnly() const { return textSequence; }

    virtual BasicElement* goToPos( FormulaCursor*, bool& handled,
                                   const LuPixelPoint& point,
                                   const LuPixelPoint& parentOrigin );
 
    // 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.

    void setSizeReduction(const ContextStyle& context);

    bool isEmpty();

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

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

    virtual void dispatchFontCommand( FontCommand* cmd );
 
    virtual void drawEmptyRect( TQPainter& painter, const ContextStyle& context,
                                double factor, const LuPixelPoint& upperLeft );
 
    virtual void calcCursorSize( const ContextStyle& context,
                                 FormulaCursor* cursor, bool smallCursor );

    virtual void drawCursor( TQPainter& painter, const ContextStyle& context,
                             StyleAttributes& style, FormulaCursor* cursor,
                             bool smallCursor, bool activeCursor );
 
    // 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 moveWordLeft(FormulaCursor* cursor);

    virtual void moveWordRight(FormulaCursor* cursor);

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

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

    virtual void moveHome(FormulaCursor* cursor);

    virtual void moveEnd(FormulaCursor* cursor);

    virtual void goInside(FormulaCursor* cursor);

    virtual void goInsideLast(FormulaCursor* cursor);
 
 
    // children

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

    virtual void remove(FormulaCursor*, TQPtrList<BasicElement>&, Direction);

    virtual void normalize(FormulaCursor*, Direction);

    virtual BasicElement* getChild(FormulaCursor*, Direction = beforeCursor);

    virtual void selectChild(FormulaCursor* cursor, BasicElement* child);

    virtual void childWillVanish(FormulaCursor* cursor, BasicElement* child);

    uint countChildren() const { return children.count(); }

    bool isChildNumber( uint pos, BasicElement* child )
        { return children.at( pos ) == child; }

    void selectAllChildren(FormulaCursor* cursor);
 
    bool onlyTextSelected( FormulaCursor* cursor );
 

    virtual KCommand* buildCommand( Container*, Request* );
 

    virtual KCommand* input( Container* container, TQChar ch );
    virtual KCommand* input( Container* container, TQKeyEvent* event );

    virtual void parse();

    void getChildrenDom( TQDomDocument& doc, TQDomElement elem, uint from, uint to);

    void getChildrenMathMLDom( TQDomDocument& doc, TQDomNode& elem, uint from, uint to );

    bool buildChildrenFromDom(TQPtrList<BasicElement>& list, TQDomNode n);

    virtual TQString toLatex();
 
    virtual TQString formulaString();

    BasicElement* getChild(uint i) { return children.at(i); }
    const BasicElement* getChild(uint i) const;
 
    int childPos( BasicElement* child ) { return children.find( child ); }
    int childPos( const BasicElement* child ) const;
 
    class ChildIterator {
    public:
        ChildIterator( SequenceElement* sequence, int pos=0 )
            : m_sequence( sequence ), m_pos( pos ) {}
 
        typedef BasicElement value_type;
        typedef BasicElement* pointer;
        typedef BasicElement& reference;
 
        // we simply expect the compared iterators to belong
        // to the same sequence.
        bool operator== ( const ChildIterator& it ) const
            { return /*m_sequence==it.m_sequence &&*/ m_pos==it.m_pos; }
        bool operator!= ( const ChildIterator& it ) const
            { return /*m_sequence!=it.m_sequence ||*/ m_pos!=it.m_pos; }
 
        const BasicElement& operator* () const
            { return *m_sequence->getChild( m_pos ); }
        BasicElement& operator* ()
            { return *m_sequence->getChild( m_pos ); }
 
        BasicElement* operator->() const
            { return m_sequence->getChild( m_pos ); }
 
        ChildIterator& operator++ ()
            { ++m_pos; return *this; }
        ChildIterator operator++ ( int )
            { ChildIterator it( *this ); ++m_pos; return it; }
        ChildIterator& operator-- ()
            { --m_pos; return *this; }
        ChildIterator operator-- ( int )
            { ChildIterator it( *this ); --m_pos; return it; }
        ChildIterator& operator+= ( int j )
            { m_pos+=j; return *this; }
        ChildIterator & operator-= ( int j )
            { m_pos-=j; return *this; }
 
    private:
        SequenceElement* m_sequence;
        int m_pos;
    };
 
    typedef ChildIterator iterator;
 
    iterator begin() { return ChildIterator( this, 0 ); }
    iterator end() { return ChildIterator( this, countChildren() ); }
 
    static void setCreationStrategy( ElementCreationStrategy* strategy );
 
    virtual void setStyle(StyleElement *style);
    virtual int buildChildrenFromMathMLDom(TQPtrList<BasicElement>& list, TQDomNode n);
    virtual int readContentFromMathMLDom(TQDomNode& node);
    int buildMathMLChild( TQDomNode node );
 
protected:
 
    //Save/load support

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

    virtual void writeDom(TQDomElement element);
 
    virtual TQString getElementName() const { return "mrow"; }
    virtual void writeMathMLContent( TQDomDocument& doc, 
                                     TQDomElement& element,
                                     bool oasisFormat ) const;
    virtual bool readAttributesFromDom(TQDomElement element);

    virtual bool readContentFromDom(TQDomNode& node);

    virtual void setChildrenPositions();

    virtual BasicElement* createElement(TQString type, const TQDomElement &element);

    luPixel getChildPosition( const ContextStyle& context, uint child );

    virtual bool isFirstOfToken( BasicElement* child );

    bool insert( uint index, BasicElement *child );
 
    static ElementCreationStrategy* getCreationStrategy() { return creationStrategy; }

    virtual luPt getSpaceBefore( const ContextStyle&, ContextStyle::TextStyle, double ) { return 0; }
    virtual luPt getSpaceAfter( const ContextStyle&, ContextStyle::TextStyle, double ) { return 0; }
 
    static ElementCreationStrategy* creationStrategy;
    
private:

    void removeChild(TQPtrList<BasicElement>& removedChildren, int pos);
 

    TQPtrList<BasicElement> children;

    ElementType* parseTree;

    bool textSequence;
 
    bool singlePipe; //The key '|' produces one '|' not '| |', '||' produces '| |'
 
    StyleElement *style;
};
 

class NameSequence : public SequenceElement {
    typedef SequenceElement inherited;
public:
 
    NameSequence( BasicElement* parent = 0 );
 
    virtual NameSequence* clone() {
        return new NameSequence( *this );
    }
 
    virtual bool accept( ElementVisitor* visitor );

    //virtual bool isTextOnly() const { return true; }

    virtual TQChar getCharacter() const { return '\\'; }

    virtual TokenType getTokenType() const { return NAME; }

    virtual SequenceElement* getMainChild() { return this; }
 
    virtual void calcCursorSize( const ContextStyle& context,
                                 FormulaCursor* cursor, bool smallCursor );

    virtual void drawCursor( TQPainter& painter, const ContextStyle& context,
                             StyleAttributes& style, FormulaCursor* cursor, 
                             bool smallCursor, bool activeCursor );

    virtual void moveWordLeft(FormulaCursor* cursor);

    virtual void moveWordRight(FormulaCursor* cursor);

    virtual KCommand* buildCommand( Container*, Request* );
 

    virtual KCommand* input( Container* container, TQChar ch );

    virtual void setElementType( ElementType* t );

    BasicElement* replaceElement( const SymbolTable& table );

    static bool isValidSelection( FormulaCursor* cursor );
 
protected:

    virtual TQString getTagName() const { return "NAMESEQUENCE"; }
 
    virtual TQString getElementName() const { return "mi"; }
    virtual BasicElement* createElement( TQString type );

    //virtual void parse();

    virtual bool isFirstOfToken( BasicElement* ) { return false; }
 
private:
 
    KCommand* compactExpressionCmd( Container* container );
 
    TQString buildName();
};
 
KFORMULA_NAMESPACE_END
 
#endif // SEQUENCEELEMENT_H