Added repeat functionality (hard coded to 100ms delay).

nhmkdev · nhmkdev · commit 927cc3b7fa4f · 2019-12-30T14:00:06.000-08:00
diff --git a/Format/OutputConfig.cs b/Format/OutputConfig.cs
@@ -54,6 +54,7 @@ public enum OutputFlag
             Toggle = 1 << 6,
             Down = 1 << 7,
             Up = 1 << 8,
+            Repeat = 1 << 9,
             // all ThreadKill ?
             // supports up to 32 entries
         }
@@ -146,7 +147,7 @@ public bool IsAssignedAction()
         private string GetOutputDescriptionText(Enum eInputId, string sActionPrefix)
         {
             return "[" +
-                   (Keys)VirtualKey +
+                   eInputId +
                    (IsFlaggedAs(OutputFlag.Down) && IsFlaggedAs(OutputFlag.Up)
                        ? ":Press"
                        : ((IsFlaggedAs(OutputFlag.Down) ? ":{0}Down".FormatString(sActionPrefix) : string.Empty) +
@@ -156,6 +157,7 @@ private string GetOutputDescriptionText(Enum eInputId, string sActionPrefix)
                    (IsFlaggedAs(OutputFlag.Alt) ? "+Alt" : string.Empty) +
                    (IsFlaggedAs(OutputFlag.Control) ? "+Control" : string.Empty) +
                    (IsFlaggedAs(OutputFlag.Toggle) ? "+Toggle" : string.Empty) +
+                   (IsFlaggedAs(OutputFlag.Repeat) ? "+Repeat" : string.Empty) +
                    "]";
         }
     }
diff --git a/Format/RemapEntry.cs b/Format/RemapEntry.cs
@@ -72,9 +72,7 @@ public RemapEntry(FileStream zFileStream)
             }
 
             // TODO: comment on why this is
-            zFileStream.ReadByte();
-            zFileStream.ReadByte();
-            zFileStream.ReadByte();
+            zFileStream.Read(new byte[3], 0, 3);
 
             try
             {
@@ -107,9 +105,7 @@ public byte[] SerializeToBytes()
             InputConfig.SerializeToStream(zStream);
             zStream.WriteByte((byte)OutputConfigs.Count);
             // TODO: comment on padding
-            zStream.WriteByte(0);
-            zStream.WriteByte(0);
-            zStream.WriteByte(0);
+            zStream.Write(new byte[3], 0, 3);
             OutputConfigs.ForEach(oc => oc.SerializeToStream(zStream));
             return zStream.ToArray();
         }
diff --git a/Forms/KeyCaptureConfig.cs b/Forms/KeyCaptureConfig.cs
@@ -498,6 +498,7 @@ private OutputConfig UpdateOutputFlags(OutputConfig zOutputConfig)
             var bShift = checkOutputShift.Checked;
             var bNone = checkOutputDoNothing.Checked;
             var bToggle = checkOutputToggle.Checked;
+            var bRepeat = checkOutputRepeat.Checked;
             var bDown = checkOutputDown.Checked;
             var bUp = checkOutputUp.Checked;
 
@@ -510,6 +511,7 @@ private OutputConfig UpdateOutputFlags(OutputConfig zOutputConfig)
 
             nFlags = BitUtil.UpdateFlag(nFlags, bNone, OutputConfig.OutputFlag.DoNothing);
             nFlags = BitUtil.UpdateFlag(nFlags, bToggle, OutputConfig.OutputFlag.Toggle);
+            nFlags = BitUtil.UpdateFlag(nFlags, bRepeat, OutputConfig.OutputFlag.Repeat);
             nFlags = BitUtil.UpdateFlag(nFlags, bDown, OutputConfig.OutputFlag.Down);
             nFlags = BitUtil.UpdateFlag(nFlags, bUp, OutputConfig.OutputFlag.Up);
             zOutputConfig.Flags = nFlags;
diff --git a/Forms/KeyCaptureConfig.designer.cs b/Forms/KeyCaptureConfig.designer.cs
diff --git a/KeyCapLib/KeyCapture.cpp b/KeyCapLib/KeyCapture.cpp
@@ -42,7 +42,7 @@ extern "C"
 HHOOK g_hookMain = NULL;
 
 // sweet globals
-RemapEntryListItem* g_KeyTranslationTable[WIN_KEY_COUNT];
+RemapEntryContainerListItem* g_KeyTranslationTable[WIN_KEY_COUNT];
 RemapEntry* g_KeyTranslationHead = NULL;
 void* g_KeyTranslationEnd = NULL; // pointer indicating the end of the input file data
 
@@ -69,7 +69,7 @@ __declspec(dllexport) int LoadAndCaptureFromFile(HINSTANCE hInstance, char* sFil
 	}
 
 	// validate file (and compile the "hash" table g_KeyTranslationTable)
-	memset(g_KeyTranslationTable, 0, WIN_KEY_COUNT * sizeof(RemapEntryListItem*));
+	memset(g_KeyTranslationTable, 0, WIN_KEY_COUNT * sizeof(RemapEntryContainerListItem*));
 
 	RemapEntry* pEntry = g_KeyTranslationHead;
 	bool bValidTranslationSet = false;
@@ -91,21 +91,25 @@ __declspec(dllexport) int LoadAndCaptureFromFile(HINSTANCE hInstance, char* sFil
 		// if the entry doesn't exist yet for the given input vkey create a new one with a null next pointer
 		if(NULL == g_KeyTranslationTable[pEntry->inputConfig.virtualKey])
 		{
-			g_KeyTranslationTable[pEntry->inputConfig.virtualKey] = (RemapEntryListItem*)malloc(sizeof(RemapEntryListItem));
-			g_KeyTranslationTable[pEntry->inputConfig.virtualKey]->pEntry = pEntry;
+			g_KeyTranslationTable[pEntry->inputConfig.virtualKey] = (RemapEntryContainerListItem*)malloc(sizeof(RemapEntryContainerListItem));
+			g_KeyTranslationTable[pEntry->inputConfig.virtualKey]->pEntryContainer = (RemapEntryContainer*)malloc(sizeof(RemapEntryContainer));
+			g_KeyTranslationTable[pEntry->inputConfig.virtualKey]->pEntryContainer->pEntryState = (RemapEntryState*)malloc(sizeof(RemapEntryState));
+			g_KeyTranslationTable[pEntry->inputConfig.virtualKey]->pEntryContainer->pEntry = pEntry;
 			g_KeyTranslationTable[pEntry->inputConfig.virtualKey]->pNext = NULL;
 		}
 		// if the entry does exist create a new entry and append it to the existing linked list
 		else
 		{
-			RemapEntryListItem* pKeyItem = g_KeyTranslationTable[pEntry->inputConfig.virtualKey];
+			RemapEntryContainerListItem* pKeyItem = g_KeyTranslationTable[pEntry->inputConfig.virtualKey];
 			while(NULL != pKeyItem->pNext)
 			{
 				pKeyItem = pKeyItem->pNext;
 			}
-			pKeyItem->pNext = (RemapEntryListItem*)malloc(sizeof(RemapEntryListItem));
+			pKeyItem->pNext = (RemapEntryContainerListItem*)malloc(sizeof(RemapEntryContainerListItem));
 			pKeyItem = pKeyItem->pNext;
-			pKeyItem->pEntry = pEntry;
+			pKeyItem->pEntryContainer = (RemapEntryContainer*)malloc(sizeof(RemapEntryContainer));
+			pKeyItem->pEntryContainer->pEntryState = (RemapEntryState*)malloc(sizeof(RemapEntryState));
+			pKeyItem->pEntryContainer->pEntry = pEntry;
 			pKeyItem->pNext = NULL;
 		}
 		// jump to the next entry
@@ -170,13 +174,16 @@ __declspec(dllexport) void ShutdownCapture()
 	{
 		if(NULL != g_KeyTranslationTable[nIdx])
 		{
-			RemapEntryListItem* pKeyItem = g_KeyTranslationTable[nIdx];
-			RemapEntryListItem* pKeyNextItem = NULL;
-			while(NULL != pKeyItem)
+			RemapEntryContainerListItem* pListItem = g_KeyTranslationTable[nIdx];
+			RemapEntryContainerListItem* pNextItem = NULL;
+			while(NULL != pListItem)
 			{
-				pKeyNextItem = pKeyItem->pNext;
-				free(pKeyItem);
-				pKeyItem = pKeyNextItem;
+				pNextItem = pListItem->pNext;
+				free(pListItem->pEntryContainer->pEntryState);
+				free(pListItem->pEntryContainer);
+				// NOTE: the entry itself was freed above
+				free(pListItem);
+				pListItem = pNextItem;
 			}
 			g_KeyTranslationTable[nIdx] = NULL;
 		}
diff --git a/KeyCapLib/KeyCaptureUtil.cpp b/KeyCapLib/KeyCaptureUtil.cpp
@@ -25,23 +25,23 @@
 #include "keycapturestructs.h"
 #include "keycaptureutil.h"
 
-bool IsButtonDownRequired(RemapEntry* pRemapEntry, OutputConfig* pKeyDef)
+bool IsButtonDownRequired(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef)
 {
 	if (pKeyDef->outputFlag.bToggle)
 	{
-		return !pRemapEntry->bToggled;
+		return !pRemapEntryState->bToggled;
 	}
 
 	bool keyDownRequired = true;
 	keyDownRequired = pKeyDef->outputFlag.bDown;
 	return keyDownRequired;
 }
 
-bool IsButtonUpRequired(RemapEntry* pRemapEntry, OutputConfig* pKeyDef)
+bool IsButtonUpRequired(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef)
 {
 	if (pKeyDef->outputFlag.bToggle)
 	{
-		return pRemapEntry->bToggled;
+		return pRemapEntryState->bToggled;
 	}
 
 	bool keyUpRequired = true;
diff --git a/KeyCapLib/KeyCaptureUtil.h b/KeyCapLib/KeyCaptureUtil.h
@@ -30,8 +30,8 @@
 
 const int DESCRIPTION_BUFFER_SIZE = 256;
 
-bool IsButtonDownRequired(RemapEntry* pRemapEntry, OutputConfig* pKeyDef);
-bool IsButtonUpRequired(RemapEntry* pRemapEntry, OutputConfig* pKeyDef);
+bool IsButtonDownRequired(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef);
+bool IsButtonUpRequired(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef);
 
 void LogDebugMessage(const char *format, ...);
 void ValidateStructs();
diff --git a/KeyCapLib/KeyboardInput.cpp b/KeyCapLib/KeyboardInput.cpp
@@ -88,16 +88,14 @@ pKeyDef: pointer to a key definition for a keyboard input to send
 pTriggerDefinition: The definition of the triggering key. Modifiers like shift/alt/ctrl require special handling under
 certain circumstances
 */
-void SendInputKeys(RemapEntry* pRemapEntry, OutputConfig* pKeyDef)
+void SendInputKeys(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef)
 {
 	int nIndex = 0;
-	bool bSendKeyDown = IsButtonDownRequired(pRemapEntry, pKeyDef);
-	bool bSendKeyUp = IsButtonUpRequired(pRemapEntry, pKeyDef);
+	bool bSendKeyDown = IsButtonDownRequired(pRemapEntryState, pKeyDef);
+	bool bSendKeyUp = IsButtonUpRequired(pRemapEntryState, pKeyDef);
 	INPUT inputBuffer[MAX_KEY_INPUT_PER_STROKE];
 	memset(&inputBuffer, 0, sizeof(INPUT) * MAX_KEY_INPUT_PER_STROKE);
 
-	LogDebugMessage("%d", pKeyDef->outputFlag);
-
 	if (pKeyDef->outputFlag.bToggle && pKeyDef->virtualKey >= MAX_VKEY)
 	{
 		LogDebugMessage("---- ERROR Cannot have a vkey value over 255: %d", pKeyDef->virtualKey);
diff --git a/KeyCapLib/KeyboardInput.h b/KeyCapLib/KeyboardInput.h
@@ -27,7 +27,7 @@
 
 #include "keycapturestructs.h"
 
-void SendInputKeys(RemapEntry* pRemapEntry, OutputConfig* pKeyDef);
+void SendInputKeys(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef);
 void SendTriggerEndInputKeys(RemapEntry* pRemapEntry);
 void AppendSingleKey(short keyScan, INPUT* inputChar, DWORD dwFlags);
 void ProcessModifierKeys(OutputConfig* pKeyDef, INPUT* pInput, int* nIndex, DWORD dwFlags);
diff --git a/KeyCapLib/MouseInput.cpp b/KeyCapLib/MouseInput.cpp
@@ -36,13 +36,13 @@ Sends the desired mouse input
 
 pKeyDef: pointer to a key definition for a mouse input
 */
-void SendInputMouse(RemapEntry* pRemapEntry, OutputConfig *pKeyDef)
+void SendInputMouse(RemapEntryState* pRemapEntryState, OutputConfig *pKeyDef)
 {
 	INPUT inputBuffer[MAX_KEY_INPUT_PER_STROKE];
 	memset(&inputBuffer, 0, sizeof(INPUT) * MAX_KEY_INPUT_PER_STROKE);
 
-	bool bSendMouseDown = IsButtonDownRequired(pRemapEntry, pKeyDef);
-	bool bSendMouseUp = IsButtonUpRequired(pRemapEntry, pKeyDef);
+	bool bSendMouseDown = IsButtonDownRequired(pRemapEntryState, pKeyDef);
+	bool bSendMouseUp = IsButtonUpRequired(pRemapEntryState, pKeyDef);
 
 	if (pKeyDef->virtualKey == MOUSE_NONE)
 	{
diff --git a/KeyCapLib/MouseInput.h b/KeyCapLib/MouseInput.h
@@ -36,7 +36,7 @@ enum MOUSE_BUTTON
 	MOUSE_BUTTON_COUNT
 };
 
-void SendInputMouse(RemapEntry* pRemapEntry, OutputConfig *pKeyDef);
+void SendInputMouse(RemapEntryState* pRemapEntryState, OutputConfig *pKeyDef);
 void AppendSingleMouse(INPUT* inputChar, unsigned char nVkKey);
 
 #endif // MOUSE_INPUT_H_
diff --git a/KeyCapLib/keyboardproc.cpp b/KeyCapLib/keyboardproc.cpp
@@ -22,7 +22,7 @@
 #include "keyboardproc.h"
 #include "sendinputthread.h"
 
-extern RemapEntryListItem* g_KeyTranslationTable[WIN_KEY_COUNT];
+extern RemapEntryContainerListItem* g_KeyTranslationTable[WIN_KEY_COUNT];
 
 /*
 Implementation of the win32 LowLevelKeyboardProc (see docs for information)
@@ -51,19 +51,19 @@ LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
 		case WM_SYSKEYDOWN:
 			// detect a keydown that matches a remaped key (and start the input thread to respond accordingly then indicate to the OS that the key has been handled)
 			{
-				RemapEntryListItem* pKeyListItem = g_KeyTranslationTable[pHook->vkCode];
+				RemapEntryContainerListItem* pKeyListItem = g_KeyTranslationTable[pHook->vkCode];
 				while (NULL != pKeyListItem)
 				{
-					InputConfig* pKeyDef = &pKeyListItem->pEntry->inputConfig;
+					InputConfig* pKeyDef = &pKeyListItem->pEntryContainer->pEntry->inputConfig;
 					if ((bAlt == pKeyDef->inputFlag.bAlt) &&
 						(bControl == pKeyDef->inputFlag.bControl) &&
 						(bShift == pKeyDef->inputFlag.bShift))
 					{
 						char* pInputConfigDescription = GetInputConfigDescription(*pKeyDef);
-						LogDebugMessage("Detected Key Press: %s Outputs: %d", pInputConfigDescription, pKeyListItem->pEntry->outputCount);
+						LogDebugMessage("Detected Key Press: %s Outputs: %d", pInputConfigDescription, pKeyListItem->pEntryContainer->pEntry->outputCount);
 						free(pInputConfigDescription);
 						// TODO: get thread handle, also check for null
-						CreateThread(NULL, 0, SendInputThread, pKeyListItem->pEntry, 0, NULL);
+						CreateThread(NULL, 0, SendInputThread, pKeyListItem->pEntryContainer, 0, NULL);
 						bSentInput = true;
 						break;
 					}
@@ -75,10 +75,10 @@ LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
 		case WM_SYSKEYUP:
 			// detect a keyup that matches a remaped key (and indicate to the OS that the key has been handled)
 			{
-				RemapEntryListItem* pKeyListItem = g_KeyTranslationTable[pHook->vkCode];
+				RemapEntryContainerListItem* pKeyListItem = g_KeyTranslationTable[pHook->vkCode];
 				while (NULL != pKeyListItem)
 				{
-					InputConfig* pKeyDef = &pKeyListItem->pEntry->inputConfig;
+					InputConfig* pKeyDef = &pKeyListItem->pEntryContainer->pEntry->inputConfig;
 					if ((bAlt == pKeyDef->inputFlag.bAlt) &&
 						(bControl == pKeyDef->inputFlag.bControl) &&
 						(bShift == pKeyDef->inputFlag.bShift))
diff --git a/KeyCapLib/keycapturestructs.h b/KeyCapLib/keycapturestructs.h
@@ -46,15 +46,6 @@ struct InputFlag
 
 struct OutputFlag
 {
-#if 0
-	const int KEYCAP_SHIFT = 1 << 0;
-	const int KEYCAP_CONTROL = 1 << 1;
-	const int KEYCAP_ALT = 1 << 2;
-	const int KEYCAP_DONOTHING = 1 << 3;
-	const int KEYCAP_MOUSEOUT = 1 << 4;
-	const int KEYCAP_DELAY = 1 << 5;
-	const int KEYCAP_TOGGLE = 1 << 6;
-#endif
 	BYTE bShift : 1;
 	BYTE bControl : 1;
 	BYTE bAlt : 1;
@@ -64,7 +55,8 @@ struct OutputFlag
 	BYTE bToggle : 1;
 	BYTE bDown : 1;
 	BYTE bUp : 1;
-	BYTE padTwo : 7;
+	BYTE bRepeat : 1;
+	BYTE padTwo : 6;
 	BYTE padThree : 8;
 	BYTE padFour : 8;
 };
@@ -93,17 +85,33 @@ struct RemapEntry
 {
 	InputConfig inputConfig;
 	BYTE outputCount;
-	BYTE bToggled : 1;
-	BYTE padOne : 7;
+	BYTE padOne : 8;
 	BYTE padTwo : 8;
 	BYTE padThree : 8;
 	// KeyDefintion[outputCount]
 };
 
-struct RemapEntryListItem
+struct RemapEntryState
+{
+	BYTE bToggled : 1;
+	BYTE bRepeating : 1;
+	BYTE padOne : 6;
+	BYTE padTwo : 8;
+	BYTE padThree : 8;
+	BYTE padFour : 8;
+	HANDLE threadHandle;
+};
+
+struct RemapEntryContainer
 {
 	RemapEntry* pEntry;
-	RemapEntryListItem* pNext;
+	RemapEntryState* pEntryState;
+};
+
+struct RemapEntryContainerListItem
+{
+	RemapEntryContainer* pEntryContainer;
+	RemapEntryContainerListItem* pNext;
 };
 
 enum HOOK_RESULT
diff --git a/KeyCapLib/sendinputthread.cpp b/KeyCapLib/sendinputthread.cpp
diff --git a/Resources/KeyCapActive.ico b/Resources/KeyCapActive.ico
diff --git a/Resources/KeyCapIdle.ico b/Resources/KeyCapIdle.ico
diff --git a/bin/Release/KeyCap.odt b/bin/Release/KeyCap.odt

Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,7 @@ public enum OutputFlag`
`54`	`54`	`Toggle = 1 << 6,`
`55`	`55`	`Down = 1 << 7,`
`56`	`56`	`Up = 1 << 8,`
	`57`	`+ Repeat = 1 << 9,`
`57`	`58`	`// all ThreadKill ?`
`58`	`59`	`// supports up to 32 entries`
`59`	`60`	`}`
`@@ -146,7 +147,7 @@ public bool IsAssignedAction()`
`146`	`147`	`private string GetOutputDescriptionText(Enum eInputId, string sActionPrefix)`
`147`	`148`	`{`
`148`	`149`	`return "[" +`
`149`		`- (Keys)VirtualKey +`
	`150`	`+ eInputId +`
`150`	`151`	`(IsFlaggedAs(OutputFlag.Down) && IsFlaggedAs(OutputFlag.Up)`
`151`	`152`	`? ":Press"`
`152`	`153`	`: ((IsFlaggedAs(OutputFlag.Down) ? ":{0}Down".FormatString(sActionPrefix) : string.Empty) +`
`@@ -156,6 +157,7 @@ private string GetOutputDescriptionText(Enum eInputId, string sActionPrefix)`
`156`	`157`	`(IsFlaggedAs(OutputFlag.Alt) ? "+Alt" : string.Empty) +`
`157`	`158`	`(IsFlaggedAs(OutputFlag.Control) ? "+Control" : string.Empty) +`
`158`	`159`	`(IsFlaggedAs(OutputFlag.Toggle) ? "+Toggle" : string.Empty) +`
	`160`	`+ (IsFlaggedAs(OutputFlag.Repeat) ? "+Repeat" : string.Empty) +`
`159`	`161`	`"]";`
`160`	`162`	`}`
`161`	`163`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,9 +72,7 @@ public RemapEntry(FileStream zFileStream)`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`// TODO: comment on why this is`
`75`		`- zFileStream.ReadByte();`
`76`		`- zFileStream.ReadByte();`
`77`		`- zFileStream.ReadByte();`
	`75`	`+ zFileStream.Read(new byte[3], 0, 3);`
`78`	`76`
`79`	`77`	`try`
`80`	`78`	`{`
`@@ -107,9 +105,7 @@ public byte[] SerializeToBytes()`
`107`	`105`	`InputConfig.SerializeToStream(zStream);`
`108`	`106`	`zStream.WriteByte((byte)OutputConfigs.Count);`
`109`	`107`	`// TODO: comment on padding`
`110`		`- zStream.WriteByte(0);`
`111`		`- zStream.WriteByte(0);`
`112`		`- zStream.WriteByte(0);`
	`108`	`+ zStream.Write(new byte[3], 0, 3);`
`113`	`109`	`OutputConfigs.ForEach(oc => oc.SerializeToStream(zStream));`
`114`	`110`	`return zStream.ToArray();`
`115`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,23 +25,23 @@`
`25`	`25`	`#include "keycapturestructs.h"`
`26`	`26`	`#include "keycaptureutil.h"`
`27`	`27`
`28`		`-bool IsButtonDownRequired(RemapEntry* pRemapEntry, OutputConfig* pKeyDef)`
	`28`	`+bool IsButtonDownRequired(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef)`
`29`	`29`	`{`
`30`	`30`	`if (pKeyDef->outputFlag.bToggle)`
`31`	`31`	`{`
`32`		`- return !pRemapEntry->bToggled;`
	`32`	`+ return !pRemapEntryState->bToggled;`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`bool keyDownRequired = true;`
`36`	`36`	`keyDownRequired = pKeyDef->outputFlag.bDown;`
`37`	`37`	`return keyDownRequired;`
`38`	`38`	`}`
`39`	`39`
`40`		`-bool IsButtonUpRequired(RemapEntry* pRemapEntry, OutputConfig* pKeyDef)`
	`40`	`+bool IsButtonUpRequired(RemapEntryState* pRemapEntryState, OutputConfig* pKeyDef)`
`41`	`41`	`{`
`42`	`42`	`if (pKeyDef->outputFlag.bToggle)`
`43`	`43`	`{`
`44`		`- return pRemapEntry->bToggled;`
	`44`	`+ return pRemapEntryState->bToggled;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`bool keyUpRequired = true;`
Original file line number	Diff line number	Diff line change
`@@ -36,13 +36,13 @@ Sends the desired mouse input`
`36`	`36`
`37`	`37`	`pKeyDef: pointer to a key definition for a mouse input`
`38`	`38`	`*/`
`39`		`-void SendInputMouse(RemapEntry* pRemapEntry, OutputConfig *pKeyDef)`
	`39`	`+void SendInputMouse(RemapEntryState* pRemapEntryState, OutputConfig *pKeyDef)`
`40`	`40`	`{`
`41`	`41`	`INPUT inputBuffer[MAX_KEY_INPUT_PER_STROKE];`
`42`	`42`	`memset(&inputBuffer, 0, sizeof(INPUT) * MAX_KEY_INPUT_PER_STROKE);`
`43`	`43`
`44`		`- bool bSendMouseDown = IsButtonDownRequired(pRemapEntry, pKeyDef);`
`45`		`- bool bSendMouseUp = IsButtonUpRequired(pRemapEntry, pKeyDef);`
	`44`	`+ bool bSendMouseDown = IsButtonDownRequired(pRemapEntryState, pKeyDef);`
	`45`	`+ bool bSendMouseUp = IsButtonUpRequired(pRemapEntryState, pKeyDef);`
`46`	`46`
`47`	`47`	`if (pKeyDef->virtualKey == MOUSE_NONE)`
`48`	`48`	`{`