Reputation: 927

Key Combination event

As per requirement I need to capture the event of Key combination of two character and One control key(Example (ALT+S+C). How can I implement the same.

Thanks Ranish

Upvotes: 4

Answers (6)

Ranish

Reputation: 927

XAML:

 <interactivity:EventTrigger EventName="KeyDown">
 <mvvmlight:EventToCommand Command="{Binding Command}"
     PassEventArgsToCommand="True" />
 </interactivity:EventTrigger>

code behind:

 private void Event()
 {
    if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
    {  
        if (Keyboard.IsKeyDown(Key.C) && Keyboard.IsKeyDown(Key.T))
        {
            //code
        }
    }
 }

Upvotes: 1

Richard E

Reputation: 4919

EDIT: Modified code. Using both Gesture and Key properties is not possible. The last declared property will be used as the key and the key specified in the Gesture property will be ignored.

The following code is only possible with 2 ModifierKeys, not 2 Keys:

<KeyBinding Gesture="Alt+Shift+C" Command="{Binding ACommand}"/>

To implement Key combinations with 2 Keys and a single ModifierKey the following article looks quite useful:

KeyGesture with Multiple Keys

Upvotes: 3

Andy

Reputation: 6466

If the intention is to allow users to enter a sequence of characters with control keys like the comment/uncomment macros in visual studio then you could do something like this (this is very rough it's just to give you an idea of how it would work)

Add a custom control that looks for key presses on it's window and also holds a collection of gestures to watch for.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Markup;

namespace WpfApplication4
{
    [ContentProperty("Gestures")]
    public class KeyGestures : Control
    {
        public List<IKeyGesture> Gestures
        {
            get { return (List<IKeyGesture>)GetValue(GesturesProperty); }
            set { SetValue(GesturesProperty, value); }
        }
        public static readonly DependencyProperty GesturesProperty =
            DependencyProperty.Register("Gestures", typeof(List<IKeyGesture>), typeof(KeyGestures), new PropertyMetadata(null));

        public List<string> CurrentSequence
        {
            get { return (List<string>)GetValue(CurrentSequenceProperty); }
            set { SetValue(CurrentSequenceProperty, value); }
        }
        public static readonly DependencyProperty CurrentSequenceProperty =
            DependencyProperty.Register("CurrentSequence", typeof(List<string>), typeof(KeyGestures), new PropertyMetadata(null));

        public KeyGestures()
        {
            Gestures = new List<IKeyGesture>();
            CurrentSequence = new List<string>();
        }

        protected override void OnInitialized(EventArgs e)
        {
            var hostWindow = Window.GetWindow(this);
            if (hostWindow != null)
            {
                hostWindow.PreviewKeyDown += hostWinow_PreviewKeyDown;
                hostWindow.PreviewKeyUp += hostWinow_PreviewKeyUp;
            }
            base.OnInitialized(e);
        }

        bool IsAnyKeyPressed()
        {
            var allPossibleKeys = Enum.GetValues(typeof(Key));
            bool results = false;
            foreach (var currentKey in allPossibleKeys)
            {
                Key key = (Key)currentKey;
                if (key != Key.None)
                    if (Keyboard.IsKeyDown((Key)currentKey)) { results = true; break; }
            }
            return results;
        }

        void hostWinow_PreviewKeyUp(object sender, System.Windows.Input.KeyEventArgs e)
        {
            if (!IsAnyKeyPressed())
            {
                CurrentSequence.Clear();
            }
        }

        void hostWinow_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)
        {
            if (e.SystemKey == Key.None)
            {
                if (!CurrentSequence.Contains(e.Key.ToString()))
                    CurrentSequence.Add(e.Key.ToString());
            }
            else
                if (!CurrentSequence.Contains(e.SystemKey.ToString()))
                    CurrentSequence.Add(e.SystemKey.ToString());

            foreach (var gesture in Gestures)
                if (gesture.IsComplete(this.CurrentSequence))
                {
                    if (gesture.Command != null && gesture.Command.CanExecute(gesture.CommandParameter))
                        gesture.Command.Execute(gesture.CommandParameter);
                    System.Diagnostics.Debug.WriteLine("Completed gesture " + gesture);
                }
        }

    }

    public interface IKeyGesture
    {
        bool IsComplete(List<string> currentSequence);
        ICommand Command { get; }
        object CommandParameter { get; set; }
    }

    public class SequenceKeyGesture : DependencyObject, IKeyGesture
    {
        public string Sequence { get; set; }
        public char SplitChar { get; set; }
        public ICommand Command { get; set; }


        public object CommandParameter
        {
            get { return (object)GetValue(CommandParameterProperty); }
            set { SetValue(CommandParameterProperty, value); }
        }
        public static readonly DependencyProperty CommandParameterProperty =
            DependencyProperty.Register("CommandParameter", typeof(object), typeof(SequenceKeyGesture), new PropertyMetadata(null));


        public bool IsComplete(List<string> currentSequence)
        {

            string[] splitSequence = Sequence.Split(SplitChar);
            if (splitSequence.Length != currentSequence.Count) return false;
            if (splitSequence != null && splitSequence.Length > 0)
                for (int i = 0; i < splitSequence.Length; i++)
                    if (splitSequence[i] != currentSequence[i])
                        return false;

            return true;
        }
        public SequenceKeyGesture()
        {
            SplitChar = '+';
        }
        public override string ToString()
        {
            return Sequence;
        }
    }
}

This can then be used with the following xaml

<Window x:Class="WpfApplication4.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApplication4"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <local:KeyGestures>
            <local:SequenceKeyGesture Sequence="LeftAlt~S~C" SplitChar="~" Command="{Command binding here}" CommandParameter="Action1" />
            <local:SequenceKeyGesture Sequence="LeftAlt+S+V" Command="{Command binding here" CommandParameter="Action2"/>
        </local:KeyGestures>
    </Grid>
</Window>

There is a Debug.WriteLine in there to show you when the gesture is triggered in case you want to test without setting up commands.

Upvotes: 0

Sivakumar

Reputation: 478

You can detect using the below code,

    private void UIElement_OnPreviewKeyDown(object sender, KeyEventArgs e)
    {
        if (Keyboard.Modifiers == ModifierKeys.Alt && Keyboard.IsKeyDown(Key.S)
            && Keyboard.IsKeyDown(Key.C))
        {
            //if you want, you can fire event here
        }
    }

Upvotes: 0

Bhupendra

Reputation: 1743

If you want to bind an action it that combination than you do it,

<KeyBinding Gesture="Alt+S+C" Command="{Binding YourCommand}" />

See this msdn link

Upvotes: 0

Sheridan

Reputation: 69959

Using the KeyDown event:

if ((Keyboard.Modifiers & ModifierKeys.Alt) == ModifierKeys.Alt) // Is Alt key pressed
{
    if (Keyboard.IsKeyDown(Key.S) && Keyboard.IsKeyDown(Key.C))
    {
        // do something here
    }
}

Upvotes: 4

Key Combination event

Answers (6)

Related Questions