Sophie

Sophie

distrib > Mandriva > 2010.0 > i586 > media > contrib-release > by-pkgid > 6f31691e252df0379b2dc094814df461 > files > 86

howto-sgml-it-2006-6mdv2010.0.noarch.rpm

<!doctype linuxdoc system> 

<article>

<title>Linux Keystroke-HOWTO
<author>Zenon Fortuna(<htmlurl url="mailto:zenon@netcom.com"
			name="zenon@netcom.com">)

Traduzione a cura di Veronese Andrea (<htmlurl url="mailto:albero@maya.dei.unipd.it"
			name="albero@maya.dei.unipd.it">) (Aprile 1996)

<date>Versione 2.0, 4 Aprile 1995                        

<abstract>
Questo documento descrive come assegnare macro (sequenze di tasti o esecuzione di script) ad alcuni tasti della tastiera. Il metodo proposto &egrave; quello di usare <bf/ loadkeys(1)/, oppure quello di modificare il file <tt/ defkeymap.c / e relinkare il Kernel.

Questo testo NON descrive la riconfigurazione dei tasti, come ad esempio &lsqb;Backspace&rsqb; o &lsqb;Delete&rsqb;. Per informazioni su come rimappare i tasti leggere il BackSpace Mini-HOWTO scritto da Stephen Lee.

Il metodo descritto di seguito &egrave; stato testato sulla versione 1.2.1 di Linux e incluso nella distribuzione Slackware 2.2.0.

</abstract>
<p>


<sect> Revisioni a questo documento <p>

4 Aprile 1995   -   Versione 2.0 <newline>
	Adattato per Linux 1.2.1: <newline>
	- semplici cambiamenti circa le modifiche proposte al file 			<tt/my_defkeymap.map/. <newline>
	- modifiche all'esempio di macro con lo <bf> screen dumping </bf> di 	/dev/vcs* (riversamento della schermata di una console virtuale in un file o alla stampante). 

7 Maggio 1994   -   Versione 1.0 <newline>
	Versione iniziale del "Keystroke-HOWTO", scritta per Linux 1.0.



<sect> Breve Descrizione <p>

I driver di terminale virtuale e di tastiera attribuiscono come valore di default alla mappa dei tasti quello definito nel file <tt> /drivers/char/defkeymap.c </tt> presente nei sorgenti del Kernel. Si possono associare delle stringhe all'azione dei 12 tasti Funzione presenti sulla tastiera: dopo aver premuto uno di quei tasti, anche assieme a &lsqb;Ctrl&rsqb; o &lsqb;Alt&rsqb; (detti tasti modificatori), il terminale virtuale corrente aggiunge la stringa corrispondente ai suoi buffer d'ingresso e d'uscita, emulando quindi la digitazione di tale stringa dalla tastiera.

Associando una stringa appropriata ad un determinato tasto Funzione possiamo semlificare l'esecuzione di certi comandi, per esempio la chiamata ad uno Shell-script <tt> /usr/local/bin/key_macro </tt> che ci possiamo creare e modificare a piacimento.



<sect> Strumenti per la modifica del driver di tastiera <p>

Possiamo usare <bf/loadkeys(1)/, <bf/dumpkeys(1)/ e <bf/showkey(1)/. 
L'utility <bf/ loadkeys(1) / aiuta a caricare nuove stringhe nei buffer di tastiera del Kernel, o anche a preparare nuovo codice C per modificare il Kernel.
<bf/dumpkeys(1) / dovrebbe essere usata per visualizzare la mappa attuale della tastiera se si volesse poi ispezionarla o modificarla.
<bf/showkey(1) / pu&ograve; aiutarci per ottenere il codice del tasto Funzione selezionato.

Se il vostro sistema Linux non ha queste utility potete ottenerle tramite ftp anonimo agli indirizzi

<htmlurl url="ftp://sunsite.unc.edu/pub/Linux/system/Keyboards" name="sunsite.unc.edu:/pub/Linux/system/Keyboards">, oppure <newline>
<htmlurl url="ftp://tsx-11.mit.edu/pub/linux/sources/system" name="tsx-11.mit.edu:/pub/linux/sources/system">

coi nomi <tt/ kbd-0.89.tar.gz / oppure <tt/ kbd-0.90.tar.gz /. Usare lo GNU tar per scompattare i file desiderati.



<sect> Modificare il file tabella di conversione (keytable) <p>

Il Kernel di Linux comprende il codice compilato <tt/defkeymap.c/, il quale &egrave; generato con l'utility <bf/ loadkeys(1) / partendo dal file <tt/ defkeymap.map/. Entrambi i file sono inclusi nella directory <tt> src/linux/drivers/char</tt>.

Al fine di modificare il file <tt/ defkeymap.map / ce ne facciamo una copia locale con

<tt/   # cp defkeymap.map my_keytable.map/ ; oppure <newline>
<tt/   # dumpkeys > my_keytable.map/

C'&egrave; anche un'ampia raccolta di file di configurazione della tastiera nella directory <tt> /usr/lib/kbd/keytables</tt>, dalla quale <tt/ defkeymap.map / pu&ograve; essere copiato e usato come file <tt> src/linux/drivers/char/defkeymap.map </tt> nel vostro sistema.

Il metodo che usa l'utility <bf/ dumpkeys(1) / &egrave; raccomandato perch&eacute; pu&ograve; accadere che il vostro Kernel sia gi&agrave; stato modificato o creato per voi con un differente <tt/ defkeymap.map / rispetto a quello che potreste trovare nei sorgenti.

Leggiamo ora il contenuto del file <tt/ my_defkeymap.map/. Non ci sono pi&ugrave; di 300 linee di codice e vi possiamo trovare 3 gruppi di dichiarazioni: il primo gruppo consiste in linee con la parola "<tt/keycode/", anche preceduta da altre parole come "<tt/alt/", "<tt/control/", ecc.; nel secondo gruppo troviamo la parola "<tt/string/"; il terzo ed ultimo gruppo consiste in linee con la parola "<tt/compose/".

Altre informazioni sulla sintassi di <bf/ keytables(5) / possono essere reperite tramite il comando

<tt/   % man keytables/



<sect1> Esempio di modifica del file tabella di conversione <p>

Come esempio dell'assegnazione di una stringa-macro alla pressione di un tasto Funzione facciamo in modo che la combinazione &lsqb;Ctrl+F1&rsqb; chiami l'esecuzione del nostro Shell-script "<tt>/usr/local/bin/key_macro</tt>".

Prima di tutto dovremmo vedere qual &egrave; il codice del tasto Funzione &lsqb;F1&rsqb;. Possiamo usare l'utility <bf/ showkey(1) / per trovare tale codice, premendo &lsqb;F1&rsqb;. Altrimenti possiamo cercare la stringa "<tt/F1/" nel file <tt/ my_keytable.map/, col risultato di ottenere la seguente linea:

<tt/   keycode 59 = F1/

Questa suggerisce che il codice per il tasto Funzione &lsqb;F1&rsqb; &egrave; 59. Inoltre definisce il fatto che, dopo aver premuto &lsqb;F1&rsqb;, il driver di tastiera manda in uscita la stringa denotata dal codice stringa "<tt/F1/". Per vederne il contenuto si pu&ograve; cercare sempre all'interno di questo file "<tt/string F1/" e si trova:

<tt>   string F1 = "&bsol;033[[A"</tt>

Cio&egrave;, dopo aver premuto &lsqb;F1&rsqb;, il driver di tastiera manda "<tt>Esc[[A</tt>" (senza spazi).

Non bisognerebbe combiare questa stringa perch&eacute; alcune applicazioni basano su di essa l'azione di [F1] come valore di default.

Comunque possiamo definire una nuova macro per la combinazione &lsqb;Ctrl+F1&rsqb;, la quale non &egrave; riservata dal Kernel per altri usi speciali. Per vedere i codici del tasto &lsqb;F1&rsqb; premuto assieme a &lsqb;Ctrl&rsqb;, &lsqb;Shift&rsqb; o con altri modificatori, possiamo cercare nel file <tt/ my_keytable.map / il codice 59 tramite

<tt/   # grep 59 my_keytable.map/

Nel caso in cui non vi sia alcuna linea con "<tt/control keycode 59/" allora possiamo usare &lsqb;Ctrl+F1&rsqb senza problemi (si pu&ograve; procedere anche se &egrave; presente una linea con "<tt/shift control keycode 59/").

Aggiungiamo la seguente linea al file <tt/my_keytable.map/:

<tt/   control keycode 59 = key_symbol/

dove "<tt/key_symbol/" definirebbe l'azione della combinazione &lsqb;Ctrl+F1&rsqb;. Linux 1.2.* ammette un'allocazione dinamica delle stringhe, ma la stringa "<tt/key_symbol/" pu&ograve; essere scelta solo tra un insieme ben definito di nomi. Tra gli altri sono permessi i simboli-tasto F1-F246. Nel mio sistema F21 non era usato nel file <tt/ my_keytable.map / ma ognuno dovrebbe ispezionare il proprio e scegliere il simbolo-tasto opportuno. Nel nostro esempio si pu&ograve; quindi concludere con la linea

<verb>   string F21 = "/usr/local/bin/key_macro\n" </verb>
Riassumendo, abbiamo apportato due cambiamenti al file di partenza <tt/ my_keytable.map/: abbiamo dichiarato la nuova stringa F21 e abbiamo deciso che la combinazione &lsqb;Ctrl+F1&rsqb; chiamer&agrave; l'esecuzione del contenuto della stringa 21.
  


<sect1> Modifica temporanea della configurazione della tastiera <p>

Dopo aver opportunamente modificato il file <tt/ my_keytable.map / possiamo copiarne i cambiamenti al driver di tastiera del Kernel, usando l'utility <bf/ loadkeys(1)/: 

<tt/   % loadkeys my_keytable.map/

La modifica al driver di tastiera del Kernel &egrave; concessa a chiunque abbia l'accesso in lettura al dispositivo "<tt>/dev/console</tt>". <newline>
Per verificare che i cambiamenti voluti siano stati effettivamente installati possiamo usare l'utility <bf/dumpkeys(1)/ e controllare il valore di F21, ad esempio

<tt/   % dumpkeys |grep F21/

Si ottiene:
<verb>   keycode 59 = F1          F11       Console_13 F21
   string F21 = "/usr/local/bin/key_macro\012"

la quale va bene perch&eacute; "012", o LF, &egrave; equivalente a "\n".</verb>
Ora, premendo &lsqb;Ctrl+F1&rsqb; dovrebbe avvenire la chiamata allo Shell script "<tt>/usr/local/bin/key_macro</tt>", come desiderato.



<sect1> Modifica permanente <p>

I cambiamenti imposti da <bf/ loadkeys(1) / al driver di tastiera del Kernel rimangono effettivi solo fino al successivo reboot (o fino alla successiva chiamata a <tt/loadkeys/).

(N.d.T.: Per una modifica permanente) possiamo aggiungere a <tt> /etc/rc.d/rc.local </tt> la chiamata a <tt/ loadkeys / con argomento il nostro <tt/ my_keytable.map/. Altrimenti, &egrave; possibile modificare <tt> src/linux/drivers/char/defkeymap.c </tt> e relinkare il Kernel con i nuovi valori di default.

Non si dovrebbe modificare manualmente il file <tt/ defkeymap.c / ma, piuttosto, generarlo tramite l'utility <bf/ loadkeys(1)/:

<tt/   # mv defkeymap.c defkeymap.c.ORIG/ <newline>
<tt/   # loadkeys --mktable my_keytable.map > defkeymap.c/

Poi si dovrebbe creare il nuovo Kernel essenzialmente ponendosi alla radice dei sorgenti di Linux e usando <bf/ make(1)/. <newline>
Infine, per mezzo di <bf/lilo(1)/ dovremmo installare e riavviare il nuovo Kernel.



<sect> Esempio di script assegnato a un tasto <p>

Uno script particolarmente utile come esempio di macro eseguibile premendo un tasto, pu&ograve; essere quello che riversa in un file o alla stampante la schermata del video (screen dumping).

Questo esempio &egrave; stato cambiato rispetto a quello della versione 1.0 di Linux a causa delle modifiche al Kernel, il quale non fornisce pi&ugrave; la chiamata di sistema <tt/ ioctl(0,TIOCLINUX)/.

Al fine di leggere le schermate delle console virtuali si dovrebbero prima preparare alcuni file di dispositivo. Come utente "root" possiamo creare i seguenti file:

<tt/   # mknod /dev/vcs1 c 7 1 <newline>
<tt/   # mknod /dev/vcs2 c 7 2 <newline>
<tt>     ... </tt> <newline>
<tt/   # mknod /dev/vcs63 c 7 63

Naturalmente &egrave; sufficiente avere tanti file /dev/vcs* quante sono le console virtuali che si stanno usando.

Il codice sotto riportato dovrebbe essere considerato come esempio di possibile file <tt>/usr/local/bin/key_macro</tt>:
<code>

	#!/bin/sh
	#
	# Questo &egrave; un esempio utile di script 
	# eseguibile premendo un tasto
	#

	VT_NUMBER=`tty|cut -c9-`
	FILE=/tmp/vt$VT_NUMBER.dump
	cp /dev/vcs$VT_NUMBER $FILE
	echo SCREEN DUMP saved in $FILE
	#
	# Uncommenta la linea sotto se vuoi 
	# stampare il file "schermata"
	#
	# lpr $FILE
</code>


<sect> Considerazioni <p>

Non c'&egrave; limite pratico alla somma delle lunghezze di tutte le stringhe che vorremmo caricare nel driver di tastiera. Il precedente buffer della lunghezza di FUNC_BUFSIZE, costante (posto a 512 byte), &egrave; stato rimpiazzato in Linux 1.2.* da una strategia di allocazione del buffer dinamica ... in pezzi di 512 byte ciascuno.

La copia pi&ugrave; recente del Keystroke-HOWTO pu&ograve; essere trovata all'indirizzo:

<htmlurl url="ftp://ftp.netcom.com/pub/ze/zenon/linux/howto" name="ftp.netcom.com: /pub/ze/zenon/linux/howto">



<sect> Altre idee? <p>

Nel caso troviate qualsiasi cosa che valga la pena di aggiungere a questo documento, spedite i vostri suggerimenti a <htmlurl url="mailto:zenon@netcom.com" name="zenon@netcom.com"> - grazie (zf)


</article>