Panoramica dell'input da tastiera

Le applicazioni devono accettare l'input dell'utente dalla tastiera e dal mouse. Un'applicazione riceve l'input da tastiera sotto forma di messaggi inviati alle relative finestre.

Modello di input da tastiera

Il sistema fornisce il supporto della tastiera indipendente dal dispositivo per le applicazioni installando un driver di dispositivo da tastiera appropriato per la tastiera corrente. Il sistema fornisce il supporto della tastiera indipendente dalla lingua usando il layout di tastiera specifico della lingua attualmente selezionato dall'utente o dall'applicazione. Il driver del dispositivo da tastiera riceve i codici di analisi dalla tastiera, che vengono inviati al layout della tastiera in cui vengono convertiti in messaggi e inviati alle finestre appropriate nell'applicazione.

Assegnato a ogni tasto su una tastiera è un valore univoco denominato codice di analisi, un identificatore dipendente dal dispositivo per il tasto sulla tastiera. Una tastiera genera due codici di analisi quando l'utente digita un tasto, uno quando l'utente preme il tasto e un altro quando l'utente rilascia il tasto.

Il driver di dispositivo da tastiera interpreta un codice di analisi e lo converte (mappa) in un codice di chiave virtuale, un valore indipendente dal dispositivo definito dal sistema che identifica lo scopo di un tasto. Dopo aver tradotto un codice di analisi, il layout della tastiera crea un messaggio che include il codice di analisi, il codice della chiave virtuale e altre informazioni sulla sequenza di tasti e quindi inserisce il messaggio nella coda dei messaggi di sistema. Il sistema rimuove il messaggio dalla coda dei messaggi di sistema e lo inserisce nella coda di messaggi del thread appropriato. Infine, il ciclo di messaggi del thread rimuove il messaggio e lo passa alla procedura di finestra appropriata per l'elaborazione. La figura seguente illustra il modello di input della tastiera.

Attivazione e stato attivo della tastiera

Il sistema inserisce i messaggi della tastiera nella coda di messaggi del thread in primo piano che ha creato la finestra con lo stato attivo della tastiera. Lo stato attivo della tastiera è una proprietà temporanea di una finestra. Il sistema condivide la tastiera tra tutte le finestre sullo schermo spostando lo stato attivo della tastiera, in direzione dell'utente, da una finestra a un'altra. La finestra con lo stato attivo della tastiera riceve (dalla coda di messaggi del thread che lo ha creato) tutti i messaggi della tastiera fino a quando lo stato attivo non cambia in una finestra diversa.

Un thread può chiamare la funzione GetFocus per determinare quale delle finestre (se presenti) ha attualmente lo stato attivo della tastiera. Un thread può assegnare lo stato attivo della tastiera a una delle relative finestre chiamando la funzione SetFocus . Quando lo stato attivo della tastiera passa da una finestra a un'altra, il sistema invia un messaggio WM_KILLFOCUS alla finestra che ha perso lo stato attivo e quindi invia un messaggio WM_edizione Standard TFOCUS alla finestra che ha ottenuto lo stato attivo.

Il concetto di stato attivo della tastiera è correlato a quello della finestra attiva. La finestra attiva è la finestra di primo livello con cui l'utente sta attualmente lavorando. La finestra con lo stato attivo della tastiera è la finestra attiva o una finestra figlio della finestra attiva. Per aiutare l'utente a identificare la finestra attiva, il sistema lo inserisce nella parte superiore dell'ordine Z e ne evidenzia la barra del titolo (se presente) e il bordo.

L'utente può attivare una finestra di primo livello facendo clic su di essa, selezionandola usando la combinazione di tasti ALT+TAB o ALT+ESC oppure selezionandola dall'elenco attività. Un thread può attivare una finestra di primo livello usando la funzione SetActiveWindow. Può determinare se una finestra di primo livello creata è attiva usando la funzione GetActiveWindow.

Quando una finestra viene disattivata e un'altra attivata, il sistema invia il messaggio di WM_ACTIVATE . La parola in ordine basso del parametro wParam è zero se la finestra viene disattivata e diversa da zero se viene attivata. Quando la routine della finestra predefinita riceve il messaggio WM_ACTIVATE , imposta lo stato attivo della tastiera sulla finestra attiva.

Per bloccare gli eventi di input della tastiera e del mouse dal raggiungimento delle applicazioni, usare BlockInput. Si noti che la funzione BlockInput non interferisce con la tabella dello stato di input della tastiera asincrona. Ciò significa che la chiamata alla funzione SendInput mentre l'input è bloccato modificherà la tabella dello stato di input della tastiera asincrona.

Messaggi di sequenza di tasti

Se si preme un tasto, un WM_KEYDOWN o WM_SYSKEYDOWN messaggio viene inserito nella coda dei messaggi del thread collegata alla finestra con lo stato attivo della tastiera. Il rilascio di una chiave determina l'inserimento di un messaggio WM_KEYUP o WM_SYSKEYUP nella coda.

I messaggi key-up e key-down si verificano in genere in coppie, ma se l'utente tiene premuto un tasto abbastanza a lungo per avviare la funzionalità di ripetizione automatica della tastiera, il sistema genera un numero di WM_KEYDOWN o WM_SYSKEYDOWN messaggi in una riga. Genera quindi un singolo messaggio WM_KEYUP o WM_SYSKEYUP quando l'utente rilascia la chiave.

Questa sezione contiene gli argomenti seguenti:

• Sequenze di tasti di sistema e non di sistema
• Codici di chiave virtuale descritti
• Flag messaggio di sequenza di tasti

Sequenze di tasti di sistema e non di sistema

Il sistema distingue le sequenze di tasti di sistema e le sequenze di tasti non di sistema. Le sequenze di tasti di sistema producono messaggi di sequenza di tasti di sistema, WM_SYSKEYDOWN e WM_SYSKEYUP. Le sequenze di tasti non di sistema producono messaggi di sequenza di tasti non di sistema, WM_KEYDOWN e WM_KEYUP.

Se la routine della finestra deve elaborare un messaggio di sequenza di tasti di sistema, assicurarsi che dopo l'elaborazione del messaggio la routine lo passi alla funzione DefWindowProc. In caso contrario, tutte le operazioni di sistema che coinvolgono il tasto ALT verranno disabilitate ogni volta che la finestra ha lo stato attivo della tastiera. Ovvero, l'utente non sarà in grado di accedere ai menu o al menu di sistema della finestra oppure di utilizzare la combinazione di tasti ALT+ESC o ALT+TAB per attivare una finestra diversa.

I messaggi di sequenza di tasti di sistema vengono usati principalmente dal sistema anziché da un'applicazione. Il sistema li usa per fornire l'interfaccia della tastiera predefinita ai menu e per consentire all'utente di controllare quale finestra è attiva. I messaggi di tastiera di sistema vengono generati quando l'utente digita un tasto in combinazione con il tasto ALT o quando l'utente digita e nessuna finestra ha lo stato attivo della tastiera, ad esempio quando l'applicazione attiva viene ridotta a icona. In questo caso, i messaggi vengono inseriti nella coda di messaggi collegata alla finestra attiva.

I messaggi di sequenza di tasti non di sistema sono usati dalle finestre dell'applicazione; la funzione DefWindowProc non esegue alcuna operazione con esse. Una procedura di finestra può eliminare qualsiasi messaggio di sequenza di tasti non di sistema che non è necessario.

Codici di chiave virtuale descritti

Il parametro wParam di un messaggio di sequenza di tasti contiene il codice del tasto virtuale del tasto premuto o rilasciato. Una routine finestra elabora o ignora un messaggio di sequenza di tasti, a seconda del valore del codice della chiave virtuale.

Una routine finestra tipica elabora solo un piccolo sottoinsieme dei messaggi di sequenza di tasti ricevuti e ignora il resto. Ad esempio, una routine finestra potrebbe elaborare solo WM_KEYDOWN messaggi di sequenza di tasti e solo quelli che contengono codici di tasto virtuale per i tasti di spostamento del cursore, i tasti di spostamento (detti anche tasti di controllo) e i tasti funzione. Una routine di finestra tipica non elabora i messaggi di sequenza di tasti dai tasti di scelta rapida. Usa invece la funzione TranslateMessage per convertire il messaggio in messaggi di tipo carattere. Per altre informazioni sui messaggi TranslateMessage e carattere, vedere Messaggi di carattere.

Flag messaggio di sequenza di tasti

Il parametro lParam di un messaggio di sequenza di tasti contiene informazioni aggiuntive sulla sequenza di tasti che ha generato il messaggio. Queste informazioni includono il numero di ripetizioni, il codice di analisi, il flag di chiave estesa, il codice di contesto, il flag di stato chiave precedente e il flag di transizione. La figura seguente mostra i percorsi di questi flag e valori nel parametro lParam .

Un'applicazione può usare i valori seguenti per ottenere i flag di sequenza di tasti da parole di ordine elevato di lParam.

Codice di esempio:

case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
{
    WORD vkCode = LOWORD(wParam);                                 // virtual-key code
    
    WORD keyFlags = HIWORD(lParam);

    WORD scanCode = LOBYTE(keyFlags);                             // scan code
    BOOL isExtendedKey = (keyFlags & KF_EXTENDED) == KF_EXTENDED; // extended-key flag, 1 if scancode has 0xE0 prefix
    
    if (isExtendedKey)
        scanCode = MAKEWORD(scanCode, 0xE0);

    BOOL wasKeyDown = (keyFlags & KF_REPEAT) == KF_REPEAT;        // previous key-state flag, 1 on autorepeat
    WORD repeatCount = LOWORD(lParam);                            // repeat count, > 0 if several keydown messages was combined into one message

    BOOL isKeyReleased = (keyFlags & KF_UP) == KF_UP;             // transition-state flag, 1 on keyup

    // if we want to distinguish these keys:
    switch (vkCode)
    {
    case VK_SHIFT:   // converts to VK_LSHIFT or VK_RSHIFT
    case VK_CONTROL: // converts to VK_LCONTROL or VK_RCONTROL
    case VK_MENU:    // converts to VK_LMENU or VK_RMENU
        vkCode = LOWORD(MapVirtualKeyW(scanCode, MAPVK_VSC_TO_VK_EX));
        break;
    }

    // ...
}
break;

Ripeti conteggio

È possibile controllare il numero di ripetizioni per determinare se un messaggio di sequenza di tasti rappresenta più di una sequenza di tasti. Il sistema incrementa il conteggio quando la tastiera genera WM_KEYDOWN o WM_SYSKEYDOWN messaggi più velocemente di quanto un'applicazione possa elaborarli. Questo spesso si verifica quando l'utente tiene premuto un tasto abbastanza a lungo per avviare la funzionalità di ripetizione automatica della tastiera. Invece di riempire la coda dei messaggi di sistema con i messaggi chiave-down risultanti, il sistema combina i messaggi in un singolo messaggio di chiave verso il basso e incrementa il numero di ripetizioni. Il rilascio di una chiave non può avviare la funzionalità di ripetizione automatica, quindi il numero di ripetizioni per WM_KEYUP e WM_SYSKEYUP messaggi è sempre impostato su 1.

Codici di analisi

Il codice di analisi è il valore generato dal sistema quando l'utente preme un tasto. Si tratta di un valore che identifica il tasto premuto indipendentemente dal layout di tastiera attivo, anziché il carattere rappresentato dal tasto. Un'applicazione in genere ignora i codici di analisi. Usa invece i codici di chiave virtuale per interpretare i messaggi di sequenza di tasti.

Le tastiere moderne usano la specifica HID (Human Interface Devices) per comunicare con un computer. Il driver della tastiera converte i valori di utilizzo HID segnalati inviati dalla tastiera ai codici di analisi e li passa alle applicazioni.

La tabella seguente elenca il set di codici di analisi attualmente riconosciuti da Windows. I valori HID Usage ID HID/Usage NAME della pagina/HID Usage Name fanno riferimento al documento HiD Usage Tables (Tabelle di utilizzo HID). I valori di Posizione chiave fanno riferimento all'immagine della tastiera precedente.

Il codice make scan 1 viene recapitato in WM_KEYDOWN/WM_KEYUP/WM_SYSKEYDOWN WM_SYSKEYUP/ e WM_INPUT messaggi.

Note:

1. Il codice di analisi della chiave SysRq viene generato nella sequenza di tasti ALT+Stampa schermo
2. Il codice di analisi della chiave di interruzione viene generato nella sequenza di tasti Control+Pause
3. Come illustrato nei messaggi di tastiera legacy
4. Il tasto è presente sulle tastiere brasiliane
5. Il tasto è presente nelle tastiere giapponesi
6. Il codice di analisi viene generato solo nell'evento di rilascio della chiave

Flag chiave estesa

Il flag di tasti esteso indica se il messaggio di tastiera ha avuto origine da uno dei tasti aggiuntivi nella tastiera avanzata 101/102. I tasti estesi sono costituiti dai tasti ALT e CTRL sul lato destro della tastiera; i tasti INS, DEL, HOME, END, PAGE UP, PAGE DOWN e freccia nei cluster a sinistra del tastierino numerico; il tasto BLOC NUM; il tasto BREAK (CTRL+PAU edizione Standard), il tasto PRINT SCRN e i tasti di divisione (/) e INVIO nel tastierino numerico. Il tasto MAIUSC a destra non è considerato un tasto esteso, ma ha un codice di analisi separato.

Se specificato, il codice di analisi è costituito da una sequenza di due byte, in cui il primo byte ha un valore di 0xE0.

Codice di contesto

Il codice di contesto indica se il tasto ALT è inattivo quando è stato generato il messaggio di sequenza di tasti. Il codice è 1 se il tasto ALT era inattivo e 0 se era inattivo.

Flag stato chiave precedente

Il flag di stato della chiave precedente indica se la chiave che ha generato il messaggio di sequenza di tasti è stata precedentemente alzata o inattiva. È 1 se la chiave era precedentemente inattiva e 0 se la chiave era in precedenza su. È possibile usare questo flag per identificare i messaggi di sequenza di tasti generati dalla funzionalità di ripetizione automatica della tastiera. Questo flag è impostato su 1 per WM_KEYDOWN e WM_SYSKEYDOWN messaggi di sequenza di tasti generati dalla funzionalità di ripetizione automatica. È sempre impostato su 1 per i messaggi WM_KEYUP e WM_SYSKEYUP.

Flag di transizione

Il flag di stato di transizione indica se premere un tasto o rilasciare un tasto ha generato il messaggio di sequenza di tasti. Questo flag è sempre impostato su 0 per i messaggi WM_KEYDOWN e WM_SYSKEYDOWN; è sempre impostato su 1 per i messaggi WM_KEYUP e WM_SYSKEYUP.

Messaggi di carattere

I messaggi di sequenza di tasti forniscono molte informazioni sulle sequenze di tasti, ma non forniscono codici carattere per le sequenze di tasti. Per recuperare i codici carattere, un'applicazione deve includere la funzione TranslateMessage nel ciclo di messaggi del thread. TranslateMessage passa un messaggio WM_KEYDOWN o WM_SYSKEYDOWN al layout della tastiera. Il layout esamina il codice della chiave virtuale del messaggio e, se corrisponde a una chiave di carattere, fornisce l'equivalente del codice carattere (tenendo conto dello stato dei tasti MAIUSC e C piattaforma di strumenti analitici LOCK). Genera quindi un messaggio di carattere che include il codice carattere e inserisce il messaggio nella parte superiore della coda di messaggi. L'iterazione successiva del ciclo di messaggi rimuove il messaggio di carattere dalla coda e invia il messaggio alla procedura di finestra appropriata.

Questa sezione contiene gli argomenti seguenti:

• Messaggi carattere non di sistema
• Messaggi non recapitabili

Messaggi carattere non di sistema

Una routine finestra può ricevere i messaggi di carattere seguenti: WM_CHAR, WM_DEADCHAR, WM_SYSCHAR, WM_SYSDEADCHAR e WM_UNICHAR. La funzione TranslateMessage genera un messaggio WM_CHAR o WM_DEADCHAR quando elabora un messaggio WM_KEYDOWN. Analogamente, genera un messaggio di WM_SYSCHAR o WM_SYSDEADCHAR quando elabora un messaggio di WM_SYSKEYDOWN.

Un'applicazione che elabora l'input da tastiera ignora in genere tutti i messaggi WM_CHAR e WM_UNICHAR, passando qualsiasi altro messaggio alla funzione DefWindowProc. Si noti che WM_CHAR usa UTF-16 (formato di trasformazione Unicode a 16 bit) o un set di caratteri ANSI mentre WM_UNICHAR usa sempre UTF-32 (formato di trasformazione Unicode a 32 bit). Il sistema usa i messaggi WM_SYSCHAR e WM_SYSDEADCHAR per implementare i mnemonic del menu.

Il parametro wParam di tutti i messaggi di caratteri contiene il codice carattere del tasto carattere premuto. Il valore del codice carattere dipende dalla classe finestra della finestra che riceve il messaggio. Se la versione Unicode della funzione RegisterClass è stata usata per registrare la classe window, il sistema fornisce caratteri Unicode a tutte le finestre di tale classe. In caso contrario, il sistema fornisce codici carattere ANSI. Per altre informazioni, vedere Registrazione delle classi di finestre e Usare le tabelle codici UTF-8 nelle app di Windows.

Il contenuto del parametro lParam di un messaggio di carattere è identico al contenuto del parametro lParam del messaggio key-down convertito per produrre il messaggio di caratteri. Per informazioni, vedere Flag messaggio di sequenza di tasti.

Messaggi non recapitabili

Alcune tastiere non inglesi contengono tasti di carattere che non devono produrre caratteri da soli. Vengono invece usati per aggiungere un diacritico al carattere prodotto dalla sequenza di tasti successiva. Queste chiavi sono denominate chiavi non recapitabili. Il tasto circonflesso su una tastiera tedesca è un esempio di tasto morto. Per immettere il carattere costituito da un "o" con una circonflessa, un utente tedesco digita la chiave circonflessa seguita dalla chiave "o". La finestra con lo stato attivo della tastiera riceverà la sequenza di messaggi seguente:

1. WM_KEYDOWN
2. WM_DEADCHAR
3. WM_KEYUP
4. WM_KEYDOWN
5. WM_CHAR
6. WM_KEYUP

TranslateMessage genera il messaggio WM_DEADCHAR quando elabora il messaggio WM_KEYDOWN da una chiave non morta. Anche se il parametro wParam del messaggio WM_DEADCHAR contiene il codice carattere del diacritico per la chiave morta, un'applicazione in genere ignora il messaggio. Elabora invece il messaggio WM_CHAR generato dalla sequenza di tasti successiva. Il parametro wParam del messaggio WM_CHAR contiene il codice carattere della lettera con il diacritico. Se la sequenza di tasti successiva genera un carattere che non può essere combinato con un diacritico, il sistema genera due messaggi WM_CHAR . Il parametro wParam del primo contiene il codice carattere del diacritico. Il parametro wParam del secondo contiene il codice carattere della chiave di carattere successiva.

La funzione TranslateMessage genera il messaggio di WM_SYSDEADCHAR quando elabora il messaggio WM_SYSKEYDOWN da un tasto non recapitabili di sistema (un tasto morto premuto in combinazione con il tasto ALT). Un'applicazione ignora in genere il messaggio di WM_SYSDEADCHAR .

Stato chiave

Durante l'elaborazione di un messaggio da tastiera, un'applicazione potrebbe dover determinare lo stato di un altro tasto oltre a quello che ha generato il messaggio corrente. Ad esempio, un'applicazione di elaborazione delle parole che consente all'utente di premere MAIUSC+END per selezionare un blocco di testo deve controllare lo stato del tasto MAIUSC ogni volta che riceve un messaggio di sequenza di tasti dal tasto END. L'applicazione può usare la funzione GetKeyState per determinare lo stato di una chiave virtuale al momento della generazione del messaggio corrente. Può usare la funzione GetAsyncKeyState per recuperare lo stato corrente di una chiave virtuale.

Il layout della tastiera mantiene un elenco di nomi. Il nome di una chiave che produce un singolo carattere corrisponde al carattere prodotto dalla chiave. Il nome di una chiave non carattere, ad esempio TAB e INVIO, viene archiviato come stringa di caratteri. Un'applicazione può recuperare il nome di qualsiasi chiave dal driver di dispositivo chiamando la funzione GetKeyNameText.

Sequenze di tasti e traduzioni di caratteri

Il sistema include diverse funzioni speciali che convertono codici di analisi, codici carattere e codici di chiave virtuale forniti da vari messaggi di sequenza di tasti. Queste funzioni includono MapVirtualKey, ToAscii, ToUnicode e VkKeyScan.

Inoltre, Microsoft Rich Edit 3.0 supporta l'IME HexToUnicode, che consente a un utente di eseguire la conversione tra caratteri esadecimali e Unicode usando i tasti di scelta rapida. Ciò significa che quando Microsoft Rich Edit 3.0 viene incorporato in un'applicazione, l'applicazione erediterà le funzionalità dell'IME hexToUnicode.

Supporto di tasti di scelta rapida

Un tasto di scelta rapida è una combinazione di tasti che genera un messaggio WM_HOTKEY , un messaggio che il sistema posiziona nella parte superiore della coda dei messaggi di un thread, ignorando eventuali messaggi esistenti nella coda. Le applicazioni usano i tasti di scelta rapida per ottenere l'input della tastiera ad alta priorità dall'utente. Ad esempio, definendo un tasto di scelta rapida costituito dalla combinazione di tasti CTRL+C, un'applicazione può consentire all'utente di annullare un'operazione lunga.

Per definire un tasto di scelta rapida, un'applicazione chiama la funzione RegisterHotKey, specificando la combinazione di chiavi che genera il messaggio WM_HOTKEY, l'handle alla finestra per ricevere il messaggio e l'identificatore del tasto di scelta rapida. Quando l'utente preme il tasto di scelta rapida, un messaggio di WM_HOTKEY viene inserito nella coda di messaggi del thread che ha creato la finestra. Il parametro wParam del messaggio contiene l'identificatore della chiave di scelta rapida. L'applicazione può definire più tasti di scelta rapida per un thread, ma ogni tasto di scelta rapida nel thread deve avere un identificatore univoco. Prima che l'applicazione termini, deve usare la funzione UnregisterHotKey per eliminare definitivamente il tasto di scelta rapida.

Le applicazioni possono usare un controllo tasto di scelta rapida per semplificare la scelta di un tasto di scelta rapida da parte dell'utente. I controlli tasto di scelta rapida vengono in genere usati per definire un tasto di scelta rapida che attiva una finestra; non usano le funzioni RegisterHotKey e UnregisterHotKey. Al contrario, un'applicazione che usa un controllo tasto di scelta rapida invia in genere il messaggio WM_edizione Standard THOTKEY per impostare il tasto di scelta rapida. Ogni volta che l'utente preme il tasto di scelta rapida, il sistema invia un messaggio di WM_SYSCOMMAND che specifica SC_HOTKEY. Per altre informazioni sui controlli con tasti di scelta rapida, vedere "Uso di controlli tasto di scelta rapida" in Controlli a tasti di scelta rapida.

Tasti da tastiera per l'esplorazione e altre funzioni

Windows offre supporto per le tastiere con tasti speciali per funzioni del browser, funzioni multimediali, avvio delle applicazioni e risparmio energia. Il WM_APPCOMMAND supporta i tasti aggiuntivi della tastiera. Inoltre, la funzione ShellProc viene modificata per supportare i tasti aggiuntivi della tastiera.

È improbabile che una finestra figlio in un'applicazione componente sia in grado di implementare direttamente i comandi per questi tasti aggiuntivi. Quindi, quando viene premuto uno di questi tasti, DefWindowProc invierà un messaggio WM_APPCOMMAND a una finestra. DefWindowProc a bollerà anche il messaggio WM_APPCOMMAND nella finestra padre. Questo è simile al modo in cui i menu di scelta rapida vengono richiamati con il pulsante destro del mouse, ovvero defWindowProc invia un messaggio di WM_CONTEXTMENU su un clic con il pulsante destro del mouse e lo bolle nel relativo elemento padre. Inoltre, se DefWindowProc riceve un messaggio di WM_APPCOMMAND per una finestra di primo livello, chiamerà un hook della shell con codice HSHELL_APPCOMMAND.

Windows supporta anche Microsoft IntelliMouse Explorer, ovvero un mouse con cinque pulsanti. I due pulsanti aggiuntivi supportano lo spostamento avanti e indietro del browser. Per altre informazioni, vedere XBUTTONs.

Simulazione dell'input

Per simulare una serie ininterrotta di eventi di input utente, usare la funzione SendInput. La funzione accetta tre parametri. Il primo parametro, cInputs, indica il numero di eventi di input che verranno simulati. Il secondo parametro, rgInputs, è una matrice di strutture INPUT , ognuna che descrive un tipo di evento di input e informazioni aggiuntive su tale evento. L'ultimo parametro, cbSize, accetta le dimensioni della struttura INPUT , in byte.

La funzione SendInput funziona inserendo una serie di eventi di input simulati nel flusso di input di un dispositivo. L'effetto è simile alla chiamata ripetuta della funzione keybd_event o mouse_event, ad eccezione del fatto che il sistema garantisce che nessun altro evento di input si intermingle con gli eventi simulati. Al termine della chiamata, il valore restituito indica il numero di eventi di input riprodotti correttamente. Se questo valore è zero, l'input è stato bloccato.

La funzione SendInput non reimposta lo stato corrente della tastiera. Pertanto, se l'utente ha tasti premuti quando si chiama questa funzione, potrebbe interferire con gli eventi generati da questa funzione. Se si è preoccupati per possibili interferenze, controllare lo stato della tastiera con la funzione GetAsyncKeyState e correggere in base alle esigenze.

Lingue, impostazioni locali e layout di tastiera

Una lingua è un linguaggio naturale, ad esempio inglese, francese e giapponese. Una sottolanguage è una variante di una lingua naturale parlata in una regione geografica specifica, ad esempio le sottolanguature inglesi parlate nel Regno Unito e il Stati Uniti. Le applicazioni usano valori, denominati identificatori di lingua, per identificare in modo univoco le lingue e le sottolanguazioni.

Le applicazioni usano in genere le impostazioni locali per impostare la lingua in cui viene elaborato l'input e l'output. L'impostazione delle impostazioni locali per la tastiera, ad esempio, influisce sui valori dei caratteri generati dalla tastiera. L'impostazione delle impostazioni locali per la visualizzazione o la stampante influisce sui glifi visualizzati o stampati. Le applicazioni impostano le impostazioni locali per una tastiera caricando e usando layout di tastiera. Impostano le impostazioni locali per una visualizzazione o una stampante selezionando un tipo di carattere che supporta le impostazioni locali specificate.

Un layout della tastiera non solo specifica la posizione fisica dei tasti sulla tastiera, ma determina anche i valori dei caratteri generati premendo tali tasti. Ogni layout identifica la lingua di input corrente e determina i valori di carattere generati da quali chiavi e combinazioni di tasti.

Ogni layout di tastiera ha un handle corrispondente che identifica il layout e la lingua. La parola bassa dell'handle è un identificatore di lingua. La parola alta è un handle del dispositivo, specificando il layout fisico o è zero, che indica un layout fisico predefinito. L'utente può associare qualsiasi lingua di input a un layout fisico. Ad esempio, un utente di lingua inglese che lavora molto occasionalmente in francese può impostare la lingua di input della tastiera su francese senza modificare il layout fisico della tastiera. Ciò significa che l'utente può immettere testo in francese usando il layout inglese familiare.

Le applicazioni in genere non devono modificare direttamente i linguaggi di input. L'utente configura invece le combinazioni di linguaggio e layout, quindi passa tra di esse. Quando l'utente fa clic su testo contrassegnato con una lingua diversa, l'applicazione chiama la funzione ActivateKeyboardLayout per attivare il layout predefinito dell'utente per tale lingua. Se l'utente modifica il testo in una lingua che non è presente nell'elenco attivo, l'applicazione può chiamare la funzione LoadKeyboardLayout con la lingua per ottenere un layout basato su tale lingua.

La funzione ActivateKeyboardLayout imposta la lingua di input per l'attività corrente. Il parametro hkl può essere l'handle del layout della tastiera o un identificatore di lingua esteso zero. Gli handle di layout della tastiera possono essere ottenuti dalla funzione LoadKeyboardLayout o GetKeyboardLayoutList. I valori HKL_NEXT e HKL_PREV possono essere usati anche per selezionare la tastiera successiva o precedente.

La funzione GetKeyboardLayoutName recupera il nome del layout di tastiera attivo per il thread chiamante. Se un'applicazione crea il layout attivo usando la funzione LoadKeyboardLayout , GetKeyboardLayoutName recupera la stessa stringa usata per creare il layout. In caso contrario, la stringa è l'identificatore di lingua principale corrispondente alle impostazioni locali del layout attivo. Ciò significa che la funzione non può necessariamente distinguere tra layout diversi con la stessa lingua primaria, quindi non può restituire informazioni specifiche sulla lingua di input. La funzione GetKeyboardLayout , tuttavia, può essere usata per determinare la lingua di input.

La funzione LoadKeyboardLayout carica un layout di tastiera e rende il layout disponibile per l'utente. Le applicazioni possono rendere il layout immediatamente attivo per il thread corrente usando il valore KLF_ACTIVATE . Un'applicazione può usare il valore KLF_REORDER per riordinare i layout senza specificare anche il valore KLF_ACTIVATE . Le applicazioni devono usare sempre il valore KLF_SUBSTITUTE_OK durante il caricamento dei layout di tastiera per assicurarsi che la preferenza dell'utente, se presente, sia selezionata.

Per il supporto multilingue, la funzione LoadKeyboardLayout fornisce i flag KLF_REPLACELANG e KLF_NOTELLSHELL. Il flag KLF_REPLACELANG indirizza la funzione a sostituire un layout di tastiera esistente senza modificare la lingua. Il tentativo di sostituire un layout esistente usando lo stesso identificatore di lingua, ma senza specificare KLF_REPLACELANG è un errore. Il flag KLF_NOTELLSHELL impedisce alla funzione di notificare alla shell quando viene aggiunto o sostituito un layout di tastiera. Ciò è utile per le applicazioni che aggiungono più layout in una serie consecutiva di chiamate. Questo flag deve essere usato in tutti gli altri ma nell'ultima chiamata.

La funzione UnloadKeyboardLayout è limitata in quanto non può scaricare la lingua di input predefinita del sistema. In questo modo, l'utente dispone sempre di un layout disponibile per immettere testo usando lo stesso set di caratteri usato dalla shell e dal file system.