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ą!

O autorach (15) Wstęp (17) Wprowadzenie (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)
• 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)
• 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)

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)

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)
• 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)
• 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)

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)
  • 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 (618) Skorowidz (621)