rc.h

Go to the documentation of this file.

#ifndef __rc_h
#define __rc_h
 
#include <list>
#include <map>
 
#include <linux/input.h>
 
#include <lib/base/ebase.h>
#include <libsig_comp.h>
#include <lib/python/python.h>
#include <string>
#include <unordered_map>
 
class eRCInput;
class eRCDriver;
class eRCKey;
 
#ifndef SWIG
 
class eRCDevice: public sigc::trackable
{
protected:
  eRCInput *input;
  eRCDriver *driver;
  std::string id;
public:
  eRCDevice(std::string id, eRCDriver *input);
  virtual ~eRCDevice();
  virtual void handleCode(long code)=0;
  virtual const char *getDescription() const=0;
  const std::string getIdentifier() const { return id; }
  virtual void setExclusive(bool b) { };
  virtual int setKeyMapping(const std::unordered_map<unsigned int, unsigned int>& remaps);
};
 
class eRCDriver: public sigc::trackable
{
protected:
  std::list<eRCDevice*> listeners;
  eRCInput *input;
  int enabled;
public:
  eRCDriver(eRCInput *input);
  eRCInput *getInput() const { return input; }
  void addCodeListener(eRCDevice *dev)
  {
    listeners.push_back(dev);
  }
  void removeCodeListener(eRCDevice *dev)
  {
    listeners.remove(dev);
  }
  virtual ~eRCDriver();
 
  void enable(int en) { enabled=en; }
  virtual void setExclusive(bool) { }
  virtual bool isKeyboard() { return false; }
  virtual bool isPointerDevice() { return false; }
};
 
class eRCShortDriver: public eRCDriver
{
protected:
  int handle;
  ePtr<eSocketNotifier> sn;
  void keyPressed(int);
public:
  eRCShortDriver(const char *filename);
  ~eRCShortDriver();
};
 
class eRCInputEventDriver: public eRCDriver
{
protected:
  bool m_remote_control;
  int handle;
  unsigned char evCaps[(EV_MAX / 8) + 1];
  unsigned char keyCaps[(KEY_MAX / 8) + 1];
  ePtr<eSocketNotifier> sn;
  void keyPressed(int);
public:
  std::string getDeviceName();
  eRCInputEventDriver(const char *filename);
  ~eRCInputEventDriver();
  void setExclusive(bool b); // in exclusive mode data is not carried to console device
  bool isKeyboard();
  bool isPointerDevice();
  bool hasCap(unsigned char *caps, int bit);
};
 
class eRCKey
{
public:
  eRCDevice *producer;
  int code, flags;
 
  eRCKey(eRCDevice *producer, int code, int flags):
    producer(producer), code(code), flags(flags)
  {
  }
  enum
  {
      /* there are not really flags.. */
    flagMake=0,
    flagBreak=1,
    flagRepeat=2,
    flagLong=3,
      /* but this is. */
    flagAscii=4,
  };
 
  bool operator<(const eRCKey &r) const
  {
    if (r.producer == producer)
    {
      if (r.code == code)
      {
        if (r.flags < flags)
          return 1;
        else
          return 0;
      } else if (r.code < code)
        return 1;
      else
        return 0;
    } else if (r.producer < producer)
      return 1;
    else
      return 0;
  }
};
 
class eRCConfig
{
public:
  eRCConfig();
  ~eRCConfig();
  void reload();
  void save();
  void set(int delay, int repeat);
  int rdelay, // keypress delay after first keypress to begin of repeat (in ms)
    rrate;    // repeat rate (in ms)
};
 
#endif
 
class eRCInput: public sigc::trackable
{
  int locked;
  static eRCInput *instance;
  int keyboardMode;
#ifdef SWIG
  eRCInput();
  ~eRCInput();
public:
#else
public:
  struct lstr
  {
    bool operator()(const std::string &a, const std::string &b) const
    {
      return a<b;
    }
  };
protected:
  std::map<std::string,eRCDevice*,lstr> devices;
public:
  sigc::signal1<void, const eRCKey&> keyEvent;
  eRCInput();
  ~eRCInput();
 
  void close();
  bool open();
 
  /* This is only relevant for "keyboard"-styled input devices,
     i.e. not plain remote controls. It's up to the input device
     driver to decide wheter an input device is a keyboard or
     not.
 
     kmNone will ignore all Ascii Characters sent from the
     keyboard/console driver, only give normal keycodes to the
     application.
 
     kmAscii will filter out all keys which produce ascii characters,
     and send them instead. Note that Modifiers like shift will still
     be send. Control keys which produce escape codes are send using
     normal keycodes.
 
     kmAll will ignore all keycodes, and send everything as ascii,
     including escape codes. Pretty much useless, since you should
     lock the console and pass this as the console fd for making the
     tc* stuff working.
  */
 
  void keyPressed(const eRCKey &key)
  {
    /*emit*/ keyEvent(key);
  }
 
  void addDevice(const std::string &id, eRCDevice *dev);
  void removeDevice(const std::string &id);
  eRCDevice *getDevice(const std::string &id);
  std::map<std::string,eRCDevice*,lstr> &getDevices();
 
  eRCConfig config;
#endif
  enum { kmNone, kmAscii, kmAll };
  enum { remapOk, remapUnsupported, remapFormatErr, remapNoSuchDevice };
  void setKeyboardMode(int mode) { keyboardMode = mode; }
  int  getKeyboardMode() { return keyboardMode; }
  int setKeyMapping(const std::string &id, SWIG_PYOBJECT(ePyObject) keyRemap);
  static eRCInput *getInstance() { return instance; }
  void lock();
  void unlock();
  int islocked() { return locked; }
};
 
#endif