示例#1
0
        /// <summary>
        /// Get the mapping for this wndproc action
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public MediaPortal.InputDevices.InputHandler.Mapping GetMapping(Message msg)
        {
            if (_enabled && ((FireDTVConstants.FireDTVWindowMessages)msg.Msg == FireDTVConstants.FireDTVWindowMessages.RemoteControlEvent))
            {
                int remoteKeyCode = msg.LParam.ToInt32();
                if (_logVerbose)
                {
                    Log.Info("FireDTVRemote: GetMapping {0}", remoteKeyCode);
                }

                return(_inputHandler.GetMapping(remoteKeyCode.ToString()));
            }
            return(null);
        }
示例#2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="action"></param>
        /// <param name="key"></param>
        /// <param name="keyCode"></param>
        /// <returns></returns>
        public bool WndProcAppCommand(ref Message msg, out Mapping mappedCommand, bool shouldRaiseAction = true)
        {
            mappedCommand = null;

            AppCommands appCommand = (AppCommands)Win32.Macro.GET_APPCOMMAND_LPARAM(msg.LParam);

            // find out which request the MCE remote handled last
            if ((appCommand == InputDevices.LastHidRequest) && (appCommand != AppCommands.VolumeDown) &&
                (appCommand != AppCommands.VolumeUp))
            {
                if (Enum.IsDefined(typeof(AppCommands), InputDevices.LastHidRequest))
                {
                    // possible that it is the same request mapped to an app command?
                    if (Environment.TickCount - InputDevices.LastHidRequestTick < 500)
                    {
                        return(true);
                    }
                }
            }

            InputDevices.LastHidRequest = appCommand;

            if (logVerbose)
            {
                Log.Info("AppCommand: {0} - {1}", appCommand, InputDevices.LastHidRequest.ToString());
            }

            mappedCommand = _inputHandler.GetMapping(((int)appCommand).ToString());

            if (shouldRaiseAction)
            {
                if (!_inputHandler.MapAction((int)appCommand))
                {
                    return(false);
                }
            }

            msg.Result = new IntPtr(1);

            return(true);
        }
示例#3
0
        /// <summary>
        /// Map an app command to the MCE RemoteButton
        /// </summary>
        /// <param name="command"></param>
        /// <returns></returns>
        private Mapping MapFromAppCommand(AppCommands command)
        {
            Mapping      result = null;
            RemoteButton button = RemoteButton.None;

            switch (command)
            {
            case AppCommands.BrowserBackward:
                button = RemoteButton.Back;
                break;

            case AppCommands.VolumeMute:
                button = RemoteButton.Mute;
                break;

            case AppCommands.VolumeDown:
                button = RemoteButton.VolumeDown;
                break;

            case AppCommands.VolumeUp:
                button = RemoteButton.VolumeUp;
                break;

            case AppCommands.MediaNextTrack:
                button = RemoteButton.Skip;
                break;

            case AppCommands.MediaPreviousTrack:
                button = RemoteButton.Replay;
                break;

            case AppCommands.MediaStop:
                button = RemoteButton.Stop;
                break;

            case AppCommands.MediaPlayPause:
                button = RemoteButton.Pause;
                break;

            case AppCommands.Print:
                button = RemoteButton.Print;
                break;

            case AppCommands.MediaPlay:
                button = RemoteButton.Play;
                break;

            case AppCommands.MediaPause:
                button = RemoteButton.Pause;
                break;

            case AppCommands.MediaRecord:
                button = RemoteButton.Record;
                break;

            case AppCommands.MediaFastForward:
                button = RemoteButton.Forward;
                break;

            case AppCommands.MediaRewind:
                button = RemoteButton.Rewind;
                break;

            case AppCommands.MediaChannelUp:
                button = RemoteButton.ChannelUp;
                break;

            case AppCommands.MediaChannelDown:
                button = RemoteButton.ChannelDown;
                break;
            }

            if (button != RemoteButton.None)
            {
                if (_inputHandler == null)
                {
                    InitInputHandler();
                }
                if (_inputHandler == null || !_inputHandler.IsLoaded)
                {
                    return(null);
                }

                result = _inputHandler.GetMapping(((int)button).ToString());

                // Get the mapping
                if (result != null)
                {
                    if (logVerbose)
                    {
                        Log.Info("MCE: Command \"{0}\" mapped from AppCommands {1}", button, command);
                    }
                }
                else if (logVerbose)
                {
                    Log.Info("MCE: Command \"{0}\" not mapped from AppCommands {1}", button, command);
                }
            }
            return(result);
        }
示例#4
0
        /// <summary>
        /// Map a WndProc message and optionally execute it
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        private Mapping MapWndProcMessage(Message msg, bool shouldRaiseAction = true)
        {
            Mapping result = null;

            if (msg.Msg == WM_KEYDOWN || msg.Msg == WM_SYSKEYDOWN || msg.Msg == Win32.Const.WM_APPCOMMAND || msg.Msg == WM_LBUTTONDOWN ||
                msg.Msg == WM_RBUTTONDOWN || msg.Msg == WM_MOUSEMOVE)
            {
                switch ((Keys)msg.WParam)
                {
                case Keys.ControlKey:
                    break;

                case Keys.ShiftKey:
                    break;

                case Keys.Menu:
                    break;

                default:
                    int keycode = (int)msg.WParam;

                    AppCommands appCommand = (AppCommands)Win32.Macro.GET_APPCOMMAND_LPARAM(msg.LParam);
                    InputDevices.LastHidRequest = appCommand;

                    // Due to the non-perfect placement of the OK button we allow the user to remap the joystick to okay.
                    if (_mapMouseButton)
                    {
                        if (msg.Msg == WM_LBUTTONDOWN)
                        {
                            if (_verboseLogging)
                            {
                                Log.Debug("Centarea: Command \"{0}\" mapped for left mouse button", keycode);
                            }
                            keycode = 13;
                        }
                        if (msg.Msg == WM_RBUTTONDOWN)
                        {
                            if (_verboseLogging)
                            {
                                Log.Debug("Centarea: Command \"{0}\" mapped for right mouse button", keycode);
                            }
                            keycode = 10069;
                        }
                    }
                    // Since mouse support is semi optimal we have this option to use the joystick like cursor keys
                    if (_mapJoystick && GUIGraphicsContext.Fullscreen)
                    {
                        if (msg.Msg == WM_MOUSEMOVE)
                        {
                            Point p = new Point(msg.LParam.ToInt32());
                            _ignoreDupMsg++;
                            // since our ResetCursor() triggers a mouse move MSG as well we ignore every second event
                            if (_ignoreDupMsg % 2 == 0)
                            {
                                GUIGraphicsContext.ResetCursor(false);
                            }
                            // we ignore double actions for the configured time
                            if (Environment.TickCount - _lastMouseTick < 400)
                            {
                                return(null);
                            }

                            MouseDirection mmove = OnMouseMoved(p);
                            _lastMouseTick = Environment.TickCount;
                            _ignoreDupMsg  = 0;

                            switch (mmove)
                            {
                            case MouseDirection.Up:
                                keycode = 38;
                                break;

                            case MouseDirection.Right:
                                keycode = 39;
                                break;

                            case MouseDirection.Down:
                                keycode = 40;
                                break;

                            case MouseDirection.Left:
                                keycode = 37;
                                break;
                            }
                            if (mmove != MouseDirection.None)
                            {
                                GUIGraphicsContext.ResetCursor(false);
                                if (_verboseLogging)
                                {
                                    Log.Debug("Centarea: Command \"{0}\" mapped for mouse movement", mmove.ToString());
                                }
                            }
                        }
                    }
                    // The Centarea Remote sends key combos. Therefore we use this trick to get a 1:1 mapping
                    if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
                    {
                        keycode += 1000;
                    }
                    if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
                    {
                        keycode += 10000;
                    }
                    if ((Control.ModifierKeys & Keys.Alt) == Keys.Alt)
                    {
                        keycode += 100000;
                    }

                    try
                    {
                        result = _inputHandler.GetMapping(keycode.ToString());
                        if (shouldRaiseAction)
                        {
                            // Get & execute Mapping
                            if (_inputHandler.MapAction(keycode))
                            {
                                if (_verboseLogging)
                                {
                                    Log.Debug("Centarea: Command \"{0}\" mapped", keycode);
                                }
                            }
                            else
                            {
                                if (keycode > 0)
                                {
                                    Log.Debug("Centarea: Command \"{0}\" not mapped", keycode);
                                }
                                return(null);
                            }
                        }
                    }
                    catch (ApplicationException ex)
                    {
                        Log.Error("CentAreaRemote:MapWndProcMessage: {0}", ex.Message);
                        return(null);
                    }
                    msg.Result = new IntPtr(1);
                    break;
                }
            }
            return(result);
        }
示例#5
0
 public void GetMappingNotFound()
 {
   string xmlFile = "TestDefault";
   InputHandler inputHandler = new InputHandler(xmlFile);
   Assert.AreEqual(null, inputHandler.GetMapping("1"));
 }
示例#6
0
    public void GetMapping()
    {
      string xmlFile = "TestDefault";
      InputHandler inputHandler = new InputHandler(xmlFile);

      int layer = 0;
      string condition = "*";
      string conProperty = "-1";
      string command = "ACTION";
      string cmdProperty = "93";
      int cmdKeyChar = 48;
      int cmdKeyCode = 0;
      string sound = "cursor.wav";
      bool focus = true;

      InputHandler.Mapping mapExpected = new InputHandler.Mapping(layer, condition, conProperty, command, cmdProperty,
                                                                  cmdKeyChar, cmdKeyCode, sound, focus);
      InputHandler.Mapping mapTest = inputHandler.GetMapping("0");

      Assert.AreEqual(mapExpected.Layer, mapTest.Layer);
      Assert.AreEqual(mapExpected.Condition, mapTest.Condition);
      Assert.AreEqual(mapExpected.ConProperty, mapTest.ConProperty);
      Assert.AreEqual(mapExpected.Command, mapTest.Command);
      Assert.AreEqual(mapExpected.CmdProperty, mapTest.CmdProperty);
      Assert.AreEqual(mapExpected.CmdKeyChar, mapTest.CmdKeyChar);
      Assert.AreEqual(mapExpected.CmdKeyCode, mapTest.CmdKeyCode);
      Assert.AreEqual(mapExpected.Sound, mapTest.Sound);
      Assert.AreEqual(mapExpected.Focus, mapTest.Focus);
    }