undostate.h

/*
For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/
/***************************************************************************
 *   Copyright (C) 2005 by Riku Leino                                      *
 *   riku@scribus.info                                                     *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
 ***************************************************************************/

#ifndef UNDOSTATE_H
#define UNDOSTATE_H

#include <vector>

#include <QMap>
#include <QPair>
#include <QPixmap>
#include <QVariant>
#include <QList>

#include "scribusapi.h"
#include "undoobject.h"

class QString;
class PageItem;

class SCRIBUS_API UndoState
{
public:
    UndoState(const QString& name, const QString& description = 0, QPixmap* pixmap = 0);

    virtual ~UndoState();

    virtual QString getName();

    virtual void setName(const QString &newName);

    virtual QString getDescription();

    virtual void setDescription(const QString &newDescription);

    virtual QPixmap* getPixmap();

    virtual void setPixmap(QPixmap *newPixmap);

    virtual void undo();
    virtual void redo();
    virtual bool isTransaction(){ return false;};
    virtual void setUndoObject(UndoObject *object);
    virtual UndoObject* undoObject();
    int transactionCode;

private:
    QString actionName_;
    QString actionDescription_;
    QPixmap *actionPixmap_;
    UndoObjectPtr undoObject_;
};

/*** SimpleState **************************************************************************/

class SCRIBUS_API SimpleState : public UndoState
{
public:
    SimpleState(const QString& name, const QString& description = 0, QPixmap* pixmap = 0);

    virtual ~SimpleState();

    bool contains(const QString& key);

    QString get(const QString& key, const QString& def = "");

    int getInt(const QString& key, int def = 0);

    uint getUInt(const QString& key, uint def = 0);

    double getDouble(const QString& key, double def = 0.0);

    bool getBool(const QString& key, bool def = false);

    void set(const QString& key, const QString& value);

    void set(const QString& key, int value);

    void set(const QString& key, uint value);

    void set(const QString& key, double value);

    void set(const QString& key, bool value);

private:
    QMap<QString, QVariant> values_;

    QVariant variant(const QString& key, const QVariant& def);
};

/*** ItemState ***************************************************************************/

template<class C>
class ScItemState : public SimpleState
{
public:
    ScItemState(const QString& name, const QString& description = 0, QPixmap* pixmap = 0)
    : SimpleState(name, description, pixmap) {}
    ~ScItemState() {}
    void setItem(const C &c) { item_ = c; }
    C getItem() const { return item_; }
private:
    C item_;
};

/**** ItemsState for list of pointers to items *****/
//template<class C>
class ScItemsState : public SimpleState
{
public:
    ScItemsState(const QString& name, const QString& description = 0, QPixmap* pixmap = 0)
    : SimpleState(name, description, pixmap) {}
    ~ScItemsState() {}
    void insertItem(QString itemname, void * item) { pointerMap.insert(itemname, item); }
    void* getItem(QString itemname) const { if (pointerMap.contains(itemname)) return pointerMap.value(itemname); else return NULL;}
    QList< QPair<void*, int> > insertItemPos;
private:
    QMap<QString,void*> pointerMap;
};

/*** TransactionState ********************************************************************/

class TransactionState : public UndoState
{
public:
    TransactionState();
    ~TransactionState();
    bool isTransaction(){return true;}

    void pushBack(UndoObject *target, UndoState *state);
    uint sizet() const;
    void useActionName();
    UndoState* at(int index) const;
    UndoState* last() const;
    bool contains(int uid) const;
    
    bool containsOnly(int uid) const;
    UndoObject* replace(ulong uid, UndoObject *newUndoObject);

    void undo();
    void redo();
private:
    uint size_;
    std::vector<UndoState*> states_;
};

#endif