Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 19 WPF-Steuerelemente
Pfeil 19.1 Hierarchie der WPF-Komponenten
Pfeil 19.2 Steuerelemente positionieren
Pfeil 19.2.1 Die Eigenschaften »Top«, »Bottom«, »Right« und »Left«
Pfeil 19.2.2 Außenrand mit der Eigenschaft »Margin« festlegen
Pfeil 19.2.3 Innenrand mit der Eigenschaft »Padding« festlegen
Pfeil 19.3 Allgemeine Eigenschaften der WPF-Komponenten
Pfeil 19.3.1 Die Eigenschaft »Content«
Pfeil 19.3.2 Größe einer Komponente
Pfeil 19.3.3 Ausrichtung einer Komponente
Pfeil 19.3.4 Die Eigenschaften »Padding« und »Margin«
Pfeil 19.3.5 Sichtbarkeit eines Steuerelements
Pfeil 19.3.6 Farbeinstellungen
Pfeil 19.3.7 Schriften
Pfeil 19.4 Buttons
Pfeil 19.4.1 Die Basisklasse »ButtonBase«
Pfeil 19.4.2 Das Steuerelement »Button«
Pfeil 19.4.3 Das Steuerelement »ToggleButton«
Pfeil 19.4.4 Das Steuerelement »RepeatButton«
Pfeil 19.4.5 Das Steuerelement »Checkbox«
Pfeil 19.4.6 Das Steuerelement »RadioButton«
Pfeil 19.5 Einfache Eingabesteuerelemente
Pfeil 19.5.1 Das Steuerelement »Label«
Pfeil 19.5.2 Das Steuerelement »TextBox«
Pfeil 19.5.3 Das Steuerelement »PasswordBox«
Pfeil 19.5.4 Das Steuerelement »TextBlock«
Pfeil 19.5.5 Das Steuerelement »Tooltip«
Pfeil 19.6 FlowDocuments
Pfeil 19.6.1 Allgemeine Beschreibung
Pfeil 19.6.2 Eigenschaften eines FlowDocuments
Pfeil 19.6.3 Blöcke eines FlowDocuments
Pfeil 19.6.4 Inline-Elemente
Pfeil 19.6.5 FlowDocuments mit Code erzeugen
Pfeil 19.6.6 Speichern und Laden von FlowDocuments
Pfeil 19.7 Das Element »FlowDocumentViewer«
Pfeil 19.7.1 Das Anzeigeelement »FlowDocumentScrollViewer«
Pfeil 19.7.2 Das Anzeigeelement »FlowDocumentPageViewer«
Pfeil 19.7.3 Das Anzeigeelement »FlowDocumentReader«
Pfeil 19.8 XPS-Dokumente mit »DocumentViewer«
Pfeil 19.8.1 Allgemeines zum XPS-Format
Pfeil 19.8.2 Beispielprogramm
Pfeil 19.8.3 Das Steuerelement »RichTextBox«
Pfeil 19.9 WPF-Listenelemente – ItemControls
Pfeil 19.9.1 Das Steuerelement »ListBox«
Pfeil 19.9.2 ComboBox
Pfeil 19.9.3 Das Steuerelement »ListView«
Pfeil 19.9.4 Das Steuerelement »TreeView«
Pfeil 19.9.5 Das Steuerelement »TabControl«
Pfeil 19.9.6 Menüleisten
Pfeil 19.9.7 Kontextmenüs
Pfeil 19.9.8 Symbolleisten
Pfeil 19.9.9 Die Statusleiste
Pfeil 19.10 Weitere Steuerelemente
Pfeil 19.10.1 Die »ProgressBar«
Pfeil 19.10.2 Das Steuerelement »Slider«
Pfeil 19.10.3 Das »GroupBox«-Steuerelement
Pfeil 19.10.4 Das Steuerelement »ScrollViewer«
Pfeil 19.10.5 Das Steuerelement »Expander«
Pfeil 19.10.6 Das Steuerelement »Border«
Pfeil 19.10.7 Die »Image«-Komponente
Pfeil 19.10.8 Grafik zur Laufzeit laden


Galileo Computing - Zum Seitenanfang

19.6 FlowDocuments Zur nächsten ÜberschriftZur vorigen Überschrift


Galileo Computing - Zum Seitenanfang

19.6.1 Allgemeine Beschreibung Zur nächsten ÜberschriftZur vorigen Überschrift

Mit den Steuerelementen Label und TextBlock haben Sie auf den letzten Seiten zwei Steuerelemente kennengelernt, die zur Laufzeit keine Textänderungen zulassen. Mit einer TextBox-Komponente ermöglichen Sie dem Anwender auf der einen Seite, eigene Einträge vorzunehmen. Der eingegebene Text ist allerdings unformatiert, das bedeutet, in einer TextBox kann der Inhalt nur in einer Schriftart dargestellt werden, er ist entweder komplett fett oder kursiv, lässt auch keine anderen optischen Hervorhebungen (beispielsweise durch unterschiedliche Farbwahl) zu. Verglichen mit den Möglichkeiten, die selbst HTML bietet, ist das geradezu erbärmlich, es genügt aber den Anforderungen, die an ein einfaches Eingabesteuerelement gestellt werden.

Hinsichtlich der Verarbeitung und Darstellung von Text hat die WPF aber noch weitaus mehr zu bieten als die genannten einfachen Steuerelemente Label oder TextBox. Eins haben Sie bereits kennengelernt, nämlich TextBlock. Genau genommen ist TextBlock jedoch kein Steuerelement, da es nicht von Control abgeleitet ist. Aber ein TextBlock lässt bereits kurze, formatierte Texte zu. Sollen innerhalb eines Dokuments darüber hinaus auch Listen, Tabellen oder Bilder angezeigt werden, ist auch TextBlock an den Grenzen seiner Fähigkeiten angelangt. Für solche Anwendungsfälle bietet Ihnen die WPF mit

  • FlowDocumentReader
  • FlowDocumentPageViewer
  • FlowDocumentScrollViewer

drei weitere Steuerelemente an, mit denen praktisch beliebig strukturierte Dokumente in einem Window oder einer Page angezeigt werden können.

Ehe wir uns aber diesen drei Steuerelementen widmen, müssen wir uns damit auseinandersetzen, wie der anzuzeigende Dokumentinhalt definiert wird, der im allgemeinen als FlowDocument bezeichnet wird.

Bei einem FlowDocument handelt es sich also um ein Dokument, das in einem der drei zuvor angeführten Viewer angezeigt werden kann. Im XAML-Code wird das FlowDocument im Viewer eingebettet, wie im folgenden Listing gezeigt wird:


<FlowDocumentReader>
  <FlowDocument>
    <!-- Inhalt, der durch Blöcke beschrieben wird --> 
  </FlowDocument>
</FlowDocumentReader>

Für ein FlowDocument gibt es klare Richtlinien, die die Darstellung und den strukturellen Aufbau beschreiben. Ein FlowDocument setzt sich aus einem oder mehreren sogenannten Blöcken zusammen. Es stehen Ihnen insgesamt fünf verschiedene Block-Typen mit einer Vielzahl von Eigenschaften zur Verfügung, die dem FlowDocument das gewünschte Aussehen und Verhalten verleihen. Bei den Blöcken handelt es sich um Section, Paragraph, List, Table und BlockUIContainer.


Hinweis

Genau genommen kennen Sie bereits ein FlowDocument. Es handelt sich um den weiter oben behandelten TextBlock. Ein TextBlock gestattet jedoch nur die Anzeige einfacher Elemente. Weitergehende Darstellungsformen, beispielsweise die Anzeige einer Liste oder einer Tabelle, werden von der TextBlock-Komponente nicht angeboten. Ein TextBlock benötigt keinen separaten Viewer, denn dieses Steuerelement ist FlowDocument und Viewer gleichzeitig.



Galileo Computing - Zum Seitenanfang

19.6.2 Eigenschaften eines FlowDocuments Zur nächsten ÜberschriftZur vorigen Überschrift

Um ein FlowDocument zu beschreiben, stehen Ihnen viele Eigenschaften zur Verfügung. Einige sind Ihnen bereits geläufig, beispielsweise Padding, Margin, FontStyle usw. Auf einige spezifische Eigenschaften soll aber an dieser Stelle eingegangen werden. Sehen Sie sich dazu bitte Tabelle 19.9 an.


Tabelle 19.9 Eigenschaften eines FlowDocuments

Eigenschaft Beschreibung
IsHyphenationEnabled

Diese Eigenschaft gibt an, ob eine Silbentrennung durchgeführt werden soll.

IsOptimalParagraphEnabled

Wird diese Eigenschaft auf true gestellt, wird der Absatzumbruch optimiert. Das vermindert zu große Abstände zwischen den Wörtern.

LineHeight

Diese Eigenschaft gibt den Zeilenabstand innerhalb eines Absatzes an.

Style

Mit dieser Eigenschaft können Sie Formatierungen durch externe Styles beschreiben. Wir werden später in diesem Buch die Styles noch thematisieren.

TextAlignment

Diese Eigenschaft gibt die Textausrichtung an und kann auf Left, Right, Center und Justify eingestellt werden.



Anmerkung

Dieses Buch kann nur eine mehr oder weniger oberflächliche Einführung in die FlowDocuments sein. Für eine umfassende Beschreibung aller WPF-Klassen und deren Fähigkeiten reicht der Platz einfach nicht aus. Daher sei auch an dieser Stelle auf die MSDN-Online-Hilfe verwiesen, die diesbezüglich natürlich deutlich mehr Informationen liefert.



Galileo Computing - Zum Seitenanfang

19.6.3 Blöcke eines FlowDocuments Zur nächsten ÜberschriftZur vorigen Überschrift

FlowDocumente beschreiben einen textuellen Inhalt. Die Darstellung erfolgt, wie nicht anders zu erwarten ist, in XML. Die Grundstruktur eines FlowDocument setzt sich aus einem oder mehreren sogenannten Blöcken zusammen, wobei Ihnen zur Gestaltung der Grundstruktur fünf unterschiedliche Blöcke zur Verfügung stehen, die Sie Tabelle 19.10 entnehmen können. Alle Blöcke werden durch entsprechende Klassen beschrieben und haben die Basis Block, die zum Namespace System.Windows.Documents gehört.


Tabelle 19.10 Blöcke eines FlowDocuments

Block Beschreibung
Paragraph

Ein Paragraph-Element beschreibt Text. Dieses Element beschreibt also gewissermaßen das Fleisch des FlowDocument.

<Paragraph>
<!—Textinhalt -->
</Paragraph>
Section

Das Section-Element dient dazu, mehrere Blöcke zusammenzuführen, um eine einheitliche Formatierung aller enthaltenen Blöcke zu erreichen.

<Section>
<!—weitere Blöcke -->
</Section>
List

Das List-Element beschreibt eine Collection von ListItem-Elementen. Damit werden Listen innerhalb eines FlowDocument beschrieben. Jedes ListItem-Element darf seinerseits einen beliebigen Block-Typ enthalten, natürlich auch wieder selbst ein List-Element, um eine verschachtelte Liste abzubilden.

Table

Das Table-Element bildet eine Tabelle ab. Jede Zelle der Tabelle darf einen beliebigen Block-Typ enthalten.

BlockUIContainer

Das BlockUIElement kann ein beliebiges UIElement-Element enthalten, beispielsweise einen Button oder eine TextBox. Damit lassen sich BlockDocuments erstellen, die programmierbar sind.

<BlockUIContainer>
<Button... />
</BlockUIContainer>

Paragraph, Section und BlockUIContainer sind recht simpel und bedürfen keiner weiteren Beschreibung. List und Table hingegen sind etwas komplexer, sodass wir uns mit diesen beiden Blöcken weiter unten noch genauer beschäftigen werden.

Beispielprogramm

Das folgende Beispielprogramm FlowDocumentDemo zeigt, wie ein FlowDocument in XAML-Code aussieht. Um das Grundprinzip zu verdeutlichen, wird in diesem Beispiel nur der Paragraph-Block verwendet.


// -----------------------------------------------------
// Beispiel: ...\Kapitel 19\FlowDocumentDemo  
// -----------------------------------------------------
<FlowDocumentReader>
  <FlowDocument>
    <Paragraph FontSize="20" FontFamily="Arial" 
               FontWeight="Bold" Foreground="Blue">
      Kapitel 3: das Klassendesign 
    </Paragraph>
    <Paragraph FontSize="16" FontFamily="Arial" FontWeight="Bold">
      3.1 Einführung in die Objektorientierung
    </Paragraph>
    <Paragraph FontSize="12" FontFamily="Arial">
      Die beiden wichtigsten ...
    </Paragraph>
    <Paragraph FontSize="12" FontFamily="Arial">
      Stellen Sie sich ein Architekturbüro ...        
    </Paragraph>
    <Paragraph FontSize="12" FontFamily="Arial">
      Der Bauplan dient also ...
    </Paragraph>
  </FlowDocument>
</FlowDocumentReader>

In Abbildung 19.14 sehen Sie die Ausgabe des FlowDocument.

Abbildung 19.14 Ausgabe des FlowDocuments

Fließtexte werden in Paragraph-Elementen beschrieben. Das Beispielprogramm zeigt allerdings nur den einfachen Einsatz der Fließtexte. Wie schon angedeutet, können Sie auch innerhalb eines Textes einzelne Wörter oder Passagen unterschiedlich formatieren. Dazu dienen Inline-Elemente, mit denen wir uns weiter unten noch beschäftigen werden. Zuvor aber sollten wir uns noch zwei der in Tabelle 19.10 aufgeführten Block-Elemente etwas detaillierter ansehen: List und Table.

Der »List«-Block

Etwas komplexer als die Elemente Paragraph, Section und BlockUIContainer ist das Element List. Dieses Block-Element dient zum Erzeugen von Aufzählungen. Jeder Listeneintrag wird innerhalb von List durch ein ListItem-Element beschrieben. ListItem-Elemente beinhalten ihrerseits Blockelemente, sodass Sie den anzuzeigenden Text zum Beispiel in ein Paragraph-Element einschließen.

Mit der Eigenschaft MarkerStyle des List-Elements legen Sie das Aufzählungszeichen fest. Es entstammt der Enumeration TextMarkerStyle und enthält zehn verschiedene Varianten, angefangen bei einfachen Symbolen bis hin zu Zahlen und Buchstaben. Verwenden Sie Zahlen, kann mit der Eigenschaft StartIndex der Index des ersten Elements festgelegt werden. Den Abstand zwischen den Aufzählungszeichen und dem Text des Listeneintrags können Sie bei Bedarf mit der Eigenschaft MarkerOffset definieren.


<List MarkerStyle="Decimal" FontFamily="Arial">
  <ListItem>
    <Paragraph>Erster Listeneintrag</Paragraph>
  </ListItem>
  <ListItem>
    <Paragraph>Zweiter Listeneintrag</Paragraph>
  </ListItem>
</List>

Der »Table«-Block

Das komplexeste Blockelement beschreibt eine Tabelle und wird mit Table eingeleitet. Innerhalb des Table-Elements werden mit TableRowGroup alle Zeilen innerhalb der Tabelle beschrieben. Ausgedrückt wird dabei jede Zeile durch ein TableRow-Element, jede Zelle der Datenzeile durch das Element TableCell. Ein Table-Element kann auch mehrere TableRowGroup-Elemente enthalten. Das macht Sinn, wenn mehrere Zeilen innerhalb der Tabelle unterschiedlich formatiert werden sollen.

Geben Sie innerhalb einer Tabellendefinition keine Spalten an, werden diese alle gleich breit dargestellt. Möchten Sie jedoch Einfluss auf die Spaltenbreiten ausüben, sollten Sie im Table-Element auch einen Table.Columns-Abschnitt definieren, der als Container für die definierten TableColumn-Elemente dient. Geben Sie jedem TableColumn-Element die gewünschte Breite mit Width an. Dabei können Sie entweder die absolute Breite einstellen, z. B. mit Width=70, oder die relative Breite, beispielsweise mit Width=3*.


<Table CellSpacing="10" Padding="0" Background="Yellow"
       FontFamily="Arial" FontSize="12">
  <!-- Spaltendefinition -->
  <Table.Columns>
    <TableColumn Width="70" />
    <TableColumn Width="120" />
    <TableColumn Width="200"/>
    </Table.Columns>
  <!-- Zeilendefinition -->
  <TableRowGroup Background="LightCyan">
    <TableRow>
      <TableCell BorderThickness="1" BorderBrush="Black">
        <Paragraph>Zelle 0,0</Paragraph>
      </TableCell>
      <TableCell BorderThickness="1" BorderBrush="Black">
        <Paragraph>Zelle 0,1</Paragraph>
      </TableCell>
      <TableCell BorderThickness="1" BorderBrush="Black">
        <Paragraph>Zelle 0,2</Paragraph>
      </TableCell>
      </TableRow>
      <TableRow>
      <TableCell BorderThickness="1" BorderBrush="Black" >
        <Paragraph>Zelle 1,0</Paragraph>
      </TableCell>
      <TableCell BorderThickness="1" BorderBrush="Black">
        <Paragraph>Zelle 1,1</Paragraph>
      </TableCell>
      <TableCell BorderThickness="1" BorderBrush="Black">
        <Paragraph>Zelle 1,2</Paragraph>
      </TableCell>
    </TableRow>
  </TableRowGroup>          
</Table>


Galileo Computing - Zum Seitenanfang

19.6.4 Inline-Elemente Zur nächsten ÜberschriftZur vorigen Überschrift

Innerhalb eines Fließtextes können Formatierungen am Text vorgenommen werden. Dazu dienen Inline-Elemente, die intern von der abstrakten Klasse Inline abgeleitet sind.

  • LineBreak: Mit diesem Element wird ein Zeilenumbruch durchgeführt.
  • Bold, Italic und Underline: Diese Inline-Elemente formatieren den enthaltenen Text fett, kursiv oder unterstrichen. Sie können Inline-Elemente grundsätzlich auch ineinander verschachteln, also Textpassagen auch fett und gleichzeitig kursiv darstellen, wie im folgenden XAML-Code gezeigt wird:

<Paragraph>
  Ein typisches Urlaubsland ist 
  <Italic><Bold>Österreich</Bold></Italic>. 
</Paragraph>

  • Figure: Das Element Figure können Sie sich als ein FlowDocument vorstellen, das in einen anderen, übergeordneten Bereich eingebettet wird, beispielsweise in das Paragraph-Element. Der umgebende Inhalt umschließt das Figure-Element, wobei Sie mit den Eigenschaften HorizontalAnchor und VerticalAnchor sowie HorizontalAnchor und VerticalAnchor die Positionierung beliebig selbst festlegen dürfen. Height und Width legen dabei die Abmessungen fest. Sollte der gewünschte Inhalt nicht in das Figure-Element passen, wird er abgeschnitten. Das Element eignet sich gut für Werbung, Zusatzinformationen oder auch Bilder.
  • Floater: Das Floater-Element ist eine vereinfachte Form des Figure-Elements. Im Gegensatz zu Figure kann es nicht positioniert werden. Der Inhalt wird dort angezeigt, wo entsprechender Platz zur Verfügung steht. Für ein Floater-Element können Sie weder eine Offset-, noch eine Anchor-Eigenschaft angeben. Im Allgemeinen eignen sich Floater eher zum Einfügen fortlaufender Inhalte.
  • InlineUIContainer: Dieses Element verwenden Sie, um andere UIElement-Elemente in den Fließtext einzubetten, beispielsweise einen Button. Mit diesem Element können Sie zwar nur UI-Elemente direkt angeben, aber es steht Ihnen frei, dazu einen Container zu verwenden, der natürlich seinerseits mehrere Elemente aufnehmen kann. Im Großen und Ganzen ähnelt es dem Element BlockUIContainer.
  • Span: Obwohl Sie mit den Elementen Bold, Underline und Italic Möglichkeiten haben, einzelne Passagen des Textes besonders darzustellen, reichten diese oft nicht aus. Hier kommt das Span-Element ins Spiel, das wesentlich mehr Gestaltungsspielraum bietet. So lassen sich einzelne Wörter oder Passagen mit FontFamily in einer anderen Schriftart darstellen, oder Sie können mit Background die Hintergrundfarbe anders festlegen als im restlichen Teil des Dokuments.

<Paragraph>
  Dies ist 
  <Span Background="Yellow" 
        Foreground="Blue" 
        FontFamily="Californian FB">
    ein Beispiel
  </Span> für das
  <Span FontFamily="Courier New">
    Span
  </Span>-Element.
</Paragraph>

  • Hyperlink: Dieses Element stellt einen Hyperlink dar. Dem Attribut NavigateUri geben Sie einen URI an, der nach dem Klicken auf das Element angezeigt werden soll. Stellen Sie dem URI das Zeichen # voran, können Sie sogar zu einer benannten Stelle im Dokument wechseln. Mit dem Attribut TargetName legen Sie das Ziel der Navigation fest. Dabei kann es sich zum Beispiel um ein Fenster oder einen Frame handeln.
  • Run: Das Element Run gibt einen unformatierten Text aus. Dieser kann durch umschließende Elemente wieder eine eigene Formatierung erhalten.

Das folgende Beispielprogramm demonstriert den Einsatz des Figure-Elements. Sicher ist das Layout des Windows durchaus verbesserungsbedürftig, aber dem Autor fehlt dazu einfach die erforderliche Begabung ...


// -------------------------------------------------------
// Beispiel: ...\Kapitel 19\FigureElement
// -------------------------------------------------------
<FlowDocumentReader>
  <FlowDocument>
    <Paragraph FontSize="22" Background="LightBlue" FontStyle="Oblique" 
               FontFamily="Arial" TextAlignment="Center" Padding="10">
      <TextBlock  VerticalAlignment="Center">
        <Bold>Seychellen-Infos</Bold>
      </TextBlock> 
    </Paragraph>
    <Paragraph FontFamily="Arial" FontSize="15">
      Zu den vermutlich schönsten ...
      <Figure Width="150" HorizontalAnchor="PageLeft" 
                          VerticalAnchor="PageCenter" 
                          HorizontalOffset="0" 
                          VerticalOffset="40">
        <BlockUIContainer>
          <Image  Source="1.jpg"></Image>
        </BlockUIContainer>
      </Figure>
      <Figure Width="150" HorizontalAnchor="PageRight" 
                          VerticalAnchor="PageCenter" 
                          VerticalOffset="-5">
        <BlockUIContainer>
          <Image Source="2.jpg"></Image>
        </BlockUIContainer>
      </Figure>
    </Paragraph>
  </FlowDocument>
  </FlowDocumentReader>

Abbildung 19.15 Die Ausgabe des Beispiels »FigureElement«


Anmerkung

Alle hier behandelten Inline-Elemente wurden in den Codebeispielen in Paragraph-Elementen verwendet. Grundsätzlich unterstützt aber auch das TextBlock-Element alle Inlines.



Galileo Computing - Zum Seitenanfang

19.6.5 FlowDocuments mit Code erzeugen Zur nächsten ÜberschriftZur vorigen Überschrift

Nicht immer werden Sie Ihre FlowDocuments im XAML-Code von Visual Studio bereitstellen können. Hier bieten sich Ihnen zwei weitere Alternativen an:

  • Sie beschreiben den Inhalt des FlowDocument mit Programmcode.
  • Sie greifen auf eine bereitgestellte XAML-Datei zurück.

In diesem Abschnitt wollen wir uns zunächst mit der Codierung beschäftigen, daran anschließend mit dem Einlesen aus einer Datei.

Das Schreiben des Programmcodes wird zu einem mittleren Drama. Nicht die Komplexität ist dafür verantwortlich, sondern vielmehr der Gesamtumfang. Vielleicht sollten Sie sich daher zunächst einmal Abbildung 19.16 ansehen.

Abbildung 19.16 Ausgabe des Beispielprogramms »FlowDocument_mit_Code«

Eigentlich wird nicht viel dargestellt; das FlowDocument enthält auch keine besonderen »Spezialitäten«. Doch schauen Sie sich jetzt den Beispielcode an, der dieser Ausgabe zugrunde liegt.


// -------------------------------------------------------
// Beispiel: ...\Kapitel 19\FlowDocument_mit_Code
// -----------------------------------------------------
private void Window_Loaded(object sender, RoutedEventArgs e) {
  FlowDocumentReader flowReader = new FlowDocumentReader();
  FlowDocument document = new FlowDocument();
  flowReader.Document = document;
  this.Content = flowReader;
  // 1. Block – Paragraph
  Paragraph para1 = new Paragraph();
  para1.FontSize = 22;
  para1.Background = new SolidColorBrush(Colors.LightBlue);
  para1.FontFamily = new FontFamily("Arial");
  para1.TextAlignment = TextAlignment.Center;
  para1.Padding = new Thickness(10);
  TextBlock textBlock1 = new TextBlock();
  textBlock1.VerticalAlignment = System.Windows.VerticalAlignment.Center;
  textBlock1.Inlines.Add(new Bold(new Run("Wir planen ...")));
  para1.Inlines.Add(textBlock1);
  document.Blocks.Add(para1);
  // 2. Block – Paragraph
  Paragraph para2 = new Paragraph();
  TextBlock textBlock2 = new TextBlock();
  textBlock2.FontSize = 14;
  textBlock2.TextWrapping = TextWrapping.Wrap;
  textBlock2.FontFamily = new FontFamily("Arial");
  textBlock2.Inlines.Add(new Run("Buchen Sie ..."));
  para2.Inlines.Add(textBlock2);
  document.Blocks.Add(para2);
  // 3. Block – Tabelle
  Table table = new Table();
  table.FontFamily = new FontFamily("Arial");
  // 1. Spalte
  TableColumn col1 = new TableColumn();
  col1.Width = new GridLength(350);
  table.Columns.Add(col1);
  // 2. Spalte
  TableColumn col2 = new TableColumn();
  col2.Width = new GridLength(100);
  table.Columns.Add(col2);
  TableRowGroup rowGroup = new TableRowGroup();
  TableRow row1 = new TableRow();
  // Zelle 1, Reihe 1      
  TableCell cell00 = new TableCell(
     new Paragraph(new Run("Australien - 3 wöchige Rundreise")));
  cell00.BorderThickness = new Thickness(1);
  cell00.BorderBrush = new SolidColorBrush(Colors.Black);
  row1.Cells.Add(cell00);
  // Zelle 2, Reihe 1
  TableCell cell01 = new TableCell(new Paragraph(new Run("5570,-€")));
  cell01.TextAlignment = TextAlignment.Right;
  cell01.BorderThickness = new Thickness(1);
  cell01.BorderBrush = new SolidColorBrush(Colors.Black);
  row1.Cells.Add(cell01);
  rowGroup.Rows.Add(row1);
  table.RowGroups.Add(rowGroup);
  document.Blocks.Add(table);
}

Erstellt wird das FlowDocument im Ereignis Loaded des Window. Als Viewer des Dokuments wird auch in diesem Fall ein FlowDocumentReader benutzt. Das FlowDocument beschreibt drei Blöcke, unter ihnen eine Tabelle. Um den Code nicht unnötig aufzublähen, ist in der Tabelle nur eine Zeile definiert. Das wird aber ausreichen, um den Ablauf zu erklären.

Sehen wir uns exemplarisch die erste Paragraph-Definition an. Ein Paragraph-Objekt verwaltet eine Collection von Inline-Objekten, die über die Eigenschaft Inlines veröffentlicht wird. Jedes zu einem Paragraph-Objekt gehörende Inline-Objekt muss dieser Collection hinzugefügt werden. In unserem Beispielprogramm handelt es sich um ein TextBlock-Objekt. Sehr ähnlich wird auch das zweite Paragraph-Objekt behandelt.

Ein Table-Block beschreibt mindestens ein TableGroup-Objekt, das seinerseits mehrere Zeilen beherbergt. Eine Zeile wiederum ist durch TableCell-Objekte beschrieben. Jedes TableCell-Objekt muss der Collection aller Zellen einer Tabellenzeile hinzugefügt werden, zum Beispiel so:


row1.Cells.Add(cell00);

row1 ist hierbei die Referenz einer Tabellenzeile.

Mit


rowGroup.Rows.Add(row1);

wird die Zeile zum Mitglied des TableRowGroup-Objekts. Die TableRowGroup wird mit


table.RowGroups.Add(rowGroup);

zu einem Mitglied der Tabelle.

Ein FlowDocument beschreibt mit einer Collection vom Typ BlockCollection alle in ihm enthaltenen Blöcke. Natürlich müssen auch diese Blöcke erst dem Dokument bekannt gegeben werden. Im Fall unserer Tabelle ist das die Anweisung


document.Blocks.Add(table);

Das FlowDocument muss natürlich auch noch dem Viewer übergeben werden, der sich selbst auch noch dem Window-Objekt bekannt machen muss. Hierfür sind die beiden Anweisungen


flowReader.Document = document;
this.Content = flowReader;

zuständig.


Galileo Computing - Zum Seitenanfang

19.6.6 Speichern und Laden von FlowDocuments topZur vorigen Überschrift

Sie können ein FlowDocument als XAML-Datei speichern. Hierbei kommt die Klasse XamlWriter ins Spiel, deren Namespace System.Windows.Markup Sie mit using bekannt geben sollten. Mit der statischen Methode Save() der Klasse wird das Dokument in die angegebene Datei geschrieben.


FileStream fs = new FileStream(@"C:\test.xaml", FileMode.Create);
XamlWriter.Save(FlowDocument, fs);
fs.Close();

Zum Laden eines FlowDocument kommt die Klasse XamlWriter zum Einsatz. Hier ist es die statische Methode Load(), die das Laden initiiert.


File.OpenRead(@"C:\test.xaml");
DocumentViewer.DocumentProperty = XamlReader.Load(fs);
fs.Close();



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern