Subversion Repositories Scribus

Rev

Rev 17826 | Rev 19416 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

/*
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 <QMap>
#include <QPair>
#include <QPixmap>
#include <QVariant>
#include <QList>

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

class QString;
class PageItem;

/**
 * @brief UndoState describes an undoable state (action).
 *
 * Undoable objects implement undo/redo by sending and receiving UndoState
 * subclasses. This means that they will need to produce some sort of information
 * for the UndoState subclass (if no suitable subclass exists it must be also
 * created) and later they will need to be able to restore the state described
 * by the subclass to apply undo/redo.
 *
 * UndoManager will handle the deletion of UndoState objects.
 *
 * @sa SimpleState
 * @author Riku Leino riku@scribus.info
 * @date December 2004
 */

class SCRIBUS_API UndoState
{
public:
        /**
         * @brief Creates a new UndoState instance.
         * @param name Name of the state (action). Will be used when describing the
         * state in UndoGui subclasses.
         * @param description Description of the state (action)
         * @param pixmap Pointer to an icon describing the action visually.
         */

        UndoState(const QString& name, const QString& description = 0, QPixmap* pixmap = 0);

        virtual ~UndoState();

        /**
         * @brief Returns name of the state (action).
         * @return name of the state
         */

        virtual QString getName();

        /**
         * @brief Set the name for this UndoState.
         * @param newName name for this UndoState
         */

        virtual void setName(const QString &newName);

        /**
         * @brief Returns description of the state.
         * @return description of the state
         */

        virtual QString getDescription();

        /**
         * @brief Set the description for this UndoState
         * @param newDescription description for this UndoState
         */

        virtual void setDescription(const QString &newDescription);

        /**
         * @brief Returns a pointer to the icon attached to the state.
         * @return A pointer to the icon attached to the state
         */

        virtual QPixmap* getPixmap();

        /**
         * @brief Set the icon for this UndoState.
         * @param newPixmap icon for this UndoState
         */

        virtual void setPixmap(QPixmap *newPixmap);

        /** @brief undo the state described by this UndoState,
         *  @brief requires related UndoObject */

        virtual void undo();
        /** @brief redo the state described by this UndoState,
         *  @brief requires the related UndoObject */

        virtual void redo();
        /** @brief To know if the state is a transaction */
        virtual bool isTransaction(){ return false;};
        /** @brief Set the UndoObject this state belongs to */
        virtual void setUndoObject(UndoObject *object);
        /** @brief return the UndoObject this state belongs to */
        virtual UndoObject* undoObject();
        int transactionCode;

private:
        /** @brief Name of the state (operation) (f.e. Move object) */
        QString actionName_;
        /** @brief Detailed description of the state (operation). */
        QString actionDescription_;
        /** @brief Icon related to the state (operation) */
        QPixmap *actionPixmap_;
        /** @brief UndoObject this state belongs to */
        UndoObjectPtr undoObject_;
};

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

/**
 * @brief SimpleState provides a simple implementation of the UndoState.
 *
 * SimpleState uses a <code>QMap</code> to store key-value pairs that can be queried and
 * set using it's get() and set() methods.
 *
 * @author Riku Leino tsoots@gmail.com
 * @date December 2004
 */

class SCRIBUS_API SimpleState : public UndoState
{
public:
        /**
         * @brief Creates a new SimpleState instance.
         * @param name Name of the state (action). Will be used when describing the
         * state in UndoGui subclasses.
         * @param description Description of the state (action)
         * @param pixmap Pointer to an icon describing the state (action) visually.
         */

        SimpleState(const QString& name, const QString& description = 0, QPixmap* pixmap = 0);

        virtual ~SimpleState();

        /**
         * @brief Returns true if parameter key exists in the map.
         * @param key Key that is searched from the map
         * @return true if parameter key exists in the map if not false
         */

        bool contains(const QString& key);

        /**
         * @brief Returns the QString value attached to the key.
         *
         * If key is not found from the map it will be added there with the
         * value given as a parameter def. In such case <code>def</code> will also
         * be returned.
         * @param key Key that is searched from the map
         * @param def Default value to be used if key is not found from the map
         * @return Value attached to the key in the map. If the key is not found
         * from the map it will be added with the value described in the param
         * <code>def</code> which is then returned.
         */

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

        /**
         * @brief Returns the int value attached to the key.
         *
         * Values are stored as <code>QString</code>s in the map and when queried
         * with this method value attached to the key is converted to an int. If
         * the conversion fails value of the parameter <code>def</code> will be returned.
         * If key is not found from the map it will be added there with the
         * value given as a parameter <code>def</code>. In such case <code>def</code>
         * will also be returned.
         * @param key Key that is searched from the map
         * @param def Default value to be used if key is not found from the map
         * @return <code>int</code> value attached to the key in the map. If the key is not found
         * from the map it will be added with the value described in the param
         * <code>def</code> which is then returned.
         */

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

        /**
         * @brief Returns the uint value attached to the key.
         *
         * Values are stored as <code>QString</code>s in the map and when queried
         * with this method value attached to the key is converted to an int. If
         * the conversion fails value of the parameter <code>def</code> will be returned.
         * If key is not found from the map it will be added there with the
         * value given as a parameter <code>def</code>. In such case <code>def</code>
         * will also be returned.
         * @param key Key that is searched from the map
         * @param def Default value to be used if key is not found from the map
         * @return <code>uint</code> value attached to the key in the map. If the key is not found
         * from the map it will be added with the value described in the param
         * <code>def</code> which is then returned.
         */

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

        /**
         * @brief Returns the double value attached to the key.
         *
         * Values are stored as <code>QString</code>s in the map and when queried
         * with this method value attached to the key is converted to a double. If
         * the conversion fails value of the parameter <code>def</code> will be returned.
         * If key is not found from the map it will be added there with the
         * value given as a parameter def. In such case <code>def</code> will also be returned.
         * @param key Key that is searched from the map
         * @param def Default value to be used if key is not found from the map
         * @return <code>Double</code> value attached to the key in the map. If the key is not found
         * from the map it will be added with the value described in the parameter
         * <code>def</code> which is then returned.
         */

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

        /**
         * @brief Returns the boolean value attached to the key.
         *
         * Values are stored as <code>QString</code>s in the map and when queried
         * with this method value attached to the key is converted to a bool. If
         * the conversion fails value of the parameter <code>def</code> will be returned.
         * If key is not found from the map it will be added there with the
         * value given as a parameter def. In such case <code>def</code> will also be returned.
         * @param key Key that is searched from the map
         * @param def Default value to be used if key is not found from the map
         * @return <code>Bool</code> value attached to the key in the map. If the key is not found
         * from the map it will be added with the value described in the parameter
         * <code>def</code> which is then returned.
         */

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

        /**
         * @brief Set a value for the key.
         * @param key Key that can be later used to query the value.
         * @param value Value attached to the key.
         */

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

        /**
         * @brief Set a value for the key.
         * @param key Key that can be later used to query the value.
         * @param value Value attached to the key.
         */

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

        /**
         * @brief Set a value for the key.
         * @param key Key that can be later used to query the value.
         * @param value Value attached to the key.
         */

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

        /**
         * @brief Set a value for the key.
         * @param key Key that can be later used to query the value.
         * @param value Value attached to the key.
         */

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

        /**
         * @brief Set a value for the key.
         * @param key Key that can be later used to query the value.
         * @param value Value attached to the key.
         */

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

private:
        /** @brief QMap to store key-value pairs */
        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;
};

#endif