WPF

Pete O'Hanlon wrote:

It's fixed in .NET 4.5.

.NET 4.5 Beta Readme[^]

1.3.10 Windows Presentation Foundation (WPF)

1.3.10.1 HwndHost feature has been removed from WPF in the .NET Framework 4.5 Beta
The .NET Framework 4.5 Developer Preview included a WPF HwndHost redirection feature. However, this feature had several known issues and has been removed from the .NET Framework 4.5 Beta. It will not be included in any future releases.

Pete O'Hanlon wrote:

Pete Brown, at Microsoft, promised me this would be in

<Button x:Name="button1" Click="button1_onClick" Template={StaticResource MyTemplate} />

private void button1_onClick(object sender, RoutedEventArgs e)
{
     //handle button click event here.
}

<Button Name="btnControl"  Canvas.ZIndex="10"  Canvas.Left="175" Canvas.Top="25" Content="ICOM"
MaxWidth="75" MaxHeight="75" Style="{StaticResource ICOMButtonStyle}" Command="{Binding LaunchControlModule}"/>

Public ReadOnly Property LaunchControlModule() As ICommand
    Get
        Return New ViewModelCommand(AddressOf HandlerLaundControlModule)
    End Get
End Property

Private Sub HandlerLaundControlModule()
    ShowControlModule = True
End Sub

    Public Class ViewModelCommand
        Implements ICommand

        Private _handler As Action


        Public Sub New(ByVal handler As Action)
            _handler = handler
        End Sub


#Region "ICommand Members"
         Public Function CanExecute(ByVal parameter As Object) As Boolean Implements System.Windows.Input.ICommand.CanExecute
            Return True
        End Function

        Public Event CanExecuteChanged(ByVal sender As Object, ByVal e As System.EventArgs) Implements System.Windows.Input.ICommand.CanExecuteChanged

        Public Sub Execute(ByVal parameter As Object) Implements System.Windows.Input.ICommand.Execute
            _handler()
        End Sub

#End Region

Mycroft Holmes wrote:

You have low expectations of your client base (reasonable in an independant
developer) as you are using a tabcontrol as your client collection UI

Mycroft Holmes wrote:

One reason not to use a messaging paradigm is that it is a bitch to maintain,
there is no direct link between the firer of the message and the consumer of
that message. a bitch to support.

Kevin Marois wrote:

There is a list of clients on the side

Kevin Marois wrote:

Other than that,

<TabControl Grid.Row="2"
            Grid.Column="2"
            x:Name="MyTabControl"
            BorderBrush="#6593CF"
            Background="White"
            ItemsSource="{Binding TabManager.Tabs}"
            SelectedItem="{Binding TabManager.ActiveTab}"
            Margin="2"/>

public class ViewManager : BindableBase, ITabManager
{
    #region Events
    public event EventHandler TabActivated;
    #endregion

    #region Bound Properties
    private ObservableCollection<TabItem> _Tabs = new ObservableCollection<TabItem>();
    public ObservableCollection<TabItem> Tabs
    {
        get { return _Tabs; }
        set
        {
            if (_Tabs != value)
            {
                _Tabs = value;
                RaisePropertyChanged("Tabs");
            }
        }
    }

    private TabItem _ActiveTab;
    public TabItem ActiveTab
    {
        get { return _ActiveTab; }
        set
        {
            if (_ActiveTab != value)
            {
                _ActiveTab = value;
                RaisePropertyChanged("ActiveTab");

                if (TabActivated != null)
                {
                    TabActivated(this, new EventArgs());
                }
            }
        }
    }

    private bool _TabsVisible;
    public bool TabsVisible
    {
        get { return _TabsVisible; }
        set
        {
            if (_TabsVisible != value)
            {
                _TabsVisible = value;
                RaisePropertyChanged("TabsVisible");
            }
        }
    }
    #endregion

    #region Public Methods
    public void ActivateTab(ViewInfo TabInfo)
    {
        var tab = GetTab(TabInfo);
        ActiveTab = tab;
    }
    public void AddTab(TabItem Tab, bool Activate = true, int IndexPosition = -1)
    {
        if (IndexPosition == -1)
        {
            Tabs.Add(Tab);
        }
        else
        {
            Tabs.Insert(IndexPosition, Tab);
        }

        if (Activate)
        {
            ActivateTab((ViewInfo)Tab.Tag);

            // Show/Hide the tab control based on whether there are any tabs open
            TabsVisible = Tabs.Count > 0;
        }
    }
    public bool CloseAllButThisTab(ViewInfo TabInfo)
    {
        bool retVal = true;

        for (int i = Tabs.Count - 1; i >=0; i-- )
        {
            var tab = Tabs[i];
            var tabInfo = (ViewInfo)tab.Tag;

            if (tabInfo.View == TabInfo.View && tabInfo.EntityId == TabInfo.EntityId)
            {
                continue;
            }
            else
            {
                retVal = CloseTab(tabInfo);

                if (!retVal)
                {
                    break;
                }
            }
        }

        return retVal;
    }
    public bool CloseAllTabs()
    {
        bool retVal = true;

        for(int i = Tabs.Count - 1; i > 0; i--)
        {
            var tab = Tabs[i];
            retVal = CloseTab((ViewInfo)tab.Tag);
        }

        return retVal;
    }
    public bool CloseTabAtIndex(int Index)
    {
        Tabs.RemoveAt(Index);
        return true;
    }
    public bool CloseActiveTab()
    {
        return CloseTab((ViewInfo)ActiveTab.Tag);
    }
    public bool CloseTab(ViewInfo TabInfo)
    {
        bool retVal = true;
        var tab = GetTab(TabInfo);

        if (tab != null)
        {
            // Make the tab active
            ActivateTab((ViewInfo)tab.Tag);

            // Get the view off the tab
            var view = (UserControl)tab.Content;

            // If the view is a Center...
            if (view.DataContext is _CenterViewModelBase)
            {
                // Get the view Entity off the center
                _CenterViewModelBase centerVM = (_CenterViewModelBase)view.DataContext;

                // Go through all the tab's subtabs and try to close each one...
                for(int i = centerVM.TabManager.Tabs.Count - 1; i > -1 ; i--)
                //foreach (var centerTab in centerVM.TabManager.Tabs)
                {
                    // Get the tab
                    TabItem centerTab = centerVM.TabManager.Tabs[i];

                    // Call back into this method, passing in the sub tab's View Info to close it
                    bool closed = centerVM.TabManager.CloseTab((ViewInfo)centerTab.Tag);

                    // If the tab was not closed...
                    if (!closed)
                    {
                        // Turn off the retun flag and exit...
                        retVal = false;
                        break;
                    }
                }
            }
            else
            {
                // Get the data entry VM off the tab
                dynamic vm = (_DataEntryViewModelBase)view.DataContext;

                // If the VM has pending changes, prompt the user to save
                retVal = vm.PromptSaveChanges(true);
            }

            // If ok to continue closing...
            if (retVal)
            {
                // If the tab was saved, remove it
                Tabs.Remove(tab);

                // Show/Hide the tab control based on whether there are any tabs open
                TabsVisible = Tabs.Count > 0;
            }
        }

        return retVal;
    }
    public bool HasDirtyTabs()
    {
        bool retVal = false;

        foreach(var tab in Tabs)
        {
            // Activate the tab
            ActivateTab((ViewInfo)tab.Tag);

            // Get the view off the tab
            var view = (UserControl)tab.Content;

            // Get the View Entity off the view
            _DataEntryViewModelBase vm = (_DataEntryViewModelBase)view.DataContext;

            // See if the tab is dirty
            retVal = vm.IsDirty();

            // If so, exit the loop
            if (retVal)
            {
                break;
            }
        }

        return retVal;
    }
    public bool IsTabOpen(ViewInfo TabInfo)
    {
        TabItem tabItem = GetTab(TabInfo);
        return tabItem != null;
    }
    public TabItem GetTab(ViewInfo TabInfo)
    {
        // This doesn't work for some reason
        //TabItem tab = Tabs.Where(t => ((ViewInfo)t.Tag).View == TabInfo.View && ((ViewInfo)t.Tag).EntityId == TabInfo.EntityId).FirstOrDefault();
        TabItem retVal = null;

        foreach (var tab in Tabs)
        {
            ViewInfo vi = (ViewInfo)tab.Tag;

            if (vi.View == TabInfo.View && vi.EntityId == TabInfo.EntityId)
            {
                retVal = tab;
                break;
            }

        }

        return retVal;
    }
    public void RefreshTabInfo(AppMessageArgs Args)
    {
        foreach (var tab in Tabs)
        {
            UserControl view = tab.Content as UserControl;
            _DataEntryViewModelBase vm = view.DataContext as _DataEntryViewModelBase;
            ViewInfo vi = (ViewInfo)tab.Tag;

            if (vi.View == Args.ViewType)
            {
                tab.Header = vm.GetEntityCaption(); ;
                vi.EntityId = vm.GetEntityId();

                tab.Tag = vi;
            }
        }
    }
    public bool SaveAllOpenTabs()
    {
        bool retVal = false;

        foreach (var tab in Tabs)
        {
            // Activate the tab
            ActivateTab((ViewInfo)tab.Tag);

            // Get the view off the tab
            var view = (UserControl)tab.Content;

            // Get the View Entity off the view
            _DataEntryViewModelBase vm = (_DataEntryViewModelBase)view.DataContext;

            // Attempt to save changes
            retVal = vm.PromptSaveChanges(true);

            // If not saved, cancel out
            if (!retVal)
            {
                break;
            }
        }

        return retVal;
    }
    #endregion
}

private void loadView(BOMArgs Args)
{
    // Create a View Info instance
    ViewInfo tabInfo = new ViewInfo
    {
        View = View.BOM,
        EntityId = Args.BOM.Id
    };

    if (tabInfo.EntityId > 0 && TabManager.IsTabOpen(tabInfo))
    {
        TabManager.ActivateTab(tabInfo);
    }
    else
    {
        // Create an instance of the BOM view Entity and load it
        BOMViewModel vm = new BOMViewModel(Engine);
        vm.Load(Args);

        // Create the view and assign the view Entity to it
        UserControl view = new BOMView();
        view.DataContext = vm;

        // Cretae a tab and assign the presenter view to it
        TabItem tabItem = new TabItem
        {
            Header = vm.GetEntityCaption(),
            Content = view,
            Tag = tabInfo
        };

        // Add the tab and activate it
        TabManager.AddTab(tabItem, true);
    }
}

<ComboBox
   Grid.Row="1" Grid.Column="3"
   ItemsSource="{Binding PayTypes}"
   SelectedValue="{Binding Client.PayType}"
   DisplayMemberPath="Caption"
/>

<ComboBox Grid.Row="1" 
            Grid.Column="3"
            IsEnabled="{Binding Path=FieldEnableHelper.PayType}"
            ItemsSource="{Binding PayTypes}"
            SelectedValue="{Binding Client.PayType}"
            DisplayMemberPath="Caption"
            TabIndex="10"
            Style="{StaticResource ComboBoxStyle}"
            Width="150"/>