Usare la pogrammazione orientata agli oggetti

Mi è stato chiesto se Livecode è un linguaggio di programmazione orientato agli oggetti, la risposta è si.
Credo che possa essere visto come il linguaggio più orientato agli oggetti che esista al mondo. Non è possibile scrivere del codice se non si crea un oggetto dove metterlo dentro.
La programmazione orientata ad oggetti è una moda molto in voga ultimamente, ma chi ne parla raramente sa quanto renda molto più complicata la programmazione nella maggior parte dei linguaggi di programmazione.
Oggi andremo con ordine e vedremo cosa è la programmazione ad oggetti e come implementarla in maniera rigorosa in Livecode. Premetto che l'utente medio, grazie a Livecode, programma ad oggetti in maniera veloce senza accorgersene.
La programmazione ad oggetti richiede una classe cioè un modello da cui derivare delle copie da personalizzare. Le copie sono chiamate oggetti.
Come esempio creiamo un pulsante, il pulsante sarà la nostra classe. Tutte le copie del pulsante saranno gli oggetti.

Torniamo al nostro pulsante, la programmazione ad oggetti impone che dobbiamo fornire degli attributi e dei metodi. Gli attributi sono delle variabili che contengo valori, e in livecode basta aggiungere del proprietà personalizzate al pulsante (custom properties). Aggiungiamo tre attributi: attributo1, attributo2 e controllo;  a quest'ultimo diamo il valore false.

I metodi sono le funzioni per interagire con i dati della classe. Essi li possiamo avere con SetProp, GetProp, e i classici messaggi degli oggetti. La programmazione ad oggetti impone che i dati non siano visibili e modificabili direttamente, ma che bisogna passare attraverso i metodi; questa regola è detta incapsulamento.
Facciamo che il nostro oggetto sia un totalizzatore. Creiamo un metodo che metta nell'attributo1  il numero di volte che è stato usato l'oggetto, mentre nell'attributo2 sommi ogni volta un numero a quelli precedenti. La proprietà controllo ci servirà ad evitare di poter modificare gli attributi direttamente. Ecco il codice del pulsante:

setprop attributo1 nuovoValore
   if the controllo of me then
      set the attributo1 of me to nuovoValore
   else
      answer "Per la legge dell'incapsulamento, non puoi impostare il valore direttamente"
   end if
end attributo1

setprop attributo2 nuovoValore
   if the controllo of me then
      set the attributo2 of me to nuovoValore
   else
      answer "Per la legge dell'incapsulamento, non puoi impostare il valore direttamente"
   end if
end attributo2


getprop attributo1
   if the controllo of me then
      return (the attributo1 of me)
   else
      answer "Per la legge dell'incapsulamento, non puoi leggere il valore direttamente"
   end if
end attributo1

getprop attributo2
   if the controllo of me then
      return (the attributo2 of me)
   else
      answer "Per la legge dell'incapsulamento, non puoi leggere il valore direttamente"
   end if
end attributo2


on somma numero
   set the controllo of me to true
   put the attributo1 of me into cont
   add 1 to cont
   set the attributo1 of me to cont
   put the attributo2 of me into totale
   put totale + numero into totale
   set the attributo2 of me to totale
   set the controllo of me to false
   answer "Hai usato questo messaggio " & cont & " volte. Il totale dei numeri che hai fornito fin'ora è " & totale
end somma

Quindi lanciando somma 3 otteniamo:

Un'altra proprietà della programmazione ad oggetti è l'ereditarietà, cioè gli oggetti copiato portano dietro tutti i dati e le funzioni dell'oggetto padre e in più si possono aggiungere altre funzioni, metodi e attributi. Tutte queste cose in Livecode avvengono con un semplice copia e incolla.
Come vedete, volendo Livecode supporta tutte le proprietà dei linguaggi ad ad oggetti. Liveocde è un linguaggio di altissimo livello, chiamato anche il sacro Graal della programmazione, quindi forzarsi ad usare la programmazione ad oggetti è solo un passo indietro invece che uno in avanti.
La letteratura in informatica è piena di esempi che mostrano come la programmazione a oggetti porti più svantaggi che vantaggi, ed è di qualche utilità solo per linguaggi di basso livello.
Se comunque siete dei patiti della programmazione ad oggetti, esiste una libreria specifica per usare tutta una serie di comandi come se stesse programmando ad oggetti in C: http://www.exformedia.se/downloads/oopengine/

Grafici a torta

I grafici a torta sono tipici per esprimere la percentuale dei dati sul totale, e con Livecode è un gioco da ragazzi crearli e modificarli.
Creiamo uno stack con quattro campi di testo, un pulsante e quattro cerchi colorati; ogni cerchio deve avere un colore diverso, ovviamente impostate opaque su true per i cerchi.. Impostate la proprietà rect uguale per tutti i cerchi, in modo da farli coincidere in forma e posizione.  Il nostro obbiettivo è questo:

Le proprietà da modificare di volta in volta saranno startAngle e arcAngle dei cerchi.
Mettete nel pulsante il seguente codice:

on mouseUp
   closefield
end mouseUp

on closefield
   #metodo veloce di fare le somme del contenuto dei campi
   put (field 1) + (field 2) + (field 3) + (field 4) into somma
   #calcoliamo la percentuale di ciascun valore
   put (field 1) / somma into perc1
   put (field 2) / somma into perc2
   put (field 3) / somma into perc3
   put (field 4) / somma into perc4
   #ridimensioniamo gli spicchi
   set the arcangle of graphic 1 to (360 * perc1)
   set the startangle of graphic 2 to (360 * perc1)
   set the arcangle of graphic 2 to (360 * perc2)
   set the startangle of graphic 3 to (360 * perc1) + (360 * perc2)
   set the arcangle of graphic 3 to (360 * perc3)
   set the startangle of graphic 4 to (360 * perc1) + (360 * perc2) + (360 * perc3)
   set the arcangle of graphic 4 to (360 * perc4)
end closefield

e impostate il behavior dei campi a quelle del pulsante. In questo modo cambiando i valori nei campi (o premendo il pulsante), il grafico si aggiornerà da solo.
Come vedete l'angolo iniziale (startAngle) di uno spicchio deve coincidere son l'angolo finale (arcAngle) del precedente.
Per chi non lo sapesse, il behavior è una proprietà che impone ad un oggetto di eseguire il codice in un altro oggetto. Nel nostro esempio ci ha risparmiato di scrivere quattro volte lo stesso codice. Per impostarlo bisogna fornire il long ID del pulsante. Nel mio caso è: button id 1015 of stack "Untitled 1".

Gioco Drops

Oggi presentiamo un giochino fatto con Livecode: Drops.

Questo gioco è disponibile per Windows, Linux e Mac.
L'obbiettivo è di cancellare più colori possibili, i colori si cancellano cliccandoci solo se sono adiacenti ad almeno uno dello stesso tipo (orizzontalmente o verticalmente).
All'inizio i colori sono solo tre, ma pian piano aumentano, rendendo il gioco sempre più complicato.
Ogni tanto appaiono richieste bonus, tipo cliccare 30 colori in 30 secondi, e altre sfide.
Potete inviare i vostri punteggi al sito per confrontarli con gli altri giocatori intorno al mondo.
E' possibile scaricare dal sito la versione gratuita, oppure acquistare quella a pagamento ad appena $ 12.95.

Inviare dati via POST o GET

Le pagine web accettano i dati, usualmente, attraverso i metodi POST o GET. Vediamo come implementarli in Livecode.

Differenza fra GET e POST

Il metodo GET è il più semplice, basta aggiungere all'indirizzo della pagina i dati preceduti da un punto di domanda. Proviamo ad inviare i dati di Mario Rossi, cioè nome=Mario e cognome=Rossi.
Tutti i dati debbono essere incorporati in un'unica stringa di testo, e separati dal carattere &. Per una corretta formattazione, mettiamo tutti i dati in pasto alla funzione URLEncode(), che trasforma i caratteri non accettati per gli indirizzi web nelle loro controparti accettate. Infine basta il comando put per inviare i dati. Esempio:

put URLEncode("nome=Mario&cognome=Rossi") into dati
put URL ("http://www.sitotest.it/demo.php?" & dati) into risultato

Facciamo lo stesso esempio, ma usando il metodo POST, in questo caso basta usare il comando post:

put URLEncode("nome=Mario&cognome=Rossi") into dati
post dati to URL "http://www.sitotest.it/demo.php"
put it into risultato

Come vedete, in entrambi i casi, i dati che riceviamo dalla pagina, dopo avergli inviati i nostri, sono memorizzati nella variabile risultato. In questo modo il nostro programma può colloquiare in maniera bidirezionale con server, utilizzando i due protocolli più utilizzati al mondo.

Trasformare un'immagine in bianco e nero

Le immagini che usiamo, di solito, sono a colori. Tuttavia ci potrebbe interessare trasformarle in bianco e nero; ad esempio per dare un effetto di antico ad una foto.
Le foto che chiamiamo in bianco e nero, in realtà sono composte da diverse gradazione di grigio: cioè tutte le sfumature che vanno dal bianco fino al nero. In gergo informatico di dice in scala di grigi. In effetti i computer potrebbero creare un'immagine che usi solo il bianco e nero, ma perderemmo molti dettagli.
Ecco un esempio che mostra la stessa immagine con i tre diverse impostazioni:

Oggi vedremo come ottenere un'immagine in scala di grigi.
Prima di proseguire è meglio rinfrescare la teoria delle immagini in informatica. Ogni immagine è composta da puntini colorati, chiamati pixel. Ogni pixel è di un colore, ma questo colore si esprime attraverso quattro valori:

1. quantità di trasparenza
2. quantità di rosso
3. quantità di verde
4. quantità di blu

Le ultime tre sono semplici da capire,ogni colore si può ottenere mescolando opportune quantità di rosso, verde e blu. Il primo valore si usa solo in informatica, dove un'immagine può avere delle parti trasparenti o semi trasparenti. I valori delle quantità di solito variano da 0 a 255.
Per ottenere una sfumatura di grigio basta dare lo stesso valore ai tre colori fondamentali rosso, verde e blu. Il problema è: come calcolare questo valore?
Non esiste una regola scientifica per farlo, siccome è una trasformazione artificiale che noi imponiamo, sta a noi decidere il risultato che vogliamo ottenere.
Le tre modalità più utilizzate sono:

• lucentezza
• media
• luminosità

Il metodo della lucentezza fa la media tra il massimo e il minimo dei valori dei colori fondamentali
Il metodo della media fa la somma dei valori dei colori fondamentali e li divide per 3.
Il metodo della luminosità usa una formula particolare: 0.3 * rosso + 0.59 * verde + 0.11 blu.
Oggi vedremo tutti e tre i casi.
Creiamo uno stack con due immagini uguali, che chiameremo rispettivamente partenza e arrivo. Poi mettiamo un menu a tendina con le tre possibili trasformazioni (che chiameremo tipo), un pulsante per eseguire la trasformazione e una scrollbar di tipo progress bar che ci mostrerà a che punto è l'elaborazione. In questo modo abbiamo fatto metà del programma senza scrivere una riga di codice, ottenendo un risultato simile a questo:

Livecode può fornire l'imageData cioè una serie di lettere, dove ognuna rappresenta una dei 4 valori di ciascun pixel. Con le funzioni charToNum() e numToChar() possiamo trasformare le lettere in valori e viceversa.
In rete si trovano molti esempi di codice per trasformare le immagini con Livecode, ma sono quasi tutti troppo lenti; il codice ottimizzato per la velocità sulle immagini è il seguente:

on mouseUp
   #memorizziamo i dati dell'immagine
   put the imageData of image "partenza" into tImage
   put the number of chars of tImage into totChars
   #contatore delle lettere   
   put 0 into cont   
   repeat for each char tChar in tImage
      add 1 to cont
      put cont mod 4 into cont2
      #cerchiamo di capire che valore sia (trasp., rosso , verde , Blu)
      switch cont2
         case 1 #trasparenza
            put tChar after tImage2
            break
         case 2 #rosso
            put chartonum(tChar) into rosso
            break
         case 3 #verde
            put chartonum(tChar) into verde
            break
         case 0 #blu
            put chartonum(tChar) into blu
            #qui cambiamo formula a seconda del tipo di trasformazione che preferiamo
            switch (the label of button "tipo")
               case "lucentezza"
                  put ( max(rosso, verde, blu) + min(rosso, verde, blu) ) / 2 into tGray
                  break
               case "media"
                  put (rosso + verde + blu) / 3 into tGray   
                  break
               case "luminosità"
                  put (0.3 * rosso + 0.59 * verde + 0.11 * blu) into tGray   
                  break
            end switch
            put numToChar(tGray) after tImage2
            put numToChar(tGray) after tImage2
            put numToChar(tGray) after tImage2
            break
      end switch            
      #qui ogni 1000 pixel aggiorniamo la barra dell'elaborazione
      if (cont mod 4000) = 0 then               
         set the thumbpos of scrollbar "elaborazione" to round(cont/totChars * 100 )
      end if
   end repeat            
   # impostiamo i dati per la nuoca immagine
   set the imageData of image "arrivo" to tImage2   
end mouseUp



Così possiamo vedere i risultati:

Foto e immagini con Adroid e iOS

Se vogliamo scattare una foto, oppure prendere una foto dal nostro cellulare o tablet, Livecode mette a disposizione il comando mobilePickPhoto. Vediamo come funziona.
Questo comando si aspetta da uno o tre parametri.
Il primo può essere uno dei seguenti:

• library:  scegli una foto dal cellulare (su iOS libray e album sono due cartelle diverse)
• album: scegli una foto dal cellulare  (su iOS libray e album sono due cartelle diverse)
• camera: scatta una foto
• rear camera: scatta una foto (su iOS solo utilizzando la fotocamera posteriore)
• front camera: scatta una foto (su iOS solo utilizzando la fotocamera anteriore)

Gli altri due servono per impostare le dimensioni della foto, ma solo su iOS.
Una volta utilizzato mobilePickPhoto, nella card corrente viene creata un'immagine come quella scelta o scattata.

Ma attenzione che dopo che è stata creata, non potete fare nulla nel messaggio corrente. Tutte le modifiche alla foto vanno fatte prima, applicandole al modello generico per le nuove immagini: templateImage.
Ad esempio un buon codice per scattare una foto è:

on mouseUp
    set the lockloc of the templateimage to true
    set the width of the templateimage to "300"
    set the height of the templateimage to "400"
    set the left of the templateimage to "10"
    set the top of the templateimage to "10"
    mobilePickPhoto "camera"
    if the result is empty then
       answer "Foto annullata"
    end if
end mouseUp

Con le fotocamere ad alta risoluzione di oggi, se non modificate il templateImage, vi ritroverete un'immagine enorme, più grande del cellulare stesso.

Accendere un led con raspberry PI

Visto che siamo vicini al natale, la schedina raspberri può essere utilizzata anche per accendere e spegnere delle lucine LED e creare simpatici effetti.

Esempio con un LED

La scheda raspberry mette a disposizione ben 17 pin digitali che possiamo attivare (ON) o disattivare (OFF) e perfino leggere il valore della corrente che gli arriva; questi particolari sono chiamati GPIO (General Purpose Input Output).
Quelli qui sotto in giallo sono i pin GPIO:

Nel nostro caso basterà solo attivarli e disattivarli.
Prima vediamo i comandi Linux necessari, e poi vediamo come inserirli in Livecode.
In Lunx i comandi da dare da terminale sarebbero i seguenti:
per attivare il ventitreesimo pin bisogna prima creare il sistema di cartelle dentro la cartella /sys, con:

echo 23 > /sys/class/gpio/export

In questo modo Linux in automaticamente crea un sistema di cartelle in /sys/class/gpio/gpio23/ poi dobbiamo dire a Linux che vogliamo impostare l'uscita, cioè il pin deve essere di tipo out con questo comando:

echo out > /sys/class/gpio/gpio23/direction

Ora per impostare l'uscita come acceso bisogna impostare il valore 1, mentre per spegnerlo basta impostare il valore 0 nel file value, ecco il codice per imporre il valore:

echo 1 > /sys/class/gpio/gpio23/value

Per far fare questi comandi a Livecode basta usare la funzione shell():

put shell("echo 23 > /sys/class/gpio/export") into risultato
put shell("echo out > /sys/class/gpio/gpio23/direction") into risultato
put shell("echo 1 > /sys/class/gpio/gpio23/value") into risultato

la variabile risultato conterrà di volta in volta eventuali messaggi di Lunux in risposta ai nostri comandi.
Per spegnere il LED il codice è:

put shell("echo 0 > /sys/class/gpio/gpio23/value") into risultato

mentre se non ci serve più il PIN 23, possiamo liberarlo con questo comando:

put shell("echo 23 > /sys/class/gpio/unexport") into risultato

Ricordate che quando un pin è acceso fornisce 3.3V, quindi fatevi bene i calcoli per LED e resitenza da mettere in serie:

Esempio di schema di montaggio LED e resistenza.

Buon divertimento!

Ora e data

Vediamo oggi come lavorare con ora e data. Cominciamo dai formati disponibili:

• short date: 12/16/14  (viene messo prima il mese, poi il giorno, poi l'anno; come in USA)
• abbreviated date: Tue, Dec 16, 2014
• long date: Tuesday, December 16, 20140
• short time: 11:56 AM   (AM è del mattino, PM è del pomeriggio)
• abbreviated time: 11:56 AM
• long time: 12:03:35 PM
• internet date:  Tue, 16 Dec 2014 12:03:57 +0100
• seconds:  1418727859  (sarebbe il numero di secondi a partire dal 1 Gennaio 1970)
• dateItems:  2014,12,16,0,0,0,3 (questo lo spiego più sotto)
• system date: 16/12/2014  (questo dipende dal computer, In Italia prima il giorno, poi il mese e poi l'anno)

Per fare calcoli con le ore o le date si può passare attraverso seconds o attraverso dateItems.
Usare seconds è la vecchia e scomoda tecnica che usano anche altri linguaggi, cioè si trasforma l'ora o la data in secondi a partire dal 1 Gennaio 1970 e si aggiungono i secondi, si aggiungono o sottraggono i secondi e poi si riconverte il tutto. Ad esempio per aggiungere 3 ore e 5 minuti all'ora corrente il codice è:


put the time into temp #temp ora vale "1:58 PM"
convert temp to seconds #temp ora vale 1418734680   
add (3*60*60 + 5*60 ) to temp #aggiungiamo 3 ore e 5 minuti
convert temp to time #temp ora vale "5:03 PM"
answer temp   



Come vedete è complicato e poco chiaro, perchè bisogna moltiplicare ore, minuti, giorni, mesi e anni per i numeri opportuni in modo da trasformali in secondi.
Per fortuna c'è un modo più semplice, usare dateItems. Il formato dateItems è composto da una serie di valori separato da virgole secondo questo ordine:

1. anno
2. mese
3. giorno
4. ora
5. minuti
6. secondi
7. giorno della settimana (un numero da 1, domenica, a 7, sabato)

Quindi se vogliamo aggiungere 3 ore e 5 minuti all'ora corrente basta scrivere:


put the time into temp #temp ora vale "1:58 PM"
convert temp to dateitems #temp ora vale "2014,12,16,13,58,0,3"
add 3 to item 4 of temp #aggiungiamo 3 ore
add 5 to item 5 of temp #aggiungiamo 5 minuti
convert temp to time #temp ora vale "5:03 PM"
answer temp   



Lo stesso identico discorso lo potete fare con giorni, mesi e anni. Potete aggiungere o sottrarre valori senza problemi convert si occupa di ricalcolare tutto in maniera corretta.

SQLite: controllare l'esistenza di una colonna

SQLite è un database che presenta molti vantaggi: portabile, non necessita di un server, basato su un solo file, piccolo e potente. L'altro lato della medaglia, al momento, è che gli mancano delle funzioni sofisticate sull'analisi e la modifica: ad esempio per sapere se esiste una colonna in una tabella, non c'è un metodo diretto.
SQLite mette a disposizione solamente il comando PRAGMA table_info(table-name). Questo comando restituisce una tabella come la seguente:

cid	name	type	notnull	dflt value	pk
0	prima colonna	TEXT	0		0
1	seconda colonna	TEXT	0		0

i nomi della tabella sono quelli della colonna name. Se ad esempio volessimo veirificare l'esitenza della colonna musiche nella tabella miatabella, sfruttando livecode possiamo scrivere il seguente codice atto alla verifica dell'esistenza di una colonna.:

put "PRAGMA table_info(miatabella);" into tSQL
put revDataFromQuery(comma,return,connID,tSQL) into tRecords
if "musiche" is not among the items of tRecords then   
   answer "La colonna musiche non esiste"
else
   answer "Colonna musiche trovata"
end if

Creare un elaboratore di testi

Siete stufi di Word, OpenOffice, LibreOffice e volete farvi il vostro programma per testi personalizzato? Ecco come fare in 5 minuti con Livecode.
Create uno stack come il seguente:

Nei pulsanti mettiamo il seguente codice:

on mouseUp
   set the textstyle of the selectedchunk to "plain"
end mouseUp

Questo significa che il testo selezionato deve tornare normale (plain). Cambiamo plain con:

• bold (grassetto)
• italic (corsivo)
• underline (sottolineato)
• strikeout (barrato)
• box (inscatalato)

nei relativi pulsanti e avremo ottenuto un modo per  cambiare lo stile alla parte di testo evidenziata. Volendo si potrebbero mescolare insieme i valori separandoli da virgola, ma per ora lasciamo così.
Ora chiamiamo il pulsante di scelta vicino a font Fonts e mettiamo il seguente codice nella card:

on Opencard
   put the fontnames into temp
   sort temp
   set the text of button "Fonts" to temp
end Opencard

In questo modo mettiamo tutti i font disponibili (fontnames) in ordine alfabetico nel pulsante di scelta dei font.
Poi inseriamo il seguente codice nel pulsante Fonts:

on menuPick pItemName   
   set the textfont of the selectedchunk to pItemName   
end menuPick

In questo modo possiamo anche cambiare il font.
Poi inseriamo i numeri delle grandezze dei font che preferiamo nell'ultimo pulsante rimasto e inseriamogli il seguente codice:

on menuPick pItemName   
   set the textsize of the selectedchunk to pItemName   
end menuPick

Come vedete ora possiamo anche cambiare l'altezza del font. Semplice, no?
Lascio a voi il compito di scrivere il codice per cambiare i colori. :-)

Creare uno screensaver per Windows

Gli screensaver (salvaschermo) sono programmi che si avviano quando l'utente non fa più nulla sullo schermo per un lungo periodo. Erano nati con i televisori a tubo catodico che si rovinavano con le immagini ferme.
Windows utilizza come salvaschermo i file .SCR, i quali non sono altro che dei normali programmi .EXE rinominati.
Livecode è lo strumento più adatto per creare un programma del genere.
Prima di tutto creiamo lo stack principale che useremo solo quando programmiamo con Livecode, del tipo:

e mettiamo le pulsante Impostazioni un semplice:

on mouseUp
   go to stack "impostazioni"
end mouseUp



mentre per il pulsante Avvia salvaschermo mettiamo il seguente codice:

on mouseUp
   set the stato of card 1 of stack "salvaschermo" to "test"
   go to stack "salvaschermo"
end mouseUp




Creiamo un sotto stack per le impostazioni, al momento il nostro salvaschermo è talmente semplice che non servirebbe, ma così in futuro possiamo aggiungere al salvaschermo tutte le opzioni che vogliamo.

Ora creiamo un sotto-stack che rappresenterà il salvaschermo e lo chiameremo salvaschermo. Facciamolo con lo schermo nero e con l'ora e la data che fluttuano a caso per lo schermo, quindi ci basterà fare il fondo nero dello stack, mettere un campo di testo e mettere un messaggio ciclico da chiamare, ad esempio ciclos:

on opencard
   put the screenrect into schermo
   put item 3 of schermo into tx
   put item 4 of schermo into ty
   switch the stato of me
      case "test"
         put round(tx / 2) into tx
         put round(ty / 2) into ty
         set the rect of this stack to 0,0,tx,ty
         break
      case "preview"
         set the rect of this stack to (0,0,tx / 10,ty / 10)
         set the loc of this stack to tx/2,ty/2
         break
      default
         set the rect of this stack to the screenrect
   end switch   
   ciclos
end opencard

on ciclos
   set the text of field 1 to ( (the long system time) & " - " & (the long system date))
   set the width of field 1 to (the formattedwidth of field 1)
   set the foregroundcolor of field 1 to (random(255),random(255),random(255))
   put the width of me into tx
   put the height of me into ty
   move field 1 to (random(tx),random(ty)) without waiting
   send ciclos to me in 1 sec
end ciclos

on mouseDown
   if the stato of me is not "test" then    cancellatutto
end mouseDown

on mouseMove
   if the stato of me is not "test" then    cancellatutto
end mouseMove

on rawkeyDown
   cancellatutto
end rawkeyDown

on cancellatutto  
   if the stato of me is "test" then     
      cancelmessage ciclos
      close this stack
   else
      quit
   end if
end cancellatutto

on cancelmessage myMex
   repeat for each line templ in the pendingmessages
      if item 3 of templ is myMex then   
         cancel item 1 of templ
      end if
   end repeat
end cancelmessage



Come vedete ho messo anche i messaggi per  controllare se stiamo facendo delle prove o se lo screensaver è lanciato da windows. Se lo stiamo utilizzando noi la proprietà personalizzata stato ha il valore "test", e quindi lo screensaver se ne va solo premendo un pulsante, altrimenti anche muovendo il mouse. Stessa cosa quando chiudiamo il programma: in un caso chiude solo lo screensaver, nell'altro chiude tutto (quit).
levare il programma.
Il nostro screensaver animatodovrebbe avere un aspetto simile a questo:

A questo punto il nostro screensaver è quasi pronto, quando viene posto trai gli screensaver dentro la cartella C:\Windows\System32 viene chiamato con delle opzioni:

• /p vuol dire che vuole la preview piccola nello schermo
• /c vuol dire che vuole la finestra di configurazione (può essere seguito da numeri tipo /c:75829)
• /s vuol dire modalità salvaschermo normale

Quindi se viene chiamato con /p dobbiamo creare uno stack piccolo piccolo per la piccola preview nel monitor di esempio; se viene chiamato con la /c bisogna avere una finestra di configurazione, con /s deve avviarsi il salvaschermo. Per questo motivo ci conviene mettere il seguente codice nello stack principale:

on PreOpenStack
   put char 1 to 2 of $1 into temp
   switch temp
      case "/p"
         set the stato of card 1 of stack "salvaschermo" to "prewiev"
         hide me
         go to stack "salvaschermo"
         break
      case "/c"
         hide me
         go to stack "Impostazioni"
         break
      case "/s"         
         hide me
         set the stato of card 1 of stack "salvaschermo" to empty
         go to stack "salvaschermo"
      default
         #qui possiamo mettere altre azioni da fare all'avio                     
   end switch   
end PreOpenStack



Ora possiamo creare l'eseguibile .EXE, rinominarlo in .SCR e metterlo nella cartella C:\Windows\System32. Provato e funziona, voi ora potete sbizzarrirvi, mettendo la vostra foto, una frase a caso letta da internete, effetti grafici, ecc.