Numero 12 del 2021
Titolo: Gli script di Jaws 14d. Le procedure guidate: gestione dei pulsanti ed elementi base.
Autore: Abramo Volpato.
Articolo:
Gli script di Jaws 14d. Le procedure guidate: gestione dei pulsanti ed elementi base.
Di Abramo Volpato.
Note.
1. La combinazione scelta per questo script richiama la precedente, in quanto vi aggiunge soltanto il tasto "Shift", in modo del tutto analogo a quanto si fa in alcuni funzioni di ripetizione di ricerca, ad esempio, nell'Editor di Script, dove si usa il tasto funzione "F3" per ripetere una ricerca in avanti, e "Shift+F3" per ripeterla all'indietro.
Codice.
Script MuoveSingoloPrecedente1 ()
GestisceDato (); chiama l'apposita funzione.
EndScript
Collaudo.
1. Dopo aver compilato, ripetete le operazioni di prima, posizionandovi dentro al corpo dello script e premendo "Shift+Control+Windows+P". Confermate poi la scelta del valore 9, quindi premete Invio anche alla successiva richiesta, e attendete la conclusione della procedura.
2. Se non siete in fondo al file script, andatevi, e da lì premete "Shift+Windows+1", ed il cursore dovrebbe fermarsi nell'intestazione dello script "MuoveSingoloPrecedente9 ()". Se volete, provate a premere anche "Shift+Windows+2", e la ricerca dovrebbe iniziare un movimento all'indietro sino alla prima funzione esistente. Poiché la prima dovrebbe essere la nostra "ElaboraDato ()", la ricerca potrebbe protrarsi per più di qualche secondo, ma alla fine si dovrebbe giungere a destinazione.
3. Per sfruttare al massimo i singoli elementi di ricerca, completiamo la registrazione delle stringhe testuali necessarie, premendo "Windows+0", da dentro l'Editor di Script con aperto il file script predefinito. Nella schermata che si presenta, contenente i tre elementi sinora memorizzati, premete ripetutamente "Alt+I",inserendo come elementi di ricerca i comandi posti di seguito, e confermando la stringa immessa premendo Invio dopo ciascun termine:
- While
- EndWhile
- For
- EndFor
- EndScript
- EndFunction
4. Non lasciate spazi né prima, né dopo il termine. Dopo aver immesso queste ulteriori sei stringhe, dovreste così aver completato il numero massimo di elementi disponibili, che abbiamo stabilito essere 9. Se adesso provate ancora una vota a premere "Alt+I", infatti, sarà emesso un segnale acustico di errore, e la sintesi pronuncerà con la voce del cursore Jaws il seguente messaggio:
"Alt+I"Raggiunto il limite massimo di voci."
5. In ogni caso, uscite dalla procedura di elaborazione premendo il tasto Escape. Una volta tornati all'Editor, se non ci siete già, andate all'inizio della funzione "ElaboraDato ()", e premete la combinazione "Windows+4"; dovreste così posizionarvi all'inizio del ciclo "While" principale, poiché quella che avete premuto è proprio la ricerca rapida di tale parola chiave.
6. Premete ora la scelta rapida "Windows+5", che corrisponde al comando di chiusura ciclo, "EndWhile", e dovreste posizionarvi sulla prima occorrenza di tale termine. Poiché in questa funzione i cicli "While" erano due, l'uno dentro all'altro, il primo comando di chiusura incontrato corrisponde in realtà a quello relativo al ciclo più interno, quello secondario. Se da lì premete ora il comando per tornare indietro, "Shift+Windows+4", tornerete quindi al comando di inizio ciclo, ma quello secondario, non il precedente, che invece raggiungerete premendo un'altra volta la citata combinazione tasti.
14.5.13. Ridurre il numero degli elementi da ricercare.
Sperimentando la ricerca per singoli elementi, abbiamo così registrato tutte e nove le stringhe possibili per l'estensione ".JSS". Se noi torniamo ad aprire un file con tale estensione tramite il Blocco Note, e torniamo invece ad usare i comandi di spostamento agli elementi successivo o precedente, "Windows+FrecciaGiù" o "Windows+FrecciaSu", il cursore si fermerà al primo elemento trovato, cercando tra gli elementi registrati fino a quello sul quale abbiamo avviato la ricerca, premendo Invio direttamente dall'interno della procedura.
In pratica, se noi ad esempio volessimo limitare la ricerca alle sole tre parole chiave di script o funzioni, allora dovremmo almeno una volta rientrare nella procedura con "Windows+0", selezionare la terza voce dell'elenco e quindi premere Invio per avviare la ricerca. Da quel momento in poi, tutte le volte che si premeranno i tasti "Windows+FrecciaGiù" o "Windows+FrecciaSu", la ricerca sarà limitata alle prime tre voci dell'elenco.
Se invece noi volessimo allargare questa ricerca generica anche ai comandi di apertura e chiusura dei cicli "While", dovremmo invece far partire la ricerca cliccando sulla quinta voce dell'elenco, e così via. Una volta impostate, per non cambiare le proprie preferenze, si potranno sempre effettuare delle modifiche al contenuto, al numero ed alla posizione degli elementi di ricerca, purché si abbandoni la fase di elaborazione premendo il tasto Escape.
14.5.14. Elementi di ricerca per tutte le estensioni.
Per i file script, almeno nell'Editor di Jaws, sono già presenti dei comandi nativi per lo spostamento tra elementi di codice, e per questo il nostro sistema è più utile per spostarsi alle singole parole chiave . Tale procedura è invece indispensabile nei documenti di tutte le altre estensioni, per i quali non sono previsti sistemi di ricerca neppure dentro allo stesso Editor di Script.
Per averne la riprova, seguite questi passi:
1. Aprite con l'Editor di Jaws un qualsiasi file tasti, quelli con estensione ".JKM", ad esempio "Default.JKM".
2. Avviate la procedura guidata per gli elementi di ricerca, premendo "Windows+0", ed il sistema vi avvertirà che non sono registrati degli elementi per tale estensione.
3. Cogliete l'occasione per inserire il solo carattere Aperta Quadra, quindi confermate con Invio. Da adesso in poi, premendo i tasti per gli elementi successivo e precedente, "Windows+FrecciaGiù" e "Windows+FrecciaSu", vi sposterete alle etichette di sezione presenti nel file, come ad esempio "Common Keys", oppure "Desktop Keys".
4. Se voleste fare un'altra prova, aprendo i file Messaggi, quelli con estensione ".JSM", ripetete il passaggio al punto 2, e quindi inserite il solo carattere Punto e Virgola, ";". In questo modo, usando i soliti tasti di movimento, vi sposterete tra le intestazioni dei messaggi, quelle che hanno appunto tale carattere ad inizio riga.
A margine di quanto appena illustrato, se ricordate, lo spostamento al carattere Punto e Virgola, tramite il nostro sistema, era previsto anche dagli script "MuoveCommentoSuccessivo ()" e "MuoveCommentoPrecedente ()", che abbiamo realizzato alla fine del dodicesimo capitolo . Di tali script, tuttavia, se ne consiglia l'uso appunto nei soli file con estensione ".JSS",dove hanno il compito di spostarsi tra i commenti che occupano tutta una riga, mentre per i file Messaggi si consiglia di usare il sistema appena illustrato.
Questo, infatti, porta a servirsi dei tasti "Windows+FrecciaGiù" e "Windows+FrecciaSu" per cercare gli elementi eventualmente registrati in qualsiasi tipo di documento, senza star lì a pensare troppo quale estensione il file abbia, oppure quale applicativo si stia usando. le uniche condizioni sono che siano applicazioni per le quali, come detto, sia stato registrato un tipo di finestra di "Editing", ed il massimo di nove elementi registrabili per ciascuna estensione.
14.6. Le macro testuali .
Fin dai primi capitoli avevamo realizzato degli script che inserivano stringhe predefinite nel documento corrente, il cui nome era "InserisceFirma ()" e "AperturaCodice ()". Successivamente, prima nel decimo capitolo e poi in quello scorso, avevamo creato altri tre script, "MetteMacroTesto3 ()", "MetteMacroTesto4 ()" e "MetteMacroTesto5 ()", che ci sono serviti per compiere senza errori delle modifiche a elementi di codice nativi di Jaws.
In quei casi le stringhe immesse nel testo erano state preimpostate, memorizzandole in costanti o messaggi. Ora che ci siamo dotati di una nostra procedura per l'inserimento e la registrazione di stringhe testuali, ne approfittiamo per allargare a tale tipo di strumenti il sistema appena creato.
Per fare questo, realizzeremo la versione definitiva della funzione creata nel sesto capitolo, "MetteTesto ()", la quale si occupava di scrivere materialmente le stringhe nel documento. Per omologarla alla procedura, ne creeremo una nuova versione,il cui nome avrà solo la prima parte in comune, mentre per la seconda useremo il suffisso predefinito di questo tipo di funzioni, e cioè "Dato".
Per completare la sezione, in modo analogo a quella precedente, faremo uno script per avviare la procedura di inserimento stringhe, che d'ora in poi chiameremo "macro", ed una serie che avrà comunque un suffisso numerico da 1 a 9, con un nome che esamineremo poi da cosa sia composto.
Durante i collaudi, infine, capiremo meglio quali siano le caratteristiche peculiari di questa opzione, rispetto agli elementi di ricerca. In particolare, anticipiamo già che le macro saranno sempre legate alle estensioni, e che avranno un suffisso numerico da 1 a 9, ma potranno essere articolate in più serie, le quali saranno a loro volta legate a particolari combinazioni tasti.
Esercizio 14.6.1. La funzione MetteDato.
FileScript. Default.JSS
Nome. MetteDato
Descrizione. Inserisce nel documento attivo il contenuto della macro testuale avente l'oggetto ed il numero progressivo specificati.
Ritorni. Di tipo Void. Nessuno.
Parametri.
1. sEstensione. L'estensione dei file cui sono associati i dati registrati. Di tipo String.
2. sProg. Il numero progressivo in forma testuale che identifica il dato. Di tipo String.
3. iAiuto. Se valorizzato con TRUE, attiva l'omonima fase. Di tipo Int.
Note.
1. Il codice della funzione corrisponde per poco più di un terzo con quella originaria, "MetteTesto ()", quindi conviene senz'altro riscriverlo da zero; continueremo comunque ad usare anche l'altra versione, che serve, per esempio, a realizzare le serie di script.
Codice.
Void Function MetteDato (string sEstensione, string sProg, int iAiuto)
Var
String sSezione, ; nome della sezione con i dati
String sMacro, ;testo della macro
String sTitolo, ; titolo della finestra di dialogo
String sMessaggio, ; testo del messaggio nel corpo della finestra
String sChiavi, ; elenco delle chiavi presenti
Int i, ; contatore del ciclo
Int iRighe, ; numero delle righe copiate
String sRiga; singolo segmento da scrivere
If !ArchivioDati () Then; se il file di configurazione è mancante o incompleto,
Return; interrompe il flusso
EndIf; fine controllo file configurazione
Let sSezione = gsCategoria + gsOggetto + sEstensione; compone la sezione dove cercare i dati
Let gnMultiple = TRUE; imposta l'immissione di testo su più righe
Let sMacro = LeggeRecord (gsArchivio, sSezione, sProg); rileva il testo della macro
If !sMacro Then; se nessun testo è presente,
Let sTitolo = FormatString (ttlNoMacro, gsOggetto, sProg); compone il titolo della conferma,
Let sMessaggio = FormatString (msgImmissione, _A); e ne formatta anche il messaggio
If ChiedeConferma (sTitolo, sMessaggio) Then; se si conferma l'l'inserimento della macro,
; rileva le chiavi delle macro registrate per l'estensione del documento corrente
Let sChiavi = CambiaCampo (ChiaviUtente (gsArchivio, sSezione), ZERO)
; compone il numero progressivo con quello delle macro registrate aumentato di un'unità
Let sProg = IntToString (StringSegmentCount (sChiavi, PIPE) + 1)
; memorizza il dato eventualmente immesso
Let sMacro = InserisceTesto (FormatString (ttlElaboraVoce, AGGIUNGE, gsCategoria, sProg))
If sMacro Then; se una nuova macro è stata immessa,
If !ScriveRecord (gsArchivio, sSezione, sProg, sMacro) Then; se la macro non si registra,
Let sMacro = NULLO; resetta la macro per impedire la successiva scrittura
If iAiuto Then; se è attiva la fase, legge l'avviso
SayFormattedMessage (OT_ERROR, hlpNoScrittura, hlpNoScrittura_corto, gsArchivio)
EndIf; fine controllo aiuto
Return; in ogni caso, interrompe il flusso
EndIf; fine controllo scrittura macro
EndIf; fine controllo immissione macro
EndIf; fine controllo conferma prosecuzione
EndIf; fine controllo presenza macro
If !sMacro Then; se un testo comunque non è stato rilevato,
If iAiuto Then; se è attiva la fase Aiuto, formatta e pronuncia l'avviso
SayFormattedMessage (OT_ERROR, hlpNoDato, hlpNoDato_corto, FormatString (msgPosizione, sProg))
EndIf; fine controllo aiuto
Return; in ogni caso, interrompe il flusso
EndIf; fine controllo presenza dato
; converte il testo della macro, sostituendo gli eventuali separatori con un carattere Ascii 13
Let sMacro = InverteForma (sMacro, TRUE, CR)
SpeechOff (); spegne la sintesi
; esegue un ciclo, ripetendolo per il numero di segmenti nella stringa
For i = 1 To StringSegmentCount (sMacro, CR)
If i > 1 Then; dal secondo passaggio in poi,
EnterKey (); simula la pressione di Invio, per creare una nuova riga
Let iRighe = iRighe + 1; aggiorna il contatore delle righe copiate
Pause (); sospende momentaneamente il flusso
EndIf; fine controllo passaggi
Let sRiga = StringSegment (sMacro, CR, i); estrae il segmento equivalente ad una riga,
TypeString (sRiga); e lo trascrive nel documento
EndFor; fine ciclo scansione testo
If StringRight (sMacro, 1) == CR Then; se l'ultimo carattere del testo è quello di ritorno a capo,
EnterKey (); crea un'ulteriore riga
Let iRighe = iRighe + 1; aggiorna il numero complessivo delle righe
EndIf; fine controllo ultimo carattere
SpeechOn (); riattiva la sintesi
If iRighe Then; se sono state copiate delle righe intere,
If iRighe > 1 Then; se le righe sono più di una,
Let sRiga =FormatString (msgMettiRighe, iRighe); formatta il dato con il numero di righe
EndIf; fine controllo numero righe
SayUsingVoice (VCTX_JAWSCURSOR, sRiga, OT_HELP); legge il testo con la voce del cursore Jaws,
EndIf; fine controllo righe copiate
Delay (ATTESA); sospende temporaneamente il flusso
SayLine (); legge la riga corrente
EndFunction
Collaudo.
1. Come nel caso precedente, limitatevi per il momento a compilare, perché il collaudo lo faremo con il prossimo script.
Esercizio 14.6.2. Lo script ElaboraMacroTesto.
FileScript. Default.JSS
Nome. ElaboraMacroTesto
Sommario. Avvia la procedura di elaborazione delle macro denominate Testo.
Descrizione. Chiama la funzione che gestisce le procedure guidate, la quale consente in questo caso di elaborare le macro disponibili per i documenti con l'estensione di quello corrente, e identificate con il termine Testo.
TastiAttivazione. Shift+Control+0
Note.
1. La combinazione tasti suggerita per attivare lo script, se avete notato, ha la stessa base di quella adottata per i nostri script che iniziavano con "MetteMacroTesto", avendo però in questo caso il suffisso numerico 0; tale suffisso, infatti, è quello usato per indicare proprio una delle nostre procedure guidate per l'elaborazione dei dati.
2. la differenza sostanziale rispetto alla procedura per gli elementi di ricerca è che qui, con le macro testuali, le voci da elaborare si possono inserire su più righe, e durante il collaudo analizzeremo anche come fare.
Codice.
Script ElaboraMacroTesto ()
GestisceDato (); chiama l'apposita funzione
EndScript
Collaudo.
1. Dopo aver compilato, restate nell'Editor di Jaws, e dalla sua schermata principale premete la combinazione di avvio procedura, "Shift+Control+0"; si presenterà una richiesta di conferma analoga a quella già incontrata con gli elementi di ricerca, che dovrebbe essere la seguente:
Nessuna Macro per l'estensione .JSS
Immetterla ora?
2. Il cursore sarà posizionato sul pulsante "Ok", che consigliamo di cliccare con Invio; si entrerà così nel campo di immissione testo, mentre il titolo ed il corpo della finestra di dialogo pronunciati da Jaws saranno i seguenti:
Aggiungere la MacroTesto numero 1.
Control+Invio nuova riga. Invio conferma, Esc annulla.
3. La novità, come accennato nelle note, è la possibilità chiarita dalle istruzioni di poter inserire il testo anche su più righe, creando una nuova riga tramite la combinazione "Control+Invio"; ed approfittiamo subito di questa opportunità, inserendo dapprima la nostra etichetta di inizio codice, "; _Ps Codice", ovviamente senza virgolette, quindi premendo per due volte la citata combinazione per la nuova riga, e concludendo poi l'immissione con Invio.
4. Si Aprirà di seguito la schermata principale della procedura, dove il testo appena inserito sarà preceduto dal numero 1; nel dettaglio, i ritorni a capo inseriti con "Control+Invio" saranno visualizzati con il nostro separatore di voce, costituito da due punti esclamativi dentro ad una coppia di parentesi quadre, come rappresentato di seguito:
1. ; _Ps Codice[!!][!!]
5. Dovreste essere rimasti alla fine del file script, al momento di avviare la procedura di elaborazione; anche se così non fosse, provate ora a premere il tasto Invio: dovreste tornare all'Editor di Jaws, con inserite l'iscrizione appena immessa e la riga vuota associata; dopo aver verificato che ciò sia realmente accaduto, premete due volte "Control+Z" per annullare l'operazione, in quanto le righe immesse sono state due, ed il sistema le registra come due operazioni distinte.
6. In ogni caso, Portatevi alla fine del file script corrente, casomai create una riga vuota se non ci fosse, quindi eseguite lo script "AperturaCodice ()", premendo la combinazione "Shift+Control+2". Nel file script aperto saranno scritte cinque righe, le nostre dichiarazioni per includere i file esterni, che voi dovete selezionare e tagliare, rimuovendole così dal file script.
7. Riaprite la procedura guidata con "Shift+Control+0", quindi inserite una nuova voce, premendo l'apposito pulsante o la scelta rapida "Alt+I". Nel campo d'inserimento che si apre, incollate il contenuto che avevate tagliato prima dal file script, quindi premete Invio per confermare il testo immesso, e tornare alla schermata principale.
8. Ripetete la procedura illustrata nei punti 6 e 7, eseguendo uno alla volta i tre citati script, "MetteMacroTesto3 ()", "MetteMacroTesto4 ()" e "MetteMacroTesto5 ()". Essi vanno eseguiti premendo "Shift+Control" assieme ai numeri 3, 4 e 5, inserendo poi il loro contenuto in altrettante nuove voci di macro.
9. Al termine, la schermata principale della procedura di elaborazione dovrebbe avere l'aspetto indicato di seguito, dove solo la voce numero 2 è stata ridotta per motivi di lunghezza:
1. ; _Ps Codice[!!][!!]
2. ; Include "HJConst.JSH"; file costanti predefinito di Jaws[!!]Include "_PsConst.JSH"; ...
3. ScriveSegno (iCurCharPos); registra il dato con l'apposita funzione[!!]
4. GestisceDato (TORNA, APERTURA); _Ps Codice[!!]
5. InterrompeAttesa (strKeyName); chiama l'apposita funzione[!!]
10. Uscite per il momento dalla schermata principale della nostra procedura; passiamo subito, prima di dimenticarcene, a cancellare i cinque script di cui abbiamo spostato il contenuto dentro alle altrettante voci sopra elencate, ovvero "InserisceFirma ()", "AperturaCodice ()", "MetteMacroTesto3 ()", "MetteMacroTesto4 ()" e "MetteMacroTesto5 ()"; è importante usiate il comando apposito dell'Editor di Jaws, "Cancella script" dal menu Script, perché è necessario eliminare anche le relative assegnazioni dei tasti nel file "Default.JKM"; al termine delle cancellazioni, salvate compilando, e procediamo realizzando il prototipo per la nuova serie di script.
Esercizio 14.6.3. Lo script MetteMacroTesto1.
FileScript. Default.JSS
Nome. MetteMacroTesto1
Sommario. Inserisce la macro Testo numero 1.
Descrizione. Inserisce alla posizione del cursore la macro testuale identificata con il termine Testo ed il numero 1, tra quelle registrate per l'estensione del documento corrente.
TastiAttivazione. Shift+Control+1
Note.
1. Come avete potuto notare, il nome ha la stessa base dei tre script che abbiamo appena eliminato, i quali di diverso avevano solo il suffisso; siccome lo scopo è crearne una serie tramite il nostro apposito script, faremo prima a rifarli nuovi, con il sommario e la descrizione corretta, anziché andare manualmente a modificarne contenuto e documentazione.
2. Per quanto riguarda i tasti di attivazione, essi seguono fedelmente la linea dettata da quelli che eseguono lo script di avvio della procedura, cambiando solo il suffisso numerico da 0 ad 1; questa sarà la regola da seguire anche più avanti, quando faremo altri esempi di macro testuali.
Codice.
Script MetteMacroTesto1 ()
GestisceDato (); chiama l'apposita funzione
EndScript
Collaudo.
1. Dopo aver compilato, seguite nuovamente le fasi illustrate per già due volte in questo capitolo, posizionandovi all'interno dello script e premendo "Shift+Control+Windows+P" per eseguire lo script che ne crea le serie.
2. Confermate poi la scelta del valore 9, quindi premete Invio anche alla successiva richiesta, e attendete la conclusione della procedura.
3. Se anche la compilazione al termine della serie di script ha avuto successo, sarebbe possibile ora completare il collaudo, eseguendo i singoli script, e così inserendo nel documento le stringhe impostate come macro testuali, secondo lo schema proposto di seguito:
- Voce Numero = Script MetteMacroTestoNumero, attivato con Shift+Control+Numero.
4. Nel caso in cui si voglia completare l'elenco delle possibili macro testuali, cioè 9 per ciascuna estensione di file, i nomi di script che bisognerà richiamare, e quindi le combinazioni tasti da premere, dovranno seguire la sequenza, e corrispondenza numerica, come nello schema appena presentato.
14.6.4. Inserire una macro non ancora registrata.
Nel caso delle macro appena inserite, essendo queste soltanto cinque, se premessimo la combinazione "Shift+Control+9", non avremmo una macro registrata per tale suffisso numerico. La procedura, in tal caso, vi avvertirebbe del fatto, e vi proporrebbe di poterla inserire direttamente.
Se a tale richiesta premete Escape, tornerete al documento senza nessuna modifica. Se invece confermerete la sua creazione, e poi al campo di editazione successivo sarà immesso un testo da registrare come macro, la macro verrà sia creata, e sarà quindi a disposizione da quel momento in poi, sia inserita nel documento aperto.
Da notare che la macro inserita avrà il numero di un'unità superiore a quello totale delle macro già registrate, non quindi necessariamente quello che si era tentato di premere. Ad esempio, nel caso citato, avendo noi registrato solo cinque voci, premendo uno qualsiasi dei tasti dal 6 al 9, assieme alla combinazione "Shift+Control", sarà in ogni caso registrata la macro numero 6.
Non si tratta, tuttavia, di un errore, ma del limite strutturale di dover avere le chiavi dei record relativi alle diverse voci che procedono in ordine sequenziale. Come già accennato in precedenza, infatti, non si possono saltare dei numeri di voce, almeno per quel che riguarda gli elementi di ricerca e le macro testuali.
14.6.5. Moltiplicare le macro per le singole estensioni.
Avere nove stringhe registrabili per ciascuna estensione spesso non è sufficiente per coprire tutte le nostre esigenze di macro testuali. Chi scrive, ad esempio, si è costruito ben sei serie di script, che porta le macro disponibili per ciascuna estensione ad un massimo di 54. Questa grande disponibilità, tuttavia, è stata sfruttata interamente solo con l'estensione dei file script, ".JSS", mentre con altre estensioni la si è utilizzata molto meno.
In ogni caso, l'unico limite sta, come spesso accade, nel riuscire a trovare delle combinazioni tasti libere, o almeno non utilizzate nei documenti di editing. Una volta trovati i tasti, sarà sufficiente individuare un termine identificativo qualsiasi, che andrà posto come terza parte del nome dello script, sia in quello che avvia la procedura, sia nel nome che inserisce le macro nei documenti.
Così, allo stesso modo in cui prima avevamo usato la base "Shift+Control" per i tasti di attivazione, ed il termine "Testo" per identificare la serie di macro, potremmo usare ad esempio i tasti, ed i termini, seguenti:
- Alt+da 0 a 9. Termine Alt.
- Control+da 0 a 9. Termine Control.
- Alt+Control+da 0 a 9. Termine Base.
- Shift+Control+Windows+da 0 a 9. Termine Windows.
- Alt+Control+Windows+da 0 a 9. Termine Extra.
Poi, da un elenco di tasti e termini come quello proposto, noi per ciascuno di essi dovremmo realizzare:
1. Uno script di avvio della procedura, che abbia un nome con la base "ElaboraMacro", seguito dal termine individuato, e dal suffisso numerico 0, come ad esempio "ElaboraMacroAlt0".
2. Una serie di script, i quali abbiano la base "MetteMacro", seguita ancora dal termine identificativo, ma con un suffisso numerico crescente da 1 a 9, ad esempio "MetteMacroAlt1."
14.6.6. Alcuni esempi di macro testuali.
Per completare l'argomento, a chi interessa l'applicazione pratica delle macro, proponiamo di seguito tre esempi di nove voci da usare dentro ai file script, tutte legate ovviamente agli script per Jaws. Queste serie saranno casomai da porre sulle varie combinazioni tasti, e con il termine identificativo, che si preferisce
In generale, le macro possono avere tutti i contenuti che è possibile esprimere con dei tasti, ad eccezione del carattere Pipe, Ascii 124, che non può essere presente in quanto causerebbe degli errori nel conteggiare i campi dei record.
Prima serie:
1. StringSegment (s, PIPE, i)
2. Pause ()[!!]
3. Var[!!]
4. Return
5. SayMessage (OT_ERROR,
6. If Then; se
7. SayFormattedMessage (OT_ERROR,
8. Let
9. EndIf; fine controllo
Seconda serie:
1. StringSegmentCount (s, PIPE)
2. FormatString (
3. String s
4. Return TRUE; restituisce l'esito positivo[!!]
5. SayMessage (OT_HELP,
6. While ; continua finché
7. SayFormattedMessage (OT_HELP,
8. ElIf Then; se
9. EndWhile; fine ciclo
Terza serie:
1. StringSegmentIndex (s, PIPE, TRUE)
2. StringReplaceSubstrings (
3. Int i
4. Return FALSE; restituisce un risultato nullo[!!]
5. SayUsingVoice (VCTX_JAWSCURSOR, , OT_HELP);
6. For i = 1 To ; scorre
7. SayUsingVoice (VCTX_PCCURSOR, , OT_HELP);
8. Else; altrimenti,[!!]
9. EndFor; fine scansione
14.6.7. Le serie di voci in orizzontale o in verticale.
Se noi volessimo considerare le macro come celle di una tabella, le serie che noi abbiamo proposto sarebbero in verticale, perché ciascuna macro è posta sotto all'altra. D'altro canto, se noi ponessimo queste tre serie di macro l'una affiancata all'altra, le tre diverse voci che hanno il numero 1 apparterebbero tutte alla stessa riga, quindi si potrebbero leggere come una serie posta in orizzontale.
Se questo può essere un modo per ricordarle meglio, allora le varie serie di nove macro, possono essere casomai raggruppate, o trovare delle corrispondenze, proprio nei due citati versi. Nelle tre serie proposte, ad esempio, le tre macro che hanno il numero 1 contengono le tre diverse funzioni che iniziano con "StringSegment", oppure le macro con il numero 3 sono tutte legate alle dichiarazioni di variabili, "Var", "String" e "Int", e quindi si possono considerare raggruppate in orizzontale.
Allo stesso modo, le macro con il numero 6 sono le istruzioni di inizio, "If", "While" e "For", ed in ciascuna serie esse trovano la loro istruzione di fine nella macro numero 9, "EndIf", "EndWhile" e "EndFor", e quindi possono essere considerate come in una sorta di mini serie verticale.
In questo caso, tuttavia, ciascuno ha un modo per aiutarsi a memorizzare, anche sulla base di come si è abituati a farlo. L'importante è aver capito come funziona lo strumento, mentre spetta a ciascuno poterlo eventualmente personalizzare nel suo utilizzo.
14.7. Gli script a Gestione personale .
Dei tre tipi previsti di procedura, quella per gli script a gestione personale è di gran lunga la più articolata, e quella che in sostanza ha generato l'esigenza del maggior numero di condizioni nel codice, e di funzioni specifiche alla loro elaborazione. Tanta è la complessità nel realizzarla, quanto il suo utilizzo è in realtà poi molto semplice, ridotto all'essenziale. L'intento, speriamo riuscito, è quello di semplificare al massimo la creazione di nuovi script, o meglio, di nuove azioni che noi vogliamo far compiere a questi strumenti, così indispensabili per migliorare la nostra efficacia al computer.
Rinviando per i dettagli alle note ed ai titoli sui singoli elementi, sarà il collaudo a far chiarezza sui passaggi necessari a realizzare uno script a gestione personale. Partiremo da zero, facendo un esempio di semplice script, di cui faremo una versione per ciascuno dei quattro applicativi in cui abbiamo lavorato in queste pagine.
L'unico aspetto da evidenziare è che, diversamente da quanto accade con gli elementi di ricerca e le macro testuali, qui gli script realizzati saranno validi soltanto per l'applicativo dentro alla quale si lancia la procedura guidata per la loro creazione. Esiste però l'archivio personale, che abbiamo più volte citato, dove sarà registrata una copia di tutti gli script realizzati con lo stesso nome: da qui, infatti, si potrà attingere per duplicarne il contenuto nelle varie applicazioni , così come faremo anche nel primo nostro esempio di utilizzo.
14.7.1. Eseguire gli script personali dall'Aiuto in linea.
L'aspetto più interessante dell'Aiuto in linea, sia quello nativo di Jaws, sia la versione da noi predisposta, è la possibilità di eseguire gli script elencati direttamente dal suo interno. Se con gli script di tipo tradizionale questo è stato sinora possibile, con quelli a gestione personale sono necessari due accorgimenti in più:
1. Uscire dal Visualizzatore virtuale non appena si clicca per eseguire lo script.
2. Impostare i tasti abbinati allo script da eseguire come fossero stati gli ultimi premuti.
Ad occuparsi del primo aspetto saranno due funzioni native di Jaws:
1. "UserBufferIsActive", (E'AtivoBufferUtente), che restituisce TRUE o FALSE, qualora il Visualizzatore virtuale sia attivo oppure no. Senza parametri.
2. "UserBufferDeactivate", (DisattivaBufferUtente), che fa scomparire il Visualizzatore virtuale, restituendo TRUE o FALSE come esito di tale azione. Senza parametri.
Circa il secondo obiettivo tra quelli citati, l'impostazione dei tasti come fossero gli ultimi ad essere premuti, ricorreremo invece al comando nativo già visto nell'undicesimo capitolo, "SetLastScriptKey ()".
Per quanto riguarda gli elementi in cui porre le varie istruzioni, le prime due saranno inserite in un'apposita struttura di controllo all'inizio di "GestisceDato ()", di cui realizzeremo quindi la versione definitiva. Circa il comando d'impostazione tasti, diversamente, creeremo sia un nuovo elemento, prodotto qui di seguito, sia modificheremo una nostra funzione, quella che aggiunge il testo al Visualizzatore virtuale.
Esercizio 14.7.2. La funzione ImpostaEsegue.
FileScript. Default.JSS
Nome. ImpostaEsegue
Descrizione. Imposta i tasti specificati come se fossero gli ultimi premuti; se tale impostazione riesce, si esegue lo script ad essi abbinato, altrimenti viene proposto un messaggio d'errore.
Ritorni. Di tipo Void. Nessuno.
Parametri.
1. sTasti. I tasti di attivazione di cui simulare la pressione. Di tipo String.
2. sNome. Il nome dello script da eseguire. Di tipo String.
Note.
1. Nell'unica struttura di controllo che compone la funzione, la prima via viene seguita qualora l'impostazione dei tasti specificati come gli ultimi premuti riesca, eseguendo lo script di cui si è indicato il nome tramite l'apposita funzione nativa; altrimenti, un avviso informerà sul tipo di errore verificatosi.
2. Pur essendo stata creata in particolare per gli script a gestione personale, la funzione è ovviamente compatibile anche con tutti gli altri tipi di script, nativi o tradizionali che siano, che si intenda far eseguire direttamente dall'Aiuto in linea.
***
Per ulteriori spiegazioni, scrivere a: Abramo Volpato, oppure, a: Nunziante Esposito
