#35.
Átmenetes maszk
Gradient mask
(Flash 8)

Gradiens átlátszó maszk használatára egy példa. A lényeg, hogy a maszkolt és a maszkoló MovieClip-eknek a cacheAsBitmap tulajdonsága true-ra legyen állítva és a maszkolást kódból kell elvégezni.

An example for gradient transparency mask. We have to set true the cacheAsBitmap property on the masker and masked MovieClips and use script-masking.

Forrás - Source (50K)

2006.04.17.
version: 8

#34.
Dinamikusan előállított kép mentése fájlba (BitmapData és PHP)
Capture dynamically created graphic and save to file (BitmapData and PHP)
(Flash 8)

A következő példában, dinamikusan előállított tartalmat fogunk "lefényképezni" és az adatokat átküldeni a szervernek. Majd az így létrejött képet letölthetővé tesszük.

In the next example, we'll create dynamic content, snap it and send the data to the server. Finally the server-generated picture can be downloaded.

Forrás - Source (85K)

2006.09.14.
version: 8

#33.
Külső tartalom duplikása (BitmapData)
Duplicata external contents (BitmapData)
(Flash 8)

Ha külső tartalmat töltünk be, akkor ezek duplikálása nem lehetséges a duplicateMovieClip()-pel, mivel ez csak az eredeti (nem dinamikusan létrehozott) tartalmat duplikálja. Erre nyújt megoldást a BitmapData osztály a BitmapData.draw és a MovieClip.attachBitmap metódusok segítségével. Az alábbi példában két jpeg fájlt lehet betölteni, amiket betöltődés után hatszor duplikálunk.

When loading external contents, then we can't duplicate these with duplicateMovieClip(), because this only duplicate the original contnent (not the dinamically created). To solve this problem, we can use the BitmapData class with BitmapData.draw and MovieClip.attachBitmap methods. Below in the example, we load two jpeg files, and after they downloaded duplicate them six times.

Forrás - Source (44K)

2006.08.06.
version: 8

#32.
FlashVars segítségével paraméterezhető flv lejátszó
flv player with FlashVars parameters
(Flash 7)

Eme bejegyzést ismét Summan-nak köszönhetjük:
Ebben a részben egy minimális tudással rendelkező flv (flash video) lejátszót készítünk.
A lejátszani kívánt flv fájl nevét, az URL-ben, paraméterként adjuk át a Flash mozinak, ennek előnye, hogy a videólejátszónkat elég csak egyszer elkészíteni, így ezt később bárhol, bármikor felhasználhatjuk, pusztán csak az átadott paramétert kell cserélnünk a megfelelőre.
Nézzük a mozinkat egy paraméterezett linkkel, klikk ide!
Ide klikkelve egy másik filmet játszunk le!
Mindkét esetben a popup-ban megnyitott PHP oldal, és az abba FlashObject-tel beágyazott Flash mozi teljesen ugyanaz, a különbség az átadott paraméterben mutakozik meg!

Flash ActionScript
// A Flashvars-ban megadott mozi változót flashben így érjük el: _root.mozi, a fogadott változót a "file" változóban tároljuk el
file = _root.mozi;
// Kapcsolat létrehozása
var nc:NetConnection = new NetConnection();
nc.connect(null);
// NetStream definiálása
var ns:NetStream = new NetStream(nc);
// A buffer, előtöltés idejét 5 másodpercben határozzuk meg
ns.setBufferTime(5);
// Csatoljuk a stream-et a saját videónkhoz
my_display.attachVideo(ns);
// A lejátszás megkezdése
ns.play(file);
//------------------------------------------------------------------------------------------------------------
// A hit_mc-t láthatatlanná tesszük, mivel az egész video kijelzőnket lefedi és gombként fog funkcionálni
hit_mc._alpha = 0;
// Ha a kijelzőnk felett lévő már nem látszó hit_mc-re kattintunk, akkor a lejátszás szünetel, ismét kattintva újra elindul
hit_mc.onPress = function() {
ns.pause();
};
// replay gombunkkal vissza térhetünk a mozi elejére
replay_btn.onPress = function() {
ns.seek(0);
};

Bővebben a NetStream osztályról

Flash beágyazása, (player.php)
A Flash beágyazása, a player.php-n belül, az előző blogbejegyzésben bemutatott FlashObject-tel történik. Az URL-ből kiszűrt változó a FlashObject, addVariable metódusával adódik át a Flash-nek, így:
fo.addVariable("mozi", "<? echo $mozi ?>");

A letölthető források között a player.php forrásában megtalálható teljes egészében, hogy miként is fogadjuk, majd adjuk tovább a kapott paramétert a Flash mozinak.

Forrás - Source (6K)

2006.06.14.
version: MX 2004

#31.
Az Internet Explorer és az ActiveX vezérlők új barátsága
The new friendship of Internet Explorer and ActiveX controls

A frissült Internet Explorer-ben (lásd itt) az ActiveX vezérlőkön keresztül betöltött tartalmakban, csak egy felesleges kattintásal tudjuk aktiválni a kezelőfelületet és az ily módon betöltődött tartalmakat, eme nagyszerü ötlet ellenszere, a FlashObject alant megtalálható (a megoldás eredetijét Geoff Stearns-nak köszönhetjük). A lényege, hogy JavaScript segítségével irassuk ki a Flash-t beágyazó kódot, amelyet egy különálló fájlban kell elhelyezni. Ez a JavaScript kód tartalmaz még Flash Player detektálást, FlashVars kezelést is, szóval nagyon hasznos darab.

In the refreshed Internet Explorer (see here) needs an unwanted click on the ActiveX contents to activate their functions. But we have got a workaround against this great idea, remedy is the FlashObject, as you can see below (thanks for Geoff Stearns for the original solution) You have to use JavaScript to write the Flash embedding code into the HTML, this code must placed in an external file. This JavaScript code contains Flash Player detection, FlashVars handling too, so it's very useful thing.

Kötelező paraméterek/Required parameters:
- swf
- id
- width
- height
- version
- background

Opcionális paraméterek/Optional parameters:
- useExpressInstall
- quality
- xiRedirectUrl
- redirectUrl
- detectKey

Forrás - Source (5K)

2006.04.20.

#30.
Dinamikus DropShadow és Blur használat
Using dynamically DropShadow and Blur
(Flash 8)

Példa a fent említett filterek dinamikus használatára:

An example for above-mentioned fillters.

Forrás - Source (16K)

2006.04.09.
version: 8

#29.
DropShadow és Blur filterek a Flash 8-ban
DropShadow and Blur filters in Flash 8
(Flash 8)

Eme bejegyzés Summan érdeme:
A PhotoShop-ból jól ismert Blur és DropShadow filter debütált a Flash 8-ban, ezek a szűrők a propertyes panelen keresztül kézzel, illetve ActionScript 2 segítségével dinamikusan is scriptelhetők, testre szabhatók.
Ebben a fejezetben a szűrők dinamikus kezelésével foglalkozunk csak.
Az említett, és a példában bemutatott két szűrő mellett, a Flash 8-ban helyet kaptak még az alábbi filterek is, ezeket csak felsorolás szintjén említeném meg (Glow, Bevel, Gradient Glow, Gradient Bevel)
Íme a példa fájl:

This entry posted by Summan:
The filters "Blur" and "Dropshadow" well known from the Photoshop has been debuted in Flash 8, these filters can be customized and scripted by the Actionscript 2 or manually through the properties panel of the filter.
In this chapter we conclude only about the dynamic handling of the filters.
Aside from the above-mentioned and in the example presented two filters there are several ones in the Flash 8. I would mention them only in brief (Glow, Bevel, Gradient Glow, Gradient Bevel)
Here is the example file:

Forrás - Source (139K)

2006.04.06.
version: 8

#28.
SWF Metadata Flash 8-ban - az swf fájl indexelése a keresőmotorokban.
SWF Metadata in Flash 8 - swf file will be indexed by search engines.
(Flash 8)

Ez a Flash 8 egyik újdonsága, mely lehetővé teszi, hogy az swf fájl tartalma könnyebben indexelhetővé váljon a keresőmotorok számára. A Flash mozihoz (swf fájlhoz) most metaadatot adható hozzá, mely az swf fájl fejlécében helyezkedik el, és így könnyű kiolvasni.
Ezen tulajdonságok beállításához, egy új vagy már létező Flash dokumentumot esetében nyissuk meg a Document Properties ablakot: válasszuk a Modify > Document (CTRL+M) menüpontot.

One of the new features of Flash 8 enables your swf file content to be more easily indexed by search engines. Now you can add metadata to your Flash movie (swf file). The metadata is added to the head of the SWF file so that it's easily read.
To set properties for a new or existing document in the Document Properties dialog box: choose Modify > Document (CTRL+M)

Itt lehet megadni a Flash dokumentum címét és leírását, ezek az értékek automatikusan bekerülnek az swf fájlba, amikor a mozit teszteljük vagy publikáljuk, A metaadatok tárolása RDF (Resource Description Framework) formában történik, mely egy W3C által elfogadott formátum.

Here you can enter a title and description for the Flash document, these values are automatically included with your swf file whenever you test or publish the movie. The metadata is specified in RDF (Resource Description Framework) and stored in the SWF file in a W3C-compliant format.


Linkek / Links:
Macromedia - Flash Professional 8: Features
Creating or opening a document and setting properties

2006.03.22.

#27.
Valid SWF beágyazás HTML-be, <embed> nélkül
Valid SWF embedding into HTML, without <embed>

Ez a bejegyés caber_net-nek köszönhető:
A Macromedia Flash programja által automatikusan elkészített HTML kód hagy némi kívánnivalót maga után, erről magad is meggyőződhetsz, ha meglátogatod a w3c validator oldalát.
Hibákat azonban nem csak a Flash követ el, sok más helytelen beidegződés forog még közkézen.
Nézzük miként kell kinéznie egy egyszerű, swf fájlt tartalmazó weboldalnak.

This entry posted by caber_net, thanks for him:
The HTML code generated by Macromedia Flash is not the best, you can see this, if you visiting the w3c validator's page.
Not the Flash alone what makes mistake.
Let's see how looks like a simply page which contains an swf file.


1. Dokumentum típus deklaráció.
Ezen a linken találhatóak a valid DTD típusok. Ezek közül egyet el kell helyeznünk rögtön a dokumentum elején. Preferálandó típus az XHTML, melynek legfrissebb verziója az 1.1-es.
1. Doctype declaration.
This link you can find out the valid DTD types. We have to place one of in front of the documentum. Preferred type is the XHTML, version 1.1 is the newest now.
<?xml version="1.0" encoding="iso-8859-2"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">


2. html tag.
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">


3. A head rész.
Ügyeljünk rá, hogy az XML jól formázottság érdekében minden tag legyen lezárva. Amelyiknek nincs záró párja (pl. meta és link tag-ek), azt önmagában.
Ha CSS-t és Javascriptet is használunk az oldalon, akkor ezek típusát is ajánlott megadni:
3. head part.
Take care of XML formatting, all tags will be close. Which has no closing pair (like meta and link tags), that will be close in itself.
If we use CSS and Javascript in the page, recommended to define type of these.
<title>Valid Flash beágyazás - valid Flash embedding </title>
<meta http-equiv="content-type" content="text/html;charset=ISO-8859-2" />
<meta http-equiv="Content-Style-Type" content="text/css" />
<meta http-equiv="Content-Script-Type" content="text/Javascript" />


4. CSS
Felejtsd el a body tag-ben megadott margin-top, margin-left attribútumokat, mert ezeket nem támogatja az ajánlás, a HTML tag-ek a dokumentum strukturájának felépítésére lettek kitalálva, formázásra ott a CSS.
Először egy 100%*100% méretű "fullscreen" Flash beágyazáshoz tartozó stílusinformációt adunk meg.
4. CSS
Forget the margin-top, margin-left attributes in body tag, because the reference doesnot support this, the HTML tags build the document structure, and CSS formats it.
First we define style informations for Flash what is embedded in an 100%*100% sized "fullscreen" page.
<style type="text/css">
body {
  margin:0px;
  padding:0px;
  background:#FFFFFF;
  color:#000000;
  overflow:hidden;
}
div.top {
  position:absolute;
  left:0px;
  top:0px;
  margin:0px;
  padding:0px;
  width:100%;
  height:100%;
}
object {
  width:100%;
  height:100%;
  margin:0px;
}
</style>

Széles körben elterjedt szokás a fix méretű swf-ek középre igazítását táblázattal megoldani, mely megoldások többsége nem valid, mindamellett korszerűtlen is. A táblázatok adatok strukturált megjelenítésére valók, nem pedig a design felépítésére. Lássunk egy megoldást egy 550*400px méretű doboz középre igazításra.
Use tables to centering a fix sized swf is a widespread technique, but in most case it's not valid and it's anachronistic. Use tables to show structured data, not for create design.
Let's see a workaround to centering a 550x400px sized box.
div.top {
  width:550px;
  height:400px;
  position:absolute;
  left:50%;
  top:50%;
  margin-left:-275px;
  margin-top:-200px;
}


5. Beágyazás
Talán legfeltűnőbb az <embed> tag hiánya. Elhagyására azért van szükség, mert nem tartalmazza az XHTML specifikáció. Ahhoz azonban, hogy ezzel együtt minden böngészőben megjelenjen az swf-ünk, nem elég a flash által generált kódból azt kitörölnük, egyéb változtatásokra is szükség van. Hogy miként alakult ki végül ez a formula, azaz a "satay method", arról bővebben Drew McLellan cikkében olvashatsz.
5. Embedding
Maybe well-marked we have no <embed> tag. We leave this, because the XHTML specification isnot contains. To work this code in all browser we need more changes, not enough to delete this from Flash generated code. If you want to know more about, how the formula "satay method" shaped out , you can read this in Drew McLellan's article.
<div class="top">
<object type ="application/x-shockwave-flash" data ="flash.swf">
<param name ="movie" value ="flash.swf" />
<param name ="quality" value ="high" />
<param name ="bgcolor" value ="#FFFFFF" />
</object>
</div>


6. Egyéb tennivalók
- Fontos megjegyezni, hogy ebben az esetben Internet Explorer alatt nem működik a _root töltésfigyelése, a flash tartalmát egy külső swf-ben kell elhelyezni, és egy üres moziklipbe tölteni, ha preloadert szeretnénk használni. Ez azonban nem jelenthet problémát, mert több okból kifolyólag is kerülendő a tartalom fő idősíkra helyezése, de ez már nem tartozik ezen leírás keretei közé.
- Valid beágyazásnál sajnos nem tudjuk közölni a böngészővel azt, hogy milyen verziószámú Flash plug-in kell a beágyazott mozi lejátszáshoz (codebase attribútum, csak az IE és a hasonló böngészők ismerik), ezért szükséges lehet egy detektáló moziklip, vagy Javascript elhelyezése is az oldalon.
6. Other things to do
- Important to notice, Internet Explorer doesn't stream the movie, so to preload the movie itself (_root) doesnot works, so we have to create an empty container movie which in the first frame and loads the essentials, what is an external swf and the preloader works fine.
- In valid embedding we can't tell the browser which Flash plug-in needs to play the embed movie (codebase attribute, IE and similar browsers using it) then we need a detector movie or JavaScript on the page.


7. Befejezés
Lezárjuk a html és body elemeket.
7. Finish
Close the html and body elements.
</body>
</html>

Forrás - Source (1K)

2006.02.28.

#26.
XML alapú menü
XML based menu
(Flash MX)

A mostani bejegyzésben vendégelőadónk, Summan következik, rögtön át is adnám a szót neki:
Ebben a részben egy egyszerű, XML-ből feltöltött flash menüt készítünk. Előnye, hogy csak egyetlen egy gombot kell "megrajzolnunk", a többi gombot kis programunk az XML file tartalma alapján duplikálja. Valamint ha a színét, betűtípusát, betű színét szeretnénk megváltoztatni akkor elég azt is csak egyszer elvégeznünk, azon az egy gombon. Előnyei közé tartozik az is, hogy módosításához elegendő akár egy jegyzettömb is, vagy akár egy szöveg szerkesztésre képes ftp kliens is. A menünek 2 féle paraméterezhető tulajdonsága van, egyik a gombok felirata, másik a gombnyomásra megnyitni kívánt url címe. Hátránya, hogy a flash beállított magassága miatt "csak" maximálisan 9 gombot tudunk megjeleníteni. Ill. ha több gombot szeretnénk akkor a flash magasságát, gombonként 26 pixellel kell megnövelnünk. A 26 pixel = 25 pixel a gomb magassága + 1 pixel a gombok közötti távolság.
Az XML file egy gombra vonatkozó adatai a következők:
<link>
<url>tandco.hu</url>
<leiras>Summan</leiras>
</link>
Az url sorba a megnyitni kívánt webcímet kell írni, http://www előtag nélkül, mert ezeket a részeket is majd a Flash "kipótolja" nekünk. A leiras taghoz tartozó szöveget pedig a gomb feliratként láthatjuk majd viszont. A menü bővítéséhez tehát elegendő egy ilyen részt lemásolni, átírni a 2 paraméter, majd az XML file-ban egy tetszőleges pozícióba beszúrni, a <link> és </link> tag-ek közé. Az XML-ben meghatározott sorrend egyben meghatározza a gombok sorrendjét is.
További kiegészítések és kommentek a forráskódban olvashatók. Érdekesség még talán, hogy a menü flash player 6-tól működő képes, ha 6-os flashre publikáljuk az alkalmazást akkor a végtermég mindössze csak 2 kbyte, ez is elenyésző méret már.., de 7-es flashre publikálva a méretet tovább csökkenthetjük 1 kbyte-ra ! :)
Sok szerencsét mindenkinek:)

This entry posted by Summan.
This time we create an XML based Flash menu. Advantage of this, we need create the button once, and this little program will create the others by the contets of XML file. If need to change the color, text, etc., change once in the source button. The menu has two parameters, the first is the button's label, and the second is the url which open, when the button was clicked. Disadvantage is that we can show only 9 buttons in the movie, when needs more buttons, we have to increae the movie's height with 26 pixels. 26 pixels = 25 pixels are the button's height + 1 pixel is the shift between buttons.
The XML file main structure:
<link>
<url>tandco.hu</url>
<leiras>Summan</leiras>
</link>
To the url write the url without http://www prefix ('cause the Flash will add it), and to the leiras write the text which will appears on the button (label). If we need a new menu element, enough to copy this between <link> and </link> tags to create one. Other supplements and comments in the source. Curiosity: this menu works on Flash player 6, when we publish to Flash 6 player, the size is evanescent: 2 kbyte, to publish Flash 7 player the size is decrased to 1 kbyte !:)
Good luck for everyone:)

Forrás - Source (5K)

2006.02.08.
version: MX 2004

#25.
MovieClipLoader Osztály
MovieClipLoader Class
(Flash MX 2004)

A MovieClipLoader osztály segítségével egy külső SWF vagy JPEG fájl (Flash 8-tól kezdve pedig, akár GIF vagy PNG) betöltődését kisérhetjük figyelemmel, hasonlóan mint bármilyen onEnterFrame-es előtöltővel. Mégis amiért foglalkolkozunk ezzel az osztállyal, annak az az oka, hogy jópár - a MovieClipLoader osztályhoz rendelt figyelőhöz kapcsolható - beépített eseménykezelővel rendelkezik. Ezek közül is leginkább az onLoadError eseménykezelőt emelném ki, amellyel a betöltés során fellépő hiba természete állapítható meg.

A MovieClipLoader csak Flash MX 2004-től és 7 player-től kezdve használható. A forrásfájlok Flash MX 2004-gyel készültek.

Gyorsan nézzünk is rá egy működő példát:

Az egész mozi egy frame-ből és 6 layer-ből áll, egy layer az ActionScript-eké, a többi pedig a különböző grafikáké és szimbólumoké.
A layereken tartalma, fentről lefelé:

Az ActionScript:
//A preloader részei ne látszódjanak
preloader_mc._visible = preloader_txt._visible = false;
// MovieClipLoader osztály my_mcl nevü példányát hozzuk létre
var my_mcl:MovieClipLoader = new MovieClipLoader();
// A figyelő létrehozása
var myListener:Object = new Object();
// Az addListener()-rel regisztráljuk a függvényeket tartalmazó objektumot az eseménykezelésekhez
my_mcl.addListener(myListener);
//
// A figyelőhöz társított eseménykezelők
//
// A betöltés megkezdődik
myListener.onLoadStart = function(target_mc:MovieClip) {
   preloader_mc._visible = preloader_txt._visible = true;
   echo(":: onLoadStart esemény ::\nA betöltés elkezdődött a "+target_mc+" nevü MovieClip-be.\n");
};
// A betöltődés folyamatos figyelése
myListener.onLoadProgress = function(target_mc:MovieClip, loadedBytes:Number,totalBytes:Number) {
   percent = Math.floor((loadedBytes/totalBytes)*100);
   preloader_txt.text = percent+" %";
   preloader_mc._width = 2*percent;
};
// A fájl sikeres betöltődött
myListener.onLoadComplete = function(target_mc:MovieClip) {
   echo(":: onLoadComplete esemény ::\nA betöltés befejeződött a "+target_mc+" nevü MovieClip-be.");
   var loadProgress:Object = my_mcl.getProgress(target_mc);
   echo(loadProgress.bytesLoaded+" = bájt töltődött be");
   echo(loadProgress.bytesTotal+" = bájtból.\n");
};
// A tartalom teljesen betöltődött és inicializálódott
myListener.onLoadInit = function(target_mc:MovieClip) {
   preloader_mc._visible = preloader_txt._visible = false;
   echo(":: onLoadInit esemény ::\nA "+target_mc+" nevü MovieClip inicializálódott.\n");
};
// Valamilyen hiba lépett fel a betöltés során, azt kezeljük le itt
myListener.onLoadError = function(target_mc:MovieClip, errorCode:String) {
   echo":: onLoadError esemény ::\nHIBA!"();
   echo("A HIBA KÓDJA: "+errorCode);
   echo("Nem sikerült a betöltés a "+target_mc+" nevü MovieClip-be.\n");
};
// Egy üres moziklip létrehozása, ebbe fogunk betölteni
this.createEmptyMovieClip("clip1_mc", this.getNextHighestDepth());
clip1_mc._x = 257;
clip1_mc._y = 5;
//
correct_btn.onRelease = function () {
   // A létező fájl betöltésének megkezdése
   my_mcl.loadClip("images/boris.jpg", clip1_mc);
}
wrong_btn.onRelease = function () {
   // A nem létező fájl betöltésének megkezdése
   my_mcl.loadClip("images/nincs_ilyen_fajl.jpg", clip1_mc);
}
// Függvény, mely a dinamikus szövegmezőbe írogat
function echo (src) {
   output_txt.text += src+"\n";
   output_txt.scroll = output_txt.maxscroll;
}



Most pedig következzék a MovieClipLoader osztály részletes ismertetése.


Első lépések: a deklarálás és a figyelőobjektum (listener) létrehozása

A következő két sorral létrehozzuk a MovieClipLoader osztály my_mcl nevü példányát és egy myListener nevü objektumot, amit majd hozzáadunk a MovieClipLoader-hez, de ne kapkodjuk el, hiszen ez lesz majd az első metódusunk:

var my_mcl:MovieClipLoader = new MovieClipLoader();
var myListener:Object = new Object();



Metódusok


addListener
my_mcl.addListener( listenerObject:Object )

Regisztrál egy objektumot, amely fogadja majd a hívott MovieClipLoader eseménykezelők jelzéseit. A "hallgató" a paraméterként megadott objektum lesz. Ezt a sort az előző kettőhöz hozzáírva, már el is végeztük a figyelőobjektum hozzáadását a MovieClipLoader-hez:

my_mcl.addListener(myListener);



loadClip
my_mcl.loadClip( url:String , target:Object )

Betölt egy SWF, JPEG (Flash 8-tól kezdve akár progressive JPEG, nem animált GIF, vagy PNG) fájlt egy MovieClip-be. (animált GIF esetén csak az első frame jelenik meg.) Ezt a metódust gyakorlatilag a loadMovie() vagy MovieClip.loadMovie() metódus helyett használjuk. A szerepe mindnek ugyanaz - egy külső fájl betöltése.

Paraméterek
url: Egy abszolút vagy relativ URL a fentebb említett fájltipusokhoz, amit be akarunk tölteni.

target: A MovieClip elérési útvonala, amibe betöltjük a fájlt, illetve hivatkozhatunk itt egy Flash-en belüli szintre (_level) is. Ebben az esetben a szint számát kell megadnunk.
A célpontul szolgáló MovieClip tartalma (ha van neki) felülíródik a betöltött SWF fájl vagy képfájl tartalmával.
Van egy Boolean tipusú visszatérési értéke, mely ha az URL kérés sikeresen elment true-val tér vissza ellenkező esetben false-szal.



removeListener
my_mcl.removeListener( listenerObject:Object )

Eltávolítja a figyelőt, melyet az addListener()-rel adzunk hozzá a MovieClipLoader-hez, így nem kapunk további visszajelzéseket a MovieClipLoader-ről.

Paraméterek
listenerObject: a figyelőobjektum, melyet a MovieClipLoader osztály addListener() metódusával adtunk a osztálypéldányunkhoz.
Boolean tipusú visszatérési értékkel rendelkezik, amely true ha a figyelő eltávolítása sikeres és false ha sikertelen.



unloadClip
my_mcl.unloadClip( target:Object )

Egy loadClip()-pel töltött mozi tartalmát üríti ki, a MovieClip.unloadMovie() metódushoz hasonlóan. Ha a metódust a betöltési folyamat alatt hívjuk, akkor a MovieClipLoader.onLoadError esemény is létrejön.

Paraméterek
target: A MovieClip elérési útvonala vagy a mozi egy szintje, ahová a loadClip()-pel töltöttünk.
Van egy Boolean tipusú visszatérési értéke, mely true ha sikeresen kiürült a mozi, ellenkező esetben false.



getProgress
my_mcl.getProgress( target_mc:Object )

Annak a fájlnak betöltődött és a teljes, betöltendő bájtjainak számával tér vissza, melyet a MovieClipLoader.loadClip() metódus használatával töltünk be, tömörített fájloknál a tömörített bájtok számát adja vissza. A metódus ezen információk lekérésére szolgál, annélkül, hogy egy MovieClipLoader.onLoadProgress eseményt kellene alkalmazni.

Paraméterek
target_mc: Egy SWF, JPEG, GIF vagy PNG fájl, ami a MovieClipLoader.loadClip() használatával töltődött.
Két egész szám értékkel tér vissza, a fentebb említett bájtok számai: a bytesLoaded és a bytesTotal tulajdonságok.

Használata:
var mclProgress:Object = image_mcl.getProgress(target_mc);
trace("Betöltött bájtok: "+mclProgress.bytesLoaded+" Teljes bájtmennyiség: "+mclProgress.bytesTotal);



Eseménykezelők


onLoadStart
listenerObject.onLoadStart = function([ target_mc:Object ]) {
   // ide jönnek a kódok
}

Ha egy MovieClipLoader.loadClip() sikeresen elkezdte a fájl letöltésést, akkor hívódik meg ez az esemény. A target_mc azonosítja azt a MovieClip-et, amelyikre meg lett hívva, ez akkor hasznos, ha több fájlt töltünk be ugyanazokkal az eseménykezelőkkel.

Paraméterek
listenerObject: a figyelőobjektum, amelyik a MovieClipLoader.addListener()-rel lett hozzáadva .
target_mc: a MovieClip amelyikbe a MovieClipLoader.loadClip() metódussal töltünk. Ez a paraméter opcionális.



onLoadComplete
listenerObject.onLoadComplete = function([ target_mc:Object], [httpStatus:Number]) {
   // ide jönnek a kódok
}

Ha egy MovieClipLoader.loadClip()-rel meghívott fájl teljesen betöltődik, akkor fut le ez az esemény. A target_mc azonosítja azt a MovieClip-et, amelyikre meg lett hívva, ez akkor hasznos, ha több fájlt töltünk be ugyanazokkal az eseménykezelőkkel.
Fontos dolog megérteni az MovieClipLoader.onLoadComplete és MovieClipLoader.onLoadInit közötti különbséget. Az onLoadComplete esemény, akkor jön létre, ha az SWF, JPEG, GIF vagy PNG fájl betöltődött, de még azelőtt, hogy inicializálódott volna. Ezért ezen a ponton még nem elérhetőek a betöltött mozi metódusai és tulajdonságai, nem hívhatóak függvények, nem küldhető el a lejátszófej egy kiválaszott frame-re, stb. Ha ilyesmit szeretnénk, akkor ehelyett használjuk inkább az onLoadInit eseményt, mely akkor fut le, ha a tartalom teljesen betöltődött és inicializálódott.
Flash Player 8-tól kezdve a figyelő egy HTTP státuszkóddal is visszatud térni. Ha a Flash Player nem tudja elérni a státuszkódot a szerverről, vagy nem tud kommunikálni a szerverrel, akkor az alap 0 értéket adja át az AS kódnak. Mindig 0 érték generálódik ha a Flash Player plug-in a következő böngészőkben fut, melyek nem tudnak HTTP státuszkódot átadni a szervertől a Flash Player-nek: Netscape, Mozilla, Safari, Opera, és Internet Explorer for the Macintosh.

Paraméterek
listenerObject: a figyelő objektum, amelyik a MovieClipLoader.addListener()-rel lett hozzáadva .
target_mc: a MovieClip amelyikbe a MovieClipLoader.loadClip() metódussal töltünk. Ez a paraméter opcionális.
httpStatus: Number [opcionális] - (csak Flash Player 8-tól) A HTTP státuszkód amivel visszatér a szerver. Például 404-es kód jelenik meg, ha a szerver nem talál semmit, ami megfelelne a kért URI-nak. További információk fellelhetőek a HTTP státuszkódokról, a HTTP specifikációk 10.4-es és a 10.5-ös fejezeteiben: ftp://ftp.isi.edu/in-notes/rfc2616.txt



onLoadInit
listenerObject.onLoadInit = function([ target_mc:MovieClip ]) {
   // ide jönnek a kódok
}

Ha a betöltött klipben, az első frame-en lévő cselekmények lefutottak, akkor ez az esemény meghívódik. Miután ez az esemény lefutott, lehet a betöltött mozihoz tulajdonságokat hozzárendelni, metódusokat meghívni és egyéb interakciókat végrehajtani.
A target_mc azonosítja azt a MovieClip-et, amelyikre meg lett hívva, ez akkor hasznos, ha több fájlt töltünk be ugyanazokkal az eseménykezelőkkel.

Paraméterek
listenerObject: a figyelőobjektum, amelyik a MovieClipLoader.addListener()-rel lett hozzáadva .
target_mc: a MovieClip amelyikbe a MovieClipLoader.loadClip() metódussal töltünk. Ez a paraméter opcionális.



onLoadError
listenerObject.onLoadError = function( target_mc:Object , errorCode:String, [httpStatus:Number] ) {
   // ide jönnek a kódok
}

Ha egy MovieClipLoader.loadClip()-pel nem tudunk betölteni, akkor ez az esemény jön létre, ennek számos oka lehet, a szerver leállt, a fájl nem található, stb.
A target_mc azonosítja azt a MovieClip-et, amelyikre meg lett hívva, ez akkor hasznos, ha több fájlt töltünk be ugyanazokkal az eseménykezelőkkel.
Ha az errorCode az "URLNotFound" sztringgel tér vissza, akkor sem a MovieClipLoader.onLoadStart sem a MovieClipLoader.onLoadComplete esemény nem hívódott meg, ennek az oka lehet például, hogy a szerver leállt, vagy a fájl nem található.
Ha pedig a "LoadNeverCompleted" sztringgel, akkor a MovieClipLoader.onLoadStart ugyan lefutott, de a MovieClipLoader.onLoadComplete nem, oka lehet például, hogy letöltés megszakadt, mert a szerver túlterhelődött vagy összeomlott közben, stb.
Flash Player 8-tól kezdve a figyelő egy HTTP státuszkóddal is visszatud térni, ezzel kapcsolatban lásd a fentebb leírtakat az onLoadComplete-nél.

Paraméterek
listenerObject: a figyelőobjektum, amelyik a MovieClipLoader.addListener()-rel lett hozzáadva .
target_mc: a MovieClip amelyikbe a MovieClipLoader.loadClip() metódussal töltünk. Ez a paraméter opcionális.
errorCode: Egy sztring, amelyből megállapítható a hiba oka, ennek két értéke lehet:"URLNotFound" vagy "LoadNeverCompleted".
httpStatus: Number [opcionális] - (csak Flash Player 8-tól), a többit lásd fentebb az onLoadComplete-nél leírtakban.



onLoadProgress
listenerObject.onLoadProgress=function([target_mc:Object[,loadedBytes:Number[,totalBytes:Number]]]) {
   // ide jönnek a kódok
}

Az esemény folyamatosan lefut, amikor a betöltődő tartalom íródik a háttértárra (időben a MovieClipLoader.onLoadStart és a MovieClipLoader.onLoadComplete között helyezkedik el). Arra használható ez a esemény, hogy a letöltés állapotáról jeleníthessünk meg információkat, a loadedBytes és a totalBytes paraméterek használatával. A target_mc azonosítja azt a MovieClip-et, amelyikre meg lett hívva, ez akkor hasznos, ha több fájlt töltünk be ugyanazokkal az eseménykezelőkkel.
Megjegyzés: fontos tudni, hogy a Flash fejlesztői környezetben ez az esemény nem szimulálható, így csak online jeleníti meg a betöltöttségi állapot eredményeit.

Paraméterek
listenerObject: a figyelőobjektum, amelyik a MovieClipLoader.addListener()-rel lett hozzáadva .
target_mc: a MovieClip amelyikbe a MovieClipLoader.loadClip() metódussal töltünk. Ez a paraméter opcionális.
loadedBytes: A betöltődött bájtok száma, amikor az esemény lefutott.
totalBytes: A teljes fájlméret bájtban, aminek be kell töltődnie.



Linkek

A Flash 7 dokumentációja a MovieClipLoader Osztály-ról:
A Flash 8 dokumentációja a MovieClipLoader Osztály-ról:
A HTTP státuszkódokhoz a link (10.4-es és a 10.5-ös fejezetek): ftp://ftp.isi.edu/in-notes/rfc2616.txt

Forrás - Source (135K)

2006.02.04.
version: MX 2004

#24.
Popupablak hozzáigazítása egy képhez, vagy egy swf fájlhoz.
Adjust a popup window to a picture or an swf file

A 16-os bejegyzésben már volt szó erről, így ez annak a felújított változata, ez a verzió PHP használatával már swf fájlhoz is hozzátudja igazítani a popup ablakot:

Ez a segédlet arról fog szólni, hogyan lehet az új ablakban megnyitott képekhez (jpeg, gif vagy png)/swf fájlokhoz hozzáigazítani a böngészőablakot, ehhez Javascript, az swf-hez való igazításhoz pedig PHP szükségeltetik, ezért nem árt majd egy kis alapszintű JavaScript és PHP tudás a segédlethez. Ez a megoldás képgalériáknál, a nagyobb képek megjelenítéséhez jöhet jól.
Előfordulhat, hogy a böngészőkompabilitás nem az igazi, de Firefox és Internet Explorer alatt működik :)
Alább kipróbálható mind a két változat, jpeg és swf megnyitása is:

Forrás - Source (42K)

2005.11.04.

#23.
LoadVars Osztály
(Flash MX)

A LoadVars osztály egy nagyon egyszerű eszköz a kezünkben arra, hogy adatokat (változók tartalmát) cseréljünk a Flash alkalmazásunk és a szerver között. Tekinthetjük a megszokott loadVariables() függvény alkalmazását kiváltó alternatív megoldásnak is, de amellett, hogy mindazt, amit a loadVariables tud elvégeztethetjük vele, szebb, színesebb, szagosabb és könnyebben kezelhetőbb, ráadásul közelebb is áll az OO programozási szemléletéhez..

Az egyik lényeges különbség a LoadVars objektum és a loadVariables függvény között, hogy míg az előbbi csak a saját mezőjeként őrzött és általunk meghatározott változókat küldi el, addig az utóbbi kivédhetetlenül küldi az összes változóját annak a Movie Clip-nek, ahonnan meghívtuk.
A szerverrel való kommunikáció során az adatokat url-encoded formában és név-érték párokba rendezetten küldi és fogadja, ugyanúgy, mintha a loadVariables-t használnánk. Pl.: age=26&name=Gary
Szintén alkalmas a változók küldésén-fogadásán túl a nagyobb méretű külső szövegek betöltésére is, amely szöveg lehet egy statikusan tárolt szövegfájl tartalma, de lehet egy dinamikusan (PHP-n, adatbázison keresztül, stb.) előállított szöveges tartalom is. Azt hiszem annak előnyét pedig nem kell külön ecsetelnem, ha a fla-ba nyúlás, átírás, publish-olás, majd az swf fájl szerverre másolása helyett csak egy szövegfájlt kell átírnunk és a szerverre felmásolunk. Nem mellékesen a szöveges tartalomhoz lehet admin felületet is készíteni, így annak, aki módosítja a tartalmat nem kell értenie a Flash-hez.

Fontos még megemlíteni, hogy a LoadVars csak Flash 6-os player-től kezdve használható.
A forrásfájlok Flash MX 2004-gyel készültek.



Első lépés: a deklarálás

A következő egysoros példával már létre is hoztuk a LoadVars osztály my_lv nevezetü példányát:

var my_lv:LoadVars = new LoadVars();




Eseménykezelők

LoadVars.onLoad
A LoadVars osztályú példány leginkább használt eseménykezelője, amely akkor hívódik meg, amikor egy LoadVars.load() vagy egy LoadVars.sendAndLoad() művelet végrehajtódott. Nagyon hasznos, hogy paramétereként kapunk egy Boolean tipusú változót, melyet hibaellenörzésre tudunk használni. Ha az adatátvitel sikeres volt true, ha bármi probléma lépett fel false értékkel tér vissza.
Ha a művelet sikeresen végrehajtódott, akkor a LoadVars-példányban létrejönnek a letöltött változók és az eseménykezelő lefutásakor a példány egy-egy mezőjeként elérhetővé is válnak. (pl. my_lv.szoveg)
Ez az eseménykezelő nincs definiálva alapból, így nekünk kell hozzárendelnünk a LoadVars-unkhoz, ez történhet így például:

var my_lv:LoadVars = new LoadVars();

my_lv.onLoad = function(success:Boolean) {
   if (success) {
      trace("Sikeres adatfogadás.");
   } else {
      trace("Hiba!");
   }
}


LoadVars.onData
Nagyon hasonlít az onLoad-ra. Szintén egy LoadVars.load() vagy egy LoadVars.sendAndLoad() metódushívás után hívódik meg akkor, amikor befejeződött az adatok letöltődése a szerverről, vagy ha bármiféle hiba adódott a letöltés során. Az eseményezelő még azelött hívódik, hogy az adatok elemezve (feldolgozva, parse-olva) lennének, azaz megjelennének mint a LoadVars példány változói. Ezért az onData kifejezetten szöveg fogadásra alkalmas eseménykezelő, két okból is. Egyrészt paraméterként itt a teljes nyers szöveget kapjuk meg, amivel azt kezdünk amit akarunk, másrészt az adathalmaz feldolgozatlansága miatt nincs jelentősége az url-encoded szabvány szerinti szövegírásnak. Megkerülhető tehát a % a + vagy az & jelek url-encoded formára hozása (& jel helyett %26, + jel helyett %2B-t, stb.), mivel ezek a karakterek csak az adatfeldolgozás során bírnak különleges jelentőséggel és nem is jelennek meg a szövegekben (az & jel például a változókat választja el egymástól, mint ahogyan ezt a bevezetőben említettem is (age=26&name=Gary)). Ha ezt az eseménykezelőt használjuk, akkor ezzel nem kell foglalkoznunk. Hibaellenőrzésre itt is használhatjuk az eseménykezelő paraméterét, amely értéke hiba esetén undefined lesz.
Alapból definiált változatában a LoadVars.onData meghívja a LoadVars.onLoad eseménykezelőt. Ha saját függvényt rendelünk az eseményhez - ahogy az elöbb is tettük - akkor a LoadVars.onLoad természetesen nem hívódik meg, hacsak mi meg nem hívjuk az új függvényünkből. Ezt csak akkor tegyük meg, ha valamiért az onData után szükségünk lenne még az onLoad-ra is.
Példa:

var my_lv:LoadVars = new LoadVars();

my_lv.onData = function(src:String) {
   if (src == undefined) {
      trace("Hiba!");
   } else {
      trace("Megérkezett a nyers szöveg.");
   }
}




Főbb metódusok

load
Ezzel a metódussal tudunk letölteni változókat egy meghatározott URL-ről. A változók automatikusan jönnek létre a feldolgozás során. Ha a LoadVars példányunknak volt már elötte ilyen nevű mezője, akkor annak a tartalma felülíródik az új adattal. A betöltött változóktól eltérő nevü változóink természetesen megmaradnak.

A metódus szintaktikája:
my_lv.load(url:String)

Az egyetlen paraméter az URL, ahonnan az adatokat várjuk.

A következő két példában már működőképes dolgokat fogunk összehozni; először egy külső szövegfájlból töltünk változókat - ezt az onLoad eseménykezelővel oldjuk meg - másodjára egy hosszabb szövegrészt töltünk be a szövegfájlból, aminek töltődését az onData eseménykezelővel kísérjük figyelemmel, a fentebb már említett nehézségek elkerülése végett. Az egyszerűség kedvéért mindkét esetben egy-egy kódból létrehozott szövegmezőbe fogjuk kiiratni az eredményt:

1. példa - load és onLoad használata:



Mivel az egyetlen gombon kívül minden script-ből lett létrehozva, nem írnám le az elkészítését és screenshot-ot sem csinálok róla - a forrás meg úgyis mellékelve van :)
Azt persze nem szabad elfelejteni, hogy a gombnak instance name-t kell adni - my_btn.
A szövegfájlnak pedig ez az egy sor a tartalma, ami alapján két változó jelenik meg a LoadVars-ban - age és name:
age=26&name=Gary
Ezek értékeit íratjuk ki az ablakba.

Az actionscript:

// A szövegmező létrehozása
this.createTextField("my_txt", 0, 12, 12, 140, 80);
my_txt.border = true;
my_txt.multiline = true;
my_txt.background = true;
my_txt.backgroundColor = 0xFCFCFC;
// ----------------------------------
// LoadVars létrehozása
var my_lv:LoadVars = new LoadVars();
// onLoad eseménykezelő
my_lv.onLoad = function(success:Boolean) {
   if (success) {   // Ha sikeres volt a betöltés
      my_txt.text = "Sikeres adatfogadás.\n\nAge: "+this.age+"\nName: "+this.name;
   } else {          // Ha nem volt sikeres a betöltés
      my_txt.text = "Hiba!";
}
}
// Gombra kattintáskor indul el a betöltés
my_btn.onRelease = function () {
   // A szövegfájlból a változók betöltése
      my_lv.load("images/loadvars_load-onload.txt");
}



2. példa - load és onData használata:



Ez a példa nagyban hasonlít az előzőre, azzal a különbséggel, hogy egy most HTML formázott szöveget töltünk be.
A formázáshoz hasznos segítség lehet a Flash által támogatott HTML tag-ek listája.

Az actionscript:

// A szövegmező létrehozása
this.createTextField("my_txt", 0, 4, 36, 400, 280);
my_txt.border = true;
my_txt.multiline = true;
my_txt.background = true;
my_txt.backgroundColor = 0xFCFCFC;
my_txt.html = true; // Tudjon fogadni HTML formázott szövegeket
my_txt.condenseWhite = true; // A fölösleges szüneteket törli ki a szövegből (space, sortörés, stb)
my_txt.wordWrap = true;
// ----------------------------------
// LoadVars osztálypéldány létrehozása
var my_lv:LoadVars = new LoadVars();
// onData eseménykezelő
my_lv.onData = function(src:String) {
   if (src == undefined) {   // Ha nem volt sikeres a betöltés
      my_txt.htmlText = "Hiba!";
   } else {                  // Ha sikeres volt a betöltés
      my_txt.htmlText = src;
   }
}
// Gombra kattintáskor indul el a betöltés
my_btn.onRelease = function () {
   // A szövegfájlból a HTML formázott szöveg betöltése
   my_lv.load("images/loadvars_load-ondata.html");
}




send
Ezt a metódust a LoadVars-ban létező változók egy meghatározott URL-re való elküldésére használhatjuk. Az összes létező változót egy sztringgé fűzve küldi el, az application/x-www-form-urlencoded formának megfelelően. A küldéshez POST metódust használja ha a paraméter megadását elmulasztjuk, vagy nem határozzuk meg, hogy GET legyen.
A POST és a GET metódus közötti alapvető különbség a webszervernek küldött adatok utaztatási helye. A GET metódusnál a függvény magához az URL-hez fűzi az adatokat, a POST metódusnál a HTTP kérés törzsébe ágyazza.
A küldött változók automatikusan megjelennek a PHP-n belül, ezeket a $_POST['változónév'] vagy a $_GET['változónév'] asszociatív tömbökön keresztül lehet elérni, részletesebben lásd itt.
Régebbi verziójú PHP-knál (4.1.0. elöttieknél) pedig a $HTTP_POST_VARS['változónév'] vagy a $HTTP_GET_VARS['változónév'] módon érhetjük el adatainkat.

A send metódus szintaktikailag így néz ki:
my_lv.send(url:String,target:String [, method:String])

Mint látható 3 paramétere van, melyek közül az adatküldés tipusa - a harmadik paraméter - opcionális, tehát elhagyható, mint azt már fentebb említetettem.
Az első paraméter a megcímzett URL, ahova az adatainkat szánjuk. A szerveroldalon bármilyen CGI program lehet (PHP, ASP, Perl, de akár C-ben, Delphi-ben is lehet ilyet írni), az egyszerűség kedvéért most PHP-t fogunk használni.
A második paraméterként azt az ablakot, vagy frame-et kell megadni, melyben a szervertől jött választ dolgozzuk fel. A send metódus mindenképp új ablakot nyit. Ha ezt el szeretnénk kerülni, akkor majd a következőben tárgyalt sendAndLoad metódust kell használnunk.
A második paraméter lehet:
_self - az aktuálisban, azaz magában nyitja meg.
_blank - új ablakban nyitja meg.
_parent - az aktuális szülőjében nyitja meg.
_top - a legfelső szinten lévőben nyitja meg.
vagy egy frame-ben, ekkor a frame nevét kell ideírni

Lássunk rá egy példát:




A fla ismét rendkivül egyszerü. Mindössze egy statikus szövegmező, egy beviteli szövegmező - ahova az elküldendő adatot írjuk - és a küldésre szolgáló gomb a tartalma, mindezek külön layer-en. Így néz ki belülről:




és az elmaradhatatlan actionscript:
input_txt.restrict = "0-9"; // Csak számjegyeket fogadjon el
// LoadVars objektum létrehozása
var my_lv:LoadVars = new LoadVars();
// Gombra kattintáskor indul el a küldés
my_btn.onRelease = function () {
   my_lv.szam = parseInt(input_txt.text, 10); // Egész számmá konvertálás
   my_lv.send("images/loadvars_send.php", "_blank", "POST"); // Az adatok elküldése a PHP-nak
}

Persze ehhez jár egy kis PHP kód is:
$szam = $_POST['szam'];  // az átküldött szám fogadása
$dupla = 2*$szam;            //szorozva kettővel :)
// Majd a böngészőben megjelenítjük az adatokat
echo "<b>A fogadott szám:</b> $szam<br><b>A szám kétszerese:</b> $dupla";




sendAndLoad
Végül elérkeztünk a szerintem leghasznosabb metódushoz.
A sendAndLoad metódus gyakorlatilag a load és send metódusok egyesítése. A LoadVars-ban levő változókat send metódusban tárgyalt módon küldi el, majd a válaszként érkező adatokat változók tartalmaként dolgozza fel, ahogy azt a load-nál már megismertük.

Szintaktikája:
my_lv.sendAndLoad(url:String, targetObject[, method:String])

Szintén három paraméterrel rendelkezik, az első paraméter itt is a megcímzett URL, a második paraméter az a LoadVars objektum, mely fogadja a letöltött adatokat (nem kötelező, hogy ugyanaz a LoadVars objektum fogadja is az adatokat, amelyik küldi, de általában célszerű), a harmadik paraméter pedig szintén az adatküldés tipusa (POST, GET), ez a send-nél már megismert módon elhagyható.

Flash 7 player-től kezdve a load és sendAndLoad metódusok URL-jeinek biztonsági megszorításként ugyanarra a domain-re kell mutatniuk ahol az SWF fájl is található. Ez a szigorítás a cross-domain policy file használatával kerülhető meg. Erről bővebben a következő két linken: Flash Player security features és About allowing cross-domain data loading.

Példa:







Actionscript:
num1_txt.restrict = num2_txt.restrict = "0-9"; // Csak számjegyeket fogadjon el
op_txt.restrict = "+\\-*/"; // Csak a műveleti jeleket fogadja el (+, -, *, /)
var my_lv:LoadVars = new LoadVars();
my_lv.onLoad = function(success:Boolean) {
// Ha sikeres volt a betöltés és a PHP is fel tudta dolgozni az adatokat
if (success && this.error == "no") {
receiver_txt.text = "Sikeres adatfogadás.\n "+this.reply;
} else { // Ha nem volt sikeres a betöltés
receiver_txt.text = "Hiba!\n "+this.errorCode;
}
}
my_btn.onRelease = function () {
my_lv.num1 = parseInt(num1_txt.text, 10); // Egész számmá konvertálások
my_lv.num2 = parseInt(num2_txt.text, 10);
my_lv.op = op_txt.text;
// Az adatok küldésének és fogadásának megkezdése
my_lv.sendAndLoad("images/loadvars_sendandload.php", my_lv, "POST");
}

PHP kód:
// a két szám fogadása és a műveleti jel fogadása
$num1 = $_POST['num1'];
$num2 = $_POST['num2'];
$op = $_POST['op'];
// ---------------------------------------------------------- //
// Hibaellenőrzés és a kiválasztott művelet elvégzése, ha rendben megjöttek az adatok
if ($num1 != "NaN" && $num2 != "NaN" && $op != "") {
$error = "no";
switch ($op) { // A kiválasztott művelet elvégzése
case "+" : $newNum = $num1+$num2; $op="összeadás"; break;
case "-" : $newNum = $num1-$num2; $op="kivonás"; break;
case "*" : $newNum = $num1*$num2; $op="szorzás"; break;
case "/" : $newNum = $num1/$num2; $op="osztás"; break;
}
$reply = "Az új érték a két számon elvégzet $op művelet után: $newNum.";
} else {
$error = "yes";
$errorCode = "Vagy nincs megadva mindkét szám, vagy nincs műveleti jel!";
}
// url-encoded formában küldjük vissza az adatokat, úgymint 1/ van-e hiba, 2/ a hiba kódja, 3/ és a válasz
// a sztring utf-8-ban van kódolva arra az esetre, ha ékezetes karaktereket küldenénk
// persze az utf8_encode() helyett célszerűbb az iconv() függvényt használni, ha lehetőségünk van rá.
echo utf8_encode("&error=$error&errorCode=$errorCode&reply=$reply");



Egyéb metódusok

Nagyobb mennyiségű szöveges adat töltésekor figyelhetjük menet közben a letöltöttség állapotát - akár előtöltőt is készíthetünk, mint ahogy a jpeg és swf fájlokhoz esetében ez megszokott. Ebben a következő két metódus lehet a segítségünkre.

getBytesLoaded
A metódus a letöltött bájtok számával tér vissza. Ha épp nincs folyamatban betöltés, vagy a töltés még nem kezdődött el, akkor undefined értékkel tér vissza.

getBytesTotal
A letöltendő bájtok számát kapjuk meg visszatérési értékként. Szintén undefined-dal tér vissza, ha nincs betöltés folyamatban, vagy a töltés még nem kezdődött el, illetve akkor is, ha ugyan elkezdődött a letöltés, de a szerver még nem küldte át a fájlméretre vonatkozó információkat.

decode
Paraméterként egy url-encoded sztringet vár, amely név-érték párokat tartalmaz. Ez a metódus alapból lefut az onData eseménykezelőben, ezért általában nincs is szükség a használatára, de ha felülírjuk az onData eseménykezelőt, akkor egyértelműen meg kell hívnunk, hogy feldolgozza a változókat tartalmazó sztringet.

var my_lv:LoadVars = new LoadVars();
//Convert the variable string to properties
my_lv.decode("age=26&name=Gary");
// Végig lépegetünk a változókon a LoadVars-ban
for (var prop in my_lv) {
trace(prop+": "+my_lv[prop]);
}

A trace() eredménye:
name: Gary
age: 26

toString
Ez a metódus egy url-encoded formájú sztringgel tér vissza, amit a LoadVars objektumban található változókból készít el. Gyakorlatilag a decode metódus ellentéte

var my_lv:LoadVars = new LoadVars();
my_lv.name = "Gary";
my_lv.age = 26;
trace (my_lv.toString());

A trace() eredménye:
age=26&name=Gary



Kevésbé "értékes" metódusok

addRequestHeader
Hozzáad vagy megváltoztatja a HTTP kérés fejléceit. Akit bővebben érdekel a dolog az itt talál leírást.

contentType
Ezzel a MIME type-ot határozhatjuk meg, ami alapból application/x-www-form-urlencoded formára van beállítva, a MIME type-ról bővebben.

loaded
Egy Boolean tipusú értékkel tér vissza. Ha egy LoadVars.load() vagy egy LoadVars.sendAndLoad() kérés elindul az értéke false-ra vált, amikor a művelet sikeresen befejeződött, az értéke true lesz. Ha a letöltéskérés sikertelenül, hibával ér véget, értéke false marad. Alapból undefined értékkel rendelkezik.




Linkek

A sokat emlegetett url-encoded forma és az UTF-8 ami elengedhetetlen az ékezetes karakterek átviteléhez.

Ha valaki még többet szeretne megtudni a LoadVars-ról, az a Macromedia LiveDocs-on találhat további információkat.


Ez a segédlet nem jöhetett volna létre Jucka segítsége nélkül, köszönet érte neki.

Forrás - Source (22K)

2005.11.03.
version: MX 2004

#22.
Egy fájl letöltésének kikényszerítése
Force to download a file
(Flash MX)

Előfordulhat, hogyha egy link pdf-re, Word dokumentumra, videófájlra (mov, avi, stb.) vagy hangfájlra (mp3, wav) mutat, akkor a böngésző a - beállításainak megfelelően - önmagában nyitja meg a fájlt, vagy megpróbálja lejátszani. De ehelyett mi azt szeretnénk, ha letöltené a fájlt és rögtön megjelenjen a mentés sajátgépre lehetőség. A következő példa ezt mutatja be.

Sometimes, when a link point to pdf, Word document, video file (mov, avi, etc.) or sound file (mp3, wav), then the browser - as in the settings has defined - try to open itself or try to play the file. But we want to download this file and see right now an availability to save to My Computer. So next example will show this.

Forrás - Source (42K)

2005.08.12.
version: MX

#21.
URL-ből változók átadása az swf-nek
How to passing URL-variables to swf
(Flash MX)

Az URL-ből való változó(k) átadására egyrészt használhatjuk a FlashVars-t (bővebben itt: Macromedia - Flash TechNote) amit az OBJECT és az EMBED tag-ekben kell elhelyezni, hogy működjön minden böngésző alatt (a szöveg maximum 64KB lehet). Flash 6, vagy későbbi lejátszókkal használható. Vagy egyszerűen az swf URL-je után adjuk meg a változó(ka)t (bővebben itt: Macromedia - Macromedia - Flash Player TechNote). A változók mindkét esetben automatikusan a _root-on jönnek létre.

Passing variable(s) from URL, first we can use the FlashVars property (more: Macromedia - Flash TechNote) it must be assigned in both the OBJECT and EMBED tags in order to work on all browsers (the max string sizes is 64KB). This feature requires Flash Player 6 (or later). Or simply appending the query string to URL of the swf (more: Macromedia - Macromedia - Flash Player TechNote). The variable(s) automatically creating on the _root.

Forrás - Source (24K)

2005.07.17.
version: MX