Windows Presentation Foundation (WPF)

I've created an own RibbonCommand:

public class RibbonCommandEx : RibbonCommand
    {
        private ICommand _delegatedCommand;
        public ICommand DelegatedCommand
        {
            get { return _delegatedCommand; }
            set
            {
                if (_delegatedCommand != value)
                {
                    _delegatedCommand = value;
                    if (_delegatedCommand != null)
                    {
                        this.CanExecute += RibbonCommandEx_CanExecute;
                        this.Executed += RibbonCommandEx_Executed;
                    }
                    else
                    {
                        this.CanExecute -= RibbonCommandEx_CanExecute;
                        this.Executed -= RibbonCommandEx_Executed;
                    }
                }
            }
        }

        private void RibbonCommandEx_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            DelegatedCommand.Execute(e.Parameter);
        }

        private void RibbonCommandEx_CanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = DelegatedCommand.CanExecute(e.Parameter);
        }
    }

<commands:CommandReference x:Key="WelcomePageCommandReference" Command="{Binding WelcomePageCommand}"/>

<commands:RibbonCommandEx x:Key="RibbonWelcomePageCommand"
                              DelegatedCommand="{StaticResource WelcomePageCommandReference}"
                              LabelTitle="{x:Static properties:Resources.RSTR_WelcomePage}"
                              LabelDescription="{x:Static properties:Resources.RSTR_WelcomePageDescription}"
                              SmallImageSource="/Resources/Images/WelcomePage.png"
                              LargeImageSource="/Resources/Images/WelcomePage.png"
                              ToolTipImageSource="/Resources/Images/WelcomePage.png"
                              ToolTipTitle="{x:Static properties:Resources.RSTR_WelcomePage}"                                         
                              ToolTipDescription="{x:Static properties:Resources.RSTR_WelcomePageDescription}"/>

Hi, sorry if I'm being stupid, but I just can't figure out what is the CommandReference.

Can someone give me a clue?

Tks

Diego

I've found it.

Tks everyone.

Thanks for this. It has been very useful.

But!! I do have another question. How can I change the ribbontab Selected event to a Command in the viewmodel.

<r:RibbonTab Label="Home" Selected="RibbonTab_Selected"  >
<r:RibbonTab Label="House Keeping" Selected="RibbonTab_Selected">
<r:RibbonTab Label="Config" Selected="RibbonTab_Selected">

 
What I need to do is, each tab has its own workspace. Any button clicked on the selected tab goes only to the selected workspace. Selecting a different tab hides the previous workspace and shows this workspace only. The current code behind looks like this

private void RibbonTab_Selected(object sender, RoutedEventArgs e)
        {
            switch (ribbonmenu.SelectedTab.Label)
            {
                case "Home":
                    SelectControl(ucHome);
                    break;
                case "House Keeping":
                    SelectControl(ucHouse);
                    break;
                case "Config":
                    SelectControl(ucConfig);
                    break;
              default:
                    SelectControl(ucHome);
                    break;
            }

        }
private void SelectControl(Control selectedControl)
        {
            foreach (UserControl uc in workspace.Children.OfType<UserControl>())
            {
                uc.Visibility = Visibility.Collapsed;
            }

            selectedControl.Visibility = Visibility.Visible;
        }

Hi,

Your command call is wrong  - Command="{Binding infrastructure:MenuCommands.DivertCommand}"

This should be property in your ViewModel - Command="{Binding DivertCommand}"

The viewmodel looks like:

public class ViewModel

{

private SimpleCommand divertCommand;


public ViewModel()
{
testCommand = new SimpleCommand
        {
            CanExecuteDelegate = x => true,
            ExecuteDelegate = x => ExecuteCommand()
        };
}

        public SimpleCommand DivertCommand
        {
            get { return divertCommand; }
        }

        private void ExecuteCommand()
        {
            DivertCommand.CommandSucceeded = false;

//Your code to execute

            DivertCommand.CommandSucceeded = true;
        }

}

Thank you all, I have found this discussion very helpful.

I have just started to get to grips with the ribbon control and MVVM and would like some help regarding how best to implement it into the MVVM pattern.

I take it you should have one main view containing the ribbon, that is binded to a main view model. From this main view I want to access a number of different child views, which will be displayed within the main view. The child views should use the same ribbon contained within the main view. How do I bind the ribbon controls so that depending on which child view is open the ribbon control responds to that view?

baraholka wrote:

segioesp!

You are a freaking legend. Well done, man.

I downloaded the MVVM toolkit, foudn the CommandReference class and converted it to VB.NET.

Now, with sergioesp's RibbonCommandEx I am using the RibbonCommand in a fully MVVM-complaint manner (including Input Gestures) with no forwarding of CanExecute and Execute handlers  from code-behind.

Thanks WPF Futures for the CodeReference class and thanks sergio for the RibbonCommandEx class

Will post the conversion to VB.NEt on my blog soon.

Here's Sergio's Code in VB.NET with support for InputGestures and not requiring you to use WPF MVVM Toolkit http://waxtadpole.wordpress.com/2010/01/31/integrating-wpf-ribbon-with-prism-and-mvvm-with-vb-net-example/