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

Go to the documentation of this file.

// =====================================================================================
//       Filename:  SDLTranslator.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 {
  namespace SDL {
    class Relay : public SystemClient, 
                   public Logger {
      public:
        Relay(System* const sys);
        virtual unsigned long int getTimeRef() const = 0; 

        void UpdateSystem(ModData& input);
        void UpdateSystem(InputData& input);

        void quit(); 
        virtual std::string getName() const;
     };


    class DefaultMouse : public Mouse {
      public:
        DefaultMouse(const std::string& name ); 
        DefaultMouse(); 
        virtual ~DefaultMouse() {}
        
        bool operator==(const Mouse& mouse);
      private:
       void init(); 
    };
  
   class DefaultKeyboard : public Keyboard {
     public:
       DefaultKeyboard() : Keyboard("Keyboard") {
        removeInput("Percent");            
       }

       virtual ~DefaultKeyboard() {}
   }; 

   class DeviceTranslator : public Relay {
     public:
       DeviceTranslator(System* const sys) : Relay(sys) {}  
       virtual ~DeviceTranslator() {};

       virtual std::string getName() const = 0;

       virtual bool translate(const SDL_Event& input_event) = 0;
       
       virtual DeviceRegistry& getDevices() = 0;

       virtual unsigned long int getTimeRef() const = 0;

       virtual bool addCustomDevice(InputDevice* device) = 0; 
       
       virtual bool operator==(const DeviceTranslator& rhs) const {
        log_debug("calling operator==");
        return (getName() == rhs.getName());
       }  
   }; 

    template <typename DeviceBase> class tDeviceTranslator :  public DeviceTranslator {
      public:
        tDeviceTranslator(System* const sys) : DeviceTranslator(sys) {}; 
        virtual bool translate(const SDL_Event& input_event) = 0;

        bool addCustomDevice(InputDevice* device) {
          DeviceBase* tmp_derived_ptr;

          if(!(tmp_derived_ptr= dynamic_cast<DeviceBase*>(device))) {
            log_error("addCustomDevice() not adding custom device due to cast check failure.");
            device->cleanup();
            delete device;
          }
          else {
            for(typename std::list<DeviceBase*>::iterator i = m_custom_devices.begin(); 
                i != m_custom_devices.end() ; ++i)
              if(*(*i) == *tmp_derived_ptr) {
                log_error("addCustomDevice() tried to add pre-existing controller type"); 
                return false;
              }

            log_debug(std::string("addCustomDevice() adding device type with name: ").append(device->getName())); 
            m_custom_devices.push_back( tmp_derived_ptr);
            return true;
          }

          return false;
        } 
        
        virtual DeviceRegistry& getDevices() = 0;

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

        unsigned long int getTimeRef() const {
          return (unsigned long)SDL_GetTicks(); 
        } 
        
      protected:
        friend class SDLTranslator;

        virtual ~tDeviceTranslator() {
          for(typename std::list<DeviceBase*>::iterator i = m_custom_devices.begin(); i != m_custom_devices.end() ; ++i) {
            if(*i) { (*i)->cleanup(); delete (*i); }
          }
        }

        std::list<DeviceBase*> m_custom_devices;
    };


    class SDLKeyboards : public tDeviceTranslator<Keyboard> {
      public:
        SDLKeyboards(System* const sys) : 
          tDeviceTranslator<Keyboard>(sys), 
          m_keyboard(NULL), 
          m_keys(SDLK_LAST) {}

        virtual ~SDLKeyboards() { 
          log_debug("dtor");
          if(m_keyboard) {
            log_debug("deleting keyboard");
            delete m_keyboard; 
          }
        };

        void setKey(SDLKey key, InputData* const press);

        Press* getData(SDLKey key) const { return m_keys.getData(key); }

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

        bool translate(const SDL_Event& input_event);

        DeviceRegistry& getDevices();

      private:
        void assign_inputs();

        InputDevice* m_keyboard;
        DeviceRegistry m_registry; 

        tInputIndex<Press> m_keys;
    };

    class SDLMice: public tDeviceTranslator<Mouse> {  
      public:
        SDLMice(System* const sys);

        virtual ~SDLMice() {
          if(m_mouse) {
            delete m_mouse;
          }
        };

        Coord* getPositioner() const { return m_positioner; }
        void setPositioner( InputData* const coord);

        DeviceRegistry& getDevices(); 

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

        bool translate(const SDL_Event& input_event);

      private:
        void assign_inputs();

        Mouse* m_mouse;
        DeviceRegistry m_registry; 
        tInputIndex<Press> m_buttons; 

        Coord* m_positioner;
    };

    class SDLControllers : public tDeviceTranslator<GameController> { 
      public:
        virtual ~SDLControllers() {
          for(std::vector<Device* >::iterator i = m_sdljoysticks.begin(); i != m_sdljoysticks.end(); ++i)
            if(*i) delete (*i);
        } 

        SDLControllers(System* const sys) : tDeviceTranslator<GameController>(sys) {}

        class Device {
          public:
            Device( const GameController& joy, SDL_Joystick* opened ); 

            virtual ~Device() {
              if(SDL_WasInit(SDL_INIT_JOYSTICK)) 
                if(m_opened_sdl_joy)
                  SDL_JoystickClose(m_opened_sdl_joy);
            }

            Axis* getAxis(unsigned int id) const {
              return m_axes.getData(id); 
            }

            Hat* getHat(unsigned int id) const {
              return m_hats.getData(id); 
            }

            Press* getButton(unsigned int id) const {
              return m_buttons.getData(id); 
            }

            Motion* getBall(unsigned int id) const {
              return m_balls.getData(id); 
            }

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

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

            SDL_Joystick* m_opened_sdl_joy;
        };

        Axis*   getAxis(unsigned int which, unsigned int id) const; 
        Hat*    getHat(unsigned int which, unsigned int id) const;
        Press*  getButton(unsigned int which, unsigned int id) const;
        Motion* getBall(unsigned int which, unsigned int id) const; 

        bool addController(const GameController* controller);

        DeviceRegistry& getDevices();
        std::string getName() const { return "SDLControllers"; }

        bool translate(const SDL_Event& input_event);

      private:
        bool translate(const SDL_JoyAxisEvent& jaxis);
        bool translate(const SDL_JoyBallEvent& jball);
        bool translate(const SDL_JoyHatEvent& jhat);
        bool translate(const SDL_JoyButtonEvent& jbutton, bool movement);

        std::vector<Device* > m_sdljoysticks;
        DeviceRegistry m_registry;
    };

    

    class SDLTranslator : public InputTranslator, SystemClient, Logger {
      public:

        SDLTranslator(System* const sys) : SystemClient(sys) {} 

        typedef std::list<DeviceTranslator*> DeviceTranslators;

        virtual bool addTranslated(DeviceTranslator* sdl_device);
        
        //TODO protect against duplicate calling
        DeviceRegistry& getDevices();

        virtual void poll();
        virtual void translate(const SDL_Event& input_event);

        virtual ~SDLTranslator() {
          log_debug("dtor");
          for(DeviceTranslators::iterator i = m_sdltranslators.begin(); i != m_sdltranslators.end() ; ++i)
            if(*i) { 
              log_debug("dtor : deleting device translator");
              delete (*i); 
            }
        }
        

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

        DeviceRegistry m_devices;
          
        DeviceTranslators m_sdltranslators;
        
        SDL_Event m_event;
    };

    enum Supported {
      Keyboards,
      Mice,
      Controllers 
    }; 

    class SupportedFactory: public Logger {
      public:
        std::string getName() const { return "DeviceTranslatorFactory"; }
        static DeviceTranslator* const create(const Supported type, System* const sys);
    };

  }
}

---