Articoli con Tag ‘Flash’


Adobe Flash 3D simulator

Guardate che bella simulazione 3D (a volo d’uccello pilotabile con il mouse) in tempo reale realizzata in Adobe Flash!

Loading Flash Player...

Continua...

Nasce N3TV: NetTV 2.0

image È andata, il giorno è arrivato. Parte oggi il progetto N3TV, il nuovo “canale” NetTV di Tommaso Tessarolo con moltissime novità interessanti. Ho avuto il piacere di partecipare come CTO allo sviluppo della nuova piattaforma di interazione che fornisce servizi di Poll, Digg e Chat. Complimenti a tutto il gruppo per i consigli, i test, i nuovi video e i testi. Così N3TV rappresenta davvero un nuovo modo di fare e vedere la NetTV, dove interazione e qualità s’incontrano. Tenete d’occhio il sito e partecipate alla prossima trasmissione!

Continua...

Mogulus Studio 1.2 Beta

È stata rilasciata la Beta 1.2 di Mogulus Studio, l’applicazione Web in Flash utilizzata per la messa in onda delle trasmissioni. Poche le novità rispetto alla versione precedente, tuttavia (come suggerito) si procede nella direzione giusta:

Continua...

How I Did It: scrivere un countdown in Flash

Per la serie “How I Did It” (ovvero come lo feci) ecco come realizzare un countdown in Flash per visualizzare, partendo da un data, quanto giorni, ore, minuti e secondi mancano ad un evento! Nel filmato Flash qui sotto, ad esempio, vediamo quanti giorni mancano al primo dell’anno! Possono essere utilizzati i menu a tendina per selezionare un diversa data:

Loading Flash Player...

Creiamo tre combo day_cmb, month_cmb ed year_cmb e li inizializziamo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// init combo
import mx.controls.ComboBox;
//
for (var i = 1; i < 32; i++) {
  day_cmb.addItem(i, i);
}
var sm:Array = Array("Gennaio", "Febbraio", "Marzo", "Aprile", "Maggio", "Giugno", "Luglio", "Agosto", "Settembre", "Ottobre", "Novembre", "Dicembre");
for (var i = 0; i < 12; i++) {
  month_cmb.addItem(sm[i], i);
}
// potrei partire dall'anno attuale...
for (var i = 2007; i < 2020; i++) {
  year_cmb.addItem(i, i);
}
// imposto la data al 1 gennaio 2008
day_cmb.selectedIndex = 0; // -1
month_cmb.selectedIndex = 0; // -1
year_cmb.selectedIndex = 1;

Il cuore del sistema lo posizioniamo nell’evento onEnterFrame:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
this.onEnterFrame = function() {
  //
  var today:Date = new Date();
  var currentYear = today.getFullYear();
  var currentTime = today.getTime();
  //
  var targetDate:Date = new Date(year_cmb.selectedItem.data, month_cmb.selectedItem.data, day_cmb.selectedItem.data);
  var targetTime = targetDate.getTime();
  //
  var timeLeft = targetTime - currentTime;
  //
  var sec = Math.floor(timeLeft / 1000);
  var min = Math.floor(sec / 60);
  var hrs = Math.floor(min / 60);
  var days = Math.floor(hrs / 24);
  //
  sec = String(sec % 60);
  sec = (sec.length < 2) ? "0" + sec : sec;
  //  
  min = String(min % 60);
  min = (min.length < 2) ? "0" + min : min;
  //  
  hrs = String(hrs % 24);
  hrs = (hrs.length < 2) ? "0" + hrs : hrs;
  //  
  days = String(days);
  days = (days.length < 2) ? "0" + days : days;
  //
  var counter:String = days + ":" + hrs + ":" + min + ":" + sec;
  //
  time_txt.text = counter;
};

Continua...

Aptana IDE update: milestone 9

È disponibile l’aggiornamento ad Aptana IDE, l’ambiente di sviluppo Web che supporta Adobe AIR e Apple iPhone. Tra le novità segnaliamo il miglioramento della sezione PHP con l’aggiornamento del Code Assist sia sulle funzioni che sui parametri. Migliorata anche la "colorazione" del codice. Aggiunto il supporto per gli ultimi framework Ajax tra cui Prototype.js e jQuery. Migliorata anche la gestione di Javascript.

image

Per la lista complete delle nuove funzionalità clicca qui.

Continua...

Right Click in AS3: menu contestuali personalizzati

Eliminare i menu contestuali o più semplicemente rispondere al “right click” del mouse del Flash Player è una possibilità non permessa direttamente da codice ActionScript anche nella versione CS3. Questa caratteristica sarebbe interessante sia per i giochi che per le Applicazioni RIA. Paulius Uza ha proposto una soluzione per ActionScript 3 (AS3) che lavora in accoppiata con Javascript. Questa “patch” è ancora in fase di testing in quanto dipende dal Flash Player installato e dal browser. Si può contribuire testando un’applicazione demo qui.
È stato apero anche un “progetto” su Google Code:

The idea is fairly simple:

1-Use Javascript in the HTML container page to disable the right-click on top of the SWF.

2-Capture the event and pass it to a function that communicates with Flash via the External Interface

3-In Actionscript the function called from Javascript does whatever you need to display your own custom context-menu.

Continua...

ActionScript: _parent e controllo dei contesti

Quando “scatta” un evento di un oggetto il contesto, ovvero l’oggetto madre che rappresenta l’area di validità di tutte le variabili, diventa l’oggetto stesso. Questa caratteristica, propria della programmazioni Object Oriented, può disorientare provocando errori e malfunzionamenti nel codice. Inoltre, in determinate situazioni, può impedire di accedere ad alcune variabili “prima” disponibili.

Prima di tutto vediamo una caratteristica di ActionScript legata alla gestione dei contesti che, se compresa, ci farà risparmiare alcune ore di inutili prove. Quando abbiamo a che fare con oggetti grafici o più semplicemente di MovieClip innestati uno all’interno dell’altro, la proprietà _parent risolve qualsiasi problema di contesto. Ad esempio se il MovieClip padre_mc contiente un altro MovieClip figlio_mc e si usa il seguente codice:

1
2
3
4
5
// codice all'interno di padre_mc
figlio_mc.onRelease = function() {
    trace(this); // figlio_mc
    trace(this._parent); // padre_mc
}

Risalisre al “padre”, quindi, risulta chiaro ed immediato.

Con classi pure, di solo codice, o estensioni di MovieClip, la proprietà _parent non è disponibile e le cose si potrebbero complicare! Immaginiiamo di avere una Classe MyClass:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Class MyClass extends MovieClip {
    function MyClass() {
        // constructor
    }
    //
    function myMethod() {
         trace(this); // myClass
         var num = 5;
         var cp = this;
         ....
         var myObject = new [ un oggetto ];
         myObject.onLoad = function() {
              trace(this); // myObject
              trace(cp); // myClass
         }
    }

Il contesto di MyMethod() è, ovviamente, this, ovvero il puntatore alla classe MyClass. La variabile num, ad esempio, ha un ciclo di vita racchiuso all’interno del metodo MyMethod(). È visibile quindi solo all’interno del metodo e verrà distrutta all’uscita. Stessa cosa per la variabile myObject che tuttavia inizializza un evento, in questo caso onLoad. Quando scatterà onLoad() il contesto diventerà myObject lasciandoci, apparentemente, senza il puntatore alla classe madre myClass. Analizzando attentamente il codice ci accorgiamo che la variabile cp, definita nel metodo myMethod(), ha lo stesso contesto della variabile myObject! Infatti la variabile cp(class pointer) sarà visibile all’interno del metodo onLoad dell’oggetto myObject in quanto condivide con esso lo stesso contesto. In realtà il metodo myMethod() non viene deallocato proprio perchè l’oggetto myObject ha necessità di “vivere” più al lungo del previsto visto che ha “allocato” un evento (di tutto questo se ne occupa Flash a nostra “insaputa”).

 

Consiglio

Per gli eventi legati a bottoni o a MovieClip una buona abitudine sarebbe quella di usare la forma:

1
2
3
4
5
my_mc.onRelease = myOnRelease;
function myOnRelease() {
    trace(this); // _root
    trace("Click me");
}

Al posto della più rapida ed immediata:

1
2
3
4
my_mc.onRelease = function() {
    trace(this); // my_mc
    trace("Click me");
}

Il vantaggio di usare un funzione esterna è quella di avere un contesto neutro e la possibilità di accedere alla funzione a prescindere dal MovieClip che la controlla. Nel secondo caso, ad esempio, se volessi forzare l’esecuzione del codice legato al “click” del MovieClip dovrei usare un codice di questo tipo:

1
my_mc.onRelease();

In pratica chiamo l’evento come fosse un metodo. Tuttavia devo – appunto – avere a disposizione il MovieClip my_mc. Nell’altro modo, invece, posso eseguire il codice chiamando direttamente myOnRelease(). Ovviamente, come mostrato negli esempi, occhio ai contesti. Nel primo caso il contesto di myOnRelease() è quello dell’oggetto madre dove è scritto, ad esempio _root. Nel secondo caso, invece, il contesto è sempre il MovieClip my_mc!

 

Forzare un diverso contesto

Concludiamo con un tricks utile in molte circostanze. Flash mette a disposizione una libreria, mx.utils, con un oggetto Delegate in grado di forzare un contesto di un metodo o funzione. Il suo uso è davvero semplice:

1
2
3
4
5
6
7
8
import mx.utils.Delegate;
//
var my_mc; // puntatore ad un MovieClip
var my_btn; // un bottone
function myFunction() {
    trace(this);
}
my_btn.onPress = Delegate.create(my_mc, myFunction);

L’evento onPress del bottone my_btn punta ad un “nuova” funzione creata appunto con il contesto my_mc. Quando si clicca sul bottone my_btn, il codice eseguito in myFunction() avrà come contesto my_mc!

Continua...

Gestione degli eventi: similitudini tra Flash e Javascript

Uno dei punti di forza di Adobe Flash risiede nella scelta di ECMAScript (sottoprodotti di ECMA – European Computer Manufacturers Association) come standard di scripting. ActionScript e Javascript, infatti, derivano entrambi da uno standard superiore che li rende estremamente simili. Questo è uno dei motivi per il quale molti programmatori ActionScript sviluppano con estrema semplicità anche in Javascript e viceversa.

ActionScript ha da sempre avuto una gestione “doppia” degli eventi che spesso ha confuso alcuni sviluppatori. Nei MovieClip, ad esempio, è possibile impostare un evento semplicemente dichiarando una funzione alla proprietà dell’evento stesso, ad esempio:

Metodo 1

1
2
3
mio_mc.onRelease = function() {
    trace("Click sul MovieClip");
}

Altri oggetti, diversamente, richiedono una gestione diversa dell’evento che si vuole monitorare, richiedendo il classico listener, un oggetto predisposto a tale compito. Ad esempio l’oggetto Mouse può essere controllato in questo modo:

Metodo 2

1
2
3
4
5
var mouseListener:Object = new Obejct();
mouseListener.onMouseMove = function() {
    trace("Mouse in moto");
}
Mouse.addListener(mouseListener);

I componenti possiedono un’ulteriore variante, come il componente Loader:

Metodo 3

1
2
3
4
5
var loaderListener:Object = new Object();
loaderListener.complete = function(evt:Object) {
    trace("Caricamento completato");
};
myLoader_ldr.addEventListener("complete", loaderListener);

Perchè queste differenze? La ragione, in verità, è molto semplice. Il metodo 1, quello più immediato, viene utilizzato quando l’evento da “intercettare” è unico nel suo genere, cioè quando non ha senso far “scattare” più funzioni una di seguito all’altra. I metodi 2 e 3, invece, creano delle “liste” di “ascoltatori” e sono estremamente utili e potenti in quanto consentono di agganciare virtualmente infinite funzioni ad un determinato evento.

La stessa identica cosa accade in Javascript e la si può ammirare in librerie come prototype. Il comodissimo metodo observe(), messo a disposizione dall’oggetto Event, permette di agganciare funzioni ad un evento di un oggetto. Ad esempio:

1
Event.observe(window, 'load', function() { alert("Finestra caricata"); } );

In questo caso abbiamo agganciato la nostra funzione che mostra un alert all’evento load dell’oggetto window. Potremmo tuttavia ripetere l’istruzione e agganciare un’ulteriore evento:

1
2
Event.observe(window, 'load', function() { alert("Finestra caricata - 1"); } );
Event.observe(window, 'load', function() { alert("Finestra caricata - 2"); } );

Questa caratteristica, comune anche in ActionScript, è estremamente versatile è, in particolare in Javascript, è stata la chiave per la realizzazione di moltissimi “Widgets” ed estensioni (vedi il classico Snap) che oggi proliferano nel Web. La possibilità di accodarsi, infatti, ad eventi già controllati da altre funzioni, permette di essere non intrusivi (Unobtrusive) e quindi, in pratica, di aggiungere funzioni a quelle già presenti.

Continua...

BlogBabel API: finalmente la beta

Aggiornamento: Blogbabel ha chiuso – tutti i servizi, widget e plugin non sono più attivi

Grazie alle segnalazioni di P|xel e Dat sono venuto a conoscenza delle nuove API messe a disposizione dal sito BlogBabel. Così ho rilasciato una nuova versione dell’antipixel di BlogBabel in Flash.

image

In questa nuova versione (chi ha installato la precedente versione in Flash non deve fare nulla, l’aggiornamento è automatico) sono sfruttate le nuove API messe a disposizione da BlogBabel. Il codice è meno invasivo e più veloce rispetto al precedente. Dal menu contestuale, inoltre, è possibile accedere a maggiori informazioni e il calcolo sulla "salita" o "discesa" (sfondo verde o rosso) è ora corretto essendo fornito dallo stesso sistema API di BlogBabel.

Ricordo che per usare l’antipixel basta essere registrati su BlogBabel e inserire le seguenti linee di codice nel vostro sito:

[html

Ultimi Commenti



Stop SOPA