Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Stroomdocumenten zijn ontworpen om de weergave en leesbaarheid te optimaliseren. In plaats van op één vooraf gedefinieerde indeling te worden ingesteld, passen stroomdocumenten hun inhoud dynamisch aan en herstromen op basis van runtimevariabelen, zoals venstergrootte, apparaatresolutie en optionele gebruikersvoorkeuren. Daarnaast bieden stroomdocumenten geavanceerde documentfuncties, zoals paginering en kolommen. In dit onderwerp vindt u een overzicht van stroomdocumenten en hoe u deze kunt maken.
Wat is een stroomdocument?
Een stroomdocument is ontworpen om inhoud opnieuw te laten stromen, afhankelijk van de grootte van het venster, de apparaatresolutie en andere omgevingsvariabelen. Daarnaast hebben stroomdocumenten een aantal ingebouwde functies, waaronder zoeken, weergavemodi die de leesbaarheid optimaliseren en de mogelijkheid om de grootte en het uiterlijk van lettertypen te wijzigen. Flow-documenten worden het beste gebruikt wanneer gemakkelijk lezen het primaire scenario voor documentgebruik is. Vaste documenten zijn daarentegen ontworpen voor een statische presentatie. Vaste documenten zijn handig wanneer betrouwbaarheid van de broninhoud essentieel is. Zie Documenten in WPF voor meer informatie over verschillende typen documenten.
In de volgende afbeelding ziet u een voorbeeld van een stroomdocument dat in verschillende vensters van verschillende grootten wordt weergegeven. Naarmate het weergavegebied verandert, wordt de inhoud opnieuw aangepast om optimaal gebruik te maken van de beschikbare ruimte.
Zoals u in de bovenstaande afbeelding ziet, kan stroominhoud veel onderdelen bevatten, waaronder alinea's, lijsten, afbeeldingen en meer. Deze onderdelen komen overeen met elementen in markeringen en objecten in procedurele code. Deze klassen worden verderop in de sectie Gerelateerde stroomklassen van dit overzicht uitgebreid besproken. Hier volgt nu een eenvoudig codevoorbeeld waarmee een stroomdocument wordt gemaakt dat bestaat uit een alinea met vetgedrukte tekst en een lijst.
<!-- This simple flow document includes a paragraph with some
bold text in it and a list. -->
<FlowDocumentReader xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<FlowDocument>
<Paragraph>
<Bold>Some bold text in the paragraph.</Bold>
Some text that is not bold.
</Paragraph>
<List>
<ListItem>
<Paragraph>ListItem 1</Paragraph>
</ListItem>
<ListItem>
<Paragraph>ListItem 2</Paragraph>
</ListItem>
<ListItem>
<Paragraph>ListItem 3</Paragraph>
</ListItem>
</List>
</FlowDocument>
</FlowDocumentReader>
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
namespace SDKSample
{
public partial class SimpleFlowExample : Page
{
public SimpleFlowExample()
{
Paragraph myParagraph = new Paragraph();
// Add some Bold text to the paragraph
myParagraph.Inlines.Add(new Bold(new Run("Some bold text in the paragraph.")));
// Add some plain text to the paragraph
myParagraph.Inlines.Add(new Run(" Some text that is not bold."));
// Create a List and populate with three list items.
List myList = new List();
// First create paragraphs to go into the list item.
Paragraph paragraphListItem1 = new Paragraph(new Run("ListItem 1"));
Paragraph paragraphListItem2 = new Paragraph(new Run("ListItem 2"));
Paragraph paragraphListItem3 = new Paragraph(new Run("ListItem 3"));
// Add ListItems with paragraphs in them.
myList.ListItems.Add(new ListItem(paragraphListItem1));
myList.ListItems.Add(new ListItem(paragraphListItem2));
myList.ListItems.Add(new ListItem(paragraphListItem3));
// Create a FlowDocument with the paragraph and list.
FlowDocument myFlowDocument = new FlowDocument();
myFlowDocument.Blocks.Add(myParagraph);
myFlowDocument.Blocks.Add(myList);
// Add the FlowDocument to a FlowDocumentReader Control
FlowDocumentReader myFlowDocumentReader = new FlowDocumentReader();
myFlowDocumentReader.Document = myFlowDocument;
this.Content = myFlowDocumentReader;
}
}
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Documents
Namespace SDKSample
Partial Public Class SimpleFlowExample
Inherits Page
Public Sub New()
Dim myParagraph As New Paragraph()
' Add some Bold text to the paragraph
myParagraph.Inlines.Add(New Bold(New Run("Some bold text in the paragraph.")))
' Add some plain text to the paragraph
myParagraph.Inlines.Add(New Run(" Some text that is not bold."))
' Create a List and populate with three list items.
Dim myList As New List()
' First create paragraphs to go into the list item.
Dim paragraphListItem1 As New Paragraph(New Run("ListItem 1"))
Dim paragraphListItem2 As New Paragraph(New Run("ListItem 2"))
Dim paragraphListItem3 As New Paragraph(New Run("ListItem 3"))
' Add ListItems with paragraphs in them.
myList.ListItems.Add(New ListItem(paragraphListItem1))
myList.ListItems.Add(New ListItem(paragraphListItem2))
myList.ListItems.Add(New ListItem(paragraphListItem3))
' Create a FlowDocument with the paragraph and list.
Dim myFlowDocument As New FlowDocument()
myFlowDocument.Blocks.Add(myParagraph)
myFlowDocument.Blocks.Add(myList)
' Add the FlowDocument to a FlowDocumentReader Control
Dim myFlowDocumentReader As New FlowDocumentReader()
myFlowDocumentReader.Document = myFlowDocument
Me.Content = myFlowDocumentReader
End Sub
End Class
End Namespace
In de onderstaande afbeelding ziet u hoe dit codefragment eruitziet.
In dit voorbeeld wordt het FlowDocumentReader besturingselement gebruikt om de stroominhoud te hosten. Zie Flowdocumenttypen voor meer informatie over controls voor het hosten van flowinhoud. Paragraph, List, ListItemen Bold elementen worden gebruikt om inhoudsopmaak te beheren, op basis van hun volgorde in markeringen. Het element beslaat bijvoorbeeld Bold slechts een deel van de tekst in de alinea. Hierdoor wordt alleen dat deel van de tekst vetgedrukt. Als u HTML hebt gebruikt, is dit voor u bekend.
Zoals is gemarkeerd in de bovenstaande afbeelding, zijn er verschillende functies ingebouwd in Stroomdocumenten:
Zoeken: Hiermee kan de gebruiker een zoekopdracht in volledige tekst van een heel document uitvoeren.
Weergavemodus: De gebruiker kan de gewenste weergavemodus selecteren, waaronder een weergavemodus met één pagina (pagina-op-een-tijd), een weergavemodus met twee pagina's tegelijk (leesindeling voor boeken) en een continue weergavemodus (bodemloos). Zie FlowDocumentReaderViewingModevoor meer informatie over deze weergavemodi.
Besturingselementen voor paginanavigatie: als de weergavemodus van het document pagina's gebruikt, bevatten de besturingselementen voor paginanavigatie een knop om naar de volgende pagina (de pijl-omlaag) of vorige pagina (de pijl-omhoog) te gaan, evenals indicatoren voor het huidige paginanummer en het totale aantal pagina's. U kunt ook door pagina's bladeren met behulp van de pijltoetsen op het toetsenbord.
Zoom: Met de zoombesturingselementen kan de gebruiker het zoomniveau vergroten of verkleinen door respectievelijk op de plus- of minknoppen te klikken. De zoombesturingselementen bevatten ook een schuifregelaar voor het aanpassen van het zoomniveau. Zie Zoom voor meer informatie.
Deze functies kunnen worden gewijzigd op basis van het besturingselement dat wordt gebruikt om de stroominhoud te hosten. In de volgende sectie worden de verschillende besturingselementen beschreven.
Stroomdocumenttypen
Weergave van flowdocumentinhoud en hoe deze eruitziet hangt af van het object dat wordt gebruikt om de flowinhoud te bevatten. Er zijn vier besturingselementen die ondersteuning bieden voor het weergeven van stroominhoud: FlowDocumentReader, FlowDocumentPageViewer, RichTextBoxen FlowDocumentScrollViewer. Deze besturingselementen worden hieronder kort beschreven.
Opmerking
FlowDocument is vereist voor het rechtstreeks hosten van stroominhoud, zodat al deze weergavebesturingselementen een FlowDocument verbruiken om het hosten van stroominhoud in te schakelen.
FlowDocumentReader
FlowDocumentReader bevat functies waarmee de gebruiker dynamisch kan kiezen tussen verschillende weergavemodi, waaronder een weergavemodus met één pagina (pagina-op-een-tijd), een weergavemodus met twee pagina's tegelijk (leesindeling voor boeken) en een doorlopende (ondersteloze) weergavemodus. Zie FlowDocumentReaderViewingModevoor meer informatie over deze weergavemodi. Als u niet de mogelijkheid nodig hebt om dynamisch te schakelen tussen verschillende weergavemodi, bieden FlowDocumentPageViewer en FlowDocumentScrollViewer lichtere stroominhoudweergaven die vastzitten in een bepaalde weergavemodus.
FlowDocumentPageViewer en FlowDocumentScrollViewer
FlowDocumentPageViewer toont inhoud in de weergavemodus voor pagina's tegelijk, terwijl FlowDocumentScrollViewer inhoud weergeeft in de modus voor doorlopend schuiven. Zowel FlowDocumentPageViewer als FlowDocumentScrollViewer zijn vastgemaakt aan een bepaalde weergavemodus. Vergelijk met FlowDocumentReader, dat functies bevat waarmee de gebruiker dynamisch kan kiezen tussen verschillende weergavemodi (zoals voorzien door de FlowDocumentReaderViewingMode-opsomming), maar wel meer middelen vergt dan FlowDocumentPageViewer of FlowDocumentScrollViewer.
Standaard wordt er altijd een verticale schuifbalk weergegeven en wordt een horizontale schuifbalk zo nodig zichtbaar. De standaardgebruikersinterface voor FlowDocumentScrollViewer bevat geen werkbalk; De eigenschap IsToolBarVisible kan echter worden gebruikt om een ingebouwde werkbalk in te schakelen.
RichTextBox
U gebruikt een RichTextBox optie als u de gebruiker wilt toestaan stroominhoud te bewerken. Als u bijvoorbeeld een editor wilt maken waarmee een gebruiker zaken zoals tabellen, cursief en vetgedrukt, enzovoort kan bewerken, gebruikt u een RichTextBox. Zie RichTextBox-overzicht voor meer informatie.
Opmerking
Stroominhoud binnen een RichTextBox gedraagt zich niet precies zoals stroominhoud in andere besturingselementen. Er zijn bijvoorbeeld geen kolommen in een RichTextBox en dus geen gedrag voor automatisch herschalen. Bovendien zijn de doorgaans ingebouwde functies van stroominhoud, zoals zoeken, weergavemodus, paginanavigatie en zoom, niet beschikbaar in een RichTextBox.
Flow-inhoud creëren
Stroominhoud kan complex zijn, bestaande uit verschillende elementen, waaronder tekst, afbeeldingen, tabellen en zelfs UIElement afgeleide klassen zoals besturingselementen. Als u wilt weten hoe u complexe stroominhoud maakt, zijn de volgende punten essentieel:
Stroomgerelateerde klassen: elke klasse die wordt gebruikt in stroominhoud heeft een specifiek doel. Daarnaast helpt de hiërarchische relatie tussen stroomklassen u te begrijpen hoe ze worden gebruikt. Klassen die zijn afgeleid van de Block klasse worden bijvoorbeeld gebruikt om andere objecten te bevatten, terwijl klassen die zijn afgeleid van Inline objecten bevatten die worden weergegeven.
Inhoudsschema: Een stroomdocument kan een aanzienlijk aantal geneste elementen vereisen. In het inhoudsschema worden mogelijke bovenliggende/onderliggende relaties tussen elementen opgegeven.
In de volgende secties vindt u meer informatie over elk van deze gebieden.
Stroomgerelateerde klassen
In het onderstaande diagram ziet u de objecten die het meest worden gebruikt met stroominhoud:
Voor de doeleinden van stroominhoud zijn er twee belangrijke categorieën:
Van blokken afgeleide klassen: ook wel 'Blokinhoudselementen' of 'Blokelementen' genoemd. Elementen die overnemen van Block , kunnen worden gebruikt om elementen onder een gemeenschappelijke bovenliggende groep te groeperen of om algemene kenmerken toe te passen op een groep.
Inline-afgeleide klassen: ook wel 'Inline-inhoudselementen' of gewoon 'Inline-elementen' genoemd. Elementen die erven van Inline bevinden zich in een blok-element of een ander inline-element. Inline-elementen worden vaak gebruikt als de directe container met inhoud die op het scherm wordt weergegeven. Bijvoorbeeld, een Paragraph (blokelement) kan een Run (inline-element) bevatten, maar Run bevat daadwerkelijk de tekst die op het scherm wordt weergegeven.
Elke klas in deze twee categorieën wordt hieronder kort beschreven.
Blok-afgeleide klassen
alinea
Paragraph wordt meestal gebruikt om inhoud in een alinea te groeperen. Het eenvoudigste en meest voorkomende gebruik van Alinea is het maken van een alinea met tekst.
<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Paragraph>
Some paragraph text.
</Paragraph>
</FlowDocument>
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
namespace SDKSample
{
public partial class ParagraphExample : Page
{
public ParagraphExample()
{
// Create paragraph with some text.
Paragraph myParagraph = new Paragraph();
myParagraph.Inlines.Add(new Run("Some paragraph text."));
// Create a FlowDocument and add the paragraph to it.
FlowDocument myFlowDocument = new FlowDocument();
myFlowDocument.Blocks.Add(myParagraph);
this.Content = myFlowDocument;
}
}
}
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Documents
Namespace SDKSample
Partial Public Class ParagraphExample
Inherits Page
Public Sub New()
' Create paragraph with some text.
Dim myParagraph As New Paragraph()
myParagraph.Inlines.Add(New Run("Some paragraph text."))
' Create a FlowDocument and add the paragraph to it.
Dim myFlowDocument As New FlowDocument()
myFlowDocument.Blocks.Add(myParagraph)
Me.Content = myFlowDocument
End Sub
End Class
End Namespace
U kunt echter ook andere inline-afgeleide elementen bevatten, zoals hieronder wordt weergegeven.
Afdeling
Section wordt alleen gebruikt om andere Block-afgeleide elementen te bevatten. Er worden geen standaardopmaak toegepast op de elementen die deze bevat. Alle eigenschapswaarden die op een Section eigenschap zijn ingesteld, zijn echter van toepassing op de onderliggende elementen. Met een sectie kunt u ook programmatisch door de onderliggende verzameling doorlopen. Section wordt op een vergelijkbare manier gebruikt als de <DIV-tag> in HTML.
In het onderstaande voorbeeld worden drie alinea's gedefinieerd onder één Section. De sectie heeft een Background eigenschapswaarde Rood, dus de achtergrondkleur van de alinea's is ook rood.
<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<!-- By default, Section applies no formatting to elements contained
within it. However, in this example, the section has a Background
property value of "Red", therefore, the three paragraphs (the block)
inside the section also have a red background. -->
<Section Background="Red">
<Paragraph>
Paragraph 1
</Paragraph>
<Paragraph>
Paragraph 2
</Paragraph>
<Paragraph>
Paragraph 3
</Paragraph>
</Section>
</FlowDocument>
using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Controls;
using System.Windows.Documents;
namespace SDKSample
{
public partial class SectionExample : Page
{
public SectionExample()
{
// Create three paragraphs
Paragraph myParagraph1 = new Paragraph(new Run("Paragraph 1"));
Paragraph myParagraph2 = new Paragraph(new Run("Paragraph 2"));
Paragraph myParagraph3 = new Paragraph(new Run("Paragraph 3"));
// Create a Section and add the three paragraphs to it.
Section mySection = new Section();
mySection.Background = Brushes.Red;
mySection.Blocks.Add(myParagraph1);
mySection.Blocks.Add(myParagraph2);
mySection.Blocks.Add(myParagraph3);
// Create a FlowDocument and add the section to it.
FlowDocument myFlowDocument = new FlowDocument();
myFlowDocument.Blocks.Add(mySection);
this.Content = myFlowDocument;
}
}
}
Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents
Namespace SDKSample
Partial Public Class SectionExample
Inherits Page
Public Sub New()
' Create three paragraphs
Dim myParagraph1 As New Paragraph(New Run("Paragraph 1"))
Dim myParagraph2 As New Paragraph(New Run("Paragraph 2"))
Dim myParagraph3 As New Paragraph(New Run("Paragraph 3"))
' Create a Section and add the three paragraphs to it.
Dim mySection As New Section()
mySection.Background = Brushes.Red
mySection.Blocks.Add(myParagraph1)
mySection.Blocks.Add(myParagraph2)
mySection.Blocks.Add(myParagraph3)
' Create a FlowDocument and add the section to it.
Dim myFlowDocument As New FlowDocument()
myFlowDocument.Blocks.Add(mySection)
Me.Content = myFlowDocument
End Sub
End Class
End Namespace
BlockUIContainer
BlockUIContainer UIElement maakt het mogelijk om elementen (bijvoorbeeld een Button) in te sluiten in blok-afgeleide doorlopende inhoud. InlineUIContainer (zie hieronder) wordt gebruikt voor het insluiten van UIElement elementen in inline-afgeleide doorstromende inhoud. BlockUIContainer en InlineUIContainer zijn belangrijk omdat er geen andere manier is om een UIElement in stromende inhoud te gebruiken, tenzij deze zich in een van deze twee elementen bevindt.
In het volgende voorbeeld ziet u hoe u het BlockUIContainer-element gebruikt om UIElement-objecten in de stroominhoud te hosten.
<FlowDocument ColumnWidth="400">
<Section Background="GhostWhite">
<Paragraph>
A UIElement element may be embedded directly in flow content
by enclosing it in a BlockUIContainer element.
</Paragraph>
<BlockUIContainer>
<Button>Click me!</Button>
</BlockUIContainer>
<Paragraph>
The BlockUIContainer element may host no more than one top-level
UIElement. However, other UIElements may be nested within the
UIElement contained by an BlockUIContainer element. For example,
a StackPanel can be used to host multiple UIElement elements within
a BlockUIContainer element.
</Paragraph>
<BlockUIContainer>
<StackPanel>
<Label Foreground="Blue">Choose a value:</Label>
<ComboBox>
<ComboBoxItem IsSelected="True">a</ComboBoxItem>
<ComboBoxItem>b</ComboBoxItem>
<ComboBoxItem>c</ComboBoxItem>
</ComboBox>
<Label Foreground ="Red">Choose a value:</Label>
<StackPanel>
<RadioButton>x</RadioButton>
<RadioButton>y</RadioButton>
<RadioButton>z</RadioButton>
</StackPanel>
<Label>Enter a value:</Label>
<TextBox>
A text editor embedded in flow content.
</TextBox>
</StackPanel>
</BlockUIContainer>
</Section>
</FlowDocument>
In de volgende afbeelding ziet u hoe dit voorbeeld wordt weergegeven:
Lijst
List wordt gebruikt om een lijst met opsommingstekens of numerieke lijsten te maken. Stel de MarkerStyle eigenschap in op een TextMarkerStyle opsommingswaarde om de stijl van de lijst te bepalen. In het onderstaande voorbeeld ziet u hoe u een eenvoudige lijst maakt.
<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<List>
<ListItem>
<Paragraph>
List Item 1
</Paragraph>
</ListItem>
<ListItem>
<Paragraph>
List Item 2
</Paragraph>
</ListItem>
<ListItem>
<Paragraph>
List Item 3
</Paragraph>
</ListItem>
</List>
</FlowDocument>
using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Controls;
using System.Windows.Documents;
namespace SDKSample
{
public partial class ListExample : Page
{
public ListExample()
{
// Create three paragraphs
Paragraph myParagraph1 = new Paragraph(new Run("List Item 1"));
Paragraph myParagraph2 = new Paragraph(new Run("List Item 2"));
Paragraph myParagraph3 = new Paragraph(new Run("List Item 3"));
// Create the ListItem elements for the List and add the
// paragraphs to them.
ListItem myListItem1 = new ListItem();
myListItem1.Blocks.Add(myParagraph1);
ListItem myListItem2 = new ListItem();
myListItem2.Blocks.Add(myParagraph2);
ListItem myListItem3 = new ListItem();
myListItem3.Blocks.Add(myParagraph3);
// Create a List and add the three ListItems to it.
List myList = new List();
myList.ListItems.Add(myListItem1);
myList.ListItems.Add(myListItem2);
myList.ListItems.Add(myListItem3);
// Create a FlowDocument and add the section to it.
FlowDocument myFlowDocument = new FlowDocument();
myFlowDocument.Blocks.Add(myList);
this.Content = myFlowDocument;
}
}
}
Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents
Namespace SDKSample
Partial Public Class ListExample
Inherits Page
Public Sub New()
' Create three paragraphs
Dim myParagraph1 As New Paragraph(New Run("List Item 1"))
Dim myParagraph2 As New Paragraph(New Run("List Item 2"))
Dim myParagraph3 As New Paragraph(New Run("List Item 3"))
' Create the ListItem elements for the List and add the
' paragraphs to them.
Dim myListItem1 As New ListItem()
myListItem1.Blocks.Add(myParagraph1)
Dim myListItem2 As New ListItem()
myListItem2.Blocks.Add(myParagraph2)
Dim myListItem3 As New ListItem()
myListItem3.Blocks.Add(myParagraph3)
' Create a List and add the three ListItems to it.
Dim myList As New List()
myList.ListItems.Add(myListItem1)
myList.ListItems.Add(myListItem2)
myList.ListItems.Add(myListItem3)
' Create a FlowDocument and add the section to it.
Dim myFlowDocument As New FlowDocument()
myFlowDocument.Blocks.Add(myList)
Me.Content = myFlowDocument
End Sub
End Class
End Namespace
Opmerking
List is het enige stromingselement dat gebruikmaakt van ListItemCollection om subelementen te beheren.
Tabel
Table wordt gebruikt om een tabel te maken. Table is vergelijkbaar met het Grid element, maar heeft meer mogelijkheden en vereist daarom meer overhead voor resources. Aangezien Grid een UIElement is, kan deze niet worden gebruikt in doorlopende inhoud, tenzij deze is opgenomen in een BlockUIContainer of InlineUIContainer. Zie Table voor meer informatie.
Inline-afgeleide klassen
Rennen
Run wordt gebruikt om niet-opgemaakte tekst te bevatten. U kunt verwachten dat Run objecten veelvuldig worden gebruikt in vloeiende inhoud. In markeringen Run hoeven elementen echter niet expliciet te worden gebruikt. Run moet worden gebruikt bij het maken of bewerken van stroomdocumenten met behulp van code. In de onderstaande markeringen geeft de eerste Paragraph bijvoorbeeld het Run element expliciet op, terwijl de tweede dat niet doet. Beide alinea's genereren identieke uitvoer.
<Paragraph>
<Run>Paragraph that explicitly uses the Run element.</Run>
</Paragraph>
<Paragraph>
This Paragraph omits the Run element in markup. It renders
the same as a Paragraph with Run used explicitly.
</Paragraph>
Opmerking
Vanaf .NET Framework 4 is de Text eigenschap van het Run object een afhankelijkheidseigenschap. U kunt de Text eigenschap verbinden met een gegevensbron, zoals een TextBlock. De Text eigenschap biedt volledige ondersteuning voor binding in één richting. De Text eigenschap biedt ook ondersteuning voor tweerichtingsbindingen, met uitzondering van RichTextBox. Zie Run.Textvoor een voorbeeld.
Span
Span groepeert andere inline-inhoudselementen. Er wordt geen inherente rendering toegepast op inhoud binnen een Span element. Elementen die erven van Span, inclusief Hyperlink, Bold, Italic en Underline, passen echter opmaak toe op tekst.
Hieronder ziet u een voorbeeld van een Span die wordt gebruikt om inline inhoud te bevatten, waaronder tekst, een Bold element en een Button.
<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Paragraph>
Text before the Span. <Span Background="Red">Text within the Span is
red and <Bold>this text is inside the Span-derived element Bold.</Bold>
A Span can contain more then text, it can contain any inline content. For
example, it can contain a
<InlineUIContainer>
<Button>Button</Button>
</InlineUIContainer>
or other UIElement, a Floater, a Figure, etc.</Span>
</Paragraph>
</FlowDocument>
In de volgende schermopname ziet u hoe dit voorbeeld wordt weergegeven.
InlineUIContainer
InlineUIContainer UIElement maakt het mogelijk dat elementen (bijvoorbeeld een besturingselement zoals Button) worden ingesloten in een Inline inhoudselement. Dit element is het inline-equivalent zoals hierboven beschreven met BlockUIContainer. Hieronder ziet u een voorbeeld dat InlineUIContainer gebruikt om een Button inline in een Paragraph in te voegen.
<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Paragraph>
Text to precede the button...
<!-- Set the BaselineAlignment property to "Bottom"
so that the Button aligns properly with the text. -->
<InlineUIContainer BaselineAlignment="Bottom">
<Button>Button</Button>
</InlineUIContainer>
Text to follow the button...
</Paragraph>
</FlowDocument>
using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Controls;
using System.Windows.Documents;
namespace SDKSample
{
public partial class InlineUIContainerExample : Page
{
public InlineUIContainerExample()
{
Run run1 = new Run(" Text to precede the button... ");
Run run2 = new Run(" Text to follow the button... ");
// Create a new button to be hosted in the paragraph.
Button myButton = new Button();
myButton.Content = "Click me!";
// Create a new InlineUIContainer to contain the Button.
InlineUIContainer myInlineUIContainer = new InlineUIContainer();
// Set the BaselineAlignment property to "Bottom" so that the
// Button aligns properly with the text.
myInlineUIContainer.BaselineAlignment = BaselineAlignment.Bottom;
// Asign the button as the UI container's child.
myInlineUIContainer.Child = myButton;
// Create the paragraph and add content to it.
Paragraph myParagraph = new Paragraph();
myParagraph.Inlines.Add(run1);
myParagraph.Inlines.Add(myInlineUIContainer);
myParagraph.Inlines.Add(run2);
// Create a FlowDocument and add the paragraph to it.
FlowDocument myFlowDocument = new FlowDocument();
myFlowDocument.Blocks.Add(myParagraph);
this.Content = myFlowDocument;
}
}
}
Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents
Namespace SDKSample
Partial Public Class InlineUIContainerExample
Inherits Page
Public Sub New()
Dim run1 As New Run(" Text to precede the button... ")
Dim run2 As New Run(" Text to follow the button... ")
' Create a new button to be hosted in the paragraph.
Dim myButton As New Button()
myButton.Content = "Click me!"
' Create a new InlineUIContainer to contain the Button.
Dim myInlineUIContainer As New InlineUIContainer()
' Set the BaselineAlignment property to "Bottom" so that the
' Button aligns properly with the text.
myInlineUIContainer.BaselineAlignment = BaselineAlignment.Bottom
' Asign the button as the UI container's child.
myInlineUIContainer.Child = myButton
' Create the paragraph and add content to it.
Dim myParagraph As New Paragraph()
myParagraph.Inlines.Add(run1)
myParagraph.Inlines.Add(myInlineUIContainer)
myParagraph.Inlines.Add(run2)
' Create a FlowDocument and add the paragraph to it.
Dim myFlowDocument As New FlowDocument()
myFlowDocument.Blocks.Add(myParagraph)
Me.Content = myFlowDocument
End Sub
End Class
End Namespace
Opmerking
InlineUIContainer hoeft niet expliciet in markeringen te worden gebruikt. Als u deze weglaat, wordt er toch een InlineUIContainer gemaakt wanneer de code wordt gecompileerd.
Afbeelding en zwevende elementen
Figure en Floater worden gebruikt voor het insluiten van inhoud in Flow-documenten met plaatsingseigenschappen die onafhankelijk van de primaire inhoudsstroom kunnen worden aangepast. Figure of Floater elementen worden vaak gebruikt om delen van inhoud te markeren of accentueren, om ondersteunende afbeeldingen of andere inhoud binnen de hoofdinhoudsstroom te hosten, of om losjes gerelateerde inhoud zoals advertenties te injecteren.
In het volgende voorbeeld ziet u hoe u een Figure insluit in een alinea met tekst.
<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Paragraph>
<Figure
Width="300" Height="100"
Background="GhostWhite" HorizontalAnchor="PageLeft" >
<Paragraph FontStyle="Italic" Background="Beige" Foreground="DarkGreen" >
A Figure embeds content into flow content with placement properties
that can be customized independently from the primary content flow
</Paragraph>
</Figure>
Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy
nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi
enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis
nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure.
</Paragraph>
</FlowDocument>
using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Controls;
using System.Windows.Documents;
namespace SDKSample
{
public partial class FigureExample : Page
{
public FigureExample()
{
// Create strings to use as content.
string strFigure = "A Figure embeds content into flow content with" +
" placement properties that can be customized" +
" independently from the primary content flow";
string strOther = "Lorem ipsum dolor sit amet, consectetuer adipiscing" +
" elit, sed diam nonummy nibh euismod tincidunt ut laoreet" +
" dolore magna aliquam erat volutpat. Ut wisi enim ad" +
" minim veniam, quis nostrud exerci tation ullamcorper" +
" suscipit lobortis nisl ut aliquip ex ea commodo consequat." +
" Duis autem vel eum iriure.";
// Create a Figure and assign content and layout properties to it.
Figure myFigure = new Figure();
myFigure.Width = new FigureLength(300);
myFigure.Height = new FigureLength(100);
myFigure.Background = Brushes.GhostWhite;
myFigure.HorizontalAnchor = FigureHorizontalAnchor.PageLeft;
Paragraph myFigureParagraph = new Paragraph(new Run(strFigure));
myFigureParagraph.FontStyle = FontStyles.Italic;
myFigureParagraph.Background = Brushes.Beige;
myFigureParagraph.Foreground = Brushes.DarkGreen;
myFigure.Blocks.Add(myFigureParagraph);
// Create the paragraph and add content to it.
Paragraph myParagraph = new Paragraph();
myParagraph.Inlines.Add(myFigure);
myParagraph.Inlines.Add(new Run(strOther));
// Create a FlowDocument and add the paragraph to it.
FlowDocument myFlowDocument = new FlowDocument();
myFlowDocument.Blocks.Add(myParagraph);
this.Content = myFlowDocument;
}
}
}
Imports System.Windows
Imports System.Windows.Media
Imports System.Windows.Controls
Imports System.Windows.Documents
Namespace SDKSample
Partial Public Class FigureExample
Inherits Page
Public Sub New()
' Create strings to use as content.
Dim strFigure As String = "A Figure embeds content into flow content with" & " placement properties that can be customized" & " independently from the primary content flow"
Dim strOther As String = "Lorem ipsum dolor sit amet, consectetuer adipiscing" & " elit, sed diam nonummy nibh euismod tincidunt ut laoreet" & " dolore magna aliquam erat volutpat. Ut wisi enim ad" & " minim veniam, quis nostrud exerci tation ullamcorper" & " suscipit lobortis nisl ut aliquip ex ea commodo consequat." & " Duis autem vel eum iriure."
' Create a Figure and assign content and layout properties to it.
Dim myFigure As New Figure()
myFigure.Width = New FigureLength(300)
myFigure.Height = New FigureLength(100)
myFigure.Background = Brushes.GhostWhite
myFigure.HorizontalAnchor = FigureHorizontalAnchor.PageLeft
Dim myFigureParagraph As New Paragraph(New Run(strFigure))
myFigureParagraph.FontStyle = FontStyles.Italic
myFigureParagraph.Background = Brushes.Beige
myFigureParagraph.Foreground = Brushes.DarkGreen
myFigure.Blocks.Add(myFigureParagraph)
' Create the paragraph and add content to it.
Dim myParagraph As New Paragraph()
myParagraph.Inlines.Add(myFigure)
myParagraph.Inlines.Add(New Run(strOther))
' Create a FlowDocument and add the paragraph to it.
Dim myFlowDocument As New FlowDocument()
myFlowDocument.Blocks.Add(myParagraph)
Me.Content = myFlowDocument
End Sub
End Class
End Namespace
In de volgende afbeelding ziet u hoe dit voorbeeld wordt weergegeven.
Figure en Floater verschillen op verschillende manieren en worden gebruikt voor verschillende scenario's.
Cijfer:
Positie instellen: u kunt de horizontale en verticale ankers instellen om deze relatief aan de pagina, inhoud, kolom of alinea te koppelen. U kunt ook de eigenschappen HorizontalOffset en VerticalOffset gebruiken om willekeurige verschuivingen op te geven.
Is aanpasbaar naar meer dan één kolom: u kunt de Figure hoogte en breedte instellen op veelvouden van pagina-, inhouds- of kolomhoogte of -breedte. Houd er rekening mee dat in het geval van pagina en inhoud veelvouden groter dan 1 niet zijn toegestaan. U kunt bijvoorbeeld de breedte van een Figure instellen op "0,5 pagina", "0,25 inhoud" of "2 kolommen". U kunt ook de hoogte en breedte instellen op absolute pixelwaarden.
Pagineert niet: Als de inhoud in een Figure niet binnen de Figureinhoud past, wordt de inhoud weergegeven die past en gaat de resterende inhoud verloren
Floater:
Kan niet worden geplaatst en wordt weergegeven waar ruimte beschikbaar kan worden gesteld. U kunt de verschuiving en het anker niet instellen voor een Floater.
Kan niet groter worden gemaakt dan één kolom: Floater past standaard in één kolom. Deze heeft een Width eigenschap die kan worden ingesteld op een absolute pixelwaarde, maar als deze waarde groter is dan één kolombreedte, wordt deze genegeerd en heeft de floater de grootte van één kolom. U kunt de grootte wijzigen in minder dan één kolom door de juiste pixelbreedte in te stellen, maar de grootte is niet kolom-relatief, dus '0,5Column' is geen geldige expressie voor Floater breedte. Floater heeft geen hoogte-eigenschap en de hoogte kan niet worden ingesteld, de hoogte is afhankelijk van de inhoud
Floater pagineren: Als de inhoud van de opgegeven breedte meer dan 1 kolomhoogte overschrijdt, gaan zwevende elementen over naar de volgende kolom, de volgende pagina, enzovoort.
Figure is een goede plek om zelfstandige inhoud te plaatsen waar u de grootte en plaatsing wilt bepalen en erop kunt vertrouwen dat de inhoud in de opgegeven grootte past. Floater is een goede plek om meer vrije stromende inhoud te plaatsen die vergelijkbaar is met de inhoud van de hoofdpagina, maar is ervan gescheiden.
LineBreak
LineBreak veroorzaakt een regeleinde in vloeiende inhoud. In het volgende voorbeeld ziet u het gebruik van LineBreak.
<FlowDocument xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Paragraph>
Before the LineBreak in Paragraph.
<LineBreak />
After the LineBreak in Paragraph.
<LineBreak/><LineBreak/>
After two LineBreaks in Paragraph.
</Paragraph>
<Paragraph>
<LineBreak/>
</Paragraph>
<Paragraph>
After a Paragraph with only a LineBreak in it.
</Paragraph>
</FlowDocument>
In de volgende schermopname ziet u hoe dit voorbeeld wordt weergegeven.
Elementen van stroomverzameling
In veel van de bovenstaande voorbeelden worden de BlockCollection en InlineCollection gebruikt voor het programmatisch samenstellen van stroominhoud. Als u bijvoorbeeld elementen wilt toevoegen aan een Paragraph, kunt u de syntaxis gebruiken:
myParagraph.Inlines.Add(new Run("Some text"));
Hiermee wordt een Run toegevoegd aan de InlineCollection van de Paragraph. Dit is hetzelfde als de impliciete Run gevonden in een Paragraph markering:
<Paragraph>
Some Text
</Paragraph>
Als een voorbeeld van het gebruik van BlockCollection, wordt in het volgende voorbeeld een nieuwe Section gemaakt en vervolgens de methode Toevoegen gebruikt om een nieuwe Paragraph aan de Section inhoud toe te voegen.
Section secx = new Section();
secx.Blocks.Add(new Paragraph(new Run("A bit of text content...")));
Dim secx As New Section()
secx.Blocks.Add(New Paragraph(New Run("A bit of text content...")))
Naast het toevoegen van items aan een stroomverzameling kunt u ook items verwijderen. In het volgende voorbeeld wordt het laatste Inline element in de Spanverwijderd.
spanx.Inlines.Remove(spanx.Inlines.LastInline);
spanx.Inlines.Remove(spanx.Inlines.LastInline)
In het volgende voorbeeld worden alle inhoud (Inline elementen) uit de Spangewist.
spanx.Inlines.Clear();
spanx.Inlines.Clear()
Wanneer u programmatisch met stroominhoud werkt, maakt u waarschijnlijk uitgebreid gebruik van deze verzamelingen.
Of een flow-element een InlineCollection (Inline) of BlockCollection (Blokken) gebruikt om onderliggende elementen te bevatten, hangt af van het type onderliggende elementen (Block of Inline) dat door het bovenliggende element kan worden opgenomen. Insluitingsregels voor stroominhoudselementen worden samengevat in het inhoudsschema in de volgende sectie.
Opmerking
Er is een derde type verzameling dat wordt gebruikt met stroominhoud, de ListItemCollection, maar deze verzameling wordt alleen gebruikt met een List. Daarnaast worden er verschillende collecties gebruikt bij Table. Zie Tabeloverzicht voor meer informatie.
Inhoudsschema
Gezien het aantal verschillende elementen van stroominhoud kan het overweldigend zijn om bij te houden welk type onderliggende elementen een element kan bevatten. In het onderstaande diagram worden de insluitingsregels voor stroomelementen samengevat. De pijlen geven de mogelijke ouder/kind-relaties aan.
Zoals te zien is in het bovenstaande diagram, worden de elementen die zijn toegestaan voor een element niet noodzakelijkerwijs bepaald door of het een Block element is of een Inline element. Bijvoorbeeld, een Span (een Inline element) kan alleen Inline onderliggende elementen hebben, terwijl een Figure (ook een Inline element) alleen Block onderliggende elementen kan hebben. Daarom is een diagram handig om snel te bepalen welk element in een ander element kan worden opgenomen. Laten we bijvoorbeeld het diagram gebruiken om te bepalen hoe de stroominhoud van een RichTextBoxmoet worden samengesteld.
1. Een RichTextBox moet een FlowDocument object bevatten dat op zijn beurt een Block-afgeleide object moet bevatten. Hieronder ziet u het bijbehorende segment uit het bovenstaande diagram.
Tot nu toe is dit hoe de markeringen eruit kunnen zien.
<RichTextBox>
<FlowDocument>
<!-- One or more Block-derived object… -->
</FlowDocument>
</RichTextBox>
2. Volgens het diagram zijn er verschillende Block elementen waaruit u kunt kiezen, waaronderParagraph, SectionTable, , Listen BlockUIContainer (zie bovenstaande blokklassen). Stel dat we een Tablewillen. Volgens het bovenstaande diagram bevat een Table een TableRowGroup dat TableRow elementen bevat, die op hun beurt TableCell elementen bevatten welke op hun beurt een object bevatten dat is afgeleid van Block. Hieronder ziet u het bijbehorende segment Table dat uit het bovenstaande diagram is genomen.
Hieronder ziet u de bijbehorende markeringen.
<RichTextBox>
<FlowDocument>
<Table>
<TableRowGroup>
<TableRow>
<TableCell>
<!-- One or more Block-derived object… -->
</TableCell>
</TableRow>
</TableRowGroup>
</Table>
</FlowDocument>
</RichTextBox>
3. Nogmaals, een of meer Block elementen zijn vereist onder een TableCell. Om het eenvoudig te maken, plaatsen we tekst in de cel. We kunnen dit doen met behulp van een Paragraph met een Run element. Hieronder ziet u de bijbehorende segmenten uit het diagram waarin wordt weergegeven dat een Paragraph een Inline element kan bevatten en dat een Run (een Inline element) alleen platte tekst kan bevatten.
Hieronder ziet u het volledige voorbeeld in markeringen.
<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<RichTextBox>
<FlowDocument>
<!-- Normally a table would have multiple rows and multiple
cells but this code is for demonstration purposes.-->
<Table>
<TableRowGroup>
<TableRow>
<TableCell>
<Paragraph>
<!-- The schema does not actually require
explicit use of the Run tag in markup. It
is only included here for clarity. -->
<Run>Paragraph in a Table Cell.</Run>
</Paragraph>
</TableCell>
</TableRow>
</TableRowGroup>
</Table>
</FlowDocument>
</RichTextBox>
</Page>
Tekst aanpassen
Meestal is tekst het meest voorkomende type inhoud in een stroomdocument. Hoewel de hierboven geïntroduceerde objecten kunnen worden gebruikt om de meeste aspecten van de weergave van tekst te bepalen, zijn er enkele andere methoden voor het aanpassen van tekst die in deze sectie wordt behandeld.
Tekstdecoraties
Met tekstdecoraties kunt u de onderstrepings-, overlijn-, basislijn- en doorhalen-effecten toepassen op tekst (zie afbeeldingen hieronder). Deze decoraties worden toegevoegd met behulp van de TextDecorations eigenschap die wordt weergegeven door een aantal objecten, waaronder Inline, Paragraph, TextBlocken TextBox.
In het volgende voorbeeld ziet u hoe u de TextDecorations-eigenschap van een Paragraph instelt.
<FlowDocument ColumnWidth="200">
<Paragraph TextDecorations="Strikethrough">
This text will render with the strikethrough effect.
</Paragraph>
</FlowDocument>
Paragraph parx = new Paragraph(new Run("This text will render with the strikethrough effect."));
parx.TextDecorations = TextDecorations.Strikethrough;
Dim parx As New Paragraph(New Run("This text will render with the strikethrough effect."))
parx.TextDecorations = TextDecorations.Strikethrough
In de volgende afbeelding ziet u hoe dit voorbeeld wordt weergegeven.
In de volgende afbeeldingen ziet u hoe de decoraties Overline, Basislijn en Onderstreping worden weergegeven.
Typografie
De Typography eigenschap wordt weergegeven door de meeste stroomgerelateerde inhoud, waaronder TextElement, FlowDocumenten TextBlockTextBox. Deze eigenschap wordt gebruikt voor het beheren van typografische kenmerken/variaties van tekst (dat wil bijvoorbeeld kleine of grote hoofdletters, superscripts en subscripts maken, enzovoort).
In het volgende voorbeeld ziet u hoe u het kenmerk Typography instelt met behulp van Paragraph als voorbeeldelement.
<Paragraph
TextAlignment="Left"
FontSize="18"
FontFamily="Palatino Linotype"
Typography.NumeralStyle="OldStyle"
Typography.Fraction="Stacked"
Typography.Variants="Inferior"
>
<Run>
This text has some altered typography characteristics. Note
that use of an open type font is necessary for most typographic
properties to be effective.
</Run>
<LineBreak/><LineBreak/>
<Run>
0123456789 10 11 12 13
</Run>
<LineBreak/><LineBreak/>
<Run>
1/2 2/3 3/4
</Run>
</Paragraph>
In de volgende afbeelding ziet u hoe dit voorbeeld wordt weergegeven.
In de volgende afbeelding ziet u daarentegen hoe een vergelijkbaar voorbeeld met standaard typografische eigenschappen wordt weergegeven.
In het volgende voorbeeld ziet u hoe u de eigenschap Typography programmatisch instelt.
Paragraph par = new Paragraph();
Run runText = new Run(
"This text has some altered typography characteristics. Note" +
"that use of an open type font is necessary for most typographic" +
"properties to be effective.");
Run runNumerals = new Run("0123456789 10 11 12 13");
Run runFractions = new Run("1/2 2/3 3/4");
par.Inlines.Add(runText);
par.Inlines.Add(new LineBreak());
par.Inlines.Add(new LineBreak());
par.Inlines.Add(runNumerals);
par.Inlines.Add(new LineBreak());
par.Inlines.Add(new LineBreak());
par.Inlines.Add(runFractions);
par.TextAlignment = TextAlignment.Left;
par.FontSize = 18;
par.FontFamily = new FontFamily("Palatino Linotype");
par.Typography.NumeralStyle = FontNumeralStyle.OldStyle;
par.Typography.Fraction = FontFraction.Stacked;
par.Typography.Variants = FontVariants.Inferior;
Dim par As New Paragraph()
Dim runText As New Run("This text has some altered typography characteristics. Note" & "that use of an open type font is necessary for most typographic" & "properties to be effective.")
Dim runNumerals As New Run("0123456789 10 11 12 13")
Dim runFractions As New Run("1/2 2/3 3/4")
par.Inlines.Add(runText)
par.Inlines.Add(New LineBreak())
par.Inlines.Add(New LineBreak())
par.Inlines.Add(runNumerals)
par.Inlines.Add(New LineBreak())
par.Inlines.Add(New LineBreak())
par.Inlines.Add(runFractions)
par.TextAlignment = TextAlignment.Left
par.FontSize = 18
par.FontFamily = New FontFamily("Palatino Linotype")
par.Typography.NumeralStyle = FontNumeralStyle.OldStyle
par.Typography.Fraction = FontFraction.Stacked
par.Typography.Variants = FontVariants.Inferior
Zie Typografie in WPF voor meer informatie over typografie.
Zie ook
- Tekst
- Typografie in WPF
- Handleidingonderwerpen
- Overzicht van TextElement-inhoudsmodel
- Overzicht van RichTextBox
- Documenten in WPF—
- Tabeloverzicht
- Overzicht van aantekeningen
Met ons samenwerken op GitHub
De bron voor deze inhoud vindt u op GitHub, waar u ook problemen en pull-aanvragen kunt maken en controleren. Bekijk onze gids voor inzenders voor meer informatie.
.NET Desktop feedback