Guida A Rebol
REBOL per utonti
Guida iniziata il 12/11/2008
Introduzione
Rebol e' un linguaggio di programmazione meraviglioso e gratuito, e' semplice, potente e potete creare applicazioni con interfaccia grafica con pochissime righe di programmazione!. Grazie a Rebol potrete fare anche grafica 2D, grafica 3D, script CGI, tutto con il minimo sforzo e occupa solo 500kb (mezzo floppy, praticamente meno di una foto!!!) In parole povere potete programmare in 5 minuti!, e funziona su Windows, Linux e Mac!
Se volete scrivermi: maxint@tiscali.it
Tutte le versioni si scaricano da qui:
Se volete piu' informazioni esiste:
- il portale degli utenti: http://rebol.informe.com
- il gruppo Facebook: http://www.facebook.com/groups/rebol/
- la community G+:
- Il pagina Rebol World contenete tutti i siti dedicati a Rebol: https://www.maxvessi.net/rebsite/wr/
- Un blog costantemente aggiornato: http://rebol2.blogspot.com
- Potete scaricare tantissimi esempi da: http://www.rebol.org/script-index.r
Rebol significa RIVOLUZIONE.
Indice Guida
Versioni a pagamento
REBOL 2
REBOL 2 E' GRATIS
Tutto quello mostrato in questa guida si può fare con la versione gratuita, che fondamentalmente copre ogni aspetto della programmazione, comunque esistono anche delle versioni a pagamento per programmatori piu' esigenti:
- la versione professionale a pagamento che aggiunge alcune funzioni che potete leggere in questo link: http://www.rebol.com/command.html
- l'ambiente di sviluppo per programmatori professionali si può acquistare qui: http://www.rebol.com/sdk.html
REBOL 3
Rebol 3 non solo e' gratis, ma e' anche OPEN SOURCE, potete scaricare sorgenti originali da qui: https://github.com/rebol/r3 Ma adesso esiste una versione un po' piu' curata qui: https://github.com/angerangel/r3bazaar
La guida seguente è al momento per Rebol 2, quando Rebol 3 sara' sufficientemente maturo, parlera' di Rebol 3.
Video dimostrativi:
Guardate questa demo:
Video guida:
Edidte una guida in inglese attraverso dei video, eccola
Utilizzatori nel mondo:
Vantaggi
I vantaggi sono molteplici:
- Linguaggio di altissimo livello: cioe' piu' vicino al modo di pensare delle persone che dei computer, piu' facile da correggere e da scrivere.
- GRATIS: potete scaricare Rebol (meno di 1 MB) dal sito http://www.rebol.com per far girare tutti i programmi. Se invece andate su http://www.rebol.org troverete centinaia di programmi da scaricare e studiare.
- Multipiattaforma: funziona su Windows, Linux, OSX, BSD e altre 42 piattaforme senza alcuna modifica
- Compatto: con poche righe di codice potete fare cose che in un qualsiasi altro linguaggio servirebbero centinaia di righe
- Interpretato: non dovete compilare il programma o modificare qualcosa, una volta scritto è pronto, quindi di ogni programma e' possibile vedere il sorgente.
Video Guida
Esiste anche una guida fatta da filmati su youtube, potete vederli qui: Rebol Video Guida
Prova
Scaricate rebview e avviatelo, avrete a disposizione programmi, demo, e altre cose per capire se Rebol fa per voi.
LA VERSIONE DI REBOL DA SCARICARE E' LA 2.x.x , LA VERSIONE 3 E' ANCORA IN FASE DI TESTING E NON FUNZIONA CON GLI ESEMPI RIPORTATI
Installazione
Non e' necessario installare Rebol, e' un semplice eseguibile, ma se non siete pratici di programmazione, fate i seguenti passi.
Scaricarlo
Basta scaricarlo da qui: http://www.rebol.com/download-view.html
Ho preparato dei pacchetti autoinstallanti per Linux, per tutti i formati piu' popolari: DEB, RPM e TGZ (Ubuntu/Debian, Mandriva, Fedora, Red Hat, Suse, Slackware, ecc.). Si possono scaricare da questo indirizzo:
https://www.maxvessi.net/rebsite/Linux/ 
Windows
- Scaricate rebview.exe
- Avviatelo
- Lanciate la console (icona sulla sinistra)
- digitate install e premete invio
Linux
Scaricare il pacchetto gia' pronto da: https://www.maxvessi.net/rebsite/Linux/ oppure:
- Installate rebview in /usr/bin/
- per avviare un programma basta lanciare rebview nomeprogramma.r
- oppure aggiungere alla prima riga del programma con #!/usr/bin/rebview
MAC
Si scarica si decomprime e si installa come tutti i programmi.
Programmi per scrivere i programmi (editor)
Per scrivere un programma basta un qualunque editor di testo come il blocco note di Windows o kate, gedit su linux. I migliori comunque sono:
- SciTE: http://www.scintilla.org/SciTE.html (Linux, Windows)
- Crimson editor: http://www.crimsoneditor.com/ (Windows)
- Rebolide: http://www.rebol.org/view-script.r?script=rebolide.r
Chiedere aiuto
Prima di tutto, qualunque cosa succeda, se usate il terminale di Rebol e non sapete un comando, usate il punto interrogativo:
>> ?
oppure
>> ? insert
e vi apparira' un aiuto o una spiegazione.
Tipi di dati
Rebol ha tutta una serie di tipi di dati gia' pronti per essere utilizzati e manipolati correttamente. Il vantaggio e' che automaticamente operera' correttamente su di loro (somma, sottrazione, ecc.). L'elemnto piu' impressionante e' che REBOL capisce da solo che tipo di dato sia! La funzione //type?// ci dice di che tipo sia il dato.
Denaro
Rebol ha un tipo di dato per i soldi, basta anteporre il simbolo del dollaro davanti ad una cifra decimale, esempio:
$0.40
altro esempio:
>> type? $9.89 == money!
Ma c'e' di piu', potete anche usare diverse valute usando le 3 lettere internazionali di identificazione davanti al dollaro: EUR$, CHF$
>> type? EUR$84.87 == money!
Interi
Sono numeri interi:
>> type? 8 == integer!
Decimali
Sono numeri decimali, hanno il punto per dividere le unita' dai decimali:
>> type? 14.8 == decimal!
Stringhe
Sono variabili che contengono parole o frasi, hanno le virgolette prima e dopo:
>> type? "Ciao a tutti" == string!
Se dovete azzerare il valore di una stinga (soprattuto all'interno di funzioni), consiglio:
temp: copy ""
Caratteri speciali per le stringhe
- ^" insericsce i doppi apici "
- ^} Inserisce la graffa destra }
- ^^ inserisce l'accento circonflesso ^
- ^/ o ^(line) inserisce l'accapo
- ^- o ^(tab) inserice un TAB
- ^(page) comincia una nuova pagina
- ^(back) cancella il carattere prima
- ^(null) inserisce un carattere vuoto
- ^(escape) inserisce Esc
- ^(letter) inserisce una lettera di controllo (A-Z).
- ^(xx) inserisce un carattere ASCII, dove xx sta per il valore esadecimale
Tempo
Per memorizzare l'ora, si usano i due punti (ore, minuti, secondi):
>> type? 15:32:01 == time!
Coppie
Per memorizzare coppie di numeri, come la risoluzione di un monitor:
>> type? 640x480 == pair!
se si vuole prendere solo un valore della coppia e' semplicissimo, basta indicale /1 o /x per il primo valore; oppure /2 o /y per il secondo.
>> a: 640x480 == 640x480 >> a/1 == 640
Caratteri
Per memorizzare singole lettere, per fare cio' anteponete il cancelletto e mettete il carattere tra virgolette:
>> type? #"D" == char!
Bytes
Potete scrivere direttamente in codice macchina! Potete scrivere sia in esadecimale che in 64 bit,esempi:
>> type? #{42652061205245424F4C}
== binary!
>> type? 64#{UkVCT0wgUm9ja3Mh}
== binary!
Esiste anche il formato email:
>> type? maxint@tiscali.it == email!
Identificativi
Codici di idcentificazione, basta anteporre il cancelletto:
>> type? #0000-1234-56EV-989 == issue!
Tag
I tag usati in vari linguaggi, utili nella programmazioni di applicazioni per il web:
>> type? <img src="cover.png"> == tag!
Percorsi file
I percorsi dei file si inseriscono anteponendo il simbolo %:
>> type? %/c/rebol/rebol.exe == file!
URL
Gli indirizzi web:
>> type? http://maxint.dynalias.org == url!
Blocco
Il blocco è una peculiarita' di Rebol molto importante, si tratta di un elenco che permette di essere elencato di idnca con parle racchiuse da parentesi quadre:
>> type? [mano piede naso] == block!
Altri
Rebol interpreta tutto, ecco una lista di tutti i tipi che si ottiene digitando:
help datatype! action! datatype! action! any-block! datatype! any-block! any-function! datatype! any-function! any-string! datatype! any-string! any-type! datatype! any-type! any-word! datatype! any-word! binary! datatype! binary! bitset! datatype! bitset! block! datatype! block! char! datatype! char! datatype! datatype! datatype! date! datatype! date! decimal! datatype! decimal! email! datatype! email! error! datatype! error! event! datatype! event! file! datatype! file! function! datatype! function! get-word! datatype! get-word! hash! datatype! hash! image! datatype! image! integer! datatype! integer! issue! datatype! issue! library! datatype! library! list! datatype! list! lit-path! datatype! lit-path! lit-word! datatype! lit-word! logic! datatype! logic! money! datatype! money! native! datatype! native! none! datatype! none! number! datatype! number! object! datatype! object! op! datatype! op! pair! datatype! pair! paren! datatype! paren! path! datatype! path! port! datatype! port! refinement! datatype! refinement! routine! datatype! routine! series! datatype! series! set-path! datatype! set-path! set-word! datatype! set-word! string! datatype! string! struct! datatype! struct! symbol! datatype! symbol! tag! datatype! tag! time! datatype! time! tuple! datatype! tuple! unset! datatype! unset! url! datatype! url! word! datatype! word!
Variabili
In Rebol tutto è una variabile, anche le parole riservate possono essere utilizzate come variabili e ridefinite. Per definire una variabile basta che cominci per una lettera e l'assegnamento si fa con i due punti, ecco un esempio:
>> melo: 12 == 12 >> melo: melo + 2 == 14 >> melo: "Apriti sesamo" == "Apriti sesamo"
Per stampare una variabile basta usare il comando print:
>>print melo == "Apriti sesamo"
Costanti
Rebol ha gia' dei valori preimpostati, tipo il pi greco o i nomi dei colori; voi comunque potete assegnarli altri valori se volete:
>> pi == 3.14159265358979 >> aqua == 40.100.130
Colori
Ecco i nomi dei colori:
| Name | Value | Color | Name | Value | Color | |
| aqua | 40.100.130 | base-color | 200.200.200 | |||
| beige | 255.228.196 | black | 0.0.0 | |||
| blue | 0.0.255 | brick | 178.34.34 | |||
| brown | 139.69.19 | coal | 64.64.64 | |||
| coffee | 76.26.0 | crimson | 220.20.60 | |||
| cyan | 0.255.255 | forest | 0.48.0 | |||
| gold | 255.205.40 | gray | 128.128.128 | |||
| green | 0.255.0 | ivory | 255.255.240 | |||
| khaki | 179.179.126 | leaf | 0.128.0 | |||
| linen | 250.240.230 | magenta | 255.0.255 | |||
| maroon | 128.0.0 | mint | 100.136.116 | |||
| navy | 0.0.128 | oldrab | 72.72.16 | |||
| olive | 128.128.0 | orange | 255.150.10 | |||
| papaya | 255.80.37 | pewter | 170.170.170 | |||
| pink | 255.164.200 | purple | 128.0.128 | |||
| reblue | 38.58.108 | rebolor | 142.128.110 | |||
| red | 255.0.0 | sienna | 160.82.45 | |||
| silver | 192.192.192 | sky | 164.200.255 | |||
| snow | 240.240.240 | tan | 222.184.135 | |||
| teal | 0.128.128 | violet | 72.0.90 | |||
| water | 80.108.142 | wheat | 245.222.129 | |||
| white | 255.255.255 | yellow | 255.255.0 |
Spostarsi tra le cartelle
Se eseguiamo un programma, esso verrà eseguito nella cartella dove si trova il programma. Che cartella e'? Il comando what-dir ci viene in aiuto e ce lo svela:
>> what-dir == %/home/max/Libri/
Per spostarci possiamo usare il comando change-dir:
>> change-dir %/home/max/Libri/ == %/home/max/Libri/
Eseguire programmi esterni
Molte volte esistono programmi scritti in altri linguaggi che sono gia' pronti a fare quello che ci serve, con Rebol e' possibili usarli. Per lanciare un eseguibile, basta usare il comando call, esempi:
>> call notpad.exe >> call "ls -l"
se volete aspettare che il programma finisca, usate l'opzione /wait:
>> call/wait "ls -l"
Eseguire script esterni
Per eseguire altri script basta usare il comando do:
do %prova.r
se volete avere informazioni sullo script, caricatelo col comando load/header, per sempio se abbiamo un script così:
Rebol [ title: "Esempio" version:117 ] print "hello world"
possiamo ricavare tutte le informazioni che vogliamo così (probe viene lanciato solo a scopo illustrativo):
>> a: load/header %prova.r
>> probe a
== [make object! [
Title: "Esempio"
Date: none
Name: none
Version: 117
File: none
Home: none
Author: none
Owner: none
Rights: none
Needs: none
Tabs: none
Usage: none
Purpose: none
Comment: none
History: none
Language: none
Type: none
Content: none
] print "hello world"
]
>> a/1/version
== 117
>> a/1/Title
== "Esempio"
I blocchi o serie
I blocchi sono una parte importante di Rebol, i blocchi possono contenere altri blocchi. Ecco alcuni esempi:
>> prova: [a b c] == [a b c] >> prova: [10 [5x3 $4] "Ciccio" now/date] == [10 [5x3 $4.00] "Ciccio" now/date]
per creare una nuova serie vuota usate i comando copy, se non lo fate rischiate di associare la variabile ad un blocco vuoto già esistente:
b: copy []
per copiare una serie usate sempre copy:
>> prova: [a b c] == [a b c] >> prova2: copy prova == [a b c]
Per prendere un elemento di un blocco basta indicare la posizione:
>> prova/1 == a >> prova/3 == c
Se il blocco e composto da altri blocchi, potete comunque arrivare al dato richiesto:
>> prova: [ Marco [$1 10.5] Mario [$3 20.1]] == [ Marco [$1 10.5] Mario [$3 20.1]] >> prova/2/1 == $1 >> prova/4/2 == 20.1
Se il vi servite di molte variabili per arrivare ad una posizione, dovete utilizzare i due punti cosi':
>> prova: [ Marco [$1 10.5] Mario [$3 20.1]] >> a: 2 >> b: 1 >> prova/:a/:b == $1
La funzione now/date non è interpretata. Se si usa la funzione reduce viene interpretata:
>> prova: reduce [10 [5x3 $4] "Ciccio" now/date] == [10 [5x3 $4.00] "Ciccio" 26-Nov-2008]
ATTENZIONE Se il blocco contiene altri blocchi, i blocchi interni non sono valutati.
Se volete sapere quanto e' lunga una serie, basta chiederlo con il comando length?
>> a: [ 1 2 3 4 5 6 7 20] >> length? a == 8
Indice di una serie
I blocchi nascondo anche altre peculiarita', per tecniche di programmazione avanzate; hanno tutti una testa (head) e una coda (tail), e un indice. La testa e' sempre il primo elemento della serie, mentre la coda e' sempre dopo l'ultimo elemento. L'indice, invece, e' una specie di segnalibro che ci dice da che punto in poi considerare la serie, e puo' essere spostato a piacere lungo tutta la serie.
In un blocco appena creato l'indice punta sempre al primo elemento della serie. Se sposto l'indice in avanti con il comando next, la serie cambia:
>> a: [ 1 2 3 4] >> a: next a == [ 2 3 4]
pero' non ho perso i dati, ho solo spostato l'indice in avanti, posso sempre riportarlo indietro di un passo con back, oppure all'inzio della serie con head:
>> a: [ 1 2 3 4] >> a: next a == [ 2 3 4] >> a: next a == [ 3 4] >> a: back a == [ 2 3 4] >> a: head a == [ 1 2 3 4]
Inserire dati nei blocchi
Vi sono molti modi per inserire dei dati nei blocchi:
APPEND
append inserisce i dati alla fine del blocco:
a: ["Buon"] append a "anno!" == ["Buon" "anno!"]
INSERT
Con insert si inserisce in testa:
>> a: [1 2 3 ] >> insert a 10 == [10 1 2 3]
REPEND
Aggiunge valori o blocchi alla fine di una serie, ma li valuta prima:
>> a: 1 >> b: 2 >> c: [ a b] >>d: copy [] >> append d c == [ a b] >> repend d c == [a b 1 2]
Rimuovere
Ecco alcuni comandi per rimuovere i dati da un blocco.
CLEAR
Rimuove tutti i dati dall'indice corrente fino alla fine della serie.
>> a: [1 2 3 ] >> clear a == []
REMOVE
Rimuove un elemento dalla testa della serie o fino posizione indicata:
>> a: ["a" "b" "c" "d"] >> remove a == ["b" "c" "d"] >> remove/part a 2 == ["d"]
REMOVE-EACH
E' una rimozione condizionale, rimuove gli elementi che verificano il blocco alal fine del comando:
>> a: [1 9 2 8 3 7 4 6 5] >> remove-each elemento a [ elemento > 5] == [ 1 2 3 4 5]
ALTER
Cerca e rimuove un elemento nella serie, se non lo trova, lo aggiunge alla fine. Quando rimuove riotnra false, quando lo aggiunge ritorna true:
>> a: ["a" "b" "c" "d" "e" "f"] >> alter a "c" == false >> a == ["a" "b" "d" "e" "f"] >> alter a "c" == true >> a == ["a" "b" "d" "e" "f" "c"]
Estrarre i dati
Per trovare quello che ci serve da una serie abbiamo molti comandi:
EXTRACT
Estrae a intervalli regolari, ha molte opzioni:
>> a: [ 1 2 3 4 5 6 7 8 9 0] == [1 2 3 4 5 6 7 8 9 0] >> extract a 2 == [1 3 5 7 9]
FIND
Cerca all'interno della serie e restituisce una serie, dall'elemento trovato in poi:
>> a == [1 2 3 4 5 6 7 8 9 0] >> find a 3 == [3 4 5 6 7 8 9 0] >> a: [ "a" "b" "c" "d"] == ["a" "b" "c" "d"] >> find a "c" == ["c" "d"]
LAST
Vi dice l'ultimo elemento della serie:
>> a == [1 2 3 4 5 6 7 8 9 0] >> last a == 0
PICK
Vi rende il valore alla posizione data:
>> a: [ a b c d e f] == [a b c d e f] >> pick a 3 == c
AT
Ritorna la serie dalla posizione specificata in poi:
>> a: [ a b c d e f] == [a b c d e f] >> at a 3 == [c d e f]
SELECT
Cerca e vi restituisce l'elemento dopo quello indicato:
>> a: [ "a" "b" "c" "d" "e" "f"] >> select a "c" == "d"
Modificare una serie
CHANGE
Cambia un valore alla posizione dell'indice della serie e ritorna la serie dopo la modifica:
>> a: [ "a" "b" "c" "d" "e" "f"] >> change a "c" == ["b" "c" "d" "e" "f"] >> a == ["c" "b" "c" "d" "e" "f"]
ARRAY
DIFFERENCE
EXCLUDE
INDEX?
INTERSECT
JOIN
POKE
REPLACE
REVERSE
SKIP
SORT
TAIL
TAIL?
UNION
UNIQUE
Scelte e cicli
IF
Per fare una determinata azione se una espressione è vera, ecco alcuni esempi:
>> a: 1 >> if a = 0 [ "zero" ] >> if a = 1 [ "uno" ] == "uno"
EITHER
Questo comando serve per fare delle scelte fra 2 opzioni, il primo blocco saranno sel istruzioni se la condizione e' vera; il secondo blocco se l'istruzione e' falsa:
>>a: 3 >> either a > 1 [ print "E' vero: a e' maggiore di 2"] [ >> print "E' falso: a e' minore di 2"] == "E' vero: a e' maggiore di 2"
While
La funzione while serve a utilizzare più condizioni per decidere se fare un'azione e/o la durata:
>>a: 0 >>b: 0 >> while [ a = 0 b < 10 ] [ print b b: b + 1] 0 1 2 3 4 5 6 7 8 9 == 10
loop
Ripete un ciclo un numero di volte:
>>loop 5 [print "Ciao"] Ciao Ciao Ciao Ciao Ciao
Forever
Il comando forever ripete un ciclo finche' non si da' il comando break:
>>a: 0 >>forever [ a: a + 1 print a if a = 10 [ break] ] 1 2 3 4 5 6 7 8 9 10
Foreach
Il comando foreach risulta utilissimo quando si lavora con le serie, permette di attraversare la serie e sfruttarla; esempio:
a: ["Gino" "Paola" "Mario"] foreach item a [ print ["a contiene" item]] == a contiene Gino a contiene Paola a contiene Mario
Inoltre il comando foreach, permette di utilizzare gruppi di identificativi, vediamo quest'altro esempio:
a: ["Gino" $4 "Paola" $5 "Mario" $10.5]
foreach [nome soldi] a [
print [nome " ha nel portafoglio " soldi ]
]
==
Gino ha nel portafoglio $4.00
Paola ha nel portafoglio $5.00
Mario ha nel portafoglio $10.50
Switch
Il comando switch permette di scegliere fra varie possibilità, oppure un caso che non rientra in nessuno di essi; dopo il comando si mette la variabile e poi il blocco dei vari casi della variabile e per ultimo il caso di default:
>>a: 3 ==3 switch/default a [ 1 [print "uno"] 3 [print "tre"] ] [print "boh"] ==tre
Funzioni Logiche
Molte volte bisogna descrivere una condizione complicata, dove c'e' la necessita' di dover avere due o piu' condizioni da verificare contemporaneamente, grazie alle funzioni logiche possiamo chiedere a Rebol di verificare se sono vere tuee od alcune condizioni. Esempi:
- controllare che la variabile a e' maggiore di 5 o minore di 3.
- controllare se almeno una delle variabili e' uguale a 23
AND
Rapresenta E logico:
a: 3 b: 5 if (a > 1) and (b > 1) [print "a e b sono entrambi maggiori di 1"] == a e b sono entrambi maggiori di 1
ALL
Rappresenta tutti veri, controlla se tutte le espressioni nel blocco sono vere e esce con l'ultimo valore del blocco. In pratica e come avere tutti and uno dietro l'altro, ma con una piccola sofisticazione in piu' per renderlo piu' versatile:
a: 3 b: 5 c: 7 d: 9 if all [(a > 1) (b > 1) c > 1 d > 1 true] [print "sono tutti maggiori di 1"] == sono tutti maggiori di 1
ANY
Significa uno qualunque, e ritorna il valore che incontra che non sia falso nel blocco:
a: -3 b: -5 c: -7 d: 9 if any [(a > 1) (b > 1) c > 1 d > 1 ] [print "c'e' ne almeno uno che e' maggiore di 1"] == c'e' ne almeno uno che e' maggiore di 1
NOT
E' la negazione del risultato (se e' vero diventa falso e viceversa):
a: 5 a = 5 == true not a = 5 == false
OR
O logico, ritorna vero se una delle due espressioni e' vera: a: -5 b: 2 if (a > 0) or (b > 0) [print "Almeno una variabile e' maggiore di zero"] == Almeno una variabile e' maggiore di zero
XOR
XOR restituisce vero solo se uno e' vero e l'altro e' falso:
>> true xor false == true >> true xor true == false >> false xor false == false
Matematica
USATE SEMPRE LE PARENTESI TONDE, Rebol non da' precedenze agli operatori:
>>print 5 + 5 * 4 "SBAGLIATO" 40 == "SBAGLIATO" >> print 5 + (5 * 4) "GIUSTO" 25 == "GIUSTO"
Funzioni Matematiche
Rebol ha tutte le piu' importanti funzioni matematiche:
** POTENZA // RESTO exp e elevato log-10 LOGARITMO BASE 10 log-2 LOGARITMO BASE 2 log-e LOGARITMO BASE e square-root RADICE QUADRATA absolute valore assoluto negate CAMBIA SEGNO min MINIMO FRA 2 VALORI max MASSIMO FRA 2 VALORI sine SENO cosine COSENO tangent TANGENTE arcsine ARCSENO arccosine ARCCOSENO arctangent ARCTANGENTE
Arrotondamento
L'arrotondamento si fa con il comando round/to (mentre il troncamento solo con round). Bisogna sempe impostare il fattore di arrotondamento, esempio:
a: 10.123456 == 10.123456 round/to a 0.01 == 10.12
Tutte le funzioni
L'elenco delle funzioni pronte in Rebol lo potete trovare a questo indirizzo:
http://www.rebol.com/docs/dictionary.html
Un elenco delle funzioni piu' utili si puo' scaricare dal seguenti link:
Mi limitero' ad illustrare solo le piu' utili.
Lavorare con internet
Rebol e' gia' pronto per leggere da internet, provate
a: read http://www.rebol.com == {<html> <head> <META NAME="Description" CONTENT="REBOL: a Web 3.0 language and system based on new lightweight computing methods...
come potete vedere dall'esempio, Rebol ha letto da internet una pagina web e l'ha memorizzata nella variabile a.
FTP
Se volete caricare o leggere file dal web dovete conoscere il linguaggio FTP, che e' lo standard per internet per caricare i file su un server.
Rebol e' gia' predisposto per leggere e scrivere su un server su internet, basta che si conoscano le credenziali per accedervi (user name, password). Ecco un esempio per leggere:
read ftp://max:la_mia_password@ftp.maxvessi.net/lista_spesa.txt
Per scrivere basta:
write/binary ftp://max:la_mia_password@ftp.maxvessi.net/archivio.zip read/binary %archivio.zip
usare il raffinamento binary e' sempre consigliato quando si tratta di file che non sono testo semplice (quasi sempre).
Email: POP e SMTP
Per leggere la posta ci si collega ai server POP, per inviare i messaggi ci si collega ai server SMTP; questo e' lo standard e Rebol e' gia' pronto all'uso. Basta usare il comando set-net per impostare i dati dell'utente e poi il gioco e' fatto.
set-net [ maxint@tiscali.it ; indirizzo email smtp.tiscali.it ; server smtp pop.tiscali.it ; server pop none ; indicare il proxy di rete se c'e' altrimenti none none ; indicare la porta del proxy altrimenti none none ;indicare il tipo di proxy altrimenti none (generic, socks, socks4, socks5) "maxint" ; indicare il nome utente "la mia password" ; indicare la password ]
Spedire
Facile, basta usare send (e' pieno di opzioni, studiatelo bene):
send pippo@libero.it "Ciao"
Leggere
Basta:
read pop://maxint:la_mia_password@pop.tiscali.it
Altri protocolli di comunicazione
Con Rebol e' possibile leggere e scrivere da altre fonti, ecco alcuni esempi:
Internet
Leggere da internet e' semplicissimo: riconosce automaticamente un indirizzo web, quindi se volete leggere una pagina:
editor http://www.rebol.com ;oppure a: read http://www.rebol.com
Clipboard (copia e incolla)
E' possibile leggere la clipboard, cioe' il luogo del computer dove si memorizzano i dati del copia di ogni programma. Esempio:
a: read clipboard:// ;oppure editor clipboard://
Informazioni sui DNS
Ecco un esempio
print read dns://msn.com
Gruppi usenet
print read nntp://public.teranews.com ; (Hit the [ESC] key to stop ; this Usenet listing.)
oppure
print read nntp://news.eternal-september.org
Creare le proprie funzioni
Cosa e' una funzione?
Una funzione e' una serie di comandi da poter richiamare liberamente. Le funzioni nascono per non dover riscrivere continuamente gli stessi comandi ed anche per aggiornare un programma facilmente. Immaginate di dover cambiare il modo di operare di un programma: se fosse stata scritta 100 volte la serie di comandi, dovreste riscriverla 100 volte; ma se 100 volte viene chiamata la funzione, basterà modificare la funzione e tutte le chiamate faranno la cosa giusta.
E' possibile creare le proprie funzioni, nel programma le funzioni devono essere lette (messe prima) del punto in cui sono chiamate. Per creare una funzione si usa il comando func:
prima_funzione: func [] [print "Fatto"] prima_funzione
Le prime parentesi quadre indicano gli argomenti da passare alla funzione (di solito dei valori):
la_media: func [primo secondo][
risultato: (primo + secondo) / 2
return risultato
]
print la_media 5 15
E' possibile indicare ce valori sono accettati e se l'ambito delle variabili e locale o generale. Esempio
a: "cane"
esempio: func [ primo secondo /local a] [
a: (primo + secondo) / 2
print a
]
esempio 3 5
print a
se lo provate noterete che la variabile a, non viene realmente alterata dalla funzione, perche' appena finisce la funzione a ritorna quella di prima.
Si puo' richiedere che i valori immessi rispettino certi criteri; ad esempio se sono interi, stringhe o altro:
esempio: func [primo [integer! decimal!] secondo [integer! decimal!] ][
print ( primo + secondo )]
esempio 4 6
esempio 4 $4
Qualunque funzione da l'ultimo valutazione come valore, oppure potere usare return; se non volete restituire nessun risultato, usate EXIT:
esempio: func [ a b] [ a + b] esempio 5 3 esempio: func [a b] [return a + b] esempio 5 3 esempio: func [a b] [exit] esempio 5 3
Aggiungere un raffinamento
Potete anche inventarvi i vostri raffinamenti. Vediamo come funziona
somma_tutti: func [ a [block!] /media ] [
totale: 0
foreach elemento a [
totale: totale + elemento
]
testo: ["La somma e':" totale]
if media [ num_ele: length? a
la_media: totale / num_ele
append testo ["e la media e':" la_media]
]
print remold testo
]
somma_tutti [ 1 2 3 4 5]
somma_tutti/media [ 1 2 3 4 5]
Metterci anche una guida
Potete anche mettere una guida ad una funzione, aggiungendo delle stringhe di spiegazione per ogni parametro, potete anche mettere una stringa iniziale di descrizione. Questa guida apparira' con il comando help:
somma_tutti: func [
"Una funzione per fare la somma e a media di numeri"
a [block!] "La lista di numeri"
/media "Fa anche la media"] [
totale: 0
foreach elemento a [
totale: totale + elemento
]
testo: ["La somma e':" totale]
if media [ num_ele: length? a
la_media: totale / num_ele
append testo ["e la media e':" la_media]
]
print remold testo
]
help somma_tutti
Funzioni ricorrenti
Una funzione ricorrente e' una funzione che chiama se stessa per eseguire piu' volte la stessa cosa. E' utile ma e' anche molto facile creare cicli infiniti da cui non si esce piu'.
Vediamo un caso concreto: cerchiamo di entrare in tutte le cartelle, partendo da dove e' eseguito il programma. Ecco come si fa:
funz_ric: func [ /local a] [
a: read %.
foreach nome a [
if dir? nome [
print reform ["Entro dentro " nome]
change-dir nome
funz_ric
change-dir %..
]
]
]
Oggetti
Gli oggetti sono come dei contenitori, molto comodi per raggruppare dati e funzioni.
Creare un oggetto
Per capire bene gli oggetti bisogna mettere subito in pratica la loro utilita'; creiamo un oggetto "moto", che conterra' dei valori per freni, km e luci
moto: make object! [ luci: "funzionano" freni: "a disco" km: 63000 ]
ora possiamo esaminare l'oggetto moto con il comando probe o print, che hanno risultati leggermente diversi:
print moto probe moto
E' possibile creare un oggetto con una funzione:
esempio: make object! [
nome: "esempio"
creazione: now
ora_corrente: func [] [now]
somma: func [ a b ] [ a + b]
]
e poi lanciate
print esempio esempio/ora_corrente esempio/somma 2 3
Usare un oggetto
Abbiamo creato l'oggetto moto, ora possiamo creare altri oggetti come moto, che abbiano proprio moto come padre:
guzzi: make moto [ ]
in questa maniera l'oggetto guzzi avra' gli stessi valori dell'oggetto padre moto.
Se invece facciamo cosi':
honda: make moto [
luci: "rotte"
freni: "a tamburo"
km: 25600
]
avremo un oggetto honda come il genitore moto, ma con i valori di partenza diversi.
E' possibile alterare solo alcuni valori:
kawasaki: make moto [ km: 500]
se volete vedere le differenze:
print guzzi print honda print kawasaki
Estrarre i valori
Se vogliamo estrarre un valore possiamo richiamarlo cosi':
print moto/km print honda/luci
Interfacce gia' pronte
In Rebol esistono delle interfacce gia' pronte per tutte quelle finestre utilizzate nella maggior parte dei programmi moderni: dagli avvisi alla richiesta dei file, alla richiesta del colore e cosi' via... Ecco un elenco:
alert
Manda un messaggio di attenzione:
alert "Stai per distruggere tutto!"
confirm
Chiede di confermare una scelta a cui rispendere YES o NO; ritorna TREU o FALSE di default. Potete impostare anche le scritte dei pulsanti con la raffinazione with:
confirm "Sei biondo?" confirm/with "Sei moro?" ["SI" "No, sono biondo"]
editor
Un comodo editor di testo:
editor "prova"
emailer
Una finestra per inviare email (il resto del codice verra' spiegato piu' avanti):
view layout [btn "Manda una email" [emailer ]]
flash
Fa apparire una finestra di avviso e poi scompare con il comando unview. ATTENZIONE: dovete sempre usare unview per cancellarlo:
flash "Sto contando fino a 6." wait 6 unview f1: flash "Sto contando fino a 5." wait 5 unview f1
notify
Permette di far apparire un avviso:
notify "Hai fatto un disastro!"
request-color
Permette di far scegliere all'utente un colore, ovviamente restituisce una tripletta:
colore: request-color
request-date
Permette di chiedere all'utente una data:
data: request-date
request-dir
Permette di far scegliere all'utente una directory:
directory: request-dir
request-download
Mostra all'utente lo scaricamento di un file da internet, ma l'utente puo' interrompere il download in ogni momento:
request-download http://www.rebol.com/
request-file
Fa scegliere all'utente un file:
request-file
request-list
Fa scegliere un elemento da una lista:
request-list "Esempio" [ "Mario" 23 $2]
request-pas
Fa immettere username e password, potete far apparrire lo username con il raffinamento user:
request-pass request-pass/user "Max"
request-text
Chiede all'utente una stringa (es. parola o frase):
request-text/title "Come ti chiami?"
Input / Output
Ci sono vari modi per prendere dei dati ma sono tutti estremamente semplici.
Read
Con la funzione read leggiamo direttamente cio' che ci serve (file, pagine web, ecc.):
>> read http://www.google.it == {<html><head><meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"><title>Google</title><style>body,td,a,p,.h{... >> a: read http://www.google.it == {<html><head><meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"><title>Google</title><style>body,td,a,p,.h{...
Ask
Con la funzione ask chiediamo via terminale qualcosa ad un utente:
>> pass: ask "Nome in codice?"
Input
input è come ask ma non chiede, aspetta l'utente che digiti qualcosa e basta.
Write
write scrive in un file i dati:
>> write %./prova.txt "Ciao"
Ultima modifica
Permette di sapere l'ultima modifica ad un file:
modified? %file.txt
Inviare e ricevere email
Rebol ha due comandi: send e read per inviare e leggere le email.
Prima di tutto dobbiamo mettere i dati di connessione con il comando set-net:
set-net [ tec@rometec.it ;indirizzo email del mittente mailbus.fastweb.it ;server smtp pop.rometec.it ;server pop none ;eventuale proxy none ;eventuale porta del proxy none ;tipo di proxy tra: socks, socks4, sock5, generic tec@rometec.it ;user di riconoscimento per il server smtp lamia_password ;password di riconoscimento per il server stmp ]
Inviare
A questo punto per inviare una email potete usare send
send maxint@tiscali.it "Ciao bello!"
se il testo e' su piu' righe, la prima rappresenta l'oggetto del messaggio:
send maxint@tiscali.it {Oggetto: Prova
Ciao bello!}
altrimenti puo' essere piu' semplice usare la raffinazione subject:
send/subject maxint@tiscali.it "Ciao bello!" "Oggetto: una semplice prova"
Criptare e decriptare
E' possibile sia decriptare che decriptare dei testi, basta usare encloak e decloack ; per entrambi i programmi e' necessario fornire la stessa chiave di criptazione:
>> encloak "prova" "chiave" == "›ˆ\^X" >> decloak "›ˆ\^X" "chiave" == "prova"
Database
La versione a pagamento di Rebol ha accesso alla maggior parte dei databse professionali (MySQL, Oracle, SQLServer, Access, Excel), per maggiori informazioni: http://www.rebol.com/command.html
Inoltre in rete esistono varie librerie gratuite per dialogare con i piu' famosi database del mondo, guardate qui per esempio:
- http://softinnov.org/rebol/mysql.shtml
- http://softinnov.org/rebol/pgsql.shtml
- http://softinnov.org/rebol/ldap.shtml
Se comunque ci serve di creare un semplice database possiamo sfruttare le funzioni base.
Per organizzare i dati basta creare una serie vuota:
db: copy [] == []
poi possiamo aggiungere i dati con il seguente comando (i dati sono di pura fantasia):
append/only db ["Nome" "Cognome" "0650603080" $40 52] == [ ["Nome" "Cognome" "0650603080" $40.00 52] ] append/only db ["Gino" "Rossi" "068052080" $50 23] == [ ["Nome" "Cognome" "0650603080" $40.00 52] ["Gino" "Rossi" "068052080" $50.00 23] ]
poi possiamo salvare i dati con il seguente comando:
save %file_dati.txt db
e per recuperarli basta:
db: load %file_dati.txt == [ ["Nome" "Cognome" "0650603080" $40.00 52] ["Gino" "Rossi" "068052080" $50.00 23] ]
In questa maniera abbiamo un database dove è semplicemente accessibile ogni elemento, ad esempio Gino e' db/2/1:
db/2/1 == "Gino
Un altro modo molto comodo per organizzare i dati è mettere davanti ai dati la descrizione:
a: [nome "Mario" cognome "Rossi" stipendio $1000 assunzione 15/5/1990 ] select a 'nome == "Mario" select a 'stipendio == $1000
In questo modo i dati possono essere inseriti in qualsiasi ordine.
RebDB
Esiste anche un'altra possibilità, utilizzare lo script RebDB che ci permette di utilizzare la sintassi SQL per avere a propria disposizione un database professionale, senza dover installare alcun che'; funziona tutto attraverso e solo con Rebol. Prima di tutto potete scaricarlo da qui: RebDB.zip oppure dal sito ufficiale: http://www.dobeash.com/rebdb.html
Una volta scompattata il file zip, troverete i seguenti file:
- db.r
- db-client.r
- SQL.r
Non sto a descrivere i primi due, ma basta lanciare il terzo per trovarsi in una sessione di un database SQL!!!
>> do %SQL.r SQL>
I comandi sono tantissimi, basta lanciare HELP per rendersene conto:
SQL> help
+-----------------------------------------------------------------------------+
| Row Retrieval |
+-----------------------------------------------------------------------------+
| LOOKUP table {key [keys]} |
| SELECT {* column [{rowid} columns]} FROM table |
| WHERE {key [keys] [conditions]} |
| GROUP BY {column [columns]} (HAVING [conditions]} |
| ORDER BY {column [columns]} {DESC} |
+-----------------------------------------------------------------------------+
| Row Management |
+-----------------------------------------------------------------------------+
| DELETE FROM table {key [keys]} |
| WHERE {key [keys] [conditions]} |
| INSERT INTO table VALUES [{next} values] |
| TRUNCATE table |
| UPDATE table SET {column [columns]} TO {value [values]} {key [keys]} |
| WHERE {key [keys] [conditions]} |
+--------------------------------------+--------------------------------------+
| Table Management | Informational |
+--------------------------------------+--------------------------------------+
| CLOSE {table *} | {DESC DESCRIBE} table |
| COMMIT {table *} | EXPLAIN statement |
| CREATE table [columns] | ROWS table |
| DROP table | SHOW |
| ROLLBACK {table *} | TABLE? table |
| | TABLES |
+--------------------------------------+--------------------------------------+
| Commands | Settings |
+--------------------------------------+--------------------------------------+
| ; {comment} | SET ADDRESS url |
| ECHO {text "text"} | SET HTML {on off} |
| EXIT | SET LINES {on off} |
| HELP | SET PATH path |
| RUN {script script.sql} | SET SPOOL {file off} |
| | SET USERNAME string |
+--------------------------------------+--------------------------------------+
SQL>
Creiamo una tabella
Se vogliamo creare una tabella, basta indicare il nome delle colonne:
SQL> create table esempio [ prima seconda terza] true SQL> vediamo come e' fatta: SQL> desc esempio Column Type ------- ---- prima none seconda none terza none 3 row(s) selected in 0:00 seconds
adesso le colonne hanno come tipo none, ma prenderanno il primo tipo inserito
Inserire i dati
Ecco come fare:
SQL> INSERT INTO esempio VALUES [ 1 $5 "Max" ]
prima seconda terza
----- ------- -----
1 $5.00 Max
1 row(s) selected in 0:00 seconds
SQL>
adesso le colonne possono descriverci cosa contengono:
SQL> desc esempio Column Type ------- ------- prima integer seconda money terza string 3 row(s) selected in 0:00 seconds
Checksum
E' possibile ottenere il checksum dei file o di un qualunque dato; per chi non lo conosce, il checksum e' come la firma di un file, permette di capire se due file sono uguali. Il checksum che fa Rebol e' il tipo CRC. Il comando si lancia cosi':
checksum %prova.jpg == 13260183
ha molte opzioni, eccole:
- /tcp -- Returns an Internet TCP 16-bit checksum.
- /secure -- Returns a cryptographically secure checksum.
- /hash -- Returns a hash value
- size -- Size of the hash table (Type: integer)
- /method -- Method to use
- word -- Method: SHA1 MD5 (Type: word)
- /key -- Returns keyed HMAC value
- key-value -- Key to use (Type: any-string)
Alcuni esercizi
Ecco degli esercizi per capire se si è appreso i concetti fino a qui esposti:
- Salvare il contenuto della pagina http://www.rebol.com in un file chiamato rebol.html
- Scrivere un programma che chieda all'utente di fornire 3 numeri e far indicare al programma quale sia il piu' alto.
- Fare un programma che chieda all'utente continuamente un numero, e stampi la media di tutti i numeri inseriti fino a quel momento.
- Come l'esercizio precedente ma per un gruppo di numeri arbitrari, deciso volta per volta dall'utente (per 5 numeri, per 3, per 12...)
- Calcolare il numero di giorni dal proprio compleanno.
- Modifica in ROT-13 di un testo, in entrambi i sensi.
Parsing (ovvero trovare nel testo)
Il parsing con Rebol è semplice e potente, ma solo se si conoscono le regole del comando parse. Di regola non distingue fra caratteri maiuscoli o minuscoli a meno che non si usa la raffinazione /case.
Suddividere
L'uso piu' semplice di parse e' per suddividere. Per suddividere una stringa o un documento, basterà indicare il carattere o la sequenza di caratteri da usare come riferimento. Gli spazi vengono sempre usati a meno che non si usa la raffinazione /all:
esemp: "Ciao, mi chiamo Max, tu come ti chiami?" parse esemp none == ["Ciao" "mi" "chiamo" "Max" "tu" "come" "ti" "chiami?"] parse/all esemp ", " == ["Ciao" "mi chiamo Max" "tu come ti chiami?"]
Se vogliamo dividere un testo utilizzando uno piu' caratteri, per esempio la punteggiatura, basta fornire la stringa dei caratteri da utilizzare come divisori:
esemp: "La rosa e' rosa. Se fosse stata viola, l'avrei chiamata violetta. Giusto?" parse esemp ",.?" == ["La" "rosa" "e'" "rosa" "Se" "fosse" "stata" "viola" "l'avrei" "chiamata" "violetta" "Giusto"]
Uso avanzato
parse e' uno strumento molto potente, perche' dopo la stringa da analizzare potete mettere tutta una serie di comandi e opzioni per controllare che la stringa corrsponda a quanto richiesto e se si (o solo per alcune parti), faccia qualcosa.
Opzioni
Il carattere | permette di dare delle opzioni:
a: "fiore" parse a ["fiore" | "casa"] == true
ma andiamo oltre:
mezzo: [ "in moto" | "in macchina"] chi: ["Sara" | "Laura"] parse frase [ chi mezzo ]
parse restituisce vero per tutte le combinazioni:
- "Sara in moto"
- "Sara in macchina"
- "Laura in moto"
- "Laura in macchina"
Testare
Si puo' richiedere al comando 'parse se una certa parola e' ripetuta un certo numero di volte.
Ad esempio chiediamo se Max e' ripetuto 4 volte:
esemp: "Max Max Max Max" parse esemp [4 "Max"] == true
Se non sapete quante volte, potete scrivere any (da zero in poi) o some (almeno uno):
frase: "b" parse frase [ some "a"] == false parse frase [ any "a"] == true frase: "aaaab" parse frase [ some "a"] == true parse frase [ any "a"] == true
Ora chiediamo se è ripetuta tra 2 e 5:
parse esemp [2 5 "Max"] == true
Saltare l'input
Con i comandi to e thru e' possibile saltare il contenuto di una stringa fino ad un certo punto. to prima della sequenza scelta, thru dopo. Esempi:
a: "fiore.jpg" parse a [thru "." ["jpg"|"gif"] end] == true parse a [to "." [".jpg"|".gif"] end] == true
Il comando 'end serve a dire che dopo non ci deve essere nulla. In questo modo abbiamo controllato se il nome è di una immagine.
Controllare l'estensione di un file
In Rebol esiste il comando suffix? per capire l'estensione di un file:
suffix? %Esempio.pdf == %.pdf
Ma anche controllare l'estensione di un file con parse e' un esercizio molto semplice, proviamo a controllare che il file sia un PDF:
a: request-file b: parse to-string a [ thru ".pdf" end] if b [alert "E' un PDF!"]
Charset (set di caratteri)
E' possibile specificare un set di caratteri, per esempio da 0 a 9, con il comando charset
numeri: charset "0123456789" a: "067025555" parse a [some numeri] == true
e' possibile anche indicare da che valore della tabella ASCII cominciare e finire per il set:
lettere_min: charset [#"a" - #"z"] lettere: charset [#"A" - #"Z" #"a" - #"z"]
Eseguire operazioni
E' possibile eseguire delle operazioni, basta metterle tra parentesi tonde, ad esempio:
a: "Che bella persona!"
parse a [
to "bella" (print "trovato bella")
to "persona" (print "trovato persona")
to end
]
==trovato bella
==trovato persona
Estrarre del testo
Se vogliamo estrarre del testo usando delle regole, la formula piu' comune e' any con skip. Per esempio, ipotizziamo di voler estrarre il testo che si trova tra un numero di tre cifre e il punto:
cifre: charset "0123456789"
esempio: {
Nome in codice 007 Massimiliano Vessi.
Nome in codice 012 Sassenrath Carl.
Nome in codice 121 Semseddin Moldibi.
}
parse esempio [any [3 cifre copy temp to "." (print temp) | skip]]
Massimiliano Vessi
Sassenrath Carl
Semseddin Moldibi
== true
Interfacce (VID)
In Rebol fare programmi con interfacce grafiche è semplicissimo e permette di ottenere risultati strabilianti in breve tempo. In Rebol tutti gli elementi grafici sono contenuti in facce; ogni faccia si può immaginare come un rettangolo con tutta una serie di proprietà (colore, bordo, immagine contenuta, font dei caratteri e molto altro ancora...).
Il linguaggio per le interfacce puo' essere molto semplice se si usa un dialetto di Rebol il VID (sempre gia' incluso in Rebol), il VID sono tutta una serie di comandi che permettono di scrivere velocemente delle interfacce. Volendo, pero', e' possibile andare piu' a fondo del linguaggio delle interfacce e non usare il VID.
Esiste anche una piccola guida in inglese su http://www.rebol.com/docs/easy-vid.html
Primo esempio
view layout [
across
label italic font [ color: brick ] "To:"
tab
inp-to: field
return
label italic font [ color: brick ] "Subject:"
tab
inp-subj: field
return
inp-text: area
return
button "Send" [
foreach addr parse inp-to/text ",;" [
send to-email addr
rejoin [inp-subj/text newline inp-text/text]
]
quit
]
]
Ecco cosa esce fuori:
E' un programma per scrivere email. Esiste un altro linguaggio che permette cosi' tanto con cosi' poco? NO.
Altro esempio:
do http://www.fys.ku.dk/~niclasen/rebol/space/ngc7635.r
Da dove cominciare
Per fare programmi grafici bisogna usare la funzione view layout []. All'interno di questa funzione vanno messe le varie *facce*.
Se volete che una finestra si apra al centro dello schermo, basta usare il comando center-face:
view center-face layout [ text "Ciao" ]
Per avere le dimensioni dello schermo, basta interrogare system/view/screen-face/size
>> system/view/screen-face/size == 1280x1024
Quindi se volete fare un programma a schermo intero basta sfruttarlo:
view center-face layout [ at 0x0 image system/view/screen-face/size logo.gif [unview] ]
Posizione
Esistono 2 possibili posizionamenti, che possono essere anche alternati, across e below; per ogni nuova riga o colonna usare la parole return. Se non viene scritto nulla si sottointende below:
view layout [ across text "a1" text "a2" text "a3" return text "aA" text "aB" text "aC" below text "b1" text "b2" text "b3" return text "bA" text "bB" text "bC"]
Provate a vedere le differenze cambiando l'ordine delle parole.
Se volete sistemare un elemento in una posizione particolare, potete utilizzare il comando at e la posizione:
view layout [
text "proviamo"
at 3x3
image logo.gif]
Testi
Per far apparire del testo dentro una finestra esistono tante possibilità, come l'HTML:
view layout [ title "Titolo" text "normal text" h1 "Titolo 1" h2 "Titolo 2" h3 "Titolo 3" h4 "Titolo 4" h5 "Titolo 5" code "Codice programmi" banner "Banner" vtext "Video text" vh1 "Video Titolo 1" vh2 "Video Titolo 2" vh3 "Video Titolo 3" vh4 "Video Titolo 4" label "etichetta" ]
Tutti gli stili sono:
- BASE-TEXT
- CODE
- H1
- H2
- H3
- H4
- H5
- TEXT
- title
- tt
- txt
- VH1
- VH2
- VH3
- VH4
- vtext
Se preferiti colori diversi da quelli di default, si possono decidere nella massima libertà.
Testi (avanzato)
Nel caso non vi bastassero gli stili, potete personalizzare i testi con ulteriori comandi. Il comando font e il comando para. Ognuno di questi comandi ha delle variabili da poter impostare per modificare l'effetto, prima un esempio e poi una spiegazione dettagliata:
view layout [ text "Ciao" text "Ciao a tutti" font [ size: 25] text "Ciao ancora" font [ color: white shadow: 2x2] ]
Spiegamo meglio i due comandi:
Font
Font puo' impostare le seguenti variabili:
| Variabile | Tipo | Descrizione |
|---|---|---|
| name | string! | Nome del font, rebol ha già in memoria: font-serif, font-sans-serif , e font-fixed. Default e' font-sans-serif. |
| size | integer! | Grandezza del font |
| style | word! o block! | Stile del testo: bold, italic, underline o none. Si può usare anche un blocco con tutti insieme. |
| color | tuple! | Colore del testo, default e' 0.0.0 |
| align | word! | Allineamento del testo. Le scelte sono: left, right, and center. |
| valign | word! | Allineamento verticale del testo, le scelte sono: top, bottom e middle. |
| offset | pair! | L'offest del testo dall'angolo in alto a sinistra. Default e' 2x2. |
| space | pair! | Spazio tra caratteri e righe di testo, default e' 0x0. |
| shadow | pair! | Ombreggiatura, quando deve essere spostata, default e' 0x0 |
Para
Para puo' impostare le seguenti variabili:
| Variabile | Tipo | Descrizione |
|---|---|---|
| origin | pair! | L'offset del testo dall'angolo in alto a sinistra. Default e' 2x2. |
| margin | pair! | Il margine estremo in basso a destra del testo. Default e' 2x2. |
| indent | pair! | Lo spaziamento della prima riga del paragrafo, si possono usare anche valori negativi. Default e' 0x0. |
| scroll | pair! | Utilizzato per lo scrolling, default e' 0x0. |
| tabs | integer! o block! | Si può impostare un intero per spazzi fissi o un blocco di interi per posizionare i vari tab. Default is 40. |
| wrap? | logic! | Indica se madare a capo automaticamente il testo. |
Barra
L'oggetto bar e' una barra orizzontale 200x3, potete cambiare la dimensione per renderla verticale
view layout [ bar bar 3x200 ]
Bottoni
Per i bottoni il comando e' button:
view layout [ button "Premi qui!" [ alert "Bravo!"] ]
Potete mettere piu' testi, uno rappresentera' il testo normale, l'altro apparira' quando viene premuto.
view layout [ button "Premi qui!" "Bravo!" ]
Esistono i seguenti stili di bottoni:
- BTN
- BTN-CANCEL
- BTN-ENTER
- BTN-HELP
- BUTTON
Gli stili btn si ridimensionano automaticamente al testo contenuto.
Altri esempi
Ecco un esempio con un la maggior parte degli oggetti che si possono mettere in una finestra:
view layout [
h1 "Altri esempi:"
box red 500x2
text "Ci sono piu' di 40 oggetti da poter utilizzare in Rebol"
bar: progress
slider 200x16 [bar/data: value show bar]
area "Scrivi qui"
drop-down "Primo" "Secondo" "Terzo"
text-list 60x60 "uno" "due" "tre"
across
toggle "Click" "Here"
rotary "Click" "Again" "And Again"
choice "Choose" "Item 1" "Item 2" "Item 3" [alert value]
radio radio radio
led
return
arrow
arrow left
arrow right
arrow down
return
field "oppure qui.."
return
image logo.gif
]
Analizzare qualunque elemento in VID
Usate l'editor integrato di Rebol per analizzare qualunque elemento vi interessi conoscere, esempio:
view layout [ prova: choice "a" "b" button [ editor prova] ]
Oppure il punto di domanda:
view layout [ prova: choice "a" "b" button [ ? prova] ]
Prova a vedere le differenze.
Sfondo
Potete impostare un colore o un'immagine come sfondo. L'immagine può essere scalata o ripetuta per riempire la finestra. I comandi sono: backdrop e backtile. Per il colore si possono usare entrambi, poichè si potrebbe utilizzare come sfondo di un'immagine trasparente.
view layout [ backdrop red button "esempio" ]
Sfondo scalato:
view layout [ backdrop logo.gif button "esempio" button "esempio" ]
Sfondo ripetuto:
view layout [ backtile logo.gif button "esempio" button "esempio" ]
Casella di controllo (check)
La casella check può essere comodo per far decidere si o no all'utente. DI partenza il suo valore è nullo, e puo' diventare true o false; si accede al suo contenuto con /data. Meglio un esempio che chiarisca le idee:
view layout [
a: check [b/text: a/data show b ]
b: text 100x20
]
Esistono i seguenti tipi di check:
- CHECK
- CHECK-LINE
- CHECK-MARK
Check-line e' il migliore per mettere dei testi in colonna:
view layout [ check-line "Opzione 1" check-line "Opzione 2" check-line "Opzione 3" ]
Input di testo
Per prendere del testo basta impostare una variabile con il tipo di input preferito field singola riga o area per più righe:
view layout [ campo: field areatesto: area ]
Io consiglio di utilizzare gli stili label per aggiungere del testo vicino ai campi di immissione: esempio:
view layout [ label "Nome:" label "Cognome:" label "Testo:" return field field area ]
Frecce
Potete aggiungere dei pulsanti con delle frecce, potete indicare direzione e dimensione.
view layout [ arrow arrow left arrow right arrow down ]
Icon
Lo stile icon crea un pulsante con una immagine e un testo, utile per fare videogiochi:
view layout [ icon "Clicca qui" ]
Scroller
Questo stile e' ottimo per far scorre dei sottopannelli e aree di testo:
view layout [
t1: area wrap system/license
return
scroller (as-pair 15 t1/size/y) [
t1/para/scroll/y: negate (face/data * second size-text t1)
show t1
]
]
Progress
Questo stile e' una barra di riempimento progresivo, il suo valore varia da zero a uno (decimale):
view layout [ a: progress slider [a/data: face/data show a] ]
Radio button
Lo stile radio e' utile quando l'utente deve scegliere solo una delle possibili opzioni, gli stili radio sono:
- RADIO
- RADIO-LINE
Esempio:
view layout [ radio-line "Opzione 1" radio-line "Opzione 2" radio-line "Opzione 3" ]
E' possibile raggrupparli con il comando of:
view layout [ text "Quale e' il pasto che preferisci?" radio-line "Colazione" of 'pasto radio-line "Pranzo" of 'pasto radio-line "Cena" of 'pasto text "Quando preferisci uscire?" radio-line "Di Giorno" of 'uscire radio-line "Di sera" of 'uscire ]
Logo-bar
Si tratta di una barra verticale con il logo Rebol 24x300:
view layout [ logo-bar]
Panel
Questo oggetto e' molto comodo per raggruppare oggetti e posizionarli come volete:
view layout [ Text "Esempio:" return panel yellow [ text "Prova" button button] ]
Led
Potete mettere delle luci che cambiano colore a seconda dello stato del programma:
si invoca con led:
view layout [title "Esempio"
led ]
di default led e' rosso, e led/data e' impostato a false. Cambiando a il valore di led a true diventa verde. led/colors: [red green] imposta i colori. Traducendo in un esempio:
view layout [ title "Esempio"
led1: led
button "Cambia colore" [
either led1/data = true [led1/data: false] [led1/data: true]
show led1
]
]
Menu scelte: choice, drop-down e rotary
Sonno tutti elementi che permotto di scegliere da una lista di opzioni, la lista puo' essere fornita o con dei testi di seguito, oppure fornendo una serie dopo la parola data:
view layout [ choice data [1 2 3 ] button ]
Choice
Ecco un menu a tendina molto comodo:
view layout [ text "Cosa preferisci?" choice "Pasta" "dolci" [ alert reform ["Hai scelto" value] ] ]
L'elemento choice ha diverse variabile, value nella sua azione rappresenta il testo scelto. text rappresenta il testo che appare, ecco un altro esempio:
view layout [ prova: choice "a" "b" button "scelta" [ print prova/text] button "modifica" [ prova/text: "c" show prova] ]
Drop-down
E' una lista, stile windows:
view layout [ prova: drop-down "uno" "due" "tre" button [print prova/text] ]
la varibile text vi dice quale sia la scelta (prova/text).
Rotary
E' un pulsante che cambia valore ogni volta che ci clicchiamo sopra:
view layout [ rotary "1" "2" "3" ]
Liste di testo
Un lista di testo e una colonna in cui mettere delle righe da cui scegliere, ecco un esempio:
view layout [ text-list "Acqua" "Fuoco" "Vento" "Terra"]
Come vedete e' molto semplice scrivere delle liste.
Ma se avete da lavorare con molti dati, è meglio usare la parola data, in modo da poter prendere i valori da altre variabili, esempio:
a: [ "Acqua" "Fuoco" "Vento" "Terra"] view layout [ text-list data a ]
Se volete modificare successivamente una lista basta cambiare il valore dell'elemento data di questo oggetto, provate il seguente:
a: [ "Acqua" "Fuoco" "Vento" "Terra"]
view layout [
bb: text-list data a
button "Clicca!" [
bb/data: [ "Sale" "Pepe" "olio" "origano"]
show bb
]
]
Per sapere quale elemento e' stato scelto, basta usare il raffinamento picked, esempio:
view layout [ a: text-list "Marco" "Laura" [print a/picked] ]
Titolo della finestra
Il titolo della finestra e' impostato da Rebol come il titolo dello script, ma potete usare la funzione view/title per impostarlo voi:
Rebol [ Title: "Esempio"] view layout [ text "Il titolo della finestra e' Esempio." ] view/title layout [ text "Il titolo della finestra e' demo." ] "demo"
Aggiungere uno scroller per gli elementi di testo
Per aggiungere uno scroller per scorrere gli elementi di testo, basta usare il comando scroll-para, questo comando collega uno elemnto di testo con uno scroller:
view layout [across a: area b: scroller [scroll-para a b] ]
Box
Il box è un rettangolo, potete colorarlo, metterci un testo dentro, ma la parte più interessante e' utilizzarlo per fare dei sotto-pannelli o menu'. Esempio semplice box:
view layout [ box red "Esempio" ]
Sottopannelli
Creare sottopannelli e' una caratteristica molto interessante, vediamo come si fa:
view layout [ button "esempio 1" [es/pane: layout [txt "esempio 1" button ] show es] button "esempio 2" [es/pane: layout [txt "esempio 2" button red] show es] return bar 3x200 return es: box 200x200 ]
Con l'opzione offset potete decidere da dove partire a creare il sotopannello, provate ad inserire:
es/offset: 0x0
Aprire una nuova finestra
Per aprire una nuova finestra basta usa view/new
Rebol [ Title: "Esempio"]
view layout [ button "info" [ view/new layout [text "Finestra con titolo Esempio"] ]
button "info" [ view/new/title layout [text "Finestra con titolo Info"] "Info" ]
]
Chiudere una finestra
Per chiudere una finestra basta usare il comando unview
view layout [ button "info" [ view/new layout [button "Chiudi" [unview]]
]
]
Potete anche chiudere un'altra finestra, basta mettere il nome del layout che volete chiudere dopo il comando unview.
Nascondere e mostrare
E' possibile far scomparire e riapparire gli elementi di VID con i comandi show e hide, ecco un esempio molto divertente:
view layout [
a: text "Testo magico"
button "Nascondi" [ hide a]
button "Mostra" [show a]
]
Un elemento puo' essere nascosto fin dall'inizio imponendogli il settaggio di show? su falso:
view layout [
a: button "a" [ hide b show c ]
b: button "b" [hide c show a]
c: button "c" [hide a show b] with [show?: false]
]
Un elemento non può nascondere se stesso con hide, ma tale limitazione può essere superata con gli eventi (v. piu' avanti), ecco un esempio:
view layout [
button "Cliccami per nascondermi!" 120
feel [engage: func [f a e][hide f ]]
]
Eseguire comandi allinterno di VID
E' difficile che dobbiate eseguire dei comandi, ma potrebbe risultarvi comodo per impostare alcune variabili. Beh, per eseguire dei comandi basta usare il comando do:
view layout [ button do [ print "Ciao mondo!"] ]
Capire le variabili utilizzabili di un elemento
Molte volte e' difficile capire cosa si puo' sfruttare di un elemento di VID, il seguente script vi aiutera':
view layout [ b: check a: button [ ? b]]
Come vedete il punto interrogativo può essere usato come help sugli elementi VID, infatti la risposta che otterrete premendo il pulsante è (usate prima l'elemento per attivarne alcuni valori, ad esempio data e' null finche' non ci cliccate sopra:
B is an object of value: type word! face offset pair! 20x20 size pair! 16x16 span none! none pane none! none text none! none color tuple! 240.240.240 image none! none effect block! length: 1 data logic! true edge object! [color image effect size] font none! none para none! none feel object! [redraw detect over engage cue blink] saved-area none! none rate none! none show? logic! true options none! none parent-face object! [type offset size span pane text color image effec... old-offset pair! 20x20 old-size pair! 16x16 line-list none! none changes none! none face-flags integer! 1 action none! none state logic! false access object! [set-face* get-face* clear-face* reset-face*] style word! check alt-action none! none facets none! none related none! none words none! none colors none! none texts none! none images none! none file none! none var word! b keycode none! none reset none! none styles none! none init block! length: 0 multi object! [text size file image color block] blinker none! none pane-size pair! 140x88 dirty? none! none help none! none user-data none! none flags block! length: 2 doc object! [info string image logic integer pair tuple file u... effects none! none depth integer! 128
Azioni
Ogni elemento grafico che potete usare ha la possibilità di attivare un'azione, basta mettere un paio di parentesi quadre dopo l'elemento.
view layout [ button "Esempio." [view layout [ text "Ciao"]]]
Pulsante destro del mouse
Ogni elemento può attivare un'azione diversa se si clicca col pulsante sinistro o destro del mouse. Se si vuole assegnare un'azione al pulsante destro del mouse, basta aggiungere un'altra azione all'oggetto, esempio:
view layout [ button "Esempio" [ alert "cliccato col pulsante sinistro" ][ alert "cliccato col pulsante destro" ] ]
Si possono anche associare pulsanti ad azioni, senza doverle associare a particolari elementi della finestra; per fare cio' leggete piu' avanti nella sezione Eventi (avanzato)
Scorciatoie da tastiera
E' possibile aggiungere delle scorciatoie da tastiera, per esempio premere la lettera a se invece di premere un pulsante. Per fare ciò basta aggiungere la lettera ad un oggetto. Provate a premere e con l'esempio sottostante:
view layout [ button "esEmpio" #"e" [
alert "hai premuto e"]]
E' possibile anche mettere delle scorciatoie senza usare degli elementi, basta usare il comando key:
view layout [ text "Prova a premere e" key #"e" [alert "Hai premuto e"] ]
Si possono utilizzare più pulsanti per la stessa funzione, utilizzando la parola keycode:
view layout [ text "Prova a premere e o E" key keycode [#"e" #"E"] [alert "Hai premuto e o E"] ]
Sempre grazie al comando keycode e' possibile utilizzare i tasti speciali della tastiera (Inizio, Fine, PaggUp, PagDown, le freccie, ecc.). Ecco un esempio:
view layout [ text "Prova ad usare le freccie della tastiera" key keycode [up] [alert "Hai premuto su"] key keycode [down] [alert "Hai premuto giu' "] key keycode [left] [alert "Hai premuto sinistra"] key keycode [right] [alert "Hai premuto destra"] ]
Ecco l'elenco dei tasti speciali:
| Tasto | Codice |
|---|---|
| Ins | insert |
| Canc | #"^~" |
| Home | home |
| Fine | end |
| PageUp | page-up |
| PageDown | page-down |
| Freccia sinistra | left |
| Freccia destra | right |
| Freccia su | up |
| Freccia giu' | down |
| Spazio | #" " |
| TAB | #"^-" |
| CTRL+S | #"^S" |
La combinazione con il tasto Control + un altro si ottengono indicando il carattere maiuscolo con preceduto dal carattere ^
Modificare gli elementi
E' sempre possibile modificare un elemento grafico anche dopo che e' apparso sullo schermo, basta:
- assegnargli una variabile
- modificare una sua caratteristica
- dire di far vedere la variazione (comando show)
per esempio il testo di un pulsante:
view layout [
a: button "clicca qui" [
a/text: "BRAVO!"
show a
]
]
E' possibile attivare piu' oggetti:
view layout [
b: title "Esempio"
a: button "clicca qui" [
a/text: "BRAVO!"
b/text: "BRAVO!"
show [a b]
]
]
Immagini
E' possibile mettere delle immagini con il comando image:
view layout [
image logo.gif
]
Modificare le immagini
Rebol permette di modificare le immagini, con tante funzioni a disposizioni. Prima di tutto carichiamo un'immagine:
a: load %esempio.jpg
poi possiamo estrarre delle informazioni(altezza e larghezza):
b: a/size/x c: a/size/y
a questo punto possiamo anche cambiare le dimensioni dell'immagine:
view layout[
image a 50x50
]
Poi se si mette un colore apparira' come sfondo
view layout [ image 200.123.200 logo.gif]
Effetti alle immagini
E' possibile applicare tutta una serie di effetti alle immagini:
FIT
Scala l'immagine
view layout [image logo.gif effect [fit 100x100]]
ASPECT
Scala l'immagine ma preseerva le proporzioni:
view layout [image logo.gif effect [aspect 100x100]]
Animazioni
Potete creare molto facilmente delle animazioni con il comando anim, basta avere delle immagini da inserire:
view layout [
anim rate 10 frames [ ciccio.jpg %rebologo2.gif] ]
Rebol accetta qualsiasi formato immagine (jpg, png, gif), ma non utilizzate gif animate con questo comando. Potete utilizzare gif animate da sole, senza altre immagini.
Eventi (avanzato)
Certe colte ci serve sapere dove si trova il cursore, oppure quale stato sia stato premuto, oppure ripetere ciclicamente un comando. Per tutte queste cose ci viene in aiuto il comando feel.
feel ha le seguenti eventi utilizzabili:
- redraw [face action position]
- over [face action position]
- engage [face action event]
- detect [face event]
Ogni volta che avviene un evento ad un elemento con feel, esso si attiva. Si attiva se passa sopra il mouse, se viene cliccato l'elemento e cosi' via. Bisogna capire che non c'e' differenza fra un pulsante o un'immagine, per il PC sono la stessa cosa, mentre per noi sembrano differenti.
Ogni volta che dobbiamo usare feel, va come questo esempio:
view layout [ a: box feel [
redraw: func [face act pos][print pos]
]]
Qui di seguito spiegheremo meglio.
redraw
L'evento redraw puo' essere utilizzata o per variare l'aspetto di un elemento o per attivare una funzione quando viene ridisegnata. Ma vediamolo meglio con un esempio:
view layout [
a: box green feel [
redraw: func [face act pos][
print act
print pos
? pos
]
]
button "Nascondi" [hide a]
button "Mostra" [show a]
]
Come si vede dall'esempio, la prima volta viene disegnato l'elemento e si attiva redraw, poi si attiva quando ci si clicca sopra. Se scompare non si attiva piu', e poi si riattiva quando appare.
Over
Evento molto importante, permette di sapere se il mouse e' sull'elemento, dove si trova il mouse quando viene cliccato. Un esempio chiarisce ogni dubbio:
view layout [
box "A Box" forest feel [
over: func [face act pos] [print [act pos]]
]
]
Vediamo un altro esempio molto simpatico (muovete il mouse sopra):
view layout [
box "A Box" forest feel [
over: func [face act pos] [
face/text: either act ["Over"]["Away"]
face/color: either act [brick][forest]
show face
]
]
]
E' anche possibile sapere costantemente dove si trova il mouse, e non solo quando entra/esce o viene cliccato, ma e' cattiva programmazione farlo:
out: layout [
box "A Box" forest feel [
over: func [face act pos] [print [act pos]]
]
]
view/options out [all-over]
Engage
Comando molto importante, permette di intercettare la pressione di un tasto del mouse, la posizione del mouse, timers e tante altre cose. Prima di spiegare oltre e' meglio fare un esempio di base, che anche se non molto utile apparentemente, chiarirà meglio gli esempi successivi:
view layout [
box "A Box" forest feel [
engage: func [face action event] [
print action
]
]
]
L'esempio appena descritto vi dice quando viene premuto o rilasciato il pulsante sinistro ('up' o 'down') o destro ('alt-up' o 'alt-down') del mouse. Oppure vi dirà se tenendo premuto il mouse e' sopra o no sull'elemento ('over' oppure 'away'). Anche se apparentemente non sembra molto, guardate come puo' essere sfruttato nel prossimo esempio per fare un elemento trascinabile:
view layout [
size 200x200
box 40x40 coal "Trascinami!" font-size 11 feel [
engage: func [face action event] [
if action = 'down [start: event/offset]
if find [over away] action [
face/offset: face/offset + event/offset - start
show face
]
]
]
]
La cosa bella di Rebol e' che facendo uno stile, non c'e' bisogno di ripetere gli comandi per tutti gli elementi, guardate qua:
view layout [
vtext "Trascinale tutte!"
size 240x240
style dragbox box 40x40 font-size 11 feel [
engage: func [face action event] [
if action = 'down [face/data: event/offset]
if find [over away] action [
face/offset: face/offset + event/offset - face/data
show face
]
]
]
dragbox "Box 1" navy
dragbox "Box 2" teal
dragbox "Box 3" maroon
dragbox "Box 4" gold
]
Si possono intercettare anche i pulsanti premuti, ma deve avere il focus l'elemento che ha il comando di intercettare i pulsanti, esempio:
view layout [
the-box: box "A Box" forest feel [
engage: func [face action event] [
print [action event/key]
]
]
do [ focus the-box]
]
Come vedete sono intercettati tutti i pulsanti della tastiera, del mouse e perfino la rotellina del mouse. Se volete sapere se un pulsante viene premuto insieme al tasto CONTROL o SHIFT, basta controllare lo se e' TRUE lo stato dei seguenti:
if event/control [...] ; controlla CONTROL if event/shift [...] ;controlla SHIFT if event/contro and event/shift [...] ;controlla sia CONTROL che SHIFT
E adesso parliamo di un altro evento importantissimo, i timers. E' possibile chiedere ad un elemento di ripetere un'azione un certo numero di volte al secondo oppure ogni X secondi/minuti/ore. Esempio:
view layout [
box "A Box" forest rate 1 feel [
engage: func [face action event] [
print action
]
]
]
Apparira' una volta al secondo l'evento 'timer'. Ma se avessimo scritto
rate 10
sarebbe apparso 10 volte al secondo
rate 0:00:10
sarebbe apparso ogni 10 secondi
E ora mostriamo la semplicita' del tutto, ecco a voi un orologio digitale fatto con 5 righe di codice:
view layout [
origin 0
banner "00:00:00" rate 1 feel [
engage: func [face act evt] [
face/text: now/time
show face
]
]
]
Si puo' bloccare l'iterazione continua di un timer impostando:
face/rate: none
Tutti i comandi di VID
Ecco la lista:
- face - base face style
- blank-face - empty style (transparent, minimized)
- IMAGE - base style for images
- BACKDROP - image scaled to fill pane
- BACKTILE - image tiled to fill pane
- BOX - shortcut for image
- BAR - horizontal separator
- SENSOR - transparent sensor area
- KEY - keyboard action
- BASE-TEXT - base text style
- VTEXT - video text (light on dark)
- TEXT - document text
- BODY - document text
- TXT - document text
- BANNER - video text title
- VH1 - video text heading
- VH2 - video text heading
- VH3 - video text heading
- VH4 - video text heading
- LABEL - label for dark background
- VLAB - label for dark forms, right aligned
- LBL - label for light background
- LAB - label for light forms, right aligned
- TITLE - document title
- H1 - document heading
- H2 - document heading
- H3 - document heading
- H4 - document heading
- H5 - document heading
- TT - typewriter text (monospaced)
- CODE - source code text (monospaced)
- BUTTON - rectangular, rendered buttons
- CHECK - rectangular, rendered buttons
- CHECK-MARK - transparent sensor area
- RADIO - transparent sensor area
- CHECK-LINE - base text style
- RADIO-LINE - base text style
- LED - rectangular, rendered buttons
- ARROW - rectangular, rendered buttons
- TOGGLE - rectangular, rendered buttons
- ROTARY - rectangular, rendered buttons
- CHOICE - rectangular, rendered buttons
- DROP-DOWN - document text
- ICON - base face style
- FIELD - base face style
- INFO - base face style
- AREA - base face style
- SLIDER - base face style
- SCROLLER - base face style
- PROGRESS - base style for images
- PANEL - base style for images
- LIST - base style for images
- TEXT-LIST - document text
- ANIM - base style for images
- BTN - base face style
- BTN-ENTER - base face style
- BTN-CANCEL - base face style
- BTN-HELP - base face style
- LOGO-BAR - base style for images
- TOG - base face style
RebGui
Se VID e' semplice e basilare, esiste RebGUI che è una versione di VID molto più bella da poter utilizzare. Per usarla basta aggiungere :
do %rebgui.r ;... il mio script ... ;... fine dello script... do-events
e avrete:
Per avere RebGui o vi collegate al sito di chi l'ha scritto (c'e' anche la guida): http://www.dobeash.com/rebgui.html
o la scaricate da qui: rebgui.zip
VID Extension Kit
Un altro progetto che cerca di migliorare ulteriormente le interfacce con VID e' il VID Extension Kit che potete scaricare da qui: http://hmkdesign.dk/project.rsp?id=vid-ext-kit&page=info
oppure lo potete scaricare da qui: vid_extension_kit.zip
I comandi sono gli stessi di VID a parte che si usa make-window invece di layout, ecco un esempio:
Rebol[]
do %vid-ext-kit.r
view make-window [
across
h3 "Main Window" return
bar return
label "Enter Name"
field return
ok-cancel
]
Grafica 2D (DRAW)
Per la grafica 2D conviene usare un altro dialetto di Rebol il DRAW; anche in questo caso possiamo andare piu' a fondo del draw, ma già cosi' di solito basta. Un elenco delle funzioni di DRAW lo trovate qui: http://www.rebol.com/docs/draw-ref.html vi consiglio fortemente di andarlo a leggere.
Per mettere un disegno bisogna mettere una box con l'effetto draw dove mettere il disegno, esempio:
view layout [ box effect [ draw [ arc 20x20 20x20 0 360 ] ] ]
Il sistema di riferimento parte da in ALTO A SINISTRA e prosegue verso destra (x) e verso il basso (y), esempio:
view layout [ box 100x100 effect [ draw [ arrow 1x0 line 5x5 90x5 line 5x5 5x90 text 90x5 "X" text 10x80 "Y" ]]]
Arc (ellissi)
Il comando ARC serve per fare archi, ellissi e circonferenze. Sinossi:
| Argomento | Tipo | Descrizione |
|---|---|---|
| Centro | Coppia | Centro della ellissi |
| Raggio | Coppia | Raggio dei due assi delle ellissi |
| Angolo d'inizio | decimale | Angolo d'inizio dell'arco (opzionale) |
| Angolo finale | decimale | Angolo finale dell'arco (opzionale) |
| Chiuso | parola | closed Parola opzionale per disegnare anche i raggi e chiudere gli archi aperti |
Esempio:
view layout [ box effect [ draw [ arc 40x40 40x20 0 150 closed ] ] ]
Arrow (Frecce)
Le frecce si possono mettere a molti tipi di geometrie di DRAW (linee, archi, box, polilinee), sinossi:
| Argomento | Tipo | Descrizione |
|---|---|---|
| inizio x fine | coppia | Una qualunque combinazione di 0 (nulla) 1 (punta) 2 (coda) |
Esempio:
view layout [ box 350x350 effect [ draw [ pen yellow arrow 1x2 line 20x20 100x100 pen blue arrow 1x2 curve 50x50 300x50 50x300 300x300 pen navy arrow 1x2 box 100x50 230x330 ] ] ]
BOX (rettangoli)
Per fare rettangoli, se scrivete fill-pen prima il rettangolo sarà pieno; potete riempirlo anche con una immagine (ripetuta):
| Argomento | Tipo | Descrizione |
|---|---|---|
| Angolo in alto sinistra | Coppia | Primo angolo del rettangolo |
| Angolo in basso a destra | Coppia | Ultimo angolo del rettangolo |
| Raggio di curvatura | Decimale | Se volete gli angoli arrotondati e di quanto |
Esempio:
view layout [ box 100x100 effect [ draw [
box 10x10 30x30
fill-pen red box 30x30 40x40
fill-pen logo.gif box 10x50 60x90 ]]]
CIRCLE (cerchi ed ellissi)
Il comando permette di fare cerchi ed ellissi, pieni o vuoti. Per fare cerchi basta indicare un raggio solo:
| Argomento | Tipo | Descrizione |
|---|---|---|
| Centro | Coppia | Centro della figura |
| Raggio X | Decimale | Raggio della circonferenza o primo asse dell'ellisse |
| Raggio Y | Decimale | Raggio del secondo asse dell'ellissi |
view layout [ box 100x100 effect [ draw [
circle 30x30 20
circle 60x60 35 15 ]]]
FILL-PEN
Il comando in questione permette di decidere il riempimento delle figure disegnate successivamente; si puo' usare anche un'immagine:
view layout [ box 100x100 effect [ draw [
fill-pen blue box 10x10 90x90
fill-pen yellow circle 30x70 20
]]]
Image (immagini)
Per mettere un'immagine, grazie al comando IMAGE abbiamo tantissime opzioni: si può indicare la poszione, la forma indicando 2 o 4 punti,
| Argomento | Tipo | Descrizione |
|---|---|---|
| Immagine | immagine | la variabile immagine da mostrare |
| Punto 1 | Coppia | Primo estremo alto a sinistra |
| Punto 2 | Coppia | Secondo estremo punto basso a destra (opzionale) |
| Punto 3 | Coppia | Terzo punto (opzionale) |
| Punto 4 | Coppia | Quarto punto (opzionale) |
| Colore trasparente | tripletta | Colore da rendere trasparente (opzionale) |
| Bordo | border | Se mettere una cornice (opzionale) |
view layout [ box 250x250 effect [ draw [
image logo.gif 1x1
image logo.gif 1x50 100x100
pen yellow red line-width 5 line-pattern 5 5
image logo.gif 1x100 border
pen yellow red line-width 5 line-pattern 5 5
image logo.gif 120x1 254.254.254 border
image logo.gif 1x150 150x180 150x200 1x200
]]]
LINE (linee e spezzate)
Se volete disegnare una linea o una spezzata, questo e' il comando di cui avete bisogno:
| Argomento | Tipo | Descrizione |
|---|---|---|
| Punto 1 | Coppia | Primo punto |
| Punto 2 | Coppia | secondo punto |
| Punto 3 | Coppia | terzo punto (opzionale) |
| Punto 4 | Coppia | quarto punto (opzionale) |
| Punto ... | Coppia | ... punto (opzionale), e cosi' via |
view layout [ box 100x100 effect [draw [ line 1x1 90x1 1x90 90x90 50x50 ]]]
LINE-WIDTH (spessore linea)
Usato per variare lo spessore delle linee:
| Argomento | Tipo | Descrizione |
|---|---|---|
| spessore | decimale | spessore della linea |
view layout [ box 100x100 effect [ draw [
line-width 5 line 50x50 70x100 80x50 25x90
]]]
PEN (impostare i colori)
Con il comando PEN si impostano il colore della penna:
| Argomento | Tipo | Descrizione |
|---|---|---|
| colore | tripletta | colore linea |
| colore | tripletta | colore linea pattern (opzionale) |
| immagine | tripletta | per usare un'immagine |
view layout [ box 100x100 effect [ draw [
pen yellow red line-width 5 box 50x50 250x250
pen logo.gif line-width 10 box 0x0 50x50
]]]
Polygon
Serve per fare figure chiuse:
| Argomento | Tipo | Descrizione |
|---|---|---|
| punto | coppia | primo punto |
| punto | coppia | secondo punto |
| punto | coppia | terzo punto |
| ... | coppia | ... |
view layout [ box 100x100 effect [ draw [
polygon 1x1 1x60 60x1 50x50
]]]
ROTATE (ruotare)
Con rotate si ruota il sistema di riferimento per i comandi che vengono dopo:
| Argomento | Tipo | Descrizione |
|---|---|---|
| angolo | decimale | angolo di rotazione |
view layout [ box 100x100 effect [ draw [
fill-pen blue box 1x1 25x25
rotate 30
box 50x50 25x25
box 90x1 50x50
]]]
SCALE (scalare)
Si cambia la scala dei comandi, si puo' scegliere che valga solo per un asse:
| Argomento | Tipo | Descrizione |
|---|---|---|
| scala su x | decimale | scala dell'asse x |
| scala su y | decimale | scala dell'asse y |
view layout [ box 100x100 effect [ draw [
fill-pen red box 0x0 100x100
scale 0.5 0.5
fill-pen blue box 0x0 100x100
]]]
SPLINE (linea curva)
Permette di ottenere una linea curva tra un qualsiasi numero di punti, la curva sara' molto morbida se sara' indcato un numero di segmenti da utilizzare elevato:
| Argomento | Tipo | Descrizione |
|---|---|---|
| numero segmenti | intero | numero di segmenti tra ogni punto |
| closed | closed | parola da utilizzare se la si vuole chiusa (opzionale) |
| punto | coppia | primo punto |
| punto | coppia | secondo punto |
| punto | coppia | terzo punto |
| ... | coppia | ... |
view layout [ box 100x100 effect [ draw [
spline 10 closed 20x20 25x90 80x80 70x25
pen red spline 2 closed 20x20 25x90 80x80 70x25
]]]
TEXT (testo)
ATTENZIONE: su Linux c'e' un piccolo bug, non trova il font giusto, prima di tutto aggiungete questo codice:
switch system/version/4 [
4 [ ;it's Linux
my-font: make face/font [
name: "/usr/share/fonts/truetype/freefont/FreeSans.ttf" ;replace with your path to font you prefe
size: 12
]
]
]
e usate my-font cone font per il testo, altrimenti non vedrete nessuna scritta e nessun disegno dopo il comando text.
TEXT: con questo comando possiamo inserire il testo, mentre con il comando font possiamo scegliere il tipo di font utilizzare:
| Argomento | Tipo | Descrizione |
|---|---|---|
| testo | stringa | la stringa da inserire |
| posizione | coppia | la posizione della frase da inserire |
| modo | anti-aliased/vectorial/aliased | la modalità nello scriverla (opzionale) |
view layout [ box 300x100 effect [ draw [
text "This is a string of text - Default size (12)" 1x10
text aliased "This is a string of text 2" 1x25
text vectorial "This is a string of text 1" 1x75
]]]
TRANSLATE (traslare)
Trasla l'origine, con il comando reset-matrix rimettete tutto a posto:
| Argomento | Tipo | Descrizione |
|---|---|---|
| traslazione | coppia | spostamento dell'origine |
view layout [ box 100x100 effect [ draw [
circle 1x1 10
pen red
translate 20x20
circle 1x1 10
pen blue
translate 20x20
circle 1x1 10
reset-matrix
pen green
box 1x1 10x10
]]]
Grafica 2D (SHAPE)
SHAPE e' un altro dialetto che permette di disegnare forme del tutto arbitrarie, utilizzando posizioni relative o assolute. Grazie a SHAPE e' possibile avere dei disegni compatibili con i disegni vettoriali SVG (v. http://www.w3.org/TR/SVG11/paths.html )
Ogni volta che disegnamo una figura con SHAPE, se non specificato diversamente, Rebol la chiudera'. SHAPE si usa dentro DRAW, ecco un esempio ingombrante:
view layout [
box 300x400 effect [ draw [
pen yellow line-width 4 fill-pen red
shape [
move 100x175
arc 75 200x175 false true
line 100x175
move 100x200
arc 100 200x200 true true
line 100x200
]]]]
Adesso sara' elencata una lista dei comandi.
Posizioni relative e assolute
Quando un comando e' preceduto dall'apostrofo, vuol dire che le coordinate sono da intendersi relative. Quando un comando non e' preceduto dall'apostrofo e' da intendersi che le coordinate sono assolute. Esempio:
view layout [box 120x30 effect [ draw [ shape [ move 10x10 'line 100x0 ] pen red shape [ move 10x20 line 100x0 ] ]]
ARC
Disegna una curva ellittica dall'ultimo punto al punto indicato. LARGE va impostato per archi maggiori di 180 gradi.
| Descrizione | Tipo |
|---|---|
| punto arrivo | coppia |
| raggio x | intero |
| raggio y | intero |
| angolo | decimale |
| sweep | logico |
| largo | logico |
Esempio
view layout [box 400x400 effect [
draw [
pen yellow line-width 4
shape [
move 100x200
arc 75 200x200 false false
]
pen red shape [
move 100x205
arc 75 200x205 true false
]
pen green line-width 4 shape [
move 150x200
arc 75 200x200 false true
]
pen blue shape [
move 150x205
arc 75 200x205 true true
]]]]
CURV
Disegna una curva morbida. Servono almeno 2 punti.
| Descrizione | Tipo |
|---|---|
| punto1 | coppia |
| punto2 | coppia |
| punto1 | coppia |
| punto2 | coppia |
| punto1 | coppia |
| ... | coppia |
Esempio
view layout [ box 300x300 effect [ draw [ shape [ move 100x50 vline 150 curv 300x150 300x50 move 0x0 ]]]]
CURVE
Disegna una cirva cubica di Beizer, servono almeno 3 punti:
| Descrizione | Tipo |
|---|---|
| punto1 | coppia |
| punto2 | coppia |
| punto3 | coppia |
| punto1 | coppia |
| punto2 | coppia |
| ... | coppia |
view layout [ box 300x300 effect [ draw [ shape [ move 100x50 curve 100x150 300x150 300x50 move 0x0 ]]]]
HLINE
Disegna un linea orizzontale dal punto corrente:
| Descrizione | Tipo |
|---|---|
| lunghezza | decimale |
view layout [ box 300x300 effect [ draw [ shape [ move 100x100 hline 50 ]]]]
LINE
Disegna una spezzata:
| Descrizione | Tipo |
|---|---|
| punto1 | coppia |
| punto2 | coppia |
| punto3 | coppia |
| ... | coppia |
view layout [ box 300x300 effect [ draw [ shape [ move 100x100 line 50x50 20x220 120x42 ]]]]
MOVE
Imposta il nuovo punto di partenza per una nuova forma, senza disegnare nulla. Può essere utilizzato per non chiudere le forme:
| Descrizione | Tipo |
|---|---|
| punto1 | coppia |
view layout [ box 300x300 effect [ draw [ shape [ move 20x20 line 20x100 100x100 120x20 ] pen red shape [ move 25x25 line 25x105 105x105 125x25 move 0x0 ]]]]
QCURV
Disegna una curva di Bezier fino al punto indicato:
| Descrizione | Tipo |
|---|---|
| punto1 | coppia |
view layout [ box 300x300 effect [
draw [ shape [
move 0x150
qcurve 100x250 200x150
qcurv 400x150
move 0x0
]]]]
VLINE
Disegna una linea verticale dalla posizione corrente:
| Descrizione | Tipo |
|---|---|
| lunghezza | decimale |
view layout [ box 300x300 effect [ draw [ shape [ move 100x100 vline 50 ]]]]
3D
Rebol gestisce e puo' creare immagini tridimensionali (il 3D), grazie allo script r3d2.r che potete scaricare da qui:
http://www.rebol.org/view-script.r?script=r3d2.r
se volete divertirvi con un demo, vi consiglio questo (l'ho scritto io):
http://www.rebol.org/view-script.r?script=advanced-r3d.r
ecco cosa fa:
Tutta la documentazione per usarla è qui: http://www.rebol.org/documentation.r?script=r3d2.r
La libreria carica anche i file 3D in formato OFF, ecco un esempio:
Suono
Con Rebol e' possibile anche utilizzare i suoni.
Aprire e chiudere una porta audio
L'audio per Rebol e' una porta quindi va aperta e chiusa. Per vedere se potete usare l'audio, lanciate:
if error? try [ sound-port: open sound:// close sound-port ] [ alert "Non puoi accedere all'audio" quit ]
Se non vi appare un messaggio di errore, potete usare l'audio.
Come avete visto dall'esempio, per aprire una porta audio bisogna usare il seguente comando:
audio1: open sound://
al posto della variabile audio1 potete usare quello che vi pare. Una volta aperta la porta, le altre applicazioni non possono accedervi. Quando abbiamo finito con l'audio ricordiamo di chiuderlo:
close audio1
Suonare un file
Rebol accetta come formato dei file il wav. Ecco come far suonare un file:
audio1: open sound:// a: load %esemepio.wav insert audio1 a wait audio1 close audio1
Migliorare l'audio
Quando carichiamo un suono, possiamo modificare la qualita' del suono. E' possibili variare i seguenti parametri:
- data, i dati del file audio
- volume, il volume dell'audio; valore tra 0 e 1
- channels, quanti canali se 1 o 2
- bits, i bit di campionamento se 8, 16, 24, 32
- rate, il frequenza di campionamento in Hertz
si modificano come i dati di un oggetto:
a: load %esempio.wav a/volume: 0.5 a/channels: 2
Rebol plugin
Esiste il plugin per i browser tipo Firefox, Opera e Internet Explorer. Per ora funziona solo su windows. Per installarlo basta:
- scaricarlo da http://www.rebol.com/plugin/rebol-operab2.zip
- scompattare i files e copiarli nella directory dei plugin del browser; ad esempio per Firefox e' C:/Program Files/Mozilla Firefox/plugins/
- riavviare il browser
Potete provare il seguente link, se appare un quadrato colorato, funziona: http://www.rebol.com/plugin/web-plugin-install.html
Come scrivere una pagina web per il plugin?
E' moolto facile scrivere una pagina web per il plugin, basta incorporare pochissime righe tipo:
<embed type="application/x-rebol-plugin-v1"
WIDTH="200" HEIGHT="40" BORDER="1"
LaunchURL="http://www.rebol.net/plugin/demos/ready.r" >
</embed>
Semplicissimo, basta impostare:
- l'altezza e la larghezza corretta della finestra del plugin (WIDTH e HEIGHT)
- il tipo di plugin (application/x-rebol-plugin-v1)
- il link dello script rebol (LAUNCHURL)
Altri esempi li trovate qui: https://www.maxvessi.net/rebsite/plugin/index.html
Su un server meglio del PHP (script CGI)
Rebol può essere installato su un server come eseguibile per degli script CGI! In questo modo il server potra' creare dell pagine dinamice, come fa il PHP, ma con un liguaggio molto piu' semplice! Per prima cosa bisogna scaricare la versione CORE, sempre gratuita, dal sito: http://www.rebol.com/download-core.html e installarla sul proprio server. Le altre versioni non vanno bene per gli script.
A questo punto e' possibile creare degli script come fossero normali script, basta ricordarci di mettere sempre come prima riga il percorso dell'eseguibile rebol-core con l'opzione -cs e come primo output la seguente:
print "Content-type: text/html^/"
in modo che il nostro server non ci dia problemi.
Se tutto e' andato per il verso giusto possiamo provare con il seguente file, esempio.cgi:
#! /home/max/public_html/rebol-core -cs Rebol [ title: "Esempio.cgi"] print "Content-type: text/html^/" print [<html><body> "REBOL CGI funziona!" <br> "Sono le ore: " now/time </body></html>]
e se vi collegherete col vostro browser alla pagina dello script, vi apparira':
REBOL CGI funziona! Sono le ore: 16:32:17
L'opzione -cs significa:
- c per script CGI
- s per "nessun problema di sicurezza"