Overzicht van WPF Graphics Rendering

Dit onderwerp bevat een overzicht van de WPF-visuallaag. Het richt zich op de rol van de Visual klasse voor renderingondersteuning in het WPF-model.

Rol van het visuele object

De Visual klasse is de basisabstractie waaruit elk FrameworkElement object is afgeleid. Het fungeert ook als toegangspunt voor het schrijven van nieuwe besturingselementen in WPF, en op veel manieren kan worden beschouwd als de venstergreep (HWND) in het Win32-toepassingsmodel.

Het Visual-object is een WPF-kernobject, waarvan de primaire rol is om renderingondersteuning te bieden. Besturingselementen voor de gebruikersinterface, zoals Button en TextBox, zijn afgeleid van de Visual-klasse en gebruiken deze om hun renderinggegevens te bewaren. Het Visual object biedt ondersteuning voor:

• Uitvoerweergave: De persistente, geserialiseerde tekeninhoud van een visual weergeven.

• Transformaties: transformaties uitvoeren op een visual.

• Clippen: Het ondersteunen van het clippen van een regio voor een visual.

• Hittests: Bepalen of een coördinaat of geometrie zich binnen de grenzen van een visual bevindt.

• Berekeningen van begrenzingsvakken: de begrenzingsrechthoek van een visual bepalen.

Het Visual object bevat echter geen ondersteuning voor niet-renderingfuncties, zoals:

• Gebeurtenisafhandeling

• Indeling

• Stijlen

• Gegevensbinding

• Globalisering

Visual wordt weergegeven als een openbare abstracte klasse waaruit onderliggende klassen moeten worden afgeleid. In de volgende afbeelding ziet u de hiërarchie van de visuele objecten die worden weergegeven in WPF.

DrawingVisual-klasse

De DrawingVisual is een lichtgewicht tekenklasse die wordt gebruikt om vormen, afbeeldingen of tekst weer te geven. Deze klasse wordt als lichtgewicht beschouwd omdat deze geen indeling of gebeurtenisafhandeling biedt, waardoor de runtimeprestaties worden verbeterd. Daarom zijn tekeningen ideaal voor achtergronden en illustraties. Deze DrawingVisual kan worden gebruikt om een aangepast visueel object te maken. Zie Gebruik van DrawingVisual-objectenvoor meer informatie.

Viewport3DVisual-klasse

Het Viewport3DVisual biedt een brug tussen 2D Visual en Visual3D objecten. De Visual3D klasse is de basisklasse voor alle 3D-visuele elementen. U moet voor Viewport3DVisual een Camera waarde en een Viewport waarde definiëren. Met de camera kunt u de scène bekijken. De viewport bepaalt waar de projectie op het 2D-oppervlak wordt geprojecteerd. Zie 3D Graphics Overview voor meer informatie over 3D in WPF.

ContainerVisual-klasse

De ContainerVisual klasse wordt gebruikt als een container voor een verzameling Visual objecten. De DrawingVisual klasse is afgeleid van de ContainerVisual klasse, zodat deze een verzameling visuele objecten kan bevatten.

Inhoud tekenen in visuele objecten

Een Visual object slaat de weergegeven gegevens op als een vectorafbeeldingenlijst. Elk item in de instructielijst vertegenwoordigt een set grafische gegevens op laag niveau en gekoppelde resources in een geserialiseerde indeling. Er zijn vier verschillende typen rendergegevens die tekeninhoud kunnen bevatten.

Inhoudstype tekenen	Beschrijving
Vectorafbeeldingen	Vertegenwoordigt vectorafbeeldingsgegevens en eventuele bijbehorende Brush gegevens en Pen informatie.
Afbeelding	Vertegenwoordigt een afbeelding binnen een regio die is gedefinieerd door een Rect.
Schriftteken	Vertegenwoordigt een tekening die een GlyphRun weergeeft, wat een reeks glyphs is uit een opgegeven lettertypebron. Dit is hoe tekst wordt weergegeven.
Video	Vertegenwoordigt een tekening die video weergeeft.

DrawingContext stelt u in staat om een Visual te vullen met visuele inhoud. Wanneer u de tekenopdrachten van een DrawingContext object gebruikt, slaat u in feite een set rendergegevens op die later door het grafische systeem worden gebruikt. U tekent niet in realtime op het scherm.

Wanneer u een WPF-besturingselement maakt, zoals een Button, genereert het besturingselement impliciet rendergegevens voor het tekenen zelf. Als u bijvoorbeeld de Content eigenschap van het Button besturingselement instelt, wordt een weergaverepresentatie van een glyph opgeslagen.

A Visual beschrijft de inhoud als een of meer Drawing objecten in een DrawingGroup. A DrawingGroup beschrijft ook dekkingsmaskers, transformaties, bitmapeffecten en andere bewerkingen die op de inhoud ervan worden toegepast. DrawingGroup bewerkingen worden toegepast in de volgende volgorde wanneer inhoud wordt weergegeven: OpacityMask, Opacity, BitmapEffect, ClipGeometry, , GuidelineSeten vervolgens Transform.

In de volgende afbeelding ziet u de volgorde waarin DrawingGroup bewerkingen worden toegepast tijdens de renderingreeks.

Volgorde van DrawingGroup-bewerkingen

Zie Overzicht van tekenobjecten voor meer informatie.

Inhoud tekenen op de visuallaag

Je instantieert nooit rechtstreeks een DrawingContext; je kunt echter een tekencontext verkrijgen van bepaalde methoden zoals DrawingGroup.Open en DrawingVisual.RenderOpen. Het volgende voorbeeld haalt een DrawingContext op uit een DrawingVisual en gebruikt het om een rechthoek te tekenen.

// Create a DrawingVisual that contains a rectangle.
private DrawingVisual CreateDrawingVisualRectangle()
{
    DrawingVisual drawingVisual = new DrawingVisual();

    // Retrieve the DrawingContext in order to create new drawing content.
    DrawingContext drawingContext = drawingVisual.RenderOpen();

    // Create a rectangle and draw it in the DrawingContext.
    Rect rect = new Rect(new System.Windows.Point(160, 100), new System.Windows.Size(320, 80));
    drawingContext.DrawRectangle(System.Windows.Media.Brushes.LightBlue, (System.Windows.Media.Pen)null, rect);

    // Persist the drawing content.
    drawingContext.Close();

    return drawingVisual;
}

' Create a DrawingVisual that contains a rectangle.
Private Function CreateDrawingVisualRectangle() As DrawingVisual
    Dim drawingVisual As New DrawingVisual()

    ' Retrieve the DrawingContext in order to create new drawing content.
    Dim drawingContext As DrawingContext = drawingVisual.RenderOpen()

    ' Create a rectangle and draw it in the DrawingContext.
    Dim rect As New Rect(New Point(160, 100), New Size(320, 80))
    drawingContext.DrawRectangle(Brushes.LightBlue, CType(Nothing, Pen), rect)

    ' Persist the drawing content.
    drawingContext.Close()

    Return drawingVisual
End Function

Tekeninginhoud op de visuallaag opsommen

Naast andere toepassingen bieden Drawing objecten ook een objectmodel voor het inventariseren van de inhoud van een Visual.

Opmerking

Wanneer u bezig bent met het opsommen van de inhoud van de visuele component, haalt u Drawing objecten op, en niet de onderliggende representatie van de rendergegevens als een instructielijst voor vectorgraphics.

In het volgende voorbeeld wordt de methode GetDrawing gebruikt om de DrawingGroup waarde van een Visual op te halen en op te sommen.

public void RetrieveDrawing(Visual v)
{
    DrawingGroup drawingGroup = VisualTreeHelper.GetDrawing(v);
    EnumDrawingGroup(drawingGroup);
}

// Enumerate the drawings in the DrawingGroup.
public void EnumDrawingGroup(DrawingGroup drawingGroup)
{
    DrawingCollection dc = drawingGroup.Children;

    // Enumerate the drawings in the DrawingCollection.
    foreach (Drawing drawing in dc)
    {
        // If the drawing is a DrawingGroup, call the function recursively.
        if (drawing is DrawingGroup group)
        {
            EnumDrawingGroup(group);
        }
        else if (drawing is GeometryDrawing)
        {
            // Perform action based on drawing type.
        }
        else if (drawing is ImageDrawing)
        {
            // Perform action based on drawing type.
        }
        else if (drawing is GlyphRunDrawing)
        {
            // Perform action based on drawing type.
        }
        else if (drawing is VideoDrawing)
        {
            // Perform action based on drawing type.
        }
    }
}

Hoe visuele objecten worden gebruikt om besturingselementen te bouwen

Veel van de objecten in WPF bestaan uit andere visuele objecten, wat betekent dat ze verschillende hiërarchieën van onderliggende objecten kunnen bevatten. Veel van de elementen van de gebruikersinterface in WPF, zoals besturingselementen, bestaan uit meerdere visuele objecten, die verschillende typen renderingelementen vertegenwoordigen. Het besturingselement kan bijvoorbeeld Button een aantal andere objecten bevatten, waaronder ClassicBorderDecorator, ContentPresenteren TextBlock.

De volgende code toont een Button controle die is gedefinieerd in markup.

<Button Click="OnClick">OK</Button>

Als u de visuele objecten opsommen die deel uitmaken van het standaardbesturingselement Button , vindt u de hiërarchie van visuele objecten die hieronder worden geïllustreerd:

Het Button besturingselement bevat een ClassicBorderDecorator element, dat op zijn beurt een ContentPresenter element bevat. Het ClassicBorderDecorator element is verantwoordelijk voor het tekenen van een rand en een achtergrond voor de Button. Het ContentPresenter element is verantwoordelijk voor het weergeven van de inhoud van de Button. Omdat u tekst weergeeft, bevat het ContentPresenter element in dit geval een TextBlock element. Het feit dat het Button-besturingselement een ContentPresenter gebruikt, betekent dat de inhoud kan worden weergegeven door andere elementen, zoals een Image of een geometrie als een EllipseGeometry.

Besturingselementsjablonen

De sleutel tot de uitbreiding van een besturingselement in een hiërarchie van besturingselementen is de ControlTemplate. Een sjabloon voor een besturingselement specificeert de standaard visuele hiërarchie voor een besturingselement. Wanneer u expliciet naar een besturingselement verwijst, verwijst u impliciet naar de visuele hiërarchie. U kunt de standaardwaarden voor een besturingssjabloon overschrijven om een aangepast uiterlijk van een besturingselement te maken. U kunt bijvoorbeeld de achtergrondkleurwaarde van het Button besturingselement wijzigen, zodat er een lineaire kleurovergangswaarde wordt gebruikt in plaats van een effen kleurwaarde. Zie Knopstijlen en -sjablonen voor meer informatie.

Een element van de gebruikersinterface, zoals een Button bedieningselement, bevat verschillende instructielijsten voor vectorgraphics die de volledige renderingdefinitie van een bedieningselement beschrijven. De volgende code toont een Button controle die is gedefinieerd in markup.

<Button Click="OnClick">
  <Image Source="images\greenlight.jpg"></Image>
</Button>

Als u de visuele objecten en vectorafbeeldingen opsommen die deel uitmaken van het Button besturingselement, vindt u de onderstaande hiërarchie van objecten:

Het Button besturingselement bevat een ClassicBorderDecorator element, dat op zijn beurt een ContentPresenter element bevat. Het ClassicBorderDecorator element is verantwoordelijk voor het tekenen van alle discrete grafische elementen waaruit de rand en de achtergrond van een knop bestaan. Het ContentPresenter element is verantwoordelijk voor het weergeven van de inhoud van de Button. Omdat u een afbeelding weergeeft, bevat het ContentPresenter element in dit geval een Image element.

Er zijn een aantal punten om op te merken over de hiërarchie van visuele objecten en vectorgrafische instructielijsten.

• De volgorde in de hiërarchie vertegenwoordigt de weergavevolgorde van de tekengegevens. Vanuit het wortelvisuelelement worden de onderliggende elementen doorlopen, van links naar rechts, van boven naar beneden. Als een element visuele onderliggende elementen bevat, worden deze doorkruist vóór de broers en zussen van het element.

• Niet-bladknooppuntelementen in de hiërarchie, zoals ContentPresenter, worden gebruikt om onderliggende elementen te bevatten. Ze bevatten geen instructielijsten.

• Als een visueel element zowel een instructielijst voor vectorafbeeldingen als visuele onderliggende elementen bevat, wordt de instructielijst in het bovenliggende visuele element weergegeven voordat tekeningen in een van de onderliggende objecten van de visual worden weergegeven.

• De items in de instructielijst voor vectorafbeeldingen worden van links naar rechts weergegeven.

Visuele structuur

De visuele boom bevat alle visuele elementen die worden gebruikt in de gebruikersinterface van een applicatie. Aangezien een visueel element persistente tekengegevens bevat, kunt u de visuele structuur beschouwen als een scènegrafiek met alle renderinggegevens die nodig zijn om de uitvoer op te stellen op het weergaveapparaat. Deze boom is de verzameling van alle visuele elementen die rechtstreeks door de toepassing zijn gemaakt, hetzij in code of in markup. De visuele boom bevat ook alle visuele elementen die zijn gemaakt door de sjabloonexpansie van elementen zoals controles en gegevensobjecten.

De volgende code toont een StackPanel element dat is gedefinieerd in markeringen.

<StackPanel>
  <Label>User name:</Label>
  <TextBox />
  <Button Click="OnClick">OK</Button>
</StackPanel>

Als u de visuele objecten opsommen die deel uitmaken van het StackPanel element in het opmaakvoorbeeld, vindt u de hiërarchie van visuele objecten die hieronder worden geïllustreerd:

Weergavevolgorde

De visualstructuur bepaalt de weergavevolgorde van WPF-visuals en tekenobjecten. De volgorde van doorkruising begint met de wortelvisual, het bovenste knooppunt in de visuele boom. De kinderen van de rootvisual worden vervolgens van links naar rechts doorlopen. Als een visueel kinderen heeft, worden de kinderen doorlopen vóór de broers en zussen van het visueel. Dit betekent dat de inhoud van een kindvisual wordt weergegeven vóór de eigen inhoud van de visual zelf.

Hoofdvisual

De basisvisual is het bovenste element in een visuele boomhiërarchie. In de meeste toepassingen is de basisklasse van de hoofdvisual Window of NavigationWindow. Als u echter visuele objecten host in een Win32-toepassing, is de hoofdvisual de meest relevante visual die u in het Win32-venster host. Zie Zelfstudie: Visual Objects hosten in een Win32-toepassing voor meer informatie.

Relatie met de logische structuur

De logische structuur in WPF vertegenwoordigt de elementen van een toepassing tijdens runtime. Hoewel u deze structuur niet rechtstreeks bewerkt, is deze weergave van de toepassing handig voor informatie over overname van eigenschappen en gebeurtenisroutering. In tegenstelling tot de visualstructuur kan de logische structuur niet-visuele gegevensobjecten vertegenwoordigen, zoals ListItem. In veel gevallen komt de logische structuur zeer nauw overeen met de opmaakdefinities van een toepassing. De volgende code toont een DockPanel element dat is gedefinieerd in markeringen.

<DockPanel>
  <ListBox>
    <ListBoxItem>Dog</ListBoxItem>
    <ListBoxItem>Cat</ListBoxItem>
    <ListBoxItem>Fish</ListBoxItem>
  </ListBox>
  <Button Click="OnClick">OK</Button>
</DockPanel>

Als u de logische objecten opsommen die deel uitmaken van het DockPanel element in het opmaakvoorbeeld, vindt u de hiërarchie van logische objecten die hieronder worden geïllustreerd:

Diagram van logische structuur

Zowel de visuele boomstructuur als de logische structuur worden gesynchroniseerd met de huidige set toepassingselementen, waarbij alle toevoegingen, verwijderingen of wijzigingen van elementen worden weergegeven. De bomen bieden echter verschillende weergaven van de toepassing. In tegenstelling tot de visualstructuur breidt de logische structuur het element van ContentPresenter een besturingselement niet uit. Dit betekent dat er geen directe een-op-een-correspondentie is tussen een logische boom en een visuele structuur voor dezelfde set objecten. Het aanroepen van de methode van het GetChildren en de methode van het GetChild met hetzelfde element als een parameter levert verschillende resultaten op.

Zie Trees in WPFvoor meer informatie over de logische structuur.

De visualstructuur weergeven met XamlPad

Het WPF-hulpprogramma, XamlPad, biedt een optie voor het weergeven en verkennen van de visuele structuur die overeenkomt met de momenteel gedefinieerde XAML-inhoud. Klik op de knop Visuele structuur weergeven op de menubalk om de visualstructuur weer te geven. Hieronder ziet u de uitbreiding van XAML-inhoud in visuele structuurknooppunten in het deelvenster Visual Tree Explorer van XamlPad:

Merk op hoe de Label, TextBox, en Button bedieningselementen elk een afzonderlijke hiërarchie van visuele objecten weergeven in het deelvenster Visual Tree Explorer van XamlPad. Dit komt doordat WPF-besturingselementen een ControlTemplate hebben die de visuele structuur van dat besturingselement bevat. Wanneer u expliciet naar een besturingselement verwijst, verwijst u impliciet naar de visuele hiërarchie.

Profileren van visuele prestaties

WPF biedt een reeks hulpprogramma's voor prestatieprofilering waarmee u het runtimegedrag van uw toepassing kunt analyseren en de typen prestatieoptimalisaties kunt bepalen die u kunt toepassen. Het hulpprogramma Visual Profiler biedt een uitgebreide, grafische weergave van prestatiegegevens door rechtstreeks aan de visualstructuur van de toepassing te koppelen. In deze schermopname geeft de sectie CPU-gebruik van visual profiler u een nauwkeurige uitsplitsing van het gebruik van WPF-services van een object, zoals rendering en indeling.

De uitvoer van Visual Profiler weergeven

Gedrag van visuele rendering

WPF introduceert verschillende functies die van invloed zijn op het renderinggedrag van visuele objecten: behoudmodusafbeeldingen, vectorafbeeldingen en apparaatonafhankelijke afbeeldingen.

Grafische weergave in de vastgehouden modus

Een van de sleutels voor het begrijpen van de rol van het Visual-object is het verschil tussen de directe modus en de grafische systemen voor de bewaarde modus . Een standaard Win32-toepassing op basis van GDI of GDI+ maakt gebruik van een immediate mode grafisch systeem. Dit betekent dat de applicatie verantwoordelijk is voor het hertekenen van het gedeelte van het clientgebied dat ongeldig is geworden, door een actie zoals het aanpassen van de grootte van een venster of het veranderen van het visuele uiterlijk van een object.

WPF maakt daarentegen gebruik van een systeem voor de bewaarde modus. Dit betekent dat toepassingsobjecten met een visueel uiterlijk een set geserialiseerde tekengegevens definiëren. Zodra de tekeninggegevens zijn gedefinieerd, is het systeem vervolgens verantwoordelijk voor het reageren op alle herhalingsaanvragen voor het weergeven van de toepassingsobjecten. Zelfs tijdens runtime kunt u toepassingsobjecten wijzigen of maken en nog steeds vertrouwen op het systeem om te reageren op verfaanvragen. De kracht van een grafisch systeem in de behouden modus is dat tekeninformatie altijd door de applicatie wordt opgeslagen in een geserialiseerde staat, maar dat de verantwoordelijkheid voor het renderen bij het systeem ligt. In het volgende diagram ziet u hoe de toepassing afhankelijk is van WPF voor het reageren op verfaanvragen.

Intelligent opnieuw tekenen

Een van de grootste voordelen van het gebruik van afbeeldingen in de bewaarde modus is dat WPF efficiënt kan optimaliseren wat er opnieuw moet worden getekend in de toepassing. Zelfs als u een complexe scène hebt met verschillende niveaus van dekking, hoeft u in het algemeen geen speciale code te schrijven om het opnieuw tekenen te optimaliseren. Vergelijk dit met Win32-programmering waarin u veel moeite kunt besteden aan het optimaliseren van uw toepassing door de hoeveelheid hertekening in de updateregio te minimaliseren. Zie Opnieuw tekenen in de updateregio voor een voorbeeld van het type complexiteit dat is betrokken bij het optimaliseren van opnieuw tekenen in Win32-toepassingen.

Vectorafbeeldingen

WPF maakt gebruik van vectorafbeeldingen als renderinggegevensindeling. Vectorafbeeldingen, waaronder Scalable Vector Graphics (SVG), Windows-metabestanden (.wmf) en TrueType-lettertypen, slaan renderinggegevens op en verzenden deze als een lijst met instructies waarin wordt beschreven hoe u een afbeelding opnieuw maakt met behulp van grafische primitieven. TrueType-lettertypen zijn bijvoorbeeld overzichtslettertypen die een reeks lijnen, curven en opdrachten beschrijven, in plaats van een matrix met pixels. Een van de belangrijkste voordelen van vectorafbeeldingen is de mogelijkheid om te schalen naar elke grootte en resolutie.

In tegenstelling tot vectorafbeeldingen slaan bitmapafbeeldingen renderinggegevens op als een pixel-by-pixelweergave van een afbeelding, vooraf gerenderd voor een specifieke resolutie. Een van de belangrijkste verschillen tussen bitmap- en vectorafbeeldingsindelingen is betrouwbaarheid van de oorspronkelijke bronafbeelding. Wanneer de grootte van een bronafbeelding bijvoorbeeld wordt gewijzigd, rekken bitmapafbeeldingssystemen de afbeelding uit, terwijl vectorgrafische systemen de afbeelding schalen, waardoor de beeldkwaliteit van de afbeelding behouden blijft.

In de volgende afbeelding ziet u een bronafbeelding die met 300%is verkleind. Let op de vervormingen die optreden wanneer de bronafbeelding wordt uitgerekt als een bitmapafbeelding in plaats van geschaald als een vectorafbeelding.

In de volgende markeringen ziet u twee Path gedefinieerde elementen. Het tweede element gebruikt een ScaleTransform om de tekeninstructies van het eerste element met 300%te vergroten. U ziet dat de tekeninstructies in de Path elementen ongewijzigd blijven.

<Path
  Data="M10,100 C 60,0 100,200 150,100 z"
  Fill="{StaticResource linearGradientBackground}"
  Stroke="Black"
  StrokeThickness="2" />

<Path
  Data="M10,100 C 60,0 100,200 150,100 z"
  Fill="{StaticResource linearGradientBackground}"
  Stroke="Black"
  StrokeThickness="2" >
  <Path.RenderTransform>
    <ScaleTransform ScaleX="3.0" ScaleY="3.0" />
  </Path.RenderTransform>
</Path>

Over resolutie en Device-Independent grafische elementen

Er zijn twee systeemfactoren die de grootte van tekst en afbeeldingen op uw scherm bepalen: resolutie en DPI. Resolutie beschrijft het aantal pixels dat op het scherm wordt weergegeven. Naarmate de resolutie hoger wordt, worden pixels kleiner, waardoor afbeeldingen en tekst kleiner worden weergegeven. Een afbeelding die op een monitor wordt weergegeven op 1024 x 768, wordt veel kleiner weergegeven wanneer de resolutie wordt gewijzigd in 1600 x 1200.

De andere systeeminstelling, DPI, geeft de grootte van een scherminch in pixels weer. De meeste Windows-systemen hebben een DPI van 96, wat betekent dat een scherm inch 96 pixels is. Als u de DPI-instelling verhoogt, wordt het scherm groter; als u de DPI verlaagt, wordt het scherm kleiner. Dit betekent dat een scherm inch niet dezelfde grootte heeft als een echte inch; op de meeste systemen is dat waarschijnlijk niet zo. Wanneer u de DPI verhoogt, worden dpi-bewuste afbeeldingen en tekst groter omdat u de grootte van de scherm inch hebt vergroot. Door de DPI te vergroten, kunt u tekst beter leesbaar maken, met name bij hoge resoluties.

Niet alle toepassingen zijn DPI-bewust: sommige gebruiken hardware pixels als de primaire maateenheid; het wijzigen van de systeem-DPI heeft geen effect op deze toepassingen. Veel andere toepassingen gebruiken DPI-compatibele eenheden om tekengrootten te beschrijven, maar gebruik pixels om alles te beschrijven. Door de DPI te klein of te groot te maken, kunnen indelingsproblemen voor deze toepassingen optreden, omdat de tekstschaal van de toepassing wordt aangepast met de DPI-instelling van het systeem, maar de gebruikersinterface van de toepassingen niet. Dit probleem is geëlimineerd voor toepassingen die zijn ontwikkeld met WPF.

WPF ondersteunt automatisch schalen met behulp van de onafhankelijke pixel van het apparaat als de primaire maateenheid, in plaats van hardware pixels; afbeeldingen en tekst worden correct geschaald zonder extra werk van de toepassingsontwikkelaar. In de volgende afbeelding ziet u een voorbeeld van hoe WPF-tekst en -afbeeldingen worden weergegeven in verschillende DPI-instellingen.

Afbeeldingen en tekst bij verschillende DPI-instellingen

VisualTreeHelper-klasse

De VisualTreeHelper klasse is een statische helperklasse die functionaliteit op laag niveau biedt voor programmeren op het niveau van het visuele object, wat handig is in zeer specifieke scenario's, zoals het ontwikkelen van aangepaste besturingselementen met hoge prestaties. In de meeste gevallen bieden de WPF-frameworkobjecten op een hoger niveau, zoals Canvas en TextBlock, meer flexibiliteit en gebruiksgemak.

Raaktest

De VisualTreeHelper klasse biedt methoden voor het testen van treffers op visuele objecten wanneer de standaardondersteuning voor hittests niet aan uw behoeften voldoet. U kunt de HitTest methoden in de VisualTreeHelper klasse gebruiken om te bepalen of een geometrie- of puntcoördinaatwaarde zich binnen de grens van een bepaald object bevindt, zoals een besturingselement of grafisch element. U kunt bijvoorbeeld hittests gebruiken om te bepalen of een muisklik binnen de begrenzingsrechthoek van een object binnen de geometrie van een cirkel valt. U kunt er ook voor kiezen om de standaard implementatie van hittests te overschrijven om uw eigen aangepaste hittestberekeningen uit te voeren.

Zie Hit Testing in de visuallaag voor meer informatie over hit testing.

De visualstructuur opsommen

De VisualTreeHelper klasse biedt functionaliteit voor het inventariseren van de elementen van een visuele boom. Als u een ouder wilt ophalen, roept u de GetParent-methode aan. Om een kindobject of directe afstammeling van een visueel object op te halen, roept u de GetChild method aan. Deze methode retourneert een onderliggend element Visual van het bovenliggende item in de opgegeven index.

In het volgende voorbeeld ziet u hoe u alle afstammelingen van een visueel object opsommen. Dit is een techniek die u mogelijk wilt gebruiken als u geïnteresseerd was in het serialiseren van alle renderinginformatie van een visuele objecthiërarchie.

// Enumerate all the descendants of the visual object.
static public void EnumVisual(Visual myVisual)
{
    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(myVisual); i++)
    {
        // Retrieve child visual at specified index value.
        Visual childVisual = (Visual)VisualTreeHelper.GetChild(myVisual, i);

        // Do processing of the child visual object.

        // Enumerate children of the child visual object.
        EnumVisual(childVisual);
    }
}

' Enumerate all the descendants of the visual object.
Public Shared Sub EnumVisual(ByVal myVisual As Visual)
    For i As Integer = 0 To VisualTreeHelper.GetChildrenCount(myVisual) - 1
        ' Retrieve child visual at specified index value.
        Dim childVisual As Visual = CType(VisualTreeHelper.GetChild(myVisual, i), Visual)

        ' Do processing of the child visual object.

        ' Enumerate children of the child visual object.
        EnumVisual(childVisual)
    Next i
End Sub

In de meeste gevallen is de logische structuur een nuttigere weergave van de elementen in een WPF-toepassing. Hoewel u de logische structuur niet rechtstreeks wijzigt, is deze weergave van de toepassing handig voor informatie over overname van eigenschappen en gebeurtenisroutering. In tegenstelling tot de visualstructuur kan de logische structuur niet-visuele gegevensobjecten vertegenwoordigen, zoals ListItem. Zie Trees in WPFvoor meer informatie over de logische structuur.

De VisualTreeHelper klasse biedt methoden voor het retourneren van de begrenzingsrechthoek van visuele objecten. U kunt de begrenzingsrechthoek van een visueel object retourneren door aan te roepen GetContentBounds. U kunt de begrenzingsrechthoek van alle afstammelingen van een visueel object, inclusief het visuele object zelf, retourneren door het aan te roepen GetDescendantBounds. De volgende code laat zien hoe u de begrenzingsrechthoek van een visueel object en alle onderliggende objecten ervan berekent.

// Return the bounding rectangle of the parent visual object and all of its descendants.
Rect rectBounds = VisualTreeHelper.GetDescendantBounds(parentVisual);

' Return the bounding rectangle of the parent visual object and all of its descendants.
Dim rectBounds As Rect = VisualTreeHelper.GetDescendantBounds(parentVisual)

Zie ook

• Visual
• VisualTreeHelper
• DrawingVisual
• 2D Grafische weergave en beeldvorming
• Hit Testing in de visuele laag
• DrawingVisual-objecten gebruiken
• Zelfstudie: Visuele objecten hosten in een Win32-toepassing
• WPF-toepassingsprestaties optimaliseren