Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00187 005915 13604016 na godz. na dobę w sumie
Adobe Flex 3. Oficjalny podręcznik - książka
Adobe Flex 3. Oficjalny podręcznik - książka
Autor: , , , Liczba stron: 648
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1966-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> grafika komputerowa >> flex
Porównaj ceny (książka, ebook (-89%), audiobook).

Poznaj potężne możliwości Adobe Flex 3 i twórz bogate aplikacje internetowe

Adobe Flex 3 to odpowiedź na zapotrzebowanie programistów w zakresie tworzenia bogatych aplikacji internetowych za pomocą przyjaznych i intuicyjnych narzędzi. Na Flex składają się m.in.: ActionScript 3.0, zwiększający wydajność i prostotę programowania; Flash Player 9, pozwalający na szybszą pracę i wykorzystujący mniejszą ilość pamięci; Flex Builder 3, udostępniający m.in. świetne narzędzia do usuwania błędów i promujący najlepsze praktyki kodowania oraz programowania aplikacji.

Książka 'Adobe Flex 3. Oficjalny podręcznik' poprowadzi Cię krok po kroku przez proces budowania dynamicznych, interaktywnych aplikacji. Zawiera ona szczegółowy, wyczerpujący, praktyczny kurs tworzenia i projektowania architektury bogatych aplikacji internetowych (RIA) w językach MXML i ActionScript 3.0. Dzięki temu podręcznikowi nauczysz się pracować ze złożonymi zbiorami danych, tworzyć własne zdarzenia niestandardowe, stosować style i skórki, a także instalować aplikacje w sieci lub komputerze. Poznasz wszystkie możliwości Fleksa i będziesz umiał zastosować w praktyce nowoczesne narzędzia, a także z łatwością korzystać z innowacyjnych technologii.

Skorzystaj z indywidualnych warsztatów Flex 3 i zbuduj samodzielnie wyjątkową aplikację internetową!

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

Darmowy fragment publikacji:

Adobe Flex 3. Oficjalny podrêcznik Autorzy: Jeff Tapper, Michael Labriola, Matthew Boles, James Talbot T³umaczenie: Andrzej Goñda, Aleksander Lam¿a ISBN: 978-83-246-1966-5 Tytu³ orygina³u: Adobe Flex 3: Training from the Source Format: B5, stron: 648 Poznaj potê¿ne mo¿liwoœci Adobe Flex 3 i twórz bogate aplikacje internetowe • Jak tworzyæ, wdra¿aæ i debugowaæ bogate aplikacje internetowe? • Jak u¿ywaæ jêzyka MXML do budowania uk³adu aplikacji? • Jak tworzyæ niestandardowe komponenty interfejsu u¿ytkownika w jêzykach MXML i ActionScript? Adobe Flex 3 to odpowiedŸ na zapotrzebowanie programistów w zakresie tworzenia bogatych aplikacji internetowych za pomoc¹ przyjaznych i intuicyjnych narzêdzi. Na Flex sk³adaj¹ siê m.in.: ActionScript 3.0, zwiêkszaj¹cy wydajnoœæ i prostotê programowania; Flash Player 9, pozwalaj¹cy na szybsz¹ pracê i wykorzystuj¹cy mniejsz¹ iloœæ pamiêci; Flex Builder 3, udostêpniaj¹cy m.in. œwietne narzêdzia do usuwania b³êdów i promuj¹cy najlepsze praktyki kodowania oraz programowania aplikacji. Ksi¹¿ka „Adobe Flex 3. Oficjalny podrêcznik” poprowadzi Ciê krok po kroku przez proces budowania dynamicznych, interaktywnych aplikacji. Zawiera ona szczegó³owy, wyczerpuj¹cy, praktyczny kurs tworzenia i projektowania architektury bogatych aplikacji internetowych (RIA) w jêzykach MXML i ActionScript 3.0. Dziêki temu podrêcznikowi nauczysz siê pracowaæ ze z³o¿onymi zbiorami danych, tworzyæ w³asne zdarzenia niestandardowe, stosowaæ style i skórki, a tak¿e instalowaæ aplikacje w sieci lub komputerze. Poznasz wszystkie mo¿liwoœci Fleksa i bêdziesz umia³ zastosowaæ w praktyce nowoczesne narzêdzia, a tak¿e z ³atwoœci¹ korzystaæ z innowacyjnych technologii. • Technologie bogatych aplikacji internetowych • Pulpit programu Flex Builder 3 • Obs³uga zdarzeñ i struktury danych • U¿ywanie zdalnych danych z kontrolkami • Tworzenie komponentów w jêzyku MXML • Repetery ze zbiorami danych • Tworzenie niestandardowych komponentów w jêzyku ActionScript 3.0 • Stosowanie siatek danych i generatorów elementów • Wprowadzanie nawigacji • Formatowanie i walidacja danych • Zarz¹dzanie histori¹ i g³êbokie linkowanie • Wizualizowanie danych • Wdra¿anie aplikacji Fleksa Skorzystaj z indywidualnych warsztatów Flex 3 i zbuduj samodzielnie wyj¹tkow¹ aplikacjê internetow¹! Spis treści O autorach Wstęp Wprowadzenie 15 17 19 Lekcja 1 Wprowadzenie do bogatych aplikacji internetowych 29 Rozwój aplikacji komputerowych ................................................................................ 29 Odejście od architektury opartej na stronie ................................................................. 31 Zalety bogatych aplikacji internetowych ......................................................................33 Menedżerowie przedsiębiorstw ...................................................................................... 33 Przedsiębiorstwa branży IT ............................................................................................. 33 Użytkownicy końcowi ..................................................................................................... 33 Technologie bogatych aplikacji internetowych ...........................................................33 Asynchroniczny JavaScript i XML (AJAX) ..................................................................34 Flash ...................................................................................................................................35 Flex .....................................................................................................................................35 Windows Presentation Foundation, XAML, Silverlight i Expression .....................36 Czego się nauczyłeś? .......................................................................................................37 Lekcja 2 Zaczynamy 39 Wstęp do programowania aplikacji Fleksa .................................................................. 40 Tworzenie projektu i aplikacji MXML ........................................................................ 40 Pulpit programu Flex Builder 3 .....................................................................................43 Uruchamianie aplikacji ..................................................................................................46 Tworzenie drugiej strony aplikacji w trybie projektowania .......................................52 Przygotowania do następnej lekcji ................................................................................57 Czego się nauczyłeś? .......................................................................................................58 Lekcja 3 Projektowanie interfejsu użytkownika 61 Kontenery ........................................................................................................................61 Tworzenie układu aplikacji e-commerce w trybie projektowania ..............................62 Praca z układami opartymi na więzach ........................................................................68 Wiązanie do kontenera nadrzędnego ............................................................................69 Użycie zaawansowanych więzów ...................................................................................74 6 ADOBE FLEX 3. Oficjalny podręcznik Praca ze stanami widoku ................................................................................................76 Sterowanie stanami widoku ............................................................................................78 Projektowanie aplikacji w trybie edycji kodu źródłowego ......................................... 80 Dodawanie stanów widoku i sterowanie nimi za pomocą MXML ...........................82 Czego się nauczyłeś? .......................................................................................................86 Lekcja 4 Stosowanie prostych kontrolek 89 Wprowadzenie do prostych kontrolek ........................................................................ 90 Wyświetlanie obrazów ....................................................................................................91 Tworzenie widoku szczegółów ...................................................................................... 94 Korzystanie z wiązania danych do powiązania struktury danych z prostą kontrolką ..................................................................................................... 97 Wykorzystywanie kontenera układu formularzy do umieszczania prostych kontrolek w aplikacji ................................................................................. 99 Dodawanie przycisków radiowych i pól daty do aplikacji Dashboard ...................103 Czego się nauczyłeś? .....................................................................................................105 Lekcja 5 Obsługa zdarzeń i struktury danych 107 Zrozumienie obsługi zdarzeń ......................................................................................108 Prosty przykład ...............................................................................................................108 Obsługa zdarzenia przez funkcję języka ActionScript .............................................109 Przekazywanie danych podczas wywołania funkcji uchwytu zdarzenia ................ 110 Tworzenie struktury danych w zdarzeniu creationComplete ...................................111 Używanie danych z obiektu Event .............................................................................. 114 Tworzenie własnej klasy języka ActionScript ............................................................. 118 Tworzenie obiektu wartości .......................................................................................... 118 Tworzenie metody kreującej obiekt ............................................................................123 Tworzenie klas koszyka na zakupy ..............................................................................125 Czego się nauczyłeś? .....................................................................................................129 Lekcja 6 Używanie zdalnych danych XML z kontrolkami 131 Pobieranie danych XML za pośrednictwem HTTPService .......................................132 Tworzenie obiektu HTTPService ................................................................................. 132 Wywoływanie metody send() ........................................................................................ 133 Używanie zwróconych danych ..................................................................................... 133 Zagadnienia bezpieczeństwa ........................................................................................ 134 Pobieranie danych XML za pośrednictwem HTTPService ....................................... 135 Wypełnianie ArrayCollection danymi z HTTPService .............................................137 Używanie obiektów ArrayCollection .......................................................................... 137 Używanie kolekcji w roli dostawców danych ............................................................. 138 Wypełnianie kontrolki ComboBox i programowe dodawanie opcji ......................140 Używanie danych XML z kontrolką Tree ...................................................................143 Pojęcie operatorów E4X ................................................................................................ 143 Wypełnianie kontrolki Tree danymi XML ................................................................148 Pobieranie danych XML i przekształcanie ich w kolekcję ArrayCollection obiektów użytkownika .............................................................................................154 ADOBE FLEX 3. Spis treści 7 Stosowanie powiązania danych ze złożonymi strukturami danych ........................157 Przekształcanie danych koszyka na zakupy ...............................................................159 Dodawanie elementów do koszyka ............................................................................. 159 Sortowanie elementów kolekcji ArrayCollection ..................................................... 160 Dodawanie elementu lub aktualizowanie ilości ........................................................ 162 Korzystanie z kursora do umieszczania elementu koszyka na zakupy .................. 164 Dodawanie przycisku Remove (usuń) ........................................................................ 171 Czego się nauczyłeś? .....................................................................................................172 Lekcja 7 Tworzenie komponentów w języku MXML 175 Wprowadzenie do komponentów języka MXML ......................................................176 Podstawy tworzenia niestandardowych komponentów ........................................... 176 Tworzenie własnego komponentu krok po kroku ....................................................177 Wykorzystanie niestandardowych komponentów w architekturze aplikacji .......179 Tworzenie komponentu aktualizującego i usuwającego informacje o produkcie oraz jego egzemplarza ........................................................................180 Wyświetlanie informacji o produkcie po kliknięciu przycisków aktualizacji i usuwania .................................................................................................................184 Tworzenie kolejnego obiektu wartości .......................................................................189 Tworzenie komponentu zarządzającego danymi dla wszystkich trzech aplikacji ......... 191 Używanie nowego komponentu zarządzającego danymi .........................................197 Wprowadzanie funkcji dodawania produktu ........................................................... 200 Tworzenie i używanie komponentów dla aplikacji Dashboard ...............................201 Czego się nauczyłeś? .....................................................................................................203 Lekcja 8 Używanie kontrolek i komponentów Repeater ze zbiorami danych 205 Używanie zbiorów danych .......................................................................................... 206 Komponenty HorizontalList i TileList ......................................................................207 Wprowadzenie labelFunction ......................................................................................208 Wprowadzenie właściwości itemRenderer .................................................................209 Wyświetlanie kategorii za pomocą elementów HorizontalList i itemRenderer .................210 Wyświetlanie informacji o produktach spożywczych należących do określonej kategorii ............................................................................................214 Używanie komponentu Repeater do wykonania pętli przeszukującej zbiór danych ..............................................................................................................214 Pobieranie danych z komponentów Repeater ........................................................... 215 Adresowanie komponentów utworzonych przez Repeater .....................................217 Wyjaśnienie różnic w wydajności komponentów TileList i Repeater ....................218 Wyświetlanie informacji o artykułach spożywczych należących do określonej kategorii .............................................................................................218 Kodowanie stanów wyświetlających szczegółowe informacje o produkcie ........... 224 Umieszczanie produktów w koszyku na zakupy ...................................................... 227 Czego się nauczyłeś? .................................................................................................... 229 8 ADOBE FLEX 3. Oficjalny podręcznik Lekcja 9 Używanie zdarzeń niestandardowych 232 Korzyści ze stosowania luźno powiązanej architektury ............................................232 Wysyłanie zdarzeń ........................................................................................................233 Deklarowanie zdarzeń komponentu ..........................................................................235 Kiedy używa się klas niestandardowych zdarzeń .......................................................236 Tworzenie i używanie CategoryEvent .........................................................................237 Tworzenie i używanie klasy ProductEvent ................................................................ 240 Używanie ProductEvent do usuwania produktu z koszyka ....................................244 Wykorzystanie ProductEvent do dodawania produktu do koszyka ......................246 Zrozumienie przepływu i bąbelkowania zdarzeń ..................................................... 247 Czego się nauczyłeś? .....................................................................................................252 Lekcja 10 Tworzenie niestandardowych komponentów w języku ActionScript 3.0 255 Wprowadzenie do tworzenia komponentów w języku ActionScript 3.0 ................256 Tworzenie struktury klasy ............................................................................................257 Nadpisywanie metody createChildren() .....................................................................259 Tworzenie przycisku w języku ActionScript ..............................................................260 Używanie metody addChild() do dodawania przycisku do komponentu ............260 Co to jest chrom i rawChildren ................................................................................... 261 Używanie metod addChild() i rawChildren do dodawania elementów do chromu ..................................................................................................................262 Ustalanie rozmiarów i pozycji komponentów we Fleksie ........................................265 Zrozumienie metody measure() ................................................................................. 267 Nadpisywanie metody updateDisplayList() .............................................................. 267 Czego się nauczyłeś? .....................................................................................................273 Lekcja 11 Stosowanie siatek danych i rendererów elementów 276 Wprowadzenie do siatek danych i rendererów elementów ...................................... 277 Dodawanie standardowej siatki danych do komponentu ChartPod ..................... 277 Dodawanie wywołań HTTPService do aplikacji Dashboard ................................... 278 Wyświetlanie koszyka na zakupy w siatce danych .................................................... 282 Dodawanie kontrolek edycji w siatce do DataGridColumn ...................................284 Tworzenie renderera elementów służącego do wyświetlania informacji o produkcie ................................................................................................................285 Tworzenie lokalnego renderera elementów w celu wyświetlenia przycisku Remove .....................................................................................................287 Aktualizowanie ShoppingCartItem funkcjami Set i Get .........................................292 Używanie zaawansowanej siatki danych .....................................................................293 Sortowanie AdvancedDataGrid ...................................................................................294 Sortowanie w trybie zaawansowanym .........................................................................295 Nadawanie stylów zaawansowanej siatce danych ......................................................296 Grupowanie danych ......................................................................................................300 Wyświetlanie danych podsumowujących ...................................................................305 Czego się nauczyłeś? ..................................................................................................... 313 ADOBE FLEX 3. Spis treści 9 Lekcja 12 Używanie techniki „przeciągnij i upuść” 315 Wprowadzenie do menedżera przeciągania i upuszczania ....................................... 316 Przeciąganie i upuszczanie pomiędzy dwiema siatkami danych .............................317 Przeciąganie i upuszczanie między siatką danych i listą ...........................................320 Używanie komponentu z wyłączonym przeciąganiem w operacji przeciągania i upuszczania ............................................................................................................324 Przeciąganie produktu do koszyka na zakupy ...........................................................329 Czego się nauczyłeś? .....................................................................................................334 Lekcja 13 Wprowadzanie nawigacji 337 Wprowadzenie do nawigacji ........................................................................................337 Używanie komponentu TabNavigator w aplikacji DataEntry .................................340 Dodawanie strony głównej i strony płatności w aplikacji e-commerce ...................343 Przygotowywanie pierwszego etapu procesu płatności wyświetlanego w ViewStack ........ 346 Wykorzystanie komponentu ViewStack do finalizacji płatności ............................353 Czego się nauczyłeś? .....................................................................................................358 Lekcja 14 Formatowanie i walidacja danych 361 Podstawowe informacje o klasach formatujących i walidujących ........................... 361 Wykorzystanie klasy Formatter do wyświetlania informacji o walucie ..................362 Korzystanie z klas walidatorów ...................................................................................366 Sprawdzanie poprawności danych za pomocą wyrażeń regularnych (część 1.) ..............368 Sprawdzanie poprawności danych za pomocą wyrażeń regularnych (część 2.) .............370 Tworzenie własnej klasy walidatora ............................................................................373 Czego się nauczyłeś? .....................................................................................................377 Lekcja 15 Zarządzanie historią i głębokie linkowanie 379 Wprowadzenie do zarządzania historią .....................................................................380 Implementowanie zarządzania historią w kontenerze nawigacyjnym ....................382 Tworzenie własnego mechanizmu zarządzania historią ...............................................383 Wprowadzenie do głębokiego linkowania .................................................................388 Głębokie linkowanie we Fleksie 3 ................................................................................388 Wykorzystanie techniki głębokiego linkowania w aplikacji ....................................388 Czego się nauczyłeś? .....................................................................................................393 Lekcja 16 Zmiana wyglądu aplikacji 396 Projekty oparte na stylach i skórkach .........................................................................396 Stosowanie stylów .........................................................................................................397 Nadawanie stylów przez atrybuty znaczników ..........................................................398 Dziedziczenie stylów .....................................................................................................400 Nadawanie stylów za pomocą znacznika mx:Style ...............................................400 Korzystanie z narzędzi wspomagających pracę ze stylami .......................................403 Nadawanie stylów za pomocą plików CSS .................................................................404 10 ADOBE FLEX 3. Oficjalny podręcznik Zmiana stylów w trakcie działania aplikacji ..............................................................414 Korzyści płynące z wczytywania stylów ......................................................................414 Tworzenie pliku SWF z arkusza CSS ...........................................................................414 Wczytywanie arkusza stylów za pomocą klasy StyleManager .................................414 Przesłanianie stylów we wczytanych plikach CSS ..................................................... 415 Tworzenie skórek dla komponentów ..........................................................................415 Skórki graficzne .............................................................................................................. 416 Importowanie skórek utworzonych w narzędziach z pakietu CS3 ......................... 416 Skórki programistyczne ................................................................................................419 Czego się nauczyłeś? .....................................................................................................423 Lekcja 17 Korzystanie z usług sieciowych 426 Komunikacja z serwerem ............................................................................................ 427 Stosowanie wywołań zdalnego modelu zdarzeń ....................................................... 428 Konfigurowanie aplikacji do lokalnej pracy ............................................................. 428 Wykorzystanie usług sieciowych w aplikacji Dashboard ......................................... 429 Obsługa wyników dostarczanych przez usługi sieciowe ..........................................432 Wywoływanie metod usług sieciowych .......................................................................434 Wykorzystanie usług sieciowych w aplikacji DataEntry ...........................................436 Korzystanie z kreatora Web Service Introspection ...................................................441 Korzystanie z wygenerowanego kodu w aplikacjach .................................................443 Refaktoryzacja we Flex Builderze ................................................................................445 Finalizowanie łączenia wygenerowanego kodu z aplikacją ..................................... 446 Uaktualnianie i usuwanie produktów ....................................................................... 447 Czego się nauczyłeś? .................................................................................................... 449 Lekcja 18 Dostęp do obiektów po stronie serwera 451 Przesyłanie plików na serwer .......................................................................................452 Integrowanie komponentu FileUpload z aplikacją DataEntry ..............................455 Korzystanie z klasy RemoteObject do zapisywania zamówienia .............................457 Aktualizowanie argumentów kompilatora Flex ........................................................459 Rozgłaszanie zdarzenia potwierdzającego proces zamawiania ...............................460 Tworzenie i wywoływanie obiektów RemoteObject .................................................460 Przekazywanie obiektu ShoppingCart do komponentu Checkout .......................464 Przywracanie aplikacji do stanu początkowego .........................................................464 Mapowanie obiektów ActionScript na obiekty serwera ........................................... 464 Kreatory dostępu do danych ....................................................................................... 467 Tworzenie projektu serwera ..........................................................................................468 Czego się nauczyłeś? .....................................................................................................471 Lekcja 19 Wizualizowanie danych 473 Komponenty wykresów we Fleksie ............................................................................. 474 Typy wykresów ................................................................................................................474 Pakiety z komponentami wykresów ............................................................................474 Elementy wykresu ..........................................................................................................475 Przygotowanie wykresów ............................................................................................. 476 ADOBE FLEX 3. Spis treści 11 Wypełnianie wykresów danymi .................................................................................. 477 Określanie serii danych dla wykresu ...........................................................................478 Dodawanie poziomych i pionowych osi do wykresów liniowych i kolumnowych ..........................................................................................................483 Dodawanie legendy do wykresu ................................................................................. 489 Ograniczanie liczby etykiet wyświetlanych na osi .................................................... 490 Interaktywność wykresów ............................................................................................491 Zdarzenia związane ze wskaźnikiem myszy ...............................................................492 Zdarzenia związane z klikaniem ..................................................................................492 Zdarzenia związane z zaznaczaniem ...........................................................................492 Dodawanie zdarzeń do wykresów .............................................................................. 492 Dodawanie animacji do wykresów ............................................................................. 496 Personalizowanie wyglądu wykresu za pomocą stylów ............................................ 498 Czego się nauczyłeś? .....................................................................................................500 Lekcja 20 Tworzenie aplikacji modułowych 503 Wprowadzenie do tworzenia modułowych aplikacji we Fleksie ..............................503 Korzystanie z modułów Fleksa ....................................................................................505 Korzystanie z klasy modułu .........................................................................................505 Wprowadzenie znacznika ModuleLoader ..................................................................507 Mechanizm RSL ............................................................................................................508 Zadania konsolidatora .................................................................................................. 510 Przechowywanie bibliotek RSL ................................................................................... 511 Cel przechowywania bibliotek ......................................................................................511 Podpisane i niepodpisane biblioteki RSL .................................................................. 512 Kontrolowanie bieżącego rozmiaru aplikacji ............................................................ 512 Dostosowanie aplikacji do korzystania z bibliotek RSL .......................................... 513 Skontrolowanie zmian dokonanych przez zastosowanie bibliotek RSL ............... 514 Tworzenie projektu biblioteki ..................................................................................... 515 Dodawanie do biblioteki klas i danych ...................................................................... 515 Wykorzystanie biblioteki w aplikacji FlexGrocer ..................................................... 516 Czego się nauczyłeś? .....................................................................................................517 Lekcja 21 Wdrażanie aplikacji Fleksa 519 Kompilowanie wdrożeniowej wersji aplikacji ............................................................520 Porzucenie okna przeglądarki i przejście do AIR ......................................................520 Rozpoczęcie pracy ze środowiskiem AIR ................................................................... 521 Instalowanie środowiska uruchomieniowego AIR ................................................... 521 Instalowanie pierwszej aplikacji ...................................................................................522 Tworzenie aplikacji AIR ...............................................................................................523 Tworzenie nowego projektu AIR .................................................................................523 Przenoszenie aplikacji Dashboard do projektu AIR ................................................525 Dostosowanie aplikacji za pomocą pliku XML .........................................................526 Eksportowanie pliku AIR .............................................................................................529 Czego się nauczyłeś? .....................................................................................................533 12 ADOBE FLEX 3. Oficjalny podręcznik Lekcja 22 Tworzenie przejść i zachowań 535 Wprowadzenie do zachowań i przejść ........................................................................535 Wykorzystanie zachowań w komponentach ..............................................................536 Wykorzystanie przejść w stanach aplikacji .................................................................538 Implementowanie efektów w komponencie ..............................................................539 Dodawanie efektów do stanów aplikacji ....................................................................541 Czego się nauczyłeś? .....................................................................................................542 Lekcja 23 Drukowanie we Fleksie 546 Wprowadzenie do drukowania we Fleksie ..................................................................547 Pierwszy wydruk z Fleksa .............................................................................................547 Korzystanie z klasy PrintDataGrid w niewidocznych kontenerach ........................549 Tworzenie widoku drukowania w osobnym komponencie ....................................553 Skalowanie drukowanego dokumentu .......................................................................555 Drukowanie potwierdzenia procesu zamawiania ......................................................559 Czego się nauczyłeś? .....................................................................................................562 Lekcja 24 Stosowanie obiektów współdzielonych 565 Wprowadzenie do obiektów współdzielonych ..........................................................565 Tworzenie obiektów współdzielonych ........................................................................566 Odczytywanie obiektów współdzielonych .................................................................568 Tworzenie obiektu współdzielonego przechowującego zawartość koszyka ............569 Odczytywanie danych z istniejącego obiektu współdzielonego ..............................571 Czego się nauczyłeś? .....................................................................................................574 Lekcja 25 Debugowanie aplikacji we Fleksie 577 Wprowadzenie do technik debugowania ...................................................................577 Śledzenie wymiany danych między klientem a serwerem .........................................578 Zaawansowane korzystanie z debugera .......................................................................579 Więcej na temat ustawiania pułapek ...........................................................................579 Inspekcja zmiennych i powiązanych wartości ...........................................................580 Obsługa błędów za pomocą instrukcji try-catch ........................................................586 Korzystanie z instrukcji try-catch ................................................................................587 Występujące typy błędów ..............................................................................................588 Korzystanie z wielu bloków catch ...............................................................................588 Przykład wykonywania tylko jednego bloku catch ...................................................589 Przykład niewłaściwego zastosowania klasy Error w pierwszym bloku catch ..............590 Korzystanie z instrukcji finally ....................................................................................590 Korzystanie z instrukcji throw ..................................................................................... 591 Tworzenie własnych klas błędów .................................................................................592 Czego się nauczyłeś? .....................................................................................................594 Lekcja 26 Profilowanie aplikacji Fleksa 597 Wykorzystanie pamięci przez Flash Player ................................................................598 Alokowanie pamięci we Flash Playerze .......................................................................598 Przekazywanie przez referencję lub przez wartość ....................................................598 ADOBE FLEX 3. Spis treści 13 Mechanizm oczyszczający pamięć we Flash Playerze ...............................................599 Oczyszczanie pamięci ....................................................................................................602 Profilowanie pamięci w aplikacjach Fleksa ............................................................... 604 Omówienie aplikacji ProfilerTest ................................................................................605 Profilowanie aplikacji ProfilerTest ..............................................................................607 Poprawianie klasy ImageDisplay ..................................................................................611 Profilowanie wydajności aplikacji Fleksa ...................................................................612 Profilowanie aplikacji ProfilerTest .............................................................................. 613 Poprawianie klasy ProfilerTest ..................................................................................... 615 Czego się nauczyłeś? ..................................................................................................... 615 Dodatek A Instalowanie oprogramowania Skorowidz 618 621 5 Obsĥuga zdarzeħ i struktury danych WaŮnû czďŎciû tworzenia bogatych aplikacji internetowych jest zbudowanie efektywnej architektury po stronie klienta. Za pomocû programu Flash Player do tworzenia aplikacji moŮna uŮyý opartego na zdarzeniach modelu programowania, tworzyý bogate modele danych po stronie klienta i tworzyý logiczne aplikacje, postďpujûc wedķug dobrych praktyk programowania zorientowanego obiektowo. Ten typ projektowania róŮni siď bardzo od metod stosowanych przez programistów aplikacji siecio- wych, poniewaŮ nie korzysta siď w nim z modelu projektowania opartego na stronie, sterowanego przepķywem. Korzystanie z opartej na zdarzeniach architektury po stronie klienta skutkuje lepiej dziaķajûcymi aplikacjami, w mniejszym stopniu obciûŮajûcymi sieý, poniewaŮ nie jest konieczne ciûgķe odŎwieŮanie strony. W tej lekcji zastosujemy techniki programowania opartego na zdarzeniach z niestandardowymi klasami ActionSriptu we Fleksie. Ukoĭczona struktura danych FlexGrocer, utworzona w jăzyku ActionScript 3.0 i zintegrowana z aplikacjï 108 ADOBE FLEX 3. Oficjalny podrýcznik Zrozumienie obsĥugi zdarzeħ Flex wykorzystuje model programowania oparty na zdarzeniach lub, inaczej, sterowany zdarzeniami. Oznacza to, Ůe zdarzenia decydujû o przebiegu dziaķania aplikacji. Na przykķad klikniďcie przez uŮytkownika przycisku lub dane zwracane z usķugi sieciowej decydujû o tym, co powinno nastûpiý w aplikacji. Zdarzenia te reprezentujû dwa typy: zdarzenia uŮytkownika (na przykķad klikniďcie myszû lub wci- Ŏniďcie klawisza) i systemowe (uruchomienie aplikacji i wyŎwietlenie jej, wyŎwietlenie niewidocznego elementu). Programista Fleksa decyduje, co powinno wydarzyý siď po wystûpieniu danego zdarzenia, obsķuguje te zdarzenia i pisze kod, który ma zostaý wykonany. Wiele osób zajmujîcych siĂ programowaniem po stronie serwera przywykĪo do modelu programowania sterowanego przepĪywem, w którym to programista decyduje o przebiegu dziaĪania aplikacji, a nie zdarzenia systemowe i ušytkownika. Oddziaķywanie uŮytkownika na aplikacjď wywoķuje szereg czynnoŎci: 1. UŮytkownik oddziaķuje na aplikacjď. 2. Obiekt, na który oddziaķuje uŮytkownik, tworzy zdarzenie. 3. Zdarzenie zostaje odczytane i uchwycone. 4. Zostaje wykonany kod powiûzany z odpowiednim uchwytem zdarzenia. Prosty przykĥad Aby uķatwiý zrozumienie tematu, przyjrzyjmy siď konkretnemu przykķadowi. Po klikniďciu przez uŮytkownika przycisku w etykiecie pojawia siď tekst: mx:Label id= myL / mx:Button id= myButton label= Click Me click= myL.text= Button Clicked / Zostaje wyŎwietlony przycisk z tekstem Click Me. Po klikniďciu przycisku przez uŮytkownika zostaje wysķane zdarzenie. W tym przypadku zostaje wykonany kod jďzyka ActionScript — myL.text= ´ Button Clicked . WķaŎciwoŎci text etykiety zostaje przypisany ķaĹcuch znakowy Button Clicked. Ten fragment kodu zawiera wartoŎci zagnieŮdŮone i dlatego konieczne jest uŮycie zagnieŮdŮonych cudzysķowów pojedynczych i podwójnych. Cudzysķowy podwójne otaczajû caķy wiersz kodu, a poje- dyncze wyodrďbniajû ķaĹcuch. Do tej pory przypisywaliŎmy wķaŎciwoŎciom wartoŎci skalarne lub powiûzania. WartoŎci skalarne to proste typy danych, takie jak ķaĹcuchy znakowe, liczby lub wartoŎci logiczne. UŮywaliŎmy ich na przykķad do okreŎlania wartoŎci wspóķrzďdnych x i y, szerokoŎci i wartoŎci wyŎwietlanych w ety- Obsĥuga zdarzeħ i struktury danych LEKCJA 5. 109 kietach. StosowaliŎmy takŮe powiûzania. Byķo tak zawsze, gdy wartoŎý byķa umieszczona w nawiasach klamrowych. W ostatniej lekcji nawiasy pozwalaķy na wprowadzenie kodu ActionScript jako wartoŎci wķaŎciwoŎci. JeŮeli wķaŎciwoŎý zostaje przypisana do zdarzenia, jest ona rozumiana przez kompilator Fleksa jako kod jďzyka ActionScript. MoŮna wiďc wpisaý kod ActionScript bezpoŎrednio jako wartoŎý zdarzenia, pomijajûc nawiasy. Widaý to we wczeŎniejszym przykķadowym kodzie: click= myL.text= Button Clicked . Podpowiadanie kodu pomaga nie tylko podczas wpisywania nazw wķaŎciwoŎci, ale takŮe nazw zdarzeĹ. Na poniŮszym rysunku widaý zdarzenia change i click ze znajdujûcû siď przed nimi ikonû bķyskawicy, która oznacza zdarzenia. Obsĥuga zdarzenia przez funkcjý jýzyka ActionScript Po klikniďciu przycisku kod uŮyty do wpisania tekstu w etykiecie dziaķa poprawnie. Pojawia siď jednak problem, gdy trzeba wpisaý wiďcej niŮ dwa wiersze kodu ActionScript, który ma zostaý wykonany w celu obsķugi zdarzenia. Po zdarzeniu click naleŮaķoby uŮyý wielu wierszy kodu oddzielonych Ŏrednikami. Taki zapis, chociaŮ prawidķowy, powoduje baķagan. Po wystûpieniu róŮnych zdarzeĹ moŮe byý wykonywany jednakowy kod. Aby zastosowaý to rozwiûzanie, trzeba skopiowaý i wkleiý ten kod w wielu miejscach, co w przypadku koniecznoŎci jego edycji wymaga wprowadzenia wielu zmian. Lepszû metodû obsķugiwania zdarzeĹ jest tworzenie funkcji w jďzyku ActionScript. Zostanie ona umieszczona w bloku mx:Script , który informuje kompilator Fleksa, Ůe kod w bloku Script jest kodem ActionScript. Zamiast wiďc umieszczaý kod ActionScript, który ma zostaý wykonany, jako wartoŎý zdarzenia click, lepiej jest wywoķaý funkcjď. PoniŮej znajduje siď kod wykonujûcy dokķadnie to samo, co zaprezentowany wczeŎniej. RóŮnica polega na tym, Ůe korzystano z zalecanej techniki umieszczania kodu, który ma zostaý wykonany w odpowiedzi na zdarzenie, w funkcji. mx:Script ![CDATA[ private function clickHandler():void { myL.text= Button Clicked ; } ]] /mx:Script 110 ADOBE FLEX 3. Oficjalny podrýcznik mx:Label id= myL / mx:Button id= myButton label= Click Me click= clickHandler() / Blok !CDATA[]] wewnîtrz bloku skryptu oznacza danî sekcjĂ jako dane znakowe. Informuje on kompilator, še zamiast kodu XML w bloku sî zawarte dane znakowe, co zabezpiecza przed wygenerowaniem bĪĂdów XML dla tego bloku. Teraz, gdy zostanie klikniďty przycisk, zostaje wywoķana funkcja clickHandler() i do etykiety zostaje wpisany ķaĹcuch znakowy. PoniewaŮ nie ma w kodzie zagnieŮdŮonych cudzysķowów, do otoczenia tekstu mogķy zostaý uŮyte cudzysķowy podwójne. Samej funkcji zostaķ nadany typ void. Oznacza to, Ůe nie zwraca ona Ůadnej wartoŎci. Bardzo dobrû praktykû jest przypisywanie funkcjom typu, nawet jeŮeli jest to typ void wskazujûcy, Ůe nie zostaje zwrócona Ůadna wartoŎý. Kompilator wyŎwietli ostrzeŮenie, jeŮeli funkcji nie zostanie nadany Ůaden typ. Przekazywanie danych podczas wywoĥania funkcji uchwytu zdarzenia Podczas wywoķywania funkcji moŮe zaistnieý potrzeba przekazania danych. W ActionScripcie dziaķa to tak, jak moŮna siď spodziewaý. Dane, które majû zostaý przekazane, sû wpisywane wewnûtrz nawia- sów nastďpujûcych po nazwie funkcji, nastďpnie uchwyt zdarzenia musi zostaý zmodyfikowany tak, by mógķ przyjûý te dane. Parametry, tak jak funkcje, równieŮ powinny posiadaý typ, który funkcja akceptuje. W poniŮszym przykķadzie aplikacja jest zmodyfikowana tak, Ůe ķaĹcuch znaków wyŎwietlany w etykiecie jest przekazywany do uchwytu zdarzenia jako parametr. mx:Script ![CDATA[ private function clickHandler(toDisplay:String):void { myL.text=toDisplay; } ]] /mx:Script mx:Label id= myL / mx:Button id= myButton label= Click Me click= clickHandler( Value Passed ) / W tym przypadku po klikniďciu przycisku do funkcji uchwytu zdarzenia zostaje przekazany ķaĹcuch Value Passed. Funkcja przyjmuje dane do parametru toDisplay, któremu zostaķ nadany typ String. WartoŎý przechowywana w zmiennej toDisplay zostaje nastďpnie wyŎwietlona jako wķaŎciwoŎý text etykiety. Obsĥuga zdarzeħ i struktury danych LEKCJA 5. 111 Tworzenie struktury danych w zdarzeniu creationComplete Zdarzenie creationComplete zostaje wysķane po utworzeniu egzemplarza elementu i jego poprawnym umieszczeniu w aplikacji. Element bďdzie widoczny w aplikacji po wystûpieniu zdarzenia creation ´Complete, chyba Ůe jego wķaŎciwoŎý visible jest ustawiona na false. Zdarzenie creationComplete obiektu gķównego Application zostaje wysķane po wysķaniu przez wszystkie jego elementy potomne (wszystkie elementy zawarte w kontenerze Application) zdarzeĹ creationComplete, które ich dotyczû. Przeanalizujmy poniŮszy fragment kodu: ?xml version= 1.0 encoding= utf-8 ? mx:Application xmlns:mx= http://www.adobe.com/2006/mxml creationComplete= addToTextArea( Application creationComplete ) mx:Script ![CDATA[ private function addToTextArea(eventText:String):void { var existingText:String=reportEvents.text; reportEvents.text=existingText+eventText+ ; } ]] /mx:Script mx:TextArea editable= false height= 100 width= 200 borderStyle= solid id= reportEvents / mx:HBox creationComplete= addToTextArea( HBox creationComplete ) mx:Label creationComplete= addToTextArea( Label creationComplete ) / mx:Button creationComplete= addToTextArea( Button creationComplete ) / /mx:HBox /mx:Application Spójrzmy najpierw na uchwyt zdarzenia nazwany addToTextArea. Przyjmuje on parametr o nazwie eventText i umieszcza go w obszarze tekstu, wprowadzajûc po nim ķamanie wiersza. Dla kaŮdego z ele- mentów, czyli Application, HBox, Label i Button, zostaje wywoķane wydarzenie creationComplete. Gdy proces tworzenia kaŮdego z elementów zostaje zakoĹczony, zdarzenie jest wysyķane i odpo- wiedni dla niego ķaĹcuch znaków zostaje przekazany do uchwytu zdarzenia w celu wyŎwietlenia w obszarze tekstowym. Flex nie tworzy elementów w kolejnoŎci od góry do doķu. NaleŮy sobie wyobraŮaý ten proces raczej jako tworzenie od Ŏrodka na zewnûtrz. Zdarzenia creationComplete sû wiďc wysyķane najpierw przez kontrolki Label i Button. Nastďpnie, skoro tworzenie elementów potomnych kontenera HBox zostaķo zakoĹczone, zdarzenie creationComplete zostaje wysķane przez HBox. W koĹcu, gdy wszystkie elementy potomne aplikacji zostaķy utworzone, sam element Application moŮe wysķaý zdarzenie creationComplete. 112 ADOBE FLEX 3. Oficjalny podrýcznik Wyniki wyŎwietlone na ekranie w obszarze tekstowym wyglûdajû tak, jak te zaprezentowane poniŮej. Teraz juŮ rozumiesz, dlaczego zdarzenie creationComplete obiektu Application jest czďsto wyko- rzystywane do pobierania danych. Kiedy wszystkie obiekty potomne obiektu Application zostanû juŮ utworzone, nadchodzi odpowiedni moment na Ůûdanie danych z zewnďtrznego Ŭródķa i wyko- rzystanie ich. W nastďpnym ýwiczeniu wprowadzimy dwie duŮe zmiany: utworzymy odwoķanie do pliku zewnďtrz- nego bďdûcego Ŭródķem danych, które zostanû osadzone w aplikacji, oraz zastosujemy uchwyt zda- rzenia do Ŏledzenia niektórych danych w celu upewnienia siď, Ůe sû one poprawnie pobierane. Najpierw zostanie okreŎlony zewnďtrzny model XML dla znacznika mx:Model . Nastďpnie zdarzenie creationComplete zostanie wykorzystane do wywoķania metody lub funkcji, która za pomocû wķasnej klasy ActionScript ostatecznie utworzy pojedyncze obiekty wartoŎci. 1. W programie Flex Builder otwórz plik srcassetsinventory.xml. Plik ten jest zbiorem danych uŮytych w poprzedniej lekcji, tylko Ůe obecnie jest plikiem zewnďtrznym. 2. Otwórz plik EComm.mxml, z którym pracowaķeŎ w poprzedniej lekcji. JeŮeli jej nie ukoĹczyķeŎ, moŮesz go otworzyý z katalogu Lekcja05start i zapisaý go w swoim folderze flexGrocersrc. 3. UsuĹ wďzķy potomne ze znacznika mx:Model oraz znacznik zamykajûcy /mx:Model . 4. Dodaj na koĹcu znacznika mx:Model ukoŎnik zamykajûcy: mx:Model id= groceryInventory / 5. Wewnûtrz znacznika mx:Model wskaŮ zewnďtrzny plik XML, okreŎlajûc wartoŎý atrybutu source jako assetsinventory.xml : mx:Model id= groceryInventory source= assets/inventory.xml / Znacznik mx:Model automatycznie przeprowadzi analizď skķadniowû danych z zewnďtrznego pliku XML do pierwotnej postaci struktury danych ActionScriptu — w tym przypadku obiektu. W lekcji 6., „UŮywanie zdalnych danych XML z kontrolkami”, napiszemy wiďcej o bardziej zķoŮonych strukturach danych. 6. Do znacznika mx:Application dodaj zdarzenie creationComplete i spraw, by wywoķywaķo ono funkcjď uchwytu zdarzenia o nazwie prodHandler(), tak jak poniŮej: mx:Application xmlns:mx= http://www.adobe.com/2006/mxml layout= absolute creationComplete= prodHandler() Obsĥuga zdarzeħ i struktury danych LEKCJA 5. 113 Jak juŮ wyjaŎniliŎmy, jeŮeli zdarzenie creationComplete znajduje siď w znaczniku mx:Application , zostaje ono wysķane dopiero po utworzeniu wszystkich elementów potomnych tego znacznika. Jest to korzystne, poniewaŮ oznacza, Ůe wszystkie elementy aplikacji sû juŮ gotowe do uŮycia. 7. PrzeŎlij do funkcji prodHandler() strukturď danych utworzonû w znaczniku mx:Model — groceryInventory: mx:Application xmlns:mx= http://www.adobe.com/2006/mxml layout= absolute creationComplete= prodHandler(groceryInventory) Identyfikator znacznika mx:Model jest równy groceryInventory. Znacznik ten utworzyķ automatycznie z pliku XML prosty obiekt jďzyka ActionScript i moŮe zostaý teraz wykorzystany do wiûzania danych. Ješeli zostaĪa utworzona zmienna lub funkcja, podczas wpisywania znacznika dostĂpna jest pomoc. W tym przypadku, wprowadzajîc nazwĂ zmiennej groceryInventory jako parametr funkcji, mošna wpisað gr, nastĂpnie wcisnîð Ctrl+spacja i wybrað nazwĂ zmiennej z listy. 8. Zaraz po istniejûcym znaczniku mx:Model dodaj blok mx:Script . ZauwaŮ, Ůe Flex Builder automatycznie dodaje znacznik CDATA. U góry bloku skryptu zdefiniuj funkcjď prywatnû typu void o nazwie prodHandler(). Musi ona przyjmowaý parametr typu Object o nazwie theItems. mx:Script ![CDATA[ private function prodHandler(theItems:Object):void { } ]] /mx:/Script Funkcja prodHandler() jest uchwytem zdarzenia creationComplete. Zostaķa okreŎlona jako prywatna, co oznacza, Ůe moŮe byý uŮywana tylko wewnûtrz klasy. Funkcja bďdzie przyjmowaķa pojedynczy parametr typu Object oraz nie bďdzie zwracaķa Ůadnej wartoŎci, poniewaŮ jako typ zwracany zostaķ okreŎlony void. 9. Wewnûtrz funkcji prodHandler() dodaj dwa wyraŮenia trace, wyŎwietlajûce nazwď i koszt elementów przekazywanych do funkcji. private function(prodHandler(theItems:Object):void { trace (theItems.prodName); trace(theItems.cost); } 10. Kliknij narzďdzie Debug, aby skompilowaý aplikacjď. Wróý do Flex Buildera. W widoku Console zostanû wyŎwietlone wyniki dziaķania wyraŮeĹ trace. W oknie konsoli powinna byý widoczna nazwa produktu i jego koszt. Bďdziesz musiaķ zminimalizowaý wyŎwietlone okno przeglûdarki oraz wybraý z menu opcjď Window/Console, jeŮeli widok Console nie jest wyŎwietlany. (Zobacz rysunek na nastďpnej stronie). 114 ADOBE FLEX 3. Oficjalny podrýcznik UŜywanie danych z obiektu Event Flex tworzy obiekt Event za kaŮdym razem, gdy zostaje wysķane zdarzenie. Obiekt ten zawiera in- formacje o zdarzeniu, które nastûpiķo. Jest tworzony automatycznie nawet wtedy, gdy nie zostanie wykorzystany. Bďdzie jednak czďsto stosowany. Zwykle obiekt zdarzenia jest wysyķany do uchwytu zdarzenia i odczytywane sû z niego wķaŎciwoŎci. Istnieje bardzo wiele rodzajów obiektów zdarzeĹ, których moŮna uŮyý. Ogólny obiekt Event jest zdefiniowany w klasie jďzyka ActionScript. Ta ogólna wersja nie bďdzie jednak dziaķaķa we wszyst- kich zdarzeniach. MoŮna siď domyŎliý, Ůe najwaŮniejsza informacja zwrócona ze zdarzenia „prze- ciûgniďcia i upuszczenia” bďdzie róŮna od najwaŮniejszej informacji zwróconej po zakoĹczeniu wywoķania usķugi sieciowej. Z tego powodu ogólna klasa Event stanowi podstawď dla wielu innych klas zdarzeĹ. Na poniŮszym rysunku widaý, jak wiele innych klas jest opartych na ogólnej klasie Event lub stanowi jej podklasy. Czy wszystkie te obiekty zdarzeĹ sû potrzebne? Potrzebne sû te zawierajûce wszystkie potrzebne informacje, ale nie ich nadmiar. Ogólny obiekt Event zawiera wķaŎciwoŎci uŮyte we wszystkich obiektach typu zdarzenie. Dwa ķatwe do zrozumienia typy to type i target. WķaŎciwoŎý type zdarzenia jest ķaĹcuchem zawierajûcym nazwď uchwyconego zdarzenia, na przykķad click lub creationComplete. WķaŎciwoŎý target wskazuje element, który wysķaķ zdarzenie, na przykķad element Button, jeŮeli zdarzenie zostaķo wysķane przed klikniďciem przycisku. Target (cel) moše wydawað siĂ dziwnym okreŁleniem tej wĪaŁciwoŁci, skoro jest to zdarzenie, które wysĪaĪo inne zdarzenie, a nie cel czegokolwiek. WyjaŁni siĂ to w lekcji 9., „Stosowanie zdarzeĬ ušytkownika”, i gdy dowiesz siĂ czegoŁ o przepĪywie zdarzeĬ. Przyjrzyjmy siď poniŮszemu kodowi, który wysyķa obiekt zdarzenia, w tym przypadku obiekt MouseEvent, do uchwytu zdarzenia. Obsĥuga zdarzeħ i struktury danych LEKCJA 5. 115 mx:Script ![CDATA[ private function clickHandler(event:MouseEvent):void { trace(event.type); } ]] /mx/Script mx:Label id= myL / mx:Button id= myButton label= Click Me click= clickHandler(event) / W powyŮszym kodzie zdarzenie zostaje wysķane do uchwytu zdarzenia i podczas debugowania aplikacji w widoku Console zostaje wyŎwietlone sķowo click. ChociaŮ obiekt Event nie jest uŮywany w Ůadnym miejscu tworzonych obecnie aplikacji, zrozumienie, do czego sķuŮy, jest niezbďdne. W zwiûzku z tym, chociaŮ obiekt ten nie jest zawarty w Ůadnej z trzech aplikacji tworzonych podczas pracy z ksiûŮkû, w poniŮszym ýwiczeniu zastosujemy go. 1. Wybierz z menu File/New/Flex Project. Nadaj projektowi nazwď EventObject. 2. Ustal lokalizacjď pliku projektu jako flexopLekcja05eventObjectstart. 3. Jako typ aplikacji wybierz Web application. 4. Ustaw technologiď serwera jako none, a nastďpnie kliknij Next. 5. Pozostaw typ folderu wyjŎciowego bin-debug i kliknij Next. 6. Pozostaw src jako gķówny folder Ŭródķowy. 7. Przeszukaj opcjď Main application file i zaznacz EventTest.mxml. Kliknij Finish. WķaŎnie utworzyķeŎ projekt. MoŮesz uruchomiý aplikacjď, która bďdzie wykorzystywana do eksperymentowania z obiektem zdarzenia. Plik ten jest tylko szkieletem aplikacji z dodanym blokiem Script. 8. Dodaj przycisk pomiďdzy zamykajûcym znacznikiem /mx:Script a koĹcem aplikacji. Nadaj przyciskowi za pomocû wķaŎciwoŎci id nazwď egzemplarza myButton. Dodaj wķaŎciwoŎý label o wartoŎci Click To Debug. Dodaj zdarzenie click i spowoduj, by wywoķywaķo ono uchwyt zdarzenia o nazwie doClick(), przesyķajûcy obiekt zdarzenia w formie parametru: mx:Button id= myButton label= Click To Debug click= doClick(event) / Kiedy zostanie klikniďty przycisk, zostanie wywoķana funkcja doClick() i zostanie do niej wysķany obiekt event. 9. W bloku skryptu dodaj prywatnû funkcjď typu void o nazwie doClick(). Przyjmij parametr typu MouseEvent o nazwie event, tak jak poniŮej: 116 ADOBE FLEX 3. Oficjalny podrýcznik private function doClick(event:MouseEvent):void { } Mošna przyjîð spójne nazewnictwo dla uchwytów zdarzeĬ. Na przykĪad w tej lekcji ušywane jest zdarzenie click obsĪugiwane przez uchwyty zdarzeĬ o nazwach clickHandler() i doClick(). Nie istnieje jedyna sĪuszna metoda nadawania nazw uchwytom zdarzeĬ, mošna jednak wybrað sobie konwencjĂ nazewnictwa i trzymað siĂ jej. W nastďpnym kroku uŮyjemy wbudowanego w program Flex Builder debugera w najprostszy sposób. Debuger zostanie dokķadnie omówiony w lekcji 25., „Debugowanie aplikacji we Fleksie”. Tutaj uŮyjemy go do przyjrzenia siď obiektowi zdarzenia. 10. Dodaj punkt przerwania programu na zamykajûcym funkcjď nawiasie klamrowym, dwukrotnie klikajûc pasek znaczników po lewej stronie kodu i numerów wierszy. Na pasku pojawi siď maķy niebieski punkt wskazujûcy miejsce, w którym zostanie wstrzymane wykonanie programu. W tym punkcie moŮna przyjrzeý siď aktualnym wartoŎciom. Debuger jest niesamowicie pomocny w zrozumieniu tego, co dzieje siď w aplikacji Fleksa, dlatego warto czďsto go uŮywaý. 11. Kliknij przycisk Debug interfejsu programu Flex Builder. 12. W przeglûdarce kliknij przycisk z etykietû Click To Debug. We Flex Builderze zostaniesz poproszony o skorzystanie z perspektywy Debugging. PowinieneŎ to zrobiý. 13. Kliknij dwukrotnie belkď widoku Variables, aby wyŎwietliý jû w trybie peķnoekranowym. Okno zawiera wiele informacji i przejŎcie do widoku peķnoekranowego uķatwi ich przeglûdanie. 14. Zostanû wyŎwietlone dwie zmienne: this i event (tak jak poniŮej). Obsĥuga zdarzeħ i struktury danych LEKCJA 5. 117 Zmienna this reprezentuje caķû aplikacjď. JeŮeli klikniesz znajdujûcy siď przed niû znak +, zobaczysz wiele wķaŎciwoŎci i skojarzonych wartoŎci. Zmienna event reprezentuje zmiennû zdarzenia lokalnû dla funkcji, w której zostaķ wstawiony punkt przerwania. Litera L umieszczona w ikonie po lewej stronie zmiennej event wskazuje, Ůe jest to zmienna lokalna. 15. Kliknij znak + przed zmiennû event, a nastďpnie znak + przed zestawem wķaŎciwoŎci [inherited]. ZnajdŬ wķaŎciwoŎý target. Zwróý uwagď, Ůe target jest elementem wysyķajûcym zdarzenie Button. ZauwaŮ takŮe, Ůe wķaŎciwoŎý type ma wartoŎý click. Wszystkie te wartoŎci zostaķy juŮ omówione. 16. Kliknij znak + przed target, nastďpnie kliknij znak + przed zestawem wķaŎciwoŎci [inherited] i znajdŬ wķaŎciwoŎý id. ZauwaŮ, Ůe wartoŎciû wķaŎciwoŎci jest myButton, tak jak zostaķo to wpisane w kodzie. 17. Przywróý widok Variables, klikajûc dwukrotnie jego belkď. Kliknij czerwony kwadracik w widoku Debug lub Console, by zakoĹczyý debugowanie. Nie zapominaj o tym, aby zakoĹczyý sesjď debugowania. MoŮliwe jest dziaķanie jednej sesji debugowania w innej. MoŮe byý to przydatne w pewnych przypadkach, nie jest jednak zalecane. 18. Wróý do perspektywy Development, klikajûc znak w prawym górnym rogu ekranu i wybierajûc Flex Development. Ješeli umieŁcisz kursor z lewej strony ikony Open Perspective, pojawi siĂ podwójna strzaĪka. Mošesz kliknîð i przeciîgnîð okno w lewo w celu zwiĂkszenia iloŁci miejsca przydzielonego perspektywom. BĂdzie widoczna zarówno perspektywa Development, jak i Debugging, i bĂdzie mošna Īatwo przeĪîczað siĂ miĂdzy nimi, klikajîc ich zakĪadki. 19. Zamknij projekt EventObject i wróý do projektu FlexGrocer. 118 ADOBE FLEX 3. Oficjalny podrýcznik Tworzenie wĥasnej klasy jýzyka ActionScript Jak wspomniano pod koniec lekcji 2., ksiûŮka ta nie jest podrďcznikiem programowania zoriento- wanego obiektowo, kaŮdy programista Fleksa musi jednak chociaŮ w podstawowym stopniu znaý specjalistycznû terminologiď. JeŮeli wiďc nie sû Ci znane takie wyraŮenia, jak klasa, obiekt, wIJaʼnciwoʼnø i metoda, nadszedķ najwyŮszy czas, by skorzystaý z setek, jeŮeli nie tysiďcy, publikacji wprowadzajû- cych do programowania zorientowanego obiektowo. TworzyliŎmy juŮ wķasne klasy jďzyka ActionScript podczas pracy z tû ksiûŮkû, choý mogķeŎ o tym nie wiedzieý, poniewaŮ Flex ukrywa je przed programistû. Podczas tworzenia aplikacji w jďzyku MXML tworzymy tak naprawdď nowû klasď jďzyka ActionScript. Kod MXML jest poķûczony z kodem ActionScript w bloku skryptu i jest tworzona czysta klasa jďzyka ActionScript skompilowana do pliku .swf, gotowego do uŮycia przez program Flash Player. W ostatnim ýwiczeniu po utworzeniu EventTest.mxml powstaķ wiďc plik EventTest-generated.as zawierajûcy poniŮszy kod: public class EventTest extends mx.core.Application W wyniku utworzenia EventTest.mxml zostaķa rozszerzona klasa Application, tak jak w wyniku utworzenia kaŮdej z aplikacji w tej ksiûŮce. Aby widzieð tworzony kod jĂzyka ActionScript, nalešy dodað argument kompilatora we Flex Builderze. Przejdş do Project/Properties/Flex Compiler/Additional compiler arguments (projekt/wĪaŁciwoŁci/kompilator Fleksa/dodatkowe argumenty kompilatora) i dodaj na koĬcu istniejîcych argumentów tekst -keep-generated-actionscript. W projekcie zostanie automatycznie utworzony katalog generated, a w nim — wiele plików jĂzyka ActionScript. Aktualne pliki aplikacji znajdujî siĂ w formularzu Name-generated.as. Nie zapomnij o usuniĂciu argumentu kompilatora po zakoĬczeniu sprawdzania. W tej czďŎci lekcji zbudujemy klasy jďzyka ActionScript bezpoŎrednio w tym jďzyku, nie korzystajûc z konwersji kodu MXML na kod ActionScript przez Fleksa. Po co siď to robi? Tworzenie klas jďzyka ActionScript jest niezbďdne do wykonania niektórych ýwi- czeĹ przedstawionych w tej ksiûŮce, wliczajûc w to tworzenie wķasnych klas zdarzeĹ oraz obiektów wartoŎci. Niedawno poznaliŎmy obiekty zdarzeĹ. W lekcji 9. utworzymy obiekty zdarzeĹ do prze- chowywania okreŎlonych danych i tworzenie wķasnych klas jďzyka ActionScript bďdzie wówczas konieczne. Tworzenie obiektu wartoļci Obiekty wartoʼnci (value objects, nazywane równieŮ obiektami transferu danych — DTO), lub po prostu obiekty transferu, przechowujû dowolne dane zwiûzane z obiektem, nie zawierajû szczegóķowego kodu i logiki biznesowej oraz sû wdroŮone jako klasy ActionScript. Nazwa obiektów transferu jest zwiûzana z tym, Ůe czďsto sķuŮû one do przesyķania danych do zaplecza aplikacji w celu zachowania ich na staķe w bazie danych. W tej lekcji utworzymy obiekty wartoŎci dla produktów spoŮywczych, produktu przeniesionego do koszyka na zakupy oraz samego koszyka. Najpierw jednak omówimy podstawy tworzenia klasy jďzyka ActionScript. PoniŮej zostaķa poka- zana bardzo prosta klasa: Obsĥuga zdarzeħ i struktury danych LEKCJA 5. 119 W linii A wyraŮenie package reprezentuje strukturď katalogu, w którym jest przechowywana klasa. Plik jest przechowywany w katalogu grocery/product w strukturze plików aplikacji. W linii B klasie zostaje nadana nazwa Fruit. Musi to odpowiadaý nazwie pliku — Fruit.as. W linii C zostaķy zadeklarowane wķasnoŎci klasy. MoŮe ich byý wiele. Linia D zawiera konstruktor klasy. Jest on wywoķywany automatycznie, gdy tworzony jest nowy egzemplarz obiektu klasy. Nazwa funkcji konstruktora klasy musi byý taka sama jak nazwa klasy, która z kolei jest taka sama jak nazwa pliku. Funkcja ta musi byý funkcjû publicznû i nie moŮe mieý nadanego typu. W linii E zostaķy zdefiniowane metody klasy. MoŮe zostaý zadeklarowanych wiele metod. W aplikacji FlexGrocer trzeba zarzûdzaý wielkimi iloŎciami danych i przesyķaý je do innych apli- kacji. W kolejnym ýwiczeniu utworzymy obiekt wartoŎci przechowujûcy informacje o produkcie spoŮywczym. 1. Utwórz nowy plik klasy jďzyka ActionScript, wybierajûc z menu File/New/ActionScript class (plik/nowy/klasa ActionScript). W polu Package wpisz valueObjects, co spowoduje automatyczne utworzenie przez Flex Builder katalogu o tej samej nazwie. Nazwij klasď Product i pozostaw wartoŎci domyŎlne wszystkich pozostaķych pól. Kliknij Finish, aby utworzyý plik. Zostaje utworzony plik o nazwie Product.as, zawierajûcy podstawowû strukturď klasy jďzyka ActionScript. WyraŮenia package i class sû sķowami kluczowymi uŮytymi w definicji tej klasy. NaleŮy pamiďtaý, Ůe bďdzie ona podstaw
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Adobe Flex 3. Oficjalny podręcznik
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ą: