SolidColorBrush Classe

Définition

Espace de noms:

Windows.UI.Xaml.Media

Peint une zone avec une couleur unie. La couleur unie est définie par une valeur Color .

public ref class SolidColorBrush sealed : Brush

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.UI.Xaml.Markup.ContentProperty(Name="Color")]
/// [Windows.Foundation.Metadata.Activatable(Windows.UI.Xaml.Media.ISolidColorBrushFactory, 65536, "Windows.Foundation.UniversalApiContract")]
/// [Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
class SolidColorBrush final : Brush

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.UI.Xaml.Markup.ContentProperty(Name="Color")]
[Windows.Foundation.Metadata.Activatable(typeof(Windows.UI.Xaml.Media.ISolidColorBrushFactory), 65536, "Windows.Foundation.UniversalApiContract")]
[Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
public sealed class SolidColorBrush : Brush

Public NotInheritable Class SolidColorBrush
Inherits Brush

<SolidColorBrush .../>
-or-
<SolidColorBrush>colorString</SolidColorBrush>
- or -
<SolidColorBrush Color="predefinedColorName"/>
- or -
<SolidColorBrush Color="#rgb"/>
- or -
<SolidColorBrush Color="#argb"/>
- or -
<SolidColorBrush Color="#rrggbb"/>
- or -
<SolidColorBrush Color="#aarrggbb"/>
- or -
<SolidColorBrush Color="sc#scR,scG,scB"/>
- or -
<SolidColorBrush Color="sc#scA,scR,scG,scB"/>

Héritage

Object Platform::Object IInspectable DependencyObject Brush SolidColorBrush

Attributs

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute ContentPropertyAttribute

Configuration requise pour Windows

Famille d’appareils	Windows 10 (introduit dans 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduit dans v1.0)

Exemples

La façon la plus courante d’utiliser SolidColorBrush consiste à définir un élément XAML en tant que ressource dans un ResourceDictionary, puis à référencer cette ressource ultérieurement à partir d’autres définitions, styles ou modèles d’interface utilisateur à l’aide de l’extension de balisage {StaticResource} ou de l’extension de balisage {ThemeResource} .

<ResourceDictionary>
...
    <SolidColorBrush x:Key="BlockBackgroundBrush" Color="#FF557EB9"/>
...
</ResourceDictionary>

<Border Background="{StaticResource BlockBackgroundBrush}" 
    Width="80" Height="80"/>

Il existe plusieurs façons de définir un SolidColorBrush en tant que valeur d’interface utilisateur inline plutôt qu’en tant que ressource :

• Sélectionnez une couleur prédéfinie par nom et appuyez-vous sur le « raccourci » XAML pour que cette couleur crée un SolidColorBrush lorsqu’elle est analysée. Par exemple, vous pouvez définir le remplissage d’un rectangle sur « Rouge » comme suit :

<Canvas
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <!-- This rectangle's fill is painted with a red SolidColorBrush,
       described using a named color. -->
  <Rectangle Width="100" Height="100" Fill="Red" />
</Canvas>

• Sélectionnez une couleur personnalisée à partir d’une plage de couleurs 24 bits composée de quantités choisies de rouge, de vert et de bleu à l’aide d’un code de couleur RVB hexadécimal :

<Canvas
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <!-- This rectangle's fill is painted with a Red SolidColorBrush,
       described using an RGB-style hex color code. -->
  <Rectangle Width="100" Height="100" Fill="#FF0000" />
</Canvas>

• Vous pouvez également spécifier une couleur personnalisée avec une opacité spécifiée en définissant la propriété souhaitée sur un code de couleur ARGB au format hexadécimal :

<Canvas
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <!-- This rectangle's fill is painted with a fully opaque red SolidColorBrush,
       described using an ARGB style hex code. -->
  <Rectangle Width="100" Height="100" Fill="#FFFF0000" />
</Canvas>

Des pinceaux de couleur unie peuvent être créés dans code-behind en instanciant un objet SolidColorBrush avec une couleur prédéfinie à partir du struct Colors .

SolidColorBrush greenBrush = new SolidColorBrush(Colors.Green);

Windows::UI::Xaml::Media::SolidColorBrush greenBrush{ Windows::UI::Colors::Green() };

auto greenBrush = ref new SolidColorBrush(Colors::Green);

Une autre façon de définir un nouvel objet SolidColorBrush consiste à utiliser la méthode d’utilitaire statique FromArgb . Cela est utile s’il n’existe aucune valeur de couleurs nommée pour la couleur souhaitée.

SolidColorBrush myBrush = new SolidColorBrush(Color.FromArgb(255, 20, 20, 90));

Windows::UI::Xaml::Media::SolidColorBrush myBrush{ Windows::UI::ColorHelper::FromArgb(255, 90, 200, 90) };

auto myBrush = ref new SolidColorBrush(ColorHelper::FromArgb(255, 90, 200, 90));

Remarques

SolidColorBrush est le type de pinceau le plus courant utilisé pour de nombreuses propriétés d’interface utilisateur possibles qui utilisent un pinceau pour remplir tout ou partie de la zone visuelle d’un objet dans l’interface utilisateur de l’application. Voici quelques-unes des propriétés les plus couramment utilisées qui utilisent une valeur Brush : Control.Background, Control.Foreground, Shape.Fill, Control.BorderBrush, Panel.Background, TextBlock.Foreground.

Pour ces propriétés, une valeur null est souvent acceptable et a pour résultat que rien n’y est rendu. Si l’élément apparaît dans le même espace de coordonnées que d’autres éléments, la valeur null d’une propriété telle que Background empêche cet élément de s’inscrire à des fins de test d’accès et de déterminer d’où provient un événement d’entrée. Tous les événements de pointeur, mouvements ou autres qui se produisent sur ce point dans l’espace de coordonnées de l’interface utilisateur ne sont détectables que s’il existe une valeur autre que null pour la propriété Brush qui influence le rendu pour ce point.

Vous pouvez créer un SolidColorBrush qui utilise la valeur Transparent , et bien que cela n’applique pas visuellement les modifications apportées à l’interface utilisateur (il est transparent), ce point est détectable à des fins de test d’accès. Il s’agit donc d’une propriété Brush avec une valeur null . Un pinceau transparent peut être utile pour des techniques telles que la création de régions de superposition sur des éléments d’interface utilisateur où vous souhaitez intercepter le test d’accès avec un élément tel qu’un rectangle, une bordure ou un panneau. Vous pouvez le faire si les éléments en dessous ne sont pas en mesure d’effectuer leurs propres tests d’accès, mais que vous souhaitez toujours détecter les événements d’entrée. Pour plus d’informations sur les tests d’accès, consultez la section « Test d’accès » dans Interactions avec la souris.

Les propriétés utilisant des pinceaux peuvent être animées dans le cadre de transitions ou d’animations décoratives. Vous n’animez généralement pas un objet SolidColorBrush entier, vous devez utiliser une animation objet discrète et qui n’est ni efficace ni esthétique. Au lieu de cela, vous utilisez le ciblage de propriété pour animer uniquement la valeur Color , à l’aide de l’un des types d’animation dédiés qui peuvent animer une valeur Color . Cela implique généralement de faire .(SolidColorBrush.Color) partie de la valeur Storyboard.TargetProperty . Pour plus d’informations sur le ciblage de propriétés et sur l’animation de propriétés qui utilisent SolidColorBrush ou d’autres valeurs Brush , consultez Animations storyboarded.

Un SolidColorBrush est un objet partageable, comme le sont les autres types dérivés de Brush tels que LinearGradientBrush et ImageBrush. Étant donné qu’il est partageable, SolidColorBrush est parfois défini en XAML en tant que ressource dans un ResourceDictionary XAML. L’avantage de l’utilisation de ressources partageables à partir de XAML est que vous ne créez la valeur qu’une seule fois et que vous l’appliquez à plusieurs propriétés.

L’application d’une valeur UIElement.Opacity peut modifier l’apparence de couleur d’une propriété SolidColorBrush appliquée à un objet. La valeur UIElement.Opacity peut être cumulative en fonction de la disposition des objets qui se chevauchent. Les couleurs s’affichent comme prévu uniquement lorsque la valeur d’opacité nette est 1. Il existe également une propriété Brush.Opacity qui peut affecter la couleur apparente de la même façon. Brush.Opacity est généralement laissé à sa valeur par défaut de 1, sauf s’il est délibérément animé pour un effet fondu ou fondu.

Pinceaux en tant que ressources XAML

Chacun des types de pinceau qui peuvent être déclarés en XAML (SolidColorBrush, LinearGradientBrush, ImageBrush) est destiné à être défini en tant que ressource, afin que vous puissiez réutiliser ce pinceau en tant que ressource dans votre application. La syntaxe XAML indiquée pour les types Brush est appropriée pour définir le pinceau en tant que ressource. Lorsque vous déclarez un pinceau en tant que ressource, vous avez également besoin d’un attribut x:Key que vous utiliserez ultérieurement pour faire référence à cette ressource à partir d’autres définitions d’interface utilisateur. Pour plus d’informations sur les ressources XAML et sur l’utilisation de l’attribut x:Key, consultez ResourceDictionary et références de ressources XAML.

L’avantage de déclarer des pinceaux en tant que ressources est qu’il réduit le nombre d’objets runtime nécessaires à la construction d’une interface utilisateur : le pinceau est désormais partagé en tant que ressource commune qui fournit des valeurs pour plusieurs parties du graphique d’objets.

Si vous examinez les définitions de modèle de contrôle existantes pour Windows Runtime contrôles XAML, vous verrez que les modèles utilisent largement les ressources de pinceau. La plupart de ces ressources sont des ressources système et utilisent l’extension de balisage {ThemeResource} pour la référence de ressource plutôt que l’extension de balisage {StaticResource}. Pour plus d’informations sur l’utilisation des pinceaux de ressources système dans votre propre modèle de contrôle XAML, consultez Ressources de thème XAML.

Constructeurs

SolidColorBrush()	Initialise une nouvelle instance de la classe SolidColorBrush sans couleur.
SolidColorBrush(Color)	Initialise une nouvelle instance de la classe SolidColorBrush avec la couleur spécifiée.

Propriétés

Color	Obtient ou définit la couleur de ce SolidColorBrush.
ColorProperty	Identifie la propriété de dépendance Color .
Dispatcher	Obtient le CoreDispatcher auquel cet objet est associé. CoreDispatcher représente une fonctionnalité qui peut accéder à DependencyObject sur le thread d’interface utilisateur, même si le code est initié par un thread autre que l’interface utilisateur. (Hérité de DependencyObject)
Opacity	Obtient ou définit le degré d’opacité d’un pinceau. (Hérité de Brush)
RelativeTransform	Obtient ou définit la transformation appliquée au pinceau en utilisant des coordonnées relatives. (Hérité de Brush)
Transform	Obtient ou définit la transformation appliquée au pinceau. (Hérité de Brush)

Méthodes

ClearValue(DependencyProperty)	Efface la valeur locale d’une propriété de dépendance. (Hérité de DependencyObject)
GetAnimationBaseValue(DependencyProperty)	Retourne toute valeur de base établie pour une propriété de dépendance, qui s’applique dans les cas où une animation n’est pas active. (Hérité de DependencyObject)
GetValue(DependencyProperty)	Retourne la valeur effective actuelle d’une propriété de dépendance à partir d’un DependencyObject. (Hérité de DependencyObject)
PopulatePropertyInfo(String, AnimationPropertyInfo)	Définit une propriété qui peut être animée. (Hérité de Brush)
PopulatePropertyInfoOverride(String, AnimationPropertyInfo)	En cas de substitution dans une classe dérivée, définit une propriété qui peut être animée. (Hérité de Brush)
ReadLocalValue(DependencyProperty)	Retourne la valeur locale d’une propriété de dépendance, si une valeur locale est définie. (Hérité de DependencyObject)
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)	Inscrit une fonction de notification pour écouter les modifications apportées à un DependencyProperty spécifique sur cette instance DependencyObject . (Hérité de DependencyObject)
SetValue(DependencyProperty, Object)	Définit la valeur locale d’une propriété de dépendance sur un DependencyObject. (Hérité de DependencyObject)
UnregisterPropertyChangedCallback(DependencyProperty, Int64)	Annule une notification de modification précédemment inscrite en appelant RegisterPropertyChangedCallback. (Hérité de DependencyObject)

Voir aussi

• Color
• Colors
• Brush
• Color.FromArgb
• Utiliser des pinceaux
• Références aux ressources ResourceDictionary et XAML