formulacursor.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 FORMULACURSOR_H
#define FORMULACURSOR_H
 
#include <tqstring.h>
 
#include "basicelement.h"
#include "kformuladefs.h"
 
KFORMULA_NAMESPACE_BEGIN
 
class FormulaElement;
class IndexElement;
class MatrixElement;
class NameSequence;
class RootElement;
class SymbolElement;
class TextElement;
 
 
class FormulaCursor {
 
    // Yes, we do have a friend.
    friend class SequenceElement;
 
public:
 
    FormulaCursor(FormulaElement* element);
 
    FormulaCursor& operator= (const FormulaCursor&);
 
    // where the cursor and the mark are
    uint getPos() const { return cursorPos; }
    int getMark() const { return markPos; }
 
    bool hasChanged() const { return hasChangedFlag; }
 
    void clearChangedFlag() { hasChangedFlag = false; }
 
    bool isSelectionMode() const { return selectionFlag; }
 
    bool isSelection() const { return selectionFlag && (getPos() != getMark()); }
 
    void setSelection(bool selection) { selectionFlag = selection; hasChangedFlag = true; }
 
    void calcCursorSize( const ContextStyle& context, bool smallCursor );
 
    void draw( TQPainter&, const ContextStyle& context, StyleAttributes& style,
               bool smallCursor, bool activeCursor );
 
 
    // simple cursor movement.
 
    void moveLeft(int flag = NormalMovement);
    void moveRight(int flag = NormalMovement);
    void moveUp(int flag = NormalMovement);
    void moveDown(int flag = NormalMovement);
 
    void moveHome(int flag = NormalMovement);
    void moveEnd(int flag = NormalMovement);
 
    bool isHome() const;
 
    bool isEnd() const;
 
    // how to travel
 
    bool getLinearMovement() const { return linearMovement; }
 
    void setLinearMovement(bool linear) { linearMovement = linear; }
 
    void goInsideElement(BasicElement* element);
 
    // mouse selection
 
    void mousePress( const LuPixelPoint&, int flags );
    void mouseMove( const LuPixelPoint&, int flags );
    void mouseRelease( const LuPixelPoint&, int flags );
 
    void insert(BasicElement*, Direction = beforeCursor);
 
    void insert(TQPtrList<BasicElement>&,
                Direction = beforeCursor);
 
    void remove(TQPtrList<BasicElement>&,
                Direction = beforeCursor);
 
 
    void replaceSelectionWith(BasicElement*,
                              Direction = beforeCursor);
 
    BasicElement* replaceByMainChildContent(Direction = beforeCursor);
 
    BasicElement* removeEnclosingElement(Direction = beforeCursor);
 
    bool elementIsSenseless();
 
 
    // The range that is selected. Makes no sense if there is
    // no selection.
 
    int getSelectionStart() const { return TQMIN(getPos(), getMark()); }
    int getSelectionEnd() const { return TQMAX(getPos(), getMark()); }
 
 
    void setTo(BasicElement* element, uint cursor, int mark=-1);
 
    void setPos(uint pos);
    void setMark(int mark);
 
 
    BasicElement* getElement() { return current; }
    const BasicElement* getElement() const { return current; }
 
 
    void normalize(Direction direction = beforeCursor);
 
 
    SequenceElement* normal();
    const SequenceElement* normal() const;
 
    IndexElement* getActiveIndexElement();
 
    RootElement* getActiveRootElement();
 
    SymbolElement* getActiveSymbolElement();
 
    NameSequence* getActiveNameSequence();
 
    TextElement* getActiveTextElement();
 
    MatrixElement* getActiveMatrixElement();
 
    void selectActiveElement();
 
    void copy( TQDomDocument& doc );
 
    bool buildElementsFromDom( TQDomElement root, TQPtrList<BasicElement>& list );
 
    bool buildElementsFromMathMLDom( TQDomElement root, TQPtrList<BasicElement>& list );
 
    // undo/redo support
 
    class CursorData {
        friend class FormulaCursor;
        BasicElement* current;
        uint cursorPos;
        int markPos;
        bool selectionFlag;
        bool linearMovement;
        bool readOnly;
 
        CursorData(BasicElement* c,
                   uint pos, int mark, bool selection, bool linear, bool ro)
            : current(c), cursorPos(pos), markPos(mark),
              selectionFlag(selection), linearMovement(linear),
              readOnly(ro) {}
    };
 
    CursorData* getCursorData();
 
    void setCursorData(CursorData* data);
 
    void elementWillVanish(BasicElement* element);
 
    void formulaLoaded(FormulaElement* rootElement);
 
    const LuPixelPoint& getCursorPoint() const { return cursorPoint; }
 
    const LuPixelRect& getCursorSize() const { return cursorSize; }
    void addCursorSize( const LuPixelRect& rect ) { cursorSize |= rect; }
 
    bool isReadOnly() const;
 
    void setReadOnly(bool ro) { readOnly = ro; }
 
private:
 
    BasicElement* getActiveChild(Direction direction);
 
    BasicElement* getSelectedChild();
 
    bool pointsAfterMainChild(BasicElement*);
 
    void handleSelectState(int flag);
 
 
    BasicElement* current;
 
    uint cursorPos;
 
    int markPos;
 
    bool selectionFlag;
 
    bool linearMovement;
 
    LuPixelPoint cursorPoint;
 
    LuPixelRect cursorSize;
 
    bool hasChangedFlag;
 
    bool readOnly;
};
 
KFORMULA_NAMESPACE_END
 
#endif // FORMULACURSOR_H