Zeichnen mit Bildern, Zeichnungen und visuellen Elementen
Aktualisiert: November 2007
In diesem Thema wird beschrieben, wie mithilfe der Objekte ImageBrush, DrawingBrush und VisualBrush-ein Bereich mit einem Bild, einer Drawing oder einem Visual gezeichnet wird.
Dieses Thema enthält folgende Abschnitte.
- Vorbereitungsmaßnahmen
- Zeichnen eines Bereichs mit einem Bild
- Beispiel: Zeichnen eines Objekts mit einem Bitmapbild
- Zeichnen eines Bereichs mit einer Zeichnung
- Beispiel: Zeichnen eines Objekts mit einer Zeichnung
- Zeichnen eines Bereichs mit einem visuellen Element
- Beispiel: Zeichnen eines Objekts mit einem visuellen Element
- Beispiel: Erstellen einer Reflektion
- TileBrush-Features
- Verwandte Abschnitte
Vorbereitungsmaßnahmen
Für dieses Thema sollten Sie mit den von Windows Presentation Foundation (WPF) bereitgestellten unterschiedlichen Pinseltypen sowie deren grundlegenden Features vertraut sein. Eine Einführung finden Sie unter Übersicht über WPF-Pinsel.
Zeichnen eines Bereichs mit einem Bild
Ein ImageBrush zeichnet einen Bereich mit einem ImageSource-Objekt. Der mit einem ImageBrush am häufigsten verwendete ImageSource-Typ ist ein BitmapImage, was eine Bitmapgrafik darstellt. Sie können zum Zeichnen ein DrawingImage mithilfe eines Drawing-Objekts verwenden, wobei ein DrawingBrush einfacher anzuwenden ist. Weitere Informationen über ImageSource-Objekte finden Sie unter Übersicht über die Bildverarbeitung.
Um mit einem ImageBrush zu zeichnen, erstellen Sie ein BitmapImage und verwenden es zum Laden des Bitmapinhalts. Verwenden Sie dann das BitmapImage, um die ImageSource-Eigenschaft für den ImageBrush festzulegen. Zum Schluss wenden Sie den ImageBrush auf das zu zeichnende Objekt an. In Extensible Application Markup Language (XAML) können Sie aber auch einfach die ImageSource-Eigenschaft von ImageBrush auf den Pfad des zu ladenden Bilds setzen.
Wie alle Brush-Objekte kann ein ImageBrush zum Zeichnen von Objekten, z. B. Formen, Bereichen, Steuerelementen und Text, verwendet werden. Die folgende Abbildung zeigt einige Effekte, die mit einem ImageBrush erreicht werden können.
Von einem ImageBrush gezeichnete Objekte
.gif)
Standardmäßig wird ein Bild mithilfe von ImageBrush gestreckt, um den zu zeichnenden Bereich vollständig auszufüllen. Dabei wird das Bild möglicherweise verzerrt, wenn der gezeichnete Bereich ein anderes Seitenverhältnis als das Bild aufweist. Sie können dieses Verhalten ändern, indem Sie die Stretch-Eigenschaft von ihrem Standardwert Fill in None, Uniform oder UniformToFill ändern. Da ImageBrush ein TileBrush-Typ ist, können Sie genau angeben, wie ein Bildpinsel den Ausgabebereich ausfüllt, und sogar Muster erstellen. Weitere Informationen über die erweiterten TileBrush-Features finden Sie unter Übersicht über TileBrush.
Beispiel: Zeichnen eines Objekts mit einem Bitmapbild
Im folgenden Beispiel wird ein ImageBrush verwendet, um den Background von einem Canvas zu zeichnen.
<Page
xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
x:Class="Microsoft.Samples.BrushExamples.ImageBrushExample"
WindowTitle="ImageBrush Example"
Background="White">
<StackPanel>
<Canvas
Height="200" Width="300">
<Canvas.Background>
<ImageBrush ImageSource="sampleImages\Waterlilies.jpg" />
</Canvas.Background>
</Canvas>
</StackPanel>
</Page>
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
namespace Microsoft.Samples.BrushExamples
{
public class ImageBrushExample : Page
{
public ImageBrushExample()
{
StackPanel mainPanel = new StackPanel();
canvasBackgroundExample(mainPanel);
this.Content = mainPanel;
}
private void canvasBackgroundExample(Panel mainPanel)
{
BitmapImage theImage = new BitmapImage
(new Uri("sampleImages\\Waterlilies.jpg", UriKind.Relative));
ImageBrush myImageBrush = new ImageBrush(theImage);
Canvas myCanvas = new Canvas();
myCanvas.Width = 300;
myCanvas.Height = 200;
myCanvas.Background = myImageBrush;
mainPanel.Children.Add(myCanvas);
}
}
}
Zeichnen eines Bereichs mit einer Zeichnung
Ein DrawingBrush ermöglicht es Ihnen, einen Bereich mithilfe von Formen, Text, Bildern und einem Video zu zeichnen. Die Formen innerhalb des Zeichenpinsels können selbst mit einer Volltonfarbe, einem Farbverlauf, einem Bild oder sogar mit einem weiteren DrawingBrush gezeichnet sein. In der folgenden Abbildung werden einige Verwendungen für den DrawingBrush veranschaulicht.
Von einem DrawingBrush (Zeichenpinsel) gezeichnete Objekte
.png)
Ein DrawingBrush zeichnet einen Bereich mit einem Drawing-Objekt. Ein Drawing-Objekt beschreibt sichtbaren Inhalt, z. B. eine Form, Bitmap, ein Video oder eine Textzeile. Die verschiedenen Zeichnungstypen beschreiben unterschiedliche Inhaltstypen. Die folgende Liste enthält die verschiedenen Typen von Zeichnungsobjekten.
GeometryDrawing – Zeichnet eine Form.
ImageDrawing – Zeichnet ein Bild.
GlyphRunDrawing – Zeichnet Text.
VideoDrawing – Gibt eine Audio- oder Videodatei wieder.
DrawingGroup – Zeichnet andere Zeichnungen. Verwenden Sie eine Zeichnungsgruppe, um aus anderen Zeichnungen eine einzelne zusammengesetzte Zeichnung zu bilden.
Weitere Informationen über Drawing-Objekte finden Sie unter Übersicht über Zeichnungsobjekte.
Wie ein ImageBrush streckt ein DrawingBrush seine Drawing, um den Ausgabebereich auszufüllen. Sie können dieses Verhalten überschreiben, indem Sie die Standardeinstellung Fill der Stretch-Eigenschaft ändern. Weitere Informationen finden Sie in den Ausführungen zur Stretch-Eigenschaft.
Beispiel: Zeichnen eines Objekts mit einer Zeichnung
Das folgende Beispiel zeigt, wie ein Objekt mithilfe einer Zeichnung aus drei Ellipsen gezeichnet wird. Für die Beschreibung der Ellipsen wird ein GeometryDrawing-Zeichnungsobjekt verwendet.
<Button Content="A Button">
<Button.Background>
<DrawingBrush>
<DrawingBrush.Drawing>
<GeometryDrawing Brush="LightBlue">
<GeometryDrawing.Geometry>
<GeometryGroup>
<EllipseGeometry RadiusX="12.5" RadiusY="25" Center="25,50" />
<EllipseGeometry RadiusX="12.5" RadiusY="25" Center="50,50" />
<EllipseGeometry RadiusX="12.5" RadiusY="25" Center="75,50" />
</GeometryGroup>
</GeometryDrawing.Geometry>
<GeometryDrawing.Pen>
<Pen Thickness="1" Brush="Gray" />
</GeometryDrawing.Pen>
</GeometryDrawing>
</DrawingBrush.Drawing>
</DrawingBrush>
</Button.Background>
</Button>
// Create a DrawingBrush.
DrawingBrush myDrawingBrush = new DrawingBrush();
// Create a drawing.
GeometryDrawing myGeometryDrawing = new GeometryDrawing();
myGeometryDrawing.Brush = Brushes.LightBlue;
myGeometryDrawing.Pen = new Pen(Brushes.Gray, 1);
GeometryGroup ellipses = new GeometryGroup();
ellipses.Children.Add(new EllipseGeometry(new Point(25,50), 12.5, 25));
ellipses.Children.Add(new EllipseGeometry(new Point(50,50), 12.5, 25));
ellipses.Children.Add(new EllipseGeometry(new Point(75,50), 12.5, 25));
myGeometryDrawing.Geometry = ellipses;
myDrawingBrush.Drawing = myGeometryDrawing;
Button myButton = new Button();
myButton.Content = "A Button";
// Use the DrawingBrush to paint the button's background.
myButton.Background = myDrawingBrush;
Zeichnen eines Bereichs mit einem visuellen Element
VisualBrush ist der vielseitigste und leistungsfähigste aller Pinsel und zeichnet einen Bereich mit einem Visual. Ein Visual ist ein Grafiktyp auf niedriger Ebene, der für viele nützliche grafische Komponenten als Stammelement fungiert. Die Klassen Window, FrameworkElement und Control sind beispielsweise alle Visual-Objekttypen. Mithilfe von VisualBrush können Sie Bereiche mit fast jedem grafischen Objekt in Windows Presentation Foundation (WPF) zeichnen.
Tipp
Obwohl VisualBrush ein Freezable-Objekttyp ist, kann es nicht gesperrt (als schreibgeschützt definiert) werden, wenn die Visual-Eigenschaft nicht auf den Wert null festgelegt ist.
Es gibt zwei Möglichkeiten, den Visual-Inhalt von einem VisualBrush anzugeben.
Erstellen Sie ein neues Visual-Element, und verwenden Sie es, um die Visual-Eigenschaft vom VisualBrush festzulegen. Ein Beispiel finden Sie im folgenden Abschnitt unter Beispiel: Zeichnen eines Objekts mit einem visuellen Element.
Verwenden Sie ein vorhandenes Visual-Element, das vom Ziel-Visual ein Bildduplikat erstellt. Sie können dann den VisualBrush verwenden, um interessante Effekte zu erstellen, z. B. Reflektion und Vergrößerung. Ein Beispiel finden Sie im Abschnitt Beispiel: Erstellen einer Reflektion.
Wenn Sie ein neues Visual für einen VisualBrush definieren und es sich bei dem Visual um ein UIElement handelt (z. B. ein Bereich oder ein Steuerelement), wird das Layoutsystem auf dem UIElement und dessen untergeordneten Elementen ausgeführt, sofern die AutoLayoutContent-Eigenschaft auf true festgelegt ist. Das Stamm-UIElement ist jedoch im Grunde vom Rest des Systems isoliert: Stile und externes Layout können diese Abgrenzung nicht durchdringen. Daher sollten Sie die Größe für das Stamm-UIElement explizit angeben, zumal VisualBrush sein einziges übergeordnetes Objekt ist und es sich deshalb nicht automatisch an den gezeichneten Bereich anpassen kann. Weitere Informationen über Layouts in Windows Presentation Foundation (WPF) finden Sie unter Das Layoutsystem.
Wie ein ImageBrush und ein DrawingBrush streckt ein VisualBrush seinen Inhalt, um den Ausgabebereich auszufüllen. Sie können dieses Verhalten überschreiben, indem Sie die Standardeinstellung Fill der Stretch-Eigenschaft ändern. Weitere Informationen finden Sie in den Ausführungen zur Stretch-Eigenschaft.
Beispiel: Zeichnen eines Objekts mit einem visuellen Element
Im folgenden Beispiel werden mehrere Steuerelemente und ein Bereich verwendet, um ein Rechteck zu zeichnen.
<Rectangle Width="150" Height="150" Stroke="Black" Margin="5,0,5,0">
<Rectangle.Fill>
<VisualBrush>
<VisualBrush.Visual>
<StackPanel Background="White">
<Rectangle Width="25" Height="25" Fill="Red" Margin="2" />
<TextBlock FontSize="10pt" Margin="2">Hello, World!</TextBlock>
<Button Margin="2">A Button</Button>
</StackPanel>
</VisualBrush.Visual>
</VisualBrush>
</Rectangle.Fill>
</Rectangle>
VisualBrush myVisualBrush = new VisualBrush();
// Create the visual brush's contents.
StackPanel myStackPanel = new StackPanel();
myStackPanel.Background = Brushes.White;
Rectangle redRectangle = new Rectangle();
redRectangle.Width = 25;
redRectangle.Height =25;
redRectangle.Fill = Brushes.Red;
redRectangle.Margin = new Thickness(2);
myStackPanel.Children.Add(redRectangle);
TextBlock someText = new TextBlock();
FontSizeConverter myFontSizeConverter = new FontSizeConverter();
someText.FontSize = (double)myFontSizeConverter.ConvertFrom("10pt");
someText.Text = "Hello, World!";
someText.Margin = new Thickness(2);
myStackPanel.Children.Add(someText);
Button aButton = new Button();
aButton.Content = "A Button";
aButton.Margin = new Thickness(2);
myStackPanel.Children.Add(aButton);
// Use myStackPanel as myVisualBrush's content.
myVisualBrush.Visual = myStackPanel;
// Create a rectangle to paint.
Rectangle myRectangle = new Rectangle();
myRectangle.Width = 150;
myRectangle.Height = 150;
myRectangle.Stroke = Brushes.Black;
myRectangle.Margin = new Thickness(5,0,5,0);
// Use myVisualBrush to paint myRectangle.
myRectangle.Fill = myVisualBrush;
Beispiel: Erstellen einer Reflektion
Im vorherigen Beispiel wurde veranschaulicht, wie ein neues Visual zur Verwendung als Hintergrund erstellt wird. Sie können mit einem VisualBrush auch vorhandene visuelle Elemente anzeigen. Durch diese Funktion lassen sich interessante visuelle Effekte wie Reflektionen und Vergrößerungen darstellen. Im folgenden Beispiel wird mit VisualBrush eine Reflektion von Border erstellt, die mehrere Elemente enthält. In der folgenden Abbildung ist die von diesem Beispiel erstellte Ausgabe dargestellt.
Ein reflektiertes visuelles Objekt
.jpg)
using System;
using System.Windows;
using System.Windows.Data;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Effects;
using System.Windows.Media.Imaging;
using System.IO;
using System.Collections.ObjectModel;
using System.Windows.Shapes;
namespace SDKSample
{
public partial class ReflectionExample : Page
{
public ReflectionExample()
{
// Create a name scope for the page.
NameScope.SetNameScope(this, new NameScope());
this.Background = Brushes.Black;
StackPanel myStackPanel = new StackPanel();
myStackPanel.Margin = new Thickness(50);
Border myReflectedBorder = new Border();
this.RegisterName("ReflectedVisual", myReflectedBorder);
// Create a gradient background for the border.
GradientStop firstStop = new GradientStop();
firstStop.Offset = 0.0;
Color firstStopColor = new Color();
firstStopColor.R = 204;
firstStopColor.G = 204;
firstStopColor.B = 255;
firstStopColor.A = 255;
firstStop.Color = firstStopColor;
GradientStop secondStop = new GradientStop();
secondStop.Offset = 1.0;
secondStop.Color = Colors.White;
GradientStopCollection myGradientStopCollection = new GradientStopCollection();
myGradientStopCollection.Add(firstStop);
myGradientStopCollection.Add(secondStop);
LinearGradientBrush myLinearGradientBrush = new LinearGradientBrush();
myLinearGradientBrush.StartPoint = new Point(0, 0.5);
myLinearGradientBrush.EndPoint = new Point(1, 0.5);
myLinearGradientBrush.GradientStops = myGradientStopCollection;
myReflectedBorder.Background = myLinearGradientBrush;
// Add contents to the border.
StackPanel borderStackPanel = new StackPanel();
borderStackPanel.Orientation = Orientation.Horizontal;
borderStackPanel.Margin = new Thickness(10);
TextBlock myTextBlock = new TextBlock();
myTextBlock.TextWrapping = TextWrapping.Wrap;
myTextBlock.Width = 200;
myTextBlock.Text = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit." +
" Suspendisse vel ante. Donec luctus tortor sit amet est." +
" Nullam pulvinar odio et wisi." +
" Pellentesque quis magna. Sed pellentesque." +
" Nulla euismod." +
"Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.";
borderStackPanel.Children.Add(myTextBlock);
StackPanel ellipseStackPanel = new StackPanel();
Ellipse ellipse1 = new Ellipse();
ellipse1.Margin = new Thickness(10);
ellipse1.Height = 50;
ellipse1.Width = 50;
ellipse1.Fill = Brushes.Black;
ellipseStackPanel.Children.Add(ellipse1);
Ellipse ellipse2 = new Ellipse();
ellipse2.Margin = new Thickness(10);
ellipse2.Height = 50;
ellipse2.Width = 50;
ellipse2.Fill = Brushes.Black;
ellipseStackPanel.Children.Add(ellipse2);
Ellipse ellipse3 = new Ellipse();
ellipse3.Margin = new Thickness(10);
ellipse3.Height = 50;
ellipse3.Width = 50;
ellipse3.Fill = Brushes.Black;
ellipseStackPanel.Children.Add(ellipse3);
borderStackPanel.Children.Add(ellipseStackPanel);
myReflectedBorder.Child = borderStackPanel;
// Create divider rectangle
Rectangle dividerRectangle = new Rectangle();
dividerRectangle.Height = 1;
dividerRectangle.Fill = Brushes.Gray;
dividerRectangle.HorizontalAlignment = HorizontalAlignment.Stretch;
// Create the object to contain the reflection.
Rectangle reflectionRectangle = new Rectangle();
// Bind the height of the rectangle to the border height.
Binding heightBinding = new Binding();
heightBinding.ElementName = "ReflectedVisual";
heightBinding.Path = new PropertyPath(Rectangle.HeightProperty);
BindingOperations.SetBinding(reflectionRectangle, Rectangle.HeightProperty, heightBinding);
// Bind the width of the rectangle to the border width.
Binding widthBinding = new Binding();
widthBinding.ElementName = "ReflectedVisual";
widthBinding.Path = new PropertyPath(Rectangle.WidthProperty);
BindingOperations.SetBinding(reflectionRectangle, Rectangle.WidthProperty, widthBinding);
// Creates the reflection.
VisualBrush myVisualBrush = new VisualBrush();
myVisualBrush.Opacity = 0.75;
myVisualBrush.Stretch = Stretch.None;
Binding reflectionBinding = new Binding();
reflectionBinding.ElementName = "ReflectedVisual";
BindingOperations.SetBinding(myVisualBrush, VisualBrush.VisualProperty, reflectionBinding);
ScaleTransform myScaleTransform = new ScaleTransform();
myScaleTransform.ScaleX = 1;
myScaleTransform.ScaleY = -1;
TranslateTransform myTranslateTransform = new TranslateTransform();
myTranslateTransform.Y = 1;
TransformGroup myTransformGroup = new TransformGroup();
myTransformGroup.Children.Add(myScaleTransform);
myTransformGroup.Children.Add(myTranslateTransform);
myVisualBrush.RelativeTransform = myTransformGroup;
reflectionRectangle.Fill = myVisualBrush;
// Create a gradient background for the border.
GradientStop firstStop2 = new GradientStop();
firstStop2.Offset = 0.0;
Color c1 = new Color();
c1.R = 0;
c1.G = 0;
c1.B = 0;
c1.A = 255;
firstStop2.Color = c1;
GradientStop secondStop2 = new GradientStop();
secondStop2.Offset = 0.5;
Color c2 = new Color();
c2.R = 0;
c2.G = 0;
c2.B = 0;
c2.A = 51;
firstStop2.Color = c2;
GradientStop thirdStop = new GradientStop();
thirdStop.Offset = 0.75;
Color c3 = new Color();
c3.R = 0;
c3.G = 0;
c3.B = 0;
c3.A = 0;
thirdStop.Color = c3;
GradientStopCollection myGradientStopCollection2 = new GradientStopCollection();
myGradientStopCollection2.Add(firstStop2);
myGradientStopCollection2.Add(secondStop2);
myGradientStopCollection2.Add(thirdStop);
LinearGradientBrush myLinearGradientBrush2 = new LinearGradientBrush();
myLinearGradientBrush2.StartPoint = new Point(0.5, 0);
myLinearGradientBrush2.EndPoint = new Point(0.5, 1);
myLinearGradientBrush2.GradientStops = myGradientStopCollection2;
reflectionRectangle.OpacityMask = myLinearGradientBrush2;
BlurBitmapEffect myBlurBitmapEffect = new BlurBitmapEffect();
myBlurBitmapEffect.Radius = 1.5;
reflectionRectangle.BitmapEffect = myBlurBitmapEffect;
myStackPanel.Children.Add(myReflectedBorder);
myStackPanel.Children.Add(dividerRectangle);
myStackPanel.Children.Add(reflectionRectangle);
this.Content = myStackPanel;
}
/*
<Rectangle
Height="{Binding Path=ActualHeight, ElementName=ReflectedVisual}"
Width="{Binding Path=ActualWidth, ElementName=ReflectedVisual}">
<Rectangle.OpacityMask>
<LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
<GradientStop Color="#FF000000" Offset="0.0" />
<GradientStop Color="#33000000" Offset="0.5" />
<GradientStop Color="#00000000" Offset="0.75" />
</LinearGradientBrush>
</Rectangle.OpacityMask>
<Rectangle.BitmapEffect>
<BlurBitmapEffect Radius="1.5" />
</Rectangle.BitmapEffect>
</Rectangle>
</StackPanel>
</Page>
*/
}
}
<Page
xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
Background="Black">
<StackPanel Margin="50">
<!-- The object to reflect. -->
<Border Name="ReflectedVisual" Width="400">
<Border.Background>
<LinearGradientBrush StartPoint="0,0.5" EndPoint="1,0.5">
<GradientStop Offset="0.0" Color="#CCCCFF" />
<GradientStop Offset="1.0" Color="White" />
</LinearGradientBrush>
</Border.Background>
<StackPanel Orientation="Horizontal" Margin="10">
<TextBlock TextWrapping="Wrap" Width="200" Margin="10">
Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Suspendisse vel ante. Donec luctus tortor sit amet est.
Nullam pulvinar odio et wisi.
Pellentesque quis magna. Sed pellentesque.
Nulla euismod.
Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.
</TextBlock>
<StackPanel>
<Ellipse Margin="10" Height="50" Width="50" Fill="Black" />
<Ellipse Margin="10" Height="50" Width="50" Fill="Black" />
<Ellipse Margin="10" Height="50" Width="50" Fill="Black" />
</StackPanel>
</StackPanel>
</Border>
<Rectangle Height="1" Fill="Gray" HorizontalAlignment="Stretch" />
<!-- The object to contain the reflection.-->
<Rectangle
Height="{Binding Path=ActualHeight, ElementName=ReflectedVisual}"
Width="{Binding Path=ActualWidth, ElementName=ReflectedVisual}">
<Rectangle.Fill>
<!-- Creates the reflection. -->
<VisualBrush
Opacity="0.75" Stretch="None"
Visual="{Binding ElementName=ReflectedVisual}">
<VisualBrush.RelativeTransform>
<!-- Flip the reflection. -->
<TransformGroup>
<ScaleTransform ScaleX="1" ScaleY="-1" />
<TranslateTransform Y="1" />
</TransformGroup>
</VisualBrush.RelativeTransform>
</VisualBrush>
</Rectangle.Fill>
<Rectangle.OpacityMask>
<LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
<GradientStop Color="#FF000000" Offset="0.0" />
<GradientStop Color="#33000000" Offset="0.5" />
<GradientStop Color="#00000000" Offset="0.75" />
</LinearGradientBrush>
</Rectangle.OpacityMask>
<Rectangle.BitmapEffect>
<BlurBitmapEffect Radius="1.5" />
</Rectangle.BitmapEffect>
</Rectangle>
</StackPanel>
</Page>
Weitere Beispiele zur Vergrößerung von Bildschirmbereichen und zur Erstellung von Reflektionen finden Sie unter Beispiel zu VisualBrush.
TileBrush-Features
ImageBrush, DrawingBrush und VisualBrush sind TileBrush-Objekttypen. TileBrush-Objekte bieten Ihnen umfangreiche Steuerungsmöglichkeiten beim Zeichnen eines Bereichs mit einem Bild, einer Zeichnung oder einem visuellen Element. Sie können beispielsweise zum Zeichnen eines Bereichs anstelle eines einzelnen gestreckten Bilds eine Reihe von Bildkacheln verwenden, die ein Muster ergeben.
Ein TileBrush verfügt über drei primäre Komponenten: Inhalt, Kacheln und Ausgabebereich.
Komponenten eines TileBrush mit einer einzelnen Kachel
.png)
Komponenten eines TileBrush mit mehreren Kacheln
.png)
Weitere Informationen über das Kacheln von TileBrush-Objekten finden Sie unter Übersicht über TileBrush.
Siehe auch
Aufgaben
Konzepte
Übersicht über die Bildverarbeitung
Übersicht über Zeichnungsobjekte
Übersicht über Durchlässigkeitsmasken
Übersicht über das Grafikrendering in Windows Presentation Foundation