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

Go to the documentation of this file.

// =====================================================================================
//       Filename:  InputData.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 Ev;
  class InputDevice;
  class InputIdentifiers;
  class InputRelay;

  const bool pressed = true;
  const bool released = false;


  namespace SDL {
    class Relay;  
  }
  
  class InputData : public Logger {
    public:
      InputData(const std::string& name) : m_state(true), m_name(name), m_id(0) {}; 

      virtual ~InputData() {}

      bool operator==(const InputData& other) {
        if(m_name == other.m_name) {
          return true;
        }
        else  { return false; }
      } 


      std::string getName() const;
      bool getState() const { return m_state; }
      unsigned long getTime() const { return m_time; };
      unsigned int getID() const { return m_id; }

      virtual Ev createEv() const;

      virtual InputData* clone() = 0;
      virtual bool isActionCompatible(InputAction* const action) const = 0 ;
      virtual void run(InputAction* const action) const = 0;
      
    protected:  
      friend class DeviceRegistry;
      friend class DeviceInputs;
      

      bool m_state;

      void setDevice(const std::string& device) { m_device = device; }

      void setName(const std::string& name) { 
        m_name = name; 
      }

      void setWhichDevice(int num_device) { m_num_device = num_device; }

      void setID(const int id) { m_id = id; }

    private:
      //FIXME this is wrong, InputData should have no notion of any kind of relay.
      friend class SDL::Relay;
      void setTime(unsigned long time) { m_time = time; };

      std::string m_name;
      unsigned long m_time;
      
      unsigned int m_id;

      std::string m_device; 
      unsigned int m_num_device;  
    
      InputData& operator=(const InputData& );
  };

  template <typename ActionType> class tInputData : public InputData {
    public:
      tInputData(const std::string& name) : InputData(name) {} 

      bool isActionCompatible(InputAction* const action) const {
        log_debug( std::string("template isActionCompatible() typeid(*action).name() : ")
            .append(typeid(*action).name()));

        if(action) {
            log_debug( "template isActionCompatible() running cast test" );
          if(dynamic_cast<ActionType*>(action) != 0) {
            log_debug( "template isActionCompatible() finished cast test" );
            return true;
          }
        }

        log_debug( "template isActionCompatible() returning false" );
        return false;
      }

      virtual void run(InputAction* const action) const {
        ActionType* tmp_action_type;

        if(action) {
          if((tmp_action_type = dynamic_cast<ActionType*> (action)) != 0) {
            do_run(tmp_action_type);
          }
          else 
            log_debug("run()  unable to run action due to incompatible action type. " );
        }
        else  
          log_error("run() called on a null action");
      }

    private:
      virtual void do_run(ActionType* action) const = 0;
  };

  class ModAction : public virtual InputAction {
    public:
      ModAction(const std::string& name) : InputAction(name) {}

      void Movement(bool movement) {
        if (movement == pressed) {
          doPress();
        }
        else  {
          doRelease();
        }
      }

    virtual void doPress() = 0; 
    virtual void doRelease() {}; 
  };

  class ModData : public tInputData<ModAction> {
    public:
      ModData(const std::string& ident) : tInputData<ModAction>(ident) {};

      virtual InputData* clone() = 0;

      virtual void do_run(ModAction* action) const = 0; 

      void setState(const bool state) { m_state = state; }
  };

  class Press : public ModData {
    public:
      Press(const std::string& ident) : ModData(ident) {};

      virtual InputData* clone() {
        return new Press(*this);
      };

      void do_run(ModAction* action) const {
        action->Movement(m_state);
      }
  };

  class AxisAction : public virtual InputAction {
    public:
      AxisAction(const std::string& name) : InputAction(name) {}
      virtual void runAxis(signed int axis) = 0; 
  };

  class Axis : public tInputData<AxisAction> {
    public:
      Axis(const std::string& ident) : tInputData<AxisAction>(ident), m_axis(0) {}

      virtual InputData* clone() {
        return new Axis(*this);
      };

      virtual void setAxis(signed int axis) {
        m_axis = axis;
      }
        
      void do_run(AxisAction* action) const {
        action->runAxis(m_axis);
      }
      
    private:
      signed int m_axis;
  };

  class MotionAction : public virtual InputAction {
    public:
      MotionAction(const std::string& name) : InputAction(name) {}
      virtual void runMotion(unsigned int xrel, unsigned long int yrel) = 0; 
  };
  
  class Motion : public tInputData<MotionAction> {
    public:
      Motion(const std::string& ident) : tInputData<MotionAction>(ident), m_xrel(0), m_yrel(0) {}

      virtual InputData* clone() {
        return new Motion(*this);
      };


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

      void do_run(MotionAction* action) const {
        action->runMotion(m_xrel, m_yrel);
      }

      void setMotion(int xrel, int yrel) {
        if( ((xrel * yrel) <= 1) )  {
          m_xrel = xrel;
          m_yrel = yrel;
        }
        else 
          log_error("setMotion() unable to to set motion due to relative bounds exceeded");
      }
        
    private:
      unsigned int m_xrel; 
      unsigned int m_yrel; 
  };

  class CoordAction : public virtual InputAction {
    public:
      CoordAction(const std::string& name) : InputAction(name) {}
      virtual void runCoord(unsigned long int x, unsigned long int y, int xrel, int yrel) = 0; 
  };
  
  class Coord : public tInputData<CoordAction> {
    public:
      Coord(const std::string& ident) : tInputData<CoordAction>(ident), m_x(0), m_y(0), m_xrel(0), m_yrel(0) {}

      virtual InputData* clone() {
        return new Coord(*this);
      };


      virtual void setCoord(int x, int y, int xrel, int yrel) {
        m_x=x;
        m_y=y;
        m_xrel=xrel;
        m_yrel=yrel;
      }; 

      void do_run(CoordAction* action) const {
        action->runCoord(m_x, m_y, m_xrel, m_yrel);
      };

    private:
      //These values store the screen position.
      int m_x,m_y;
      
      //These values store relative movement. 
      int m_xrel,m_yrel;
  };

  class HatAction : public virtual InputAction {
    public:
      enum Position {
        Centered, 
        Up,
        Right,
        Down,
        Left,
        RightUp,  
        RightDown,
        LeftUp, 
        LeftDown
      };

      HatAction(const std::string& name) : InputAction(name) {}
      virtual void Movement(Position pos) = 0; 
  };

  class Hat : public tInputData<HatAction> {
    public:
      Hat(const std::string& ident) : tInputData<HatAction>(ident) {}

      virtual InputData* clone() {
        return new Hat(*this);
      };

      virtual void setPosition(HatAction::Position pos) {
        m_pos = pos;
      }; 
      const HatAction::Position getPosition() const {
        return m_pos; 
      }; 

      void do_run(HatAction* action) const {
        action->Movement(m_pos);
      };
    private:
      HatAction::Position m_pos;
  };
}

---