Discussion :

[Themacleod1980]

Salut,
je (re)débute en WPF et comme projet 'test' pour me mettre à niveau j'ai décidé de refaire un clavier virtuel (ancien projet déjà créé en Windows Form).
J'ai créé un control utilisateur contenant une grille dont les champs contiennent chacun une touche (control 'Button') du pavé numérique (je commence petit ^^)
Comme je désire gérer chaque touche indépendamment, j'ai associé un évènement 'Click' à chaque 'Button' du control.
Dans chacune des fonctions attribuées aux 'Clicks' j'appelle un Event de mon userControl.

Par exemple, pour la touche '5' :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
void t_5_Click(object sender, RoutedEventArgs e)
{
                OnKeyPress(Key.NumPad5);
}

Voici le code de mon Event :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
public delegate void KeypressDelegate(Control parent, Key touche);
public event KeypressDelegate KeyPress;
void OnKeyPress(Key touche)
{
            if (KeyPress != null)
            {
                KeyPress(this, touche);
            }
}

Dans un autre projet j'ai créé une Fenetre dans laquelle j'ai glissé mon UserControl (paveNumerique) ainsi qu'une TextBox (monTexte) censée recevoir ses évènements :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
public MainWindow()
{
            InitializeComponent();
 
            paveNumerique.KeyPress += paveNumerique_KeyPress;
}
 
void paveNumerique_KeyPress(Control parent, Key touche)
{
            monTexte.Focus();
 
            InputManager.Current.ProcessInput(
                new KeyEventArgs(
                Keyboard.PrimaryDevice,
                PresentationSource.FromVisual(monTexte),
                0,
                touche) { RoutedEvent = Keyboard.PreviewKeyDownEvent }
            );
 
           // monTexte.RaiseEvent(
           //   new KeyEventArgs(
           //     Keyboard.PrimaryDevice,
           //     PresentationSource.FromVisual(monTexte),
           //     0,
           //     touche) { RoutedEvent = Keyboard.PreviewKeyDownEvent }
           // );    
 
           // monTexte.RaiseEvent(
           //  new KeyEventArgs(
           //    Keyboard.PrimaryDevice,
           //    PresentationSource.FromVisual(monTexte),
           //    0,
           //    touche) { RoutedEvent = Keyboard.PreviewKeyUpEvent }
           //);      
}

Cependant, lors du debug, quand je clique sur une touche, j'entre bien dans la fonction "paveNumerique_KeyPress", "monTexte" prend bien le focus mais rien ne s'écrit dans "monTexte".
J'ai tenté plusieurs méthodes retrouvées un peu partout sur le web mais aucune ne fonctionne (voir le code en commentaire)

La question est donc :
comment faire croire à mon TexteBox que j'ai tapé une touche ?¿

Merci

[MABROUKI]

bonjour

InputSimulator sur le site CodePlex est ton ami ,il utilise l'API SendKey Window en coulisse ...!!!!

exemple avec ton UserControl
code Xaml du UserControl :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
<UserControl x:Class="WpfInputSimulator.UserControl1"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300">
 
 
    <UniformGrid  
 
           ButtonBase.Click="UniformGrid_Click" 
            >
        <Button Content="1" />
        <Button Content="2" />
        <Button Content="3" />
        <Button Content="4" />
        <Button Content="5" />
 
    </UniformGrid>
 
</UserControl>

et son code code .cs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
using System;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using WindowsInput;
namespace WpfInputSimulator
{
    /// <summary>
    /// Logique d'interaction pour UserControl1.xaml
    /// </summary>
    public partial class UserControl1 : UserControl
    {
        public UserControl1()
        {
            InitializeComponent();
        }
 
        private void UniformGrid_Click(object sender, RoutedEventArgs e)
        {
            Button cmd = e.OriginalSource as Button;
            if (cmd == null) return;
            OnKeyPress(VirtualKeyCode.NUMPAD5);
 
 
       }
 
        public delegate void KeypressDelegate(Control parent, VirtualKeyCode touche);
        public event KeypressDelegate KeyPress;
        private void OnKeyPress(VirtualKeyCode touche)
        {
            if (KeyPress != null)
            {
                KeyPress(this, touche);
            }
        }
 
 
    }
}

code Xaml du Form :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
<Window x:Class="WpfInputSimulator.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:local="clr-namespace:WpfInputSimulator"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel >
        <local:UserControl1 x:Name="paveNumerique"></local:UserControl1>
        <TextBox 
            x:Name="monTexte"
            TextWrapping="Wrap" FontSize="24" Foreground="SaddleBrown"
            Text="Comme je désire gérer chaque touche indépendamment, j'ai associé un évènement 'Click' à chaque 'Button' du control. 
 Dans chacune des fonctions attribuées aux 'Clicks' j'appelle un Event de mon userControl.">
 
        </TextBox>
    </StackPanel>
</Window>

et son code code .cs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
 
using System;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using WindowsInput;
namespace WpfInputSimulator
{
    /// <summary>
    /// Logique d'interaction pour MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.paveNumerique.KeyPress += new UserControl1.KeypressDelegate(paveNumerique_KeyPress);
 
        }
 
        void paveNumerique_KeyPress(Control parent, VirtualKeyCode touche)
        {
            this.monTexte.Focus();
            InputSimulator.SimulateKeyPress(touche);
        }
    }
}

lien du site CodePlex (inputsimulator)

http://inputsimulator.codeplex.com/

bon code........

[Noxen]

Qu'est-ce-que tu essaies d'obtenir en fait ? Est-ce-qu'il s'agit de simuler des keypress avec les boutons et d'intercepter ces keypress avec le textbox, ou bien plus génériquement de répercuter l'activation des boutons vers le textbox. L'approche MVVM avec WPF serait plutôt d'avoir d'un côté un textbox et des boutons dans l'interface graphique et de l'autre un modèle de vue avec une propriété texte et des commandes, attachés aux éléments de l'interface.
Une classe de commande implémentant ICommand :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class NumPadCommand : ICommand
    {
        public NumPadCommand(string value = null)
        {
            Value = value ?? string.Empty;
        }
        public string Value { get; }
        public bool CanExecute(object parameter)
        {
            return !string.IsNullOrEmpty(Value);
        }
 
        public void Execute(object parameter)
        {
            var handler = CommandCalled;
            if (handler != null) handler(Value);
        }
 
        public event EventHandler CanExecuteChanged;
 
        public delegate void CommandCalledHandler(string value);
        public event CommandCalledHandler CommandCalled;
    }

Une classe de modèle de vue implémentant INotifyPropertyChanged :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class NumPadViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            var handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
 
        public NumPadViewModel()
        {
            var list = new List<NumPadCommand>();
 
            for (int i = 0; i < 10; ++i)
            {
                var npc = new NumPadCommand(i.ToString());
                npc.CommandCalled += s =>
                {
                    Text += s;
                };
                list.Add(npc);
            }
 
            CommandCollection = new CollectionView(list);
 
            ClearCommand = new NumPadCommand("Clear");
            ClearCommand.CommandCalled += _ => Text = string.Empty;
        }
 
        private string _text;
        public string Text
        {
            get { return _text; }
            private set
            {
                if (value == _text) return;
                _text = value;
                OnPropertyChanged();
            }
        }
        public CollectionView CommandCollection { get; private set; }
        public NumPadCommand ClearCommand { get; set; }
    }

La fenêtre principale avec ses éléments graphiques et un modèle de vue en DataContext :

Code XAML :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<Window x:Class="VirtualNumPad.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:VirtualNumPad"
        Title="MainWindow" Height="350" Width="525"
        DataContext="{DynamicResource ResourceKey=ViewModel}">
    <Window.Resources>
        <local:NumPadViewModel x:Key="ViewModel"/>
    </Window.Resources>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <TextBox Text="{Binding Text, Mode=OneWay}"/>
        <ItemsControl Grid.Row="1" ItemsSource="{Binding CommandCollection}">
            <ItemsControl.ItemsPanel>
                <ItemsPanelTemplate>
                    <UniformGrid Columns="3"/>
                </ItemsPanelTemplate>
            </ItemsControl.ItemsPanel>
            <ItemsControl.ItemTemplate>
                <DataTemplate DataType="{x:Type local:NumPadCommand}">
                    <Button Content="{Binding Value, Mode=OneTime}" Command="{Binding}" Margin="2" Height="Auto"/>
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
        <Border Grid.Row="2" BorderThickness="2" HorizontalAlignment="Right">
            <Button Command="{Binding ClearCommand}" Content="{Binding ClearCommand.Value, Mode=OneTime}"/>
        </Border>
    </Grid>
</Window>

Note que je me suis sans doute permis certains raccourcis, n'hésite pas à demander si tu veux des précisions.

[Themacleod1980]

Salut,
désolé pour mon absence prolongée ^^ mais j'étais à fond dans le dev de mon clavier;
mon but était de faire un clavier virtuel 'maison' afin de l'intégrer dans certaines de mes applications qui doivent pouvoir être tactiles (destinées à des ordinateurs étanches fonctionnant sous des Windows inférieurs à 7)
Envoyer simplement du texte ou des caractères ne m’intéresse pas car je veux pouvoir vraiment simuler un clavier (Alt-F4 doit fonctionner, les touches Windows aussi etc...)
J'avais déjà installé InputSimulator et d'autres packages Nugget mais je me suis rendu compte qu'aucun ne suffirait pour ce que je voulais faire (récupérer l'état des LED du clavier par exemple).

Je suis donc revenu aux bons vieux DLLImports/user32.dll

J'ai terminé ce soir mon clavier

et comme je suis (TRES) sympa je vous fais profiter de quelques unes de mes découvertes (je vous laisse chercher les constantes) :

Pour envoyer une combinaison de touches :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
        [DllImport("user32", ExactSpelling = true, CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
        public void Imprime_Ecran()
        {
            DLLImports.keybd_event(Constantes.VK_SNAPSHOT, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
            DLLImports.keybd_event(Constantes.VK_SNAPSHOT, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
        }

Une fonction un peu batarde mais rigolote : tu lui donnes une 'Key' et lui précises quelles modifier key est enfoncée et elle se charge de les enfoncer, taper la Key, puis de les relacher :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
        public static void PressKey(IntPtr hWindow, System.Windows.Input.Key key, bool shift, bool maj, bool control, bool alt, bool altGr)
        {
            if (altGr)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.RightAlt), (int)Key.RightAlt, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
 
            if (alt)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.LeftAlt), (int)Key.LeftAlt, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
 
            if (control)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.RightCtrl), (int)Key.RightCtrl, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
 
            if (shift || maj)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.RightShift), (int)Key.RightShift, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
 
            DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(key), (int)Key.RightShift, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
 
            if (shift || maj)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.RightShift), (int)Key.RightShift, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
 
            if (control)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.RightCtrl), (int)Key.RightCtrl, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
 
            if (alt)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.LeftAlt), (int)Key.LeftAlt, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
 
            if (altGr)
                DLLImports.keybd_event((byte)System.Windows.Input.KeyInterop.VirtualKeyFromKey(Key.RightAlt), (int)Key.RightAlt, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
        }

Pour récupérer l'état des LED du clavier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
        [DllImport("user32", ExactSpelling = true, CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern int GetKeyState(byte nVirtKey);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
        public bool Etat_NumLock()
        {
            return Convert.ToBoolean(DLLImports.GetKeyState(Constantes.VK_NUMLOCK) & 1);
        }
 
        public bool Etat_CapsLock()
        {
            return Convert.ToBoolean(DLLImports.GetKeyState(Constantes.VK_CAPITAL) & 1);
        }
 
        public bool Etat_ArretDefil()
        {
            return Convert.ToBoolean(DLLImports.GetKeyState(Constantes.VK_OEM_SCROLL) & 1);
        }

Quelques fonctions trouvées sur le web (je ne sais plus où ) et adaptées à mes besoins; Elles vérifient l'état des touches/LED et les basculent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
        [DllImport("user32", ExactSpelling = true, CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern long GetKeyboardState(byte pbKeyState);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
        private byte[] keys = new byte[256];
 
        public void ToggleNumLock()
        {
            DLLImports.GetKeyboardState(keys[0]);
            // NumLock handling:
 
            NumLockState = Convert.ToBoolean(keys[Constantes.VK_NUMLOCK]);
            if (NumLockState != true) //Turn numlock on
            {
                //Simulate Key Press
                DLLImports.keybd_event(Constantes.VK_NUMLOCK, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
                //Simulate Key Release
                DLLImports.keybd_event(Constantes.VK_NUMLOCK, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
            }
        }
 
        public void ToggleCapsLock()
        {
            DLLImports.GetKeyboardState(keys[0]);
            // CapsLock handling:
            CapsLockState = Convert.ToBoolean(keys[Constantes.VK_CAPITAL]);
            if (CapsLockState != true) //Turn capslock on
            {
                //Simulate Key Press
                DLLImports.keybd_event(Constantes.VK_CAPITAL, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
                //Simulate Key Release
                DLLImports.keybd_event(Constantes.VK_CAPITAL, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
            }
        }
 
        public void ToggleScrollLock()
        {
            DLLImports.GetKeyboardState(keys[0]);
            // ScrollLock handling:
            ScrollLockState = Convert.ToBoolean(keys[Constantes.VK_OEM_SCROLL]);
            if (ScrollLockState != true) //Turn Scroll lock on
            {
                //Simulate Key Press
                DLLImports.keybd_event(Constantes.VK_OEM_SCROLL, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | 0, (UIntPtr)0);
                //Simulate Key Release
                DLLImports.keybd_event(Constantes.VK_OEM_SCROLL, 0x45, Constantes.KEYEVENTF_EXTENDEDKEY | Constantes.KEYEVENTF_KEYUP, (UIntPtr)0);
            }
        }