WPF/XAML: Comment faire de tout le texte en majuscule dans TextBlock?

Je veux tous les caractères dans un TextBlock pour être affichés en majuscules

 <TextBlock Name="tbAbc"
            FontSize="12"
            TextAlignment="Center"
            Text="Channel Name"
            Foreground="{DynamicResource {x:Static r:RibbonSkinResources.RibbonGroupLabelFontColorBrushKey}}" />

Les cordes sont prises par le biais de la Liaison. Je ne veux pas faire les chaînes de caractères en majuscules dans le dictionnaire lui-même.

voir C# format de la chaîne de drapeau ou un modificateur de minuscules param
Double Possible de WPF/XAML: comment faire de tout le texte en majuscule / capitale?

OriginalL'auteur feralbino | 2014-07-25

22

Ou de l'utilisation
```
Typography.Capitals="AllSmallCaps"
```
dans votre TextBlock définition.

Voir ici: MSDN - Typographie.Capitales

EDIT:

Cela ne fonctionne pas dans Windows Phone 8.1, uniquement dans Windows 8.1 ...

Cela ne fonctionne pas, chapiteaux seront les grandes capitales et bas de casse des caractères sera de petites capitales.

OriginalL'auteur TheEye

Mettre en œuvre un convertisseur personnalisé.

using System.Globalization;
using System.Windows.Data;
//...
public class StringToUpperConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value != null && value is string )
        {
            return ((string)value).ToUpper();
        }

        return value;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return null;
    }
}

Puis de l'inclure dans votre XAML comme une ressource:

<local:StringToUpperConverter  x:Key="StringToUpperConverter"/>

Et l'ajouter à votre liaison:

Converter={StaticResource StringToUpperConverter}

OriginalL'auteur kidshaw

Vous pouvez utiliser une propriété attachée comme ceci:

public static class TextBlock
{
    public static readonly DependencyProperty CharacterCasingProperty = DependencyProperty.RegisterAttached(
        "CharacterCasing",
        typeof(CharacterCasing),
        typeof(TextBlock),
        new FrameworkPropertyMetadata(
            CharacterCasing.Normal,
            FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.NotDataBindable,
            OnCharacterCasingChanged));

    private static readonly DependencyProperty TextProxyProperty = DependencyProperty.RegisterAttached(
        "TextProxy",
        typeof(string),
        typeof(TextBlock),
        new PropertyMetadata(default(string), OnTextProxyChanged));

    private static readonly PropertyPath TextPropertyPath = new PropertyPath("Text");


    public static void SetCharacterCasing(DependencyObject element, CharacterCasing value)
    {
        element.SetValue(CharacterCasingProperty, value);
    }

    public static CharacterCasing GetCharacterCasing(DependencyObject element)
    {
        return (CharacterCasing)element.GetValue(CharacterCasingProperty);
    }

    private static void OnCharacterCasingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is System.Windows.Controls.TextBlock textBlock)
        {
            if (BindingOperations.GetBinding(textBlock, TextProxyProperty) == null)
            {
                BindingOperations.SetBinding(
                    textBlock,
                    TextProxyProperty,
                    new Binding
                    {
                        Path = TextPropertyPath,
                        RelativeSource = RelativeSource.Self,
                        Mode = BindingMode.OneWay,
                    });
            }
        }
    }

    private static void OnTextProxyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        d.SetCurrentValue(System.Windows.Controls.TextBlock.TextProperty, Format((string)e.NewValue, GetCharacterCasing(d)));

        string Format(string text, CharacterCasing casing)
        {
            if (string.IsNullOrEmpty(text))
            {
                return text;
            }

            switch (casing)
            {
                case CharacterCasing.Normal:
                    return text;
                case CharacterCasing.Lower:
                    return text.ToLower();
                case CharacterCasing.Upper:
                    return text.ToUpper();
                default:
                    throw new ArgumentOutOfRangeException(nameof(casing), casing, null);
            }
        }
    }
}

Alors l'utilisation de xaml ressemblera:

<StackPanel>
    <TextBox x:Name="TextBox" Text="abc" />
    <TextBlock local:TextBlock.CharacterCasing="Upper" Text="abc" />
    <TextBlock local:TextBlock.CharacterCasing="Upper" Text="{Binding ElementName=TextBox, Path=Text}" />
    <Button local:TextBlock.CharacterCasing="Upper" Content="abc" />
    <Button local:TextBlock.CharacterCasing="Upper" Content="{Binding ElementName=TextBox, Path=Text}" />
</StackPanel>

C'est une excellente solution si le textblock en question est déjà à l'aide d'un convertisseur.
Excellente solution, car elle n'implique pas, vous pouvez changer le contenu de l'élément.

OriginalL'auteur Johan Larsson

3

Si ce n'est pas une grosse affaire, vous pouvez utiliser zone de texte au lieu de TextBlock comme ceci:
```
<TextBox CharacterCasing="Upper" IsReadOnly="True" />
```
href="http://meta.stackexchange.com/questions/5234/how-does-accepting-an-answer-work" title="comment accepter une réponse travailler">meta.stackexchange.com/questions/5234/...
Ce n'est pas vraiment une réponse acceptable, mais parce que la question porte sur les TextBlock.
J'ai été pas en lui demandant d'accepter ma réponse, juste pour lui faire savoir qu'il doit accepter l'une ( celle qui l'a aidé le plus, c'est tout sur ce site, non?). À mon avis, l'un avec le convertisseur est une bonne réponse. (le mien est juste une solution de rechange).
Sur la zone de texte, définissant le caractère boîtier true à la propriété n'affecte manuellement le texte tapé. Le choix de IsReadOnly à true dans le même temps élimine la CharacterCasing propriétés de l'utilité de ce cas d'utilisation. Je ne connaissais pas la propriété CharacterCasing existé sur la zone de texte bien que si j'ai appris quelque chose ici!
est correcte, CharacterCasing="Haut" sur l'élément de zone de texte ne s'appliquera qu'aux nouveaux texte tapé dans l'élément. Il ne s'applique pas à un déjà existant "text" value malheureusement

OriginalL'auteur RazvanR

- Je utiliser un caractère de valeur de la carcasse converter:

class CharacterCasingConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var s = value as string;
        if (s == null)
            return value;

        CharacterCasing casing;
        if (!Enum.TryParse(parameter as string, out casing))
            casing = CharacterCasing.Upper;

        switch (casing)
        {
            case CharacterCasing.Lower:
                return s.ToLower(culture);
            case CharacterCasing.Upper:
                return s.ToUpper(culture);
            default:
                return s;
        }
    }

    object IValueConverter.ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotSupportedException();
    }
}

OriginalL'auteur Stephen Drew

0

Un Convertisseur qui convertit votre texte en majuscules. De cette façon, vous texte original reste inchangé.

Comment utiliser IValueConverter dans la Liaison de WPF

OriginalL'auteur Marcel B

Vous devez vous connecter pour publier un commentaire.