#ifndef MENUBAR_COMMAND_H

#define MENUBAR_COMMAND_H

#include <vector></vector>

#include <map></map>

#include <string></string>

#include "tcommon.h"

#include <qaction></qaction>

#include <qmenu></qmenu>

#undef DVAPI

#undef DVVAR

#ifdef TOONZQT_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//

// forward declaration

//

class QAction;

//

// base class

//

class DVAPI CommandHandlerInterface

{

public:

	virtual ~CommandHandlerInterface() {}

	virtual void execute() = 0;

};

//-----------------------------------------------------------------------------

//

// command identifier (e.g. "copy"). They are NOT command names (e.g. "&Copy")

//

typedef const char *CommandId;

enum CommandType {

	UndefinedCommandType = 0,

	RightClickMenuCommandType,

	MenuFileCommandType,

	MenuEditCommandType,

	MenuScanCleanupCommandType,

	MenuLevelCommandType,

	MenuXsheetCommandType,

	MenuCellsCommandType,

	MenuViewCommandType,

	MenuWindowsCommandType,

	PlaybackCommandType,

	RGBACommandType,

	FillCommandType,

	ToolCommandType,

	ToolModifierCommandType,

	ZoomCommandType,

	MiscCommandType,

	MenuCommandType

};

//-----------------------------------------------------------------------------

class AuxActionsCreator

{

public:

	AuxActionsCreator();

	virtual ~AuxActionsCreator(){};

	virtual void createActions(QObject *parent) = 0;

};

//-----------------------------------------------------------------------------

class AuxActionsCreatorManager

{

	bool m_auxActionsCreated;

	std::vector<auxactionscreator *=""> m_auxActionsCreators;</auxactionscreator>

	AuxActionsCreatorManager();

public:

	static AuxActionsCreatorManager *instance();

	void addAuxActionsCreator(AuxActionsCreator *auxActionsCreator);

	void createAuxActions(QObject *parent);

};

//-----------------------------------------------------------------------------

//

// command manager:

//    setExecutor(id, executor)

//    setAction(id, qaction)

//    execute(qaction)/

//

class DVAPI CommandManager

{ // singleton

	class Node

	{

	public:

		std::string m_id;

		CommandType m_type;

		QAction *m_qaction;

		CommandHandlerInterface *m_handler;

		bool m_enabled;

		QString m_onText, m_offText; // for toggle commands. e.g. show/hide something

		Node(CommandId id)

			: m_id(id), m_type(UndefinedCommandType), m_qaction(0), m_handler(0), m_enabled(true) {}

		~Node()

		{

			if (m_handler)

				delete m_handler;

		}

	};

	std::map<std::string, *="" node=""> m_idTable;</std::string,>

	std::map<qaction *="" *,="" node=""> m_qactionTable;</qaction>

	std::map<std::string, *="" node=""> m_shortcutTable;</std::string,>

	CommandManager();

	Node *getNode(CommandId id, bool createIfNeeded = true);

	void setShortcut(CommandId id, QAction *action, std::string shortcutString);

	void createAuxActions();

public:

	static CommandManager *instance();

	~CommandManager();

	void setHandler(CommandId id, CommandHandlerInterface *handler);

	void define(

		CommandId id,

		CommandType type,

		std::string defaultShortcutString,

		QAction *action);

	QAction *createAction(const char *id, const char *name, const char *defaultShortcut);

	void getActions(CommandType type, std::vector<qaction *=""> &actions);</qaction>

	QAction *getActionFromShortcut(std::string shortcutString);

	std::string getShortcutFromAction(QAction *action);

	std::string getShortcutFromId(CommandId id);

	int getKeyFromShortcut(const std::string &shortcut);

	int getKeyFromId(CommandId id);

	void setShortcut(QAction *action, std::string shortcutString);

	QAction *getAction(CommandId id, bool createIfNeeded = false);

	// createAction creates a new indepenent QAction with text and shortcut

	// if the action is a toggle action (e.g. show/hide something) the text is controlled by state

	// you can use createAction() for context menu

	QAction *createAction(CommandId id, QObject *parent = 0, bool state = true);

	void execute(QAction *action);

	/*! If action is defined in m_qactionTable recall \b execute(action), otherwise recall execute(menuAction).*/

	void execute(QAction *action, QAction *menuAction);

	void execute(CommandId id);

	void enable(CommandId id, bool enabled);

	// if id is a toggle (e.g. a checkable menu item) then set its status;

	// note: this will trigger any associated handler

	void setChecked(CommandId id, bool checked);

	// use setToggleTexts for toggle commands that have two names according to the current status. e.g. show/hide something

	void setToggleTexts(CommandId id, const QString &onText, const QString &offText);

	std::string getIdFromAction(QAction* action);

};

//-----------------------------------------------------------------------------

//

// CommandHandlerHelper = target + method

//

template <class t=""></class>

class CommandHandlerHelper : public CommandHandlerInterface

{

	T *m_target;

	void (T::*m_method)();

public:

	CommandHandlerHelper(T *target, void (T::*method)())

		: m_target(target), m_method(method)

	{

	}

	void execute() { (m_target->*m_method)(); }

};

template <class r="" t,="" typename=""></class>

class CommandHandlerHelper2 : public CommandHandlerInterface

{

	T *m_target;

	void (T::*m_method)(R value);

	R m_value;

public:

	CommandHandlerHelper2(T *target, void (T::*method)(R), R value)

		: m_target(target), m_method(method), m_value(value)

	{

	}

	void execute() { (m_target->*m_method)(m_value); }

};

//-----------------------------------------------------------------------------

template <class t=""></class>

inline void setCommandHandler(CommandId id, T *target, void (T::*method)())

{

	CommandManager::instance()->setHandler(id, new CommandHandlerHelper<t>(target, method));</t>

}

//-----------------------------------------------------------------------------

class DVAPI MenuItemHandler : public QObject

{

	Q_OBJECT

public:

	MenuItemHandler(CommandId cmdId);

	virtual ~MenuItemHandler(){};

	virtual void execute() = 0;

};

template <class t=""></class>

class OpenPopupCommandHandler : public MenuItemHandler

{

	T *m_popup;

	CommandId m_id;

public:

	OpenPopupCommandHandler(CommandId cmdId)

		: MenuItemHandler(cmdId), m_popup(0)

	{

	}

	void execute()

	{

		if (!m_popup)

			m_popup = new T();

		m_popup->show();

		m_popup->raise();

		m_popup->activateWindow();

	}

};

//-----------------------------------------------------------------------------

class DVAPI DVAction : public QAction

{

	Q_OBJECT

public:

	DVAction(const QString &text, QObject *parent);

	DVAction(const QIcon &icon, const QString &text, QObject *parent);

public slots:

	void onTriggered();

};

//-----------------------------------------------------------------------------

class DVAPI DVMenuAction : public QMenu

{

	Q_OBJECT

	int m_triggeredActionIndex;

public:

	DVMenuAction(const QString &text, QWidget *parent, QList<qstring> actions);</qstring>

	void setActions(QList<qstring> actions);</qstring>

	int getTriggeredActionIndex() { return m_triggeredActionIndex; }

public slots:

	void onTriggered(QAction *action);

};

//-----------------------------------------------------------------------------

#endif // MENUBAR_COMMAND_H