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 una chiave. 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.

Messa a fuoco e attivazione della tastiera

Il sistema inserisce i messaggi della tastiera nella coda di messaggi del thread in primo piano che ha creato la finestra che ha il focus della tastiera. Il dello 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 che ha la messa a fuoco della tastiera riceve (dalla coda di messaggi del thread che l'ha creata) tutti i messaggi della tastiera fino a quando la messa a fuoco non cambia a una finestra diversa.

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

Il concetto di fuoco 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 figlia 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 ALT+TAB o combinazione di tasti 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 funzioneGetActiveWindow.

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 impedire agli eventi di input della tastiera e del mouse di raggiungere le 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 messaggio WM_KEYDOWN o WM_SYSKEYDOWN 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 di WM_KEYUP o WM_SYSKEYUP quando l'utente rilascia la chiave.

In questa sezione vengono illustrati gli argomenti seguenti:

• Tasti di sistema e non di sistema
• Virtual-Key Codici Descritti
• flag di 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 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 o di usare il ALT+ESC o ALT+TAB tasto 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 tasti di sistema vengono generati quando l'utente digita un tasto in combinazione con il tasto Alt , oppure quando l'utente digita e nessuna finestra ha lo stato attivo della tastiera (ad esempio, quando l'applicazione attiva è 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 funzioneDefWindowProcnon esegue alcuna operazione con essi. Una procedura di finestra può eliminare qualsiasi messaggio di sequenza di tasti non di sistema di cui non abbia bisogno.

Virtual-Key I Codici 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 procedura della finestra potrebbe elaborare solo i messaggi di pressione tasti WM_KEYDOWN e solo quelli che contengono codici di tasto virtuale per i tasti cursore, i tasti di shift (anche chiamati tasti di controllo) e i tasti funzione. Una routine di finestra tipica non elabora i messaggi di sequenza di tasti dai tasti carattere. Usa invece la funzione TranslateMessage per convertire il messaggio in messaggi di tipo carattere. Per ulteriori informazioni su TranslateMessage e sui messaggi di carattere, vedere Messaggi di carattere.

Indicatori di messaggio della battitura

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 scansione , il flag di tasto esteso , il codice di contesto , il flag di stato del tasto precedente e il flag di stato di transizione . La figura seguente mostra le posizioni di questi flag e valori nel parametro lParam.

Un'applicazione può usare i valori seguenti per ottenere i flag di tasto dalla parola alta del 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;

Conteggio ripetizioni

È 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 di pressione dei tasti risultanti, il sistema combina i messaggi in un singolo messaggio di pressione del tasto e incrementa il conteggio delle 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 scansione

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é dal carattere rappresentato dal tasto . Un'applicazione in genere ignora i codici di scansione. Usa invece i codici di chiave virtuale per interpretare i messaggi di sequenza di tasti.

Le tastiere moderne utilizzano 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 in codici di scansione e li passa alle applicazioni.

La tabella seguente elenca il set di codici di analisi attualmente riconosciuti da Windows. Pagina di utilizzo HID /ID di utilizzo HID/i valori del nome utilizzo HID fanno riferimento al documento 'Tabelle di utilizzo HID'. I valori di posizione chiave si riferiscono all'immagine della tastiera precedente.

I messaggi Scan 1 Make vengono recapitati nei WM_KEYDOWN/WM_KEYUP/WM_SYSKEYDOWN/WM_SYSKEYUP e WM_INPUT.

Note:

1. codice di scansione del tasto SysRq viene emesso con la combinazione di tasti Alt+Stamp
2. Il codice di scansione del tasto Pausa viene generato alla pressione di Ctrl+Pausa
3. Come illustrato nei messaggi legacy della tastiera
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

Extended-Key Bandiera

Il flag dei tasti estesi indica se il messaggio del tasto proviene da uno dei tasti aggiuntivi della tastiera migliorata 101/102. I tasti estesi sono costituiti dai tasti Alt e Control sul lato destro della tastiera; i tasti Inserisci*, Elimina*, Home, Fine, Page Up, Page Downe Freccia a sinistra del tastierino numerico; il tasto Blocco Num; il tasto Interruzione (Ctrl+Sospendi); il tasto Stampa Schermo; e i tasti Dividi (/) e Invio sul tastierino numerico. La tasto maiusc a destra non è considerata una chiave estesa, ma ha invece 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 la tasto ALT è inattiva quando è stato generato il messaggio di sequenza di tasti. Il codice è 1 se il tasto alt è inattivo e 0 se è inattivo.

Flag Key-State precedente

Il flag di stato del tasto precedente indica se il tasto che ha generato il messaggio di sequenza di tasti era precedentemente su o giù. È 1 se il tasto era stato precedentemente premuto e 0 se il tasto era stato precedentemente rilasciato. È 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 nei messaggi di sequenza di tasti generati dalla funzionalità di ripetizione automatica per WM_KEYDOWN e WM_SYSKEYDOWN. È sempre impostato su 1 per i messaggi WM_KEYUP e WM_SYSKEYUP.

Transition-State Bandiera

L'indicatore di stato di transizione indica se la pressione o il rilascio di un tasto ha generato il messaggio di pressione dei 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 funzioneTranslateMessagenel ciclo di messaggi del thread. TranslateMessage passa un messaggio WM_KEYDOWN o WM_SYSKEYDOWN al layout della tastiera. Il layout esamina il codice virtual-key del messaggio e, se corrisponde a un tasto di carattere, fornisce l'equivalente del codice carattere (tenendo conto dello stato del Maiusc e dei tasti Bloc Maiusc). 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.

In questa sezione vengono illustrati gli argomenti seguenti:

• messaggi di caratteri non di sistema
• Dead-Character messaggi

Messaggi di carattere non di sistema

Una routine finestra può ricevere i messaggi di carattere seguenti: WM_CHAR, WM_DEADCHAR, WM_SYSCHAR, WM_SYSDEADCHARe WM_UNICHAR. La funzioneTranslateMessagegenera un messaggio WM_CHAR o WM_DEADCHAR quando elabora un messaggio di 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 funzioneDefWindowProc. 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 è stata usata la versione Unicode della funzioneRegisterClassper 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 di 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 chiave-down convertito per produrre il messaggio di carattere. Per informazioni, vedere flag di messaggio per la sequenza di tasti .

Dead-Character messaggi

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. Questi tasti vengono chiamati tasti morti . 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 un tasto morto. Sebbene il parametro wParam del messaggio WM_DEADCHAR contenga il codice carattere del diacritico per la chiave non usata, 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 WM_SYSDEADCHAR quando elabora il messaggio WM_SYSKEYDOWN da un tasto morto di sistema (un tasto morto che viene premuto in combinazione con il tasto Alt). Un'applicazione ignora in genere il messaggio 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 testi che consente all'utente di premere Shift+End per selezionare un blocco di testo deve controllare lo stato del tasto Shift ogni volta che riceve un messaggio dalla tastiera relativo al tasto End. L'applicazione può usare la funzioneGetKeyStateper determinare lo stato di una chiave virtuale al momento della generazione del messaggio corrente; può usare la funzioneGetAsyncKeyStateper recuperare lo stato corrente di una chiave virtuale.

Alcuni tasti sono considerati interruttori che modificano lo stato del layout della tastiera. I tasti di blocco in genere includono Blocco Maiuscole (VK_CAPITAL), blocco numerico (VK_NUMLOCK) e tasti blocco di scorrimento (VK_SCROLL). La maggior parte delle tastiere ha indicatori LED corrispondenti per questi tasti.

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 un tasto non carattere, come Tab e Enter, viene memorizzato come stringa di caratteri. Un'applicazione può recuperare il nome di qualsiasi tasto dal layout della tastiera chiamando la funzioneGetKeyNameText.

Sequenze di tasti e traduzioni di caratteri

Il sistema include diverse funzioni speciali che convertono codici di scansione, codici carattere e codici di tasti virtuali forniti da vari messaggi di sequenza di tasti. Queste funzioni includono MapVirtualKey, ToAscii, ToUnicodee VkKeyScan.

Inoltre, Microsoft Rich Edit 3.0 supporta la HexToUnicode IME, 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 Hot-Key

Un tasto di scelta rapida è una combinazione di tasti che genera un messaggio WM_HOTKEY, che il sistema posiziona in cima alla coda dei messaggi di un thread, ignorando eventuali messaggi già presenti nella coda. Le applicazioni usano i tasti di scelta rapida per ricevere dall'utente input della tastiera con priorità elevata. Ad esempio, definendo un tasto di scelta rapida costituito dalla controllo+C sequenza di tasti, un'applicazione può consentire all'utente di annullare un'operazione lunga.

Per definire un tasto di scelta rapida, un'applicazione chiama la funzioneRegisterHotKey, 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, viene inserito un messaggio di WM_HOTKEY nella coda di messaggi del thread che ha creato la finestra. Il parametro wParam del messaggio contiene l'identificatore del tasto 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 distruggere 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_SETHOTKEY per impostare il tasto di scelta rapida. Ogni volta che l'utente preme il tasto di scelta rapida, il sistema invia un messaggio WM_SYSCOMMAND che specifica SC_HOTKEY. Per altre informazioni sui controlli a tasti di scelta rapida, vedere "Uso di controlli a tasti 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 funzioneShellProcviene modificata per supportare i tasti aggiuntivi della tastiera.

È improbabile che una finestra figlia in un'applicazione di componenti sia in grado di implementare direttamente i comandi per questi tasti aggiuntivi. Quindi, quando viene premuto uno di questi tasti, DefWindowProc invierà un messaggio di WM_APPCOMMAND a una finestra. DefWindowProc trasmetterà anche il messaggio WM_APPCOMMAND alla 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 pulsante destro del mouse e lo fa 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 funzioneSendInput. 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 funzioneSendInputnon 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 è una lingua naturale, ad esempio inglese, francese e giapponese. Un sottolingua è una variante di una lingua naturale parlata in una regione geografica specifica, ad esempio le sottolingue inglesi parlate nel Regno Unito e negli Stati Uniti. Le applicazioni utilizzano valori, denominati identificatori di lingua , per identificare in modo univoco le lingue e i sottolinguaggi.

Le applicazioni usano in genere 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. Il word alto è un handle del dispositivo, che specifica il layout fisico, oppure è zero, nel qual caso 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 funzioneLoadKeyboardLayoutcon 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 o l'handle per il layout della tastiera o un identificatore di lingua a estensione 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 indicatore dovrebbe essere usato in tutte le chiamate tranne l'ultima.

La funzione UnloadKeyboardLayout è limitata perché 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.