GenericGUI.h

#ifndef GENERIC_GUI_H
#define GENERIC_GUI_H

#include <KrisLibrary/utils/AnyCollection.h>
#include <KrisLibrary/math3d/primitives.h>
#include <string>
#include <sstream>

namespace Klampt {
  using namespace std;

class GenericGUIBase;
class GenericBackendBase;

class GenericGUIBase
{
 public:
  GenericGUIBase(GenericBackendBase* backend);
  virtual ~GenericGUIBase() {}
  virtual void Run();
  virtual bool ProcessMessage(const AnyCollection& msg);
  virtual bool SendMessage(const AnyCollection& msg);

  void AddRule(const AnyCollection& inschema,const AnyCollection& outschema,bool mapWildcardStrings=true);
  void AddCommandRule(const AnyCollection& inschema,const string& cmd,const string& args,bool mapWildcardStrings=true);
  bool LoadRules(const char* fn);
  bool LoadRules(istream& in);

  virtual bool OnQuit() { return false; }
  virtual bool OnCommand(const string& cmd,const string& args) { return false; }
  virtual bool OnNotify(const string& text,const string& msglevel) { return false; }
  virtual bool OnPauseIdle(double secs) { return false; }
  virtual bool OnRefresh() { return false; }
  virtual bool OnResize(int w,int h) { return false; }
  virtual bool OnDrawText(double x, double y, double z, const std::string &text, int height) { return false; }
  virtual bool OnDrawText(int x,int y, const std::string &text, int height) { return false; }

  bool SendIdle();
  bool SendGLRender();
  bool SendGLViewport(int x,int y,int w,int h);
  bool SendCommand(const string& cmd,const string& args);
  bool SendCommand(const string& cmd);
  template <class T>
  bool SendCommand(const string& cmd,const T& arg1);
  template <class T1,class T2>
  bool SendCommand(const string& cmd,const T1& arg1,const T2& arg2);
  template <class T1,class T2,class T3>
  bool SendCommand(const string& cmd,const T1& arg1,const T2& arg2,const T3& arg3);
  bool SendButtonPress(const string& widget);
  bool SendButtonToggle(const string& widget,int checked);
  bool SendWidgetValue(const string& widget,const string& value);
  bool SendMouseClick(int button,int state,int mx,int my);
  bool SendMouseMove(int mx,int my);
  bool SendMouseWheel(int dwheel);
  bool SendScroll(int dy);
  bool SendKeyDown(const string& key);
  bool SendKeyUp(const string& key);
  bool SendSpaceball(const Math3D::RigidTransform& T);
  bool SendDevice(const string& name,const string& data);

  GenericBackendBase* backend;
  vector<pair<AnyCollection,AnyCollection> > rules;
};

class GenericBackendBase
{
 public:
  GenericBackendBase();
  virtual ~GenericBackendBase() {}
  virtual void Start() {}
  virtual void Stop() {}
  virtual bool ProcessMessage(const AnyCollection& msg);
  virtual bool SendMessage(const AnyCollection& msg) { return gui->ProcessMessage(msg); }

  //"live" button mappings
  void MapButtonPress(const string& button,int* var);
  void MapButtonToggle(const string& button,int* var);
  void MapWidgetValue(const string& button,string* var);
  void MapKeyToggle(const string& key,int* var);

  virtual bool OnIdle() { SendPauseIdle(); return true; }
  virtual bool OnGLRender() { return false; }
  virtual bool OnGLViewport(int x,int y,int w, int h) { return false; }
  virtual bool OnCommand(const string& cmd,const string& args) { return false; }
  virtual bool OnButtonPress(const string& button);
  virtual bool OnButtonToggle(const string& button,int checked);
  virtual bool OnWidgetValue(const string& widget,const string& value);
  virtual bool OnMouseClick(int button,int state,int mx,int my) { return false; }
  virtual bool OnMouseMove(int mx,int my) { return false; }
  virtual bool OnMouseWheel(int dwheel) { return false; }
  virtual bool OnScroll(int dy) { return false; }
  virtual bool OnKeyDown(const string& key);
  virtual bool OnKeyUp(const string& key);
  virtual bool OnSpaceball(const Math3D::RigidTransform& T) { return false; }
  virtual bool OnDevice(const string& name,const string& data) { return false; }

  bool SendQuit();
  bool SendCommand(const string& cmd,const string& args);
  bool SendNotify(const string& text,const string& msglevel="");
  bool SendError(const string& text) { return SendNotify(text,"error"); }
  bool SendWarning(const string& text) { return SendNotify(text,"warning"); }
  bool SendPauseIdle(double secs=1e300);
  bool SendRefresh();
  bool SendResize(int w,int h);
  bool SendDrawText(double x, double y, double z, const std::string &text, int height = 10);
  bool SendDrawText(int x, int y, const std::string &text, int height = 10);

  GenericGUIBase* gui;
  map<string,int*> liveButtonPresses;
  map<string,int*> liveButtonToggles;
  map<string,string*> liveWidgetValues;
  map<string,int*> liveKeys;
};

class CompositeBackend : public GenericBackendBase
{
 public:
  void Add(std::shared_ptr<GenericBackendBase>& backend);
  void SetDefaultBroadcasts();
  void SetBroadcast(const string& msgtype) { targets[msgtype]="all"; }
  virtual bool ProcessMessage(const AnyCollection& msg);

  vector<std::shared_ptr<GenericBackendBase> > children;
  map<string,string> targets;
};


#define DISPATCHBEGIN() \
  bool res; \
  string type; \
  res = msg["type"].as<string>(type); \
  if(!res) { \
    cerr<<"Message doesn't contain type"<<endl; \
    return false; \
  } \

#define DISPATCHEND() \
  else { \
    cerr<<"Unhandled message type "<<type<<endl; \
    return false; \
  }


#define DISPATCH0(msgtype,func)         \
  else if(type == msgtype)      \
    return func();  

#define DISPATCH1(msgtype,arg1,func)            \
  else if(type == msgtype) \
    return func(msg[#arg1]);                    


#define DISPATCH2(msgtype,arg1,arg2,func)               \
  else if(type == msgtype) \
    return func(msg[#arg1],msg[#arg2]);      

#define DISPATCH3(msgtype,arg1,arg2,arg3,func)  \
  else if(type == msgtype) \
    return func(msg[#arg1],msg[#arg2],msg[#arg3]);      

#define DISPATCH4(msgtype,arg1,arg2,arg3,arg4,func)     \
  else if(type == msgtype) \
    return func(msg[#arg1],msg[#arg2],msg[#arg3],msg[#arg4]);  

#define DISPATCH5(msgtype,arg1,arg2,arg3,arg4,arg5,func)        \
  else if(type == msgtype) \
    return func(msg[#arg1],msg[#arg2],msg[#arg3],msg[#arg4],msg[#arg5]);  


#define SEND0(msgtype)\
  AnyCollection msg; \
  msg["type"] = string(msgtype); \
  return SendMessage(msg);

#define SEND1(msgtype,arg1)                     \
  AnyCollection msg; \
  msg["type"] = string(msgtype); \
  msg[#arg1] = arg1; \
  return SendMessage(msg);

#define SEND2(msgtype,arg1,arg2)                        \
  AnyCollection msg; \
  msg["type"] = string(msgtype); \
  msg[#arg1] = arg1; \
  msg[#arg2] = arg2; \
  return SendMessage(msg);

#define SEND3(msgtype,arg1,arg2,arg3)                   \
  AnyCollection msg; \
  msg["type"] = string(msgtype); \
  msg[#arg1] = arg1; \
  msg[#arg2] = arg2; \
  msg[#arg3] = arg3; \
  return SendMessage(msg);

#define SEND4(msgtype,arg1,arg2,arg3,arg4)              \
  AnyCollection msg; \
  msg["type"] = string(msgtype); \
  msg[#arg1] = arg1; \
  msg[#arg2] = arg2; \
  msg[#arg3] = arg3; \
  msg[#arg4] = arg4; \
  return SendMessage(msg);

#define SEND5(msgtype,arg1,arg2,arg3,arg4,arg5)         \
  AnyCollection msg; \
  msg["type"] = string(msgtype); \
  msg[#arg1] = arg1; \
  msg[#arg2] = arg2; \
  msg[#arg3] = arg3; \
  msg[#arg4] = arg4; \
  msg[#arg5] = arg5; \
  return SendMessage(msg);


template <class T>
bool GenericGUIBase::SendCommand(const string& cmd,const T& arg1)
{
  stringstream ss;
  ss<<arg1;
  return this->SendCommand(cmd,ss.str());
}

template <class T1,class T2>
bool GenericGUIBase::SendCommand(const string& cmd,const T1& arg1,const T2& arg2)
{
  stringstream ss;
  ss<<arg1<<" "<<arg2;
  return this->SendCommand(cmd,ss.str());
}

template <class T1,class T2,class T3>
bool GenericGUIBase::SendCommand(const string& cmd,const T1& arg1,const T2& arg2,const T3& arg3)
{
  stringstream ss;
  ss<<arg1<<" "<<arg2<<" "<<arg3<<endl;
  return this->SendCommand(cmd,ss.str());
}

} //namespace Klampt

#endif