Renaming of files in preparation for code style tools.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 1934 insertions, 0 deletions

diff --git a/lib/kformula/sequenceelement.cpp b/lib/kformula/sequenceelement.cpp
new file mode 100644
index 00000000..187bcd65
--- /dev/null
+++ b/lib/kformula/sequenceelement.cpp
@@ -0,0 +1,1934 @@
+/* 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.
+*/
+
+#include <stdlib.h>
+#include <math.h>
+
+#include <tqpainter.h>
+#include <tqpaintdevice.h>
+#include <tqvaluestack.h>
+
+#include <kcommand.h>
+#include <kdebug.h>
+#include <tdelocale.h>
+
+//#include <boost/spirit.hpp>
+
+#include "MatrixDialog.h"
+#include "bracketelement.h"
+#include "creationstrategy.h"
+#include "elementtype.h"
+#include "elementvisitor.h"
+#include "formulacursor.h"
+#include "formulaelement.h"
+#include "fractionelement.h"
+#include "indexelement.h"
+#include "kformulacommand.h"
+#include "kformulacontainer.h"
+#include "kformuladocument.h"
+#include "matrixelement.h"
+#include "rootelement.h"
+#include "sequenceelement.h"
+#include "sequenceparser.h"
+#include "spaceelement.h"
+#include "symbolelement.h"
+#include "symboltable.h"
+#include "textelement.h"
+#include "numberelement.h"
+#include "identifierelement.h"
+#include "operatorelement.h"
+
+#include <assert.h>
+
+KFORMULA_NAMESPACE_BEGIN
+//using namespace std;
+
+ElementCreationStrategy* SequenceElement::creationStrategy = 0;
+
+void SequenceElement::setCreationStrategy( ElementCreationStrategy* strategy )
+{
+    creationStrategy = strategy;
+}
+
+void SequenceElement::setStyle( StyleElement *st ) 
+{
+    style = st;
+}
+
+SequenceElement::SequenceElement(BasicElement* parent)
+        : BasicElement(parent), parseTree(0), textSequence(true),singlePipe(true), style(0)
+{
+    assert( creationStrategy != 0 );
+    children.setAutoDelete(true);
+}
+
+
+SequenceElement::~SequenceElement()
+{
+    delete parseTree;
+}
+
+SequenceElement::SequenceElement( const SequenceElement& other )
+    : BasicElement( other )
+{
+    children.setAutoDelete(true);
+    uint count = other.children.count();
+    for (uint i = 0; i < count; i++) {
+        BasicElement* child = children.at(i)->clone();
+        child->setParent( this );
+        children.append( child );
+    }
+}
+
+
+bool SequenceElement::accept( ElementVisitor* visitor )
+{
+    return visitor->visit( this );
+}
+
+
+bool SequenceElement::readOnly( const FormulaCursor* ) const
+{
+    return getParent()->readOnly( this );
+}
+
+
+/**
+ * Returns the element the point is in.
+ */
+BasicElement* SequenceElement::goToPos( FormulaCursor* cursor, bool& handled,
+                                        const LuPixelPoint& point, const LuPixelPoint& parentOrigin )
+{
+    BasicElement* e = BasicElement::goToPos(cursor, handled, point, parentOrigin);
+    if (e != 0) {
+        LuPixelPoint myPos(parentOrigin.x() + getX(),
+                           parentOrigin.y() + getY());
+
+        uint count = children.count();
+        for (uint i = 0; i < count; i++) {
+            BasicElement* child = children.at(i);
+            e = child->goToPos(cursor, handled, point, myPos);
+            if (e != 0) {
+                if (!handled) {
+                    handled = true;
+                    if ((point.x() - myPos.x()) < (e->getX() + e->getWidth()*2/3)) {
+                        cursor->setTo(this, children.find(e));
+                    }
+                    else {
+                        cursor->setTo(this, children.find(e)+1);
+                    }
+                }
+                return e;
+            }
+        }
+
+        luPixel dx = point.x() - myPos.x();
+        //int dy = point.y() - myPos.y();
+
+        for (uint i = 0; i < count; i++) {
+            BasicElement* child = children.at(i);
+            if (dx < child->getX()) {
+                cursor->setTo( this, i );
+                handled = true;
+                return children.at( i );
+            }
+        }
+
+        cursor->setTo(this, countChildren());
+        handled = true;
+        return this;
+    }
+    return 0;
+}
+
+
+bool SequenceElement::isEmpty()
+{
+    uint count = children.count();
+    for (uint i = 0; i < count; i++) {
+        BasicElement* child = children.at(i);
+        if (!child->isInvisible()) {
+            return false;
+        }
+    }
+    return true;
+}
+
+
+/**
+ * Calculates our width and height and
+ * our children's parentPosition.
+ */
+void SequenceElement::calcSizes( const ContextStyle& context,
+								 ContextStyle::TextStyle tstyle,
+								 ContextStyle::IndexStyle istyle,
+								 StyleAttributes& style )
+{
+    double factor = style.sizeFactor();
+    if (!isEmpty()) {
+        luPixel width = 0;
+        luPixel toBaseline = 0;
+        luPixel fromBaseline = 0;
+
+        width += context.ptToPixelX( getSpaceBefore( context, tstyle, factor ) );
+
+        // Let's do all normal elements that have a base line.
+        TQPtrListIterator<BasicElement> it( children );
+        for ( ; it.current(); ++it ) {
+            BasicElement* child = it.current();
+
+            if ( !child->isInvisible() ) {
+                child->calcSizes( context, tstyle, istyle, style );
+                child->setX( width );
+                width += child->getWidth();
+
+                luPixel childBaseline = child->getBaseline();
+                if ( childBaseline > -1 ) {
+                    toBaseline = TQMAX( toBaseline, childBaseline );
+                    fromBaseline = TQMAX( fromBaseline,
+                                         child->getHeight() - childBaseline );
+                }
+                else {
+                    luPixel bl = child->getHeight()/2 + context.axisHeight( tstyle, factor );
+                    toBaseline = TQMAX( toBaseline, bl );
+                    fromBaseline = TQMAX( fromBaseline, child->getHeight() - bl );
+                }
+            }
+            else {
+                child->setX( width );
+            }
+        }
+
+        width += context.ptToPixelX( getSpaceAfter( context, tstyle, factor ) );
+
+        setWidth(width);
+        setHeight(toBaseline+fromBaseline);
+        setBaseline(toBaseline);
+
+        setChildrenPositions();
+    }
+    else {
+        luPixel w = context.getEmptyRectWidth( factor );
+        luPixel h = context.getEmptyRectHeight( factor );
+        setWidth( w );
+        setHeight( h );
+        setBaseline( h );
+        //setMidline( h*.5 );
+    }
+}
+
+
+void SequenceElement::setChildrenPositions()
+{
+    TQPtrListIterator<BasicElement> it( children );
+    for ( ; it.current(); ++it ) {
+        BasicElement* child = it.current();
+        child->setY(getBaseline() - child->getBaseline());
+    }
+}
+
+
+/**
+ * Draws the whole element including its children.
+ * The `parentOrigin' is the point this element's parent starts.
+ * We can use our parentPosition to get our own origin then.
+ */
+void SequenceElement::draw( TQPainter& painter, const LuPixelRect& r,
+                            const ContextStyle& context,
+                            ContextStyle::TextStyle tstyle,
+                            ContextStyle::IndexStyle istyle,
+                            StyleAttributes& style,
+                            const LuPixelPoint& parentOrigin )
+{
+    LuPixelPoint myPos( parentOrigin.x() + getX(), parentOrigin.y() + getY() );
+    // There might be zero sized elements that still want to be drawn at least
+    // in edit mode. (EmptyElement)
+    //if ( !LuPixelRect( myPos.x(), myPos.y(), getWidth(), getHeight() ).intersects( r ) )
+    //    return;
+
+    if (!isEmpty()) {
+        TQPtrListIterator<BasicElement> it( children );
+        for (int i = 0 ; it.current(); i++) {
+            BasicElement* child = it.current();
+            if (!child->isInvisible()) {
+                child->draw(painter, r, context, tstyle, istyle, style, myPos);
+
+                // Each starting element draws the whole token
+                // This only concerns TextElements.
+                /*
+                ElementType* token = child->getElementType();
+                if ( token != 0 ) {
+                    it += token->end() - token->start();
+                }
+                else {
+                    ++it;
+                }
+                */
+            }
+//            else {
+                ++it;
+//            }
+        }
+    }
+    else {
+        drawEmptyRect( painter, context, style.sizeFactor(), myPos );
+    }
+    // Debug
+    //painter.setPen(TQt::green);
+    //painter.drawRect(parentOrigin.x() + getX(), parentOrigin.y() + getY(),
+    //                 getWidth(), getHeight());
+//     painter.drawLine( context.layoutUnitToPixelX( parentOrigin.x() + getX() ),
+//                       context.layoutUnitToPixelY( parentOrigin.y() + getY() + axis( context, tstyle ) ),
+//                       context.layoutUnitToPixelX( parentOrigin.x() + getX() + getWidth() ),
+//                       context.layoutUnitToPixelY( parentOrigin.y() + getY() + axis( context, tstyle ) ) );
+//     painter.setPen(TQt::red);
+//     painter.drawLine( context.layoutUnitToPixelX( parentOrigin.x() + getX() ),
+//                       context.layoutUnitToPixelY( parentOrigin.y() + getY() + getBaseline() ),
+//                       context.layoutUnitToPixelX( parentOrigin.x() + getX() + getWidth() ),
+//                       context.layoutUnitToPixelY( parentOrigin.y() + getY() + getBaseline() ) );
+}
+
+
+void SequenceElement::dispatchFontCommand( FontCommand* cmd )
+{
+    TQPtrListIterator<BasicElement> it( children );
+    for ( ; it.current(); ++it ) {
+        BasicElement* child = it.current();
+        child->dispatchFontCommand( cmd );
+    }
+}
+
+
+void SequenceElement::drawEmptyRect( TQPainter& painter, const ContextStyle& context,
+                                     double factor, const LuPixelPoint& upperLeft )
+{
+    if ( context.edit() ) {
+        painter.setBrush(TQt::NoBrush);
+        painter.setPen( TQPen( context.getEmptyColor(),
+                              context.layoutUnitToPixelX( context.getLineWidth( factor ) ) ) );
+        painter.drawRect( context.layoutUnitToPixelX( upperLeft.x() ),
+                          context.layoutUnitToPixelY( upperLeft.y() ),
+                          context.layoutUnitToPixelX( getWidth() ),
+                          context.layoutUnitToPixelY( getHeight() ) );
+    }
+}
+
+void SequenceElement::calcCursorSize( const ContextStyle& context,
+                                      FormulaCursor* cursor, bool smallCursor )
+{
+    LuPixelPoint point = widgetPos();
+    uint pos = cursor->getPos();
+
+    luPixel posX = getChildPosition( context, pos );
+    luPixel height = getHeight();
+
+    luPixel unitX = context.ptToLayoutUnitPixX( 1 );
+    luPixel unitY = context.ptToLayoutUnitPixY( 1 );
+
+    // Here are those evil constants that describe the cursor size.
+
+    if ( cursor->isSelection() ) {
+        uint mark = cursor->getMark();
+        luPixel markX = getChildPosition( context, mark );
+        luPixel x = TQMIN(posX, markX);
+        luPixel width = abs(posX - markX);
+
+        if ( smallCursor ) {
+            cursor->cursorSize.setRect( point.x()+x, point.y(), width, height );
+        }
+        else {
+            cursor->cursorSize.setRect( point.x()+x, point.y() - 2*unitY,
+                                        width + unitX, height + 4*unitY );
+        }
+    }
+    else {
+        if ( smallCursor ) {
+            cursor->cursorSize.setRect( point.x()+posX, point.y(),
+                                        unitX, height );
+        }
+        else {
+            cursor->cursorSize.setRect( point.x(), point.y() - 2*unitY,
+                                        getWidth() + unitX, height + 4*unitY );
+        }
+    }
+
+    cursor->cursorPoint.setX( point.x()+posX );
+    cursor->cursorPoint.setY( point.y()+getHeight()/2 );
+}
+
+
+/**
+ * If the cursor is inside a sequence it needs to be drawn.
+ */
+void SequenceElement::drawCursor( TQPainter& painter, const ContextStyle& context,
+                                  StyleAttributes& style, FormulaCursor* cursor,
+                                  bool smallCursor, bool activeCursor )
+{
+    painter.setRasterOp( TQt::XorROP );
+    if ( cursor->isSelection() ) {
+        const LuPixelRect& r = cursor->cursorSize;
+        painter.fillRect( context.layoutUnitToPixelX( r.x() ),
+                          context.layoutUnitToPixelY( r.y() ),
+                          context.layoutUnitToPixelX( r.width() ),
+                          context.layoutUnitToPixelY( r.height() ),
+                          TQt::white );
+    }
+    painter.setPen( TQPen( TQt::white,
+                          context.layoutUnitToPixelX( context.getLineWidth( style.sizeFactor() )/2 ) ) );
+    const LuPixelPoint& point = cursor->getCursorPoint();
+    const LuPixelRect& size = cursor->getCursorSize();
+    if ( activeCursor )
+    {
+        int offset = 0;
+        if ( cursor->isSelection() && cursor->getPos() > cursor->getMark() )
+            offset = -1;
+        painter.drawLine( context.layoutUnitToPixelX( point.x() ) + offset,
+                          context.layoutUnitToPixelY( size.top() ),
+                          context.layoutUnitToPixelX( point.x() ) + offset,
+                          context.layoutUnitToPixelY( size.bottom() )-1 );
+        painter.drawLine( context.layoutUnitToPixelX( point.x() ) + offset + 1,
+                          context.layoutUnitToPixelY( size.top() ),
+                          context.layoutUnitToPixelX( point.x() ) + offset + 1,
+                          context.layoutUnitToPixelY( size.bottom() )-1 );
+    }
+    if ( !smallCursor && !cursor->isSelection() )
+        painter.drawLine( context.layoutUnitToPixelX( size.left() ),
+                          context.layoutUnitToPixelY( size.bottom() )-1,
+                          context.layoutUnitToPixelX( size.right() )-1,
+                          context.layoutUnitToPixelY( size.bottom() )-1 );
+    // This might be wrong but probably isn't.
+    painter.setRasterOp( TQt::CopyROP );
+}
+
+
+luPixel SequenceElement::getChildPosition( const ContextStyle& context, uint child )
+{
+    if (child < children.count()) {
+        return children.at(child)->getX();
+    }
+    else {
+        if (children.count() > 0) {
+            return children.at(child-1)->getX() + children.at(child-1)->getWidth();
+        }
+        else {
+            return context.ptToLayoutUnitPixX( 2 );
+        }
+    }
+}
+
+
+// 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.
+
+/**
+ * Enters this element while moving to the left starting inside
+ * the element `from'. Searches for a cursor position inside
+ * this element or to the left of it.
+ */
+void SequenceElement::moveLeft(FormulaCursor* cursor, BasicElement* from)
+{
+    // Our parent asks us for a cursor position. Found.
+    if (from == getParent()) {
+        cursor->setTo(this, children.count());
+        if ( cursor->isSelectionMode() ) {
+            cursor->setMark( children.count() );
+        }
+        from->entered( this );
+    }
+
+    // We already owned the cursor. Ask next child then.
+    else if (from == this) {
+        if (cursor->getPos() > 0) {
+            cursor->setTo(this, cursor->getPos()-1);
+
+            // invisible elements are not visible so we move on.
+            if (children.at(cursor->getPos())->isInvisible()) {
+                moveLeft(cursor, this);
+            }
+        }
+        else {
+            // Needed because FormulaElement derives this.
+            if (getParent() != 0) {
+                getParent()->moveLeft(cursor, this);
+            }
+            else {
+                formula()->moveOutLeft( cursor );
+            }
+        }
+    }
+
+    // The cursor came from one of our children or
+    // something is wrong.
+    else {
+        int fromPos = children.find(from);
+        if ( fromPos > 0 ) {
+            children.at( fromPos - 1)->moveLeft( cursor, this );
+        }
+
+        // invisible elements are not visible so we move on.
+        if (from->isInvisible()) {
+            moveLeft(cursor, this);
+        }
+        formula()->tell( "" );
+    }
+}
+
+/**
+ * Enters this element while moving to the right starting inside
+ * the element `from'. Searches for a cursor position inside
+ * this element or to the right of it.
+ */
+void SequenceElement::moveRight(FormulaCursor* cursor, BasicElement* from)
+{
+    // Our parent asks us for a cursor position. Found.
+    if (from == getParent()) {
+        cursor->setTo(this, 0);
+        from->entered( this );
+    }
+
+    // We already owned the cursor. Ask next child then.
+    else if (from == this) {
+        uint pos = cursor->getPos();
+        if (pos < children.count()) {
+            cursor->setTo(this, pos+1);
+            
+            // invisible elements are not visible so we move on.
+            if (children.at(pos)->isInvisible()) {
+                moveRight(cursor, this);
+            }
+        }
+        else {
+            // Needed because FormulaElement derives this.
+            if (getParent() != 0) {
+                getParent()->moveRight(cursor, this);
+            }
+            else {
+                formula()->moveOutRight( cursor );
+            }
+        }
+    }
+
+    // The cursor came from one of our children or
+    // something is wrong.
+    else {
+        int fromPos = children.find(from);
+        if ( fromPos < children.count() - 1 ) {
+            children.at( fromPos + 1 )->moveDown( cursor, this );
+        }
+        else {
+            cursor->setTo(this, fromPos+1);
+        }
+        if (cursor->isSelectionMode()) {
+            cursor->setMark(fromPos);
+        }
+
+        // invisible elements are not visible so we move on.
+        if (from->isInvisible()) {
+            moveRight(cursor, this);
+        }
+        formula()->tell( "" );
+    }
+}
+
+
+void SequenceElement::moveWordLeft(FormulaCursor* cursor)
+{
+    uint pos = cursor->getPos();
+    if (pos > 0) {
+        ElementType* type = children.at(pos-1)->getElementType();
+        if (type != 0) {
+            cursor->setTo(this, type->start());
+        }
+    }
+    else {
+        moveLeft(cursor, this);
+    }
+}
+
+
+void SequenceElement::moveWordRight(FormulaCursor* cursor)
+{
+    uint pos = cursor->getPos();
+    if (pos < children.count()) {
+        ElementType* type = children.at(pos)->getElementType();
+        if (type != 0) {
+            cursor->setTo(this, type->end());
+        }
+    }
+    else {
+        moveRight(cursor, this);
+    }
+}
+
+
+/**
+ * Enters this element while moving up starting inside
+ * the element `from'. Searches for a cursor position inside
+ * this element or above it.
+ */
+void SequenceElement::moveUp(FormulaCursor* cursor, BasicElement* from)
+{
+    if (from == getParent()) {
+        moveRight(cursor, this);
+    }
+    else if ( from == this ) {
+        if ( getParent() != 0 ) {
+            uint pos = cursor->getPos();
+            if ( pos < (children.count() - 1) / 2 ) {
+                getParent()->moveLeft( cursor, this );
+            }
+            else {
+                getParent()->moveRight( cursor, this );
+            }
+        }
+        else {
+                formula()->moveOutAbove( cursor );
+        }
+    }
+    else {
+        if (getParent() != 0) {
+            getParent()->moveUp(cursor, this);
+        }
+        else {
+            formula()->moveOutAbove( cursor );
+        }
+    }
+}
+
+/**
+ * Enters this element while moving down starting inside
+ * the element `from'. Searches for a cursor position inside
+ * this element or below it.
+ */
+void SequenceElement::moveDown(FormulaCursor* cursor, BasicElement* from)
+{
+    if (from == getParent()) {
+        cursor->setTo(this, 0);
+        from->entered( this );
+    }
+    else if (from == this) {
+        uint pos = cursor->getPos();
+        if (pos < children.count()) {
+                children.at(pos)->moveDown(cursor, this);
+        }
+    }
+    else {
+        if (getParent() != 0) {
+            getParent()->moveDown(cursor, this);
+        }
+        else {
+            cursor->setTo( this, children.count() );
+            from->entered( this );
+//            formula()->moveOutBelow( cursor );
+        }
+    }
+}
+
+/**
+ * Moves the cursor to the first position in this sequence.
+ * (That is before the first child.)
+ */
+void SequenceElement::moveHome(FormulaCursor* cursor)
+{
+    if (cursor->isSelectionMode()) {
+        BasicElement* element = cursor->getElement();
+        if (element != this) {
+            while (element->getParent() != this) {
+                element = element->getParent();
+            }
+            cursor->setMark(children.find(element)+1);
+        }
+    }
+    cursor->setTo(this, 0);
+}
+
+/**
+ * Moves the cursor to the last position in this sequence.
+ * (That is behind the last child.)
+ */
+void SequenceElement::moveEnd(FormulaCursor* cursor)
+{
+    if (cursor->isSelectionMode()) {
+        BasicElement* element = cursor->getElement();
+        if (element != this) {
+            while (element->getParent() != this) {
+                element = element->getParent();
+                if (element == 0) {
+                    cursor->setMark(children.count());
+                    break;
+                }
+            }
+            if (element != 0) {
+                cursor->setMark(children.find(element));
+            }
+        }
+    }
+    cursor->setTo(this, children.count());
+}
+
+/**
+ * Sets the cursor inside this element to its start position.
+ * For most elements that is the main child.
+ */
+void SequenceElement::goInside(FormulaCursor* cursor)
+{
+    cursor->setSelection(false);
+    cursor->setTo(this, 0);
+}
+
+/**
+ * Sets the cursor inside this element to its end position.
+ * For most elements that is the main child.
+ */
+void SequenceElement::goInsideLast(FormulaCursor* cursor)
+{
+    cursor->setSelection(false);
+    cursor->setTo(this, children.count());
+}
+
+
+// children
+
+    /**
+     * Insert a new child in the sequence
+     * 
+     * @returns true if succesful, i.e. if index is in range, otherwise returns
+     * false. The valid range is 0 to count(). The child is appended if index == count().
+     *
+     * @param index position in the sequence to insert the child
+     * @param child the child to insert in the sequence
+     */
+
+bool SequenceElement::insert( uint index, BasicElement *child )
+{
+    return children.insert( index, child );
+}
+
+/**
+ * Removes the child. If this was the main child this element might
+ * request its own removal.
+ * The cursor is the one that caused the removal. It has to be moved
+ * to the place any user expects the cursor after that particular
+ * element has been removed.
+ */
+// void SequenceElement::removeChild(FormulaCursor* cursor, BasicElement* child)
+// {
+//     int pos = children.find(child);
+//     formula()->elementRemoval(child, pos);
+//     cursor->setTo(this, pos);
+//     children.remove(pos);
+//     /*
+//         if len(self.children) == 0:
+//             if self.parent != None:
+//                 self.parent.removeChild(cursor, self)
+//                 return
+//     */
+//     formula()->changed();
+// }
+
+
+/**
+ * Inserts all new children at the cursor position. Places the
+ * cursor according to the direction. The inserted elements will
+ * be selected.
+ *
+ * The list will be emptied but stays the property of the caller.
+ */
+void SequenceElement::insert(FormulaCursor* cursor,
+                             TQPtrList<BasicElement>& newChildren,
+                             Direction direction)
+{
+    int pos = cursor->getPos();
+    uint count = newChildren.count();
+    for (uint i = 0; i < count; i++) {
+        BasicElement* child = newChildren.take(0);
+        child->setParent(this);
+        children.insert(pos+i, child);
+    }
+    if (direction == beforeCursor) {
+        cursor->setTo(this, pos+count, pos);
+    }
+    else {
+        cursor->setTo(this, pos, pos+count);
+    }
+
+    formula()->changed();
+    parse();
+}
+
+
+/**
+ * Removes all selected children and returns them. Places the
+ * cursor to where the children have been.
+ *
+ * The ownership of the list is passed to the caller.
+ */
+void SequenceElement::remove(FormulaCursor* cursor,
+                             TQPtrList<BasicElement>& removedChildren,
+                             Direction direction)
+{
+    if (cursor->isSelection()) {
+        int from = cursor->getSelectionStart();
+        int to = cursor->getSelectionEnd();
+        for (int i = from; i < to; i++) {
+            removeChild(removedChildren, from);
+        }
+        cursor->setTo(this, from);
+        cursor->setSelection(false);
+    }
+    else {
+        if (direction == beforeCursor) {
+            int pos = cursor->getPos() - 1;
+            if (pos >= 0) {
+                while (pos >= 0) {
+                    BasicElement* child = children.at(pos);
+                    formula()->elementRemoval(child);
+                    children.take(pos);
+                    removedChildren.prepend(child);
+                    if (!child->isInvisible()) {
+                        break;
+                    }
+                    pos--;
+                }
+                cursor->setTo(this, pos);
+                formula()->changed();
+            }
+        }
+        else {
+            uint pos = cursor->getPos();
+            if (pos < children.count()) {
+                while (pos < children.count()) {
+                    BasicElement* child = children.at(pos);
+                    formula()->elementRemoval(child);
+                    children.take(pos);
+                    removedChildren.append(child);
+                    if (!child->isInvisible()) {
+                        break;
+                    }
+                }
+                // It is necessary to set the cursor to its old
+                // position because it got a notification and
+                // moved to the beginning of this sequence.
+                cursor->setTo(this, pos);
+                formula()->changed();
+            }
+        }
+    }
+    parse();
+}
+
+
+/**
+ * Removes the children at pos and appends it to the list.
+ */
+void SequenceElement::removeChild(TQPtrList<BasicElement>& removedChildren, int pos)
+{
+    BasicElement* child = children.at(pos);
+    formula()->elementRemoval(child);
+    children.take(pos);
+    removedChildren.append(child);
+    //cerr << *removedChildren.at(0) << endl;
+    formula()->changed();
+}
+
+
+/**
+ * Moves the cursor to a normal place where new elements
+ * might be inserted.
+ */
+void SequenceElement::normalize(FormulaCursor* cursor, Direction)
+{
+    cursor->setSelection(false);
+}
+
+
+/**
+ * Returns the child at the cursor.
+ * Does not care about the selection.
+ */
+BasicElement* SequenceElement::getChild( FormulaCursor* cursor, Direction direction )
+{
+    if ( direction == beforeCursor ) {
+        if ( cursor->getPos() > 0 ) {
+            return children.at( cursor->getPos() - 1 );
+        }
+    }
+    else {
+        if ( cursor->getPos() < tqRound( children.count() ) ) {
+            return children.at( cursor->getPos() );
+        }
+    }
+    return 0;
+}
+
+
+/**
+ * Sets the cursor to select the child. The mark is placed before,
+ * the position behind it.
+ */
+void SequenceElement::selectChild(FormulaCursor* cursor, BasicElement* child)
+{
+    int pos = children.find(child);
+    if (pos > -1) {
+        cursor->setTo(this, pos+1, pos);
+    }
+}
+
+void SequenceElement::childWillVanish(FormulaCursor* cursor, BasicElement* child)
+{
+    int childPos = children.find(child);
+    if (childPos > -1) {
+        int pos = cursor->getPos();
+        if (pos > childPos) {
+            pos--;
+        }
+        int mark = cursor->getMark();
+        if (mark > childPos) {
+            mark--;
+        }
+        cursor->setTo(this, pos, mark);
+    }
+}
+
+
+/**
+ * Selects all children. The cursor is put behind, the mark before them.
+ */
+void SequenceElement::selectAllChildren(FormulaCursor* cursor)
+{
+    cursor->setTo(this, children.count(), 0);
+}
+
+bool SequenceElement::onlyTextSelected( FormulaCursor* cursor )
+{
+    if ( cursor->isSelection() ) {
+        uint from = TQMIN( cursor->getPos(), cursor->getMark() );
+        uint to = TQMAX( cursor->getPos(), cursor->getMark() );
+        for ( uint i = from; i < to; i++ ) {
+            BasicElement* element = getChild( i );
+            if ( element->getCharacter() == TQChar::null ) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+
+KCommand* SequenceElement::buildCommand( Container* container, Request* request )
+{
+    FormulaCursor* cursor = container->activeCursor();
+    if ( cursor->isReadOnly() ) {
+        formula()->tell( i18n( "write protection" ) );
+        return 0;
+    }
+
+    switch ( *request ) {
+    case req_addText: {
+        KFCReplaceToken* command = new KFCReplaceToken( i18n("Add Text"), container );
+        TextRequest* tr = static_cast<TextRequest*>( request );
+        IdentifierElement* id = creationStrategy->createIdentifierElement();
+        command->addToken( id );
+        for ( uint i = 0; i < tr->text().length(); i++ ) {
+            TextElement* text = creationStrategy->createTextElement( tr->text()[i] );
+            command->addContent( id, text );
+        }
+        return command;
+    }
+    case req_addTextChar: {
+        KFCReplaceToken* command = new KFCReplaceToken( i18n("Add Text"), container );
+        TextCharRequest* tr = static_cast<TextCharRequest*>( request );
+        IdentifierElement* id = creationStrategy->createIdentifierElement();
+        TextElement* text = creationStrategy->createTextElement( tr->ch() );
+        command->addToken( id );
+        command->addContent( id, text );
+        return command;
+    }
+
+    case req_addOperator: {
+        KFCReplaceToken* command = new KFCReplaceToken( i18n("Add Operator"), container );
+        OperatorRequest* opr = static_cast<OperatorRequest*>( request );
+        OperatorElement* op = creationStrategy->createOperatorElement();
+        TextElement* text = creationStrategy->createTextElement( opr->ch() );
+        command->addToken( op );
+        command->addContent( op, text );
+        return command;
+    }
+
+    case req_addNumber: {
+        KFCReplaceToken* command = new KFCReplaceToken( i18n("Add Number"), container );
+        NumberRequest* nr = static_cast<NumberRequest*>( request );
+        NumberElement* num = creationStrategy->createNumberElement();
+        num->setParent( this );
+        TextElement* text = creationStrategy->createTextElement( nr->ch() );
+        text->setParent( num );
+        command->addToken( num );
+        command->addContent( num, text );
+        return command;
+    }
+
+    case req_addEmptyBox: {
+        EmptyElement* element = creationStrategy->createEmptyElement();
+        if ( element != 0 ) {
+            KFCReplace* command = new KFCReplace( i18n("Add Empty Box"), container );
+            command->addElement( element );
+            return command;
+        }
+        break;
+    }
+    case req_addNameSequence:
+        if ( onlyTextSelected( container->activeCursor() ) ) {
+            NameSequence* nameSequence = creationStrategy->createNameSequence();
+            if ( nameSequence != 0 ) {
+                KFCAddReplacing* command = new KFCAddReplacing( i18n( "Add Name" ), container );
+                command->setElement( nameSequence );
+                return command;
+            }
+        }
+        break;
+    case req_addBracket: {
+        BracketRequest* br = static_cast<BracketRequest*>( request );
+        BracketElement* bracketElement =
+            creationStrategy->createBracketElement( br->left(), br->right() );
+        if ( bracketElement != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing(i18n("Add Bracket"), container);
+            command->setElement( bracketElement );
+            return command;
+        }
+        break;
+    }
+    case req_addOverline: {
+        OverlineElement* overline = creationStrategy->createOverlineElement();
+        if ( overline != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing(i18n("Add Overline"), container);
+            command->setElement( overline );
+            return command;
+        }
+        break;
+    }
+    case req_addUnderline: {
+        UnderlineElement* underline = creationStrategy->createUnderlineElement();
+        if ( underline != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing(i18n("Add Underline"), container);
+            command->setElement( underline );
+            return command;
+        }
+        break;
+    }
+    case req_addMultiline: {
+        MultilineElement* multiline = creationStrategy->createMultilineElement();
+        if ( multiline != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing(i18n("Add Multiline"), container);
+            command->setElement( multiline );
+            return command;
+        }
+        break;
+    }
+    case req_addSpace: {
+        SpaceRequest* sr = static_cast<SpaceRequest*>( request );
+        SpaceElement* element = creationStrategy->createSpaceElement( sr->space() );
+        if ( element != 0 ) {
+            KFCReplace* command = new KFCReplace( i18n("Add Space"), container );
+            command->addElement( element );
+            return command;
+        }
+        break;
+    }
+    case req_addFraction: {
+        FractionElement* fraction = creationStrategy->createFractionElement();
+        if ( fraction != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing(i18n("Add Fraction"), container);
+            command->setElement( fraction );
+            return command;
+        }
+        break;
+    }
+    case req_addRoot: {
+        RootElement* root = creationStrategy->createRootElement();
+        if ( root != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing(i18n("Add Root"), container);
+            command->setElement( root );
+            return command;
+        }
+        break;
+    }
+    case req_addSymbol: {
+        SymbolRequest* sr = static_cast<SymbolRequest*>( request );
+        SymbolElement* symbol = creationStrategy->createSymbolElement( sr->type() );
+        if ( symbol != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing( i18n( "Add Symbol" ), container );
+            command->setElement( symbol );
+            return command;
+        }
+        break;
+    }
+    case req_addOneByTwoMatrix: {
+        FractionElement* element = creationStrategy->createFractionElement();
+        if ( element != 0 ) {
+            KFCAddReplacing* command = new KFCAddReplacing( i18n("Add 1x2 Matrix"), container );
+            element->showLine(false);
+            command->setElement(element);
+            return command;
+        }
+    }
+    case req_addMatrix: {
+        MatrixRequest* mr = static_cast<MatrixRequest*>( request );
+        uint rows = mr->rows(), cols = mr->columns();
+        if ( ( rows == 0 ) || ( cols == 0 ) ) {
+            MatrixDialog* dialog = new MatrixDialog( 0 );
+            if ( dialog->exec() ) {
+                rows = dialog->h;
+                cols = dialog->w;
+            }
+            delete dialog;
+        }
+
+        if ( ( rows != 0 ) && ( cols != 0 ) ) {
+            KFCAddReplacing* command = new KFCAddReplacing( i18n( "Add Matrix" ), container );
+            command->setElement( creationStrategy->createMatrixElement( rows, cols ) );
+            return command;
+        }
+        else
+            return 0L;
+    }
+    case req_addIndex: {
+        if ( cursor->getPos() > 0 && !cursor->isSelection() ) {
+            IndexElement* element =
+                dynamic_cast<IndexElement*>( children.at( cursor->getPos()-1 ) );
+            if ( element != 0 ) {
+                element->goInside( cursor );
+                return element->buildCommand( container, request );
+            }
+        }
+        IndexElement* element = creationStrategy->createIndexElement();
+        if ( element != 0 ) {
+            if ( !cursor->isSelection() ) {
+                cursor->moveLeft( SelectMovement | WordMovement );
+            }
+            IndexRequest* ir = static_cast<IndexRequest*>( request );
+            KFCAddIndex* command = new KFCAddIndex( container, element,
+                                                    element->getIndex( ir->index() ) );
+            return command;
+        }
+        break;
+    }
+    case req_removeEnclosing: {
+        if ( !cursor->isSelection() ) {
+            DirectedRemove* dr = static_cast<DirectedRemove*>( request );
+            KFCRemoveEnclosing* command = new KFCRemoveEnclosing( container, dr->direction() );
+            return command;
+        }
+    }
+    case req_remove: {
+        SequenceElement* sequence = cursor->normal();
+        if ( sequence &&
+             ( sequence == sequence->formula() ) &&
+             ( sequence->countChildren() == 0 ) ) {
+            sequence->formula()->removeFormula( cursor );
+            return 0;
+        }
+        else {
+            DirectedRemove* dr = static_cast<DirectedRemove*>( request );
+
+            // empty removes are not legal!
+            if ( !cursor->isSelection() ) {
+                if ( countChildren() > 0 ) {
+                    if ( ( cursor->getPos() == 0 ) && ( dr->direction() == beforeCursor ) ) {
+                        return 0;
+                    }
+                    if ( ( cursor->getPos() == countChildren() ) && ( dr->direction() == afterCursor ) ) {
+                        return 0;
+                    }
+                }
+                else if ( getParent() == 0 ) {
+                    return 0;
+                }
+            }
+
+            KFCRemove* command = new KFCRemove( container, dr->direction() );
+            return command;
+        }
+    }
+    case req_compactExpression: {
+        cursor->moveEnd();
+        cursor->moveRight();
+        formula()->cursorHasMoved( cursor );
+        break;
+    }
+    case req_makeGreek: {
+        TextElement* element = cursor->getActiveTextElement();
+        if ((element != 0) && !element->isSymbol()) {
+            cursor->selectActiveElement();
+            const SymbolTable& table = container->document()->getSymbolTable();
+            if (table.greekLetters().find(element->getCharacter()) != -1) {
+                KFCReplace* command = new KFCReplace( i18n( "Change Char to Symbol" ), container );
+                TextElement* symbol = creationStrategy->createTextElement( table.unicodeFromSymbolFont( element->getCharacter() ), true );
+                command->addElement( symbol );
+                return command;
+            }
+            cursor->setSelection( false );
+        }
+        break;
+    }
+    case req_paste:
+    case req_copy:
+    case req_cut:
+        break;
+    case req_formatBold:
+    case req_formatItalic: {
+        if ( cursor->isSelection() ) {
+            CharStyleRequest* csr = static_cast<CharStyleRequest*>( request );
+            CharStyle cs = normalChar;
+            if ( csr->bold() ) cs = static_cast<CharStyle>( cs | boldChar );
+            if ( csr->italic() ) cs = static_cast<CharStyle>( cs | italicChar );
+            CharStyleCommand* cmd = new CharStyleCommand( cs, i18n( "Change Char Style" ), container );
+            int end = cursor->getSelectionEnd();
+            for ( int i = cursor->getSelectionStart(); i<end; ++i ) {
+                cmd->addElement( children.at( i ) );
+            }
+            return cmd;
+        }
+        break;
+    }
+    case req_formatFamily: {
+        if ( cursor->isSelection() ) {
+            CharFamilyRequest* cfr = static_cast<CharFamilyRequest*>( request );
+            CharFamily cf = cfr->charFamily();
+            CharFamilyCommand* cmd = new CharFamilyCommand( cf, i18n( "Change Char Family" ), container );
+            int end = cursor->getSelectionEnd();
+            for ( int i = cursor->getSelectionStart(); i<end; ++i ) {
+                cmd->addElement( children.at( i ) );
+            }
+            return cmd;
+        }
+        break;
+    }
+    default:
+        break;
+    }
+    return 0;
+}
+
+
+KCommand* SequenceElement::input( Container* container, TQKeyEvent* event )
+{
+    TQChar ch = event->text().at( 0 );
+    if ( ch.isPrint() ) {
+        return input( container, ch );
+    }
+    else {
+        int action = event->key();
+        int state = event->state();
+        MoveFlag flag = movementFlag(state);
+
+	switch ( action ) {
+        case TQt::Key_BackSpace: {
+            DirectedRemove r( req_remove, beforeCursor );
+            return buildCommand( container, &r );
+        }
+        case TQt::Key_Delete: {
+            DirectedRemove r( req_remove, afterCursor );
+            return buildCommand( container, &r );
+        }
+	case TQt::Key_Left: {
+            FormulaCursor* cursor = container->activeCursor();
+            cursor->moveLeft( flag );
+            formula()->cursorHasMoved( cursor );
+            break;
+        }
+        case TQt::Key_Right: {
+            FormulaCursor* cursor = container->activeCursor();
+            cursor->moveRight( flag );
+            formula()->cursorHasMoved( cursor );
+            break;
+        }
+        case TQt::Key_Up: {
+            FormulaCursor* cursor = container->activeCursor();
+            cursor->moveUp( flag );
+            formula()->cursorHasMoved( cursor );
+            break;
+        }
+        case TQt::Key_Down: {
+            FormulaCursor* cursor = container->activeCursor();
+            cursor->moveDown( flag );
+            formula()->cursorHasMoved( cursor );
+            break;
+        }
+        case TQt::Key_Home: {
+            FormulaCursor* cursor = container->activeCursor();
+            cursor->moveHome( flag );
+            formula()->cursorHasMoved( cursor );
+            break;
+        }
+        case TQt::Key_End: {
+            FormulaCursor* cursor = container->activeCursor();
+            cursor->moveEnd( flag );
+            formula()->cursorHasMoved( cursor );
+            break;
+        }
+        default:
+            if ( state & TQt::ControlButton ) {
+                switch ( event->key() ) {
+                case TQt::Key_AsciiCircum: {
+                    IndexRequest r( upperLeftPos );
+                    return buildCommand( container, &r );
+                }
+                case TQt::Key_Underscore: {
+                    IndexRequest r( lowerLeftPos );
+                    return buildCommand( container, &r );
+                }
+                default:
+                    break;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+
+KCommand* SequenceElement::input( Container* container, TQChar ch )
+{
+    int unicode = ch.unicode();
+    switch (unicode) {
+    case '(': {
+        BracketRequest r( container->document()->leftBracketChar(),
+                          container->document()->rightBracketChar() );
+        singlePipe = true;
+        return buildCommand( container, &r );
+    }
+    case '[': {
+        BracketRequest r( LeftSquareBracket, RightSquareBracket );
+        singlePipe = true;
+        return buildCommand( container, &r );
+    }
+    case '{': {
+        BracketRequest r( LeftCurlyBracket, RightCurlyBracket );
+        singlePipe = true;
+        return buildCommand( container, &r );
+    }
+    case '|': {	
+        if (!singlePipe) { // We have had 2 '|' in a row so we want brackets
+
+          DirectedRemove rDelete( req_remove, beforeCursor ); //Delete the previous '|' we dont need it any more
+          KCommand* command = buildCommand( container, &rDelete );
+          command->execute();
+          
+          BracketRequest rBracket( LeftLineBracket , RightLineBracket);
+          singlePipe = true;  //the next '|' will be a single pipe again
+          return buildCommand( container, &rBracket );    
+        }
+        else { // We really do only want 1 '|'
+          TextCharRequest r(ch);
+
+          //in case another '|' character is entered right after this one, '| |' brackets are made; see above
+          singlePipe = false;
+
+          return buildCommand( container, &r );   
+        }
+    }
+    case '^': {
+        IndexRequest r( upperRightPos );
+        singlePipe = true;
+        return buildCommand( container, &r );
+    }
+    case '_': {
+        IndexRequest r( lowerRightPos );
+        singlePipe = true;
+        return buildCommand( container, &r );
+    }
+        /*
+    case ' ': {
+        Request r( req_compactExpression );
+        singlePipe = true;
+        return buildCommand( container, &r );
+        }*/
+    case '}': {
+        Request r( req_addEmptyBox );
+        singlePipe = true;
+        return buildCommand( container, &r );
+    }
+    case ']':
+    case ')':
+        singlePipe = true; 
+        break;
+    case '\\': {
+        Request r( req_addNameSequence );
+        singlePipe = true;
+        return buildCommand( container, &r );
+    }
+    default: {
+        singlePipe = true;
+        if ( ch.isPunct() || ch.isSymbol() ) {
+            OperatorRequest r( ch );
+            return buildCommand( container, &r );
+        }
+        if ( ch.isNumber() ) {
+            NumberRequest r( ch );
+            return buildCommand( container, &r );
+        }
+        TextCharRequest r( ch );
+        return buildCommand( container, &r );
+    }
+    }
+    return 0;
+}
+
+/**
+ * Stores the given childrens dom in the element.
+ */
+void SequenceElement::getChildrenDom( TQDomDocument& doc, TQDomElement elem,
+                                     uint from, uint to)
+{
+    for (uint i = from; i < to; i++) {
+        TQDomElement tmpEleDom=children.at(i)->getElementDom(doc);
+        elem.appendChild(tmpEleDom);
+    }
+}
+
+/**
+ * Stores the given childrens MathML dom in the element.
+ */
+void SequenceElement::getChildrenMathMLDom( TQDomDocument& doc, TQDomNode& parent,
+                                            uint from, uint to)
+{
+    for ( uint i = from; i < to; i++ ) {
+        children.at( i )->writeMathML( doc, parent, false );
+    }
+}
+
+
+/**
+ * Builds elements from the given node and its siblings and
+ * puts them into the list.
+ * Returns false if an error occures.
+ */
+bool SequenceElement::buildChildrenFromDom(TQPtrList<BasicElement>& list, TQDomNode n)
+{
+    while (!n.isNull()) {
+        if (n.isElement()) {
+            TQDomElement e = n.toElement();
+            BasicElement* child = 0;
+            TQString tag = e.tagName().upper();
+
+            child = createElement(tag, e);
+            if (child != 0) {
+                child->setParent(this);
+                if (child->buildFromDom(e)) {
+                    list.append(child);
+                }
+                else {
+                    delete child;
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        n = n.nextSibling();
+    }
+    parse();
+    return true;
+}
+
+
+BasicElement* SequenceElement::createElement( TQString type, const TQDomElement& element )
+{
+    return creationStrategy->createElement( type, element );
+}
+
+/**
+ * Appends our attributes to the dom element.
+ */
+void SequenceElement::writeDom(TQDomElement element)
+{
+    BasicElement::writeDom(element);
+
+    uint count = children.count();
+    TQDomDocument doc = element.ownerDocument();
+    getChildrenDom(doc, element, 0, count);
+}
+
+/**
+ * Reads our attributes from the element.
+ * Returns false if it failed.
+ */
+bool SequenceElement::readAttributesFromDom(TQDomElement element)
+{
+    if (!BasicElement::readAttributesFromDom(element)) {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Reads our content from the node. Sets the node to the next node
+ * that needs to be read.
+ * Returns false if it failed.
+ */
+bool SequenceElement::readContentFromDom(TQDomNode& node)
+{
+    if (!BasicElement::readContentFromDom(node)) {
+        return false;
+    }
+
+    return buildChildrenFromDom(children, node);
+}
+
+
+void SequenceElement::parse()
+{
+    delete parseTree;
+
+    textSequence = true;
+    for (BasicElement* element = children.first();
+         element != 0;
+         element = children.next()) {
+
+        // Those types are gone. Make sure they won't
+        // be used.
+        element->setElementType(0);
+
+        if (element->getCharacter().isNull()) {
+            textSequence = false;
+        }
+    }
+
+    const SymbolTable& symbols = formula()->getSymbolTable();
+    SequenceParser parser(symbols);
+    parseTree = parser.parse(children);
+
+    // With the IndexElement dynamically changing its text/non-text
+    // behaviour we need to reparse your parent, too. Hacky!
+    BasicElement* p = getParent();
+    if ( p != 0 ) {
+        SequenceElement* seq = dynamic_cast<SequenceElement*>( p->getParent() );
+        if ( seq != 0 ) {
+            seq->parse();
+        }
+    }
+    // debug
+    //parseTree->output();
+}
+
+
+bool SequenceElement::isFirstOfToken( BasicElement* child )
+{
+    return ( child->getElementType() != 0 ) && isChildNumber( child->getElementType()->start(), child );
+}
+
+
+TQString SequenceElement::toLatex()
+{
+    TQString content;
+    uint count = children.count();
+    for ( uint i = 0; i < count; i++ ) {
+        BasicElement* child = children.at( i );
+//         if ( isFirstOfToken( child ) ) {
+//             content += "";
+//         }
+        content += child->toLatex();
+    }
+    return content;
+}
+
+
+TQString SequenceElement::formulaString()
+{
+    TQString content;
+    uint count = children.count();
+    for ( uint i = 0; i < count; i++ ) {
+        BasicElement* child = children.at( i );
+        //if ( isFirstOfToken( child ) ) {
+        //    content += " ";
+        //}
+        content += child->formulaString();
+    }
+    return content;
+}
+
+
+void SequenceElement::writeMathMLContent( TQDomDocument& doc, TQDomElement& element, bool oasisFormat ) const
+{
+    for ( TQPtrListIterator<BasicElement> it( children ); it.current(); ++it ) {
+        it.current()->writeMathML( doc, element, oasisFormat );
+    }
+}
+
+
+const BasicElement* SequenceElement::getChild( uint i ) const
+{
+    TQPtrListIterator<BasicElement> it( children );
+    it += i;
+    return it.current();
+}
+
+
+int SequenceElement::childPos( const BasicElement* child ) const
+{
+    TQPtrListIterator<BasicElement> it( children );
+    uint count = it.count();
+    for ( uint i=0; i<count; ++i, ++it ) {
+        if ( it.current() == child ) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+
+NameSequence::NameSequence( BasicElement* parent )
+    : SequenceElement( parent )
+{
+}
+
+
+bool NameSequence::accept( ElementVisitor* visitor )
+{
+    return visitor->visit( this );
+}
+
+
+void NameSequence::calcCursorSize( const ContextStyle& context,
+                                   FormulaCursor* cursor, bool smallCursor )
+{
+    inherited::calcCursorSize( context, cursor, smallCursor );
+    LuPixelPoint point = widgetPos();
+    luPixel unitX = context.ptToLayoutUnitPixX( 1 );
+    luPixel unitY = context.ptToLayoutUnitPixY( 1 );
+    cursor->addCursorSize( LuPixelRect( point.x()-unitX, point.y()-unitY,
+                                        getWidth()+2*unitX, getHeight()+2*unitY ) );
+}
+
+void NameSequence::drawCursor( TQPainter& painter, const ContextStyle& context,
+                               StyleAttributes& style, FormulaCursor* cursor,
+                               bool smallCursor, bool activeCursor )
+{
+    LuPixelPoint point = widgetPos();
+    painter.setPen( TQPen( context.getEmptyColor(),
+                          context.layoutUnitToPixelX( context.getLineWidth( style.sizeFactor() )/2 ) ) );
+    luPixel unitX = context.ptToLayoutUnitPixX( 1 );
+    luPixel unitY = context.ptToLayoutUnitPixY( 1 );
+    painter.drawRect( context.layoutUnitToPixelX( point.x()-unitX ),
+                      context.layoutUnitToPixelY( point.y()-unitY ),
+                      context.layoutUnitToPixelX( getWidth()+2*unitX ),
+                      context.layoutUnitToPixelY( getHeight()+2*unitY ) );
+
+    inherited::drawCursor( painter, context, style, cursor, smallCursor, activeCursor );
+}
+
+void NameSequence::moveWordLeft( FormulaCursor* cursor )
+{
+    uint pos = cursor->getPos();
+    if ( pos > 0 ) {
+        cursor->setTo( this, 0 );
+    }
+    else {
+        moveLeft( cursor, this );
+    }
+}
+
+void NameSequence::moveWordRight( FormulaCursor* cursor )
+{
+    int pos = cursor->getPos();
+    if ( pos < countChildren() ) {
+        cursor->setTo( this, countChildren() );
+    }
+    else {
+        moveRight( cursor, this );
+    }
+}
+
+
+KCommand* NameSequence::compactExpressionCmd( Container* container )
+{
+    BasicElement* element = replaceElement( container->document()->getSymbolTable() );
+    if ( element != 0 ) {
+        getParent()->selectChild( container->activeCursor(), this );
+
+        KFCReplace* command = new KFCReplace( i18n( "Add Element" ), container );
+        command->addElement( element );
+        return command;
+    }
+    return 0;
+}
+
+KCommand* NameSequence::buildCommand( Container* container, Request* request )
+{
+    switch ( *request ) {
+    case req_compactExpression:
+        return compactExpressionCmd( container );
+    case req_addSpace:
+    case req_addIndex:
+    case req_addMatrix:
+    case req_addOneByTwoMatrix:
+    case req_addSymbol:
+    case req_addRoot:
+    case req_addFraction:
+    case req_addBracket:
+    case req_addNameSequence:
+        return 0;
+    default:
+        break;
+    }
+    return inherited::buildCommand( container, request );
+}
+
+
+KCommand* NameSequence::input( Container* container, TQChar ch )
+{
+    int unicode = ch.unicode();
+    switch (unicode) {
+    case '(':
+    case '[':
+    case '|':
+    case '^':
+    case '_':
+    case '}':
+    case ']':
+    case ')':
+    case '\\': {
+//         KCommand* compact = compactExpressionCmd( container );
+//         KCommand* cmd = static_cast<SequenceElement*>( getParent() )->input( container, ch );
+//         if ( compact != 0 ) {
+//             KMacroCommand* macro = new KMacroCommand( cmd->name() );
+//             macro->addCommand( compact );
+//             macro->addCommand( cmd );
+//             return macro;
+//         }
+//         else {
+//             return cmd;
+//         }
+        break;
+    }
+    case '{':
+    case ' ': {
+        Request r( req_compactExpression );
+        return buildCommand( container, &r );
+    }
+    default: {
+        TextCharRequest r( ch );
+        return buildCommand( container, &r );
+    }
+    }
+    return 0;
+}
+
+void NameSequence::setElementType( ElementType* t )
+{
+    inherited::setElementType( t );
+    parse();
+}
+
+BasicElement* NameSequence::replaceElement( const SymbolTable& table )
+{
+    TQString name = buildName();
+    TQChar ch = table.unicode( name );
+    if ( !ch.isNull() ) {
+        return new TextElement( ch, true );
+    }
+    else {
+        ch = table.unicode( i18n( name.latin1() ) );
+        if ( !ch.isNull() ) {
+            return new TextElement( ch, true );
+        }
+    }
+
+    if ( name == "!" )    return new SpaceElement( NEGTHIN );
+    if ( name == "," )    return new SpaceElement( THIN );
+    if ( name == ">" )    return new SpaceElement( MEDIUM );
+    if ( name == ";" )    return new SpaceElement( THICK );
+    if ( name == "quad" ) return new SpaceElement( QUAD );
+
+    if ( name == "frac" ) return new FractionElement();
+    if ( name == "atop" ) {
+        FractionElement* frac = new FractionElement();
+        frac->showLine( false );
+        return frac;
+    }
+    if ( name == "sqrt" ) return new RootElement();
+
+    return 0;
+}
+
+BasicElement* NameSequence::createElement( TQString type )
+{
+    if      ( type == "TEXT" )         return new TextElement();
+    return 0;
+}
+
+// void NameSequence::parse()
+// {
+//     // A name sequence is known as name and so are its children.
+//     // Caution: this is fake!
+//     for ( int i = 0; i < countChildren(); i++ ) {
+//         getChild( i )->setElementType( getElementType() );
+//     }
+// }
+
+TQString NameSequence::buildName()
+{
+    TQString name;
+    for ( uint i = 0; i < countChildren(); i++ ) {
+        name += getChild( i )->getCharacter();
+    }
+    return name;
+}
+
+bool NameSequence::isValidSelection( FormulaCursor* cursor )
+{
+    SequenceElement* sequence = cursor->normal();
+    if ( sequence == 0 ) {
+        return false;
+    }
+    return sequence->onlyTextSelected( cursor );
+}
+
+int SequenceElement::buildChildrenFromMathMLDom(TQPtrList<BasicElement>& list, TQDomNode n) 
+{
+    while (!n.isNull()) {
+        int nodeNumber = 1;
+        if (n.isElement()) {
+            TQDomElement e = n.toElement();
+            BasicElement* child = 0;
+            TQString tag = e.tagName().lower();
+
+			kdDebug( DEBUGID ) << "Sequence Tag: " << tag << endl;
+            if ( tag == "semantics" ) { // Special case, just pick the first child
+                TQDomNode node = e.firstChild();
+                while( ! node.isElement() ) {
+                    node = node.nextSibling();
+                    if ( node.isNull() ) {
+                        return -1;
+                    }
+                }
+                e = node.toElement();
+                tag = e.tagName().lower();
+            }
+            child = creationStrategy->createElement(tag, e);
+            if (child != 0) {
+                child->setParent(this);
+                if (style != 0) {
+                    child->setStyle(style);
+                }
+                nodeNumber = child->buildFromMathMLDom( e );
+                if ( nodeNumber != -1 ) {
+                    list.append(child);
+                }
+                else {
+                    delete child;
+                    return -1;
+                }
+            }
+            else {
+                kdWarning() << "Unsupported MathML element: " << tag << endl;
+            }
+        }
+        for (int i = 0; i < nodeNumber; i++ ) {
+            if ( n.isNull() ) {
+                return -1;
+            }
+            n = n.nextSibling();
+        }
+    }
+    // Operator elements inside a sequence have to be parsed to get proper form
+    // value. Form value is needed to access operator dictionary and has to be
+    // obtained after sequence parsing since its value depends on position
+    // inside the sequence.
+
+    // If the sequence contains more than one element, if the first or last
+    // element are operators, they have to be marked differently
+    if ( list.count() > 1 ) {
+        if ( list.getFirst()->getElementName() == "mo" ) {
+            static_cast<OperatorElement*>( list.getFirst() )->setForm( PrefixForm );
+        }
+        if ( list.getLast()->getElementName() == "mo" ) {
+            static_cast<OperatorElement*>( list.getLast() )->setForm( PostfixForm );
+        }
+        for ( uint i = 1; i < list.count() - 1; i++ ) {
+            if ( list.at( i )->getElementName() == "mo" ) {
+                static_cast<OperatorElement*>( list.at( i ) )->setForm( InfixForm );
+            }
+        }
+    }
+    else if ( list.count() == 1 ) {
+        if ( list.getFirst()->getElementName() == "mo" ) {
+            static_cast<OperatorElement*>( list.getFirst() )->setForm( InfixForm );
+        }
+    }
+	parse();
+    return 1;
+}
+
+/**
+ */
+int SequenceElement::readContentFromMathMLDom(TQDomNode& node)
+{
+    if ( BasicElement::readContentFromMathMLDom(node) == -1 ) {
+        return -1;
+    }
+
+    return buildChildrenFromMathMLDom(children, node);
+}
+
+int SequenceElement::buildMathMLChild( TQDomNode node )
+{
+    int nodeCounter = 1;
+    while ( ! node.isElement() ) {
+        node = node.nextSibling();
+        nodeCounter++;
+        if ( node.isNull() ) {
+            return -1;
+        }
+    }
+    TQDomElement e = node.toElement();
+    BasicElement* child = 0;
+    TQString tag = e.tagName().lower();
+
+    child = creationStrategy->createElement(tag, e);
+    if (child != 0) {
+        child->setParent(this);
+        if (style != 0) {
+            child->setStyle(style);
+        }
+        if (child->buildFromMathMLDom(e) != -1) {
+            children.append(child);
+        }
+        else {
+            delete child;
+            return -1;
+        }
+    }
+    else {
+        return -1;
+    }
+    parse();
+    return nodeCounter;
+}
+
+
+
+KFORMULA_NAMESPACE_END