/home/jpf/code/cc/project/cmil/include/InputDevice.h

Go to the documentation of this file.

// =====================================================================================
//       Filename:  InputDevice.h 
//    Description:  
//        Created:  02/15/2007 08:47:46 PM EST
//       Revision:  none
//       Compiler:  gcc 3.4.6
// 
//         Author:  John P. Feltz 
//          Email:  jfeltz@gmail.com
//        License:  Copyright (c) 2006-2007, John P. Feltz 
//                  This program is free software; you can redistribute it and/or
//                  modify it under the terms of the GNU General Public License as
//                  published by the Free Software Foundation, version 2 of the
//                  License.
//                  This program is distributed in the hope that it will be
//                  useful, but WITHOUT ANY WARRANTY; without even the implied
//                  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//                  PURPOSE.
//                  See the GNU General Public License version 2 for more details.
// 
// =====================================================================================

namespace cmil { 
  class DeviceInputs : public Logger {
    public: 
      typedef std::map<const std::string, InputData* const> Inputs; 
      DeviceInputs() {};

      void cleanup();

      void add(const std::string& set_device_name, InputData* input);

      DeviceInputs* clone() const;

      void dumpInputs() const;

      const Inputs& getInputs() const; 
      const Inputs& getCustomInputs() const; 

      static const bool use_base = true;
      static const bool use_custom = false;

      InputData* const getData(bool which, const std::string& name) const;

      std::string getName() const;

      bool isEqual(bool match_custom, const DeviceInputs& inputs) const;

      bool operator==(const DeviceInputs& inputs) const;

      void removeInput(const std::string& name);

      unsigned long int resetIDs( unsigned long int count );

      void resetWhichDevice( unsigned long int which_device);

      bool setInput(const std::string& old_name, const std::string& new_name);
      bool setInputs(const DeviceInputs& dev_inputs);

    private:
      DeviceInputs(const Inputs& cloned_base, const Inputs& cloned_custom); 

      InputData* const getData(const Inputs& inputs, const std::string& name) const;

      bool match_inputs(const Inputs& first, const Inputs& second) const;

      bool erase(const std::string& name, Inputs& inputs);
      bool remove(const std::string& name, Inputs& inputs);

      bool renameData(Inputs& inputs, const std::string& old_name, const std::string& new_name);

      Inputs   m_base;

      Inputs   m_custom;
  };

  template <typename T> class tInputIndex : public Logger {
    public:
      tInputIndex(unsigned int size) : m_index(size, NULL) {}; 
      tInputIndex() {};

      bool addData(InputData* input);

      void fill_indexes(const std::string& device_name, const std::string& input_name, unsigned int num, DeviceInputs& inputs); 

      unsigned int getSize() const;


      bool setData(unsigned int i, InputData* input) {
        T* tmp_input_type;  

        if(m_index.size() >= i)
          if ( (tmp_input_type = dynamic_cast<T*>(input)) != 0 ) {
            if(m_index[i]) {
              log_error("setData() : InputData already present at key index value;  memory will be leaked.");
              delete input;

              return false;
            }
            else
              m_index[i] = tmp_input_type;
          }
          else
            return false;

        return true;
      }

      T* getData(unsigned int i) const; 

      std::string getName() const; 

      bool operator==(const tInputIndex<T>& other) const; 

    private:
      std::vector<T* > m_index;
  };


  class InputDevice : public Logger {
    public:
      ~InputDevice() {}

      virtual InputDevice* clone() const;

      void cleanup();


      void dumpInputs() const {
        m_inputs.dumpInputs();
      }


      std::string getName() const {
        return m_name;
      };

      InputData* const getData(const std::string& name) const;

      InputData* const getData(bool base_data, const std::string& name) const;


      virtual bool operator==(const InputDevice& dev) const; 

      const DeviceInputs& getInputs() const; 


      bool setInputs(const InputDevice& dev);

    protected:  
      friend class DeviceRegistry;

      InputDevice(); 

      InputDevice(const std::string& name,  const DeviceInputs& cloned_inputs );


      InputDevice( const std::string& name ); 

      unsigned long int resetIDs( const unsigned long int count );
      void resetWhichDevice( const unsigned long int which_device );
      void add( InputData* const input );


      void removeInput(const std::string& name);

      bool setInput(const std::string& old_name, const std::string& new_name);

      DeviceInputs m_inputs;

    private:
      std::string m_name;
  }; 


  class DeviceRegistry : public Logger {
    public: 
      typedef std::vector<InputDevice > DeviceMultiple;
      typedef std::map<const std::string, DeviceMultiple> DeviceIndex; 

      DeviceRegistry() {}

      void cleanup();
      void clear(); 

      virtual ~DeviceRegistry() {}; 

      virtual std::string getName() const {
        return "DeviceRegistry";
      }; 

      void registerDevice(InputDevice& dev);
      void mergeRegistry(DeviceRegistry& reg);
      void SetInputIDs(InputDevice& dev);

      int getSize() const;

      std::string getDefaultDevice() const;

      InputData* const  getData(unsigned int id) const; 
      InputData* const  getData(const Ev& event) const;
      

      int getID(const Ev& event) const;
      void integrityCheck() const;

    private:
      void copyDevice(InputDevice& dev);

      DeviceIndex m_index;

      std::string m_default_device;

      std::vector<InputData* > m_inputs;
  };

  class GameController : public InputDevice {
    public:
      GameController(const std::string& name, unsigned int axis, unsigned int buttons, unsigned int balls, 
                                      unsigned int hats); 

      //FIXME This kind of cloning falls victem to the same leaks as the mouse
      virtual InputDevice* clone() const;

     bool operator==(const GameController& controller) const; 

      tInputIndex<Axis>   m_axes;
      tInputIndex<Press>  m_buttons;
      tInputIndex<Motion> m_balls;
      tInputIndex<Hat>    m_hats;
  };


  class Keyboard : public InputDevice {
    public:
      std::string getName() const {
        return "Keyboard";
      }; 

      Keyboard(const std::string& name); 
      Keyboard();

      virtual InputDevice* clone() const; 

      bool operator==(const Keyboard& keyboard) const; 

    private:
     void init_inputs();
  };


  class Mouse : public InputDevice {
    public:
      Mouse(const std::string& name, 
                   unsigned int buttons,
                   unsigned int coords);
      //virtual ~Mouse() {}

      virtual InputDevice* clone() const; 

      virtual bool operator==(const Mouse& mouse) const;

      tInputIndex<Press>  m_buttons;
      tInputIndex<Coord>  m_coords;

    private:
      void init_inputs(const std::string& name, unsigned int buttons, unsigned int coords); 
  };
}

---