Thomas Claudius Huber - s3-eu-west-1.amazonaws.com · Thomas Claudius Huber Windows Presentation...

Thomas Claudius Huber

Windows Presentation Foundation

1538.book Seite 1 Mittwoch, 9. Juni 2010 4:40 16

Auf einen Blick

TEIL I WPF-Grundlagen und Konzepte

1 Einführung in die WPF ........................................................................... 39

2 Das Programmiermodell ........................................................................ 77

3 XAML .................................................................................................... 141

4 Der Logical und der Visual Tree ............................................................. 189

5 Controls ................................................................................................. 233

6 Layout ................................................................................................... 309

7 Dependency Properties .......................................................................... 385

8 Routed Events ....................................................................................... 427

9 Commands ............................................................................................ 469

TEIL II Fortgeschrittene Techniken

10 Ressourcen ............................................................................................ 519

11 Styles, Trigger und Templates ................................................................ 569

12 Daten .................................................................................................... 643

TEIL III Reichhaltige Medien und eigene Controls

13 2D-Grafik ............................................................................................... 773

14 3D-Grafik ............................................................................................... 849

15 Animationen .......................................................................................... 895

16 Audio und Video ................................................................................... 959

17 Eigene Controls ...................................................................................... 983

18 Text und Dokumente ............................................................................. 1037

TEIL IV WPF-Anwendungen und Interoperabilität

19 Windows, Navigation und XBAP ............................................................ 1101

20 Interoperabilität ..................................................................................... 1163


5

Inhalt

Vorwort ...................................................................................................................... 21Hinweise zum Buch ..................................................................................................... 25

TEIL I WPF-GRUNDLAGEN UND KONZEPTE

1 Einführung in die WPF ........................................................................ 39

1.1 Die WPF und das .NET Framework ........................................................... 391.1.1 Die WPF im .NET Framework 3.0 .............................................. 391.1.2 Die WPF und das .NET Framework 3.5 ...................................... 401.1.3 Die WPF und das .NET Framework 4.0 ...................................... 411.1.4 Die WPF als zukünftiges Programmiermodell ............................. 431.1.5 Stärken und Eigenschaften der WPF ........................................... 451.1.6 Auf Wiedersehen GDI+ .............................................................. 47

1.2 Von Windows 1.0 zur Windows Presentation Foundation ........................ 481.2.1 Die ersten Wrapper um die Windows-API ................................. 481.2.2 Windows Forms und GDI+ ......................................................... 481.2.3 Die Windows Presentation Foundation ...................................... 49

1.3 Die Architektur der WPF .......................................................................... 521.3.1 MilCore – die »Display Engine« .................................................. 531.3.2 WindowsBase ............................................................................ 561.3.3 PresentationCore ....................................................................... 561.3.4 PresentationFramework ............................................................. 571.3.5 Vorteile und Stärken der WPF-Architektur ................................. 57

1.4 Konzepte .................................................................................................. 591.4.1 XAML ........................................................................................ 601.4.2 Dependency Properties .............................................................. 621.4.3 Routed Events ........................................................................... 661.4.4 Commands ................................................................................ 691.4.5 Styles und Templates ................................................................. 721.4.6 3D ............................................................................................. 73

1.5 Zusammenfassung .................................................................................... 75

2 Das Programmiermodell ...................................................................... 77

2.1 Einführung ............................................................................................... 772.2 Grundlagen der WPF ................................................................................ 78

2.2.1 Namespaces .............................................................................. 78


Inhalt

6

2.2.2 Assemblies ................................................................................. 792.2.3 Die Klassenhierarchie ................................................................. 79

2.3 Projektvorlagen in Visual Studio 2010 ...................................................... 872.3.1 WPF-Anwendung (Windows) ..................................................... 882.3.2 WPF-Browseranwendung (Web) ................................................ 892.3.3 WPF-Benutzersteuerelementbibliothek ...................................... 892.3.4 Benutzerdefinierte WPF-Steuerelementbibliothek ...................... 90

2.4 Windows-Projekte mit Visual Studio 2010 ............................................... 912.4.1 Ein Windows-Projekt mit XAML und C# .................................... 922.4.2 Eine reine Codeanwendung (C#) ................................................ 1052.4.3 Eine reine, kompilierte XAML-Anwendung ................................ 1072.4.4 Best Practice .............................................................................. 110

2.5 Application, Dispatcher und Window ....................................................... 1102.5.1 Die Klasse Application ............................................................... 1102.5.2 Die Klasse Dispatcher ................................................................ 1182.5.3 Fenster mit der Klasse Window .................................................. 124


3 XAML ................................................................................................... 141

3.1 Einführung ............................................................................................... 1413.2 <Warum>XAML?</Warum> ..................................................................... 1413.3 Elemente und Attribute ............................................................................ 1443.4 Namespaces ............................................................................................. 145

3.4.1 Der XML-Namespace der WPF .................................................. 1463.4.2 Der XML-Namespace für XAML ................................................. 1493.4.3 Über Namespace-Alias ............................................................... 1503.4.4 XAML mit eigenen CLR-Namespaces erweitern .......................... 151

3.5 Properties in XAML setzen ....................................................................... 1543.5.1 Die Attribut-Syntax .................................................................... 1553.5.2 Die Property-Element-Syntax ..................................................... 1563.5.3 Die Content-Property (Default-Property) ................................... 1573.5.4 Die Attached-Property-Syntax ................................................... 159

3.6 Type-Converter ........................................................................................ 1593.6.1 Vordefinierte Type-Converter .................................................... 1603.6.2 Eigene Type-Converter implementieren ..................................... 1623.6.3 Type-Converter in C# verwenden ............................................... 166

3.7 Markup-Extensions ................................................................................... 1683.7.1 Verwenden von Markup-Extensions in XAML und C# ................ 1683.7.2 XAML-Markup-Extensions ......................................................... 1713.7.3 Markup-Extensions der WPF ...................................................... 172


Inhalt

7

3.8 XAML-Spracherweiterungen ..................................................................... 1733.9 Collections in XAML ................................................................................. 178

3.9.1 Collections, die IList implementieren ......................................... 1793.9.2 Collections, die IDictionary implementieren ............................... 180

3.10 XamlReader und XamlWriter .................................................................... 1833.10.1 XAML mit XamlReader dynamisch laden .................................... 1833.10.2 Objekte mit XamlWriter in XAML serialisieren ........................... 185


4 Der Logical und der Visual Tree .......................................................... 189

4.1 Einleitung ................................................................................................. 1894.2 Zur Veranschaulichung verwendete Komponenten ................................... 192

4.2.1 Der InfoDialog von FriendStorage .............................................. 1924.2.2 Die Anwendung XAMLPadExtensionClone ................................ 193

4.3 Der Logical Tree ....................................................................................... 1954.3.1 Der Logical Tree des InfoDialogs ................................................ 1954.3.2 Für den Logical Tree verantwortliche Klassen ............................. 1994.3.3 Die Klasse LogicalTreeHelper ..................................................... 2034.3.4 NameScopes, FindName und FindLogicalNode .......................... 208

4.4 Der Visual Tree ......................................................................................... 2154.4.1 Der Visual Tree des InfoDialogs ................................................. 2164.4.2 Eigene Klassen im Visual Tree .................................................... 2194.4.3 Die Klasse VisualTreeHelper ....................................................... 2224.4.4 Der Visual Tree und das Rendering ............................................ 225


5 Controls ............................................................................................... 233

5.1 Einleitung ................................................................................................. 2335.2 Die Klasse Control .................................................................................... 2365.3 ContentControls ....................................................................................... 238

5.3.1 Buttons ...................................................................................... 2415.3.2 Labels ........................................................................................ 2485.3.3 ToolTips anzeigen ...................................................................... 2505.3.4 Scrollen mit ScrollViewer ........................................................... 2535.3.5 WPF- und HTML-Inhalte mit Frame darstellen ........................... 2565.3.6 ContentControls mit Header ...................................................... 258

5.4 ItemsControls ........................................................................................... 2615.4.1 ItemsControls mit Header .......................................................... 2645.4.2 Baumansicht mit der TreeView .................................................. 267


Inhalt

8

5.4.3 Navigation über Menüs ............................................................. 2725.4.4 Elemente mit einem Selector auswählen .................................... 2775.4.5 Eine StatusBar mit Informationen ............................................... 2845.4.6 »Alternating Rows« mit AlternationCount .................................. 285

5.5 Controls zur Textdarstellung und -bearbeitung ......................................... 2865.5.1 TextBox zum Editieren von Text ................................................. 2875.5.2 RichTextBox für formatierten Text .............................................. 2895.5.3 PasswordBox für maskierten Text ............................................... 2895.5.4 TextBlock zur Anzeige von Text .................................................. 2905.5.5 Zeichnen mit dem InkCanvas ..................................................... 290

5.6 Datum-Controls ........................................................................................ 2935.6.1 Calendar .................................................................................... 2935.6.2 DatePicker ................................................................................. 296

5.7 Range-Controls ......................................................................................... 2975.7.1 Bereich mit Slider auswählen ..................................................... 2985.7.2 ProgressBar zur Statusanzeige .................................................... 2995.7.3 Scrollen mit der ScrollBar ........................................................... 300

5.8 Sonstige, einfachere Controls .................................................................... 3005.8.1 Decorator zum Ausschmücken ................................................... 3005.8.2 Bilder mit der Image-Klasse darstellen ....................................... 3025.8.3 Einfaches Popup anzeigen .......................................................... 303


6 Layout .................................................................................................. 309

6.1 Einleitung ................................................................................................. 3096.2 Der Layoutprozess .................................................................................... 310

6.2.1 Die zwei Schritte des Layoutprozesses ....................................... 3106.2.2 MeasureOverride und ArrangeOverride ..................................... 3126.2.3 Ein eigenes Layout-Panel (DiagonalPanel) .................................. 3136.2.4 Zusammenfassung des Layoutprozesses ..................................... 318

6.3 Layoutfunktionalität von Elementen ......................................................... 3196.3.1 Width und Height ...................................................................... 3196.3.2 Margin und Padding .................................................................. 3206.3.3 Alignments ................................................................................ 3226.3.4 Die Visibility-Property ................................................................ 3246.3.5 Die UseLayoutRounding-Property .............................................. 3256.3.6 Transformationen ....................................................................... 327

6.4 Panels ...................................................................................................... 3386.4.1 Die Klasse Panel ........................................................................ 3396.4.2 Canvas ....................................................................................... 341


Inhalt

9

6.4.3 StackPanel ................................................................................. 3436.4.4 WrapPanel ................................................................................. 3456.4.5 DockPanel ................................................................................. 3466.4.6 Grid ........................................................................................... 3486.4.7 Primitive Panels ......................................................................... 3616.4.8 Übersicht der Alignments in den verschiedenen Panels .............. 3636.4.9 Wenn der Platz im Panel nicht ausreicht .................................... 365

6.5 Das Layout von FriendStorage .................................................................. 3676.5.1 Das Hauptfenster aus Benutzersicht ........................................... 3676.5.2 Das Hauptfenster aus Entwicklersicht ......................................... 3696.5.3 Animation des Freunde-Explorers .............................................. 378


7 Dependency Properties ....................................................................... 385

7.1 Einleitung ................................................................................................. 3857.2 Die Keyplayer ........................................................................................... 386

7.2.1 DependencyObject und DependencyProperty ........................... 3867.2.2 Was ist die Property Engine? ...................................................... 388

7.3 Dependency Properties ............................................................................ 3897.3.1 Eine Dependency Property implementieren ............................... 3907.3.2 Metadaten einer Dependency Property ..................................... 3927.3.3 Validieren einer Dependency Property ....................................... 3997.3.4 Die FontSize-Property als Ziel eines Data Bindings ..................... 4027.3.5 Existierende Dependency Properties verwenden ........................ 4047.3.6 Read-only-Dependency-Properties implementieren ................... 4067.3.7 Ermittlung des Wertes einer Dependency Property .................... 4097.3.8 Lokal gesetzte Werte löschen ..................................................... 4107.3.9 Überblick der Quellen mit DependencyPropertyHelper .............. 4127.3.10 Auf Änderungen in existierenden Klassen lauschen .................... 412

7.4 Attached Properties .................................................................................. 4137.4.1 Eine Attached Property implementieren .................................... 4147.4.2 Ein einfaches Panel mit Attached Properties .............................. 4177.4.3 Bekannte Vertreter .................................................................... 421


8 Routed Events ..................................................................................... 427


8.2.1 Die Klassen RoutedEvent und EventManager ............................. 428


Inhalt

10

8.2.2 Die Routing-Strategie ................................................................ 4298.2.3 Das Interface IInputElement ...................................................... 4328.2.4 Die Klasse RoutedEventArgs ...................................................... 4338.2.5 Das Event System ...................................................................... 434

8.3 Eigene Routed Events ............................................................................... 4358.3.1 Ein Routed Event implementieren .............................................. 4358.3.2 Das Routed Event als Attached Event verwenden ...................... 4408.3.3 Existierende Routed Events in eigenen Klassen nutzen ............... 4428.3.4 Instanz- und Klassenbehandlung ................................................ 443

8.4 Die RoutedEventArgs im Detail ................................................................ 4488.4.1 Sender vs. Source und OriginalSource ........................................ 4498.4.2 Die Handled-Property ................................................................ 451

8.5 Routed Events der WPF ............................................................................ 4538.5.1 Tastatur-Events .......................................................................... 4548.5.2 Maus-Events .............................................................................. 4588.5.3 Stylus-Events (Stift) .................................................................... 4628.5.4 Multitouch-Events ..................................................................... 4638.5.5 Die statischen Mitglieder eines FrameworkElements .................. 466


9 Commands ........................................................................................... 469


9.2.1 Das Interface ICommand ........................................................... 4709.2.2 Das Interface ICommandSource ................................................. 471

9.3 Eigene Commands mit ICommand ............................................................ 4729.3.1 Ein Command implementieren ................................................... 4729.3.2 Das Command verwenden ......................................................... 4739.3.3 Das Command von der Logik entkoppeln ................................... 474

9.4 Die »wahren« Keyplayer ........................................................................... 4779.4.1 Die Klassen RoutedCommand/RoutedUICommand .................... 4789.4.2 Der CommandManager .............................................................. 4809.4.3 Die Klasse CommandBinding ..................................................... 4819.4.4 Elemente mit einer CommandBindings-Property ........................ 4829.4.5 Das Zusammenspiel der Keyplayer ............................................. 483

9.5 Eigene Commands mit der Klasse RoutedUICommand .............................. 4869.5.1 Die eigenen Commands in FriendStorage ................................... 4879.5.2 Commands mit InputGestures versehen ..................................... 4889.5.3 CommandBindings zum Window-Objekt hinzufügen ................. 4909.5.4 Die Commands im Menü und in der ToolBar verwenden ........... 492


Inhalt

11

9.6 Built-in-Commands der WPF .................................................................... 4979.6.1 Built-in-Commands in FriendStorage ......................................... 4989.6.2 Bestehende Commands mit InputBindings auslösen ................... 5009.6.3 Controls mit integrierten CommandBindings .............................. 502

9.7 Das Model-View-ViewModel-Pattern (MVVM) ........................................ 5059.7.1 Die Idee des Model-View-Controller-Patterns (MVC) ................ 5069.7.2 Die Idee des Model-View-ViewModel-Patterns (MVVM) .......... 5079.7.3 Ein MVVM-Beispiel ................................................................... 509


TEIL II FORTGESCHRITTENE TECHNIKEN

10 Ressourcen ........................................................................................... 519

10.1 Logische Ressourcen ................................................................................. 51910.1.1 Logische Ressourcen definieren und verwenden ........................ 52010.1.2 Die Suche nach Ressourcen im Detail ........................................ 52310.1.3 Elemente als Ressourcen verwenden .......................................... 52710.1.4 Statische Ressourcen .................................................................. 53010.1.5 Dynamische Ressourcen ............................................................. 53210.1.6 Ressourcen in separate Dateien auslagern .................................. 53610.1.7 Logische Ressourcen in FriendStorage ........................................ 539

10.2 Binäre Ressourcen .................................................................................... 54110.2.1 Binäre Ressourcen im .NET Framework ...................................... 54210.2.2 Binäre Ressourcen bei der WPF ................................................. 54510.2.3 Die Pack-URI-Syntax .................................................................. 54810.2.4 Auf Dateien im Anwendungsverzeichnis zugreifen ..................... 54910.2.5 In C# auf binäre Ressourcen zugreifen ........................................ 55010.2.6 Lokalisierung von WPF-Anwendungen ....................................... 55310.2.7 Eine binäre Ressource als Splashscreen ...................................... 563


11 Styles, Trigger und Templates ............................................................. 569

11.1 Einleitung ................................................................................................. 56911.2 Styles ....................................................................................................... 570

11.2.1 Grundlagen und Keyplayer ......................................................... 57011.2.2 Styles als logische Ressourcen definieren ................................... 57311.2.3 Einen Style für verschiedene Typen verwenden .......................... 57711.2.4 Bestehende Styles erweitern ...................................................... 579


Inhalt

12

11.2.5 Setter und EventSetter ............................................................... 58111.2.6 Styles und Trigger ...................................................................... 584

11.3 Trigger ...................................................................................................... 58411.3.1 Property-Trigger ........................................................................ 58511.3.2 DataTrigger ................................................................................ 59011.3.3 EventTrigger .............................................................................. 59211.3.4 Komplexe Bedingungen mit Triggern ......................................... 597

11.4 Templates ................................................................................................. 59911.4.1 Arten von Templates .................................................................. 59911.4.2 Layout mit ItemsPanelTemplate ................................................. 60111.4.3 Daten mit DataTemplates visualisieren ....................................... 60211.4.4 Das Aussehen von Controls mit ControlTemplates anpassen ...... 60611.4.5 Das Default-ControlTemplate eines Controls .............................. 60911.4.6 Verbindung zwischen Control und Template .............................. 61211.4.7 Two-Way-Contract zwischen Control und Template ................... 61611.4.8 VisualStateManager statt Trigger verwenden ............................. 62011.4.9 Templates in C# ......................................................................... 631

11.5 Styles, Trigger & Templates in FriendStorage ............................................. 63211.5.1 Der Next-Button ........................................................................ 63311.5.2 Die Image-Objekte der Toolbar-Buttons .................................... 63511.5.3 Die DataGridRows des Freunde-Explorers .................................. 637


12 Daten ................................................................................................... 643

12.1 Einleitung ................................................................................................. 64312.2 Data Binding ............................................................................................ 644

12.2.1 Data Binding in XAML ............................................................... 64412.2.2 Data Binding in C# ..................................................................... 64512.2.3 Die Binding-Klasse im Detail ...................................................... 64612.2.4 Der DataContext ........................................................................ 64912.2.5 Die Path-Property im Detail ....................................................... 65012.2.6 Die Richtung des Bindings ......................................................... 65212.2.7 Der UpdateSourceTrigger ........................................................... 65412.2.8 Die BindingExpression ............................................................... 65512.2.9 Bindings entfernen ..................................................................... 65712.2.10 Debugging von Data Bindings .................................................... 658

12.3 Datenquellen eines Data Bindings ............................................................ 66012.3.1 Binding an die Dependency Properties eines Elements ............... 66012.3.2 Binding an einfache .NET Properties .......................................... 66112.3.3 Binding an logische Ressourcen ................................................. 663


Inhalt

13

12.3.4 Binding an Quellen unterschiedlichen Typs ................................ 66412.3.5 Binding an relative Quellen mit RelativeSource .......................... 66712.3.6 Binding der Target-Property an mehrere Quellen ....................... 66912.3.7 DataSourceProvider für Objekte und XML ................................. 67412.3.8 Binding an XLinq ....................................................................... 681

12.4 Data Binding an Collections ...................................................................... 68212.4.1 Der Fallback-Mechanismus ........................................................ 68212.4.2 Die CollectionViews der WPF .................................................... 68612.4.3 Die DefaultView ........................................................................ 69012.4.4 Daten filtern, sortieren und gruppieren ...................................... 69112.4.5 Hinzufügen und Löschen von Daten ........................................... 69712.4.6 Mehrere Collections als Datenquelle verwenden ........................ 69812.4.7 Binding an ADO.NET DataSet .................................................... 699

12.5 Benutzereingaben validieren ..................................................................... 70212.5.1 Validieren mit ExceptionValidationRule ..................................... 70412.5.2 Validieren mit eigener ValidationRule ........................................ 70612.5.3 Validieren mit DataErrorValidationRule ..................................... 70712.5.4 Die Validation-Klasse ................................................................. 70912.5.5 Validieren mehrerer Bindings mit BindingGroup ........................ 711

12.6 Das DataGrid ............................................................................................ 72012.6.1 Die verwendeten Testdaten ....................................................... 72112.6.2 Autogenerieren von Columns ..................................................... 72312.6.3 Unterschiedliche Column-Typen ................................................ 72512.6.4 Columns manuell zum DataGrid hinzufügen ............................... 72812.6.5 Die Breite einer Column ............................................................ 73012.6.6 Columns mit der DataGridTemplateColumn ............................... 73112.6.7 RowDetails anzeigen .................................................................. 73312.6.8 Daten gruppieren ...................................................................... 73512.6.9 Die Auswahlmöglichkeiten festlegen .......................................... 73712.6.10 Auf ausgewählte Daten zugreifen ............................................... 73712.6.11 Bearbeiten von Daten ................................................................ 73912.6.12 Daten im DataGrid validieren .................................................... 74012.6.13 Sonstige Eigenschaften des DataGrids ........................................ 744

12.7 Daten mit DataTemplates visualisieren ..................................................... 74512.7.1 Auswahl mit DataTemplateSelector ........................................... 74512.7.2 Hierarchische DataTemplates ..................................................... 747

12.8 Drag & Drop ............................................................................................. 75012.9 Daten in FriendStorage ............................................................................. 754

12.9.1 Die Entitäten Friend, Address und FriendCollection ................... 75512.9.2 Daten im MainWindow ............................................................. 755


Inhalt

14

12.9.3 Daten im NewFriendDialog ....................................................... 76512.9.4 Speichern in gezippter .friends-Datei ......................................... 767


TEIL III REICHHALTIGE MEDIEN UND EIGENE CONTROLS

13 2D-Grafik ............................................................................................. 773

13.1 Einleitung ................................................................................................. 77313.2 Shapes ...................................................................................................... 774

13.2.1 Das Rectangle ............................................................................ 77513.2.2 Die Ellipse ................................................................................. 77613.2.3 Linien mit Line und Polyline ...................................................... 77613.2.4 Spezielle Formen mit Polygon .................................................... 77813.2.5 Ein Außerirdischer aus Shapes .................................................... 78113.2.6 Die StrokeXXX-Properties der Shape-Klasse ............................... 78213.2.7 Komplexe Shapes mit Path ........................................................ 785

13.3 Geometries ............................................................................................... 78613.3.1 RectangleGeometry und EllipseGeometry .................................. 78713.3.2 LineGeometry ............................................................................ 78813.3.3 Mehrere Geometry-Objekte gruppieren ..................................... 78913.3.4 Geometries kombinieren ............................................................ 78913.3.5 Komplexe Formen mit PathGeometry ........................................ 79113.3.6 Die Klasse StreamGeometry ....................................................... 79413.3.7 Die Path-Markup-Syntax ............................................................ 79513.3.8 Clipping mit Geometry-Objekten ............................................... 797

13.4 Drawings .................................................................................................. 79713.4.1 GeometryDrawing und DrawingGroup ....................................... 79813.4.2 ImageDrawing und VideoDrawing ............................................. 80013.4.3 Ein Außerirdischer aus Geometries und Drawings ...................... 801

13.5 Programmierung des Visual Layers ............................................................ 80313.5.1 Die Klasse DrawingContext ........................................................ 80413.5.2 DrawingVisual einsetzen ............................................................ 80513.5.3 Visual-Hit-Testing ...................................................................... 807

13.6 Brushes .................................................................................................... 80813.6.1 Der SolidColorBrush und die Color-Struktur ............................... 80913.6.2 Farbverläufe mit GradientBrushes .............................................. 81113.6.3 TileBrushes ................................................................................ 815

13.7 Cached Compositions ............................................................................... 82113.7.1 BitmapCache für ein Element aktivieren ..................................... 822


Inhalt

15

13.7.2 Nebeneffekte des Cachings ........................................................ 82313.7.3 Element mit BitmapCacheBrush zeichnen .................................. 826

13.8 Effekte ...................................................................................................... 82813.8.1 Die Effect-Klassen ...................................................................... 82813.8.2 Blur und DropShadow verwenden ............................................. 82813.8.3 Properties von BlurEffect und DropShadowEffect ....................... 83013.8.4 Effekte mit eigenen Pixelshadern ............................................... 83113.8.5 Pixelshader mit weiteren Konstanten ......................................... 840

13.9 Bitmaps .................................................................................................... 84313.9.1 BitmapSources – Bildquellen ...................................................... 84313.9.2 Bitmap-Operationen .................................................................. 84413.9.3 Bitmap-Operationen in FriendStorage ........................................ 845


14 3D-Grafik ............................................................................................. 849

14.1 Einleitung ................................................................................................. 84914.2 3D im Überblick ....................................................................................... 850

14.2.1 Inhalte einer 3D-Szene .............................................................. 85014.2.2 2D und 3D im Vergleich ............................................................ 851

14.3 Die Objekte einer 3D-Szene im Detail ...................................................... 85314.3.1 Das 3D-Koordinatensystem ....................................................... 85314.3.2 Der Viewport3D als Fernseher ................................................... 85414.3.3 Die richtige Kamera ................................................................... 85514.3.4 Visual3D-Objekte ...................................................................... 85914.3.5 Model3D-Objekte ..................................................................... 86014.3.6 GeometryModel3D aufbauen .................................................... 86114.3.7 Licht ins Dunkel bringen ............................................................ 86714.3.8 Transformationen ...................................................................... 87014.3.9 Verschiedene Materialien .......................................................... 87314.3.10 Texturen .................................................................................... 87414.3.11 Normalen .................................................................................. 878

14.4 Benutzerinteraktion mit 3D-Objekten ....................................................... 88214.4.1 Interaktivität in WPF 3.0 mit Visual-Hit-Testing ......................... 88214.4.2 Interaktivität in WPF 3.5 mit UIElement3D ................................ 88314.4.3 Interaktive 2D-Elemente auf 3D-Objekten in WPF 3.5 ............... 885

14.5 Komplexe 3D-Objekte .............................................................................. 88714.5.1 Landschaft im Code generieren .................................................. 88714.5.2 Kugel erstellen ........................................................................... 88914.5.3 Komplexe 3D-Objekte mit Third-Party-Tools erstellen ............... 891



Inhalt

16

15 Animationen ........................................................................................ 895

15.1 Einleitung ................................................................................................. 89515.2 Animationsgrundlagen .............................................................................. 896

15.2.1 Voraussetzungen für Animationen ............................................. 89615.2.2 Übersicht der Animationsarten und -klassen .............................. 89715.2.3 Timelines und Clocks ................................................................. 90015.2.4 Das Interface IAnimatable .......................................................... 903

15.3 Basis-Animationen in C# ........................................................................... 90415.3.1 Start- und Zielwert mit From, To und By .................................... 90515.3.2 Dauer, Startzeit und Geschwindigkeit ........................................ 90815.3.3 Rückwärts und Wiederholen ...................................................... 91115.3.4 Die Gesamtlänge einer Timeline ................................................. 91215.3.5 Wiederholen mit neuen Werten ................................................ 91215.3.6 Beschleunigen und Abbremsen .................................................. 91415.3.7 Das Füllverhalten einer Animation ............................................. 91515.3.8 Animation mit AnimationClock steuern ...................................... 91715.3.9 Animationen in FriendStorage .................................................... 921

15.4 Basis-Animationen in XAML ..................................................................... 92215.4.1 Einfache Animation in XAML ..................................................... 92515.4.2 Das Storyboard als Timeline-Container ....................................... 92815.4.3 Animation mit ControllableStoryboard steuern .......................... 931

15.5 Keyframe-Animationen ............................................................................. 93315.5.1 Lineare Keyframe-Animationen .................................................. 93415.5.2 SplineKeyframe-Animationen ..................................................... 93715.5.3 Animationen mit diskreten Keyframes ........................................ 938

15.6 Pfad-Animationen .................................................................................... 94215.7 Easing Functions ....................................................................................... 944

15.7.1 Grundlagen der Easing Functions ............................................... 94415.7.2 Easing Functions in Basis-Animationen ...................................... 94815.7.3 Easing Functions in Keyframe-Animationen ............................... 95015.7.4 Eigene Easing Functions erstellen ............................................... 952

15.8 Low-Level-Animationen ........................................................................... 95415.9 Zusammenfassung .................................................................................... 958

16 Audio und Video .................................................................................. 959

16.1 Einleitung ................................................................................................. 95916.2 Audio (.wav) mit SoundPlayerAction und SoundPlayer ............................. 959

16.2.1 Audio mit SoundPlayerAction (XAML) ....................................... 96016.2.2 Audio mit SoundPlayer (C#) ....................................................... 961


Inhalt

17

16.3 Audio und Video mit MediaPlayer (C#) .................................................... 96316.3.1 Einfaches Abspielen ................................................................... 96416.3.2 Steuerung mit MediaClock und MediaTimeline .......................... 967

16.4 Audio und Video mit MediaElement (XAML) ............................................ 97016.4.1 Einfaches Abspielen ................................................................... 97116.4.2 Steuerung mit Methoden (unabhängiger Modus) ....................... 97216.4.3 Steuerung mit MediaTimeline (Clock-Modus) ............................ 97216.4.4 Storyboard mit MediaTimeline und AnimationTimeline ............. 97516.4.5 Snapshots von Videos ................................................................ 977


17 Eigene Controls ................................................................................... 983

17.1 Einleitung ................................................................................................. 98317.2 Custom Control ........................................................................................ 984

17.2.1 Die Struktur eines Custom Controls ........................................... 98517.2.2 Der zu erstellende VideoPlayer .................................................. 98817.2.3 Klassenname anpassen ............................................................... 98817.2.4 Template-Parts definieren .......................................................... 99017.2.5 Dependency Properties erstellen ................................................ 99317.2.6 Routed Events implementieren .................................................. 99717.2.7 Commands unterstützen ............................................................ 99817.2.8 Das Aussehen des lookless Controls festlegen ............................ 100117.2.9 Das Control testen ..................................................................... 100617.2.10 Optional weitere Theme-Styles anlegen ..................................... 100717.2.11 Templates auf Windows-Ebene definieren ................................. 1010

17.3 Custom Control mit Visual States .............................................................. 101417.3.1 Visual States im Code implementieren ....................................... 101417.3.2 States für andere sichtbar machen ............................................. 101717.3.3 States im Default-ControlTemplate unterstützen ........................ 101817.3.4 Den VideoPlayer mit Visual States testen ................................... 1020

17.4 User Control ............................................................................................. 102117.4.1 Die Struktur eines User Controls ................................................ 102117.4.2 Das zu erstellende PrintableFriend-Control ................................ 102317.4.3 UI des Controls definieren ......................................................... 102417.4.4 Properties in der Codebehind-Datei erstellen ............................. 102517.4.5 Die Content-Property festlegen .................................................. 1027

17.5 Alternativen zu Custom Control und User Control .................................... 102817.5.1 Wann sollte man die OnRender-Methode überschreiben? ......... 102817.5.2 Adorner erstellen und Elemente damit ausschmücken ................ 1028



Inhalt

18

18 Text und Dokumente ........................................................................... 1037

18.1 Einleitung ................................................................................................. 103718.2 Text .......................................................................................................... 1038

18.2.1 FrameworkContentElement als Basis für Text ............................. 103918.2.2 Formatierung mit Spans ............................................................. 104018.2.3 Formatierung mit den Properties aus TextElement ..................... 104218.2.4 Elemente im Text mit InlineUIContainer .................................... 104518.2.5 Fonts und Typefaces .................................................................. 104518.2.6 Typographie ............................................................................... 104718.2.7 Die FormattedText-Klasse .......................................................... 104818.2.8 Texteffekte ................................................................................ 104918.2.9 Nützliche Eigenschaften der TextBlock-Klasse ............................ 1051

18.3 Das Text-Rendering beeinflussen .............................................................. 105318.3.1 Kleine Zeichen sind schlecht lesbar ............................................ 105418.3.2 Die Schrift führt beim Animieren zu Performance-Problemen ..... 105518.3.3 Der Algorithmus für das Anti-Aliasing lässt sich nicht

festlegen .................................................................................... 105518.3.4 Der ClearType-Algorithmus greift nicht immer ........................... 1056

18.4 Flow-Dokumente ..................................................................................... 105818.4.1 Die Klasse FlowDocument ......................................................... 105818.4.2 Die fünf Block-Arten .................................................................. 106018.4.3 Die AnchoredBlocks Figure und Floater ..................................... 106418.4.4 Controls zum Betrachten ............................................................ 1067

18.5 Annotationen ........................................................................................... 106918.6 XPS-Dokumente (Fixed-Dokumente) ........................................................ 1073

18.6.1 FlowDocument als XPS speichern .............................................. 107418.6.2 XPS-Dokument laden und anzeigen ........................................... 107818.6.3 Die Inhalte eines XPS-Dokuments .............................................. 107918.6.4 XPS in C# mit FixedDocument & Co. erstellen ........................... 1083

18.7 Drucken ................................................................................................... 108518.7.1 Einfaches Ausdrucken ................................................................ 108518.7.2 Drucken mit PrintQueue ............................................................ 108718.7.3 Festlegen von Druckeigenschaften mit PrintTicket ..................... 108818.7.4 Drucken mit PrintDialog ............................................................ 1088

18.8 Dokumente in FriendStorage .................................................................... 109018.8.1 Hilfe mit Flow-Dokument .......................................................... 109018.8.2 Export der Freundesliste als XPS ................................................ 109118.8.3 Drucken der Freundesliste ......................................................... 1096



Inhalt

19

TEIL IV WPF-ANWENDUNGEN UND INTEROPERABILITÄT

19 Windows, Navigation und XBAP ........................................................ 1101

19.1 Einleitung ................................................................................................. 110119.2 Windows-Anwendungen .......................................................................... 1102

19.2.1 »Built-in-Dialoge ........................................................................ 110219.2.2 Anwendungen mit UI Automation automatisieren ..................... 110419.2.3 Deployment ............................................................................... 1120

19.3 Windows-Anwendungen und die Windows 7-Taskbar .............................. 112119.3.1 Übersicht der Möglichkeiten ...................................................... 112219.3.2 Thumb-Buttons im Vorschaufenster ........................................... 112419.3.3 Ein Overlay-Bild auf dem Taskbar-Button ................................... 112719.3.4 Eine Fortschrittsanzeige auf dem Taskbar-Button ....................... 112819.3.5 Den Ausschnitt im Thumbnail festlegen ..................................... 113019.3.6 Eine JumpList mit JumpTasks ..................................................... 113119.3.7 JumpList mit JumpTasks und JumpPaths .................................... 113219.3.8 JumpList mit letzten und häufigen Elementen ............................ 1134

19.4 Navigationsanwendungen ........................................................................ 113619.4.1 Container für eine Page ............................................................. 113719.4.2 Navigation zu einer Seite/Page ................................................... 114119.4.3 Navigation-Events ...................................................................... 114619.4.4 Daten übergeben ....................................................................... 114919.4.5 Daten mittels PageFunction zurückgeben .................................. 1153

19.5 XBAP-Anwendungen ................................................................................ 115719.5.1 FriendViewer als XBAP erstellen ................................................ 115719.5.2 Generierte Dateien .................................................................... 116019.5.3 XBAP vs. Loose XAML ............................................................... 116119.5.4 XBAP vs. Silverlight .................................................................... 1161


20 Interoperabilität .................................................................................. 1163

20.1 Einleitung ................................................................................................. 116320.2 Unterstützte Szenarien und Grenzen ......................................................... 1164

20.2.1 Mögliche Interoperabilitätsszenarien ......................................... 116420.2.2 Grenzen und Einschränkungen ................................................... 1165

20.3 Windows Forms ....................................................................................... 116620.3.1 Windows Forms in WPF ............................................................ 116720.3.2 WPF in Windows Forms ............................................................ 117520.3.3 Dialoge ...................................................................................... 1176


Inhalt

20

20.4 ActiveX in WPF ........................................................................................ 117920.5 Win32 ...................................................................................................... 1181

20.5.1 Win32 in WPF ........................................................................... 118220.5.2 WPF in Win32 ........................................................................... 119220.5.3 Dialoge ...................................................................................... 119620.5.4 Win32-Nachrichten in WPF abfangen ........................................ 1201

20.6 Direct3D in WPF ...................................................................................... 120420.6.1 Voraussetzungen und Konfiguration .......................................... 120420.6.2 Die Direct3D-Oberfläche integrieren ......................................... 1206


Index ........................................................................................................................... 1211


25

Bevor es losgeht, hier noch ein paar Hinweise, wie Sie mit diesem Buch arbeiten. Auf den folgenden Seiten finden Sie kurze Inhaltsangaben zu allen Kapiteln und Infor-mationen zu den verwendeten Beispielen: wo Sie diese finden und welche Systemvor-aussetzungen notwendig sind, um sie nachzuvollziehen.

Hinweise zum Buch

Für wen ist dieses Buch gedacht?

Sie sollten über eine gute Portion an C#-Know-how und etwas Wissen rund um das .NETFramework verfügen. Fragen zu Events, Delegates, anonymen Methoden, LambdaExpressions oder Automation Properties sollten Sie nicht gleich in Verlegenheit bringen.Sind Sie beim Thema .NET oder C# etwas unsicher, empfehle ich Ihnen das Buch »VisualC# 2010 – Das umfassende Handbuch« von Andreas Kühnel.1 Grundkenntnisse in XMLsind von Vorteil, allerdings nicht zwingend erforderlich.

Das Buch richtet sich an .NET-Entwickler, die Windows-Anwendungen mit der moderns-ten Technologie aus dem Hause Microsoft implementieren möchten. Es eignet sich so-wohl für WPF-Einsteiger als auch für leicht fortgeschrittene WPF-Entwickler. Gehobenere.NET-Kenntnisse werden vorausgesetzt.

Neben den Handgriffen, die Sie zum Entwickeln einer WPF-Anwendung benötigen, erhal-ten Sie reichlich Hintergrundinformationen über Konzepte der WPF, wie die ExtensibleApplication Markup Language (XAML), Dependency Properties, Routed Events, Com-mands, Ressourcen oder Logical und Visual Trees. Für einfache Applikationen ist das Wis-sen um diese Konzepte nicht immer erforderlich, bei der Entwicklung Ihrer umfangrei-chen Wunschanwendung ist es allerdings eine wichtige Voraussetzung. Erst mit diesenKonzepten im Hinterkopf werden Sie in der Lage sein, mit der WPF erfolgreich komplexeAnwendungen zu entwickeln.

Das vorliegende Buch richtet sich also an Entwickler und nicht an grafische Designer. EinDesigner kann mit Hilfe dieses Buchs zwar den XAML-Code nachvollziehen, den seineTools wie Expression Design oder Expression Blend generieren, aber eben nur dann,wenn er auch die Grundlagen der .NET-Programmierung und C# beherrscht. Haben SieWebseiten entwickelt und dazu Tools wie FrontPage oder Dreamweaver eingesetzt, wer-

1 Erschienen bei Galileo Press, ISBN 978-3-8362-1552-7


26

Hinweise zum Buch

den Sie bestimmt die Erfahrung gemacht haben, dass für komplexere Fälle das Programmnicht den gewünschten Output liefert und Sie das HTML-Dokument manuell editierenmüssen. Gleich verhält es sich mit XAML. Obwohl es viele Tools gibt, die XAML generie-ren, werden Sie bestimmte Dinge in XAML weiterhin »händisch« erstellen oder zumin-dest anpassen müssen, um zu Ihrem Ziel zu kommen.

Aufbau des Buches

Das Buch besteht aus 20 Kapiteln, die sich grob in vier Gruppen einordnen lassen:

� WPF-Grundlagen und KonzepteIn dieser Gruppe lernen Sie die Grundlagen der WPF kennen. Dazu gehören die wich-tigsten Klassen, XAML, Controls, Layout und Konzepte der WPF, wie Dependency Pro-perties, Routed Events oder Commands.

� Kapitel 1: Einführung in die WPF

� Kapitel 2: Das Programmiermodell

� Kapitel 3: XAML

� Kapitel 4: Der Logical und der Visual Tree

� Kapitel 5: Controls

� Kapitel 6: Layout

� Kapitel 7: Dependency Properties

� Kapitel 8: Routed Events

� Kapitel 9: Commands

� Fortgeschrittene TechnikenFortgeschrittene Techniken werden in den Kapiteln 10–12 betrachtet. Dazu gehörenneben Ressourcen die in der WPF existierenden Styles, Trigger und Templates. MitLetzteren lässt sich das Aussehen von Controls neu definieren. In dieser Gruppe erfah-ren Sie auch, wie die WPF mit Daten umgeht. In diesem Zusammenhang gehe ich spe-ziell auf das Data Binding ein.

� Kapitel 10: Ressourcen

� Kapitel 11: Styles, Trigger und Templates

� Kapitel 12: Daten

� Reichhaltige Medien und eigene ControlsIn dieser Gruppe lernen Sie, wie Sie mit WPF 2D- und 3D-Grafiken darstellen und auchdynamisch erzeugen. Sie erhalten zudem das Know-how über das in die WPF integrierteAnimationssystem, über die Audio-/Video-Unterstützung und über Texte und Doku-


27

Hinweise zum Buch

mente. Die Dokumente in der WPF sind gleichzeitig auch der Schlüssel zum Drucken.Neben all den Medien lernen Sie in dieser Gruppe das Entwickeln eigener Controls.

� Kapitel 13: 2D-Grafik

� Kapitel 14: 3D-Grafik

� Kapitel 15: Animationen

� Kapitel 16: Audio und Video

� Kapitel 17: Eigene Controls

� Kapitel 18: Text und Dokumente

� WPF-Anwendungen und InteroperabilitätMit der WPF lassen sich sowohl Windows- als auch Webbrowser-Anwendungen ent-wickeln. Diese Gruppe enthält alles Wissenswerte rund um die verschiedenen Artenvon WPF-Anwendungen. Sie erfahren auch etwas über Randthemen, wie beispiels-weise die automatisierte Steuerung einer Windows-Anwendung. Ebenso zeigt Ihnendiese Gruppe, wie sich alte Technologien in einer Anwendung mittels Interoperabilitätmit der WPF verbinden lassen.

� Kapitel 19: Windows, Navigation und XBAP

� Kapitel 20: Interoperabilität

Inhalt der einzelnen Kapitel

� Kapitel 1, »Einführung in die WPF«Wir starten mit einem Überblick der WPF. Sie erfahren, wie sich die WPF ins .NETFramework eingliedert. Dabei werden die .NET-Versionen 3.0, 3.5 und 4.0 betrachtet,zudem erhalten Sie einen Überblick über die wichtigsten Neuerungen der WPF im.NET Framework 4.0. Nach einem Blick auf die Geschichte der Windows-Programmie-rung lernen Sie die technische Architektur der WPF kennen und bekommen einen ers-ten Einblick in WPF-Konzepte wie XAML, Dependency Properties, Routed Events undCommands.

� Kapitel 2, »Das Programmiermodell«Die WPF besitzt eine tief verschachtelte Klassenhierarchie. Hier lernen Sie die zentra-len Klassen kennen. Sie erhalten in diesem Kapitel eine Übersicht der Projektvorlagenin Visual Studio 2010, bevor wir die ersten WPF-Anwendungen mit speziellem Fokusauf die Klassen Application, Dispatcher und Window entwickeln.

� Kapitel 3, »XAML«Die in der WPF zum Beschreiben von Benutzeroberflächen eingesetzte XML-basierteBeschreibungssprache Extensible Application Markup Language (XAML) ist Kernpunktdieses Kapitels. Hier lernen Sie die Syntax von XAML mit zahlreichen Tipps und Trickskennen.


28

Hinweise zum Buch

� Kapitel 4, »Der Logical und der Visual Tree«Entwickeln Sie eine Benutzeroberfläche in der WPF, bauen Sie im Grunde eine Hierar-chie von Objekten auf. Ein Window enthält einen Button, ein Button einen String usw.Die WPF kennt zur Laufzeit zwei Hierarchien, die Voraussetzung für viele Funktionender WPF sind, wie Routed Events und Ressourcen. Dieses Kapitel liefert reichlich In-formationen über die Funktionsweise der beiden Hierarchien und zeigt mit einer Sub-klasse von FrameworkElement, wie die WPF die Hierarchien aufbaut.

� Kapitel 5, »Controls«Wie für ein UI-Framework üblich, enthält auch die WPF eine Vielzahl von bereits vor-definierten Controls. Dieses Kapitel zeigt Ihnen die wichtigsten dieser Controls, wieTextBox, Menu, Button, TreeView, ListBox und ListView.

� Kapitel 6, »Layout«Das Anordnen und Positionieren von Elementen auf der Benutzeroberfläche unterliegtbei der WPF dem sogenannten Layoutprozess. Dieses Kapitel verrät, was sich hinterdem Layoutprozess verbirgt, und geht speziell auf die Größe von Elementen, den Rand,die Ausrichtung, Transformationen und Layout-Panels ein. Mit dem in diesem Kapitelvermittelten Wissen sind Sie in der Lage, ein pinnbares, animiertes Fenster ähnlichdem Projektmappen-Explorer in Visual Studio zu implementieren.

� Kapitel 7, »Dependency Properties«Dependency Properties erweitern die klassischen .NET Properties um WPF-spezifischeLogik. Sie sind die Grundlage für Animationen, Styles oder Data Bindings. Was Depen-dency Properties genau sind, wozu Sie benötigt werden und wie Sie Dependency Pro-perties nutzen und implementieren, ist Thema dieses Kapitels.

� Kapitel 8, »Routed Events«Die Events der WPF treten meist als sogenannte Routed Events auf. In diesem Kapitelwird gezeigt, wie Routed Events genau funktionieren und wie Sie eigene Routed-Events implementieren. Darüber hinaus gehe ich auf Maus-, Tastatur-, Stift- undTouch-Events ein.

� Kapitel 9, »Commands«Commands sind insbesondere dann sinnvoll, wenn Sie mit mehreren Elementen(Button, MenuItem etc.) einen Befehl auslösen möchten. Neben dem Implementierenvon eigenen Commands lernen Sie in diesem Kapitel die in der WPF bereits vorhande-nen Commands kennen. Zudem erhalten Sie hier einen Blick auf das Model-View-ViewModel-Pattern (MVVM), das auf der Logik von Commands basiert.

� Kapitel 10, »Ressourcen«Dieses Kapitel zeigt Ihnen die Funktionsweise der WPF-spezifischen logischen Res-sourcen. Es wird auch auf die bereits aus älteren .NET-Versionen bekannten binärenRessourcen eingegangen und gezeigt, wie Sie Ihre Anwendung mit Hilfe von binären


29

Hinweise zum Buch

Ressourcen lokalisieren. Zudem lernen Sie hier, wie Sie auf einfache Weise einenSplashscreen erstellen.

� Kapitel 11, »Styles, Trigger und Templates«Styles werden in der WPF eingesetzt, um Werte für mehrere Properties zu definieren.Diese »Wertesammlung« lässt sich dann auf mehreren Elementen setzen. Templatesdienen dazu, das Aussehen für ein Control oder für Daten zu definieren. In einem Stylewie auch in einem Template lassen sich Trigger erstellen, die sich beispielsweise fürMouseOver-Effekte verwenden lassen. Dieses Kapitel gibt Ihnen einen gründlichenEinblick in die Möglichkeiten mit Styles, Triggern und Templates, dabei wird auch aufden in .NET 4.0 neu eingeführten VisualStateManager eingegangen.

� Kapitel 12, »Daten«Alles Wissenswerte über Data Binding lesen Sie in diesem Kapitel. Darüber hinaus gehtdieses Kapitel auf CollectionViews ein und zeigt, wie Sie bei der WPF durch Ihre Datennavigieren. Sie lernen, Daten zu gruppieren, zu sortieren, zu filtern und zu validieren.Ein Überblick über das DataGrid bringt Ihnen die zentralen Funktionen dieses Cont-rols zum Darstellen von Listen näher.

� Kapitel 13, »2D-Grafik«In diesem Kapitel erfahren Sie alles über das »Zeichnen« mit der WPF. Sie erhalten In-formationen über Brushes, Shapes und Drawings eingegangen. Zudem zeige ich hier,wie Sie Elemente mit Effekten ausstatten – die sogenannten Pixel Shader –, damit diesebeispielsweise einen Schatten werfen.

� Kapitel 14, »3D-Grafik«Dieses Kapitel führt Sie in die 3D-Programmierung mit der WPF ein und bringt Ihnendie dazu notwendigen Grundlagen näher, wie das 3D-Koordinatensystem, dasViewport3D-Element, Kameras und 3D-Modelle. Sie lernen auch, wie Sie Ihre 3D-Inhalte interaktiv gestalten.

� Kapitel 15, »Animationen«Die WPF besitzt eine integrierte Unterstützung für Animationen. In diesem Kapitel er-fahren Sie alles Notwendige über Timelines, Storyboards, einfache Animationen, Key-frame- und Pfad-Animationen und über die Animation Easing Functions.

� Kapitel 16, »Audio und Video«Integrierte Audio- und Video-Unterstützung ist eine der Stärken der WPF. Wie Sie un-ter anderem Videos in Ihre Anwendung einbinden und sie zudem noch steuern, zeigtdieses Kapitel.

� Kapitel 17, »Eigene Controls«Visual Studio bietet Ihnen zum Erstellen von Controls zwei Projektvorlagen, eine fürUser Controls und eine für Custom Controls. Wie Sie ein User Control und ein CustomControl entwickeln, erfahren Sie hier.


30

Hinweise zum Buch

� Kapitel 18, »Text und Dokumente«Reichhaltig Funktionalität bietet die WPF im Zusammenhang mit Text und Dokumen-ten. Was Flow-, Fix- und XPS-Dokumente sind und wie Sie diese Dokumente in IhrerAnwendung erstellen oder darstellen, ist Teil dieses Kapitels. Dokumente sind auch derSchlüssel zum Drucken. Sie erfahren hier also auch, wie Sie aus Ihrer WPF-Anwendungetwas ausdrucken können.

� Kapitel 19, »Windows, Navigation und XBAP«Windows-, Navigations- und XBAP-Anwendungen sind Thema dieses Kapitels. Sie ler-nen, wie Sie Ihre Windows-Anwendung in die Taskbar von Windows 7 integrierenoder wie Sie eine navigationsbasierte Anwendung entwickeln, die mehrere Seiten ent-hält. Randthemen wie UI-Automation runden das Kapitel ab. UI-Automation ist ein mitder WPF ausgeliefertes Automations-Framework, mit dem sich WPF- und Win32-Anwendungen fernsteuern lassen.

� Kapitel 20, »Interoperabilität«In diesem Kapitel erfahren Sie, wie Sie WPF mit Windows Forms, ActiveX, Win32 oderDirect3D kombinieren. Sie erhalten einen Überblick über mögliche Migrationsstrate-gien Ihrer Altanwendungen und erfahren anhand zahlreicher Beispiele, wie Sie ver-schiedene Interoperabilitätsszenarien implementieren.

Wie Sie das Buch lesen

Das Buch eignet sich, um bei Kapitel 1 zu beginnen und sich von dort Schritt für Schrittzu Kapitel 20 hinzuarbeiten. Am Ende jedes Kapitels folgt eine Zusammenfassung derwichtigsten Punkte. Daran können Sie grob kontrollieren, ob Sie die wichtigsten Inhalteeines Kapitels aufgenommen haben.

Gehören Sie nicht zu den Lesern, die Bücher von vorn nach hinten durcharbeiten, könnenSie sich natürlich auch einzelne Kapitel herauspicken und diese als Nachschlagelektüre ver-wenden. Beim Schreiben des Buchs habe ich darauf geachtet, die einzelnen Kapitel mög-lichst unabhängig voneinander zu gestalten. Allerdings sollten einzelne Kapitel auch nichtimmer alles wiederholen müssen, was in vorherigen Kapiteln bereits erläutert wurde. So-mit benötigen Sie für spätere Kapitel dieses Buchs meist ein Basiswissen, das Sie entwederbereits haben oder eben erlangen, indem Sie die vorherigen Kapitel durcharbeiten.

Hinweis

Das Buch verwendet aus didaktischen Gründen an manchen Stellen bewusst Wiederholungen.So erhalten Sie beispielsweise im ersten Kapitel einen Überblick der WPF-Konzepte. In späte-ren Kapiteln werden diese Konzepte wiederholt und vertieft.


31

Hinweise zum Buch

Systemvoraussetzungen

Alle Beispiele in diesem Buch wurden mit der finalen deutschen Version von Visual Stu-dio 2010 Ultimate auf Windows 7 entwickelt. Dabei wurde als Target-Version der WPF-Projekte das .NET Framework 4.0 angegeben, das sich gleich mit Visual Studio 2010 in-stalliert. Damit Sie also sofort loslegen und einige Beispiele der Buch-DVD ausprobierenkönnen, sollten Sie auf Ihrem Rechner Folgendes installieren:

� als Betriebssystem mindestens Windows XP mit den aktuellen Service-Packs; besser istWindows Vista oder Windows 7

� als Entwicklungsumgebung Visual Studio 2010 Ultimate2

� .NET Framework 4.0 (wird mit Visual Studio 2010 automatisch installiert)

Die Entwicklung von .NET-Anwendungen mit Visual Studio hat sich in den vergangenenJahren bewährt. Dennoch hat man mir berichtet, dass es anscheinend immer noch Ent-wickler gibt, die ihre Anwendungen lieber im Notepad als in Visual Studio schreiben undsomit auf viele Features verzichten, wie beispielsweise IntelliSense, Codesnippets odereinfaches Kompilieren mit (F5). Ich bevorzuge Visual Studio, denn nur mit einer professi-onellen Entwicklungsumgebung lassen sich meiner Meinung nach auch professionelleAnwendungen entwickeln.

Für Notepad-Fans

Sind Sie einer der Notepad-Fans, können Sie für dieses Buch auch schlicht und einfach aufdie Installation von Visual Studio 2010 verzichten und stattdessen das .NET Framework4.0 und das sogenannte Windows SDK (enthält Compiler etc.) installieren. Das WindowsSDK können Sie aus dem Internet herunterladen. Allerdings sollten Sie beim Verzicht aufVisual Studio sehr fit im Umgang mit dem im Windows SDK enthaltenen Werkzeug MS-Build sein. Die meisten WPF-Anwendungen lassen sich nämlich nicht mit dem einfachenKommandozeilen-Compiler csc.exe kompilieren, sondern nur mit dem Kommandozeilen-Programm MSBuild, das als Input eine MSBuild-Datei benötigt.

Codebeispiele

Alle Codebeispiele dieses Buches sind auf der Buch-DVD enthalten. Sie finden sie im Ord-ner Beispiele, der den entsprechenden Quellcode aller Beispiele enthält. Diesen Ordner

2 Eine Trial-Version von Visual Studio 2010 Ultimate finden Sie auf der Buch-DVD. Falls Sie die Visual C#2010 Express Edition einsetzen, können Sie auch mit ihr die meisten WPF-Beispiele in diesem Buchnachvollziehen. Allerdings haben Sie in der Express Edition nicht alle Möglichkeiten der Ultimate Edi-tion.


32

Hinweise zum Buch

sollten Sie auf Ihre lokale Platte kopieren, um dort die Beispiele zu kompilieren und zustarten. Einige der Beispiele lassen sich auch ohne vorheriges Kompilieren direkt im Inter-net Explorer betrachten.

Beispiele zu einem Kapitel

Der auf der Buch-DVD enthaltene Beispiele-Ordner enthält eine nach Kapiteln aufgebauteOrdnerstruktur. Das bedeutet, Sie finden für jedes Kapitel einen Ordner: K01, K02, K03usw. Die Beispiele für Kapitel 5, »Controls«, liegen im Ordner K05. Unter den Codeaus-schnitten in diesem Buch finden Sie eine Unterschrift mit dem Pfad zur Datei, die den dar-gestellten Code enthält. Folgend ein Codeausschnitt aus Kapitel 5, »Controls«; beachtenSie die Unterschrift:

<Label Content="_Benutzer"Target="{Binding ElementName=benutzer}"/>

<TextBox x:Name="benutzer" MinWidth="120" Text="Hallo"/>

Listing 5.5 Beispiele\K05\05 LabelTarget.xaml

Den Code aus Listing 5.5 finden Sie, wie in der Unterschrift angegeben, in der Datei 05LabelTarget.xaml im Ordner K05 des Beispiele-Ordners der Buch-DVD.

Quellcode zu Abbildungen

In diesem Buch befinden sich auch Abbildungen, zu denen der Code nicht explizit abge-bildet ist, da es beispielsweise an der entsprechenden Stelle für den dargestellten Sachver-halt nicht erforderlich ist. Dennoch finden Sie im Beispiele-Ordner auf der Buch-DVD imOrdner eines Kapitels oft auch jenen Code, der diesen Abbildungen zugrunde liegt. ImOrdner K05 gibt es unter anderem eine Datei Abbildung 5.14 – ScrollViewer.xaml, die denfür Abbildung 5.14 verwendeten, im Buch nicht explizit dargestellten Code enthält.

Kapitelübergreifende Beispiele

Neben den Kapitelordnern wie K04 und K05 finden Sie im Beispiele-Ordner auch kapitel-übergreifende Beispiele. Kapitelübergreifend ist unter anderem der Quellcode der in die-sem Buch oft verwendeten Anwendung FriendStorage. Die kapitelübergreifenden Bei-spiele sind auf gleicher Ebene wie die Kapitelordner zu finden. Ein Ausschnitt desBeispiele-Ordners enthält somit die folgenden Ordner:

� FriendStorage

� K01

� K02


33

Hinweise zum Buch

� K03

� …

Darstellungskonventionen

Wie auch Ihre zukünftigen WPF-Anwendungen ein durchgängiges Designkonzept ver-wenden sollten, so macht es auch dieses Buch. Hier ein paar Hinweise zur Darstellung vonText, Code und Bemerkungen.

Textdarstellung

Pfade zu Dateien werden im Fließtext C:\In\Der\PfadFormatierung geschrieben. Tritt einwichtiger Begriff das erste Mal auf, wird er in der Begriff-Formatierung dargestellt. Dia-lognamen, Menüfunktionen u. Ä. werden in Kapitälchen notiert.

Codedarstellung

Codebeispiele sind immer in der Codeformatierung dargestellt. In der Codeformatierungist besonders wichtiger Code fett abgebildet, was natürlich nicht gleich heißen soll, dassder restliche Code unwichtig ist.

Wie im vorherigen Abschnitt bereits erwähnt, werden die meisten Codebeispiele in die-sem Buch mit einer Unterschrift versehen. Die Unterschrift enthält entweder einen Pfadzur Quelldatei auf der Buch-DVD oder eine kurze Beschreibung des dargestellten Codes.Sehr kurze, selbsterklärende Codebeispiele besitzen keine Unterschrift.

Wenige Listings in diesem Buch besitzen Zeilennummern. Diese gehören nicht zum ei-gentlichen Quellcode, sondern dienen einfach als zusätzliches Beschreibungsmittel. In Ka-pitel 4, »Der Logical und der Visual Tree«, finden Sie ein solches Listing mit Zeilenangabe.Im Buchtext wird eine Listingzeile dann beispielsweise mit »Beachten Sie in Listing 4.2 inZeile 8 …« referenziert.

1 <TextBlock Height="50"2 Padding="5,16,0,0"3 Background="Black"4 Foreground="White"5 FontSize="17">6 <Bold Foreground="LightGray">Friend</Bold><Bold7 FontSize="20" Foreground="Red">S</Bold><Italic>8 torage</Italic> – Info9 </TextBlock>

Listing 4.2 Beispiele\FriendStorage\Dialogs\InfoDialog.xaml


34

Hinweise zum Buch

An vielen Stellen dieses Buches ist eine vollständige Darstellung einer Quellcode-Dateinicht notwendig und würde den Sachverhalt nur komplizierter darstellen, als er tatsäch-lich ist. Entweder wird aus einer solchen Quellcode-Datei in einem Listing nur ein zusam-menhängender Ausschnitt dargestellt, oder es werden einzelne Codeabschnitte weggelas-sen. Auf nicht gezeigte Codeabschnitte wird im Listing, soweit sich die Codeabschnittenicht am Anfang oder Ende des dargestellten Codeausschnitts befinden, mit drei Punkten– ... – hingewiesen.

Bemerkungen

Um den Fließtext etwas kompakter zu gestalten und besondere Informationen zusätzlichhervorzuheben, finden Sie in den Kapiteln dieses Buches einige Bemerkungen in einemKasten dargestellt. Es werden dabei drei Arten von Bemerkungen verwendet: In einemKasten befindet sich entweder ein Tipp, eine Warnung oder ein Hinweis.

Etwas zu Anglizismen

Ich bin wirklich kein Fan von Anglizismen. Allerdings ist es für einige Begriffe in diesemFachbuch meines Erachtens wenig sinnvoll, sie ins Deutsche zu übertragen. Dieses Buchverwendet daher an vielen Stellen durchgängig die englischen Originalwörter und -be-griffe. Diese Entscheidung ist gefallen, da einerseits eine deutsche Variante eines Begriffsoft zu Missverständnis führt und es andererseits in der WPF Begriffe wie beispielsweiseDependency Properties gibt, für die in der Entwicklerszene einfach kein konsistentes deut-sches Pendant existiert. Es wird daher auch unter deutschsprachigen WPF-Entwicklernvon »Dependency Properties« und nicht von »Abhängigkeitseigenschaften« gesprochen(auch wenn sie in der deutschen MSDN-Dokumentation als solche bezeichnet werden).

Tipp

Ein Tipp gibt Ihnen etwas Nützliches mit auf den Weg. Der Tipp ist in manchen Situationensehr hilfreich.

Achtung

Dieser Kasten weist Sie explizit auf ein eventuell auftretendes Problem, mögliche Stolperfallenoder etwas extrem Wichtiges hin.

Hinweis

Ein Hinweis-Kasten hebt wichtige Details hervor oder erläutert einen Sachverhalt noch etwastiefgründiger.


35

Hinweise zum Buch

Aufgrund dieser Tatsache finden Sie in diesem Buch die original englischen Begriffe wieDependency Properties, Routed Events, Commands, Markup Extensions etc. Diese Begriffegehen meist mit den Klassennamen einher, die für die entsprechende Funktionalität ver-wendet werden. Für Dependency Properties haben Sie die Klassen DependencyObjectund DependencyProperty, für Routed Events die Klasse RoutedEvent usw.

Auch Steuerelemente werden durchgängig als »Controls« bezeichnet, die .NET-Eigen-schaften eines Objekts als »Properties« oder die Behandlungsmethoden für ein Event als»Event Handler«.


39

Lehnen Sie sich zurück. In diesem Kapitel werden Sie »gebootet«. Nach einem Blick auf die WPF im .NET Framework und einem Schnelldurchlauf durch die Windows-Programmiergeschichte erfahren Sie mehr über die Architektur und Konzepte der WPF.

1 Einführung in die WPF

1.1 Die WPF und das .NET Framework

Mit der Windows Presentation Foundation (WPF) steht seit der Einführung des .NETFrameworks 3.0 gegen Ende des Jahres 2006 ein modernes Programmiermodell für dieEntwicklung von Windows- und Webbrowser-Anwendungen zur Verfügung. Als Teil des.NET Frameworks ab Version 3.0 ist die WPF Microsofts strategische Plattform für dieEntwicklung von Benutzeroberflächen unter Windows.

1.1.1 Die WPF im .NET Framework 3.0

Das Ende 2006 eingeführte .NET Framework 3.0 besteht aus den Komponenten des .NETFrameworks 2.0 und vier umfangreichen Programmiermodellen. Dies sind WPF, Win-dows Communication Foundation (WCF), Windows Workflow Foundation (WF) und Win-dows CardSpace (WCS).

Das auf Windows Vista standardmäßig vorinstallierte .NET Framework 3.0 wird auch aufWindows Server 2003 und Windows XP unterstützt (siehe Abbildung 1.1). Mit den viereingeführten Programmiermodellen WPF, WCF, WF und WCS stellte Microsoft erstmalsgrößere, in Managed Code implementierte Bibliotheken zur Verfügung. Für die Entwick-lung von Benutzeroberflächen unter Windows stellt die WPF das zukünftige Program-miermodell dar.


40

Einführung in die WPF1

1.1.2 Die WPF und das .NET Framework 3.5

Das im November 2007 eingeführte .NET Frameworks 3.5, das mit Windows 7 standard-mäßig installiert wird, enthält Erweiterungen der Sprache C#, wie Lambda-Ausdrücke,Objekt-Initialisierer und Language Integrated Query (LINQ). Allerdings baut das .NETFramework 3.5 ebenfalls – wie Version 3.0 – noch auf der Common Language Runtime(CLR) 2.0 auf. .NET 3.5 besitzt weitere Klassen und Optimierungen. Ein Teil dieser Klassenund Optimierungen ist auch im Service Pack 1 (SP1) für .NET 3.0 verfügbar. .NET 3.5 istsomit ein Superset, das sowohl .NET 3.0 + SP1 als auch .NET 2.0 + SP1 enthält (siehe Abbil-dung 1.2).

Abbildung 1.1 .NET Framework 3.0 = .NET Framework 2.0 + WPF + WCF + WF + WCS

.NET Framework 3.0

.NET Framework 2.0


(WPF)

Windows Communication

Foundation (WCF)

Windows Workflow

Foundation (WF)

Windows CardSpace

(WCS)

Common Language Runtime (CLR)

ADO.NET ASP.NET Windows Forms

...

Windows Vista, Windows Server 2003, Windows XP

Base Class Library

Abbildung 1.2 Das .NET Framework 3.5 erweitert die Version 3.0 um zusätzliche Klassen und Optimierungen und baut weiterhin auf der CLR 2.0 auf.

.NET Framework 3.5

.NET Framework 3.0 + Service Pack 1

.NET Framework 2.0 + Service Pack 1

Windows Workflow

Foundation (WF)

Windows CardSpace

(WCS)


ADO.NET ASP.NET Windows Forms

...

Base Class Library


(WPF)


Foundation (WCF)

LINQ AJAX REST ...


41

Die WPF und das .NET Framework 1.1

Wird .NET 3.5 installiert, wird auch etwas an den Assemblies einer bestehenden .NET 3.0-Installation geändert (Service Pack 1). Existiert noch keine .NET 3.0-Installation, werdenmit .NET 3.5 auch alle Assemblies von .NET 3.0 installiert. Folglich ist .NET 3.5 ein Super-set von .NET 3.0.

1.1.3 Die WPF und das .NET Framework 4.0

Im Frühling 2010 wurde das .NET Framework 4.0 eingeführt. Es enthält zahlreiche Neu-erungen, wie Parallel Extensions oder beispielsweise eine performantere Variante desGarbage Collectors. Abbildung 1.3 zeigt das .NET Framework 4.0 mit den wichtigsten Be-standteilen.

Die WPF wird übrigens mit der Version des .NET Frameworks bezeichnet. Bei der ersten,mit dem .NET Framework 3.0 eingeführten Version wird also tatsächlich nicht von WPF1.0, sondern von WPF 3.0 gesprochen. Die im .NET Framework 3.5 enthaltene Versionwird als WPF 3.5 und die des .NET Frameworks 4.0 als WPF 4.0 bezeichnet. Die WPF 4.0enthält zahlreiche Neuerungen:

� neue Controls, wie das DataGrid oder den DatePicker

� Multitouch-Support dank neuer Events

� Unterstützung für den aus Silverlight stammenden VisualStateManager

� grafische Erweiterungen (Pixel Shader 3.0, Cached Compositions etc.)

Abbildung 1.3 Das .NET Framework 4.0 ist eine komplett eigenständige Installation.

.NET Framework 4.0

Data AccessUser Interface

Core 4.0

Common Language Runtime (CLR 4.0)

Languages Parallel Extensions

Managed Extensibility Framework

...

Base Class Library


(WPF)

WindowsForms

ASP.NET

Services


Foundation (WCF)

Windows Workflow

Foundation (WF)

ADO.NET

Entity Framework

......

DynamicLanguageRuntime


42


� Wrapper-Klassen für die Integration in die Taskbar von Windows 7

� Animation Easing Functions, um Animationen mit Effekten zu versehen

� ...

Im Gegensatz zu .NET 3.0 und .NET 3.5 baut .NET 4.0 nicht mehr auf .NET 2.0 auf. Statt-dessen ist .NET 4.0 eine eigenständige Installation – dies wird auch als Side-by-Side-Instal-lation bezeichnet. .NET 4.0 wird also »neben« den älteren .NET-Versionen installiert,während die Versionen .NET 3.0 und .NET 3.5 auf .NET 2.0 aufbauen. Abbildung 1.4 zeigtdie Zusammenhänge.

Während die Version des .NET Frameworks noch einfach zu merken ist, wird es bei ei-nem zusätzlichen Blick auf Visual Studio, C# und die CLR etwas komplexer. Ein neues.NET Framework heißt nicht immer gleich eine neue C#-Version oder eine neue CLR-Ver-sion. Tabelle 1.1 schafft Abhilfe und betrachtet die vier Komponenten Visual Studio, C#,Framework und CLR von .NET 1.0 bis .NET 4.0. In Version 1.0 war alles bei Version 1.0,und es wurde Visual Studio 2002 verwendet. Das Besondere in Tabelle 1.1 ist die Tatsa-che, dass vom .NET Framework 2.0 bis zum .NET Framework 3.5 immer dieselbe, mit.NET 2.0 eingeführte CLR verwendet wird: dies entspricht Abbildung 1.4. Mit .NET 4.0und Visual Studio 2010 werden auch C# und die CLR auf Version 4.0 angehoben und dasBild wird bezüglich der Versionsnummern wieder einheitlich.

Abbildung 1.4 .NET 4.0 ist eine »Side-by-Side«-Installation und baut nicht mehr auf .NET 2.0 auf.

.NET Framework Installationen

.NET 1.0 .NET 1.1 .NET 2.0 .NET 4.0

.NET 3.0

.NET 3.5

Jahr Visual Studio C# Framework CLR

2002 VS 2002 v1.0 .NET 1.0 v1.0

2003 VS 2003 v1.1 .NET 1.1 v1.1

2005 VS 2005 v2.0 .NET 2.0 v2.0

2006 VS 2005 + Extensions (WPF, WF …)

v2.0 .NET 3.0 v2.0

2007 VS 2008 v3.0 .NET 3.5 v2.0

2010 VS 2010 v4.0 .NET 4.0 v4.0

Tabelle 1.1 Versionen von Visual Studio, C#, Framework und CLR seit 2002


43


Mit dem .NET Framework 4.0 erschien im Frühling 2010 auch eine neue Version vonVisual Studio. Visual Studio 2010 unterstützt die Entwicklung von .NET-Anwendungenfür die .NET-Versionen 2.0, 3.0, 3.5 und 4.0. Dies wird als Multitargeting bezeichnet.

Für die WPF bietet Visual Studio 2010 verschiedene Projektvorlagen und einen intelligen-ten Oberflächen-Designer. Neben Visual Studio 2010 gibt es mittlerweile viele weitereWerkzeuge, die Sie beim Entwickeln Ihrer Anwendungen unterstützen. So bietet Micro-soft selbst mit den Programmen der Expression Suite wie Expression Design und Expres-sion Blend hochwertige Werkzeuge an, die Sie zum Erstellen reichhaltiger Benutzerober-flächen mit der WPF einsetzen können. Diese Werkzeuge legen dabei ein speziellesAugenmerk auf das Design der Anwendung.

Natürlich verwenden Sie zum Programmieren von WPF-Anwendungen nach wie vorVisual Studio. Die zusätzlichen Programme der Expression Suite bieten Ihnen allerdingsbeim Benutzeroberflächen-Design weitaus mehr Unterstützung als Visual Studio. Sie fin-den in Expression Blend ähnliche Funktionen und Werkzeuge wie in einem Grafikpro-gramm, beispielsweise Farbpaletten, Timelines für Animationen, Pens, Pencils und vielesmehr. Damit kann ein Grafikdesigner arbeiten, ohne den vom Programm generiertenCode zwingend kennen zu müssen.

1.1.4 Die WPF als zukünftiges Programmiermodell

Bei manchen Programmierern, die die technische Entwicklung im Hause Microsoft nichtmitverfolgt haben, sorgte die Nachricht von einem weiteren Programmiermodell fürBenutzeroberflächen als Teil von .NET 3.0 zuerst für etwas Verwirrung. Schließlich ent-hielt das .NET Framework seit Version 1.0 mit Windows Forms ein bewährtes Program-miermodell zur Entwicklung von Windows-Anwendungen. Insbesondere in .NET 2.0wurde Windows Forms stark verbessert und erfreute sich großer Beliebtheit. Viele Ent-wickler stellten sich demzufolge die Frage, was das neue Programmiermodell für Vorteilebringen würde und warum sie in Zukunft die WPF anstelle von Windows Forms einsetzensollten.

Wer damals bereits erste Gehversuche mit den von Microsoft als Download bereitgestell-ten Vorabversionen von .NET 3.0 – den sogenannten Community Technology Previews(CTPs) – hinter sich hatte, wusste, dass mit der WPF auch scheinbar komplexe Aufgaben –wie die Programmierung von animierten, rotierenden 3D-Objekten mit Videos auf derOberfläche – relativ einfach und schnell umsetzbar sind (siehe Abbildung 1.5, aus Kapitel14, »3D-Grafik«).

Hinweis

In diesem Buch wird generell WPF 4.0 verwendet. Viele Beispiele in diesem Buch sind aller-dings auch unter .NET 3.0 lauffähig. Stellen Sie in Visual Studio 2010 dazu einfach in den Pro-jekteigenschaften das Zielframework von 4.0 auf 3.0 um.


44


Allerdings trat beim Versuch, eine etwas umfangreiche Anwendung mit der WPF zu ent-wickeln, meist die erste Ernüchterung auf. Dies ist in der relativ mächtigen Einstiegshürdeder WPF begründet, die um einiges höher als jene von Windows Forms liegt. Die erstenErfolgserlebnisse mit der WPF werden Sie also schon bald haben, für die professionelleund erfolgreiche Entwicklung müssen Sie jedoch auch die Konzepte und Hintergründe derWPF verstanden haben. Dazu gehören unter anderem Layout, Dependency Properties,Routed Events sowie Styles und Templates. Haben Sie diesen Punkt erreicht, lassen sichmit der WPF auch sehr komplexe Anwendungen erstellen, ohne auf komplizierte weitereTechnologien zugreifen zu müssen.

In diesem Buch werde ich zum Verständnis der Konzepte auch einige Beispiele aus derAnwendung FriendStorage herauspicken. FriendStorage ist eine kleine Anwendung, dieSie beim Studieren der WPF-Konzepte unterstützt. In FriendStorage können Sie eine Listemit Freunden speichern und für jeden Freund verschiedene persönliche Daten und einBild erfassen (siehe Abbildung 1.6). Die Anwendung zeigt auf der rechten Seite eine ListeIhrer Freunde an. Auf der linken Seite sehen Sie die Details zum aktuell in der Liste aus-gewählten Freund.

Bisher konnten grafisch hochwertige Anwendungen nur mit weiteren einarbeitungsinten-siven Technologien wie DirectX erstellt werden. Mit der WPF stellt Microsoft im Zeitaltervon Windows Vista und Windows 7 ein einheitliches, zeitgemäßes Programmiermodellzur Verfügung, das zur Entwicklung moderner Anwendungen keine Kenntnisse überkomplexe, weitere Technologien wie eben DirectX erfordert. Und das Besondere an demeinheitlichen Programmiermodell der WPF ist, dass Sie für die Verwendung von Anima-tionen, Data Bindings oder Styles immer die gleichen Konstrukte verwenden, egal ob Siedamit 2D-, 3D-, Text- oder sonstige Inhalte beeinflussen wollen. Haben Sie also einmal ge-lernt, wie Sie ein 2D-Element animieren, können Sie das Erlernte auch auf 3D-Objekte an-wenden.

Abbildung 1.5 Ein 3D-Würfel, auf dem ein Video abläuft


45


1.1.5 Stärken und Eigenschaften der WPF

Mit 2D, 3D und Text bzw. Dokumenten wurden schon einige der Stärken der WPF ange-schnitten. Im Gegensatz zu Windows Forms bietet die WPF viele weitere, vorteilhafte Ei-genschaften, die sich nicht nur auf die Erstellung reichhaltiger Benutzeroberflächen ausSicht des Grafikers beziehen. Unter anderem sind dies erweitertes Data Binding, verbes-serte Layout-Möglichkeiten, ein flexibles Inhaltsmodell, eine verbesserte Unterstützungfür Audio/Video, integrierte Animationen, Styles, Templates und vieles mehr. In Tabelle1.2 finden Sie eine Handvoll der wohl bedeutendsten Eigenschaften der WPF.

Abbildung 1.6 Die Anwendung FriendStorage speichert Listen mit Freunden. Sie verwendet verschiedene Features der WPF wie Commands, Styles, Trigger, Animationen und Data Binding.

Eigenschaft Beschreibung

Flexibles Inhalts-modell

Die WPF besitzt ein flexibles Inhaltsmodell. In bisherigen Programmiermodellen, wie Windows Forms, konnte beispielsweise ein Button lediglich Text oder ein Bild als Inhalt enthalten. Mit dem flexiblen Inhaltsmodell der WPF kann ein But-ton – genau wie viele andere visuelle Elemente – einen beliebigen Inhalt haben. So ist es beispielsweise möglich, in einen Button ein Layout-Panel zu setzen und darin wiederum mehrere 3D-Objekte und Videos. Ihrer Kreativität sind keine Grenzen gesetzt.

Tabelle 1.2 Wichtige Eigenschaften der WPF


46


Layout Die WPF stellt einige Layout-Panels zur Verfügung, um Controls in einer Anwen-dung dynamisch anzuordnen und zu positionieren. Aufgrund des flexiblen Inhaltsmodells lassen sich die Layout-Panels der WPF auch beliebig ineinander verschachteln, wodurch Sie in Ihrer Anwendung auch ein sehr komplexes Layout erstellen können.

Styles Ein Style ist eine Sammlung von Eigenschaftswerten. Diese Sammlung lässt sich einem oder mehreren Elementen der Benutzeroberfläche zuweisen, wodurch deren Eigenschaften dann die im Style definierten Werte annehmen. Sie definie-ren einen Style üblicherweise als Ressource, um ihn beispielsweise mehreren Buttons zuzuweisen, die alle die gleiche Hintergrundfarbe und die gleiche Breite haben sollen. Ohne Styles müssten Sie auf jedem Button diese Properties setzen. Mit Styles setzen Sie lediglich die Style-Property auf den Buttons, was sogar im-plizit passieren kann; mehr dazu in Kapitel 11, »Styles, Trigger und Templates«.

Trigger Trigger erlauben es Ihnen, auf deklarativem Weg festzulegen, wie ein Control auf bestimmte Eigenschaftsänderungen oder Events reagieren soll. Mit Triggern können Sie bereits deklarativ Dinge erreichen, für die Sie ansonsten einen Event Handler benötigen würden. Trigger definieren Sie meist in einem Style oder einem Template.

»lookless« Controls Custom Controls sind bei der WPF »lookless«: Sie trennen ihre visuelle Erschei-nung von ihrer eigentlichen Logik und ihrem Verhalten. Das Aussehen eines Controls wird dabei mit einem ControlTemplate beschrieben. Das Control selbst definiert kein Aussehen, sondern nur Logik und Verhalten – daher »look-less«. Durch Ersetzen des ControlTemplates (durch Setzen der Template-Pro-perty der Klasse Control) lässt sich das komplette Aussehen eines Controls anpassen. Aufgrund dieser Flexibilität und der Tatsache, dass die meisten Cont-rols der WPF als Custom Control implementiert sind, müssen Sie keine Subklas-sen mehr erstellen, um lediglich das Aussehen anzupassen. Es sind folglich weni-ger eigene Custom Controls als in bisherigen Programmiermodellen notwendig.

Daten Die Elemente in Ihrer Applikation können Sie mit Data Binding an verschiedene Datenquellen binden. Dadurch ersparen Sie sich die Programmierung von Event Handlern, die die Benutzeroberfläche oder die Datenquelle bei einer Änderung aktualisieren. Neben dem Data Binding können Sie mit Data Templates das Aus-sehen Ihrer Daten auf der Benutzeroberfläche definieren.

2D- und 3D-Grafiken

3D-Grafiken können Sie in der WPF auf dieselbe Weise zeichnen und animieren wie auch 2D-Grafiken. Dazu stellt die WPF viele Zeichenwerkzeuge bereit, wie beispielsweise die verschiedenen Brushes. Auch die Möglichkeit der Benutzer-interaktion mit 3D-Elementen wurde mit WPF 3.5 stark vereinfacht.

Animationen Die WPF besitzt einen integrierten Mechanismus für Animationen. Während Sie bisher für Animationen einen Timer und einen dazugehörigen Event Handler ver-wendeten, ist dies jetzt wesentlich einfacher realisiert, wie Sie in Kapitel 15, »Animationen«, sehen werden.

Audio/Video Audio- und Video-Elemente lassen sich einfach in Ihre Applikation einbinden. Dafür stehen verschiedene Klassen zur Verfügung.


Tabelle 1.2 Wichtige Eigenschaften der WPF (Forts.)


47


Neben all den in Tabelle 1.2 dargestellten Eigenschaften, die Sie in einzelnen Kapiteln die-ses Buches wiederfinden, ist eine weitere große Stärke der WPF die verbesserte Unterstüt-zung des Entwicklungsprozesses zwischen dem Designer einer Benutzeroberfläche unddem Entwickler, der die eigentliche Geschäftslogik implementiert. Dies wird durch die in.NET 3.0 eingeführte XML-basierte Beschreibungssprache Extensible Application MarkupLanguage (XAML, sprich »Semmel«) erreicht. XAML wird in der WPF zur deklarativen Be-schreibung von Benutzeroberflächen eingesetzt. Sie können Ihre Benutzeroberflächenzwar auch weiterhin in C# erstellen, profitieren dann aber nicht von den Vorteilen, die Ih-nen XAML bietet. So dient XAML beispielsweise im Entwicklungsprozess als Austausch-format zwischen Designer und Entwickler. Es gibt mittlerweile zig Programme, dieXAML-Dateien öffnen können und zum Editieren einen grafischen Editor bereitstellen,wodurch ein Designer Ihre Benutzeroberfläche wie eine Grafik »designen« kann. Sie wer-den XAML in den Kapiteln dieses Buchs mit allen Tricks und Kniffen kennenlernen. Ins-besondere in Kapitel 3, »XAML«, dreht sich alles rund um die Markup-Sprache.

1.1.6 Auf Wiedersehen GDI+

Neben dem Modell der WPF, Benutzeroberflächen mit XAML zu erstellen, unterscheidetsich die WPF auch aus rein technologischer Sicht von Windows Forms und den bisherigenProgrammiermodellen unter Windows. Erstmals baut die grafische Darstellung nicht aufder GDI-Komponente (Graphics Device Interface) der Windows-API auf, wie das bei Win-dows Forms (verwendet GDI+, eine verbesserte Variante von GDI) und vorherigen Pro-grammiermodellen der Fall war. Stattdessen greift die WPF zur Darstellung des Fenster-inhalts auf DirectX zurück.

Ja, Sie haben richtig gelesen. Für das Zeichnen der Pixel (= Rendering) macht die WPF vondem bisher meist nur in Spielen verwendeten DirectX Gebrauch. DirectX ist eine aus meh-reren APIs bestehende Suite, die auf Windows-Rechnern die Kommunikation zwischenHardware und Software ermöglicht. Dadurch lassen sich die Möglichkeiten der in heuti-gen Computern mittlerweile standardmäßig eingebauten Grafikkarten mit 3D-Beschleuni-gern richtig ausnutzen. Bisher, so auch unter Windows Forms, blieben die meisten Mög-lichkeiten der vorhandenen Hardware völlig ungenutzt.

Text & Dokumente Die WPF stellt eine umfangreiche API zum Umgang mit Text und Dokumenten bereit. Es werden fixe und fließende Dokumente unterstützt. Fixe Dokumente unterstützen eine gleichbleibende, fixierte Darstellung des Inhalts – ähnlich wie PDF-Dokumente –, während fließende Dokumente ihren Inhalt an verschiedene Faktoren anpassen, wie beispielsweise die Größe des Fensters. Zum Anzeigen der Dokumente stehen verschiedene Controls zur Verfügung.


Tabelle 1.2 Wichtige Eigenschaften der WPF (Forts.)


48


Den guten alten Grafikschnittstellen GDI und GDI+ kehrt die WPF also den Rücken zu.Verständlich, denn DirectX ist natürlich weitaus attraktiver und leistungsfähiger. Zu Eh-ren der klassischen Windows-API und der darin enthaltenen GDI-Komponente wagen wireinen ganz kurzen Rückblick ins Jahr 1985, als alles begann.

1.2 Von Windows 1.0 zur Windows Presentation Foundation

Als im November 1985 die erste Version von Windows auf den Markt kam – eine grafi-sche Erweiterung zum damaligen Betriebssystem MS-DOS –, gab es nur eine Möglichkeit,Windows-Anwendungen zu schreiben: Mit der Programmiersprache C wurde zur Erstel-lung von Fenstern und zur Verwendung weiterer Systemfunktionalität auf die Funktionender ebenfalls in C geschriebenen Windows-Programmierschnittstelle – kurz Windows-API– zugegriffen. Mit der Umstellung auf eine 32-Bit-Architektur wurden die Bibliothekender Windows-API angepasst und erweitert. Sie tragen seitdem die Namen gdi32.dll,kernel32.dll und user32.dll. Man spricht in diesem Zusammenhang statt von der Win-dows-API auch von der Win32-API.

1.2.1 Die ersten Wrapper um die Windows-API

Da bei der direkten Verwendung der Windows-API viele Funktionsaufrufe auf sehr nied-rigem, detailliertem Betriebssystem-Level notwendig waren, was zu Unmengen von Codeführte, fiel bei der zeitintensiven Programmierung durch diese vielen zu programmieren-den Details der Blick auf das Wesentliche sehr schwer. Es war nur eine Frage der Zeit, bisdie ersten Programmbibliotheken entstanden, die die Aufrufe der Windows-API kapsel-ten und diese Aufrufe zu logischen, abstrakteren Einheiten zusammenfassten.

Für C++ entwickelte Microsoft die Microsoft Foundation Classes (MFC) als objektorien-tierte »Wrapper«-Bibliothek um die Windows-API. Borland brachte mit der Object Win-dow Library (OWL) ein Konkurrenzprodukt auf den Markt. Auch im Zeitalter von .NETwerden von Windows Forms die Funktionen der Windows-API gekapselt. Man könntealso sagen, dass die Programmierung von Windows-Applikationen seit der Einführungvon Windows 1.0 im Jahr 1985 in den Grundzügen gleich geblieben ist – im Hintergrundwurde seit eh und je auf die Programmbibliotheken der Windows-API zugegriffen.

1.2.2 Windows Forms und GDI+

Die Aufrufe der zur Windows-API gehörenden Programmbibliothek GDI+ kapselt Win-dows Forms hauptsächlich in der Klasse System.Drawing.Graphics. Jedes Control inWindows Forms nutzt ein Graphics-Objekt zum Zugriff auf GDI+. In Abbildung 1.7 ist zusehen, dass GDI+ die entsprechenden Befehle an die Grafikkarte weitergibt, um das Con-trol auf den Bildschirm zu zeichnen (Zeichnen auf den Bildschirm = Rendering).


49

Von Windows 1.0 zur Windows Presentation Foundation 1.2

Ein einzelnes Control von Windows Forms und Win32 wird aus Windows-Sicht als einFenster angesehen. Jedes Fenster wird über einen Window-Handle (HWND-Datentyp in C/C++, System.IntPtr in .NET) referenziert und besitzt einen bestimmten Bereich auf demBildschirm, auf den es zeichnen darf. Auf die Bereiche eines anderen Window-Handlesdarf das Fenster nicht zeichnen.

Die WPF schlägt einen neuen, zeitgemäßen Weg ein und lässt die »Altlasten« vergangenerJahrzehnte hinter sich. Ein Control hat bei der WPF keinen Window-Handle mehr;1 eskann somit auch auf die Pixel anderer Controls zeichnen, wodurch beispielsweise Trans-parenzeffekte möglich sind.

1.2.3 Die Windows Presentation Foundation

Mit der Entwicklung der WPF begann Microsoft bereits vor dem Erscheinen der erstenVersion des .NET Frameworks im Jahr 2001. Damals war den Microsoft-Entwicklern und-Entscheidern bereits klar, dass .NET die Zukunft sein würde. Somit entschied man sich,auch die WPF in Managed Code statt nativem Code zu implementieren.

Während die bisherigen Programmiermodelle von Microsoft für Benutzeroberflächenmeist nur dünne Wrapper um die Windows-API darstellten, wie eben auch WindowsForms, ist die WPF das erste, umfangreiche Programmiermodell für Benutzeroberflächen,das fast vollständig in .NET geschrieben ist.

Eines der Designziele der WPF war es, nicht auf den vielen in die Jahre gekommenenFunktionen der Windows-API aufzubauen. Langfristig plant Microsoft sogar, die Win32-API durch Klassen im .NET Framework zu ersetzen. Die WPF macht hier den ersten Schrittnach vorn und setzt beispielsweise für die Darstellung DirectX anstelle von GDI+ ein, um

Abbildung 1.7 In Windows Forms werden Controls mit GDI+ gezeichnet.

Windows Forms

Grafikkarte

.NET + Native

GDI+

Windows/Controls

1 Es gibt einige Ausnahmen, wie beispielsweise ein Window, das in einen Top-Level-Handle gesetzt wird.Auch ein Kontextmenü wird bei der WPF in einen Window-Handle gesetzt, damit es immer im Vorder-grund ist.


50


die Leistung der heutigen Grafikkarten nicht nur in Spielen, sondern auch in »gewöhnli-chen« Windows-Anwendungen voll und ganz auszureizen. Dabei werden die Komponen-ten einer WPF-Anwendung nicht mehr durch das Betriebssystem, sondern durch die WPFselbst unter Verwendung von DirectX gezeichnet. Ein einzelnes Control der WPF besitztnicht wie ein Window-Handle unter Win32 seinen Bereich, in dem es zeichnen darf. So-mit kann ein Control der WPF wie gesagt über die Pixel eines anderen Controls zeichnen,was Transparenzeffekte ermöglicht.

Durch die Tatsache, dass die WPF alles selbst zeichnet, sind das flexible Inhaltsmodelloder Dinge wie Templates – mit denen Sie das Erscheinungsbild von Controls individuellan Ihre Bedürfnisse anpassen können – überhaupt erst möglich.

Setzen Sie als Entwickler für Ihre Anwendungen .NET ein und wollen Sie auch in Zukunftmit .NET zeitgemäße Anwendungen entwickeln, sind Sie mit der WPF auf dem richtigenWeg. Microsoft wird zwar in nächster Zukunft auch Windows Forms weiterhin unterstüt-zen, aber die WPF ist ganz klar das strategische Programmiermodell für Anwendungenunter Windows.

Nach der Einführung von .NET 3.0 war es noch so, dass Windows Forms mit Controls wieder DataGridView Komponenten besaß, die man in der WPF vergeblich suchte. Auch derWindows-Forms-Designer in Visual Studio 2005 war dem damals zur Verfügung stehen-den WPF-Designer weit voraus. Somit lautete der Grundsatz zu dieser Zeit, Anwendun-gen, die ohne verschiedene Medienelemente und ohne grafische Kunststücke auskamen,weiterhin mit Windows Forms zu entwickeln.

Heute in .NET 4.0 enthält die WPF ein DataGrid, und es gibt genügend Controls aus derdritten Reihe von altbekannten Herstellern wie beispielsweise Infragistics, DevExpressoder Telerik. Auch der WPF-Designer in Visual Studio 2010 steht jenem von WindowsForms in nichts nach. Die IntelliSense-Unterstützung für XAML wurde in Visual Studio2010 ebenfalls nochmals verbessert. Neben Visual Studio 2010 stehen für die Bearbeitungvon Benutzeroberflächen und für die Bearbeitung von XAML weitere Tools wie die Ex-pression Suite zur Verfügung.

Hinweis

Die Expression Suite ist eine Programmsammlung, die von Microsoft speziell für Designerangeboten wird. Dazu zählen u. a. Expression Design, mit dem Sie Grafiken als XAML expor-tieren können, und Expression Blend, mit dem Sie komplette Visual-Studio-Projektdateienöffnen und bearbeiten können.

Im Gegensatz zu Visual Studio 2010 erlaubt Expression Blend das Definieren von Animationenüber eine rein grafische Benutzeroberfläche, die keinerlei XAML-Kenntnisse voraussetzt. Esgibt in Expression Blend ein Timeline-Fenster ähnlich wie das aus Adobe Flash, in dem sicheine Animation über einen Zeitraum mit einfachen Mausklicks definieren lässt.


51

Von Windows 1.0 zur Windows Presentation Foundation 1.2

Die damaligen Gründe für Windows Forms – mehr Controls und bessere Design-Unter-stützung in Visual Studio 2005 – sind aus meiner Sicht heute nicht mehr gegeben. Auchfür typische datenintensive Geschäftsanwendungen ist die WPF bestens geeignet, da siemit Features wie dem umfangreichen Data Binding optimale Unterstützung bietet. Dereinzige Grund, warum ich heute ein Projekt noch mit Windows Forms statt mit WPF ent-wickle, ist die Lauffähigkeit von Windows Forms auf älteren Plattformen. Während dieWPF nur unter den neueren Windows-Versionen Windows XP, Windows Server 2003,Windows Vista und Windows 7 läuft, wird Windows Forms bereits ab Windows 98 un-terstützt.

Haben Sie sich für die WPF entschieden, stehen Ihnen für Ihre bereits entwickeltenWin32- und Windows-Forms-Anwendungen verschiedene Interoperabilitätsmöglich-keiten mit der WPF zur Verfügung. In Visual Studio 2010 gibt es zwar keinen integriertenMigrationsmechanismus von Windows Forms/Win32 zur WPF – die Programmier-modelle sind einfach zu unterschiedlich –, doch die im .NET Framework enthaltenen Klas-sen für Interoperabilität zwischen WPF und Windows Forms/Win32 bieten Ihnen ver-schiedene Möglichkeiten, Ihre älteren Anwendungen nach und nach zu migrieren. InKapitel 20, »Interoperabilität«, erfahren Sie mehr über verschiedene Interoperabilitäts-szenarien und mögliche Migrationsstrategien.

Ebenfalls lassen sich in Expression Blend ControlTemplates auf rein grafischer Ebene editie-ren. In Visual Studio 2010 müssen Sie Animationen und Templates manuell in XAML erstellen.

Neben der grafischen Unterstützung von Animationen und Templates besitzt ExpressionBlend viele designerfreundliche Merkmale, wie Farbpaletten, eine Werkzeugleiste mit ausGrafikprogrammen bekannten Werkzeugen wie Stift, Pinsel, Radiergummi etc. ExpressionBlend wird allerdings auch lediglich als Programm für den Feinschliff der Benutzeroberflächeangesehen und wird Visual Studio somit keinesfalls ersetzen. In diesem Buch wird mit derWPF und XAML programmiert und folglich außer Visual Studio kein anderes Programmgenutzt. Wenn Sie später Expression Blend verwenden, werden Sie nach diesem Buch den vonExpression Blend und auch von anderen Programmen generierten XAML-Code verstehen.

Achtung

Neben der Lauffähigkeit unter älteren Plattformen gibt es einen weiteren Grund zu bedenken,falls Sie die WPF zum Entwickeln einer Terminal-Server-Anwendung einsetzen möchten:

Läuft eine WPF-Anwendung auf einem Terminal-Server ab, kann es aufgrund des Renderingsvia DirectX zu Performance-Problemen kommen. Microsoft ist im Begriff, dieses Problem zulösen, hat es bis zur Drucklegung dieses Buchs allerdings noch nicht geschafft.


52


1.3 Die Architektur der WPF

Nachdem Sie jetzt bereits einige Eigenschaften und Hintergründe der WPF kennen, ist esan der Zeit, einen Blick auf die Architektur der WPF zu werfen. Der Kern der WPF bestehtaus drei Bibliotheken:

� milcore.dll

� presentationcore.dll

� presentationframework.dll

Obwohl Microsoft sich dazu entschieden hat, die WPF in .NET statt nativem Code zu im-plementieren, setzt die WPF aus Performanzgründen auf einer in nativem Code geschrie-benen Schicht namens Media Integration Layer (MIL) auf. Die Kernkomponente desMedia Integration Layers ist die milcore.dll.

Wie Abbildung 1.8 zeigt, ist MilCore unter anderem für die Darstellung von 2D- und 3D-Inhalten, Bildern, Videos, Text und Animationen verantwortlich. Zur Darstellung der In-formationen auf dem Bildschirm greift MilCore auf die Funktionalität von DirectX zu, umdie Leistung der Grafikhardware voll auszunutzen.

Abbildung 1.8 Die WPF-Architektur mit den Hauptkomponenten PresentationFramework, PresentationCore und MilCore

PresentationFramework


DirectXUser32

Kernel

PresentationCore

Controls

Layout

Dokumente

Data Binding ...

MilCore

Verantwortlich für Darstellung von:

2D

3D

Bilder

Effekte

Video

Animationen

WindowsBase Eigenschaftssystem ...

...


53

Die Architektur der WPF 1.3

Beim Entwickeln einer WPF-Anwendung werden Sie mit MilCore nicht direkt in Kontaktkommen. Die Programmierschnittstelle, die zur Programmierung von WPF-Anwendun-gen genutzt wird, liegt komplett in Managed Code vor. Die Assemblies presenta-tionCore.dll und presentationframework.dll bilden dabei die zentralen Bausteine der WPF.Aufgrund ihrer Implementierung in Managed Code sind sie in Abbildung 1.8 oberhalbder Laufzeitumgebung von .NET – der Common Language Runtime (CLR) – positioniert.PresentationCore und PresentationFramework enthalten Logik für Controls, Layout, Do-kumente oder Data Binding. Darüber hinaus kapselt PresentationCore die Aufrufe der na-tiven MilCore-Komponente. Beide Komponenten bauen auf der Assembly windowsbase.dllauf, die nicht Teil der WPF ist, sondern Klassen für alle in .NET 3.0 neu eingeführten Pro-grammiermodelle enthält. So finden Sie in WindowsBase beispielsweise Klassen für daserweiterte Eigenschaftssystem mit Dependency Properties, das bei der WPF und auch beider Windows Workflow Foundation (WF) verwendet wird.

Sehen wir uns genauer an, was die drei Komponenten der WPF – MilCore, Presentation-Core und PresentationFramework – und auch die WindowsBase-Komponente enthalten,was ihre Aufgaben sind, und – wohl am spannendsten – wie sie diese Aufgaben meistern.

1.3.1 MilCore – die »Display Engine«

Die in nativem Code geschriebene Komponente milcore.dll kapselt DirectX. MilCore ist inder WPF zuständig für die Darstellung von 3D, 2D, Text, Video, Bilder, Effekte und Ani-mationen. Prinzipiell alles, was in einer WPF-Anwendung gezeichnet wird, basiert auf derFunktionalität von MilCore und DirectX.

Ein wohl entscheidender Vorteil, die Ihre WPF-Anwendung durch MilCore erreicht, istdie vektorbasierte Darstellung. MilCore stellt alle Inhalte vektorbasiert dar; dadurch kön-nen Sie Ihre Anwendungen beliebig skalieren, ohne an »Schärfe« zu verlieren. Abbildung1.9 zeigt eine vergrößerte Aufnahme von WPF und Windows Forms Controls. Linkssehen Sie einen Button und einen Radio-Button der WPF, rechts einen Button und einenRadio-Button aus Windows Forms. Beachten Sie, wie glatt die Elemente der WPF imGegensatz zu denen von Windows Forms gezeichnet werden.

Hinweis

Windows Vista und Windows 7 enthalten auf die WPF zugeschnittene Treiber, die ein Anti-Aliasing (Glätten der Kanten) erlauben. Unter Windows XP und Windows Server 2003 sinddiese Treiber nicht vorhanden, folglich werden unter diesen Betriebssystemen die visuellenElemente nicht so glatt dargestellt. Dies fällt dem menschlichen Auge insbesondere bei 3D-Inhalten auf, wie Sie am Ende dieses Abschnitts selbst sehen werden. Abbildung 1.9 wurdeunter Windows Vista erstellt, wodurch die Elemente der WPF geglättet sind.


54


Im Folgenden werfen wir einen Blick darauf, wie MilCore die Aufgabe wahrnimmt, dieeinzelnen Elemente Ihrer Anwendung auf dem Bildschirm darzustellen.

Den darzustellenden Bildschirminhalt verwaltet MilCore in Form einer Baumstruktur,dem sogenannten Composition Tree. Dieser Baum besteht aus einzelnen Knoten (Composi-tion Nodes), die Metadaten und Zeichnungsinformationen enthalten. Bei Änderungen amComposition Tree generiert MilCore die entsprechenden DirectX-Befehle, die die Ände-rungen visuell umsetzen und mit Hilfe der Grafikkarte auf dem Bildschirm darstellen. Dievielen Composition Nodes werden also durch MilCore zu einem großen, zu zeichnendenBild zusammengesetzt; dieser Prozess wird auch als Composition bezeichnet. Das zusam-mengesetzte Bild wird dann auf dem Bildschirm dargestellt. In früheren Modellen, wieWindows Forms, hatte jedes Control seinen eigenen Ausschnitt, in dem es sich selbstzeichnen durfte. Der Ausschnitt ist über ein Window-Handle (HWND) definiert. Über denAusschnitt kam das Control nicht hinaus. Dieses System wird als Clipping-System bezeich-net, da einfach am Rand abgeschnitten bzw. geclippt wird und jedes Control seinen eige-nen Ausschnitt hat, auf dem es sich zeichnen darf. Bei einem Composition-System wirdnicht abgeschnitten. Stattdessen darf jedes Control überall zeichnen, und am Ende wirdalles zu einem großen Bild zusammengefügt. Mit der Composition in MilCore kann einControl auch über die Pixel eines anderen Controls zeichnen, wodurch Effekte wie Halb-transparenz erst möglich werden.

Der Composition Tree ist mit allen Zeichnungsinformationen zwischengespeichert. Da-durch kann die Benutzeroberfläche sehr effektiv und schnell neu gezeichnet werden, auchdann, wenn Ihre Anwendung gerade beschäftigt ist. Die Zeiten von visuell eingefrorenenAnwendungen sind also vorbei.

Der zur Laufzeit mit den Zeichnungsinformationen bestückte, in der nativen MilCore-Komponente lebende Composition Tree besitzt auf der .NET-Seite ein Pendant, den soge-nannten Visual Tree. Der Visual Tree setzt sich aus allen visuellen Elementen einer WPF-Anwendung zusammen. Das Prinzip der Entwicklung von WPF-Anwendungen und -Con-trols besteht im Grunde darin, mit XAML und/oder prozeduralem Code eine Hierarchievon visuellen Elementen zu erzeugen, wie etwa Window, TextBox und Button. Die einzel-nen Controls in dieser Hierarchie setzen sich wiederum aus einfacheren visuellen Elemen-ten wie Rectangle, TextBlock oder Border zusammen. Alle visuellen Elemente haben diegemeinsame Basisklasse Visual. Die gesamte Hierarchie, einschließlich der einfacherenvisuellen Elemente, wird daher als Visual Tree bezeichnet.

Abbildung 1.9 In der WPF werden die Elemente im Gegensatz zu Windows Forms vektorbasiert gezeichnet, wodurch sie auch vergrößert nicht pixelig wirken.


55


Über einen zweiseitigen Kommunikationskanal sind der Visual Tree und der CompositionTree miteinander verbunden, wie in Abbildung 1.10 zu sehen ist. Über diesen Kommuni-kationskanal werden Änderungen auf die jeweils andere Seite übertragen. Dabei sind diebeiden Bäume nicht 100 %ig identisch, z. B. können einem Knoten im Visual Tree mehrereKnoten im Composition Tree entsprechen. Objekte mit hohem Speicherplatzbedarf, wieetwa Bitmaps, werden gemeinschaftlich verwendet. Wie Abbildung 1.10 zeigt, verwendetMilCore DirectX, das die entsprechenden Befehle an die Grafikkarte gibt, wodurch dieDarstellung auf dem Bildschirm (= Rendering) erfolgt.

Auch der Desktop Window Manager (DWM) in Windows Vista und Windows 7 nutzt fürdie Darstellung der Betriebssystem-Oberfläche die Funktionen von MilCore. Der DWMist unter Vista für die Zeichnung des kompletten Desktops verantwortlich. Mit Hilfe vonMilCore fügt er die zwischengespeicherten Zeichnungsdaten zu einem großen Bild zusam-men, das dann auf Ihrem Bildschirm dargestellt wird. Viele Fähigkeiten von WindowsVista und Windows 7, wie die in Abbildung 1.11 dargestellte Flip3D-Funktion, basierenauf der Funktionalität von MilCore.

Wie bereits erwähnt, werden Sie die Programmbibliothek milcore.dll nicht direkt verwen-den, sondern über .NET Assemblies indirekt darauf zugreifen. MilCore wird Ihnen dahernicht begegnen, zumal die Bibliothek (noch) nicht öffentlich ist. Somit stellen die drei.NET Assemblies den Teil dar, mit dem Sie bei der Entwicklung von WPF-Anwendungenin Berührung kommen. Folgend ein kurzer Überblick dieser drei Assemblies.

Abbildung 1.10 Kommunikation zwischen der .NET-Komponente PresentationCore und der auf DirectX aufbauenden Komponente MilCore

Grafikkarte

.NET Native

PresentationCore MilCore

Visual Tree Composition Tree

DirectX

Hinweis

Tatsächlich verwendet die WPF im Hintergrund einen weiteren Thread, der für das Rendering(= Zeichnen auf den Bildschirm) verantwortlich ist. Eine WPF-Anwendung besitzt somit immerzwei Threads:

� einen UI-Thread, der Benutzereingaben mit der Maus oder Tastatur entgegennimmt,Events entgegennimmt und Ihren Code ausführt

� einen Render-Thread, der für das Zeichnen der Inhalte verantwortlich ist


56


1.3.2 WindowsBase

Die Assembly windowsbase.dll enthält die Basislogik für Windows-Anwendungen und istin .NET geschrieben. Unter anderem ist in der Assembly WindowsBase die Logik für das in.NET 3.0 eingeführte, erweiterte Eigenschaftssystem implementiert, das aus den soge-nannten Dependency Properties besteht. Dependency Properties werden in Kapitel 7,»Dependency Properties«, genauer betrachtet. Weiter enthält WindowsBase Low-Level-Klassen, die notwendig sind, um beispielsweise in Ihrer WPF-Anwendung die Nachrich-tenschleife zu starten. Die Assemblies PresentationCore und PresentationFramework bauenbeide auf WindowsBase auf.

1.3.3 PresentationCore

In PresentationCore ist auf der .NET-Seite die Verbindung der beiden BaumstrukturenVisual Tree und Composition Tree (auf MilCore-Seite) in der abstrakten Klasse Sys-tem.Windows.Media.Visual implementiert. Der Visual Tree einer WPF-Anwendung be-steht aus Objekten von Subklassen der Klasse Visual. Die Klasse Visual enthält private

Abbildung 1.11 Die Flip3D-Funktion von Windows Vista und Windows 7 basiert auf MilCore.


57


Methoden zur Kommunikation mit dem auf MilCore-Seite bestehenden CompositionTree. Visual dient als Basisklasse für jene Klassen, die in der WPF visuell dargestellt wer-den sollen.

Neben Visual enthält PresentationCore einige weitere interessante Klassen, unter ande-rem die Klasse UIElement, die in der WPF von Visual ableitet und eine konkrete Imple-mentierung für visuelle Elemente darstellt. Mehr zu Visual, UIElement und weiterenKlassen möchte ich Ihnen an dieser Stelle noch nicht verraten; ich werde sie in Kapitel 2,»Das Programmiermodell«, und in den folgenden Kapiteln ausführlicher behandeln.

1.3.4 PresentationFramework

Für die Entwicklung der grafischen Benutzerschnittstelle wie auch der Funktionalität ei-ner Anwendung befinden sich die wichtigsten Klassen der WPF in der Assembly presenta-tionframework.dll. Darunter sind Klassen für Controls, Dokumente, Layout-Panels, Benut-zerführung und Animationen sowie Klassen zum Einbinden von Videos und Bildern. Oftwird diese Assembly allein als »die« WPF bezeichnet, da die anderen Assemblies Win-dowsBase und PresentationCore nur die Basis für ein UI-Framework bieten. Die WPF ist einsolches UI-Framework, das in der Assembly PresentationFramework implementiert ist.

In Kapitel 2, »Das Programmiermodell«, werden Sie sehen, dass die Assemblies presenta-tioncore.dll, presentationframework.dll und auch die Assembly windowsbase.dll standard-mäßig in Ihrem WPF-Projekt referenziert werden.

1.3.5 Vorteile und Stärken der WPF-Architektur

Durch die Architektur der WPF und dem darunterliegenden MilCore als Wrapper umDirectX ergeben sich viele Vorteile gegenüber Windows Forms und älteren Win32-Tech-nologien. Die Wichtigsten fasse ich an dieser Stelle kurz zusammen:

� Volle Ausnutzung der HardwareDurch den Aufbau auf DirectX können WPF-Anwendungen die in heutigen Rechnernbereits standardmäßig vorhandenen, leistungsfähigen Grafikkarten voll ausnutzen.Falls die Kraft der Grafikkarte nicht ausreicht, wird von Hardware- auf Software-Ren-dering umgestellt.

� Die WPF »zeichnet« selbstIn einer WPF-Anwendung werden die visuellen Elemente durch die WPF gezeichnetund nicht wie in Windows Forms und älteren Win32-Technologien durch das Betriebs-system. Dies erlaubt zum einen verschiedene Effekte wie die bereits erwähnte Trans-parenz. Neben solchen Effekten ist zum anderen durch das selbstständige Zeichnen derWPF das flexible Inhaltsmodell möglich, wodurch Sie visuelle Elemente beliebig inein-ander verschachteln können. Zu guter Letzt können Sie aufgrund der Zeichnung durch


58


die WPF das visuelle Erscheinungsbild von Controls mit Styles und Templates nach Ih-ren Wünschen anpassen.

� Zwischengespeicherte ZeichnungsdatenDurch die zwischengespeicherten Zeichnungsdaten eines visuellen Elements ist ein ef-fektives Neuzeichnen möglich. Die Informationen des Visual Trees werden mit demseitens MilCore bestehenden Composition Tree abgeglichen. Ist ein Neuzeichnen not-wendig, weil vielleicht ein anderes Fenster das Fenster Ihrer Applikation verdeckt hat,können dafür die im Composition Tree bereits vorhandenen, zwischengespeichertenZeichnungsinformationen verwendet werden. Auch Änderungen an einem visuellenElement – und somit an einem Knoten des Visual Trees – können sehr effizient neu ge-zeichnet werden. Ändern Sie die Border-Linie eines Buttons, wird diese Änderung anMilCore übertragen und der entsprechende DirectX-Befehl zur Neuzeichnung der Bor-der-Linie erstellt. In Windows Forms wäre eine Neuzeichnung des ganzen Buttons not-wendig.

� Vektorbasierte GrafikenDie Inhalte Ihrer Anwendung werden durch die WPF vektorbasiert gezeichnet. Somitist Ihre Anwendung beliebig skalierbar und wirkt auch vergrößert nicht pixelig.

Tipp

Ob eine WPF-Anwendung die Hardware voll ausnutzt, hängt von den Eigenschaften der Gra-fikkarte und von der installierten DirectX-Version ab. Die WPF teilt Rechner aufgrund dieserUmstände in drei Ebenen ein:

� Ebene 0 – es ist DirectX kleiner Version 7.0 installiert. Es findet somit keine Hardware-beschleunigung statt. Das ganze Rendering (= Zeichnen) findet in der Software statt. Dasist nicht sehr leistungsstark.

� Ebene 1 – eingeschränkte Hardwarebeschleunigung durch die Grafikkarte. DirectX ist min-destens in der Version 7.0 installiert, aber kleiner als Version 9.0.

� Ebene 2 – fast alle Grafikfeatures der WPF verwenden die Hardwarebeschleunigung derGrafikkarte. Auf dem Rechner ist mindestens DirectX 9.0 installiert.

In einer WPF-Anwendung können Sie prüfen, auf welcher Ebene Ihre Anwendung läuft. Nut-zen Sie dazu die statische Tier-Property der Klasse RenderCapability (Namespace: Sys-tem.Windows.Media). Die Tier-Property ist vom Typ int. Allerdings müssen Sie aus diesemint das sogenannte High-Word extrahieren, damit Sie die eigentliche Ebene erhalten. Sieextrahieren ein High-Word (auch hWord genannt), indem Sie eine Bit-Verschiebung um 16Bits durchführen. Folgende Zeile zeigt, wie es geht:

int ebene = RenderCapability.Tier >> 16;

Auf meinem Rechner enthält der Integer ebene den Wert 2. Meine Grafikkarte ist somit gut,und es ist mindestens DirectX in der Version 9.0 installiert. Demnach findet bei WPF-Anwen-dungen eine Hardwarebeschleunigung statt.


59

Konzepte 1.4

Die WPF wurde speziell für Windows Vista und zukünftige Windows-Versionen wie Win-dows 7 entwickelt. Obwohl WPF-Anwendungen auch unter Windows Server 2003 undWindows XP lauffähig sind, werden unter Windows Vista Grafiken schärfer und Anima-tionen glatter dargestellt. Der Grund dafür liegt darin, dass Windows Vista und Windows 7spezielle Treiber für die WPF zur Verfügung stellen, die beispielsweise Anti-Aliasing un-terstützen (Glätten der Kanten). Insbesondere bei WPF-Anwendungen mit 3D-Inhaltenfällt in Windows Server 2003 und Windows XP die fehlende Anti-Aliasing-Unterstützungauf (siehe Abbildung 1.12).

Wundern Sie sich also nicht, wenn Ihre WPF-Anwendung unter Windows XP oder Win-dows Server 2003 ein wenig kantiger als unter Windows Vista oder Windows 7 aussieht.

Neben der neuartigen Architektur baut die WPF auch auf diversen Konzepten auf. So kön-nen Sie beispielsweise eine Benutzeroberfläche deklarativ mit der XML-basierten Be-schreibungssprache XAML erstellen. Einige dieser Konzepte, die uns Programmierern dasLeben erleichtern sollen, werden im nächsten Abschnitt betrachtet.

1.4 Konzepte

Mit der WPF-Architektur haben Sie bereits einen kleinen Blick hinter die Kulissen derWPF werfen können. In diesem Abschnitt erfahren Sie mehr über ein paar der grund-legenden Konzepte der WPF, die auf der .NET-Seite verankert sind. Neben der deklarati-ven Sprache XAML sind dies unter anderem Dependency Properties, Routed Events, Com-mands, Styles, Templates und 3D. Hier dargestellte und weitere Konzepte – wie Layout,

Abbildung 1.12 Windows Vista stellt Kanten schärfer dar als Windows XP.


60


Ressourcen und Data Binding – werden in späteren Kapiteln separat betrachtet. An dieserStelle erhalten Sie lediglich einen kleinen Einblick. Es soll dabei (noch) nicht jedes Detailbeleuchtet werden; betrachten Sie diesen Abschnitt somit als eine kleine Schnupper-runde, die Sie locker angehen können.

1.4.1 XAML

Die Extensible Application Markup Language (XAML) ist eine in .NET 3.0 eingeführte,XML-basierte Beschreibungssprache, mit der Sie Objektbäume erstellen können. Zur Lauf-zeit werden aus den in XAML deklarierten XML-Elementen .NET-Objekte erzeugt.

Bei der WPF können Sie XAML für die Beschreibung von Benutzeroberflächen für Win-dows- und Webanwendungen einsetzen. Dafür definieren Sie in XAML Controls, Styles,Animationen oder 3D-Objekte, um nur einige der Möglichkeiten zu nennen. FolgenderCodeschnipsel stellt bereits einen gültigen XAML-Ausschnitt dar und erstellt einen Buttonmit kursiver Schriftart, einem Rand von 10 Einheiten und dem Inhalt »OK«:

<Button Name="btnOk" FontStyle="Italic" Margin="10">OK</Button>

Event Handler und sonstige Logik werden üblicherweise in einer in C# geschriebenenCodebehind-Datei eingefügt. XAML-Dateien, die nicht Teil eines Visual-Studio-Projektssind, werden auch als Loose XAML bezeichnet. Sie können diese alleinstehenden XAML-Dateien mit der Endung .xaml direkt im Internet Explorer öffnen, ohne sie vorher zu kom-pilieren. Ein installiertes .NET Framework in der Version 3.0 wird allerdings vorausge-setzt.

Der XAML-Ausschnitt in Listing 1.1 ordnet das Button-Element durch das xmlns-Attributdem XML-Namespace der WPF zu. Der XAML-Parser kann durch diesen XML-Namespacedas Button-Element beim Parsen dem CLR-Namespace System.Windows.Controls undder in diesem Namespace enthaltenen Klasse Button zuordnen. Die Details werden wiruns in Kapitel 3, »XAML«, genauer ansehen. Tippen Sie den untenstehenden Code in No-tepad ein, und speichern Sie die Datei mit der Endung .xaml ab. Wenn Sie die erstellte Da-tei doppelklicken, wird der Button im Internet Explorer mit einem Rand von 10, kursiverSchriftart und dem Inhalt »OK« dargestellt (siehe Abbildung 1.13).

<Button xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"Name="btnOk" FontStyle="Italic" Margin="10">

OK</Button>

Listing 1.1 Beispiele\K01\01 Button.xaml

Hinweis

Mit anderen Worten: XAML ist ein Serialisierungsformat. Zur Laufzeit werden die Inhalteeiner XAML-Datei deserialisiert und die entsprechenden Objekte erzeugt.


61

Konzepte 1.4

Anstatt Ihre Benutzeroberflächen mit XAML zu definieren, ist natürlich auch der prozedu-rale Weg mit C# möglich. Der XAML-Ausschnitt aus Listing 1.1 entspricht folgendem C#-Code:

System.Windows.Controls.Button btnOk =new System.Windows.Controls.Button();

btnOk.FontStyle = System.Windows.FontStyles.Italic;btnOk.Margin = new System.Windows.Thickness(10);btnOk.Content = "Ok";

Listing 1.2 Ein Button in C#

Obwohl Sie Ihre Benutzeroberfläche auch rein in C# erstellen können – und dies in Aus-nahmen bei komplexen Oberflächen manchmal auch sinnvoll ist –, profitieren Sie dannnatürlich nicht von den Vorteilen, die Ihnen XAML bietet:

� Sie können mit XAML die Darstellung Ihrer Anwendung besser von der dahinterlie-genden Businesslogik trennen. Üblicherweise definieren Sie dazu in XAML die Be-schreibung Ihrer Oberfläche und setzen die eigentliche Logik in eine Codebehind-Da-tei, die in einer prozeduralen Sprache wie C# programmierte Methoden und EventHandler enthält. Das Prinzip der Codebehind-Datei kennen Sie vielleicht aus ASP.NET;auch dort werden Darstellung und Logik auf diese Weise getrennt.

� Die Beschreibung einer Benutzeroberfläche in XAML ist wesentlich kompakter undübersichtlicher als die Erstellung in C#. XAML schraubt somit die Komplexität IhresCodes nach unten.

� Eine XAML-Datei ist ideales Futter für einen Designer, der Ihrer Benutzeroberflächemit Tools wie Expression Blend und Zam3D mehr Leben einhaucht und eine zeitge-mäße Darstellung verleiht. Diese Tools können XAML lesen und/oder exportieren.

� In XAML erstellte Benutzeroberflächen werden zur Designzeit stets aktuell im WPF-Designer dargestellt. In C# erstellte Benutzeroberflächen dagegen nicht; diese sehenSie erst zur Laufzeit.

Abbildung 1.13 Im Internet Explorer geöffnete Loose-XAML-Datei


62


� In XAML lässt sich jede öffentliche .NET-Klasse verwenden, die einen Default-Kon-struktor besitzt.

� Wenn Sie bereits mit Windows Forms und Visual Studio programmiert haben, dannwissen Sie, dass in Visual Studio zu jeder Form Code vom Windows-Forms-Designer ge-neriert wird. In .NET 2.0 wurde dieser generierte Code in eine partielle Klasse ausge-lagert. Sobald etwas an diesem generierten Code geändert wurde, hatte der Windows-Forms-Designer meist Probleme, die Form wieder korrekt darzustellen, da er eine be-stimmte Formatierung des Codes voraussetzte. In XAML besteht dieses Problem nichtmehr: Sie können in XAML beliebige Änderungen durchführen, die sofort vom WPF-Designer dargestellt werden. Nehmen Sie umgekehrt Änderungen im WPF-Designervor, werden diese gleich in XAML übernommen.

Wie Sie sehen, bietet XAML einige Vorteile gegenüber C#. Bedenken Sie jedoch, dassXAML die Sprache C# nicht ersetzen wird. XAML ist eine deklarative Sprache, in der Siebeispielsweise keine Methoden definieren können. Dennoch eignet sich eine deklarativeSprache bestens für die Definition von Benutzeroberflächen.

In Kapitel 3, »XAML«, werden wir XAML genau durchleuchten und uns die Syntax undMöglichkeiten dieser deklarativen, XML-basierten Sprache ansehen. An dieser Stelle wen-den wir uns einem weiteren Konzept zu, auf dem die WPF aufbaut, den Dependency Pro-perties.

1.4.2 Dependency Properties

Dependency Properties sind eines der wichtigsten Konzepte der WPF. In der WPF lassensich Properties auf verschiedene Arten setzen: Entweder auf dem üblichen Wege direktauf einem Objekt in C#, in XAML oder über Styles, Data Binding oder Animationen. Ei-nige Properties werden sogar durch eine Eltern-Kind-Beziehung »vererbt«. Ändern Sieden Wert der FontSize-Property eines Window-Objekts, wird der gesetzte Wert wie vonGeisterhand – im Hintergrund hat natürlich die WPF ihre Hände im Spiel – auch von imFenster enthalten Button- und TextBox-Objekten verwendet.

Eine Dependency Property ist also abhängig – daher der Name »Dependency« (»Abhängig-keit«) – von mehreren Quellen in Ihrer Anwendung und im System. Wenn eine Depen-dency Property nicht gesetzt ist, hat sie einen Default-Wert.

Dependency Properties sind bei der WPF die Grundlage für Styles, Animationen, DataBinding, Property-Vererbung und vieles mehr. Mit einer normalen .NET Property könnenSie keinen Gebrauch von diesen »Diensten« der WPF machen. Glücklicherweise sind diemeisten Properties der Elemente der WPF als Dependency Property implementiert undlassen sich somit mit Animationen, Data Bindings oder Styles verwenden.


63

Konzepte 1.4

Die wohl wichtigste Eigenschaft einer Dependency Property ist ihr integrierter Benach-richtigungsmechanismus für Änderungen, wodurch die WPF beobachten kann, wann sichihr Wert ändert. Dies macht sie auch als Quelle für ein Data Binding ideal.

Dependency Properties werden in der Laufzeitumgebung der WPF in der sogenanntenProperty Engine registriert, die die Grundlage für die Möglichkeiten wie etwa die Pro-perty-Vererbung ist.

Zusammengefasst bieten Dependency Properties folgenden Mehrwert gegenüber klassi-schen .NET Properties:

� Verfügen über einen integrierten Benachrichtigungsmechanismus

� Besitzen einen Default-Wert

� Besitzen Metadaten, die unter anderem Information enthalten, ob durch eine Ände-rung des Wertes ein Neuzeichnen des visuellen Elements notwendig ist.

� Verfügen über eine integrierte Validierung

� Bieten Property-Vererbung über den Visual Tree

� Viele Dienste der WPF wie Animationen oder Styles lassen sich nur mit DependencyProperties verwenden. Mit normalen Properties wäre es ohne weiteren Code nichtmöglich zu bestimmen, welche Quelle (Animation, Style, lokaler Wert etc.) den end-gültigen Wert einer Dependency Property festlegt.

� Können als Attached Property implementiert auch auf anderen Elementen gesetzt wer-den.

Aus Entwicklersicht besteht eine Dependency Property aus einer klassischen .NET Pro-perty – wenn diese auch optional ist – und einem öffentlichen, statischen Feld vom TypDependencyProperty. Dieses Feld stellt den Schlüssel zum eigentlichen Wert der Propertydar.

public class MyClass:DependencyObject{public static readonly DependencyProperty FontSizeProperty= DependencyProperty.Register("FontSize"

,typeof(double),typeof(Button),new FrameworkPropertyMetadata(11.0,FrameworkPropertyMetadataOptions.Inherits|FrameworkPropertyMetadataOptions.AffectsRender));

public double FontSize{

get { return (double)GetValue(FontSizeProperty); }


64


set { SetValue(FontSizeProperty, value); }}

}

Listing 1.3 Implementierung einer Dependency Property

Die Methoden GetValue und SetValue, die in Listing 1.3 in den get- und set-Accessorender .NET Property aufgerufen werden, sind in der Klasse DependencyObject definiert, vonder die dargestellte Klasse erbt. Jede Klasse, die Dependency Properties speichern möchte,muss von DependencyObject abgeleitet sein.

Der obere Codeausschnitt soll Ihnen nur eine kleine Vorstellung davon geben, wie die Im-plementierung einer Dependency Property aussieht. In Kapitel 7, »Dependency Proper-ties«, werden wir diese Implementierung ausführlich betrachten. Denken Sie an dieserStelle noch an das Motto dieses Kapitels, »Lehnen Sie sich zurück«. Wir werden uns späteralles noch sehr genau anschauen.

Auf den ersten Blick werden Sie aufgrund der Kapselung durch eine normale .NET Pro-perty nicht bemerken, dass Sie auf eine Dependency Property zugreifen. Beispielsweise istdie FontSize-Property der Button-Klasse als Dependency Property implementiert, diesich aufgrund der Kapselung durch eine »normale« .NET Property auch wie eine solcheverwenden lässt:

System.Windows.Controls.Button btn =new System.Windows.Controls.Button();

btn.FontSize = 15.0;

Neben der Kombination eines statischen Feldes vom Typ DependencyProperty mit einernormalen .NET Property als Wrapper treten Dependency Properties auch als AttachedProperties auf. Das Besondere an einer Attached Property ist, dass sie Teil einer Klasse ist,aber auf Objekten anderer Klassen gesetzt wird. Dies mag zunächst etwas verwunderlichklingen, wird aber insbesondere bei Layout-Panels verwendet. Kindelemente müssen so-mit nicht mit unnötig vielen Eigenschaften für jedes Layout-Panel überladen werden, dadie Definition der Dependency Properties im Panel selbst liegt. Wie kann das gehen?

Das Panel definiert nur den Schlüssel für einen Wert. Dieser Schlüssel ist ein statischesFeld vom Typ DependencyProperty. Objekte, die Dependency Properties speichern, müs-sen zwingend vom Typ DependencyObject sein. Diese Klasse enthält vereinfacht geseheneine Art Hashtable, in der mit der Methode SetValue Schlüssel/Wert-Paare gespeichertwerden. Alle Controls der WPF leiten von dieser Klasse ab und besitzen somit intern eine

Hinweis

Im Gegensatz zu einer normalen .NET Property kann die als Dependency Property implemen-tierte FontSize in Animationen oder Styles verwendet werden.


65

Konzepte 1.4

solche Art Hashtable. Möchten Sie auf einem Button eine Layout-Property speichern, sowird der Wert in der Hashtable des Button-Objekts unter dem in der Panel-Klasse defi-nierten Schlüssel gespeichert. Nimmt das Panel-Objekt das Layout vor, so kann es mitdem Schlüssel die für das Layout benötigten Werte der einzelnen Controls abrufen.

XAML definiert für die Attached Properties eine eigene Syntax. In Listing 1.4 wird einGrid mit zwei Zeilen definiert. Ein Grid ist eines der Layout-Panels der WPF, das Elementein Zeilen und Spalten anordnet. Im Grid in Listing 1.4 wird eine TextBox der ersten undein Button der zweiten Zeile zugeordnet. Dazu wird die in der Klasse Grid als AttachedProperty implementierte Grid.Row auf der TextBox und auf dem Button gesetzt:

<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"><Grid.RowDefinitions><RowDefinition/><RowDefinition/></Grid.RowDefinitions><TextBox Grid.Row="0" Text="In Zeile 1 des Grid" Margin="10"/><Button Grid.Row="1" Content="In Zeile 2 des Grid" Margin="10"/></Grid>

Listing 1.4 Beispiele\K01\02 DependencyProperties.xaml

Nimmt das Grid nun das Layout vor, so kann es auf jedem einzelnen Element dieGrid.Row durch Aufruf von GetValue abfragen und so die Elemente in die entsprechendeZeile setzen. Abbildung 1.14 zeigt, wie der Internet Explorer die XAML-Datei aus Listing1.4 darstellt.

Obwohl Sie Dependency Properties wahrscheinlich meist nur bei der Implementierungeigener Controls benötigen, trägt ihr Verständnis natürlich zu einem effektiveren Umgangmit der WPF bei. Beim Einstieg in die WPF sorgen Dependency Properties bei den meis-

Abbildung 1.14 Durch die Attached Properties werden hier eine TextBox und ein Button in einem Grid untereinander in zwei Zeilen angeordnet.


66


ten Entwicklern für Missverständnisse und manchmal auch für etwas Frust. Dies liegtmeist daran, dass am Anfang nicht ganz klar ist, wofür die Dependency Properties dennletztlich gut sind, und sie das Bild von .NET ein wenig komplizierter erscheinen lassen. Se-hen Sie sich nochmals den Mehrwert von Dependency Properties gegenüber klassischen.NET Properties am Anfang dieses Abschnitts an. Behalten Sie an dieser Stelle im Hinter-kopf, dass Sie die in der WPF integrierten Animationen, Styles und vieles mehr nur mitDependency Properties verwenden können. Auch das Prinzip der Attached Properties –die Sie unter anderem in Kapitel 6, »Layout«, noch öfter sehen werden – ist nur dank De-pendency Properties möglich.

Da die Dependency Properties ein zentrales Element der WPF sind, dieser Abschnitt si-cher einige Fragen offenlässt und Ihren Wissensdurst über Dependency Properties gewissund hoffentlich nicht gestillt hat, ist ihnen in diesem Buch ein eigenes Kapitel gewidmet.In Kapitel 7, »Dependency Properties«, werden Sie alle Details zu Dependency Propertiesund ihrer Implementierung erfahren.

1.4.3 Routed Events

Neben Dependency Properties bilden Routed Events ein in der WPF durchgängig verwen-detes Konzept. Bei der WPF besteht das Prinzip der Entwicklung von Benutzeroberflächendarin, eine Hierarchie von Elementen zu erzeugen; die Hierarchie wird als Element Treebezeichnet. Die Elemente im Element Tree stehen in einer Eltern-Kind-Beziehung. EinButton kann als Inhalt ein StackPanel – ein Layout-Container der WPF – enthalten, und da-rin könnte sich ein einfaches Rectangle-Objekt befinden.

Stellen Sie sich vor, was passiert, wenn ein Benutzer auf das im StackPanel der Button-Instanz enthaltene Rectangle klickt. Bekommt der Button dann auch eine Benachrichti-gung über das ausgelöste MouseLeftButtonDown-Event? In bisherigen Programmiermodel-len wird er nicht benachrichtigt, denn bisher war es so, dass das Element, das im Vorder-grund steht und auf dem der Fokus liegt, auch das Event empfängt, in diesem Fall dasMouseLeftButtonDown-Event.

In der WPF ist die klassische Behandlung von Events nicht ausreichend, da sich auch ein-fache Controls wie ein Button aus mehreren anderen visuellen Elementen zusammenset-zen und nach dem klassischen Prinzip diese Elemente das Event absorbieren würden. DerButton selbst erhielte somit eventuell gar keine Information darüber, dass etwas »in ihm«geklickt wurde. Um zu unserem Button mit einem StackPanel und einem Rectangle zu-rückzukommen, bedeutet dies, dass der Button, wenn ein Benutzer auf das Rectangle oderdas StackPanel klickt, nach klassischem Event Handling selbst kein MouseLeftButtonDown-Event mitbekommt. Und genau das ist der Punkt, an dem die Routed Events der WPF insSpiel kommen. Routed Events können bei der WPF eine von drei verschiedenen Routing-Strategien verwenden:


67

Konzepte 1.4

� Tunnel – das Event wird von oben durch den Visual Tree in niedrigere Hierarchie-stufen geroutet.

� Bubble – das Event blubbert von einem im Visual Tree tiefer liegenden Element nachoben.

� Direct – das Event wird nur auf dem geklickten visuellen Element gefeuert. Diese Stra-tegie gleicht der bei Events, die Sie aus der bisherigen Programmierung mit .NET 2.0und früher kennen, mit der Ausnahme, dass sich diese Events auch in einem sogenann-ten EventTrigger verwenden lassen.

Das MouseLeftButtonDown-Event der WPF besitzt die Strategie Bubble. Wird in unseremButton auf das Rectangle geklickt, »blubbert« das Event nach oben zum StackPanel undvon dort zum Button. Der Button selbst löst beim Empfang des MouseLeftButtonDown-Events sein eigenes Click-Event aus, das auch die Bubble-Strategie besitzt und weiternach oben blubbert.

Tunneling Events und Bubbling Events treten oft in Paaren auf. So gibt es zum BubblingEvent MouseLeftButtonDown ein passendes Gegenstück, das Tunneling Event Preview-MouseLeftButtonDown. Abbildung 1.15 verdeutlicht den Button und das darin enthalteneStackPanel mit dem Rectangle als Inhalt. Sie sehen, wie zuerst die Tunneling Events – kon-ventionsgemäß mit dem Präfix »Preview« benannt – von oben nach unten und anschlie-ßend die Bubbling Events von unten nach oben gefeuert werden. Jedes Element, das indieser Route liegt, kann beispielsweise für das MouseLeftButtonDown-Event einen EventHandler installieren.

In Abbildung 1.16 sehen Sie ein Fenster, das unseren Button enthält. Im Button ist einStackPanel (schwarz), das wiederum ein Rectangle (rot) enthält. Auf dem Window, aufdem StackPanel, auf dem Button und auf dem Rectangle wurden Event Handler für dieEvents PreviewMouseLeftButtonDown und MouseLeftButtonDown installiert, die das Eventund den Sender in einer ListView ausgeben.

Abbildung 1.15 Bei der WPF werden Routed Events im Element Tree von oben nach unten getunnelt und blubbern von unten nach oben.

Button

StackPanel

Rectangle

Tu

nn

elin

g

Bu

bb

ling

Preview

Preview

Preview


68


In Abbildung 1.16 wurde direkt auf das Rectangle geklickt. Die ListView unterhalb desButtons wird anschließend durch die Event Handler auf den einzelnen Elementen mitEvent-Informationen gefüllt. Darin lässt sich gut erkennen, wie das PreviewMouseLeft-ButtonDown-Event vom Window bis zum Rectangle getunnelt wird. Anschließend blub-bert das MouseLeftButtonDown-Event vom Rectangle im Element Tree nach oben zurückzum Window.

In Abbildung 1.17 sehen Sie, wie das Event geroutet wird, wenn nicht auf das rote Rec-tangle, sondern auf das schwarze StackPanel geklickt wird.

Abbildung 1.16 Das Event wird vom MainWindow bis zum geklickten roten Rectangle getunnelt und blubbert wieder nach oben zum MainWindow.

Abbildung 1.17 Das Event wird vom MainWindow bis zum geklickten schwarzen StackPanel getunnelt und blubbert wieder nach oben zum MainWindow.


69

Konzepte 1.4

Ähnlich wie bei den mit Hilfe von Dependency Properties implementierten Attached Pro-perties lassen sich Routed Events auch auf visuellen Elementen setzen, die das RoutedEvent nicht selbst definieren. Es wird dann von Attached Events gesprochen. Stellen Siesich folgendes simples Beispiel vor:

Sie haben ein Fenster, das neun Buttons enthält. Jeder Button soll beim Klicken eine Mes-sagebox mit einer String-Repräsentation seines Inhalts anzeigen. Mit gewöhnlichenEvents installieren Sie für diese Aufgabe für jeden Button einen Event Handler für dasClick-Event, oder Sie verwenden einen gemeinsamen Event Handler, den Sie dennochmit dem Click-Event jedes Buttons verbinden müssen.

Wie Sie bereits erfahren haben, besitzt das Click-Event die Strategie Bubble. Somit habenSie die Möglichkeit, nur einen Event Handler für das Button.ClickEvent auf dem Win-dow-Objekt einmalig zu installieren. Wird auf einen Button geklickt, blubbert das Click-Event vom Button nach oben zum Window-Objekt. Das Window-Objekt erhält das Eventund ruft den Event Handler auf. Allerdings befindet sich in der sender-Variablen desEvent Handlers immer das Window-Objekt. Sie erhalten über die Source-Property der beiRouted Events verwendeten RoutedEventArgs eine Referenz auf den geklickten Buttonund können so die MessageBox mit dem Namen anzeigen.

Wie Sie sehen, eröffnen sich Ihnen mit Routed Events interessante, neue Möglichkeiten.In Kapitel 8, »Routed Events«, erfahren Sie alle notwendigen Details zu Routed Events undlernen, wie Sie Routed Events in eigenen Klassen implementieren.

1.4.4 Commands

Ein weiteres Konzept der WPF ist die integrierte Infrastruktur für Commands. Im Gegen-satz zu Events erlauben Commands eine bessere Trennung der Präsentationsschicht vonder Anwendungslogik. Sie geben auf einem Element in XAML nicht direkt einen EventHandler an, sondern lediglich ein Command.

Stellen Sie sich vor, Sie werden beauftragt, einen kleinen Texteditor zu programmieren.Darin benötigen Sie unter anderem Funktionalität zum Ausschneiden, Kopieren und Ein-fügen von Text. Typischerweise kann ein Benutzer diese Funktionen aus dem Menü, demKontextmenü oder der Toolbar aufrufen. In unserem Beispiel soll es der Einfachheit hal-ber je Funktion ein MenuItem wie auch einen Button geben.

Klassisch würden Sie für jedes MenuItem und jeden Button einen Event Handler imple-mentieren, der die entsprechende Funktion ausführt. Haben Sie den Event Handler fürdas Ausführen des Kopierens auf dem MenuItem und auch auf dem Button erstellt, somüssen Sie darüber hinaus Ihre Controls entsprechend aktivieren und deaktivieren. Dennnur, wenn Text in der Textbox markiert ist, sollen die Controls für die Kopierfunktionali-tät auch aktiviert sein. Auch dies lässt sich mit den entsprechenden Event Handlern aus-


70


programmieren. Neben dem Aktivieren und Deaktivieren möchten Sie eventuell die Tas-tenkombinationen (Strg) + (C) unterstützen. Hier ist ebenso ein weiterer Event Handlernotwendig, der auf das KeyDown-Event reagiert und das entsprechende Kopieren des mar-kierten Textes in die Zwischenablage auslöst.

Fügen Sie ein weiteres Control zu Ihrem Texteditor hinzu, das die Copy-Funktionalität un-terstützen soll, beispielsweise einen Button in einer Toolbar, müssen Sie auch für diesesControl wieder alle Event Handler installieren und dafür sorgen, dass das Control richtigaktiviert und deaktiviert wird. Möchten Sie die Controls, die an der Kopierfunktionalitätteilnehmen, nicht fest in Ihrem Code verdrahten, wartet schon mehr Aufwand auf Sie.

Glücklicherweise gibt es in der WPF eine eigene Infrastruktur für Commands, die Ihnengenau solche Aufgaben wesentlich erleichtert und Ihnen im Gegensatz zu den Events einebessere Entkopplung Ihrer Benutzeroberfläche von der Anwendungslogik erlaubt. Klärenwir zunächst, was ein Command überhaupt ist. Bei einem Command handelt es sich umein Objekt einer Klasse, die das Interface ICommand (Namespace: System.Windows.Input)implementiert, das die Methoden Execute und CanExecute und das Event CanExe-cuteChanged definiert.

� Execute löst das Command aus.

� CanExecute gibt einen booleschen Wert zurück, der aussagt, ob das Command über-haupt ausgelöst werden kann.

� CanExecuteChanged wird ausgelöst, wenn CanExecute beim nächsten Aufruf vermut-lich einen anderen Wert zurückgibt.

Einem Button können Sie ein ICommand-Objekt über die Command-Property zuweisen. DasICommand wird automatisch ausgelöst, sobald Sie auf den Button klicken. Gibt die Can-Execute-Methode des Commands false zurück, so wird die IsEnabled-Property des But-tons automatisch auf false gesetzt.

Mit der Klasse RoutedCommand besitzt die WPF bereits eine pfannenfertige ICommand-Im-plementierung. Es gibt bereits vordefinierte RoutedCommand-Objekte. So besitzt die KlasseApplicationCommands statische Properties wie Copy oder Paste, die RoutedCommand-Instanzen enthalten. Der Knackpunkt bei den Routed Commands ist, dass eine Routed-Command-Instanz die Logik für die Behandlung des Commands nicht selbst enthält. Dasheißt, die Execute-Methode der RoutedCommand-Klasse enthält nicht die Logik, die bei-spielsweise für einen Kopiervorgang notwendig ist.

Die Execute-Methode eines RoutedCommands löst im Hintergrund vereinfacht gesagt nureine Suche am Element Tree entlang nach sogenannten CommandBinding-Objekten aus. Je-des Control hat eine CommandBindings-Property, die mehrere CommandBinding-Objekteenthalten kann.


71

Konzepte 1.4

Ein CommandBinding-Objekt besitzt eine Referenz auf ein ICommand und definiert unter an-derem die Events Executed und CanExecute. Das Event Executed eines CommandBindingswird ausgelöst, wenn das RoutedCommand ausgeführt wird. Vor dem Executed-Event wirdimmer das Event CanExecute ausgeführt. Im Eventhandler dieses Events setzen Sie dieProperty CanExecute der CanExecuteRoutedEventArgs auf false, damit das Commandnicht ausgeführt werden kann und ein Button, dessen Command-Property das entspre-chende Command enthält, beispielsweise automatisch deaktiviert wird.

Die Suche nach einem CommandBinding und damit nach der auszuführenden Logik für einCommand beginnt meist bei dem fokussierten Control. Allerdings lässt sich auf einemMenuItem oder auf einem Button auch explizit die CommandTarget-Property auf ein be-stimmtes Control setzen, wodurch die Suche bei diesem CommandTarget beginnt. Wirdkein CommandBinding auf dem Zielelement gefunden, wird im Element Tree auf demnächsthöheren Element nach einem CommandBinding für das ausgelöste Command ge-sucht. Die Suche endet, wenn ein CommandBinding-Objekt gefunden wurde oder die Suchebeim Wurzelelement angelangt ist.

Die große Stärke bei der WPF liegt nun darin, dass viele Controls für die in der WPF vor-definierten Commands – wie eben ApplicationCommands.Copy – bereits CommandBinding-Objekte und somit vordefinierte Logik besitzen. Eine TextBox hat für das Command Ap-plicationCommands.Copy ein CommandBinding definiert, das im CanExecute-Event dieProperty CanExecute der CanExecuteEventArgs auf false setzt, falls in der Textbox keinText markiert ist. Wird das ApplicationCommands.Copy ausgeführt, wird im Executed-Event-Handler des in der TextBox enthaltenen CommandBindings der selektierte Text in dieZwischenablage kopiert.

Die in den Controls der WPF bereits vordefinierten CommandBinding-Instanzen erlaubenes Ihnen, einen funktionsfähigen Texteditor ohne prozeduralen Code rein in XAML zu er-stellen (siehe Listing 1.5).

<StackPanel Margin="10"><Menu>

<MenuItem Header="Copy" Command="ApplicationCommands.Copy"/><MenuItem Header="Cut" Command="ApplicationCommands.Cut"/>...

</Menu>

Hinweis

Das Zielelement eines Commands ist das in der CommandTarget-Property eines MenuItemsangegebene. Ist die CommandTarget-Property des MenuItems null, wird als Zielelement desCommands das Element mit dem Tastatur-Fokus verwendet. Beim Zielelement startet danndie Suche nach CommandBinding-Objekten aufwärts im Element Tree.


72


<TextBox MinHeight="100" TextWrapping="Wrap">...

</StackPanel>

Listing 1.5 Beispiele\K01\03 Commands.xaml

Hat der Benutzer im Texteditor aus Listing 1.5 keinen Text markiert, sind die MenuItemsfür Copy und Cut deaktiviert (siehe Abbildung 1.18). Sobald er Text selektiert, werden dieMenuItems und Buttons aktiviert.

In Kapitel 9, »Commands«, werden wir die Infrastruktur der Commands genauer unter dieLupe nehmen. Sie werden anhand der FriendStorage-Anwendung sehen, wie eigeneRouted Commands implementiert werden, und Sie lernen die vordefinierten Built-in-Commands der WPF kennen. Zudem erfahren Sie in Kapitel 9, »Commands«, mehr zumsogenannten Model-View-ViewModel-Pattern (MVVM), das auf Commands und DataBinding basiert.

1.4.5 Styles und Templates

Mit Styles und Templates lassen sich die Controls der WPF sehr einfach anpassen. EinStyle definiert lediglich eine Sammlung von Werten für Properties. Meistens wird einStyle als Ressource erstellt, damit er sich auf mehrere Elemente anwenden lässt. In Listing1.6 wird ein Style für Buttons erstellt, der die Width-, Height- und Template-Propertysetzt.

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"><Page.Resources><Style TargetType="Button"><Setter Property="Width" Value="75"/><Setter Property="Height" Value="30"/><Setter Property="Background" Value="Black"/><Setter Property="Foreground" Value="White"/><Setter Property="Template"><Setter.Value>

Abbildung 1.18 Der Texteditor, angezeigt im Internet Explorer


73

Konzepte 1.4

<ControlTemplate TargetType="Button"><Grid><Border Background="{TemplateBinding Background}"

CornerRadius="5"/><ContentPresenter HorizontalAlignment="Center"VerticalAlignment="Center"/>

</Grid></ControlTemplate>

</Setter.Value></Setter>

</Style></Page.Resources><StackPanel>

<Button Content="OK"/><Button Content="Abbrechen" Margin="5"/>

</StackPanel></Page>

Listing 1.6 Beispiele\K01\04 StylesUndTemplates.xaml

Mit dem Style in Listing 1.6 wird die Template-Property für Buttons in diesem Page-Ob-jekt gesetzt. Die Buttons behalten Ihre ganz normale Funktionalität, lösen beim Klickendas Click-Event aus usw., werden aber durch das ControlTemplate nicht wie gewöhnli-che Buttons dargestellt, wie Abbildung 1.19 zeigt. Dieser Ausschnitt gibt Ihnen nur einenkleinen Vorgeschmack darauf, wie einfach Sie das Aussehen der Controls der WPF durchdie Definition eines neuen Templates komplett verändern können.

1.4.6 3D

Mit der WPF können Sie 3D-Inhalte einfach in Ihre Anwendungen integrieren. 3D-Ob-jekte lassen sich vollständig in XAML definieren. Der dreidimensionale Inhalt wird durchdas Element Viewport3D dargestellt. Listing 1.7 enthält ein Viewport3D-Element. Darinwird ein Würfel erstellt (siehe Abbildung 1.20). Die Details lernen Sie in Kapitel 14, »3D-Grafik«, kennen.

Abbildung 1.19 Mit einem Template angepasste Buttons


74


<Viewport3D Height="250" Width="250"><Viewport3D.Camera><PerspectiveCamera Position="0.5 0.5 4" LookDirection="0 0 –1"/></Viewport3D.Camera><Viewport3D.Children><ModelVisual3D><ModelVisual3D.Content><DirectionalLight Color="White" Direction="0,0,-1"/>

</ModelVisual3D.Content></ModelVisual3D><ModelVisual3D><ModelVisual3D.Content><GeometryModel3D><GeometryModel3D.Geometry><MeshGeometry3D Positions="0,0,1 1,0,1 1,1,1 0,1,1

1,0,0 0,0,0 0,1,0 1,1,01,0,1 1,0,0 1,1,0 1,1,10,0,0 0,0,1 0,1,1 0,1,00,1,1 1,1,1 1,1,0 0,1,01,0,1 0,0,1 0,0,0 1,0,0"

TriangleIndices="0 1 2 2 3 04 5 6 6 7 48 9 10 10 11 812 13 14 14 15 1216 17 18 18 19 1620 21 22 22 23 20"

TextureCoordinates="0,1 1,1 1,0 0,00,1 1,1 1,0 0,00,1 1,1 1,0 0,00,1 1,1 1,0 0,00,1 1,1 1,0 0,00,1 1,1 1,0 0,0"/>

</GeometryModel3D.Geometry><GeometryModel3D.Material><DiffuseMaterial><DiffuseMaterial.Brush><ImageBrush ImageSource="thomas.jpg"/>

</DiffuseMaterial.Brush></DiffuseMaterial>

</GeometryModel3D.Material></GeometryModel3D>

</ModelVisual3D.Content><ModelVisual3D.Transform><RotateTransform3D><RotateTransform3D.Rotation>


75

Zusammenfassung 1.5

<AxisAngleRotation3D Axis="0.5 1 0" Angle="30"/></RotateTransform3D.Rotation>

</RotateTransform3D></ModelVisual3D.Transform>

</ModelVisual3D></Viewport3D.Children>

</Viewport3D>

Listing 1.7 Beispiele\K01\05 3D.xaml

1.5 Zusammenfassung

Die WPF ist ein umfangreiches Programmiermodell, mit dem sich sowohl Webbrowser-als auch Windows-Anwendungen entwickeln lassen.

Das .NET Framework 4.0 baut nicht wie .NET 3.5 und .NET 3.0 auf .NET 2.0 auf, sondernist eine »Side-by-Side«-Installation. Mit Visual Studio 2010 lassen sich Anwendungen für.NET 2.0, 3.0, 3.5 und 4.0 erstellen. Dies wird als Multitargeting bezeichnet.

Während bisherige Programmiermodelle unter Windows nur dünne Wrapper um dieWindows-API waren – so auch Windows Forms –, ist die WPF die erste UI-Bibliothek, diein .NET entwickelt wurde und nicht mehr auf der Windows-API aufbaut.

In der WPF können Sie Oberflächen mit der XML-basierten Beschreibungssprache XAMLdefinieren. XAML wird als Austauschformat zwischen Designer und Entwickler verwen-det. Doch auch wenn Sie allein, ohne Designer, eine Anwendung erstellen, erlaubt Ihnen

Abbildung 1.20 Einfaches 3D-Objekt mit einem Bild

Hinweis

Obwohl die 3D-API der WPF auf DirectX aufbaut, ist sie nicht zum Entwickeln von Spielengedacht. Dafür sollten Sie Managed DirectX verwenden, das wesentlich performanter ist. Die3D-API der WPF ist allerdings ein recht einfaches Mittel, um Ihrer Anwendung mit 3D-Effek-ten etwas Pep zu verleihen oder um beispielsweise Geschäftsdaten in 3D darzustellen.


76


XAML eine bessere Strukturierung Ihrer Anwendung und eine bessere Trennung zwi-schen Ihrer Benutzeroberfläche und Ihrer Programmlogik.

Visuelle Elemente werden in der WPF nicht durch das Betriebssystem, sondern durch dieWPF selbst gezeichnet. Dazu wird die auf DirectX aufsetzende MilCore-Komponente ver-wendet. Auch Windows Vista nutzt die native Low-Level-Komponente (MilCore) der WPFzur Darstellung des kompletten Desktops.

Die WPF zeichnet die Inhalte Ihrer Anwendung vektorbasiert. Dadurch ist Ihre Anwen-dung beliebig skalierbar und wird auch bei höherer Auflösung nicht pixelig dargestellt.Allerdings werden die Elemente nur unter Vista, Windows 7 und zukünftigen Windows-Versionen durch Anti-Aliasing »geglättet«. Unter Windows XP und Windows Server 2003erscheinen Ihre Anwendungen etwas kantiger.

Die WPF besitzt ein flexibles Inhaltsmodell, wodurch Sie in jedes visuelle Element anderevisuelle Elemente packen können.

Die WPF bietet integrierte Unterstützung für Animationen, 2D- und 3D-Grafiken, Layout,Data Binding und vieles mehr.

Mit der WPF können Sie nicht nur einfacher grafisch hochwertige Benutzeroberflächenerstellen als zuvor. Konzepte wie Dependency Properties, Routed Events und Commandsbieten Ihnen auch bei der Entwicklung von reinen Geschäftsanwendungen, die grafischnicht so anspruchsvoll sind, viele neue Möglichkeiten. Mit Templates können Sie zudemdas Aussehen eines Controls komplett neu definieren.

Benutzeroberflächen können Sie nur aus XAML, nur aus C# (oder einer anderen prozedu-ralen Sprache wie VB.NET) oder aus einer Mischung aus XAML und C# (in Codebehind-Datei) erstellen. Reine XAML-Anwendungen – sogenanntes Loose XAML – lassen sich di-rekt im Internet Explorer darstellen, wenn .NET 3.0 oder höher installiert ist.

In .NET 4.0 wurde die WPF um ein paar Features erweitert. Dies sind insbesondere dieneuen Controls, wie DataGrid und DatePicker. Auch der VisualStateManager aus Silver-light wird in WPF 4.0 unterstützt, zudem gibt es neue Grafik-Features, das Text-Renderingwurde verbessert, es gibt Wrapper-Klassen zum Steuern der Windows-7-Taskbar und vie-les mehr.

Microsoft wird in Zukunft Windows Forms zwar weiterhin unterstützen und diese Klas-sen weiterhin mit dem .NET Framework ausliefern, aber vorangetrieben wird die Ent-wicklung der WPF, der neuen strategischen Plattform für die Erstellung von Benutzer-oberflächen unter Windows.

Im nächsten Kapitel werden wir uns das Programmiermodell der WPF ansehen. Sie wer-den unter anderem die wichtigsten Klassen der WPF kennenlernen, und wir werden dieerste Windows-Anwendung mit der WPF implementieren.


959

Mit den Klassen der WPF lassen sich verschiedenste Formate wie .wav, .mp3, .mpeg oder .avi abspielen. Doch mit dem Abspielen allein ist es noch nicht genug: Videos lassen sich beispielsweise mit einem DrawingBrush fast überallhin zeichnen. Erfah-ren Sie in diesem Kapitel die Details.

16 Audio und Video

16.1 Einleitung

Die WPF bietet reichhaltige Audio- und Video-Unterstützung an. In diesem Kapitel lernenSie, wie Sie Audio und Video in Ihre Anwendungen einbinden. Um Audio-Dateien abzu-spielen, gibt es prinzipiell zwei Möglichkeiten:

� mit der Klasse SoundPlayer in C# bzw. mit SoundPlayerAction in XAML

� mit der Klasse MediaPlayer in C# bzw. mit MediaElement in XAML

Die erste Möglichkeit erlaubt nur das Abspielen von .wav-Dateien. Sie ist Thema von Ab-schnitt 16.2, »Audio (.wav) mit SoundPlayerAction und SoundPlayer«. Die zweite Mög-lichkeit mit MediaPlayer/MediaElement baut auf der Funktionalität des Windows MediaPlayers auf und beherrscht somit alle auch im Windows Media Player unterstützten For-mate, wie .wav oder .mp3. Die zweite Möglichkeit für Audio ist gleichzeitig auch die Artund Weise, wie Videos in WPF-Anwendungen eingebunden werden. Neben .wav und.mp3 unterstützen die Klassen MediaPlayer und MediaElement Formate wie .wmv, .aviund .mpeg. In Abschnitt 16.3, »Audio und Video mit MediaPlayer (C#)«, betrachten wir,wie Sie Audio- und Video-Dateien in C# mit der Klasse MediaPlayer abspielen.

In Abschnitt 16.4, »Audio und Video mit MediaElement (XAML)«, werden Audio- und Video-Dateien mit der von FrameworkElement abgeleiteten Klasse MediaElement abgespielt.MediaElement kapselt die Funktionalität der Klasse MediaPlayer. Im Gegensatz zur Media-Player-Klasse lässt sich ein MediaElement auch in XAML verwenden.

16.2 Audio (.wav) mit SoundPlayerAction und SoundPlayer

Zum Abspielen von einfachen .wav-Dateien bietet die WPF für XAML die Klasse Sound-PlayerAction an. Um in C# eine .wav-Datei abzuspielen, verwenden Sie die bereits seit


960

Audio und Video16

.NET 2.0 verfügbare Klasse SoundPlayer (Namespace: System.Media). Werfen wir einenBlick auf die Klassen SoundPlayerAction und SoundPlayer.

16.2.1 Audio mit SoundPlayerAction (XAML)

Mit einem Objekt der Klasse SoundPlayerAction (Namespace: System.Windows.Con-trols) lassen sich .wav-Dateien abspielen. Die Klasse SoundPlayerAction erbt neben denbereits aus dem vorherigen Kapitel, »Animationen«, bekannten Klassen BeginStoryboardund ControllableStoryboardAction von der Klasse TriggerAction (siehe Abbildung16.1). Folglich lässt sich ein SoundPlayerAction-Element der EnterActions-/Exit-Actions-Property eines Triggers oder der Actions-Property eines EventTriggers zuwei-sen.

Die Klasse SoundPlayerAction besitzt lediglich eine einzige Property, die Property Sourcevom Typ Uri. Sie definiert die zu verwendende .wav-Datei.

Der Button in Listing 16.1 hat zwei EventTrigger für die Events MouseEnter und Click. Inbeiden EventTriggern befindet sich ein SoundPlayerAction-Element, das implizit derActions-Property des jeweiligen EventTriggers zugewiesen wird. Wird die Maus über denButton bewegt, wird ein G-Akkord abgespielt. Beim Klicken ist die Gitarrensound.wav-Datei zu hören. Die .wav-Dateien wurden mit dem Buildvorgang Resource in die Assemblyeingebettet.

<Button Width="100" Height="23" Content="Sound-Button"><Button.Triggers><EventTrigger RoutedEvent="Button.MouseEnter">

<SoundPlayerAction Source="GAkkord.wav"/></EventTrigger><EventTrigger RoutedEvent="Button.Click"><SoundPlayerAction Source="Gitarrensound.wav"/>

</EventTrigger></Button.Triggers>

</Button>

Listing 16.1 Beispiele\K16\01 SoundInXAML\MainWindow.xaml

Abbildung 16.1 Die Klasse SoundPlayerAction erbt von TriggerAction.

DependencyObject

TriggerAction(abstract)

SoundPlayerActionBeginStoryboard ControllableStoryboardAction(abstract)


961

Audio (.wav) mit SoundPlayerAction und SoundPlayer 16.2

In Loose-XAML-Dateien kann eine .wav-Datei nur als Site-of-Origin-Datei vorliegen. DieKlasse SoundPlayerAction gibt sich leider nicht mit einem relativen Pfad zufrieden. Ent-weder definieren Sie absolute Pfade zur .wav-Datei, oder Sie geben den vollständigen PackURI mit dem packageURI siteOfOrigin:,,, an (siehe Listing 16.2).

<Button Width="100" Height="23" Content="Sound-Button"><Button.Triggers>

<EventTrigger RoutedEvent="Button.MouseEnter"><SoundPlayerAction

Source="pack://siteOfOrigin:,,,/GAkkord.wav"/></EventTrigger><EventTrigger RoutedEvent="Button.Click"><SoundPlayerActionSource="pack://siteOfOrigin:,,,/Gitarrensound.wav"/>

</EventTrigger></Button.Triggers>

</Button>

Listing 16.2 Beispiele\K16\02 SoundInLooseXAML.xaml

16.2.2 Audio mit SoundPlayer (C#)

In C# lässt sich eine .wav-Datei mit der bereits seit .NET 2.0 im Namespace System.Mediaverfügbaren Klasse SoundPlayer sowohl synchron als auch asynchron abspielen. Folgen-der Ausschnitt spielt die Datei GAkkord.wav ab. Die Datei GAkkord.wav liegt im gleichenVerzeichnis wie die Assembly:

SoundPlayer player = new SoundPlayer("GAkkord.wav");player.Play();

Hinweis

Die in der Source-Property des SoundPlayerAction-Elements angegebene .wav-Datei kanngemäß den binären Ressourcen bei der WPF:

� mit dem Buildvorgang Resource in die Assembly eingebettet werden

� mit dem Buildvorgang Inhalt lose neben der Assembly existieren. Die Assembly wird beidem Buildvorgang Inhalt mit dem Attribut AssemblyAssociatedContentFile versehen,das die Existenz der Datei definiert.

� als lose Datei vorliegen, die keine Verbindung zur Assembly hat (Site-of-Origin-Datei)

Je nachdem, an welchem Ort die .wav-Datei liegt, muss der entsprechende Pfad angegebenwerden. Für Resource und Content reicht die einfache Angabe eines relativen Pfads in XAMLaus. Bei einer Site-of-Origin-Datei muss der absolute Pfad oder der vollständige Pack URIangegeben werden. Mehr Informationen zu Pack URIs finden Sie in Kapitel 10, »Ressourcen«.


962

Audio und Video16

Die Play-Methode spielt die .wav-Datei asynchron ab. Zum synchronen Abspielen enthältdie Klasse SoundPlayer die Methode PlaySync. Eine dritte Methode namens PlayLoopingspielt die Datei in einer Endlosschleife ab. Dies geschieht natürlich asynchron. Es ergäbekeinen Sinn machen, an der Stelle des Methodenaufrufs zu warten. Zum Stoppen rufenSie die Stop-Methode auf.

Per Default lädt die Klasse SoundPlayer die .wav-Datei erst beim ersten Abspielen. Mitden Methoden Load oder LoadAsync lässt sich die Datei schon vorher laden. Sie finden aufder Klasse zusätzlich zu den beiden Methoden das LoadCompleted-Event, das gefeuertwird, sobald die Datei vollständig geladen wurde.

Die SoundPlayer-Klasse besitzt zwei Properties, um die Quelle einer .wav-Datei anzugeben:

� SoundLocation – vom Typ String. Definiert den Dateipfad oder eine URL zu einer.wav-Datei.

� Stream – vom Typ Stream. Definiert den Stream, von dem die .wav-Datei geladen wer-den soll.

Es gibt Konstruktoren, die direkt einen String für die SoundLocation-Property oder ebeneinen Stream entgegennehmen. Den ersten Konstruktor zum Setzen der SoundLocation-Property haben wir mit der GAkkord.wav-Datei bereits verwendet.

Die Stream-Property wird interessant, wenn Sie eine .wav-Datei beispielsweise mit demBuildvorgang Resource in Ihre Assembly eingebettet haben und diese aus C# abspielenmöchten. Mit der Methode GetResourceStream der Application-Klasse erhalten Sie einStreamResourceInfo-Objekt, das die gewünschte Ressource als Stream enthält. DerStream lässt sich dann direkt dem Konstruktor der SoundPlayer-Klasse übergeben. Listing16.3 zeigt, wie die mit dem Buildvorgang Resource in die Assembly eingebettete Gitarren-sound.wav-Datei abgespielt wird.

StreamResourceInfo sri = Application.GetResourceStream(new Uri("Gitarrensound.wav",UriKind.Relative));

SoundPlayer player = new SoundPlayer(sri.Stream);player.Play();

Listing 16.3 Beispiele\K16\03 SoundInCSharp\MainWindow.xaml.cs

Hinweis

Die in XAML verwendete Klasse SoundPlayerAction stellt tatsächlich nur einen Wrapper umdie Klasse SoundPlayer dar. Dank SoundPlayerAction ist es lediglich möglich, das Abspieleneiner .wav-Datei deklarativ in XAML zu definieren. Da SoundPlayerAction auf der KlasseSoundPlayer aufbaut, besitzt sie die gleichen Einschränkungen; es lassen sich nur .wav-Dateien abspielen.


963

Audio und Video mit MediaPlayer (C#) 16.3

Neben der Klasse SoundPlayer finden Sie im Namespace System.Media die beiden Klas-sen SystemSound und SystemSounds. Die Klasse SystemSound repräsentiert einen System-Sound. Sie besitzt lediglich die Methode Play. Einen öffentlichen Konstruktor gibt esnicht. Stattdessen finden Sie in der Klasse SystemSounds fünf statische Properties, die Ih-nen SystemSound-Objekte zurückgeben. Dies sind die Properties Asterisk, Beep, Excla-mation, Hand und Question. Mit folgender Zeile lässt sich somit ein einfacher Piepton ab-spielen:

SystemSounds.Beep.Play();

16.3 Audio und Video mit MediaPlayer (C#)

Mit der im vorherigen Abschnitt dargestellten Klasse SoundPlayer und ihrem XAML-Wrapper SoundPlayerAction lassen sich nur .wav-Dateien abspielen. Die WPF besitztzum Abspielen von Audio und Video (.mp3, .wav, .wmv, .avi, .mpeg) die Klasse Media-Player (Namespace: System.Windows.Media), die auf dem Windows Media Player auf-baut. Diese Klasse benötigt prozeduralen Code, um Audio-/Video-Dateien abzuspielen. Esgibt eine weitere, von FrameworkElement abgeleitete Klasse namens MediaElement, diesich in XAML verwenden lässt. Bevor wir uns MediaElement ansehen, werfen wir einenBlick auf die Klasse MediaPlayer.

Die Klasse SoundPlayer selbst kapselt übrigens die schon in älteren Windows-Versionen ver-fügbare native PlaySound-API, die in der nativen Winmm.dll zu finden ist.

Achtung

Obwohl die SystemSounds-Klasse auf den ersten Blick interessant scheint, sollten Sie sehrsparsam und sorgfältig damit umgehen. Der Benutzer kennt diese vom Betriebssystem ver-wendeten Geräusche und verbindet sie mit bestimmten Aktionen. Wenn Sie Ihre eigeneAnwendung an einigen Stellen mit diesen System-Geräuschen ausstatten, könnte es denBenutzer Ihrer Anwendung mehr verwirren als unterstützen.

Achtung

Die Klasse MediaPlayer verwendet den Windows Media Player zum Abspielen von Audio-und Video-Dateien. Auf dem Client muss der Windows Media Player mindestens in der Ver-sion 10 installiert sein.

Die später beschriebene Klasse MediaElement kapselt lediglich die MediaPlayer-Klasse.Auch sie setzt somit die Installation des Windows Media Players voraus.


964

Audio und Video16

16.3.1 Einfaches Abspielen

Die Klasse MediaPlayer besitzt fünf Methoden: Open, Pause, Play, Stop und Close. Mitder Open-Methode öffnen Sie eine Audio-/Video-Datei. Mit Play spielen Sie die Datei ab.

Neben den Methoden enthält die MediaPlayer-Klasse Properties wie HasAudio und Has-Video, um herauszubekommen, ob der MediaPlayer eine Audio- oder eine Video-Dateiabspielt, NaturalDuration, um die natürliche Länge der geladenen Datei abzufragen, undSpeedRatio, um die Geschwindigkeit festzulegen. Weisen Sie der Volume-Property einenWert zwischen 0 und 1 zu, um die Lautstärke zu regeln (Default ist 0.5). Die Balance-Pro-perty verwenden Sie zum Regeln der Stereo-Lautsprecher; –1 bedeutet links, und 1 bedeu-tet rechts. Der Default ist 0. Es ist an der Zeit, Audio- und Video-Dateien mit MediaPlayerabzuspielen.

Audio mit dem MediaPlayer

Zum Abspielen von Audio-Dateien wie .wav- oder .mp3-Dateien wird auf einem Media-Player-Objekt mit der Open-Methode die gewünschte Datei geladen und mit Play abge-spielt.

Listing 16.4 zeigt den Event Handler für das Click-Event eines Buttons. Nachdem darindie Klassenvariable _player mit einem MediaPlayer-Objekt initialisiert wurde, wird dieDatei Gitarrensound.wav mit der Open-Methode geladen und mit Play abgespielt. Für dieDatei Gitarrensound.wav wurde der Buildvorgang Inhalt ausgewählt, und sie wurde in dasAusgabeverzeichnis der Anwendung kopiert.

private MediaPlayer _player;private void Button_Click(object sender, RoutedEventArgs e){_player = new MediaPlayer();_player.Open(new Uri("Gitarrensound.wav", UriKind.Relative));_player.Play();

}

Listing 16.4 Beispiele\K16\04 MediaPlayer_Audio\MainWindow.xaml.cs

Beachten Sie, dass in Listing 16.4 die Klassenvariable _player eine Referenz zum Media-Player festhält. Würden Sie im Button_Click-Event-Handler eine lokale MediaPlayer-Va-riable erstellen, fiele diese dem Garbage Collector zum Opfer, wodurch die Audio-Dateiunkontrolliert abbräche.

Achtung

Da die Klasse MediaPlayer auf dem Windows Media Player aufbaut, ist es nicht möglich,Audio- oder Video-Dateien abzuspielen, die mit dem Buildvorgang Resource in die Assemblyeingebettet wurden.


965


Videos abspielen

Die Klasse MediaPlayer leitet über Animatable von der Klasse Freezable ab. Sie ist dem-nach nicht vom Typ Visual und kann sich somit nicht selbst darstellen. Wie können Siedann ein Video auf den Bildschirm bringen? Eine MediaPlayer-Instanz lässt sich derPlayer-Property eines VideoDrawing-Objekts zuweisen. Das VideoDrawing-Objekt wie-derum lässt sich mit einem DrawingBrush verwenden, der das Video letztendlich irgend-wohin zeichnet.

Listing 16.5 zeigt, wie es geht. In einem StackPanel befinden sich lediglich ein Rectanglenamens rect und ein Button. Auf dem Button-Element ist für das Click-Event der EventHandler Button_Click definiert.

<StackPanel><Rectangle x:Name="rect" Width="290" Height="200" Margin="5"/><Button Content="Play" Click="Button_Click" Margin="5"Width="75"/>

</StackPanel>

Listing 16.5 Beispiele\K16\05 MediaPlayer_Video\MainWindow.xaml

Das Rectangle aus Listing 16.5 wird im Button_Click-Event-Handler in der Codebehind-Datei mit einem Video gefüllt (siehe Listing 16.6). Dazu wird ein MediaPlayer-Objekt er-stellt und der Player-Property eines VideoDrawing-Objekts zugewiesen. Beachten Sie, dassauf dem VideoDrawing-Objekt auch die Rect-Property gesetzt wird. Dies ist notwendig,damit Sie überhaupt etwas sehen können. Das VideoDrawing-Objekt wird dem Drawing-Brush-Konstruktor übergeben, der der Fill-Property des Rectangle zugewiesen wird. EinAufruf der Play-Methode genügt, und das Video wird auf dem Rectangle abgespielt (sieheAbbildung 16.2).

private void Button_Click(object sender, RoutedEventArgs e){MediaPlayer player = new MediaPlayer();player.Open(new Uri("thomasOnBoard.wmv", UriKind.Relative));VideoDrawing drawing = new VideoDrawing();drawing.Player = player;drawing.Rect = new Rect(0, 0, 290, 200);DrawingBrush brush = new DrawingBrush(drawing);rect.Fill = brush;player.Play();

}

Listing 16.6 Beispiele\K16\05 MediaPlayer_Video\MainWindow.xaml.cs


966

Audio und Video16

Mit einem DrawingBrush und einem MediaPlayer lässt sich ein Video überall dort zeich-nen, wo ein Brush-Objekt erwartet wird. Weisen Sie den DrawingBrush beispielsweise derForeground-Property einer TextBox zu, damit ein Video auf dem Text abläuft. In Kapitel13, »2D-Grafik«, finden Sie dazu im Zusammenhang mit der VideoDrawing-Klasse ein Bei-spiel.

Abbildung 16.2 Video mit MediaPlayer

Tipp

Um das Video eines MediaPlayers darzustellen, gibt es neben der gezeigten Möglichkeit miteinem VideoDrawing-Objekt eine weitere. Die Klasse DrawingContext besitzt eine DrawVi-deo-Methode, die eine MediaPlayer-Instanz und ein Rect-Objekt entgegennimmt. Ein Dra-wingContext-Objekt erhalten Sie, indem Sie entweder die OnRender-Methode eines UIEle-ments überschreiben oder die RenderOpen-Methode eines DrawingVisual-Objekts aufrufen:

MediaPlayer player = new MediaPlayer();player.Open(new Uri("thomasOnBoard.avi", UriKind.Relative));DrawingVisual dv = new DrawingVisual();using(DrawingContext ctx = dv.RenderOpen()){ ctx.DrawVideo(player,new Rect(0,0,300,250));}

Das DrawingVisual-Objekt müssen Sie zum Visual Tree hinzufügen, damit es dargestelltwird. In Kapitel 13, »2D-Grafik«, finden Sie ein Beispiel zum Hinzufügen eines Drawing-Visual-Objekts.


967


16.3.2 Steuerung mit MediaClock und MediaTimeline

Die Klasse MediaPlayer besitzt die Open-Methode, mit der eine Audio-/Video-Datei geöff-net wird. Mit Methoden wie Play, Pause, Stop und Properties wie SpeedRatio oder Po-sition lässt sich die geladene Audio-/Video-Datei steuern.

Neben dieser Möglichkeit mit Methoden und Properties bietet die Klasse MediaPlayer ei-nen zweiten Weg an, Audio-/Video-Dateien abzuspielen. Dieser zweite Weg ähnelt denim vorherigen Kapitel beschriebenen Animationen, da auch hier eine Timeline und einClock-Objekt verwendet werden. Auf diese Weise steuern wir in diesem Abschnitt eineAudio-Datei.

Die Klasse MediaPlayer bietet demnach zum Abspielen einer Audio-/Video-Datei zweiMöglichkeiten:

� Unabhängiger Modus – wurde die Datei mit der Open-Methode geladen, läuft der Me-diaPlayer im sogenannten unabhängigen Modus. Sie steuern die Wiedergabe mit denMethoden Play, Stop usw. des MediaPlayers.

� Clock-Modus – wurde der Clock-Property eines MediaPlayers ein MediaClock-Objektzugewiesen, läuft der MediaPlayer im sogenannten Clock-Modus. Die Wiedergabesteuern Sie über den ClockController, der in der Controller-Property der verwende-ten MediaClock zu finden ist.

Bisher wurde der MediaPlayer im unabhängigen Modus verwendet. Im Folgenden nutzenwir den Clock-Modus, der alle aus dem Animationsbereich bekannten Möglichkeiten bietet.

Um einen MediaPlayer im Clock-Modus zu starten, muss ein Objekt der Klasse Media-Timeline erstellt werden. MediaTimeline erbt wie auch die für Animationen verwendeteBasisklasse AnimationTimeline von der abstrakten Klasse Timeline (siehe Abbildung16.3).

MediaTimeline erweitert Timeline um die Property Source (Typ Uri), der Sie die zu ver-wendende Audio-/Video-Datei zuweisen.

Eine Timeline beschreibt bekanntlich nur die Zeitlinie. Die tatsächliche Aktualisierung fin-det durch ein Clock-Objekt statt. Bei Animationen wird die von Clock abgeleitete Anima-tionClock verwendet, bei Audio/Video die ebenfalls von Clock abgeleitete MediaClock.Ein MediaClock-Objekt erstellen Sie, indem Sie auf Ihrer MediaTimeline die CreateClock-Methode aufrufen.

Achtung

Läuft der MediaPlayer im Clock-Modus, führt ein Aufruf der auf der MediaPlayer-Instanz ver-fügbaren Methoden wie Stop oder Pause zu einer InvalidOperationException. Die Steue-rung funktioniert nur über den ClockController der verwendeten MediaClock.


968

Audio und Video16

Ist die MediaClock-Instanz erstellt, brauchen Sie diese nur noch der Clock-Property einesMediaPlayer-Objekts zuzuweisen. Sie haben dann alle Möglichkeiten, mit dem ClockCon-troller die Animation zu steuern. Den ClockController finden Sie in der Controller-Property der verwendeten MediaClock.

Sehen wir uns dazu ein kleines Beispiel an. Listing 16.7 enthält ein StackPanel mit einerTextBox, einer ProgressBar und einem Button.

<Window ... Loaded="Window_Loaded"><StackPanel><TextBox IsReadOnly="True" x:Name="txtTime" Margin="5 5 5 0"/><ProgressBar x:Name="progressBar" Height="10" Margin="5"/><Button Content="Play" Click="PlayButton_Click" Width="75"

Margin="5"/></StackPanel></Window>

Listing 16.7 Beispiele\K16\06 MediaPlayer_Kontrollieren\MainWindow.xaml

In der Codebehind-Datei (siehe Listing 16.8) werden zwei Klassenvariablen vom Typ Me-diaTimeline und MediaClock erstellt. Im Window_Loaded-Event-Handler wird die Media-Timeline initialisiert und in der Source-Property der relative Pfad zur Datei Gitarren-sound.wav angegeben. Auf der MediaTimeline wird die CreateClock-Methodeaufgerufen, die die MediaClock-Variable initialisiert. Für das CurrentTimeInvalidated-Event wird ein Event Handler installiert. Dieser wird immer aufgerufen, wenn sich dieZeit der MediaClock ändert. Der Controller wird mit der Stop-Methode angehalten, damiter nicht gleich losläuft. Der Clock-Property der MediaPlayer-Instanz wird die erstellte Me-diaClock zugewiesen. Für das Event MediaOpened der MediaPlayer-Instanz wurde derEvent Handler OnPlayerMediaOpened definiert. Dieser wird aufgerufen, wenn die Audio-Datei vollständig geladen ist. Ist dies der Fall, enthält die NaturalDuration-Property des

Abbildung 16.3 Die Klasse MediaTimeline in der Klassenhierarchie

DependencyObject

Timeline(abstract)

AnimationTimeline(abstract)

TimelineGroup(abstract)

MediaTimeline


969


MediaPlayers die natürliche Länge der Datei – ideal, um die Maximum-Property der Pro-gressBar zu setzen.

Im OnCurrentTimeInvalidated-Event-Handler werden sowohl die TextBox als auch dieProgressBar aktualisiert. Im Event Handler PlayButton_Click wird auf dem ClockCon-troller die Begin-Methode aufgerufen, wodurch die Audio-Datei abgespielt wird. DerFortschritt ist dann in der TextBox und in der ProgressBar zu sehen (siehe Abbildung16.4).

public partial class MainWindow : Window{...private MediaTimeline _timeline;private MediaClock _clock;void Window_Loaded(object sender, RoutedEventArgs e){

_timeline = new MediaTimeline();_timeline.Source = new Uri("Gitarrensound.wav",

UriKind.Relative);_clock = _timeline.CreateClock();_clock.CurrentTimeInvalidated += OnCurrentTimeInvalidated;_clock.Controller.Stop();MediaPlayer player = new MediaPlayer();player.MediaOpened += OnPlayerMediaOpened;player.Clock = _clock;

}void OnPlayerMediaOpened(object sender, EventArgs e){

MediaPlayer player = sender as MediaPlayer;progressBar.Maximum = player.NaturalDuration.TimeSpan.Ticks;progressBar.Minimum = 0;

}void OnCurrentTimeInvalidated(object sender, EventArgs e){

txtTime.Text = _clock.CurrentTime.ToString();progressBar.Value = _clock.CurrentTime.Value.Ticks;

}void PlayButton_Click(object sender, RoutedEventArgs e){

_clock.Controller.Begin();}

}

Listing 16.8 Beispiele\K16\06 MediaPlayer_Kontrollieren\MainWindow.xaml.cs


970

Audio und Video16

16.4 Audio und Video mit MediaElement (XAML)

Die im vorherigen Abschnitt gezeigte Klasse MediaPlayer lässt sich zwar in XAML instan-tiieren, aber zumindest zum Abspielen wird immer C#-Code benötigt. Die WPF besitztmit der Klasse MediaElement (erbt direkt von FrameworkElement) im Namespace Sys-tem.Windows.Controls eine Klasse, die sich aus XAML zum Abspielen von Audio- und Vi-deo-Dateien verwenden lässt. Die Beziehung zwischen MediaPlayer und MediaElement istähnlich der zwischen SoundPlayer und SoundPlayerAction.

Tatsächlich kapselt die Klasse MediaElement einen MediaPlayer, eine MediaTimeline undeine MediaClock. Sie finden auf der Klasse MediaElement ähnliche Methoden und Proper-ties wie auf der Klasse MediaPlayer. Dennoch ist MediaElement natürlich ein Framework-Element, das sich im Gegensatz zum MediaPlayer selbst darstellen kann und direkt ver-wenden lässt.

Wie auch ein MediaPlayer-Objekt kann eine Instanz der Klasse MediaElement Dateien inzwei unterschiedlichen Modi abspielen:

� Unabhängiger Modus – Sie setzen die Source-Property eines MediaElements auf eineAudio-/Video-Datei, und das MediaElement spielt die Datei ab. Mit den Methoden desMediaElements (Play, Pause, Stop etc.) steuern Sie den Ablauf.

� Clock-Modus – Sie setzen auf einer MediaTimeline die Storyboard.TargetName-Pro-perty auf den Namen des MediaElements. Die Quelldatei befindet sich in der Source-Property der MediaTimeline. Das MediaElement befindet sich jetzt im Clock-Modusund lässt sich in XAML mit TriggerActions, wie BeginStoryboard oder PauseStory-board, steuern.

Abbildung 16.4 Mit MediaClock und MediaTimeline gesteuerte Audio-Datei

Tipp

Die Klasse MediaPlayer besitzt weitere nützliche Events. MediaEnded wird beispielsweisegefeuert, wenn das Ende der Datei erreicht wurde. Das Event MediaFailed wird ausgelöst,wenn beim Laden der Audio-/Video-Datei ein Fehler aufgetreten ist.


971

Audio und Video mit MediaElement (XAML) 16.4

16.4.1 Einfaches Abspielen

Zum einfachen Abspielen eines Videos oder einer Audio-Datei genügt es, die Source-Pro-perty eines MediaElements zu setzen. Je nachdem, in welchem Container sich das Media-Element befindet, sollten Sie im Falle einer Video-Datei noch die Properties Width undHeight setzen (siehe Listing 16.9).

<MediaElement Width="300" Height="200"Source="thomasOnBoard.wmv"/>

Listing 16.9 Beispiele\K16\07_MediaElement_Video.xaml

Die Klasse MediaElement besitzt wie die in Kapitel 5, »Controls«, beschriebene KlasseViewbox die Properties Stretch und StretchDirection. Mit diesen Properties lässt sichbeschreiben, wie ein Video im MediaElement ausgedehnt wird. Die Stretch-Property istvom Typ der Aufzählung Stretch, die die Werte None, Fill, Uniform (Default) und Uni-formToFill definiert. Abbildung 16.5 zeigt die verschiedenen Werte für ein in einem Me-diaElement abgespieltes Video.

Achtung

Da die Klasse MediaElement intern die Klasse MediaPlayer verwendet, gelten die Einschrän-kungen für MediaPlayer auch für MediaElement:

� Windows Media Player muss in Version >=10 installiert sein.

� Mit dem Buildvorgang Resource eingebettete Dateien lassen sich nicht abspielen.

Weitere Vorsicht ist geboten, wenn MediaPlayer oder MediaElement unter 64-Bit-Win-dows-Versionen ablaufen. Vorgänger von Windows Vista, die unter 64 Bit laufen, enthaltennur eine 32-Bit-Version des Windows Media Players. Daher werden Sie auf diesen Systemendie Funktionalitäten der MediaPlayer- und MediaElement-Klasse nicht verwenden können,wenn Ihre Anwendung als 64-Bit-Anwendung läuft. Sie müssen beim Kompilieren sicherstel-len, dass Ihre Anwendung im 32-Bit-Modus läuft.

Hinweis

Obwohl das MediaElement natürlich ein FrameworkElement ist, wird es auch häufig genutzt,um lediglich Audio abzuspielen. Da dann sowieso nichts sichtbar ist, werden die PropertiesWidth und Height üblicherweise auf 0 oder die Visibility auf Collapsed gesetzt.

Tipp

Obwohl das MediaElement zum Darstellen von Audio-/Video-Dateien gedacht ist, kann esauch einfache Bilder anzeigen. Weisen Sie einfach der Source-Property ein Bild zu:

<MediaElement Width="300" Height="200" Source="thomas.png"/>


972

Audio und Video16

16.4.2 Steuerung mit Methoden (unabhängiger Modus)

Die Klasse MediaElement besitzt Methoden wie Play, Pause, Stop etc. Um diese Metho-den zu verwenden, setzen Sie die LoadedBehavior-Property auf Manual. Die LoadedBe-havior-Property ist vom Typ der Aufzählung MediaState, die die Werte Play (Default),Pause, Close, Stop und Manual enthält. Nur wenn LoadedBehavior auf Manual ist, lässtsich die in der Source-Property angegebene Audio-/Video-Datei mit den Methoden Play,Pause usw. steuern.

Der unabhängige Modus benötigt zum Steuern einer Audio-/Video-Datei allerdings C#, dadort die entsprechenden Methoden aufgerufen werden müssen. Im Clock-Modus lässtsich eine Audio-/Video-Datei auch rein in XAML steuern.

16.4.3 Steuerung mit MediaTimeline (Clock-Modus)

Um in XAML eine Audio-/Video-Datei zu steuern, wird eine MediaTimeline-Instanz er-stellt. In XAML muss eine Timeline in ein Storyboard gepackt werden, das wiederum miteinem BeginStoryboard-Element, beispielsweise der Actions-Property eines EventTrig-gers, zugewiesen wird. Mit den aus Kapitel 15, »Animationen«, bekannten Klassen Stop-Storyboard, PauseStoryboard usw. lässt sich die abgespielte Datei steuern.

Abbildung 16.5 Stretch-Property für Videos im MediaElement


973


Listing 16.10 zeigt, wie es geht. Beachten Sie, dass auf der MediaTimeline das MediaEle-ment mit dem Namen media als Ziel angegeben wird. Auf dem MediaElement selbst istdie Source-Property nicht gesetzt, stattdessen kennt die MediaTimeline die zu verwen-dende Datei. Das MediaElement läuft jetzt nicht mehr im unabhängigen Modus, sondernim Clock-Modus. Es lässt sich somit komplett über die MediaTimeline steuern. Die fürverschiedene Buttons definierten EventTrigger starten, stoppen oder pausieren das Video(siehe Abbildung 16.6).

<DockPanel Width="300" Height="250" LastChildFill="False"><DockPanel.Triggers><EventTrigger RoutedEvent="Button.Click"

SourceName="btnPlay"><BeginStoryboard Name="beginStoryboard"><Storyboard>

<MediaTimeline Source="thomasOnBoard.wmv"Storyboard.TargetName="media"/>

</Storyboard></BeginStoryboard>

</EventTrigger><EventTrigger RoutedEvent="Button.Click" SourceName="btnStop">

<StopStoryboard BeginStoryboardName="beginStoryboard"/></EventTrigger><EventTrigger RoutedEvent="Button.Click" SourceName="btnPause">

<PauseStoryboard BeginStoryboardName="beginStoryboard"/></EventTrigger><EventTrigger RoutedEvent="Button.Click" SourceName="btnResume">

<ResumeStoryboard BeginStoryboardName="beginStoryboard"/></EventTrigger><EventTrigger RoutedEvent="Button.Click" SourceName="btn2x">

<SetStoryboardSpeedRatio SpeedRatio="2"BeginStoryboardName="beginStoryboard"/>

</EventTrigger><EventTrigger RoutedEvent="Button.Click" SourceName="btn1x">

<SetStoryboardSpeedRatio SpeedRatio="1"BeginStoryboardName="beginStoryboard"/>

</EventTrigger></DockPanel.Triggers><MediaElement x:Name="media" Width="300" Height="220"Stretch="Fill" DockPanel.Dock="Top"/>

<Button Margin="5" x:Name="btnPlay" Content="Start"/><Button Margin="5" x:Name="btnStop" Content="Stop"/><Button Margin="5" x:Name="btnPause" Content="Pause"/><Button Margin="5" x:Name="btnResume" Content="Weiter"/><Button Margin="5" x:Name="btn1x" Content="1x"/>


974

Audio und Video16

<Button Margin="5" x:Name="btn2x" Content="2x"/></DockPanel>

Listing 16.10 Beispiele\K16\08_MediaElement_Kontrollieren.xaml

In einigen Anwendungen, die hauptsächlich für Produktmarketing oder Werbezweckeverwendet werden, läuft im Hintergrund eine Audio-Datei ab. Oftmals ist es notwendig,diese in einer Schleife zu wiederholen. Auf dem MediaElement finden Sie keine Property,die das erledigt. Aber mit den Properties der Timeline-Klasse (Teil von Kapitel 15, »Ani-mationen«), von der ja auch MediaTimeline erbt, kommen Sie schnell ans Ziel. Setzen Sieeinfach die aus Timeline geerbte RepeatBehavior-Property auf Ihrer MediaTimeline aufden Wert Forever, um beispielsweise wie in Listing 16.11 eine Audio-Datei zu loopen.

<Grid><Grid.Triggers><EventTrigger RoutedEvent="Grid.Loaded">

<BeginStoryboard><Storyboard TargetName="media"><MediaTimeline Source="Gitarrensound.wav"RepeatBehavior="Forever"/>


</EventTrigger></Grid.Triggers><MediaElement x:Name="media"/><TextBlock Text="Whiskey in the Jar-Riff bis die Nachbarn klingeln"/>

</Grid>

Listing 16.11 Beispiele\K16\09_MediaElement_AudioLoop.xaml

Abbildung 16.6 Steuern eines MediaElements mit MediaTimeline


975


16.4.4 Storyboard mit MediaTimeline und AnimationTimeline

Eine MediaTimeline lässt sich einfach in ein Storyboard integrieren und mit anderen Ani-mationen kombinieren. Allerdings kann es zu einem Problem kommen, das sich Slipping(Verrutschen) nennt. Eine Audio-/Video-Datei benötigt meist etwas Zeit, bis sie geladenist, wodurch die MediaTimeline erst nach einem bestimmten Offset startet. Andere Ani-mationen im Storyboard beginnen während dieser Zeit schon zu laufen.

Storyboard erbt von der Klasse ParallelTimeline die Property SlipBehavior vom Typder Aufzählung SlipBehavior. Diese Property definiert, was passiert, wenn der Start ei-ner Timeline durch Laden und Puffern verzögert wird, was bei einer MediaTimeline meistder Fall ist. Die Aufzählung SlipBehavior definiert lediglich zwei Werte:

Tipp

Mit MediaElement und MediaTimelines lässt sich der zu Beginn dieses Kapitels mit Sound-PlayerAction erstellte Button (siehe Listing 16.1) ebenfalls erstellen. Weisen Sie statt derSoundPlayerAction den Triggern einfach ein BeginStoryboard-Element zu, das ein Story-board und eine MediaTimeline mit der abzuspielenden Datei enthält; auf den MediaTimeli-nes muss die Storyboard.TargetName-Property auf ein MediaElement zeigen:

<MediaElement x:Name="media"/><Button Width="100" Height="23" Content="Sound-Button"> <Button.Triggers> <EventTrigger RoutedEvent="Button.MouseEnter"> <BeginStoryboard> <Storyboard> <MediaTimeline Source="GAkkord.wav" Storyboard.TargetName="media"/> </Storyboard> </BeginStoryboard> </EventTrigger> <EventTrigger RoutedEvent="Button.Click"> <BeginStoryboard> <Storyboard> <MediaTimeline Source="Gitarrensound.wav" Storyboard.TargetName="media"/> </Storyboard> </BeginStoryboard> </EventTrigger> </Button.Triggers></Button>

Sie finden obigen Code in den Beispielen auf der Buch-DVD in der Datei Beispiele\K16\10SoundInLooseXAMLTeil2.xaml.


976

Audio und Video16

� Grow (Default) – Animationen im Storyboard starten sofort. Die MediaTimeline beginntaber erst, sobald das Video geladen wurde.

� Slip – Animationen im Storyboard werden erst gestartet, wenn die Audio-/Video-Da-tei der MediaTimeline geladen und gepuffert wurde.

Listing 16.12 zeigt einen klassischen Fall. Ein Grid enthält lediglich ein MediaElementund einen EventTrigger. Beachten Sie, dass die Opacity-Property des MediaElements 0ist, wodurch es transparent ist. Beim Laden des Grids soll das MediaElement ein Video ab-spielen und langsam eingeblendet werden.

Im EventTrigger des Grids befindet sich ein Storyboard mit einer DoubleAnimation undeiner MediaTimeline. Die DoubleAnimation animiert die Opacity-Property des MediaEle-ments in drei Sekunden auf den Wert 1. Die MediaTimeline versorgt das MediaElementmit einem kleinen Video aus dem Web, damit der Ladevorgang etwas dauert.

<Grid Width="200" Height="150" Background="Black"><Grid.Triggers><EventTrigger RoutedEvent="Grid.Loaded">

<BeginStoryboard><Storyboard SlipBehavior="Slip"><DoubleAnimation Duration="0:0:3"Storyboard.TargetProperty="Opacity"Storyboard.TargetName="media" To="1"/>

<MediaTimeline Storyboard.TargetName="media"Source="http://www.thomasclaudiushuber.com/thomasOnBoard.wmv"/>


</EventTrigger></Grid.Triggers><MediaElement x:Name="media" Stretch="Fill" Opacity="0"/>

</Grid>

Listing 16.12 Beispiele\K16\11_MediaUndAnimationen.xaml

Auf dem Storyboard in Listing 16.12 wurde die SlipBehavior-Property auf den WertSlip gesetzt. Dadurch startet die DoubleAnimation erst dann, wenn das Video geladenwurde und die MediaTimeline ebenfalls zum Start bereit ist. Folglich wird das MediaEle-ment durch die DoubleAnimation erst eingeblendet, wenn auch tatsächlich das Videoläuft (siehe Abbildung 16.7).

Setzen Sie in Listing 16.12 die SlipBehavior-Property überhaupt nicht oder auf den WertGrow (Default), wird die DoubleAnimation sofort zu Beginn des Storyboards starten. Folg-lich startet der eigentliche Einblendeffekt bzw. die Animation der Opacity-Property desMediaElements, bevor das Video im MediaElement sichtbar ist. Im schlimmsten Fall dau-


977


ert das Laden der Datei thomasOnBoard.wmv länger als drei Sekunden. Nach drei Sekun-den ist die DoubleAnimation, die die Opacity-Property animiert, beim Wert 1 angelangtund beendet. Beginnt die MediaTimeline dann erst zu laufen, wird das Video überhauptnicht animiert eingeblendet, sondern erscheint plötzlich (siehe Abbildung 16.8).

16.4.5 Snapshots von Videos

In diesem letzten Abschnitt dieses Kapitels möchte ich Ihnen noch die Möglichkeit zeigen,wie Sie einfache Snapshots von Ihren Videos machen und diese direkt als .jpeg-Datei ab-speichern. Dazu kommen Klassen ins Spiel, die in Kapitel 13, »2D-Grafik«, bereits er-wähnt wurden.

Listing 16.13 zeigt das StackPanel, das sich direkt im Window-Element befindet. Es ent-hält lediglich ein MediaElement und einen Button. Das MediaElement enthält einenEventTrigger für das Loaded-Event. Dort wird ein Video mit einer MediaTimeline gestar-tet. Beachten Sie, dass auf der MediaTimeline die Storyboard.TargetName-Property nichtgesetzt wurde. Es wird somit implizit das Element verwendet, zu dem der Trigger gehört.

Abbildung 16.7 SlipBehavior Slip. DoubleAnimation wartet, bis das Video geladen ist.

Abbildung 16.8 SlipBehavior Grow (Default). DoubleAnimation wartet nicht, bis das Video geladen ist.


978

Audio und Video16

Es wurde in Listing 16.13 eine MediaTimeline und nicht nur ein MediaElement verwen-det, um auf der MediaTimeline die RepeatBehavior-Property auf den Wert Forever zusetzen, wodurch das Video ständig wiederholt wird.

<Window ...><StackPanel><MediaElement x:Name="media" Width="300" Height="200"

Stretch="Fill"><MediaElement.Triggers><EventTrigger RoutedEvent="MediaElement.Loaded"><BeginStoryboard><Storyboard><MediaTimeline Source="thomasOnBoard.wmv"RepeatBehavior="Forever"/>


</EventTrigger></MediaElement.Triggers>

</MediaElement><Button Click="Button_Click" Content="Snapshot"Width="75" Margin="5"/>

</StackPanel></Window>

Listing 16.13 Beispiele\K16\12 SnapShots\MainWindow.xaml

Im Event Handler Button_Click wird in der Codebehind-Datei (siehe Listing 16.14) eine.jpeg-Datei gespeichert. Dazu wird ein Objekt der Klasse RenderTargetBitmap erstellt. DerKonstruktor nimmt Größe, dpi (Dots per Inch) und Pixelformat entgegen. In der KlassePixelFormats finden Sie statische Properties, die verschiedene Pixelformate repräsentie-ren. Auf dem RenderTargetBitmap-Objekt wird die Render-Methode aufgerufen, die alsParameter ein Visual-Objekt verlangt. Hier wird das MediaElement übergeben. Damit hatdas RenderTargetBitmap bereits das Bild gespeichert.

Im nächsten Schritt wird ein JpegBitmapEncoder erstellt, ein BitmapFrame hinzugefügtund mittels FileStream gespeichert. Zu guter Letzt wird der statischen Start-Methodeder Process-Klasse (Namespace: System.Diagnostics) die Datei übergeben, wodurchsich das Default-Programm für .jpeg-Dateien öffnet und das Bild anzeigt. Unter WindowsVista ist dieses Programm standardmäßig die Windows Photo Gallery (siehe Abbildung16.9).

void Button_Click(object sender, RoutedEventArgs e){Size dpi = new Size(96,96);RenderTargetBitmap bmp = new RenderTargetBitmap(300, 200,


979


dpi.Width, dpi.Height, PixelFormats.Pbgra32);bmp.Render(media);JpegBitmapEncoder encoder = new JpegBitmapEncoder();encoder.Frames.Add(BitmapFrame.Create(bmp));string filename = Guid.NewGuid().ToString()+".jpg";FileStream fs = new FileStream(filename,FileMode.Create);encoder.Save(fs);fs.Close();Process.Start(filename);

}

Listing 16.14 Beispiele\K16\12 SnapShots\MainWindow.xaml.cs

Sie finden in den Beispielen auf der Buch-DVD im Ordner Beispiele\K16\13 SnapShotsAls-Gif ein ähnliches Projekt wie das hier vorgestellte, das Ihnen mit einem DispatcherTimerund der GifBitmapEncoder-Klasse aus einem Video eine animierte .gif-Datei erstellt. DasPrinzip ist dabei das gleiche wie in Listing 16.14. Es werden allerdings bei einem GIF zurFrames-Property des GifBitmapEncoders mehrere BitmapFrame-Instanzen hinzugefügt.

Abbildung 16.9 Der Snapshot wird sofort geöffnet.

Tipp

Da die Render-Methode der Klasse RenderTargetBitmap Objekte vom Typ Visual entge-gennimmt, lässt sich die in Listing 16.14 gezeigte Methode verwenden, um beliebige Ele-mente der WPF als Bild abzuspeichern. Dazu müssen die Elemente allerdings einen Layout-prozess durchlaufen haben. Erzeugen Sie Elemente im Code, rufen Sie Measure, Arrange undUpdateLayout auf, bevor Sie das Element an die Render-Methode übergeben.


980

Audio und Video16

16.5 Zusammenfassung

Für die Audio- und Video-Unterstützung haben Sie in diesem Kapitel vier wichtige Klas-sen kennengelernt:

� SoundPlayer und SoundPlayerAction zum Abspielen von .wav-Dateien in C# und inXAML

� MediaPlayer und MediaElement zum Abspielen von Audio-/Video-Dateien in C# undin XAML

Die Klasse MediaPlayer kann Audio-/Video-Dateien in zwei Modi abspielen:

� Unabhängiger Modus – Sie öffnen eine Datei mit der Open-Methode und steuern dieWiedergabe mit Methoden wie Play, Stop, Pause usw.

� Clock-Modus – Sie erzeugen eine MediaTimeline und setzen die Source-Property derMediaTimeline auf die abzuspielende Datei. Mit der CreatClock-Methode erstellen Sieein MediaClock-Objekt zu Ihrer MediaTimeline. Das MediaClock-Objekt weisen Sie derClock-Property des MediaPlayers zu, der jetzt die Datei im Clock-Modus abspielt. DieWiedergabe steuern Sie über den ClockController, der in der Controller-Propertyder MediaClock steckt.

Die Klasse MediaElement kapselt MediaPlayer, auch sie kann Audio-/Video-Dateien inzwei Modi abspielen:

� Unabhängiger Modus – Sie setzen die Source-Property des MediaElements auf die ab-zuspielende Datei. Wollen Sie die Wiedergabe mit den Methoden und Properties desMediaElements steuern, setzen Sie zusätzlich die LoadedBehavior-Property auf Man-ual.

� Clock-Modus – Sie erstellen eine MediaTimeline und definieren auf der MediaTime-line mit der Storyboard.TargetName-Property ein MediaElement als Ziel. Das Media-Element läuft jetzt im Clock-Modus. Die Steuerung kann in XAML über Controlla-bleStoryboards wie PauseStoryboard oder StopStoryboard erfolgen.

Während SoundPlayer und SoundPlayerAction die Playsound-API von Windowsverwenden, bauen MediaPlayer und MediaElement auf dem Windows Media Player auf.

Haben Sie kein MediaElement, sondern einen MediaPlayer, lassen sich auch von diesemSnapshots machen, indem Sie ein DrawingVisual erstellen, mit RenderOpen das Drawing-Context-Objekt holen und auf diesem die DrawVideo-Methode mit dem MediaPlayer aufru-fen. Übergeben Sie anschließend das DrawingVisual-Objekt an die Render-Methode einerRenderTargetBitmap-Instanz.


981

Zusammenfassung 16.5

Daher gibt es für MediaPlayer/MediaElement ein paar Voraussetzungen und Einschrän-kungen:

� Windows Media Player mit Versionsnummer >=10 wird benötigt.

� Mit dem Buildvorgang Resource in die Assembly eingebettete Dateien lassen sich nichtabspielen.

� Auf Windows-Versionen, die älter als Vista sind, ist der Windows Media Player nur in32 Bit vorhanden. Ihre WPF-Anwendung muss dort unter 32 Bit laufen, damit Media-Player und MediaElement funktionieren.

Trotz dieser Einschränkungen ist die Audio-/Video-Unterstützung bei der WPF im Gegensatzzu älteren Programmiermodellen natürlich enorm. Ein Video lässt sich mit in ein Video-Drawing verpacken und mit einem DrawingBrush überallhin zeichnen. Ein MediaElementlässt sich transformieren, clippen usw.

Im nächsten Kapitel erstellen wir eigene Controls. Dabei erzeugen wir ein Custom Controlnamens VideoPlayer. Es verwendet das hier bereits beschriebene MediaElement zum Ab-spielen von Videos.


1211

Index

.fx-Datei 831

.NET Framework.NET 3.0 39.NET 3.5 40.NET 4.0 41

.ps-Datei 831

.resources-Datei 543

.resx-Datei 543

.xbap-Datei 1160/clr-Compiler-Flag 11932D-Grafik

Brush 808Drawing 797DrawingContext 803Ebenen von (Level) 773Geometry 786im Vergleich mit 3D 851Shape 774Spiegeleffekt 820

2D-Transformation 327Layout- vs. RenderTransform

329MatrixTransform 336RotateTransform 331ScaleTransform 333SkewTransform 334TransformGroup 337TranslateTransform 335

3D-Grafik 8502D-Elemente in 3D 885Benutzerinteraktion 882Drei-Finger-Regel 854GeometryModel3D aufbauen

861Kamera 855Koordinatensystem 853Kugel erstellen 889Landschaft generieren 887Licht 867Material 873Model3D 860Normale 878Projektion 855Rechte-Daumen-Regel 864Textur 874

3D-Grafik (Forts.)Überblick 73Vergleich mit 2D 851Viewport3D 854Visual3D 859Vorder-/Rückseite 864

3D-Transformation 870

A

AccelerationRatio 900, 914Accepted (FilterEventArgs) 697AcceptsReturn 288AcceptsTab 287AccessKey 248, 250

AutomationElement 1106AccessText 250Action<T> 122ActionCommand 510Actions (EventTrigger) 592, 923Activate (Window) 125Activated

Application 112Window 137

Active (ClockState) 917ActiveX, Interop mit 1179ActiveXHost 1181ActualHeight 128, 311ActualWidth 128, 311Add[Eventname]Handler 441,

474AddAutomationEventHandler

1110AddAutomationPropertyChanged-

EventHandler 1111AddBackEntry 1146AddFixedDocument 1084AddFixedDocumentSequence

1084AddFixedPage 1084AddHandler 432AddHook (HwndSource) 1202AddLogicalChild 200AddNew 690

AddOwnerDependencyProperty 404RoutedEvent 442

Address 755AddToRecentCategory 1136AddValueChanged 412AddVisualChild 219ADO.NET 699Adobe

Flash 901, 955Illustrator 143

AdornedElement 1029AdornedElementPlaceholder 710Adorner 1028AdornerDecorator 1032AdornerLayer 1029AffectsArrange 393AffectsMeasure 393AffectsParentArrange 394AffectsParentMeasure 394AffectsRender 394Airspace 1166Alias (Namespace) 150Aliased (TextRenderingMode)

1055AllowDrop 750AllowedEffects (DragEventArgs)

751AllowsTransparency 127, 360Alpha-Kanal (Color) 810AlternatingRowBackground 744AlternationCount 262, 285AlternationIndex 285AmbientColor 874AmbientLight 867Amplitude 946AnalysisStatus 292Analyze (InkAnalyzer) 292AncestorLevel 667Ancestors (TreeScope) 1107AncestorType 667AnchoredBlock 1064AndCondition 1108Angle

AxisAngleRotation 871


Index

1212

Angle (Forts.)DoubleAnimationUsingPath

942RotateTransform 331

AngleX (SkewTransform) 334AngleY (SkewTransform) 334Animatable 903Animated (TextHintingMode)

1055Animation 895

Arten 897Basis-Animation 904beschleunigen 914Clock 900Dauer 908entfernen 916Füllverhalten 915Gesamtlänge 912Geschwindigkeit 910Grundlagen 896IAnimatable 903in C# 904in FriendStorage 921in XAML 922Interpolation 898Keyframe-Animation 933Klassen 898kontrollieren in C# 917kontrollieren in XAML 931Low-Level 954Pfad-Animation 942rückwärts 911Startzeit 910Timeline 900verzögern 914Voraussetzungen für 896wiederholen 911

AnimationClock 902, 917Animationssystem 897AnimationTimeline 902Anker 1142Annotation 1069AnnotationService 497, 1069AnnotationStore 1071Anti-Aliasing 53, 1055ApartmentState 107App.g.cs 101App.xaml 99App.xaml.cs 100

Application 110, 524Definition 103Events 111MainWindow 115Ressource laden 551ShutdownMode 116

ApplicationCommands 497ApplicationGestures 291ApplicationPath 1131ApplyAnimationClock 903, 917ApplyPropertyValue (RichText-

Box) 1069ApplyTemplate 632, 990ArcSegment 792Args (StartupEventArgs) 112ArgumentException 400Arguments (JumpItem) 1132Arrange 311ArrangeCore 313ArrangeOverride 204, 312ArrayList 201Arrow (Cursors) 462Ascending (ListSortDirection)

693Assembly 542AssemblyAssociatedContentFile-

Attribute 545AssemblyName (ThemeDictio-

nary) 1010Asterisk (SystemSounds) 963ATL 1164Attached

Event 440Property 413

Attached Propertybekannte Vertreter 421eigenes Panel 417implementieren 414

Attached-Event-Syntax 269, 440AttachedPropertyBrowsableFor-

ChildrenAttribute 417Attached-Property-Syntax 159AttributeTargets 167Attribut-Syntax 155Audio 959

in Schleife abspielen 974mit MediaElement 970mit MediaPlayer 964mit SoundPlayer 961

Audio (Forts.)mit SoundPlayerAction 960

Ausgabekoordinate 832Austauschformat 143Authorisierungsschlüssel 407Auto

DataGridLengthUnitType 730GridResizeDirection 355GridUnitType 350

autoClose 565AutoFlush (AnnotationStore)

1072AutoGenerateColumns 724AutoGeneratingColumn 724Automatic (Duration) 909Automation (Klasse) 1110AutomationElement 1105AutomationElementInformation

1106AutomationEvent 1110AutomationId (Automation-

Element) 1106AutomationPattern 1109AutomationPeer 1014, 1117AutomationProperty 602, 1108AutoReverse 900, 911AutoToolTipPlacement 298AutoToolTipPrecision 298availableSize 312AxImp.exe 1179Axis (AxisAngleRotation) 871AxisAngleRotation 871AxWindowsMediaPlayer 1179

B

Backbuffer 1207BackEase 946Background 236Backmaterial (GeometryModel3D)

861BadImageFormatException 1181Balance (MediaPlayer) 964BAML (Binary Application

Markup Language) 98BamlLocalizer 561Band 265BandIndex 265BasedOn (Style) 579


Index

1213

BasedOnAlignment (GridResize-Behavior) 355

BaselineBaselineAlignment 1043TextDecorationLocation 1043

BaselineAligment 1043BasePattern 1109BaseValueSource 412Basis-Animation

beschleunigen 914Dauer 908Gesamtlänge 912Geschwindigkeit 910in C# 904in XAML 922kontrollieren in C# 917kontrollieren in XAML 931mit From und By 907nur mit From 907nur mit To 906rückwärts 911Startzeit 910Übersicht Start-/Zielwert 908verzögern 914wiederholen 911

Beep (SystemSounds) 963Begin

ClockController 918Storyboard 930

BeginAnimation 903BeginInvoke 121BeginStoryboard 923BeginStoryboardName 931BeginTime (Timeline) 900, 910Benannter Style 573Benutzerdefiniertes Steuerelement

985Benutzereingabe validieren 702Beschleunigungsfunktionen 944Betrag (3D) 857BetterTextLabel 398BevelBitmapEffect 828Bézierkurven 792BezierSegment 792Binäre Ressource 541

bei der WPF 545im .NET Framework 542in C# 550in XAML 548

Binary Application Markup Language 98

Binding 172, 646Condition 598DataTrigger 590

BindingBase 669BindingExpression 655BindingGroup 711BindingGroupName 647, 713BindingListCollectionView 688BindingMode 652BindingOperations 645BindingSource (Windows Forms)

1171BindingStatus 657BindsDirectlyToSource 647, 675BindsTwoWayByDefault 394,

652Bitmap

Bitmap-Operation 844BitmapSource 843

BitmapCache 822BitmapCacheBrush 826BitmapEffect 828BitmapEffectInput 828BitmapFrame 844BitmapImage 303, 844Bitmap-Operation

BitmapDecoder 844BitmapEncoder 844GifBitmapEncoder 979in FriendStorage 845JpegBitmapEncoder 845, 978unterstützte Formate 844

BitmapSource 843BitmapFrame 844BitmapImage 844CachedBitmap 844ColorConvertedBitmap 844CroppedBitmap 844FormatConvertedBitmap 844InteropBitmap 844RenderTargetBitmap 844, 978TransformedBitmap 844WritableBitmap 844

BlackoutDates 294BlackWhiteEffect 837Blickrichtung 857Block 1058

BlockCollection 1060BlockUIContainer 1061BlurBitmapEffect 828BlurEffect 828BlurRadius (DropShadowEffect)

831Bogenmaß 890Bold 196, 1040bool? 134BoolToBrushConverter 665Border 300

Fenster 126BorderBrush 237, 300BorderThickness 237, 300Both (StretchDirection) 302Bottom

Canvas 341VerticalAlignment 323

BounceEase 946Bounces 946Bounciness 946Box

KernelType 830TextMarkerStyle 1061

BreakColumnBefore 1060BreakPageBefore 1060BringIntoView 203BrowseBack 1145BrowseForward 1145BrowserInteropHelper 1160Brush 808

DrawingBrush 800, 816ImageBrush 816Klassenhierarchie 808LinearGradientBrush 811RadialGradientBrush 813SolidColorBrush 809TileBrush 815VisualBrush 816

BrushConverter 664, 809Brushes 810BrushMappingMode 812Bubble (RoutingStrategy) 429Bubbling Event 429BuildGeometry 1048Buildvorgang 102

Application Definition 103Inhalt 103, 545kompilieren 102


Index

1214

Buildvorgang (Forts.)Page 103Resource 103, 545

BuildWindowCore 1182Button 241ButtonBase 241ButtonChrome 302By 905

C

C#Automation-Property 602Lambda-Expression 693Type-Converter verwenden 166typeof 172Versionen 42

Cached Composition 821CachedBitmap 844CacheMode 822Calendar 293CalendarButtonStyle 295CalendarDayButtonStyle 295CalendarItemStyle 295CalendarSelectionMode 293CalenderMode 295Callback (Dependency Property)

396Camera (Viewport3D) 854Cancel (CancelEventArgs) 137CancelEdit 689, 719CancelEventArgs 137CancelNew 690CanContentScroll 255CanCustomFilter 692CanExecute 471CanExecuteChanged 471CanExecuteRoutedEventArgs 481CanFilter 691CanFreeze 86CanGoBack 1145CanGoForward 1145CanGroup 691CanMinimize 128CanRedo 287CanResize 128CanResizeWithGrip 128CanSort 691CanUndo 287

CanUserAddRows 739CanUserDeleteRows 739CanUserReorderColumns 740CanUserResizeColumns 740CanUserResizeRows 740CanUserSortColumns 740Canvas 341Capitals 1047Capture 461CaptureMouse 241, 459Capturing, Maus 459CaretBrush 287CaretPosition 289CDATA (Character Data) 108Cell (DataGridSelectionUnit) 737CellEditingTemplate 731CellOrHeader (DataGridSelection-

Unit) 737Cells (TableRow) 1061CellSpacing (Table) 1062CellStyle 744CellTemplate 284, 731Center

HorizontalAlignment 323RadialGradientBrush 813VerticalAlignment 323

CenterOwner 131CenterScreen 131CenterX

RotateTransform 331ScaleTransform 333SkewTransform 334

CenterYRotateTransform 331ScaleTransform 333SkewTransform 334

ChangeVisualState 1015ChangeWindowVisualState 1110CharacterEllipsis (TextTrimming)

1052CheckAccess 81, 121CheckBox 247Checked

MenuItem 274ToggleButton 245

ChildBlockUIContainer 1061Decorator 300InlineUIContainer 1045

Child (Forts.)WindowsFormsHost 1167

ChildrenModelVisual3D 860Panel 340TimelineGroup 924TransformGroup 337TreeScope 1107Viewport3D 854

Chrome 126chromeless 126Circle (TextMarkerStyle) 1061CircleEase 946ClassClickHandler 444ClassName (Automation-

Element) 1106Clear 270ClearAllBindings 657ClearBinding 657ClearHighlightsCommand 1070ClearInvalid 711ClearType (TextRenderingMode)

1055ClearType-Algorithmus 1055ClearTypeHint 1056ClearValue 410Click (ButtonBase) 241Clicked (MenuItem) 274ClickMode 241ClickOnce 1120Client

Area 126Profile 1121

Client-Side-Provider 1117Clip (UIElement) 797, 1048Clipboard 481Clipping (3D) 856Clipping-System 54ClipToBounds 322Clock 902, 917ClockController 918, 968Clock-Modus 967ClockState 917Clone (Freezable) 85, 811Close

DrawingContext 804MediaPlayer 964Window 125XpsDocumentWriter 1075


Index

1215

Closed (Window) 137Closing (Window) 137CLR (Common Language Runtime)

40CLR-Compiler-Flag 1193CLR-Event-Wrapper 432, 438CLR-Namespace 146cm 167Codebehind-Datei 95Code-Snippet

propa 416propdp 392

CoerceValue 411CoerceValueCallback 396Collapsed

Expander 259TreeViewItem 268Visibility 325

Collection 682ändern 697CollectionView 686DefaultView 690filtern 691gruppieren 691in XAML 178sortieren 691

CollectionChanged 697CollectionContainer 698CollectionView 686

Arten 688CollectionViewGroup 694CollectionViewSource 690, 695COLOR 833Color 809ColorConvertedBitmap 844Colors (Klasse) 810Column (Grid) 349ColumnDefinition 349ColumnHeaderStyle 745Columns

DataGrid 726GridResizeDirection 355GridView 282Table 1061UniformGrid 361

ColumnSpanGrid 349TableCell 1062

ColumnWidth (FlowDocument) 1060

COM 106, 1179Combine (Geometry) 791CombinedGeometry 789ComboBox 278ComboBoxItem 278Command 470

auf Klassenebene 999eigenen implementieren 472in Custom Control unterstützen

998in FriendStorage 486Überblick 69und der Fokus 503verwenden 473von Logik entkoppeln 474vordefinierter 497

CommandBinding 481CommandBindingCollection 482CommandBindings 482CommandConverter 499CommandManager 480CommandParameter 471CommandTarget 471Commit 1084CommitEdit 689, 712, 718CommitedValue (ValidationStep)

718CommitNew 690Common Language Runtime 40CommonDialog 1102CommonStates 622Community Technology Preview

43Completed 902ComponentCommands 497ComponentResourceKey 172,

1004Compose 916CompositeCollection 698Composition 54

Tree 54Composition-System 54CompositionTarget 954Condition

Trigger 598UI Automation 1107

ConstantAttenuation 868

ConstructorParameters 675ContainerUIElement3D 883Contains (ResourceDictionary)

534Content

Buildvorgang 545ContentControl 238ModelVisual3D 860NavigationService 1143Window 126

ContentControl 238ContentElement 85, 1039ContentPresenter 248, 612Content-Property (XAML) 157ContentPropertyAttribute 158ContentRendered 137, 227ContentStringFormat 240ContentTemplate 240, 605ContentType (ResourceStream-

Info) 551ContentViewWalker 1107ContextMenu 275ContextMenuService 275Control 84

Content Control 238Custom Control erstellen 984Datum-Controls 293eigenes 983für Text 286HeaderedContentControls 258HeaderedItemsControl 264Items Control 261Klasse 236Panel 338Pattern 1109Range Control 297User Control erstellen 1021

ControllableStoryboardAction 931

Controller 918ControlTemplate 217, 240, 606

Default 609für Button 612für ProgressBar 617mit DerTemplateSpion betrachten

620PARTxxx-Elemente 616Verbindung Control und 612


Index

1216

ControlType (Automation-Element) 1106

ControlViewWalker 1107Convert 664ConvertBack 664Converter (Binding) 647, 664ConverterCulture (Binding) 647ConverterParameter 647ConverterProposedValue (Valida-

tionStep) 718ConvertFrom 160Core-Level 84, 393CornerRadius 300Count (RepeatBehavior) 911CreateClock 917, 967CreateHighlightCommand 1070CreateInkStickyNoteCommand

1069CreateInstanceCore 86, 952CreateTextStickyNoteCommand

1069CreateVisualsCollator 1087CreateWindowEx (Win32) 1182CreateXpsDocumentWriter

PrintQueue 1085XpsDocument 1075

CroppedBitmap 844Cross (Cursors) 462CSV (LocBaml) 560CTP (Community Technology

Preview) 43CubicEase 946CultureInfo 164, 554CurrencyManager 1172Current

Application 111AutomationElement 1106

CurrentAndNext (GridResize-Behavior) 356

CurrentDispatcher 118CurrentItem 686CurrentItemChanged 687CurrentItemChanging 687CurrentPosition 690CurrentProgress (Clock) 902, 917CurrentState (Clock) 917CurrentTime (Clock) 902, 917CurrentTimeInvalidated 968Cursor 462

Custom Control 90, 984Alternativen zu 1028Commands unterstützen 998Dependency Property erstellen

993mit Visual States 1014Routed Event implementieren

997Struktur 985Template-Part definieren 990unterstützte Windows-Themes

1008weitere Themes unterstützen

1007CustomCategory 1131CustomContentState 1146CustomControl1.cs 985CustomFilter 692CustomSort 695CustomVisualStateManager 631Cycle (KeyboardNavigation) 265

D

D3DImage 1204D3DResourceType 1208DashStyle 785Data

DataSourceProvider 675DragEventArgs 751

Data Binding 644Aktualisieren der Source 654an .NET Property 661an ADO.NET 699an Collections 682an DataSourceProvider 675an Dependency Property 660an logische Ressourcen 663an mehrere Quellen 669an relative Quellen 667an unterschiedliche Typen 664an XLinq 681an XML 676Datenquellen 660Debugging 658entfernen 657Fallback-Mechanismus 682in C# 645in XAML 644

Data Binding (Forts.)Path-Property 650Richtung 652und DataContext 649Validieren von Daten 703

DataContext 649DataErrorValidationRule 707DataGrid 720

Auswahl 737Column-Breite 730Columns erstellen 728Columns generieren 723Column-Typen 725Daten validieren 740gruppieren 735Row-Details 733

DataGridAutoGenerating-ColumnEventArgs 724

DataGridBoundColumn 727DataGridCellInfo 738DataGridCellsPanel 362DataGridCheckBoxColumn 726DataGridComboBoxColumn 726DataGridGridLinesVisibility 744DataGridHeadersVisibility 737DataGridHyperlinkColum 726DataGridLength 730DataGridLengthUnitType 730DataGridRowDetailsVisibility-

Mode 733DataGridSelectionMode 737DataGridSelectionUnit 737DataGridTemplateColumn 727,

731DataGridTextColumn 726DataGridView (Windows Forms)

1167DataGridViewTextBoxColumn

1170DataItem 656DataSet 699DataSourceProvider 674

ObjectDataProvider 674XmlDataProvider 676

DataTemplate 602, 731, 745DataTemplateKey 605DataTemplateSelector 745DataTrigger 590DataType (DataTemplate) 602


Index

1217

DataView 699Daten 643

ADO.NET 699Collection 682Data Binding 644DataSourceProvider 674Datenquellen 660Drag & Drop 750filtern 691gruppieren 691hinzufügen 697in FriendStorage 754löschen 697sortieren 691Synchronization in Interop-

Szenarien 1169validieren 702visualisieren 745

DatePicker 296DatePickerFormat 296DatePickerTextBox 296DayOfWeek 294Deactivated

Application 112Window 138

DebuggerNonUserCodeAttribute 93

DecelerationRatio 901, 914Decimal (TextMarkerStyle) 1061Decorator 300, 1032Default

BindingMode 652UpdateSourceTrigger 654

Default-ControlTemplate 609Default-Konstruktor 144DefaultMetadata 398Default-Namespace 150DefaultPrintQueue 1087Default-Property (XAML) 157DefaultStyleKey 578, 986Default-Transition 628DefaultUpdateSourceTrigger 394,

654DefaultView 690DefinitionBase 357, 1039DegreeToRadian 890Delay (RepeatButton) 243DeleteAnnotationsCommand

1070

DeleteFriend (FriendStorage) 492DeleteStickyNotesCommand

1070Dependency Property 385

Änderungen überwachen 412Callback 396Data Binding 402Default-Metadaten 398existierendes verwenden 404für Custom Control erstellen 993implementieren 390Metadaten 392Nutzen 389Quelle ermitteln 412read-only 406, 995Überblick 62validieren 399Vererbung über Logical Tree 405Vorrangsrecht 409vs. klassische .NET-Property 390

DependencyObject 82, 386DependencyProperty 386DependencyPropertyDescriptor

412DependencyPropertyHelper 412DependencyPropertyKey 407DependUpon (MSBuild) 105Deployment 1120Descendant (XLinq) 681Descendants (TreeScope) 1107Descending (ListSortDirection)

693Deserialisieren 183Designer/Entwickler 141DesignerProperties 1027Designmodus 1027DesiredFrameRate 902Desktop Window Manager

(DWM) 55DestroyWindow (Win32) 1182DestroyWindowCore 1182DevExpress 50Device (InputEventArgs) 453DiagonalPanel 313Dialog

in Interop mit Win32 1196in Interop mit Windows Forms

1176modaler 132

Dialog (Forts.)nicht modaler 136TaskDialog von Windows Vista

1196DialogResult 132DiffuseMaterial 862, 873Direct (RoutingStrategy) 430Direct3D, Interop mit 1204Direction

DirectionalLight 867DropShadowEffect 831SortDescription 693

DirectionalLight 867DirectX 47

SDK 834Disable (AnnotationService) 1071Disc (TextMarkerStyle) 1061DiscreteDoubleKeyFrame 934,

938Diskrete Keyframe-Animation

938DismissWhenClicked 1124Dispatcher

Klasse 80, 118Property 81

DispatcherObject 80Dispatcher-Klasse 120Multithreading 121

DispatcherOperation 123DispatcherOperationCallback

123DispatcherPriority 122DispatcherTimer 957DispatcherUnhandledException

112DisplayDate 294DisplayDateChanged 294DisplayDateEnd 294DisplayDateStart 294DisplayMemberBinding 282DisplayMemberPath 262DisplayMode 295DisplayModeChanged 295DisplaySettingsChanged 1203DisplayString (KeyGesture) 488Distanzformel (3D) 858Dock

DockPanel 346Windows Forms 1175


Index

1218

DockPanel 346Document 1067

WebBrowser 257DocumentPage 1075DocumentPaginator 1075DocumentReference 1079DocumentViewer 1078DocumentViewerBase 1078DoDragDrop 750Dokument

Annotation 1069Block-Arten 1060Fixed-Dokument 1073Flow-Dokument 1058in FriendStorage 1090Inline-Element 1038Text 1038XPS-Dokument 1073

DoNothing (Binding) 665DoubleAnimationUsingKey-

Frames 934, 939DoubleAnimationUsingPath 942DoubleKeyFrameCollection 934DownOnly (StretchDirection)

302DragDrop 750DragDropEffects 751DragEnter 751DragEventsArgs 751DragIncrement (GridSplitter) 356DragLeave 751DragMove 125, 361DragOver 751DrawDrawing (DrawingContext)

804DrawEllipse (DrawingContext)

804DrawGeometry (Drawing-

Context) 804DrawGlyphRun (Drawing-

Context) 804DrawImage (DrawingContext)

804Drawing 797

Darstellung 798DrawingGroup 798GeometryDrawing 798GlyphRunDrawing 803ImageDrawing 800

Drawing (Forts.)Klasse 797Klassenhierarchie 797VideoDrawing 800

DrawingBrush 800, 816Video auf Text 800

DrawingContext 803, 1029, 1048vs. Graphics aus Windows Forms

804DrawingGroup 798DrawingImage 539, 798DrawingVisual 805DrawLine (DrawingContext) 804DrawRectangle (Drawing-

Context) 804, 1029DrawRoundedRectangle

(DrawingContext) 804DrawText (DrawingContext) 804,

1048DrawVideo (DrawingContext)

804, 966Drehrichtung (3D) 864Dreieck 862Drei-Finger-Regel 854Drop 751DropShadowEffect 828Drucken 1085

aus FriendStorage 1096Eigenschaften mit PrintTicket

1088mit PrintDialog 1088mit PrintQueue 1087

Duration 901, 908DurationConverter 909DynamicResource 172, 532

E

Ease 944EaseInCore 952Easing Function 944

eigene erstellen 952Grundlagen 944in Basis-Animationen 948in Keyframe-Animationen 950Klassenhierarchie 945

EasingDoubleKeyFrame 934, 950EasingFunctionBase 945EasingFunctionTester 948

EasingMode 945EditingCommands 497EditingMode 291Effect (Klasse) 828Effects (DragEventArgs) 751Effekt 828

Blur 828DropShadow 828eigener mit Pixelshader 831Klassenhierarchie 828

Effekt-Klassen 828Eigenes Control

User Control 1021Einheit

geräteunabhängige 83in Pixel umrechnen 83logische 83

ElasticEase 946Element

öffnendes 144schließendes 144Tree 66TreeScope 1107verschachteltes 144XLinq 681

ElementEditingStyle 727ElementHost 1175ElementName (Binding) 647ElementStyle 727Ellipse 776EllipseGeometry 787EMF (Enhanced Meta File) 1074EmissiveMaterial 873Empty-Element-Syntax 145Enable (AnnotationService) 1071EnableClearType 823Enabled (ClearTypeHint) 1056EnableModelessKeyboard-

Interop 1178EnableVisualStyles (Windows

Forms) 1172EndBatchWrite 1087EndPoint (LinearGradientBrush)

811Enhanced Meta File (EMF) 1074EnterActions (TriggerBase) 584,

923Entity-Referenz (XAML) 178


Index

1219

EntryPointNotFoundException 1197

Environment 676, 1200Error 1128error X3501 836ErrorContent (ValidationResult)

706Errors (Validation) 709ErrorTemplate (Validation) 709,

761Erweiterbar (XAML) 151Escape-Sequenz 169EvenOdd (FillRule) 779Event

EventSetter 582Handler 95, 433System 434

event 439Event-Attribut 144EventManager 429, 437Event-Route 431EventSetter 582EventTrigger 592Event-Wrapper 438ExceptionValidationRule 704Exclamation (SystemSounds) 963Execute 471Exit (Application) 112ExitActions (TriggerBase) 584,

923ExitAllFrames 119ExpandCollapsePattern 1110ExpandDirection 260Expanded

Expander 259TreeViewItem 268

Expander 258Explicit (UpdateSourceTrigger)

654ExponentialEase 946Expression 389, 534

Blend 50Design 274Suite 43, 50

Expression BlendDesigner/Entwickler 143vs. Visual Studio 50

Expression SuiteExpression Blend 50, 143

Expression Suite (Forts.)Expression Design 50, 274

Extended (SelectionMode) 281Extensible Application Markup

Language � XAMLExtentHeight 1086ExtentWidth 1086ExternalAssembly (Resource-

DictionaryLocation) 1009ExtraData 1151

F

Fade (PopupAnimation) 304Fallback-Mechanismus

Data Binding 682Ressourcen 555

FallbackValue (Binding) 647FalseCondition 1107FamilyTypeface 1045Farbraum

scRGB 810sRGB 810

FarPlaneDistance (Projection-Camera) 856

FieldOfView 859Figure 1065FigureHorizontalAnchor 1065FigureVerticalAnchor 1066FileDialog 1102Fill

Shape 775Stretch 301

FillBehavior 901, 915Filling (ClockState) 917FillRule 779

EvenOdd 779NonZero 779

Filter 692FileDialog 1103

FilterEventArgs 697finalSize 312FindAll (AutomationElement)

1106FindAncestor (RelativeSource-

Mode) 668FindCommonVisualAncestor 224FindFirst (AutomationElement)

1106

FindLogicalNode 203, 213FindName 185, 208, 990FindResource 522FirstColumn (UniformGrid) 361FirstDayOfWeek 294FitToHeightCommand 1079FitToMaxPagesAcrossCommand

1079FitToWidthCommand 1079Fixed (TextHintingMode) 1055FixedDocument 1040FixedDocumentSequence 1079Fixed-Dokument 1073FixedPage 1080Flags 396Flash 901, 955Flexibles Inhaltsmodell 45, 238Flip3D 55FlipX (TileMode) 817FlipXY (TileMode) 817FlipY (TileMode) 817float4 832Floater 1066FlowDirection 344FlowDocument 1040, 1058FlowDocumentPageViewer 1067FlowDocumentReader 1067FlowDocumentReaderViewing-

Mode 1067FlowDocumentScrollViewer

1067Flow-Dokument 1058

als XPS speichern 1074Controls zum Betrachten von

1067erstellen 1058

Focus 456Focusable 238FocusedElement

AutomationElement 1105FocusManager 457Keyboard 456, 476

FocusManager 456, 504FocusNavigationDirection 1192FocusStates 622FocusVisualElement 625FocusVisualStyle 573Fokus und Commands 503


Index

1220

Fokus-Artenlogischer Fokus 456Tastatur-Fokus 456

Fokus-Style 573FolderBrowserDialog 136Font 1045FontCapitals 1047FontFamily 237, 1042, 1045FontFamilyConverter 1046Fonts (Klasse) 1046FontSize 237, 1042FontSizeProperty 391, 421FontStretch 237, 1042FontStretches 1042FontStyle 237, 1042FontStyles 237, 1042FontWeight 237, 1042FontWeights 237, 1042ForceCursor 462Foreground 237, 1042Forever

Duration 909RepeatBehavior 912, 974

FormatConvertedBitmap 844FormattedText 402, 1048Fortschrittsbalken 299FragmentNavigation 1147Frame 1137

Klasse 256FrameReported 464Framework 153FrameworkContentElement 85,

199, 1039FrameworkContentElement-

AutomationPeer 1118FrameworkElement 83, 199

Subklasse erstellen 199FrameworkElementAutomation-

Peer 1013, 1118FrameworkElementFactory 631FrameworkId (Automation-

Element) 1106Framework-Level 84, 393FrameworkPropertyMetadata

393FrameworkPropertyMetadata-

Options 396FrameworkTemplate 599Freezable 85, 811

Freeze (Freezable) 85, 811Freunde-Explorer 368

DataGridRows 637Friend 755FriendCollection 755FriendCommands 487FriendStorage 44

Animation 378, 921Anzeige des NewFriendDialogs

133Beschreibung 44Bitmap-Operation 845Command 486DataGridRows im Freunde-

Explorer 637Daten im NewFriendDialog 765Daten in 754Dokumente 1090DrawingImage 798Drucken 1096Hilfe-Dialog 1090Icons 274Interoperabilität 1169Layout von 367Logical/Visual Tree des Info-

Dialogs 192logische Ressource 539OpenFileDialog 1104PrintableFriend-Control 1023SaveFileDialog 1103Spiegeleffekt der Überschrift 820Splashscreen 563Styles, Trigger & Templates 632XPS-Export 1091

FriendViewerals XBAP 1157Beschreibung 1136

From 905From/To/By-Animationen 897FromArgb 810FromHandle (Automation-

Element) 1105FromHwnd (HwndSource) 1201FromLocalProvider 1105FromMilliSeconds 909FromName 412FromOpenTypeWeight 1046FromPoint (AutomationElement)

1105

FromRgb 810FromSeconds 909FromThread 120FrontBuffer 1207FullRow (DataGridSelectionUnit)

737fxc.exe 834FX-Compiler 834

G

Gadget-Fenster 360Garbage Collector 1148Gaussian (KernelType) 830GDI (Graphics Device Interface)

47GDI+ 48gdi32.dll 48GeneralTransform 327generate (LocBaml) 561GeneratedDuration 626Generic.xaml 986Generics 151Geometry 786

Anwendungsbereiche 786Clipping 797CombinedGeometry 789EllipseGeometry 787Geometry (Typ) 786GeometryGroup 789GeometryModel3D 861Klassenhierarchie 786LineGeometry 788PathGeometry 791RectangleGeometry 787StreamGeometry 794

Geometry3D 852, 862GeometryCollection 789GeometryCombineMode 790GeometryDrawing 798GeometryGroup 789GeometryModel3D 852, 861Geräteunabhängige Einheit 83Gesture

InkCanvas 291InputBinding 500

GetAdornerLayer 1029GetAdorners 1031GetApartmentState 107


Index

1221

GetAutomationId 1118GetBinding 657GetBindingExpression 655, 657GetChild 223GetChildren 203GetChildrenCount 223GetClassName 1118GetCommandLineArgs 100GetContentStream 551GetConverter 166GetCurrentPattern 1109GetCurrentThemeName 1202GetCurrentValue 902, 917GetData 751GetDataPresent 751GetDefaultPrintQueue 1087GetDefaultView 690GetDisplayStringForCulture 494GetEntryAssembly 549GetEnumerator 201GetErrors (FriendStorage) 767GetFirstChild (TreeWalker) 1107GetFixedDocumentSequence

1078GetFocusScope 457GetIsInDesignMode 1027GetLastChild (TreeWalker) 1107GetLineLength 288GetLineText 288GetLogicalDrives 676GetManifestResourceNames 542GetManifestResourceStream 542GetMetadata 399Get-Methode 414GetMultiBindingExpression 674GetName 1118GetNavigationService 1142GetNextSibling (TreeWalker)

1107GetParent

LogicalTreeHelper 203TreeWalker 1107VisualTreeHelper 223

GetPattern 1117GetPosition 462GetPreviousSibling (TreeWalker)

1107GetPrintQueues 1087

GetPriorityBindingExpression 674

GetRecognizedString 292GetRemoteStream 551GetResourceSet 544GetResourceStream 551, 962GetRoutedEvents 435GetRoutedEventsForOwner 435GetStream 544, 554GetSupportedPatterns 1110GetTemplateChild 617, 991GetTouchPoint 463GetValue 386GetValueOrDefault 134GetValueSource 412GetVisualChild 219GetVisualChildrenCount 219GetWindow 125GifBitmapEncoder 979GiveFeedback 750Globalisierung 553GLSL 831GoBack 1144GoForward 1144GotFocus 457GotKeyboardFocus 457GoToElementState 1020GoToState 1014GoToStateCore 631GradientBrush 811

Koordinatensystem 811LinearGradientBrush 811Offset von GradientStops 813RadialGradientBrush 813

GradientOrigin (RadialGradient-Brush) 814

Gradients (GradientBrush) 811GradientStop 811GradientStopCollection 811Graphics Device Interface 47GrayScale (TextRenderingMode)

1055Grid 348GridLength 350GridLinesVisibility 744GridResizeBehavior 355GridResizeDirection 355GridSplitter 353GridUnitType 350

GridView 282GridViewColumn 282GridViewColumnHeader 282GridViewRowPresenter 616GroupDescriptions 693GroupName 246Groups (ICollectionView) 694GroupStyle 262, 694Grow (SlipBehavior) 976

H

HandCursors 462, 580SystemSounds 963

HandleHWND, IntPtr 1165HwndHost 1167IWin32Window 1177WindowInteropHelper 1177

HandledDispatcherUnhandledException-

EventArgs 112RoutedEventArgs 434, 451

handledEventsToo (AddHandler) 452

HandledEventsToo (EventSetter) 582

Handler (EventSetter) 582HandleRef 1183HandlerType (RoutedEvent) 429HandOffBehavior 916Hardwarebeschleunigung 58

Ebenen 58RenderCapability 58, 892

HasAudio 964HasContent

ContentControl 238FrameworkTemplate 600

HasCount (RepeatBehavior) 911HasDropShadow (ToolTip) 252HasDuration (RepeatBehavior)

911HasError

BindingExpression 657Validation 709

HasHeader 258, 264Hashtable 180HasItems 262


Index

1222

HasKeyboardFocus (Automation-Element) 1106

HasTimeSpan 909HasValue (Nullable<T>) 134HasVideo 964Header

HeaderedContentControl 258HeaderedItemsControl 264

HeaderedContentControl 258HeaderedItemsControl 264HeaderStringFormat 258HeadersVisibility 737HeaderTemplate 258, 264HeaderTemplateSelector 264Height 128, 319

RowDefinition 350Hidden (Visibility) 325Hide (Window) 125HierarchicalDataTemplate 747Hierarchie

Logical Tree 195Visual Tree 215

High Level Shading Language (HLSL) 831

High-Word (hWord) 58, 892HitTest 882HitTestResult 808HitTestResultCallback 808HLSL 831HoldEnd (FillBehavior) 915Horizontal (Orientation) 343HorizontalAlignment 323HorizontalAnchor (Figure) 1065HorizontalContentAlignment

237, 324HorizontalGridLinesBrush 744HorizontalOffset (ToolTip)

251–252HorizontalScrollBarVisibility 253HostInBrowser (MSBuild) 1160HostScript 1161Hover (ClickMode) 241HTML 143HWND 49, 1165HwndHost 1167, 1182HwndParentWindow 1192HwndSource 1192HwndSourceHook 1202HwndSourceParameters 1192

hWord 58, 892Hybrid-Anwendungen 1164Hyperlink 1040, 1141

I

IAddChild 1083IAnimatable 903ICollectionView 686ICommand 470ICommandSource 471, 1124Icon (Window) 127Icon mit Transparenzfarbe 274IconResourcePath 1131ICustomTypeDescriptor 699Id (AutomationPattern) 1109IDataErrorInfo 707IDataObject 751Identity (Transform) 327IDictionary 180, 387IDirect3DSurface9 1208IDocumentPaginatorSource 1075IEasingFunction 944IEditableCollectionView 689IEditableObject 740IEnumerable 201IEnumerator 201IExpandCollapseProvider 1117IFrame 1161IInputElement 433, 478IInvokeProvider 1117IKeyboardInputSink 1190IKeyframe 934IList 179Image (Klasse) 302ImageableArea 1086ImageBrush 816ImageDrawing 800ImageSource 303, 843ImageSourceConverter 550Immediate-Mode-System 773Impliziter Style 574IMultiValueConverter 671in 167INameScope 209, 617Indeterminate 1128Info-Dialog

Logical Tree 195Visual Tree 216

Infragistics 50Inhalt (Buildvorgang) 103, 545Inhaltsmodell

flexibles 45, 238Inherits 394InitializeComponent 97InitialShowDelay (ToolTip-

Service) 253InkAnalyzer 292InkCanvas 290InkCanvasEditingMode 291Inline 1040

Bold 1040Hyperlink 1040Italic 1040Underline 1040

Inline-Code 108InlineCollection 198Inlines 198

Figure 1065Floater 1066InlineUIContainer 1045LineBreak 1047Run 1040

Inline-Style 572InlineUIContainer 1045Inline-XML 676InnerConeAngle 867INotifyCollectionChanged 697INotifyPropertyChanged 661InputBinding 500

KeyBinding 500MouseBinding 501

InputEventArgs 453InputGestures 478, 488

KeyGesture 488MouseGesture 488

InputGestureText (MenuItem) 273

InteropBitmap 844Interoperabilität

ActiveX in WPF 1179Airspace 1166Daten-Synchronisation 1169Grenzen und Einschränkungen

1165in FriendStorage 1169mögliche Szenarien 1164Win32 in WPF 1182


Index

1223

Interoperabilität (Forts.)Win32-Dialoge aus WPF 1196Win32-Nachrichten in WPF

1201Windows Forms in WPF 1167Windows Forms-Dialoge aus

WPF 1176WPF in Win32 1192WPF in Windows Forms 1175WPF-Dialoge aus Win32 1200WPF-Dialoge aus Windows

Forms 1178Interpolation 898Interval

DispatcherTimer 957RepeatButton 243

IntPtr 49, 1165InvalidateArrange 318InvalidateMeasure 318InvalidateProperty 411InvalidateRequerySuggested 480,

495, 1001Inverse (Transform) 327Invoke 121InvokeEvent 1110InvokePattern 1109InvokeScript 257InvokeShutdown 119IRawElementProviderSimple

1105IsAbsolute

DataGridLength 730GridLength 351

IsActive 127IsAdditive 912IsAncestorOf 224IsAnimationProhibited 393, 903IsAsync (Binding) 647, 673IsAsynchronous 677IsAttached 412IsAuto


IsBackgroundVisible 1124IsBrowserHosted 1160IsCancel 241IsCheckable (MenuItem) 272IsChecked

MenuItem 272

IsChecked (Forts.)ToggleButton 244

IsColumnWidthFlexible 1060IsCumulative 912IsCurrentAfterLast 690IsDataBindingAllowed 394IsDataBound 657IsDefault 241IsDefaulted 241IsDefaultView 691IsDeferredScrollingEnabled 255IsDescendantOf 224IsDocumentEnabled 289, 1069IsEditable (ComboBox) 278IsEnabled 238

AutomationElement 1106IsExpanded

Expander 258TreeViewItem 268

IsFocusScope 456, 504IsFrontBufferAvailable 1207IsFrozen 85IsGrouping 262IsHitTestVisible 454IsHyphenated 1060IsHyphenationEnabled 1058IsIndeterminate 299IsItemsHost 341, 615IsKeyboardFocusable (Automa-

tionElement) 1106IsKeyboardFocused 456IsKeyDown 455IsLocked 267IsMainMenu 272IsManipulationEnabled 464IsMouseCaptured 461IsMouseOver 458IsNotDataBindable 394IsOpen

ContextMenu 275Popup 304ToolTip 252

IsPixelShaderVersionSupported 836

IsPixelShaderVersionSupported-InSoftware 836

IsReadOnlyComboBox 278

IsReadOnly (Forts.)DependencyPropertyDescriptor

412IsRepeat (KeyEventArgs) 455IsSealed

FrameworkTemplate 600Style 580–581

IsSelected 637Selector 279TreeViewItem 268

IsSelectionRangeEnabled 299IsSharedSizeScope 349, 356, 372IsSizeToCells (DataGridLength)

730IsSizeToHeader (DataGrid-

Length) 730IsSnapToTickEnabled 298IsStar


IsSynchronizedWithCurrentItem 277, 687

IsTabStop 237IsTextSearchCaseSensitive 262IsTextSearchEnabled 262IsThreeState 244IsTodayHighlighted 294IsUndoEnabled 287IsValid (ValidationResult) 706IsValidValue 400IsVirtualizing 363IsVisible 325IsVisualHostMaterial 886Italic 196, 1040ItemBindingGroup 262, 744ItemCollection 688ItemContainerStyle 262ItemContainerStyleSelector 573ItemHeight (WrapPanel) 345Items (ItemsControl) 262ItemsContainerStyle 572ItemsControl 261ItemsPanel 262, 601ItemsPanelTemplate 601ItemsPresenter 615ItemsSource 263ItemStringFormat 263, 293ItemTemplate 262–263, 602ItemTemplateSelector 747


Index

1224

ItemWidth (WrapPanel) 345ITextProvider 1117IToggleProvider 1117ITransformProvider 1117IValueConverter 664IValueProvider 1117IWin32Window 1177IWindowProvider 1117IXpsFixedDocumentSequence-

Writer 1084IXpsFixedDocumentWriter 1084IXpsFixedPageWriter 1084

J

JournalEntry 1143JournalOwnership 1145JpegBitmapEncoder 845, 978JumpItem 1131JumpItemsRejected 1136JumpItemsRemovedByUser 1136JumpList 1123, 1131JumpPath 1132JumpTask 1131

K

KameraOrthographicCamera 855PerspectiveCamera 855

KeepAlive 1146kernel32.dll 48KernelType 830Key 455

KeyGesture 488KeyBinding 500Keyboard 476

Klasse 455KeyboardDelay 243KeyboardNavigation 265, 458KeyboardNavigationMode 265KeyboardSpeed 243KeyDown 455KeyEventArgs 455Keyframe-Animation 933

diskrete 938lineare 934Spline 937

KeyFrames 934

KeyGesture 488KeyTime 934KeyTimeConverter 936KeyUp 455Kommandozeilen-Parameter 100Kontextmenü 275Koordinatensystem (3D) 853Korkenzieher-Regel 865Kugel (3D) 889

L

Label 248Lambda-Expression 40, 693Language 297, 1058Language Integrated Query (LINQ)

40to XML (XLinq) 681

LargeChange 297LastChildFill 346Layout

2D-Transformation 327Layoutfunktionalität von Elemen-

ten 319Panel 338von FriendStorage 367

Layoutprozess 310Layout-Rounding 325LayoutTransform 329, 365Lazy Load 268Left

Canvas 341HorizontalAlignment 323Window 127

LeftButton 459LengthConverter 167Licht (3D) 867Light 867Line (Shape) 776LinearAttenuation 868LinearDoubleKeyFrame 934Lineare Keyframe-Animation 934LinearGradientBrush 811

verschiedene Start-/Endpunkte 812

LineBreak 1047LineGeometry 788LineHeight 1060LineJoin 785

LineSegment 791LineStackingStrategy 1060LINQ

Language Integrated Query 40to XML (XLinq) 681

List 1061ListBox 280ListBoxHost (Interop) 1183ListBoxItem 280ListChanged 699ListCollectionView 688ListSortDirection 693ListView 281Load

SoundPlayer 962XamlReader 183

LoadAsync (SoundPlayer) 962LoadCompleted

NavigationService 1147SoundPlayer 962

LoadComponent 97, 551Loaded 137LoadedBehavior 972LocalPrintServer 1087Location (TextDecoration) 1043LocationChanged 138LocBaml 554Lock 1208Logical Tree 195LogicalChildren 199, 201Logische

Einheit 83Ressource 519

Logische Ressourcedynamische 532Element verwenden als 527in FriendStorage 539statische 530Suche nach 523

Logischer Fokus 456und Commands 503

LogischesOder (Trigger) 597Und (Trigger) 597

Lokalisierung 553LookAtPoint (3D) 858LookDirection (Projection-

Camera) 856Lookless 606


Index

1225

Loose XAML 91vs. XBAP 1161

LostFocusUIElement 457UpdateSourceTrigger 654

LostKeyboardFocus 457LowerLatin (TextMarkerStyle)

1061LowerRoman (TextMarkerStyle)

1061Low-Level-Animation 954

M

Main 101MainAssembly 557MainWindow (Application) 115MainWindow.baml 98, 547MainWindow.g.cs 96MainWindow.xaml 95MainWindow.xaml.cs 96Manifest-Resource-Stream 542ManipulationCompleted 464ManipulationCompletedEven-

tArgs 464ManipulationDelta 464ManipulationDeltaEventArgs 464ManipulationModes 464ManipulationOrigin 464ManipulationStarted 464ManipulationStartedEventArgs

464ManipulationStarting 464ManipulationStartingEventArgs

464Manual (MediaState) 972MappingMode 812Margin 320MarkerStyle 1061MarkInvalid 711Markup-Extension 168

als Objektelement 170der WPF 172Escape-Sequenz 169in XAML und C# verwenden 168von XAML 171

MarkupExtension 168Master-Detail 682, 699

Material (GeometryModel3D) 861

MaterialGroup 873Matrix 336Matrix3D 859MatrixCamera 859MatrixTransform 336, 465MatrixTransform3D 871Maus-Capturing 459MaxHeight 128, 319Maximum (RangeBase) 297MaxLength 287MaxWidth 128, 319Measure 310MeasureCore 313MeasureOverride 204, 312Media Integration Layer 52

Composition Tree 54MilCore 53

MediaClock 967MediaCommands 497MediaElement 970MediaEnded 970MediaFailed 970MediaOpened 968MediaPlayer 963MediaSizeHeight 1086MediaSizeWidth 1086MediaState 972MediaTimeline 967Menu 272MenuBase 272MenuFontSize 525MenuFontWeight 525MenuItem 272MergedDictionaries 537MeshGeometry3D 862Metadata 412Metadaten 392

Default 398überschreiben 398

Methode, anonyme 119MethodName 676MethodParameters 676MFC 1164, 1193

Microsoft Foundation Classes 48Microsoft

Active Accessability 1105Foundation Classes � MFC

Microsoft (Forts.)Intermediate Language 99Software Installer (MSI) 1120

Microsoft.Win32 1102MiddleButton 459MilCore 53MinHeight 128, 319Miniaturbild 1122Minimum (RangeBase) 297MinimumWindowHeight 129MinimumWindowWidth 129MinWidth 128, 319MirrorAdorner 1030Mnemonic 248Mode

Binding 647RelativeSource 667

Model3D 852, 860GeometryModel3D 861Light 867

Model3DGroup 861, 868ModelUIElement3D 883Model-View-Controller-Pattern

506Model-View-ViewModel-Pattern

505ModelVisual3D 859ModifierKey 455ModifierKeys 488Modifiers 455

KeyGesture 488MouseGesture 489

ModusClock- 967unabhängiger 967

Mouse 458MouseAction (MouseGesture)

489MouseButtonEventArgs 449Mouse-Capturing 459MouseDoubleClick 238MouseDown 450MouseEnter 458MouseGesture 488MouseLeave 458MouseUp 458MouseWheel 458MoveCurrentTo 765MoveCurrentToNext 690


Index

1226

MoveFocus 458MSBuild 102, 558MSIL (Microsoft Intermediate

Language) 99MultiBinding 670MultiBindingExpression 674MultiDataTrigger 597Multiple (SelectionMode) 281MultiSelect (DataGridView) 1170MultiSelector 720Multi-threaded Apartment (MTA)

107Multithreading 121MultiToBrushConverter 670Multitouch 463MultiTrigger 597MVC-Pattern 506MVVM-Pattern 505

N

Nachrichtenschleife 80, 118Name

AutomationElement 1106FrameworkElement 173JournalEntry 1143RoutedCommand 479RoutedEvent 429Timeline 901

NameScope 209, 617Namespace 145Namespace-Alias 150Namespace-Mapping 146NaN (Not a Number) 128NativeCalls 1182NaturalDuration (MediaPlayer)

964Navigate 1142Navigated 1147Navigating 1147NavigatingCancelEventArgs 1147NavigationCommands 497, 1145NavigationEventArgs 1151NavigationFailed 1147NavigationProgress 1147Navigationsanwendung 1136

Container 1137Daten übergeben 1149Events 1146

Navigationsanwendung (Forts.)Möglichkeiten zur Navigation

1141Navigation zu einer Seite 1141PageFunctions 1153

NavigationService 1142NavigationStopped 1147NavigationUIVisibility 1138NavigationUri 1141NavigationWindow 1137NearPlaneDistance (Projection-

Camera) 856NeutralResourcesLanguage-

Attribute 557New (ApplicationCommands)

498NewFriend (FriendStorage) 492NewFriendDialog, Daten im 765NewImage (FriendStorage) 492None

ResourceDictionaryLocation 1009

TextTrimming 1052NonZero (FillRule) 779NoResize 128Normal 1128Normalisierte Zeit 945Normalize (Vector3D) 857normalizedTime 945Normals (MeshGeometry3D) 878No-Routing-Strategie 430NotACommand 502NotCondition 1108NotifyCollectionChanged-

EventArgs 697NotifyOnSourceUpdated 647,

711NotifyOnTargetUpdated 647,

711NotifyOnValidationError 647,

709NoWrap (TextWrapping) 1051Nullable<T> 134NullExtension 169

O

Object Window Library 48ObjectDataProvider 674ObjectInstance 674Objektelement 144Objekt-Initialisierer 40ObservableCollection<T> 697OnApplyTemplate 618, 990OnCreateAutomationPeer 1013,

1118OneTime (BindingMode) 652OneWay (BindingMode) 652OneWayToSource (Binding-

Mode) 652OnExecute 482OnExecutedThunk 482OnExplicitShutdown 116OnLastWindowClose 116OnMainWindowClose 116OnRender 82, 204, 310, 788

wann überschreiben 1028OnReturn (PageFunction<T>)

1155OnSourceChanged (VideoPlayer)

993OnStartup 112OnStateChanged (VideoPlayer)

995OnTemplateChanged 991Opacity 815OpacityMask 815, 818, 1030OPC (Open Packaging Conven-

tions) 1083Open

ApplicationCommands 498MediaPlayer 964Packaging Conventions (OPC)

1083OpenFile 1104OpenFileDialog 1102OpenGL 1164

Shading Language 831OpenType 1045OrCondition 1108Orientation

StackPanel 343ToolBar 266


Index

1227

OriginalSource (RoutedEventArgs) 434, 449

OriginHeight 1086OriginWidth 1086OrthographicCamera 855Oscillations 946OSVersion 1200out (LocBaml) 559OuterConeAngle 867OutputColor (PrintTicket) 1088OverflowMode (ToolBar) 266Overlay 1127Overline (TextDecoration-

Location) 1043OverrideMetadata 398OverridesInheritanceBehavior

394OWL (Object Window Library)

48OwnedWindows (Window) 132Owner

Window 132WindowInteropHelper 1178

OwnerTypeRoutedCommand 479RoutedEvent 429

OwnsJournal (JournalOwner-ship) 1145

P

packageURI 548Pack-URI-Syntax 548Padding 237, 321Page 1136

Buildvorgang 103FlowDocumentReaderViewing-

Mode 1067PageContent 1079PageFunction<T> 1153PageFunctionBase 1153PageHeight (FlowDocument)

1060PageOrientation (PrintTicket)

1088PageRange (PrintDialog) 1089Pages (FixedDocument) 1079PageWidth (FlowDocument)

1060

Panel 313, 338Alignment-Übersicht 363Canvas 341DataGridCellsPanel 362DockPanel 346eigenes mit Attached Properties

417Grid 348Klasse 339StackPanel 343TabPanel 363ToolBarOverflowPanel 363ToolBarPanel 345UniformGrid 361VirtualizingStackPanel 362wenn Platz nicht ausreicht 365WrapPanel 345ZIndex 342

PanningMode 255Paragraph 1058, 1061ParallelTimeline 924Parent 200

TreeScope 1107ParentBinding 656parse (LocBaml) 559Parse (TimeSpan) 909ParseAndLoadXAML 228PART_Indicator 616PART_MediaElement 991PART_Track 616partial 96PARTxxx-Element 616PasswordBox 289PasswordChanged 289PasswordChar 289Path 785

Binding 647PathAnimationSource 942PathFigure 791PathGeometry 791, 942

Figures 791Segments 791

Path-Markup-Syntax 795PathSegment 791

ArcSegment 792BezierSegment 792LineSegment 791PolyBezierSegment 793PolyLineSegment 791

PathSegment (Forts.)QuadraticBezierSegment 793

Pattern 1109PatternInterface 1117Pause

ClockController 918MediaElement 972MediaPlayer 964

Paused 1128PauseStoryboard 931PDF (Portable Document Format)

1074Pen 782PenLineCap 783Performance (RenderBias) 830Performanz 330PerspectiveCamera 855Pfad-Animation 942Phi 889PInvoke 1182Pixel

DataGridLengthUnitType 730GridUnitType 350

PixelFormats 978Pixelshader 831

erstellen 831kompilieren 834

PixelShaderConstantCallback 840Placement (ToolTip) 251Play

MediaElement 972MediaPlayer 964SoundPlayer 962

Player (VideoDrawing) 965PlayLooping (SoundPlayer) 962PlaySound-API 963PlaySync (SoundPlayer) 962Point 330, 852Point3D 852Point3DCollection 862PointAnimationUsingPath 942PointCollectionConverter 778PointConverter 330PointLight 867PointLightBase 868PolyBezierSegment 793Polygon (Shape) 778Polyline (Shape) 778PolyLineSegment 791


Index

1228

Pop (DrawingContext) 804Popup 303PopupAnimation 304Position (ProjectionCamera) 856PositionCount (TextEffect) 1049Positions (MeshGeometry3D)

862PositionStart (TextEffect) 1049PositionX (HwndSource) 1192PositionY (HwndSource) 1192PowerEase 946PowerSixEase 952Predicate<T> 693PredictFocus 458PresentationCore 56PresentationFramework 57PresentationHost.exe 1160PresentationTraceLevel 658PresentationTraceSources 658preserve (xml:space) 177Press (ClickMode) 241PreviewMouseDoubleClick 238PreviewMouseDown 450PreviousAndCurrent (GridResize-

Behavior) 356PreviousAndNext (GridResize-

Behavior) 356PreviousData (RelativeSource-

Mode) 669PrimaryScreenHeight 525PrimaryScreenWidth 525PrintableFriend 1023, 1150PrintDialog 1088PrintDocument 1088PrintDocumentImageableArea

1085PrintQueue 1085PrintServer 1087PrintTicket 1088PrintVisual 1089PriorityBinding 672PriorityBindingExpression 674ProgrammaticName (Automation-

Pattern) 1109ProgressBar 299, 616ProgressPercentage 1075ProgressState 1128ProgressValue 1128ProjectionCamera 856

ProjectionMatrix 859Projektion 855Projektvorlage

WPF-Anwendung 88WPF-Benutzersteuerelement-

bibliothek 89Projektvorlagen

WPF-Browseranwendung 89propa (Code-Snippet) 416propdp (Code-Snippet) 392Properties (Application) 114,

1146Property

Condition 598Engine 388Mapping 1173Setter 581System 388Trigger 586

Property-Attribut 144PropertyChanged (UpdateSource-

Trigger) 654PropertyChangedCallback 396,

408PropertyCondition 1108PropertyConditionFlags 1108Property-Element 156Property-Element-Syntax 156PropertyGroupDescription 693PropertyMap 1173PropertyMetadata 392PropertyName (SortDescription)

693PropertyPath 650PropertyTranslator 1173Property-Trigger 585Property-Vererbung 405ProvideValue 168pt 167PushClip (DrawingContext) 804PushEffect (DrawingContext) 804PushGuidelineSet (Drawing-

Context) 804PushOpacity (DrawingContext)

804PushOpacityMask (Drawing-

Context) 804

PushTransform (Drawing-Context) 804

px 167

Q

QuadraticAttenuation 868QuadraticBezierSegment 793QuadraticEase 946Quality (RenderBias) 830QuarticEase 946Quaternion 872QuaternionRotation 871Question (SystemSounds) 963QuinticEase 946

R

RadialGradientBrush 813verschiedene Center 814verschiedene GradientOrigins

814RadioButton 245Radius 830RaiseAutomationEvent 1119RaiseEvent 433, 438RangeBase 297RawProposedValue (Validation-

Step) 718RawViewWalker 1107ReachFramework 1074ReadLocalValue 411ReadResources 543Rechte-Daumen-Regel 864Rect 131, 311Rectangle 775RectangleAdorner 1029RectangleGeometry 787References (FixedDocument-

Sequence) 1079Reflection 147Reflector 120Reflektionseffekt 820Refresh 1145

DataSourceProvider 681Register (Methode) 391RegisterAttached 416RegisterAttachedReadOnly 420


Index

1229

RegisterClassCommandBinding 505, 999

RegisterClassHandler 444RegisterName 209, 211RegisterPixelShaderSampler-

Property 838RegisterReadOnly 406RegisterRoutedEvent 429, 437,

997RelativeResource 667RelativeResourceMode 667RelativeSource 172, 615

Binding 647Release (ClickMode) 241ReleaseMouseCapture 461Remove

AdornerLayer 1031ClockController 918ResourceDictionary 534

Remove[Eventname]Handler 441, 474

RemoveAllEventHandlers 1111RemoveBackEntry 1144RemoveFromJournal 1146RemoveHandler 433RemoveLogicalChild 200RemoveStoryboard 931RemoveVisualChild 219Render 978RenderAtScale 822RenderBias 830RenderCapability 58, 836, 892Rendering (CompositionTarget)

954RenderOpen 805RenderOptions 1054, 1056RenderSize 311RenderTargetBitmap 844, 978Render-Thread 55RenderTransform 329, 365RenderTransformOrigin 330RepeatBehavior 901, 911RepeatButton 243Replay (CustomContentState)

1146RequerySuggested 480ResetBindings (BindingSource)

1172ResGen.exe 543

ResizeBehaviour 355ResizeDirection 355ResizeGrip 126ResizeMode 127Resource (Buildvorgang) 103,

545ResourceAssembly 549ResourceDictionary 519ResourceDictionaryLocation

1009ResourceId 1004ResourceManager 543Resources

FrameworkTemplate 600Property 520

ResourceSet 544Resource-Stream 543ResourceStreamInfo 551Ressource

binäre 541logische 519

Ressourcenpfad 523Resume (ClockController) 918ResumeStoryboard 931Retained-Mode-System 773Return (PageFunction<T>) 1153ReturnEventArgs<T> 1153RGB 809RichTextBox 289, 1068Right

Canvas 341HorizontalAlignment 323

RightButton 459RootElement (Automation-

Element) 1105RootVisual (HwndSource) 1192Rotate (Matrix) 337RotateAt (Matrix) 337RotateTransform 331RotateTransform3D 871Rotation

Aufzählung 845RotationTransform3D 871

Rotation3D 871Routed Event

Attached Event 440Event Handler für 433Event System 434

Routed Event (Forts.)existierendes in eigener Klasse

442implementieren 436in Custom Control implementie-

ren 997Instanz-/Klassenbehandlung

443Sender/Source/OriginalSource

449Überblick 66und Commands 474vs. klassischer Event 435

RoutedCommand 478RoutedEvent 428

EventTrigger 592RoutedEventArgs 434

RoutedEventArgs 433RoutedEventHandler 438RoutedUICommand 479, 487RoutingStrategy 429Row (Grid) 349RowBackground 744RowDefinition 349RowDetailsTemplate 733RowDetailsTemplateSelector 735RowDetailsVisibilityMode 733RowGroups (Table) 1061RowHeaderStyle 737, 745RowHeaderWidth 737Rows

GridResizeDirection 355TableRowGroup 1061UniformGrid 361

RowSpanGrid 349TableCell 1062

RowStyle 638, 744RowValidationErrorTemplate

743RowValidationRules 740RSS (Real Simple Syndication)

678Run 196, 1040

Application 110Dispatcher 118

RuntimeNamePropertyAttribute 173


Index

1230

S

s0 832sampler2D 832Satellite 557Satellite-Assembly 554Save

ApplicationCommands 498XamlWriter 185

SaveFileDialog 1102SaveFlowAsXPS 1076Scale (Matrix) 337ScaleAt (Matrix) 337ScaleTransform 333ScaleTransform3D 871ScaleX (ScaleTransform) 333ScaleY (ScaleTransform) 333SceneCleanup 1206SceneInit 1206SceneRender 1206Schlüsselbild 933Schrift 1045scRGB 810Scroll (FlowDocumentReader-

ViewingMode) 1067ScrollBar 243, 300ScrollBarVisibility 253ScrollChanged 255ScrollContentPresenter 616ScrollIntoView 690ScrollToBottom 255ScrollToTop 255ScrollViewer 253Seal 581sealed 313Section 1061SecureString 290Seek (ClockController) 918SeekAlignedToLastTick 918

ClockController 918SeekStoryboard 931SegmentCollection 791Select (TextBox) 288SelectAll 281Selected

Selector 277TreeViewItem 268

SelectedCells 738SelectedCellsChanged 738

SelectedDate 293SelectedDates 293SelectedDatesChanged 294SelectedFormat 296SelectedIndex (Selector) 277SelectedItem

Selector 277TreeView 268

SelectedItemBinding 726SelectedItemChanged (Tree-

View) 268SelectedItems 280SelectedValue


SelectedValueBinding 726SelectedValuePath


Selection (RichTextBox) 289, 1069

SelectionBrush 287SelectionChanged

DataGrid 738Selector 277TextBoxBase 287

SelectionLength (TextBox) 288SelectionMode 281, 293

DataGrid 737DataGridView 1170

SelectionOpacity 287SelectionStart (TextBox) 288SelectionUnit 737Selector 277SelectStyle 573SelectTemplate 746Self (RelativeSourceMode) 667sender (Routed Event) 449SendMessage (Win32) 1184Separator 265Serialisieren 185Serialisierungsformat 141SessionEnding 112SetBackBuffer 1208SetBinding 645SetCurrentValue 404SetFocus (Win32) 1191SetJumpList 1133Set-Methode 414

SetResourceReference 534SetStoryboardSpeedRatio 931Setter 581SetterBase 581SetterBaseCollection 581Setters

DataTrigger 591Style 570Trigger 586

Setup-Projekt 1120SetValue 386SetView (FriendStorage) 756,

1170ShaderEffect 837Shape 774

Ellipse 776Klassenhierarchie 774Line 776Path 785Polygon 778Polyline 778Rectangle 775Stroke-Properties 782

SharedSizeGroup 357Show 125ShowActivated 127ShowDialog 125, 132ShowDuration (ToolTipService)

253ShowFrequentCategory 1134ShowGridLines 349ShowInTaskbar 127ShowOnDisabled (ToolTip-

Service) 253ShowRecentCategory 1134ShowsNavigationUI 1137ShowsPreview (GridSplitter) 356Shutdown 111ShutdownMode 116Side-by-Side-Installation 42Silverlight vs. XBAP 1161SimpleButton 435SimpleCanvas 417SineEase 946Single (SelectionMode) 281SingleBorderWindow 131Single-threaded Apartment 106Site of Origin 545Size 311


Index

1231

SizeChanged 138SizeToCells (DataGridLengthUnit-

Type) 730SizeToContent 127, 317SizeToHeader (DataGridLength-

UnitType) 730SkewTransform 334Skinning 581SkipStoryboardToFill 931SkipToFill (ClockController) 918Slide (PopupAnimation) 304Slider 298Slip (SlipBehavior) 976SlipBehavior 975Slipping 975SmallChange 297Snapshot 977SnapshotAndReplace 916SnapsToDevicePixels 777, 823SolidColorBrush 809SortDescription 693SoundLocation 962SoundPlayer 960SoundPlayerAction 959–960Source

Binding 647CollectionViewSource 695Frame 256NavigationService 1143RoutedEventArgs 434, 449SoundPlayerAction 960

SourceAssembly 1007SourceCollection (ICollection-

View) 688SourceName

Condition 598EventTrigger 592Trigger 586

SourceUpdated 711Span 1040SpecularMaterial 873SpeedRatio 901, 910

MediaPlayer 964SpellCheck 287Spiegeleffekt 820Splashscreen 563SplineDoubleKeyFrame 934, 937Spline-Keyframe-Animation 937SpotLight 867

Spracherweiterungen (XAML) 173

SpreadMethod 812Springiness 946Square (TextMarkerStyle) 1061sRGB 810STA (Single-threaded Apartment)

106StackPanel 343Star

DataGridLengthUnitType 730GridUnitType 350

Star-Sizing 352StartEndDateValidationRule 741StartPoint (LinearGradientBrush)

811Startup 112StartupEventArgs 112StartupUri 99Startzeit 910StateChanged 138States (VisualStateGroup) 626STAThreadAttribute 106StaticExtension 169StaticResource 172, 520, 530Status (BindingExpression) 657StatusBar 284StatusBarItem 284StickyNoteControl 1069Stop

ClockController 918FillBehavior 915MediaElement 972MediaPlayer 964SoundPlayer 962

StopLoading 1147Stopped (ClockState) 917StopStoryboard 931Storyboard 924Stream

ResourceStreamInfo 551SoundPlayer 962

StreamGeometry 794Stretch

HorizontalAlignment 323Property 301VerticalAlignment 323

StretchDirection 302

Strikethrough (TextDecoration-Location) 1043

StringFormat 648, 758StrokeCollected 291StrokeCollection 290Stroke-Properties (Shape) 782StrokeReplaced 291Strokes 290Style 570

als logische Ressource 573benannter 573erweitern 579Fokus-Style 573für DataGridRow 637für mehrere Typen 577impliziter 574Inline-Style 572Klasse 570Theme-Style 609und Templates (Überblick) 72und Trigger 584

StyleSelector 573, 747StyleTypedPropertyAttribute 572Stylus 462StylusDown 462StylusUp 462SubmenuClosed (MenuItem) 274SubmenuOpened (MenuItem)

274SubPropertiesDoNotAffect-

Render 394Subscript (BaselineAlignment)

1043Subtree (TreeScope) 1107Successful 292Superscript (BaselineAlignment)

1043Swift3D 891System.Collections.Specialized

697System.ComponentModel 160System.Diagnostics 658System.Globalization 554System.IO.Packaging 1083System.Media 960System.Printing 1074System.Resources 557System.Windows 78


Index

1232

System.Windows.Annotations 1069

System.Windows.Annotations.Storage 1071

System.Windows.Automation 1104

System.Windows.Automa-tion.Peer 1117

System.Windows.Controls 234System.Windows.Controls.Primi-

tives 234System.Windows.Data 643System.Windows.Documents

1039System.Windows.Forms.

Integration 1166System.Windows.Ink 290System.Windows.Input 453System.Windows.Iterop 1177System.Windows.Markup 149System.Windows.Markup.

Localizer 561System.Windows.Media 786,

797, 963System.Windows.Media.

Animation 895System.Windows.Media.

Imaging 843System.Win-

dows.Media.Media3D 849System.Windows.Navigation

1137System.Windows.Shapes 774System.Windows.Shell 1122System.Windows.Threading 80System.Windows.Xps 1074System.Windows.Xps.Packaging

1074System.Xaml.dll 183SystemColors 524SystemEvents 1203SystemFontFamilies 1046SystemFonts 525Systemmenü 126SystemParameters 128, 524SystemSounds 963SystemTypefaces 1046

T

t:updateuid 558TabIndex 237TabInto (IKeyboardInputSink)

1191Table 1061TableCell 1061TableColumn 1061TableRow 1061TableRowGroup 1061TabNavigation 265TabPanel 363TabStripPlacement 284Tag 423

FrameworkElement 269Target (Label) 249TargetName

Setter 582Storyboard 924

TargetNullValue 648TargetProperty (Storyboard) 924TargetPropertyType 902TargetType

ControlTemplate 606Style 571

TargetType (Style)vs. x:Key 576

TargetUpdated 711Taskbar 1121TaskbarItemInfo 127, 1122–1123TaskbarItemProgressState 1128TaskDialog 1196TaskDialogIndirect 1200Tastatur-Fokus 456

und Commands 503Telerik 50Template 599

Arten 599Control 237, 606ControlTemplate 606DataTemplate 602in C# 631ItemsPanelTemplate 601

TemplateBinding 172, 612, 987TemplatedParent

FrameworkElement 614RelativeSourceMode 668

Template-Part 990

TemplatePartAttribute 616, 991TemplatesDefault-Control-

Template 609TemplateVisualStateAttribute

621tex2D 832TEXCOORD 833Text 1038

Formatierung mit Spans 1040RoutedUICommand 479TextBox 287Texteffekte 1049Typographie 1047UIElemente im 1045

TextAlignment (FlowDocument) 1060

TextBinding 726TextBlock 196, 290, 1038TextBox 287TextBoxBase 287TextChanged (TextBoxBase) 287TextCompositionEventArgs 455TextDecoration 1043TextDecorationLocation 1043TextEffect 1049TextElement 421, 1042TextFormattingMode 1054TextHintingMode 1055TextInput 455TextLabel 390TextLength 287TextMarkerStyle 1061TextOptions 1054TextPattern 1110TextPointer 289TextRenderingMode 1055TextSelection 289, 1069TextTrimming 1052Textur 832, 874TextureCoordinates 875TextWrapping 288, 1051Theme 1008ThemeDictionary 173, 1009ThemeInfoAttribute 1007Theme-Style 609Theta 889Thickness 320ThicknessConverter 320ThreeDBorderWindow 131


Index

1233

Thumb 299ThumbButtonInfo 1124Thumbnail 1122ThumbnailClipMargin 1130Tick (DispatcherTimer) 957TickPlacement 298Tier 58

RenderCapability 892Tile (TileMode) 817TileBrush 815

ImageBrush 816VisualBrush 816

TileBrushDrawingBrush 816TileMode 817TimeChanged (SystemEvents)

1203Timeline 900TimelineCollection 924Timer 957TimeSpanConverter 909TimeSpanSeek 918Title

Page 1143Window 127

Titlebar 125To 905ToggleButton 244TogglePattern 1110ToolBar 264ToolBarOverflowPanel 363ToolBarPanel 345ToolBars (ToolBarTray) 265ToolBarTray 265ToolTip 251ToolTipService 252ToolWindow 130Top

Canvas 341VerticalAlignment 323Window 127

Topmost 127TotalManipulation 464Touch 463–464TouchAction 464TouchDevice 463TouchDown 463TouchEnter 463TouchEventArgs 463TouchFrameEventArgs 464

TouchLeave 463TouchMove 463TouchPoint 463TouchUp 463TraceLevel 658Transform 327

Camera 858Model3D 861ModelVisual3D 860Transform 1049

Transform3D 852, 871Transform3DGroup 871Transformation

2D-Transformation 3273D-Transformation 870

TransformCollection 337TransformConverter 336TransformedBitmap 844TransformGroup 337TransformPattern 1110Transitions (VisualStateGroup)

626Translate (Matrix) 337TranslateAccelerator 1190TranslatePoint 335TranslateTransform 335TranslateTransform3D 871Transparent (Background) 360Transparenz

AllowsTransparency 127, 360Opacity 815OpacityMask 815Transparenzfarbe für Icons 274

TraversalRequest 1192TreeScope 1106TreeView 267TreeViewItem 268TreeWalker 1107Treppeneffekt 1055TriangleIndices (MeshGeometry)

863Trigger 585

DataTrigger 590EventTrigger 592komplexe Bedingungen 597Property-Trigger 585

TriggerAction 589, 923TriggerBase 584TriggerCollection 584

TrueCondition 1107TrueType 1045TryFindResource 523TryGetCurrentPattern 1109Tunnel (RoutingStrategy) 429Tunneling Event 429TwoPage (FlowDocumentReader-

ViewingMode) 1067TwoWay (BindingMode) 652Type-Converter 159

eigenen implementieren 162greift nur, wenn 161in C# verwenden 166vordefinierter 160

TypeConverterAttribute 161TypeDescriptor 166Typeface 1045TypeInTargetAssembly 1004typeof 172, 576Typography 1047

U

UI Automation 1104Gründe für 1104in eigenen Controls 1013Tree 1105

UIElement 82UIElement3D 86, 852, 883UIElementAutomationPeer 1118UIElementCollection 221, 313UIPropertyMetadata 393UISpy 1117UI-Thread 55UltimateResourceFallback-

Location 557UltraBold (FontWeights) 1046Unabhängiger Modus 967Unboxing 671Unchecked

MenuItem 274ToggleButton 245

UnderlineInline 1040TextDecorationLocation 1043

UndoLimit (TextBoxBase) 287Uniform

KeyTime 936Stretch 301


Index

1234

UniformGrid 361UniformToFill (Stretch) 301UnitType 730Unlock 1208UnregisterName 209UnselectAll 281Unselected

Selector 277TreeViewItem 268

UnsetValue 411UpdatedValue (ValidationStep)

718UpdateGraph 947UpdateLayout 318UpdateShaderValue 838UpdateSource 656UpdateSourceExceptionFilter

648UpdateSourceExceptionFilter-

Callback 706UpdateSourceTrigger 648, 654UpdateTarget 656UpDirection (ProjectionCamera)

856UpOnly (StretchDirection) 302UpperLatin (TextMarkerStyle)

1061UpperRoman (TextMarkerStyle)

1061Ursprung (Koordinatensystem)

853UseLayoutRounding 325User Control 1021

Alternativen zu 1028Content-Property festlegen 1027Properties erstellen 1025Struktur 1021UI definieren 1024

user32.dll 48UserControl 89, 1021UserPageRangeEnabled 1089UserValidationRule 714UsesParentJournal (Journal-

Ownership) 1145

V

Validate (ValidationRule) 706ValidateInput (FriendStorage)

767ValidatesOnDataErrors 648, 709ValidatesOnExceptions 648ValidateValueCallback 399Validation 709ValidationAdornerSite 715ValidationAdornerSiteFor 715ValidationError 657, 709ValidationResult 706ValidationRules 648, 702, 712ValidationStep 718Validieren

Benutzereingabe 702Dependency Property 399mit DataErrorValidationRule

707mit eigener ValidationRule 706mit ExceptionValidationRule

704Validation-Klasse 709

ValidResult 706Value

Condition 598DataTrigger 590GridLength 350IKeyframe 934RangeBase 297Setter 581Transform 327Transform3D 871Trigger 586

Value (Nullable<T>) 134ValueChanged 297ValueConversionAttribute 665ValuePattern 1109–1110ValueSource 412Vector3D 857VerifyAccess 81Vertexshader 831Vertical (Orientation) 343VerticalAlignment 323VerticalAnchor (Figure) 1065VerticalContentAlignment 237,

324VerticalGridLinesBrush 744

VerticalOffset (ToolTip) 251VerticalScrollBarVisibility 253VerticalStackPanel 364Video 959

mit MediaElement 970mit MediaPlayer 965Snapshot 977steuern in C# 972steuern in XAML 972

VideoDrawing 800, 965VideoPlayer 988VideoPlayerState 995View

CollectionViewSource 695ListView 281

ViewBase 281Viewbox 301

TileBrush 816ViewboxUnits (TileBrush) 817ViewingMode (FlowDocument-

Reader) 1067ViewMatrix 859Viewport (TileBrush) 816Viewport2DVisual3D 885Viewport3D 854Viewport3DVisual 855ViewportHeight (ScrollViewer)

254ViewportUnits (TileBrush) 817ViewportWidth (ScrollViewer)

254ViewThumbnailsCommand 1079VirtualizingStackPanel 362Visibility 324Visible (Visibility) 324VisisbleWhenSelected (DataGrid-

RowDetailsVisibilityMode ) 733

Visual 82Inheritance 1027Layer-Programmierung 803Tree 54, 215

Visual Studio.csproj-Datei öffnen 104alle Dateien anzeigen 93Buildprozess 102Code-Snippet 392, 416Debug-Optionen 93Hostprozess ausschalten 1199


Index

1235

Visual Studio (Forts.)Multitargeting 43nicht sichtbare Datei 92Projektvorlage 87Versionen 42Windows-Projekt mit 91WPF-Designer 50

Visual3D 86, 852, 859Visual3DCollection 854VisualBrush 816, 818, 877VisualCollection 222VisualHit (HitTestResult) 808Visual-Hit-Testing

2D 8073D 882

VisualState 623VisualStateGroup 622VisualStateGroups 622VisualStateManager 620, 1014VisualsToXpsDocument 1087VisualTransition 626VisualTree (Framework-

Template) 600VisualTreeHelper 222, 882Vorrangsrecht (Dependency

Property) 409Vorschaufenster 1122

W

W3C 177Wait (Cursors) 462WaitForInputIdle 1111WaitHandle 123WalkLogicalTree 207WalkVisualTree 223WebBrowser 256Width 128, 319

ColumnDefinition 350OrthographicCamera 859

Win32 48Interop mit 1181Nachrichten in WPF abfangen

1201Ressourcen 1200

Window 124Events 137Komponenten 125Methoden 125

Window (Forts.)Properties 126Properties für Dialoge 132

WindowBrushKey 527WindowClosedEvent 1110WindowCollection 115Window-Handle 49, 1165WindowHeight (Page) 1137WindowInteropHelper 1177WindowPattern 1110Windows

7 1121Application 115CardSpace (WCS) 39Communication Foundation

(WCF) 39Forms 43Media Player 963Presentation Foundation � WPFSDK 191Workflow Foundation (WF) 39

Windows FormsInterop mit 1166Rendering mit GDI+ 48

Windows-API 48Wrapper 48

WindowsBase 56WindowsFormsHost 1167Windows-Projekt

Best Practice 110reine Code-Anwendung (C#) 105reine, kompilierte XAML-Anwen-

dung 107XAML und C# 92

WindowStartupLocation 127WindowState 127Windows-Theme 1008WindowStyle 128–129WindowTitle (Page) 1137WindowWidth (Page) 1137windschief 334WinFX 149Winmm.dll 963WM_TOUCH 463WndProc (HwndHost) 1187Wohlgeformt 144WordEllipsis (TextTrimming)

1052WorkArea 131

WorkingDirectory 1132World Wide Web Consortium �

W3CWPF

3.5 weiterer XML-Namespace 148

4.0 41Assemblies 79Einführung in die 39Einstiegshürde 44Elternelement 340Gründe gegen 51Grundlagen 78Kern- und Framework-Funktiona-

lität 84Kernklassen 79Konzepte 59Markup-Extension 172Namespace 78Projektvorlage 87Rendering 55Services 389Stärken, Nutzen 45, 57strategisches Programmier-

modell 50Warum STA? 106WPF-Architektur 52XML-Namespace der 146

WPF-ArchitekturComposition Tree 54Composition-System 54Kernbibliotheken 52Media Integration Layer 52MilCore 53PresentationCore 56PresentationFramework 57Rendering 55Visual Tree 54Vorteile/Stärken der 57WindowsBase 56

WPF-Kernklasse 79ContentElement 85Control 84DependencyObject 82DispatcherObject 80FrameworkContentElement 85FrameworkElement 83Freezable 85UIElement 82


Index

1236

WPF-Kernklasse (Forts.)UIElement3D 86Visual 82Visual3D 86

Wrap (TextWrapping) 1051WrapPanel 345WrapWithOverflow (Text-

Wrapping) 1051WritableBitmap 844Write (XpsDocumentWriter)

1075WriteAsync (XpsDocumentWriter)

1075WritingCancelled 1075WritingCompleted 1075WritingProgressChanged 1075WritingProgressChangedEven-

tArgs 1075Wurzelelement 144WYSIWYG 1074

X

XDoubleAnimationUsingPath

942TranslateTransform 335

x:Array 171, 682x:Class 95, 175x:ClassModifier 175x:Code 107, 175x:FieldModifier 176x:Key 176, 519

vs. TargetType (Style) 576x:Name 176x:Null 171, 245x:Reference 171x:Shared 176, 529x:Static 171, 473x:Subclass 176x:Type 172, 572x:TypeArguments 176, 1154x:Uid 177x:XData 177, 676

XAML 47, 141Attached-Event-Syntax 269, 440Attached-Property-Syntax 159Attribute 144Attribut-Syntax 155CLR-Namespaces der WPF 147Collections in 178Content-Property 157Default -Property 157dynamisch laden 183eigene CLR-Namespaces in 151Elemente 144Entity-Referenzen in 178Inline-Code 108Kindelemente eines Objektele-

ments 182kompiliertes 551Markup-Extension 168Namespace 145Nutzen von 141Objekt serialisieren in 185Property setzen in 154Property-Element-Syntax 156qualifizierter double-Wert 167Spracherweiterungen 173Type-Converter 159Überblick 60Wurzelelement 144XML-Namespace für 149zugeordneter CLR-Namespace

149XAML-Compiler 147XAMLPadExtensionClone 193,

227XAML-Parser 146XamlReader 183XamlWriter 185XBAP (XAML Browser Applica-

tion) 89, 1157FriendViewer als 1157vs. Loose XAML 1161vs. Silverlight 1161

XElement 681XLinq 681XML 144

Paper Specification (XPS) 1073

xml:lang 177, 288, 297, 1059xml:space 177XML-Attribut 144XML-basiert 141XmlDataProvider 676XML-Dateninsel 676XML-Element 144XML-Namespace 146XmlNamespace 146XmlNamespaceManager 678XmlNamespaceManagerCollec-

tion 678xmlns 146XmlnsDefinitionAttribute 146XmlReader 183XmlStreamStore 1071XmlWriter 185XPath (Binding) 648, 676XpsDocument 1074XpsDocumentWriter 1074XPS-Dokument 1073

anzeigen 1078aus FriendStorage exportieren

1091drucken 1085FlowDocument speichern als

1074in C# erstellen 1083Inhalte 1079laden 1078

Y

YDoubleAnimationUsingPath

942TranslateTransform 335

Z

Zam3D 143, 891Zeicheninformationen 804Zeitmanager 902ZIndex 341Zoom-Effekt 594


Thomas Claudius Huber - s3-eu-west-1.amazonaws.com · Thomas Claudius Huber Windows Presentation...

Documents

Transcript of Thomas Claudius Huber - s3-eu-west-1.amazonaws.com · Thomas Claudius Huber Windows Presentation...