Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00101 009740 11027983 na godz. na dobę w sumie
C#. Tworzenie aplikacji graficznych w .NET 3.0 - książka
C#. Tworzenie aplikacji graficznych w .NET 3.0 - książka
Autor: Liczba stron: 304
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1076-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj techniki budowania interfejsów użytkownika dla aplikacji Windows

Najnowsza wersja platformy .NET, oznaczona numerem 3.0, zawiera wiele usprawnień, dzięki którym tworzenie aplikacji z interfejsem graficznym stało się zdecydowanie prostsze. Część platformy o nazwie Windows Presentation Foundation (WPF) wraz z przeznaczonym wyłącznie do projektowania interfejsów użytkownika językiem XAML pozwala na całkowite oddzielenie warstwy prezentacji aplikacji od warstwy logiki i danych. Wykorzystując podstawowy język programowania platformy .NET -- C# -- można niemal błyskawicznie stworzyć aplikację z graficznym interfejsem użytkownika. Udostępniane bezpłatnie przez firmę Microsoft narzędzia Microsoft Visual C# Orcas Express Edition i Microsoft SQL Server 2005 Express Edition znacznie ułatwiają programistom poznanie nowej technologii.

Książka 'C#. Tworzenie aplikacji graficznych w .NET 3.0' opisuje ten właśnie język w kontekście pisania programów wyposażonych w interfejs graficzny zbudowany w oparciu o WPF. Czytając ją, dowiesz się, jak zainstalować i skonfigurować narzędzia do pracy. Poznasz język C#, zasady programowania obiektowego i najważniejsze klasy platformy .NET. Nauczysz się konstruować dokumenty XAML i tworzyć aplikacje WPF. Przeczytasz o komponentach wizualnych, zdarzeniach i programowaniu operacji graficznych. Znajdziesz tu również informacje o obsłudze plików, połączeniach z bazami danych oraz komunikacji sieciowej.

Poznaj najnowszą wersję narzędzia, które zrewolucjonizowało proces
tworzenia oprogramowania dla systemu Windows.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

C#. Tworzenie aplikacji graficznych w .NET 3.0 Autor: Krzysztof Rychlicki-Kicior ISBN: 978-83-246-1076-1 Format: B5, stron: 304 Poznaj techniki budowania interfejs(cid:243)w u¿ytkownika dla aplikacji Windows (cid:149) Opanuj jŒzyk C# i wykorzystaj mo¿liwo(cid:156)ci programowania obiektowego (cid:149) Zaprojektuj interfejs u¿ytkownika, wykorzystuj„c jŒzyk XAML (cid:149) Zaimplementuj mechanizmy obs‡ugi plik(cid:243)w i wymiany danych Najnowsza wersja platformy .NET, oznaczona numerem 3.0, zawiera wiele usprawnieæ, dziŒki kt(cid:243)rym tworzenie aplikacji z interfejsem graficznym sta‡o siŒ zdecydowanie prostsze. CzŒ(cid:156)(cid:230) platformy o nazwie Windows Presentation Foundation (WPF) wraz z przeznaczonym wy‡„cznie do projektowania interfejs(cid:243)w u¿ytkownika jŒzykiem XAML pozwala na ca‡kowite oddzielenie warstwy prezentacji aplikacji od warstwy logiki i danych. Wykorzystuj„c podstawowy jŒzyk programowania platformy .NET (cid:150) C# (cid:150) mo¿na niemal b‡yskawicznie stworzy(cid:230) aplikacjŒ z graficznym interfejsem u¿ytkownika. Ksi„¿ka (cid:132)C#. Tworzenie aplikacji graficznych w .NET 3.0(cid:148) opisuje ten w‡a(cid:156)nie jŒzyk w kontek(cid:156)cie pisania program(cid:243)w wyposa¿onych w interfejs graficzny zbudowany w oparciu o WPF. Czytaj„c j„, dowiesz siŒ, jak zainstalowa(cid:230) i skonfigurowa(cid:230) narzŒdzia do pracy. Poznasz jŒzyk C#, zasady programowania obiektowego i najwa¿niejsze klasy platformy .NET. Nauczysz siŒ konstruowa(cid:230) dokumenty XAML i tworzy(cid:230) aplikacje WPF. Przeczytasz o komponentach wizualnych, zdarzeniach i programowaniu operacji graficznych. Znajdziesz tu r(cid:243)wnie¿ informacje o obs‡udze plik(cid:243)w, po‡„czeniach z bazami danych oraz komunikacji sieciowej. (cid:149) Pobieranie i instalacja narzŒdzi (cid:149) Podstawowe elementy jŒzyka C# (cid:149) Programowanie obiektowe (cid:149) Konstruowanie dokument(cid:243)w XAML (cid:149) Hierarchia klas komponent(cid:243)w wizualnych (cid:149) Obs‡uga zdarzeæ (cid:149) Geometria 2D (cid:149) Operacje graficzne (cid:149) Tworzenie animacji (cid:149) Korzystanie z szablon(cid:243)w (cid:149) Obs‡uga plik(cid:243)w i danych (cid:149) Przetwarzanie dokument(cid:243)w XML (cid:149) Po‡„czenia z sieci„ Poznaj najnowsz„ wersjŒ narzŒdzia, kt(cid:243)re zrewolucjonizowa‡o proces tworzenia oprogramowania dla systemu Windows Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści Wstęp .............................................................................................. 9 Część I Przygotowanie środowiska ............................................ 11 Rozdział 1. Przygotowanie środowiska Orcas .................................................... 13 Pobieranie aplikacji ......................................................................................................... 14 Pobieranie alternatywnego instalatora ...................................................................... 15 Instalacja .......................................................................................................................... 15 Konfiguracja serwera SQL .............................................................................................. 17 Część II Język C# ...................................................................... 19 Rozdział 2. Podstawowe elementy języka ......................................................... 21 Zmienne ........................................................................................................................... 22 Stałe ................................................................................................................................. 24 Operatory ......................................................................................................................... 25 Instrukcje ......................................................................................................................... 28 Instrukcja warunkowa ............................................................................................... 29 Instrukcja switch ....................................................................................................... 30 Pętle ................................................................................................................................. 31 Pętla for ..................................................................................................................... 31 Pętle while i do..while ............................................................................................... 31 While vs for ............................................................................................................... 32 Komentarze ...................................................................................................................... 33 Tablice ............................................................................................................................. 33 Tablice zagnieżdżone ................................................................................................ 34 Tablice wielowymiarowe .......................................................................................... 35 Rzutowanie ...................................................................................................................... 36 Typ wyliczeniowy ........................................................................................................... 37 Pytania testowe ................................................................................................................ 38 Rozdział 3. Wszystko jest obiektem! ................................................................ 39 Tworzenie klas ................................................................................................................. 40 Pola ............................................................................................................................ 40 Metody ...................................................................................................................... 40 Konstruktor ................................................................................................................ 41 Modyfikatory dostępu ............................................................................................... 42 Destruktor .................................................................................................................. 43 4 C#. Tworzenie aplikacji graficznych w .NET 3.0 Przestrzenie nazw ............................................................................................................ 44 Dziedziczenie ................................................................................................................... 45 Abstrakcja a programowanie obiektowe ......................................................................... 46 Tworzenie klasy potomnej ........................................................................................ 46 Metody — zaawansowane możliwości ........................................................................... 48 Nadpisywanie metod nieabstrakcyjnych ................................................................... 48 Metody statyczne ....................................................................................................... 49 Przeładowywanie metod ........................................................................................... 50 Klasy finalne .................................................................................................................... 50 Polimorfizm ..................................................................................................................... 51 Virtual i override vs new ........................................................................................... 51 Słowa kluczowe as i is .............................................................................................. 52 Przykład zastosowania polimorfizmu ....................................................................... 52 Pytania testowe ................................................................................................................ 53 Rozdział 4. Jeśli nie klasa, to co? ..................................................................... 55 Struktury .......................................................................................................................... 55 Słowa kluczowe ref i out ........................................................................................... 56 Zastosowanie struktur ............................................................................................... 58 Właściwości ..................................................................................................................... 59 Właściwości w praktyce ............................................................................................ 60 Interfejsy .......................................................................................................................... 61 Interfejsy w praktyce ................................................................................................. 62 Jawna implementacja interfejsów ............................................................................. 63 Delegacje ......................................................................................................................... 65 Zdarzenia ......................................................................................................................... 66 Tworzenie zdarzeń .................................................................................................... 68 Indeksery ......................................................................................................................... 70 Wyjątki ............................................................................................................................ 72 Klasy wyjątków ......................................................................................................... 73 Słowo using raz jeszcze ................................................................................................... 74 Typy nullowalne .............................................................................................................. 75 Typy generyczne .............................................................................................................. 76 Pytania testowe ................................................................................................................ 77 Część III .NET 3.0 ...................................................................... 79 Rozdział 5. Przykłady ważnych klas w .NET ....................................................... 81 Klasa Object .................................................................................................................... 81 Klasa DependencyObject (System.Windows) ................................................................. 82 Klasa Freezable (System.Windows) ................................................................................ 82 Klasa String ..................................................................................................................... 83 Klasa Array ...................................................................................................................... 84 Klasa ArrayList (System.Collections) ............................................................................. 85 Pytania testowe ................................................................................................................ 86 Rozdział 6. Zasady konstruowania dokumentów XAML ..................................... 87 XML i XAML ................................................................................................................. 87 XAML w praktyce ........................................................................................................... 89 Rozszerzenia znaczników ................................................................................................ 91 Zasoby podstawą aplikacji graficznych .................................................................... 91 Style — jedna deklaracja, wiele zastosowań ................................................................... 93 Zdarzenia ......................................................................................................................... 94 Wstawianie kodu XAML i C# w jednym pliku ........................................................ 95 Wstawianie kodu w osobnym pliku .......................................................................... 95 Spis treści 5 Name i x:Name w jednym byli kodzie ...................................................................... 96 Zdarzenia a style ........................................................................................................ 96 Właściwości dołączane .................................................................................................... 97 Pytania ............................................................................................................................. 98 Rozdział 7. Struktura aplikacji WPF ................................................................ 101 Tworzenie aplikacji w środowisku programistycznym ................................................. 101 Teoria w praktyce. PPP — Pierwszy Prosty Program ................................................... 106 Pytania testowe .............................................................................................................. 109 Rozdział 8. Hierarchia klas komponentów wizualnych ...................................... 111 System.Windows.Media.Visual .................................................................................... 112 System.Windows.UIElement ......................................................................................... 113 Obliczanie i ustawianie ........................................................................................... 114 System.Windows.FrameworkElement .......................................................................... 114 System.Windows.Controls.Control ............................................................................... 116 System.Windows.Controls.Panel .................................................................................. 116 Pytania testowe .............................................................................................................. 117 Rozdział 9. Komponenty wizualne ................................................................... 119 Button ............................................................................................................................ 119 TextBox ................................................................................................................... 120 TextBlock ................................................................................................................ 123 ListBox .................................................................................................................... 125 Image ............................................................................................................................. 127 Wyświetlanie z wymiarami ..................................................................................... 128 Menu .............................................................................................................................. 130 CheckBox ...................................................................................................................... 131 RadioButton ................................................................................................................... 133 ToolTip .......................................................................................................................... 133 ComboBox ..................................................................................................................... 135 ContextMenu ................................................................................................................. 136 TabControl ..................................................................................................................... 137 ScrollViewer .................................................................................................................. 138 ProgressBar .................................................................................................................... 139 ProgressBar a Slider ................................................................................................ 139 StatusBar ........................................................................................................................ 140 Pytania testowe .............................................................................................................. 141 Rozdział 10. Zdarzenia w praktyce ................................................................... 143 Zdarzenia w WPF .......................................................................................................... 143 Przykłady… ............................................................................................................. 144 Najważniejsze zdarzenia w WPF ............................................................................ 145 RoutedEventArgs a klasa EventArgs ...................................................................... 147 Pytania testowe .............................................................................................................. 148 Rozdział 11. Pojemniki ..................................................................................... 149 StackPanel ..................................................................................................................... 149 DockPanel ...................................................................................................................... 150 Canvas ........................................................................................................................... 151 WrapPanel ............................................................................................................... 152 Grid .......................................................................................................................... 153 Pytania testowe .............................................................................................................. 154 6 C#. Tworzenie aplikacji graficznych w .NET 3.0 Część IV Zaawansowane zagadnienia graficzne ......................... 157 Rozdział 12. Geometria 2D ............................................................................... 159 Klasa Geometry ............................................................................................................. 159 EllipseGeometry ............................................................................................................ 160 PathGeometry ................................................................................................................ 160 GeometryGroup ............................................................................................................. 163 GeometryGroup a mieszanie figur w klasie CombinedGeometry .......................... 164 Kształty — zastosowanie i użycie ................................................................................. 165 Pytania testowe .............................................................................................................. 166 Rozdział 13. Pozostałe ważne operacje graficzne .............................................. 169 Transformacje ................................................................................................................ 169 ScaleTransform ....................................................................................................... 169 RotateTransform ...................................................................................................... 170 SkewTransform ....................................................................................................... 171 TranslateTransform ................................................................................................. 172 Grupy transformacji ................................................................................................ 172 Rysunki .......................................................................................................................... 172 Pędzle ............................................................................................................................. 173 SolidColorBrush ...................................................................................................... 174 LinearGradientBrush ............................................................................................... 174 RadialGradientBrush ............................................................................................... 175 ImageBrush ............................................................................................................. 176 DrawingBrush ......................................................................................................... 176 VisualBrush ............................................................................................................. 177 Pióro ........................................................................................................................ 178 Efekty bitmap ................................................................................................................ 180 Pytania testowe .............................................................................................................. 182 Rozdział 14. Animacje ..................................................................................... 183 Triggery ......................................................................................................................... 183 Animacje ........................................................................................................................ 186 Animacje podstawowe (From / To / By) ................................................................. 188 Animacje z użyciem klatek kluczowych ................................................................. 189 Wiele animacji w jednej .......................................................................................... 196 Kontrola uruchomionej animacji ............................................................................. 196 Pytania testowe .............................................................................................................. 199 Rozdział 15. Szablony ...................................................................................... 201 Podstawowe operacje na szablonach ............................................................................. 201 Klasa Template ........................................................................................................ 201 Wykorzystywanie szablonu w stylach .................................................................... 204 TemplateBinding ..................................................................................................... 205 Szablony a triggery ........................................................................................................ 206 Pytania testowe .............................................................................................................. 208 Część V Obsługa danych .......................................................... 209 Rozdział 16. WPF i system plików .................................................................... 211 Pliki i katalogi ................................................................................................................ 211 Struktura katalogów ................................................................................................ 212 Directory .................................................................................................................. 213 File ........................................................................................................................... 215 Tworzenie plików .................................................................................................... 217 Spis treści 7 Strumienie, czytniki, zapisywacze… ...................................................................... 220 Tekst vs binaria ....................................................................................................... 222 Konwersja między kodowaniami ............................................................................ 224 Wyjątki wejścia-wyjścia ......................................................................................... 225 Przykład ................................................................................................................... 225 Pytania testowe .............................................................................................................. 227 Rozdział 17. Wiązanie danych .......................................................................... 229 Warstwy aplikacji .......................................................................................................... 229 Podstawy wiązania danych ............................................................................................ 230 Klasa Binding ................................................................................................................ 231 Sposoby oddziaływania źródła i celu wiązania ............................................................. 233 Interfejs INotifyPropertyChanged ................................................................................. 234 Kontrola zmiany danych źródła ..................................................................................... 236 Wiązanie danych a kolekcje .......................................................................................... 237 Szablon elementu ........................................................................................................... 239 Szablon, dane i triggery ........................................................................................... 240 Walidacja danych .......................................................................................................... 242 Pytania testowe .............................................................................................................. 244 Rozdział 18. Obsługa XML ............................................................................... 245 Wczytywanie dokumentów XML ................................................................................. 245 Wykorzystywanie danych XML .................................................................................... 246 Pytania testowe .............................................................................................................. 248 Rozdział 19. Różne źródła danych ..................................................................... 251 Źródło danych XML ...................................................................................................... 251 XmlDataProvider ........................................................................................................... 252 Microsoft SQL Server w praktyce ................................................................................. 256 Tworzenie połączenia z bazą danych ...................................................................... 257 Struktura bazy danych ................................................................................................... 258 Pytania testowe .............................................................................................................. 261 Rozdział 20. Multimedia w WPF ....................................................................... 263 MediaElement ................................................................................................................ 263 Oś czasowa i powrót do animacji… ........................................................................ 265 MediaPlayer ............................................................................................................ 267 Pytania testowe .............................................................................................................. 268 Rozdział 21. Wątki i internet ............................................................................ 269 Wątki ............................................................................................................................. 269 Internet ........................................................................................................................... 272 Protokół TCP ........................................................................................................... 272 Implementacja protokołu TCP w .NET 3.0 ............................................................. 273 TcpClient ................................................................................................................. 273 TcpListener .............................................................................................................. 274 Przykładowy projekt ............................................................................................... 275 Pytania testowe .............................................................................................................. 279 Dodatki ..................................................................................... 281 Dodatek A Bibliografia .................................................................................. 283 Dodatek B Odpowiedzi do pytań .................................................................... 285 Skorowidz .................................................................................... 289 Rozdział 14. Animacje W rozdziale tym dowiesz się, jak dokonać animacji właściwości. Do tego celu będzie Ci potrzebna również wiedza na temat triggerów. Mechanizm animacji daje ogromne możliwości, jednak jak w przypadku wszystkich udogodnień, należy pamiętać, że wyma- ga on szybkiego komputera! Triggery Trigger jest mechanizmem, który pozwala na wykonanie pewnej ściśle określonej czyn- ności, gdy jest spełniony dokładnie określony warunek. Wyróżniamy kilka rodzajów triggerów. Najpierw zapoznajmy się z pierwszym z nich — triggerem właściwości. Trigger właściwości jest reprezentowany przez klasę System.Windows.Trigger. Najczę- ściej jest wykorzystywany i tworzony w kodzie XAML, podobnie jak pozostałe triggery. Trigger służy do zmiany właściwości (za pomocą obiektu Setter) w sytuacji, gdy inna właściwość ma ściśle określoną wartość. Zapoznajmy się z pierwszym przykładem. Pole tekstowe przybierze zielony kolor, gdy użytkownik wprowadzi tajne hasło. Uści- ślając — gdy w polu tekstowym znajdzie się pewna wartość, nastąpi zmiana właściwości Background. XAML pozwala na wyrażenie tego w poniższy sposób: Window.Resources Style x:Key= triggery TargetType= {x:Type TextBox} Style.Triggers Trigger Property= Text Value= tajnehaslo Setter Property= Background Value= Lime / /Trigger /Style.Triggers /Style /Window.Resources StackPanel TextBox Text= Tu wpisz hasło Style= {StaticResource triggery} / /StackPanel 184 Część IV ♦ Zaawansowane zagadnienia graficzne Kluczowa część kodu jest zadeklarowana w stylu znajdującym się w zasobach okna. Wynika to z faktu, że triggery właściwości mogą być tworzone jedynie w deklaracjach stylów. Wszystkie triggery muszą znaleźć się w kolekcji Style.Triggers. Jak widać, każdy Trigger składa się z trzech kluczowych elementów: (cid:141) właściwości, która ma być obserwowana, (cid:141) wartości, jaką ma przyjąć ta właściwość w celu wykonania triggera, (cid:141) grupy obiektów klasy Setter, które dokonują żądanych zmian. Mechanizm triggerów automatycznie przywraca poprzednie wartości właściwości, które uległy zmianie w wyniku działania obiektów klasy Setter. Po wprowadzeniu tajnego hasła, gdy kolor zmieni się z białego na zielony, usunięcie choćby jednej litery spo- woduje powrót do białego tła. Oczywiście, podobny efekt można uzyskać za pomocą tradycyjnych zdarzeń. Pomijając jednak fakt, że nie wszystkie właściwości mają odpowiednie zdarzenia informujące o ich zmianie, kod potrzebny do osiągnięcia tego samego efektu jest po prostu dłuższy i mniej zwarty (rozdzielony na kod XAML i C#): StackPanel TextBox Name= txtBox Text= Tu wpisz tekst TextChanged= zmiana / /StackPanel void zmiana(object o, RoutedEventArgs rea) { if (txtBox.Text == tajnehaslo ) txtBox.Background = Brushes.Lime; else txtBox.Background = Brushes.White; } Pomijając fakt, że kod jest podzielony na dwie części, można łatwo sobie wyobrazić, co by było, gdybyśmy chcieli dokonać zmiany większej liczby właściwości! Do triggera należałoby dodać jedynie jeden obiekt Setter, zaś w drugim przypadku znacznego roz- szerzenia wymagałby kod metody. Idąc tropem triggerów właściwości, dojdziemy do innego interesującego mechanizmu — triggerów zdarzeń. Sens ich działania jest identyczny; inny jest jedynie element źródłowy, powodujący wywołanie obiektów Setter; jest nim zdarzenie (a nie zmiana właściwości, choć w gruncie rzeczy zmiana właściwości też jest zdarzeniem). Można zastanawiać się, po co właściwie wprowadzać taką konstrukcję, skoro stanowi ona ewidentny przykład dublowania funkcjonalności zdarzeń? Powód jest jeden, ale bardzo istotny. Są nim animacje — a konkretnie animowane właściwości, które są oma- wiane w następnym podrozdziale. Na razie zajmiemy się zatem schematem samego zdarzenia: Style x:Key= triggery TargetType= {x:Type TextBox} Style.Triggers Trigger Property= Text Value= tajnehaslo Setter Property= Background Value= Lime / /Trigger Rozdział 14. ♦ Animacje 185 EventTrigger RoutedEvent= PreviewMouseDown !-- tu znajdzie się treść animacji -- /EventTrigger /Style.Triggers /Style Najważniejszym atrybutem obiektu EventTrigger jest RoutedEvent — określa on zda- rzenie, które wywoła trigger. Co ważne, triggery zdarzeń mogą być umieszczane nie tylko w deklaracji stylu, ale także w kolekcji Triggers, którą posiada każda kontrolka: TextBox TextBox.Triggers EventTrigger RoutedEvent= PreviewMouseDown !-- tu znajdzie się treść animacji -- /EventTrigger /TextBox.Triggers /TextBox Ostatnim typem zdarzeń (choć nie ostatnim w ogóle), który chciałbym omówić w tym momencie, jest MultiTrigger. Jest to trigger właściwości, przy czym aby zostały wyko- nane założenia zapisane w obiektach Setter, muszą zajść wszystkie warunki określone w obiekcie MultiTrigger, a nie tylko jeden. Warunki pojedynczego triggera były zapisywane jako atrybuty. Pozostawienie takiej formy dla większej liczby warunków mijało się z celem, dlatego utworzono specjalną właściwość klasy MultiTrigger — Conditions (przechowującą obiekty klasy Condi- tion). Zobaczmy, jak wygląda to w praktyce, rozszerzając nasz przykład. W celu uzy- skania efektu zielonego tła dodamy konieczność wskazania pola tekstowego kursorem — innymi słowy, właściwość IsMouseOver musi mieć wartość true: Window.Resources Style x:Key= triggery TargetType= {x:Type TextBox} Style.Triggers MultiTrigger MultiTrigger.Conditions Condition Property= IsMouseOver Value= True / Condition Property= Text Value= tajnehaslo / /MultiTrigger.Conditions Setter Property= Background Value= Lime / /MultiTrigger /Style.Triggers /Style /Window.Resources StackPanel TextBox Name= txtBox Text= Tu wpisz tekst Style= {StaticResource triggery} / /StackPanel Obiekty klasy Condition przyjmują identyczne atrybuty jak w przypadku zwykłego obiektu Trigger. Obiekt klasy Setter ustawiamy poza blokiem warunków. W dekla- racji pola tekstowego nie musimy nic zmieniać — wszelkie zmiany zachodzą bowiem jedynie w obrębie stylu. 186 Część IV ♦ Zaawansowane zagadnienia graficzne Animacje Na wstępie pozwolę sobie od razu zaznaczyć — tytułowe animacje nie mają ścisłego związku z animacjami wykonywanymi w programie Flash, tudzież z animowanymi pli- kami w formacie GIF lub jakimikolwiek innymi formatami animacji, chociaż można odnaleźć wiele elementów wspólnych między nimi. Istotą tego zagadnienia w WPF jest animowanie różnych obiektów, a nie animacja sama w sobie. Dokładnie jest to ani- macja właściwości, czyli płynna zmiana wartości właściwości w określonym czasie. Wykonanie tej czynności powoduje jednak często efekty w postaci faktycznych ani- macji — czyli np. ruchu niektórych elementów znajdujących się w oknie. Istnieje kilka rodzajów animacji. Najprostszym z nich jest animacja wartości liczbowych. Istotą takiej animacji jest określenie wartości początkowej i końcowej. Nie można za- pomnieć też o ustawieniu czasu, w jakim dochodzi do wykonania animacji. Od niego zależy, czy animacja będzie przebiegała płynnie, czy nie. Nie wszystkie typy danych obsługują animację (choć podstawowe, takie jak liczby czy łańcuchy znaków, nie mają z tym problemu), natomiast istnieje możliwość stworzenia własnego sposobu animacji. Najpierw zajmiemy się jednak budową najprostszej animacji i sposobami jej wywołania. Najważniejszą częścią każdej animacji jest obiekt zawierający w nazwie słowo Animation. Oprócz tego na początku nazwy znajduje się typ animacji, co w rezultacie daje efekt w postaci nazwy np. DoubleAnimation. Zajmijmy się więc tą najprostszą z animacji, operującą na liczbach niecałkowitych. Przed chwilą wymieniłem najistotniejsze elementy takiej animacji; czas pokazać, w jaki sposób są one reprezentowane w kodzie XAML. Właściwości określające początko- wą i końcową wartość to From i To (od i do). Ze względu na typ danych muszą to być wartości typu Double. Trzecią kluczową właściwością jest Duration — okres trwania animacji. Jest on wyrażany za pomocą znacznika czasu (nie mam jednak na myśli znacznika w rozumieniu języka XML). Ma on postać h:m:s, gdzie h to liczba godzin, m — liczba minut, a s — liczba sekund (wszystkie trzy wartości mogą być niecałko- wite). W kodzie C# tego rodzaju konstrukcja jest reprezentowana przez klasę TimeSpan (przedział czasowy). Aby zilustrować opisane mechanizmy, utwórzmy prosty przykład — przycisk powiększający swoją szerokość trzykrotnie. Zaczniemy od obiektu animacji: DoubleAnimation Storyboard.TargetName= przycisk Storyboard.TargetProperty= Width From= 50 To= 150 Duration= 0:0:5 / Stosujemy wartość 50 dla właściwości From, aby rozpocząć animację od tej samej wartości, jaka jest zadeklarowana dla przycisku domyślnie (w kodzie XAML). Wyzna- czenie czasu na 5 sekund i szerokości na 150 pikseli powoduje, że co sekundę przyci- skowi przybędzie 20 pikseli z prawej strony. Za pomocą właściwości dołączanych klasy Storyboard określamy obiekt docelowy i animowaną właściwość. Zanim jednak powiem, w jakich sytuacjach należy określać pierwszą z tych właściwości, należy za- uważyć, że skoro korzystamy z właściwości dołączanych klasy Storyboard, to obiekt animacji jest umieszczony właśnie w znaczniku Storyboard. Tak rzeczywiście się dzieje; za pomocą właściwości tej klasy określamy właściwość i obiekt, z którymi jest związana animacja. Rozdział 14. ♦ Animacje 187 Obiekt Storyboard nie jest ostatnim znacznikiem, który poznajemy w tym miejscu. Do powiązania tego obiektu z triggerem zdarzenia należy wykorzystać obiekt Begin- Storyboard. Całość animacji wygląda zatem następująco: Button Name= przycisk Width= 50 Height= 70 Button.Triggers EventTrigger RoutedEvent= Button.Click BeginStoryboard Storyboard DoubleAnimation Storyboard.TargetName= przycisk Storyboard.TargetProperty= Width From= 50 To= 150 Duration= 0:0:5 / /Storyboard /BeginStoryboard /EventTrigger /Button.Triggers /Button !--Tuż po kliknięciu przycisku rozpocznie się animacja, która po 5 sekundach doprowadzi do poszerzenia przycisku na szerokość całego okna (przy założeniu, że okno ma 150 pikseli szerokości).-- Wszystkie animacje udostępniają inne ciekawe właściwości, które pozwalają na bar- dziej precyzyjną kontrolę nad nimi: public RepeatBehavior RepeatBehavior — określa sposób powtarzania animacji. Należy podać liczbę powtórzeń (z sufiksem x, np. 2x), aby uzyskać n-krotność powtórzeń, wartość Forever, aby animacja była powtarzana nieskończenie wiele razy, lub wartość typu TimeSpan (czyli przedział czasowy), aby animacja była powtarzana przez określony czas (przy ustawieniu tej wartości na 0:0:6 i czasie trwania animacji wynoszącym 3 sekundy, animacja zostanie wykonana dwa razy). W pierwszym przypadku można podać wartość niecałkowitą (np. 0.3x), aby animacja była wykonana tylko w części. public bool AutoReverse — określa, czy animacja (przy wielokrotnym wykonywaniu) ma być odtwarzana od początku (wartość domyślna — False), czy ma cofać się od stanu końcowego do początkowego (True — w naszym przykładzie przy tej właściwości ustawionej na False szerokość przycisku po osiągnięciu wartości 150 pikseli zostanie ponownie ustawiona na 50 pikseli, natomiast przy właściwości równej True szerokość będzie stopniowo zmniejszana od 150 do 50 pikseli). Liczba wykonań określona we właściwości RepeatBehavior dotyczy całkowitych wykonań animacji — wykonanie animacji i wycofanie do stanu początkowego jest traktowane jako jedno wykonanie animacji. public TimeSpan BeginTime — określa opóźnienie, z jakim rozpocznie się wykonywanie animacji. Domyślnie jest to wartość 0:0:0, czyli brak opóźnienia. Można też ustawić wartość null (w kodzie XAML {x:Null}) — wtedy animacja nie zostanie wykonana. public FillBehavior FillBehavior — określa sposób zachowania animowanego obiektu po zakończeniu animacji. Dla wartości Stop obiekt powraca do stanu sprzed animacji, natomiast dla wartości HoldEnd (domyślnej) zatrzymywany jest stan z końca animacji. 188 Część IV ♦ Zaawansowane zagadnienia graficzne Z ostatnią właściwością jest związany jeszcze jeden istotny fakt. Gdy po zakończeniu animacji będziemy próbowali zmienić wartość animowanej właściwości, zwyczajna zmiana następującej animacji: DoubleAnimation Storyboard.TargetName= przycisk Storyboard.TargetProperty= Width From= 50 To= 150 Duration= 0:0:5 / (np. w postaci przypisania) nie przyniesie rezultatu: void zmien(object o, RoutedEventArgs rea) { przycisk.Width = 200.0; } // kod metody przypisany do innego przycisku Kliknięcie tego innego przycisku, a zatem wywołanie metody, nie ma żadnego wpływu na wartość właściwości Width. Wynika to z faktu, że domyślne ustawienie właściwo- ści FillBehavior przechowuje wartość animacji nawet po zakończeniu jej działania. Aby rozwiązać ten problem, należy ustawić właściwość FillBehavior na Stop. Wtedy animacja nie będzie miała wpływu na właściwość po zakończeniu działania i zmiana się powiedzie. Co jednak zrobić, jeśli zależy nam, aby animacja była typu HoldEnd, a z drugiej strony musimy zmienić wartość tej właściwości? Wystarczy, że po jej za- kończeniu (najlepiej przed pożądaną zmianą wartości) usuniemy animację z obiektu Storyboard. Wystarczy nadać temu obiektowi nazwę: Storyboard Name= story i wywołać następującą metodę: void zmien(object o, RoutedEventArgs rea) { story.Remove(przycisk); przycisk.Width = 250.0; } Ostatnią interesującą właściwością jest SpeedRatio, czyli współczynnik, za pomocą którego możemy przyspieszyć lub spowolnić wykonywanie animacji. Domyślnie współ- czynnik ten ma wartość 1, wartość mniejsza od 1 oznacza spowolnienie, a większa — przyspieszenie. Po zapoznaniu się z pierwszym przykładem możemy przejść do omówienia różnych typów animacji; każdy z nich zostanie poparty typowym przykładem. Animacje podstawowe (From / To / By) Pierwszy przykład, z którym zapoznaliśmy się przed chwilą, jest najprostszym, pod- stawowym rodzajem animacji. Nazwa pochodzi od trzech właściwości, które odgrywają kluczową rolę w działaniu tej animacji (właściwość By określa całkowitą zmianę warto- ści właściwości, jaka zachodzi od początku do końca animacji — w naszym przykła- dzie miałaby ona wartość 100). WPF udostępnia 16 rodzajów animacji (do podanych nazw należy dodać słowo Animation): Rozdział 14. ♦ Animacje 189 (cid:141) Byte, Int16, Int32, Int64, Single, Double, Decimal — dokonuje zmiany zwykłej wartości liczbowej (całkowitej lub niecałkowitej). (cid:141) Color — wykonuje płynne przejście od jednego do drugiego koloru (w kodzie XAML można je określić jedynie za pomocą nazw — aplikacja sama znajdzie odpowiedni sposób przejścia). (cid:141) Point — wykonuje płynne przejście od jednego do drugiego punktu. (cid:141) Quaternion — wykonuje płynne przejście kwaternionu (obiektu reprezentującego obrót względem pewnego punktu w przestrzeni trójwymiarowej) między podanymi wartościami. (cid:141) Rect — dokonuje zmiany położenia i rozmiaru prostokąta. (cid:141) Rotation3D — animuje oś obrotu (w przestrzeni trójwymiarowej). (cid:141) Size, Thickness — animują rozmiar i grubość obramowań. (cid:141) Vector3D — animuje wartość i kierunek wektora trójwymiarowego. (cid:141) Vector — animuje wartość i kierunek wektora normalnego (dwuwymiarowego). Przy tego rodzaju animacjach do określenia sposobu animacji można wykorzysty- wać różnego rodzaju kombinacje właściwości From, To i By (nigdy nie wykorzystu- jemy wszystkich trzech właściwości naraz, gdyż nie ma to sensu). W przykładzie zastosowaliśmy połączenie właściwości From i To; pozostałe możliwe warianty są uwzględnione na poniższej liście: (cid:141) tylko właściwość From — animacja rozpoczyna się od wartości określonej we właściwości From aż do wartości, którą właściwość posiada domyślnie zadeklarowaną, (cid:141) tylko właściwość To — animacja rozpoczyna się od wartości domyślnie zadeklarowanej do wartości określonej we właściwości To, (cid:141) właściwości From i By — animacja rozpoczyna się od wartości określonej we właściwości From, a kończy wraz z wartością będącą sumą właściwości From i By — dla From=100 i By=300 animacja zakończy się wraz z wartością 400, (cid:141) właściwości To i By nie tworzą kombinacji, według której jest tworzona animacja — właściwość By jest ignorowana. Animacje z użyciem klatek kluczowych Powyższy sposób animowania jest niezwykle przyjazny dla programisty — nie trzeba się troszczyć o sposób przechodzenia od jednej wartości do drugiej. Z drugiej strony nie mamy możliwości, aby dokładnie kontrolować proces przebiegu animacji — np. zmieniać pośrednie stany, w jakich znajduje się obiekt w trakcie animacji. Dzięki ani- macji z użyciem klatek kluczowych możemy, właśnie za ich pomocą, definiować po- szczególne stany obiektu w ściśle określonych momentach czasowych, dzięki czemu zachowanie obiektów może być nieco bardziej złożone. 190 Część IV ♦ Zaawansowane zagadnienia graficzne Animacje klatkowe obsługują wszystkie typy obsługiwane przez animacje podstawo- we, dodatkowo wprowadzając cztery nowe typy (w ich przypadku nazwa klasy składa się z nazwy typu i słów AnimationUsingKeyFrames): (cid:141) Boolean — animuje klatki pomiędzy dwoma wartościami logicznymi (z uwagi na istnienie tylko dwóch wartości logicznych zmiany między klatkami są nagłe — nie ma płynnych przejść). (cid:141) Matrix — animuje transformację macierzy, która odpowiada za przekształcenie dwuwymiarowej przestrzeni. (cid:141) Object — animuje klatki pomiędzy wartościami różnych typów; z tego względu zmiany są dokonywane nagle (bez płynnego przejścia, podobnie jak w przypadku typu Boolean). (cid:141) String — animuje klatki zawierające łańcuchy znaków. Najistotniejsze znaczenie z nowo wprowadzonych powyższych typów ma String — bar- dzo często istnieje konieczność wykorzystania w animacji zwykłych tekstów, a ten ro- dzaj animacji to udostępnia. Zanim zajmiemy się przykładami, warto zapoznać się z inną ciekawą cechą tego rodzaju animacji — możliwością wyboru typu animacji klatkowej. Typy animacji klatkowych Istnieją trzy typy animacji klatkowych, które można stosować do różnych rodzajów animacji: (cid:141) Dyskretny — zmiany między klatkami następują w sposób nagły, nie występuje płynne przejście. Można go stosować dla wszystkich typów animacji, jednak efekty działania tych animacji zazwyczaj są niezadowalające. (cid:141) Linearny — zmiany następują w sposób płynny; animacja wygląda bardziej realnie niż w przypadku typu dyskretnego. Typ linearny można stosować jedynie w przypadku typów podstawowych, tj. z pominięciem typów wprowadzonych do animacji klatek kluczowych (Boolean, Matrix, Object i String). (cid:141) Krzywoliniowy — zmiany następują w sposób złożony, z wykorzystaniem krzywej Béziera (dokładny opis znajduje się poniżej). Można go stosować w tych samych przypadkach co typ linearny. Najbardziej interesujący wydaje się oczywiście typ krzywoliniowy. Szybkość zmian w takiej animacji jest wykonywana na podstawie krzywej Béziera, którą definiuje pro- gramista. Krzywą Béziera definiuje się za pomocą tzw. punktów kontrolnych (poza punktem początkowym i końcowym, jak w przypadku każdego odcinka). W przypad- ku tej animacji punkty początkowy i końcowy są zdefiniowane odgórnie — lewy dolny (0,0) i prawy górny (1,1). Zadaniem programisty jest zdefiniowanie punktów (w od- niesieniu do dwóch istniejących w każdym przypadku), aby na ich podstawie została utworzona krzywa Béziera, która będzie miała wpływ na szybkość odtwarzanej animacji. Przykład takiej krzywej, wraz z zaznaczonymi punktami znajduje się na rysunku 14.1. Rozdział 14. ♦ Animacje Rysunek 14.1. Krzywa Béziera (ze stałymi punktami (0;0) i (1;1)) 191 W momencie, gdy krzywa zbliża się do linii poziomej, szybkość animacji maleje; gdy krzywa zaczyna przypominać linię pionową, szybkość wzrasta. Krzywą deklaruje się dla każdej klatki animacji; początek i koniec krzywej oznaczają początek i koniec od- twarzania klatki. W niniejszym podrozdziale rozpatrzymy animację klatkową na przykładzie klasy Strin- gAnimationUsingKeyFrames. Napis WPF najlepsze jest będzie pojawiał się w następują- cy sposób: najpierw pojedynczo będą wyświetlane litery WPF, a następnie pojawią się kolejne wyrazy napisu. Każda animacja klatkowa składa się z wielu elementów, a nie tak jak w przypadku animacji podstawowej — tylko z jednego znacznika. Zawiera ona szereg obiektów klasy o nazwie zgodnej ze schematem typ_animacji typ_klatki KeyFrame. W naszym przykładzie wykorzystamy animację dyskretną i związaną z tekstem, więc nazwa klasy zastosowanych klatek to DiscreteStringKeyFrame. Każda z klas-klatek zawiera dwie kluczowe właściwości — KeyTime, określającą czas, w którym animowana właściwość ma przyjąć stosowną wartość, i Value — definiującą tę wartość. Dodatkowo w animacji krzywoliniowej należy zdefiniować punkty kontrol- ne krzywej Béziera, co można zrobić za pomocą właściwości KeySpline. Przechowuje ona kolekcję punktów, które w języku XAML deklaruje się w następujący sposób: KeySpline= x1,y1 x2,y2 Należy też pamiętać, że układ współrzędnych stosowany przy deklarowaniu punktów dla tej właściwości jest identyczny z kartezjańskim, różny zaś od znanego i stosowane- go przy określaniu współrzędnych na ekranie ((0;0) stanowi lewy dolny róg prostokąta, w którym możemy określać współrzędne, a nie lewy górny). Przykład wykorzystuje przycisk znany z poprzedniego fragmentu kodu; animacja będzie związana z właściwością Content przycisku, tak więc będzie modyfikowała tekst na nim wyświetlany: Button Name= przycisk Width= 200 Height= 70 Button.Triggers EventTrigger RoutedEvent= Button.Click BeginStoryboard Storyboard x:Name= story StringAnimationUsingKeyFrames Storyboard.TargetName= przycisk Storyboard. TargetProperty= Content Duration = 0:0:5 DiscreteStringKeyFrame KeyTime= 0:0:0.5 Value= W / 192 Część IV ♦ Zaawansowane zagadnienia graficzne DiscreteStringKeyFrame KeyTime= 0:0:1 Value= WP / DiscreteStringKeyFrame KeyTime= 0:0:1.5 Value= WPF / DiscreteStringKeyFrame KeyTime= 0:0:2.5 Value= WPF najlepsze / DiscreteStringKeyFrame KeyTime= 0:0:3.5 Value= WPF najlepsze jest! / /StringAnimationUsingKeyFrames /Storyboard /BeginStoryboard /EventTrigger /Button.Triggers /Button Pierwsze trzy litery pojawiają się w tempie dwa razy szybszym od wyrazów, które są wyświetlane później. Warto również przetestować powyższy kod z uwzględnieniem właściwości FillBehavior, RepeatBehavior i AutoReverse. Odstępy czasowe pozostają bez zmian (czyli w przypadku odwrócenia animacji dwa pierwsze słowa będą znikać w odstępie sekundy, a litery w tempie dwa razy szybszym). Zachowanie tego typu animacji jest podobne do linearnej, gdyż można powiedzieć, że animacja linearna jest animacją dyskretną o niezmiernie dużej liczbie klatek, generowanych automatycznie na bieżąco przez aplikację — stąd podobieństwo w działaniu obu animacji. Przykład animacji krzywoliniowej zaprezentuję, wykorzystując ponownie właściwość Width, ponieważ działa ona tylko na właściwościach typów, które obowiązują w ani- macji podstawowej. Do tej animacji wykorzystamy krzywą Béziera, zaprezentowaną na rysunku 14.1. Kod animacji wygląda następująco: Button Name= przycisk Width= 50 Height= 70 Button.Triggers EventTrigger RoutedEvent= Button.Click BeginStoryboard Storyboard x:Name= story DoubleAnimationUsingKeyFrames Storyboard.TargetName= przycisk Storyboard. TargetProperty= Width Duration= 0:0:5 SplineDoubleKeyFrame KeyTime= 0:0:5 Value= 250 KeySpline= 0.08,0.94 0.88,0.09 / /DoubleAnimationUsingKeyFrames /Storyboard /BeginStoryboard /EventTrigger /Button.Triggers /Button Szerokość jest animowana od wartości 50 do 250, a więc zwiększa się pięciokrotnie. Na początku zmiana szerokości jest bardzo szybka, blisko środka animacji zwalnia, po czym znowu przyspiesza. Naszą uwagę powinna skupić deklaracja właściwości Key- Spline. Dwa punkty, pochodzące z rysunku 14.1, zostały zadeklarowane w określonej kolejności — i nie można jej zmieniać, gdyż spowodowałoby to efekt odwrotny do za- mierzonego — tempo animacji byłoby wolne na początku, zaś szybkie w jej środku (nastąpiłoby przekształcenie krzywej Béziera). Istnieje możliwość łączenia animacji różnych typów. Poniższy przykład zawiera klatki wszystkich trzech typów animacji (pozostały kod jest taki sam jak w poprzednim przy- kładzie, więc nie umieszczam go ponownie): Rozdział 14. ♦ Animacje 193 DoubleAnimationUsingKeyFrames Storyboard.TargetName= przycisk Storyboard. TargetProperty= Width Duration= 0:0:10 LinearDoubleKeyFrame KeyTime= 0:0:2 Value= 100 / SplineDoubleKeyFrame KeyTime= 0:0:6 Value= 250 KeySpline= 0.08,0.94 0.88,0.09 / DiscreteDoubleKeyFrame KeyTime= 0:0:10 Value= 300 / /DoubleAnimationUsingKeyFrames Przez pierwsze dwie sekundy animacja w stałym tempie podwaja swoją wartość. Na- stępnie w ciągu czterech sekund zachodzą kolejno procesy przyspieszania, spowolniania i ponownie przyspieszania — jak w poprzednim przykładzie, tylko tym razem na nie- co mniejszej szerokości. Następnie animacja zatrzymuje swe działanie i po czterech sekundach przycisk nagle zmienia swoją szerokość, jednocześnie wypełniając całe okno (które ma również 300 pikseli). Jeśli nie znamy dokładnych wartości czasu, w jakich chcemy wprowadzać nowe klatki, a znamy jedynie proporcje czasowe między nimi (np. odstęp między pierwszą a drugą klatką jest dwa razy mniejszy niż między drugą a trzecią), warto podawać wartość właściwości KeyTime w procentach. Wtedy odstęp między klatkami jest proporcjonal- ny, a aby zmienić faktyczne odstępy czasowe, wystarczy manipulować właściwością Duration obiektu animacji. Aby uzyskać taki sam efekt jak w powyższym przykładzie, stosując wartości procentowe, należałoby wykonać małe obliczenia: (2s/10s) * 100 = 20 (6s/10s) * 100 = 60 (10s/10s) * 100 = 100 Istnieją jeszcze dwie specjalne wartości, jakie możemy wykorzystywać przy podawaniu wartości właściwości KeyTime. Jeśli chcemy, aby odstęp pomiędzy wszystkimi klatkami był taki sam, musimy nadać im wartość Uniform: DoubleAnimationUsingKeyFrames Storyboard.TargetName= przycisk Storyboard. TargetProperty= Width Duration= 0:0:10 LinearDoubleKeyFrame KeyTime= Uniform Value= 100 / SplineDoubleKeyFrame KeyTime= Uniform Value= 250 KeySpline= 0.08,0.94 0.88,0.09 / DiscreteDoubleKeyFrame KeyTime= Uniform Value= 300 / /DoubleAnimationUsingKeyFrames Na każdą klatkę przypada 10/3, czyli ok. 3,3 sekundy. Możliwe jest jednak łączenie wartości Uniform z tradycyjnymi wartościami KeyTime. Zanalizujmy następującą sekwen- cję klatek: LinearDoubleKeyFrame KeyTime= Uniform Value= 100 / SplineDoubleKeyFrame KeyTime= Uniform Value= 250 KeySpline= 0.08,0.94 0.88,0.09 / DiscreteDoubleKeyFrame KeyTime= 10 Value= 300 / DiscreteDoubleKeyFrame KeyTime= 50 Value= 275 / Jej działanie jest następujące — obydwa płynne przejścia następują bardzo szybko (każde z nich zajmuje (100-90)/2) =5 , tak więc na każde przypada po 0,5 sekundy), gdyż pierwsza z klatek o zadeklarowanym czasie wywołania jest ustawiona bardzo wcze- śnie (już na początek drugiej sekundy). Następnie, po kolejnych czterech sekundach, szerokość jest minimalnie zmniejszana. 194 Część IV ♦ Zaawansowane zagadnienia graficzne Kolejną specjalną wartością dla właściwości KeyTime jest Paced. Stosowanie jej spra- wia, że animacja przebiega w jednym, stałym tempie, które jest wypadkową prędko- ści odtwarzania animacji wszystkich klatek. Stosowanie tej wartości ma sens tylko w przypadku klatek linearnych. Należy pamiętać, że jeśli pierwsza klatka ze wszystkich będzie miała właściwość KeyTime ustawioną na Paced, zostanie ona odtworzona od razu (efekt taki sam jak w przypadku ustawienia właściwości KeyTime=0:0:0). Animacje z użyciem ścieżki Animacje tego typu do animowania wykorzystują ścieżki, czyli krzywe określone przez szereg wyznaczonych przez programistę punktów. Tak jak w animacjach From, To, By pierwsze skrzypce grają właśnie te właściwości, a w animacjach klatkowych — klatki kluczowe, tak w tym przypadku najważniejszą właściwością animacji jest PathGeometry, definiująca zestaw punktów mających wpływ na wykonanie animacji. WPF udostępnia trzy rodzaje animacji ścieżkowych (nazwa składa się z typu i słów AnimationUsingPath): (cid:141) Double — animuje właściwość na podstawie jednej ze współrzędnych punktu, (cid:141) Point — animuje właściwość na podstawie obydwu współrzędnych (całego punktu), (cid:141) Matrix — animuje właściwość z wykorzystaniem transformacji macierzowej (MatrixTransform). Skupimy się na dwóch pierwszych animacjach, gdyż są one najpopularniejsze. Najbar- dziej oczywistym rodzajem animacji wydaje się punktowa — przecież poszczególne fragmenty ścieżki są definiowane za pomocą punktów. W trakcie animacji między kolejnymi punktami ścieżki aktualny punkt jest pobierany i przypisywany do animo- wanej właściwości. Dzieje się tak np. w poniższym przykładzie: Button Content= Przycisk Width= 100 Height= 100 Name= przycisk Button.Background RadialGradientBrush x:Name= pedzel Center= 0.5,0.5 RadiusX= 0.5 RadiusY= 0.5 GradientStop Color= White Offset= 0.0 / GradientStop Color= Red Offset= 2.0 / /RadialGradientBrush /Button.Background Button.Triggers EventTrigger RoutedEvent= Button.Click BeginStoryboard Storyboard PointAnimationUsingPath Storyboard.TargetName= pedzel Storyboard.TargetProperty= Center Duration= 0:0:5 PointAnimationUsingPath.PathGeometry PathGeometry PathFigure StartPoint= 0.5,0.5 LineSegment Point= 0.1,0.3 / LineSegment Point= 0.7,0.9 / /PathFigure Rozdział 14. ♦ Animacje 195 /PathGeometry /PointAnimationUsingPath.PathGeometry /PointAnimationUsingPath /Storyboard /BeginStoryboard /EventTrigger /Button.Triggers /Button W powyższym kodzie główne znaczenie mają dwie sekcje — pierwsza, odpowiedzialna za deklarację pędzla promienistego, i druga, związana z animacją ścieżkową. Deklaracja pędzla zawiera dwa istotne elementy — definicję właściwości Center (którą wykorzystu- jemy w animacji) oraz nazwy obiektu. Proszę zauważyć, że klasa RadialGradientBrush nie udostępnia właściwości Name, zazwyczaj stosowanej w tym celu. Musimy więc wy- korzystać konstrukcję języka XAML, która da nam ten sam efekt. Jest to potrzebne, gdyż w animacji musimy podać nazwę obiektu, którego właściwość chcemy animować. Najistotniejszym obiektem jest oczywiście figura (w istocie trójkąt), po której bokach będzie animowany środek pędzla. Można oczywiście zastosować segment krzywej Béziera, dzięki czemu sposób poruszania się pędzla będzie bardziej urozmaicony. Nieco bardziej skomplikowana jest animacja typu Double. Ogólne zasady działania tej animacji są takie same jak w przypadku animacji punktowej, jednak należy rozważyć jedną różnicę — animacja Double wykorzystuje jedną wartość, podczas gdy punkt składa się z dwóch współrzędnych. Koniecznym staje się więc określenie, która z właściwo- ści punktu pobieranego z animacji ma być przypisywana do animowanej właściwości. Służy do tego celu właściwość Source, zdefiniowana w klasie animacji DoubleAnimation- UsingPath. Przyjmuje ona jedną z trzech wartości typu wyliczeniowego, które umożli- wiają pobieranie różnych wartości z animowanego punktu: (cid:141) X — pobiera współrzędną X (wartość domyślna), (cid:141) Y — pobiera współrzędną Y, (cid:141) Angle — określa tangens kąta obrotu. Pozostała treść animacji się nie zmienia, tak więc nie będzie widać zbyt dużych różnic między poprzednim a poniższym kodem: DoubleAnimationUsingPath Storyboard.TargetName= pedzel Source= X Storyboard. TargetProperty= RadiusX Duration= 0:0:5 DoubleAnimationUsingPath.PathGeometry PathGeometry PathFigure StartPoint= 0.5,0.5 LineSegment Point= 0.1,0.0 / LineSegment Point= 1.0,0.3 / /PathFigure /PathGeometry /DoubleAnimationUsingPath.PathGeometry /DoubleAnimationUsingPath Najistotniejszą różnicą jest wykorzystanie właściwości Source, a także zmiana animo- wanej właściwości — Center jest typu Point, wobec czego zmieniliśmy ją na właściwość bardziej stosowną do sytuacji. 196 Część IV ♦ Zaawansowane zagadnienia graficzne Wiele animacji w jednej Istnieje możliwość umieszczenia dwóch lub większej liczby animacji w jednej. Wystar- czy umieścić więcej niż jeden obiekt animacji w obiekcie Storyboard: Storyboard DoubleAnimation Storyboard.TargetName= przycisk Storyboard.TargetProperty= Width From= 100 To= 150 Duration= 0:0:10 / DoubleAnim
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C#. Tworzenie aplikacji graficznych w .NET 3.0
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: