Model View ViewModel

using System.Windows.Input;
using ActiproSoftware.Windows.Controls.Wizard;
using System.Windows;
using System;

namespace ForesightSystems.WizardEx
{
    public class WizardPageEx : WizardPage, ICommandSource
    {
        /* MSDN Sources:
         * How to: http://msdn.microsoft.com/en-us/library/ms748978.aspx
         * Sample code: http://msdn.microsoft.com/en-us/library/ms771361.aspx */
        
         #region Fields

        // Member variables
        private static EventHandler m_CanExecuteChangedHandler;

        #endregion

        #region Constructor

        public WizardPageEx() : base()
        {
        }

        #endregion

        #region Method Overrides

        /// <summary>
        /// If the Command property holds a command, this method invokes it when 
        /// this wizard page is selected (becomes the active page).
        /// </summary>
        protected override void OnSelected(WizardSelectedPageChangeEventArgs e)
        {
            base.OnSelected(e);

            if (this.Command != null)
            {
                // Attempt to cast command as RoutedCommand (null if an ICommand)
                RoutedCommand command = Command as RoutedCommand;

                // Execute the command
                if (command != null)
                {
                    // Command is a RoutedCommand
                    command.Execute(CommandParameter, CommandTarget);
                }
                else
                {
                    // Command is an ICommand
                    ((ICommand)Command).Execute(CommandParameter);
                }
            }
        }

        #endregion

        #region ICommandSource Members

        /// <summary>
        /// Gets or sets the command to invoke when this wizard page is selected (becomes the active 
        /// wizard page). This is a dependency property. 
        /// </summary>
        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }

        /// <summary>
        /// Gets or sets the parameter to pass to the Command property. This is a dependency property. 
        /// </summary>
        public object CommandParameter
        {
            get { return (object)GetValue(CommandParameterProperty); }
            set { SetValue(CommandParameterProperty, value); }
        }

        /// <summary>
        /// Gets or sets the element on which to raise the specified command. This is a dependency property.
        /// </summary>
        public IInputElement CommandTarget
        {
            get { return (IInputElement)GetValue(CommandTargetProperty); }
            set { SetValue(CommandTargetProperty, value); }
        }

        #endregion

        #region Dependency Properties

        /// <summary>
        /// Command dependency property.
        /// </summary>
        public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command",
            typeof(ICommand),
            typeof(WizardPageEx),
            new PropertyMetadata((ICommand)null,
            new PropertyChangedCallback(CommandChanged)));

        /// <summary>
        /// CommandParameter dependency property.
        /// </summary>
        public static readonly DependencyProperty CommandParameterProperty =
            DependencyProperty.Register("CommandParameter",
            typeof(object),
            typeof(WizardPageEx),
            new PropertyMetadata((object)null));

        /// <summary>
        /// CommandTarget dependency property.
        /// </summary>
        public static readonly DependencyProperty CommandTargetProperty =
            DependencyProperty.Register("CommandTarget", 
            typeof(IInputElement), 
            typeof(WizardPageEx),
            new PropertyMetadata((IInputElement)null));

        #endregion

        #region Dependency Property Callback Methods

        /// <summary>
        /// Property change callback method for the Command dependency property.
        /// </summary>
        private static void CommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            WizardPageEx wizardPage = (WizardPageEx)d;
            wizardPage.HookUpCommand((ICommand)e.OldValue, (ICommand)e.NewValue);
        }

        #endregion

        #region Event Handlers

        /// <summary>
        /// Handles the CanExecuteChanged event.
        /// </summary>
        private void OnCanExecuteChanged(object sender, EventArgs e)
        {
            if (this.Command != null)
            {
                RoutedCommand command = this.Command as RoutedCommand;

                // If a RoutedCommand.
                if (command != null)
                {
                    this.IsEnabled = (command.CanExecute(CommandParameter, CommandTarget));
                }

                // If a not RoutedCommand.
                else
                {
                    this.IsEnabled = (Command.CanExecute(CommandParameter));
                }
            }
        }

        #endregion

        #region Utility Methods

        /// <summary>
        /// Connect the new command handlers when the Command property changes.
        /// </summary>
        /// <param name="oldCommand">The old command assigned to the Command property.</param>
        /// <param name="newCommand">The new command assigned to the Command property.</param>
        private void HookUpCommand(ICommand oldCommand, ICommand newCommand)
        {
            // If oldCommand is not null, then we need to remove the handlers.
            if (oldCommand != null)
            {
                RemoveCommand(oldCommand);
            }
            AddCommand(newCommand);
        }

        /// <summary>
        /// Removes an old command from the Command property.
        /// </summary>
        /// <param name="oldCommand">The old command assigned to the Command property.</param>
        private void RemoveCommand(ICommand oldCommand)
        {
            EventHandler handler = OnCanExecuteChanged;
            oldCommand.CanExecuteChanged -= handler;
        }

        /// <summary>
        /// Adds a new command to the Command property.
        /// </summary>
        /// <param name="newCommand">The new command assigned to the Command property.</param>
        private void AddCommand(ICommand newCommand)
        {
            /* We assign the delegate we create below to a member variable, 
             * to ensure that it doesn't get garbage collected. */

            // Create a delegate to handle CanExecuteChanged event
            m_CanExecuteChangedHandler = new EventHandler(OnCanExecuteChanged);

            // Attach the delegate to the new command
            if (newCommand != null)
            {
                newCommand.CanExecuteChanged += m_CanExecuteChangedHandler;
            }
        }

        #endregion
    }
}