Uso di un editor di metodi di input in un gioco
Nota
Questo articolo illustra in dettaglio l'uso dell'IME (Input Method Editor) di Windows XP. Sono state apportate modifiche all'IME per Windows Vista che non sono completamente dettagliate in questo articolo.
Un editor di metodi di input (IME) è un programma che consente una semplice immissione di testo usando una tastiera standard per lingue asiatiche come cinese, giapponese, coreano e altre lingue con caratteri complessi. Ad esempio, con gli IMEs un utente può digitare caratteri complessi in un elaboratore di testo o un giocatore di un gioco online multiplayer massiccio può chattare con amici in personaggi complessi.
Questo articolo illustra come implementare un controllo di modifica IME di base in un'applicazione Microsoft DirectX a schermo intero. Le applicazioni che sfruttano DXUT ottengono automaticamente la funzionalità IME. Per le applicazioni che non usano il framework, questo articolo descrive come aggiungere il supporto IME a un controllo di modifica.
Contenuti:
- Comportamento IME predefinito
- Uso di messaggistica istantanea con DXUT
- Override del comportamento IME predefinito
- Funzioni
- Messaggi
- Esempi
- Messaggi IME
- Rendering
- Limitazioni
- Informazioni sul Registro di sistema
- Appendice A: Versioni CHT per sistema operativo
- Altre informazioni
- GetReadingString
- ShowReadingWindow
Comportamento IME predefinito
Gli imes eseguono il mapping dell'input della tastiera ai componenti fonetici o ad altri elementi del linguaggio specifici di una lingua selezionata. In uno scenario tipico, l'utente digita le chiavi che rappresentano la pronuncia di un carattere complesso. Se l'IME riconosce la pronuncia come valida, presenta all'utente un elenco di candidati di parole o frasi da cui l'utente può selezionare una scelta finale. La parola scelta viene quindi inviata all'applicazione tramite una serie di messaggi di Microsoft Windows WM_CHAR . Poiché l'IME funziona a un livello inferiore all'applicazione intercettando l'input della tastiera, la presenza di un IME è trasparente per l'applicazione. Quasi tutte le applicazioni Windows possono facilmente sfruttare i vantaggi di IMEs senza essere consapevoli della loro esistenza e senza richiedere codice speciale.
Un IME tipico visualizza diverse finestre per guidare l'utente tramite la voce di carattere, come illustrato negli esempi seguenti.
| Tipo di finestra | Descrizione | IME Output |
|---|---|---|
| R. Finestra di lettura | Contiene le sequenze di tasti dalla tastiera; in genere cambia dopo ogni sequenza di tasti. | stringa di lettura |
| B. Finestra composizione | Contiene la raccolta di caratteri che l'utente ha composto con l'IME. Questi caratteri vengono disegnati dall'IME sopra l'applicazione. Quando l'utente notifica all'IME che la stringa di composizione è soddisfacente, l'IME invia quindi la stringa di composizione all'applicazione tramite una serie di messaggi WM_CHAR. | stringa di composizione |
| C. Finestra candidata | Quando l'utente ha immesso una pronuncia valida, l'IME visualizza un elenco di caratteri candidati che corrispondono alla pronuncia specificata. L'utente seleziona quindi il carattere desiderato da questo elenco e l'IME aggiunge questo carattere alla visualizzazione Finestra di composizione. | il carattere successivo nella stringa di composizione |
| D. Indicatore delle impostazioni locali di input | Mostra la lingua selezionata dall'utente per l'input da tastiera. Questo indicatore è incorporato nella barra delle applicazioni di Windows. È possibile selezionare la lingua di input aprendo il Pannello di controllo Opzioni internazionali e della lingua e quindi facendo clic su Dettagli nella scheda Lingue. | - |
Uso di messaggistica istantanea con DXUT
In DXUT la classe CDXUTIM edizione Enterprise ditBox implementa la funzionalità IME. Questa classe è derivata dalla classe CDXUTEditBox, il controllo di modifica di base fornito dal framework. CDXUTIM edizione Enterprise ditBox estende tale controllo di modifica per supportare gli IMEs eseguendo l'override dei metodi CDXUTIM edizione Enterprise ditBox. Le classi sono progettate in questo modo per aiutare gli sviluppatori a imparare ciò che devono prendere dal framework per implementare il supporto IME nei propri controlli di modifica. Nella parte restante di questo argomento viene illustrato in che modo il framework e CDXUTIM edizione Enterprise ditBox, in particolare, esegue l'override di un controllo di modifica di base per implementare la funzionalità IME.
La maggior parte delle variabili specifiche di IME in CDXUTIM edizione Enterprise ditBox viene dichiarata come statica, perché molti buffer e stati IME sono specifici del processo. Ad esempio, un processo ha un solo buffer per la stringa di composizione. Anche se il processo ha dieci controlli di modifica, tutti condividono lo stesso buffer di stringhe di composizione. Il buffer della stringa di composizione per CDXUTIM edizione Enterprise ditBox è quindi statico, impedendo all'applicazione di occupare spazio di memoria non necessario.
CDXUTIM edizione Enterprise ditBox viene implementato nel codice DXUT seguente:
(RADICE SDK)\Samples\C++\Common\DXUTgui.cpp
Override del comportamento IME predefinito
In genere un IME usa procedure di Windows standard per creare una finestra (vedere Uso di Windows). In circostanze normali, questo produce risultati soddisfacenti. Tuttavia, quando l'applicazione presenta in modalità schermo intero, come è comune per i giochi, le finestre standard non funzionano più e potrebbero non essere visualizzate sopra l'applicazione. Per risolvere questo problema, l'applicazione deve disegnare le finestre IME stesse anziché basarsi su Windows per eseguire questa attività.
Quando il comportamento di creazione della finestra IME predefinito non fornisce ciò che richiede un'applicazione, l'applicazione può eseguire l'override della gestione delle finestre IME. Un'applicazione può ottenere questo risultato elaborando i messaggi correlati a IME e chiamando l'API IMM (Input Method Manager ).
Quando un utente interagisce con un IME per inserire caratteri complessi, IMM invia messaggi all'applicazione per notificare gli eventi importanti, ad esempio l'avvio di una composizione o la visualizzazione della finestra candidata. Un'applicazione ignora in genere questi messaggi e li passa al gestore di messaggi predefinito, che fa sì che l'IME li gestisca. Quando l'applicazione, invece del gestore predefinito, gestisce i messaggi, controlla esattamente cosa accade in ogni evento IME. Spesso il gestore messaggi recupera il contenuto delle varie finestre IME chiamando l'API IMM. Una volta che l'applicazione dispone di queste informazioni, può disegnare correttamente le finestre IME stesse quando è necessario eseguire il rendering sullo schermo.
Funzioni
Un IME deve ottenere la stringa di lettura, nascondere la finestra di lettura e ottenere l'orientamento della finestra di lettura. Questa tabella mostra le funzionalità per ogni versione IME:
| Recupero della stringa di lettura | Nascondere la finestra di lettura | Orientamento della finestra di lettura | |
|---|---|---|---|
| Prima della versione 6.0 | R. Lettura diretta dei dati privati IME di Accesso alla finestra. Vedere "4 Struttura" | Intercettare i messaggi privati IME. Vedere "3 Messaggi" | Esaminare le informazioni del Registro di sistema. Vedere "5 Informazioni sul Registro di sistema" |
| Dopo la versione 6.0 | GetReadingString | ShowReadingWindow | GetReadingString |
Messaggi
I messaggi seguenti non devono essere elaborati per i file IME più recenti che implementano ShowReadingWindow().
I messaggi seguenti vengono intrappolati dal gestore dei messaggi dell'applicazione (ovvero non vengono passati a DefWindowProc) per impedire la visualizzazione della finestra di lettura.
Msg == WM_IME_NOTIFY
wParam == IMN_PRIVATE
lParam == 1, 2 (CHT IME version 4.2, 4.3 and 4.4 / CHS IME 4.1 and 4.2)
lParam == 16, 17, 26, 27, 28 (CHT IME version 5.0, 5.1, 5.2 / CHS IME 5.3)
Esempi
Gli esempi seguenti illustrano come ottenere informazioni sulle stringhe da IME meno recenti che non hanno GetReadingString(). Il codice genera gli output seguenti:
| Output | Descrizione |
|---|---|
| DWORD dwlen | Lunghezza della stringa di lettura. |
| DWORD dwerr | Indice del carattere di errore. |
| LPWSTR wstr | Puntatore alla stringa di lettura. |
| BOOL Unicode | Se true, la stringa di lettura è in formato Unicode. In caso contrario, è in formato multibyte. |
CHT IME versione 4.2, 4.3 e 4.4
LPINPUTCONTEXT lpIMC = _ImmLockIMC(himc);
LPBYTE p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIMC->hPrivate) + 24);
if (!p) break;
dwlen = *(DWORD *)(p + 7*4 + 32*4);
dwerr = *(DWORD *)(p + 8*4 + 32*4);
wstr = (WCHAR *)(p + 56);
unicode = TRUE;
CHT IME versione 5.0
LPINPUTCONTEXT lpIMC = _ImmLockIMC(himc);
LPBYTE p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIMC->hPrivate) + 3*4);
if (!p) break;
p = *(LPBYTE *)((LPBYTE)p + 1*4 + 5*4 + 4*2 );
if (!p) break;
dwlen = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16);
dwerr = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 + 1*4);
wstr = (WCHAR *)(p + 1*4 + (16*2+2*4) + 5*4);
unicode = FALSE;
CHT IME versione 5.1, 5.2 e CHS IME versione 5.3
LPINPUTCONTEXT lpIMC = _ImmLockIMC(himc);
LPBYTE p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIMC->hPrivate) + 4);
if (!p) break;
p = *(LPBYTE *)((LPBYTE)p + 1*4 + 5*4);
if (!p) break;
dwlen = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * 2);
dwerr = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * 2 + 1*4);
wstr = (WCHAR *) (p + 1*4 + (16*2+2*4) + 5*4);
unicode = TRUE;
CHS IME versione 4.1
// GetImeId(1) returns VS_FIXEDFILEINFO:: dwProductVersionLS of IME file
int offset = ( GetImeId( 1 ) >= 0x00000002 ) ? 8 : 7;
LPINPUTCONTEXT lpIMC = _ImmLockIMC(himc);
BYTE p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIMC->hPrivate) + offset * 4);
if (!p) break;
dwlen = *(DWORD *)(p + 7*4 + 16*2*4);
dwerr = *(DWORD *)(p + 8*4 + 16*2*4);
dwerr = min(dwerr, dwlen);
wstr = (WCHAR *)(p + 6*4 + 16*2*1);
unicode = TRUE;
CHS IME versione 4.2
int nTcharSize = IsNT() ? sizeof(WCHAR) : sizeof(char);
LPINPUTCONTEXT lpIMC = _ImmLockIMC(himc);
BYTE p = *(LPBYTE *)((LPBYTE)_ImmLockIMCC(lpIMC->hPrivate) + 1*4 + 1*4 + 6*4);
if (!p) break;
dwlen = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * nTcharSize);
dwerr = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16 * nTcharSize + 1*4);
wstr = (WCHAR *) (p + 1*4 + (16*2+2*4) + 5*4);
unicode = IsNT() ? TRUE : FALSE;
Messaggi IME
Un'applicazione a schermo intero deve gestire correttamente i messaggi correlati all'IME seguenti:
WM_INPUTLANGCHANGE
IMM invia un messaggio di WM_INPUTLANGCHANGE alla finestra attiva di un'applicazione dopo che le impostazioni locali di input sono state modificate dall'utente con una combinazione di tasti (in genere ALT+MAIUSC) o con l'indicatore delle impostazioni locali di input sulla barra delle applicazioni o sulla barra della lingua. La barra della lingua è un controllo sullo schermo con cui l'utente può configurare un servizio di testo. (Vedere Come visualizzare la barra della lingua. La schermata seguente mostra un elenco di selezione della lingua visualizzato quando l'utente fa clic sull'indicatore delle impostazioni locali.
Quando IMM invia un messaggio di WM_INPUTLANGCHANGE, CDXUTIM edizione Enterprise ditBox deve eseguire diverse attività importanti:
- Il metodo GetKeyboardLayout viene chiamato per restituire l'identificatore delle impostazioni locali di input (ID) per il thread dell'applicazione. La classe CDXUTIM edizione Enterprise ditBox salva questo ID nella variabile membro statica s_hklCurrent per un uso successivo. È importante che l'applicazione conosca le impostazioni locali di input correnti, perché l'IME per ogni lingua ha un comportamento distinto. Lo sviluppatore potrebbe dover fornire codice diverso per impostazioni locali di input diverse.
- CDXUTIM edizione Enterprise ditBox inizializza una stringa da visualizzare nell'indicatore della lingua della casella di modifica. Questo indicatore può visualizzare la lingua di input attiva quando l'applicazione è in esecuzione in modalità schermo intero e non è visibile né la barra delle applicazioni né la barra della lingua.
- Viene chiamato il metodo ImmGetConversionStatus per indicare se le impostazioni locali di input sono in modalità di conversione nativa o non nativa. La modalità di conversione nativa consente all'utente di immettere testo nella lingua scelta. La modalità di conversione non nativa rende la tastiera come tastiera inglese standard. È importante fornire all'utente un segnale visivo in base al tipo di modalità di conversione in cui si trova l'IME, in modo che l'utente possa facilmente sapere quali caratteri aspettarsi quando si preme un tasto. CDXUTIM edizione Enterprise ditBox fornisce questo segnale visivo con un colore indicatore di lingua. Quando le impostazioni locali di input usano un IME con modalità di conversione nativa, la classe CDXUTIM edizione Enterprise ditBox disegna il testo dell'indicatore con il colore definito dal parametro m_IndicatorImeColor. Quando l'IME è in modalità di conversione non nativa o non viene usato alcun IME, la classe disegna il testo dell'indicatore con il colore definito dal parametro m_IndicatorEngColor.
- CDXUTIM edizione Enterprise ditBox controlla le impostazioni locali di input e imposta la variabile membro statica s_bInsertOnType su TRUE per coreano e FAL edizione Standard per tutte le altre lingue. Questo flag è obbligatorio a causa dei diversi comportamenti degli IMEs coreani e di tutti gli altri IMEs. Quando si immettono caratteri in lingue diverse dal coreano, il testo immesso dall'utente viene visualizzato nella finestra di composizione e l'utente può modificare liberamente il contenuto della stringa di composizione. L'utente preme il tasto INVIO quando è soddisfatto della stringa di composizione e la stringa di composizione viene inviata all'applicazione come una serie di messaggi WM_CHAR. Negli IMEs coreani, tuttavia, quando un utente preme un tasto per immettere testo, un carattere viene immediatamente inviato all'applicazione. Quando successivamente l'utente preme più tasti per modificare il carattere iniziale, il carattere nella casella di modifica cambia in modo da riflettere l'input aggiuntivo dell'utente. Essenzialmente, l'utente sta componendo caratteri nella casella di modifica. Questi due comportamenti sono sufficientemente diversi dal fatto che CDXUTIM edizione Enterprise ditBox deve scrivere codice per ognuno di essi in modo specifico.
- Il metodo membro statico SetupImeApi viene chiamato per recuperare gli indirizzi di due funzioni dal modulo IME: GetReadingString e ShowReadingWindow. Se queste funzioni esistono, ShowReadingWindow viene chiamato per nascondere la finestra di lettura predefinita per questo IME. Poiché l'applicazione esegue il rendering della finestra di lettura stessa, notifica all'IME di disabilitare il disegno della finestra di lettura predefinita in modo che non interferisca con il rendering a schermo intero.
IMM invia un messaggio WM_IME_edizione Standard TCONTEXT quando viene attivata una finestra dell'applicazione. Il parametro lParam di questo messaggio contiene un flag che indica all'IME quali finestre devono essere disegnate e che non devono essere create. Poiché l'applicazione gestisce tutto il disegno, non è necessario che l'IME disegnare alcuna delle finestre IME. Pertanto, il gestore messaggi dell'applicazione imposta semplicemente lParam su 0 e restituisce.
Per consentire alle applicazioni di supportare IME, è necessaria un'elaborazione speciale per il messaggio correlato all'IME WM_IME_edizione Standard TCONTEXT. Poiché Windows invia in genere questo messaggio all'applicazione prima di chiamare il metodo PanoramaInitialize(), Panorama non ha la possibilità di elaborare l'interfaccia utente per visualizzare le finestre degli elenchi candidati.
Il frammento di codice seguente specifica alle applicazioni Windows di non visualizzare alcuna interfaccia utente associata alla finestra dell'elenco dei candidati, consentendo a Panorama di gestire in modo specifico questa interfaccia utente.
case WM_IME_SETCONTEXT:
lParam = 0;
lRet = DefWindowProc(hWnd, msg, wParam, lParam);
break;
//... more message processing
return lRet;
WM_IME_STARTCOMPOSITION
IMM invia un messaggio di WM_IME_STARTCOMPOSITION all'applicazione quando una composizione IME sta per iniziare a causa di sequenze di tasti da parte dell'utente. Se l'IME usa la finestra di composizione, viene visualizzata la stringa di composizione corrente in una finestra di composizione. CDXUTIM edizione Enterprise ditBox gestisce questo messaggio eseguendo due attività:
- CDXUTIM edizione Enterprise ditBox cancella il buffer della stringa di composizione e il buffer degli attributi. Questi buffer sono membri statici di CDXUTIM edizione Enterprise ditBox.
- CDXUTIM edizione Enterprise ditBox imposta la variabile membro statica s_bHideCaret su TRUE. Questo membro, definito nella classe CDXUTEditBox di base, controlla se il cursore nella casella di modifica deve essere disegnato quando viene eseguito il rendering della casella di modifica. La finestra di composizione funziona in modo analogo a una casella di modifica con testo e cursore. Per evitare confusione quando la finestra di composizione è visibile, la casella di modifica nasconde il cursore in modo che un solo cursore sia visibile alla volta.
WM_IME_COMPOSITION
IMM invia un messaggio WM_IME_COMPOSITION all'applicazione quando l'utente immette una sequenza di tasti per modificare la stringa di composizione. Il valore di lParam indica il tipo di informazioni che l'applicazione può recuperare da Input Method Manager (IMM). L'applicazione deve recuperare le informazioni disponibili chiamando ImmGetCompositionString e quindi salvare le informazioni nel buffer privato in modo che possa eseguire il rendering degli elementi IME in un secondo momento.
CDXUTIM edizione Enterprise ditBox controlla e recupera i dati della stringa di composizione seguenti:
WM_IME_ENDCOMPOSITION
IMM invia un messaggio WM_IME_ENDCOMPOSITION all'applicazione al termine dell'operazione di composizione IME. Ciò può verificarsi quando l'utente preme il tasto INVIO per approvare la stringa di composizione o il tasto ESC per annullare la composizione. CDXUTIM edizione Enterprise ditBox gestisce questo messaggio impostando il buffer della stringa di composizione su vuoto. Imposta quindi s_bHideCaret su FAL edizione Standard perché la finestra di composizione è chiusa e il cursore nella casella di modifica dovrebbe essere nuovamente visibile.
Il gestore dei messaggi CDXUTIM edizione Enterprise ditBox imposta anche s_bShowReadingWindow su FAL edizione Standard. Questo flag controlla se la classe disegna la finestra di lettura quando viene eseguito il rendering della casella di modifica, pertanto deve essere impostata su FAL edizione Standard quando termina una composizione.
WM_IME_NOTIFY
IMM invia un messaggio di WM_IME_NOTIFY all'applicazione ogni volta che viene modificata una finestra IME. Un'applicazione che gestisce il disegno delle finestre IME deve elaborare questo messaggio in modo che sia a conoscenza di qualsiasi aggiornamento del contenuto della finestra. WParam indica il comando o la modifica che viene eseguita. CDXUTIM edizione Enterprise ditBox gestisce i comandi seguenti:
| Comando IME | Descrizione |
|---|---|
| IMN_edizione Standard TOPENSTATUS | Questo attributo contiene informazioni quali lo stato di ogni carattere nella stringa di composizione( ad esempio, convertito o non convertito). Queste informazioni sono necessarie perché CDXUTIM edizione Enterprise ditBox colora i caratteri della stringa di composizione in modo diverso in base ai relativi attributi. |
| / IMN_OPENCANDIDATE IMN_CHANGECANDIDATE | Inviato all'applicazione quando la finestra candidata sta per essere aperta o aggiornata, rispettivamente. La finestra candidata viene visualizzata quando un utente desidera modificare la scelta del testo convertito. La finestra viene aggiornata quando un utente sposta l'indicatore di selezione o modifica la pagina. CDXUTIM edizione Enterprise ditBox usa un gestore messaggi per entrambi questi comandi perché le attività necessarie sono esattamente le stesse:
|
| IMN_CLOedizione Standard CANDIDATE | Inviato all'applicazione quando una finestra candidata sta per chiudersi. Ciò si verifica quando un utente ha effettuato una selezione dall'elenco dei candidati. CDXUTIM edizione Enterprise ditBox gestisce questo comando impostando il flag visibile della finestra candidata su FAL edizione Standard e quindi cancellando il buffer della stringa candidata. |
| IMN_PRIVATE | Inviato all'applicazione quando l'IME ha aggiornato la stringa di lettura in seguito alla digitazione o alla rimozione di caratteri da parte dell'utente. L'applicazione deve recuperare la stringa di lettura e salvarla per il rendering. CDXUTIM edizione Enterprise ditBox include due metodi per recuperare la stringa di lettura, in base al modo in cui le stringhe di lettura sono supportate nell'IME:
|
Rendering
Il rendering degli elementi e delle finestre IME è semplice. CDXUTIM edizione Enterprise ditBox consente prima di tutto il rendering della classe di base perché le finestre IME devono essere visualizzate sopra il controllo di modifica. Dopo il rendering della casella di modifica di base, CDXUTIM edizione Enterprise ditBox controlla il flag di visibilità di ogni finestra IME (indicatore, composizione, candidato e finestra di lettura) e disegna la finestra se deve essere visibile. Vedere Comportamento IME predefinito per le descrizioni dei diversi tipi di finestra IME.
Indicatore delle impostazioni locali di input
Il rendering dell'indicatore delle impostazioni locali di input viene eseguito prima di qualsiasi altra finestra IME perché è un elemento sempre visualizzato. Dovrebbe quindi apparire sotto altre finestre IME. CDXUTIM edizione Enterprise ditBox esegue il rendering dell'indicatore chiamando il metodo RenderIndicator, in cui il colore del carattere dell'indicatore viene determinato esaminando la variabile statica s_ImeState, che riflette la modalità di conversione IME corrente. Quando l'IME è abilitato e la conversione nativa è attiva, il metodo usa m_IndicatorImeColor come colore dell'indicatore. Se l'IME è disabilitato o è in modalità di conversione non nativa, m_IndicatorImeColor viene usato per disegnare il testo dell'indicatore. Per impostazione predefinita, la finestra dell'indicatore viene disegnata a destra della casella di modifica. Le applicazioni possono modificare questo comportamento eseguendo l'override del metodo RenderIndicator.
La figura seguente mostra i diversi aspetti di un indicatore delle impostazioni locali di input per l'inglese, il giapponese in modalità di conversione alfanumerica e il giapponese in modalità di conversione nativa:
Finestra composizione
Il disegno della finestra di composizione viene gestito nel metodo RenderComposition di CDXUTIM edizione Enterprise ditBox. La finestra di composizione galleggia sopra la casella di modifica. Deve essere disegnato in corrispondenza della posizione del cursore del controllo di modifica sottostante. CDXUTIM edizione Enterprise ditBox gestisce il rendering come segue:
- L'intera stringa di composizione viene disegnata utilizzando i colori predefiniti della stringa di composizione.
- I caratteri con determinati attributi speciali devono essere disegnati in colori diversi, quindi CDXUTIM edizione Enterprise ditBox esamina i caratteri della stringa di composizione ed esamina l'attributo stringa. Se l'attributo chiama colori diversi, il carattere viene di nuovo disegnato con i colori appropriati.
- Il cursore della finestra di composizione viene disegnato per completare il rendering.
Il cursore deve lampeggiare per gli IMEs coreani, ma non deve essere per altri IMEs. RenderComposition determina se il cursore deve essere visibile in base ai valori timer quando viene utilizzato l'IME coreano.
Lettura e windows candidata
Il rendering delle finestre di lettura e candidati viene eseguito dallo stesso metodo CDXUTIM edizione Enterprise ditBox, RenderCandidateReadingWindow. Entrambe le finestre contengono una matrice di stringhe per il layout verticale o una singola stringa nel caso del layout orizzontale. La maggior parte del codice in RenderCandidateReadingWindow viene usata per posizionare la finestra in modo che nessuna parte della finestra si trova all'esterno della finestra dell'applicazione e venga ritagliata.
Limiti
Le messaggistica istantanea in alcuni casi contengono funzionalità avanzate per migliorare la facilità di input del testo. Alcune delle funzionalità disponibili negli IME più recenti sono illustrate nelle figure seguenti. Queste funzionalità avanzate non sono presenti in DXUT. L'implementazione del supporto per queste funzionalità avanzate può risultare complessa perché non esiste un'interfaccia definita per ottenere le informazioni necessarie dagli imes.
IME cinese tradizionale avanzato con elenco di candidati espanso:
IME giapponese avanzato con alcune voci candidate che contengono testo aggiuntivo per descrivere i loro significati:
IME coreano avanzato che include un sistema di riconoscimento della grafia:
Informazioni sul Registro di sistema
Le informazioni del Registro di sistema seguenti vengono controllate per determinare l'orientamento della finestra di lettura, quando l'IME corrente è precedente CHT New Telefono tic che non implementa GetReadingString().
| Chiave | Valore |
|---|---|
| HKCU\software\microsoft\windows\currentversion\IME_Name | mapping della tastiera |
Dove: IME_Name è MSTCIPH se la versione del file IME è 5.1 o successiva; in caso contrario, IME_Name è TINTLGNT.
L'orientamento della finestra di lettura è orizzontale se:
- L'IME è la versione 5.0 e il valore di mapping della tastiera è 0x22 o 0x23
- L'IME è versione 5.1 o versione 5.2 e il valore di mapping della tastiera è 0x22, 0x23 o 0x24.
Se nessuna delle due condizioni viene soddisfatta, la finestra di lettura è verticale.
Appendice A: Versioni CHT per sistema operativo
| Sistema operativo | Versione IME di CHT |
|---|---|
| Windows 98 | 4.2 |
| Windows 2000 | 4.3 |
| Sconosciuto | 4.4 |
| Windows ME | 5.0 |
| Office XP | 5.1 |
| Windows XP | 5,2 |
| Download Web autonomo | 6.0 |
Altre informazioni
Per altre informazioni, vedere quanto segue:
- Installazione e uso di editor di metodi di input
- Visualizzazione testo internazionale
- Consorzio Unicode
- Sviluppo di software internazionale. Dr. International. 2° ed. Redmond, WA: Microsoft Press, 2003.
GetReadingString
Ottiene informazioni sulla stringa di lettura.
Parametri
-
himc
-
[in] Contesto di input.
-
uReadingBufLen
-
[in] Lunghezza di lpwReadingBuf, in WCHAR. Se è zero, significa che la lunghezza del buffer di lettura delle query è pari a zero.
-
lpwReadingBuf
-
[out] Restituisce la stringa di lettura (non di fine zero).
-
pnErrorIndex
-
[out] Restituisce l'indice del carattere di errore nella stringa di lettura, se presente.
-
pfIsVertical
-
[out] Se è TRUE, la lettura dell'interfaccia utente è verticale. In caso contrario, puMaxReadingLen orizzontale.
-
puMaxReadingLen
-
[out] Lunghezza dell'interfaccia utente di lettura. La lunghezza massima di lettura non è fissa; dipende non solo dal layout della tastiera, ma anche dalla modalità di input (ad esempio, codice interno, input surrogato).
Valori restituiti
Lunghezza della stringa di lettura.
Osservazioni:
Se il valore restituito è maggiore del valore di uReadingBufLen, tutti i parametri di output non sono definiti.
Questa funzione viene implementata in CHT IME 6.0 o versione successiva e può essere acquisita da GetProcAddress su un handle di modulo IME; L'handle del modulo IME può essere acquisito da ImmGetIMEFileName e LoadLibrary.
Requisiti
-
Intestazione
-
Dichiarato in Imm.h.
-
Importa libreria
-
Usare Imm.lib.
ShowReadingWindow
Mostra (o nasconde) la finestra di lettura.
Parametri
-
himc
-
[in] Contesto di input.
-
bShow
-
[in] Impostare su TRUE per visualizzare la finestra di lettura (o FAL edizione Standard per nasconderla.
Valori restituiti
Osservazioni:
Restituisce TRUE se ha esito positivo o FAL edizione Standard in caso contrario.
Requisiti
-
Intestazione
-
Dichiarato in Imm.h.
-
Importa libreria
-
Usare Imm.lib.
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per