Main

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:

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:

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:

Locations of visitors to this page

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:

http://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: http://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:

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!

Email

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:

NameValueColor  NameValueColor
aqua40.100.130 base-color200.200.200 
beige255.228.196 black0.0.0 
blue0.0.255 brick178.34.34 
brown139.69.19 coal64.64.64 
coffee76.26.0 crimson220.20.60 
cyan0.255.255 forest0.48.0 
gold255.205.40 gray128.128.128 
green0.255.0 ivory255.255.240 
khaki179.179.126 leaf0.128.0 
linen250.240.230 magenta255.0.255 
maroon128.0.0 mint100.136.116 
navy0.0.128 oldrab72.72.16 
olive128.128.0 orange255.150.10 
papaya255.80.37 pewter170.170.170 
pink255.164.200 purple128.0.128 
reblue38.58.108 rebolor142.128.110 
red255.0.0 sienna160.82.45 
silver192.192.192 sky164.200.255 
snow240.240.240 tan222.184.135 
teal0.128.128 violet72.0.90 
water80.108.142 wheat245.222.129 
white255.255.255 yellow255.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:

ListaComandiRebol.pdf

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:

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:

  1. Salvare il contenuto della pagina http://www.rebol.com in un file chiamato rebol.html
  2. Scrivere un programma che chieda all'utente di fornire 3 numeri e far indicare al programma quale sia il piu' alto.
  3. Fare un programma che chieda all'utente continuamente un numero, e stampi la media di tutti i numeri inseriti fino a quel momento.
  4. Come l'esercizio precedente ma per un gruppo di numeri arbitrari, deciso volta per volta dall'utente (per 5 numeri, per 3, per 12...)
  5. Calcolare il numero di giorni dal proprio compleanno.
  6. 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:

VariabileTipoDescrizione
namestring!Nome del font, rebol ha già in memoria: font-serif, font-sans-serif , e font-fixed. Default e' font-sans-serif.
sizeinteger!Grandezza del font
styleword! o block!Stile del testo: bold, italic, underline o none. Si può usare anche un blocco con tutti insieme.
colortuple!Colore del testo, default e' 0.0.0
alignword!Allineamento del testo. Le scelte sono: left, right, and center.
valignword!Allineamento verticale del testo, le scelte sono: top, bottom e middle.
offsetpair!L'offest del testo dall'angolo in alto a sinistra. Default e' 2x2.
spacepair!Spazio tra caratteri e righe di testo, default e' 0x0.
shadowpair!Ombreggiatura, quando deve essere spostata, default e' 0x0

Para

Para puo' impostare le seguenti variabili:

VariabileTipoDescrizione
originpair!L'offset del testo dall'angolo in alto a sinistra. Default e' 2x2.
marginpair!Il margine estremo in basso a destra del testo. Default e' 2x2.
indentpair!Lo spaziamento della prima riga del paragrafo, si possono usare anche valori negativi. Default e' 0x0.
scrollpair!Utilizzato per lo scrolling, default e' 0x0.
tabsinteger! 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:

TastoCodice
Insinsert
Canc#"^~"
Homehome
Fineend
PageUppage-up
PageDownpage-down
Freccia sinistraleft
Freccia destraright
Freccia suup
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:

ArgomentoTipoDescrizione
CentroCoppiaCentro della ellissi
RaggioCoppiaRaggio dei due assi delle ellissi
Angolo d'iniziodecimaleAngolo d'inizio dell'arco (opzionale)
Angolo finaledecimaleAngolo finale dell'arco (opzionale)
Chiusoparolaclosed 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:

ArgomentoTipoDescrizione
inizio x finecoppiaUna 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):

ArgomentoTipoDescrizione
Angolo in alto sinistraCoppiaPrimo angolo del rettangolo
Angolo in basso a destraCoppiaUltimo angolo del rettangolo
Raggio di curvaturaDecimaleSe 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:

ArgomentoTipoDescrizione
CentroCoppiaCentro della figura
Raggio XDecimaleRaggio della circonferenza o primo asse dell'ellisse
Raggio YDecimaleRaggio 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,

ArgomentoTipoDescrizione
Immagineimmaginela variabile immagine da mostrare
Punto 1CoppiaPrimo estremo alto a sinistra
Punto 2CoppiaSecondo estremo punto basso a destra (opzionale)
Punto 3CoppiaTerzo punto (opzionale)
Punto 4CoppiaQuarto punto (opzionale)
Colore trasparentetriplettaColore da rendere trasparente (opzionale)
BordoborderSe 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:

ArgomentoTipoDescrizione
Punto 1CoppiaPrimo punto
Punto 2Coppiasecondo punto
Punto 3Coppiaterzo punto (opzionale)
Punto 4Coppiaquarto 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:

ArgomentoTipoDescrizione
spessoredecimalespessore 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:

ArgomentoTipoDescrizione
coloretriplettacolore linea
coloretriplettacolore linea pattern (opzionale)
immaginetriplettaper 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:

ArgomentoTipoDescrizione
puntocoppiaprimo punto
puntocoppiasecondo punto
puntocoppiaterzo 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:

ArgomentoTipoDescrizione
angolodecimaleangolo 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:

ArgomentoTipoDescrizione
scala su xdecimalescala dell'asse x
scala su ydecimalescala 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:

ArgomentoTipoDescrizione
numero segmentiinteronumero di segmenti tra ogni punto
closedclosedparola da utilizzare se la si vuole chiusa (opzionale)
puntocoppiaprimo punto
puntocoppiasecondo punto
puntocoppiaterzo 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:

ArgomentoTipoDescrizione
testostringala stringa da inserire
posizionecoppiala posizione della frase da inserire
modoanti-aliased/vectorial/aliasedla 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:

ArgomentoTipoDescrizione
traslazionecoppiaspostamento 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.

DescrizioneTipo
punto arrivocoppia
raggio xintero
raggio yintero
angolodecimale
sweeplogico
largologico

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.

DescrizioneTipo
punto1coppia
punto2coppia
punto1coppia
punto2coppia
punto1coppia
...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:

DescrizioneTipo
punto1coppia
punto2coppia
punto3coppia
punto1coppia
punto2coppia
...coppia
 view layout [ box 300x300 effect [
  draw [ shape [ 
   move 100x50
   curve 100x150 300x150 300x50
   move 0x0 
   ]]]]

HLINE

Disegna un linea orizzontale dal punto corrente:

DescrizioneTipo
lunghezzadecimale
 view layout [ box 300x300 effect [
  draw [ shape [ 
   move 100x100
   hline  50
   ]]]]

LINE

Disegna una spezzata:

DescrizioneTipo
punto1coppia
punto2coppia
punto3coppia
...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:

DescrizioneTipo
punto1coppia
 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:

DescrizioneTipo
punto1coppia
 view layout [ box 300x300 effect [
  draw [ shape [ 
        move 0x150
	qcurve 100x250 200x150
	qcurv 400x150
	move 0x0
   ]]]]

VLINE

Disegna una linea verticale dalla posizione corrente:

DescrizioneTipo
lunghezzadecimale
 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:

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: http://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"

HomePage

Guide

Altro

Translate:

Pubblicità:

Licenza Creative Commons
DuckDuckGo

edit SideBar

edit TopNav

Blix theme adapted by David Gilbert, powered by PmWiki