Creare titoli di coda in Premiere Pro CS3

Una delle caratteristiche più innovative in Premiere Pro è sicuramente la possibilità di poter lavorare agevolmente con la titolatrice per creare appunto testi, titoli di coda, huston, ecc...
Tra questi appunto ci sono i cosidetti "titoli di coda", come capita di vederne al termine di un film.
(Partiamo dal concetto che abbiate un progetto aperto in Premiere)

Per prima cosa dal pannello "Project" faccio click con il tasto destro e scegliamo "New Item", quindi "Title".
Dal pannello "Titolatrice" che ne uscirà successivamente, creiamo il nostro testo come serve.
Al termine, quando tutto il nostro testo è stato scritto, clicchiamo sul menu principale: "Title" e scegliamo la voce: "Roll/Crowl Option".
Quindi dal pannello successivo, selezioniamo la prima opzione "Roll" (per effetto tipo "titoli di coda"), quindi depenniamo i due checkbox successivi "Start Off Screen" ed "End Off Screen", che indicheranno appunto al testo di iniziare e finire l'animazione fuori dallo schermo. Per maggiore chiarezza inseriamo l'immagine delle opzioni da scegliere:
Confermiamo con ok e chiudiamo la titolatrice.
Il file del titolo verrà inserito nel pannello Project. Quindi montiamo il file sulla nostra timeline e ... buona visione!

Guida ad Actionscript 3.0Capitolo 5_2: Cicli in ActionScript 3.0

INDICE: Guida ad ActionScript 3.0

In questo capitolo vedremo alcuni tipi, con relativi esempi, di cicli in ActionScript 3.0. I cicli permettono, non solo in ActionScript, ma in tutti i linguaggi di programmazione (PHP, JavaScript, ...), di "scrivere" una volta sola un'istruzione che deve essere ripetuta "x" volte, sia sempre la stessa, sia diversa (ovviamente in quest'ultimo caso abbiamo altre cose in più da considerare).

I Cicli sono diversi, poichè diverse possono essere i criteri secondo i quali le istruzioni vanno ripetute.
I principali, e più usati, sono: for, for each, while.

Ciclo FOR:
Utilizzato soprattutto quando dobbiamo indicare un numero esatto (anche se non effettivamente conosciuto) di volte in cui un'istruzione va ripetuta.

Esempio:

var studenti:Array=new Array();
studenti=["fabio", "mario", "francesca", "dorotea"];

for(var i:Number=0; i<studenti.length; i++)
{
trace(studenti[i]);
}

Con questo semplice codice, già visto anche negli esercizi precedenti, sto chiedendo ad ActionScript di tracciare tutti i nomi presenti nell'Array studenti. L'istruzione tuttavia è stata indicata una volta sola.

La variabile incrementale i diventa il punto cardine in questo ciclo. Il ciclo for prevede 3 espressioni, utilizzando proprio "i". La prima espressione istanzia la variabile i impostandone il valore iniziale. La seconda imposta "fino a quando" il ciclo è valido. La terza indica come incrementa la variabile all'interno del ciclo (cioè di 1 unità, poichè i++ è equivalente a i=i+1).

Ciclo FOR...EACH:
Questo ciclo è utilizzato quando si vuole eseguire una iterazione sulle voci di una raccolta (ad esempio dati XML, XMLList, ArrayCollection, ... ).

Esempio:

var myXML:XML = <utenti>
   <nome>Jane</nome>
   <nome>Susan</nome>
<nome>John</nome>

</utenti>

for each (var nodi in myXML.nome)
{
   trace(nodi);
}

Così facendo vengono letti tutti i nodi presenti nella stringa (in formato XML) e ritracciati a video

Ciclo WHILE:
Questo ciclo verifica una condizione (potremmo tradurlo "mentre è vera una determinata condizione") vengono eseguite determinate istruzioni.

Esempio:

var i:Number=0;
while(i<10)
{
trace(i);
i++;
}

Ovviamente all'interno del ciclo abbiamo dovuto incrementare la variabile i, altrimenti il ciclo sarebbe risultato infinito, situazione paradossale nonchè impraticabile.

Guida ad Actionscript 3 ... work in progress!

Parte da oggi un nuovo progetto (nel quale spero di rendere qualche favore a tutti i lettori del blog) che vede la realizzazione di una guida di Actionscript 3.0. Ovviamente con questo progetto non voglio assolutamente sopperire ai molteplici aiuti che noi tutti possiamo trovare altrove nella rete, quanto un compendio o più semplicemente un riassunto degli aspetti fondamentali che potrebbero interessare soprattutto chi è interessato a studiare Actionscript 3.0

Essendo un progetto totalmente free (soprattutto per il materiale didattico che lo accompagnerà), sono aperto a qualsiasi consiglio, critica, suggerimento o anche allargamento di contenuti che vogliate indicarmi.
Il progetto sarà raggiungible attraverso il link che troverete qui a fianco sotto "Guide & Resources".

Nella speranza che questo possa interessarvi... buona lettura.

Creare uno slide-show in Fireworks CS3

Creare uno slideshow di immagini è molto utile durante la progettazione di lavori Web o Multimediali.
La recente versione di Fireworks CS3 permette oltretutto di crearne comodamente uno indicando pochi parametri e la cartella delle foto o singole foto. Vediamo come.

Apriamo Fireworks CS3 e dal menu "Comandi", andiamo su "Create Slideshow".
Sulla successiva finestra, clicchiamo sul "+" in alto a sinistra (come da foto).

Quindi scegliamo nel pannello successivo nella voce "File da elaborare", "Personalizza..".
Selezioniamo le foto e clicchiamo su "Completato".
Quindi, tornati sul pannello precedente, clicchiamo su "ok".
Ecco che il pannello si è aggiornato secondo le indicazioni date (vedi foto sotto):

Nel pannello laterale all'elenco diamo tutte le informazioni possibile su "Nome" dell'album, eventuali didascalie da leggere per le foto. In "Proprietà Album Book" scegliamo la nostra template preferita.
Nell'ultimo pannello dell'elenco opzioni (purtroppo non posso indicarlo meglio perchè nella versione italiana il pannello non stato tradotto correttamente) indichiamo dove vogliamo salvare il nostro lavoro.

Completiamo cliccando su "Create". Attendete qualche secondo per la creazione del prodotto.
Andate quindi nella cartella dove avete destinato la realizzazione del lavoro e buona visione!

Ecco qui sotto un'esempio:

Adobe AIR anche per Flash CS3 in italiano!

Con l'ultima release di Adobe AIR 1 (beta 3), è stato reso disponibile l'estensione per Flash CS3 per poter sviluppare, attraverso Flash in AIR.
Peccato che per questa estensione dobbiamo avere Flash in : inglese o francese o tedesco o giapponese!!

Pazienza. Diremmo noi. Aspetteremo la versione definitiva per quella italiana (a meno che non decidiamo di usare la versione inglese e faremmo bene!).
Invece siccome sono caparbio e voglio usare la versione in italiano, la Adobe per fortuna ha reso disponibile uno zippato per l'installazione manuale per PC o MAC per tutti coloro che abbiano lingue diverse (forse gli spagnoli oltre agli italiani?).
Il link è il seguente:
http://download.macromedia.com/pub/labs/flashcs3/flashcs3_air_extension_manualinstall_p3_win_121407.zip
Disponibile comunque sempre dal sito classico labs.adobe.com


Ora dentro la cartella zippata c'è un file TXT dove spiega cosa fare per filo e per segno. Seguite con attenzione le indicazioni (che nella maggioranza dei casi significa copiare e incollare file dentro la cartella di Flash).
Al termine potrete lavorare tranquillamente in Adobe AIR con Flash CS3 in italiano.
L'unica differenza rispetto agli altri (stiamo sempre indietro noi italiani) è che bisogna impostare il linguaggio e le classi di Actionscript 3 per Adobe AIR nel pannello di Impostazioni Esportazione di Flash, come da foto. E da ora in poi... buon lavoro.

XML e Dreamweaver CS3: come creare contenuti dinamici

Grazie all'introduzione dei cosidetti Spry di Dreamweaver CS3, oggi è possibile, sfruttare le potenzialità di Javascript ed XML per creare pagine dal contenuto dinamico senza doversi finalmente più preoccupare di fastidiosi aggiornamenti. Certo, la soluzione migliore sarebbe conoscere linguaggi server-side, come PHP, ASP.NET, Coldfusion, ecc... .

Vediamo comunque come intervenire.

Prendiamo un classico caso di aggiornamento quasi obbligatorio: un catalogo di prodotti che in breve potrebbe anche essere la pagina dei "servizi" di un'agenzia.

Per prima cosa in Dreamweaver CS3 inseriamo nella parte esatta della nostra pagina del testo generico che sostituisca momentaneamente quello effettivo. Più o meno come nell'esempio sottostante:
Ora, questa sezione composta da "titolo", "tipo" e descrizione dovrebbe essere ripetuta orientativamente per il numero degli elementi contenuti nel file XML. Andiamolo a vedere:







Ecco un esempio, scaricabile da qui se volete utilizzarlo come esempio.
Come potete vedere il file XML altro non è che una sequenza di dati gestiti da codice di marcatura (tag) come l'HTML. Solo che i nomi dei nodi sono personalizzati.
L'importante è che la struttura (dvd-titolo-anno) rimanga sempre uguale per ciascun lavoro.

Così facendo, i dati saranno salvati sull'XML, la pagina HTML li formatterà da un punto di vista grafico e il codice Javascript che Dreamweaver aggiungerà, gestirà la loro ripetizione all'interno del documento in funzione del numero di nodi "lavoro" contenuti nel documento XML.

Quindi per elaborare le nostre informazioni e posizionarle al posto giusto, dovremo utilizzare il framework Spry di Dreamweaver, raggiungibile cliccando sul menu alla voce "Spry".
Da questa voce, clicchiamo sul primo pulsante a sinistra: "Dataset XML Spry".
Nel pannello successivo impostiamo i seguenti valori in questa maniera:
Nome dataset: rs1
Origine XML: catalogo.xml
Elemento di riga: scegliamo il nodo principale "dvd"(se state usando l'esempio di prima).
XPath: catalogo/dvd
Il resto lasciamo pressapoco invariato. Confrontate con l'immagine sottostante per testare la prova.
L'immagine sottostante sintetizza quanto detto finora:
Confermiamo cliccando su "ok".
Così facendo abbiamo stabilito una connessione tra la nostra pagina e il file XML.
Salviamo il nostro documento e Dreamweaver ci chiederà di salvare dei file Javascript all'interno della nostra applicazione. Confermiamo.
Ora, su Dreamweaver selezioniamo la porzione di pagina che vogliamo venga ripetuta per il numero di nodi "dvd" contenuti nel file XML, cioè la sezione precedenemtente inserita con i testi generici.

Ora non faremo altro che selezionare questa sezione e chiedere a Dreamweaver CS3 di ripetere questa parte (anche se ancora con i testi generici).

Quindi evidenziamo le varie : "titolo", "tipo" e "descrizione dalla pagina".
Clicchiamo sul terzo pulsante degli strumenti "Spry", cioè "Ripetizione Spry". Con ciò confermiamo che l'area selezionata è quella da ripetere. Per concludere la corretta ripetizione, dobbiamo apportare delle leggere modifiche al codice.
Andiamo in vista codice di Dreamweaver e cambiamo la riga corrispondente a quella selezionata e modifichiamo il codice in modo tale da aggiungere all'attributo (in arancione) "spry:repeat" anche il "spry:region="id".
Ora se provassimo a salvare e guardare in anteprima di Internet Explorer 7 o Firefox 2 vedremo che l'area viene ripetuta esattamente quanti sono i nodi "dvd" dell'XML ma sempre col testo "di appoggio".
Concludiamo quindi sostituendo quel testo con quello corretto. Durante il nostro lavoro, Dremweaver dovrebbe aver reso agibile un ulteriore pannello "Applicazioni"-->"Associazioni" (vedi foto):
Ora selezioniamo sulla pagina la parola "titolo", cancelliamola e sostituiamola nel punto esatto (tramite appunto drag&drop) con la voce "titolo" presente nel pannello "Associazioni". Così facendo sostituiamo tutte le voci.
Al termine salviamo e testiamo la nostra pagina in Internet Explorer (7 possibilmente) o Firefox od Opera.
Come vedrete il file inserisce automaticamente tutti i film estratti dal file XML.
Ora per fare modifiche o aggiornamenti, basterà prendere il file XML e aggiungere o togliere quanto serve.

SCARICA L'ESEMPIO COMPLETO

Flex 3 beta 3 ed Adobe AIR beta 3, finalmente disponibili

E' di pochi minuti fa (almeno per me) la notizia che sono finalmente resi pubblici la beta 3 di Adobe AIR e Flex 3. Ovviamente scaricabili gratuitamente da labs.adobe.com. Giusto alcune precauzioni: il Runtime di Adobe AIR sarà utile solo per visualizzare lavori futuri (visto che è appena uscito). Se volete vedere/usare Air beta2 dovete lasciarla installata sul vostro PC. Pare infatti che possano convivere tra loro. Dalle note di release però viene specificato che il runtime "morirà" il 1 novembre 2008 (complimenti a chi ha scelto la data! :) )

Per Flex 3 invece pare non esserci problemi. Nei giorni seguenti vi annoteremo le novità! Buon download!

Esce in versione beta Adobe BRIO

Chi già conosceva "Adobe Connect", riguardo la possibilità di connettere insieme più persone anche attraverso audio e video (molto buono per conferenze online), oggi si ritroverà un nuovo importante prodotto: Adobe BRIO.

Per ora la versione è BETA, tuttavia gratuitamente utilizzabile da tutti coloro che vogliano testare il prodotto.

L'attivazione è raggiungible facilmente dal sito Labs di Adobe.

Nuovi video sull'AIR CAMP di Milano (30 ottobre 07)

Finalmente sono riuscito a realizzare i video dell'evento AIR CAMP, svoltosi a Milano lo scorso 30 ottobre presso gli uffici di Adobe (Adobe System Italia Headquarter). Marco Casario (Comtaste, Adobe|Guru) ha reso pubblico il materiale, oltre che su Augitaly anche su YouTube.
All'evento hanno partecipato come relatori, oltre al sottoscritto, anche Matteo Ronchi (già collaboratore di FLEXGALA, usergroup ufficiale di Adobe Flex), due grandi personalità del panorama dello sviluppo Web: Enrique Duvos (Senior Platform Evangelist Adobe) e Marco Casario appunto.

Qui di seguito trovate il link alla pagina del blog di AUGITALY: http://blog.augitaly.com/2007/12/adobe_air_camp_italy_enrique_d_1.html
Buona visione!

Problemi di compatibilità tra Adobe CS3 e Windows Vista: come risolverli

Lavorare in ambiente Windows Vista sta diventando ormai obbligatorio. Da qualche mese ormai se vogliamo comprare un nuovo PC ci troviamo con Windows Vista sopra. E se lavoriamo con un prodotto Adobe CS3 abbiamo forse pure qualche problema!

Due sono i problemi principali che ormai risultano evidenti:

1. lentezze spropositate
2. problemi di installazioni

Vediamo quindi come risolvere il primo caso. Per entrambe le soluzioni prenderemo ad esempio FLASH CS3, ovviamente varrà per qualunque altro prodotto (compresi Photoshop CS3, Photoshop CS3 Extended, Illustrator CS3, Premiere Pro CS3, Dreamweaver CS3, ecc....)

La questione si incentra completamente sulla nuova visualizzazione Aero di Windows, presente in tutte le versioni eccetto la Home Basic. Per eliminare l'inconveniente basterà cambiare l'impostazione di visualizzazione per Flash, ovverosia bisogna disattivare la configurazione Aero.
Quindi:

• Entro nella cartella di Flash persente sull' HardDisk. Il percorso del file dovrebbe presumibilmente essere uguale per tutti e cioè: C:\Programmi\Macromedia\Flash8\., eccetto casi di installazione su hard disk secondari o partizioni.


• Seleziono il file di avvio di Flash: "flash.exe" senza far partire il programma ovviamente.


• Clicco con il tasto destro del mouse sul file indicato e scelgo dal menu contestuale la voce "Proprietà".


• Dei 4 pannelli che Windows mette a disposizione ("generale", "compatibilità", "protezione", "dettagli") scelgo il secondo: "compatibiltà".
  Quindi seleziono (con il segno di spunta) l'opzione "Disattiva composizioni del desktop".


• Confermo con "Ok" e il gioco è fatto.

Ultima nota. Appena Flash verrà avviato la visualizzazione generale di Windows Vista cambierà disattivando la configurazione Aero, con preventivo avviso di Windows stesso tramite una box che si apre in basso sulla barra delle applicazioni.

Aero ritornerà attivo non appena chiuderete Flash.

Se invece avete problemi di installazione è capace che vi sia apparso il seguente messaggio di errore: "Internal Error 2739. Impossibile continuare l'installazione. Contattare il supporto tecnico Adobe". Il problema riguarda delle librerie Java che Windows ha disabilitate di default.
Dobbiamo riabilitarle!!

Prima di tutto andate nel menu "Start" e dal pannello ricerca scrivete:
cmd, cioè il prompt C: dei comandi.

Quindi avviatelo come "Amministratore", cliccando con il tasto destro del mouse e selezionando la voce dal menu contestuale "Avvia come Amministratore".

Quindi direttmente dal path indicato dal programma digiate questa stringa: regsvr32 jscript.dll.
Un messaggio di registrazione avvenuta con successo, vi permetterà di installare ora senza problemi il vostro programma della Adobe CS3.

Sviluppare in Adobe Air con Flash...ma solo in inglese

Ebbene si. E' possibile creare in Adobe AIR... ma bisogna avere Flash CS3 in inglese.
E' disponibile, in realtà già da diverso tempo un estensione per Flash (scaricabile gratuitamente dal seguente link) per creare in Adobe AIR.

Ovviamente riguardo ad Adobe AIR, RIA (Rich Internet Application) e Web 2.0 vi rimandiamo agli articoli sottostanti.

Adobe AIR

Sicuramente avrete sentito parlare molto di Adobe AIR in quest'ultimo periodo. Così dovrebbe essere altrettanto chiaro cosa sia. ... No??
Allora andiamo a vedere per sommi capi di cosa si tratta.

Adobe AIR, di cui vedete il logo qui a fianco, è l'acronimo di ADOBE INTEGRATED RUNTIME.
Non è un software. Non è un linguaggio. E' ... una tecnologia, se possiamo usare questo termine.
Che vuol dire? Che possiamo usare ad esempio i linguaggi del Web (HTML, CSS, Javascript, XHTML, XML ed Actionscript) per produrre in Adobe AIR.

La differenza in che consiste? Che ora, con i linguaggi del Web possiamo finalmente creare dei veri e propri applicativi. Editor di testo, Lettori audio e video multimediali, il tutto senza browser.
Pioniere di questo progetto è stato primo fra tutti E-BAY, creando la versione "Desktop" del suo sito. Utilizzabile in tutto e per tutto al sito ufficiale.

Oggi Air è ancora in versione beta. Quindi non definitiva. Ma se vogliamo già possiamo cominciare a lavorarci. Vi consiglio quindi una visitina al sito labs.adobe.com dove potrete trovare molte informazioni al riguardo.

Riguardo agli "strumenti" da usare ovviamente i soliti: Dreamweaver CS3 per cominciare. Quindi Flash CS3 oppure il più corredato: Flex 3. Per questi ultimi ovviamente bisognerà installare delle estensioni scaricabili gratuitamente sempre dal sito Labs di Adobe.

Se siete già sviluppatori avanzati anche altri prodotti vanno benissimo: FlashDevelop o Aptana, per esempio.

Rich Internet Application e Web 2.0

Ormai se ne parla da diverso tempo e anche i più riluttanti non possono non considerarlo. Siamo ormai prepotentemente entrati nel nuovo mondo del Web, quello che appunto oggi va sotto la parola di Web 2.0. Una sorta di seconda generazione del Web. E in effetti le cose sono cambiate non poco. Cambiano le richieste degli utenti, quindi le necessità degli sviluppatori si modificano sulle tracce di nuovi percorsi da battere.

I Blog (come questo sito) stanno ormai spopolando per le ampie possibilità che danno a chiunque di crearsi uno spazio quasi gratuitamente.
L'XML sulla scia di questa "moda" è divenuto veicolo d'informazione sempre più diffuso e accettato (anche incosapevolmente).


Ecco quindi affacciarsi all'orizzonte (diciamo anche che solo oggi cominciamo a sentirlo sempre più), AJAX (Javascript e XML asincrono).
In sostanza XML carica i dati e Javascript gestisce i dati e all'occorrenza crea qualche animazione.
In altri casi ancora Javascript gestisce non pochi dati importanti.
Sempre su questa strada troviamo prodotti molto interessanti che usiamo senza sapere bene come funzionino: Google Maps, Yahoo!Maps, ecc..

E come dico sempre, e come dicevano i saggi una volta, il futuro viene sempre dal passato: Javascript è vecchio quasi come il Web e XML già c'è l'avevamo prima della nascita del Web 2.0

E dato che le cose non capitano per caso anche i prodotti che noi sviluppatori, più o meno abili, usiamo si sono adeguati alle tecnologie: la Adobe, Microsoft, ecc.. hanno rimodellato i loro prodotti su questa nuova strada.

C'era una volta in Actionscript "on press"...

..e ora non c'è più.
In effetti le cose sono un pò cambiate in Actionscript 3.
Soprattutto per chi lavorava in maniera "easy" o più semplicemente "assistita", avrà qualche problema.

Una volta appunto, si scriveva così per un semplice collegamento a una pagina:

on(press){
getURL(http://www.miapagina.it/);
}

Oggi invece:
1- Non si scrivono più le azioni sui pulsanti ma sul frame (oppure in classi esterne)
2- Si scrive così la stessa cosa di prima:

function collegati(evt:MouseEvent):void{
var path:URLRequest=new URLRequest(http://www.miapagina.it/);
navigateToURL(path);
}

nomePulsante.addEventListener(MouseEvent.CLICK, collegati);

Carino vero? :)
Nei prossimi post vedremo come e perchè si scrive così e cosa vuol dire tutto il codice scritto...

FlashDevelop, l'altra risorsa a Flash... free!

In effetti lavorare con Flash (qualunque versione) potrebbe essere dispendioso, in termini di costi di licenza. Così, se avete dimestichezza con Actionscript 3 (ma anche 2 va bene), potete utilizzare un utilissimo strumento gratuito di sviluppo "FLASH DEVELOP", oggi alla release 3 beta. Il prodotto è perfetto soprattutto per chi ha dimestichezza con Classi e affini vari. Infatti il programma lavora esclusivamente via codice Actionscript.
Per tutti gli interessati: http://www.flashdevelop.org/
E buon lavoro!
Ringraziamo per la notizia dell'esistenza di questo prodotto, un grande amico prima ancora che collega, Matteo Ronchi di Cef62!

Creare e gestire testi dinamici scorrevoli: ScrollingText class

INDICE: Guida ad ActionScript 3.0

Scarica l'esempio completo

SPIEGAZIONE:
La classe in ActionScript 3.0 che ho creato per l'occerrenza permette in circa 3 righe di codice di

• creare un campo di testo dinamico impostando: larghezza, altezza, posizione x, posizione y sullo stage ed eventuale bordo di cornice.
• (opzionale a seconda delle vostre necessità) scegliere il font da associare e la dimensione del font.
• scrivere utilizzando tag dell'HTML o meno (ad esempio per formattare testo con qualche tag).
  

Ciascuna delle 3 opzioni è gestita da un relativo metodo:

• setTextField(posizioneX:Number, posizioneY:Number, altezza:Number, larghezza:Number, bordo:Boolean);
• setFormatText(nomeDelFont:String, sizeDelFont:Number);
• insertContent(testo:String, html:Boolean);

Al vostro lavoro dovrete solo aggiungere i pulsanti che vorrete utilizzare per lo scrolling. Questa scelta è stata volontaria. Presumo che ognuno voglia disegnare i proprio pulsanti ! :)

NOTA: Il costruttore ha impostato un parametro (_fla) di tipo Movie Clip, per ereditare la Display Object dello Stage.

ESEMPIO:
In questo esempio vedremo come creare un testo scorrevole utilizzando la classe ScrollingText.
Per l'occorrenza dobbiamo solo disegnare i pulsanti (come spiegato poche righe fa) e aggiungere il codice necessario.

1. Aprite un nuovo documento Flash e salvatelo dove preferite.
   
2. Disegnate i pulsanti di up e down per lo scorrimento del testo. Convertiteli ciascuno in MovieClip (non in pulsanti).
3. Se volete crerae un effetto di rollover, disegnate il vostro rollover nel 2° fotogramma dei pulsanti di scorrimento che avete disegnato al punto 2. Non è necessario inserire alcuna azione in questi pulsanti .
   
4. Cancellate i pulsanti dallo stage ma NON dalla libreria.
5. Aprite la libreria e cliccate col tasto destro sui simboli Movie Clip dei pulsanti appena creati.
   
6. Cliccate sulla voce "Concatenamento".
7. Spuntate la voce "Esporta per ActionScript" e inserite come nome Classe: "TextButtonDown" (come mostrato nella figura seguente).
8. Ripetete il punto 7 inserendo come nome Classe "TextButtonUp".
9. Cliccate sul primo fotogramma e aprite il pannello Azioni.
   
10. Scrivete il seguente codice:

var testoScorrevole:ScrollingText=new ScrollingText(this);

testoScorrevole.setTextField(100,30,200,80,true);
//100: posizione x; 30:posizione y; 200:larghezza del testo; 80:altezza del testo; true:mostra bordo (false:nasconde bordo).

testoScorrevole.insertContent("<b>Lorem ipsum dolor Morbi nunc gravidcursus nec, luctus a, lorem</b>.<br>Maecenas tristique orci ac sem.Duis ultricies pharetra magna. Donec accumsan malesuada orci. Donec sit amet eros. Lorem ipsum dolor amet, consectetuer adipiscing elitLorem ipsum dolor Morbi nunc gravidcursus nec, luctus a, lorem. Maecenas tristique orci ac sem. Duis ultricies pharetra magna. Donec accumsan malesuada orci. Donec sit amet eros. Lorem ipsum dolor amet, consectetuer adipiscing elitLorem ipsum dolor Morbi nunc gravidcursus nec, luctus a, lorem. Maecenas tristique orci ac sem. Duis ultricies pharetra magna. Donec accumsan malesuada orci. Donec sit amet eros. Lorem ipsum dolor amet, consectetuer adipiscing elit FINE", true);//Il primo gruppo di testo è il testo effettivo da visualizzare. Il parametro true riguarda l'uso di tag HTML (true: i tag possono essere usati; false: i tag NON posso essere usati).

testoScorrevole.setFormatText("Arial", 13);//Fate attenzione a scrivere sempre bene il nome della Font!!! 13=dimensione del font

Guida ad Actionscript 3.0Capitolo 15: Gestire metodi e proprietà di una classe in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

Ultimo capitolo della nostra guida. Dopo aver analizzato una classe e iniziato a scriverne "l'ossatura", proseguiamo lavorando nei suoi elementi principali: metodi (funzioni) e proprietà (variabili).
package{

public class Scripting {
public function Scripting():void{
trace("Hello World!");
}
}

}

Questa era la classe creata nel precedente articolo. Come indicato, questa classe ci permetterà di creare campi di testo e popolarli. Cominciamo:

Modifichiamo il codice precedente alla seguente maniera:
package{

import flash.text.TextField;
import flash.display.MovieClip;

public class Scripting extends MovieClip{


public var myStage:MovieClip=new MovieClip();//variabile-proprietà della classe
public var mioTesto:TextField=new TextField();//variabile-proprietà della classe
public function Scripting():void{ // metodo -costruttore della classe

}
}

}
Cos'è cambiato? Abbiamo importato tutte le classi di cui abbiamo bisogno: TextField e MovieClip. La prima perchè useremo dei campi di testo, la seconda perchè la nostra classe utilizzerà metodi della MovieClip quindi dobbiamo "estenderla" partendo proprio da essa.
Ora dobbiamo fare in modo che dati 4 parametri (stage, testo da scrivere, posizione X del testo, posizione Y del testo) il campo venga creato, popolato e spostato. Inoltre è utile ricordare che ogni classe utilizzata all'interno della classe che creiamo va sempre importata!!!!

Inoltre abbiamo creato due variabili (mioTesto, myStage) che all'interno di una classe diventano (diciamo anche che "vanno considerate") semplicemente due proprietà. L'attributo "public" indica che queste sono "accessibili" (o modificabili) anche da codice esterno alla classe. Questo perchè i loro valori saranno inseriti solo in un secondo momento e non sono fissi sin dall'inizio!

Modifichiamo il costruttore alla seguente maniera:

public function Scripting(_root:MovieClip, words:String, posX:Number, posY:Number):void{

}
I parametri inseriti all'interno del costruttore ora dovranno essere "utilizzati", vediamo come:

mioTesto.text=words;
mioTesto.x=posX;
mioTesto.y=posY;
myStage=_root;
myStage.addChild(mioTesto);

Andiamo ora sul nostro documento FLA e vediamo cosa scrivere.
Modifichiamo la prima e unica riga di codice dell'esercizio precedente nella seguente maniera:
var test:Scripting=new Scripting(this, "Hello World", 100, 100);

Proviamo il nostro lavoro. Vedremo il testo all'interno dell'applicativo!

Ecco il codice completo della classe:

package{
import flash.text.TextField;
import flash.display.MovieClip;

public class Scripting extends MovieClip{

public var mioTesto:TextField=new TextField();
public var myStage:MovieClip=new MovieClip();

public function Scripting(_root:MovieClip, words:String, posX:Number, posY:Number):void{
mioTesto.text=words;
mioTesto.x=posX;
mioTesto.y=posY;
myStage=_root;
myStage.addChild(mioTesto);
}
}
}

Guida ad Actionscript 3.0Capitolo 14: Lavorare con le classi in Actionscript 3

INDICE: Guida ad Actionscript 3.0

Come abbiamo scritto nei precedenti capitoli, oggi Flash Cs3, quindi Actionscript 3 è "totally class-based". Molto velocemente potremmo dire che ogni cosa in Actionscript 3 è una classe.
Lavorare correttamente con le classi in Actionscript 3 significa quindi avvicinarsi al mondo della "programmazione a oggetti" (vedi Java, C, VB, ecc..).
Lavorare effettivamente con la programmazione a oggetti permette di rendere veramente "scabili" e/o universali i nostri lavori.

Partiamo dal concetto che tutti gli "elementi" che usiamo in Flash/Actionscript sono classi.
Questo vuol dire che quando creiamo, ad esempio, un quadrato e lo convertiamo in MovieClip, stiamo usando la classe "MovieClip".

Quando creiamo un testo dinamico, stiamo usando la classe TextField. Con i pulsanti, invece utilizziamo la "SimpleButton" ecc...

Come detto nel capitolo precedente, ogni classe ha i suoi metodi e le sue proprietà.
I metodi altro non sono che funzioni, mentre le proprietà sono variabili.

Riducendo all'osso (senza offendere nessuno :) ) potremmo dire che le Classi sono un insieme, possibilmente ragionato, di variabili e funzioni!!!!

Questo significa che potrei, ad esempio, creare delle classi personali per generare testi scorrevoli, leggere file XML e farmi restituire valori specifici, inserire data e ora sullo stage, ecc...

Lavorare a oggetti quindi è un pò come lavorare con i LEGO. Tanti pezzi di forme e colori diversi che messi insieme possono creare case, ponti, giardini, macchine, ecc... (Carino come esempio, no? :) ).

Ora la classe per esistere ha bisogno di una struttura particolare.
Anzitutto creare una classe significa creare un file Actionscript (estensione "as"). Questo tipo di file è ovviamente possibile crearlo in Flash CS3, ma anche col Blocco Note, oppure con Flex 3, o ancora Dreamweaver CS3, ... Nel nostro caso però useremo Flash CS3. Per chi lavora su PC consiglio vivamente FLASH DEVELOP!

Quindi da Flash: menu "File", "Nuovo", "File Actionscript".
Il "File Actionscript" è solo codice. E infatti vi ritroverete senza stage, ecc.. ma solo con un enorme pannello azioni! :)
Niente paura!

Presupposti: creeremo una classe che inserisca un campo di testo dinamico sullo stage e scriva una frase che diciamo noi!

Primissimo passo: salvare il file! Pare inutile invece è di vitale importanza!
Pensiamo bene al nome che daremo al file poichè quello sarà anche il nome della Classe, quindi il riferimento fondamentale!!!! Salviamolo quindi come "Scripting.as". (Ricordatevi di salvare il file con la lettera iniziale maiuscola).

Passo successivo: la classe che creeremo, come tutte del resto, deve essere inserito all'interno del pacchetto o "package".
Quindi nel file appena aperto scriviamo:

package{
}

Ora, tutto ( e dico tutto) quello che useremo, scriveremo, creeremo, ... dovrà essere scritto dentro il package.
Ora modifichiamo il testo nella seguente maniera:

package{

public class Scripting {
public function Scripting():void{
trace("Hello World!");
}
}

}

Come vedete, all'interno del package abbiamo "istanziato la classe", quindi al suo interno abbiamo inserito una funzione omonima della classe (e cioè sempre "Scripting").
Quella funzione (accompagnata dall'operatore "void") viene anche detta in gergo "costruttore". Un pò come l'ossatura della classe. Ogni Classe deve infatti avere il suo costruttore.
Nel caso in cui (per necessità o altro motivo) il costruttore non dovessere svolgere nessuno compito iniziale o preventivo, questo viene creato ma lasciato vuoto... senza istruzioni.

Nel nostro caso invece abbiamo voluto scrivere la frase storica della programmazione "Hello World!".

Salviamo il nostro file.

Per utilizzarla effettivamente, ora dobbiamo usarla all'interno di un fila Swf. Creiamo quindi un nuovo documento in Actionscript 3.

Clicchiamo sul primo fotogramma e apriamo il pannello azioni.

Qui scriviamo semplicemente:
var miaClasse:Scripting=new Scripting();

Come vedete abbiamo utilizzato la tipizzazione dei dati che usiamo sempre per tutte le altre classi (TextFiled, MovieClip, ecc...)

Salviamo il file nella stessa cartella del file Scripting.as

Proviamo il file e vederemo il pannello di output con scritta la fatidica frase.
Morale della favola: abbiamo creato una classe (Scripting.as) e l'abbiamo richiamata come una qualunque classe.
Nel prossimo capitolo vedremo come lavorare con metodi e proprietà per concludere il lavoro e creare una classe ci permetta di inserire testo dinamico nelle nostre applicazioni Flash CS3.

Qui potrete scaricare il file d'esempio.

Guida ad Actionscript 3.0Capitolo 13: Introduzione alla programmazione a oggetti in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

Quando intorno al 2004, AJAX (Asyncronous Javascript and XML) cominciava a prendere piede sistematicamente nel Web, la Macromedia sfornò FLEX.
Questo prodotto serviva fondamentalmente per creare RIA (Rich Internet Application) attraverso l'uso di Actionscript! Ora, Actionscript 2 era giunto ad un buon punto, tuttavia non era un vero linguaggio di programmazione.
Allora ecco che si decide di rigenerarlo. E nasce, ormai da un paio di anni, Actionscript 3.0
E' ormai un linguaggio di programmazione a tutti gli effetti!

Già disponibili dalla release 2, oggi possiamo creare Classi, quindi.
La possibilità di lavorare con Actionscript come una OOP (Object Oriented Programming) permette di migliorare il proprio lavoro sotto molti aspetti.
Non solo di creazione di Classi funzionali per i nostri lavori, ma anche di scrittura della programmazioni necessaria.

Come abbiamo già anticipato nei primi capitoli, Flash CS3 è divenuto completamente "class-based". Questo significa che ogni cosa può essere gestita attraverso le Classi.
Dal disegno di una forma (shape) alla creazione di un testo, e così via.
Ogni classe ha i suoi metodi (diremmo "cose che sa fare") e le sue proprietà (diremmo "caratteristiche").
Immaginiamoci la classe "Uomo". C'è chi ha la "proprietà" dei "capelli" biondi, mori, rossi, ecc..
Oppure il metodo "lavoro" di tipo: imbianchino, webmaster, musicista, ecc...
Tutti gli uomini (chiamate "istanze" della classe "uomo") sono fondamentalmente uguali: due braccia, due gambe, una testa, ecc...

Così quando creiamo via Actionscript o "a mano", una Movie Clip (ad esempio), non facciamo altro che creare un'istanza (copia esatta) della MovieClip.

Come definisce la Adobe nella documentazione ufficiale:
In pratica, la programmazione orientata agli oggetti consiste in due parti. Una parte riguarda le strategie e le tecniche di progettazione di un programma (spesso chiamata anche progettazione orientata agli oggetti). L'altra parte della programmazione a oggetti riguarda le strutture di programmazione vere e proprie disponibili in un determinato linguaggio di programmazione e necessarie per costruire un programma seguendo un approccio orientato agli oggetti.

Concludendo in soldoni, lavorare in programmazione pura con Actionscript 3 permette di rendere i propri lavori "scalabili" o "adattabili" a più diverse esigenze.

Nel prossimo e ultimo capitolo vedremo come si scrive una classe, da cosa è composto e come generarne di nuove.

Guida ad Actionscript 3.0Capitolo 12: Gestire materiale video in Flash CS3

INDICE: Guida ad Actionscript 3.0

In questo tutorial vedremo come gestire materiale video e quali possibilità abbiamo.
Per vedere un filmato nel nostro applicativo, ovviamente utilizzeremo il componente FLVPlayBack.

Consideriamo in partenza una cosa fondamentale: attraverso il Flash Player, possiamo renderizzare solo video FLV (Flash Video). Per fortuna Flash CS3, ma anche versioni precedenti, ci permettono di convertire un filmato in MOV, AVI, WMV, ecc.. in FLV, grazie a un programma correlato "Flash Video Encoder".
Questo programma, completamente autonomo da Flash, viene richiamato quando provo a inserire in libreria un video, attraverso la voce di menu: "File", "Importa", "Importa video".
Dopo la scelta del file, tra le opzioni di "Distribuzione", scelgo "Scaricamento progressivo da un server Web", soluzione tipica che si adotta nel caso in cui ovviamente non utilizziate un server streaming.

Il successivo pannello di codifica può rimanere sostanzialmente invariato. Le opzioni di default "Flash 8 qualità media" sono soddisfacenti. Confermiamo con "Avanti". Nell'ultimo pannello possiamo scegliere la skin che preferiamo. Tuttavia per l'occorrenza, utilizzeremo "Nessuno". Infatti saremo noi che inseriremo i nostri pulsanti, dove e come vogliamo!

Confermiamo con "Continua". Quindi al pannello successivo di riepilogo, confermiamo con "FINE". Verrà creato un file FLV nella stessa cartella di dove si trova il file originale.

La conversione ovviamente durerà in funzione della lunghezza del filmato.
Una volta termianto il processo, Flash inserirà sullo stage un componente Video pronto per essere visualizzato che noi rinomineremo come istanza: myVideo.

Dal menu "Finestra", scegliamo "Componenti". Qui, dalla sezione "Video" andiamo a prendere i nostri pulsanti di: PlayButton, MuteButton, SeekerBar, VolumeBar, MuteButton.
Ogni istanza verrà così rinominata: myPlay, myMute, mySeek, myVolume.
Posizioniamo sullo Stage, ciascuno dei pulsanti dove meglio crediamo, e andiamo sul primo fotogramma della Timeline e scriviamo quanto segue:

myVideo.playPauseButton=myPlay;
myVideo.seekBar=mySeek;
myVideo.volumeBar=myVolume;
myVideo.muteButton=myMute;

Ora il nostro componente è pronto per essere utilizzato. Testate l'applicativo.

SCARICA L'ESEMPIO.

Guida ad Actionscript 3.0Capitolo 11: Gestire materiale audio in Flash CS3

INDICE: Guida ad Actionscript 3.0

La musica ha da sempre accompagnato lavori in Flash, anche e soprattutto nelle versioni precedenti di Flash e/o Actionscript. In questo tutorial vedremo come sia possibile gestire al meglio (almeno le potenzialità principali) file audio esterni in formato MP3.
Per l'occasione andremo a leggere anche i tag ID3 del brano caricato. Gli ID3 altro non sono che le informazioni su titolo, autore, genere, ecc.. che di solito leggiamo sui nostri lettori multimediali del nostro computer o iPod, ecc...

Per prima cosa creiamo un nuovo file Actionscript 3 e salviamolo. Quindi nella stessa posizione del file FLA, salviamo un qualsiasi mp3. Oppure scaricate l'esempio.

Ora, scriviamo quanto segue sul primo fotogramma:

var mySound:Sound=new Sound();
var pathSound:URLRequest=new URLRequest("brano.mp3");
mySound.load(pathSound);
mySound.play();


Abbiamo praticamente inserito una nuova istanza della classe "Sound". Quindi abbiamo impostato il percorso del file da caricare.
Lo abbiamo successivamente caricato in maniera definitiva e messo in play da subito.

mySound.addEventListener(Event.COMPLETE, Id3Info);

function Id3Info(e:Event)
{
var id3:ID3Info=e.target.id3;
trace(mySound.id3.artist);
}

Con il codice ultimo precedente, abbiamo invece ripreso, se inseriti preventivamente, i meta ID3, richiamando, tra i tanti valori a disposizione, il nome dell'artista.

Ora inseriamo un pulsnate sullo stage. Rinominiamo l'istanza come "stop_btn".
Quindi proseguiamo scrivendo il seguente codice:
stop_btn.addEventListener(MouseEvent.CLICK, ferma);

function ferma(e:MouseEvent)
{
SoundMixer.stopAll();
}

Rispetto ad Actionscript 2.0, oggi non esiste più il metodo StopAllSounds(); per fermare l'audio in esecuzione in progetti Flash.
Bisogna utilizzare la classe SoundMixer e il suo metodo "stopAll()".
Provate quindi l'applicativo.

Ecco il codice completo:

var mySound:Sound=new Sound();
var pathSound:URLRequest=new URLRequest("brano.mp3");
mySound.load(pathSound);
mySound.play();

mySound.addEventListener(Event.COMPLETE, Id3Info);

function Id3Info(e:Event)
{
var id3:ID3Info=e.target.id3;
trace(mySound.id3.artist);
}

stop_btn.addEventListener(MouseEvent.CLICK, ferma);

function ferma(e:MouseEvent)
{
SoundMixer.stopAll();
}

Guida ad Actionscript 3.0Capitolo 10: Gestire ora e data in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

Eccoci giunti quindi ad una cosa molto utile negli applicativi Flash: creare un applicativo con data e ora.

Utilizzeremo per l'occorrenza la classe "Date". Vediamo quindi il tutorial.

In un nuovo documento Flash con Actionscript 3 inseriamo un campo di testo dinamico chiamato "testo_txt".

Quindi andiamo sul primo fotogramma della linea temporarel principale ed inseriamo il seguente codice:

var mesi:Array=new Array();
mesi=["Gennaio","Febbraio", "Marzo", "Aprile", "Maggio", "Giugno", "Luglio", "Agosto", "Settembre", "Ottobre", "Novembre", "Dicembre" ]

Per prima cosa abbiamo inserito un array contentente i mesi dell'anno. Perchè questo?
Perchè quando chiediamo ad Actionscript 3 di ridarci i mesi dell'anno, Flash resituisce un valore di un array compreso tra 0 e 11. Quindi "Gennaio" sarà 0, "Febbraio" sarà 1, ecc...

Di seguito a quanto scritto aggiungiamo:
function orario(){
var giorno:Date=new Date();
testo_txt.htmlText=String(giorno.getHours()+":"+giorno.getMinutes()+":"+giorno.getSeconds()+"
"+giorno.getDate()+"/"+mesi[giorno.getMonth()]+"/"+giorno.getFullYear());
}

Come vedete nell'ultima riga, nel campo di testo dinamico inseriamo i vari metodi della classe Date: getHours(), ecc...
Manca solo richiamare la funzione non una sola volta (vedremmo l'orario solo di apertura), ma più volte. Quindi aggiungeremo un metodo atto a questo:

setInterval(orario, 1000);

Da qui potete scaricare l'esempio.

Guida ad Actionscript 3.0Capitolo 9: Lavorare con le API di disegno in Actionscript 3.0

INDICE: Guida ad Actionscript 3

In questo capitolo affronteremo un argomento apparentemente improbabile, tuttavia utile: disegnare forme e/o movieclip attraverso la programmazione.
Questa volta non ci aiuteremo con un esempio da scaricare, quindi possiamo aprire Flash CS3 e inziare con un nuovo documento in Actionscript 3.0

Con il nuovo documento aperto, cominciamo a scrivere quanto segue sul primo fotogramma dell'unico livello presente sulla linea temporale.

var miaClip_mc:MovieClip=new MovieClip();

Iniziamo istanziando la variabile della MovieClip che disegneremo.

addChild(miaClip_mc);
"Aggiungiamo" la clip allo stage in modo da renderla presente sullo stage!

with(miaClip_mc.graphics){
beginFill(0xFF0000, 1);
moveTo(0,0);
lineTo(100,0);
lineTo(100,100);
lineTo(0,100);
endFill();
}

Attraverso un semplice ciclo "with" quindi abbiamo creato una clip, rossa, di 100 pixel di lato, posizionata su coordinate 0 per le x e per le y; "graphics" è la proprietà della classe MovieClip (ma sarebbe equivalso anche per la nuova "Sprite", praticamente identica alla MovieClip ma senza la timeline) utilizzata per poter applicare i metodi di disegno vettoriale.

Provate ora l'applicativo con CTRL+INVIO (CMD+Invio su Mac).

Ecco il codice completo:

var miaClip_mc:MovieClip=new MovieClip();
addChild(miaClip_mc);
with(miaClip_mc.graphics){
beginFill(0xFF0000, 1);
moveTo(0,0);
lineTo(100,0);
lineTo(100,100);
lineTo(0,100);
endFill();
}

Guida ad Actionscript 3.0Capitolo 8: Lavorare con dati XML in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

Eccoci quindi al nuovo capitolo sulla gestione di dati caricati tramite XML.
In questo tutorial vedremo come utilizzare Flash per codificare un file XML. Ad esempio riprendere l'elenco di questo blog e leggere ad esempio tutti i titoli dei post pubblicati fino ad ora. Essendo la fonte (il file RSS dei blog altro non è che un file XML con determinate caratteristiche) online, i dati saranno sempre automaticamente aggiornate.

SCARICATE L'ESEMPIO

Apriamo quindi il nostro file scaricato e andiamo sul primo fotogramma della scena principale.

Per prima cosa dobbiamo creare un'istanza della classe XML all'interno del nostro lavoro.
var myXML:XML = new XML(); var myXMLURL:URLRequest = new URLRequest("http://faber04.blogspot.com/feeds/posts/default?alt=rss");

Oltre all'instanza XML (di nome myXML), abbiamo utilizzato anche la classe URLRequest, già vista nei precedenti capitoli, quindi abbiamo inserito il percorso del file RSS, che ricordiamo altro non è che un file XML formattato secondo regole ben precise. Ma sempre di XML si tratta!

var i:Number=1; var myLoader:URLLoader = new URLLoader(myXMLURL); myLoader.addEventListener(Event.COMPLETE, xmlLoaded);

Con queste ulteriori tre righe invece abbiamo creato una variabile numerica ("i"), che mi permetterà di fare da indice numerico delle news estratte dalla rete .
L'istanza di URLLoader invece caricherà i dati del path del file RSS.
A completamento dell'evento, partirà una funzione (xmlLoaded) che ritraccerà a video (mi farà vedere) i valori del file.
Vediamo questa funzione:

function xmlLoaded(event:Event):void { myXML = XML(myLoader.data); for each (var property:XML in myXML.channel.item) {
trace(("News "+(i++)+": ")+ String(property.title)); } }

Come potete leggere da questo file, abbiamo ripreso i valori dal file XML, quindi per ogni elemento in esso contenuto abbiamo attivato un ciclo for each.. richiedendo di tracciarci il contenutoon la variabile "i", incrementata ad ogni loop.

Ecco il risultato:













Questo è invece il codice completo:

var myXML:XML = new XML();
var myXMLURL:URLRequest = new URLRequest("http://faber04.blogspot.com/feeds/posts/default?alt=rss");
var i:Number=1;

var myLoader:URLLoader = new URLLoader(myXMLURL);
myLoader.addEventListener(Event.COMPLETE, xmlLoaded);

function xmlLoaded(event:Event):void
{
myXML = XML(myLoader.data);
for each (var property:XML in myXML.channel.item)
{

trace(("News "+(i++)+": ")+ String(property.title));
}
}

Guida ad Actionscript 3.0Capitolo 7: Caricare dati da fonti esterne in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

Per rendere i nostri applicativi sempre più performanti e pratici da aggiornare, vedremo come caricare i dati da fonti esterne.
Ho volutamente suddiviso il materiale in due capitoli: uno riguardante un caricamento di variabili (questo capitolo) e uno su dati estratti da un file XML (capitolo successivo).

In questo tutorial useremo come "fonte esterna", un file TXT (del Blocco Note di Windows o TextEdit di Mac) per pura praticità. Ovviamente, nel caso conosciate linguaggi server-side, basterà sostituire il nome del file, con l'indirizzo della pagina.

Prima di inziare quindi a vedere il codice Actionscript, vediamo come deve essere il nostro file TXT.

Scaricate l'esempio.

Nella cartella troverete, oltre al FLA, anche un file di testo. Apriamolo.
Al suo interno noterete una unica riga così fatta:
nome=fabio,franco,giorgio&cognome=bernardi,pinco,panco
Questa riga altro non è che una serie di due variabili (nome e cognome) con i relativi valori multipli associati a ciascuna variabile.

In Flash non faremo altro che prendere i singoli valori e inserirli all'interno di Array.

Apriamo quindi il nostro file Flash.
Andiamo sul primo fotogramma e cominciamo a scrivere.
Prima di tutto bisognerà spiegare a Flash da dove caricare il materiale. Per l'occasione abbiamo quindi bisogno di un'istanza della classe "URLLoader", addetta appunto all'indicazione del path del file da caricare.
Quindi:

var loader:URLLoader = new URLLoader(new URLRequest("var.txt"));

Per praticità abbiamo inserito direttamente nel costruttore della classe URLLoader, anche il parametro URLRequest che già avevamo incontrato nelle lezioni precedenti.

loader.addEventListener(Event.COMPLETE, completeHandler);
Adesso invece abbiamo indicato la funzione (completeHandler) da richiamare appena la classe URLLoader ha terminato di caricare i dati.

La funzione che andremo a vedere tra poco, invece spezzetterà ogni singolo valore delle varie variabili. Le inserirà all'interno di un Array, quindi le restituirà a video.

function completeHandler(event:Event):void {
var variables:URLVariables = new URLVariables(loader.data);
var nomeUtente:Array = variables.nome.split(",");
for(var i:Number=0; i<nomeUtente.length; i++){
trace(nomeUtente[i]);
}
}

Come vedete, carico le variabili, utilizzando un'istanza della classe URLVariables (che carica i dati contenuti nell'istanza della classe URLLoader.
Quindi "splittiamo" tutti i valori divisi dalla "," contenuti nella variabile "nome"
Al termine di facciamo restituire tutti i valori contenuti nella variabile "nome".

Ecco il codice completo:

var loader:URLLoader = new URLLoader(new URLRequest("var.txt"));

function completeHandler(event:Event):void
{

var variables:URLVariables = new URLVariables(loader.data);
var nomeUtente:Array = variables.nome.split(",");
for(var i:Number=0; i<nomeUtente.length; i++){
trace(nomeUtente[i]);
}

}

loader.addEventListener(Event.COMPLETE, completeHandler);

Guida ad Actionscript 3.0Capitolo 6: Lavorare con gli Array in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

Eccoci giunti al sesto incontro di questa nostra guida: lavorare con gli array.
Prima di tutto cercheremo di capire, cos'è un Array, perchè è così utile lavorare con gli Array, quindi come si lavorano gli array in Actionscript 3.

Cominciamo dall'ultima domanda. Lavorare oggi gli Array in Actionscript 3 non è poi così differente da prima (in AS 1 o 2). Anzi oggi abbiamo a disposizione molti altri interessanti aspetti che prima non avevamo.

Perchè è utile lavorare con gli Array? Perchè permettono di gestire le informazioni in maniera molto più versatile, dinamica e precisa. In buona sostanza grazie agli array possiamo veicolare una mole di informazioni molto più ampia e completa rispetto a un suo mancato utilizzo. Attraverso un Array, possiamo ad esempio "portarci appresso" una lunga serie di informazioni (di qualsiasi natura: numeri, testo, ecc..).

Cos'è quindi un Array? Tecnicamente, l'Array è classificato come un vettore o costruttore di tipo. In altre parole, esso consente di definire nuovi tipi di dati a partire da tipi preesistenti (come aggregati di valori di) . Si può immaginare un array come una sorta di casellario, le cui caselle sono dette celle dell'array stesso (fonte: Wikipedia).

Immaginiamo, come vedremo nell'esempio che accompagna questo tutorial, di dover creare un elenco dinamico (tipo una lista) di utenti.

Lavorando senza programmazione saremmo costretti a creare a mano questo elenco, grazie agli Array (e non solo), potremmo in poche righe di codice semplificare il tutto al massimo.

Scaricate da qui l'esempio.

Per prima cosa quindi clicchiamo sul primo fotogramma del livello azioni e scriviamo:

var elenco:Array=new Array();
elenco=[["Fabio", "Bernardi"], ["Carlo", "Bianchi"], ["Mario", "Rossi"],["Giovanni", "Verdi"]];

Questo che avete appena scritto è appunto un Array: una sequenza di valori (nel suddetto caso una coppia di valori nome-cognome) di un ipotetico elenco.
Come vedete ogni coppia è inserita all'interno di parentesi quadre. Quindi il tutto è stato racchiuso all'interno di ulteriori parentesi quadre. Questo per far si che ogni vettore o "cella" del nostro Array sia composto da due "dimensioni". Volendo avrei potuto incrementare aggiungendo (sempre tra quadre) anche l'indirizzo mail, il telefono, ecc...
Oguno di questo valori, ogni singolo nome o cognome, è riutilizzabile singolarmente quanto in coppia con il corrispettivo valore.
Cioè: posso chidere ad Actionscript ad esempio di farmi ridare solo i nomi degli utenti, solo i cognomi, tutte e due i valori, il numero totale degli utenti presenti....ecc...
Insomma diverse informazioni utili!
Ma come posso fare per chidere a Flash di farmi ritracciare un valore esatto (ad esempio "Giovanni")?
Così: trace(elenco[3][0]); ...
PS: il metodo "trace" mi traccerà il valore all'interno del pannello output di Flash.

Perchè elenco[3][0]? Semplice.

"elenco" perchè stiamo richiamando l'array che si chiama appunto "elenco".
3 perchè, partendo dallo 0, Giovanni è il quarto utente (0: fabio, 1: Carlo, 2:Mario, ecc..). L'array infatti conta a partire dallo 0 e non da 1 come faremmo noi!!!
0 perchè all'interno delle parentesi quadre più interne di ciascun nome il giro ricomincia. Quindi "Giovanni" è 0, "Verdi" è 1!

Ora che li funzionamento degli Array dovrebbe essere più semplice, continuiamo scrivendo il codice restante:

for(var i:Number=0; i<elenco.length; i++)
{
trace("Studente n°"+(i+1)+" - Nome:"+elenco[i][0]+" Cognome: "+elenco[i][1]);
}

Analizziamo quanto scritto ora.
Abbiamo utilizzato un cosidetto "ciclo for". Ovvero sia: "Per" quanti sono i valori inseriti nell'Array, tracciami un costrutto del tipo: "Studente n°....".
I Cicli infatti mi permettono di indicare l'azione da fare una volta sola. Sarà poi Flash che lo eseguirà x volte.
Ma come indicare queste "x" volte? Grazie alla proprietà "length" dell'Array.
La proprietà length infatti indica quanti sono i valori contenuti nell'Array. In maniera semplificata: quanti utenti sono stati inseriti.

Il resto altro non è che un indicazione dei valori da riprendere.
Tuttavia notate: per farmi ridare i nomi (tutti) degli utenti ho usato la dicitura del tipo: elenco[i][0]. All'interno di un ciclo la variabile "i" assume valori che vanno da 0 a 4 (in questo caso solo ovviamente, perchè 4 sono gli utenti dell'array).
Quindi invece di dire a Flash: elenco[0][0] per scrivere "Fabio", elenco[1][0] per scrivere "Carlo", ecc... utilizzo la variabile "i" e la inserisco nelle prime parentesi quadre ed il gioco è fatto. La cosa ovviamente si ripete per i cognomi.

Riguardo poi all'elenco numerato, visto che "i" parte da 0, basterà aggiungere al valore 1 così da far ritornare il conto finale.

Ecco il codice completo:

var elenco:Array=new Array();
elenco=[["Fabio", "Bernardi"], ["Carlo", "Bianchi"], ["Mario", "Rossi"],["Giovanni", "Verdi"]];

for(var i:Number=0; i<elenco.length; i++)
{
trace("Studente n°"+(i+1)+" - Nome:"+elenco[i][0]+" Cognome: "+elenco[i][1]);
}

Guida ad Actionscript 3.0Capitolo 5: Caricare e gestire immagini esterne in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

Lavorare a grossi progetti è sempre stato un dilemma. Sia per la quantità di materiale, sia per l'eccessivo ingombro di KB che il lavoro finale può arrivare ad avere.
Caricare quindi il materiale "dall'esterno" invece di incorporarlo dentro un file Flash, potrebbe essere comodo per gestire con più facilità (e rendere quindi il lavoro più light) il nostro file SWF.

Scaricate da qui l'esempio.

Quello che fare in questo nostro progetto sarà quello di importare una foto (che si trova in rete), ad esempio il logo di Google dentro il nostro applicativo. Ovviamente al posto di Google potremmo mettere una nostra foto...!

Nelle vecchie versioni di Actionscript (1 e 2), esisteva un metodo: "loadMovie" o "loadMovieNum". Molto pratiche.
Oggi, ahimè, non più!

In Actionscript 3, abbiamo bisogno di due Classi: URLRequest (ci permetterà di indicare l'URL del file da caricare) e Loader (caricherà fisicamente l'immagine dentro Flash).

Quindi andiamo sul primo fotogramma, apriamo il pannello delle azioni (F9) e scriviamo:
var urlPath:URLRequest=new URLRequest("http://www.google.it/intl/it_it/images/logo.gif");

Abbiamo richiamato la classe URLRequest (dandole il nome "urlPath") e di seguito abbiamo indicato l'indirizzo esatto.

var loaderImg:Loader=new Loader();
Qui invece abbiamo semplicemente richiamato la classe Loader, dandogli il nome di "loaderImg".
Ora il nostro loader dovrà caricare l'immagine dal percorso indicato in urlPath.

loaderImg.load(urlPath);

Bene. Ora però il nostro loader dovrà essere inserito sullo stage. Altrimenti rimane solo impostato a livello di programmazione. Noi invece vogliamo vederlo "fisicamente" sullo stage questo logo!!!!

addChild(loaderImg);


Eccoci. Ora l'immagine, caricata da loaderImg è inserita sullo stage.
Ma le coordinate dell'immagine sono x=0, y=0! Non va molto bene. Infatti rischiamo questo:
Dobbiamo quindi dare meglio le coordinate al loader!
Basterà impostare le proprietà x e y del loader, che ricordiamo è per noi il contenitore della foto!

Quindi subito dopo le righe scritte finora aggiungiamo:

loaderImg.x=100;
loaderImg.y=100;

Se preferite, potrete cambiare le coordinate con altri valori.

Qui di seguito reinserisco il codice completo:

var urlPath:URLRequest=new URLRequest("http://www.google.it/intl/it_it/images/logo.gif");

var loaderImg:Loader=new Loader();

loaderImg.load(urlPath);

addChild(loaderImg);

loaderImg.x=100;
loaderImg.y=100;

Guida ad Actionscript 3.0Capitolo 4: Lavorare con il testo e le stringhe in Actionscript 3.0

INDICE: Guida ad Actionscript 3.0

In questo tutorial vedremo come lavorare dinamicamente il testo, come gestirlo e cosa è possibile sfruttare con i campi di testo dinamici.

Cominciando dall'inizio, possiamo dire subito che in Flash (tutte le versioni) esistono 3 tipi di campi di testo: statici, dinamici e di input. Ce ne accorgiamo di questa opzioni attraverso il pannello "Proprietà" quando creiamo un campo di testo.
Ovviamente nel nostro caso lavoreremo con il campo di testo dinamico che in molti casi è simile a quello di input. Quest'ultimo verrà comunque amplito successivamente.

Considerazione iniziale. Il campo di testo statico ci permette di utilizzare tutti i font che vogliamo del nostro sistema operativo senza preoccuparci se le macchine dei nostri utenti siano più o meno equipaggiate di tale font.
Con il testo dinamico o di input il discorso non è equivalente.
Questo significa che è preferibile utilizzare font di sistema classici (Verdana, Times New Roman, Courier, Geneva, ecc..) come per l'HTML. Questo per evitare di dover incorporare i font all'interno del nostro SWF finale e farlo così pesare oltre ogni ragionevole compromesso!
Infatti font particolari ai quali non volete rinunciare, possono essere incorporati anche nel caso di testi dinamici o input. Per fare ciò basterà clic sul pulsante "Incorpora" e scegliere i tipi di glifi (singoli caratteri) da introdurre (vd. foto).

Quand'è quindi che necessitiamo di un testo dinamico?
Nel momento in cui dobbiamo scrivere del testo senza sapere / avere il contenuto al momento della progettazione ma solo in runtime (esecuzione). Ad esempio un sito di news o blog reader.
Creiamo la nostra interfaccia ma i testi verranno caricati solo in un secondo momento (altrimenti dovremmo salvare il nostro file 10-20 volte al giorno! )
I testi di input li usiamo invece quando l'utente deve inserire dei valori (esempio: controllo password e username).
Date queste informazioni introduttive, iniziamo a vedere come lavorare col testo.

Scaricate l'esempio !

Aprite il file. Troverete due campi di testo dinamici. Nel primo scriveremo del semplice testo dinamicamente. Nel secondo invece formatteremo il testo utilizzando l'HTML.

Altra nota importante: quando lavorate con Actionscript (qualunque versione) ricordatevi sempre di dare un nome alle istanze presenti sullo stage (movie clip, testi dinamici, pulsanti, ecc.. ), questo per fare in modo che i nostri script "raggiungano" l'oggetto che vogliamo lavorare.
Sarebbe come chiamare una persona senza dire il nome. E' possibile?

Se non utilizzate l'esempio, create in nuovo documento Flash con Actionscript 3.0 ed inserite due campi di testo dinamici, dando un nome alle loro istanze.

Andiamo sul primo fotogramma (possibilmente del livello "as" dell'esempio oppure su un livello per le azioni a parte) e scriviamo quanto segue:

myText_txt.multiline=true;
myText_txt.wordWrap=true;
myText_txt.text="Lorem ipsum dolor Morbi nunc gravidcursus nec, luctus a, lorem. Maecenas tristique orci ac sem. Duis ultricies pharetra magna. Donec accumsan malesuada orci. Donec sit amet eros. Lorem ipsum dolor amet, consectetuer adipiscing elit";


(Ovviamente per "myText_txt" intendiamo il nome dell'istanza di uno dei due campi di testo.)

Lo script è abbastanza intuibile così da solo.
Con text scrivo nel campo di testo, con multiline indico che il campo deve essere multiriga e con wordWrap imposto l' "a capo automatico".

Giusto un'anticipazione: text, multiline e wordWrap sono "proprietà" dei campi di testo. Per ora ci limiteremo a questo. Più avanti ri-affronteremo il discorso quando parleremo di "classi" e programmazione a oggetti.

NOTA: Dovendo scrivere all'interno di un campo di testo il contenuto (Lorem ipsuet...) deve essere inserito tra "---".

Proviamo a salvare il file e a generare l'SWF e vediamo il risultato.
Nel primo campo di testo troviamo riscritto quanto abbiamo indicato! Bene! La prima parte è fatta. Proseguiamo.

Come noterete dall'esempio precedente il testo è tutto uguale. Niente formattazione, a capo, grassetti, corsivi... Insomma un pò povero.
Per dare una formattazione al tutto possiamo sfruttare i tag dell'HTML (non XHTML) !
Possiamo ad esempio utilizzare i seguenti tag : b (grassetto), i (corsivo), br (a capo), a (collegamenti), img (inserire immagini), u (sottolineato).

Subito sotto al codice precedente, scriviamo:
otherText_txt.multiline=true;
otherText_txt.wordWrap=true;
otherText_txt.htmlText=" <b> Lorem ipsum dolor Morbi </b> <br>
<i> nunc gravidcursus nec, luctus a, lorem. </i> <br> Maecenas tristique orci ac sem. Duis ultricies pharetra magna. Donec accumsan malesuada orci. Donec sit amet eros. Lorem ipsum dolor amet, consectetuer adipiscing elit";


Come vedete l'unica differenza questa volta è la proprietà "htmlText" invece di "text". Quindi abbiamo usato alcuni tag all'interno del testo seguendo la sintassi dell'HTML.

CODICE COMPLETO:

myText_txt.multiline=true;
myText_txt.wordWrap=true;
myText_txt.text="Lorem ipsum dolor Morbi nunc gravidcursus nec, luctus a, lorem. Maecenas tristique orci ac sem. Duis ultricies pharetra magna. Donec accumsan malesuada orci. Donec sit amet eros. Lorem ipsum dolor amet, consectetuer adipiscing elit";

otherText_txt.multiline=true;
otherText_txt.wordWrap=true;
otherText_txt.htmlText=" <b> Lorem ipsum dolor Morbi </b> <br>
<i> nunc gravidcursus nec, luctus a, lorem. </i> <br> Maecenas tristique orci ac sem. Duis ultricies pharetra magna. Donec accumsan malesuada orci. Donec sit amet eros. Lorem ipsum dolor amet, consectetuer adipiscing elit"

Ora proviamo il nostro lavoro. Il risultato dovrebbe essere come quello presentato nella foto sottostante:

Guida ad Actionscript 3.0Capitolo 3: Gestire gli eventi

INDICE: Guida ad Actionscript 3.0

Una delle prime modifiche sostanziali che si sono avute con Flash, è stata la gestione dei cosidetti "eventi".
Come già illustrato in un vecchio post, oggi Flash non permette nella maniera più assoluta di scrivere nulla sulle istanze presenti sullo Stage. Già dalla precedente versione infatti era possibile. se non auspicabile, scrivere le azioni almeno sul fotogramma chiave della linea temporale. La soluzione ottimale era ovviamente scrivere in classi esterne il proprio lavoro. Così se l'ultima delle opzioni sopra elencate non era molto diffusa a livello amatoriale o semi professionistico, la seconda vantava qualche seguace, la prima praticamente usatissima.

Ecco uno dei primi ostacoli, proprio per chi le azioni non poteva fare a meno di metterle sul pulsante o altri simboli presenti sullo stage, oppure usava la timeline con la sintassi di Actionscript 2.0

Dato che ormai lavoriamo solo classi, abituiamoci all'idea che in Actionscript 3.0 ogni movieclip od ogni pulsante ha il suo Listener di eventi. O più correttamente potremmo dire che ogni azione o funzione che impostiamo può essere assegnata tramite Listener ad un evento specifico, un momento esatto in cui vorremmo che l'azione si verifichi.

Seguendo questa logica quindi dobbiamo creare una funzione che gestisca la nostra azione.
Quindi, scaricate da questo link il file per l'esercitazione.
Per l'occorrenza, ho creato un semplice esercizio. L'applicativo, fermo inizialmente al primo fotogramma, si sposterà al 15° fotogramma appena cliccato sul pulsante al centro dello stage. Come una volta utilizzeremo il semplice metodo "gotoAndStop"

Sia che vogliate usare l'esempio, che crearne uno vostro, bisogna sempre ricordarsi di dare un nome alle istanze. Uno qualsiasi. Anche se la documentazione ufficiale suggerisce di concludere il nome col suffisso "_btn". Quindi il nome potrebbe essere "vai_btn".

Tornando alle nostre azioni: per ogni evento che si vuole gestire bisogna creare una funzione che definisca le azioni da svolgere. Quindi un Listenere a cui associare l'azione.

Cominciamo dalla funzione. Al primo fotogramma scrivete quanto segue:

stop();
function sposta(e:MouseEvent):void
{
gotoAndStop(15);
}

Ora dobbiamo creare il listener, o più esattamente dobbiamo assegnare al listener delle azioni del pulsante, questa nostra azione di nome "sposta". Così:

vai_btn.addEventListener(MouseEvent.CLICK, sposta);

Come vedete ogni azione viene creata all'interno di una funzione e quindi assegnata. Il parametro della funzione sposta (parametro di nome "e") è di tipo MouseEvent. E questo è abbastanza intuitivo. Tuttavia questo piccolo esempio mostra come non basta creare una funzione ed assegnarla ma anche indicare il tipo di evento. Quindi nel listener il tipo specifico dell'evento, visto che il mouse ha diverse opzioni (rolloOver, rollout, click, up, down, ecc... ).

CODICE COMPLETO:

function sposta(e:MouseEvent):void
{
gotoAndStop(15);
}

vai_btn.addEventListener(MouseEvent.CLICK, sposta);

SCARICA L'ESEMPIO

Arrivederci al prossimo capitolo!

Guida ad Actionscript 3.0Capitolo 2: Le novità di Actionscript 3.0

INDICE - Guida ad Actionscript 3.0

Come già abbiamo anticipato nell'introduzione di questa guida, Actionscript 3.0 è divenuto ormai (almeno al 98%) un linguaggio a oggetti alla stregua di Java (tanto per citare un linguaggio di programmazione diffuso).
Questo significa che se da una parte il lavoro è cambiato (bisogna cominciare ad avere una mente aperta verso la programmazione a oggetti), dall'altra si è potenziato di molto il risultato finale in termini di performabilità.

Oggi il Flash Player (scaricabile gratuitamente dal sito ufficiale di Adobe) permette una quantità considerevole di possibilità, fino a ieri impensate o difficili da realizzare.

Secondo quanto indicato anche dalle specifiche ufficiali ActionScript è un linguaggio che viene eseguito dall'AVM (ActionScript Virtual Machine), che fa parte di Flash Player. Il codice viene solitamente compilato in formato codice byte mediante un compilatore, come quello incorporato in Adobe Flash CS3 o in Adobe Flex 3 e in Flex Data Services. Il codice byte viene incorporato in file SWF, che viene quindi eseguito in Flash Player (l'ambiente runtime).

Actionscript 3.0 si basa sulla bozza di specifica del nuovo linguaggio ECMAScript (ECMA-262) edizione 4 che permette di fornire ottimizzazioni più estese rispetto alle versioni precedenti del compilatore.

L'AVM2 su cui si basa oggi Actionscript 3.0 permette (oltre a una ottima retrocompatibilità con script di versione 1.0 e 2.0) di velocizzare la lettura e l'esecuzione del codice fino a 8-9 volte superiore, rispetto a prima! Almeno così dicono! :)

A tal proposito sottolineo un aspetto. La retrocompatibilità con Actionscript 1 o 2 vuol dire che vecchi filmati prodotti con queste versioni vengono letti dal player. Tuttavia in ambiente di sviluppo (Flash o Flex ad esempio) non possiamo produrre filmati creati per Actionscript 3.0 e riscrivere il codice con la sintessi di Actionscript 1 o 2.

Nei prossimi capitoli entreremo nel vivo della questione lavorando con il testo in Flash CS3 e la classe TextField.

Guida ad Actionscript 3.0 Capitolo 1: Le novità di Adobe Flash CS3

INDICE - Guida ad Actionscript 3.0

Con l'ultima release di Flash CS3 le novità che bollono in pentola sono diverse.
In questo capitolo vedremo quali sono le nuove possibilità (almeno le principali).

La prima ovviamente proviene proprio dall'interfaccia iniziale. Ovvero sia la possiblità di scegliere come creare il nuovo documento di Flash CS3, soprattutto per quanto riguarda la versione di Actionscript. Ovviamente , ve ne sarete già resi conto, il codice non è riutilizzabile come era accaduto fino ad oggi tra Actionscript 1.0 e 2.0. Esattamente intendo dire che del vecchio codice Actionscript 2.0 che abbiamo usato fino a ieri potrebbe non andare più bene ora.
Infatti, da oggi con Actionscript 3.0 non è più possibile inizializzare variabili o creare alcuna riga di codice direttamente sulle istanze movieclip o button del nostro lavoro.
Quindi? Seguendo una buona regola che possiamo adottare anche in Actionscript 2.0, inseriamo le nostre azioni direttamente sul primo fotogramma della nostra timeline della scena principale.

Ovviamente questa scelta è solo una possibilità rispetto ad altre. Ad esempio è possibile creare classi esterne da associare al nostro progetto Flash evitando così di scrivere codice sulla timeline e rendere i nostri script riusabili, ad esempio, per progetti Flex 3 o altri progetti Flash CS3.

Come prima cosa quindi dobbiamo prendere come buona abitudine: nominare tutte le nostre istanze presenti sullo stage (campi di testo, movie clip, button, ecc...)
Così facendo infatti Actionscript 3.0 avrà accesso ai nostri elementi presenti sullo stage.
Ricordiamo anche un altro fattore importante al riguardo. Actionscript 3.0 è totally class-based. Questo significa che dovremmo almeno sforzarci di considerare il fatto che lavoriamo con oggetti (in termini di programmazione, ovviamente). Con tutti i suoi pro e contro.

Alla lunga lavorandoci, vi/ci renderemo/ete conto che il lavorare in maniera più completa in programmazione alla fine ripaga. Cambia il punto di vista, dobbiamo fare attenzione rispetto a prima a molte altre cose, ma ne vale la pena.

Il discorso della programmazione a oggetti in Actionscript 3.0 verrà affrontato più completamente in uno degli ultimi capitoli di questa guida. Per ora quindi ci fermiamo qui.

Riguardo invece ad altre nuove features di Flash CS3, andiamo a vedere:

• Le animazioni generate sulla timeline possono essere importate o esportate per altri progetti in formato XML (al riguardo vi consiglio la lettura di questo post)
• Nuove forme di disegno (rettangolo di base, ovale di base). Anche per questo vi consiglio questo secondo post.

Dati inoltre i recenti ed importanti traguardi raggiunti dal formato video FLV, è stata notevolmente migliorato anche il componente FLVPlayBack, il quale ora supporta anche API di ActionScript per garantire la compatibilità del ridimensionamento con accelerazione hardware per il video a schermo intero.
Sempre per il video il componente FLVPlayBack è stato potenziato con il supporto del codec H264.
H.264 fa parte dello standard MPEG-4 (MPEG-4 Parte 10) e garantisce una qualità video superiore a velocità di trasferimento dati anche molto basse, in un'ampia gamma di applicazioni.

Sono state introdotte nuove API per una migliore riproduzione di filmato in FULLSCREEN.

Il Flash Player ora supporta l'IPv6 (Internet Protocol version 6). Questo significa che supporta indirizzi in formato a 128 bit rispetto ai precedenti 32 della versione 4.

La classe ExternalInterface è stata aggiornata in modo da rendere maggiormente integrato il lavoro tra Javascript ed Actionscript.

Nel prossimo capitolo vedremo quali sono invece le novità effettive di Actionscript 3.0.

INDICE - Guida ad Actionscript 3.0

Guida ad Actionscript 3.0Introduzione

Visti i recenti sviluppi che il Flash Player e quindi Actionscript hanno avuto in questo periodo, ho pensato di creare una specie di guida all'uso di Actionscript 3 in Flash CS3.
Questa scelta è stata dettata soprattutto dal fatto che in alcuni casi i cambiamenti sono risultati anche profondi proprio per chi non aveva molta dimestichezza con la programmazione o con Flash in generale. Piuttosto che creare singoli tutorial sparsi, ho preferito seguire un ordine logico che qui di seguito espongo.
Ovviamente ognuno di questi punti riguarda un argomento che verrà affrontato progressivamente nel tempo. Rimanete quindi sintonizzati su questo canale visto che di volta in volta troverete attivi i link dei vari capitoli. Per rendere il tutto più comprensibile il lavoro verrà corredeto da esempi scaricabili gratuitamente senza limitazioni.

GUIDA AD ACTIONSCRIPT 3.0

• Introduzione
• Le novità di Adobe Flash CS3
• Le novità di Actionscript 3.0
• Gestire gli eventi in Actionscript 3.0
• Lavorare con il testo e le stringhe in Actionscript 3.0
• Caricare e gestire immagini esterne in Actionscript 3.0
• I Cicli in ActionScript 3.0
  
• Lavorare con gli Array in Actionscript 3.0
• Caricare dati da fonti esterne in Actionscript 3.0
• Lavorare con dati XML in Actionscript 3.0
• Lavorare con le API di disegno in Actionscript 3.0
• Gestire ora e data in Actionscript 3.0
• Gestire materiale audio in Flash CS3
• Gestire materiale video in Flash CS3
• Introduzione alla programmazione a oggetti in Actionscript 3.0
• Lavorare con le classi in Actionscript 3.0
• Creare una classe in Actionscript 3.0
  
• Gestire metodi e proprietà di una classe in Actionscript 3.0

CATALOGO di CLASSI ActionScript 3.0

• ScrollingText (per creare e gestire campi di testo dinamici scorrevoli)
• PreloadingContent (per gestire il caricamento di file SWF, JPG o GIF)

AGGIORNAMENTI (upgrade) di ActionScript 3.0

• Creare animazioni 3D . Gli assi X, Y e Z*
• Lavorare con i componenti di Flash: Button
  
• Lavorare con i componenti di Flash: DataGrid
  
• Lavorare con i componenti di Flash: ProgressBar
  
• Lavorare con i componenti di Flash: ComboBox.
  
• Lavorare con i componenti di Flash: RadioButton.
• Lavorare con i componenti di Flash: CheckBox.
• Lavorare con i componenti di Flash: NumericStepper, Slider
• Lavorare con i componenti di Flash: Label, TextArea, TextInput
  

* per versioni a partire da Flash CS4.