CommandBinding.cs source code in C# .NET

                        Code:
                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Input / Command / CommandBinding.cs / 1 / CommandBinding.cs
                        
                        
                            //---------------------------------------------------------------------------- 
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
//--------------------------------------------------------------------------- 

using System; 
using System.ComponentModel; 
using System.Windows;
using System.Windows.Markup; 
using MS.Internal;
using System.Security;
using System.Security.Permissions;
 
namespace System.Windows.Input
{ 
    ///  
    /// CommandBinding - Command-EventHandlers map
    ///         CommandBinding acts like a map for EventHandlers and Commands. 
    ///         PreviewExecute/Execute, PreviewCanExecute/CanExecute handlers
    ///         can be added at CommandBinding which will exist at Element level
    ///         in the form of a Collection and will be invoked when the system
    ///         is routing the corresponding RoutedEvents. 
    /// 
    public class CommandBinding 
    { 
        #region Constructors
 
        /// 
        ///     Default Constructor - required to allow creation from markup
        /// 
        public CommandBinding() 
        {
        } 
 
        /// 
        /// Constructor 
        /// 
        /// Command associated with this binding.
        public CommandBinding(ICommand command)
            : this(command, null, null) 
        {
        } 
 
        /// 
        /// Constructor 
        /// 
        /// Command associated with this binding.
        /// Handler associated with executing the command.
        public CommandBinding(ICommand command, ExecutedRoutedEventHandler executed) 
            : this(command, executed, null)
        { 
        } 

        ///  
        /// Constructor
        /// 
        /// Command associated with this binding.
        /// Handler associated with executing the command. 
        /// Handler associated with determining if the command can execute.
        public CommandBinding(ICommand command, ExecutedRoutedEventHandler executed, CanExecuteRoutedEventHandler canExecute) 
        { 
            if (command == null)
            { 
                throw new ArgumentNullException("command");
            }

            _command = command; 

            if (executed != null) 
            { 
                Executed += executed;
            } 
            if (canExecute != null)
            {
                CanExecute += canExecute;
            } 
        }
 
        #endregion 

        #region Public Properties 

        /// 
        ///     Command associated with this binding
        ///  
        [Localizability(LocalizationCategory.NeverLocalize)] // cannot be localized
        public ICommand Command 
        { 
            get
            { 
                return _command;
            }

            set 
            {
                if (value == null) 
                { 
                    throw new ArgumentNullException("value");
                } 

                _command = value;
            }
        } 

        #endregion 
 
        #region Public Events
 
        /// 
        ///     Called before the command is executed.
        /// 
        public event ExecutedRoutedEventHandler PreviewExecuted; 

        ///  
        ///     Called when the command is executed. 
        /// 
        public event ExecutedRoutedEventHandler Executed; 

        /// 
        ///     Called before determining if the command can be executed.
        ///  
        public event CanExecuteRoutedEventHandler PreviewCanExecute;
 
        ///  
        ///     Called to determine if the command can be executed.
        ///  
        public event CanExecuteRoutedEventHandler CanExecute;

        #endregion
 
        #region Implementation
 
        ///  
        ///     Calls the CanExecute or PreviewCanExecute event based on the event argument's RoutedEvent.
        ///  
        /// The sender of the event.
        /// Event arguments.
        internal void OnCanExecute(object sender, CanExecuteRoutedEventArgs e)
        { 
            if (!e.Handled)
            { 
                if (e.RoutedEvent == CommandManager.CanExecuteEvent) 
                {
                    if (CanExecute != null) 
                    {
                        CanExecute(sender, e);
                        if (e.CanExecute)
                        { 
                            e.Handled = true;
                        } 
                    } 
                    else if (!e.CanExecute)
                    { 
                        // If there is an Executed handler, then the command can be executed.
                        if (Executed != null)
                        {
                            e.CanExecute = true; 
                            e.Handled = true;
                        } 
                    } 
                }
                else // e.RoutedEvent == CommandManager.PreviewCanExecuteEvent 
                {
                    if (PreviewCanExecute != null)
                    {
                        PreviewCanExecute(sender, e); 
                        if (e.CanExecute)
                        { 
                            e.Handled = true; 
                        }
                    } 
                }
            }
        }
 
        private bool CheckCanExecute(object sender, ExecutedRoutedEventArgs e)
        { 
            CanExecuteRoutedEventArgs canExecuteArgs = new CanExecuteRoutedEventArgs(e.Command, e.Parameter); 
            canExecuteArgs.RoutedEvent = CommandManager.CanExecuteEvent;
 
            // Since we don't actually raise this event, we have to explicitly set the source.
            canExecuteArgs.Source = e.OriginalSource;
            canExecuteArgs.OverrideSource(e.Source);
 
            OnCanExecute(sender, canExecuteArgs);
 
            return canExecuteArgs.CanExecute; 
        }
 
        /// 
        ///     Calls Executed or PreviewExecuted based on the event argument's RoutedEvent.
        /// 
        /// The sender of the event. 
        /// Event arguments.
        internal void OnExecuted(object sender, ExecutedRoutedEventArgs e) 
        { 
            if (!e.Handled)
            { 
                if (e.RoutedEvent == CommandManager.ExecutedEvent)
                {
                    if (Executed != null)
                    { 
                        if (CheckCanExecute(sender, e))
                        { 
                            Executed(sender, e); 
                            e.Handled = true;
                        } 
                    }
                }
                else // e.RoutedEvent == CommandManager.PreviewExecutedEvent
                { 
                    if (PreviewExecuted != null)
                    { 
                        if (CheckCanExecute(sender, e)) 
                        {
                            PreviewExecuted(sender, e); 
                            e.Handled = true;
                        }
                    }
                } 
            }
        } 
 
        #endregion
 
        #region Data

        private ICommand _command;
 
        #endregion
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
CommandBinding.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
