it-swarm-pt.tech

uso de booleano para conversor de cores em XAML

Estou trabalhando no aplicativo WPF. Eu vinculei meu bloco de texto ao meu botão. Quero definir o primeiro plano do meu bloco de texto como preto quando o isEnabled do botão associado for verdadeiro. Eu quero fazer isso usando o conversor. Mas não está funcionando. também não dando nenhum erro. Eu declarei a seguinte classe na minha pasta "Modelos".

public class BrushColorConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if ((bool)value)
        {
            {
                return System.Windows.Media.Colors.Black;
            }
        }
        return System.Windows.Media.Colors.LightGreen;
    }

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

Ativar botão, propriedade isable muda de viewmodel (por exemplo, usando RaiseCanExecuteChanged) ())

as coisas relacionadas ao bloco de texto em XAML são:

   <Window.Resources>
            <local:BrushColorConverter x:Key="BConverter"></local:BrushColorConverter>
   </Window.Resources>
<Button>(!..all button properties..!)</Button>
    <TextBlock x:Name="AnswerText"                                           
               Text="Answer"                                          
               Foreground="{Binding ElementName=AnswerButton,Path=IsEnabled, Converter={StaticResource BConverter}}"
               TextWrapping="Wrap"/>
27
deathrace

use return new SolidColorBrush (Colors.Black);

41
user1101511

A resposta acima mostra como usar corretamente um conversor. No entanto, você realmente precisa usar um conversor? Isso pode ser feito no XAML apenas usando Triggers:

XAML

        <StackPanel>

            <Button IsEnabled="{Binding ElementName=isEnabledCheckBox, Path=IsChecked}">
                <TextBlock Text="Answer" TextWrapping="Wrap">
                    <TextBlock.Style>
                        <Style TargetType="{x:Type TextBlock}">
                            <Style.Triggers>
                                <DataTrigger Binding="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Button}}, Path=IsEnabled}" Value="True">
                                    <Setter Property="Foreground" Value="Green"/>
                                </DataTrigger>
                            </Style.Triggers>
                        </Style>
                    </TextBlock.Style>
                </TextBlock>
            </Button>

            <Button IsEnabled="{Binding ElementName=isEnabledCheckBox, Path=IsChecked}">
                <TextBlock Text="Answer" TextWrapping="Wrap">
                    <TextBlock.Style>
                        <Style TargetType="{x:Type TextBlock}">
                            <Style.Triggers>
                                <Trigger Property="IsEnabled" Value="True">
                                    <Setter Property="Foreground" Value="Green"/>
                                </Trigger>
                            </Style.Triggers>
                        </Style>
                    </TextBlock.Style>
                </TextBlock>
            </Button>

            <CheckBox x:Name="isEnabledCheckBox" Content="Toggle IsEnable on Buttons above" />

        </StackPanel>

No exemplo acima, o primeiro TextBlock se liga à propriedade IsEnabled do pai usando um DataTrigger e define o Foreground para alguma cor, se for verdadeiro.

No entanto, isso é um exagero - a propriedade IsEnabled é propagada para os filhos automaticamente pelo WPF. Ou seja, se você definir IsEnabled como false no seu Button, seu TextBlock terá sua propriedade IsEnabled atualizada automaticamente para false automaticamente. Isso é demonstrado no segundo TextBlock que usa uma propriedade Trigger para verificar sua própria propriedade IsEnabled em relação ao valor de true (uma vez que sua propriedade IsEnabled será o mesmo que o de seus pais). Essa seria a abordagem preferida.

Espero que isto ajude!

16
F Ruffell

Para tornar esse conversor geral, você pode usar um ConverterParameter para especificar as cores que serão inseridas quando value for verdadeiro ou falso. Também a opacidade pode ser interessante. Aqui eu forneço o Conversor usando o parâmetro [ColorNameIfTrue; ColorNameIfFalse; OpacityNumber].

Como o método SolidColorBrush() mencionado por @ user1101511 faz parte da biblioteca System.Windows.Media, Ele usa o tipo Color dessa mesma biblioteca. Este tipo não possui um método Color.FromName(), como a classe System.Drawing.Color.

Por isso, criei um método auxiliar chamado ColorFromName(string name). Eu especifico "LimeGreen" Como uma cor de fallback se a interoperação de ConverterParameter falhar. No meu caso, quero que a saída seja "Transparent" Quando value for false.

using System;
using System.Globalization;
using System.Windows.Data;
using System.Windows.Media;

namespace MyConverters
{
    [ValueConversion(typeof(bool), typeof(SolidColorBrush))]
    class BoolToColorBrushConverter : IValueConverter
    {
        #region Implementation of IValueConverter

        /// <summary>
        /// 
        /// </summary>
        /// <param name="value">Bolean value controlling wether to apply color change</param>
        /// <param name="targetType"></param>
        /// <param name="parameter">A CSV string on the format [ColorNameIfTrue;ColorNameIfFalse;OpacityNumber] may be provided for customization, default is [LimeGreen;Transperent;1.0].</param>
        /// <param name="culture"></param>
        /// <returns>A SolidColorBrush in the supplied or default colors depending on the state of value.</returns>
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        SolidColorBrush color;
        // Setting default values
        var colorIfTrue = Colors.LimeGreen;
        var colorIfFalse = Colors.Transparent;
        double opacity = 1;
        // Parsing converter parameter
        if (parameter != null)
        {
            // Parameter format: [ColorNameIfTrue;ColorNameIfFalse;OpacityNumber]
            var parameterstring = parameter.ToString();
            if (!string.IsNullOrEmpty(parameterstring))
            {
                var parameters = parameterstring.Split(';');
                var count = parameters.Length;
                if (count > 0 && !string.IsNullOrEmpty(parameters[0]))
                {
                    colorIfTrue = ColorFromName(parameters[0]);
                }
                if (count > 1 && !string.IsNullOrEmpty(parameters[1]))
                {
                    colorIfFalse = ColorFromName(parameters[1]);
                }
                if (count > 2 && !string.IsNullOrEmpty(parameters[2]))
                {
                    double dblTemp;
                    if (double.TryParse(parameters[2], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture.NumberFormat, out dblTemp))
                        opacity = dblTemp;
                }
            }
        }
        // Creating Color Brush
        if ((bool) value)
        {
            color = new SolidColorBrush(colorIfTrue);
            color.Opacity = opacity;
        }
        else
        {
            color = new SolidColorBrush(colorIfFalse);
            color.Opacity = opacity;
        }
        return color;
    }


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

    #endregion

    public static Color ColorFromName(string colorName)
    {
        System.Drawing.Color systemColor = System.Drawing.Color.FromName(colorName);
        return Color.FromArgb(systemColor.A, systemColor.R, systemColor.G, systemColor.B);
    }
}

No xaml, o conversor acima pode ser usado assim:

Background="{Binding MyBooleanValue, Converter={StaticResource BoolToColorBrushConverter}, ConverterParameter=LimeGreen;Transperent;0.2, Mode=OneWay}"
7
Håkon Seljåsen