Tengo un botón dentro de un ControlTemplate. ¿Cómo consigo una referencia?

Question

Solo quiero habilitar o deshabilitar el botón dentro de ControlTemplate para un editor WPF que estoy usando.

Answer 1

Estoy de acuerdo con Joel en que el método preferido sería activar la configuración de la propiedad Enabled del botón con marcado xaml, ya sea a través de un activador o vinculando el valor Enabled a otra propiedad de dependencia, posiblemente en un elemento padre, probablemente con el ayuda de un ValueConverter.

Sin embargo, si tiene que hacerlo explícitamente en C #, puede usar el método FindName () en la propiedad de plantilla del botón. Hay un 'cómo' de MSDN vinculado aquí .

Answer 2

Mi recomiendo que los botones se controlen fácilmente mediante RoutedUICommands, que incluyen habilitarlos y deshabilitarlos fácilmente. Los comandos no necesitan ningún tipo de referencia al Botón, por lo que esto también resuelve su problema.

Ver aquí:

<Window.CommandBindings>
    <CommandBinding 
        Command="{x:Static local:MyCommands.MyCommand}"
        Executed="CommandBinding_Executed"
        CanExecute="CommandBinding_CanExecute" />
</Window.CommandBindings>

<Window.Resources>
    <ControlTemplate x:Key="MyTemplate" TargetType="Label">
        <Button Command="{x:Static local:MyCommands.MyCommand}">
            <TextBlock>
                Click Me
                <TextBlock Text="{TemplateBinding Content}" />
            </TextBlock>
        </Button>
    </ControlTemplate>
</Window.Resources>

<StackPanel>
    <Label Template="{StaticResource MyTemplate}">1</Label>
    <Label Template="{StaticResource MyTemplate}">2</Label>
    <Label Template="{StaticResource MyTemplate}">3</Label>
    <Label Template="{StaticResource MyTemplate}">4</Label>
    <Label Template="{StaticResource MyTemplate}">5</Label>
</StackPanel>

Use esto:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void CommandBinding_CanExecute(object sender, System.Windows.Input.CanExecuteRoutedEventArgs e)
    {
        // your logic here
        int _Integer = -1;
        int.TryParse(e.Parameter.ToString(), out _Integer);
        e.CanExecute = _Integer % 2 == 0;
    }

    private void CommandBinding_Executed(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
    {
        // do something when clicked
    }
}

public static class MyCommands
{
    public static RoutedUICommand MyCommand = new RoutedUICommand();
}

Parece:

Answer 3

Realmente no deberías estar haciendo eso explícitamente, sino estar configurándolo con disparadores en el ControlTemplate . Estos disparadores estarían reaccionando a algún otro cambio y establecerían la propiedad Enabled del Button .

Answer 4

Tuve un problema con los botones en controlTemplates & amp; DataTemplates. Creo que los disparadores son a menudo demasiado engorrosos para proporcionar exactamente lo que mis clientes quieren, terminé con demasiados convertidores. El método que probé por primera vez fue definir estas plantillas más difíciles en línea para que pudieran estar vinculadas a los comandos (& amp; código detrás de los eventos) en ViewModel de mis pantallas.

si está modelando su propio control, debo mencionar que el método más fácil es simplemente nombrar el botón y luego usar algo como esto:

hourHand   = this.Template.FindName( "PART_HourHand",   this ) as Rectangle;

Recientemente, sin embargo, he cambiado el tacto (de nuevo a archivos independientes ... ¡REUTILIZAR!) pero comencé a agregar un ViewModel (más o menos) que sufijo ... TemplateCommandStore a todas mis plantillas eso se vuelve un poco complejo. Incluso lo uso al crear plantillas de mis controles personalizados (por consistencia, principalmente)

public class BookingDetailsTemplateCommandStore
{
    public OpenWindowCommand_Command OpenWindowCommand_Command { get; set; }

    public BookingDetailsTemplateCommandStore()
    {
        OpenWindowCommand_Command = new OpenWindowCommand_Command( this );
    }       
}

Entonces puedo usar felizmente este comando en una plantilla. También puede pasar referencias de control al almacén de comandos al vincular una propiedad (¿dependencia?) Para capturar eventos & amp; Elimine un control más preciso sobre sus plantillas.

<DataTemplate DataType="{x:Type LeisureServices:BookingSummary}">
    <Border Height="50" otherStyling="xyz">
        <Border.Resources>
            <local:BookingDetailsTemplateCommandStore x:Key="CommandStore" />
        </Border.Resources>
        <DockPanel>
            <Button otherStyling="xyz"
                    Command="{Binding Source={StaticResource CommandStore},
                                      Path=OpenWindowCommand_Command}" />

MVVM: encuentro que mientras la lógica gráfica sea solo eso, y completamente distinta de la lógica de negocios, esta metodología no interfiere con MVVM. En esencia, agrego una capacidad de código C # consistente a las plantillas, que cualquiera que haya pasado demasiado tiempo en winforms podría perder tanto como yo.