public DelayedControllerReader(IControllerReader baseControllerReader, int delayInMilliseconds)
        {
            this.baseControllerReader = baseControllerReader;
            this.delayInMilliseconds = delayInMilliseconds;

            BaseControllerReader.ControllerStateChanged += BaseControllerReader_ControllerStateChanged;
        }
        public DelayedControllerReader(IControllerReader baseControllerReader, int delayInMilliseconds)
        {
            this.baseControllerReader = baseControllerReader;
            this.delayInMilliseconds  = delayInMilliseconds;

            BaseControllerReader.ControllerStateChanged += BaseControllerReader_ControllerStateChanged;
        }
Esempio n. 3
0
        public Keybindings (string xmlFilePath, IControllerReader reader)
        {
            var xmlPath = Path.Combine (Environment.CurrentDirectory, xmlFilePath);

            if (! File.Exists (xmlPath)) {
                throw new ConfigParseException ("Could not find "+XML_FILE_PATH);
            }

            var doc = XDocument.Load (xmlPath);

            foreach (var binding in doc.Root.Elements ("binding")) 
            {
                var outputKey = readKeybinding (binding.Attribute ("output-key").Value);
                if (outputKey == 0) continue;

                List <string> requiredButtons = new List <string> ();
                foreach (var input in binding.Elements ("input")) {
                    requiredButtons.Add (input.Attribute ("button").Value);
                }

                if (requiredButtons.Count < 1) continue;

                _bindings.Add (new Binding (outputKey, requiredButtons));
            }

            _reader = reader;
            _reader.ControllerStateChanged += reader_ControllerStateChanged;
        }
Esempio n. 4
0
        public static void Add(ActionInput actionInput, IControllerReader reader)
        {
            InputReaderManager obj = InputReaderManager.Instance;

            Debug.Assert(reader != null && !obj.inputReaders.ContainsKey(actionInput));
            obj.inputReaders.Update(actionInput, reader);
        }
        public DelayedControllerReader(IControllerReader baseControllerReader, int delayInMilliseconds, bool legacyKeybindingBehavior)
        {
            BaseControllerReader     = baseControllerReader;
            DelayInMilliseconds      = delayInMilliseconds;
            LegacyKeybindingBehavior = legacyKeybindingBehavior;

            BaseControllerReader.ControllerStateChanged += BaseControllerReader_ControllerStateChanged;
            BaseControllerReader.ControllerDisconnected += BaseControllerReader_ControllerDisconnected;
        }
        public GameBoyPrinterEmulatorWindow(IControllerReader reader)
        {
            if (Properties.Settings.Default.UpgradeRequired)
            {
                Properties.Settings.Default.Upgrade();
                Properties.Settings.Default.UpgradeRequired = false;
                Properties.Settings.Default.Save();
            }

            InitializeComponent();
            DataContext = this;

            _reader = reader ?? throw new ArgumentNullException(nameof(reader));

            SelectedPalette = Properties.Settings.Default.SelectedPalette;
            PrintSize       = Properties.Settings.Default.PrintSize;

            using (Bitmap bmp = new Bitmap(Properties.Resources.PrintImage))
            {
                _imageBuffer = new BitmapPixelMaker(480, 432);

                _imageBuffer.SetColor(palettes[SelectedPalette][0][3], palettes[SelectedPalette][1][3], palettes[SelectedPalette][2][3]);

                for (int i = 0; i < bmp.Width; ++i)
                {
                    for (int j = 0; j < bmp.Height; ++j)
                    {
                        System.Drawing.Color pixel = bmp.GetPixel(i, j);
                        if (pixel.R == 255 && pixel.G == 255 && pixel.B == 255)
                        {
                            _imageBuffer.SetRed(i, j, palettes[SelectedPalette][0][0]);
                            _imageBuffer.SetGreen(i, j, palettes[SelectedPalette][1][0]);
                            _imageBuffer.SetBlue(i, j, palettes[SelectedPalette][2][0]);
                        }
                    }
                }

                WriteableBitmap wbitmap = _imageBuffer.MakeBitmap(96, 96);

                // Create an Image to display the bitmap.
                _image = new System.Windows.Controls.Image
                {
                    Stretch = Stretch.None,
                    Margin  = new Thickness(0)
                };

                _             = GameBoyPrinterEmulatorWindowGrid.Children.Add(_image);
                _image.Source = wbitmap;

                _reader.ControllerStateChanged += Reader_ControllerStateChanged;
                _reader.ControllerDisconnected += Reader_ControllerDisconnected;

                CheckPalette(SelectedPalette);
                CheckSize(PrintSize);
            }
        }
Esempio n. 7
0
        public ViewWindow(Skin skin, Skin.Background skinBackground, IControllerReader reader)
        {
            InitializeComponent();
            DataContext = this;

            _skin   = skin;
            _reader = reader;

            ControllerGrid.Width  = skinBackground.Image.PixelWidth;
            ControllerGrid.Height = skinBackground.Image.PixelHeight;

            var brush = new ImageBrush(skinBackground.Image);

            brush.Stretch             = Stretch.Uniform;
            ControllerGrid.Background = brush;

            foreach (var trigger in _skin.AnalogTriggers)
            {
                var grid = getGridForAnalogTrigger(trigger);
                _triggersWithGridImages.Add(new Tuple <Skin.AnalogTrigger, Grid> (trigger, grid));
                ControllerGrid.Children.Add(grid);
            }

            foreach (var button in _skin.Buttons)
            {
                var image = getImageForElement(button.Config);
                _buttonsWithImages.Add(new Tuple <Skin.Button, Image> (button, image));
                image.Visibility = Visibility.Hidden;
                ControllerGrid.Children.Add(image);
            }

            foreach (var button in _skin.RangeButtons)
            {
                var image = getImageForElement(button.Config);
                _rangeButtonsWithImages.Add(new Tuple <Skin.RangeButton, Image> (button, image));
                image.Visibility = Visibility.Hidden;
                ControllerGrid.Children.Add(image);
            }

            foreach (var stick in _skin.AnalogSticks)
            {
                var image = getImageForElement(stick.Config);
                _sticksWithImages.Add(new Tuple <Skin.AnalogStick, Image> (stick, image));
                ControllerGrid.Children.Add(image);
            }

            _reader.ControllerStateChanged += reader_ControllerStateChanged;
            _reader.ControllerDisconnected += reader_ControllerDisconnected;

            try {
                _keybindings = new Keybindings(Keybindings.XML_FILE_PATH, _reader);
            } catch (ConfigParseException) {
                MessageBox.Show("Error parsing keybindings.xml. Not binding any keys to gamepad inputs");
            }
        }
        private async void BaseControllerReader_ControllerStateChanged(IControllerReader sender, ControllerState state)
        {
            if (!disposedValue)
            {
                await Task.Delay(delayInMilliseconds);

                var controllerStateChanged = ControllerStateChanged;
                if (controllerStateChanged != null)
                    controllerStateChanged(this, state);
            }
        }
Esempio n. 9
0
 private InputSource(string typeTag, string name, bool requiresComPort, bool requiresId, bool requiresHostname, bool requiresComPort2, bool requiresMisterControllerId, IControllerReader buildReader3)
 {
     TypeTag          = typeTag;
     Name             = name;
     RequiresComPort  = requiresComPort;
     RequiresComPort2 = requiresComPort2;
     RequiresId       = requiresId;
     RequiresHostname = requiresHostname;
     RequiresMisterId = requiresMisterControllerId;
     BuildReader3     = buildReader3;
 }
        private async void BaseControllerReader_ControllerStateChanged(IControllerReader sender, ControllerState state)
        {
            if (!disposedValue)
            {
                await Task.Delay(delayInMilliseconds);

                var controllerStateChanged = ControllerStateChanged;
                if (controllerStateChanged != null)
                {
                    controllerStateChanged(this, state);
                }
            }
        }
Esempio n. 11
0
        public ViewWindow (Skin skin, Skin.Background skinBackground, IControllerReader reader)
        {
            InitializeComponent ();
            DataContext = this;

            _skin = skin;
            _reader = reader;

            ControllerGrid.Width = skinBackground.Image.PixelWidth;
            ControllerGrid.Height = skinBackground.Image.PixelHeight;

            var brush = new ImageBrush (skinBackground.Image);
            brush.Stretch = Stretch.Uniform;
            ControllerGrid.Background = brush;

            foreach (var trigger in _skin.AnalogTriggers) {
                var grid = getGridForAnalogTrigger (trigger);
                _triggersWithGridImages.Add (new Tuple <Skin.AnalogTrigger,Grid> (trigger, grid));
                ControllerGrid.Children.Add (grid);
            }

            foreach (var button in _skin.Buttons) {
                var image = getImageForElement (button.Config);
                _buttonsWithImages.Add (new Tuple <Skin.Button,Image> (button, image));
                image.Visibility = Visibility.Hidden;
                ControllerGrid.Children.Add (image);
            }

            foreach (var button in _skin.RangeButtons) {
                var image = getImageForElement (button.Config);
                _rangeButtonsWithImages.Add (new Tuple <Skin.RangeButton,Image> (button, image));
                image.Visibility = Visibility.Hidden;
                ControllerGrid.Children.Add (image);
            }
            
            foreach (var stick in _skin.AnalogSticks) {
                var image = getImageForElement (stick.Config);
                _sticksWithImages.Add (new Tuple <Skin.AnalogStick,Image> (stick, image));
                ControllerGrid.Children.Add (image);
            }

            _reader.ControllerStateChanged += reader_ControllerStateChanged;
            _reader.ControllerDisconnected += reader_ControllerDisconnected;

            try {
                _keybindings = new Keybindings (Keybindings.XML_FILE_PATH, _reader);
            } catch (ConfigParseException) {
                MessageBox.Show ("Error parsing keybindings.xml. Not binding any keys to gamepad inputs");
            }
        }
Esempio n. 12
0
        public ViewWindow (Skin skin, Skin.Background skinBackground, IControllerReader reader)
        {
            InitializeComponent ();
            DataContext = this;

            _skin = skin;
            _reader = reader;

            ControllerGrid.Width = skinBackground.Image.PixelWidth;
            ControllerGrid.Height = skinBackground.Image.PixelHeight;

            var brush = new ImageBrush (skinBackground.Image);
            brush.Stretch = Stretch.Uniform;
            ControllerGrid.Background = brush;

            foreach (var trigger in _skin.AnalogTriggers) {
                var grid = getGridForAnalogTrigger (trigger);
                _triggersWithGridImages.Add (new Tuple <Skin.AnalogTrigger,Grid> (trigger, grid));
                ControllerGrid.Children.Add (grid);
            }

            foreach (var button in _skin.Buttons) {
                var image = getImageForElement (button.Config);
                _buttonsWithImages.Add (new Tuple <Skin.Button,Image> (button, image));
                image.Visibility = Visibility.Hidden;
                ControllerGrid.Children.Add (image);
            }

            foreach (var button in _skin.RangeButtons) {
                var image = getImageForElement (button.Config);
                _rangeButtonsWithImages.Add (new Tuple <Skin.RangeButton,Image> (button, image));
                image.Visibility = Visibility.Hidden;
                ControllerGrid.Children.Add (image);
            }
            
            foreach (var stick in _skin.AnalogSticks) {
                var image = getImageForElement (stick.Config);
                _sticksWithImages.Add (new Tuple <Skin.AnalogStick,Image> (stick, image));
                ControllerGrid.Children.Add (image);
            }

            _reader.ControllerStateChanged += reader_ControllerStateChanged;
            _reader.ControllerDisconnected += reader_ControllerDisconnected;
        }
Esempio n. 13
0
        public Keybindings(string xmlFilePath, IControllerReader reader)
        {
            var xmlPath = Path.Combine(Environment.CurrentDirectory, xmlFilePath);

            if (!File.Exists(xmlPath))
            {
                throw new ConfigParseException("Could not find " + XML_FILE_PATH);
            }

            var doc = XDocument.Load(xmlPath);

            foreach (var binding in doc.Root.Elements("binding"))
            {
                var outputKey = readKeybinding(binding.Attribute("output-key").Value);
                if (outputKey == 0)
                {
                    continue;
                }

                List <string> requiredButtons = new List <string> ();
                foreach (var input in binding.Elements("button"))
                {
                    requiredButtons.Add(input.Attribute("pushed").Value);
                }

                List <string> requiredAxes      = new List <string>();
                List <float>  requiredAxesLimit = new List <float>();
                foreach (var input in binding.Elements("analog"))
                {
                    requiredAxes.Add(input.Attribute("axis").Value);
                    requiredAxesLimit.Add(Convert.ToSingle(input.Attribute("limit").Value));
                }

                if (requiredButtons.Count < 1 && requiredAxes.Count < 1)
                {
                    continue;
                }

                _bindings.Add(new Binding(outputKey, requiredButtons, requiredAxes, requiredAxesLimit));
            }

            _reader = reader;
            _reader.ControllerStateChanged += reader_ControllerStateChanged;
        }
Esempio n. 14
0
        void reader_ControllerStateChanged(IControllerReader reader, ControllerState state)
        {
            foreach (var binding in _bindings)
            {
                bool allRequiredButtonsDown = true;

                foreach (var requiredButton in binding.RequiredButtons)
                {
                    allRequiredButtonsDown &= state.Buttons [requiredButton];
                }

                for (int i = 0; i < binding.RequiredAxes.Count; i++)
                {
                    var axis  = binding.RequiredAxes[i];
                    var value = binding.RequiredAxesLimit[i];
                    if (value > 0)
                    {
                        if (state.Analogs[axis] < value)
                        {
                            allRequiredButtonsDown = false;
                        }
                    }
                    else
                    {
                        if (state.Analogs[axis] > value)
                        {
                            allRequiredButtonsDown = false;
                        }
                    }
                }

                if (allRequiredButtonsDown && !binding.CurrentlyDepressed)
                {
                    SendKeys.PressKey(binding.OutputKey);
                    binding.CurrentlyDepressed = true;
                }
                else if (!allRequiredButtonsDown && binding.CurrentlyDepressed)
                {
                    SendKeys.ReleaseKey(binding.OutputKey);
                    binding.CurrentlyDepressed = false;
                }
            }
        }
Esempio n. 15
0
        public Keybindings(string xmlFilePath, IControllerReader reader)
        {
            string xmlPath = Path.Combine(Environment.CurrentDirectory, xmlFilePath);

            if (!File.Exists(xmlPath))
            {
                throw new ConfigParseException(string.Format(CultureInfo.CurrentCulture, "Could not find {0}", XmlFilePath));
            }

            XDocument doc = XDocument.Load(xmlPath);

            foreach (XElement binding in doc.Root.Elements("binding"))
            {
                ushort outputKey = ReadKeybinding(binding.Attribute("output-key").Value);
                if (outputKey == 0)
                {
                    continue;
                }

                List <string> requiredButtons = new List <string>();
                foreach (XElement input in binding.Elements("input"))
                {
                    requiredButtons.Add(input.Attribute("button").Value);
                }

                if (requiredButtons.Count < 1)
                {
                    continue;
                }

                _bindings.Add(new Binding(outputKey, requiredButtons));
            }

            _reader = reader ?? throw new ArgumentNullException(nameof(reader));
            if (_reader.GetType() == typeof(DelayedControllerReader))
            {
                ((DelayedControllerReader)_reader).ControllerStateChangedNoDelay += Reader_ControllerStateChanged;
            }
            else
            {
                _reader.ControllerStateChanged += Reader_ControllerStateChanged;
            }
        }
Esempio n. 16
0
        void reader_ControllerStateChanged (IControllerReader reader, ControllerState state)
        {
            foreach (var binding in _bindings) 
            {
                bool allRequiredButtonsDown = true;

                foreach (var requiredButton in binding.RequiredButtons) {
                    allRequiredButtonsDown &= state.Buttons [requiredButton];
                }

                if (allRequiredButtonsDown && !binding.CurrentlyDepressed) {
                    SendKeys.PressKey (binding.OutputKey);
                    binding.CurrentlyDepressed = true;
                }
                else if (!allRequiredButtonsDown && binding.CurrentlyDepressed) {
                    SendKeys.ReleaseKey (binding.OutputKey);
                    binding.CurrentlyDepressed = false;
                }
            }
        }
Esempio n. 17
0
        private void GoButton_Click(object sender, RoutedEventArgs e)
        {
            Hide();
            Properties.Settings.Default.Port           = _vm.Ports.SelectedItem;
            Properties.Settings.Default.FilterCOMPorts = _vm.FilterCOMPorts;
            Properties.Settings.Default.Save();

            IControllerReader reader = InputSource.PRINTER.BuildReader("COM16");

            try
            {
                _ = new GameBoyPrinterEmulatorWindow(reader).ShowDialog();
            }
            catch (UnauthorizedAccessException ex)
            {
                _ = MessageBox.Show(ex.Message, _resources.GetString("RetroSpy", CultureInfo.CurrentUICulture), MessageBoxButton.OK, MessageBoxImage.Error);
            }

            Show();
        }
Esempio n. 18
0
        void goButton_Click(object sender, RoutedEventArgs e)
        {
            this.Hide();

            try
            {
                IControllerReader reader = null;

                if (_vm.Sources.SelectedItem.RequiresIPAdd)
                {
                    reader = _vm.Sources.SelectedItem.BuildReader(_vm.IPAddress);
                }
                else
                {
                    reader = _vm.Sources.SelectedItem.BuildReader(_vm.Ports.SelectedItem);
                }

                if (_vm.DelayInMilliseconds > 0)
                {
                    reader = new DelayedControllerReader(reader, _vm.DelayInMilliseconds);
                }

                new ViewWindow(_vm.Skins.SelectedItem,
                               _vm.Backgrounds.SelectedItem,
                               reader)
                .ShowDialog();
            }
#if DEBUG
            catch (ConfigParseException ex) {
#else
            catch (Exception ex) {
#endif
                MessageBox.Show(ex.Message, "NintendoSpy", MessageBoxButton.OK, MessageBoxImage.Error);
            }

            Properties.Settings.Default.ipAddress       = _vm.IPAddress;
            Properties.Settings.Default.lastInputChoice = _vm.Sources.SelectedItem.TypeTag;
            Properties.Settings.Default.Save();

            this.Show();
        }
Esempio n. 19
0
        public static void StartListening()
        {
            string portStr    = AppController.mainForm.comboBoxPorts.GetItemText(AppController.mainForm.comboBoxPorts.SelectedItem);
            string consoleStr = AppController.mainForm.comboBoxControllerType.GetItemText(AppController.mainForm.comboBoxControllerType.SelectedItem);

            AppController.Log("NintendoSpy: Starting wrapper on: " + portStr, Constants.Enums.LogMessageType.Basic);
            try
            {
                if (consoleStr.StartsWith("NES"))
                {
                    source       = new InputSource("nes", "NES", true, false, port => new SerialControllerReader(portStr, SuperNESandNES.ReadFromPacket_NES));
                    controlStyle = ControlStyle.NES;
                }
                else if (consoleStr.StartsWith("SNES"))
                {
                    source       = new InputSource("snes", "Super SNES", true, false, port => new SerialControllerReader(portStr, SuperNESandNES.ReadFromPacket_SNES));
                    controlStyle = ControlStyle.SNES;
                }
                else if (consoleStr.StartsWith("N64"))
                {
                    source       = new InputSource("n64", "Nintendo 64", true, false, port => new SerialControllerReader(portStr, Nintendo64.ReadFromPacket));
                    controlStyle = ControlStyle.N64;
                }
                else if (consoleStr.StartsWith("GameCube"))
                {
                    source       = new InputSource("gamecube", "GameCube", true, false, port => new SerialControllerReader(portStr, GameCube.ReadFromPacket));
                    controlStyle = ControlStyle.GameCube;
                }
                _reader = source.BuildReader(portStr);
                _reader.ControllerStateChanged += reader_ControllerStateChanged;
                _reader.ControllerDisconnected += reader_ControllerDisconnected;
                AppController.Log("NintendoSpy: Wrapper Started.", Constants.Enums.LogMessageType.Basic);
            }
            catch (Exception exc)
            {
                AppController.Log("NintendoSpy: Error:\n" + exc.ToString(), Constants.Enums.LogMessageType.Error);
            }
        }
Esempio n. 20
0
        void reader_ControllerStateChanged(IControllerReader reader, ControllerState state)
        {
            foreach (var binding in _bindings)
            {
                bool allRequiredButtonsDown = true;

                foreach (var requiredButton in binding.RequiredButtons)
                {
                    allRequiredButtonsDown &= state.Buttons [requiredButton];
                }

                if (allRequiredButtonsDown && !binding.CurrentlyDepressed)
                {
                    SendKeys.PressKey(binding.OutputKey);
                    binding.CurrentlyDepressed = true;
                }
                else if (!allRequiredButtonsDown && binding.CurrentlyDepressed)
                {
                    SendKeys.ReleaseKey(binding.OutputKey);
                    binding.CurrentlyDepressed = false;
                }
            }
        }
Esempio n. 21
0
        public Keybindings(string xmlFilePath, IControllerReader reader)
        {
            string xmlPath = Path.Combine(Environment.CurrentDirectory, xmlFilePath);

            if (!File.Exists(xmlPath))
            {
                throw new ConfigParseException("Could not find " + XML_FILE_PATH);
            }

            XDocument doc = XDocument.Load(xmlPath);

            foreach (XElement binding in doc.Root.Elements("binding"))
            {
                ushort outputKey = ReadKeybinding(binding.Attribute("output-key").Value);
                if (outputKey == 0)
                {
                    continue;
                }

                List <string> requiredButtons = new List <string>();
                foreach (XElement input in binding.Elements("input"))
                {
                    requiredButtons.Add(input.Attribute("button").Value);
                }

                if (requiredButtons.Count < 1)
                {
                    continue;
                }

                _bindings.Add(new Binding(outputKey, requiredButtons));
            }

            _reader = reader;
            _reader.ControllerStateChanged += Reader_ControllerStateChanged;
        }
Esempio n. 22
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ControllerDataChunk"/> class.
 /// </summary>
 /// <param name="controllerReader">The controller reader.</param>
 /// <param name="controllerWriter">The controller writer.</param>
 public ControllerDataChunk(IControllerReader controllerReader, IControllerWriter controllerWriter)
     : base(DatFile.Magics.ControllerData)
 {
     _controllerReader = controllerReader ?? throw new ArgumentNullException(nameof(controllerReader));
     _controllerWriter = controllerWriter ?? throw new ArgumentNullException(nameof(controllerWriter));
 }
Esempio n. 23
0
 public static void StopListening()
 {
     _reader.Finish();
     _reader = null;
 }
Esempio n. 24
0
 static void reader_ControllerStateChanged(IControllerReader reader, ControllerState newState)
 {
     state = newState;
 }
Esempio n. 25
0
        private void UpdatePortList()
        {
            if (!isClosing && Monitor.TryEnter(updatePortLock))
            {
                try
                {
                    List <string> arduinoPorts = SetupCOMPortInformation();

                    foreach (string port in arduinoPorts)
                    {
                        using (SerialPort _serialPort = new SerialPort(port, 115200, Parity.None, 8, StopBits.One)
                        {
                            Handshake = Handshake.None,
                            ReadTimeout = 500,
                            WriteTimeout = 500
                        })
                        {
                            try
                            {
                                _serialPort.Open();
                            }
                            catch (Exception)
                            {
                                continue;
                            }

                            try
                            {
                                _serialPort.Write("\x88\x33\x0F\x00\x00\x00\x0F\x00\x00");
                            }
                            catch (Exception)
                            {
                                _serialPort.Close();
                                continue;
                            }

                            try
                            {
                                string result = null;
                                do
                                {
                                    result = _serialPort.ReadLine();
                                } while (result != null && (result.StartsWith("!", StringComparison.Ordinal) || result.StartsWith("#", StringComparison.Ordinal)));

                                if (result == "parse_state:0\r" || result.Contains("d=debug"))
                                {
                                    _serialPort.Close();
                                    Thread.Sleep(1000);

                                    if (Dispatcher.CheckAccess())
                                    {
                                        Hide();
                                    }
                                    else
                                    {
                                        Dispatcher.Invoke(() =>
                                        {
                                            Hide();
                                        });
                                    }

                                    Properties.Settings.Default.Port           = _vm.Ports.SelectedItem;
                                    Properties.Settings.Default.FilterCOMPorts = _vm.FilterCOMPorts;
                                    Properties.Settings.Default.Save();

                                    try
                                    {
                                        if (Dispatcher.CheckAccess())
                                        {
                                            IControllerReader reader = InputSource.PRINTER.BuildReader(port);
                                            _ = new GameBoyPrinterEmulatorWindow(reader).ShowDialog();
                                        }
                                        else
                                        {
                                            Dispatcher.Invoke(() =>
                                            {
                                                IControllerReader reader = InputSource.PRINTER.BuildReader(port);
                                                _ = new GameBoyPrinterEmulatorWindow(reader).ShowDialog();
                                            });
                                        }
                                    }
                                    catch (UnauthorizedAccessException ex)
                                    {
                                        _ = MessageBox.Show(ex.Message, _resources.GetString("RetroSpy", CultureInfo.CurrentUICulture), MessageBoxButton.OK, MessageBoxImage.Error);
                                    }

                                    if (Dispatcher.CheckAccess())
                                    {
                                        Show();
                                    }
                                    else
                                    {
                                        Dispatcher.Invoke(() =>
                                        {
                                            Show();
                                        });
                                    }
                                }
                                else
                                {
                                    _serialPort.Close();
                                    continue;
                                }
                            }
                            catch (Exception)
                            {
                                _serialPort.Close();
                                continue;
                            }
                        }
                    }
                }
                catch (TaskCanceledException)
                {
                    // Closing the window can cause this due to a race condition
                }
                finally
                {
                    Monitor.Exit(updatePortLock);
                }
            }
        }
Esempio n. 26
0
 void reader_ControllerStateChanged(IControllerReader reader, ControllerState newState)
 {
     writePacket(newState.Packet);
 }
Esempio n. 27
0
        string movieDescription  = "TAS File recorded from console"; // 256-byte utf-8 string     placeholder

        public M64(string _fileName, IControllerReader reader)
        {
            createFile(_fileName);
            reader.ControllerStateChanged += reader_ControllerStateChanged;
        }
Esempio n. 28
0
        void reader_ControllerStateChanged (IControllerReader reader, ControllerState newState)
        {
            newState = _blinkFilter.Process (newState);

            foreach (var button in _buttonsWithImages) 
            {
                if (!newState.Buttons.ContainsKey (button.Item1.Name)) continue;

                button.Item2.Visibility = newState.Buttons [button.Item1.Name] ? Visibility.Visible : Visibility.Hidden ;
            }

            foreach (var button in _rangeButtonsWithImages) 
            {
                if (!newState.Analogs.ContainsKey (button.Item1.Name)) continue;

                var value = newState.Analogs [button.Item1.Name];
                var visible = button.Item1.From <= value && value <= button.Item1.To;

                button.Item2.Visibility = visible ? Visibility.Visible : Visibility.Hidden ;
            }

            foreach (var stick in _sticksWithImages)
            {
                var skin = stick.Item1;
                var image = stick.Item2;

                float xrange = (skin.XReverse ? -1 :  1) * skin.XRange;
                float yrange = (skin.YReverse ?  1 : -1) * skin.YRange;

                var x = newState.Analogs.ContainsKey (skin.XName)
                      ? skin.Config.X + xrange * newState.Analogs [skin.XName]
                      : skin.Config.X ;

                var y = newState.Analogs.ContainsKey (skin.YName)
                      ? skin.Config.Y + yrange * newState.Analogs [skin.YName]
                      : skin.Config.Y ;
                
                image.Margin = new Thickness (x,y,0,0);
            }
            
            foreach (var trigger in _triggersWithGridImages)
            {
                var skin = trigger.Item1;
                var grid = trigger.Item2;

                if (!newState.Analogs.ContainsKey (skin.Name)) continue;

                var val = newState.Analogs [skin.Name];
                if (skin.UseNegative) val *= -1;
                if (skin.IsReversed) val = 1 - val;
                if (val < 0) val = 0;

                switch (skin.Direction) 
                {
                    case Skin.AnalogTrigger.DirectionValue.Right:
                        grid.Width = skin.Config.Width * val;
                        break;

                    case Skin.AnalogTrigger.DirectionValue.Left:
                        var width = skin.Config.Width * val;
                        var offx = skin.Config.Width - width;
                        grid.Margin = new Thickness (skin.Config.X + offx, skin.Config.Y, 0, 0);
                        grid.Width = width;
                        break;

                    case Skin.AnalogTrigger.DirectionValue.Down:
                        grid.Height = skin.Config.Height * val;
                        break;

                    case Skin.AnalogTrigger.DirectionValue.Up:
                        var height = skin.Config.Height * val;
                        var offy = skin.Config.Height - height;
                        grid.Margin = new Thickness (skin.Config.X, skin.Config.Y + offy, 0, 0);
                        grid.Height = height;
                        break;
                }
            }
        }
Esempio n. 29
0
        public ViewWindow(Skin skin, Skin.Background skinBackground, IControllerReader reader)
        {
            InitializeComponent();
            DataContext = this;

            _skin   = skin;
            _reader = reader;

            ControllerGrid.Width  = skinBackground.Width;
            ControllerGrid.Height = skinBackground.Height;
            var brush = new SolidColorBrush(skinBackground.Color);

            ControllerGrid.Background = brush;

            if (skinBackground.Image != null)
            {
                var img = new Image();
                img.VerticalAlignment   = VerticalAlignment.Top;
                img.HorizontalAlignment = HorizontalAlignment.Left;
                img.Source  = skinBackground.Image;
                img.Stretch = Stretch.Uniform;
                img.Margin  = new Thickness(0, 0, 0, 0);
                img.Width   = skinBackground.Image.PixelWidth;
                img.Height  = skinBackground.Image.PixelHeight;
                ControllerGrid.Children.Add(img);
            }

            foreach (var detail in _skin.Details)
            {
                if (bgIsActive(skinBackground.Name, detail.Config.TargetBackgrounds, detail.Config.IgnoreBackgrounds))
                {
                    var image = getImageForElement(detail.Config);
                    ControllerGrid.Children.Add(image);
                }
            }

            foreach (var trigger in _skin.AnalogTriggers)
            {
                if (bgIsActive(skinBackground.Name, trigger.Config.TargetBackgrounds, trigger.Config.IgnoreBackgrounds))
                {
                    var grid = getGridForAnalogTrigger(trigger);
                    _triggersWithGridImages.Add(new Tuple <Skin.AnalogTrigger, Grid>(trigger, grid));
                    ControllerGrid.Children.Add(grid);
                }
            }

            foreach (var button in _skin.Buttons)
            {
                if (bgIsActive(skinBackground.Name, button.Config.TargetBackgrounds, button.Config.IgnoreBackgrounds))
                {
                    var image = getImageForElement(button.Config);
                    _buttonsWithImages.Add(new Tuple <Skin.Button, Image>(button, image));
                    image.Visibility = Visibility.Hidden;
                    ControllerGrid.Children.Add(image);
                }
            }

            foreach (var button in _skin.RangeButtons)
            {
                if (bgIsActive(skinBackground.Name, button.Config.TargetBackgrounds, button.Config.IgnoreBackgrounds))
                {
                    var image = getImageForElement(button.Config);
                    _rangeButtonsWithImages.Add(new Tuple <Skin.RangeButton, Image>(button, image));
                    image.Visibility = Visibility.Hidden;
                    ControllerGrid.Children.Add(image);
                }
            }

            foreach (var stick in _skin.AnalogSticks)
            {
                if (bgIsActive(skinBackground.Name, stick.Config.TargetBackgrounds, stick.Config.IgnoreBackgrounds))
                {
                    var image = getImageForElement(stick.Config);
                    _sticksWithImages.Add(new Tuple <Skin.AnalogStick, Image>(stick, image));
                    ControllerGrid.Children.Add(image);
                }
            }

            _reader.ControllerStateChanged += reader_ControllerStateChanged;
            _reader.ControllerDisconnected += reader_ControllerDisconnected;

            try {
                _keybindings = new Keybindings(Keybindings.XML_FILE_PATH, _reader);
            } catch (ConfigParseException) {
                MessageBox.Show("Error parsing keybindings.xml. Not binding any keys to gamepad inputs");
            }

            MassBlinkReductionEnabled   = Properties.Settings.Default.MassFilter;
            AnalogBlinkReductionEnabled = Properties.Settings.Default.AnalogFilter;
            ButtonBlinkReductionEnabled = Properties.Settings.Default.ButtonFilter;
            Topmost = Properties.Settings.Default.TopMost;
        }
Esempio n. 30
0
        void reader_ControllerStateChanged(IControllerReader reader, ControllerState newState)
        {
            newState = _blinkFilter.Process(newState);

            foreach (var button in _buttonsWithImages)
            {
                if (!newState.Buttons.ContainsKey(button.Item1.Name))
                {
                    continue;
                }

                button.Item2.Visibility = newState.Buttons [button.Item1.Name] ? Visibility.Visible : Visibility.Hidden;
            }

            foreach (var button in _rangeButtonsWithImages)
            {
                if (!newState.Analogs.ContainsKey(button.Item1.Name))
                {
                    continue;
                }

                var value   = newState.Analogs [button.Item1.Name];
                var visible = button.Item1.From <= value && value <= button.Item1.To;

                button.Item2.Visibility = visible ? Visibility.Visible : Visibility.Hidden;
            }

            foreach (var stick in _sticksWithImages)
            {
                var skin  = stick.Item1;
                var image = stick.Item2;

                float xrange = (skin.XReverse ? -1 :  1) * skin.XRange;
                float yrange = (skin.YReverse ?  1 : -1) * skin.YRange;

                var x = newState.Analogs.ContainsKey(skin.XName)
                      ? skin.Config.X + xrange * newState.Analogs [skin.XName]
                      : skin.Config.X;

                var y = newState.Analogs.ContainsKey(skin.YName)
                      ? skin.Config.Y + yrange * newState.Analogs [skin.YName]
                      : skin.Config.Y;

                image.Margin = new Thickness(x, y, 0, 0);
            }

            foreach (var trigger in _triggersWithGridImages)
            {
                var skin = trigger.Item1;
                var grid = trigger.Item2;

                if (!newState.Analogs.ContainsKey(skin.Name))
                {
                    continue;
                }

                var val = newState.Analogs [skin.Name];
                if (skin.UseNegative)
                {
                    val *= -1;
                }
                if (skin.IsReversed)
                {
                    val = 1 - val;
                }
                if (val < 0)
                {
                    val = 0;
                }
                switch (skin.Direction)
                {
                case Skin.AnalogTrigger.DirectionValue.Right:
                    grid.Width = skin.Config.Width * val;
                    break;

                case Skin.AnalogTrigger.DirectionValue.Left:
                    var width = skin.Config.Width * val;
                    var offx  = skin.Config.Width - width;
                    grid.Margin = new Thickness(skin.Config.X + offx, skin.Config.Y, 0, 0);
                    grid.Width  = width;
                    break;

                case Skin.AnalogTrigger.DirectionValue.Down:
                    grid.Height = skin.Config.Height * val;
                    break;

                case Skin.AnalogTrigger.DirectionValue.Up:
                    var height = skin.Config.Height * val;
                    var offy   = skin.Config.Height - height;
                    grid.Margin = new Thickness(skin.Config.X, skin.Config.Y + offy, 0, 0);
                    grid.Height = height;
                    break;
                }
            }
        }
Esempio n. 31
0
        void reader_ControllerStateChanged(IControllerReader reader, ControllerState newState)
        {
            newState = _blinkFilter.Process(newState);

            // This assumes you can't press left/right and up/down at the same time.  The code gets more complicated otherwise.
            var compassDirectionStates = new Dictionary <string, bool>();

            if (newState.Buttons.ContainsKey("up") && newState.Buttons.ContainsKey("left") && newState.Buttons.ContainsKey("right") && newState.Buttons.ContainsKey("down"))
            {
                string[] compassDirections = { "north", "northeast", "east", "southeast", "south", "southwest", "west", "northwest" };

                var compassDirectionStatesTemp = new bool[8];
                compassDirectionStatesTemp[0] = newState.Buttons["up"];
                compassDirectionStatesTemp[2] = newState.Buttons["right"];
                compassDirectionStatesTemp[4] = newState.Buttons["down"];
                compassDirectionStatesTemp[6] = newState.Buttons["left"];

                if (compassDirectionStatesTemp[0] && compassDirectionStatesTemp[2])
                {
                    compassDirectionStatesTemp[1] = true;
                    compassDirectionStatesTemp[0] = compassDirectionStatesTemp[2] = false;
                }
                else if (compassDirectionStatesTemp[2] && compassDirectionStatesTemp[4])
                {
                    compassDirectionStatesTemp[3] = true;
                    compassDirectionStatesTemp[2] = compassDirectionStatesTemp[4] = false;
                }
                else if (compassDirectionStatesTemp[4] && compassDirectionStatesTemp[6])
                {
                    compassDirectionStatesTemp[5] = true;
                    compassDirectionStatesTemp[4] = compassDirectionStatesTemp[6] = false;
                }
                else if (compassDirectionStatesTemp[6] && compassDirectionStatesTemp[0])
                {
                    compassDirectionStatesTemp[7] = true;
                    compassDirectionStatesTemp[6] = compassDirectionStatesTemp[0] = false;
                }

                for (int i = 0; i < compassDirections.Length; ++i)
                {
                    compassDirectionStates[compassDirections[i]] = compassDirectionStatesTemp[i];
                }
            }

            foreach (var button in _buttonsWithImages)
            {
                if (newState.Buttons.ContainsKey(button.Item1.Name))
                {
                    if (button.Item2.Dispatcher.CheckAccess())
                    {
                        button.Item2.Visibility = newState.Buttons[button.Item1.Name] ? Visibility.Visible : Visibility.Hidden;
                    }
                    else
                    {
                        button.Item2.Dispatcher.Invoke(() =>
                        {
                            button.Item2.Visibility = newState.Buttons[button.Item1.Name] ? Visibility.Visible : Visibility.Hidden;
                        });
                    }
                }
                else if (compassDirectionStates.ContainsKey(button.Item1.Name))
                {
                    if (button.Item2.Dispatcher.CheckAccess())
                    {
                        button.Item2.Visibility = compassDirectionStates[button.Item1.Name] ? Visibility.Visible : Visibility.Hidden;
                    }
                    else
                    {
                        button.Item2.Dispatcher.Invoke(() =>
                        {
                            button.Item2.Visibility = compassDirectionStates[button.Item1.Name] ? Visibility.Visible : Visibility.Hidden;
                        });
                    }
                }
            }

            foreach (var button in _rangeButtonsWithImages)
            {
                if (!newState.Analogs.ContainsKey(button.Item1.Name))
                {
                    continue;
                }

                var value   = newState.Analogs [button.Item1.Name];
                var visible = button.Item1.From <= value && value <= button.Item1.To;
                button.Item2.Visibility = visible ? Visibility.Visible : Visibility.Hidden;
            }

            foreach (var stick in _sticksWithImages)
            {
                var skin  = stick.Item1;
                var image = stick.Item2;

                float xrange = (skin.XReverse ? -1 : 1) * skin.XRange;
                float yrange = (skin.YReverse ? 1 : -1) * skin.YRange;

                var x = newState.Analogs.ContainsKey(skin.XName)
                      ? skin.Config.X + xrange * newState.Analogs[skin.XName]
                      : skin.Config.X;

                var y = newState.Analogs.ContainsKey(skin.YName)
                      ? skin.Config.Y + yrange * newState.Analogs[skin.YName]
                      : skin.Config.Y;

                Visibility visibility;
                if (skin.VisibilityName != "")
                {
                    visibility = (newState.Buttons.ContainsKey(skin.VisibilityName) && newState.Buttons[skin.VisibilityName]) ? Visibility.Visible : Visibility.Hidden;
                }
                else
                {
                    visibility = Visibility.Visible;
                }

                if (image.Dispatcher.CheckAccess())
                {
                    image.Margin     = new Thickness(x, y, 0, 0);
                    image.Visibility = visibility;
                }
                else
                {
                    image.Dispatcher.Invoke(() =>
                    {
                        image.Margin     = new Thickness(x, y, 0, 0);
                        image.Visibility = visibility;
                    });
                }
            }

            foreach (var touchpad in _touchPadWithImages)
            {
                var skin = touchpad.Item1;

                if (newState.Analogs.ContainsKey(skin.XName) && newState.Analogs.ContainsKey(skin.YName))
                {
                    // Show
                    var x = (newState.Analogs[skin.XName] * skin.XRange) + skin.Config.X - (touchpad.Item2.Width / 2);
                    var y = (newState.Analogs[skin.YName] * skin.YRange) + skin.Config.Y - (touchpad.Item2.Height / 2);

                    if (touchpad.Item2.Dispatcher.CheckAccess())
                    {
                        touchpad.Item2.Margin     = new Thickness(x, y, 0, 0);
                        touchpad.Item2.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        touchpad.Item2.Dispatcher.Invoke(() =>
                        {
                            touchpad.Item2.Margin     = new Thickness(x, y, 0, 0);
                            touchpad.Item2.Visibility = Visibility.Visible;
                        });
                    }
                }
                else
                {
                    if (touchpad.Item2.Dispatcher.CheckAccess())
                    {
                        touchpad.Item2.Visibility = Visibility.Hidden;
                    }
                    else
                    {
                        touchpad.Item2.Dispatcher.Invoke(() =>
                        {
                            touchpad.Item2.Visibility = Visibility.Hidden;
                        });
                    }
                }
            }

            foreach (var trigger in _triggersWithGridImages)
            {
                var skin = trigger.Item1;
                var grid = trigger.Item2;

                if (!newState.Analogs.ContainsKey(skin.Name))
                {
                    continue;
                }

                var val = newState.Analogs [skin.Name];
                if (skin.UseNegative)
                {
                    val *= -1;
                }
                if (skin.IsReversed)
                {
                    val = 1 - val;
                }
                if (val < 0)
                {
                    val = 0;
                }
                switch (skin.Direction)
                {
                case Skin.AnalogTrigger.DirectionValue.Right:
                    if (grid.Dispatcher.CheckAccess())
                    {
                        grid.Width = skin.Config.Width * val;
                    }
                    else
                    {
                        grid.Dispatcher.Invoke(() =>
                        {
                            grid.Width = skin.Config.Width * val;
                        });
                    }
                    break;

                case Skin.AnalogTrigger.DirectionValue.Left:
                    var width = skin.Config.Width * val;
                    var offx  = skin.Config.Width - width;
                    if (grid.Dispatcher.CheckAccess())
                    {
                        grid.Margin = new Thickness(skin.Config.X + offx, skin.Config.Y, 0, 0);
                        grid.Width  = width;
                    }
                    else
                    {
                        grid.Dispatcher.Invoke(() =>
                        {
                            grid.Margin = new Thickness(skin.Config.X + offx, skin.Config.Y, 0, 0);
                            grid.Width  = width;
                        });
                    }
                    break;

                case Skin.AnalogTrigger.DirectionValue.Down:
                    if (grid.Dispatcher.CheckAccess())
                    {
                        grid.Height = skin.Config.Height * val;
                    }
                    else
                    {
                        grid.Dispatcher.Invoke(() =>
                        {
                            grid.Height = skin.Config.Height * val;
                        });
                    }
                    break;

                case Skin.AnalogTrigger.DirectionValue.Up:
                    var height = skin.Config.Height * val;
                    var offy   = skin.Config.Height - height;
                    if (grid.Dispatcher.CheckAccess())
                    {
                        grid.Margin = new Thickness(skin.Config.X, skin.Config.Y + offy, 0, 0);
                        grid.Height = height;
                    }
                    else
                    {
                        grid.Dispatcher.Invoke(() =>
                        {
                            grid.Margin = new Thickness(skin.Config.X, skin.Config.Y + offy, 0, 0);
                            grid.Height = height;
                        });
                    }
                    break;

                case Skin.AnalogTrigger.DirectionValue.Fade:
                    if (grid.Dispatcher.CheckAccess())
                    {
                        grid.Height  = skin.Config.Height;
                        grid.Width   = skin.Config.Width;
                        grid.Opacity = val;
                    }
                    else
                    {
                        grid.Dispatcher.Invoke(() =>
                        {
                            grid.Height  = skin.Config.Height;
                            grid.Width   = skin.Config.Width;
                            grid.Opacity = val;
                        });
                    }
                    break;
                }
            }
        }