Conditionnel XAML (WPF)

Je suis en train de créer un Contrôle Utilisateur qui, selon le mode de l'utilisateur définit dans la Propriété de Dépendance, les changements à l'Utilisateur de Contrôler à un TextBlock et un autre TextBlock ou un TextBlock et une zone de texte. Je sais que les propriétés de dépendance obtenez de l'information, mais le problème se pose lorsque je tente de régler le bon modèle. Pour une raison quelconque, le modèle ne rend pas correctement.

XAML:

<UserControl x:Class="BookOrganizer.FlipBox"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
         xmlns:my="clr-namespace:BookOrganizer"
         mc:Ignorable="d" 
         d:DesignHeight="300" d:DesignWidth="300">
<StackPanel Orientation="Horizontal" Height="Auto" Width="Auto" >
    <StackPanel.Resources>
        <ContentControl x:Key="Box">
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding Path=Title}" Height="Auto" Width="Auto" />
                <TextBox Text="{Binding Path=Text}" Height="Auto" Width="Auto" />
            </StackPanel>
        </ContentControl>
        <ContentControl x:Key="Block" Height="Auto" Width="Auto">
            <StackPanel Orientation="Horizontal" Height="Auto" Width="Auto">
                <TextBlock Text="{Binding Path=Title}" Height="Auto" Width="Auto" />
                <TextBlock Text="{Binding Path=Text}" Height="Auto" Width="Auto"/>
            </StackPanel>
        </ContentControl>
    </StackPanel.Resources>
    <ContentControl Template="{Binding Path=BoxMode}" />
</StackPanel>

Code Derrière:

using System;
using System.Windows;
using System.Windows.Controls;

namespace BookOrganizer
{
    ///<summary>
    ///Interaction logic for FlipBox.xaml
    ///</summary>
    public partial class FlipBox : UserControl
    {
        public static readonly DependencyProperty TitleProperty = DependencyProperty.Register(
        "Title", typeof(String), typeof(FlipBox), new PropertyMetadata("nothing"));

        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
        "Text", typeof(String), typeof(FlipBox), new PropertyMetadata("nothing"));

        public static readonly DependencyProperty BoxModeProperty = DependencyProperty.Register(
        "BoxMode", typeof(String), typeof(FlipBox), new PropertyMetadata("Box"));

        public FlipBox()
        {
            InitializeComponent();
            this.DataContext = this;
        }

        public String Title
        {
            get { return (String)this.GetValue(TitleProperty); }
            set { this.SetValue(TitleProperty, value); }
        }

        public String Text
        {
            get { return (String)this.GetValue(TextProperty); }
            set { this.SetValue(TextProperty, value); }
        }

        public String BoxMode
        {
            get { return (String)this.GetValue(BoxModeProperty); }
            set { this.SetValue(BoxModeProperty, value); }
        }

    }
}

Merci d'avance.

Définir "ne rend pas correctement". Quel est le résultat attendu et qu'est-ce que la sortie réelle?
Le résultat attendu serait soit un Bloc de Texte et un autre Bloc de Texte ou un Bloc de Texte et une Zone de Texte. Ce que j'ai est une boîte avec un cercle rouge et un X blanc à l'intérieur du cercle ou rien. Basé sur la façon dont j'essaie de le lancer.

OriginalL'auteur chris | 2011-02-02

c#wpf wpf-controls xaml

Voici un exemple de comment vous pouvez créer une condition de contrôle:

public class ConditionalControl : ContentControl
{
static ConditionalControl()
{
DefaultStyleKeyProperty.OverrideMetadata(typeof (ConditionalControl), new FrameworkPropertyMetadata(typeof (ConditionalControl)));
}
#region Condition DP
public bool Condition
{
get { return (bool) GetValue(ConditionProperty); }
set { SetValue(ConditionProperty, value); }
}
public static readonly DependencyProperty ConditionProperty =
DependencyProperty.Register("Condition", typeof (bool), typeof (ConditionalControl), new UIPropertyMetadata(false));
#endregion
#region TrueTemplate DP
public DataTemplate TrueTemplate
{
get { return (DataTemplate) GetValue(TrueTemplateProperty); }
set { SetValue(TrueTemplateProperty, value); }
}
public static readonly DependencyProperty TrueTemplateProperty =
DependencyProperty.Register("TrueTemplate", typeof (DataTemplate), typeof (ConditionalControl), new UIPropertyMetadata(null));
#endregion
#region FalseTemplate DP
public DataTemplate FalseTemplate
{
get { return (DataTemplate) GetValue(FalseTemplateProperty); }
set { SetValue(FalseTemplateProperty, value); }
}
public static readonly DependencyProperty FalseTemplateProperty =
DependencyProperty.Register("FalseTemplate", typeof (DataTemplate), typeof (ConditionalControl), new UIPropertyMetadata(null));
#endregion
}

Ici, c'est que c'est le style que vous avez besoin de mettre en Themes/Generic.xaml dans votre projet:

<Style TargetType="{x:Type Controls:ConditionalControl}">
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="{x:Type Controls:ConditionalControl}">
<Border Background="{TemplateBinding Background}"
BorderBrush="{TemplateBinding BorderBrush}"
BorderThickness="{TemplateBinding BorderThickness}">
<Grid>
<ContentPresenter x:Name="FalseContentPresenter"
Content="{TemplateBinding DataContext}"
ContentTemplate="{TemplateBinding FalseTemplate}" />
</Grid>
</Border>
</ControlTemplate>
</Setter.Value>
</Setter>
<Style.Triggers>
<Trigger Property="Condition"
Value="True">
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="{x:Type Controls:ConditionalControl}">
<Border Background="{TemplateBinding Background}"
BorderBrush="{TemplateBinding BorderBrush}"
BorderThickness="{TemplateBinding BorderThickness}">
<Grid>
<ContentPresenter x:Name="TrueContentPresenter"
Content="{TemplateBinding DataContext}"
ContentTemplate="{TemplateBinding TrueTemplate}" />
</Grid>
</Border>
</ControlTemplate>
</Setter.Value>
</Setter>
</Trigger>
</Style.Triggers>
</Style>

Fonctionne très bien, merci!

OriginalL'auteur Pavlo Glazkov

Vous pouvez utiliser des déclencheurs pour définir le modèle. Remplacer le StackPanel dans votre UserControl avec cette...

   <StackPanel Orientation="Horizontal" Height="Auto" Width="Auto" >
<ContentControl>
<ContentControl.Style>
<Style TargetType="{x:Type ContentControl}">
<Style.Triggers>
<DataTrigger Binding="{Binding Path=BoxMode}" Value="Box">
<Setter Property="Template">
<Setter.Value>
<ControlTemplate>
<StackPanel Orientation="Horizontal" Height="Auto" Width="Auto">
<TextBlock Text="{Binding Path=Title}" Height="Auto" Width="Auto" />
<TextBlock Text="{Binding Path=Text}" Height="Auto" Width="Auto"/>
</StackPanel>
</ControlTemplate>
</Setter.Value>
</Setter>
</DataTrigger>
<DataTrigger Binding="{Binding Path=BoxMode}" Value="Block">
<Setter Property="Template">
<Setter.Value>
<ControlTemplate>
<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding Path=Title}" Height="Auto" Width="Auto" />
<TextBox Text="{Binding Path=Text}" Height="Auto" Width="Auto" />
</StackPanel>
</ControlTemplate>
</Setter.Value>
</Setter>
</DataTrigger>
</Style.Triggers>
</Style>
</ContentControl.Style>
</ContentControl>
</StackPanel>

+1, mais je pense que les liaisons devront être identifiés à l'autonomie plutôt que l' (par défaut) DataContext.
J'ai essayé ceci dans un exemple de projet et les liaisons travaillé comme-est.
Solution sympa!!
J'aime vraiment cette solution, mais je ne peux pas le faire fonctionner avec un bouton. Je veux aussi essentiellement basculer entre les deux XAML dessins. Ne devrais-je pas être en mesure d'utiliser votre XAML, mais remplacer StackPanel avec Bouton?
Ah, j'ai eu à suivre de Jay conseils. Dans mon cas, j'ai été liaison tout à moi (je suis en utilisant un custom contrôle utilisateur basé sur le Bouton), et j'ai dû faire la même chose avec la propriété que j'utilise pour le Déclencher. Excellente solution!

OriginalL'auteur John Myczek

Vous aurez probablement besoin d'un IValueConverter changer string à un ControlTemplate qui est attendue. Il ne va pas faire de la recherche de la clé de ressource lorsqu'il est passé comme une simple chaîne de caractères. Une autre solution serait d'utiliser un Style de modifier la visibilité:

<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding Title}" />
<TextBox Text="{Binding Text}">
<TextBox.Style>
<Style TargetType="TextBox">
<Setter Property="Visibility" Value="Collapsed" />
<Style.Triggers>
<DataTrigger Binding="{Binding BoxMode}" Value="Box">
<Setter Property="Visibility" Value="Visible" />
</DataTrigger>
</Style.Triggers>
</Style>
</TextBox.Style>
</TextBox>
<TextBlock Text="{Binding Text}">
<TextBlock.Style>
<Style TargetType="TextBlock">
<Setter Property="Visibility" Value="Visible" />
<Style.Triggers>
<DataTrigger Binding="{Binding BoxMode}" Value="Box">
<Setter Property="Visibility" Value="Collapsed" />
</DataTrigger>
</Style.Triggers>
</Style>
</TextBlock.Style>
</TextBlock>
</StackPanel>

OriginalL'auteur user7116

Vous devez vous connecter pour publier un commentaire.