/home/jpf/code/cc/project/cmil/src/InputDevice.cpp

Go to the documentation of this file.

// =====================================================================================
//       Filename:  InputDevice.cpp 
//    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.
// 
// =====================================================================================


#include <iostream>
#include <map>
#include <vector>
#include <deque>
#include <sstream>

#include <util/Singleton.h>
#include <util/Logger.h>

#include <InputAction.h>
#include <InputData.h>
#include <InputEv.h>
#include <InputDevice.h>

namespace cmil {

  DeviceInputs::DeviceInputs(const Inputs& cloned_base, const Inputs& cloned_custom) {
    InputData* input_data = NULL;

    Inputs::const_iterator i, i_custom;
    std::string custom_name;

    for(i = cloned_base.begin(); i != cloned_base.end(); ++i) {
      input_data = (*i).second->clone();

      std::pair<std::string, InputData* const> input_pair ( (*i).first, input_data ); 
      m_base.insert(input_pair); 
    }

    if(cloned_custom.size()) {
      if(cloned_custom.size() != cloned_base.size()) 
        log_error("DevceInputs(cloned_base, cloned_custom) : parameter indexes are not equal in size."); 
      else {
        i_custom = cloned_custom.begin();

        for(i = m_base.begin(); i != m_base.end(); ++i) {
          input_data = i->second;

          std::pair<std::string, InputData* const> input_pair ((*i_custom).first, input_data); 
          m_custom.insert(input_pair);  
          ++i_custom;
        }
      }
    } 
  }
  
  void DeviceInputs::cleanup() {
    Inputs::iterator i;
    int dcount = 0;

    for(i = m_base.begin() ; i != m_base.end() ; ++i) {
      if(i->second) {
        delete (i->second);
        dcount++;
      }
    }

    std::ostringstream debug_ss;
    debug_ss << "cleanup() deleted memory consisting of : " << dcount  << " addresses.";
    log_debug( debug_ss.str() );
  }

  void DeviceInputs::dumpInputs() const {
    for( Inputs::const_iterator i = m_custom.begin(); i != m_custom.end(); ++i) 
      log_debug( std::string("Dumping custom, input name: ").append( i->first ) ); 
  }

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

  DeviceInputs* DeviceInputs::clone() const {
    log_debug("clone()");
    return new DeviceInputs(m_base, m_custom);
  }

  void DeviceInputs::add(const std::string& device_name, InputData* input) {
    if(!input)
      log_error("add() passed null input");
    else {
      if( m_base.find(input->getName()) != m_base.end() )
        log_error(std::string("DeviceInputs::add() insertion of ").append(input->getName()).append( 
            "failed due to pre-existing input of the same name"));
      else {
        input->setDevice(device_name);
        std::pair<std::string, InputData* const> input_pair (input->getName(), input); 
//        log_debug(std::string("adding: ").append(input->getName()));
        m_base.insert(input_pair);  
      }
    }
  }

  bool DeviceInputs::erase(const std::string& name, Inputs& inputs) { 
    if(inputs.find(name) == inputs.end()) {
      log_error("remove() tried to remove non-existant input");
      return false;
    }
    else {
      delete inputs[name];
      inputs.erase(name);
    }

    return true;
  } 

  const DeviceInputs::Inputs& DeviceInputs::getInputs() const {
    return m_base;
  }

  const DeviceInputs::Inputs& DeviceInputs::getCustomInputs() const {
    return m_custom;
  }


  bool DeviceInputs::remove(const std::string& name, Inputs& inputs) {
    if(inputs.find(name) == inputs.end()) {
      log_debug("remove() Tried to remove non-existant input.");
      return false;
    }
    else {
      inputs.erase(name);
    }

    return true;
  }

  InputData* const DeviceInputs::getData(const Inputs& inputs, const std::string& name) const {
    Inputs::const_iterator i = inputs.find(name);

    if (i != inputs.end() ) { 
       //log_debug(std::string("getData() returning data for string: ").append(name)); 
       return i->second;
    }

    log_error(std::string("getData() returning NULL for string: ").append(name)); 

//    std::ostringstream num_ss; 
//    for(i = inputs.begin() ; i != inputs.end() ; i++)
//      log_error(std::string("getData() scanned : ").append(i->first)); 

    return NULL;
  }

  InputData* const DeviceInputs::getData(bool base_data, const std::string& name) const {
    if(base_data || (m_custom.size() == 0)) {
      //log_debug("getData(bool, name) : calling on base");
      return getData(m_base, name);
    }

    //log_debug("getData(bool, name) : calling on custom");
    return getData(m_custom, name);
  }

  bool DeviceInputs::operator==(const DeviceInputs& devinputs) const {
    const bool match_custom = true;

    if(isEqual(match_custom, devinputs)) {
      log_debug("operator== match_inputs returning true");
      return true;
    }

    log_error("operator== match_inputs returning false");
    return false;
  }

  bool DeviceInputs::isEqual(bool match_custom, const DeviceInputs& devinputs) const {
    log_debug("isEqual()");
    bool is_equal = false;
    if(match_custom) 
      is_equal = match_inputs(m_custom, devinputs.getCustomInputs());
    
    is_equal = match_inputs(m_base, devinputs.getInputs());
    return is_equal;
  }

  bool DeviceInputs::match_inputs(const Inputs& first, const Inputs& second) const {
    Inputs::const_iterator a, b;

    if(first.size() != second.size()) 
      return false;

    for(a = first.begin() ; a != first.end(); ++a) {
      b = second.find(a->first);

      if(b == second.end()) {
        log_error( "match_inputs() returning false due to input name mismatch");
        return false;
      }
      else if ( typeid(*(a->second)) != typeid(*(b->second)) ) {
        log_error( "match_inputs() returning false due to type mismatch");
        return false;
      }
    }
      
    return true;
  }

  void DeviceInputs::removeInput(const std::string& name) {
    if(m_custom.size())
     remove(name, m_custom);
   erase(name, m_base);
  }

  bool DeviceInputs::setInputs(const DeviceInputs& dev_inputs) {
    const bool match_base = false;
    std::string base_name, custom_name;
    Inputs::const_iterator i, i_custom;

    if( !(isEqual(match_base, dev_inputs)) ) {
      log_error("setInputs() This operation isn't allowed due to DeviceInputs base mismatch"); 
      return false;
    }
    else {
      if(dev_inputs.getInputs().size() != dev_inputs.getCustomInputs().size()) {
        log_error("setInputs() This operation isn't allowed due to a mismatch in size of parameter inputs."); 
        return false;
      }
    }

    m_custom.clear(); 

    
    for(i = dev_inputs.getInputs().begin(); i != dev_inputs.getInputs().end(); ++i) 
      setInput(i->first, i->second->getName());

    return true;
  }

  unsigned long int DeviceInputs::resetIDs( unsigned long int count ) {
    log_debug("resetting base IDs");
    Inputs::iterator i;
    for(i = m_base.begin(); i != m_base.end(); ++i)  
      (i->second)->setID(count++);

    return count;
  }

  void DeviceInputs::resetWhichDevice( unsigned long int which_device) {
    Inputs::iterator i;
    for(i = m_base.begin(); i != m_base.end(); ++i) 
      (i->second)->setWhichDevice(which_device);
  }

  bool DeviceInputs::renameData(Inputs& inputs, const std::string& old_name, const std::string& new_name) {
    InputData* tmp_ptr = NULL;  
    Inputs::iterator i; 

    if( inputs.find(new_name) != inputs.end() ) {
      //log_error("renameData() tried to set name to pre-existing input"); 
      return false;
    }
    else if( ( (i = inputs.find(old_name)) == inputs.end()) ) {
      log_error("renameData() input to be renamed doesn't exist"); 
      return false;
    }
    else if(!(tmp_ptr= inputs[old_name])) {
      log_error("renameData() InputData found null at old_name"); 
      return false;
    }

    log_debug(std::string("setting data old name: ").append(old_name).append(" to: ").append(new_name));

    tmp_ptr -> setName(new_name);

    inputs.erase(inputs.find(old_name));

    std::pair<std::string, InputData* const> input_pair (new_name, tmp_ptr); 
    inputs.insert(input_pair);

    return true;
  }

  bool DeviceInputs::setInput(const std::string& old_name, const std::string& new_name) {
    if(!m_custom.size())
      m_custom = m_base;

    if( renameData(m_custom, old_name, new_name) )
      return true;

    //log_error("setInput() failed to rename input");
    return false;
  }

  template <typename T> bool tInputIndex<T>::addData(InputData* input) {
    T* tmp_input_type;  

    if(!input) {
      log_error("addData(input) failed to add due to null input passed.");
      return false;
    }
    if ( (tmp_input_type = dynamic_cast<T*>(input)) != 0 ) {
      m_index.push_back(tmp_input_type);
      return true;
    }
    else {
      log_error("addData(input) failed to add due to casting failure.");
      return false;
    }
  } 

  template <typename T> void tInputIndex<T>::fill_indexes(const std::string& device_name, 
                                                     const std::string& input_name, 
                                                    unsigned int num, 
                                                    DeviceInputs& inputs) {

    std::ostringstream numeral_ss;
    T* tmp_input;

    for(unsigned int i = 0; i < num; ++i) {
      numeral_ss << input_name << i;
      tmp_input = new T(numeral_ss.str());

      inputs.add(device_name, tmp_input);

      addData(tmp_input);

      numeral_ss.str("");
    }

    InputData *input_d = NULL;

    for(unsigned int i = 0; i < num; ++i) {
      numeral_ss << input_name << i;
      input_d = getData(i);
      //std::cout << "input named: " << input_d->getName() << " stored in data indexed as:" << numeral_ss.str() <<   std::endl;
      numeral_ss.str("");
    }
  }

  template <typename T> unsigned int tInputIndex<T>::getSize() const {
    return m_index.size();
  }

  template <typename T> T* tInputIndex<T>::getData(unsigned int i) const {
    if(i <= m_index.size())
      return m_index[i];
    return NULL;
  }

  template <typename T> std::string tInputIndex<T>::getName() const {
    return "tInputIndex";
  }

  template <typename T> bool tInputIndex<T>::operator==(const tInputIndex<T>& other) const {
    if(m_index.size() != other.m_index.size())
      return false;
    else 
      for(unsigned int i = 0 ; i < m_index.size() ; ++i) 
        if( typeid(*(m_index[i])) != typeid(*(other.m_index[i])) ) 
          return false;

    return true;
  }
  
  InputDevice::InputDevice() {};

  InputDevice::InputDevice(const std::string& name, const DeviceInputs& cloned_inputs) : 
    m_inputs(*(cloned_inputs.clone())), m_name(name) {};

  InputDevice::InputDevice( const std::string& name) : m_name(name) {};

  unsigned long int InputDevice::resetIDs( const unsigned long int count ) {
    log_debug("deferring resetIDs to m_inputs");
    return m_inputs.resetIDs(count);
  };
  
  void InputDevice::resetWhichDevice( const unsigned long int which_device) {
    m_inputs.resetWhichDevice(which_device);
  };

  void InputDevice::add(InputData* const input) {
     m_inputs.add(m_name, input);
  };

  void InputDevice::removeInput(const std::string& name) {
    m_inputs.removeInput(name);
  };

  bool InputDevice::setInput(const std::string& old_name, const std::string& new_name) {
    return m_inputs.setInput(old_name, new_name);
  };

  bool InputDevice::setInputs(const InputDevice& dev) {
    return m_inputs.setInputs(dev.getInputs());
  };

  void InputDevice::cleanup() {
    log_debug(std::string("cleanup() of device named: ").append(m_name)); 
    m_inputs.cleanup();
  };

  InputDevice* InputDevice::clone() const {
    return new InputDevice(m_name, m_inputs);
  };

  InputData* const InputDevice::getData(const std::string& name) const {
    return getData(DeviceInputs::use_base, name); 
  };

  const DeviceInputs& InputDevice::getInputs() const {  
    return m_inputs;
  };

  InputData* const InputDevice::getData(bool base_data, const std::string& name) const {
    return m_inputs.getData(base_data, name); 
  };

  bool InputDevice::operator==(const InputDevice& dev) const { 
    log_debug("(base) operator== comparing input data");
    return ((m_name == dev.m_name) && (m_inputs == dev.m_inputs));
  };

  void DeviceRegistry::clear() {
    log_debug("cleanup()");
    std::cout << "registry size: " << getSize() << std::endl;
    DeviceIndex::iterator di_iter;
    DeviceMultiple::iterator dm_iter;
    for(di_iter = m_index.begin() ; di_iter != m_index.end() ; ++di_iter) 
      di_iter->second.clear();
    m_index.clear();
  }

  void DeviceRegistry::cleanup() {
    log_debug("cleanup()");
    std::cout << "registry size: " << getSize() << std::endl;
    DeviceIndex::iterator di_iter;
    DeviceMultiple::iterator dm_iter;
    for(di_iter = m_index.begin() ; di_iter != m_index.end() ; ++di_iter) 
      for(dm_iter = di_iter->second.begin() ; dm_iter != di_iter->second.end() ; ++dm_iter) { 
        log_debug("calling dm_iter->cleanup()");
        dm_iter->cleanup();
      }
  };

  std::string DeviceRegistry::getDefaultDevice() const {
    return m_default_device;
  };

  InputData* const DeviceRegistry::getData(unsigned int id) const {
    if(id <= m_inputs.size())
      return m_inputs[id];

    log_error("getData(id) bounds error, returnning NULL");
    return NULL;
  };

  InputData* const  DeviceRegistry::getData(const Ev& event) const {
    std::string name; 

    if((name = event.getDeviceName()) == "") {
      name = getDefaultDevice(); 
      log_debug(std::string("getData() setting name to default: ").append(name));
    }
    if(name == "")
      log_error("getData() returning null since no default device is available.");
    else {
      log_debug(std::string("getData() for device name: ").append(name));


      DeviceIndex::const_iterator i = m_index.find(name); 

      std::ostringstream size_ss;

      if(i != m_index.end()) 
        if(i->second.size() >= event.getDeviceMultiple()) {
          size_ss << "getData() number of devices with name: " << i->second.size();
          log_debug(size_ss.str());

          return i->second[event.getDeviceMultiple()].getData(DeviceInputs::use_custom, event.getName());
        }
    }

    log_error("getData() returning null");
    return NULL;
  };

  int DeviceRegistry::getID(const Ev& event) const {
    if(getData(event)) {
      log_debug("getID() found data matching event, returning id");
      return getData(event)->getID();
    }
    else {
      log_error("getID() no id found in registry which matched id");
      return 0;
    }
  };

   int DeviceRegistry::getSize() const{
     return m_inputs.size();
  };

  void DeviceRegistry::mergeRegistry(DeviceRegistry& reg) {
    log_debug("mergeRegistery() ");
    for(DeviceIndex::iterator di_iter = reg.m_index.begin() ; di_iter != reg.m_index.end() ; ++di_iter) 
      for(DeviceMultiple::iterator dm_iter = di_iter->second.begin() ; dm_iter != di_iter->second.end() ; ++dm_iter) {
        registerDevice(*dm_iter);
        log_debug(std::string("mergeRegistery() calling registerDevice() with name: ").append((*dm_iter).getName()));
      }
  };

   void DeviceRegistry::registerDevice(InputDevice& dev) {
     DeviceIndex::iterator i;

     if( (i=m_index.find(dev.getName())) == m_index.end())  {

       log_debug(std::string("registerDevice() adding device named: ").append(dev.getName()));

       if(m_index.empty()) {
         log_debug(std::string("registerDevice() setting default device to: ").append(dev.getName()));
         m_default_device = dev.getName();
       }
       copyDevice(dev); 
     }
     else {
       if ( *(i->second.begin()) == dev) {
         log_debug(std::string("registerDevices() registering another device of the same type and name: ").append(dev.getName()));
        
         copyDevice(dev); 
       }
       else {
         log_error(std::string("registerDevices() not adding device of the same name and type: ").append(dev.getName()).
           append("due to member unequality."));
       }
     }
  }

   void DeviceRegistry::copyDevice(InputDevice& dev) {
     DeviceInputs::Inputs::const_iterator i;
     int which_device;

     log_debug("copyDevice(): copying device");
     m_index[dev.getName()].push_back(dev);

     which_device = m_index[dev.getName()].size();

     //TODO Reverse lookup features should probably be decoupled from the InputData type instead, but this makes things fast. 

     dev.resetIDs(m_inputs.size());
     dev.resetWhichDevice(which_device);

     for(i = dev.getInputs().getCustomInputs().begin(); i != dev.getInputs().getCustomInputs().end(); ++i) 
       m_inputs.push_back(i->second); 

   }

  GameController::GameController(const std::string& name, 
                                unsigned int axes, 
                                unsigned int buttons, 
                                unsigned int balls, 
                                unsigned int hats) 
                                : InputDevice(name) {
    m_axes.fill_indexes (name, "axis",   axes,    m_inputs);
    m_buttons.fill_indexes (name, "button", buttons, m_inputs);
    m_balls.fill_indexes (name, "ball",   balls,   m_inputs);
    m_hats.fill_indexes (name, "hat",    hats,    m_inputs);
  }

  InputDevice* GameController::clone() const {
    log_debug("clone() ");
    InputDevice* clone = new GameController(getName(), m_axes.getSize(), m_buttons.getSize(), m_balls.getSize(), m_hats.getSize()); 

    clone->setInputs( *this );

    log_debug("clone() returning clone");
    return clone;
  };

  bool GameController::operator==(const GameController& controller) const { 
    log_debug("operator=="); 
    if ((m_axes == controller.m_axes) ||
      (m_buttons == controller.m_buttons) ||
      (m_balls   == controller.m_balls) ||
      (m_hats    == controller.m_hats)) {
    log_debug("operator== returning false due to member mismatch"); 
    return false;
    }

    return ((getName() == controller.getName()) && (m_inputs == controller.getInputs()));
  };

   Keyboard::Keyboard(const std::string& name) : InputDevice(name) {
     log_debug("Keyboard constructing");
     init_inputs();
   };

   Keyboard::Keyboard() : InputDevice("Keyboard") {
     init_inputs();
   };

   void Keyboard::init_inputs() {
      //Function keys
      add(new Press("Escape"));
      add(new Press("F1"));  add(new Press("F2"));
      add(new Press("F3"));  add(new Press("F4"));
      add(new Press("F5"));  add(new Press("F6")); 
      add(new Press("F7"));  add(new Press("F8")); 
      add(new Press("F9"));  add(new Press("F10")); 
      add(new Press("F11")); add(new Press("F12")); 

      add(new Press("Print")); add(new Press("Scroll Lock"));
      add(new Press("Pause"));

      //Numbers and their alternate
      add(new Press("1"));        add(new Press("Exclaimation Mark"));  
      add(new Press("2"));        add(new Press("@"));                  
      add(new Press("3"));        add(new Press("Hash"));               
      add(new Press("4"));        add(new Press("Dollar Sign"));        
      add(new Press("5"));        add(new Press("Percent"));            
      add(new Press("6"));        add(new Press("Caret"));              
      add(new Press("7"));        add(new Press("Ampersand"));          
      add(new Press("8"));        add(new Press("Asterisk"));           
      add(new Press("9"));        add(new Press("Left Parenthesis"));   
      add(new Press("0"));        add(new Press("Right Parenthesis"));  
      add(new Press("Minus"));    add(new Press("Underscore")); 
      add(new Press("Plus"));     add(new Press("Equals")); 
      add(new Press("Backspace"));  

      add(new Press("Q")); add(new Press("W")); add(new Press("E"));
      add(new Press("R")); add(new Press("T")); add(new Press("Y"));
      add(new Press("U")); add(new Press("I")); add(new Press("O"));
      add(new Press("P")); add(new Press("A")); add(new Press("S"));
      add(new Press("D")); add(new Press("F")); add(new Press("G"));
      add(new Press("H")); add(new Press("J")); add(new Press("K")); 
      add(new Press("L")); add(new Press("Z")); add(new Press("X")); 
      add(new Press("C")); add(new Press("V")); add(new Press("B")); 
      add(new Press("N")); add(new Press("M")); 

      //Symbols and their alternate
      add(new Press("Tab")); 
      add(new Press("Capslock")); 

      add(new Press("Less Than"));    add(new Press("Comma")); 
      add(new Press("Greater Than")); add(new Press("Period")); 

      add(new Press("Left Shift")); 
      add(new Press("Right Shift")); 
      add(new Press("Shift")); 

      add(new Press("Left Ctrl")); 
      add(new Press("Right Ctrl")); 
      add(new Press("Ctrl")); 

      add(new Press("Left Alt")); 
      add(new Press("Right Alt")); 
      add(new Press("Alt")); 

      add(new Press("Return")); 
      add(new Press("Space")); 

      add(new Press("Insert"));
      add(new Press("Home"));
      add(new Press("Page Up"));
      add(new Press("Delete"));
      add(new Press("End"));
      add(new Press("Page Down"));

      add(new Press("Left")); 
      add(new Press("Right")); 
      add(new Press("Up")); 
      add(new Press("Down")); 

      add(new Press("NumLock"));
      add(new Press("Keypad Forward Slash"));
      add(new Press("Keypad Asterisk")); 
      add(new Press("Keypad Minus ")); 
      add(new Press("Keypad Plus")); 
      add(new Press("Keypad Enter")); 

      add(new Press("Keypad Zero"));      add(new Press("Keypad Insert")); 
      add(new Press("Keypad Period"));    add(new Press("Keypad Delete")); 

      add(new Press("Keypad Left"));      add(new Press("Keypad 4")); 
      add(new Press("Keypad Right"));     add(new Press("Keypad 6")); 
      add(new Press("Keypad Up"));        add(new Press("Keypad 8")); 
      add(new Press("Keypad Down"));      add(new Press("Keypad 2")); 

      add(new Press("Keypad Home"));      add(new Press("Keypad 7")); 
      add(new Press("Keypad Page Up"));   add(new Press("Keypad 9")); 
      add(new Press("Keypad Page Down")); add(new Press("Keypad 3")); 
      add(new Press("Keypad End"));       add(new Press("Keypad 1"));
      add(new Press("Keypad 5"));

      add(new Press("Foward Slash"));     add(new Press("Question Mark"));     
      add(new Press("|"));                add(new Press("Back Slash")); 
      add(new Press("Right Bracket")); 
      add(new Press("Left Bracket")); 
      add(new Press("Backquote")); 
      add(new Press("Colon"));            add(new Press("Semi Colon")); 
      add(new Press("Double Quote"));     add(new Press("Quote")); 
   };

   bool Keyboard::operator==(const Keyboard& keyboard) const { 
     log_debug("(Keyboard) operator== Keyboard& ");
     return (m_inputs == keyboard.getInputs());
   };

  InputDevice* Keyboard::clone() const {
    InputDevice* clone = new Keyboard(getName()); 
    clone->setInputs( *this ); 
    return clone;
  };

   Mouse::Mouse(const std::string& name, 
               unsigned int buttons,
               unsigned int coords) : 
                 InputDevice(name) {
      init_inputs( name, buttons, coords );
   }

  void Mouse::init_inputs(const std::string& name, unsigned int buttons, unsigned int coords)  {
    m_buttons.fill_indexes(name, "button",   buttons,    m_inputs);
    m_coords.fill_indexes(name, "coord",     coords,    m_inputs);
  };

  InputDevice* Mouse::clone() const {
    log_debug( "Mouse clone()" );

    InputDevice* clone = new Mouse(getName(), m_buttons.getSize(), m_coords.getSize()); 

    clone->setInputs( *this );
    log_debug("clone() returning clone");
    return clone;
  }

  bool Mouse::operator==(const Mouse& mouse) const {
    log_debug("(Mouse) operator== Mouse& ");

    if(!(m_buttons == mouse.m_buttons) && (m_coords == mouse.m_coords))
      return false;
    
    if ( ( m_inputs.getInputs() == mouse.getInputs().getInputs()) ) 
      return false;
    return true;
  };
}

---