WPF

InputLanguageManager.SetInputLanguage(myTextBox, CultureInfo.CreateSpecificCulture("fr"));

geomeo123 wrote:

C#

TextBoxADCPDisplay.Select(0, 20);
TextBoxADCPDisplay.SelectedText = "";

TextBox.Select(Int32, Int32) Method (System.Windows.Controls) | Microsoft Learn[^]:

Parameters
start The zero-based character index of the first character in the selection.
length The length of the selection, in characters.

<TextBox>
  <TextBox.Text>
    <PriorityBinding>
      <Binding Path="SlowProperty" IsAsync="true" />
      <Binding Path="MediumProperty" IsAsync="true" />
      <Binding Path="FastProperty" />
    </PriorityBinding>
  </TextBox.Text>
</TextBox>

<ContentPresenter x:Name="ContentSite"
                          IsHitTestVisible="False"
                          Content="{TemplateBinding SelectionBoxItem}"
                          ContentTemplate="{TemplateBinding SelectionBoxItemTemplate}"
                          ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"
                          Margin="3,3,23,3"
                          VerticalAlignment="Stretch"
                          HorizontalAlignment="Left">

public class MyComboBox : ComboBox
{
    static MyComboBox()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(MyComboBox),
            new FrameworkPropertyMetadata(typeof(MyComboBox)));
    }

    // Add DP's * logic here
}

<Style TargetType="{x:Type ctrls:MyComboBox}">

<pre>
<Setter Property="Template">

    <Setter.Value>

        <ControlTemplate TargetType="ComboBox">

        </ControlTemplate>

    </Setter.Value>

</Setter>

geomeo123 wrote:

Do I put the above in my wpf form load event and make these public so that my modelview class can see them?

public static class LoadedBehavior
{
    public static readonly DependencyProperty LoadedCommandProperty = DependencyProperty.RegisterAttached(
        "LoadedCommand",
        typeof(ICommand),
        typeof(LoadedBehavior),
        new PropertyMetadata(null, OnLoadedCommandChanged));
    
    public static ICommand GetLoadedCommand(FrameworkElement obj)
    {
        return (ICommand)obj.GetValue(LoadedCommandProperty);
    }
    
    public static void SetLoadedCommand(FrameworkElement obj, ICommand value)
    {
        obj.SetValue(LoadedCommandProperty, value);
    }
    
    private static void OnLoadedCommandChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
    {
        FrameworkElement element = obj as FrameworkElement;
        if (element == null) return;
        
        if (e.OldValue == null)
        {
            element.Loaded += OnLoaded;
        }
        else if (e.NewValue == null)
        {
            element.Loaded -= OnLoaded;
        }
    }
    
    public static readonly DependencyProperty LoadedCommandParameterProperty = DependencyProperty.RegisterAttached(
        "LoadedCommandParameter",
        typeof(object),
        typeof(LoadedBehavior),
        new PropertyMetadata(null));
    
    public static object GetLoadedCommandParameter(FrameworkElement obj)
    {
        return obj.GetValue(LoadedCommandParameterProperty);
    }
    
    public static void SetLoadedCommandParameter(FrameworkElement obj, object value)
    {
        obj.SetValue(LoadedCommandParameterProperty, value);
    }
    
    private static void OnLoaded(object sender, RoutedEventArgs e)
    {
        FrameworkElement element = sender as FrameworkElement;
        if (element == null) return;
        
        ICommand command = GetLoadedCommand(element);
        if (command == null) return;
        
        object parameter = GetLoadedCommandParameter(element);
        command.Execute(parameter);
    }
}