Książki

informatyka

programowanie

Adobe Flex 4. Oficjalny podręcznik

Opis książki Adobe Flex 4. Oficjalny podręcznik:

Naucz się tworzyć efektowne aplikacje internetowe dzięki możliwościom Adobe Flex 4!

Tworzenie własnych komponentów, nadawanie im stylów i skórek
Praca nad aplikacjami z wykorzystaniem środowiska Flash Builder
Wydajny, zorientowany obiektowo język ActionScript 3.0

Adobe Flex 4 to najnowszy zestaw technologii służących do tworzenia bogatych aplikacji internetowych. Ta wydajna i bezpłatna struktura programistyczna to istne novum na rynku programów webowych. Flex pozwala na tworzenie prawdziwie dynamicznych i interaktywnych aplikacji o olbrzymich możliwościach. A to wszystko bez konieczności rezygnowania ze wspaniałej grafiki!

Dzięki książce "Adobe Flex 4. Oficjalny podręcznik" stopniowo, krok po kroku, nauczysz się tworzyć aplikacje w językach MXML oraz ActionScript 3.0. Znajdziesz tu omówienie nowości wprowadzonych we Fleksie 4, takich jak komponenty Spark, nowe, zaawansowane techniki tworzenia skórek oraz wiele innych. Poznasz możliwości pracy w środowisku Flex Builder oraz dowiesz się, jak tworzyć interfejsy użytkownika. Zapoznasz się z wiedzą na temat kontrolek, obsługi zdarzeń, stosowania techniki "przeciągnij i upuść", tworzenia nawigacji czy też zmiany wyglądu Twojej aplikacji za pomocą stylów. Pamiętaj, że masz przed sobą najlepszy podręcznik technologii Flex, napisany przez zespół specjalistów posiadających olbrzymie doświadczenie w prowadzeniu kursów programowania, konsultacji i wszelkich działań wspomagających programistów i projektantów.

Flash Builder
Tworzenie interfejsu użytkownika
Stosowanie kontrolek
Obsługa zdarzeń
ActionScript i MXML
Tworzenie komponentów
Siatki danych
Rendering elementów
Stosowanie mechanizmu "przeciągnij i upuść"
Style i skórki

Skorzystaj z niesamowitych możliwości Fleksa 4 i stwórz swoją wyjątkową aplikację internetową!

Spis treści: Rozwiń >>

O autorach (11)

Wstęp (13)

Wprowadzenie (15)

Lekcja 1. Wprowadzenie do bogatych aplikacji internetowych (27)

Rozwój aplikacji komputerowych (27)
Odejście od architektury opartej na stronie internetowej (29)
Zalety bogatych aplikacji internetowych (31)
Menedżerowie przedsiębiorstw (31)
Przedsiębiorstwa branży IT (31)
Użytkownicy końcowi (31)
Technologie bogatych aplikacji internetowych (32)
Asynchroniczny JavaScript i XML (AJAX) (32)
Wirtualna maszyna Javy (33)
Microsoft Silverlight (33)
Platforma Adobe Flash (34)
Czego się nauczyłeś? (37)

Lekcja 2. Zaczynamy (39)

Wstęp do tworzenia fleksowych aplikacji (40)
Tworzenie projektu i aplikacji MXML (40)
Obszar roboczy Flash Buildera (45)
Uruchamianie aplikacji (48)
Korzystanie z debugera programu Flash Builder (53)
Przygotuj się do kolejnych lekcji (60)
Czego się nauczyłeś? (62)

Lekcja 3. Projektowanie interfejsu użytkownika (65)

Layout aplikacji (65)
Kontenery (66)
Obiekty layoutu (66)
Łączenie kontenerów i obiektów layoutu (67)
Przewijanie zawartości (68)
Budowa znaczników MXML (68)
Tworzenie layoutu sklepu internetowego (69)
Tworzenie zarysu layoutu w trybie edycji źródła (70)
Praca nad layoutem w trybie projektowania (72)
Definiowanie sekcji produktów (75)
Praca z layoutami opartymi na więzach (76)
Praca ze stanami widoku (81)
Tworzenie stanów widoku (81)
Sterowanie stanami widoku (84)
Refaktoryzacja (86)
Stosowanie złożonych kontenerów (88)
Refaktoryzacja kodu aplikacji (89)
Czego się nauczyłeś? (90)

Lekcja 4. Stosowanie prostych kontrolek (93)

Wprowadzenie do prostych kontrolek (94)
Wyświetlanie obrazów (95)
Tworzenie widoku szczegółów (98)
Korzystanie z wiązania danych do powiązania struktury danych z prostą kontrolką (101)
Wykorzystanie kontenera Form do umieszczania prostych kontrolek (102)
Czego się nauczyłeś? (105)

Lekcja 5. Obsługa zdarzeń (107)

Wprowadzenie do obsługi zdarzeń (107)
Prosty przykład (109)
Obsługa zdarzenia przez funkcję języka ActionScript (110)
Przekazywanie danych podczas wywoływania funkcji obsługi zdarzenia (111)
Używanie danych z obiektu zdarzenia (111)
Dokonywanie inspekcji obiektu zdarzenia (114)
Obsługa zdarzeń systemowych (117)
Zdarzenie creationComplete (117)
Modyfikowanie danych w zdarzeniu creationComplete (118)
Czego się nauczyłeś? (120)

Lekcja 6. Korzystanie ze zdalnych danych XML (123)

Osadzanie danych XML (123)
Umieszczenie modelu poza aplikacją (124)
Wybór między obiektami a XML-em (126)
Ładowanie danych XML w trakcie działania programu (129)
Tworzenie obiektu HTTPService (129)
Wywoływanie metody send() (130)
Uzyskiwanie dostępu do otrzymanych danych (130)
Problemy związane z bezpieczeństwem (131)
Pobieranie danych XML za pośrednictwem obiektu HTTPService (133)
Przeszukiwanie XML-a za pomocą E4X (135)
Operatory E4X (136)
Korzystanie z dynamicznych danych XML (141)
Używanie obiektu XMLListCollection z kontrolką List (145)
Czego się nauczyłeś? (147)

Lekcja 7. Tworzenie klas (149)

Tworzenie własnej klasy w języku ActionScript (149)
Tworzenie obiektu wartości (150)
Przygotowanie metody tworzącej obiekt (156)
Tworzenie klas koszyka na zakupy (159)
Manipulowanie danymi w klasie ShoppingCart (164)
Dodawanie produktów do koszyka (164)
Dodawanie pozycji czy uaktualnianie liczby sztuk? (166)
Warunkowe dodawanie pozycji do koszyka (166)
Czego się nauczyłeś? (171)

Lekcja 8. Stosowanie wiązania danych i kolekcji (173)

Zasada działania mechanizmu wiązania danych (173)
Prosty przykład (174)
Bardziej skomplikowany przykład (177)
Mechanizm wiązania danych z perspektywy kompilatora (179)
Metody dostępowe set i get (180)
Rozgłaszanie i nasłuchiwanie zdarzeń (181)
Zdarzenia w mechanizmie wiązania danych (182)
Podsumowanie informacji o wiązaniu danych (184)
Korzystanie z klasy ArrayCollection (184)
Wypełnianie obiektu ArrayCollection danymi (185)
Korzystanie z danych zapisanych w kolekcji ArrayCollection (191)
Sortowanie elementów kolekcji ArrayCollection (193)
Refaktoryzacja kodu - wyszukiwanie za pomocą kursora (197)
Usuwanie elementów z wykorzystaniem kursora (200)
Filtrowanie kolekcji ArrayCollection (201)
Refaktoryzacja klasy ShoppingCartItem (202)
Czego się nauczyłeś? (204)

Lekcja 9. Tworzenie komponentów (207)

Wprowadzenie w tematykę komponentów MXML (208)
Zasady tworzenia komponentów (209)
Tworzenie własnego komponentu (209)
Własne komponenty a architektura aplikacji (211)
Tworzenie komponentu ShoppingView (213)
Tworzenie komponentu ProductItem (218)
Tworzenie komponentów zarządzających pobieraniem danych (226)
Czego się nauczyłeś? (233)

Lekcja 10. Korzystanie z komponentów DataGroup oraz List (235)

Korzystanie z komponentów List (236)
Właściwość labelFunction klasy List (236)
Korzystanie z komponentów DataGroup (238)
Implementacja renderera elementów (239)
Zastosowanie komponentu DataGroup w klasie ShoppingView (243)
Wirtualizacja (246)
Implementowanie wirtualizacji (246)
Wirtualizacja w komponentach List (247)
Wyświetlanie produktów z wybranej kategorii (249)
Filtrowanie produktów pod względem kategorii (249)
Wykorzystanie zdarzenia change komponentu List (250)
Czego się nauczyłeś? (251)

Lekcja 11. Tworzenie i rozgłaszanie zdarzeń (253)

Korzyści ze stosowania luźno powiązanej architektury (253)
Rozsyłanie zdarzeń (255)
Deklarowanie zdarzeń komponentu (258)
Kiedy przydają się klasy niestandardowych zdarzeń (260)
Tworzenie i używanie zdarzenia UserAcknowledgeEvent (261)
Strumień zdarzenia i faza propagacji (264)
Tworzenie i używanie klasy ProductEvent (269)
Tworzenie komponentu ProductList (271)
Korzystanie z komponentu ProductList (273)
Korzystanie ze zdarzenia ProductEvent podczas dodawania i usuwania produktów (274)
Obsługa zdarzenia COLLECTION_CHANGE (275)
Czego się nauczyłeś? (277)

Lekcja 12. Stosowanie siatek danych i rendererów elementów (279)

Dwa zestawy kontrolek: Spark i MX (280)
Komponent DataGrid i renderery elementów (280)
Wyświetlanie koszyka na zakupy w kontrolce DataGrid (281)
Korzystanie z komponentu CartGrid (283)
Dodawanie kontrolek edycji do DataGridColumn (283)
Tworzenie renderera elementów służącego do wyświetlenia informacji o produkcie (285)
Tworzenie renderera elementów służącego do wyświetlenia przycisku Remove (287)
Ponowne wykorzystanie klasy ProductEvent (289)
Wykorzystanie właściwości labelFunction do wyświetlania wartości produktów (290)
Używanie komponentu AdvancedDataGrid (292)
Sortowanie zawartości kontrolki AdvancedDataGrid (292)
Sortowanie w trybie zaawansowanym (293)
Nadawanie stylów komponentowi AdvancedDataGrid (294)
Grupowanie danych (298)
Wyświetlanie danych podsumowujących (303)
Czego się nauczyłeś? (311)

Lekcja 13. Obsługa techniki "przeciągnij i upuść" (313)

Zasada działania menedżera przeciągania i upuszczania (314)
Przeciąganie i upuszczanie między dwoma komponentami DataGrid (315)
Przeciąganie i upuszczanie między siatką danych i listą (317)
Stosowanie mechanizmu "przeciągnij i upuść" w komponentach, które go nie obsługują (322)
Przeciąganie produktu do koszyka na zakupy (327)
Czego się nauczyłeś? (332)

Lekcja 14. Tworzenie nawigacji (335)

Wprowadzenie do nawigacji (335)
Przygotowanie procesu dokonywania płatności wyświetlanego w kontenerze ViewStack (337)
Integrowanie aplikacji z komponentem CheckOutView (342)
Czego się nauczyłeś? (344)

Lekcja 15. Formatowanie i walidacja danych (347)

Podstawowe informacje o klasach formatujących i walidujących (347)
Klasy formatujące (348)
Klasy walidujące (348)
Korzystanie z klas formatujących (349)
Korzystanie z dwustronnego wiązania danych (352)
Korzystanie z klas walidatorów (353)
Czego się nauczyłeś? (356)

Lekcja 16. Zmiana wyglądu aplikacji za pomocą stylów (359)

Wprowadzenie projektu graficznego aplikacji za pomocą stylów i skórek (359)
Przygotowanie aplikacji na zmiany (360)
Stosowanie stylów (361)
Nadawanie stylów przez atrybuty znaczników (362)
Dziedziczenie stylów (364)
Nadawanie stylów za pomocą znacznika (365)
Nadawanie stylów za pomocą plików CSS (368)
Definiowanie stylów dla pozostałych elementów aplikacji (371)
Zmiana stylów w trakcie działania aplikacji (377)
Korzyści płynące z wczytywania stylów (378)
Tworzenie pliku SWF z arkusza CSS (378)
Wczytywanie arkusza stylów za pomocą klasy StyleManager (379)
Przesłanianie stylów we wczytanych plikach CSS (379)
Czego się nauczyłeś? (379)

Lekcja 17. Zmiana wyglądu aplikacji za pomocą skórek (381)

Skórki komponentów Spark (381)
Powiązanie między skórkami i stanami (385)
Rysowanie we Fleksie (385)
Definiowanie wyglądu przycisku w różnych stanach (389)
Tworzenie skórki dla aplikacji (393)
Czego się nauczyłeś? (397)

Lekcja 18. Tworzenie komponentów w języku ActionScript (399)

Komponenty tworzone w języku ActionScript (400)
Tworzenie komponentów może być skomplikowane (400)
Komponenty od środka (401)
Po co tworzyć komponenty? (402)
Definiowanie komponentu (403)
Definiowanie interfejsu (404)
Wybór klasy bazowej (405)
Tworzenie klasy (406)
Używanie zdefiniowanej klasy (408)
Tworzenie części wizualnej (410)
Określenie wymagań dotyczących skórki (410)
Tworzenie skórki (412)
Dodawanie funkcjonalności do komponentu (416)
Asynchroniczna praca komponentów (416)
Komunikowanie się za pomocą zdarzeń (421)
Sprzątanie po sobie (424)
Tworzenie renderera dla skórki (426)
Czego się nauczyłeś? (428)

Dodatek A: Przygotowanie do pracy (432)

Instalowanie oprogramowania (432)
Instalowanie środowiska Flash Builder (432)
Kopiowanie plików lekcji (432)
Instalowanie odtwarzacza Flash Player z możliwością debugowania (433)
Importowanie projektów (434)
Importowanie plików lekcji (434)

Skorowidz (437)

Fragment książki: Rozwiń >>

Refaktoryzacja
Refaktoryzacja jest jednym z najmniej znanych, a zarazem jednym z najbardziej użytecznych narzędzi
dostępnych dla programistów. Programiści Fleksa i języka ActionScript powinni je szczególnie docenią,
ponieważ podczas tworzenia prototypów i kolejnych faz projektów zawierających dynamiczne interfejsy
często dochodzi do zmian.
Refaktoryzacja jest procesem, w którym dochodzi do reorganizacji kodu bez ingerencji w jego funkcjonowanie,
dzięki czemu łatwiej go utrzymywać i modyfikować w przyszłości. O aplikacji trzeba myśleć
długofalowo — trzeba będzie ją poprawiać, zmieniać architekturę w celu dopasowania do nowych
możliwości oraz, co ważne, przygotować na zmianę zespołu programistów. Zawsze jednak musi obowiązywać
zasada: po pomyślnym zakończeniu procesu refaktoryzacji użytkownik niemający wglądu
do kodu nie powinien zauważyć żadnej zmiany w funkcjonowaniu aplikacji.
Wielu programistów uważa ten pogląd za niesłuszny, a samą refaktoryzację za zbędną. Po co spędzać
dużo czasu na modyfikowaniu kodu, który się właśnie napisało, skoro nie przyniesie to żadnych
zmian w funkcjonowaniu aplikacji? Na tak postawione pytanie można odpowiedzieć na wiele sposobów.
Poniżej kilka możliwych argumentów.
-Wartości edukacyjne. Nauka nowego języka i późniejsze jego używanie wymaga ciągłego
poszerzania wiedzy. Każdego dnia zdobywa się nowe umiejętności i poznaje nowe techniki.
Prowadzi to często do konstatacji, że kod napisany kilka dni, tygodni lub miesięcy temu jest

le napisany, a może nawet nie działa prawidłowo w niektórych sytuacjach. Analizowanie
napisanego wcześniej kodu połączone z chęcią wprowadzania zmian może pomóc w tworzeniu
dużo lepszego kodu, bardziej spójnego i przygotowanego na modyfikacje.
ę Powielanie kodu. Podczas programowania bardzo często zdarza się sytuacja, w której w wielu
miejscach aplikacji wymagane jest przeprowadzenie tych samych operacji. Niestety z uwagi
na pośpiech typowym rozwiązaniem jest powielanie fragmentów kodu. Najpoważniejszy
problem wynikający z takiego postępowania pojawia się wtedy, gdy do kodu trzeba wprowadzić
jakieś poprawki. Programista musi wprowadzić zmiany we wszystkich wystąpieniach powielonego
kodu. Najistotniejsze jest unikanie za wszelką cenę powielania kodu. Dzięki temu zaoszczędzimy
dużo czasu, a programowanie stanie się zdecydowanie bardziej efektywne.
ę Spojrzenie z szerszej perspektywy. Niekiedy na początku pisania kodu trudno jest przewidzieć
(o ile to w ogóle możliwe), jak będzie zbudowana cała aplikacja i jak jej elementy będą ze sobą
współpracować. Jeżeli fragmenty kodu napisane wcześniej są „niemodyfikowalne”, podczas
próby połączenia ich z innymi elementami aplikacji może się okazać, że konieczne będzie
zupełne przebudowanie fragmentów programu. Jeżeli będziesz regularnie refaktoryzował kod,
możesz na bieżąco „szlifować” poszczególne elementy, tak aby pod koniec tworzenia aplikacji
wszystko do siebie pasowało.