F:/KPlato/koffice/libs/kformula/kformulacommand.h

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2001 Andrea Rizzi <rizzi@kde.org>
                      Ulrich Kuettler <ulrich.kuettler@mailbox.tu-dresden.de>
                 2006 Martin Pfeiffer <hubipete@gmx.net>

   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 <QMap>
#include <QList>
#include <QVector>

#include <kcommand.h>

#include "fontstyle.h"
#include "FormulaContainer.h"
#include "FormulaCursor.h"

namespace KFormula {

class TextElement;
class MatrixElement;
class MatrixRowElement;
class MatrixEntryElement;

class KOFORMULA_EXPORT PlainCommand : public KNamedCommand
{
public:

    PlainCommand(const QString& name);
    virtual ~PlainCommand();

    static int getEvilDestructionCount() { return evilDestructionCount; }

private:

    // debug
    static int evilDestructionCount;
};


class Command : public PlainCommand
{
public:

    Command(const QString& name, Container* document);
    virtual ~Command();

protected:

    FormulaCursor* getExecuteCursor();

    FormulaCursor* getUnexecuteCursor();

    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; }

    void setExecuteCursor(FormulaCursor* cursor);

//    FormulaCursor::CursorData* cursordata;

//    FormulaCursor::CursorData* undocursor;

    Container* doc;
};


class KFCAdd : public Command
{
public:

    KFCAdd(const QString &name, Container* document);

    virtual void execute();
    virtual void unexecute();

    void addElement(BasicElement* element) { addList.append(element); }

private:

    QList<BasicElement*> addList;
};


class KFCRemoveSelection : public Command
{
public:

    KFCRemoveSelection(Container* document,
                       Direction dir = beforeCursor);

    virtual void execute();
    virtual void unexecute();

private:

    QList<BasicElement*> removedList;

    Direction dir;
};


class KFCReplace : public KFCAdd
{
public:

    KFCReplace(const QString &name, Container* document);
    ~KFCReplace();

    virtual void execute();
    virtual void unexecute();

private:

    KFCRemoveSelection* removeSelection;
};


class KFCRemove : public Command
{
public:

    KFCRemove(Container* document, Direction dir);
    ~KFCRemove();

    virtual void execute();
    virtual void unexecute();

    //virtual bool isSenseless() { return removedList.isEmpty(); }

private:

    QList<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 QString &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);

    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 QString& 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 QString& name, Container* document );

    void addTextElement( TextElement* element ) { list.append(element); }

    void addElement( BasicElement* element ) { elementList.append( element ); }

protected:

    QList<TextElement*>& childrenList() { return list; }

    void collectChildren();

    void parseSequences( const QMap<SequenceElement*, int>& parents );

private:

    QList<TextElement*> list;

    QList<BasicElement*> elementList;
};


class CharStyleCommand : public FontCommand {
public:
    CharStyleCommand( CharStyle cs, const QString& name, Container* document );

    virtual void execute();
    virtual void unexecute();

private:

    typedef QVector<CharStyle> StyleList;

    StyleList styleList;
    CharStyle charStyle;
};


class CharFamilyCommand : public FontCommand {
public:
    CharFamilyCommand( CharFamily cf, const QString& name, Container* document );

    virtual void execute();
    virtual void unexecute();

private:

    typedef QVector<CharFamily> FamilyList;

    FamilyList familyList;
    CharFamily charFamily;
};


class KFCRemoveRow : public Command
{
  public:
    KFCRemoveRow( const QString& name, Container* document, MatrixElement* m, int r, int c );
    ~KFCRemoveRow();

    virtual void execute();
    virtual void unexecute();

  protected:
    MatrixElement* matrix;
    int rowPos;
    int colPos;

    QList<MatrixRowElement*>* row;
};


class KFCInsertRow : public KFCRemoveRow {
public:
    KFCInsertRow( const QString& name, Container* document, MatrixElement* m, int r, int c );

    virtual void execute()   { KFCRemoveRow::unexecute(); }
    virtual void unexecute() { KFCRemoveRow::execute(); }
};


class KFCRemoveColumn : public Command {
public:
    KFCRemoveColumn( const QString& name, Container* document, MatrixElement* m, int r, int c );
    ~KFCRemoveColumn();

    virtual void execute();
    virtual void unexecute();

protected:
    MatrixElement* matrix;
    int rowPos;
    int colPos;

    QList<MatrixRowElement*>* column;
};


class KFCInsertColumn : public KFCRemoveColumn {
public:
    KFCInsertColumn( const QString& name, Container* document, MatrixElement* m, int r, int c );

    virtual void execute()   { KFCRemoveColumn::unexecute(); }
    virtual void unexecute() { KFCRemoveColumn::execute(); }
};

class KFCNewLine : public Command {
public:
    KFCNewLine( const QString& name, Container* document,
                MatrixEntryElement* line, uint pos );

    virtual ~KFCNewLine();

    virtual void execute();
    virtual void unexecute();

private:
    MatrixEntryElement* m_line;
    MatrixEntryElement* m_newline;
    uint m_pos;
};



} //namespace KFormula

#endif // KFORMULACOMMAND_H

---