joystickManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/




#pragma once

#include <joystickCore/joystickCore.h>
#include <joystickCore/joystickConfigurations.h>
#include <joystickCore/gameControlInformation.h>
#include <joystickCore/joystickDevice.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtUnicode.h>
#include <vrvCore/DtEventProcessorInterface.h>

#include <string>
#include <map>

#include <boost/signals.hpp>
#include <boost/function.hpp>
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>

struct _SDL_Joystick;
union SDL_Event;

namespace makVrv
{
   class DtDe;
   class DtRecordSettingsBackupInterface;
   class DtGenericControllerEvent;

   class DT_DLL_JOYSTICKCORE DtGameControllerEventHandler
   {
   public:
      DtGameControllerEventHandler() {};
      virtual ~DtGameControllerEventHandler() {};

      virtual bool gameControllerEvent(DtGenericControllerEvent*) = 0;

      virtual bool canProcessEvent(DtGenericControllerEvent*) const
      {
         return true;
      }

      virtual void tick(bool sentEvents)
      {
      };

      virtual void gameControllerDeviceRemoved(int)
      {
      };

      virtual void gameControllerDeviceAdded(int)
      {
      };

      virtual bool filterGameControllerEvent(DtGenericControllerEvent*)
      {
         return false;
      }

      virtual void noQueuedEvents()
      {
      };

      virtual void gameControlInformationAdded(const std::string& configuration,
         const std::string& functionGroup, const std::string& function, const DtGameControlInformation& i)
      {
      }
   };

   class DT_DLL_JOYSTICKCORE DtJoystickManager : public DtEventProcessorInterface, public DtVirtualBaseClass
   {
   public:
      struct ControllerInformation
      {
         ControllerInformation() : controllerName(DtUnicode::fromAscii("")),
            deviceNumber(-1), type(GameControllerEventUnknown) {};

         ControllerInformation(const ControllerInformation& orig)
         : controllerName(orig.controllerName)
         , deviceNumber(orig.deviceNumber)
         , type(orig.type)
         , guid(orig.guid)
         {
         }

         ControllerInformation& operator=(const ControllerInformation& rhs)
         {
            controllerName = rhs.controllerName;
            deviceNumber = rhs.deviceNumber;
            type = rhs.type;
            guid = rhs.guid;

            return *this;
         }

         DtUnicode controllerName;
         std::string guid;
         int deviceNumber;
         GameControllerEventType type;
      };

      typedef boost::unordered_map<int, ControllerInformation> Controllers;

      DtJoystickManager(DtDe&);
      virtual ~DtJoystickManager();

      static DtJoystickManager& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtJoystickManager*);

      virtual void flushAllEvents();

      virtual ControllerInformation controllerInformation(int deviceId) const;

      virtual bool processMouseEvent( const DtMouseEvent& ev, DtChannel& channel);      
      
      virtual bool processKeyboardEvent( const DtKeyEvent& ev, DtChannel& channel);

      virtual bool switchControlActive(const std::string& configuration, const std::string& switchGroup) const;

      virtual DtGenericControllerEvent* genericEventFromSDLEvent(const SDL_Event&);

      virtual void removeGameControllerEventHandler(DtGameControllerEventHandler*);

      virtual void addGameControllerEventHandlerToFront(DtGameControllerEventHandler*);

      virtual void addGameControllerEventHandlerToEnd(DtGameControllerEventHandler*);

      virtual void addJoystickControlFunction(const std::string& functionGroup, const std::string& function,
         const DtFunctionGroupInformation&);
      virtual void addJoystickControlFunction(const std::string& functionGroup, const std::string& function,
         double minimumValue, double maximumValue, bool cycle = false, const std::string& description = "");

      virtual std::set<std::string> functionGroupsSimilarTo(const std::string& functionGroup) const;

      virtual void insertGameControllerEventHandlerBefore(DtGameControllerEventHandler*, DtGameControllerEventHandler*);

      typedef std::vector<DtGameControllerEventHandler*> GameControllerEventHandlers;
      const GameControllerEventHandlers& gameControllerEventHandlers() const { return myGameControllerEventHandlers; };

      virtual DtUnicode gameControllerName(const std::string& configuration,
         const std::string& functionGroup, const std::string& functionCode) const;
      virtual DtUnicode gameControllerFunction(const std::string& configuration,
         const std::string& functionGroup, const std::string& functionCode) const;

      virtual std::set<int> deviceIndexFromControllerInfo(const DtGameControlInformation&) const;
      virtual int deviceIndexFromGuid(const std::string&) const;
      virtual int deviceIndexFromDeviceName(const std::string&) const;
      virtual int firstDeviceIndexOfConrollerType(int) const;

      std::vector<std::string> functionsForFunctionGroup(const std::string&) const;

      virtual void setFavoriteConfiguration(const std::string&);
      virtual const std::string& favoriteConfiguration() const;

      virtual void increaseLockCount();
      virtual void decreaseLockCount();
      virtual bool locked() const;

      virtual double joystickDeadzonePercentage(int) const;
      virtual void setJoystickDeadzonePercentage(int, double);

      boost::signal<void ()> signal_clear;

      boost::signal<void (int, int)> signal_joystickError;

      boost::signal<void (const ControllerInformation&)> signal_controllerAdded;

      boost::signal<void (int)> signal_controllerRemoved;

      boost::signal<void (const DtJoystickConfigurations&)> signal_configurationsChanged;
      boost::signal<void (const std::string&, const DtJoystickConfigurationSettings&)> signal_settingsChanged;

      boost::signal<void (const std::string&, const std::string&)> signal_controllerInformationRemoved;

      boost::signal<void (const DtJoystickConfigurationSetting&)> signal_controllerInformationAdded;

      boost::signal<void (const std::string& functionGroup, const std::string& function,
         const DtFunctionGroupInformation&)> signal_addedJoystickControlFunction;

      boost::signal<void (int, DtGenericControllerEvent*)> signal_gameControllerEvent;

      boost::signal<void (const std::string&)> signal_configurationAdded;

      boost::signal<void (const std::string&)> signal_configurationRemoved;

      boost::signal<void (const std::string& old, const std::string& renamed)> signal_configurationRenamed;

      boost::signal<void (bool)> signal_joystickManagerLockedForUpdates;

      boost::signal<void (const std::string&, const std::string&)> signal_favoriteConfigurationChanged;

      virtual bool joystickSettingsForConfiguration(const std::string&, DtJoystickConfigurationSettings&);
      virtual void setJoystickSettingsForConfiguration(const std::string&, const DtJoystickConfigurationSettings&);

      const DtJoystickConfigurations& joystickConfigurations() { return myJoystickConfigurations; };
      virtual std::vector<std::string> configurations() const;

      virtual void setFromRecord(const DtJoystickConfigurations&);
      virtual void getRecord(DtJoystickConfigurations&);

      virtual int numJoystickAxis(int deviceIndex) const;

      virtual int numJoystickButtons(int deviceIndex) const;

      virtual int numJoystickHats(int deviceIndex) const;

      virtual bool needsTransition(const std::string& functionalGroup, const std::string& function) const;

      virtual bool toggle(const std::string& functionalGroup, const std::string& function) const;

      virtual bool cycle(const std::string& functionGroup, const std::string& function) const;

      virtual void getFunctionMinMaxValues(const std::string& functionalGroup, const std::string& function,
         double& min, double& max) const;

      virtual void loadDefaults(bool fromFactory = false);

      const DtRecordSettingsBackupInterface* settingsBackup() const
      {
         return mySettingsBackup;
      }

      DtRecordSettingsBackupInterface* settingsBackup()
      {
         return mySettingsBackup;
      }

      virtual Controllers controllers() const;

      void exportSettings(const std::string& fileName);

      void importSettings(const std::string& fileName);

      virtual DtGameControlInformation gameControlInformationFor(
         const std::string& configuration, const std::string& functionGroup, const std::string& function) const;

      virtual std::string descriptionFor(const std::string& functionGroup, const std::string& function) const;

      virtual void removeAllGameControllers();

      virtual void removeGameControlInformationFor(
         const std::string& configuration, const std::string& functionGroup, const std::string& function);

      virtual void addGameControlInformationFor(
         const std::string& configuration, const std::string& functionGroup, const std::string& function,
         const DtGameControlInformation&);

      virtual void setAutoSave(bool);
      virtual bool autoSave() const;

      virtual bool hasConfigurationName(const std::string&) const;

      virtual void addConfiguration(const std::string&);

      virtual void removeConfiguration(const std::string&);

      virtual bool functionGroupSpecified(const std::string& configuration, const std::string& functionGroup,
         bool all = false) const;

      virtual bool canFunctionGroupBeAssigned(const std::string& configuration, const std::string& functionGroup,
         bool all = false) const;

      virtual void renameConfiguration(const std::string& old, const std::string& renamed);

      virtual void saveAsDefaults();

      virtual DtJoystickConfigurationSettings::GameControlInformation gameControlInformation(
         const std::string& configuration, const std::set<std::string>&) const;

      virtual DtJoystickConfigurationSettings::GameControlInformation gameControlInformation(
         const std::string& configuration, const std::string&) const;

      virtual void getSplitRecord(std::vector<DtJoystickConfigurations>& rec,
         std::vector<std::string>& fileNames) {};

      virtual void addRecords(DtJoystickConfigurations& recs,
         DtJoystickConfigurations& combinedRec) {};

   protected:

      static int sdlEventFilterCallback(void *userdata, SDL_Event * event);
      virtual int sdlEventFilter(SDL_Event * event);
      virtual const std::string& className(); 

      void initialize();

      virtual void sendNoQueuedEvents();

      virtual void tick();

      virtual void initializeJoysticks();

      virtual void initializeGameControllers();

      virtual void initializeKeyboard();

      virtual void addJoystickDevice(int deviceId);

      virtual void removeJoystickDevice(int deviceId);

      virtual bool processControllerEvent(DtGenericControllerEvent*);

   protected:
      DtDe& myDe;

      typedef std::map<int, DtJoystickDevice> Joysticks;
      Joysticks myJoysticks;

      typedef std::map<std::string, std::set<int> > JoysticksByGuid;
      JoysticksByGuid myJoysticksByGuid;

      DtSignalConnectionManager myConnections;

      DtJoystickConfigurations myJoystickConfigurations;
      DtRecordSettingsBackupInterface* mySettingsBackup;

      GameControllerEventHandlers myGameControllerEventHandlers;

      int myLockCount;

      DtGameControllerJoystickEvent* myJoystickControllerEvent;
      DtGameControllerKeyboardEvent* myKeyboardControllerEvent;

      bool myAmEventProcessor;
      bool mySentEvent;

      typedef std::map<int, double> JoystickDeadzonePercent;
      JoystickDeadzonePercent myJoystickDeadzonePercent;

      ControllerInformation myKeyboardInformation;

      typedef std::vector<DtGenericControllerEvent*> JoystickEventQueue;
      JoystickEventQueue myJoystickEventQueue;
   };
}