Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00507 009823 10436482 na godz. na dobę w sumie
Silverlight. Od podstaw - książka
Silverlight. Od podstaw - książka
Autor: , Liczba stron: 208
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1984-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Silverlight -- nowy sposób na tworzenie aplikacji internetowych

Technologia Silverlight, opracowana przez Microsoft, jest propozycją dla tych, którzy przymierzają się do projektowania aplikacji internetowych lub zajmują się tym już od jakiegoś czasu, a chcieliby poszerzyć spektrum swoich umiejętności. Do podstawowych zalet tej technologii należą prostota jej używania oraz ogromna elastyczność -- oprócz języka XAML, służącego do opisania interfejsu użytkownika, twórca aplikacji może posługiwać się dowolnym językiem programowania, dostępnym dla platformy .NET. Gotowe programy przygotowane w Silverlight są kompatybilne z większością przeglądarek, zainstalowanych na różnych platformach.

Książka 'Silverlight. Od podstaw' zawiera wszelkie informacje na temat najnowszej wersji tej technologii. Znajdziesz tu opis tego środowiska programistycznego, jego funkcjonalności oraz narzędzi, które musisz zainstalować, by móc sprawnie korzystać z Silverlight. Poznasz także zasady tworzenia nowych projektów i całą masę przykładów konkretnych rozwiązań. Wszystko to uzupełnione zostało licznymi zrzutami ekranu, ilustrującymi niemal każdy krok oraz efekty działania podanego kodu. Jeśli chcesz nauczyć się projektować aplikacje internetowe w Silverlight, nie znajdziesz lepszej książki!

Otwórz się na nowe możliwości. Wypróbuj Silverlight!

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

Darmowy fragment publikacji:

Silverlight. Od podstaw Autor: Pawe³ Maciejewski, Pawe³ Redmerski ISBN: 978-83-246-1984-9 Tytu³ orygina³u: COM+ Developer s Guide Format: 158x235, stron: 208 Silverlight — nowy sposób na tworzenie aplikacji internetowych • Jak tworzyæ aplikacje internetowe za pomoc¹ Silverlight? • Jakie mo¿liwoœci kryj¹ siê w tej technologii? • W jaki sposób po³¹czyæ ró¿ne elementy, by uzyskaæ wspania³y efekt? Technologia Silverlight, opracowana przez Microsoft, jest propozycj¹ dla tych, którzy przymierzaj¹ siê do projektowania aplikacji internetowych lub zajmuj¹ siê tym ju¿ od jakiegoœ czasu, a chcieliby poszerzyæ spektrum swoich umiejêtnoœci. Do podstawowych zalet tej technologii nale¿¹ prostota jej u¿ywania oraz ogromna elastycznoœæ — oprócz jêzyka XAML, s³u¿¹cego do opisania interfejsu u¿ytkownika, twórca aplikacji mo¿e pos³ugiwaæ siê dowolnym jêzykiem programowania, dostêpnym dla platformy .NET. Gotowe programy przygotowane w Silverlight s¹ kompatybilne z wiêkszoœci¹ przegl¹darek, zainstalowanych na ró¿nych platformach. Ksi¹¿ka „Silverlight. Od podstaw” zawiera wszelkie informacje na temat najnowszej wersji tej technologii. Znajdziesz tu opis tego œrodowiska programistycznego, jego funkcjonalnoœci oraz narzêdzi, które musisz zainstalowaæ, by móc sprawnie korzystaæ z Silverlight. Poznasz tak¿e zasady tworzenia nowych projektów i ca³¹ masê przyk³adów konkretnych rozwi¹zañ. Wszystko to uzupe³nione zosta³o licznymi zrzutami ekranu, ilustruj¹cymi niemal ka¿dy krok oraz efekty dzia³ania podanego kodu. Jeœli chcesz nauczyæ siê projektowaæ aplikacje internetowe w Silverlight, nie znajdziesz lepszej ksi¹¿ki! • Zasady dzia³ania technologii Silverlight • Silverlight a platforma .NET • Programowanie w jêzyku XAML • U¿ywanie kontrolek interfejsu • Pozycjonowanie za pomoc¹ kontenerów • Wykorzystywanie grafiki • Integracja z multimediami • Obs³uga zdarzeñ • Tworzenie animacji • Stosowanie stylów i szablonów Otwórz siê na nowe mo¿liwoœci. Wypróbuj Silverlight! Spis treści Rozdział 1. Wprowadzenie .................................................................................. 7 Czym jest Silverlight ........................................................................................................ 7 Silverlight jest aplikacją RIA ..................................................................................... 7 Silverlight nie jest drugim Flashem ............................................................................ 7 Silverlight jest multimedialny .................................................................................... 8 Silverlight jest multiplatformowy ............................................................................... 8 Silverlight jest łatwy ................................................................................................... 8 Do kogo kierowana jest ta książka? .................................................................................. 9 Co Czytelnik będzie potrafił po przeczytaniu książki? ..................................................... 9 Miejsce Silverlight w platformie .NET ........................................................................... 10 Narzędzia ........................................................................................................................ 10 Niezbędne narzędzia ................................................................................................ 10 Narzędzia dodatkowe ............................................................................................... 13 Specyfika projektów Silverlight ..................................................................................... 15 Tworzenie nowego projektu ..................................................................................... 15 Osadzanie obiektu Silverlight na stronie HTML ...................................................... 16 Zawartość solucji projektu Silverlight ...................................................................... 18 Kilka słów o strukturze skompilowanego projektu Silverlight ................................. 19 Jak korzystać z przykładów dołączonych do książki? .................................................... 20 Rozdział 2. Język XAML ................................................................................... 23 Obiekty i ich własności ................................................................................................... 23 Tagi .......................................................................................................................... 23 Obiekty ..................................................................................................................... 24 Właściwości ............................................................................................................. 25 Składnia atrybutowa własności ................................................................................ 25 Składnia elementów właściwości ............................................................................. 26 Składnia mieszana .................................................................................................... 27 Atrybuty dołączone .................................................................................................. 27 Korzeń dokumentu ......................................................................................................... 29 Znacznik UserControl .............................................................................................. 29 Własność Content ..................................................................................................... 30 Domyślna przestrzeń nazw ....................................................................................... 30 Dodatkowe przestrzenie nazw .................................................................................. 31 Dodatkowa przestrzeń nazw „x” .............................................................................. 32 4 Silverlight. Od podstaw Własności domyślne ....................................................................................................... 33 Domyślna własność znacznika ................................................................................. 33 Korzyści wynikające ze stosowania własności domyślnej ....................................... 34 Modele zawartości .................................................................................................... 35 Drzewo zależności .................................................................................................... 37 Zasada ciągłości własności domyślnej ..................................................................... 38 Niejawna konwersja typów ............................................................................................. 39 Prosta konwersja typów ............................................................................................ 39 Konwersja złożona ................................................................................................... 40 Zdarzenia ........................................................................................................................ 42 Przypisanie zdarzenia ............................................................................................... 42 Obsługa zdarzenia .................................................................................................... 43 Rozszerzenia znaczników ............................................................................................... 44 Składnia rozszerzeń znaczników .............................................................................. 44 Definiowanie i korzystanie z zasobów ..................................................................... 45 Wiązanie danych ...................................................................................................... 47 Rozdział 3. Kontrolki interfejsu ......................................................................... 53 Właściwości kontrolek ................................................................................................... 54 TextBox .......................................................................................................................... 57 PasswordBox .................................................................................................................. 59 CheckBox ....................................................................................................................... 60 RadioButton .................................................................................................................... 61 Kontrolki typu Button ..................................................................................................... 63 ToggleButton ............................................................................................................ 63 HyperlinkButton ....................................................................................................... 64 TextBlock ....................................................................................................................... 66 Slider .............................................................................................................................. 68 ScrollBar i ScrollViewer ................................................................................................ 69 ToolTip ........................................................................................................................... 71 ProgressBar .................................................................................................................... 73 Border ............................................................................................................................. 74 ComboBox ...................................................................................................................... 76 ListBox ........................................................................................................................... 77 Kontrolki z biblioteki System.Windows.Controls .......................................................... 79 TabControl ............................................................................................................... 80 Calendar i DatePicker ............................................................................................... 82 DataGrid ................................................................................................................... 84 Rozdział 4. Kontenery i pozycjonowanie ............................................................ 91 Pozycjonowanie relatywne ............................................................................................. 92 Marginesy ................................................................................................................. 92 Wyrównanie elementów ........................................................................................... 93 StackPanel ...................................................................................................................... 97 Określenie orientacji panelu ..................................................................................... 97 Grid ................................................................................................................................ 98 Definiowanie wierszy i kolumn ................................................................................ 98 Wielkości kolumn i wierszy ..................................................................................... 99 Wkładanie elementów do komórek ........................................................................ 100 Scalanie komórek ................................................................................................... 101 Inne właściwości siatki ........................................................................................... 102 Canvas .......................................................................................................................... 104 Canvas.Left i Canvas.Right .................................................................................... 104 Canvas.ZIndex ....................................................................................................... 106 Spis treści 5 Kontenery z poziomu kodu ........................................................................................... 108 Generowanie kontrolek .......................................................................................... 108 Generowanie kontenerów ....................................................................................... 109 Rozdział 5. Grafika i multimedia ..................................................................... 115 Pędzle (ang. Brushes) ................................................................................................... 115 SolidColorBrush ..................................................................................................... 116 LinearGradientBrush .............................................................................................. 117 RadialGradientBrush .............................................................................................. 119 ImageBrush ............................................................................................................ 120 VideoBrush ............................................................................................................ 122 Kształty ......................................................................................................................... 123 Ellipse ..................................................................................................................... 124 Rectangle ................................................................................................................ 125 Line ........................................................................................................................ 125 Polyline .................................................................................................................. 126 Polygon .................................................................................................................. 127 Geometrie ..................................................................................................................... 128 Atrybuty geometrii prostych ................................................................................... 129 Geometrie zastosowane do przycinania obiektów UIElement ................................ 129 Geometrie zastosowane w obiekcie Path ................................................................ 130 PathGeometry ......................................................................................................... 130 Atrybutowa składnia ścieżek (ang. Path Markup Syntax) ...................................... 133 Przekształcenia graficzne ............................................................................................. 134 Clip ......................................................................................................................... 134 OpacityMask .......................................................................................................... 136 RenderTransform ................................................................................................... 139 Kontrolki multimedialne ............................................................................................... 143 Image ...................................................................................................................... 143 MediaElement ........................................................................................................ 143 MultiScaleImage .................................................................................................... 145 Rozdział 6. Zdarzenia w Silverlighcie .............................................................. 147 Zdarzenia wejścia ......................................................................................................... 147 Zdarzenia myszki ................................................................................................... 147 Zdarzenia klawiatury .............................................................................................. 151 Zdarzenia aplikacji ....................................................................................................... 153 Fokus aplikacji i kontrolki ...................................................................................... 154 GotFocus i LostFocus ............................................................................................. 154 Loaded .................................................................................................................... 155 SizeChanged ........................................................................................................... 156 Zdarzenia trasowane ..................................................................................................... 156 Tunelowanie zdarzeń .............................................................................................. 156 Przykładowa aplikacja ............................................................................................ 157 Własność Handled .................................................................................................. 158 Rozdział 7. Animacje ..................................................................................... 159 Tworzenie animacji ...................................................................................................... 159 Scenariusze ............................................................................................................. 159 Podstawowe animacje ................................................................................................... 161 Animacje typu From/To/By ................................................................................... 162 Animowane własności ............................................................................................ 164 Kontrolowanie animacji ......................................................................................... 168 Animacje z klatkami kluczowymi ................................................................................ 173 Animacje używające klatek .................................................................................... 173 Klatki kluczowe ..................................................................................................... 175 6 Silverlight. Od podstaw Rozdział 8. Style i szablony ............................................................................ 183 Definiowanie stylów ..................................................................................................... 183 Słowniki zasobów .................................................................................................. 184 Pierwszy styl .......................................................................................................... 184 Definiowanie szablonów .............................................................................................. 187 Budowanie szablonu .............................................................................................. 190 Model części i stanów (ang. Parts and States Model) ............................................. 190 Visual State Manager ............................................................................................. 191 Pierwszy szablon .................................................................................................... 193 Skorowidz .................................................................................... 199 Rozdział 4. Kontenery i pozycjonowanie W poprzednim rozdziale zostały omówione szczegółowo kontrolki dostępne w Silverlighcie. Znajomość szerokiego wachlarza kontrolek, które oferuje technologia, jest niezmierne ważna, ale nie wystarczy do napisania aplikacji silverlightowej z poprawnym (przyja- znym dla użytkownika) interfejsem. Aby było to możliwe, należy rozumieć, jak działa pozycjonowanie elementów wizualnych w technologii Silverlight, które jest tematem tego rozdziału. Pozycjonowanie kontrolek odbywa się przy pomocy tzw. kontenerów (ang. containers). Są one niewidocznymi obiektami, których jedynym zadaniem jest pozycjonowanie kon- trolek (lub innych kontenerów). Tylko elementy będące wewnątrz kontenera mogą być przezeń pozycjonowane (patrz: rozdział 2., „Drzewo zależności”). Pozycjonowanie ele- mentów odbywa się zatem m.in. przez wkładanie ich do kontenerów. To jednak nie wszystko. Kontener musi mieć określone pewne własności, które determinują sposób, w jaki pozycjonuje on elementy w jego wnętrzu. W końcu pozycjonowany element może mieć pewne dołączone atrybuty, które wpływają na jego pozycję. Podsumowując, pozycję obiektu określają: (cid:141) zależność rodzic-dziecko (element pozycjonowany musi być wewnątrz kontenera), (cid:141) właściwości kontenera (np. Orientation panelu stosu), (cid:141) atrybuty dołączone do elementu pozycjonowanego (np. Canvas.Left). W polskiej literaturze można się spotkać z tłumaczeniem słowa „containers” jako „pojemniki”. W naszej książce pozostaniemy przy określeniu „kontenery”. W pierwszej kolejności omówimy metody pozycjonowania elementów graficznych w Si- lverlighcie. Następnie omówimy zasady pozycjonowania absolutnego i relatywnego. Oby- dwie zasady pozycjonowania elementów sprowadzają się w większości przypadków do wybrania właściwego kontenera oraz nadania odpowiednich wartości jego własnościom (a także własnościom dołączonym do jego dzieci). Z racji tego, że w Silverlighcie progra- mista ma dostęp do trzech różnych kontenerów: 92 Silverlight. Od podstaw (cid:141) panelu stosu StackPanel, (cid:141) siatki Grid, (cid:141) płótna Canvas, omówimy po kolei każdy z nich oraz pokażemy najbardziej typowe zastosowania. Silverlight posiada tylko trzy kontenery, podczas gdy WPF ma ich aż siedem (StackPanel, Grid, Canvas, UniformGrid, WrapPanel, DockPanel, TabControl). Wraz z rozwojem technologii Silverlight powinny się w niej pojawiać kontenery, których brakuje w sto- sunku do WPF. Pozycjonowanie relatywne Marginesy Każdy obiekt klasy FrameworkElement posiada własność Margin, czyli margines. Przy- pisując margines obiektowi, programista określa, jaki odstęp dzieli go od innych elemen- tów interfejsu. Obiekty typu FrameworkElement posiadają własność Margin, ale nie mają własności Padding. Istnieje natomiast kontrolka (opisana w rozdziale 3.), która posiada zarówno tę, jak i inne własności mające wpływ na wyświetlanie elementów graficznych na ekranie użytkownika. Tą kontrolką jest Border, która na liście członków klasy posiada własności: Margin, Padding, Background, BorderBrush, BorderThickness i inne, dzięki którym programista ma większą kontrolę nad tym, w jaki sposób są wyświetlane elementy wizualne Silverlighta. Podczas korzystania z marginesów należy pamiętać o trzech rzeczach: 1. addtywności, 2. sposobach zapisu, 3. ujemnych marginesach. Addytywnośæ Na rysunku 4.1 mamy pokazany zrzut ekranu przykładowej aplikacji (źródło można znaleźć w solucji /Rozdzial4.sln w pliku Margin.xaml). Na rysunku 4.1 kwadrat posiada margines równy 20 pikselom, natomiast koło ma margi- nes równy 50 pikselom. Addytywność marginesów przejawia się w tym, że są one do sie- bie dodawane podczas obliczania pozycji elementu graficznego na ekranie użytkownika. Dlatego odstęp pomiędzy kwadratem i kołem na rysunku 4.1 jest równy w sumie 70 pikselom. Rozdział 4. ♦ Kontenery i pozycjonowanie 93 Rysunek 4.1. Addywne działanie marginesów Różne sposoby zapisu Margines jest strukturą typu Thickness, którą już pokrótce omawialiśmy (patrz rozdział 2.). Zgodnie z tym, co wtedy wytłumaczyliśmy, marginesy można definiować w XAML-u na trzy różne sposoby. W ramach przypomnienia wszystkie zostały pokazane na listingu 4.1 (linijki od 1. do 3.). Listing 4.1. Przykłady definiowania marginesu 1 StackPanel x:Name= LayoutRoot Background= White Margin= 30 2 Rectangle Width= 100 Height= 100 Fill= Red Margin= 20 40 / 3 Ellipse Width= 100 Height= 100 Fill= Blue Margin= 50 10 5 15 / 4 /StackPanel Ujemne marginesy Czymś, o czym do tej pory jeszcze nie wspominaliśmy, są ujemne marginesy. Otóż w Silverlighcie istnieje możliwość definiowania marginesów o ujemnych wartościach. Tak jak dodatnie marginesy zwiększają odstęp pomiędzy elementami interfejsu, tak mar- ginesy ujemne go zmniejszają. Jeśli ujemny margines jest większy niż odległość dzieląca elementy, wtedy zaczynają one na siebie zachodzić (jeden przykrywa drugi), tak jak na rysunku 4.2. Wyrównanie elementów Każdy obiekt typu FrameworkElement posiada dwie własności: (cid:141) HorizontalAlignment, (cid:141) VerticalAlignment, 94 Rysunek 4.2. Nachodzenie na siebie elementów — wynik zastosowania ujemnych marginesów Silverlight. Od podstaw dzięki którym programista może określić jego wyrównanie. Własność HorizontalAlignment określa wyrównanie w poziomie, natomiast VerticalAlignment — wyrównanie w pionie. Na listingu 4.2 można zobaczyć użycie tych własności w XAML-u, a rysunek 4.3 przed- stawia efekt ich działania. Listing 4.2. Użycie podstawowych wartości własności HorizontalAlignment i VerticalAlignment 1 Grid x:Name= LayoutRoot Background= White 2 Rectangle Width= 100 Height= 100 3 HorizontalAlignment= Left VerticalAlignment= Top 4 Stroke= LightBlue StrokeThickness= 3 5 Rectangle.Fill 6 LinearGradientBrush 7 GradientStop Offset= 0 Color= DarkBlue / 8 GradientStop Offset= 1 Color= Cyan / 9 /LinearGradientBrush 10 /Rectangle.Fill 11 /Rectangle 12 Ellipse Width= 100 Height= 100 13 HorizontalAlignment= Center VerticalAlignment= Center 14 Stroke= Pink StrokeThickness= 3 15 Ellipse.Fill 16 LinearGradientBrush 17 GradientStop Offset= 0 Color= DarkRed / 18 GradientStop Offset= 1 Color= Red / 19 /LinearGradientBrush 20 /Ellipse.Fill 21 /Ellipse 22 Polygon Points= 50,75 0,0 100,0 23 HorizontalAlignment= Right VerticalAlignment= Bottom 24 Stroke= LightGreen StrokeThickness= 3 25 Polygon.Fill 26 LinearGradientBrush 27 GradientStop Offset= 0 Color= Green / 28 GradientStop Offset= 1 Color= LightGreen / 29 /LinearGradientBrush 30 /Polygon.Fill 31 /Polygon 32 /Grid Rozdział 4. ♦ Kontenery i pozycjonowanie 95 Rysunek 4.3. Demonstracja działania podstawowych wartości własności pozycjonujących Własność HorizontalAlignment posiada wartości: (cid:141) Left — wyrównanie do lewej strony, (cid:141) Center — wycentrowanie w poziomie, (cid:141) Right — wyrównanie do prawej strony, (cid:141) Stretch — wyrównanie w pionie. Analogicznie, VerticalAlignment przyjmuje wartości: (cid:141) Top — wyrównanie do góry, (cid:141) Middle — wyśrodkowanie w pionie, (cid:141) Bottom — wyrównanie do dołu, (cid:141) Stretch — wyrównanie w poziomie. W kodzie programu z listingu 4.2 nie użyliśmy jednej z wartości, która jest wspólna dla obu własności (zarówno HorizontalAlignment, jak i VerticalAlignment). Mowa tutaj o wartości Stretch. Stretch jest wartością, która mówi, aby obiekt został rozciągnięty w danym kierunku. Innymi słowy, przypisanie obiektowi własności HorizontalAlignment=”Stretch” sprawi, że zabierze on całe dostępne miejsce w poziomie. Listing 4.3 pokazuje wykorzystanie wartości Stretch (rysunek 4.4 przedstawia zrzut ekranu aplikacji). Listing 4.3. Wykorzystanie własności Stretch 1 Grid x:Name= LayoutRoot Background= White 2 Rectangle HorizontalAlignment= Stretch VerticalAlignment= Stretch 3 Stroke= LightBlue StrokeThickness= 3 4 Rectangle.Fill 5 LinearGradientBrush 96 Silverlight. Od podstaw Listing 4.3. Wykorzystanie własności Stretch — ciąg dalszy 6 GradientStop Offset= 0 Color= DarkBlue / 7 GradientStop Offset= 1 Color= Cyan / 8 /LinearGradientBrush 9 /Rectangle.Fill 10 /Rectangle 11 Ellipse Stroke= Pink StrokeThickness= 3 12 Ellipse.Fill 13 LinearGradientBrush 14 GradientStop Offset= 0 Color= DarkRed / 15 GradientStop Offset= 1 Color= Red / 16 /LinearGradientBrush 17 /Ellipse.Fill 18 /Ellipse 19 Button Content= Przycisk Height= 70 20 HorizontalContentAlignment= Stretch 21 VerticalAlignment= Stretch / 22 /Grid Rysunek 4.4. Działanie wartości Stretch Proszę zwrócić uwagę na to, że w linijce 11. listingu 4.3 elipsa nie ma nadanej ani własno- ści HorizontalAlignment, ani VerticalAlignment, a pomimo tego zostanie ona rozcią- gnięta (jak widać na rysunku 4.4). Dzieje się tak dlatego, że wartość Stretch jest domyślną wartością zarówno dla HorizontalAlignment, jak i VerticalAlignment. Własności Width i Height obiektów typu FrameworkElement mają wyższy priorytet niż wartość Stretch własności pozycjonujących. W przypadku gdy określimy wielkość obiektu w pionie lub poziomie, wartość Stretch nie ma znaczenia. Tak też jest w przypadku przycisku z listingu 4.3 (linijka 19. i 20.). Ma on określoną wysokość, dlatego zajmuje całe miejsce w poziomie. Rozdział 4. ♦ Kontenery i pozycjonowanie 97 StackPanel StackPanel, czyli inaczej panel stosu, to najprostszy z kontenerów dostępnych w Silverli- ghcie. Elementy znajdujące się w jego wnętrzu są rozmieszczane wzdłuż jednej z prostych (albo pionowej, albo poziomej), którą nazywa się orientacją. Elementy znajdujące się wewnątrz panelu stosu są wyświetlane w określonej kolejności. W przypadku orientacji poziomej elementy są wyświetlane od strony lewej do prawej. Gdy StackPanel ma orientację pionową, wtedy wyświetlane są od góry do dołu. Określenie orientacji panelu Własność Orientation określa orientację panelu stosu i może przyjmować dwie wartości: (cid:141) Vertical (domyślnie) — orientacja pionowa („jeden element pod drugim”), (cid:141) Horizontal — orientacja pozioma („jeden element obok drugiego”). W solucji /Rozdzial4.sln w pliku /StackPanelOrientation.xaml można znaleźć kod przy- kładowej aplikacji. Listing 4.4 pokazuje fragment kodu tego programu, w którym widać działanie panelu stosu z wykorzystaniem własności Orientation. Rysunek 4.5 przedstawia zrzut ekranu aplikacji. Listing 4.4. Użycie własności Orientation panelu stosu 1 StackPanel x:Name= LayoutRoot Background= White 2 StackPanel Orientation= Horizontal 3 Rectangle Width= 125 Height= 125 Fill= #BBBBBB / 4 Rectangle Width= 125 Height= 125 Fill= #EEEEEE / 5 Rectangle Width= 125 Height= 125 Fill= #BBBBBB / 6 /StackPanel 7 StackPanel 8 Rectangle Width= 125 Height= 125 Fill= #BBBBBB / 9 Rectangle Width= 125 Height= 125 Fill= #888888 / 10 /StackPanel 11 /StackPanel Jak można zobaczyć na listingu 4.4, w przykładowej aplikacji mamy trzy panele stosu: (cid:141) Panel nadrzędny o nazwie LayoutRoot — przechowuje inne dwa panele stosu. Pozycjonuje je wzdłuż pionowej linii („jeden pod drugim”). Nie ma potrzeby definiowania własności Orientation (jej domyślna wartość to Vertical). (cid:141) Panel stosu z trzema poziomymi kwadratami — ma określoną przez programistę wartość Orientation=„Horizontal”. (cid:141) Panel stosu z dwoma kwadratami. W tym panelu również nie określa się parametru Orientation ze względu na wartość domyślną. 98 Rysunek 4.5. StackPanel — użycie własności Orientation Silverlight. Od podstaw W gruncie rzeczy panele stosu są bardzo prostym narzędziem. Proszę jednak zwrócić uwagę na to, że w powyższym przykładzie użyliśmy trzech paneli stosu, zagnieżdżając dwa z nich w jednym nadrzędnym. Jak na tak prosty zabieg zaowocowało to ciekawym efektem. W dalszej części książki Czytelnik będzie miał okazję bardzo często spotykać się z podobnym użyciem paneli stosu, ich siła bowiem tkwi w tym, że można je łatwo (wręcz intuicyjnie) zagnieżdżać oraz łączyć z innymi kontenerami. Grid Siatka Grid jest najwszechstronniejszym kontenerem dostępnym w technologii Silverlight. Bez niej projektowanie interfejsów byłoby o wiele bardziej uciążliwe. Aby z niej skorzy- stać, programista najpierw definiuje siatkę, określając liczbę wierszy i kolumn (a także ich rozmiary). Efekt końcowy przypomina trochę to, co można zobaczyć po otwarciu pustego arkusza kalkulacyjnego. Pozycjonowanie za pomocą siatki polega po prostu na wkładaniu elementów (kontrolek lub innych kontenerów) do jej komórek. W tym podrozdziale omówimy zarówno etap projektowania siatki i wkładania do niej elementów, jak i dodat- kowe możliwości, takie jak choćby scalanie ze sobą komórek. Definiowanie wierszy i kolumn Definiowanie wierszy i kolumn siatki odbywa się poprzez nadanie jej odpowiednich wła- ściwości. Definicja tych własności (mowa tutaj konkretnie o właściwościach Column (cid:180)Definitions i RowDefinitions) nie może być jednak realizowana poprzez składnię atrybutową. Dzieje się tak ze względu na to, że teoretycznie programista może określić dowolną liczbę wierszy i kolumn. Ponadto, jak się za moment okaże, kolumna (czy też wiersz) może być określona nie tylko jedną liczbą (która charakteryzuje jej rozmiar), ale także paroma innymi wielkościami (choćby takimi jak minimalny i maksymalny rozmiar). Rozdział 4. ♦ Kontenery i pozycjonowanie 99 Dlatego właśnie definicja zarówno kolumn, jak i wierszy odbywa się przy pomocy składni elementów właściwości. Jak już zostało powiedziane, chodzi tutaj o dwie własności (listing 4.5 przedstawia ich użycie): (cid:141) ColumnDefinitions — definicje kolumn, (cid:141) RowDefinitions — definicje wierszy. Listing 4.5. Własności ColumnDefinitions i RowDefinitions 1 Grid x:Name= LayoutRoot ShowGridLines= True 2 Grid.ColumnDefinitions 3 ColumnDefinition Width= 100 / 4 ColumnDefinition Width= 200 / 5 ColumnDefinition Width= 100 / 6 /Grid.ColumnDefinitions 7 Grid.RowDefinitions 8 RowDefinition Height= 50 / 9 RowDefinition Height= 150 / 10 RowDefinition Height= 50 / 11 /Grid.RowDefinitions 12 /Grid Wewnątrz własności ColumnDefinitions muszą się znaleźć elementy typu Column (cid:180)Definition. Jak wskazuje nazwa, są to obiekty reprezentujące w Silverlighcie kolumnę. ColumnDefinition posiada m.in. własności: (cid:141) Width — szerokość początkowa kolumny, (cid:141) MinWidth — minimalna szerokość kolumny, (cid:141) MaxWidth — maksymalna szerokość kolumny. Własności obiektu RowDefinition, który opisuje wiersz, są analogiczne. Wielkości kolumn i wierszy W Silverlighcie mamy dwie możliwości określania wysokości wierszy czy szerokości kolumny: (cid:141) statyczne, (cid:141) procentowe. W listingu 4.5, w trzeciej linijce, mamy najprostszą z możliwych definicję własności Width: Width=”100” która mówi, że szerokość kolumny wynosi 100 pikseli. Jest to wielkość statyczna, tzn. podana jawnie w pikselach, w praktyce najczęściej stosowana. 100 Silverlight. Od podstaw Podczas pracy z siatkami bardzo szybko się okaże, że statyczne określanie wielkości jest niewystarczające i trzeba sięgnąć po wielkości procentowe. Wielkość wyrażona procentowo określa, ile procent dostępnego dla elementu graficznego miejsca może on zabrać. W Silver- lighcie 100 symbolizuje gwiazdka *. Aby kolumna zajmowała całe dostępne jej miejsce, należy napisać: ColumnDefinition Width=”*” / Jeśli natomiast użyjemy zapisu: ColumnDefinition Width=”0.8*” / wtedy kolumna zajmie 80 wolnego miejsca. Co ciekawe, równoznaczne są zapisy: ColumnDefinition Width=”8*” / ColumnDefinition Width=”80*” To, czy programista napisze w kodzie programu 0.8*, czy 80*, jest tylko kwestią jego wyboru. Wkładanie elementów do komórek Gdy programista ma już określoną siatkę za pomocą definicji wierszy i kolumn, wtedy może wkładać elementy do poszczególnych komórek. Podobnie jak to miało miejsce w przypadku panelu stosu, pozycjonowany element musi być dzieckiem siatki w drzewie zależności. Aby określić, w której komórce ma się znajdować pozycjonowany obiekt, pro- gramista musi dołączyć do niego atrybuty (patrz rozdział 2., „Atrybuty dołączone”): (cid:141) Grid.Column — indeks kolumny, (cid:141) Grid.Row — indeks wiersza. Indeksy kolumn i wierszy są numerowane w Silverlighcie od zera. Na przykład, mając zdefiniowane dwie kolumny w siatce, indeksem pierwszej z nich będzie 0, natomiast drugiej 1. Włożenie przycisku do drugiej kolumny i drugiego wiersza siatki zdefiniowanej kodem z listingu 7.2 wygląda następująco: Button Grid.Column= 1 Grid.Row= 1 Content= Przycisk Width= 100 Height= 20 / W solucji /Rozdzial4.sln w pliku ColumnsAndRowsDefinitions.xaml można znaleźć przy- kładową aplikację. Definiuje ona siatkę z listingu 4.5 oraz umieszcza w niej przycisk. Zrzut ekranu aplikacji przedstawia rysunek 4.6. Jeśli piszemy w programie pierwszy obiekt siatki, to często nie ma nadanych atrybutów Grid.Row i Grid.Column. To dlatego, że w przypadku gdy nie dołączymy atrybutów Grid.Row i Grid.Column do obiektu, który znajduje się wewnątrz siatki, wtedy zostanie on umieszczony w pierwszej kolumnie i pierwszym wierszu (czyli tak, jakby miał dołą- czone atrybuty Grid.Row=”0” i Grid.Column=”0”). Rozdział 4. ♦ Kontenery i pozycjonowanie 101 Rysunek 4.6. Pozycjonowanie za pomocą siatki Grid Scalanie komórek Posługując się siatką, w Silverlighcie istnieje możliwość scalania ze sobą komórek. Dzięki temu możliwe jest osiągnięcie efektów, takich jak na rysunku 4.7. Rysunek 4.7. Możliwości, jakie daje scalanie komórek Scalanie realizowane jest przez dwa atrybuty dołączone: (cid:141) Grid.ColumnSpan, (cid:141) Grid.RowSpan, które przyjmują jako wartość liczbę całkowitą określającą ilość scalanych wierszy/kolumn. Dla przykładu, kwadrat z powyższego rysunku scala dwie komórki w pionie i w poziomie. 102 Silverlight. Od podstaw Informacje o scaleniu są dołączane do obiektu (podobnie jak atrybuty Grid.Row i Grid. (cid:180)Column), a nie definiowane wraz z kolumnami i wierszami. Proszę zwrócić uwagę na to, że dzięki temu istnieje możliwość nadania obiektom znajdującym się w tej samej ko- mórce różnego scalania, uzyskując przy tym ciekawe efekty. Inne właściwości siatki Pisaliśmy już o definiowaniu kolumn i wierszy siatki, co w gruncie rzeczy jest nadawa- niem wartości odpowiednim własnościom klasy Grid. Rzecz jasna nie są to jedyne wła- sności siatek (chociaż prawdopodobnie najważniejsze). Na koniec wypada nam pokrótce omówić pozostałe wyróżniające się właściwości siatki. ShowGridLines ShowGridLines to własność, która znacznie ułatwia pracę programisty z siatkami. Przyj- muje ona wartość logiczną: (cid:141) true — na siatce są pokazywane linie pomocnicze w miejscach, w których przebiegają granice kolumn i wierszy, (cid:141) false (domyślnie) — ukrywa linie pomocnicze. Rysunek 4.8 przedstawia pustą siatkę z właściwością ShowGridLine ustawioną na true. Rysunek 4.8. Efekt włączenia własności ShowGridLines Width i Height Width i Height to z pozoru trywialne właściwości, które określają rozmiary elementu graficznego. W przypadku wszystkich kontenerów (nie tylko siatki) te dwie niepozorne własności mają jednak duże znaczenie. Przyjrzyjmy się listingowi 4.6 z kodem aplikacji, którą mieliśmy okazję oglądać na rysunku 4.8. Rozdział 4. ♦ Kontenery i pozycjonowanie 103 Listing 4.6. Siatka z ustalonym rozmiarem 1 Grid x:Name= LayoutRoot Background= White ShowGridLines= True 2 Width= 450 Height= 350 3 Grid.ColumnDefinitions 4 ColumnDefinition Width= 40 / 5 ColumnDefinition Width= 180 / 6 ColumnDefinition Width= 60 / 7 ColumnDefinition / 8 /Grid.ColumnDefinitions 9 Grid.RowDefinitions 10 RowDefinition Height= 50 / 11 RowDefinition Height= 70 / 12 RowDefinition Height= 30 / 13 RowDefinition Height= 60 / 14 RowDefinition Height= 90 / 15 RowDefinition / 16 /Grid.RowDefinitions 17 /Grid Pierwszą ważną cechą siatki z listingu 4.6 jest to, że ma ona określony rozmiar: 450 pikseli szerokości i 350 wysokości. Drugą ciekawą cechą jest to, że zarówno definicja ostatniej kolumny (linijka 7.), jak i definicja ostatniego wiersza (linijka 15.) nie ma określonego rozmiaru. Jest tak dlatego, że w przypadku siatek ich rozmiar określony właściwościami Width i Height ma większe znaczenie niż definicje ich wierszy i kolumn. Oznacza to mniej więcej to, że szerokość siatki nie jest równa szerokości jej kolumn, a wysokość siatki nie jest sumą wy- sokości wierszy. Z tego faktu wynika kilka konsekwencji, o których trzeba pamiętać, używając siatek. Pierwszą z nich jest to, że definicje ostatnich kolumn/wierszy mogą nie mieć określonej szerokości/wysokości. Niezależnie od tego, jaki nadamy rozmiar ostatniej kolumnie i wierszowi, ich rozmiar zostanie tak dobrany, aby siatka miała rozmiar zdefiniowany przez Width i Height. Dlatego rozmiar ostatniej kolumny czy wiersza nie ma znaczenia. Drugą konsekwencją jest natomiast to, że jeśli zdefiniujemy za mały rozmiar siatki, to kolumny i wiersze, które wykraczają poza jej granice, nie będą widoczne. Niezależnie od tego, co zrobimy z ostatnią kolumną/wierszem, siatka i tak będzie tak szeroka i tak wysoka, jak to określiliśmy właściwościami Width i Height. W przypadku gdy nie określimy własności Width i Height, siatka najpewniej zabierze całe dostępne dla niej miejsce i będzie się zachowywała dalej tak, jakby jej Width i Height były określone. Takie zachowanie siatki może się wydawać początkowo nieintuicyjne. W praktyce jednak jest ono przydatne, programista bowiem, ustalając rozmiar siatki, ma gwarancję, że ele- menty przez nią pozycjonowane nie zmienią jej rozmiaru. Taka gwarancja ma dużą wartość, w przypadku gdy programista nie ma pewności, co się może znaleźć w kontenerze (np. gdy w siatce są dynamicznie wkładane informacje pochodzące z bazy danych). 104 Canvas Silverlight. Od podstaw Jak już zostało kilka razy wspomniane, w Silverlighcie programista ma do dyspozycji trzy kontenery. Dwa z nich, które służą do pozycjonowania relatywnego, zostały już omówione. Ostatni, kontener Canvas (ang. płótno), jest jedynym narzędziem w technologii Silverlight służącym do pozycjonowania absolutnego. Można powiedzieć, że pozycjonowanie absolutne pozwala programiście na określenie współrzędnych obiektu pozycjonowanego. Przy użyciu narzędzi pozycjonowania rela- tywnego (panelu stosu i siatki) nie ma takiej możliwości. W tym podrozdziale skupimy się na omówieniu sposobu korzystania z płótna. Z racji tego, że w tym przypadku nie ma potrzeby definiowania ani kolumn, ani wierszy (określamy tylko współrzędne elementów pozycjonowanych), kontener Canvas nie posiada tylu ciekawych właściwości, co choćby siatka Grid. Posługiwanie się płótnem sprowadza się do dołączania odpowiednich atrybutów do jego dzieci (w celu określenia m.in. współ- rzędnych). Mowa tutaj o trzech atrybutach dołączonych: (cid:141) Canvas.Left, (cid:141) Canvas.Right, (cid:141) Canvas.ZIndex. Przejdziemy teraz do pokazania, jak korzystać z tych atrybutów. Canvas.Left i Canvas.Right Te dwie własności służą do określenia odległości pozycjonowanego obiektu od lewego górnego boku kontenera. Listing 4.7 pokazuje użycie tych dwóch atrybutów dołączonych. W linijce 2. są dołączone do kwadratu tak, aby jego pozycja na płótnie wynosiła 130 pikseli od góry i 230 pikseli od lewej strony. Listing 4.7. Użycie własności Canvas.Left i Canvas.Right do pozycjonowania kwadratu 1 Canvas 2 Rectangle Canvas.Left= 230 Canvas.Top= 130 3 Width= 150 Height= 150 4 Stroke= LightBlue StrokeThickness= 3 5 Rectangle.Fill 6 LinearGradientBrush 7 GradientStop Offset= 0 Color= DarkBlue / 8 GradientStop Offset= 1 Color= Cyan / 9 /LinearGradientBrush 10 /Rectangle.Fill 11 /Rectangle 12 /Canvas Rozdział 4. ♦ Kontenery i pozycjonowanie 105 W solucji /Rozdzial4.sln w pliku /CanvasLeftRight.xaml można znaleźć kod aplikacji, której fragment kodu został przedstawiony na listingu 4.7. Zrzut ekranu aplikacji (wraz z nanie- sionymi strzałkami pomocniczymi) przedstawia rysunek 4.9. Rysunek 4.9. Pozycjonowanie kwadratu za pomocą płótna Płótno Canvas, dzięki możliwości dokładnego określenia współrzędnych pozycjonowanego obiektu (za pomocą atrybutów dołączonych Canvas.Left i Canvas.Right), daje programi- ście największą swobodę pozycjonowania. Każdy obiekt wewnątrz płótna, niezależnie od tego, którym w kolejności jest dzieckiem, jest zawsze pozycjonowany względem lewego, górnego boku płótna. Dzięki temu można w mgnieniu oka napisać aplikację, która wyglą- da np. tak, jak ta przedstawiona na rysunku 4.10 (kod programu można znaleźć w solucji /Rozdzial4.sln w pliku CanvasLeftRight2.xaml). Rysunek 4.10. Możliwości pozycjonowania przy pomocy płótna Canvas 106 Silverlight. Od podstaw Wykonanie takiego programu, jaki został przedstawiony na rysunku 4.10, przy pomocy np. siatki jest również możliwe. W tym celu należałoby zdefiniować najpierw odpowied- nie kolumny i wiersze, a następnie powkładać w nie kwadraty. Lista czynności jest tutaj o wiele dłuższa, dlatego płótno Canvas nadaje się do tego zadania o wiele lepiej. Płótno jest narzędziem stosunkowo prostym, ale potężnym. W przypadku gdybyśmy chcieli dynamicznie zmieniać pozycje kwadratów z rysunku 4.10 (np. w zależności od tego, gdzie na ekranie znajduje się myszka), wystarczy tylko odpowiednio zmieniać własności atry- butów do nich dołączonych. Pomimo tych wszystkich zalet samo płótno najczęściej nie przyda nam się do pisania interfejsów — siatka jest w takich sytuacjach niezastąpiona. Canvas.ZIndex Podczas pozycjonowania absolutnego elementów często jest tak, że jedne zachodzą na drugie, zakrywając je w mniejszym bądź większym stopniu — taka sytuacja pokazana jest na rysunku 4.11. Rysunek 4.11. Nakładanie się obiektów wizualnych Często jest tak, że zachodzenie na siebie elementów nie jest wypadkiem przy pracy, a efektem zamierzonym przez programistę. Dlatego w Silverlighcie istnieje możliwość określenia kolejności wyświetlania elementów, tak aby programista miał nad nim pełną kontrolę. Koncepcja nie jest może i nowa, ale prosta i skuteczna. Polega na tym, że ele- mentom graficznym znajdującym się na kanwie można przypisać liczbę naturalną, która determinuje to, jako który zostanie on wyświetlony. Obiekty o numerach wyższych są wyświetlane „ponad” elementami o numerach niższych. Jeśli zatem chcemy, aby kwadrat z rysunku zawsze znajdował się nad kołem (niezależnie od jego miejsca w kodzie programu), wtedy napiszemy kod programu z listingu 4.8. Rozdział 4. ♦ Kontenery i pozycjonowanie 107 Listing 4.8. Uporządkowanie elementów za pomocą własności Canvas.ZIndex 1 Canvas 2 Rectangle Canvas.Left= 50 Canvas.Top= 50 3 Canvas.ZIndex= 1 4 Width= 125 Height= 125 5 Stroke= LightBlue StrokeThickness= 3 6 Rectangle.Fill 7 LinearGradientBrush 8 GradientStop Offset= 0 Color= DarkBlue / 9 GradientStop Offset= 1 Color= Cyan / 10 /LinearGradientBrush 11 /Rectangle.Fill 12 /Rectangle 13 Ellipse Canvas.Left= 100 Canvas.Top= 50 14 Width= 125 Height= 125 15 Stroke= Pink StrokeThickness= 3 16 Ellipse.Fill 17 LinearGradientBrush 18 GradientStop Offset= 0 Color= DarkRed / 19 GradientStop Offset= 1 Color= Red / 20 /LinearGradientBrush 21 /Ellipse.Fill 22 /Ellipse 23 /Canvas W trzeciej linijce kodu używamy właściwości Canvas.ZIndex. Jest to atrybut dołączony, który służy w Silverlighcie do określenia kolejności wyświetlania elementów graficznych. Dzięki ścisłemu określeniu kolejności wyświetlania udało nam się wyświetlić kwadrat ponad kołem, jak to widać na rysunku 4.12. Pełen kod programu można znaleźć w solucji /Rozdzial4.sln w pliku CanvasZIndex.xaml. Rysunek 4.12. Użycie atrybutu Canvas.ZIndex 108 Silverlight. Od podstaw Kontenery z poziomu kodu Mamy już wiedzę na temat tego, jak pisać w XAML-u kontenery i jak osadzać na nich kontrolki. Wiemy także, jak pozycjonować elementy znajdujące się wewnątrz kontenerów. Zdarza się jednak czasem tak, że istnieje potrzeba wygenerowania kontrolek z poziomu kodu, a następnie wyświetlenia ich użytkownikowi. Z taką sytuacją mamy do czynienia w przypadku pobierania informacji z bazy danych, a potem prezentacji ich w postaci listy. W tym rozdziale pokażemy, jak rozwiązać trudności, które pojawiają się przy generowa- niu treści z poziomu kodu aplikacji. Generowanie kontrolek Zanim przejdziemy do omawiania kontenerów tworzonych z poziomu kodu, pokażemy, jaka jest ogólna metoda generowania większości kontrolek interfejsu, takich jak Button czy TextBox. Jak już zostało napisane, w języku XAML piszemy znaczniki, których własnościom możemy przypisać wartości (za pomocą składni atrybutowej bądź elementów własności). Powiedzieliśmy też, że znaczniki z pliku .xaml są mapowane na obiekty języka CLR, tak samo jak kod napisany w innym, dowolnym języku platformy .NET. Dlatego też pisanie kontrolek z poziomu pliku code-behind sprowadza się do utworzenia obiektu odpowied- niej klasy (jeśli ma to być przycisk, to tworzymy obiekt klasy Button) oraz nadania wła- snościom nowo utworzonego obiektu odpowiednich wartości. Listing 4.9 pokazuje, jak tworzy się blok tekstu TextBlock z pliku code-behind. Listing 4.9. Stworzenie bloku tekstu z poziomu kodu 1 TextBlock t = new TextBlock(); 2 t.Width = 200; 3 t.Height = 50; 4 t.TextWrapping = TextWrapping.Wrap; 5 t.TextAlignment = TextAlignment.Center; 6 t.Text = To jest wygenerowana kontrolka interfejsu ; Jak widać, przypisujemy wartości własnościom, które nazywają się tak samo jak własności w XAML-u (i nie powinno być w tym nic dziwnego). Pozostaje jednak jeden problem. Tak napisanej kontrolki nie zobaczymy po uruchomieniu aplikacji Silverlight. Aby kon- trolka była wyświetlana na ekranie użytkownika, musi być osadzona na kontenerze. W poniższym podrozdziale dowiemy się, jak to zrobić. Rozdział 4. ♦ Kontenery i pozycjonowanie 109 Generowanie kontenerów Kolekcja Children Wszystkie kontenery dziedziczą po jednej wspólnej klasie o nazwie Panel. Ta klasa definiuje kolekcję Children. Jest to kolekcja typu UIElementCollection, co w praktyce oznacza, że możemy do niej włożyć dowolny element wizualny Silverlighta. Może być to zarówno kontrolka interfejsu, kształt, jak i inny kontener. Wkładając elementy wygenerowane w kodzie do kolekcji Children kontenera, sprawimy, że będzie on wyświetlony i pozycjonowany przez ten kontener. Przy czym należy pamię- tać, że kontener wcale nie musi być utworzony dynamicznie. Listing 4.10 pokazuje kod, w którym osadzamy kontrolkę z poprzedniego listingu na siatce LayoutRoot. Listing 4.10. Włożenie kontrolki do kontenera 1 TextBlock t = new TextBlock(); 2 t.Width = 200; 3 t.Height = 50; 4 t.TextWrapping = TextWrapping.Wrap; 5 t.TextAlignment = TextAlignment.Center; 6 t.FontSize = 16; 7 t.Text = To jest wygenerowana kontrolka interfejsu ; 8 9 LayoutRoot.Children.Add(t); Taki kod wyświetli nam kontrolkę bloku tekstu — proszę spojrzeć na rysunek 4.13, który pokazuje zrzut ekranu działającej aplikacji. Pełny kod programu można znaleźć w solucji /Rozdzial4.sln w pliku TextBlockFromCodeBehind.cs. Rysunek 4.13. Pierwsza kontrolka umieszczona w kontenerze z poziomu kodu 110 Silverlight. Od podstaw Pozycjonowanie wygenerowanych kontrolek Pisaliśmy powyżej o tym, że aby wyświetlić kontrolki, musimy umieścić je w kolekcji Children kontenera. Jest to zupełnie wystarczające w przypadku panelu stosu StackPanel — kolejne elementy kolekcji Children będą prawidłowo przez niego pozycjonowane tylko dzięki temu, że StackPanel to najprostszy z dostępnych kontenerów. Inne kontenery są już bardziej wymagające. Aby pozycjonować element osadzony na kanwie, musimy określić dla niego własności Left i Top. Podobnie jest z siatką Grid, gdzie możemy podać, w której kolumnie i wierszu ma się znajdować pozycjonowany obiekt. W tym podroz- dziale pokażemy, jak pozycjonować elementy graficzne Silverlighta w tych dwóch kontenerach. Pozycjonowanie na siatce Grid Napiszmy przykładową siatkę, taką jak pokazana na listingu 4.11. Listing 4.11. Siatka, na której osadzimy z poziomu kodu kontrolkę 1 Grid x:Name= LayoutRoot Background= White 2 ShowGridLines= True Loaded= LayoutRoot_Loaded 3 Grid.ColumnDefinitions 4 ColumnDefinition Width= 100 / 5 ColumnDefinition Width= 50 / 6 ColumnDefinition Width= 250 / 7 /Grid.ColumnDefinitions 8 Grid.RowDefinitions 9 RowDefinition Height= 100 / 10 RowDefinition Height= 50 / 11 RowDefinition Height= 150 / 12 /Grid.RowDefinitions 13 /Grid Rysunek 4.14 pokazuje, jaka jest struktura tej siatki. Rysunek 4.14. Siatka z listingu 4.11 Rozdział 4. ♦ Kontenery i pozycjonowanie 111 Jak widać, mamy w niej trzy kolumny i tyle samo wierszy. Będziemy teraz chcieli umie- ścić w drugiej kolumnie i wierszu przycisk. Jeśli mielibyśmy to zrobić w XAML-u, to musielibyśmy wewnątrz siatki umieścić znacznik: Button Width=”100” Height=”20” Content=”Przycisk” Grid.Row =”1” Grid.Column=”1” / Jeśli jesteśmy natomiast po drugiej stronie, czyli po stronie pliku code-behind, to musimy najpierw utworzyć przycisk i dodać go do listy członków siatki, tak jak to robiliśmy w po- przednich przykładach. Następnie musimy określić kolumnę i wiersz przycisku, co nie jest prostym zadaniem z racji tego, że w XAML-u te własności są atrybutami dołączonymi. Z pomocą przychodzi tutaj klasa Grid. Na jej liście członków można znaleźć cztery metody statyczne: (cid:141) void SetColumn(FrameworkElement element, int value) — wkłada element do kolumny o numerze value, (cid:141) void SetRow (FrameworkElement element, int value) — wkłada element do wiersza o numerze value, (cid:141) void SetColumnSpan (FrameworkElement element, int value) — ustawia scalanie kolumn o wartości value dla obiektu element, (cid:141) void SetRowSpan (FrameworkElement element, int value) — ustawia scalanie wierszy o wartości value dla obiektu element. Za pomocą tych metod możemy z poziomu kodu zrealizować nasze cele. Listing 4.12 pokazuje kod, za pomocą którego umieszczamy przycisk w drugiej kolumnie i drugim wierszu siatki, a także nadajemy mu scalanie dwóch kolumn. Listing 4.12. Umieszczenie przycisku w drugiej kolumnie i drugim wierszu siatki 1 Button b = new Button(); 2 b.Content = Przycisk ; 3 b.Width = 250; 4 b.Height = 25; 5 LayoutRoot.Children.Add(b); 6 Grid.SetColumn(b, 1); 7 Grid.SetRow(b, 1); 8 Grid.SetColumnSpan(b, 2); Rysunek 4.15 pokazuje, że rzeczywiście udało nam się osiągnąć zamierzony efekt. Pełen kod programu można znaleźć w solucji /Rozdzial4.sln w plikach ButtonOnGrid FromCodeBehind.xaml i ButtonOnGridFromCodeBehind.xaml.cs. Pozycjonowanie na kanwie Canvas W przypadku kanwy Canvas mamy problem podobny do tego z poprzedniego podrozdziału, gdzie własności pozycjonujące element były atrybutami dołączonymi. I tak jak w przypad- ku siatek, tak i tutaj rozwiązaniem są metody statyczne udostępniane poprzez klasę Canvas. Są to: (cid:141) void SetLeft(UIElement element, double length) — ustala dla obiektu element odsunięcie od lewej krawędzi o długość length, 112 Rysunek 4.15. Zrzut ekranu aplikacji, która osadza przycisk na siatce z poziomu kodu Silverlight. Od podstaw (cid:141) void SetTop(UIElement element, double length) — ustala dla obiektu element odsunięcie od górnej krawędzi o długość length, (cid:141) void SetZIndex(UIElement element, int value) — dla obiektu element kolejność wyświetlania jako value. Napiszemy przykładowy program, w którym stworzymy dwa kwadraty, ustalimy ich po- zycje na ekranie i kolejność wyświetlania. Listing 4.13 pokazuje kod pliku .cs tej aplikacji. Listing 4.13. Użycie metod pozycjonujących klasy Canvas 1 // Zdefiniowanie kwadratów 2 Rectangle r1 = new Rectangle(); 3 Rectangle r2 = new Rectangle(); 4 r1.Width = r2.Width = 100; 5 r1.Height = r2.Height = 100; 6 r1.Fill = new SolidColorBrush(Colors.Red); 7 r2.Fill = new SolidColorBrush(Colors.Green); 8 9 // Osadzenie kwadratów na kanwie 10 LayoutRoot.Children.Add(r1); 11 LayoutRoot.Children.Add(r2); 12 13 // Użycie metod klasy Canvas 14 Canvas.SetLeft(r1, 50); 15 Canvas.SetTop(r1, 50); 16 Canvas.SetZIndex(r1, 2); 17 Canvas.SetLeft(r2, 100); 18 Canvas.SetTop(r2, 100); 19 Canvas.SetZIndex(r2, 1); W kodzie aplikacji utworzyliśmy dynamicznie dwa kwadraty: jeden czerwony, drugi zielony. Następnie dodaliśmy je do istniejącej kanwy o nazwie LayoutRoot. Najpierw dodaliśmy kwadrat czerwony, a potem zielony — ma to znaczenie, ponieważ kwadrat Rozdział 4. ♦ Kontenery i pozycjonowanie 113 zielony będzie wyświetlany ponad czerwonym. Na koniec ustawiliśmy kwadraty tak, aby nachodziły na siebie. Zdefiniowaliśmy im także z-indeks, dzięki czemu ostatecz- nie kwadrat zielony będzie wyświetlany ponad czerwonym. Kod aplikacji można znaleźć w solucji /Rozdzial4.sln w pliku ButtonOnCanvasFrom CodeBehind.xaml.cs. Rysunek 4.16 pokazuje zrzut ekranu działającego programu. Rysunek 4.16. Aplikacja demonstrująca działanie metod statycznych klasy Canvas
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Silverlight. Od podstaw
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ą: