Przedmiotem aukcji jest:

Adobe Flex 4. Oficjalny podręcznik

• 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

• 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Zobacz nasze pozostałe aukcje

Dodaj nas do ulubionych sprzedawców

Zapraszamy serdecznie.