Utilisation d’un éditeur de méthode d’entrée dans un jeu

Un éditeur de méthode d’entrée (IME) est un programme qui permet d’entrer facilement du texte à l’aide d’un clavier standard pour les langues d’Asie de l’Est telles que le chinois, le japonais, le coréen et d’autres langues avec des caractères complexes. Par exemple, avec les MI, un utilisateur peut taper des caractères complexes dans un traitement de texte, ou un joueur d’un jeu en ligne multijoueur massif peut discuter avec des amis dans des caractères complexes.

Cet article explique comment implémenter un contrôle de modification IME de base dans une application Microsoft DirectX en plein écran. Les applications qui tirent parti de DXUT obtiennent automatiquement les fonctionnalités IME. Pour les applications qui n’utilisent pas l’infrastructure, cet article explique comment ajouter la prise en charge de l’IME à un contrôle d’édition.

Contenu :

• Comportement IME par défaut
• Utilisation des MIs eses avec DXUT
• Substitution du comportement IME par défaut
• Fonctions
• Messages
• Exemples
  • CHT IME version 4.2, 4.3 et 4.4
  • CHT IME version 5.0
  • CHT IME version 5.1, 5.2 et CHS IME version 5.3
  • CHS IME version 4.1
  • CHS IME version 4.2
• IME Messages
  • WM_INPUTLANGCHANGE
  • WM_IME_STARTCOMPOSITION
  • WM_IME_COMPOSITION
  • WM_IME_ENDCOMPOSITION
  • WM_IME_NOTIFY
• Rendu
  • Indicateur de paramètres régionaux d’entrée
  • Fenêtre Composition
  • Fenêtres de lecture et candidates
• Limitations
• Informations du Registre
• Annexe A : Versions CHT par système d’exploitation
• Informations complémentaires
• GetReadingString
• ShowReadingWindow

Comportement IME par défaut

Les ÉMI mappent l’entrée du clavier à des composants phonétiques ou à d’autres éléments de langage spécifiques à une langue sélectionnée. Dans un scénario classique, l’utilisateur tape des clés qui représentent la prononciation d’un caractère complexe. Si l’IME reconnaît la prononciation comme valide, il présente à l’utilisateur une liste de mots ou d’expressions candidats à partir desquelles l’utilisateur peut sélectionner un choix final. Le mot choisi est ensuite envoyé à l’application par le biais d’une série de messages Microsoft Windows WM_CHAR . Étant donné que l’IME fonctionne à un niveau inférieur à l’application en interceptant l’entrée du clavier, la présence d’un IME est transparente pour l’application. Presque toutes les applications Windows peuvent facilement tirer parti des MI, sans avoir connaissance de leur existence et sans nécessiter de codage spécial.

Un IME classique affiche plusieurs fenêtres pour guider l’utilisateur dans l’entrée de caractères, comme illustré dans les exemples suivants.

Utilisation des MIs eses avec DXUT

Dans DXUT, la classe CDXUTIMEEditBox implémente la fonctionnalité IME. Cette classe est dérivée de la classe CDXUTEditBox, le contrôle d’édition de base fourni par l’infrastructure. CDXUTIMEEditBox étend ce contrôle d’édition pour prendre en charge les ITÉ en remplaçant les méthodes CDXUTIMEEditBox. Les classes sont conçues de cette façon pour aider les développeurs à apprendre ce qu’ils doivent tirer de l’infrastructure pour implémenter la prise en charge de l’IME dans leurs propres contrôles d’édition. Le reste de cette rubrique explique comment l’infrastructure, et CDXUTIMEEditBox en particulier, remplace un contrôle d’édition de base pour implémenter la fonctionnalité IME.

La plupart des variables spécifiques à l’IME dans CDXUTIMEEditBox sont déclarées comme statiques, car de nombreux états et mémoires tampons IME sont spécifiques au processus. Par instance, un processus n’a qu’une seule mémoire tampon pour la chaîne de composition. Même si le processus a dix contrôles d’édition, ils partageront tous la même mémoire tampon de chaîne de composition. La mémoire tampon de chaîne de composition pour CDXUTIMEEditBox est donc statique, ce qui empêche l’application de prendre de l’espace mémoire inutile.

CDXUTIMEEditBox est implémenté dans le code DXUT suivant :

(racine du SDK)\Samples\C++\Common\DXUTgui.cpp

Substitution du comportement IME par défaut

Normalement, un IME utilise des procédures Windows standard pour créer une fenêtre (voir Utilisation de Windows). Dans des circonstances normales, cela produit des résultats satisfaisants. Toutefois, lorsque l’application se présente en mode plein écran, comme c’est le cas pour les jeux, les fenêtres standard ne fonctionnent plus et peuvent ne pas s’afficher au-dessus de l’application. Pour résoudre ce problème, l’application doit dessiner les fenêtres IME elle-même au lieu de s’appuyer sur Windows pour effectuer cette tâche.

Lorsque le comportement de création de fenêtre IME par défaut ne fournit pas ce dont une application a besoin, l’application peut remplacer la gestion des fenêtres IME. Une application peut y parvenir en traitant les messages liés à l’IME et en appelant l’API Input Method Manager (IMM).

Lorsqu’un utilisateur interagit avec un IME pour entrer des caractères complexes, l’imm envoie des messages à l’application pour la notifier d’événements importants, tels que le démarrage d’une composition ou l’affichage de la fenêtre candidate. Une application ignore généralement ces messages et les transmet au gestionnaire de messages par défaut, ce qui oblige l’IME à les gérer. Lorsque l’application, au lieu du gestionnaire par défaut, gère les messages, elle contrôle exactement ce qui se passe à chacun des événements IME. Souvent, le gestionnaire de messages récupère le contenu des différentes fenêtres IME en appelant l’API IMM. Une fois que l’application dispose de ces informations, elle peut dessiner correctement les fenêtres IME elle-même lorsqu’elle doit s’afficher sur l’affichage.

Fonctions

Un IME doit obtenir la chaîne de lecture, masquer la fenêtre de lecture et obtenir l’orientation de la fenêtre de lecture. Ce tableau présente les fonctionnalités par version IME :

Messages

Les messages suivants n’ont pas besoin d’être traités pour un IME plus récent qui implémente ShowReadingWindow().

Les messages suivants sont bloqués par le gestionnaire de messages d’application (c’est-à-dire qu’ils ne sont pas passés à DefWindowProc) pour empêcher la fenêtre de lecture de s’afficher.

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)

Exemples

Les exemples suivants illustrent comment obtenir des informations de chaîne de lecture à partir d’un IME plus ancien qui n’a pas GetReadingString(). Le code génère les sorties suivantes :

CHT IME version 4.2, 4.3 et 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 version 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 version 5.1, 5.2 et CHS IME version 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 version 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 version 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;

IME Messages

Une application en plein écran doit gérer correctement les messages liés à l’IME suivants :

WM_INPUTLANGCHANGE

L’imm envoie un message WM_INPUTLANGCHANGE à la fenêtre active d’une application après que les paramètres régionaux d’entrée ont été modifiés par l’utilisateur avec une combinaison de touches (généralement ALT+MAJ) ou avec l’indicateur de paramètres régionaux d’entrée dans la barre des tâches ou la barre de langue. La barre de langue est un contrôle à l’écran avec lequel l’utilisateur peut configurer un service de texte. (Voir Guide pratique pour afficher la barre de langue.) La capture d’écran suivante montre une liste de sélection de langue qui s’affiche lorsque l’utilisateur clique sur l’indicateur de paramètres régionaux.

Lorsque l’IMM envoie un message WM_INPUTLANGCHANGE, CDXUTIMEEditBox doit effectuer plusieurs tâches importantes :

1. La méthode GetKeyboardLayout est appelée pour renvoyer l’identificateur de paramètres régionaux d’entrée (ID) du thread d’application. La classe CDXUTIMEEditBox enregistre cet ID dans sa variable membre statique s_hklCurrent pour une utilisation ultérieure. Il est important que l’application connaisse les paramètres régionaux d’entrée actuels, car l’IME de chaque langue a son propre comportement distinct. Le développeur peut avoir besoin de fournir un code différent pour différents paramètres régionaux d’entrée.
2. CDXUTIMEEditBox initialise une chaîne à afficher dans l’indicateur de langue de la zone d’édition. Cet indicateur peut afficher la langue d’entrée active lorsque l’application s’exécute en mode plein écran et que ni la barre des tâches ni la barre de langue ne sont visibles.
3. La méthode ImmGetConversionStatus est appelée pour indiquer si les paramètres régionaux d’entrée sont en mode de conversion natif ou non natif. Le mode de conversion natif permet à l’utilisateur d’entrer du texte dans la langue choisie. Le mode de conversion non natif fait du clavier un clavier standard en anglais. Il est important de donner à l’utilisateur un repère visuel sur le type de mode de conversion dans lequel se trouve l’IME, afin que l’utilisateur puisse facilement savoir à quoi s’attendre les caractères lorsqu’il touche une touche. CDXUTIMEEditBox fournit ce repère visuel avec une couleur d’indicateur de langage. Lorsque les paramètres régionaux d’entrée utilisent un IME en mode de conversion natif, la classe CDXUTIMEEditBox dessine le texte de l’indicateur avec la couleur définie par le paramètre m_IndicatorImeColor. Lorsque l’IME est en mode de conversion non natif ou qu’aucun IME n’est utilisé, la classe dessine le texte de l’indicateur avec la couleur définie par le paramètre m_IndicatorEngColor.
4. CDXUTIMEEditBox vérifie les paramètres régionaux d’entrée et définit la variable membre statique s_bInsertOnType sur TRUE pour le coréen et FALSE pour toutes les autres langues. Cet indicateur est requis en raison des différents comportements des MIsuxux coréens et de tous les autres MIux.es. Lors de la saisie de caractères dans des langues autres que le coréen, le texte entré par l’utilisateur s’affiche dans la fenêtre de composition et l’utilisateur peut modifier librement le contenu de la chaîne de composition. L’utilisateur appuie sur la touche ENTRÉE lorsqu’il est satisfait de la chaîne de composition, et la chaîne de composition est envoyée à l’application sous la forme d’une série de messages WM_CHAR. Toutefois, dans les MIsesux coréens, lorsqu’un utilisateur appuie sur une touche pour entrer du texte, un caractère est immédiatement envoyé à l’application. Lorsque l’utilisateur appuie ensuite sur d’autres touches pour modifier ce caractère initial, le caractère de la zone d’édition change pour refléter les entrées supplémentaires de l’utilisateur. Essentiellement, l’utilisateur compose des caractères dans la zone d’édition. Ces deux comportements sont suffisamment différents pour que CDXUTIMEEditBox doit coder pour chacun d’eux spécifiquement.
5. La méthode membre statique SetupImeApi est appelée pour récupérer les adresses de deux fonctions à partir du module IME : GetReadingString et ShowReadingWindow. Si ces fonctions existent, ShowReadingWindow est appelé pour masquer la fenêtre de lecture par défaut pour cet IME. Étant donné que l’application affiche la fenêtre de lecture elle-même, elle avertit l’IME de désactiver le dessin de la fenêtre de lecture par défaut afin qu’elle n’interfère pas avec le rendu en plein écran.

L’IMM envoie un message WM_IME_SETCONTEXT lorsqu’une fenêtre de l’application est activée. Le paramètre lParam de ce message contient un indicateur qui indique à l’IME quelles fenêtres doivent être dessinées et celles qui ne doivent pas être dessinées. Étant donné que l’application gère l’ensemble du dessin, elle n’a pas besoin de l’IME pour dessiner les fenêtres IME. Par conséquent, le gestionnaire de messages de l’application définit simplement lParam sur 0 et retourne.

Pour que les applications prennent en charge l’IME, un traitement spécial est nécessaire pour le WM_IME_SETCONTEXT de message lié à l’IME. Étant donné que Windows envoie généralement ce message à l’application avant d’appeler la méthode PanoramaInitialize(), Panorama n’a pas la possibilité de traiter l’interface utilisateur pour afficher les fenêtres de liste de candidats.

L’extrait de code suivant spécifie aux applications Windows de ne pas afficher d’interface utilisateur associée à la fenêtre de liste candidate, ce qui permet à Panorama de gérer spécifiquement cette interface utilisateur.

case WM_IME_SETCONTEXT:
         lParam = 0;
    lRet = DefWindowProc(hWnd, msg, wParam, lParam);
    break;
    //... more message processing
    return lRet;

WM_IME_STARTCOMPOSITION

L’imm envoie un message WM_IME_STARTCOMPOSITION à l’application lorsqu’une composition IME est sur le point de commencer à la suite de frappes de l’utilisateur. Si l’IME utilise la fenêtre de composition, il affiche la chaîne de composition actuelle dans une fenêtre de composition. CDXUTIMEEditBox gère ce message en effectuant deux tâches :

1. CDXUTIMEEditBox efface la mémoire tampon de chaîne de composition et la mémoire tampon d’attribut. Ces mémoires tampons sont des membres statiques de CDXUTIMEEditBox.
2. CDXUTIMEEditBox définit la s_bHideCaret variable membre statique sur TRUE. Ce membre, défini dans la classe CDXUTEditBox de base, contrôle si le curseur dans la zone d’édition doit être dessiné lorsque la zone d’édition est affichée. La fenêtre de composition fonctionne de la même façon qu’une zone d’édition avec du texte et un curseur. Pour éviter toute confusion lorsque la fenêtre de composition est visible, la zone d’édition masque son curseur afin qu’un seul curseur soit visible à la fois.

WM_IME_COMPOSITION

L’imm envoie un message WM_IME_COMPOSITION à l’application lorsque l’utilisateur entre une frappe pour modifier la chaîne de composition. La valeur de lParam indique le type d’informations que l’application peut récupérer à partir du Gestionnaire de méthode d’entrée (IMM). L’application doit récupérer les informations disponibles en appelant ImmGetCompositionString , puis enregistrer les informations dans sa mémoire tampon privée afin qu’elle puisse afficher les éléments IME ultérieurement.

CDXUTIMEEditBox recherche et récupère les données de chaîne de composition suivantes :

WM_IME_ENDCOMPOSITION

L’imm envoie un message WM_IME_ENDCOMPOSITION à l’application lorsque l’opération de composition IME se termine. Cela peut se produire lorsque l’utilisateur appuie sur la touche ENTRÉE pour approuver la chaîne de composition ou sur la touche ÉCHAP pour annuler la composition. CDXUTIMEEditBox gère ce message en définissant la mémoire tampon de chaîne de composition sur vide. Il définit ensuite s_bHideCaret sur FALSE, car la fenêtre de composition est fermée et le curseur dans la zone d’édition doit être à nouveau visible.

Le gestionnaire de messages CDXUTIMEEditBox définit également s_bShowReadingWindow sur FALSE. Cet indicateur détermine si la classe dessine la fenêtre de lecture lorsque la zone d’édition s’affiche. Elle doit donc avoir la valeur FALSE à la fin d’une composition.

WM_IME_NOTIFY

L’imm envoie un message WM_IME_NOTIFY à l’application chaque fois qu’une fenêtre IME change. Une application qui gère le dessin des fenêtres IME doit traiter ce message afin qu’elle soit informée de toute mise à jour du contenu de la fenêtre. WParam indique la commande ou la modification en cours. CDXUTIMEEditBox gère les commandes suivantes :

Rendu

Le rendu des éléments et des fenêtres IME est simple. CDXUTIMEEditBox permet à la classe de base de s’afficher en premier, car les fenêtres IME doivent apparaître au-dessus du contrôle d’édition. Une fois la zone d’édition de base affichée, CDXUTIMEEditBox vérifie l’indicateur de visibilité de chaque fenêtre IME (indicateur, composition, candidat et fenêtre de lecture) et dessine la fenêtre si elle doit être visible. Pour obtenir des descriptions des différents types de fenêtres IME, consultez Comportement IME par défaut.

Indicateur de paramètres régionaux d’entrée

L’indicateur de paramètres régionaux d’entrée est affiché avant toutes les autres fenêtres IME, car il s’agit d’un élément qui est toujours affiché. Elle doit donc apparaître sous les autres fenêtres IME. CDXUTIMEEditBox affiche l’indicateur en appelant la méthode RenderIndicator, dans laquelle la couleur de police de l’indicateur est déterminée en examinant la variable statique s_ImeState, qui reflète le mode de conversion IME actuel. Lorsque l’IME est activé et que la conversion native est active, la méthode utilise m_IndicatorImeColor comme couleur d’indicateur. Si l’IME est désactivé ou est en mode de conversion non natif, m_IndicatorImeColor est utilisé pour dessiner le texte de l’indicateur. Par défaut, la fenêtre d’indicateur elle-même est dessinée à droite de la zone d’édition. Les applications peuvent modifier ce comportement en remplaçant la méthode RenderIndicator.

La figure suivante montre les différentes apparences d’un indicateur de paramètres régionaux d’entrée pour l’anglais, le japonais en mode de conversion alphanumérique et le japonais en mode de conversion natif :

Fenêtre Composition

Le dessin de la fenêtre de composition est géré dans la méthode RenderComposition de CDXUTIMEEditBox. La fenêtre de composition flotte au-dessus de la zone d’édition. Il doit être dessiné à la position du curseur du contrôle d’édition sous-jacent. CDXUTIMEEditBox gère le rendu comme suit :

1. La chaîne de composition entière est dessinée à l’aide des couleurs de chaîne de composition par défaut.
2. Les caractères avec certains attributs spéciaux doivent être dessinés dans des couleurs différentes. CDXUTIMEEditBox passe donc en revue les caractères de la chaîne de composition et inspecte l’attribut string. Si l’attribut appelle pour différentes couleurs, le caractère est dessiné à nouveau avec les couleurs appropriées.
3. Le curseur de la fenêtre de composition est dessiné pour terminer le rendu.

Le curseur doit clignoter pour les MI coréens, mais pas pour les autres MI.es. RenderComposition détermine si le curseur doit être visible en fonction des valeurs du minuteur lorsque l’IME coréen est utilisé.

Fenêtres de lecture et candidates

Les fenêtres de lecture et candidates sont rendues par la même méthode CDXUTIMEEditBox, RenderCandidateReadingWindow. Les deux fenêtres contiennent un tableau de chaînes pour la disposition verticale, ou une seule chaîne dans le cas d’une disposition horizontale. La majeure partie du code dans RenderCandidateReadingWindow est utilisée pour positionner la fenêtre afin qu’aucune partie de la fenêtre ne soit en dehors de la fenêtre d’application et soit coupée.

Limites

Les ITÉ contiennent parfois des fonctionnalités avancées pour améliorer la facilité d’entrée de texte. Certaines des fonctionnalités trouvées dans les MI plus récents sont illustrées dans les illustrations suivantes. Ces fonctionnalités avancées ne sont pas présentes dans DXUT. L’implémentation de la prise en charge de ces fonctionnalités avancées peut être difficile, car aucune interface n’est définie pour obtenir les informations nécessaires à partir des MI.es.

Advanced Traditional Chinese IME avec une liste de candidats étendue :

IME japonais avancé avec certaines entrées candidates qui contiennent du texte supplémentaire pour décrire leur signification :

IME coréen avancé qui inclut un système de reconnaissance de l’écriture manuscrite :

Informations du Registre

Les informations de Registre suivantes sont vérifiées pour déterminer l’orientation de la fenêtre de lecture, lorsque l’IME actuel est CHT New Phonetic plus ancien qui n’implémente pas GetReadingString().

Où : IME_Name est MSTCIPH si la version du fichier IME est 5.1 ou ultérieure ; sinon, IME_Name est TINTLGNT.

L’orientation de la fenêtre de lecture est horizontale si :

• L’IME est la version 5.0 et la valeur de mappage du clavier est 0x22 ou 0x23
• L’IME est la version 5.1 ou 5.2 et la valeur de mappage du clavier est 0x22, 0x23 ou 0x24.

Si aucune des conditions n’est remplie, la fenêtre de lecture est verticale.

Annexe A : Versions CHT par système d’exploitation

Informations complémentaires

Pour plus d'informations, reportez-vous aux procédures suivantes :

• Installation et utilisation des éditeurs de méthode d’entrée
• Affichage de texte international
• Le consortium Unicode
• Développement de logiciels internationaux. Dr. International. 2e édition. Redmond, WA: Microsoft Press, 2003.

GetReadingString

Obtient des informations de chaîne de lecture.

Paramètres

himc

[in] Contexte d’entrée.

uReadingBufLen

[in] Longueur de lpwReadingBuf, dans WCHAR. S’il est égal à zéro, cela signifie la longueur de la mémoire tampon de lecture de la requête.

lpwReadingBuf

[out] Retourne la chaîne de lecture (et non la fin zéro).

pnErrorIndex

[out] Retourne l’index du caractère d’erreur dans la chaîne de lecture, le cas échéant.

pfIsVertical

[out] Si elle a la valeur TRUE, la lecture de l’interface utilisateur est verticale. Sinon, puMaxReadingLen horizontal.

puMaxReadingLen

[out] Longueur de l’interface utilisateur de lecture. La longueur de lecture maximale n’est pas fixe ; cela dépend non seulement de la disposition du clavier, mais également du mode d’entrée (par exemple, code interne, entrée de substitution).

Valeurs retournées

Longueur de chaîne de lecture.

Remarques

Si la valeur de retour est supérieure à la valeur de uReadingBufLen, tous les paramètres de sortie ne sont pas définis.

Cette fonction est implémentée dans CHT IME 6.0 ou version ultérieure et peut être acquise par GetProcAddress sur un handle de module IME ; Le handle de module IME peut être acquis par ImmGetIMEFileName et LoadLibrary.

Configuration requise

En-tête

Déclaré dans Imm.h.

Importer la bibliothèque

Utilisez Imm.lib.

ShowReadingWindow

Afficher (ou masquer) la fenêtre de lecture.

Paramètres

himc

[in] Contexte d’entrée.

bShow

[in] Définissez sur TRUE pour afficher la fenêtre de lecture (ou FALSE pour la masquer).

Valeurs retournées

Remarques

Retourne TRUE en cas de réussite ou FALSE dans le cas contraire.

Configuration requise

En-tête

Déclaré dans Imm.h.

Importer la bibliothèque

Utilisez Imm.lib.