Discussion :

[shurikeNzL]

Bonjour à tous,

Je souhaite créér le raccourci clavier suivant CTRL + F afin de lancer une opération.

J'ai cherché sur internet et ai trouvé un tas de réponses lorsque l'on travaille sur VB.NET en Form. Mais lorsque l'on travaille sur WPF, plus rien ne fonctionne, on ne trouve rien hormis des choses bien hors de ma portée comme le routage d'evennements etc...

Bref, ma question : Comment, de manière simple, créér le raccourci clavier CTRL + F en VB.NET sur WPF et non WinForm !

Merci à tous.

[meziantou]

Avec les InputBinding
http://blogs.msdn.com/b/llobo/archiv...e-binding.aspx

[shurikeNzL]

Avec les InputBinding
http://blogs.msdn.com/b/llobo/archiv...e-binding.aspx

Merci pour ta réponse, mais il n'y a vraiment pas plus simple ? Parce que je ne comprends vraiment pas concretement comment j'adapte ça dans mon code...

[meziantou]

Il n'y a rien de compliqué.

Montre nous ton code que l'on puisse t'aider

[Pol63]

la classe RelayCommand trouvable sur google peut aider

ensuite c'est on ne peut plus simple, il suffit de binder la touche à une commande, qui est en gros un pointeur vers une sub ...

[shurikeNzL]

Merci pour vos réponses, mais je ne sais pas si c'est la fatigue ou parce que je suis nul (surement les deux), mais c'est toujours pas clair.

J'ai trouvé ce code sur le net, qui marche impécable, et qui lance une msgbox quand on presse CTRL + O, ou CTRL + F.

Mais je ne comprend rien du tout.

Fichier XAML :

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
<Window x:Class="WpfApplication1.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="commandWithHandler" Name="root">
 
    <Window.CommandBindings>
        <CommandBinding Command="ApplicationCommands.Open"
                    Executed="OpenCmdExecuted"
                    CanExecute="OpenCmdCanExecute"/>
    </Window.CommandBindings>
 
 
    <Window.InputBindings>
        <KeyBinding Command="ApplicationCommands.Open" Gesture="CTRL+F" />
    </Window.InputBindings>
 
    <StackPanel>
        <Button Command="ApplicationCommands.Open" Name="MyButton"
            Height="50" Width="200">
            HELLO
        </Button>
    </StackPanel>
</Window>

Code :

Code vb.net :

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
Imports System
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Input
 
Namespace WpfApplication1
    Partial Public Class Window1
        Inherits Window
 
        Public Sub New()
            InitializeComponent()
        End Sub
 
 
        Private Sub OpenCmdExecuted(ByVal target As Object, ByVal e As ExecutedRoutedEventArgs)
            Dim command As [String], targetobj As [String]
            command = DirectCast(e.Command, RoutedCommand).Name
            targetobj = DirectCast(target, FrameworkElement).Name
            MessageBox.Show(command & " : " & targetobj)
        End Sub
 
 
 
        Private Sub OpenCmdCanExecute(ByVal sender As Object, ByVal e As CanExecuteRoutedEventArgs)
            e.CanExecute = True
        End Sub
 
 
    End Class
End Namespace

A quoi sert CommandBindings ? A pointer sur une fonction ? Là ça pointe sur OpenCmdExecuted et OpenCmdCanExecute c'est bien ça ?

A quoi sert InputBindings ?
ApplicationCommands.Open ça fait quoi au juste ?

Interret d'utiliser des ExecutedRoutedEventArgs et des CanExecuteRoutedEventArgs ?

Pourquoi CTRL + O fonctionne ?

Peut-on simplifier ce boxon, pour arriver à un truc qui collerait à mon problème ? A savoir éxécuter une fonction lorsque je presse CTRL + F ?

[meziantou]

A quoi sert CommandBindings ? A pointer sur une fonction ? Là ça pointe sur OpenCmdExecuted et OpenCmdCanExecute c'est bien ça ?

Les CommandBindings permettent de lier une commande à une méthode dans ton code behind

A quoi sert InputBindings ?
ApplicationCommands.Open ça fait quoi au juste ?

Les InputBindings permettent de lier un raccourci à une commande et donc par transitivité à une méthode dans ton code behind.

ApplicationCommands contient une liste de commande courante. Tu peux les utiliser ou en créer de nouvelle (google). Tu peux très bien utiliser ApplicationCommands.Open pour faire ce que tu veux. Les ApplicationsCommands ont souvent un raccourci par défault.

Interret d'utiliser des ExecutedRoutedEventArgs et des CanExecuteRoutedEventArgs ?

L'évènement Executed est appelé lorsque la commande doit être exécutée: Par exemple lorsque tu cliques sur un bouton ou lorsque tu fait un raccourci Ctrl+A.
La méthode CanExecuted permet de définir si la commande peut s'exécuter. Elle renvoie un booléen. Lorsque tu lies un bouton à une commande, si la commande ne peut être exécutée, le bouton se désactive automatiquement et se réactive automatiquement lorsque la commande peut à nouveau s'exécuter.

Pourquoi CTRL + O fonctionne ?

Comme je l'ai dit plus haut les commandes de ApplicationCommands on des raccourcis par défault. La commande ApplicationCommands.Open a le raccourci Ctrl+O

Peut-on simplifier ce boxon, pour arriver à un truc qui collerait à mon problème ? A savoir éxécuter une fonction lorsque je presse CTRL + F ?

Ca va être dur de simplifier quelque chose de simple. Il suffit d'y aller étape par étape:
- Lié une commande à une méthode : CommandBinding
- Lié un raccourci à une commande (la même que définie dans le command binding) : InputBinding

[Pol63]

pour essayer de compléter bien qu'il y ait pratiquement tout

un commande en wpf, c'est une association d'un "évènement" à une action
l'action c'est 2 méthodes, can execute retourne true si à cet l'instant T la commande est autorisée, execute lance l'action
l'"évènement " ca peut etre plusieurs choses

les boutons en wpf ont une propriété Command, il suffit de leur donner une instance de command et elle sera appelée sur le clic, le canexecute servant à Enabled le bouton ou non (automatique donc avec un bon binding)

inputcommand c'est une command qui ne vient pas d'un controle, mais d'un input, à toi d'essayer de lui dire que Ctrl+F


le binding venant d'une propriété, la classe relaycommand permet de faire simplement une instance de command qu'on peut retourner dans une propriété, et à l'instanciation on lui donne l'addressof des méthodes canexecute et execute

donc au final un truc dans le genre :

Code :

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

1
2
3
4
 
<Window.InputBindings>
  <KeyBinding Command="{Binding Path=TellePropriétéAsCommandMaisPenserADefinirLeDataContextSurMe}" Gesture="CTRL+F" />
</Window.InputBindings>

[shurikeNzL]

Ok merci à tous les deux pour vos réponses. Cela m'a beaucoup aidé !

[dacid]

Bonjour,
C'est vrai que ça peut paraitre logique pour certains, mais il y a des mécanismes à s'approprier, et on sort du très simple du WinForm standard.

Perso, ça m'ennuyait d'être obligé d'attacher ma combinaison de touches à une commande de base Windows (open, help, ...).
Et de ne pas avoir la main sur la combinaison de touche par défaut associée (ctrl+O, en l'occurence).
Voici donc la façon de faire des commandes personnalisées:

Code :

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

1
2
3
4
5
6
7
8
9
    <Window.Resources>
        <RoutedUICommand x:Key="CommandLambda" Text="CommeDansHalfLife" />
    </Window.Resources>
    <Window.CommandBindings>
        <CommandBinding Command="{StaticResource CommandLambda}" CanExecute="HelpCanExecute" Executed="HelpExecuted" />
    </Window.CommandBindings>
    <Window.InputBindings>
        <KeyBinding Command="{StaticResource CommandLambda}" Key="W" Modifiers="Ctrl"/>
    </Window.InputBindings>

Code :

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

1
2
3
4
5
6
7
 
        void HelpCanExecute(object sender, CanExecuteRoutedEventArgs e) {
            e.CanExecute = true;
        }
        void HelpExecuted(object target, ExecutedRoutedEventArgs e) {
            // ... Mon code ...
        }

En espérant que ça serve à quelqu'un.