Programmiamoli da Soli!

Gli Script Parlanti.

Nel precedente capitolo abbiamo fatto una prima conoscenza con script e funzioni, producendo il nostro primo script. Sinora, tuttavia, non ci si è occupati della funzionalità principale di uno Screen-Reader come Jaws, la capacità di far leggere tramite la sintesi vocale le informazioni che servono all’utilizzo del PC.

In questo capitolo provvederemo a colmare tale lacuna, dopo aver ricevuto una prima infarinatura dei concetti, che poi troveremo applicati nei diversi argomenti. In particolare, cercheremo di illustrare subito alcuni dei sistemi per far pronunciare a Jaws quanto sia presente a video, e che nella nostra configurazione non ci viene letto in modo automatico.

Per aiutarci nella lettura delle informazioni, è fondamentale sapere come muovere Jaws nello schermo, e soprattutto capire esattamente quali mosse si devono compiere. Per questo, prima di iniziare l’analisi più operativa del da farsi, è necessario introdurre un altro paio di argomenti, che poi serviranno subito entrambi per realizzare lo script di esempio.

I Cursori di Jaws.

L’utilizzo dei diversi cursori di Jaws, ciascuno per le proprie caratteristiche, è uno degli aspetti più importanti da conoscere bene nel realizzare gli script. Per chi usa Jaws, anche il suo normale utilizzo negli applicativi richiede almeno di sapere quali siano i due cursori principali, il
Cursore PC
ed il
Cursore Jaws
, e che per attivarli di solito sono usati, rispettivamente, i tasti
Più
e
Meno
del tastierino numerico.

Per chi invece non avesse ben chiara la differenza dell’utilizzo operativo dell’uno o dell’altro, sarà sufficiente dire che il Cursore PC coincide sempre con il cursore di sistema, e può muoversi solo negli spazi che l’applicazione gli assegna. Diversamente, il Cursore Jaws consente di muoversi in tutto lo spazio occupato dall’applicazione attiva, portandosi appresso solo il
puntatore
del mouse ma non il cursore di sistema.

Per fare un esempio, ipotizziamo di essere in un programma che ha un campo di editazione dove scrivere dei caratteri, ma anche dei pulsanti da cliccare che non si trovano nello spazio di scrittura. Qui, per scrivere del testo ci si dovrà servire del Cursore PC, e tutti i caratteri saranno inseriti dove esso è posizionato. Per poter cliccare nei pulsanti, invece, bisognerà servirsi del Cursore Jaws, cercare dove siano questi pulsanti e, una volta che ci si fosse posizionati sopra, si potrà simulare in quel punto la pressione dei pulsanti del mouse.

Poiché siamo sull’argomento, è giusto precisare che esistono altri tipi di cursori:

• Cursore Invisibile, simile al Cursore Jaws, che serve quindi per muoversi anch’esso nello schermo, ma solo per funzioni di lettura, in quanto non trascina con sé né il cursore di sistema e nemmeno il puntatore del mouse.
• Cursore PC Virtuale, attivo negli ambienti Web.
• Cursore Touch, utile in particolare a partire da Windows 10.
• Cursore Braille, per chi usa la barra Braille.

Almeno per l’esercitazione di questo capitolo, useremo soltanto i due più comuni, i cursori PC e Jaws. Era tuttavia corretto citare l’esistenza anche degli altri, perché questi termini li incontreremo comunque, quando tra poco costruiremo il nostro script con i cursori di movimento.

***

Progettare uno Script.

Gli script molto semplici, come il
SalvaConNome ()
che abbiamo creato nel primo capitolo, sono davvero un’eccezione. In genere, uno script deve compiere più operazioni, o controlli, durante il suo lavoro, e per questo deve essere prima pensato nel dettaglio per le funzioni che deve svolgere.

L’esigenza di creare uno script nasce soprattutto quando c’è qualcosa che non si riesce a fare, tramite i classici menu o le scelte rapide, costringendo ad esplorare manualmente lo schermo, con delle serie anche laboriose di comandi. In questi casi, si parte dall’aprire un programma, o una finestra di dialogo del sistema operativo, iniziando ad usare i classici comandi di Jaws, e cercando di capire se siano sufficienti per fornircene un utilizzo completo.

A questo punto, lo scopo della progettazione è quello di provare, direttamente nell’applicativo da utilizzare, la giusta sequenza di tasti che servono per ottenere un determinato obiettivo. Fatto questo, si dovrà necessariamente trasferire nel nostro script i comandi che noi abbiamo attivato tramite i tasti, convertendoli in chiamate alle funzioni che ad essi corrispondono.

Non si nasconde che questa fase di conversione è forse il momento più delicato, in particolare per chi si affaccia per la prima volta a questi temi. Niente di impossibile, tuttavia: se con il tempo avete imparato ad usare i tasti di movimento di Jaws, e magari anche tutti i modi per esplorare lo schermo, adesso sarete sicuramente in grado di capire come trasporre questi comandi negli script, e lo scopo di queste pagine è proprio quello di percorrere assieme i primi passi in questa direzione.

Esercizio 2.2.1. Lo script PronunciaValoreRiga.

La nostra prima esercitazione sui cursori di movimento si pone il compito di leggere quale sia il numero della riga corrente nel
Blocco Note di Windows
. Poiché tale dato si trova nella Barra di stato in fondo alla finestra, questo tipo di informazione ci viene già fornita dal comando di lettura relativo,
TastoJaws+PaginaGiù
, che però ce lo legge assieme ad altre informazioni.

Attenzione: se agendo sul comando appena citato non fosse letto nulla, è probabile che la Barra di stato non sia visualizzata. Per mostrarla, agite sull’omonimo comando del menu
Visualizza
, che si attiva con
Alt+V, lettera S.

Se il comando fosse però disabilitato, e quindi non fosse possibile attivarlo, è probabile abbiate inserita l’opzione
A capo automatico
, che si gestisce agendo sull’omonimo comando del menu
Formato
, premendo
Alt+O, lettera U
. Tale funzionalità, infatti, sino alle versioni del Blocco Note precedenti a Windows 10, non consente di visualizzare la Barra di stato. Se siete quindi abituati a servirvene, anche se avete Windows 10, portate pazienza, ma per l’utilizzo che ne faremo del Blocco Note sarà necessario disattivare l’a capo automatico, almeno temporaneamente, ed in ogni caso rendere funzionante la Barra di stato.

A prescindere dalla sua utilità, questo esercizio ha il solo scopo di farci prendere dimestichezza con questa modalità di lettura dei dati sullo schermo. Carichiamo quindi nel Blocco Note di Windows un file che non sia vuoto, e che sia lungo almeno qualche riga così da poterci muovere liberamente.

Per la fase di progettazione che si citava prima, in particolare per chi è agli inizi, proponiamo di seguito la sequenza delle azioni che noi dovremmo compiere per raggiungere il nostro scopo:

1. Da dentro al Blocco Note, attivare il cursore Jaws, premendo il tasto
   Meno
   del tastierino Numerico.
2. Portare il cursore Jaws alla posizione di quello PC, premendo quello che usate come
   TastoJaws
   assieme al tasto
   Meno
   del tastierino numerico.
3. Portarsi nella riga in basso nella pagina, premendo
   PaginaGiù.
4. Andare ad inizio riga, con il tasto
   Home.
5. Spostarsi sulla prima parola da sinistra, premendo
   Control+FrecciaDestra
   , quindi ripetere un’altra volta questo movimento.
6. Leggere il dato sul cursore, in questo caso il numero di riga, con
   TastoJaws+5
   , quello nel tastierino numerico.
7. Tornare al cursore PC, con il tasto
   Più
   del tastierino numerico.

Se volete, provate anche voi ad eseguire queste azioni, più che altro per prenderne piena coscienza in quanto, di solito, le si compiono in modo spontaneo e senza pensarci troppo. Per poterle riprodurre nello script, invece, devono essere riportate tutte, e soprattutto nella giusta sequenza.

Costruiamo lo script.

Ora, da dentro al Blocco Note, richiamiamo l’Editor di Script di Jaws nel solito modo, con
Insert+0.

Già dalla versione 18 di Jaws anche il Blocco Note di Windows è dotato di propri script. Quindi, a seconda della versione della sintesi vocale che state usando, all’apertura dell’Editor, il file Notepad.JSS potrebbe essere vuoto, oppure avere già degli altri script al suo interno.

In quest’ultimo caso, e ed in tutte le altre occasioni in cui per la prima volta aprite un file script di un applicativo, è buona norma salvare e compilare lo script, usando la scelta rapida
Control+S
, prima che siano effettuate delle modifiche. Se tutto va bene, e si sente la frase di conferma, si può proseguire. Altrimenti, conviene rivolgersi al servizio di assistenza del software di sintesi vocale, per provare a risolvere il problema.

Una volta apertosi il file
Notepad.JSS
, nel caso che vi troviate con del codice già scritto, andate alla fine del file aperto, ottenete almeno una riga vuota premendo il tasto Invio.

Per creare un nuovo script, se ricordate, il comando è appunto
Nuovo Script
, nel menu Script, richiamabile con la scelta rapida
Control+E.

Nell’omonima finestra che compare, si dovranno poi eseguire questi passaggi:

1. Nel campo
   Nome Script
   , scrivete
   PronunciaValoreRiga
   , sempre con le iniziali delle parole in maiuscolo.
2. Nella casella di controllo
   Può essere assegnato al tasto
   , attivatela premendo una volta la barra spazio.
3. Nel campo
   Sommario
   , digitate qualcosa come:
   "Legge il numero della riga corrente.".
4. Nel campo
   Descrizione
   , il testo da inserire potrebbe essere
   "Si porta nell’ultima riga in basso nella pagina e legge il secondo dato da sinistra.".
5. Nel campo
   Categoria
   , selezionate
   "Say".
6. Nel campo
   Assegna a
   , si potrebbe premere una combinazione di tasti a piacere, ma per stavolta usate la scelta rapida
   Control+J
   . Qualora questa combinazione fosse già occupata, optate per un’altra lettera, da abbinare però sempre a un tasto Control.
7. Avendo così compilati tutti i campi necessari, premere Invio per confermare quanto inserito e tornare all’Editor di Script.

Inserire le chiamate a funzione.

Una volta costruita la cornice in cui inserire le istruzioni, dovremmo ora essere tornati nella schermata principale dell’Editor di Jaws. Qui, il cursore sarà posizionato come al solito nella riga vuota posta esattamente al centro dello script, e quindi due righe sotto alla riga d’intestazione, la quale dovrebbe avere stavolta l’aspetto seguente:

Script PronunciaValoreRiga ()

Copia

Infine, due righe sotto alla posizione del cursore, potrete trovare la solita istruzione finale
EndScript.

Si era già accennato al fatto che avremmo inserito nello script le azioni elencate in precedenza, convertendole nelle corrispondenti chiamate a funzioni. In aggiunta ai comandi che abbiamo anche provato manualmente, nello script dovremo inserire anche le funzioni per spegnere e poi riaccendere la sintesi vocale,
SpeechOff ()
e
SpeechOn ()
, che abbiamo già conosciuto durante le rifiniture al nostro primo script.

Soprattutto nel caso di movimento nello schermo, infatti, è opportuno che durante le fasi di spostamento si spenga la sintesi vocale. Così facendo, si potrà impedire che al passaggio del cursore di Jaws siano in qualche modo vocalizzate situazioni, o parti dello schermo, non di nostro interesse.

In realtà, questa esigenza si avverte di più quando ad essere attivo è il cursore PC, il cui movimento innesca una serie di controlli automatici che portano, appunto, alla vocalizzazione del testo o dei controlli incontrati. Tuttavia, anche quando si sposta il Cursore Jaws, come nel caso del nostro script PronunciaValoreRiga, è opportuno proteggere lo script da effetti indesiderati, e quindi aggiungere all’elenco delle azioni da compiere le funzioni citate.

Seguite questa procedura passo passo, tramite la quale daremo istruzioni dettagliate solo per l’inserimento delle prime funzioni, lasciando poi le altre a voi che le aggiungerete allo script per conto vostro, come ulteriore esercizio.

1. Una volta posizionati al centro dello script vuoto, attivate il comando per inserire le chiamate a funzione, tramite la scelta rapida
   Control+I
   . Nella schermata che si apre, per prima cosa inserite
   SpeechOff
   , per spegnere la sintesi, iniziando a digitarne il nome. Quando sentite il nome completo della funzione, premete Tab e poi
   Alt+F
   per chiudere l’inserimento.
2. Tornati alla schermata principale dell’Editor, vi troverete a fine riga, dopo la coppia di parentesi tonde aggiunte dall’Editor stesso alla funzione da voi immessa. Premete una volta Invio per ricreare la riga vuota. Altra pressione di
   Control+I
   per un nuovo inserimento, dopo della quale iniziate a digitare la funzione
   JAWSCursor
   , (CursoreJaws), che serve ad attivare questo tipo di cursore. Quando sentite il nome della funzione, premete Tab e poi Alt+F oppure, se siete certi di aver selezionato la parola corretta, premete Alt+F direttamente senza nemmeno usare Tab.
3. Tornati all’Editor, nuova pressione di Invio per creare la riga, ed altra chiamata a funzione con
   Control+I
   . Stavolta iniziate a digitare un nome più lungo,
   RouteJAWSToPc
   ,(AllineaCursoreJawsACursorePC), che serve appunto ad attivare il cursore JAWS, assicurandosi nel contempo che tale cursore stia dentro alla stessa finestra dove era presente quello PC. In casi come questo, conviene eventualmente premere il tasto Tab dopo le prime lettere, muovendosi poi con le frecce per posizionarsi sulla voce corretta.
4. Create di nuovo una riga vuota, e quindi ripetete l’operazione d’inserimento per tutte le altre funzioni elencate nei successivi punti. I termini da cercare e poi inserire sono soltanto il primo in inglese, che per chiarezza sarà seguito dalla traduzione tra parentesi e dall’azione che genera. Iniziate quindi da
   JAWSPageDown
   , (PaginaGiùDiJaws), per portare il cursore nell’ultima riga nella pagina.
5. JAWSHome
   , (InizioDiJaws), per andare all’inizio della riga.
6. NextWord
   , (ParolaSuccessiva), per muoversi di una parola verso destra.
7. NextWord
   , per raggiungere il numero di riga.
8. SpeechOn ()
   , come abbiamo già visto, per riaccendere la sintesi.
9. SayWord
   , (LeggiParola), per leggere il dato sul cursore, quindi il numero di riga.
10. PCCursor
    , (CursorePC), per tornare al cursore PC.

Le istruzioni che compongono lo script sono numerose, anche a causa della ripetizione della funzione
NextWord ()
. Anche per questo, il sistema scelto non è certamente il più rapido per raggiungere il nostro scopo, ma è quello che consente di avere un codice comunque funzionante.

In ogni caso, se tutto è stato fatto come si deve, il nostro script dovrebbe avere almeno le istruzioni poste nel codice qui di seguito. Per renderlo più comprensibile, sono stati aggiunti anche i commenti, separati dalle istruzioni tramite il carattere Punto e Virgola.

Script PronunciaValoreRiga ()
SpeechOff (); spegne la sintesi
JAWSCursor (); attiva il cursore Jaws
RouteJAWSToPc (); allinea il cursore Jaws a quello PC
JAWSPageDown (); si sposta all’ultima riga in basso
JAWSHome (); si sposta all’inizio della riga
NextWord (); si porta alla parola successiva
NextWord (); raggiunge il numero di riga
SpeechOn (); riattiva la sintesi
SayWord (); legge il dato sul cursore
PCCursor (); torna al cursore PC
EndScript

Copia

Ora vi resta soltanto l’ultima azione, compilare lo script, salvando il file aperto nell’Editor, tramite la scelta rapida
Control+S
. In caso di esito positivo, tornate al Blocco Note di Windows per collaudare lo script.

Qui provate a muovervi in verticale tra un testo su più righe, e provate a leggerne il numero premendo la combinazione specificata durante la creazione dello script come comando di attivazione, ad esempio
Control+J.

Se volete, agite anche sul comando
TastoJaws+PaginaGiù
per verificare se il valore letto dal nostro script corrisponde a quello presente sulla riga di stato.

Analisi delle corrispondenze.

Si era accennato in precedenza al problema, che avremmo affrontato con questo script, di convertire i tasti premuti in funzioni. A tale scopo, riprendiamo il già citato elenco di azioni da compiere.

Per ciascuna voce, sarà fornito dapprima il nome della chiamata a funzione inserita nel codice dello script, seguita dal tasto, o dalla combinazione tasti, che sono recitate quando durante l’Aiuto Tastiera si premono quei tasti.

Questo abbinamento serve per capire se esistono delle regole che possiamo seguire per la conversione dei tasti nelle rispettive funzioni, concentrandoci sui termini inglesi originali usati per identificarli. Se avete comunque dei dubbi sul significato dei termini, tornate indietro allo schema con la spiegazione in italiano, sulla base dei numeri delle voci.

1. JAWSCursor ()
   ; NumPadMinus
2. RouteJAWSToPc ()
   ; JAWSKey+NumPadMinus
3. JAWSPageDown ()
   ; PageDown.
4. JAWSHome ()
   ; Home
5. NextWord ()
   ; Control+RightArrow.
6. SayWord ()
   ; JAWSKey+NumPad5.
7. PCCursor ()
   ; NumPadPlus.

Se si analizza questo breve elenco, è possibile cogliere delle utili indicazioni per aiutarci a risolvere quel problema di cui si accennava prima, trovare una corrispondenza tra i tasti premuti ed il nome delle funzioni da inserire negli script.

In particolare, osservando i punti 3 e 4, si può notare che la funzione che simula la pressione di questo tipo di tasti di movimento, è costituita dal prefisso
JAWS
seguito dal nome in inglese del tasto, regola che vale anche nei seguenti casi:

JAWSPageUp
, (PaginaSuDiJaws), che porta il cursore in alto nella finestra.

JAWSEnd
, (FineDiJaws), che porta il cursore a fine riga.

Poi, prendendo in esame i punti 1 e 7, anche se non vi è alcuna corrispondenza tra il nome della combinazione e la relativa chiamata a funzione, si può comunque notare che il nome delle funzioni che attivano un cursore di Jaws sono costituite dal nome del cursore stesso, seguite dalla parola
Cursor
. Ad esempio, oltre a quelle utilizzate, altre funzioni che attivano i cursori di Jaws sono:

InvisibleCursor
, (CursoreInvisibile).

BrailleCursor
, (CursoreBraille).

Ancora, se il punto 5 non ci dice nulla in fatto di corrispondenze, va detto che il prefisso
Next
, (Successivo), è comune a molte altre funzioni che sono composte da due parti, in cui la seconda ne illustra l’oggetto dell’azione. Ad esempio, le seguenti funzioni hanno il significato indicato nel commento:

NextCharacter
, (CarattereSuccessivo).

NextLine
, (RigaSuccessiva).

Infine, al punto 6, la funzione
SayWord ()
fa parte di una grande famiglia di chiamate a funzione, che nelle ultime versioni di Jaws è composta da una novantina di unità. Tutte queste hanno in comune come prefisso la parola
"Say"
, che si può interpretare come
Leggi
, con la seconda parte del nome che, anche in questo caso, indica l’elemento che sarà letto.

Senza proporre qui il loro elenco completo, prendiamo l’esempio delle voci appena citate, dichiarando che esistono almeno le seguenti funzioni:

SayCharacter
, (LeggiCarattere), che pronuncia il carattere sul cursore.

SayLine
, (LeggiRiga), che pronuncia il contenuto della riga corrente.

Niente di troppo complicato, quindi, bensì un qualcosa che possiede delle regole, e che consente perciò di individuare la soluzione anche tramite un ragionamento. Se non altro, problemi di lingua a parte, seguendo qualche regola nel creare i nomi, si può anche evitare di dover imparare a memoria tutte le combinazioni che eseguono i diversi elementi di codice.

Può essere molto utile, inoltre, da dentro ad un qualsiasi script, simulare l’inserimento di una funzione, premendo
Control+I
, per avere l’opportunità di scorrere il loro lungo elenco. Sarà possibile farsi almeno un’idea degli strumenti che sono a nostra disposizione, cercando di capire cosa facciano le singole funzioni, direttamente dal nome oppure dalle note informative che sono pronunciate durante lo scorrimento.

Controllare i dati dello script.

Una volta creato uno script, può nascere l’esigenza di verificare quali dati siano stati effettivamente immessi durante la procedura di creazione, in particolare la combinazione di tasti usata per attivare lo script.

Per fare questo, sarà sufficiente posizionarsi in un qualsiasi punto al suo interno, tra l’intestazione e l’istruzione finale dello stesso. Da qui, si potrà richiamare un nuovo comando dell’Editor,
Visualizza Documentazione
, che si attiva tramite la combinazione
Alt+V, lettera D
, oppure più semplicemente con la scelta rapida
Control+D.

La schermata che si apre,
Informazioni Script
, replica in pratica la schermata
Nuovo Script
, perché presenta tutti i campi di quella finestra di dialogo. Durante la fase di creazione di un nuovo script, i campi dei vari dati servono tutti, e quindi in quel caso li si può scorrere con i tasti Tab. In realtà, sia in questa schermata di modifica, sia in quella di creazione, i vari campi hanno una loro combinazione di scelta rapida per portarsi direttamente dove si vuole intervenire. Tale caratteristica è comune a tutti i campi, ad eccezione di quello denominato
Può essere assegnato al tasto
, che però è il secondo dall’inizio e quindi si può raggiungere con una sola pressione del tasto Tab.

I tasti di scelta rapida sono facilmente memorizzabili, in quanto sono composti dal tasto
Alt
premuto assieme alla lettera iniziale del campo, come indicato di seguito:

• Alt+N, per portarsi nel campo Nome Script.
• Alt+S, per il campo Sommario.
• Alt+D, per il campo Descrizione.
• Alt+C, per il campo Categoria.
• Alt+A, per il campo Assegna a.

***

Specificare un parametro.

Nel nostro script PronunciaValoreRiga, nella forma attuale, viene letto il solo numero della riga, senza tuttavia specificare cosa tale numero rappresenti. Nella Barra di stato questo numero è preceduto dalla parola
Linea
, ed uno dei metodi possibili per fare una maggiore chiarezza sarebbe far sì che fosse letto anche questo termine, oltre al numero. Come prossima esercitazione del capitolo, invece, vogliamo che prima del numero sia pronunciata la parola
Riga
. Per ottenere questo, dovremo servirci di una delle tante funzioni che hanno come prefisso la parola
"Say"
, in questo caso
SayString
, (LeggiDatoTestuale), che appunto recita tramite la sintesi vocale un testo da noi indicato. Ma come facciamo a dire ad una chiamata a funzione che ci legga un messaggio?

Il modo più semplice per trasmettere qualcosa alle funzioni, così che possano elaborarlo o leggerlo, è quello di passare loro dei
parametri
. Questi elementi non sono altro che dei dati posti all’interno di quelle parentesi, che sinora avete incontrato solo in coppia aperte e chiuse, alla fine di ogni nome di script, oppure di ogni chiamata a funzione.

I dati che è possibile passare come parametro sono di diverso tipo, ma i due principali sono:

1. String
   , (DatoTestuale), che va inserito tra virgolette.
2. Integer
   , (NumeroIntero), che si specifica mettendo solo un numero.

Queste due parole chiave, String ed Integer, sono spesso usate in funzioni e script come seconda parte del nome, come nel caso di SayString, per indicare che l’azione indicata nella prima parte del nome, in questo caso
"Say"
, si riferisce appunto a quel tipo di dato. Per questo, analogamente a SayString, esiste anche
SayInteger
, (LeggiNumeroIntero), per far leggere un valore specificando come parametro, appunto, un numero intero.

Tornando al nostro esempio, il parametro da passare alla funzione, affinché lo legga, è un dato testuale, che va quindi indicato tra virgolette, nel nostro caso la parola
Riga
. Questa modifica al nostro script ci consente di fornire subito un esempio concreto in grado di chiarire questi concetti che, almeno per alcuni, saranno più o meno nuovi, e che potendoli analizzare in un’applicazione pratica, perdono tutta la loro dose di mistero. Per il momento, sappiate che i parametri sono solitamente specificati durante la procedura di inserimento, e che tutto si riduce in uno o più campi aggiuntivi da compilare durante questa procedura.

Esercizio 2.3.1. La seconda versione di PronunciaValoreRiga ().

A questo punto dovremmo avere ancora aperto l’Editor, con il cursore dentro al nostro script PronunciaValoreRiga. Se così non fosse, ricreate tale condizione, e portatevi nella riga che contiene l’istruzione
SpeechOn ()
. Andate sino a fine riga, e qui premete Invio per creare una riga vuota, quindi seguite i passi qui riportati:

1. Premete
   Control+I
   per inserire la chiamata a funzione citata in precedenza,
   SayString.
2. Nel campo che si apre, iniziate a digitarne il nome e, quando la sentite pronunciare, premete Tab per selezionarla. Qui, anziché concludere l’inserimento, proseguite nella procedura guidata cliccando sul pulsante
   Avanti
   oppure, più semplicemente, premendo la scelta rapida
   Alt+A.
3. Il titolo del campo in cui si è giunti,
   Parametro 1
   , indica chiaramente che qui dobbiamo digitare il nostro parametro, il testo che vogliamo sia pronunciato dalla funzione. Digitate quindi
   "Riga"
   , stavolta mettendo anche le virgolette perché altrimenti, in sede di compilazione, darebbe errore.
4. Soltanto ora, dopo aver specificato il parametro, potete concludere l’inserimento della funzione tramite la pressione di
   Alt+F.

Una volta tornati nella schermata principale dell’Editor di Script, sarete posizionati alla fine della funzione appena immessa, la cui istruzione dovrebbe avere l’aspetto seguente:

SayString ("Riga")

Copia

Come potete notare, il testo che Jaws dovrebbe leggere è quello tra virgolette all’interno delle parentesi che, come si è detto, prende il nome di Parametro.

Dopo questa modifica, lo script dovrebbe avere le istruzioni seguenti:

Script PronunciaValoreRiga ()
SpeechOff (); spegne la sintesi
JAWSCursor (); attiva il cursore Jaws
RouteJAWSToPc (); allinea il cursore Jaws a quello PC
JAWSPageDown (); si sposta all’ultima riga in basso
JAWSHome (); si sposta all’inizio della riga
NextWord (); si porta alla parola successiva
NextWord (); raggiunge il numero di riga
SpeechOn (); riattiva la sintesi
SayString ("Riga"); pronuncia il testo indicato
SayWord (); legge il dato sul cursore
PCCursor (); torna al cursore PC
EndScript

Copia

Provate adesso a compilare questa nuova versione dello script, con la scelta rapida
Control+S
. Se vi fossero errori nel codice, il problema verrebbe segnalato, con un messaggio, sempre in inglese, in una finestra di dialogo nella quale si può solo che premere il pulsante
Ok
. Usciti dall’avviso, il cursore si sarà spostato sulla riga dove il programma ha riscontrato l’errore.

Nel caso in cui abbiate modificato manualmente il testo dello script, l’unico errore che potreste aver commesso è quello di aver omesso una o entrambe le virgolette tra le parentesi ed il testo da leggere.

Quando tutto funziona, tornate al Blocco Note per provare questa versione del nostro script. Se prima del numero viene pronunciata anche la parola
Riga
, allora è tutto a posto. Non chiudete ancora, tuttavia, né il Blocco Note, né l’Editor di Jaws, al quale torneremo a breve.

***

Funzioni come parametro.

Gli script e le funzioni di Jaws sono davvero migliaia, specie se aggiungiamo tutte quelle che sono state scritte e messe a disposizione per i singoli applicativi. Conoscere tutto è davvero difficile, specie agli inizi, e può capitare di impegnarsi per far svolgere un compito al programma di sintesi vocale, per poi scoprire che esisteva già uno script o una funzione che lo svolgeva al meglio.

Se non l’aveste già saputo, e comunque prima che lo scopriate da soli, questo è il caso del nostro script appena realizzato. Infatti, Jaws restituisce il numero di riga di un documento tramite addirittura un paio di sue funzioni, tra cui
GetCursorRow
, (OttieniRigaSulCursore), che restituisce appunto il valore numerico corrispondente alla riga su cui è posto il cursore.

Mentre le funzioni analizzate sinora compivano un’azione concreta, o richiamavano un tasto, oppure muovevano il cursore, questo tipo di funzioni hanno come effetto, che in gergo si chiama
ritorno
, quello di trasformare l’istruzione eseguita in un dato ad essa corrispondente. Il dato, tuttavia, una volta restituito allo script, rimane lì nell’attesa che qualcuno lo utilizzi, come ad esempio una funzione di lettura.

In altre parole, per utilizzare un dato restituito da una funzione, testuale o numerico che sia, può essere necessario inserirlo dentro ad un’altra funzione che, come nel nostro esempio, lo legga.

Come progettazione, iniziamo col dire che lo scopo è far pronunciare a Jaws un messaggio, ancora tramite la funzione
SayString ()
. Tale messaggio, che costituisce il parametro da passare alla funzione, si compone mettendo la parola
Riga
affiancandolo poi al valore della riga stessa. Questa azione, che si definisce
concatenare una stringa
, si attua mettendo il segno
Più,
+
, tra un dato e l’altro. Per fare questo, però, i due dati devono essere entrambi delle stringhe, mentre noi il numero della riga ce l’abbiamo come dato numerico,
Integer.

Per convertire un valore numerico in stringa si usa la funzione
IntToString
, (DaNumeroInteroADatoTestuale), usando come suo parametro, in questo caso, la appena citata funzione per ottenere il numero di riga.

Quando ci si trova in presenza di più funzioni una dentro all’altra, si dice che esse siano
annidate
. In tali occasioni, le funzioni sono eseguite iniziando prima da quella più interna, passando poi a quella che la contiene, ed il risultato dell’una va ad alimentare l’azione dell’altra. Nel nostro caso, la sequenza degli eventi sarà la seguente:

1. GetCursorRow ()
   , ci fornisce il numero di riga in forma numerica.
2. IntToString ()
   , ci converte il risultato di
   GetCursorRow ()
   in forma di stringa.
3. Il segno
   Più
   ci consente di creare il messaggio unendo la parola
   Riga
   con il risultato di
   IntToString ().
4. SayString ()
   ci legge il messaggio.

Esercizio 2.4.1. La versione definitiva di PronunciaValoreRiga ().

Questo è il classico caso in cui un’azione è più difficile da spiegare che da compiere. Dopo la premessa teorica, proviamo ora a modificare lo script da noi realizzato, seguendo questi passi:

1. Tornate all’Editor di script, con caricato Notepad.JSS.
2. Portatevi all’interno dello script
   PronunciaValoreRiga ()
   , e cancellatene tutto il contenuto, lasciando solo la riga d’intestazione e l’istruzione di chiusura.
3. Portatevi in una riga vuota nello script e scrivete manualmente, senza utilizzare la procedura guidata, l’istruzione che, nella versione del nostro script qui riportata, è posta al centro:

Script PronunciaValoreRiga ()
SayString ("Riga" + IntToString (GetCursorRow ()))
EndScript

Copia

Dopo averne analizzato il contenuto, se volete, metteteci voi qualche parola di commento dopo l’istruzione. In ogni caso, provate a compilare con
Control+S
. Se si verifica un errore, ricontrollate la forma, in particolare la presenza di entrambe le virgolette, o della tripla parentesi chiusa a fine istruzione.

Quando tutto va bene, provate a premere i tasti di Attivazione dello script,
Control+J
, se avete seguito le nostre indicazioni. Dovreste sentire lo stesso risultato di prima, anche se Jaws lo pronuncerà con una voce diversa.

Nella versione precedente, infatti, quando la funzione
SayString ()
ci leggeva il numero di riga, noi avevamo attivato il cursore Jaws, e questa parte dell’informazione ci veniva pronunciata con la voce abbinata a questo cursore. In questa seconda versione, invece, la stessa funzione legge il messaggio con il cursore PC attivo, e quindi il suo contenuto viene pronunciato con la voce standard.

A tal proposito, chiariamo soltanto che più avanti impareremo come determinare quali voci di Jaws debbano leggere i nostri messaggi.

***

Riepilogo.

Giunti alla fine di questo secondo capitolo, va detto che quanto espresso sinora era rivolto in particolare a chi fosse stato a completo digiuno del mondo degli script, ed anche per questo le informazioni fornite erano necessariamente molto didascaliche, e con qualche ripetizione dei comandi e dei concetti più importanti.

Nel prossimo capitolo proveremo a dare qualche spunto in più, sia pure continuando ad analizzare i vari aspetti da conoscere per realizzare gli script. In particolare, cercheremo di capire qual è il rapporto tra i molti file script già esistenti ed il file script Predefinito, e come usare Jaws per omologare il più possibile i comandi tra i vari applicativi.

Download

Archivio da scaricare, con il codice elaborato sinora

Per ulteriori spiegazioni, scrivere a:

Abramo Volpato