reklama - zainteresowany?

Adobe Flex 4. Oficjalny podręcznik - Helion


Autor: Michael Labriola, Jeff Tapper, Matthew Boles
Tytuł oryginału: Adobe Flex 4: Training from the Source, Volume 1
Tłumaczenie: Aleksander Lamża
ISBN: 978-83-246-2884-1
stron: 448, Format: B5, okładka: miękka
Data wydania: 2011-04-15
Księgarnia: Helion

Cena książki: 23,90 zł (poprzednio: 74,69 zł)
Oszczędzasz: 68% (-50,79 zł)

Dodaj do koszyka

Tagi: FLEX

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

Dodaj do koszyka

 

Osoby które kupowały "Adobe Flex 4. Oficjalny podręcznik", wybierały także:

  • Hello! Flex 4
  • Flex 3.0. Tworzenie efektownych aplikacji
  • Android na tablecie. Receptury
  • Hello! Flex 4
  • Android w praktyce. Projektowanie aplikacji

Dodaj do koszyka

Spis treści

Adobe Flex 4. Oficjalny podręcznik -- spis treści

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 <mx:Style> (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)

Dodaj do koszyka

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2020 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.