Articoli con Tag ‘Sviluppo’
Flash CS3 ha davvero tante novità, tra cui quella “curiosa” di indicare al momento della compilazione alcuni consigli sulla scrittura del codice. Questo accade, ad esempio, quando abbiamo a che fare con gli oggetti TextField. Mi è capitato di dover aggiungere una stringa alla fine di un campo TextField, con la classica notazione:
1
| mioTextField_txt.text += "Stringa aggiunta"; |
Ma ecco che ActionScript 3.0, al momento di compilare il filmato, mi avverte (Warning) – o consiglia:
Warning: 3551: L’aggiunta di testo a un’istanza TextField mediante += è spesso un’operazione più lenta rispetto all’uso del metodo TextField.appendText().
Fantastico! Andiamo a vedere infatti la SYNOPSIS del metodo appendText() che effettivamente dice:
Aggiunge la stringa specificata dal parametro newText alla fine del testo del relativo campo. Questo metodo è più efficiente rispetto a un’assegnazione addizione (+=) applicata a una proprietà text (ad esempio <strong>someTextField.text += moreText</strong>), in particolare nel caso di un campo di testo con una quantità di contenuto significativa.
Ci fidiamo? Per sicurezza verifichiamo:
1
2
3
4
5
6
7
8
9
| import flash.utils.getTimer;
var i :uint= 0;
var s :int = getTimer();
for(i ; i < 10000;i ++) {
text_txt .text += "Ciao";
}
var f :int = getTimer();
trace(f -s ); |
Tempo: 9360 – sulla mia macchina, in debug mode. Proviamo allora come consigliato dal compilatore:
1
2
3
4
5
6
7
8
9
| import flash.utils.getTimer;
var i :uint= 0;
var s :int = getTimer();
for(i ; i < 10000;i ++) {
text_txt .appendText ("Ciao");
}
var f :int = getTimer();
trace(f -s ); |
Tempo: 8415 
Niente di eccezionale… tuttavia è vero! Il metodo appendText() è più rapido e performante dell’operatore pre-incrementale (+=). Come mai? Il motivo più ovvio è il seguente: l’operatore (+=) agisce su qualsiasi tipo di dato. Inoltre in un linguaggio OO questo operatore non è strutturato come nel semplice C ma è “oggettato”. In C++, ad esempio, è possibile sovrascrivere (override) tale operatore in quanto facente parte della struttura ad oggetti del linguaggio stesso. In definitiva appendText() è più rapido in quanto il suo obiettivo è quello di “appendere” una stringa e di conseguenza non si fa tante “domande” al suo interno. L’operatore (+=), invece, deve funzionare per qualsiasi tipo di dato e quindi non è ottimizzato per le stringhe. In C, al contrario, l’operatore (+=) è una funzione a basso livello e sarà sempre più rapida di una chiamata ad una funzione.
Continua...
ActionScript 3.0 introduce tutta una serie di formidabili strumenti di comunicazione, alcuni totalmente nuovi, altri rivisitati e migliorati rispetto alla precedente versione di ActionScript. Cominciamo a vedere come cambia il modo di interagire con un Web Server nel caso di una semplice comunicazione tra Flash e una pagina PHP con risposta in XML. Prima di tutto l’oggetto XML non esiste più! In ActionScript 3.0 sono stati introdotte nuove classi, alcune delle quali dedicate alla “retrocompatibilità”.
Nota: la classe XML (insieme alle classi correlate) di ActionScript 2.0 è stata rinominata XMLDocument e spostata nel pacchetto flash.xml. È inclusa in ActionScript 3.0 al fine di assicurare la compatibilità con le versioni precedenti.
In ActionScript 2.0 la comunicazione con un Web Server veniva spesso risolta sfruttando l’accoppiata degli oggetti LoadVars e XML, usando il metodo sendAndLoad() dell’oggetto LoadVars (vedi: Flash: LoadVars e XML per inviare dati in POST). Ora le cose cambiano, ma basta solo abituarsi ai nuovi nomi ed oggetti. Come indicato nel manuale, infatti:
Continua...
A causa della sua capacità di comunicare con il server, l’oggetto XmlHttpRequest (XHR), usato nella tecnologia Ajax (acronimo di Asynchronous JavaScript and XML, la cui pronuncia dovrebbe essere “egiacs” anche se noi italiani preferiamo “aiacs”), ha un blocco di protezione che gli impedisce di eseguire richieste esterne al dominio in cui opera. Questa protezione è necessaria per impedire Injection Javascript (tecniche di “iniezione” di codice estremamente pericoloso con lo scopo di violare il sistema) di svariato tipo, con l’obiettivo ultimo di “irrompere” nel sistema.
Questo limite è oggi tenuto in seria considerazione e si sta pensando, in qualche modo, di risolverlo – direttamente nell’oggetto XmlHttpRequest - senza pregiudicare la sicurezza (vedi anche: Third proposal for cross-site extensions to XMLHttpRequest ).
Comunque sia la situazione oggi è la seguente:
Continua...
Il sito Adobe.it si rinnova, si riveste cancellando l’ibrido Macromedia-Adobe realizzato subito dopo l’acquisizione della software house di Flash! Impaginazione orginale (a battuta a sinistra), uso di DHTML e Flash, ovviamente.
Tutte le sezioni sono state ridisegnate con un’originale uso dei background. Da rinavigare assolutamente!
Continua...
Alcuni lettori mi hanno chiesto come è stato creato il fiocco di neve, così realistico, del Widget natalizio. Chi ha scaricato il sorgente probabilmente già lo sa… comunque è stato davvero semplice. Prima di tutto ho selezionato lo Strumento Pennello in Flash ed ho disegnato un punto.
Ho trasformato questo in un simbolo ed ho applicato due effetti nella giusta sequenza: smussatura e sfocatura:
Il risultato è stato: 
A questo MovieClip (simbolo) ho associato una semplice classe CNeve, che crea di fatto l’intelligenza del fiocco stesso:
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
| class CNeve extends MovieClip {
private var _interval ;
private var _maxy :Number;
//
function CNeve () {
_interval = setInterval(this, "_move", 25);
_maxy = Math.round((Stage.height+256)/2)+_getRndRange (-20, -7);
}
//
private function _getRndRange (min:Number, max:Number):Number {
var randomNum :Number = Math.floor(Math.random()*(max -min+1))+min;
return randomNum ;
}
//
private function _move () {
_y += _getRndRange (1, 5);
_x += ((_getRndRange (-50, 50))>0) ? 1 : -1;
_rotation += _getRndRange (1, 5);
if (_y >_maxy ) {
clearInterval(_interval );
}
updateAfterEvent();
}
} |
Il metodo _move() contiene l’intelligenza del fiocco, ovvero la funzione di caduta, estremamente semplice. Variando la funzione randomica _x += ((_getRndRange(-50, 50))>0) ? 1 : -1;, ad esempio inserendo un _getRndRange(-550, 50), si può aggiungere un effetto effetto vento, cioè i fiocchi cadono con una pendenza particolare. In particolare si possono mandare i fiocchi a destra e a sinistra usando un codice di questo tipo:
1
| _x += ((_getRndRange( _getRndRange(-350, -50), _getRndRange(50, 350) ))>0) ? 1 : -1; |
La rotazione (_rotation += _getRndRange(1, 5);), poi, conferisce un ulteriore dettaglio al fiocco stesso.
Quando creo un fiocco (vedi funzione creaFiocco() più sotto) ho aggiunto anche un alpha=90 e uno scale randomico, per avere fiocchi di neve di diverse dimensioni.
1
2
3
4
5
6
7
8
9
10
11
12
| // crea fiocco
function creaFiocco () {
var s = randRange (20, 100);
var x = randRange (-Math.floor((Stage.width - 320) / 2), Math.round((Stage.width + 320) / 2));
var y = -Math.floor(((Stage.height - 256) / 2)) - 10;
c_mc .attachMovie ("neve","neve_" + index,index,{_x :x, _y :y, _xscale :s , _yscale :s , _alpha :90});
index++;
if (index > 1000) {
index = 1;
c_mc = createEmptyMovieClip ("c_mc", 2);
}
} |
E questo è tutto… Dimenticavo… Auguri a tutti e Buone feste…
Continua...
Oggi propongo un’interessante variante del “classico” orologio analogico in Flash. Questa versione contiene una transizione Tween all’avvio del filmato. Mi sono ispirato al Gadget presente in Windows Vista che esegue, appunto, questo bel effetto all’avvio.
Il codice è scritto in Actionscript 2.0 ed è stato compilato con il nuovo Adobe Flash CS3. Questo a dimostrazione che la nuova suite CS3 è pienamente compatibile con le precedenti versioni di Flash, un punto estremamente importante per chi ha deciso di prendere in considerazione l’aggiornamento del prodotto.
Per il sorgente cliccate qui.
Continua...
Grazie allo “sprono” di TV Revolution ho realizzato un piccolo Widget natalizio (vediamo se riusciamo a migliorarlo con i vostri commenti).
Per usarlo basta inserire il seguente codice sul vostro sito:
1
| <script language="javascript1.2" type="text/javascript" src="http://www.undolog.com/services/snow.php?h=100"></script> |
Il parametro h determina l’altezza in pixel del filmato. Di default questo viene mostrato in posizione assoluto e largo al 100%. Per modificare queste impostazione usate abs=0 per posizionare la neve all’interno delle pagina e non sopra. Usate invece w=800 per impostare una dimensione personale. Ad esempio:
1
| <script language="javascript1.2" type="text/javascript" src="http://www.undolog.com/services/snow.php?h=50&abs=0&w=640"></script> |
Crea la neve alta 50 pixel, in posizione relativa e larga 640 pixel, come mostrato qui sotto:
Continua...
Sembra ovvio, ma ad alcuni sfugge la sottile differenza tra costanti e variabili in un linguaggio di programmazione. Le costanti, dal nome stesso, non cambiano il loro valore durante il ciclo di un programma, mentre le variabili possono farlo! Tuttavia, spesso, capita di usare variabili al posto di costanti senza rendersene conto, anche perchè questo non impatta la logica di una applicazione. Nonostante questo, la differenza tra costanti e variabili c’è ed emerge tutta nel momento della compilazione, dove la costante gioca un ruole sicuramente più performante.
Chi viene dalla programmazione Assembly o C conosce bene la differenza tra costanti e variabili, soprattutto perchè, sia in Assembly che in C, le costanti rivestono un ruolo più da MACRO. Per MACRO indendo una “parte di codice” che viene etichettata e sostituita all’interno del codice nel momento della compilazione. Il compilatore, per farla breve, esegue una sorta di find..replace (trova e sostituitsci) nel codice ogni volta che incontra una costante.
Immaginiamo di scrivere in C la seguente semplice porzione di codice:
1
2
3
4
| int a = 5;
int b = 3;
int c;
c = a + b; |
Sia a che b sono indicate come variabili in questo caso. In C, infatti, le costanti si definiscono con la keyword #define. Notiamo subito che sia a che b sono state definite come int. Già qui si può operare una prima ottimizzazione. Se sappiamo che la nostra variabile a non supererà mai un determinato valore, è bene dichiararla in modo appropriato e non usare tipi dati a caso. Alcuni sviluppatori non si preoccupano affatto di dichiarare correttamente i tipi, pensando che questo non influisca sulle performace! Sbagliato! In alternativa è accettabile che la prima stesura del codice non implichi questo livello di dettaglio. È comunque buona regola, durante il processo di sviluppo, rivedere il codice e verificare i tipi dati.
Comunque sia, in un Assembly della famiglia Motorola, ad esempio, come il mitico 68000, il nostro codice verebbe compilato (senza ottimizzazioni) in una specie di:
1
2
3
4
| move.l #5, d0 ; int a
move.l #3, d1 ; int b
move.l d1,d2 ; int c - foo
add.l d0,d2 ; risultato in d2 ovvero c |
oppure:
1
2
3
| move.l #5, d0 ; int a
move.l #3, d1 ; int b
move.l d0,d1 ; risultato in d1... |
Il compilatore, per quanto intelligente, fatica nelle ottimizzazioni, quindi scrivere il codice con le giuste keyword può solo aiutarlo a migliorare l’output compilato. Nel nostro caso se il valore 5 è una costante non è conveniente usare una variabile intera, in quanto il compilatore, giustamente, considerando la variabile variabile, appunto, predisponde un intero per contenere il semplice valore di 5; che in binario è 101, cioè occupa 3 semplici bit (caso mai int è un 32bit o peggio un 53bit a doppia precisione a virgola mobile!!). Se avessimo scritto il codice in questo modo:
1
2
3
4
5
| #define MIA_COSTANTE 5
int b = 3;
int c;
c = MIA_COSTANTE + b; |
Il compilatore avrebbe saputo sin dall’inizio che MIA_COSTANTE, essendo costante, non muterà valore e quindi posso riservare meno spazio per trattarla. Nella pratica il codice Assembly diverebbe:
1
2
3
| moveq #3, d0 ; la "q" indica una istruzione "quick", cioè che tratta valori compresi tra -128 e +127
; una istruzione "quick" prende meno tempo della CPU (4 cicli di clock in questo caso)
addq #5,d0 ; anche qui uso una istruzione "quick" |
Quest’ultimo codice è estremamente più rapido e occupa meno byte. Quello che bisogna tenere a mente è che quando si dichiara una variabile l’ambiente si predispone per trattarla come tale, anche se i compilatori di oggi riescono a fare miracoli, eseguendo una serie di passaggi nel codice prima di compilare (alcuni compilatori, addirittura, eseguono una specie di simulazione del programma per ottimizzare al massimo la compilazione in codice macchina).
Una buona regola, quindi, è quella di dichiarare il giusto tipo per le nostre variabili, se tali sono. In alternativa usare le costanti, soprattutto se il linguaggio di programmazione che stiamo usando le prevede (come nel caso del nuovo Flash CS3).
Continua...
Per alcuni sviluppatori basta sapere che esiste una nuova versione del loro pacchetto di sviluppo preferito per correre ad acquistare l’aggiornamento. Altri, e non a torto, mantengono una maggiore calma e "pretendono" di conoscere gli effettivi miglioramente della nuova versione prima di modificare le proprie abitudini. Nel caso di Adobe Flash CS3 non c’è molto da attendere, visto gli innumerevoli cambiamenti che ha subito il pacchetto da quando Macromedia è stata acquisita da Adobe.
Ecco, quindi, 10 semplici, ma importanti, motivi che, a mio personale parere, bastano per convincersi ad eseguire l’aggiornamento ad Adobe Flash CS3. Mi soffermerò, ovviamente, solo sulle caratteristiche che mi hanno colpito personalmente; questo non vuole essere un elenco esaustivo di tutte le numerose novità introdotte con la suite CS3, solo un volo radente per anticipare qualche features della versione CS3.
1. Installazione
L’installazione è gradevole e rapida, rispetto alle precedenti versioni. Si integra, tra l’altro, con tutti i prodotti Adobe (Dreamweaver CS3, Photoshop CS3 extended, ecc…) il che rende le operazioni di installazione/rimozione ed aggiornamento un vero piacere.
2. Compatibilità a ritroso
Una questione spesso sottovalutata, ma sempre tenuta in considerazione nella storia di Flash: la possibilità di gestire le precedenti versioni del prodotto. In Flash CS3 ci sono tutti gli strumenti sia per migrare che per manipolare le precedenti versioni dei nostri filmati. Troviamo questa possibilità sia nel debug (un debug separato per Actionscript 2.0 e Actionscript 3.0) sia in fase di compilazione del filmato. Scrivere da subito applicazioni Flash in Actionscript 3.0 potrebbe essere controproducente in determinati contesti. Se il vostro sito target ha un traffico notevole potrebbe capitare che molti utenti non hanno ancora installato le ultime versioni del Player Flash per il browser e quindi non vedrebbero il filmato. Tuttavia, come già detto, Flash CS3 permette di sviluppare applicazioni Flash mantendedo la compatibilità a ritroso e quindi non vedo in questo un grosso ostocalo nell’upgrade del prodotto.
3. Interfaccia grafica e IDE
L’IDE di Flash CS3 (come quella di Dreamweaver CS3) è stata rivisitata al meglio. I pannelli (vedi figura qui a sinistra), spesso scomodi nelle precedenti versioni, sono stati completamente ridisegnati e adesso il loro uso è notevolemente meno invasivo. 
Inoltre la possibilità di ridurre ad icona i pannelli (vedi figura qui a destra) è una vera trovata che rende l’interfaccia gradevole e funzionale. Quando un pannello si trova in modalità icona occupa molto meno spazio e con un semplice click è possibile aprire il pannello principale prima sempre visibile.
Tutta l’IDE, insomma, è stata rivista compresa la zona centrale con la finestra per l’editing grafico e del codice. Non vi segnalo tutti i cambiamenti altrimenti vi rovinerei la sorpresa…
Continua...
Come si disabilità un TextField in modalità input? Visto che la proprietà enabled non è disponibile si può ricorrere ad un semplice artifizio: cambiare runtime lo stato del TextField. Fortunatamente gli sviluppatori di Flash hanno permesso di modificare lo stato di un TextField anche runtime, tramite la proprietà type. Ne deriva che se un TextField è inserito nello stage come input (quindi con type="input"), da codice possiamo trasformarlo in un testo “statico”. In realtà lo trasformeremo in testo dinamico (type="dynamic") ma il risultato visivo è il medesimo. L’artifizio funziona in quanto sia il TextField input che il TextField dinamico condividono la stessa proprietà text. Così se ho inserito un testo in un TextField input quando lo trasformo in un TextField dinamico avrò solo l’impressione di non poter più inserire caratteri! Ovvero ho disabilitato il TextField input!
L’oggetto TextField, inoltre, può essere esteso come un MovieClip, quindi potremmo avvalerci del seguente utile codice:
1
2
3
| TextField.prototype.Enabled = function(v :Boolean) {
this.type = v ? "input" : "dynamic";
}; |
Continua...
Ultimi Commenti
Giovambattista Fazioli: @Nik: Sono contento! In bocca al lupo dunque!!
Nik: Lunedì ho l’esame di informatica su java, grazie mi sei stato utilissimo, il libro che ho era poco chiaro...
Marco: Ti ringrazio moltissimo, mi hai illuminato
ho risolto impostando [cc_objc] //OptionViewController.m -...
Giovambattista Fazioli: @Marco: Ti consiglio un approccio credo più corretto. Se hai eseguito il subclass del tab...
luigi: molto chiaro e semplice devo ammettere che anche scrivendo da un pà difficilmente uso delegati creati da...