actionscript. przewodnik encyklopedyczny

Wydawnictwo Helion

ul. Chopina 6

44-100 Gliwice

tel. (32)230-98-63

e-mail: [email protected]

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TRE�CISPIS TRE�CI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

ActionScript. Przewodnik

encyklopedyczny

Autor: Colin Moock

T³umaczenie: Marek Binkowski, Ryszard Glego³a,

Bohdan G³êbocki, Rafa³ Joñca, Joanna Pasek,

Wojciech Pazdur

ISBN: 83-7197-903-7

Tytu³ orygina³u: ActionScript The Definitive Guide

Format: B5, stron: 760

Flash jest ju¿ standardem dla sieciowych multimediów, dostêpnych dla ponad 250

milionów u¿ytkowników na ca³ym �wiecie. Ksi¹¿ka „ActionScript. Przewodnik

encyklopedyczny” to pe³na dokumentacja jêzyka ActionScript — zorientowanego

obiektowo jêzyka programowania, bêd¹cego podstawowym narzêdziem tworzenia

zaawansowanych witryn internetowych dla programistów Flasha. Jest kierowana zarówno

do projektantów i grafików, którzy dopiero ucz¹ siê programowania, jak i do programistów

JavaScript, którzy chc¹ przenie�æ swoje umiejêtno�ci na jêzyk ActionScript (oba te jêzyki

opieraj¹ siê na tym samym standardzie ECMAScript).

Colin Moock nieraz ju¿ dowiód³ umiejêtno�ci przekazywania swojej szerokiej wiedzy

w praktyczny i przystêpny sposób. W pe³ni zas³u¿y³ sobie na uznanie, jakim darz¹ go

u¿ytkownicy Flasha.

W pierwszej czê�ci ksi¹¿ki opisano podstawowe zagadnienia programistyczne (zmienne,

typy danych, operatory, wyra¿enia, funkcje, zdarzenia, tablice i obiekty), po�wiêcaj¹c du¿o

uwagi ich wykorzystaniu, szczególnie w obróbce klipów filmowych. Druga czê�æ jest

po�wiêcona typowym zastosowaniom ActionScriptu, takim jak przetwarzanie formularzy

sieciowych. Trzecia czê�æ, stanowi¹ca leksykon jêzyka, zawiera opis zmiennych

globalnych, w³a�ciwo�ci, metod, detektorów zdarzeñ i obiektów wraz z przyk³adami ich

u¿ycia.

Korzystaj¹c z tej ksi¹¿ki szybko opanujesz jêzyk ActionScript. Prócz teorii znajdziesz tu

praktyczne wskazówki i przyk³ady prezentuj¹ce tworzenie pól tekstowych, przycisków

menu, quizów, witryn opartych o dokumenty XML, gier, w których obowi¹zuj¹ zasady

praw fizyki, �rodowisk dla wielu u¿ytkowników dzia³aj¹cych w czasie rzeczywistym i wielu

innych. Skrupulatne opisy poruszaj¹ wiele nieudokumentowanych lub niezbadanych

dotychczas tematów.

„Najlepsza ksi¹¿ka o jêzyku ActionScript, jak¹ widzia³em. Trudno znale�æ gdzie indziej

wiêcej informacji na temat tego jêzyka”.

— Slavik Lozben, g³ówny in¿ynier Flasha w firmie Macromedia

http://helion.pl/view/2547w



http://helion.pl/view/2547w/acscpe.htm




mailto:[email protected]

http://helion.pl/view/2547w/acscpe.htm

http://www.amazon.com/exec/obidos/ASIN/1565928520

Spis treści

Słowo wstępne.................................................................................................. 13

Wstęp ................................................................................................................ 17

Część I Podstawy ActionScript.........................................................23

Rozdział 1. Jeżeli nie jesteś programistą... ..................................................... 25

Kilka podstawowych zwrotów ............................................................................................. 27

Następne pojęcia ActionScript............................................................................................... 36

Budujemy quiz ...................................................................................................................... 44

Naprzód! ............................................................................................................................... 58

Rozdział 2. Zmienne......................................................................................... 59

Tworzenie zmiennych (deklaracja)........................................................................................ 60

Przypisywanie zmiennym wartości ...................................................................................... 62

Zmienianie i używanie wartości zmiennych......................................................................... 63

Typy wartości........................................................................................................................ 65

Zakres zmiennej .................................................................................................................... 67

Kilka praktycznych przykładów ........................................................................................... 78

Naprzód! ............................................................................................................................... 79

Rozdział 3. Dane i typy danych ...................................................................... 81

Dane kontra informacje ......................................................................................................... 81

Znaczenie zależne od typu danych ....................................................................................... 82

4 Spis treści

Tworzenie i kategoryzacja danych ........................................................................................ 83

Konwersja typów danych...................................................................................................... 85

Dane proste i dane złożone................................................................................................... 94

Naprzód! ............................................................................................................................... 95

Rozdział 4. Proste typy danych....................................................................... 97

Typ liczbowy......................................................................................................................... 97

Liczby całkowite i liczby zmiennoprzecinkowe.................................................................... 97

Liczbowe wyrażenia proste................................................................................................... 98

Korzystanie z liczb w skryptach ActionScript..................................................................... 102

Typ łańcuchowy .................................................................................................................. 103

Korzystanie z łańcuchów w skryptach ActionScript........................................................... 108

Typ logiczny........................................................................................................................ 126

Typ niezdefiniowany........................................................................................................... 129

Typ pusty, czyli null............................................................................................................ 130

Naprzód! ............................................................................................................................. 130

Rozdział 5. Operatory.................................................................................... 131

Ogólne cechy operatorów ................................................................................................... 131

Operator przypisania .......................................................................................................... 135

Operatory arytmetyczne ..................................................................................................... 136

Operatory równości i nierówności ...................................................................................... 140

Operatory porównania ........................................................................................................ 145

Operatory działające na łańcuchach.................................................................................... 149

Operatory logiczne.............................................................................................................. 149

Operator grupowania.......................................................................................................... 155

Przecinek jako operator....................................................................................................... 156

Operator void...................................................................................................................... 156

Inne operatory..................................................................................................................... 157

Naprzód! ............................................................................................................................. 160

Rozdział 6. Polecenia ..................................................................................... 161

Typy poleceń....................................................................................................................... 162

Składnia poleceń.................................................................................................................. 162

Polecenia ActionScript......................................................................................................... 164

Polecenia i akcje................................................................................................................... 172

Naprzód! ............................................................................................................................. 172

Spis treści 5

Rozdział 7. Konstrukcje warunkowe............................................................. 173

Konstrukcja if ...................................................................................................................... 174

Konstrukcja else .................................................................................................................. 176

Konstrukcja else if ............................................................................................................... 177

Symulacja konstrukcji switch .............................................................................................. 178

Składnia krótkich konstrukcji warunkowych...................................................................... 180

Naprzód! ............................................................................................................................. 180

Rozdział 8. Pętle ............................................................................................ 181

Pętla while ........................................................................................................................... 181

Terminologia pętli ............................................................................................................... 184

Pętla do-while...................................................................................................................... 186

Pętla for ............................................................................................................................... 187

Pętla for-in ........................................................................................................................... 188

Przedwczesne zatrzymanie pętli ......................................................................................... 189

Pętle na listwie czasowej i pętle przypisane do zdarzeń klipów filmowych ...................... 192

Naprzód! ............................................................................................................................. 199

Rozdział 9. Funkcje ........................................................................................ 201

Tworzenie funkcji ................................................................................................................ 202

Uruchamianie funkcji .......................................................................................................... 202

Przekazywanie informacji funkcjom ................................................................................... 203

Opuszczanie funkcji i zwracane przez funkcje wartości ..................................................... 207

Funkcje jako wyrażenia proste ............................................................................................ 209

Dostępność funkcji i jej trwałość ......................................................................................... 210

Zakres funkcji ...................................................................................................................... 211

Jeszcze kilka słów o argumentach funkcji ........................................................................... 215

Funkcje rekurencyjne........................................................................................................... 219

Funkcje standardowe .......................................................................................................... 221

Funkcje jako obiekty............................................................................................................ 222

Wszystkie skrypty w jednym miejscu................................................................................. 223

Stary quiz po nowemu ........................................................................................................ 224

Naprzód! ............................................................................................................................. 227

Rozdział 10. Zdarzenia i moduły obsługi zdarzeń ....................................... 229

Synchroniczne wykonanie kodu ......................................................................................... 229

Asynchroniczne wykonanie kodu oparte na zdarzeniach................................................... 230

Rodzaje zdarzeń .................................................................................................................. 230

Procedury obsługi zdarzeń ................................................................................................. 231

6 Spis treści

Składnia procedur obsługi zdarzeń..................................................................................... 231

Tworzenie procedur obsługi zdarzeń ................................................................................. 232

Zasięg procedur obsługi zdarzeń........................................................................................ 235

Zdarzenia dla przycisków................................................................................................... 239

Przegląd zdarzeń klipów filmowych................................................................................... 243

Zdarzenia klipowe związane z odtwarzaniem filmu.......................................................... 244

Klipowe zdarzenia generowane przez użytkownika.......................................................... 250

Kolejność wykonywania...................................................................................................... 255

Kopiowanie procedur obsługi zdarzeń klipowych ............................................................. 257

Odświeżanie ekranu przy użyciu updateAferEvent........................................................... 258

Dynamiczne procedury obsługi zdarzeń klipów filmowych.............................................. 259

Zastosowanie procedur obsługi zdarzeń ............................................................................ 260

Naprzód! ............................................................................................................................. 262

Rozdział 11. Tablice ....................................................................................... 263

Czym jest tablica?................................................................................................................ 263

Anatomia tablicy ................................................................................................................. 264

Jak tworzymy tablice? ......................................................................................................... 265

Odwołujemy się do elementów tablicy............................................................................... 268

Rozmiar tablicy.................................................................................................................... 270

Elementy indeksowane nazwami........................................................................................ 272

Dodajemy elementy do tablicy............................................................................................ 273

Usuwamy elementy z tablicy .............................................................................................. 278

Przetwarzanie zawartości tablic .......................................................................................... 282

Tablice wielowymiarowe .................................................................................................... 287

Quiz z pytaniami do wyboru, ujęcie 3. ............................................................................... 288

Naprzód! ............................................................................................................................. 289

Rozdział 12. Obiekty i klasy ......................................................................... 291

Anatomia obiektu................................................................................................................ 294

Tworzymy instancje obiektów ............................................................................................ 295

Właściwości obiektów......................................................................................................... 296

Metody ................................................................................................................................ 297

Klasy i programowanie zorientowane obiektowo .............................................................. 301

Standardowe obiekty i klasy języka ActionScript ............................................................... 316

Naprzód! ............................................................................................................................. 318

Spis treści 7

Rozdział 13. Klipy filmowe ........................................................................... 319

„Obiektowość” klipów filmowych...................................................................................... 320

Typy klipów filmowych ...................................................................................................... 321

Tworzymy klipy filmowe.................................................................................................... 324

Kolejność filmów i klonów w stosie.................................................................................... 331

Odwołania do klonów oraz filmów głównych.................................................................... 338

Usuwamy klony klipów i całe filmy ................................................................................... 351

Standardowe właściwości klipów filmowych ..................................................................... 354

Metody klipów filmowych.................................................................................................. 355

Praktyczne zastosowania klipów filmowych ...................................................................... 360

Quiz: ostatnia odsłona......................................................................................................... 364

Naprzód! ............................................................................................................................. 367

Rozdział 14. Struktura leksykalna ................................................................ 369

Białe spacje .......................................................................................................................... 369

Zakończenia instrukcji (średniki) ........................................................................................ 370

Komentarze ......................................................................................................................... 372

Słowa kluczowe................................................................................................................... 373

Identyfikatory...................................................................................................................... 374

Rozróżnianie wielkości liter ................................................................................................ 375

Naprzód! ............................................................................................................................. 376

Rozdział 15. Tematy zaawansowane ............................................................ 377

Kopiowanie, porównywanie i przekazywanie danych ....................................................... 377

Wykorzystywanie operacji na bitach................................................................................... 380

Zagadnienia związane z zakresem funkcji.......................................................................... 390

Typ danych „klip filmowy” ................................................................................................ 392

Naprzód! ............................................................................................................................. 392

Część II ActionScript w praktyce ................................................... 393

Rozdział 16. ActionScript; środowisko pracy............................................... 395

Panel Actions....................................................................................................................... 395

Umieszczanie skryptów w klatkach.................................................................................... 398

Umieszczanie skryptów w przyciskach .............................................................................. 399

Umieszczanie skryptów w klipach filmowych.................................................................... 400

Gdzie jest kod?.................................................................................................................... 401

Efektywność pracy .............................................................................................................. 402

8 Spis treści

Korzystanie z zewnętrznych skryptów............................................................................... 403

Klipy filmowe typu Smart Clip........................................................................................... 405

Naprzód! ............................................................................................................................. 413

Rozdział 17. Interaktywne formularze.......................................................... 415

Obieg danych w formularzu Flasha .................................................................................... 415

Tworzenie interaktywnego formularza............................................................................... 418

Naprzód! ............................................................................................................................. 424

Rozdział 18. Pola tekstowe ........................................................................... 425

Dynamiczne pola tekstowe ................................................................................................. 425

Wejściowe pola tekstowe .................................................................................................... 427

Opcje pól tekstowych.......................................................................................................... 428

Właściwości pól tekstowych ............................................................................................... 432

Obsługa języka HTML ........................................................................................................ 434

Zaznaczanie fragmentów tekstów w polach tekstowych.................................................... 442

Puste pola tekstowe i pętla for-in........................................................................................ 442

Naprzód! ............................................................................................................................. 443

Rozdział 19. Usuwanie błędów...................................................................... 445

Narzędzia do wyszukiwania błędów.................................................................................. 446

Zasady testowania programów........................................................................................... 451

Naprzód! ............................................................................................................................. 455

Część III Leksykon ........................................................................... 457

Dodatki ............................................................................................. 713

Dodatek A Flash w Internecie ....................................................................... 715

Dodatek B Zakres i kody znaków kodowania Latin 1................................ 719

Dodatek C Zgodność z poprzednimi wersjami ............................................. 731

Dodatek D Różnice między ActionScript a ECMA-262 i JavaScript .......... 737

Skorowidz ....................................................................................................... 741

10

Zdarzenia i modułyobsługi zdarzeń

Dowiedzieliśmy się sporo o pisaniu instrukcji wykonywanych przez interpreter Action-Script. Potrafimy już prawidłowo powiedzieć interpreterowi co chcemy zrobić, ale jakprzekazać mu, kiedy wykonać te operacje? Kod ActionScript nie wywołuje się tak poprostu sam z siebie — coś zawsze powoduje jego wykonanie.

Tym „czymś” może być zarówno synchroniczne odtwarzanie filmu, jak również prede-finiowane asynchroniczne zdarzenia.

Synchroniczne wykonanie kodu

Podczas odtwarzania filmu wskaźnik odtwarzania przemieszcza się od klatki do klatki.Za każdym razem gdy dociera do nowej klatki, interpreter wykonuje kod dołączony doniej. Po wykonaniu kodu następuje odświeżenie ekranu oraz odtworzenie dźwięku.Później wskaźnik przechodzi do następnej klatki.

Na przykład jeśli umieścimy kod w klatce 1., zostanie on wykonany, zanim klatka będziewyświetlona. Jeśli kolejny blok kodu umieścimy w klatce 5. (będącej klatką kluczową)w tym samym filmie, to najpierw zostaną wyświetlone klatki od 1. do 4., następnie będziewykonany kod zawarty w klatce 5., po czym zostanie ona wyświetlona. Kolejność wy-konywania kodu w klatkach 1. oraz 5. nazywamy synchroniczną, ponieważ następujew sposób liniowy, wynikający z kolejności klatek na listwie czasu.

Cały kod przypisany do klatek w filmie jest wykonywany synchronicznie. Nawet jeśliniektóre klatki nie są odtwarzane w kolejności z powodu instrukcji gotoAndPlay( ) lubgotoAndStop( ), kod związany z każdą klatką jest wykonywany w przewidywalnym po-rządku związanym z ruchem wskaźnika odtwarzania.

230 Rozdział 10. Zdarzenia i moduły obsługi zdarzeń

Asynchroniczne wykonanie koduoparte na zdarzeniach

Niektóre części kodu nie są wykonywane w przewidywalnej kolejności. Ich wykonanienastępuje, kiedy interpreter ActionScript wykryje, że miało miejsce jedno z predefinio-wanych zdarzeń. Wiele zdarzeń jest związanych z określonymi działaniami użytkownika(jak kliknięcie myszą czy naciśnięcie klawisza na klawiaturze). Tak jak głowica odtwa-rzająca, docierając do klatki, wywołuje kod z nią związany, tak samo wystąpienie zda-rzeń powoduje wykonanie kodu związanego ze zdarzeniami. Kod oparty na zdarzeniach(czyli taki, który jest wykonywany po wystąpieniu zdarzenia) jest określany jako wyko-nywany asynchronicznie, ponieważ jego uruchomienie nie następuje w określonym mo-mencie filmu, a raczej w momencie, w którym wystąpi określone zdarzenie.

Programowanie synchroniczne wymaga na początek ustalenia czasu wykonywania kodu.Natomiast programowanie asynchroniczne pozwala dynamicznie reagować na zachodzącezdarzenia. Asynchroniczne wykonywanie kodu ma kluczowe znaczenie dla ActionScripti dla tworzenia interaktywności.

W rozdziale tym znajdziesz wiadomości na temat tworzenia kodu opartego na zdarzeniachoraz zestawienie różnych predefiniowanych zdarzeń, obsługiwanych przez ActionScript.

Rodzaje zdarzeń

Teoretycznie zdarzenia możemy podzielić na dwa rodzaje:

zdarzenia użytkownikawywoływane przez działania użytkownika (kliknięcie myszą lub naciśnięcie klawisza),

zdarzenia systemowebędące wynikiem odtwarzania filmu (pojawienie się klipu filmowego na scenie lubzaładowanie z zewnętrznego pliku serii zmiennych).

W ActionScript nie ma różnic syntaktycznych między zdarzeniami użytkownika a zda-rzeniami systemowymi. Zdarzenia systemowe są mniej ewidentne niż klinięcie mysząprzez użytkownika. Chociaż moglibyśmy nie traktować na przykład usunięcia klipu fil-mowego ze sceny jako pełnoprawnego zdarzenia, to jednak możliwość reagowania nazdarzenia systemowe daje poważne narzędzie kontroli odtwarzania filmu.

Zdarzenia w ActionScript mogą być również podzielone bardziej praktycznie ze względuna obiekty, do których są przypisane. Wszystkie zdarzenia występują w powiązaniuz określonymi obiektami w środowisku Flasha. Interpreter nie uważa, że „użytkownikkliknął”, lecz „użytkownik kliknął ten przycisk” lub „użytkownik kliknął, kiedy ten klipfilmowy znajdował się na scenie”. I podobnie interpreter nie stwierdza: „otrzymano dane”,lecz „ten klip filmowy otrzymał jakieś dane”. Tak więc opisujemy kod odpowiadający nazdarzenia za pomocą obiektów, do których te zdarzenia są przypisane.

Składnia procedur obsługi zdarzeń 231

Obiekty ActionScript, które mogą odbierać zdarzenia to:

• klipy filmowe,

• przyciski,

• obiekty klas XML oraz XMLSocket.

W tym rozdziale dowiemy się, że ActionScript w rzeczywistości posiada dwie różne imple-mentacje obsługi zdarzeń: jedną dla zdarzeń związanych z klipami filmowymi i przyci-skami oraz drugą skojarzoną ze wszystkimi pozostałymi rodzajami obiektów.

Procedury obsługi zdarzeń

Nie każde zdarzenie powoduje wykonanie kodu. Zdarzenia często mają miejsce bez jakie-gokolwiek wpływu na odtwarzanie filmu. Przykładowo użytkownik może generowaćdziesiątki zdarzeń, klikając raz za razem przycisk, ale te kliknięcia będą ignorowane.Dlaczego? Ponieważ zdarzenia same nie mogą tworzyć kodu — to my musimy napisaćnajpierw kod odpowiadający na zdarzenie. Aby powiadomić interpreter, by wykonał kodw odpowiedzi na zdarzenie, musimy dodać do niego procedurę obsługi zdarzenia (eventhandler) opisującą akcję, która ma zostać podjęta.

Procedura obsługi zdarzenia jest czymś w rodzaju specjalnie nazwanej funkcji, która jestwykonywana automatycznie, kiedy dane zdarzenie ma miejsce. W związku z tym two-rzenie procedur obsługi zdarzeń jest bardzo podobne do tworzenia funkcji, jednak z kil-koma różnicami.

• Procedury obsługi zdarzeń mają predefiniowane nazwy, takie jak na przykład keyDown.Nie można nazwać procedury obsługi zdarzenia dowolnie, należy użyć jednej z tychpredefiniowanych nazw. Pełna lista nazw procedur obsługi zdarzeń znajduje sięw tabeli 10.1 oraz 10.2.

• Procedury obsługi zdarzeń nie są deklarowane za pomocą słowa kluczowego function.

• Procedury obsługi zdarzeń muszą być przypisane do przycisków, klipów filmowychlub innych obiektów, a nie do klatek.

Większość zdarzeń została po raz pierwszy wprowadzona we Flashu 5. Jeżelieksportujemy film do formatu Flash 4, korzystajmy tylko z procedur obsługi zdarzeńzwiązanych z przyciskami (bo tylko one są obsługiwane przez Flash 4) i testujmydokładnie nasz film w odtwarzaczu Flash Player 4.

Składnia procedur obsługi zdarzeń

Nazwy zdarzeń (a co za tym idzie, odpowiadających im procedur) są predefiniowanew ActionScript. Procedury obsługi zdarzeń przyciskowych są definiowane przy użyciuwyrażenia on (nazwaZdarzenia), zaś procedury obsługi zdarzeń klipowych za pomocą


wyrażenia onClipEvent (nazwaZdarzenia) — gdzie nazwaZdarzenia jest określeniemzdarzenia, które ma być obsługiwane.

Z tego względu wszystkie procedury obsługi zdarzeń związanych z przyciskami (opróczprocedury obsługi zdarzenia keyPress wymagającego dodatkowo parametru w postacinazwy klawisza) mają następującą postać:

on (nazwaZdarzenia) { polecenia

}

Jedna procedura obsługi przypisana do przycisku może odpowiadać na kilka zdarzeń,które muszą być rozdzielone przecinkami, na przykład:

on (rollOver, rollOut) {// wywołuje wbudowaną funkcję w odpowiedzi na zdarzenie rollOver oraz na// zdarzenie rollOut

playRandomSound( );}

Wszystkie procedury obsługi zdarzeń klipowych mają następującą postać:

onClipEvent (nazwaZdarzenia) { polecenia

}

W przeciwieństwie do procedur obsługi zdarzeń przyciskowych procedury obsługi zdarzeńprzypisywane klipom mogą odpowiadać tylko na jedno zdarzenie.

Tworzenie procedur obsługi zdarzeń

Aby utworzyć procedurę obsługi zdarzenia, musimy napisać skrypt i dołączyć go doodpowiedniego obiektu. Zaczniemy od procedur najczęściej spotykanych, czyli związa-nych z przyciskami i klipami filmowymi.

Dodawanie procedur obsługi zdarzeń do przycisków i klipów filmowych

Aby dołączyć procedurę obsługi zdarzenia do przycisku lub klipu filmowego, musimyfizycznie umieścić jego kod w wybranym przycisku lub klipie filmowym. Możemy zrobićto tylko w środowisku Flasha, wybierając obiekt na scenie i wprowadzając kod w paneluActions (patrz rysunek 10.1).

Spróbujmy napisać prostą procedurę obsługi zdarzenia, która będzie odpowiednia zarównodla przycisku, jak i dla klipu.

1. Tworzymy nowy film we Flashu.

2. Tworzymy przycisk i przeciągamy jego klon na główną scenę.

3. Po wybraniu przycisku na scenie wprowadzamy następujący kod w panelu Actions:

Tworzenie procedur obsługi zdarzeń 233

Rysunek 10.1. Przyłączanie procedury obsługi zdarzenia do przycisku

on (release) {trace("Kliknales przycisk");}

4. Wybieramy polecenie Test Movie z menu Control.

5. Klikamy utworzony wcześniej przycisk. W okienku Output pojawi się napis Kliknalesprzycisk.

Tak długo, jak film jest odtwarzany, a my klikamy przycisk, interpreter rejestruje zda-rzenie release i uruchamia kod przypisany do procedury obsługi zdarzenia on (release).Za każdym razem kiedy naciśniemy i puścimy klawisz myszy nad przyciskiem, w okienkuOutput ukaże się komunikat „Kliknales przycisk”.

Teraz spróbujemy napisać bardziej interesujący skrypt, który dołączymy do klipu fil-mowego.

1. Tworzymy nowy film we Flashu.

2. Rysujemy prostokąt na głównej scenie.

3. Wybieramy polecenie Convert to Symbol z menu Insert.

4. W okienku dialogowym Symbol Properties wpisujemy nazwę nowego symbolurectangle i wybieramy Movie Clip z grupy opcji Behavior.

5. Klikamy OK, aby zakończyć tworzenie klipu rectangle.

6. Wybieramy klip rectangle na scenie i wpisujemy następujący kod w panelu Actions:

onClipEvent (keyDown) { _visible=0;}onClipEvent (keyUp) { _visible=1;}


7. Wybieramy polecenie Test Movie z menu Control.

8. Klikamy okno z filmem, by mieć pewność, że jest aktywne, a później naciskamyi przytrzymujemy dowolny klawisz na klawiaturze. Za każdym razem gdy naciskamy

i przytrzymujemy klawisz, klip rectangle znika. Za każdym razem gdy puszczamywciśnięty klawisz, klip rectangle pojawia się znowu.

Warto zauważyć, że nie ustawialiśmy ręcznie żadnego wyrażenia wywołującego procedurę— interpreter sam wywołuje ją, kiedy zachodzi odpowiadające jej zdarzenie.

Flash nie pozwala na dodawanie lub usuwanie procedur obsługi zdarzeń za pomocąActionScript podczas odtwarzania filmu. Procedury obsługi zdarzeń muszą zostać przy-pisane do przycisków lub klipów filmowych wcześniej w środowisku Flasha. Z tegopowodu następujące wyrażenie nie jest poprawne:

myClip.onKeyDown = function ( ) { _visible = 0; };

W podrozdziale „Dynamiczne uchwyty zdarzeń klipów filmowych” dowiemy się, jaksobie radzić w podobnych sytuacjach.

Dołączanie procedur obsługi zdarzeń do innych obiektów

Procedury obsługi zdarzeń można przyłączać poza przyciskami i klipami filmowymi rów-nież do obiektów z dwóch wbudowanych klas XML oraz XMLSocket. Dla tych obiektówprocedury obsługi zdarzeń są podłączane jako metody do klonu (instancji) obiektu.

W obiektach klas XML oraz XMLSocket ActionScript wykorzystuje predefiniowane wła-ściwości, by przechowywać w nich nazwy procedur obsługi zdarzeń. Na przykład wła-

ściwość onLoad przechowuje nazwę procedury, która ma być wykonana, kiedy zostanąwczytane zewnętrzne dane XML.

Aby ustawić właściwość onLoad dla obiektu XML, piszemy następujący kod:

myDoc = new XML( );myDoc.onLoad = function ( ) {trace("Wszystkie dane załadowane!"); };

Możemy również zrobić to w inny sposób. Najpierw napiszemy procedurę obsługi zda-

rzenia, a później przypiszemy ją do właściwości onLoad naszego obiektu:

function doneMsg ( ) { trace("Wszystkie dane załadowane!");}

myDoc.onLoad = doneMsg;

Ta składnia jest bardzo podobna do składni JavaScript, gdzie funkcje mogą być przypi-sywane do właściwości procedury obsługi zdarzenia, co pokazano w listingu 10.1.

Listing 10.1. Przypisywanie procedury obsługi zdarzeń w JavaScript

// Przypisanie ciała funkcji do procedury obsługi zdarzenia onLoad w JavaScript

window.onload = function ( ) { alert("Ladowanie zakonczone"); };// Inne rozwiązanie, polegające na zdefiniowaniu funkcji, a następnie// przypisaniu jej do właściwości onLoad:

Zasięg procedur obsługi zdarzeń 235

function doneMsg ( ) { alert ("Wszystkie dane zaladowane!");}window.onload = doneMsg;

W przyszłości do większej liczby obiektów ActionScript będzie można przypisywać proce-dury obsługi zdarzeń za pomocą właściwości obiektu, dlatego warto przyzwyczajać sięjuż teraz do takiego sposobu podłączania funkcji. Jeżeli nie korzystamy z obiektów XMLi XMLSocket, możemy ćwiczyć ten sposób tworzenia procedur obsługi zdarzeń w JavaScript.Zaletą tego podejścia jest elastyczność; każda procedura obsługi zdarzenia może byćłatwo przypisana do innego obiektu czy nawet usunięta podczas odtwarzania filmu.

W rozdziale 12., „Obiekty i klasy”, napiszemy więcej o przypisywaniu funkcji do obiek-tów. Informacje o zdarzeniach obsługiwanych przez obiekty klas XML oraz XMLSocketznajdują się w części III.

Długość życia procedur obsługi zdarzeń jest związana z istnieniem obiektów, doktórych są przypisane. Kiedy klip lub przycisk usuniemy ze sceny bądź obiekt XMLzostanie zlikwidowany, wszystkie procedury obsługi zdarzeń znikają razem z nim.Obiekt musi znajdować się na scenie lub na listwie czasu, aby jego procedury obsługizdarzeń były aktywne.

Zasięg procedur obsługi zdarzeń

Podobnie jak każda funkcja, procedury obsługi zdarzeń są wykonywane w predefiniowa-nym zasięgu. Zasięg określa, skąd interpreter pobiera zmienne, podfunkcje, obiekty i wła-ściwości, do których odwołuje się ciało funkcji. Rozpatrzymy zasięg procedur obsługi zda-rzeń w odniesieniu do zdarzeń klipowych, przyciskowych oraz zdarzeń innych obiektów.

Zasięg procedur obsługi zdarzeń klipów filmowych

W przeciwieństwie do normalnych funkcji procedura obsługi zdarzenia klipowego niedefiniuje lokalnego zasięgu. Dla procedur przyłączonych do klipu zasięgiem jest całyklip, a nie procedura. Oznacza to, że wszystkie zmienne ze skryptów na listwie czasowejklipu są dostępne dla procedur obsługi zdarzeń. Jeśli na przykład dołączymy do klipunazwanego navigation procedurę obsługi zdarzenia enterFrame i wpiszemy w niejtrace(x);, interpreter będzie szukał wartości zmiennej x w skryptach listwy czasowejklipu navigation.

onClipEvent (enterFrame) { trace(x); // Wyświetla wartość zmiennej navigation.x}

Interpreter nie zaczyna od sprawdzenia w zasięgu lokalnym, gdyż takiego nie ma. Jeśliw naszej procedurze wpiszemy var y = 10;, y zostanie zdefiniowane w listwie cza-sowej navigation, mimo że słowo kluczowe var użyte w zwykłej funkcji definiuje

zmienną lokalną.


Najłatwiejszym sposobem zapamiętania zasad rządzących zasięgiem procedury obsługizdarzenia w klipie jest traktowanie wyrażeń procedury, tak jakby były dołączone do klatki

w klipie. Załóżmy, że mamy klip o nazwie ball, a w nim zmienną xVelocity. Abyodwołać się do tej zmiennej z procedury obsługi zdarzenia klipowego (w klipie ball),wystarczy, że wpiszemy wprost jej nazwę:

onClipEvent (mouseDown) { xVelocity += 10;

}

Nie musimy wpisywać całej ścieżki tej zmiennej, czyli w tym przypadku _root.ball.xVelocity, ponieważ interpreter zakłada, że chodzi o zmienną xVelocity z klipu ball.To samo dotyczy właściwości i metod. Zamiast wpisywać ball._x, wystarczy, jak napi-szemy _x. Zamiast ball.gotoAndStop(5) wystarczy gotoAndStop(5) na przykład:

onClipEvent (enterFrame) { _x += xVelocity; // Przesuń piłkę gotoAndPlay(_currentframe - 1) // Wykonaj małą pętlę}

Możemy także zdefiniować funkcję w klipie ball, używając wyrażenia deklaracji we-wnątrz procedury obsługi zdarzenia w sposób następujący:

onClipEvent (load) { function hideMe ( ) {

_visibility = 0; }}

Można łatwo zapomnieć, że wszystkie wyrażenia w procedurach obsługi zdarzeń klipumają zasięg ograniczony do listwy czasowej klipu, a nie do lokalnego zasięgu procedury czydo listwy czasowej elementu nadrzędnego klipu (czyli listwy, w której klip się znajduje).

Załóżmy, że umieściliśmy nasz klip ball w głównej listwie czasowej filmu oraz że w tejlistwie (a nie w listwie czasowej klipu ball) znajduje się definicja funkcji moveBall( ).Możemy przez nieuwagę dokonać próby wywołania funkcji moveBall( ) z procedury obsługi

zdarzenia w klipie ball w sposób następujący:

onClipEvent (enterFrame) { moveBall ( ); // Nie zadziała! W klipie ball nie ma funkcji moveBall( ).

// Jest ona zdefiniowana na poziomie _root.

}

Musimy użyć nazwy _root, by odwołać się do funkcji moveBall( ) z głównej listwy czasu:

onClipEvent (enterFrame) { _root.moveBall ( ); // Teraz działa!}

Czasami może się zdarzyć, że będziemy chcieli odwołać się z wnętrza procedury obsługizdarzenia wprost do bieżącego klipu. Możemy to zrobić, korzystając ze słowa kluczowego

this, które użyte z wnętrza procedury obsługi zdarzenia odnosi się do bieżącego klipu.Z tego powodu poniższe odwołania z wnętrza procedury obsługi zdarzenia klipowegosą równoznaczne:

Zasięg procedur obsługi zdarzeń 237

this._x // Jest tym samym co następna linia_x

this.gotoAndStop(12); // Jest tym samym co następna liniagotoAndStop(12);

Użycie this jest wymagane, kiedy dynamicznie generujemy nazwę jednej właściwościbieżącego klipu (a także nazwę zmiennej lub zagnieżdżonego klipu). Poniżej sprawimy,

że zagnieżdżone klipy z serii ball.stripe1, ball.stripe2... będą uruchamiać siępo kolei, w zależności od bieżącej klatki w klipie ball:

onClipEvent (enterFrame) { this["stripe" + _currentframe].play( );}

Słowo kluczowe this jest również często wykorzystywane z metodami klipu wymaga-jącymi podania wprost odwołania do obiektu typu Movie Clip podczas wywołania. Każ-da metoda klipu filmowego o takiej samej nazwie co globalna funkcja ActionScript musibyć używana z jednoznacznym odwołaniem do klipu. Z tego względu słowo kluczowe

this jest niezbędne, kiedy jako metody wewnątrz procedury obsługi zdarzenia wywo-łujemy następujące funkcje:

duplicateMovieClip( ),

loadMovie( ),

loadVariables( ),

print( ),

printAsBitmap( ),

removeMovieClip( ),

startDrag( ),

unloadMovie( ).

Oto przykład:

this.duplicateMovieClip("ball2", 1);this.loadVariables("vars.txt");this.startDrag(true);this.unloadMovie( );

O podwójnej naturze tych funkcji powiemy więcej w podrozdziale „Przeciążanie metodi funkcji globalnych” rozdziału 13., „Klipy filmowe”.

Trzeba zauważyć, że słowo kluczowe this umożliwia odwoływanie się do bieżącegoklipu, nawet jeśli nie ma on określonej nazwy klonu nadanej w środowisku Flash lub poprostu nie znamy nazwy klipu. Gdy nie znamy nazwy klipu, ale posłużymy się słowem

kluczowym this, możemy wręcz podawać bieżący klip jako odnośnik. Poniżej prezen-tujemy dość poprawny (i elegancki ) przykład kodu, który to zobrazuje:


// KOD NA GŁÓWNEJ LISTWIE CZASOWEJ// Ogólna funkcja przesuwająca dowolny klipfunction move (clip, x, y) { clip._x += x; clip._y += y;

}

// KOD W KLIPIE// Wywołuje funkcję z głównej listwy czasowej i nakazuje jej przesunąć// bieżący klip, odwołując się do niego za pomocą słowa kluczowego this

onClipEvent (enterFrame) { root.move(this, 10, 15);

}

W wersji 30 odtwarzacza Flash 5 Player występował błąd powodującynieprawidłowe działanie instrukcji gotoAndStop( ) oraz gotoAndPlay( ),jeśli były wywoływane w klipie z etykietami klatek jako parametrami. Na przykład

taki kod nie będzie działał:

onClipEvent(load) { gotoAndStop("intro"); // Nie działa we Flash Player 5 r30}

Aby ominąć ten błąd, wystarczy użyć odwołania do samego siebie, na przykład:

onClipEvent(load) {

this.gotoAndStop("intro");}

Zakres procedur obsługi zdarzeń dla przycisków

Dla przycisków zakresem procedur obsługi zdarzeń jest listwa czasowa, na której się znaj-dują. Jeśli na przykład umieścimy przycisk w głównej listwie czasowej, a w procedurze

obsługi zdarzenia dla tego przycisku zadeklarujemy zmienną speed, to zakresem zmiennej

speed będzie główna listwa czasowa (_root):

// KOD PROCEDURY OBSŁUGI ZDARZEŃ DLA PRZYCISKUon (release) { var speed = 10; // Definiuje zmienną speed na poziomie _root}

Jeśli w głównej listwie czasu umieścimy klip ball, a wewnątrz niego w procedurze obsługizdarzenia zadeklarujemy zmienną speed, to zakres tej zmiennej będzie ograniczony doklipu ball:

// KOD PROCEDURY OBSŁUGI ZDARZENIA DLA KLIPU ballonClipEvent (load) { var speed = 10; // Definiuje _root.ball.speed, a nie _root.speed}

W skrypcie procedury obsługi zdarzeń dla przycisku słowo kluczowe this odnosi siędo listwy czasowej, w której znajduje się przycisk:

Zdarzenia dla przycisków 239

on (release) { // Klip, w którym znajduje się przycisk staje się w 50% przezroczysty this._alpha = 50; // Przesuwa klip, w którym znajduje się przycisk, o 10 pikseli w prawo this._x += 10;

}

Zakres procedur obsługi zdarzeń innych obiektów

W przeciwieństwie do procedur obsługi zdarzeń klipów filmowych i przycisków proce-dury obsługi zdarzeń dołączone do obiektów wbudowanych klas, takich jak XML i XML-Socket, mają zakres dokładnie taki jak funkcje. Procedury obsługi zdarzeń obiektów XMLoraz XMLSocket mają zakres określany podczas definiowania funkcji. Co więcej, proceduryobsługi zdarzeń obiektów XML oraz XMLSocket mają zakres lokalny. Wszystkie zasadydotyczące zakresu funkcji i opisane w podrozdziale „Zakres funkcji” rozdziału 9.,„Funkcje”, odnoszą się także do procedur obsługi zdarzeń obiektów, które nie są przyci-skami ani klipami filmowymi.

Zdarzenia dla przycisków

Tabela 10.1 wprowadza w problematykę różnych zdarzeń dostępnych dla przycisków.Korzystając ze zdarzeń dla przycisków, możemy łatwo napisać kod dla nawigacji, for-mularzy, gier, a także innych elementów interfejsu. Przyjrzymy się po kolei wszystkimzdarzeniom dla przycisków i nauczymy się, w jaki sposób przycisk powinien być opro-gramowany, by reagować na zdarzenia generowane przez mysz i klawiaturę.

Każde ze zdarzeń przedstawionych w tabeli 10.1 jest obsługiwane przez odpowiadającąmu procedurę obsługi zdarzenia w postaci on (nazwaZdarzenia). Na przykład zdarzeniepress jest obsługiwane przez procedurę zaczynającą się od on (press). Wyjątkiem jestprocedura obsługi zdarzenia mająca postać on (keypress klawisz), gdzie klawisz jest nazwąklawisza do sprawdzania. Zdarzenia dla przycisków są wysyłane tylko do przycisku,nad którym znajduje się mysz. Jeśli kilka przycisków zachodzi na siebie, znajdujący sięnajwyżej otrzyma informację o wszystkich zdarzeniach; pozostałe przyciski nie będąmogły odpowiedzieć na zdarzenia, nawet jeśli przycisk znajdujący się najwyżej nie mazdefiniowanych procedur obsługi zdarzeń. W poniższych opisach pojęcie obszar aktywnyodnosi się do obszaru przycisku, który musi znajdować się pod kursorem myszy, abyzdarzenie zostało wygenerowane (obszar aktywny jest definiowany graficznie podczastworzenia przycisku w środowisku Flash).

press

Technicznie rzecz biorąc, kliknięcie myszą jest dwustopniowym procesem: najpierw kla-wisz myszy jest wciskany — press, a następnie zwalniany — release. Zdarzenie press mamiejsce, gdy wskaźnik myszy znajduje się nad obszarem aktywnym przycisku, a główny(lewy dla PC) klawisz myszy jest wciśnięty. Pozostałe klawisze myszy są ignorowane.


Tabela 10.1. Zdarzenia dla przycisków

Nazwa zdarzenia Zdarzenie zachodzi gdy...

Press Główny klawisz myszy (dla PC lewy) został wciśnięty, kiedy wskaźnikmyszy znajdował się nad obszarem aktywnym przycisku. Pozostałe klawisze

myszy są pomijane

Release Główny klawisz myszy (dla PC lewy) został naciśnięty, a następnie

zwolniony, kiedy wskaźnik myszy znajdował się nad obszarem aktywnymprzycisku

ReleaseOutside Główny klawisz myszy (dla PC lewy) został wciśnięty, kiedy wskaźnik

myszy znajdował się nad obszarem aktywnym przycisku, a następniezwolniony, kiedy kursor znajdował się poza tym obszarem

RollOver Wskaźnik myszy znalazł się nad obszarem aktywnym, przy niewciśniętymgłównym klawiszu myszy

RollOut Wskaźnik myszy opuścił obszar aktywny przycisku, żaden klawisz myszynie został wciśnięty

DragOut Główny klawisz myszy (dla PC lewy) został wciśnięty, kiedy wskaźnikmyszy znajdował się nad obszarem aktywnym przycisku, następnie przy

wciąż wciśniętym klawiszu wskaźnik został usunięty poza obszar aktywny

DragOver Główny klawisz myszy (dla PC lewy) został wciśnięty, kiedy wskaźnikmyszy znajdował się nad obszarem aktywnym przycisku, następnie przywciąż wciśniętym klawiszu wskaźnik został usunięty poza obszar aktywny,

by na koniec wrócić nad obszar aktywny

KeyPress Wybrany (jako parametr) klawisz został naciśnięty. Zazwyczaj zamiast tegozdarzenia stosuje się zdarzenie klipu keyDown

Przyciskowe zdarzenie press można wykorzystać do przycisków opcji czy strzelaniaw grach. Jednak aby dać użytkownikowi możliwość zmiany zdania przed zwolnieniemklawisza myszy, lepiej stosować zdarzenie release.

release

Zdarzenie release ma miejsce, kiedy zostanie wykryta następująca sekwencja działańużytkownika.

1. Wskaźnik myszy znajduje się nad obszarem aktywnym przycisku.

2. Główny klawisz myszy został wciśnięty, kiedy wskaźnik myszy wciąż znajdował sięnad obszarem aktywnym przycisku (w tym momencie następuje zdarzenie press).

3. Główny klawisz myszy został zwolniony, podczas gdy wskaźnik wciąż znajdował sięnad obszarem aktywnym przycisku (w tym momencie następuje zdarzenie release).

Używając zdarzenia release zamiast press, dajemy użytkownikowi szansę na przesunięciewskaźnika poza obszar aktywny przycisku nawet po kliknięciu (a dokładnie po wciśnięciui przytrzymaniu klawisza myszy), a co za tym idzie, na cofnięcie decyzji.

Zdarzenia dla przycisków 241

releaseOutside

Zdarzenie releaseOutside zazwyczaj wskazuje, że użytkownik zmienił zdanie. Po kliknię-ciu nad przyciskiem zjechał wskaźnikiem myszy z obszaru aktywnego i dopiero pozanim puścił klawisz myszy. Aby to zdarzenie miało miejsce, musi zaistnieć następującasekwencja działań użytkownika.

1. Wskaźnik myszy znajduje się nad obszarem aktywnym przycisku.

2. Główny klawisz myszy zostaje wciśnięty, kiedy wskaźnik myszy wciąż znajduje sięnad obszarem aktywnym przycisku (w tym momencie następuje zdarzenie press).

3. Wskaźnik myszy zostaje przesunięty poza obszar aktywny przycisku (w tym momencienastępuje zdarzenie dragOut).

4. Główny przycisk myszy zostaje zwolniony poza obszarem aktywnym przycisku(w tym momencie następuje zdarzenie releaseOutside).

Ze zdarzenia releaseOutside będziemy rzadko korzystać, gdyż oznacza ono, że użytkownikzrezygnował z akcji.

rollOver

Zdarzenie rollOver zachodzi, kiedy wskaźnik myszy nasuwa się na obszar aktywny przy-cisku, ale klawisz myszy pozostaje niewciśnięty. Zdarzenie rollOver jest rzadko używanew ActionScript, ponieważ graficzną podmianę stanów przycisku przygotowuje się w śro-dowisku Flasha bez pisania skryptów. W tym celu możemy skorzystać z ustawionychdomyślnie klatek w przycisku (up,. over i down), wprowadzając w nich różne stany gra-ficzne przycisku.

Zdarzenie rollOver we Flash 5 dostarcza poręcznego narzędzia do wydobywania zazna-czonego tekstu z pola tekstowego. Więcej szczegółów na ten temat znajdziesz w „Wybie-ranie obiektów” w części III.

rollOut

Zdarzenie rollOut jest uzupełnieniem rollOver i ma miejsce, kiedy wskaźnik myszy prze-suwa się poza obszar aktywny przycisku, przy czym klawisz myszy nie jest wciśnięty.Podobnie jak w przypadku rollOver, rollOut jest rzadko wykorzystywane, ponieważ różnestany graficzne przycisku są ustawiane w środowisku Flasha i nie trzeba podmieniać ichza pomocą skryptów.

dragOut

Zdarzenie dragOut jest podobne do rollOut, tyle że jest generowane, kiedy klawisz myszyzostał wciśnięty podczas opuszczania obszaru aktywnego przycisku przez wskaźnikmyszy. Po zdarzeniu dragOut może nastąpić zarówno zdarzenie releaseOutside (jeśli


użytkownik puści klawisz myszy), jak i zdarzenie dragOver (jeśli użytkownik przesuniewskaźnik myszy z powrotem nad obszar aktywny przycisku, nie puszczając klawiszamyszy).

dragOver

Zdarzenie dragOver można spotykać równie rzadko jak Yeti. Jest wyczarowywane ponastępującej sekwencji działań użytkownika.

1. Wskaźnik myszy przesuwa się nad obszar aktywny przycisku (następuje zdarzenierollOver).

2. Główny przycisk myszy zostaje wciśnięty i przytrzymany (zdarzenie press).

3. Wskaźnik myszy zostaje przesunięty poza obszar aktywny przycisku (zdarzeniedragOut).

4. Wskaźnik myszy wraca nad obszar aktywny przycisku (zdarzenie dragOver).

Tak więc zdarzenie dragOver oznacza, że użytkownik przesunął wskaźnik myszy z obszaruaktywnego, a później z powrotem nad obszar aktywny przy wciśniętym cały czas przy-cisku myszy. Trzeba zwrócić uwagę, że w przeciwieństwie do rollOver zdarzenie dragOverma miejsce, kiedy klawisz myszy jest wciąż wciśnięty podczas powrotu nad obszaraktywny przycisku.

keyPress

Zdarzenie keyPress, niezwiązane ze zdarzeniami myszy, w przeciwieństwie do nichjest wywoływane przez naciśnięcie określonego klawisza na klawiaturze. Umieściliśmy jetutaj, ponieważ jego procedura obsługi ma składnię typu on (nazwaZdarzenia), podobniejak inne procedury obsługi zdarzeń przycisków. Wymaga ona podania jako parametrunazwy klawisza wywołującego zdarzenie:

on (keyPress klawisz) { wyrazenia}

gdzie klawisz to nazwa klawisza wywołującego zdarzenie. Nazwą może być zarównolitera określająca klawisz (na przykład s lub S), jak i słowo kluczowe reprezentująceklawisz w następującej formie „<słowoKluczowe>”. Z jedną procedurą może byćzwiązany tylko jeden klawisz. Aby przy użyciu zdarzenia keyPress obsługiwać większąliczbę klawiszy, należy napisać kilka procedur obsługi zdarzeń, na przykład:

// Wykrywa wciśnięcie klawisza "a"on (keyPress "a") { trace("Wciśnięto klawisz 'a'");}

// Wykrywa wciśnięcie Enteron (keyPress "<Enter>") { trace("Wciśnięto klawisz Enter");}

Przegląd zdarzeń klipów filmowych 243

// Wykrywa wciśnięcie strzałki w dółon (keyPress "<Down>") { trace("Wciśnięto strzałkę w dół");}

Niżej przedstawiamy dozwolone wartości słowa kluczowego jako parametru w procedurzeobsługi zdarzenia keyPress (warto zauważyć, że nie ma pośród nich klawiszy funkcyj-nych F1, – , F12 — czyli nie są one wykrywane przez zdarzenie keyPress; ich wciśnięciewykrywa natomiast obiekt Key):

<Backspace>,

<Delete>,

<Down>,

<End>,

<Enter>,

<Home>,

<Insert>,

<Left>,

<PgDn>,

<PgUp>,

<Right>,

<Space>,

<Tab>,

<Up>.

We Flash 4 zdarzenie keyPress było jedynym sposobem obsługi przez użytkownika klawia-tury. We Flash 5 i następnych wersjach obiekt Key w połączeniu ze zdarzeniami klipówfilmowych keyDown oraz keyUp (opisanymi dalej) daje dużo większą kontrolę nad ob-sługą klawiatury. Zdarzenie keyPress wykrywa w jednym momencie tylko wciśnięciepojedynczego klawisza, podczas gdy obiekt Key potrafi wykryć równoczesne wciśnięciekilku klawiszy.

Przegląd zdarzeń klipów filmowych

Zdarzenia klipów są wywoływane przez wiele czynników, poczynając od kliknięć myszą napobieraniu danych kończąc. Zdarzenia klipowe możemy podzielić na dwie kategorie: zda-rzenia wywoływane przez użytkownika oraz zdarzenia związane z odtwarzaniem filmu.

Zdarzenia wywoływane przez użytkownika są związane z klawiaturą i myszą, a zdarzeniapowstające podczas odtwarzania filmu – z wyświetlaniem klatek przez odtwarzacz FlashPlayer, z tworzeniem i usuwaniem klipów oraz z wczytywaniem danych.


Trzeba zauważyć, że zdarzenia klipowe wywoływane przez użytkownika pokrywają sięczęściowo z funkcjonalnością zdarzeń przyciskowych opisanych wcześniej. Na przykładzdarzenie klipowe mouseDown może tak samo wykryć wciśnięcie klawisza myszy jakzdarzenie przyciskowe press. Jednak zdarzenia klipowe w przeciwieństwie do przyci-skowych nie są związane z obszarami aktywnymi i położeniem względem nich wskaź-nika myszy.

Zajmijmy się przez chwilę zdarzeniami klipów filmowych w ActionScript zebranymiw tabeli 10.2. Najpierw przyjrzymy się zdarzeniom wywoływanym podczas odtwarzaniafilmu (enterFrame, load, unload oraz data), a później zdarzeniom użytkownika (mouseDown,mouseUp, mouseMove, keyDown i keyUp). Każde zdarzenie jest obsługiwane przez odpowiada-jącą mu procedurę w postaci onClipEvent (nazwaZdarzenia). Na przykład zdarzenie enter-Frame jest obsługiwane przez procedurę rozpoczynającą się tak: onClipEvent (enterFrame).Z wyjątkiem zdarzeń load, unload oraz data zdarzenia klipowe są wysyłane do wszystkichklipów znajdujących się na scenie, nawet jeśli wskaźnik myszy znajduje się nad innymklipem lub w zupełnie innym miejscu sceny.

Tabela 10.2. Zdarzenia klipów filmowych

Nazwa zdarzenia Zdarzenie klipowe ma miejsce gdy...

EnterFrame Wskaźnik odtwarzania doszedł do kolejnej klatki (przed wyświetleniem

klatki we Flash Player)

Load Klip po raz pierwszy pojawił się na scenie

Unload Klip został usunięty ze sceny

Data Zakończono wczytywanie zmiennych do klipu lub część wczytywanegofilmu załadowała się do klipu

MouseDown Główny klawisz myszy (lewy w PC) został wciśnięty, kiedy klip znajdował

się na scenie (pozostałe klawisze są ignorowane)

MouseUp Główny klawisz myszy (lewy w PC) został zwolniony, kiedy klawiszznajdował się na scenie

MouseMove Wskaźnik myszy został przesunięty (nawet o piksel), kiedy klip znajdował

się na scenie. Wskaźnik nie musi znajdować się nad klipem

KeyDown Klawisz na klawiaturze został wciśnięty, kiedy klip znajdował się na scenie

KeyUp Wciśnięty klawisz z klawiatury został zwolniony, kiedy klip znajdował sięna scenie

Zdarzenia klipowe związanez odtwarzaniem filmu

Następujące zdarzenia są generowane bez udziału użytkownika w czasie, gdy Flashodtwarza i ładuje filmy.

Zdarzenia klipowe związane z odtwarzaniem filmu 245

enterFrame

Jeśli potrzebujemy pustego, zapętlonego klipu filmowego wywołującego skrypty, proce-dura obsługi zdarzenia enterFrame jest najlepszym rozwiązaniem. Zdarzenie enterFramejest wywoływane dla każdej klatki wyświetlanej w filmie. Na przykład jeśli w klipie

umieścimy poniższy kod, będzie on powiększał się (klip oczywiście) o 10 pikseli wzdłużi wszerz na każdą klatkę wyświetloną w filmie:

onClipEvent (enterFrame) {

_height += 10; _width += 10;

}

(Przypominamy, że właściwości _height oraz _width są wykorzystywane w zasięgu

klipu, do którego procedura obsługi zdarzenia enterFrame jest przypisana, nie ma więcpotrzeby umieszczania nazwy klonu klipu przed _width i _height).

Zdarzenie enterFrame jest generowane przed wyświetleniem każdej klatki, nawet jeżeli

wskaźnik odtwarzania klipu zawierającego procedurę obsługi zdarzenia enterFrame

jest zatrzymana. Z tego powodu zdarzenie enterFrame jest zawsze generowane.

Podczas odtwarzania we Flash Player wszystkie filmy są cały czas uruchomione, nawetjeśli na ekranie nic się nie dzieje lub wskaźnik odtwarzania jest zatrzymany na jednej

klatce. Pojedyncza procedura obsługi zdarzenia enterFrame klipu będzie więc uruchamianaraz za razem tak długo, jak ów klip znajduje się na scenie, bez względu na to, czy samklip jest uruchomiony, czy zatrzymany. Jeśli wskaźnik odtwarzania zostanie przesuniętyprzez wywołanie funkcji gotoAndStop( ), procedura obsługi zdarzenia enterFrame będzie

wciąż wykonywana dla każdej wyświetlonej klatki. Jeśli wszystkie klipy w całym filmiezostaną zatrzymane przez funkcję stop( ), wszystkie procedury enterFrame klipów (znaj-dujących się aktualnie na scenie) będą nadal działać. Zazwyczaj zdarzenie enterFrame jestwykorzystywane do odświeżania stanu klipu w sposób powtarzalny przez określony

czas. Procedura obsługi zdarzenia enterFrame nie musi być stosowana do zawierającego goklipu — może być z powodzeniem wykorzystywana z jednoklatkowym pustym klipemdo powtarzalnego wykonywania skryptów. Ta technika nazywana pętlą zdarzeń klipowych(lub bardziej luźno procesem) została szerzej omówiona w podrozdziale „Pętle na listwie

czasowej i pętle przypisane do zdarzeń klipów filmowych” rozdziału 8., „Pętle”.

Trzeba zauważyć, że procedura obsługi zdarzenia enterFrame jest wykonywana przedkażdym innym kodem z listwy czasowej klipu zawierającego tę procedurę.

Niewielkim nakładem sił możemy, wykorzystując zdarzenie enterFrame, uzyskać naprawdę

rozbudowaną kontrolę nad klipem. Przedstawiony dalej listing 10.7 rozwinie wcześniejszykod zmieniający rozmiary klipu, tak by klip na przemian zwiększał się i zmniejszał.


load

Zdarzenie load ma miejsce w momencie utworzenia klipu to znaczy, kiedy pojawia sięon na scenie po raz pierwszy. Pojawienie się klipu na scenie może odbyć się na jedenz następujących sposobów.

• Wskaźnik odtwarzania dotarł do klatki kluczowej zawierającej wywołanie nowegoklonu klipu.

• Klip został powielony z innego klipu przez funkcję duplicateMovieClip( ).

• Klip został umieszczony na scenie przy użyciu funkcji attachMovie( ).

• Zewnętrzny plik .swf został załadowany do klipu przy użyciu funkcji loadMovie( ).

• Zawartość klipu została usunięta przez funkcję unloadMovie( ) (wywołano zdarzenieload ponieważ do klipu, którego zawartość została usunięta, jest ładowany pusty klipzastępczy).

Ciało procedury obsługi zdarzenia load jest wykonywane po wszystkich kodach zawar-tych w listwie czasu w klatce, w której klip pojawił się po raz pierwszy.

Zazwyczaj procedura obsługi zdarzenia load jest wykorzystywana do inicjalizacji zmiennychlub wykonania pewnych czynności wstępnych (na przykład ustalenie rozmiarów orazmiejsca wyświetlania dynamicznie generowanego klipu). Zdarzenie load doskonale nadajesię również do zatrzymania w elegancki sposób samoczynnego odtwarzania klipu:

onClipEvent (load) { stop( );}

Ponadto procedura obsługi zdarzenia load może być również wykorzystywana do wywo-ływania funkcji istotnych dla prawidłowego funkcjonowania klipu.

Zdarzenie load jest szczególnie interesujące w połączeniu z funkcją duplicateMovieClip( )

tworzącą nowe klipy filmowe. W listingu 10.2 generujemy cały ekran klipów star, korzy-stając z jednej procedury obsługi zdarzenia load w łańcuchu rekurencyjnym. Procedura

obsługi zdarzenia load jest wykonywana dla każdego powielonego klipu star, a jegowykonanie powiela klip po raz kolejny. Proces kończy się, kiedy nastąpi powielenie 100klipów. Plik źródłowy .fla dla listingu 10.2 jest dostępny w internetowej witrynie CodeDepot oraz na serwerze FTP Wydawnictwa Helion.

Listing 10.2. Tworzenie ekranu klipów star przy użyciu zdarzenia load

onClipEvent (load) { // Umieszczenie bieżącego klipu w losowo wybranym miejscu _x = Math.floor(Math.random( ) * 550);

_y = Math.floor(Math.random( ) * 400);

// Przypisanie standardowej wielkości bieżącemu klipowi, by nie odziedziczył // rozmiarów poprzednika _xscale = 100; _yscale = 100;


// Losowe ustalenie wielkości bieżącego klipu miedzy 50% a 150% randscale = Math.floor(Math.random( ) * 100) – 50; _xscale += randScale; _yscale += randScale;

// Powielenie klipu, chyba że to już setny egzemplarz if (_name != "star100") { nextStarNumber = number(_name.substring(4, _name.length)) + 1; this.duplicateMovieClip("star" + nextStarNumber, nextStarNumber); }}

unload

Zdarzenie unload jest odwrotnością zdarzenia load i zachodzi, kiedy klip filmowy „kończyżycie”, to znaczy bezpośrednio po ostatniej klatce, w której klip znajduje się na scenie(ale przed pierwszą klatką, w której już go nie ma).

Klipowe zdarzenie unload mogą powodować przyczyny, które wymieniamy poniżej.

• Wskaźnik odtwarzania dotarł do końca klatek zajmowanych przez klip.

• Klip został usunięty przez funkcję removeMovieClip( ) (usuwającą klipy generowaneprzez funkcje attachMovie( ) oraz duplicateMovieClip ( )).

• Wcześniej załadowany zewnętrzny plik .swf został usunięty z klipu przez funkcjęunloadMovie( ).

• Zewnętrzny plik .swf został załadowany do klipu.

Ostatnia przyczyna może wydawać się nieco dziwna, lecz w rzeczywistości jest natural-nym wynikiem sposobu, w jaki filmy są ładowane do Flasha. Za każdym razem gdy plik.swf jest ładowany do klipu, jego poprzednia zawartość zostaje usunięta, powodujączdarzenie unload. Poniższy przykład obrazuje zachowanie zdarzeń load oraz unloadw połączeniu z funkcją loadMovie( ).

1. W nowym filmie Flasha umieszczamy na scenie pusty klip w klatce 1. głównej listwy

czasowej filmu. Nazwiemy go emptyClip.

2. W klatce 5. głównej listwy czasowej ładujemy do klipu emptyClip film test.swfza pomocą następującego kodu: emptyClip.loadMovie("test.swf").

3. Uruchamiamy film, wybierając polecenie Play movie z menu Control.

Wyniki są następujące.

1. W klatce 1. pojawia się emptyClip, powodując zdarzenie load.

2. Wywołanie funkcji loadMovie( ) w klatce 5. ma dwojakie skutki:

a) zawartość klipu emptyClip zostaje usunięta, by zrobić miejsce dla pliku test.swf ,oraz powoduje zdarzenie unLoad,

b) załadowanie test.swf powoduje zdarzenie load.


Zdarzenie unload jest zazwyczaj wykorzystywane do inicjalizacji kodów czyszczących,porządkujących scenę lub zerujących w jakiś sposób środowisko programu. Innym zasto-sowaniem tego zdarzenia jest wykonanie określonych działań (na przykład uruchomienieinnego filmu) po zakończeniu klipu.

data

Zdarzenie data ma miejsce, kiedy do klipu filmowego są wczytywane zewnętrzne dane.Zdarzenie to, w zależności od rodzaju wczytywanych danych, może zostać wywołaneprzez dwie całkiem różne przyczyny. Zajmiemy się obydwoma przyczynami osobno.

Korzystanie z procedury obsługi zdarzenia data w połączeniu z loadVariables( )

Jeśli pobieramy serię zmiennych z serwera za pomocą funkcji loadVariables( ), to aby z nichskorzystać, musimy poczekać, aż załadują się w całości (patrz część III).

Kiedy klip otrzyma całą porcję pobieranych zmiennych, generowane jest zdarzenie data,informujące, że można już wykonać kod odwołujący się do tych zmiennych.

Załóżmy, że mamy program zawierający księgę gości, w której odwiedzający mogą wpi-sywać swoje komentarze. Komentarze te przechowujemy na serwerze. Kiedy użytkow-nik chce przeczytać komentarz, musimy pobrać go z serwera, korzystając z loadVariables( ).Nim jednak będziemy mogli pokazać komentarz, musimy wyświetlać ekran informującyo pobieraniu danych. Wyświetlamy go do czasu, aż potrzebne dane zostaną pobranez serwera. Procedura obsługi zdarzenia data poinformuje, kiedy dane zostaną wczytanei od kiedy możemy bezpiecznie wyświetlić komentarz użytkownikowi.

Listing 10.3 jest uproszczonym skrótem kodu księgi gości ukazującym działanie proceduryobsługi zdarzenia data w połączeniu z loadVariables( ). W naszym przykładzie przyciskładuje dwie zmienne zakodowane w formacie URL z pliku tekstowego do klipu. Klipzawiera procedurę obsługi zdarzenia data wykonywaną, kiedy dane zostaną pobrane. Kodprocedury wyświetla wartość zmiennych. Wiemy, że dane mogą być bezpiecznie wy-świetlone, gdyż procedura obsługi zdarzenia będzie wykonana po zdarzeniu data (czylikiedy dane zostaną w całości pobrane).

Listing 10.3. Oczekiwanie na zdarzenie data

// ZAWARTOŚĆ PLIKU guestbook.txtname=judith&message=hello

// PRZYCISK WEWNĄTRZ KLIPUon (release) { this.loadVariables("guestbook.txt");}

// PROCEDURA WEWNĄTRZ KLIPU

onClipEvent (data) { trace(name); trace(message);}


Ze zdarzeń data będziemy jeszcze korzystać podczas budowaniu formularza w rozdziale 17.,„Interaktywne formularze”.

Użycie procedury obsługi zdarzenia data w połączeniu z loadMovie( )

Drugi sposób użycia zdarzenia data jest związany z ładowaniem zewnętrznego pliku .swfdo klipu za pomocą funkcji loadMovie( ). Podczas ładowania do klipu nadrzędnego plikdomyślnie uruchamia się natychmiast, nawet gdy tylko jego część jest załadowana. Niezawsze jest to działanie pożądane, czasami chcemy mieć pewność, że cały plik lub okre-ślona jego część została załadowana, nim zacznie się odtwarzanie. Pewność tę możnazyskać dzięki procedurze obsługi zdarzenia data oraz kilku linijkom kodu preloadera.

Zdarzenie data ma miejsce za każdym razem gdy klip nadrzędny otrzyma porcję danychz zewnętrznego pliku .swf. Definicja „porcji” jest bardziej skomplikowana, niż można byprzypuszczać. Aby wywołać zdarzenie data, co najmniej jedna klatka musi zostać zała-dowana w całości, od momentu, gdy miało miejsce poprzednie zdarzenie data lub odrozpoczęcia ładowania pliku .swf. (W rzeczywistości w tym czasie może zostać załado-wana więcej niż jedna klatka, ale jedna klatka to minimum wymagane, by wywołać zda-rzenie data). Wywoływanie zdarzeń data jest związane z wyświetlaniem klatek przezFlash Player. Po wyświetleniu każdej klatki interpreter sprawdza, czy załadowano jakąśczęść zewnętrznego pliku .swf do klipu zawierającego procedurę zdarzenia data. Jeśliczęść zewnętrznego pliku .swf została załadowana i w części tej znajduje się co najmniejjedna klatka, następuje zdarzenie data. To sprawdzenie ma miejsce raz i tylko raz nakażdą wyświetloną klatkę (nawet jeśli wskaźnik odczytu jest zatrzymany).

Warto zauważyć, że ze względu na to, iż zdarzenie data jest sprawdzane raz na klatkę,filmy z wyższą szybkością odtwarzania mają płynniejsze preloadery, gdyż częstsze jestw nich odświeżanie stanu wczytywania pliku .swf.

Dokładna liczba wywołań zdarzenia data podczas operacji loadMovie( ) zależy od budo-wy wewnętrznej pliku .swf oraz szybkości łącza. Jednoklatkowy plik .swf, nieważne jakduży, wywoła tylko jedno zdarzenie data. Z drugiej strony, plik .swf zawierający 100 klatekmoże wywołać do 100 osobnych zdarzeń data, w zależności od prędkości odtwarzaniafilmu, wielkości w bajtach każdej klatki i prędkości połączenia sieciowego. Jeśli klatki sąduże a połączenie wolne — zostanie wywołanych więcej zdarzeń data (jedno na klatkę).Jeśli klatki są małe, a połączenie szybkie, zostanie wywołanych mniej zdarzeń data (całe100 klatek można wczytać podczas wyświetlania dwóch klatek przez Flash Player, wywo-łując tylko jedno zdarzenie data).

Jak w takim razie wykorzystać procedurę obsługi zdarzenia data podczas budowaniapreloadera? Kiedy zdarzenie data ma miejsce w wyniku działania funkcji loadMovie( ),wiemy, że nastąpił postęp we wczytywaniu pliku .swf. Dzięki temu z procedury obsługizdarzenia data możemy sprawdzić, czy została wczytana wystarczająca część pliku, byzezwolić na odtwarzanie. Użyjemy do tego funkcji getBytesLoaded( ) oraz getBytesTotal( )w sposób ukazany w listingu 10.4 (alternatywny sposób opiera się na wykorzystaniuwłaściwości klipu _framesLoaded oraz _totalFrames). Listing ten zawiera równieżpewne rozwiązanie wykorzystane podczas ładowania filmu.


I jeszcze jedno. Wczytywany plik .swf powinien mieć w pierwszej klatce wywołanie funkcjistop( ), która zapobiegnie samoczynnemu odtwarzaniu przed wczytaniem w całości.Zmodyfikowana wersja listingu 10.4 dostępna jest w internetowej witrynie Code Depotoraz na serwerze FTP Wydawnictwa Helion.

Listing 10.4. Preloader wykorzystujący zdarzenie data

onClipEvent (data) { trace("Otrzymano dane"); // Właśnie się zaczyna

// Włączenie lampki transferu danych _root.transferIndicator.gotoAndStop("on");

// Jeśli wczytywanie filmu zakończyło się – wyłączenie lampki transferu // danych i uruchomienie filmu. if (getBytesTotal( ) > 0 && getBytesLoaded( ) == getBytesTotal( )) { _root.transferIndicator.gotoAndStop("off"); play( ); }

// Wyświetlenie odświeżonej informacji o ładowaniu w polach tekstowych // w _root _root.bytesLoaded = getBytesLoaded( ); _root.bytesTotal = getBytesTotal( ); _root.clipURL = _url.substring(_url.lastIndexOf("/") + 1, _url.length);}

Klipowe zdarzeniagenerowane przez użytkownika

Pozostałe zdarzenia klipowe są związane z działaniami użytkownika. Kiedy ma miejscektóreś z klipowych zdarzeń użytkownika, wszystkie klipy znajdujące się na scenie (nie-istotne, jak głęboko zagnieżdżone w innych klipach) otrzymują o tym informację. W tensposób wiele klipów może zareagować na jedno kliknięcie, ruch myszy czy wciśnięcieklawisza na klawiaturze. Aby wykonać kod w oparciu o umiejscowienie kursora myszywzględem określonego klipu, uchwyt zdarzenia powinien sprawdzać położenie wskaź-nika myszy wobec klipu. Wbudowana funkcja hitTest( ) pozwala na łatwe sprawdzenie,czy kliknięcie nastąpiło w określonym rejonie, co zobaczymy w listingu 10.9.

mouseDown

Podobnie jak przyciskowe zdarzenie press, zdarzenie klipowe mouseDown wykrywa wci-śnięcie klawisza myszy. Zdarzenie mouseDown zachodzi zawsze, kiedy główny klawiszmyszy zostanie wciśnięty niezależnie od tego, w którym miejscu sceny znajduje sięwskaźnik myszy.

W przeciwieństwie do przyciskowego zdarzenia press zdarzenie mouseDown nie jestzwiązane z żadnym obszarem aktywnym. W połączeniu ze zdarzeniami mouseUp, mouse-Move, a także z metodą Mouse.hide( ), mouseDown może być wykorzystane do utworzenianiestandardowego kursora — pokażemy to w listingu 10.8.

Klipowe zdarzenia generowane przez użytkownika 251

mouseUp

Zdarzenie mouseUp jest odpowiednikiem mouseDown. To zdarzenie ma miejsce, za każ-dym razem kiedy główny klawisz myszy zostanie zwolniony nad dowolnym obszaremsceny. Podobnie jak w przypadku mouseDown, klip musi znajdować się na scenie pod-czas kliknięcia, by zdarzenie miało dla niego jakieś konsekwencje. Zdarzenia mouseUp,mouseDown oraz mouseMove mogą być wykorzystane do zbudowania wielopoziomowejobsługi myszy bez względu na położenie jej wskaźnika (jak ma to miejsce w przypadkuzdarzeń przyciskowych).

mouseMove

Zdarzenie mouseMove pozwala wychwytywać różnice w położeniu wskaźnika myszy.Kiedy wskaźnik myszy przemieszcza się, wywoływane są raz za razem zdarzenia mouse-Move, tak szybko jak tylko procesor jest w stanie je generować. Klip zawierający proceduręobsługi zdarzenia mouseMove musi być obecny na scenie podczas ruchów myszy, by zda-rzenie mouseMove odniosło skutek

Zdarzenie mouseMove jest wykorzystywane do aktywowania „wyłączonych” aplikacji, obli-czania trasy ruchu myszy i tworzenia własnych kursorów, co zobaczymy w listingu 10.8.

keyDown

Zdarzenia keyDown i keyUp są tym samym dla klawiatury, co mouseDown i mouseUp dlamyszy. Razem są podstawowym narzędziem do budowania obsługi klawiatury. ZdarzeniekeyDown zachodzi, kiedy jakiś klawisz na klawiaturze zostanie wciśnięty. Jeśli klawiszzostanie przytrzymany, zdarzenie keyDown będzie się powtarzać z częstotliwością zależnąod systemu operacyjnego i ustawień klawiatury. W przeciwieństwie do zdarzenia przy-ciskowego keyPress klipowe zdarzenie keyDown ma miejsce po wciśnięciu dowolnegoklawisza — a nie ściśle określonego. Aby wyłapać (lub inaczej przechwycić bądź wykryć)zdarzenie keyDown, klip z procedurą obsługi zdarzenia musi znajdować się na sceniew momencie wciśnięcia klawisza. Następujący kod wyłapuje zdarzenie keyDown:

onClipEvent (keyDown) { trace("Jakiś klawisz został wciśnięty");}

Trzeba zauważyć, że nasz kod nie precyzuje, który klawisz został wciśnięty. Jeśli chce-my, by użytkownik nacisnął dowolny klawisz, to taki kod wystarczy. Zazwyczaj jednakchcemy związać z określonym klawiszem konkretne działania. Na przykład chcemy, byróżne klawisze kierowały statek kosmiczny w różne strony.

Aby dowiedzieć się, który klawisz spowodował zdarzenie keyDown, korzystamy z wbudo-wanego obiektu Key, opisującego stan klawiatury. Rodzaj poszukiwanej przez nas informacjizależy od rodzaju interaktywności, który zamierzamy osiągnąć. Gry za przykład wymagająciągle odświeżanej informacji o potencjalnie równoczesnych wciśnięciach klawiszy.


Z kolei interfejs nawigacyjny może jedynie potrzebować wykrycia pojedynczego wciśnięciaklawisza (na przykład w prezentacji — pokazie slajdów — wciśnięcia spacji). Obiekt Keymoże poinformować, który klawisz został wciśnięty jako ostatni i czy określony klawiszjest wciąż wciśnięty. Do odczytywania stanu klawiatury korzystamy z czterech metodobiektu Key:

Key.getCode( ) // dziesiętna wartość kodu ostatnio wciśniętego klawiszaKey.getAscii( ) // dziesiętna wartość w kodzie ASCII ostatnio wciśniętego // klawiszaKey.isDown(keycode) // zwraca true, jeśli klawisz podany jako parametr jest

// wciśniętyKey.isToggled(keycode) // ustala, czy Caps Lock lub Num Lock jest włączony

Listing 10.5 pokazuje procedurę obsługi zdarzenia keyDown wyświetlającą wartość koduASCII ostatnio wciśniętego klawisza.

Listing 10.5. Sprawdzanie ostatnio wciśniętego klawisza

onClipEvent (keyDown) { // Pobranie wartości ASCII ostatnio naciśniętego klawisza i przekształcenie // jej w odpowiadający jej znak

lastKeyPressed = String.fromCharCode(Key.getAscii( )); trace("Nacisnąłeś klawisz'" + lastKeyPressed + "' .");}

Listing 10.6 pokazuje przykładową procedurę obsługi zdarzenia keyDown sprawdzającą,czy ostatnim naciśniętym klawiszem była strzałka w górę.

Listing 10.6. Sprawdzanie wciśnięcia strzałki w górę

onClipEvent (keyDown) { // Sprawdzenie, czy strzałka w górę była ostatnim naciśniętym klawiszem // Strzałka w gore jest reprezentowana przez właściwość Key.UP if (Key.getCode( ) == Key.UP) { trace("Strzałka w górę jest ostatnim wciśniętym klawiszem."); }

}

Istnieje kilka sposobów sprawdzania stanu klawiatury, wybór najlepiej pasującego doaplikacji należy do użytkownika. Przykładowo metoda Key.getAscii( ) zwracająca wartośćASCII znaku związanego z ostatnio naciśniętym klawiszem na klawiaturach różnychjęzyków może się różnić (w anglojęzycznych klawiaturach rozmieszczenie liter i znakówjest jednolite).

Z drugiej strony, metoda Key.getCode( ) zwraca wartość kodu klawisza, a nie kodu ASCIIodpowiadającego mu znaku. Ta metoda może być bardziej przydatna w aplikacjachz więcej niż jedną wersją językową, a także w aplikacjach hybrydowych działających naróżnych platformach. Możemy się nią posłużyć, jeśli chcemy na przykład użyć czterechsąsiadujących klawiszy do nawigacji niezależnie od tego, jakim znakom odpowiadają. Wię-cej informacji na ten temat znajduje się w części III, w rozdziale pod tytułem „Obiekt Key”.

Z internetowej witryny Code Depot oraz serwera FTP Wydawnictwa Helion można po-brać przykładowe pliki źródłowe .fla z obsługą zdarzeń keyDown i keyUp.

Klipowe zdarzenia generowane przez użytkownika 253

Procedury obsługi zdarzeń reagujące na klawiaturę działają tylko wtedy, gdy okienkoFlash Player jest okienkiem aktywnym. Użytkownik musi kliknąć okno z filmem,by procedury obsługujące zdarzenia klawiatury prawidłowo działały. Musimy wziąćpod uwagę zmuszenie użytkownika do kliknięcia jakiegoś przycisku w prezentacjiprzed wejściem do sekcji korzystającej z klawiatury.

Obsługa klawiszy specjalnych

Aby wyłączyć obsługę poleceń menu w odtwarzaczach — projektorach (plikach .exe wyge-nerowanych z filmu Flash), dodajemy na początku filmu następującą linię kodu.

fscommand("trapallkeys", "true");

Ta linijka kodu zabezpiecza również przed wyjściem z trybu pełnoekranowego (Fullscreen)w projektorze przy użyciu klawisza Escape. Aby przechwytywać wciśnięcia klawisza Escw projektorze, użyjemy następującego kodu:

onClipEvent (keyDown) { if (Key.getCode( ) == Key.ESCAPE) { // Odpowiedz na wciśnięcie klawisza Escape }}

Warto pamiętać, że klawisz Escape może nie być przechwytywany we wszystkich przeglą-darkach. Co więcej, nie ma możliwości wyłączenia klawisza Alt lub w przypadku Win-dows sekwencji Alt/Tab czy Ctrl/Alt/Delete.

Aby przechwytywać wciśnięcie klawisza Tab, utworzymy przycisk z następującymuchwytem:

on (keyPress "<Tab>") { // Odpowiedz na wciśnięcie klawisza Tab}

W filmie odtwarzanym w samodzielnym projektorze klawisz Tab może być przechwy-tywany również przez procedurę obsługi zdarzenia w klipie, na przykład:

onClipEvent (keyDown) { if (key.getCode( ) == Key.TAB) { // Odpowiedz na wciśnięcie klawisza Tab }}

W niektórych przeglądarkach wciśnięcie klawisza Tab może być wykryte wyłącznie przezprzyciskowe zdarzenie keyPress. Czasami może nawet być konieczne połączenie keyPressz klipowym zdarzeniem keyUp. Poniższy kod najpierw przechwytuje wciśnięcie Tab zapomocą keyPress, a następnie reaguje na nie w procedurze obsługi zdarzenia keyUp. Wartozauważyć, że nie korzystamy ze zdarzenia keyDown. Metoda Key.getCode( ) w przeglą-darce Internet Explorer działa wyłącznie podczas puszczania klawisza Tab.

// KOD DLA PRZYCISKU W GŁÓWNEJ LISTWIE CZASOWEJon (keyPress "<Tab>") { // Ustawienie nieistotnej zmiennej foo = 0;}


// KOD DLA KLIPU W GŁÓWNEJ LISTWIE CZASOWEJonClipEvent (keyUp) { if (Key.getCode( ) == Key.TAB) { // ustawienie kursora w polu tekstowym myTextField w _level0

Selection.setFocus("_level0.myTextField");

}}

Zazwyczaj celem przechwytywania wciśnięcia klawisza Tab jest przesunięcie kursorawprowadzania tekstu do określonego pola tekstowego w formularzu. Więcej szczegółówna ten temat znajdziemy w rozdziale „Metoda Selection.SetFocus( )” w części III.

Aby przechwytywać skróty klawiszowe w rodzaju Ctrl/F, posłużymy się procedurą obsługizdarzenia klipowego enterFrame w połączeniu z metodą Key.isDown( ):

onClipEvent (enterFrame) { if (Key.isDown(Key.CONTROL) && Key.isDown(70)) { // Odpowiedz na wciśnięcie Ctrl-F }}

Aby przechwycić wciśnięcie klawisza Enter (Return), można skorzystać z procedury obsługizdarzenia przyciskowego:

on (keyPress "<Enter>") { // Odpowiedz na wciśnięcie Enter (na przykład wysłanie formularza)}

Można także użyć procedury obsługi zdarzenia keyDown:

onClipEvent (keyDown) { if (Key.getCode( ) == Key.ENTER) { // Odpowiedz na wciśnięcie Enter (na przykład wysłanie formularza) }}

Więcej informacji o przechwytywaniu specjalnych klawiszy (jak klawisze funkcyjne czyklawisze z klawiatury numerycznej) znajdziemy w rozdziałach „Obiekt Key” oraz „MetodaKey.getCode( )” w części III.

keyUp

Zdarzenie keyUp ma miejsce, kiedy wciśnięty klawisz zostanie puszczony. Zdarzenie keyUpma kluczowe znaczenie przy programowaniu gier — pozwala wyłączyć to, co zostałowcześniej włączone przy użyciu keyDown; klasycznym przykładem jest hamowanie statkukosmicznego. Następnym przykładem może być środowisko Flasha, gdzie wciśnięciei przytrzymanie spacji czasowo przełącza na narzędzie Hand, zaś puszczenie spacji przywra-ca poprzednie narzędzie. Takie podejście może znaleźć zastosowanie w aplikacjach dowywoływania i ukrywania pewnych elementów (na przykład menu).

Podobnie jak w przypadku keyDown, aby otrzymać od zdarzenia keyUp użyteczną infor-mację, należy je stosować w połączeniu z obiektem Key:

Kolejność wykonywania 255

onClipEvent (keyUp) { if (!Key.isDown(Key.LEFT)) { trace("Strzałka w lewo nie jest wciśnięta"); }}

Ponieważ metoda Key.isDown( ) pozwala sprawdzać stan dowolnego klawisza w dowolnejchwili, możemy użyć pętli zdarzenia enterFrame by sprawdzać, czy określony klawiszzostał puszczony. Niemniej jednak skanowanie klawiatury (czyli ciągłe sprawdzaniestanu klawiatury) jest mniej efektywne niż czekanie na zdarzenie keyDown, które poin-formuje nas, że klawisz został wciśnięty.

Podejście ostatecznie wybrane zależy od rodzaju aplikacji, którą tworzymy. W dyna-micznej aplikacji, takiej jak gra, skanowanie może być jak najbardziej uzasadnione, ponie-waż i tak każda klatka przechodzi przez główną pętlę gry. Tak więc podczas wykony-wania normalnej pętli możemy dodatkowo sprawdzać obiekt Key. Na przykład tak:

// KOD W PUSTYM KLIPIE// Pętla powodująca, ze gra działaonClipEvent (enterFrame) { _root.mainLoop( );}

// GŁÓWNY KOD GRY W GŁÓWNEJ LISTWIE CZASOWEJ// To jest wykonywane raz na każdą wyświetloną klatkęfunction mainLoop ( ) { if (Key.isDown(Key.LEFT)) { trace("Strzałka w lewo jest wciśnięta"); // Obracanie statku kosmicznego w lewo } // Sprawdzanie pozostałych klawiszy, a później rozpoczęcie cyklu od nowa}

W statycznej aplikacji z interfejsem nie musimy używać pętli enterFrame do sprawdzaniastanu klawiszy, chyba że chcemy wychwytywać specjalne kombinacje klawiszy (czylikilka klawiszy wciśniętych równocześnie). Zwykle powinniśmy stosować procedury obsługizdarzeń keyDown oraz keyUp, które są wywoływane dokładnie raz dla każdego naciśnięciai puszczenia klawisza. Używając uchwytów zdarzeń keyUp i keyDown, nie musimy zasta-nawiać się w każdej chwili, czy klawisz jest wciąż wciśnięty. Ta metoda pozwala precyzyjniewykrywać wciskanie klawiszy, nawet jeśli użytkownik puści klawisz między klatkami;jak również zabezpiecza przed sprawdzaniem dwa razy tego samego klawisza, jeśli był onwciśnięty tylko raz. Zazwyczaj będziemy korzystać z metod Key.getCode( ) oraz Key.getAscii( )wraz z procedurami obsługi zdarzeń keyDown i keyUp, by sprawdzić, który klawisz zostałwciśnięty jako ostatni.

Kolejność wykonywania

Niektóre aplikacje mają kod podzielony na wiele listew czasowych oraz klipowych pro-cedur obsługi zdarzeń. Nie jest więc niczym niezwykłym, że w pojedynczej klatce będziewykonywany kod podzielony na liczne bloki znajdujące się w procedurach obsługi zda-rzeń, listwach czasowych klipów oraz głównej listwie czasowej. W takich sytuacjach ko-lejność, w jakiej różne części kodu są wykonywane, może stać się złożona i mieć poważny


wpływ na działanie programu. Zapoznanie się z kolejnością, w jakiej procedury obsługizdarzeń są wykonywane w stosunku do różnych listew czasowych w filmie, pozwoliuniknąć przykrych niespodzianek i zagwarantować, że nasz kod będzie zachowywał się,tak jak chcemy.

Asynchroniczne procedury obsługi zdarzeń są wykonywane niezależnie od kodu znaj-dującego się na listwach czasowych. Przykładowo przyciskowe procedury obsługi zdarzeń,podobnie jak procedury obsługi zdarzeń mouseDown, mouseUp, mouseMove, keyDown orazkeyUp, są wykonywane bezpośrednio po wystąpieniu zdarzenia.

Z kolei procedury obsługi zdarzeń związanych z odtwarzaniem filmu są wykonywanew określonej kolejności związanej z odtwarzaniem filmu, co pokazuje tabela 10.3.

Tabela 10.3. Kolejność wykonywania procedur obsługi zdarzeń klipów filmowych

Procedura obsługi

zdarzenia

Czas wykonania

load Jest wykonywana w pierwszej klatce, w której klip pojawia się na scenie,po wykonaniu kodu z listwy czasowej wyższego poziomu, ale przedwewnętrznym kodem klipu oraz przed wyświetleniem klatki

unload Jest wykonywana w pierwszej klatce, w której klipu już nie ma nascenie, przed wykonaniem kodu z listwy czasowej wyższego poziomu

enterFrame Jest wykonywana w drugiej i każdej następnej klatce, w których klipznajduje się na scenie. Jest wykonywana przed kodem z listwy czasowejwyższego poziomu oraz przed wewnętrznym kodem klipu

data Jest wykonywana w każdej klatce, w której klip otrzymuje dane. Jeślizostanie wywołana, jest wykonywana zarówno przed wewnętrznymkodem klipu, jak i kodem procedury enterFrame

Zasady zawarte w tabeli 10.3 łatwiej przyswoić na konkretnym przykładzie. Załóżmy, żemamy film zbudowany z jednej warstwy, z czterema klatkami kluczowymi na głównejlistwie czasowej. Do każdej z tych klatek dołączamy pewien kod. Następnie dodajemydrugą warstwę, w której umieszczamy klip filmowy w klatkach od 1. do 3. (czyli w klat-ce 4. klipu już nie ma). W naszym klipie wprowadzamy procedury obsługi zdarzeń load,enterFrame oraz unload. W końcu wewnątrz klipu tworzymy trzy klatki kluczowe, z którychkażda również zawiera fragment kodu. Rysunek 10.2 pokazuje, jak wygląda nasz film.

Kiedy odtwarzamy nasz film, kolejność wykonywania kodu jest następująca.

========KLATKA 1========1. Wykonanie kodu z głównej listwy czasu2. Wykonanie kodu procedury obsługi zdarzenia load3. Wykonanie kodu z klatki 1. klipu========KLATKA 2========1. Wykonanie kodu procedury obsługi zdarzenia enterFrame2. Wykonanie kodu z klatki 2. klipu3. Wykonanie kodu z głównej listwy czasu========KLATKA 3========1. Wykonanie kodu procedury obsługi zdarzenia enterFrame2. Wykonanie kodu z klatki 3. klipu3. Wykonanie kodu z głównej listwy czasu

Kopiowanie procedur obsługi zdarzeń klipowych 257

Rysunek 10.2. Kolejność wykonywania kodu w przykładowym filmie

========KLATKA 4========1. Wykonanie kodu procedury obsługi zdarzenia unload2. Wykonanie kodu z głównej listwy czasu

Kolejność wykonywania kodu w naszym przykładowym filmie obrazuje kilka reguł, którewarto mieć w małym palcu podczas programowania przy wykorzystaniu procedur ob-sługi zdarzeń.

• Kod procedury obsługi zdarzenia load jest wykonywany przed wewnętrznym kodemklipu, może więc zostać użyty do inicjalizacji zmiennych, które zostaną wykorzystanejuż w pierwszej klatce klipu.

• Kod znajdujący się w klatce, w której klip pojawia się na scenie, jest wykonywanyprzed kodem procedury obsługi zdarzenia load. Z tego względu zmienne oraz funkcjezdefiniowane przez użytkownika w klipie są dostępne dla listwy czasowej wyższegopoziomu dopiero od następnej klatki po klatce, w której klip pojawił się na scenie, nawetjeśli te zmienne i funkcje zostały zadeklarowane w procedurze obsługi zdarzenia load.

• Procedura obsługi zdarzenia enterFrame nigdy nie jest wykonywana w tej samej klatceco procedury obsługi zdarzeń load i unload. Zdarzenia load i unload zastępują enterFramew klatkach, w których klip pojawia się na scenie oraz z niej znika.

• W każdej klatce kod procedury obsługi zdarzenia enterFrame jest wykonywany przedkodem w listwie czasu rodzica. Dzięki temu, korzystając z procedury obsługi zdarzeniaenterFrame, możemy zmieniać właściwości listwy czasowej elementu nadrzędnegowzględem klipu i od razu wykorzystywać je w kodzie tej listwy czasowej, a wszystkopodczas odtwarzania jednej klatki.

Kopiowanie procedur obsługi zdarzeń klipowych

Na początek krótkie stwierdzenie mające poważne implikacje — procedury obsługi zdarzeńsą kopiowane razem z klipem podczas powielania za pomocą funkcji duplicateMovieClip( ).Przypuśćmy, że mamy na scenie klip o nazwie square zawierający następującą proceduręobsługi zdarzenia load:


onClipEvent (load) { trace("Klip załadowany");}

Co się stanie, jeśli skopiujemy square, tworząc square2?

square.duplicateMovieClip("square2", 0);

Ponieważ procedura obsługi zdarzenia load jest kopiowana razem z klipem square, utwo-

rzenie square2 powoduje wykonanie jego procedury obsługi zdarzenia load, wyświetlającejw okienku Output napis „Klip załadowany”. Korzystając z tego automatycznego utrzymy-wania procedur, możemy sprawnie utworzyć funkcje rekurencyjne dające spore korzyści.Aby przekonać się, że to tylko czubek góry lodowej możliwości tkwiących w tym me-chanizmie, przyjrzyjmy się listingowi 10.2.

Odświeżanie ekranuprzy użyciu updateAferEvent

Jak dowiedzieliśmy się wcześniej w podrozdziale „Kolejność wykonywania”, proceduryobsługi zdarzeń mouseDown, mouseUp, mouseMove, keyDown oraz keyUp są wykonywaneod razu po zajściu tych zdarzeń. Od razu znaczy natychmiast, nawet jeśli zdarzenie miałomiejsce między wyświetleniem kolejnych klatek.

Ta szybkość wykonania może dać filmowi możliwość równie szybkiego reagowania, leczmożemy ją łatwo stracić. Domyślnie efekty wizualne działania procedur obsługi zdarzeńmouseDown, mouseUp, mouseMove, keyDown oraz keyUp nie zostaną fizycznie wyświetloneprzez odtwarzacz Flash Player przed wyświetleniem kolejnej klatki. By przekonać się, żetak to działa, utworzymy jednoklatkowy film o szybkości odtwarzania równej 1 fpsi umieścimy na scenie klip z następującym kodem.

onClipEvent (mouseDown) {

_x +=2;}

Uruchomimy film i postaramy się klikać najszybciej jak tylko można. Zauważymy, żewszystkie kliknięcia zostały zarejestrowane, lecz klip przesuwa się tylko raz w ciągusekundy. Jeśli więc klikniemy 6 razy między klatkami, klip przesunie się w prawo o 12pikseli podczas wyświetlania kolejnej klatki. Jeśli klikniemy 3 razy, klip przesunie się o 6pikseli. Każde wykonanie procedury obsługi zdarzenia mouseDown jest więc rejestrowanemiędzy klatkami, ale efekty można zobaczyć dopiero po wyświetleniu klatki. Może miećto dramatyczne skutki dla niektórych form interaktywności.

Na szczęście możemy zmusić Flash do natychmiastowego odwzorowywania każdej wizual-nej zmiany spowodowanej przez uchwyt zdarzenia bez potrzeby czekania na następnąklatkę. Zrobimy to, wywołując funkcję updateAfterEvent( ) z wnętrza naszej proceduryw sposób następujący:

Dynamiczne procedury obsługi zdarzeń klipów filmowych 259

onClipEvent (mouseDown) { _x +=2; updateAfterEvent( );}

Funkcję updateAfterEvent( ) można wykorzystywać tylko ze zdarzeniami mouseDown, mouse-Up, mouseMove, keyDown oraz keyUp. Ma to często kluczowe znaczenie dla płynnego orazszybko reagującego odtwarzania filmu w warstwie wizualnej podczas różnych działańużytkownika. Dalej, w listingu 10.8, użyjemy funkcji updateAfterEvent( ) do płynnegowyświetlania niestandardowego kursora. Trzeba zwrócić uwagę, że zdarzenia przyci-skowe nie potrzebują bezpośredniego użycia funkcji updateAfterEvent( ), przyciski bowiem,zgodnie ze swą naturą, są odświeżane między klatkami.

Wielokrotne użycie kodu

Korzystając ze zdarzeń przyciskowych czy klipowych, nie zapominajmy o zasadachskupiania kodu poznanych w rozdziale 9. Zawsze starajmy się unikać niepotrzebnegopowielania oraz mieszania kodu między różnymi elementami filmu. Jeśli stwierdzimy,że wpisujemy ten sam kod w kolejnej procedurze obsługi zdarzenia, może nie jest naj-lepszym pomysłem dołączanie go bezpośrednio do obiektu.

Musimy starać się, aby kod był najbardziej ogólny, przenośmy go z obiektów do „prze-chowalni kodu”. Jednym z takich miejsc jest główna listwa czasowa. W wielu przypad-kach ukrywanie kodu w procedurach obsługi przycisków czy klipów nie jest najlepszymrozwiązaniem. Pamiętajmy, że umieszczenie kodu w funkcji i wywoływanie jej w pro-cedurach obsługi zdarzeń uczyni go łatwym do znalezienia i wprowadzania zmian. Jestto szczególnie istotne w przypadku przycisków — sam rzadko umieszczam w przyciskucoś innego niż wywołanie funkcji. W przypadku klipów filmowych musimy kierowaćsię zdrowym rozsądkiem — umieszczenie kodu bezpośrednio w klipie może prowadzićdo uporządkowanej, zawierającej dobrze podzielone skrypty architektury kodu. Próbujmyz różnymi podejściami, aż znajdziemy złoty środek między potrzebami a umiejętno-ściami. Zawsze warto brać pod uwagę niepotrzebną nadmiarowość oraz łatwość wielo-krotnego użycia.

By zobaczyć różnicę między umieszczeniem kodu bezpośrednio w przycisku a wywo-ływaniem funkcji z przycisków, przyjrzymy się podrozdziałowi „Wszystkie skryptyw jednym miejscu” w rozdziale 9.

Dynamiczne proceduryobsługi zdarzeń klipów filmowych

Na początku tego rozdziału omówiliśmy dwa rodzaje zdarzeń we Flashu — te, które sąpowiązane z klipami i przyciskami oraz te, które są związane z obiektami danych, jakXML czy XMLSocket. Aby utworzyć procedurę obsługi zdarzenia dla obiektu danych,przypisujemy do niego funkcję nazwaną, tak jak właściwość obiektu. Przypominamyskładnię dynamicznego dołączania funkcji.


myXMLdoc.onload = function ( ) { trace("Wszystko załadowane");};

Dynamiczne przypisywanie funkcji pozwala na zmianę działania procedury obsługizdarzenia podczas odtwarzania filmu. Musimy tylko zmienić przypisanie właściwościprocedury:

myXMLdoc.onload = function ( ) { gotoAndPlay("displayData");};

Możemy nawet wyłączyć działanie procedury:

myXMLdoc.onload = function ( ) { return;};

Niestety procedury obsługi zdarzeń dla klipów i przycisków nie są tak elastyczne; niemogą być zmieniane lub usuwane podczas odtwarzania filmu. Procedury obsługi zdarzeńtakże nie mogą być w żaden sposób dołączane do głównej listwy czasowej filmu! Niemożna bezpośrednio utworzyć uchwytu zdarzenia dla poziomu _root.

Aby obejść to ograniczenie — w przypadku enterFrame oraz zdarzeń użytkownika —możemy wykorzystać pusty klip filmowy, by zasymulować dynamiczną podmianę lubusuwanie procedur obsługi zdarzeń. Pusty klip umożliwia nawet symulowanie zdarzeńna poziomie _root. Widzieliśmy już tę technikę w rozdziale 8., gdzie poznawaliśmy

tworzenie pętli zdarzenia.

1. Tworzymy pusty klip filmowy o nazwie process.

2. W jego wnętrzu umieszczamy kolejny pusty klip o nazwie eventClip.

3. Do klipu eventClip dołączamy potrzebną procedurę obsługi zdarzenia. Kod zawartyw tej procedurze powinien adresować listwę czasową klipu process w sposóbnastępujący:

on ClipEvent (mouseMove) { _parent._parent.doSomeFunction( );}

4. Aby przygotować klip process do użycia z funkcją attachMovie( ), wybieramy gow oknie Library, a następnie wybieramy polecenie Linkage z menu Options. Wybieramyopcję Export This Symbol i przypisujemy mu odpowiedni identyfikator (na przykładmouseMoveProcess).

5. Aby wykorzystać naszą procedurę obsługi zdarzenia, dołączamy klip process doodpowiedniej listwy czasu, używając funkcji attachMovie( ).

6. By odłączyć procedurę, usuwamy klip process za pomocą funkcji removeMovieClip( ).

Instrukcję tłumaczącą krok po kroku wykorzystanie tej techniki ze zdarzeniem enterFrameznajdziemy w podrozdziale „Pętle sterowane zdarzeniami” w rozdziale 8.

Zastosowanie procedur obsługi zdarzeń

Nasze poznawanie zdarzeń ActionScript oraz procedur ich obsługi podsumujmy kilkomaprzykładami. Będą to proste aplikacje, które dadzą obraz tego, jak elastyczne może być

Zastosowanie procedur obsługi zdarzeń 261

programowanie oparte na zdarzeniach. Dwa ostatnie przykłady można pobrać z witrynyinternetowej Code Depot oraz z serwera FTP Wydawnictwa Helion. Listing 10.7 powiększai pomniejsza klip filmowy.

Listing 10.7. Zmiana wielkości klipu filmowego

onClipEvent (load) { var shrinking = false; var maxHeight = 300; var minHeight = 30;}

onClipEvent (enterFrame) { if (_height < maxHeight && shrinking == false) { _height += 10; _width += 10; } else { shrinking = true; }

if (shrinking == true) { if (_height > minHeight) { _height -= 10; _width -= 10; } else { shrinking = false; _height += 10; // Zwiększenie już tutaj

_width += 10; // dzięki temu nie stracimy cyklu } }}

Listing 10.8 symuluje niestandardowy wskaźnik myszy przez ukrycie kursora systemo-wego i przesuwanie klipu po ekranie za ruchem niewidocznego wskaźnika. W przykła-dzie procedury obsługi zdarzeń mouseDown i mouseUp delikatnie zmieniają rozmiarymyszy, by zasygnalizować kliknięcie.

Listing 10.8. Niestandardowy kursor myszy

onClipEvent (load) {

Mouse.hide( );}

onClipEvent (mouseMove) { _x = _root._xmouse; _y = _root._ymouse; updateAfterEvent( );}

onClipEvent (mouseDown) { _width *= .5; _height *= .5; updateAfterEvent( );}

onClipEvent (mouseUp) {

_width *= 2; _height *= 2; updateAfterEvent( );}


Na koniec, tylko by pokazać możliwości procedur obsługi zdarzeń klipowych w Action-Script — listing 10.9 zamieniający klip w symulowany przycisk. Procedura obsługi zdarzeniamouseMove sprawdza najechanie kursora na przycisk. Procedury mouseUp i mouseDown spra-wdzają klikanie przycisku. Funkcja hitTest( ) sprawdza, czy kursor znajduje się w „obszarzeaktywnym”. Nasz przykład zakłada, że klip z procedurą składa się z trzech klatek kluczo-wych nazwanych up, down i over (co odpowiada stanom normalnego przycisku).

Listing 10.9. Klipowy przycisk

onClipEvent (load) { stop( );}

onClipEvent (mouseMove) { if (hitTest(_root._xmouse, _root._ymouse, true) && !buttonDown) { this.gotoAndStop("over");

} else if (!hitTest(_root._xmouse, _root._ymouse, true) && !buttonDown) { this.gotoAndStop("up"); } updateAfterEvent( );}

onClipEvent (mouseDown) { if (hitTest(_root._xmouse, _root._ymouse, true)) {

buttonDown = true; this.gotoAndStop("down"); } updateAfterEvent( );}

onClipEvent (mouseUp) { buttonDown = false;

if (!hitTest(_root._xmouse, _root._ymouse, true)) { this.gotoAndStop("up"); } else { this.gotoAndStop("over"); } updateAfterEvent( );}

Naprzód!

Poznając wyrażenia, operatory i funkcje, a ostatnio zdarzenia i procedury ich obsługi,nauczyliśmy się, jak działają wszystkie wewnętrzne narzędzia ActionScript. By pogłębićnaszą znajomość języka, w trzech kolejnych rozdziałach zajmiemy się trzema niezmiernieważnymi typami danych: tablicami, obiektami oraz klipami filmowymi.

actionscript. przewodnik encyklopedyczny

Documents