Merge branch 'thumbbehavior'

Author: calebtt

XMapLib/CPPRunnerGeneric.h

@@ -32,8 +32,8 @@ namespace sds
 		const LambdaType m_lambda;
 		InternalData m_local_state{}; // default constructed type InternalData
 		std::atomic<bool> m_is_stop_requested{ false };
-		std::unique_ptr<std::thread> m_local_thread;
-		std::mutex m_state_mutex;
+		std::unique_ptr<std::thread> m_local_thread{};
+		std::mutex m_state_mutex{};
 	public:
 		/// <summary>Starts running a new thread for the lambda.</summary>
 		///	<returns>true on success, false on failure.</returns>

XMapLib/DelayManager.h

@@ -7,13 +7,13 @@ namespace sds::Utilities
 	class DelayManager
 	{
 		using TimeType = std::chrono::time_point<std::chrono::high_resolution_clock>;
-		TimeType m_start_time = std::chrono::high_resolution_clock::now();
-		size_t m_duration = 1;
-		bool m_has_fired = false;
+		TimeType m_start_time{ std::chrono::high_resolution_clock::now() };
+		size_t m_duration{ 1 };
+		bool m_has_fired{ false };
 	public:
 		//us is microseconds
 		DelayManager() = delete;
-		DelayManager(size_t duration_us) : m_duration(duration_us) { }
+		explicit DelayManager(size_t duration_us) : m_duration(duration_us) { }
 		DelayManager(const DelayManager& other) = default;
 		DelayManager(DelayManager&& other) = default;
 		DelayManager& operator=(const DelayManager& other) = default;

XMapLib/KeyboardInputPoller.h

@@ -13,9 +13,9 @@ namespace sds
 		using InternalType = std::vector<XINPUT_KEYSTROKE>;
 		using LambdaRunnerType = sds::CPPRunnerGeneric<InternalType>;
 		using lock = LambdaRunnerType::ScopedLockType;
-		const int EMPTY_COUNT = 5000;
-		KeyboardPlayerInfo m_local_player;
-		std::unique_ptr<LambdaRunnerType> m_workThread;
+		const int EMPTY_COUNT{ 5000 };
+		KeyboardPlayerInfo m_local_player{};
+		std::unique_ptr<LambdaRunnerType> m_workThread{};
 		void InitWorkThread() noexcept
 		{
 			m_workThread =
@@ -33,58 +33,43 @@ namespace sds
 		KeyboardInputPoller(KeyboardInputPoller&& other) = delete;
 		KeyboardInputPoller& operator=(const KeyboardInputPoller& other) = delete;
 		KeyboardInputPoller& operator=(KeyboardInputPoller&& other) = delete;
-		/// <summary>
-		/// Destructor override, ensures the running thread function is stopped
-		/// inside of this class and not the base.
-		/// </summary>
-		~KeyboardInputPoller()
-		{
-			Stop();
-		}
+		~KeyboardInputPoller() = default;
+
+		/// <summary>Returns copy and clears internal one.</summary>
 		std::vector<XINPUT_KEYSTROKE> getAndClearStates() const
 		{
 			return m_workThread->GetAndClearCurrentStates();
 		}
-		/// <summary>
-		/// Start polling for updated XINPUT_STATE info.
-		/// </summary>
+		/// <summary>Start polling for updated XINPUT_KEYSTROKE info.</summary>
 		void Start() const noexcept
 		{
 			if (m_workThread)
 				m_workThread->StartThread();
 		}
-		/// <summary>
-		/// Stop input polling.
-		/// </summary>
+		/// <summary>Stop input polling.</summary>
 		void Stop() const noexcept
 		{
 			if (m_workThread)
 				m_workThread->StopThread();
 		}
-		/// <summary>
-		/// Gets the running status of the worker thread
-		/// </summary>
+		/// <summary>Gets the running status of the worker thread</summary>
 		/// <returns> true if thread is running, false otherwise</returns>
 		bool IsRunning() const noexcept
 		{
 			if (m_workThread)
 				return m_workThread->IsRunning();
 			return false;
 		}
-		/// <summary>
-		/// Returns status of XINPUT library detecting a controller.
-		/// </summary>
+		/// <summary>Returns status of XINPUT library detecting a controller.</summary>
 		/// <returns> true if controller is connected, false otherwise</returns>
 		bool IsControllerConnected() const noexcept
 		{
 			XINPUT_KEYSTROKE ss{};
 			const DWORD ret = XInputGetKeystroke(m_local_player.player_id,0, &ss);
 			return ret == ERROR_SUCCESS || ret == ERROR_EMPTY;
 		}
-		/// <summary>
-		/// Returns status of XINPUT library detecting a controller.
-		/// overload that uses the player_id value in a KeyboardPlayerInfo struct
-		/// </summary>
+		/// <summary>Returns status of XINPUT library detecting a controller.
+		/// This overload uses the player_id value in a KeyboardPlayerInfo struct</summary>
 		/// <returns> true if controller is connected, false otherwise</returns>
 		bool IsControllerConnected(const KeyboardPlayerInfo& p) const noexcept
 		{
@@ -93,10 +78,7 @@ namespace sds
 			return ret == ERROR_SUCCESS || ret == ERROR_EMPTY;
 		}
 	protected:
-		/// <summary>
-		/// Worker thread overriding the base pure virtual workThread.
-		///	Updates "m_local_state" with mutex protection.
-		/// </summary>
+		/// <summary>Worker thread used by m_workThread. Updates the protectedData with mutex protection.</summary>
 		void workThread(sds::LambdaArgs::LambdaArg1& stopCondition, sds::LambdaArgs::LambdaArg2& mut, auto& protectedData)
 		{
 			auto addElement = [this,&mut,&protectedData](const XINPUT_KEYSTROKE& state)

XMapLib/KeyboardKeyMap.h

@@ -21,11 +21,11 @@ namespace sds
 			KEYUP = XINPUT_KEYSTROKE_KEYUP
 		};
 		//Struct members
-		int SendingElementVK = 0; // VK of controller button
-		int MappedToVK = 0; // VK of mapped-to input (key or mouse button)
-		bool UsesRepeat = true; // Uses the key-repeat behavior when held down
-		ActionType LastAction = ActionType::NONE;
-		Utilities::DelayManager LastSentTime = KeyboardSettings::MICROSECONDS_DELAY_KEYREPEAT;
+		int SendingElementVK{ 0 }; // VK of controller button
+		int MappedToVK{ 0 }; // VK of mapped-to input (key or mouse button)
+		bool UsesRepeat{ true }; // Uses the key-repeat behavior when held down
+		ActionType LastAction{ ActionType::NONE };
+		Utilities::DelayManager LastSentTime{ KeyboardSettings::MICROSECONDS_DELAY_KEYREPEAT };
 		//Ctor
 		KeyboardKeyMap(const int controllerElementVK, const int keyboardMouseElementVK, const bool useRepeat)
 			: SendingElementVK(controllerElementVK), MappedToVK(keyboardMouseElementVK), UsesRepeat(useRepeat)

XMapLib/KeyboardMapper.h

@@ -14,28 +14,24 @@ namespace sds
 		using InternalType = int;
 		using LambdaRunnerType = sds::CPPRunnerGeneric<InternalType>;
 		using lock = LambdaRunnerType::ScopedLockType;
-		sds::KeyboardPlayerInfo m_localPlayerInfo;
-		sds::KeyboardInputPoller m_poller;
-		sds::KeyboardTranslator m_translator;
-		std::unique_ptr<LambdaRunnerType> m_workThread;
+		sds::KeyboardPlayerInfo m_localPlayerInfo{};
+		sds::KeyboardInputPoller m_poller{};
+		sds::KeyboardTranslator m_translator{};
+		std::unique_ptr<LambdaRunnerType> m_workThread{};
 		void InitWorkThread() noexcept
 		{
 			m_workThread =
 				std::make_unique<LambdaRunnerType>
 				([this](auto& stopCondition, auto& mut, auto& protectedData) { workThread(stopCondition, mut, protectedData); });
 		}
 	public:
-		/// <summary>
-		/// Ctor for default configuration
-		/// </summary>
+		/// <summary>Ctor for default configuration</summary>
 		KeyboardMapper()
 		{
 			InitWorkThread();
 			Start();
 		}
-		/// <summary>
-		/// Ctor allows setting a custom KeyboardPlayerInfo
-		/// </summary>
+		/// <summary>Ctor allows setting a custom KeyboardPlayerInfo</summary>
 		explicit KeyboardMapper(const sds::KeyboardPlayerInfo& player) : m_localPlayerInfo(player)
 		{
 			InitWorkThread();
@@ -45,14 +41,11 @@ namespace sds
 		KeyboardMapper(KeyboardMapper&& other) = delete;
 		KeyboardMapper& operator=(const KeyboardMapper& other) = delete;
 		KeyboardMapper& operator=(KeyboardMapper&& other) = delete;
-		/// <summary>
-		/// Destructor override, ensures the running thread function is stopped
-		/// inside of this class and not the base.
-		/// </summary>
 		~KeyboardMapper()
 		{
 			Stop();
 		}
+
 		bool IsControllerConnected() const
 		{
 			return m_poller.IsControllerConnected();
@@ -66,8 +59,9 @@ namespace sds
 			m_poller.Start();
 			m_workThread->StartThread();
 		}
-		void Stop() const noexcept
+		void Stop() noexcept
 		{
+			m_translator.CleanupInProgressEvents();
 			m_poller.Stop();
 			m_workThread->StopThread();
 		}
@@ -86,13 +80,10 @@ namespace sds
 		}
 		void ClearMaps()
 		{
-			m_translator.ClearMap();
+			m_translator.ClearMaps();
 		}
 	protected:
-		/// <summary>
-		/// Worker thread, protected visibility.
-		/// Accesses the std::atomic m_threadX and m_threadY members.
-		/// </summary>
+		/// <summary>Worker thread, protected visibility.</summary>
 		void workThread(auto& stopCondition, auto&, auto&)
 		{
 			//thread main loop

XMapLib/KeyboardSettings.h

@@ -7,11 +7,11 @@ namespace sds
 	struct KeyboardSettings
 	{
 		//Input Poller maximum number of XINPUT_KEYSTROKE structs to queue before dropping input.
-		constexpr static const int MAX_STATE_COUNT = 128;
+		constexpr static const int MAX_STATE_COUNT{ 128 };
 		//Input Poller thread delay, in milliseconds.
-		constexpr static const int THREAD_DELAY_POLLER = 10;
+		constexpr static const int THREAD_DELAY_POLLER{ 10 };
 		//Microseconds Delay Keyrepeat is the time delay a button has in between activations.
-		constexpr static const int MICROSECONDS_DELAY_KEYREPEAT = 100000;
+		constexpr static const int MICROSECONDS_DELAY_KEYREPEAT{ 100000 };
 		//It is necessary to be able to distinguish these mapping values in KeyboardTranslator.
 		constexpr static std::array<int,8> THUMBSTICK_L_VK_LIST
 		{

XMapLib/KeyboardTranslator.h

@@ -15,15 +15,15 @@ namespace sds
 	/// </summary>
 	class KeyboardTranslator
 	{
-		const std::string ERR_BAD_VK = "Either WordData.MappedToVK OR WordData.SendElementVK is <= 0";
-		const std::string ERR_DUP_KEYUP = "Sent a duplicate keyup event to handle thumbstick direction changing behavior.";
 		using ClockType = std::chrono::high_resolution_clock;
 		using PointInTime = std::chrono::time_point<ClockType>;
 		using InpType = sds::KeyboardKeyMap::ActionType;
+		const std::string ERR_BAD_VK{ "Either WordData.MappedToVK OR WordData.SendElementVK is <= 0" };
+		const std::string ERR_DUP_KEYUP{ "Sent a duplicate keyup event to handle thumbstick direction changing behavior." };
 	private:
-		Utilities::SendKeyInput m_key_send;
-		std::vector<KeyboardKeyMap> m_map_token_info;
-		KeyboardPlayerInfo m_local_player;
+		Utilities::SendKeyInput m_key_send{};
+		std::vector<KeyboardKeyMap> m_map_token_info{};
+		KeyboardPlayerInfo m_local_player{};
 	public:
 		explicit KeyboardTranslator(const KeyboardPlayerInfo &p) : m_local_player(p)
 		{
@@ -50,6 +50,17 @@ namespace sds
 				}
 			}
 		}
+		/// <summary>Call this function to send key-ups for any in-progress key presses.</summary>
+		void CleanupInProgressEvents()
+		{
+			for(auto &m: m_map_token_info)
+			{
+				if(m.LastAction == InpType::KEYDOWN || m.LastAction == InpType::KEYREPEAT)
+				{
+					this->DoOvertaking(m);
+				}
+			}
+		}
 		std::string AddKeyMap(KeyboardKeyMap w)
 		{
 			std::string result = CheckForVKError(w);
@@ -58,11 +69,11 @@ namespace sds
 			m_map_token_info.push_back(w);
 			return "";
 		}
-		void ClearMap()
+		void ClearMaps() noexcept
 		{
 			m_map_token_info.clear();
 		}
-		std::vector<KeyboardKeyMap> GetMaps() const
+		std::vector<KeyboardKeyMap> GetMaps() const noexcept
 		{
 			return m_map_token_info;
 		}
@@ -91,9 +102,7 @@ namespace sds
 				}
 			}
 		}
-		/// <summary>
-		/// Normal keypress simulation logic. 
-		/// </summary>
+		/// <summary>Normal keypress simulation logic.</summary>
 		void Normal(KeyboardKeyMap &detail, const XINPUT_KEYSTROKE &stroke)
 		{
 			const bool DoDown = (detail.LastAction == InpType::NONE) && (stroke.Flags & static_cast<WORD>(InpType::KEYDOWN));
@@ -111,17 +120,15 @@ namespace sds
 				SendTheKey(detail, false, InpType::KEYUP);
 			}
 		}
-		//Does the key send call, updates LastAction and updates LastSentTime
-		void SendTheKey(KeyboardKeyMap& mp, const bool keyDown, KeyboardKeyMap::ActionType action)
+		/// <summary>Does the key send call, updates LastAction and updates LastSentTime</summary>
+		void SendTheKey(KeyboardKeyMap& mp, const bool keyDown, KeyboardKeyMap::ActionType action) noexcept
 		{
 			//std::cerr << mp << std::endl; // temp logging
 			mp.LastAction = action;
 			m_key_send.SendScanCode(mp.MappedToVK, keyDown);
 			mp.LastSentTime.Reset(KeyboardSettings::MICROSECONDS_DELAY_KEYREPEAT); // update last sent time
 		}
-		/// <summary>
-		/// Check to see if a different axis of the same thumbstick has been pressed already
-		/// </summary>
+		/// <summary>Check to see if a different axis of the same thumbstick has been pressed already</summary>
 		/// <param name="detail">Newest element being set to keydown state</param>
 		///	<param name="outOvertaken">out key set to the one being overtaken</param>
 		/// <returns>true if is overtaking a thumbstick direction already depressed</returns>
@@ -151,7 +158,7 @@ namespace sds
 			}
 			return false;
 		}
-		void DoOvertaking(KeyboardKeyMap &detail)
+		void DoOvertaking(KeyboardKeyMap &detail) noexcept
 		{
 			SendTheKey(detail, false, InpType::KEYUP);
 		}

XMapLib/MapFunctions.h

@@ -2,26 +2,20 @@
 #include <map>
 namespace sds::Utilities::MapFunctions
 {
-	/// <summary>
-	/// Verifies that the key value is in the map{T,H} and sets a reference arg to the value
-	///	if found.
-	/// </summary>
+	/// <summary>Verifies that the key value is in the map{T,H} and sets a reference arg to the value if found.</summary>
 	/// <param name="keyValue">key value to check</param>
 	///	<param name="curMap">map of T,H to check the key</param>
 	///	<param name="retVal">will be set to the value the key points to, if found</param>
 	/// <returns>true if found, false otherwise</returns>
 	template<class T, class H>
 	bool IsInMap(const T keyValue, const std::map<T, H>& curMap, H& retVal)
 	{
-		auto it = curMap.find(keyValue);
+		const auto it = curMap.find(keyValue);
 		if(it != curMap.end())
 		{
 			retVal = it->second;
 			return true;
 		}
-		else
-		{
-			return false;
-		}
+		return false;
 	}
 }