Logo dell'UIC Logo TUV

Unione Italiana dei Ciechi e degli Ipovedenti - ONLUS-APS

 

Uiciechi.it

torna alla visualizzazione del numero 14 del Uiciechi.it

Numero 14 del 2020

Titolo: Gli script di Jaws, capitolo 2. Leggere le informazioni a video.

Autore: Abramo Volpato.


Articolo:
Gli script di Jaws, capitolo 2. Leggere le informazioni a video.

Di Abramo Volpato.

2.1. 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.

2.1.1. 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.

***

2.2. 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 al termine della riga, con il tasto "Fine".

5. Spostarsi sulla prima parola da destra, premendo "Control+FrecciaSinistra", quindi ripetere altre tre volte 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.

2.2.2. Costruiamo lo script.

Ora, da dentro al Blocco Note, richiamiamo l'Editor di Script di Jaws nel solito modo, con "Insert+0". Una volta apertosi il file "Notepad.JSS", portatevi in fondo con "Control+Fine", e create almeno una riga vuota dopo l'ultimo script presente.

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 quarto dato da destra".

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.

2.2.3. 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 ()

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. "JAWSEnd", (FineDiJaws), per Andare al termine della riga.

6. "PriorWord", (ParolaPrecedente), per muoversi di una parola verso sinistra.

7. "PriorWord", inserendo una seconda volta tale funzione, per portarsi sul titolo di colonna

8. "PriorWord",ripetendo una terza volta il movimento, per portarsi sul carattere Virgola

9. "PriorWord", per raggiungere infine il numero di riga al quarto movimento

10. "SpeechOn ()", come abbiamo già visto, per riaccendere la sintesi.

11. "SayWord", (LeggiParola), per leggere il dato sul cursore, quindi il numero di riga.

12. "PCCursor", (CursorePC), per Tornare al cursore PC.

Le istruzioni che compongono lo script sono numerose, soprattutto a causa delle quattro ripetizioni della funzione "PriorWord ()". 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 con il Blocco Note, sia nella sua versione per Windows 10, sia in quelle fornite nei precedenti sistemi operativi.

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
JAWSEnd (); si sposta al termine della riga
PriorWord (); torna indietro di una parola
PriorWord (); arriva sul titolo di colonna
PriorWord (); arriva sul carattere Virgola
PriorWord (); raggiunge il numero di riga
SpeechOn (); riattiva la sintesi
SayWord (); legge il dato sul cursore
PCCursor (); torna al cursore PC
EndScript

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.

2.2.4. 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. "JAWSEnd ()"; End

5. "PriorWord ()"; Control+LeftArrow.

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.

"JAWSHome", (InizioDiJaws), che porta il cursore ad inizio 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 "Prior", (Precedente), è comune a molte altre funzioni che sono composte da due parti, in cui la seconda ne illustra l'azione. Ad esempio, le seguenti funzioni hanno il significato indicato nel commento:

"PriorCharacter", (CaratterePrecedente).

"PriorLine", (RigaPrecedente).

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.

2.2.5. 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 tasto A.

***

2.3. 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")

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
JAWSEnd (); si sposta al termine della riga
PriorWord (); torna indietro di una parola
PriorWord (); arriva sul titolo di colonna
PriorWord (); arriva sul carattere Virgola
PriorWord (); 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

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.

***

2.4. 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 "nidificate". 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 l'istruzione che, nella versione del nostro script qui riportata, è posta al centro:

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

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.

***

2.10. 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.

2.10.1. Elementi di Codice Personale.

PronunciaValoreRiga. File script: Blocco Note. Control+J.
- Legge il numero della riga corrente.

2.10.2. Script, Funzioni e Comandi di Jaws.

JAWSCursor. (CursoreJaws).
- Attiva il cursore Jaws.

RouteJAWSToPc. (AllineaCursoreJawsACursorePC).
- Riposiziona il cursore Jaws, portandolo nel punto dove è posto il Cursore PC.

JAWSPageDown. (PaginaGiùDiJaws).
- Sposta il cursore all'ultima riga in basso nella finestra.

JAWSEnd. (FineDiJaws).
- Porta a fine riga.

SayWord. (LeggiParola).
- Pronuncia il testo sul cursore.

PCCursor. (CursorePC).
- Attiva il cursore PC.

JAWSPageUp. (PaginaSuDiJaws).
- Sposta il cursore alla prima riga in alto nella finestra.

JAWSHome. (InizioDiJaws).
- Porta ad inizio riga.

InvisibleCursor. (CursoreInvisibile).
- Attiva il cursore Invisibile.

BrailleCursor. (CursoreBraille).
- Attiva il cursore Braille.

PriorLine. (RigaPrecedente).
- Sposta il cursore attivo alla riga superiore.

SayCharacter. (LeggiCarattere).
- Pronuncia il carattere sul cursore.

SayLine. (LeggiRiga).
- Pronuncia il contenuto della riga corrente.

SayString. (LeggiDatoTestuale).
- Pronuncia il dato testuale indicato.

SayInteger. (LeggiNumeroIntero).
- Pronuncia il valore numerico indicato.

GetCursorRow. (OttieniRigaSulCursore).
- Restituisce il valore numerico corrispondente alla riga su cui è posto il cursore.

IntToString. (DaNumeroInteroADatoTestuale).
- Converte un valore numerico in un dato testuale .

2.10.3. Voci di Glossario.

Cursore PC.
- Cursore principale di Jaws, attivo all'avvio.

Cursore Jaws.
- Cursore secondario di Jaws, per l'esplorazione dello schermo.

puntatore.
- Valore che segna la posizione di un elemento o di un oggetto all'interno di un altro.

Visualizza Documentazione.
- Nell'Editor di Script, comando per visualizzare la schermata di modifica degli elementi di codice creati.

parametri.
- Dati trasmessi all'elemento di codice per l'elaborazione dei risultati.

String. (DatoTestuale).
- Tipo di dato trattato nel codice, e parola chiave per dichiarare le variabili del'omonima tipologia.

Integer. (NumeroIntero).
- Tipo di valore numerico trattato nel codice.

concatenare una stringa.
- Creare una sola stringa partendo da almeno due dati testuali.

nidificate.
- Nel caso delle funzioni, Due o più elementi dove il risultato dell'una viene passato come parametro in un'altra. Nelle strutture di controllo, serie di condizioni che sono verificate solo se quella più esterna risulta vera.

Per ulteriori spiegazioni, scrivere a: Abramo Volpato, oppure, a: Nunziante Esposito



Torna alla pagina iniziale della consultazione delle riviste

Oppure effettua una ricerca per:


Scelta Rapida