kformulacommand.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 KFORMULACOMMAND_H
#define KFORMULACOMMAND_H
 
#include <tqmap.h>
#include <tqptrlist.h>
#include <tqptrdict.h>
#include <tqvaluevector.h>
 
#include <kcommand.h>
 
#include "fontstyle.h"
#include "kformulacontainer.h"
#include "formulacursor.h"
 
KFORMULA_NAMESPACE_BEGIN
 
 
class PlainCommand : public KNamedCommand
{
public:
 
    PlainCommand(const TQString& name);
    virtual ~PlainCommand();
 
    static int getEvilDestructionCount() { return evilDestructionCount; }
 
private:
 
    // debug
    static int evilDestructionCount;
};
 
 
class Command : public PlainCommand
{
public:
 
    Command(const TQString& name, Container* document);
    virtual ~Command();
 
protected:
 
    FormulaCursor* getExecuteCursor();
 
    FormulaCursor* getUnexecuteCursor();
 
    void setExecuteCursor(FormulaCursor* cursor);
 
    void setUnexecuteCursor(FormulaCursor* cursor);
 
    FormulaCursor* getActiveCursor() { return doc->activeCursor(); }
 
    void testDirty() { doc->testDirty(); }
 
    Container* getDocument() const { return doc; }
 
private:
 
    void destroyUndoCursor() { delete undocursor; undocursor = 0; }
 
    FormulaCursor::CursorData* cursordata;
 
    FormulaCursor::CursorData* undocursor;
 
    Container* doc;
};
 
 
class KFCAdd : public Command
{
public:
 
    KFCAdd(const TQString &name, Container* document);
 
    virtual void execute();
    virtual void unexecute();
 
    void addElement(BasicElement* element) { addList.append(element); }
 
private:
 
    TQPtrList<BasicElement> addList;
};
 
 
class KFCRemoveSelection : public Command
{
public:
 
    KFCRemoveSelection(Container* document,
                       Direction dir = beforeCursor);
 
    virtual void execute();
    virtual void unexecute();
 
private:
 
    TQPtrList<BasicElement> removedList;
 
    Direction dir;
};
 
 
class KFCReplace : public KFCAdd
{
public:
 
    KFCReplace(const TQString &name, Container* document);
    ~KFCReplace();
 
    virtual void execute();
    virtual void unexecute();
 
private:
 
    KFCRemoveSelection* removeSelection;
};
 
class KFCAddToken : public Command
{
public:
    KFCAddToken( const TQString &name, Container *document);
    ~KFCAddToken();
 
    virtual void execute();
    virtual void unexecute();
 
    void addToken( BasicElement* element );
 
    void addContent( BasicElement* element, BasicElement* content ) { 
        contentList.find( element )->append( content ); 
    }
 
 
private:
 
    TQPtrList< BasicElement > tokenList;
 
    TQPtrDict< TQPtrList< BasicElement > > contentList;
};
 
class KFCReplaceToken : public KFCAddToken
{
public:
 
    KFCReplaceToken(const TQString &name, Container* document);
    ~KFCReplaceToken();
 
    virtual void execute();
    virtual void unexecute();
 
private:
 
    KFCRemoveSelection* removeSelection;
 
};
 
 
class KFCSplitToken : public KFCAddToken
{
public:
 
    KFCSplitToken(const TQString &name, Container* document);
    ~KFCSplitToken();
 
    virtual void execute();
    virtual void unexecute();
 
    void addCursor( FormulaCursor* cursor ) { setExecuteCursor( cursor ); }
 
private:
 
    KFCRemoveSelection* removeSelection;
 
    TQPtrList< BasicElement > splitList;
 
    FormulaCursor::CursorData* splitCursor;
};
 
 
class KFCRemove : public Command
{
public:
 
    KFCRemove(Container* document, Direction dir);
    ~KFCRemove();
 
    virtual void execute();
    virtual void unexecute();
 
    //virtual bool isSenseless() { return removedList.isEmpty(); }
 
private:
 
    TQPtrList<BasicElement> removedList;
 
    BasicElement* element;
 
    FormulaCursor::CursorData* simpleRemoveCursor;
 
    Direction dir;
};
 
 
class KFCRemoveEnclosing : public Command
{
public:
    KFCRemoveEnclosing(Container* document, Direction dir);
    ~KFCRemoveEnclosing();
 
    virtual void execute();
    virtual void unexecute();
 
private:
    BasicElement* element;
 
    Direction direction;
};
 
 
class KFCAddReplacing : public Command
{
public:
    KFCAddReplacing(const TQString &name, Container* document);
    ~KFCAddReplacing();
 
    virtual void execute();
    virtual void unexecute();
 
    void setElement(BasicElement* e) { element = e; }
 
private:
 
    BasicElement* element;
};
 
 
class KFCAddGenericIndex : public KFCAdd
{
public:
 
    KFCAddGenericIndex(Container* document, ElementIndexPtr &index);
    KFCAddGenericIndex(KFCAddGenericIndex const &) = delete;
    KFCAddGenericIndex& operator=(KFCAddGenericIndex const &) = delete;
 
    virtual void execute();
 
private:
    ElementIndexPtr index;
};
 
 
class IndexElement;
 
class KFCAddIndex : public KFCAddReplacing
{
public:
 
    KFCAddIndex(Container* document, IndexElement* element, ElementIndexPtr index);
    ~KFCAddIndex();
 
    virtual void execute();
    virtual void unexecute();
 
private:
    KFCAddGenericIndex addIndex;
};
 
 
class FormulaElement;
 
class KFCChangeBaseSize : public PlainCommand {
public:
    KFCChangeBaseSize( const TQString& name, Container* document, FormulaElement* formula, int size );
 
    void execute();
    void unexecute();
 
private:
    Container* m_document;
    FormulaElement* m_formula;
    int m_size;
    int m_oldSize;
};
 
 
class FontCommand : public Command {
public:
    FontCommand( const TQString& name, Container* document );
 
    void addTextElement( TextElement* element ) { list.append(element); }
 
    void addElement( BasicElement* element ) { elementList.append( element ); }
 
protected:
 
    TQPtrList<TextElement>& childrenList() { return list; }
 
    void collectChildren();
 
    void parseSequences( const TQMap<SequenceElement*, int>& parents );
 
private:
 
    TQPtrList<TextElement> list;
 
    TQPtrList<BasicElement> elementList;
};
 
 
class CharStyleCommand : public FontCommand {
public:
    CharStyleCommand( CharStyle cs, const TQString& name, Container* document );
 
    virtual void execute();
    virtual void unexecute();
 
private:
 
    typedef TQValueVector<CharStyle> StyleList;
 
    StyleList styleList;
    CharStyle charStyle;
};
 
 
class CharFamilyCommand : public FontCommand {
public:
    CharFamilyCommand( CharFamily cf, const TQString& name, Container* document );
 
    virtual void execute();
    virtual void unexecute();
 
private:
 
    typedef TQValueVector<CharFamily> FamilyList;
 
    FamilyList familyList;
    CharFamily charFamily;
};
 
 
KFORMULA_NAMESPACE_END
 
#endif // KFORMULACOMMAND_H