StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
629450
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
3
CommunityOwnedDate
CreationDate
2009-03-10T09:36:51.393
FavoriteCount
0
LastActivityDate
2009-11-20T09:52:15.277
LastEditDate
2009-11-20T09:52:15.277
LastEditorUserId
64239
OwnerUserId
64239
ParentId
612966
PostTypeId
2
Score
8
ViewCount
0
LastEditorDisplayName
text
Body
I do this by using an attached behaviour with 3 dependency properties; one is the command to execute, one is the parameter to pass to the command and the other is the key which will cause the command to execute. Here's the code: <pre><code>public static class CreateKeyDownCommandBinding { /// <summary> /// Command to execute. /// </summary> public static readonly DependencyProperty CommandProperty = DependencyProperty.RegisterAttached("Command", typeof(CommandModelBase), typeof(CreateKeyDownCommandBinding), new PropertyMetadata(new PropertyChangedCallback(OnCommandInvalidated))); /// <summary> /// Parameter to be passed to the command. /// </summary> public static readonly DependencyProperty ParameterProperty = DependencyProperty.RegisterAttached("Parameter", typeof(object), typeof(CreateKeyDownCommandBinding), new PropertyMetadata(new PropertyChangedCallback(OnParameterInvalidated))); /// <summary> /// The key to be used as a trigger to execute the command. /// </summary> public static readonly DependencyProperty KeyProperty = DependencyProperty.RegisterAttached("Key", typeof(Key), typeof(CreateKeyDownCommandBinding)); /// <summary> /// Get the command to execute. /// </summary> /// <param name="sender"></param> /// <returns></returns> public static CommandModelBase GetCommand(DependencyObject sender) { return (CommandModelBase)sender.GetValue(CommandProperty); } /// <summary> /// Set the command to execute. /// </summary> /// <param name="sender"></param> /// <param name="command"></param> public static void SetCommand(DependencyObject sender, CommandModelBase command) { sender.SetValue(CommandProperty, command); } /// <summary> /// Get the parameter to pass to the command. /// </summary> /// <param name="sender"></param> /// <returns></returns> public static object GetParameter(DependencyObject sender) { return sender.GetValue(ParameterProperty); } /// <summary> /// Set the parameter to pass to the command. /// </summary> /// <param name="sender"></param> /// <param name="parameter"></param> public static void SetParameter(DependencyObject sender, object parameter) { sender.SetValue(ParameterProperty, parameter); } /// <summary> /// Get the key to trigger the command. /// </summary> /// <param name="sender"></param> /// <returns></returns> public static Key GetKey(DependencyObject sender) { return (Key)sender.GetValue(KeyProperty); } /// <summary> /// Set the key which triggers the command. /// </summary> /// <param name="sender"></param> /// <param name="key"></param> public static void SetKey(DependencyObject sender, Key key) { sender.SetValue(KeyProperty, key); } /// <summary> /// When the command property is being set attach a listener for the /// key down event. When the command is being unset (when the /// UIElement is unloaded for instance) remove the listener. /// </summary> /// <param name="dependencyObject"></param> /// <param name="e"></param> static void OnCommandInvalidated(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e) { UIElement element = (UIElement)dependencyObject; if (e.OldValue == null && e.NewValue != null) { element.AddHandler(UIElement.KeyDownEvent, new KeyEventHandler(OnKeyDown), true); } if (e.OldValue != null && e.NewValue == null) { element.RemoveHandler(UIElement.KeyDownEvent, new KeyEventHandler(OnKeyDown)); } } /// <summary> /// When the parameter property is set update the command binding to /// include it. /// </summary> /// <param name="dependencyObject"></param> /// <param name="e"></param> static void OnParameterInvalidated(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e) { UIElement element = (UIElement)dependencyObject; element.CommandBindings.Clear(); // Setup the binding CommandModelBase commandModel = e.NewValue as CommandModelBase; if (commandModel != null) { element.CommandBindings.Add(new CommandBinding(commandModel.Command, commandModel.OnExecute, commandModel.OnQueryEnabled)); } } /// <summary> /// When the trigger key is pressed on the element, check whether /// the command should execute and then execute it. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> static void OnKeyDown(object sender, KeyEventArgs e) { UIElement element = sender as UIElement; Key triggerKey = (Key)element.GetValue(KeyProperty); if (e.Key != triggerKey) { return; } CommandModelBase cmdModel = (CommandModelBase)element.GetValue(CommandProperty); object parameter = element.GetValue(ParameterProperty); if (cmdModel.CanExecute(parameter)) { cmdModel.Execute(parameter); } e.Handled = true; } } </code></pre> To use this from xaml you can do something like this: <pre><code><TextBox framework:CreateKeyDownCommandBinding.Command="{Binding MyCommand}"> <framework:CreateKeyDownCommandBinding.Key>Enter</framework:CreateKeyDownCommandBinding.Key> </TextBox> </code></pre> Edit: CommandModelBase is a base class I use for all commands. It's based on the CommandModel class from Dan Crevier's article on MVVM (<a href="http://blogs.msdn.com/dancre/archive/2006/09/15/dm-v-vm-part-7-encapsulating-commands.aspx" rel="noreferrer">here</a>). Here's the source for the slightly modified version I use with CreateKeyDownCommandBinding: <pre><code>public abstract class CommandModelBase : ICommand { RoutedCommand routedCommand_; /// <summary> /// Expose a command that can be bound to from XAML. /// </summary> public RoutedCommand Command { get { return routedCommand_; } } /// <summary> /// Initialise the command. /// </summary> public CommandModelBase() { routedCommand_ = new RoutedCommand(); } /// <summary> /// Default implementation always allows the command to execute. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void OnQueryEnabled(object sender, CanExecuteRoutedEventArgs e) { e.CanExecute = CanExecute(e.Parameter); e.Handled = true; } /// <summary> /// Subclasses must provide the execution logic. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void OnExecute(object sender, ExecutedRoutedEventArgs e) { Execute(e.Parameter); } #region ICommand Members public virtual bool CanExecute(object parameter) { return true; } public event EventHandler CanExecuteChanged; public abstract void Execute(object parameter); #endregion } </code></pre> Comments and suggestions for improvements would be very welcome.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POKeyboard events in a WPF MVVM application?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USPaul
UserOwnerUserId
1. USPaul
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.