Définir une marge d'une liaison

J'ai une valeur contraignante qui retourne un int qui représente une valeur que je n'étais pas à attribuer aux marges gauche et droite d'un élément.

Voici ce que j'ai essayé, mais il l'habitude de compiler.

Il fonctionne si j'ai mis la totalité de la marge, mais je ne veux de gauche et de droite.

Xaml:

<Image x:Name="_image" Source="mat.png" Margin="{Binding EditorRow.BondIndent},0,{Binding EditorRow.BondIndent},0" />

classe:

public int BondIndent
{
    get { return _bondSequence * 5; }
}
Comment faire pour retourner un Thickness à la place?
Par défaut que j'ai le contrôle sur ce qui est retourné à partir de la classe derrière. S'il vous plaît pourriez-vous ajouter une réponse basée sur le retour de l'épaisseur et je vais le marquer comme réponse
ajout d'une réponse à la place. HTH

OriginalL'auteur user589195 | 2013-01-16

  1. 20

    Retour de la marge?

    public Thickness Margin
{
    get { return new Thickness(BondIndent,0,BondIndent,0);}
}

    Puis changement:

    <Image x:Name="_image" Source="mat.png" Margin="{Binding EditorRow.Margin}" />

    OriginalL'auteur Luuk

  2. 13

    Vous avez probablement besoin d'utiliser un ValueConverter pour cela. Quelque chose comme:

    public class LeftRightThicknessConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        if (value is int)
        {
            int margin = (int)value;
            return Thickness(margin, 0, margin, 0);
        }
        return Thickness();
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

    Vous pouvez ensuite utiliser le convertisseur de la manière suivante:

    <Grid>
    <Grid.Resources>
        <xxx:LeftRightThicknessConverter x:Key="LeftRightThicknessConverter" />
    </Grid.Resources>

    <Image Margin="{Binding SomePropertyPath, Converter={StaticResource LeftRightThicknessConverter}}" />
</Grid>

    En supposant que xxx est un xml valide de l'espace de noms.

    Comment l'OP utiliser cette valueconverter?
    Bon point! Ajout d'un court exemple.
    Le montant des convertisseurs statiques et stockés dans une autre assemblée?
    Vous pouvez avoir la définition de la classe de convertisseur dans une autre assemblée. Mais vous avez besoin d'une instance accessible à partir du XAML. En règle générale, vous créez une instance comme dans l'exemple ci-dessus dans les ressources d'un élément (un UserControl élément par exemple). Vous pouvez définir des espaces de noms xml qui se rapportent à votre assemblée (et de l'espace de noms spécifique) par l'ajout de xmlns:xxx="clr-namespace:MyOtherAssembly.TheNamespace;assembly=MyOtherAssembly" le nœud racine de l'objet usercontrol ou basé sur un modèle de contrôle. Remplacer xxx qui un nom de cours.
    Une suggestion serait d'utiliser as opérateur au lieu de is + cast

    OriginalL'auteur odyss-jii

  3. 2

    Au lieu de retourner une int vous pouvez revenir à une L'épaisseur de la, qui le Margin est:

    public Thickness BondIndent
{
    get
    {
        int margin = _bondSequence * 5;
        return new Thickness(margin, 0, margin, 0);
    }
}

    La raison pour laquelle votre exemple fonctionne est parce que Thickness a surcharge des constructeurs de prendre 1, 2 ou 4 arguments. Whenthe constructeur qui prend 1 argument est appelé, tous les côtés sont initialisés à la valeur. WPF convertit automatiquement à un Thickness basé sur la valeur liée.

    Sur un autre sujet, BondIndent pourrait mieux être appelé BondMargin ou BondThickness maintenant.

    OriginalL'auteur Default

  4. 1

    Juste écrit quelques propriétés attachées qui devrait rendre facile pour définir un individu en Marge de la valeur à partir d'une liaison ou de la ressource statique:

    WPF:

    public class Margin
{
public static readonly DependencyProperty LeftProperty = DependencyProperty.RegisterAttached(
"Left",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0, LeftChanged));
private static void LeftChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var frameworkElement = d as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness((double)e.NewValue, currentMargin.Top, currentMargin.Right, currentMargin.Bottom);
}
}
public static void SetLeft(UIElement element, double value)
{
element.SetValue(LeftProperty, value);
}
public static double GetLeft(UIElement element)
{
return 0;
}
public static readonly DependencyProperty TopProperty = DependencyProperty.RegisterAttached(
"Top",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0, TopChanged));
private static void TopChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var frameworkElement = d as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness(currentMargin.Left, (double)e.NewValue, currentMargin.Right, currentMargin.Bottom);
}
}
public static void SetTop(UIElement element, double value)
{
element.SetValue(TopProperty, value);
}
public static double GetTop(UIElement element)
{
return 0;
}
public static readonly DependencyProperty RightProperty = DependencyProperty.RegisterAttached(
"Right",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0, RightChanged));
private static void RightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var frameworkElement = d as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, (double)e.NewValue, currentMargin.Bottom);
}
}
public static void SetRight(UIElement element, double value)
{
element.SetValue(RightProperty, value);
}
public static double GetRight(UIElement element)
{
return 0;
}
public static readonly DependencyProperty BottomProperty = DependencyProperty.RegisterAttached(
"Bottom",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0, BottomChanged));
private static void BottomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var frameworkElement = d as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, currentMargin.Right, (double)e.NewValue);
}
}
public static void SetBottom(UIElement element, double value)
{
element.SetValue(BottomProperty, value);
}
public static double GetBottom(UIElement element)
{
return 0;
}
}

    UWP:

    public class Margin
{
public static readonly DependencyProperty LeftProperty = DependencyProperty.RegisterAttached(
"Left",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0));
public static void SetLeft(UIElement element, double value)
{
var frameworkElement = element as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness(value, currentMargin.Top, currentMargin.Right, currentMargin.Bottom);
}
}
public static double GetLeft(UIElement element)
{
return 0;
}
public static readonly DependencyProperty TopProperty = DependencyProperty.RegisterAttached(
"Top",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0));
public static void SetTop(UIElement element, double value)
{
var frameworkElement = element as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness(currentMargin.Left, value, currentMargin.Right, currentMargin.Bottom);
}
}
public static double GetTop(UIElement element)
{
return 0;
}
public static readonly DependencyProperty RightProperty = DependencyProperty.RegisterAttached(
"Right",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0));
public static void SetRight(UIElement element, double value)
{
var frameworkElement = element as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, value, currentMargin.Bottom);
}
}
public static double GetRight(UIElement element)
{
return 0;
}
public static readonly DependencyProperty BottomProperty = DependencyProperty.RegisterAttached(
"Bottom",
typeof(double),
typeof(Margin),
new PropertyMetadata(0.0));
public static void SetBottom(UIElement element, double value)
{
var frameworkElement = element as FrameworkElement;
if (frameworkElement != null)
{
Thickness currentMargin = frameworkElement.Margin;
frameworkElement.Margin = new Thickness(currentMargin.Left, currentMargin.Top, currentMargin.Right, value);
}
}
public static double GetBottom(UIElement element)
{
return 0;
}
}

    Utilisation:

    <TextBlock Text="Test"
app:Margin.Top="{Binding MyValue}"
app:Margin.Right="{StaticResource MyResource}"
app:Margin.Bottom="20" />

    La bonne chose est qu'ils ne seront pas remplacer les autres valeurs de la Marge, de sorte que vous pouvez les combiner.

    les setters et getters ne sont pas appelés directement. Vous devez ajouter un PropertyCallback à la DependencyProperty. Je ne peux pas croire vraiment, que vous l'avez testé 🙂
    href="https://msdn.microsoft.com/en-us/library/ms749011(v=vs. 110).aspx" >msdn.microsoft.com/en-us/library/ms749011(v=vs. 110).aspx faites Défiler jusqu'à "la Coutume des Propriétés Attachées" -> "Comment créer une propriété attachée". Ils utilisent des conventions de nommage pour les getter et setter et vous n'avez pas besoin de fournir une propriété de rappel sur le DependencyProperty. Nous avons été à l'aide de ce tout notre code, il fonctionne.
    Blend et Visual Studio Designer utilisation de ces fonctions, mais WPF pas. Ces méthodes sont tout simplement intéressant pour obtenir/définir les propriétés par le code derrière...mais vous définissez les propriétés dans le code XAML dans votre exemple (pas de code derrière). Parce que WPF est la gestion de l'information, vous ne devriez pas mettre de la logique dans ces méthodes, en plus de réglage et d'obtenir les informations.
    Ahh, WPF fonctionne un peu différemment. Ajout d'une version de la propriété attachée qu'il y travaille.
    merci pour votre extrait de code, il fonctionne bien pour UWP

    OriginalL'auteur RandomEngy