Gli script di Jaws 04. Variabili, Costanti, Messaggi e livelli di prolissità.

Programmiamoli da Soli!

Le basi indispensabili.

In questo capitolo iniziamo ad affrontare una prima serie di argomenti, divenuti necessari per poter proseguire nel nostro viaggio in modo sempre più efficace. In particolare, ci occuperemo principalmente di:

  1. Variabili.
  2. Variabili globali.
  3. Costanti.
  4. Messaggi.

L’aver atteso fino al quarto capitolo per accennare a questi fondamentali argomenti è stata una precisa scelta, in quanto il loro uso rappresenta l’ingresso definitivo nell’ambito della programmazione, un livello di conoscenza che non a tutti può interessare. Si spera che l’essere arrivati sin qui, riuscendo in qualche modo a creare qualcosa di concreto senza nemmeno avere questo tipo di nozioni, possa aver fatto crescere in qualcuno la voglia di andare avanti, di approfondire gli argomenti fin qui trattati.

In particolare per i neofiti del tema, si cercherà comunque di introdurre i concetti per gradi, alternandoli con i soliti esempi pratici. Al fine di non correre il rischio di fornire informazioni errate o imprecise, abbiamo qua e là attinto alla traduzione del libro
"Tutto ciò che avreste voluto sapere su come scrivere gli script JAWS, ma che non sapevate a chi chiedere"
, di Kenneth A. Gould.

Il capitolo si concluderà poi parlando di alcune funzioni di lettura, e dei
livelli di prolissità
, cercando di spiegare cosa siano e come funzionino nella pratica quotidiana.

Ora, quindi, partiamo dall’inizio, affrontando un concetto chiave della programmazione, analizzato come sempre prima in linea teorica e poi nelle sue applicazioni pratiche.

***

Variabili.

Una variabile è una parola di una o più lettere che può essere utilizzata per memorizzare un valore che viene determinato durante l’elaborazione degli script. Spesso questo valore non è già conosciuto, e comunque può cambiare una o più volte durante l’elaborazione dello script. Il valore che viene determinato è assegnato alla variabile nel corso dell’operazione dello script, che lo mantiene fino a quando non venga eventualmente modificato da un’altra operazione. Il valore di questa variabile può essere utilizzato dallo stesso script o da un altro per elaborare il proprio codice.

Ad esempio, nella seguente assegnazione:


Let x = 1

x
è la variabile, cui viene assegnato il valore 1. La variabile x mantiene il valore 1 fino al momento in cui lo modifichiamo noi, oppure viene modificato da un’operazione dello script.

La parola chiave
Let
, (Permetti), è quella che viene utilizzata per assegnare direttamente un valore a una variabile. In realtà, la parola chiave non sarebbe indispensabile, perché sarebbe valida anche un’assegnazione come la seguente:


x = 1

Si consiglia tuttavia di usare la formula con
Let
, se non altro per poter poi individuare più velocemente le assegnazioni di valori in una successiva fase di revisione degli script.

Le variabili sono necessarie in tutti quei casi in cui il dato, fornito da una funzione o impostato tramite uno script, va usato più volte, oppure quando è necessario modificarne il valore.

Ad esempio, se noi ci servissimo della funzione
GetCursorRow ()
, che abbiamo già esaminato restituirci il numero della riga corrente, per realizzare questa assegnazione:


Let x = GetCursorRow ()

avremmo memorizzato nella variabile x il risultato della funzione, e quindi il valore della riga sul cursore in quel momento.

Ora, prima di passare ad un esempio pratico, facciamo un’importante premessa teorica.

Dichiarare le variabili.

In pratica, tutto quello che appare dentro un file script deve essere conosciuto da Jaws.

Se vi ricordate, quando avevamo creato il primo script, era stato fatto notare che la procedura guidata aveva aggiunto al nome che noi avevamo specificato, la parola chiave
Script
. In altre parole, quando Jaws trova quella parola, sa che tutto il codice che troverà da lì all’istruzione di fine,
EndScript
, appartiene ad uno script. Poi, sinora, dentro agli script abbiamo usato solo delle funzioni integrate del programma di sintesi vocale, che quindi Jaws conosce.

Ora, se noi vogliamo usare delle variabili in uno script, la prima cosa da fare è dire a Jaws, appunto, che stiamo per usarle, un’azione che si chiama
dichiarare
le variabili.

in questo caso la parola chiave da usare è
Var
, che sta come diminutivo proprio di variabili. Così Jaws sa che tutto quello che troverà da lì alla fine della dichiarazione riguarda questo tipo di elementi.

Poi, dopo l’iniziale parola chiave, Jaws si aspetta che noi facciamo sapere di che tipo siano, queste variabili. Se ricordate, parlando dei parametri nelle funzioni, avevamo già incontrato i due tipi principali di dati, che corrispondono, in ordine alfabetico, ad altrettanti tipi di variabili:

  1. Integer
    , per i numeri interi, che si abbrevia con
    Int.
  2. String
    , per i dati testuali.

Queste parole chiave sono usate per indicare a Jaws il tipo di variabile che abbiamo intenzione di usare, seguito immediatamente dal nome della stessa variabile.

Riprendendo l’esempio precedente, volendo memorizzare il risultato della funzione
GetCursorRow ()
, si tratta di un dato numerico che deve essere quindi dichiarato come di tipo
Int
, usando la forma seguente:


Var Int x

La dichiarazione, iniziata con la parola chiave, si può concludere anche solo andando a capo riga, senza specificare nulla.

Quando, come spesso accade, le variabili da dichiarare in uno script sono più di una, le diverse dichiarazioni vanno separate l’una dall’altra tramite un carattere Virgola.

In questo caso, la prassi consiglia di porre la parola chiave
Var
in una riga a sé stante, seguita dalle altre singole dichiarazioni ciascuna in una propria riga.

Di seguito poniamo un esempio di dichiarazione multipla, dove è stata usata anche una variabile di tipo testuale, che quindi ha il prefisso
String:


Var
Int x,
String y,
Int z

In modo analogo a quella singola, anche le dichiarazioni multiple si concludono con l’ultima dichiarazione dell’elenco che va a capo riga, senza alcun segno di punteggiatura.

Assegnare un valore alle variabili.

Intanto, una cosa importante: quando si dichiara una variabile con l’apposita parola chiave, esse assumono:

  1. Nel caso di valori di tipo Integer, il numero 0.
  2. Nel caso di dati di tipo String, un carattere nullo, che equivale ad una coppia di caratteri virgolette, senza spazi tra di esse.

Successivamente, per assegnare un valore ad una variabile, dopo il segno di uguale,
=
, si può specificare:

  1. Per i dati Integer, un numero intero, o un’altra variabile di tipo Integer.
  2. Per i dati testuali, una stringa di caratteri posti tra virgolette, o un’altra variabile di tipo String.

Spesso ad una variabile si assegna direttamente il risultato di una funzione, come nel nostro precedente esempio. In tal caso, nella descrizione di ciascuna singola funzione è specificato di quale tipo di dato sia il loro risultato, che se ricordate si chiama
ritorno
. Ovviamente, per non creare un errore nello script, bisogna cercare di rispettare questa corrispondenza tra ritorni delle funzioni e tipi di dati impostati per le variabili.

Quando tale corrispondenza non è possibile, si dovranno convertire i dati nella forma necessaria, tramite apposite funzioni di Jaws.

Ad esempio, sempre occupandoci dei due tipi di dati principali, per:

  1. Convertire un valore numerico in testuale, usare la funzione
    IntToString ()
    , che abbiamo già incontrato nel secondo capitolo.
  2. Convertire un dato testuale in numerico, usare la funzione
    StringToInt
    , che significa appunto (DaTestoANumero).

In ogni caso, se si sbaglia ad abbinare un dato, oppure un ritorno di una funzione ad una variabile, quando si andrà a compilare lo script sarà segnalato l’errore, portando il cursore nella riga dove si è verificata l’errata assegnazione.

Infine, per quanto riguarda il nome da assegnare ad una variabile, esso sarebbe libero, purché non si usino nomi già assegnati a script o funzioni integrate di Jaws. Nel caso della nostra lingua, il problema è facilmente aggirabile usando nomi e termini in italiano, poiché quelli usati da Jaws sono tutti in inglese.

Nei brevi esempi finora mostrati sono state utilizzate delle variabili composte da una sola lettera, più che altro per semplificarne la comprensione. Solitamente, invece, i nomi sono composti da più parole, magari anche in combinazione con numeri, così da chiarirne subito il significato.

Anche per questo, esiste la convenzione di anteporre una lettera identificativa al nome di variabile, che faccia capire il tipo di dato in essa inserito. Se ad esempio noi volessimo dare il nome
"Pippo"
ad una variabile, potremmo usare:

  1. iPippo, nel caso di numero intero (Integer).
  2. sPippo, in caso di dato testuale (String).

Si tratta tuttavia soltanto di una prassi, che ciascuno può seguire oppure no. Se si decide di seguire questo sistema, per garantire una buona leggibilità del codice, converrebbe sempre mantenere le lettere identificative minuscole, seguite dal nome vero e proprio della variabile con l’iniziale maiuscola.

A questo punto, prima di passare all’esercitazione pratica sulle variabili, presentiamo come Jaws affronta due importanti argomenti.

Elaborare data e ora con Jaws.

Nel mondo di Jaws, ci sono molte funzioni, ed un paio di script, che si occupano di gestire l’elaborazione delle informazioni relative a data ed ora. Qui ora presenteremo soltanto le due funzioni principali:

  1. SysGetTime
    , (OttieniOraDiSistema), chiamata anche dagli script di Jaws premendo
    TastoJaws+F12.
  2. SysGetDate
    , (OttieniDataDiSistema), a sua volta chiamata premendo
    TastoJaws+F12
    , ma due volte velocemente.

Il risultato di entrambe le funzioni sarà un dato testuale, che dovrà quindi essere rielaborato, o sottoposto ad una funzione di lettura, per poter essere visualizzato. Entrambe, poi, hanno un funzionamento analogo, in quanto dispongono di un massimo di quattro parametri, i quali possono essere tuttavia omessi poiché sono facoltativi.

Se si utilizza tali funzioni senza parametri, saranno restituite l’ora o la data di sistema, sulla base del modo di farlo impostato come predefinito. Se invece si specificano dei parametri, questi possono essere:

  • Il primo, con il quale sarà possibile specificare una stringa di caratteri speciali, posti direttamente tra virgolette o tramite una variabile, con i quali si dice a Jaws, tra i dati a disposizione, quali debbano essere visualizzati, e in che modo.
  • Gli altri tre, in cui si possono inserire dei valori numerici, anche qui in modo diretto oppure tramite variabili, con i quali si imposta un orario o una data alternativa da far visualizzare.

Le stringhe di Formattazione.

La stringa di caratteri speciali, che in questo caso sono da inserire come primo parametro, è detta di
Formattazione
. Questo termine, di solito usato parlando di come impaginare il testo in un documento, qui sta ad indicare una serie di caratteri
segnaposto
che sono destinati ad essere sostituiti da dei valori o da altri caratteri.

Tanto per essere più chiari, la seguente istruzione:


SysGetTime ("HH:mm")

restituirà un testo in cui vi sarà l’ora corrente del sistema seguita dai minuti, con i due valori separati dal carattere Due Punti.

In questo caso, dunque, la stringa
"HH:mm"
, che avevamo inserito all’interno delle parentesi, è quella che abbiamo chiamato di formattazione, mentre il risultato della funzione sarà un testo che chiameremo dunque
formattato
. Questi termini, e questo concetto in generale, è spesso presente nel campo della programmazione con un tale tipo di significato, e lo troveremo ripreso più avanti anche in questo stesso capitolo.

Tornando all’esempio proposto, se avete notato, le prime due lettere della stringa di formattazione sono maiuscole, mentre la seconda coppia sono invece minuscole. Almeno nel caso di queste due funzioni, infatti, porre un carattere maiuscolo o minuscolo può far cambiare il risultato testuale ottenuto, ed è quindi un particolare cui prestare attenzione.

Per concludere l’argomento, poniamo di seguito i due elenchi di caratteri per la formattazione, nell’ordine in cui le due funzioni sono state proposte.

I caratteri di formattazione per SysGetTime ()

.

  • Singola h minuscola. = ora, sistema 12 ore, cifra singola.
  • Doppia h minuscola. = ora, sistema 12 ore, doppia cifra con eventuale zero iniziale.
  • Singola H maiuscola. = ora, sistema 24 ore, cifra singola.
  • Doppia H maiuscola. = ora, sistema 24 ore, doppia cifra con eventuale zero iniziale.
  • Singola m minuscola. = minuto, cifra singola.
  • Doppia m minuscola. = minuto, doppia cifra con eventuale zero iniziale.
  • Singola s minuscola. = secondi, cifra singola.
  • Doppia s minuscola. = secondi, doppia cifra con eventuale zero iniziale.

I caratteri di formattazione per SysGetDate ()

.

  • Singola d minuscola. = giorno, cifra singola.
  • Doppia d minuscola. = giorno, doppia cifra con eventuale zero iniziale.
  • Tripla d minuscola. = giorno, forma letterale abbreviata, a tre lettere.
  • Quadrupla d minuscola. = giorno, forma letterale completa.
  • Singola g minuscola. = Iniziali dopo Cristo, (D.C.)
  • Singola M maiuscola. = mese, cifra singola.
  • Doppia M maiuscola. = mese, doppia cifra con eventuale zero iniziale.
  • Tripla M maiuscola. = mese, forma letterale abbreviata, a tre lettere.
  • Quadrupla M maiuscola. = mese, forma letterale completa.
  • Singola, o doppia, y minuscola. = anno, ultime due cifre.
  • Tripla, o quadrupla, y minuscola. = anno, a quattro cifre.

I parametri numerici di SysGetTime () e SysGetDate ().

Parlando dei tre parametri numerici delle due funzioni trattate, iniziamo a dire che questi vanno utilizzati in due modi:

  1. Senza specificare nessuno dei tre, e lasciando in tal modo che i dati restituiti dalla funzione si riferiscano all’ora o alla data di sistema.
  2. Indicandoli tutti e tre, e così facendo restituire dei dati relativi a ore o date da voi decise tramite i valori inseriti.

Va subito precisato che questa impostazione riguarda solo quanto viene restituito dalla funzione, mentre l’ora o la data di sistema rimangono inalterati. Inoltre, se si volessero specificare soltanto questi tre parametri, senza specificare alcuna stringa di formattazione, si dovrà comunque porre come primo parametro una coppia di virgolette, o una variabile testuale vuota.

Nel dettaglio, proponiamo l’elenco completo dei parametri di ciascuna delle due funzioni.

I parametri di SysGetTime ().

  1. L’eventuale stringa di formattazione dei dati. Qualora non si specifichi, saranno restituite ore e minuti separati dai Due Punti.
  2. L’ora che si vuole sia elaborata, indicando un numero tra 0 e 23.
  3. I minuti, specificando un valore tra 0 e 59.
  4. I secondi, anche qui indicando un numero tra 0 e 59.

I parametri di SysGetDate ().

  1. L’eventuale stringa di formattazione dei dati. Qualora non la si specifichi, sarà restituita la data in forma estesa, con nome del giorno, valore del giorno, mese ed anno.
  2. Il mese di una data personalizzata, con un numero tra 1 e 12.
  3. Il giorno, specificando un valore valido per il mese indicato.
  4. L’anno, ponendo un numero di quattro cifre.

Errori nell’indicare ore o date alternative.

  1. Quando si indicano direttamente i dati, bisogna intanto porli tutti e tre, pena il proporsi di un errore in fase di esecuzione dello script.
  2. Bisogna fare attenzione nei dati da inserire, in quanto se si esprime un dato non conforme ad esempio le ore 24, oppure il 30 di febbraio, o il 31 di aprile, la compilazione dello script non vi darà alcun errore, ma quando lo stesso script sarà eseguito, al posto dei dati richiesti, sarà restituito questo messaggio, al quale non serve la traduzione:
  3. "Error: invalid parameter"

Eseguire calcoli con Jaws.

Prima di iniziare la parte pratica, vale la pena precisare che negli script per Jaws non sono disponibili particolari comandi o funzioni matematiche. Per eseguire qualsiasi tipo di calcolo, così come dovremo fare nel primo script da realizzare, si dovranno perciò usare i seguenti operatori matematici:

  1. Più,
    +
    , per l’addizione.
  2. Meno,

    , per la sottrazione.
  3. Asterisco,
    *
    , per la moltiplicazione.
  4. Barra,
    /
    , per la divisione.
  5. Percento,
    %
    , per la percentuale.

Qualora i calcoli da effettuare prevedano più espressioni matematiche, per ottenere un risultato, ogni singola operazione andrà racchiusa dentro ad una coppia di parentesi tonde. Seguendo la classica priorità matematica, saranno quindi eseguiti prima i calcoli tra parentesi, e tra questi quelli più interni, così peraltro come succede per i risultati delle funzioni di Jaws.

Esercizio 4.2.5. Lo script DataOra.

Concludiamo questa ampia parentesi dedicata alle due funzioni prese in esame con la solita esercitazione pratica, sia pure realizzando uno script che serve soprattutto a scopo didattico. In particolare, il suo compito principale sarà come dichiarare, assegnare ed elaborare le variabili, convertendone il valore da testuale a numerico e viceversa, ma potremo anche analizzare due esempi di come servirsi delle stringhe formattate per far visualizzare la data e l’ora.

FileScript.

Default.JSS

Nome.

DataOra

Sommario.

Legge data ed ora correnti.

Descrizione.

Pronuncia la data e l’ora corrente in forma estesa, leggendo anche le ore ed i minuti mancanti alla mezzanotte.

TastiAttivazione.

Control+Windows+BarraSpazio

Novità.
  1. Il comando
    Var
    , e le successive dichiarazioni delle variabili di tipo
    Int
    e
    String.
  2. Le funzioni
    SysGetDate ()
    e
    SysGetTime ()
    , ampiamente descritte.
  3. La funzione integrata
    StringToInt ()
    , anch’essa già citata nella parte teorica.
Fasi.
  1. Pronunciare la data e l’ora correnti, ottenendo il testo dei messaggi dalle due citate funzioni native di Jaws, ciascuna con una specifica stringa di formattazione.
  2. Calcolare le ore ed i minuti mancanti alla mezzanotte, rilevando i singoli dati relativi all’ora ed al minuto correnti e sottraendoli ai valori limite 24 e 60.
  3. Convertire di nuovo in testo i risultati così ottenuti,per facilitarne l’utilizzo successivo.
  4. Pronunciare il risultato dell’elaborazione sul tempo mancante, inserendo i dati testuali di ore e minuti in una frase informativa.
Note.
  1. La prima stringa di formattazione, applicata a
    SysGetDate ()
    , è quella che fa restituire il messaggio che viene pronunciato quando si preme due volte velocemente la combinazione
    TastoJaws+F12.
  2. La seconda stringa di formattazione, quella applicata a
    SysGetTime ()
    , è del tutto personalizzata e rende in forma estesa tutti i dati possibili, anche i secondi. Per fare ciò, si sfrutta la particolarità dei caratteri di formattazione per le ore, che sono pochi, e quasi tutti minuscoli. Così, avendo l’accortezza di scrivere in maiuscolo all’interno della stringa, si possono costruire le parole attorno alle quali porre poi i caratteri di formattazione veri e propri, che sono in questo caso la lettera
    H
    maiuscola, nonché la
    m
    e la
    s
    minuscole.
  3. Per ottenere i valori numerici di ore e minuti, si usa dapprima la funzione
    SysGetTime ()
    , ponendo come stringa di formattazione il solo carattere corrispondente al dato da estrarre. Poi, la funzione stessa ed il suo risultato testuale diventa il parametro della funzione per convertire da testo a numero,
    StringToInt ().
  4. Al valore convertito dell’ora corrente, per eseguire il calcolo corretto, si sottrae un’unità ponendo i due sottraendi tra parentesi, per sottoporre poi il risultato alla successiva sottrazione.

Codice.


Script DataOra ()
Var
Int iOre, ; ore rimanenti alla mezzanotte
Int iMinuti, ; minuti mancanti all’ora successiva
String sOre, ; messaggio testuale sulle ore
String sMinuti; messaggio sui minuti
SayString (SysGetDate ("dddd d MMMM yyyy")); pronuncia la data in forma estesa,
; e legge l’orario con i valori formattati dentro ad una frase scritta in maiuscolo
SayString (SysGetTime ("SONO LE ORE HH E m MINUTI, s SECONDI"))
Let iOre = 24 - (StringToInt (SysGetTime ("H")) + 1); calcola le ore alla mezzanotte,
Let iMinuti = 60 - StringToInt (SysGetTime ("m")); poi calcola anche i minuti rimanenti
Let sOre = IntToString (iOre); qui converte in testo il risultato delle ore,
Let sMinuti = IntToString (iMinuti); poi converte anche i minuti rimanenti
; eseguiti i calcoli, legge il messaggio con i risultati ottenuti
SayString ("Mancano " + sOre + " ore e " + sMinuti + " minuti alla mezzanotte")
EndScript

Collaudo.

  1. Dopo aver salvato e compilato, premendo i tasti di attivazione
    Control+Windows+BarraSpazio
    , lo script dovrebbe leggervi i dati previsti.
  2. Il suo scopo prettamente didattico, ed il modo stringato con cui lo si è realizzato, lo espongono a qualche inevitabile difetto. In particolare, quando lo si dovesse eseguire ad un’ora esatta, ad esempio alle ore 20 e 0 minuti, il tempo mancante alla mezzanotte sarebbe 3 ore e 60 minuti.
  3. In ogni caso, la forma dello script sarà modificata già entro la fine di questo capitolo, per aggiornarne il contenuto sulla base delle nuove nozioni che acquisiremo nel frattempo.

***

Variabili globali.

Le quattro variabili utilizzate dentro a
DataOra ()
saranno valide soltanto in quello script. Dopo che esso ha compiuto la sua funzione, infatti, tali variabili sono eliminate, e con esse anche i dati che contenevano. Per questo , esse sono anche definite
Variabili Locali.

Per far sì che una variabile mantenga il suo valore anche dopo la fine dello script, o della funzione che ne ha impostato il valore, devono essere
Variabili Globali\\
. Questo speciale tipo di variabili consentono in pratica di poter
passare
il risultato di uno script ad un altro, purché eseguito durante la stessa sessione di lavoro.

Il modo di dichiarare questo tipo di variabili è del tutto analogo a quelle locali, e la

parola chiave da usare in questo caso è
Globals
, (Globali).

Allo stesso modo, bisogna premettere il tipo di dato della variabile al nome della variabile stessa, e in caso di più variabili vanno separate dal carattere Virgola.

Anche in questo caso, la dichiarazione si conclude a fine riga oppure, nelle serie di dichiarazioni, lasciando l’ultima dell’elenco senza alcun segno di punteggiatura.

Circa i nomi, anche in questo caso sono liberi. Sul prefisso identificativo, c’è chi usa
Global
davanti al nome vero e proprio, che nel caso esaminato prima con le variabili locali darebbe
"GlobalPippo".

Può tuttavia essere sufficiente mettere la sola lettera
"g"
, seguita da un’altra per identificare il tipo di dato. A tal proposito, mentre va bene usare
"gs"
per i dati testuali , ottenendo ad esempio
"gsPippo"
, per quelli numerici conviene usare la
"n"
al posto della
"i"
, ottenendo
gnPippo.

Anche per il modo in cui assegnarne un contenuto, le variabili globali si comportano in tutto e per tutto come quelle locali, con il loro valore che può essere cambiato durante l’esecuzione di script e funzioni.

Allo stesso modo, infine, quando si dichiara una variabile globale, essa avrà un valore numerico zero, oppure una stringa nulla. Ovviamente, ciò succederà solo al momento della prima dichiarazione, per poi rimanere sempre l’ultimo impostato da eventuali script o funzioni che ne avessero mutato il valore.

Qualora si volesse azzerare una variabile globale, sarà sufficiente assegnarne un valore zero, in caso di globali numeriche, o una coppia di virgolette, in caso di globali di testo, tramite lo script o la funzione che richiede questa situazione. Diversamente, l’unico modo di annullare una variabile globale è di chiudere e poi riaprire JAWS.

Creare un file personale per le variabili Globali.

La differenza più importante tra le variabili locali e quelle globali è che queste ultime devono essere necessariamente dichiarate fuori dagli estremi del codice che compone gli script, ad esempio prima della parola chiave
Script
, oppure solo dopo il comando
EndScript
. Così, il sistema migliore per dichiarare le variabili globali è farlo in un file a sé stante, come peraltro fa in prevalenza anche Jaws con questo tipo di dati.

Proprio per tale motivo, a partire da questa occasione inizieremo a creare dei file esterni ai tradizionali file script, che in questo caso conterrà tutte le variabili globali di uso personale. Usare dei file appositi, infatti, da un lato garantisce un maggior ordine nel codice, dall’altro consente di poter facilmente individuare le dichiarazioni delle variabili ogni qual volta vi sia la necessità di aggiungerne o modificarle.

Esercizio 4.3.2. Il file Personale delle Variabili Globali.

I file dove mettere le variabili globali sono denominati file
Header
, (Intestazione), ed hanno l’estensione
JSH
. Per crearne uno, aprite l’Editor di Script, da dentro ad un programma qualsiasi, e seguite questi passi:

  1. Richiamate il comando
    Nuovo
    nel menu File, attivabile con la classica scelta rapida
    Control+N.
  2. Si aprirà una schermata dove si può scegliere il tipo di file. All’ingresso sarà selezionato
    Sorgente (JSS)
    . Scendete di una riga per selezionare
    Intestazione (JSH)
    , e premete Invio.
  3. Si aprirà un file vuoto, dal nome
    Senza titolo
    . Dichiarate ora una variabile globale che useremo più tardi, inserendo il seguente codice:
  4. 
    Globals
    Int gnTempoIniziale; valore in millisecondi trascorso dall’accensione del computer
    

  5. Salvate il lavoro con
    Control+S
    . Si presenterà la schermata
    Salva come Utente
    , che vi proporrà di salvare il file nella cartella delle
    Impostazioni personali
    . Digitate
    _PsGlobals
    , quindi premete Invio.
  6. Chiudete il file appena creato tramite il comando
    Chiudi
    nel menu File, o con la scelta rapida
    Control+F4
    , e tornate al file script che avevate aperto in precedenza.

Se avete notato, la prima parte del nome che abbiamo dato al file è lo stesso prefisso,
_Ps
, che avevamo usato come etichetta dentro ai file script. In questo caso la presenza del carattere Sottolineato in testa al nome può rendere più facilmente raggiungibili i nostri file, quando li dovremo cercare dentro a cartelle con molti elementi.

Quanto alla seconda parte del nome,
Globals
, è soltanto il termine con il quale si identifica il suo contenuto, che corrisponde alla parola chiave da porre ad inizio file per dichiarare le variabili globali.

Collegare i file esterni ai file script principali.

Se noi mettiamo le variabili globali in un file esterno, per consentire che gli script contenuti dentro ad un determinato file con estensione JSS possano utilizzarle, dobbiamo compiere un’operazione preliminare, ponendo una speciale istruzione all’inizio del file script, o comunque prima degli script o delle funzioni che poi utilizzeranno tali tipo di variabili.

Questa istruzione è composta dal comando
Include
, (Includi), cui bisogna fare seguire il nome tra virgolette del file che si vuole aggiungere al codice aperto. Si potrà specificare anche solo il nome del file, senza il suo percorso, perché Jaws in automatico lo cerca nelle cartelle dove potrebbe essere, di solito quelle delle Impostazioni personali o quelle Condivise.

Tale dichiarazione serve appunto per dire a Jaws che aggiunga al nostro script tutto quello che è inserito nel file specificato, che in questo caso è la dichiarazione dell’unica variabile globale sinora da noi impostata.

Per capire meglio come fare, se non l’avete ancora aperto dal precedente esercizio, caricate il file script Predefinito, Default.JSS, tramite l’Editor di Jaws.

Seguite poi questi passi:

  1. Portiamoci sull’etichetta d’inizio del codice personale,
    ; _Ps Codice
    , usando il comando di ricerca
    Control+F.
  2. Una volta posizionati sull’etichetta, andate a fine riga, premete Invio per creare una riga vuota, e inserite la seguente istruzione:
  3. 
    Include "_PsGlobals.JSH"
    

salvate compilando, e tutto dovrebbe andare per il meglio. Se fosse proposto un errore, ascoltate il messaggio e provate a seguire le indicazioni. In ogni caso di difficoltà, anche dopo aver già salvato e compilato, è sempre possibile premere il comando
Annulla
del menu modifica, agendo sulla scelta rapida
Control+Z
, per tornare alla situazione precedente l’ultima variazione.

Realizziamo un cronometro.

Il primo obiettivo dell’esercitazione sulle variabili globali sarà creare uno script che avvii un nostro cronometro personale. Nella seconda parte dell’esercitazione, invece, creeremo un altro script che abbia il solo compito di leggerci il tempo trascorso dall’istante in cui abbiamo fatto partire il nostro cronometro virtuale.

Di questa coppia di script ne realizzeremo subito una versione provvisoria, che poi aggiorneremo nel corso del capitolo quando acquisiremo nuovi elementi di memorizzazione in grado di migliorarne la leggibilità.

Esercizio 4.3.5. Lo script AvviaCronometro.

FileScript.

Default.JSS

Nome.

AvviaCronometro

Sommario.

Registra il tempo d’inizio conteggi.

Descrizione.

Salva i millisecondi trascorsi dal momento dell’accensione del computer in un’apposita variabile globale, avvisando dell’azione, nonché leggendo l’ora ed i minuti correnti.

TastiAttivazione.

Shift+Control+Windows+Invio

Novità.
  1. La variabile globale
    gnTempoIniziale
    , in precedenza dichiarata dentro al file d’intestazione
    _PsGlobals.JSH.
  2. La funzione
    GetTickCount
    , (OttieniConteggioTick), che restituisce il numero di millisecondi trascorsi dall’avvio del sistema operativo. Non ha parametri.
  3. La funzione
    Beep
    , (FarSuonare), che serve ad emettere un suono al pc.
Fasi.
  1. Assegnare un valore alla variabile globale, usando la funzione
    GetTickCount ().
  2. Avvisare dell’avvio del cronometro, usando le funzioni
    SysGetTime ()
    , per leggere l’ora corrente, e
    Beep ()
    , per emettere un segnale acustico.
Note.
  1. Il nome assegnato allo script serve soltanto per far capire meglio quale sia il suo scopo, ma in realtà esso non avvia nulla in quanto il
    conteggio
    rimane soltanto virtuale. L’unica azione concreta da esso compiuta, infatti, è la registrazione del valore di partenza all’interno della variabile globale
    gnTempoIniziale.
  2. In questo caso,poiché l’ora pronunciata non è un dato fondamentale, la chiamata della funzione
    SysGetTime ()
    avverrà stavolta senza alcuna stringa di formattazione, restituendo così il testo secondo le modalità predefinite. Se inserite la funzione tramite la procedura guidata, ricordatevi di cancellare i caratteri Virgola che tale procedura lascerebbe tra le parentesi, come segnaposto dei possibili suoi parametri.
  3. Se non si volesse adottare La combinazione tasti suggerita per l’attivazione, si raccomanda di sceglierne un’altra pensando che questo script va abbinato con il successivo, e che entrambi questi elementi di codice dovrebbero avere dei tasti di Attivazione con dei punti in comune, così da rendere più semplice ricordarseli in futuro.

Codice.


Script AvviaCronometro ()
Let gnTempoIniziale = GetTickCount (); registra i millisecondi trascorsi dall’avvio
SayString ("Cronometro avviato alle " + SysGetTime ()); legge il messaggio
Beep (); emette un segnale acustico
EndScript

Collaudo.

  1. Una volta compilato, limitarsi a premere
    Shift+Control+Windows+Invio
    per eseguire lo script, che dovrebbe pronunciare il messaggio ed emettere il segnale acustico.
  2. Per capirne appieno l’utilizzo, tuttavia, si dovrà attendere la scrittura dello script successivo, ed il relativo collaudo.

Esercizio 4.3.6. Lo script TempoTrascorso.

FileScript.

Default.JSS

Nome.

TempoTrascorso

Sommario.

Informa del tempo trascorso dall’attivazione del cronometro.

Descrizione.

Legge il tempo trascorso dall’ultima attivazione dello script AvviaCronometro (), oppure, nel caso in cui tale script non sia stato ancora eseguito, dal momento in cui è stato avviato il sistema operativo.

TastiAttivazione.

Shift+Control+Invio

Novità.
  1. La funzione
    StringRight
    , (StringaTestualeADestra), che estrae dalla destra di una stringa testuale, cioè dalla sua fine, il numero di caratteri specificati come parametro.
  2. La funzione
    StringLeft
    , (StringaTestualeASinistra), che estrae dalla sinistra di una stringa testuale, cioè dall’inizio, il numero di caratteri specificati come parametro.
Fasi.
  1. Calcolare il tempo trascorso.
  2. Ricavarne i dati testuali necessari.
  3. Leggere il messaggio.

Codice.


Script TempoTrascorso ()
Var
Int iValore, ; il tempo trascorso in millisecondi
String sSecondi, ; i secondi trascorsi in forma testuale
String sUltimaParte, ; la parte finale dei millisecondi convertiti in testo
String sCentesimi; la stringa con i centesimi di secondo
Let iValore = GetTickCount () - gnTempoIniziale; sottrae il tempo di partenza all’attuale
Let sSecondi = IntToString (iValore / 1000); converte i secondi in forma testuale
Let sUltimaParte = StringRight (IntToString (iValore), 3); estrae le tre cifre a destra
Let sCentesimi = StringLeft (sUltimaParte, 2); preleva le prime due cifre a sinistra
; legge l’avviso specificando i valori riscontrati
SayString ("Sono trascorsi " + sSecondi + " secondi e " + sCentesimi + " centesimi")
EndScript

Collaudo.

Dopo aver salvato e compilato, eseguite il precedente script,
AvviaCronometro ()
, per inizializzare il conteggio. Poi, attendete qualche secondo, e premete i tasti di attivazione scelti per lo script TempoTrascorso,
Shift+Control+Invio
nel caso abbiate seguito il nostro suggerimento.

Se tutto funziona, dovreste sentire un tempo espresso in secondi e centesimi, preceduti dalla formula che li preannuncia. Se attendete ancora qualche secondo, ed eseguite nuovamente
TempoTrascorso ()
, i valori letti saranno aggiornati tenendo sempre lo stesso punto di partenza di prima, e realizzando così una sorta di rilevazione di intertempi parziali e poi di un tempo finale.

Eliminare le virgolette dai file script.

All’interno di un file script, quando si specifica un testo contenuto in una coppia di virgolette, si compie un’operazione certamente rapida, ma anche non del tutto opportuna. Del resto, anche nei file script originali di Jaws, come ad esempio in quello predefinito, le istruzioni con dati tra virgolette sono poco più dell’uno per cento, limitate a quei casi in cui tale uso è indispensabile. Un esempio di tali casi sono le dichiarazioni che vanno poste all’inizio dei file script, come
Include
, che abbiamo già esaminato, che servono ad aggiungere le variabili globali.

A parte queste eccezioni, quindi, anche noi potremmo imparare a non utilizzare più i dati tra virgolette nei nostri script, per evitare alcuni aspetti negativi come i seguenti:

  1. Questo tipo di dato serve solo nel punto in cui è scritto nel codice.
  2. I dati tra virgolette non sono facilmente raggiungibili né classificabili in fase di modifica o revisione degli script.
  3. Durante le modifiche, è facile creare errori negli script a causa della mancanza di un carattere virgolette di chiusura della coppia, o qualora se ne scriva una occorrenza di troppo.

Pertanto, proveremo ora a ridurre per quanto possibile l’uso delle virgolette. Ci serviremo, a tal scopo, degli altri metodi per memorizzare usati da Jaws, oltre a quelli analizzati sinora, che andremo ad esaminare da qui sino al termine del capitolo.

***

Costanti.

Le
Costanti
sono un elemento di memorizzazione completamente diverso, rispetto alle variabili, perché il loro stesso nome indica come esse, una volta impostate, non cambino mai valore per tutto il tempo di utilizzo.

Le costanti servono sia per memorizzare con nomi facili dei dati che invece sono complessi, come ad esempio il codice fiscale, oppure per dare un nome ad un valore numerico in modo da comprenderne meglio l’utilizzo.

Inoltre, quando dovete rileggere il vostro codice a distanza di tempo, o lo dovete far esaminare da altri, è molto più facile comprendere quel che avete realizzato se sono presenti costanti con nomi ben assegnati, invece di semplici ed anonimi numeri.

Infine, se avete bisogno di modificare il valore di un numero che è utilizzato in più parti, se l’avete memorizzato in una costante, potrete farlo in una volta sola.

La loro parola chiave è
Const
, (Costanti), che ne è l’abbreviazione inglese usata ad esempio per i calcoli. Le costanti, diversamente dalle variabili, si dichiarano nel momento stesso in cui si impostano, come nell’esempio seguente:


Const AVANTI = 1

Oppure:


Const NOME = "Utente"

Per il resto, nel caso di impostazione multipla, serve un carattere Virgola per separare le diverse dichiarazioni, che si concludono a fine riga senza punteggiatura, così come le variabili.

Per quanto riguarda il tipo,
Integer
o
String
, le costanti lo assumono direttamente dal dato stesso che viene loro impostato.

ad esempio, nel caso di prima, la costante
"AVANTI"
sarà di tipo
Integer
, perché le si è impostato un dato numerico, mentre
"NOME"
sarebbe di tipo
String
, perché le si è assegnato invece un dato testuale.

Anche per questo, non essendoci la necessità di chiarire il tipo di dato, l’unica convenzione che riguarda le costanti prevede di esprimere i nomi con i caratteri tutti maiuscoli. Nel caso fosse necessario separare due o più termini che li compongono, queste parti del nome andrebbero separate dal carattere Sottolineato,
_
, come sarà mostrato nel prossimo esempio.

Infine, un particolare importante: diversamente da quanto succede per variabili locali e globali, alle costanti si può solo assegnare un valore in modo diretto, mettendo un numero o un testo tra virgolette dopo il segno di Uguale. Non è possibile, quindi, impostare ad esse, per esempio, il risultato di una funzione.

Esercizio 4.4.1. Il file personale delle Costanti.

Così come le variabili globali, anche le costanti devono essere dichiarate fuori dal codice dei singoli script, di solito ad inizio file. Allo stesso modo, conviene anche qui creare un file apposito, sempre del tipo
Intestazione
, con estensione
JSH.

Per crearne uno, aprite l’Editor di Script, da dentro ad un programma qualsiasi, e seguite la stessa sequenza di azioni utilizzata in precedenza per il file delle variabili globali:

  1. Premete
    Control+N.
  2. Selezionate
    Intestazione (JSH)
    , e premete Invio.
  3. Nel file vuoto che si apre, dal nome
    Senza titolo
    , inserite una costante che useremo tra poco, specificando il seguente codice:
  4. 
    Const
    INIZIO_PERSONALE = "; _Ps Codice"; etichetta di inizio del codice personale
    

  5. Salvate il lavoro con
    Control+S
    . Nel campo
    Nome file
    , scrivete
    _PsConst
    , quindi premete Invio.
  6. Chiudete il file con
    Control+F4
    , e tornate al file script precedente.

Anche in questo caso, per scegliere il nome da dare al nostro file, abbiamo usato il prefisso personale seguito dalla parola chiave per dichiarare le costanti,
Const.

Per rendere disponibile il contenuto del nostro file delle costanti, così come abbiamo fatto con quello delle Globali, bisogna specificare tale nome di file tramite l’istruzione
Include.

Tornate quindi al file script Predefinito,
Default.JSS.

Se vi ricordate, ripetete la procedura che abbiamo seguito per inserire il file delle variabili Globali, iniziando col cercare la nostra etichetta di inizio codice Personale. Spostatevi poi nella riga sotto, creando una riga vuota prima di quella con l’inclusione delle variabili Globali, poiché le costanti vengono prima in ordine alfabetico, ed inserite l’istruzione
Include
, seguita dal nome del file, così come fatto in precedenza.

Al termine, nel file script Predefinito, la sezione iniziale del vostro codice dovrebbe essere così composta:


; _Ps Codice
Include "_PsConst.JSH"; File personale delle costanti
Include "_PsGlobals.JSH"; file personale delle variabili globali

Tornando alla costante che abbiamo impostato, ne avrete certamente riconosciuto il contenuto, non foss’altro per il commento esplicativo che la segue. Prima di applicarci all’esercizio sul tema, concludiamo la parte teorica illustrando un aspetto molto importante dell’argomento.

Il file predefinito delle costanti.

Quella di crearsi un file con delle proprie costanti è la strada per certi versi più semplice, anche se le costanti da noi impostate potrebbero già esistere. Va detto, infatti, che i programmatori di Jaws utilizzano numerose costanti, la maggior parte delle quali dichiarate nel file
HJConst.JSH
. Per capire cosa contiene, proveremo ora ad aprirlo, seguendo questi passi:

  1. Da dentro l’Editor di Script, attivate il comando
    Apri file condiviso
    , che abbiamo già incontrato, premendo
    Alt+F, lettera E, Invio.
  2. Nella schermata che si apre, anziché andare subito alla casella elenco, premete una volta Tab per poi selezionare
    File Header (*.jsh)
    , come tipo di file.
  3. Tornando all’elenco dei file nella cartella, premete la lettera
    H
    finché non si seleziona il file desiderato,
    HJConst.JSH
    , quindi premete Invio.

In questo lungo file, ci sono appunto la gran parte delle costanti che Jaws utilizza nei suoi script. A conferma di ciò, quando l’Editor presenta delle informazioni di aiuto sui parametri da inserire nei campi, ogni qual volta si parla di poter inserire delle costanti, si fa riferimento a quelle contenute in questo file, che si invita spesso a consultare per avere maggiori informazioni.

Nel nostro caso, usiamo la funzione di ricerca dell’Editor,
Control+F
, per cercare la stringa
OT_ERROR.

Quando siete posizionati sulla riga con questa costante, potete notare che essa è di tipo numerico ed ha valore 13.

Analizzeremo più avanti nel dettaglio il significato di questo tipo di costanti, e che utilizzo ne fa Jaws. Per il momento è sufficiente che voi sappiate che tale costante esiste, e quale sia il valore da essa rappresentato. Tra poco lo useremo nell’esercizio che andremo a fare, aggiornando un nostro precedente script.

In ogni caso, per poter anche noi usare tutte le costanti già impostate, è necessario inserire il file costanti predefinito nei nostri script. A tal fine, ci si deve servire della stessa istruzione
Include
, che abbiamo utilizzato in precedenza per poter aggiungere agli script il contenuto dei nostri file intestazione, mettendo tra virgolette il nome del file costanti predefinito, come nella seguente forma:

  • Include “HJConst.JSH”

Bisogna tuttavia fare molta attenzione al fatto che, nel caso di file script già forniti con il pacchetto della sintesi vocale, questa istruzione è quasi sempre già presente, tra le prime poste all’inizio di ciascun file script, e lo è soprattutto in quello predefinito,
Default.JSS
. Se per caso doveste inserire l’istruzione dove c’era già, in fase di compilazione Jaws vi segnalerà un errore, avvertendovi che vi sono delle ripetizioni nella definizione di costanti.

A questo punto, per risolvere il problema, sarà sufficiente anteporre un carattere Punto e Virgola alla dichiarazione, oppure cancellare direttamente l’istruzione
Include
da voi posta nel codice.

In generale, tuttavia, all’inizio conviene sempre inserire questa istruzione, anche se a livello precauzionale la faremo precedere dal citato carattere Punto e Virgola. Nel caso servisse, quindi, sarà sufficiente cancellare un solo carattere e ricompilare, avendo così a disposizione tutte le costanti previste dai programmatori di Jaws.

Quindi, in tutti gli altri script che non siano quello predefinito, per quello che abbiamo analizzato sinora, l’inizio del nostro codice potrebbe essere così predisposto:


; _Ps Codice
; Include "HJConst.JSH"; file costanti predefinito di Jaws
Include "_PsConst.JSH"; File personale delle costanti
Include "_PsGlobals.JSH"; file personale delle variabili globali

Aggiorniamo lo script di scrittura testo.

Per provare il funzionamento delle costanti, anziché produrre un nuovo script, facciamo una piccola ma efficace modifica a quello da noi realizzato nel capitolo scorso,
InserisceFirma ().

Innanzi tutto, poiché abbiamo inserito il testo dell’etichetta di inizio codice Personale in una costante , useremo questa al posto della stringa tra virgolette.

Poi, se vi ricordate, quando abbiamo dato indicazioni di usare quello script, avevamo detto di premere i tasti di attivazione,
Shift+Control+1
, e poi andare a capo riga, quindi creare una riga vuota. In pratica, dopo la pressione dei tasti, vi si chiedeva di premere due volte Invio, azione che faremo svolgere dalla funzione
EnterKey ()
, già utilizzata nello scorso capitolo.

Poi, il buon esito della funzione era illustrato dal fatto che l’etichetta era letta dopo essere stata copiata, perché appunto si rimaneva nella stessa riga. Ora, invece, che ci spostiamo due righe più in basso, useremo una nuova funzione per leggere l’etichetta virtualmente, così da certificare comunque la sua scrittura nel documento.

Tale nuova funzione si chiama
SayMessage
, (LeggiMessaggio). Si tratta di una funzione molto importante, che ha tre parametri, di cui uno opzionale, ma che tratteremo nel dettaglio solo alla fine del capitolo.

Per il momento useremo soltanto i primi due, mettendo nel primo la costante che avevamo cercato nel file predefinito di Jaws,
OT_ERROR
, la quale fa leggere Jaws con una voce dal tono più basso. Come secondo parametro, invece, useremo nuovamente la nostra costante con l’etichetta di inizio codice.

Per garantire che la funzione
SayLine ()
legga la riga in cui si richiama lo script, useremo anche in questo caso la funzione
Refresh ()
, conosciuta lo scorso capitolo, inserendola appunto appena prima della funzione integrata per la lettura della riga.

Esercizio 4.4.4. La nuova versione di InserisceFirma ().

FileScript.

Default.JSS

Nome.

InserisceFirma

Novità.
  1. La funzione
    SayMessage
    , illustrata in precedenza.
  2. Le costanti
    OT_ERROR
    e
    INIZIO_PERSONALE
    , anch’esse illustrate nella premessa.
Note.

La modifica della versione precedente va effettuata nel modo illustrato di seguito:

  1. Portatevi nello script
    InserisceFirma ()
    , all’inizio della riga con la funzione
    TypeString ().
  2. Create una riga vuota, dove di porterete per scrivere direttamente la seguente istruzione, comprensiva di commento:
  3. 
    SayMessage (OT_ERROR, INIZIO_PERSONALE) ; legge l’etichetta
    

  4. Scendete di nuovo nella riga con la funzione
    TypeString
    , dentro alle parentesi tonde, cancellate tutto il suo contenuto, comprese le virgolette, ed inserite come parametro il nome della costante
    INIZIO_PERSONALE.
  5. Andate alla fine della riga e createne una di vuota, dove inserirete la prima occorrenza della funzione
    EnterKey
    , che, essendo senza parametri, potrete sia scrivere direttamente, sia inserire con
    Control+I.
  6. Ripetete l’inserimento appena effettuato, creando una nuova riga ancora con un’istruzione
    EnterKey.
  7. Inserite ora la funzione
    Refresh ()
    , anch’essa senza parametri.
  8. In ragione di quest’ultimo inserimento, la presenza dell’istruzione
    Pause ()
    è ora superflua. Per questo, si consiglia di cancellarla.

Codice.


Script InserisceFirma ()
SayMessage (OT_ERROR, INIZIO_PERSONALE); legge l’etichetta
TypeString (INIZIO_PERSONALE); scrive l’etichetta nel documento
EnterKey (); simula la pressione di Invio, per creare una riga vuota,
EnterKey (); e poi ne crea un’altra
Refresh (); resetta la schermata
SayLine (); legge la riga
EndScript

Collaudo.

  1. Salvate compilando. Se si verifica qualche problema, cercate di leggere l’eventuale messaggio d’errore, e casomai annullate le modifiche e ripetete i passaggi.
  2. Se tutto va bene, tramite la scelta rapida
    Control+O
    , aprite il file script per Microsoft Word, comunque esso si chiami sulla base della vostra configurazione, cui nello scorso capitolo avevamo volutamente omesso di inserire la nostra firma di inizio codice.
  3. Portatevi all’inizio della riga che contiene l’intestazione del primo script da noi realizzato per quell’applicazione,
    TrovaTesto ()
    , quindi premete
    Shift+Control+1
    per eseguire lo script appena aggiornato.
  4. A questo punto, dovreste sentire dapprima leggervi l’etichetta di inizio codice, con un tono più basso, poi dovrebbe essere riletta la riga d’intestazione dello script, con la voce principale di Jaws.

***

Messaggi.

Un tipo particolare di costanti sono i
Messaggi
, che servono a memorizzare le parti testuali da usare negli script. Allo stesso modo di costanti e variabili globali, anche i messaggi vanno dichiarati fuori dal codice degli script, preferibilmente in file esterni. I file dei messaggi, inoltre, hanno anche una loro estensione apposita,
JSM
, che li rende perciò immediatamente riconoscibili.

Oltre a poter dislocare i messaggi in file appositi, rendendoli facili da consultare e modificare, l’uso dei messaggi ha tra gli altri anche questi vantaggi:

  1. Creare delle stringhe standard da poter personalizzare e riutilizzare in più script.
  2. Eliminare le parti testuali dal corpo degli script.
  3. Facilitare la conversione dei testi in altre lingue.

Anche in questo caso, i messaggi vanno dichiarati premettendo una parola chiave, che è la traduzione inglese
Messages
, ma poi le analogie con gli altri modi di impostare finiscono qui.

Il nome dei messaggi, infatti, va dichiarato ponendo ad inizio riga un carattere Chiocciola, Asci 64, immediatamente seguito senza spazi dal nome. Il testo del messaggio comincia dal primo carattere non vuoto che segue il nome, di solito dalla riga seguente, e può continuare anche per più righe, terminando in ogni caso con un doppio carattere Chiocciola,
@@.

La stessa modalità va seguita per specificare ciascuno dei messaggi. Alla fine di questi, il file deve terminare obbligatoriamente con la parola chiave di chiusura,
EndMessages
, (FineMessaggi).

Essendo dedicati ai messaggi, i dati sono sempre considerati testuali. Anche per questo, il prefisso da poter mettere al nome del messaggio è libero. Di norma, si usa
"msg"
, ottenendo così nel caso del nostro classico esempio
msgPippo.

Per porre dei commenti, il carattere Punto e Virgola, se posto all’interno dei messaggi tra il nome e la doppia Chiocciola di chiusura, è interpretato come tale, e quindi non come l’inizio di un testo di commento. Pertanto, per illustrare il contenuto di ciascun messaggio, la modalità suggerita è quella di porre un carattere Punto e Virgola, seguito da una breve descrizione, in una riga a sé stante prima della dichiarazione del messaggio. Tale dichiarazione, composta dal primo carattere Chiocciola seguito dal nome, sarà quindi posta immediatamente sotto al commento.

Per capire meglio, analizzate lo schema proposto di seguito, che illustra un modello di come potrebbe essere una nostra dichiarazione di messaggi:


; testo del commento
@msgNomeDelMessaggio
Contenuto libero del messaggio
@@

Personalizzare i Messaggi.

La possibilità di
"creare delle stringhe standard da poter personalizzare e riutilizzare"
, citato come primo motivo di utilizzo dei messaggi, è resa possibile in gran parte dalla funzione integrata
FormatString
, (FormattaDatoTestuale). Questa funzione serve, appunto, a creare delle nuove porzioni di testo, partendo da una stringa speciale che contiene le
"istruzioni"
per la formattazione, così come abbiamo fatto anche con le funzioni per la data e l’ora. In questo caso, tuttavia, i
segnaposto
non sono formati da lettere, bensì dal carattere Percento,
%
, seguito da un valore numerico da 1 a 9, come ad esempio
%1,
%2,
%3
, ecc.

Come sintassi, al primo parametro della funzione bisognerà indicare il nome del messaggio da personalizzare. I segnaposto presenti nel messaggio saranno poi sostituiti, nella stringa che si otterrà come risultato, con i dati testuali o numerici indicati nella funzione stessa, a partire dal secondo parametro in poi.

Per fare un esempio, ipotizziamo di impostare il messaggio seguente:


; esprime la quantità della frutta indicata
@msgNumeroFrutti
Ci sono %1 mele e %2 pere.
@@

Una volta messo a disposizione, ipotizziamo ancora di avere uno script dove far eseguire questo comando:


FormatString (msgNumeroFrutti, 4, 2)

In questo caso, la stringa ottenuta sarebbe la seguente:

"Ci sono 4 mele e 2 pere".

Come si può notare, i segnaposto numerati sono stati sostituiti, nel risultato della funzione, con i rispettivi valori numerici specificati come secondo e terzo parametro.

Da notare che i valori da porre in sostituzione dei segnaposto possono essere tanto testuali quanto numerici, senza bisogno per questi ultimi di altre conversioni. Per questo, nel nostro esempio, abbiamo potuto specificare direttamente i valori numerici senza dover ricorrere alla funzione
IntToString ().

Anche in questo caso, dunque, l’azione compiuta da tale funzione viene definita
formattare
un testo, ed il risultato della funzione lo si dirà
formattato.

Come ultima annotazione, qualora il risultato della funzione dovesse contenere un carattere Percento, basterà non farlo seguire da un numero. Se invece si dovesse ottenere un testo che abbia per esteso un carattere di percentuale seguito da un numero, sarà sufficiente utilizzare una coppia di caratteri Percento, come nell’esempio di assegnazione seguente:


; spiega come formattare un testo
@msgIstruzioniFormattazione
Per formattare una stringa, si deve usare il carattere %%1.
@@

Esercizio 4.5.2. Il file personale dei Messaggi.

Come prova pratica sull’argomento, completiamo l’opera di rimozione delle virgolette dai nostri script, almeno nel file predefinito. In particolare, creeremo i messaggi per sostituire le parti testuali negli ultimi tre script realizzati,
DataOra (),
AvviaCronometro ()
e
TempoTrascorso ().

Inizieremo anche in questo caso con il creare il nostro file personale dei Messaggi, dove impostare le assegnazioni necessarie. Aprite dunque l’Editor di Script, da dentro ad un programma qualsiasi, seguendo poi una procedura analoga a quanto fatto nelle due precedenti occasioni:

  1. Premete
    Control+N.
  2. Scendendo di due righe, selezionate
    Messaggi (JSM)
    , e premete Invio.
  3. Nel file vuoto che si apre, dal nome
    Senza titolo
    , inserite il codice indicato di seguito:
  4. 
    Messages
    ; stringa di formattazione per data in forma estesa
    @msgDataEstesa
    dddd, d MMMM yyyy
    @@
    ; stringa di formattazione per orario in forma estesa
    @msgOraEstesa
    SONO LE ORE H E m MINUTI, s SECONDI
    @@
    ; ore e minuti rimanenti alla Mezzanotte
    @msgMezzanotte
    Mancano %1 ore e %2 minuti alla Mezzanotte
    @@
    ; ora di avvio del cronometro
    @msgOraAvvio
    Cronometro avviato alle %1.
    @@
    ; tempo trascorso in secondi e centesimi di secondo
    @msgBaseTempo
    Tempo trascorso: %1 secondi e %2 centesimi.
    @@
    EndMessages
    

  5. Salvate il lavoro con
    Control+S
    . Nel campo
    Nome file
    , digitate
    _PsMessages
    , usando ancora il prefisso personale e la parola chiave per dichiararli, quindi premete Invio.
  6. Chiudete il file con
    Control+F4
    , e tornate al file script precedente.

Anche qui, così come si è fatto nelle altre occasioni, per rendere disponibili i messaggi nei nostri script, bisogna specificare il nome del file tramite l’istruzione
Include.

Se non ci siete già, aprite il file script Predefinito. Default.JSS.

Tornate alla nostra etichetta di inizio codice Personale, quindi scendete di qualche riga per scrivere la nuova istruzione
Include
, ponendola per ultima sotto a quella delle variabili Globali.

Al termine, nel file script Predefinito, la sezione iniziale del vostro codice dovrebbe essere così composta:


; _Ps Codice
Include "_PsConst.JSH"; File personale delle costanti
Include "_PsGlobals.JSH"; file personale delle variabili globali
Include "_PsMessages.JSM"; File personale dei messaggi

Modifica delle parti testuali negli script precedenti.

Sulla base di quanto illustrato sinora, la modifica ai tre script realizzati in questo capitolo si effettua soprattutto sostituendo la parte tra parentesi delle funzioni
SayString
con una funzione
FormatString
, la quale abbia come primo parametro il messaggio da noi predisposto nel file Messaggi, e come ulteriori parametri i dati con i quali personalizzare il risultato della funzione stessa.

Oltre a ciò, dato che nelle precedenti versioni degli script avevamo anche usato le funzioni di conversione da numero a dato testuale, poiché come detto l’uso di
FormatString
rende inutile tale passaggio, laddove possibile porremo direttamente i valori numerici come parametri della funzione, anziché la loro versione testuale convertita.

Esercizio 4.5.4. La nuova versione di DataOra ().

FileScript.

Default.JSS

Nome.

DataOra

Novità.
  1. La funzione integrata
    FormatString ().
Note.

Le modifiche da apportare alla prima versione sono le seguenti:

  1. Nelle dichiarazioni, eliminare la riga contenente
    String sMinuti
    , e di conseguenza togliere il carattere Virgola alla dichiarazione precedente,
    String sOre
    , che così è diventata l’ultima della serie. Se volete, sempre a quest’ultima, cambiate il commento in
    "messaggio testuale sul tempo rimanente".
  2. Cancellare le prime due istruzioni di lettura, sostituendole con la nuova funzione
    SayMessage ()
    , ponendo la costante
    OT_ERROR
    come primo parametro, e come secondo mettendo le funzioni di data ed ora, nel cui interno andranno posti i primi due messaggi da noi impostati,
    msgDataEstesa
    e
    msgOraEstesa
    , nell’ordine.
  3. Dato che non sarà più necessario creare le versioni testuali dei valori di ore e minuti, cancellare le due conversioni tramite
    IntToString ().
  4. Assegnare al messaggio
    sOre
    il testo ottenuto dalla funzione
    FormatString ()
    . Per farne comprendere meglio la funzione, il messaggio base con i caratteri segnaposto numerati, ed i due valori usati per sostituire questi ultimi, li porremo ciascuno su una riga diversa, facendo attenzione a lasciare il carattere Virgola come ultimo valido della riga stessa.
  5. Eliminare anche l’ultima funzione di lettura, sostituendola anche in questo caso come indicato al Punto 1, ma ponendo come secondo parametro la variabile
    sOre.
  6. Al termine delle modifiche, il codice dovrebbe risultare quello posto di seguito.

Codice.


Script DataOra ()
Var
Int iOre, ; ore rimanenti alla mezzanotte
Int iMinuti, ; minuti mancanti all’ora successiva
String sOre; messaggio testuale sul tempo rimanente
SayMessage (OT_ERROR, SysGetDate (msgDataEstesa)); pronuncia la data,
SayMessage (OT_ERROR, SysGetTime (msgOraEstesa)); e legge anche l’orario
Let iOre = 24 - (StringToInt (SysGetTime ("H")) + 1); calcola le ore alla mezzanotte,
Let iMinuti = 60 - StringToInt (SysGetTime ("m")); poi calcola anche i minuti rimanenti
Let sOre = FormatString ( ; compone il messaggio, specificando:
msgMezzanotte, ; parametro1, il messaggio creato con i due segnaposti numerati,
iOre, ; parametro2, il dato sulle ore, da sostituire al segnaposto %1,
iMinuti); parametro3, il dato sui minuti, da sostituire al segnaposto %2
SayMessage (OT_ERROR, sOre); legge il messaggio formattato
EndScript

Collaudo.

  1. Salvate compilando e, se ci sono problemi, annullate e provate a ripetere i passaggi.
  2. Premendo i tasti di attivazione
    Control+Windows+BarraSpazio
    ,Il risultato dello script non dovrebbe essere cambiato dalla versione precedente, a parte la voce del messaggio, il quale dovrebbe essere letto ora con un tono più basso.

Esercizio 4.5.5. La nuova versione di AvviaCronometro ().

FileScript.

Default.JSS

Nome.

AvviaCronometro

Note.

Poniamo di seguito un elenco delle modifiche da apportare, rinviando poi al codice più sotto per la loro forma esatta.

  1. Subito dopo l’intestazione, inserire la dichiarazione della variabile
    sMessaggio
    , di tipo
    String.
  2. Prima della istruzione
    SayString
    , inserire l’assegnazione della variabile appena dichiarata con il risultato della funzione
    FormatString
    , a cui si ponga
    msgOraAvvio
    , come primo parametro, e la funzione
    SysGetTime
    , senza parametri, come secondo.
  3. Come nello script precedente, eliminare la funzione di lettura sostituendola con
    SayMessage ()
    , ponendo
    OT_ERROR
    come primo parametro, e come secondo il messaggio appena formattato.
  4. Al termine delle modifiche, il codice dovrebbe risultare quello posto di seguito.

Codice.


Script AvviaCronometro ()
Var String sMessaggio; l’avviso formattato
Let gnTempoIniziale = GetTickCount (); registra i millisecondi trascorsi dall’avvio
Let sMessaggio = FormatString ( ; formatta l’avviso da leggere
msgOraAvvio, ; parametro1, il messaggio base
SysGetTime ()); parametro2, l’ora da inserire nell’avviso
SayMessage (OT_ERROR, sMessaggio); legge l’avviso formattato
Beep (); emette un segnale acustico
EndScript

Collaudo.

Salvate compilando e, se ci sono problemi, annullate e provate a ripetere i passaggi. Anche in questo caso non ci sono modifiche sostanziali,a parte il cambio di tono nella pronuncia del messaggio.

Esercizio 4.5.6. La nuova versione di TempoTrascorso ().

FileScript.

Default.JSS

Nome.

TempoTrascorso

Note.
  1. Nelle dichiarazioni, modificare la variabile
    sSecondi
    , di tipo
    String
    , in
    iSecondi
    ,di tipo
    Integer.
  2. Sempre nelle dichiarazioni, aggiungere come penultima la variabile
    sMessaggio
    , di tipo
    String.
  3. In conseguenza alla prima modifica, si dovrà cambiare l’assegnazione della variabile
    sSecondi
    in
    iSecondi
    , rimuovendo la funzione di conversione
    IntToString ()
    . Fate attenzione a cancellare anche la parentesi tonda di chiusura della funzione.
  4. Inserite prima di
    SayString ()
    l’assegnazione di
    sMessaggio
    con il risultato di
    FormatString ()
    , ponendo
    msgBaseTempo
    come primo parametro,
    iSecondi
    come secondo e
    sCentesimi
    come terzo.
  5. Come al solito, sostituite la precedente funzione di lettura con
    SayMessage ()
    , ponendo il messaggio formattato come secondo parametro.
  6. Al termine, il codice dovrebbe avere l’aspetto seguente.

Codice.


Script TempoTrascorso ()
Var
Int iValore, ; il tempo trascorso in millisecondi
Int iSecondi, ; i secondi trascorsi
String sUltimaParte, ; la parte finale dei millisecondi convertiti in testo
String sCentesimi, ; la stringa con i centesimi di secondo
String sMessaggio; l’avviso formattato
Let iValore = GetTickCount () - gnTempoIniziale; sottrae il tempo di partenza all’attuale
Let iSecondi = iValore / 1000; converte il valore in secondi
Let sUltimaParte = StringRight (IntToString (iValore), 3); estrae le tre cifre a destra
Let sCentesimi = StringLeft (sUltimaParte, 2); preleva le prime due cifre a sinistra
Let sMessaggio = FormatString ( ; formatta l’avviso con i valori rilevati
msgBaseTempo, ; parametro1, messaggio base
iSecondi, ; parametro2, valore in secondi da inserire
sCentesimi); parametro3, centesimi in forma testuale
SayMessage (OT_ERROR, sMessaggio); legge l’avviso formattato
EndScript

Collaudo.

Salvate compilando e, se ci sono problemi, annullate e provate a ripetere i passaggi. Quando tutto è a posto, il risultato non dovrebbe essere diverso dal precedente. Nel prossimo capitolo, invece, cambieremo il concetto di costruzione del messaggio, rendendolo sensibile al risultato di volta in volta pronunciato.

Errori nei file esterni.

Quando avete creato i tre file contenenti le variabili Globali, le Costanti ed i Messaggi, le assegnazioni da impostare erano davvero poche. Quindi, salvando gli script, non dovrebbero essersi verificati particolari inconvenienti.

In generale, tuttavia, man mano che procederete con gli aggiornamenti nei prossimi capitoli, ed ancor più quando avrete modo di modificarli per vostro conto, qualche problema in fase di compilazione potrebbe senz’altro presentarsi.

In caso di errori, vi sono due tipologie di cose che possono succedere, che analizzeremo una alla volta.

Errori nei file per variabili Globali e Costanti, con estensione JSH.

In questo caso, la sequenza di ciò che succede, e di quel che si deve fare, è la seguente:

  1. L’Editor di script caricherà direttamente il file in cui si è verificato l’errore, proponendo l’avviso relativo, in inglese, e posizionandosi poi nella riga che l’ha causato.
  2. Corretto l’errore, si dovrà salvare il file esterno con
    Control+S
    , quindi chiudere il file aperto con
    Control+F4
    , tornando al file script d’origine.
  3. Se provando a compilare restano degli errori, continuare il controllo seguendo i passi 1 e 2, finché la compilazione riesce.

Errori nei file Messaggi, con estensione JSM.

Qui, diversamente, l’Editor si limiterà a mostrare un avviso, ma non a caricare il file Messaggi per posizionarsi dove si è verificato l’errore.

Non temete, tuttavia, perché c’è comunque un sistema per conoscere la riga dove tale errore è stato riscontrato. Dopo aver proposto l’avviso dell’errore, infatti, l’Editor di Script si sarà quasi certamente spostato, dal punto in cui eravate al momento di salvare il file script, sino ad una determinata riga del file.

Quindi, se non avete altre idee su dove possa essersi verificato l’errore, seguite questi passi:

  1. Senza muovere il cursore, agite sul comandoTastoJaws+PaginaGiù, per leggere la riga di stato in fondo allo schermo, e cercate di memorizzare sia il primo numero letto da Jaws, il quale sarebbe quello della riga corrente, sia l’ultimo, che invece corrisponde al numero totale delle righe nel file. Se avete problemi, premete la sequenza
    TastoJaws+BarraSpazio, lettera H
    per visualizzare la cronologia della sintesi, in pratica tutto quello che Jaws ha letto di recente, al cui ingresso dovreste essere posizionati proprio sulle informazioni appena pronunciate.
  2. Aprite manualmente il file messaggi che avete specificato nella dichiarazione
    Include
    ad inizio script.
  3. Appena entrati, agite nuovamente sul comando per leggere la riga di stato,
    TastoJaws+PaginaGiù
    , e stavolta prendete nota solo dell’ultimo valore, quello relativo alle righe totali, oppure ricorrete ancora alla cronologia della Sintesi.
  4. Se le righe totali del file script sono maggiori o almeno uguali di quelle totali nel file messaggi, allora attivate il comando
    Vai alla riga
    del menu Script, tramite
    Alt+S, lettera V, e casomai Invio
    , oppure con la scelta rapida
    Control+G
    , digitate il numero della riga su cui eravate posizionati dentro al file script, e premete Invio.
  5. Se invece il file script avesse meno righe di quello dei messaggi, chiudete il file Messaggi con
    Control+F4
    , tornando al file script. Qui create tante righe vuote quante ne servono per arrivare al numero compressivo delle righe nel file Messaggi, quindi salvate compilando nuovamente, e tornate ad eseguire il Passo 1.
  6. Nel file Messaggi, una volta arrivati alla riga in qualche modo segnalata dall’Editor di Jaws, provate ad individuare e correggere l’errore, quindi salvate e tornate all’Editor chiudendo il file Messaggi.
  7. Continuate a seguire i passi da 1 a 6 finché la compilazione non vi darà alcun errore.

***

I livelli di prolissità.

per far parlare Jaws, dopo l’iniziale utilizzo delle funzioni integrate
SayString ()
e
SayInteger ()
, da questo capitolo abbiamo iniziato ad usare
SayMessage
. Come promesso, è giunto il momento di approfondire la spiegazione di questa, e delle altre funzioni per la lettura dei messaggi.

In particolare, per spiegare questo tipo di funzioni, è necessario aprire una parentesi sui
livelli di prolissità
. Questo è il nome che si dà al modo che si ha per determinare come, e quanto, Jaws debba leggere di tutte le informazioni che compaiono a video, o che il programma di sintesi vocale elabora per potercele fornire. Questi livelli sono tre, e ciascuno di essi può essere configurato a parte, sia in generale, sia per le singole applicazioni.

Nel dettaglio, essi sono:

  1. Principiante.
  2. Intermedio.
  3. Avanzato.

Ebbene, per capire appieno cosa fa, ad esempio, la funzione
SayMessage ()
, è necessario che abbiate presente come è fatta la schermata in cui si scelgono le
Preferenze
per ciascuno di questi tre livelli. Se così non fosse, seguite questi passi:

  1. Andate nel
    Centro Impostazioni
    di Jaws, premendo
    Insert+F2
    e poi cliccando sull’omonimo comando, per modificare la configurazione per l’applicazione attiva, oppure dalla schermata o dal menu contestuale di Jaws, sotto la voce
    Utility
    , per modificare quelle generali.
  2. Nella casella di ricerca, digitate
    prolissità
    , quindi premete Tab.
  3. Scendete sino a
    Configura livelli di prolissità
    , e premete Invio.
  4. Spostatevi a destra con la freccia per aprire il menu con i tre livelli, posizionatevi sopra a quello desiderato, uno o l’altro è lo stesso, e poi premete la Barra Spazio per visualizzare la schermata delle
    Preferenze.

In questa schermata , all’ingresso si sarà nel campo
Elementi da leggere
, un elenco di caselle che si potranno singolarmente selezionare, quindi attivare o disattivare per far sì che, appunto, Jaws li legga oppure no.

Con un Tab si andrà, infine, nel campo
Lunghezza dei Messaggi di Jaws
, dove invece vi saranno solo due opzioni alternative,
Lunghi
o
Corti.

I Tipi di Output.

A ciascuno degli
Elementi da leggere
, che nelle ultime versioni di Jaws sono arrivati a 24, corrisponde una specifica modalità di visualizzazione, la quale viene chiamata
Tipo di Output
. Quest’ultima parola inglese si usa correntemente anche nella nostra lingua e si può tradurre con
Produzione
. Questi Tipi di Output sono contraddistinti da valori numerici, registrati in una serie di costanti, sul cui lungo elenco ci siamo già portati qualche pagina fa, quando avevamo aperto il file delle costanti predefinite,
HJConst.JSH
. Tali costanti sono contraddistinte dall’acronimo che hanno come prefisso,
OT_
, il quale sta appunto per
Output Type
, (TipoDiOutput).

Per capire come poter impostare i Tipi di Output, possiamo tornare ad analizzare la funzione
SayMessage ()
, la quale ha tre parametri:

  1. Il tipo di Output che si vuole sia applicato al testo da leggere, con un valore che si può esprimere in forma numerica oppure mettendo una delle citate costanti.
  2. Il testo da leggere, che sarà letto nel caso in cui sia impostata la lettura della versione lunga dei messaggi, oppure quando si specifica solo questo senza mettere nulla come terzo parametro.
  3. La versione corta del messaggio, che viene letta solo se è impostata tale modalità.

Di questi, una fondamentale importanza è assunta dal primo parametro che, così come abbiamo già fatto in precedenza usando la costante
OT_ERROR
, serve a decidere se, quando, e come, far pronunciare i messaggi a Jaws.

In particolare, ciascun testo lo possiamo abbinare anche ad uno qualsiasi

degli elementi di prolissità, solo applicando come primo parametro la costante o il valore che lo identifica.

Inoltre, con
SayMessage ()
, tale testo lo si può assegnare alla categoria dei messaggi lunghi o corti, ponendolo come secondo o come terzo parametro della funzione.

Quindi, di norma, noi dovremmo impostare il Tipo di Output come primo parametro, specificando un messaggio come secondo parametro, e casomai uno come terzo parametro. In questo caso, sulla base del livello di prolissità attivo, il messaggio potrà essere letto oppure no, e potrà esserlo nella sua versione lunga o nell’eventuale versione corta, a seconda delle preferenze impostate in quel momento da ciascun utente.

Per fare un esempio, ipotizzate che tutti i livelli di prolissità siano settati con le impostazioni predefinite. Se voi avete due versioni di un testo da leggere, una lunga e una corta, e volete che tale testo sia considerato come il tipo di elemento
Messaggio di Jaws
, si deve scrivere questa istruzione:


SayMessage (OT_JAWS_MESSAGE, "Testo Versione lunga ", " "Messaggio corto")

La costante
OT_JAWS_MESSAGE
, che identifica i messaggi di Jaws, corrisponde al valore 3, mentre le due versioni dei messaggi sono poste come secondo e terzo parametro. Se voi eseguite questa istruzione, quando sono attivi i diversi livelli di prolissità, si avrà il seguente risultato:

  1. Con il livello di prolissità
    Principiante
    , sarà letta la versione lunga del messaggio.
  2. Con il livello
    Intermedio
    , sarà letto il messaggio corto.
  3. Con il livello
    Avanzato
    , non sarà letto nessun messaggio.

Le altre funzioni integrate per leggere testo.

Ora che abbiamo illustrato cosa siano i tipi di Output, è necessario chiarire che le funzioni integrate che li utilizzano sono varie, non solo
SayMessage ().

In particolare, una delle più usate è quella chiamata semplicemente
Say
, (Leggi), la quale ha due principali parametri, che però sono invertiti rispetto a
SayMessage ():

  1. Il primo parametro è il testo da leggere.
  2. Il secondo parametro è il tipo di Output, da esprimere come al solito sia con la costante sia con il valore che vi è registrato.

Inoltre, nelle impostazioni degli Elementi di Prolissità che lo prevedono, il testo sarebbe sempre letto senza alcuna distinzione, sia come versione lunga, sia come versione corta. Anche per questo, oltre all’inversione dei parametri che può generare confusione, da qui in avanti la funzione
Say ()
non sarà usata. Essa, peraltro, avrebbe anche un terzo parametro opzionale, del quale tuttavia non ci occuperemo per non dover aprire un’ulteriore parentesi.

L’altra utilissima funzione di lettura è
SayFormattedMessage
, (LeggiMessaggioFormattato), che fonde
SayMessage ()
e
FormatString ()
, consentendo di specificare direttamente in un’unica funzione anche gli eventuali dati con i quali formattare un messaggio base. Nel dettaglio, la funzione ha i seguenti parametri:

  1. Il Tipo di Output.
  2. Il messaggio da leggere, da considerare come versione lunga se poi ne venisse specificata anche una corta.
  3. L’eventuale versione corta del messaggio.
  4. Il dato per sostituire il contrassegno
    %1.
  5. Il dato per sostituire il contrassegno
    %2
    , e così via sino al
    %9.

Data la sua similitudine con
SayMessage ()
, nelle prossime occasioni alterneremo l’uso dell’una o dell’altra, a seconda dei casi. Da notare che, qualora come terzo parametro si specifichi una stringa vuota, lo stesso messaggio posto nel secondo parametro sarebbe letto anche come versione corta. Se invece si vuole che non sia letto alcun messaggio corto, nel terzo parametro si dovrà specificare la stringa silenziosa, equivalente ad un ritorno a capo, Ascii 13.

L’uso dei livelli di prolissità.

può darsi che durante l’utilizzo quotidiano, nei piccoli script personali, non si riesca a sfruttare appieno le potenzialità delle funzioni che richiedono i Tipi di Output. D’altro canto, quando si scorre un qualsiasi codice di quelli originali di Jaws, le istruzioni di lettura hanno quasi sempre specificata tra i loro parametri qualcuna di tali costanti, e quindi l’argomento è certamente uno di quelli da conoscere.

Sul piano pratico, uno degli aspetti che appaiono più convenienti è differenziare i toni di voce tra un tipo di messaggio e l’altro. In questo, tuttavia, va anche considerato il fatto se il messaggio sia necessario o meno, o se si prevede che in un primo momento possa essere utile e poi, man mano che si imparano ad usare le procedure, esso possa non essere più indispensabile.

Circa il primo tipo di utilizzo, se si facesse una prova usando in sequenza tutti i valori numerici coinvolti, vi accorgerete che i messaggi sono pronunciati con la voce principale di Jaws nella maggior parte dei Tipi di Output, e solo alcuni di questi usano la voce secondaria.

Nel dettaglio, tra i Tipi di Output abbinati agli Elementi da leggere, quando si specificano come parametro valori dall’undici al 15, oltre al 22, sarà utilizzata la seconda voce, quella che di solito è assegnata al Cursore Jaws.

Poiché solo alcuni di questi Tipi sono sempre attivi, almeno nelle impostazioni predefinite, il consiglio è di usare quella che abbiamo già proposto, la costante
OT_ERROR
, che come detto ha valore 13, per messaggi indispensabili da attivare con la seconda voce di Jaws.

Se invece volete servirvi della voce principale, utilizzando un tipo di Output che sia generalmente attivo, allora potete usare la costante
OT_HELP
, o il suo valore 1.

***

Riepilogo.

Questa parte del nostro viaggio è stata un po’ impegnativa ma, come detto, gli argomenti erano strettamente correlati, e ne abbiamo quindi approfittato per dare le principali informazioni sui vari aspetti trattati.

Le variabili, soprattutto quelle locali, ma anche quelle globali, le costanti ed i messaggi, sono concetti base che si devono per forza conoscere, i quali riguarderanno tutto il codice prodotto da qui in avanti.

Nel prossimo capitolo cercheremo di spiegare i metodi forniti da Jaws per controllare il flusso dell’elaborazione, e come far eseguire a Jaws determinate istruzioni anziché altre, oppure per quante volte ripeterle.

Si tratta di un passaggio fondamentale della programmazione, che ci consentirà poi di produrre del codice nella forma che esso di solito assume. Se non altro, tali conoscenze ci consentiranno di provare a capire come sono fatti e come funzionano gli script originali di Jaws, o quelli realizzati da altri utenti che volessero condividerli con noi.

Download

File script da scaricare, per gli utenti di Jaws fino alla versione 18
Archivio da scaricare, per gli utenti dalla versione 2018 in poi

Per ulteriori spiegazioni, scrivere a:

Abramo Volpato

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *