WPF

''' <summary>
 ''' Set binding from Double property to TextBox.Text
 ''' </summary>
 ''' <param name="Source">The class instance</param>
 ''' <param name="Path">Property name in the class</param>
 ''' <param name="control">The textboxcontrol</param>
 ''' <remarks></remarks>
 Sub SetObjectBinding(ByVal Source As Object, ByVal Path As String, ByVal control As TextBox)
     Dim bnd As New Binding
     bnd.Path = New PropertyPath(Path)
     bnd.Source = Source
     bnd.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
     bnd.Converter = New DoubleToStringConverter
     bnd.ValidationRules.Add(New PositiveDoubleValidator)
     control.SetBinding(TextBox.TextProperty, bnd)
 End Sub

<ValueConversion(GetType(Double), GetType(String))>
Private Class DoubleToStringConverter
    Implements IValueConverter

    Public Function Convert(value As Object, targetType As System.Type, parameter As Object, culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        Return value.ToString
    End Function

    Public Function ConvertBack(value As Object, targetType As System.Type, parameter As Object, culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Dim d As Double
        Dim str As String = value.ToString

        If str.Contains(".") Then str = str.Replace(".", ",")

        If Double.TryParse(str, d) Then
            If d > 0 Then
                Return d
            Else
                Return DependencyProperty.UnsetValue
            End If
        End If

        Return value.ToString
    End Function
End Class

Public Class PositiveDoubleValidator
    Inherits ValidationRule

    Public Overloads Overrides Function Validate(value As Object, cultureInfo As System.Globalization.CultureInfo) As System.Windows.Controls.ValidationResult

        Dim d As Double
        Dim str As String = value.ToString

        If str.Contains(".") Then str = str.Replace(".", ",")
        If Double.TryParse(str, d) Then
            If d > 0 Then
                Return ValidationResult.ValidResult
            Else
                Return New ValidationResult(False, "The entered value must be positive")
            End If
        Else
            Return New ValidationResult(False, "The value '" & str & "' could not be converted to a positive number")
        End If

    End Function
End Class

<Style TargetType="{x:Type TextBox}">
    <Setter Property="Validation.ErrorTemplate">
        <Setter.Value>
            <ControlTemplate>
                <DockPanel LastChildFill="True">
                    <Border BorderBrush="Red" BorderThickness="5">
                        <AdornedElementPlaceholder />
                    </Border>
                </DockPanel>
            </ControlTemplate>
        </Setter.Value>
    </Setter>

SledgeHammer01 wrote:

1) what's the difference between the PC version and the tablet version?

SledgeHammer01 wrote:

2) why are you assigning VMs from code? ViewLocator is your friend.

SledgeHammer01 wrote:

There is no need to have two separate VMs.

private void loadView(JobArgs Args)
{
    // Create a View Info instance
    ViewInfo tabInfo = new ViewInfo
    {
        View = View.Job,
        EntityId = Args.Job.JobRevisionId
    };

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

        // Create the view and assign the view model to it
        UserControl view = new JobView();
        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);
    }
}

SledgeHammer01 wrote:

If its hard coded, I hard code it in the XAML (psuedo
code):
 
<TabControl>
  
<Tabs>
      <Tab>
  
      <ChildView1 />
     
</Tab>
      <Tab>
  
      <ChildView2 />
     
</Tab>
  
<Tabs>
</TabControl>
 
The XAML for ChildView1 and
ChildView2 would use the ViewLocator to find the VM. Something
like:
 
<UserControl
somenamespace:ViewModelBase.ViewModel="{x:Type local:DocumentMapCtrlVM}" ...
/>
 
your ViewLocator should wire up the DataContext, etc. as
shown in that link.
 
If its dynamic (or determined at runtime),
you'd need to build a collection of some object where you have the name of the
tab and the usercontrol instance for example and then bind the tab content to
the object.UserControl from the collection with a data template.

SledgeHammer01 wrote:

For opening a dialog, I like to use a dialog service. That kind of needs a DI
engine / container. You'd register a generic base
interface:
 
interface IDialogService
{
  
AddressObject ShowAddressDialog(Window owner);
}
 
for example...
in the tablet version, you'd register a version that slides it in like you are
doing now and in the desktop version, you'd register a version that shows a
popup dialog version instead, but its all the same interfaces, so your calling
code is the same for both versions.