CompositionNineGridBrush Klasse

Definition

Namespace:

Microsoft.UI.Composition

Zeichnet einen SpriteVisual mit einem CompositionBrush, nachdem Nine-Grid Stretching auf den Inhalt des Quellpinsels angewendet wurde. Die Quelle der Neun-Raster-Dehnung kann von einem beliebigen CompositionBrush des Typs CompositionColorBrush, CompositionSurfaceBrush oder einem CompositionEffectBrush verwendet werden.

public ref class CompositionNineGridBrush sealed : CompositionBrush

/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.Foundation.WindowsAppSDKContract, 65536)]
class CompositionNineGridBrush final : CompositionBrush

[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.Foundation.WindowsAppSDKContract), 65536)]
public sealed class CompositionNineGridBrush : CompositionBrush

Public NotInheritable Class CompositionNineGridBrush
Inherits CompositionBrush

Vererbung

Object Platform::Object IInspectable CompositionObject CompositionBrush CompositionNineGridBrush

Attribute

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Beispiele

Anwenden Nine-Grid Stretching auf ein Schaltflächenobjekt (CompositionSurfaceBrushSource)

private SpriteVisual CreateNineGridVisualFromImageSurface(ICompositionSurface imgSurface)
{
  CompositionSurfaceBrush sourceBrush = _compositor.CreateSurfaceBrush(imgSurface);

  // imgSurface is 50x50 pixels; nine-grid insets, as measured in the asset, are:
  // left = 1, top = 5, right = 10, bottom = 20 (in pixels)

  // create NineGridBrush to paint onto SpriteVisual
  CompositionNineGridBrush ninegridBrush = _compositor.CreateNineGridBrush();

  // set SurfaceBrush as Source to NineGridBrush
  ninegridBrush.Source = sourceBrush;

  // set Nine-Grid Insets
  ninegridBrush.SetInsets(1, 5, 10, 20);

  // set appropriate Stretch on SurfaceBrush for Center of Nine-Grid
  sourceBrush.Stretch = CompositionStretch.Fill;

  // create SpriteVisual and paint w/ NineGridBrush
  SpriteVisual visual = _compositor.CreateSpriteVisual();
  visual.Size = new Vector2(100, 75);
  visual.Brush = ninegridBrush;

  return visual;
}

Erstellen eines rahmenfarbigen Rahmens (CompositionColorBrushSource)

private SpriteVisual CreateBorderVisual(SpriteVisual childContent, float borderThickness, Color borderColor)
{
  SpriteVisual borderVisual = _compositor.CreateSpriteVisual();
  borderVisual.Size = childContent.Size + new Vector2(2 * borderThickness);

  // create NineGridBrush w/ ColorBrush Source
  CompositionNineGridBrush ninegridBrush = _compositor.CreateNineGridBrush();
  ninegridBrush.Source = _compositor.CreateColorBrush(borderColor);
  ninegridBrush.SetInsets(borderThickness);

  // opt out of drawing Center of Nine-Grid
  ninegridBrush.IsCenterHollow = true;

  // paint SpriteVisual w/ NineGridBrush
  borderVisual.Brush = ninegridBrush;

  // set child visual appropriately; manage size/scale changed events separately
  childContent.Offset = new Vector3(borderThickness, borderThickness, 0);
  borderVisual.Children.InsertAtTop(childContent);

  return borderVisual;
}

Verwenden von ExpressionAnimation zum dynamischen Aktualisieren von Eingangsskalen

private void CounterScaleInsets(SpriteVisual ninegridVisual)
{
  CompositionNineGridBrush ninegridBrush = (CompositionNineGridBrush)ninegridVisual.Brush;

  // use expressions to counter a scale transformation on visual so as to maintain a constant inset thickness
  ExpressionAnimation counterScaleXAnimation = _compositor.CreateExpressionAnimation("1/visual.Scale.X");
  counterScaleXAnimation.SetReferenceParameter("visual", ninegridVisual);

  ExpressionAnimation counterScaleYAnimation = _compositor.CreateExpressionAnimation("1/visual.Scale.Y"); 
  counterScaleYAnimation.SetReferenceParameter("visual", ninegridVisual);

  // start ExpressionAnimation on Nine-Grid InsetScales
  ninegridBrush.StartAnimation("LeftInsetScale", counterScaleXAnimation);
  ninegridBrush.StartAnimation("RightInsetScale", counterScaleXAnimation);

  ninegridBrush.StartAnimation("TopInsetScale", counterScaleYAnimation);
  ninegridBrush.StartAnimation("BottomInsetScale", counterScaleYAnimation);
}

Anwenden eines Effekts auf Nine-Grid Gestreckten Inhalt (CompositionNineGridBrush als Eingabe auf eine CompositionEffectBrush)

private void DesaturateNineGridVisual(SpriteVisual ninegridVisual)
{
  // get the NineGridBrush that the SpriteVisual is painted with
  CompositionNineGridBrush ninegridBrush = (CompositionNineGridBrush)ninegridVisual.Brush;

  // get or define IGraphicsEffect
  var saturationEffect = new SaturationEffect
  {
    Saturation = 0f,
    Source = new CompositionEffectSourceParameter("source"),
  };

  // create EffectBrush from EffectFactory
  CompositionEffectFactory saturationFactory = _compositor.CreateEffectFactory(saturationEffect);
  CompositionEffectBrush saturationBrush = saturationFactory.CreateBrush();

  // input NineGridBrush to EffectBrush
  saturationBrush.SetSourceParameter("source", ninegridBrush);

  // paint SpriteVisual with EffectBrush (w/ NineGridBrush as source parameter)
  ninegridVisual.Brush = saturationBrush;
}

Anwenden Nine-Grid Stretching auf eine Deckkraftmaske (CompositionNineGridBrush als Eingabe auf eine CompositionMaskBrush)

private SpriteVisual CreateMaskedRoundedRectVisual(ICompositionSurface myRoundedRectMaskSurface)
{
  // ColorBrush to be set as MaskBrush.Source
  CompositionColorBrush colorBrush = _compositor.CreateColorBrush(Colors.Blue);

  // SurfaceBrush w/ opacity mask surface
  CompositionSurfaceBrush roundedRectBrush = _compositor.CreateSurfaceBrush(myRoundedRectMaskSurface);
  roundedRectBrush.Stretch = CompositionStretch.Fill; // stretch for center of nine-grid

  // NineGridBrush w/ insets on opacity mask surface
  CompositionNineGridBrush ninegridBrush = _compositor.CreateNineGridBrush();
  ninegridBrush.Source = roundedRectBrush;
  ninegridBrush.SetInsets(_cornerRadius); // the radius, in pixels, of the corner as specified on my opacity mask surface 

  // Create MaskBrush
  CompositionMaskBrush maskBrush = _compositor.CreateMaskBrush();
  maskBrush.Source = colorBrush;
  maskBrush.Mask = ninegridBrush;

  // Paint SpriteVisual with MaskBrush
  SpriteVisual sprite = _compositor.CreateSpriteVisual();
  sprite.Size = new Vector2(300, 200);
  sprite.Brush = maskBrush;
  return sprite;
}

Hinweise

Nine-Grid Dehnung bezieht sich auf die Partitionierung visueller Inhalte (der Inhalt des Quellpinsels, der auf eine SpriteVisual-Instanz gemalt werden soll) in ein Raster aus neun Rechtecken, sodass die Größen der Eckrechtecke bei der Größenänderung beibehalten werden, wie im folgenden Diagramm dargestellt:

Wenn die Größe eines spriteVisual mit einem CompositionNineGridBrush-Element geändert oder skaliert wird, der linke und rechte Rand (Rechtecke 4 und 6) erstrecken sich entlang der vertikalen Achse, die Rechte am oberen und unteren Rand (Rechtecke 2 und 8) erstrecken sich entlang der horizontalen Achse, und der Mittelpunkt (Rechteck 5) wird entlang beider Achsen gestreckt, während sich die Ecken (Rechtecke 1, 3, 7 und 9) nicht erstrecken.

Die Source-Eigenschaft von CompositionNineGridBrush akzeptiert Pinsel eines von zwei Typen:

• CompositionSurfaceBrush: Wenden Sie Nine-Grid Stretching auf eine texturierte Bildoberfläche an.
• CompositionColorBrush: Erstellen sie einfarbige Farbrahmen.

Hinweise zur CompositionSurfaceBrush-Quelle

Einsets werden als Pixelwerte angegeben, die im Koordinatenraum des ICompositionSurface gemessen werden, der dem CompositionSurfaceBrush zugeordnet ist. Die Beziehung zwischen einem ImKoordinatenraum einer Fläche angegebenen Einset und dem Einset, wie er beim Malen auf einem SpriteVisual angezeigt wird, ist wie folgt:

Inset_Surface*InsetScale=Inset_SpriteVisual

The CompositionSurfaceBrush. Stretch-Eigenschaft gibt an, wie der Inhalt der Mitte des Nine-Grid gestreckt wird.

NineGridBrush-Einsets für ein abgerundetes Rechteckobjekt mit CompositionStretch.Fill; Die Einsets werden in Pixeln angegeben (gemessen im Koordinatenraum des ICompositionSurface, der das Objekt enthält).

CompositionNineGridBrush ist nicht dafür konzipiert, Nine-Grid Skalierung auf eine CompositionSurfaceBrush-Quelle anzuwenden, die eine Transformation über eine der folgenden Eigenschaften angewendet hat:

• CompositionSurfaceBrush.AnchorPoint
• CompositionSurfaceBrush.CenterPoint
• CompositionSurfaceBrush.Offset
• CompositionSurfaceBrush.RotationAngle
• CompositionSurfaceBrush.RotationAngleInDegrees
• CompositionSurfaceBrush.Scale
• CompositionSurfaceBrush.TransformMatrix Kein Pixelinhalt wird gezeichnet, wenn ein Transformationsvorgang auf die CompositionSurfaceBrush-Quelle auf eine CompositionNineGridBrush-Quelle angewendet wird.

Anwenden Nine-Grid Stretching auf eine Deckkraftmaske

Der Inhalt der CompositionSurfaceBrush-Quelle kann auch eine Deckkraftmaskenoberfläche sein. Das resultierende CompositionNineGridBrush kann dann als Maske auf ein CompositionMaskBrush festgelegt werden. Dadurch kann der maskierte Inhalt wie gewünscht skaliert werden, während die Deckkraftmaske Nine-Grid Stretching unterliegt.

In ähnlicher Weise kann die Quelle für eine CompositionMaskBrush auch vom Typ CompositionNineGridBrush sein.

Anwenden eines Effekts auf CompositionNineGridBrush

Ein CompositionNineGridBrush kann als Quelle auf ein CompositionEffectBrush festgelegt werden, um eine IGraphics- oder Windows.UI.Composition.Effect-Datei auf den Nine-Grid Stretched-Inhalt anzuwenden.

Hinweise zur CompositionColorBrush-Quelle

In Verbindung mit der IsCenterHollow-Eigenschaft ermöglicht eine CompositionColorBrush-Quelle das Erstellen von Volltonrahmen. Beachten Sie, dass Einsets für eine CompositionColorBrush-Quelle im Koordinatenraum des SpriteVisual selbst gemessen werden.

Hinweise zur Einbruchstärke und Einsetskala

Die Einsetstärke einer CompositionNineGridBrush ändert sich nicht, wenn die Size-Eigenschaft des zugeordneten SpriteVisual geändert wird.

Die Einsetskalierungseigenschaften bieten einen Mechanismus zum Skalieren Nine-Grid Einsets aus dem Koordinatenraum des Pinsels (z. B. Pixelraum für ein Bild) auf den des SpriteVisual. Für instance können die Einsetsskalierungseigenschaften verwendet werden, um die Einsetstärke als Reaktion auf eine Skalierungstransformation zu steuern, die von der SpriteVisual-Transformation geerbt wird, auf die der NineGridBrush gemalt wird, oder einem beliebigen Vorgänger in der visuellen Struktur (z. B. in Fällen von DPI-Skalierung usw.). In diesem Fall bietet ExpressionAnimations ein Mittel zum dynamischen Aktualisieren von Werten der Einsetskalierung.

Eigenschaften

BottomInset	Einset vom unteren Rand des Quellinhalts, der die Stärke der unteren Zeile angibt. Standardwert ist 0.0f.
BottomInsetScale	Skalierung, die auf BottomInset angewendet werden soll. Der Standardwert ist 1.0f.
Comment	Eine Zeichenfolge, die dem CompositionObject zugeordnet werden soll. (Geerbt von CompositionObject)
Compositor	Der Compositor , der zum Erstellen dieses CompositionObject verwendet wird. (Geerbt von CompositionObject)
DispatcherQueue	Ruft den DispatcherQueue für das CompositionObject ab. (Geerbt von CompositionObject)
ImplicitAnimations	Die Auflistung impliziter Animationen, die diesem Objekt angefügt sind. (Geerbt von CompositionObject)
IsCenterHollow	Gibt an, ob die Mitte des Nine-Grid gezeichnet ist.
LeftInset	Vom linken Rand des Quellinhalts ausgehend, der die Stärke der linken Spalte angibt. Standardwert ist 0.0f.
LeftInsetScale	Skalierung, die auf LeftInset angewendet werden soll. Der Standardwert ist 1.0f.
Properties	Die Auflistung von Eigenschaften, die dem CompositionObject zugeordnet sind. (Geerbt von CompositionObject)
RightInset	Einset vom rechten Rand des Quellinhalts, der die Stärke der rechten Spalte angibt. Standardwert ist 0.0f.
RightInsetScale	Skalierung, die auf RightInset angewendet werden soll. Der Standardwert ist 1.0f.
Source	Der Pinsel, dessen Inhalt Nine-Grid gestreckt werden soll. Kann vom Typ CompositionSurfaceBrush oder CompositionColorBrush sein.
TopInset	Einset vom oberen Rand des Quellinhalts, der die Stärke der obersten Zeile angibt. Standardwert ist 0.0f.
TopInsetScale	Skalierung, die auf TopInset angewendet werden soll. Der Standardwert ist 1.0f.

Methoden

Close()	Schließt das CompositionObject und gibt Systemressourcen frei. (Geerbt von CompositionObject)
Dispose()	Führt anwendungsspezifische Aufgaben durch, die mit der Freigabe, der Zurückgabe oder dem Zurücksetzen von nicht verwalteten Ressourcen zusammenhängen. (Geerbt von CompositionObject)
PopulatePropertyInfo(String, AnimationPropertyInfo)	Definiert eine Eigenschaft, die animiert werden kann. (Geerbt von CompositionObject)
SetInsets(Single)	Legt die Einsätze einer CompositionNineGridBrush-Instanz mit demselben Wert für oben, unten, links und rechts fest. Standardwert ist 0.0f.
SetInsets(Single, Single, Single, Single)	Legt die Einsätze einer CompositionNineGridBrush-Instanz unter Verwendung der angegebenen Werte für oben, unten, links und rechts fest. Standardwert ist 0.0f.
SetInsetScales(Single)	Legt die (gleiche) Skalierung fest, die auf die linken, oberen, rechten und unteren Einsätze angewendet werden soll. Der Standardwert ist 1.0f.
SetInsetScales(Single, Single, Single, Single)	Legt die Skalierung fest, die auf die linken, oberen, rechten und unteren Einsätze angewendet werden soll. Der Standardwert ist 1.0f.
StartAnimation(String, CompositionAnimation)	Verbindet eine Animation mit der angegebenen Eigenschaft des Objekts und startet die Animation. (Geerbt von CompositionObject)
StartAnimation(String, CompositionAnimation, AnimationController)	Verbindet eine Animation mit der angegebenen Eigenschaft des Objekts und startet die Animation. (Geerbt von CompositionObject)
StartAnimationGroup(ICompositionAnimationBase)	Startet eine Animationsgruppe. Mit der StartAnimationGroup-Methode für CompositionObject können Sie CompositionAnimationGroup starten. Alle Animationen in der Gruppe werden gleichzeitig für das Objekt gestartet. (Geerbt von CompositionObject)
StopAnimation(String)	Trennt eine Animation von der angegebenen Eigenschaft und beendet die Animation. (Geerbt von CompositionObject)
StopAnimationGroup(ICompositionAnimationBase)	Beendet eine Animationsgruppe. (Geerbt von CompositionObject)
TryGetAnimationController(String)	Gibt einen AnimationController für die Animation zurück, die für die angegebene Eigenschaft ausgeführt wird. (Geerbt von CompositionObject)

Weitere Informationen

• CompositionBrush
• IClosable