186 lines
4.5 KiB
C++
186 lines
4.5 KiB
C++
#pragma once
|
|
|
|
#ifndef TNZ_ACTION_INCLUDED
|
|
#define TNZ_ACTION_INCLUDED
|
|
|
|
#include "tw/tw.h"
|
|
|
|
#undef DVAPI
|
|
#undef DVVAR
|
|
#ifdef TWIN_EXPORTS
|
|
#define DVAPI DV_EXPORT_API
|
|
#define DVVAR DV_EXPORT_VAR
|
|
#else
|
|
#define DVAPI DV_IMPORT_API
|
|
#define DVVAR DV_IMPORT_VAR
|
|
#endif
|
|
|
|
class TButton;
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class DVAPI TGenericCommandAction {
|
|
public:
|
|
TGenericCommandAction() {}
|
|
virtual ~TGenericCommandAction() {}
|
|
|
|
virtual void sendCommand() = 0;
|
|
virtual TGenericCommandAction *clone() const = 0;
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
class TCommandAction : public TGenericCommandAction {
|
|
public:
|
|
typedef void (T::*CommandMethod)();
|
|
|
|
T *m_target;
|
|
CommandMethod m_method;
|
|
|
|
TCommandAction<T>(T *target, CommandMethod method)
|
|
: m_target(target), m_method(method){};
|
|
void sendCommand() { (m_target->*m_method)(); };
|
|
|
|
TGenericCommandAction *clone() const {
|
|
return new TCommandAction<T>(m_target, m_method);
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <class T, class Arg>
|
|
class TCommandAction1 : public TGenericCommandAction {
|
|
public:
|
|
typedef void (T::*CommandMethod)(Arg arg);
|
|
|
|
T *m_target;
|
|
CommandMethod m_method;
|
|
Arg m_arg;
|
|
|
|
TCommandAction1<T, Arg>(T *target, CommandMethod method, Arg arg)
|
|
: m_target(target), m_method(method), m_arg(arg){};
|
|
void sendCommand() { (m_target->*m_method)(m_arg); };
|
|
|
|
TGenericCommandAction *clone() const {
|
|
return new TCommandAction1<T, Arg>(m_target, m_method, m_arg);
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class DVAPI TCommandSource {
|
|
vector<TGenericCommandAction *> *m_actions;
|
|
|
|
public:
|
|
TCommandSource();
|
|
virtual ~TCommandSource();
|
|
|
|
void addAction(TGenericCommandAction *action);
|
|
void sendCommand();
|
|
|
|
private:
|
|
// not implemented
|
|
TCommandSource(const TCommandSource &);
|
|
TCommandSource &operator=(const TCommandSource &);
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
inline void tconnect(TCommandSource &src, T *target, void (T::*method)()) {
|
|
src.addAction(new TCommandAction<T>(target, method));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <class T, class Arg>
|
|
inline void tconnect(TCommandSource &src, T *target, void (T::*method)(Arg arg),
|
|
Arg arg) {
|
|
src.addAction(new TCommandAction1<T, Arg>(target, method, arg));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class DVAPI TGuiCommand {
|
|
class Imp;
|
|
Imp *m_imp;
|
|
|
|
public:
|
|
TGuiCommand(string cmdName = "none");
|
|
virtual ~TGuiCommand();
|
|
TGuiCommand(const TGuiCommand &);
|
|
TGuiCommand &operator=(const TGuiCommand &);
|
|
|
|
// void setHelp(string longHelp, string shortHelp);
|
|
// void setHelp(string help) {setHelp(help, help);}
|
|
|
|
// void setTitle(string title);
|
|
// string getTitle();
|
|
|
|
bool isToggle() const;
|
|
void setIsToggle(bool on);
|
|
void setStatus(bool on);
|
|
bool getStatus() const;
|
|
|
|
void enable();
|
|
void disable();
|
|
|
|
void add(TButton *button);
|
|
void setAction(TGenericCommandAction *action);
|
|
|
|
// debug!!
|
|
void sendCommand();
|
|
|
|
static void execute(string cmdName);
|
|
static void getNames(std::vector<string> &cmdNames);
|
|
|
|
private:
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class DVAPI TGuiCommandExecutor : public TGuiCommand {
|
|
public:
|
|
TGuiCommandExecutor(string cmdName) : TGuiCommand(cmdName) {
|
|
setAction(new TCommandAction<TGuiCommandExecutor>(
|
|
this, &TGuiCommandExecutor::onCommand));
|
|
}
|
|
|
|
virtual ~TGuiCommandExecutor() {}
|
|
|
|
virtual void onCommand() = 0;
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class TGuiCommandGenericTarget {
|
|
protected:
|
|
TGuiCommand m_command;
|
|
|
|
public:
|
|
TGuiCommandGenericTarget(string cmdName) : m_command(cmdName) {}
|
|
virtual ~TGuiCommandGenericTarget() {}
|
|
virtual void activate() = 0;
|
|
virtual void deactivate() { m_command.setAction(0); }
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
class TGuiCommandTarget : public TGuiCommandGenericTarget {
|
|
public:
|
|
typedef void (T::*Method)();
|
|
T *m_target;
|
|
Method m_method;
|
|
|
|
public:
|
|
TGuiCommandTarget(string cmdName, T *target, Method method)
|
|
: TGuiCommandGenericTarget(cmdName), m_target(target), m_method(method) {}
|
|
|
|
void activate() {
|
|
m_command.setAction(new TCommandAction<T>(m_target, m_method));
|
|
}
|
|
};
|
|
|
|
#endif
|