Help command

image_pdfimage_print


   
  

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        x:Class="AboutDialog"
        Title="About WPF Unleashed" SizeToContent="WidthAndHeight"
        Background="OrangeRed">
  <Window.CommandBindings>
    <CommandBinding Command="Help" CanExecute="HelpCanExecute" Executed="HelpExecuted"/>
  </Window.CommandBindings>
  <StackPanel>
    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
      <Button MinWidth="75" Margin="10" Command="Help" Content="{Binding RelativeSource={RelativeSource Self}, Path=Command.Text}"/>
      <Button MinWidth="75" Margin="10">OK</Button>
    </StackPanel>
    <StatusBar>asdf</StatusBar>
  </StackPanel>
</Window>

//File:Window.xaml.cs

using System.Windows;
using System.Windows.Input;

public partial class AboutDialog : Window
{
    public AboutDialog()
    {
        InitializeComponent();
    }

    void HelpCanExecute(object sender, CanExecuteRoutedEventArgs e)
    {
        e.CanExecute = true;
    }
    
    void HelpExecuted(object sender, ExecutedRoutedEventArgs e)
    {
        System.Diagnostics.Process.Start("http://www.kutayzorlu.com/java2s/com");
    }
}

   
    
     


Button CommandTarget Binding

image_pdfimage_print


   
  


<Window x:Class="WpfApplication1.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:custom="clr-namespace:WpfApplication1"
    Title="Custom RoutedCommand Sample"
    Name="RootWindow" Height="500" Width="600"
    Focusable="True">
  <Window.CommandBindings>
    <CommandBinding Command="{x:Static custom:Window1.ColorCmd}"
                    Executed="ColorCmdExecuted"
                    CanExecute="ColorCmdCanExecute"/>
  </Window.CommandBindings>
  <DockPanel>
    <Menu DockPanel.Dock="Top" Height="25">
      <MenuItem Header="Commands">
        <MenuItem Header="Color Command" Command="{x:Static custom:Window1.ColorCmd}" />
      </MenuItem>
    </Menu>
    <Border BorderBrush="Black" BorderThickness="1" Margin="10"
            Height="165" Width="250" DockPanel.Dock="Top">
      <TextBlock TextWrapping="Wrap" Margin="3">
        a
        <LineBreak/>
        b
        <LineBreak/>
        <LineBreak/>
        c
        <LineBreak/>
      </TextBlock>
    </Border>
    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" DockPanel.Dock="Bottom">
      <Border BorderBrush="Black" BorderThickness="1" Height="200" Width="200">
        <StackPanel Name="FirstStackPanel" Background="AliceBlue" Focusable="True">
          <StackPanel.CommandBindings>
            <CommandBinding Command="{x:Static custom:Window1.ColorCmd}" Executed="ColorCmdExecuted" CanExecute="ColorCmdCanExecute"/>
          </StackPanel.CommandBindings>

          <Label>StackPanel</Label>

          <Button Command="{x:Static custom:Window1.ColorCmd}"
                  CommandParameter="ButtonOne"
                  CommandTarget="{Binding ElementName=FirstStackPanel}" 
                  Content="CommandTarget = FristStackPanel" />
        </StackPanel>
      </Border>
      <Border BorderBrush="Black" BorderThickness="1" Height="200" Width="200">
        <StackPanel Background="AliceBlue" Focusable="True">
          <Label>Second StackPanel</Label>
        </StackPanel>
      </Border>
    </StackPanel>
  </DockPanel>
</Window>

//File:Window.xaml.cs


using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Input;


namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        public static RoutedCommand ColorCmd = new RoutedCommand();
        public Window1()
        {
            InitializeComponent();
        }
        private void ColorCmdExecuted(object sender, ExecutedRoutedEventArgs e)
        {
            Panel target = e.Source as Panel;
            if (target != null)
            {
                if (target.Background == Brushes.AliceBlue)
                {
                    target.Background = Brushes.Red;
                }
                else
                {
                    target.Background = Brushes.AliceBlue;
                }
            }
        }
        private void ColorCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            if (e.Source is Panel)
            {
                e.CanExecute = true;
            }
            else
            {
                e.CanExecute = false;
            }
        }
    }
}

   
    
     


Creating CommandBinding and attaching an Executed and CanExecute handler

image_pdfimage_print


   
  



<Window x:Class="WpfApplication1.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="CommandHandlerProcedural"
    >
</Window>
//File:Window.xaml.cs

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;

namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
            
            StackPanel MainStackPanel = new StackPanel();
            this.AddChild(MainStackPanel);

            Button CommandButton = new Button();
            CommandButton.Command = ApplicationCommands.Open;
            CommandButton.Content = "Open (KeyBindings: Ctrl-R, Ctrl-0)";
            MainStackPanel.Children.Add(CommandButton);

            CommandBinding OpenCmdBinding = new CommandBinding(ApplicationCommands.Open,OpenCmdExecuted,OpenCmdCanExecute);

            this.CommandBindings.Add(OpenCmdBinding);

            KeyBinding OpenCmdKeyBinding = new KeyBinding(ApplicationCommands.Open,Key.R,ModifierKeys.Control);

            this.InputBindings.Add(OpenCmdKeyBinding);
        }

        void OpenCmdExecuted(object target, ExecutedRoutedEventArgs e)
        {
            MessageBox.Show("The command has been invoked.");
        }

        void OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = true;
        }
    }
}

   
    
     


Creating a KeyBinding between the Open command and Ctrl-R

image_pdfimage_print


   
  



<Window x:Class="WpfApplication1.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="CommandHandlerProcedural"
    >
</Window>
//File:Window.xaml.cs

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;

namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
            
            StackPanel MainStackPanel = new StackPanel();
            this.AddChild(MainStackPanel);

            Button CommandButton = new Button();
            CommandButton.Command = ApplicationCommands.Open;
            CommandButton.Content = "Open (KeyBindings: Ctrl-R, Ctrl-0)";
            MainStackPanel.Children.Add(CommandButton);

            CommandBinding OpenCmdBinding = new CommandBinding(ApplicationCommands.Open,OpenCmdExecuted,OpenCmdCanExecute);

            this.CommandBindings.Add(OpenCmdBinding);

            KeyBinding OpenCmdKeyBinding = new KeyBinding(ApplicationCommands.Open,Key.R,ModifierKeys.Control);

            this.InputBindings.Add(OpenCmdKeyBinding);
        }

        void OpenCmdExecuted(object target, ExecutedRoutedEventArgs e)
        {
            MessageBox.Show("The command has been invoked.");
        }

        void OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = true;
        }
    }
}

   
    
     


Command Handler Command Binding in Xaml

image_pdfimage_print


   
  


<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+R" />
  </Window.InputBindings>

  <StackPanel>
    <Button Command="ApplicationCommands.Open" Name="MyButton"
            Height="50" Width="200">
      Open (KeyBindings: Ctrl+R, Ctrl+0)
    </Button>
  </StackPanel>
</Window>
//File:Window.xaml.cs

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
        void OpenCmdExecuted(object target, ExecutedRoutedEventArgs e)
        {
            String command, targetobj;
            command = ((RoutedCommand)e.Command).Name;
            targetobj = ((FrameworkElement)target).Name;
            MessageBox.Show(command +  " : " + targetobj);
        }
        void OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = true;
        }
    }
}

   
    
     


Command Handler Key Binding

image_pdfimage_print


   
  



<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+R" />
  </Window.InputBindings>

  <StackPanel>
    <Button Command="ApplicationCommands.Open" Name="MyButton"
            Height="50" Width="200">
      Open (KeyBindings: Ctrl+R, Ctrl+0)
    </Button>
  </StackPanel>
</Window>
//File:Window.xaml.cs

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
        void OpenCmdExecuted(object target, ExecutedRoutedEventArgs e)
        {
            String command, targetobj;
            command = ((RoutedCommand)e.Command).Name;
            targetobj = ((FrameworkElement)target).Name;
            MessageBox.Show(command +  " : " + targetobj);
        }
        void OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = true;
        }
    }
}

   
    
     


Bind the Button to a Command

image_pdfimage_print


   
  
<Window x:Class="WpfApplication1.Window1"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="WPF" Height="240" Width="300">
    <StackPanel>
        <TextBlock Text="First Name"/>
        <TextBox   Text="{Binding Path=FirstName}"/>
        <TextBlock Text="Age"/>
        <TextBox Text="{Binding Path=Age}"/>
        
        <Button Command="{Binding Path=Add}" Content="Add"/>
        <ComboBox x:Name="cboOccupation" IsEditable="False" Width="100">
             <ComboBoxItem>Student</ComboBoxItem>
             <ComboBoxItem>Skilled</ComboBoxItem>
             <ComboBoxItem>Professional</ComboBoxItem>
        </ComboBox>
        <Button Command="{Binding Path=SetOccupation}" CommandParameter="{Binding ElementName=cboOccupation, Path=Text}" Content="Set Occupation"/>
        <TextBlock Text="Status"/>
        <TextBlock Text="{Binding Path=Status, UpdateSourceTrigger=PropertyChanged}"/>
        
    </StackPanel>
</Window>

//File:Window.xaml.cs

using System.Windows;
using System;
using System.ComponentModel;
using System.Windows.Input;
namespace WpfApplication1
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
            this.DataContext = new Employee(){FirstName = "A"};
        }
    }
    public class Employee : INotifyPropertyChanged
    {
        private string firstName;
        private int age;
        private string occupation;
        private string status;

        private AddEmployeeCommand addEmployeeCommand;
        private SetOccupationCommand setOccupationCommand;
        public string Status
        {
            get
            {
                return status;
            }
            set
            {
                if(status!= value)
                {
                    status= value;
                    OnPropertyChanged("Status");
                }
            }
        }
        public string FirstName
        {
            get
            {
                return firstName;
            }
            set
            {
                if(firstName != value)
                {
                    firstName = value;
                    OnPropertyChanged("FirstName");
                }
            }
        }
        public int Age
        {
            get
            {
                return age;
            }
            set
            {
                if(this.age != value)
                {
                    this.age = value;
                    OnPropertyChanged("Age");
                }
            }
        }
        public string Occupation
        {
            get
            {
                return occupation;
            }
            set
            {
                if(this.occupation != value)
                {
                    this.occupation = value;
                    OnPropertyChanged("Occupation");
                }
            }
        }
        public AddEmployeeCommand Add
        {
            get
            {
                if(addEmployeeCommand == null)
                    addEmployeeCommand = new AddEmployeeCommand(this);

                return addEmployeeCommand;
            }
        }
        public SetOccupationCommand SetOccupation
        {
            get
            {
                if(setOccupationCommand == null)
                    setOccupationCommand = new SetOccupationCommand(this);

                return setOccupationCommand;
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;

        private void OnPropertyChanged(string propertyName)
        {
            if(this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }

    public class AddEmployeeCommand : ICommand
    {
        private Employee person;

        public AddEmployeeCommand(Employee person)
        {
            this.person = person;

            this.person.PropertyChanged += new PropertyChangedEventHandler(person_PropertyChanged);
        }

        private void person_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if(CanExecuteChanged != null)
            {
                CanExecuteChanged(this, EventArgs.Empty);
            }
        }
        public bool CanExecute(object parameter)
        {
            if(!string.IsNullOrEmpty(person.FirstName))
               if(person.Age > 0)
                    if(string.IsNullOrEmpty(person.Status))
                            return true;

            return false;
        }

        public event EventHandler CanExecuteChanged;

        public void Execute(object parameter)
        {
            person.Status = string.Format("Added {0}", person.FirstName);
        }
    }

    public class SetOccupationCommand : ICommand
    {
        private Employee person;

        public SetOccupationCommand(Employee person)
        {
            this.person = person;

            this.person.PropertyChanged += new PropertyChangedEventHandler(person_PropertyChanged);
        }

        private void person_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if(CanExecuteChanged != null)
            {
                CanExecuteChanged(this, EventArgs.Empty);
            }
        }

        public bool CanExecute(object parameter)
        {
            if(!string.IsNullOrEmpty(parameter as string))
                if(!string.IsNullOrEmpty(person.Status))
                    return true;

            return false;
        }

        public event EventHandler CanExecuteChanged;

        public void Execute(object parameter)
        {
            person.Occupation = parameter.ToString();

            person.Status = string.Format("Added {0},{1}", person.FirstName, person.Occupation);
        }
    }
}