예제 #1
0
        // ScanCode notes: https://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
        public override void ProcessStroke(List <ManagedWrapper.Stroke> strokes)
        {
            var hasSubscription = false;
            var hasContext      = ContextCallback != null;

            // Process any waiting input for this keyboard
            var block = false;

            if (_isFiltered)
            {
                var            isKeyMapping   = false; // True if this is a mapping to a single key, else it would be a mapping to a whole device
                var            processedState = ScanCodeHelper.TranslateScanCodes(strokes);
                var            code           = processedState.Code;
                var            state          = processedState.State;
                MappingOptions mapping        = null;

                // If there is a mapping to this specific key, then use that ...
                if (SingleButtonMappings.ContainsKey(code))
                {
                    isKeyMapping = true;
                    mapping      = SingleButtonMappings[code];
                }
                // ... otherwise, if there is a mapping to the whole keyboard, use that
                else if (AllButtonsMapping != null)
                {
                    mapping = AllButtonsMapping;
                }

                if (mapping != null)
                {
                    hasSubscription = true;

                    if (mapping.Block)
                    {
                        block = true;
                    }
                    if (mapping.Concurrent)
                    {
                        if (isKeyMapping)
                        {
                            ThreadPool.QueueUserWorkItem(threadProc => mapping.Callback(state));
                        }
                        else
                        {
                            ThreadPool.QueueUserWorkItem(threadProc => mapping.Callback(code, state));
                        }
                    }
                    else
                    {
                        //mapping.Callback(code, state);
                        if (isKeyMapping)
                        {
                            WorkerThreads[code]?.Actions.Add(() => mapping.Callback(state));
                        }
                        else
                        {
                            DeviceWorkerThread?.Actions.Add(() => mapping.Callback(code, state));
                        }
                    }
                }
                // If the key was blocked by Subscription Mode, then move on to next key...
                if (block)
                {
                    return;
                }

                // If this key had no subscriptions, but Context Mode is set for this keyboard...
                // ... then set the Context before sending the key
                if (!hasSubscription && hasContext)
                {
                    ContextCallback(1);
                }

                // Pass the key(s) through to the OS.
                for (int i = 0; i < strokes.Count; i++)
                {
                    var stroke = strokes[i];
                    ManagedWrapper.Send(DeviceContext, DeviceId, ref stroke, 1);
                }

                // If we are processing Context Mode, then Unset the context variable after sending the key
                if (!hasSubscription && hasContext)
                {
                    ContextCallback(0);
                }
            }
        }
예제 #2
0
        public override void ProcessStroke(List <ManagedWrapper.Stroke> strokes)
        {
            for (int i = 0; i < strokes.Count; i++)
            {
                var stroke          = strokes[i];
                var hasSubscription = false;
                var hasContext      = ContextCallback != null;

                var moveRemoved = false;
                var hasMove     = false;

                var x = stroke.mouse.x;
                var y = stroke.mouse.y;

                // Process mouse movement
                var isAbsolute = (stroke.mouse.flags & (ushort)ManagedWrapper.MouseFlag.MouseMoveAbsolute) ==
                                 (ushort)ManagedWrapper.MouseFlag.MouseMoveAbsolute;
                //Determine whether or not to report mouse movement.
                // For Relative mode, this is fairly simple - if x and y are both 0, no movement was reported (Since a real mouse never reports x=0/y=0)
                // For Absolute mode, x=0/y=0 is reported, but we should limit this to only reporting once...
                // ... so when x=0/y=0 is seen in absolute mode, set the flag _absoluteMode00Reported to true and allow it to be reported...
                // then on subsequent reports of x=0/y=0 for absolute mode, if _absoluteMode00Reported is already true, then do not report movement...
                // ... In absolute mode, when x!=0/y!=0 is received, clear the _absoluteMode00Reported flag
                if (isAbsolute)
                {
                    if (x == 0 && y == 0)
                    {
                        if (!_absoluteMode00Reported)
                        {
                            hasMove = true;
                            _absoluteMode00Reported = true;
                        }
                        else
                        {
                            hasMove = false;
                        }
                    }
                    else
                    {
                        hasMove = true;
                        _absoluteMode00Reported = false;
                    }
                }
                else
                {
                    hasMove = (x != 0 || y != 0);
                }

                if (hasMove)
                {
                    // Process Absolute Mouse Move
                    if (isAbsolute)
                    {
                        if (_mouseMoveAbsoluteMapping != null)
                        {
                            var mapping = _mouseMoveAbsoluteMapping;
                            hasSubscription = true;
                            //var debugStr = $"AHK| Mouse stroke has absolute move of {x}, {y}...";

                            if (mapping.Concurrent)
                            {
                                ThreadPool.QueueUserWorkItem(threadProc => mapping.Callback(x, y));
                            }
                            else if (WorkerThreads.ContainsKey(7))
                            {
                                WorkerThreads[7]?.Actions.Add(() => mapping.Callback(x, y));
                            }
                            if (mapping.Block)
                            {
                                moveRemoved    = true;
                                stroke.mouse.x = 0;
                                stroke.mouse.y = 0;
                                //debugStr += "Blocking";
                            }
                            else
                            {
                                //debugStr += "Not Blocking";
                            }

                            //Debug.WriteLine(debugStr);
                        }
                    }
                    else
                    {
                        if (_mouseMoveRelativeMapping != null)
                        {
                            var mapping = _mouseMoveRelativeMapping;
                            hasSubscription = true;
                            //var debugStr = $"AHK| Mouse stroke has relative move of {x}, {y}...";

                            if (mapping.Concurrent)
                            {
                                ThreadPool.QueueUserWorkItem(threadProc => mapping.Callback(x, y));
                            }
                            else if (WorkerThreads.ContainsKey(8))
                            {
                                WorkerThreads[8]?.Actions.Add(() => mapping.Callback(x, y));
                            }
                            if (mapping.Block)
                            {
                                moveRemoved    = true;
                                stroke.mouse.x = 0;
                                stroke.mouse.y = 0;
                                //debugStr += "Blocking";
                            }
                            else
                            {
                                //debugStr += "Not Blocking";
                            }

                            //Debug.WriteLine(debugStr);
                        }
                    }
                }

                var isMouseButtonsMapping = AllButtonsMapping != null;

                // Process Mouse Buttons - do this AFTER mouse movement, so that absolute mode has coordinates available at the point that the button callback is fired
                if (stroke.mouse.state != 0 && SingleButtonMappings.Count > 0 || isMouseButtonsMapping)
                {
                    var btnStates = HelperFunctions.MouseStrokeToButtonStates(stroke);
                    foreach (var btnState in btnStates)
                    {
                        if (!isMouseButtonsMapping && !SingleButtonMappings.ContainsKey(btnState.Button))
                        {
                            continue;
                        }

                        hasSubscription = true;
                        MappingOptions mapping = null;
                        if (isMouseButtonsMapping)
                        {
                            mapping = AllButtonsMapping;
                        }
                        else
                        {
                            mapping = SingleButtonMappings[btnState.Button];
                        }

                        var state = btnState;

                        if (mapping.Concurrent)
                        {
                            if (isMouseButtonsMapping)
                            {
                                ThreadPool.QueueUserWorkItem(threadProc =>
                                                             mapping.Callback(btnState.Button, state.State));
                            }
                            else
                            {
                                ThreadPool.QueueUserWorkItem(threadProc => mapping.Callback(state.State));
                            }
                        }
                        else
                        {
                            if (isMouseButtonsMapping)
                            {
                                DeviceWorkerThread?.Actions
                                .Add(() => mapping.Callback(btnState.Button, state.State));
                            }
                            else
                            {
                                WorkerThreads[btnState.Button]?.Actions
                                .Add(() => mapping.Callback(state.State));
                            }
                        }


                        if (mapping.Block)
                        {
                            // Remove the event for this button from the stroke, leaving other button events intact
                            stroke.mouse.state -= btnState.Flag;
                            // If we are removing a mouse wheel event, then set rolling to 0 if no mouse wheel event left
                            if (btnState.Flag == 0x400 || btnState.Flag == 0x800)
                            {
                                if ((stroke.mouse.state & 0x400) != 0x400 &&
                                    (stroke.mouse.state & 0x800) != 0x800)
                                {
                                    //Debug.WriteLine("AHK| Removing rolling flag from stroke");
                                    stroke.mouse.rolling = 0;
                                }
                            }

                            //Debug.WriteLine($"AHK| Removing flag {btnState.Flag} from stoke, leaving state {stroke.mouse.state}");
                        }
                        else
                        {
                            //Debug.WriteLine($"AHK| Leaving flag {btnState.Flag} in stroke");
                        }
                    }
                }

                // Forward on the stroke if required
                if (hasSubscription)
                {
                    // Subscription mode
                    // If the stroke has a move that was not removed, OR it has remaining button events, then forward on the stroke
                    if ((hasMove && !moveRemoved) || stroke.mouse.state != 0)
                    {
                        //Debug.WriteLine($"AHK| Sending stroke. State = {stroke.mouse.state}. hasMove={hasMove}, moveRemoved={moveRemoved}");
                        ManagedWrapper.Send(DeviceContext, DeviceId, ref stroke, 1);
                    }
                    else
                    {
                        // Everything removed from stroke, do not forward
                        //Debug.WriteLine("AHK| Mouse stroke now empty, not forwarding");
                    }
                }
                else if (hasContext)
                {
                    // Context Mode - forward stroke with context wrapping
                    ContextCallback(1);
                    ManagedWrapper.Send(DeviceContext, DeviceId, ref stroke, 1);
                    ContextCallback(0);
                }
                else
                {
                    // No subscription or context mode - forward on
                    //Debug.WriteLine($"AHK| Sending stroke. State = {stroke.mouse.state}. hasMove={hasMove}, moveRemoved={moveRemoved}");
                    ManagedWrapper.Send(DeviceContext, DeviceId, ref stroke, 1);
                }
            }
        }