action_system.h

Go to the documentation of this file.

/* === S Y N F I G ========================================================= */
/* ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __SYNFIGAPP_ACTIONSYSTEM_H
#define __SYNFIGAPP_ACTIONSYSTEM_H

/* === H E A D E R S ======================================================= */

#include "action.h"
#include <sigc++/signal.h>
#include <sigc++/object.h>
#include <ETL/handle>
#include <synfig/canvas.h>
#include "uimanager.h"

/* === M A C R O S ========================================================= */

/* === T Y P E D E F S ===================================================== */

/* === C L A S S E S & S T R U C T S ======================================= */

namespace synfigapp {

class CanvasInterface;

namespace Action {





class System;

class PassiveGrouper
{
    etl::loose_handle<System> instance_;
    synfig::String name_;
    bool redraw_requested_;
    int depth_;
    etl::handle<CanvasInterface> canvas_interface_;
public:

    PassiveGrouper(etl::loose_handle<System> instance_,synfig::String name_);

    ~PassiveGrouper();

    const synfig::String &get_name()const { return name_; }

    void set_name(const synfig::String &x) { name_=x; }

    etl::loose_handle<System> get_instance() { return instance_; }

    void request_redraw(etl::handle<CanvasInterface>);

    void cancel();

    void inc_depth() { depth_++; }

    void dec_depth() { depth_--; }

    const int &get_depth()const { return depth_; }
}; // END of class Action::PassiveGrouper

typedef std::list< etl::handle<Action::Undoable> > Stack;

class System : public etl::shared_object, public sigc::trackable
{
    friend class PassiveGrouper;

    /*
 -- ** -- P U B L I C   T Y P E S ---------------------------------------------
    */

public:

    /*
 -- ** -- P U B L I C  D A T A ------------------------------------------------
    */

public:

    /*
 -- ** -- P R I V A T E   D A T A ---------------------------------------------
    */

private:

    Stack undo_action_stack_;
    Stack redo_action_stack_;

    synfig::String most_recent_action_name_;

    std::list<PassiveGrouper*> group_stack_;

    sigc::signal<void,bool> signal_undo_status_;
    sigc::signal<void,bool> signal_redo_status_;
    sigc::signal<void,etl::handle<Action::Undoable> > signal_new_action_;
    sigc::signal<void> signal_undo_stack_cleared_;
    sigc::signal<void> signal_redo_stack_cleared_;
    sigc::signal<void> signal_undo_;
    sigc::signal<void> signal_redo_;
    sigc::signal<void,etl::handle<Action::Undoable> > signal_action_status_changed_;

    mutable sigc::signal<void,bool> signal_unsaved_status_changed_;

    mutable int action_count_;

    etl::handle<UIInterface> ui_interface_;

    bool clear_redo_stack_on_new_action_;

    /*
 -- ** -- P R I V A T E   M E T H O D S ---------------------------------------
    */

private:

    bool undo_(etl::handle<UIInterface> uim);
    bool redo_(etl::handle<UIInterface> uim);

    /*
 -- ** -- S I G N A L   T E R M I N A L S -------------------------------------
    */

private:

    /*
 -- ** -- P U B L I C   M E T H O D S -----------------------------------------
    */

public:

    System();
    ~System();

    /*
    template <typename T> bool
    perform_action(T x)
    {
        etl::handle<Action::Base> action((Action::Base*)new T(x));
        return perform_action(action);
    }
    */

    synfig::String get_most_recent_action_name() { return most_recent_action_name_; }

    bool get_clear_redo_stack_on_new_action()const { return clear_redo_stack_on_new_action_; }

    void set_clear_redo_stack_on_new_action(bool x) { clear_redo_stack_on_new_action_=x; }

    bool perform_action(etl::handle<Action::Base> action);

    bool set_action_status(etl::handle<Action::Undoable> action, bool x);

    const Stack &undo_action_stack()const { return undo_action_stack_; }

    const Stack &redo_action_stack()const { return redo_action_stack_; }

    bool undo();

    bool redo();

    void clear_undo_stack();

    void clear_redo_stack();


    void inc_action_count()const;


    void dec_action_count()const;


    void reset_action_count()const;


    int get_action_count()const { return action_count_; }

    void set_ui_interface(const etl::handle<UIInterface> &uim) { assert(uim); ui_interface_=uim; }
    void unset_ui_interface() { ui_interface_=new DefaultUIInterface(); }
    const etl::handle<UIInterface> &get_ui_interface() { return ui_interface_; }

    /*
 -- ** -- S I G N A L   I N T E R F A C E S -----------------------------------
    */

public:

    sigc::signal<void,bool>& signal_unsaved_status_changed() { return signal_unsaved_status_changed_; }

    sigc::signal<void,bool>& signal_undo_status() { return signal_undo_status_; }

    sigc::signal<void,bool>& signal_redo_status() { return signal_redo_status_; }

    sigc::signal<void>& signal_undo_stack_cleared() { return signal_undo_stack_cleared_; }

    sigc::signal<void>& signal_redo_stack_cleared() { return signal_redo_stack_cleared_; }

    sigc::signal<void>& signal_undo() { return signal_undo_; }

    sigc::signal<void>& signal_redo() { return signal_redo_; }

    sigc::signal<void,etl::handle<Action::Undoable> >& signal_new_action() { return signal_new_action_; }

    sigc::signal<void,etl::handle<Action::Undoable> >& signal_action_status_changed() { return signal_action_status_changed_; }

}; // END of class Action::System


}; // END of namespace synfigapp::Action
}; // END of namespace synfigapp

/* === E N D =============================================================== */

#endif