à propos des boîtes de dialogue

  • Article

Il existe de nombreuses fonctions, messages et contrôles prédéfinis pour faciliter la création et la gestion des boîtes de dialogue, ce qui facilite le développement de l’interface utilisateur pour une application. Cette vue d’ensemble décrit les fonctions et les messages de boîte de dialogue et explique comment les utiliser pour créer et utiliser des boîtes de dialogue.

Cette vue d’ensemble comprend les rubriques suivantes :

Pour plus d’informations sur les boîtes de dialogue courantes, consultez Bibliothèque de boîtes de dialogue commune.

Quand utiliser une boîte de dialogue

La plupart des applications utilisent des boîtes de dialogue pour demander des informations supplémentaires pour les éléments de menu qui nécessitent une entrée utilisateur. L’utilisation d’une boîte de dialogue est le seul moyen recommandé pour une application de récupérer l’entrée. Par exemple, un élément de menu Ouvrir classique nécessite l’ouverture du nom d’un fichier. Par conséquent, une application doit utiliser une boîte de dialogue pour inviter l’utilisateur à entrer le nom. Dans ce cas, l’application crée la boîte de dialogue lorsque l’utilisateur clique sur l’élément de menu et détruit la boîte de dialogue immédiatement après que l’utilisateur a indiqué les informations.

De nombreuses applications utilisent également des boîtes de dialogue pour afficher des informations ou des options pendant que l’utilisateur travaille dans une autre fenêtre. Par exemple, les applications de traitement de texte utilisent souvent une boîte de dialogue avec une option de recherche de texte. Pendant que l’application recherche le texte, la boîte de dialogue reste à l’écran. L’utilisateur peut ensuite revenir à la boîte de dialogue et rechercher à nouveau le même mot . ou l’utilisateur peut modifier l’entrée dans la boîte de dialogue et rechercher un nouveau mot. Les applications qui utilisent des boîtes de dialogue de cette façon en créent généralement une lorsque l’utilisateur clique sur l’élément de menu et continuent à l’afficher tant que l’application s’exécute ou jusqu’à ce que l’utilisateur ferme explicitement la boîte de dialogue.

Pour prendre en charge les différentes façons dont les applications utilisent les boîtes de dialogue, il existe deux types de boîtes de dialogue : modale et sans mode. Une boîte de dialogue modale nécessite que l’utilisateur fournisse des informations ou annule la boîte de dialogue avant d’autoriser l’application à continuer. Les applications utilisent des boîtes de dialogue modales conjointement avec des éléments de menu qui nécessitent des informations supplémentaires avant de pouvoir continuer. Une boîte de dialogue sans mode permet à l’utilisateur de fournir des informations et de revenir à la tâche précédente sans fermer la boîte de dialogue. Les boîtes de dialogue modales sont plus simples à gérer que les boîtes de dialogue sans mode, car elles sont créées, exécutent leur tâche et sont détruites en appelant une seule fonction.

Pour créer une boîte de dialogue modale ou sans mode, une application doit fournir un modèle de boîte de dialogue pour décrire le style et le contenu de la boîte de dialogue ; l’application doit également fournir une procédure de boîte de dialogue pour effectuer des tâches. Le modèle de boîte de dialogue est une description binaire de la boîte de dialogue et des contrôles qu’elle contient. Le développeur peut créer ce modèle en tant que ressource à charger à partir du fichier exécutable de l’application ou en mémoire pendant l’exécution de l’application. La procédure de boîte de dialogue est une fonction de rappel définie par l’application que le système appelle lorsqu’il a une entrée pour la boîte de dialogue ou des tâches que la boîte de dialogue doit exécuter. Bien qu’une procédure de boîte de dialogue soit similaire à une procédure de fenêtre, elle n’a pas les mêmes responsabilités.

Une application crée généralement une boîte de dialogue à l’aide de la fonction DialogBox ou CreateDialog . DialogBox crée une boîte de dialogue modale ; CreateDialog crée une boîte de dialogue sans mode. Ces deux fonctions chargent un modèle de boîte de dialogue à partir du fichier exécutable de l’application et créent une fenêtre contextuelle qui correspond aux spécifications du modèle. D’autres fonctions créent une boîte de dialogue à l’aide de modèles en mémoire ; ils transmettent des informations supplémentaires à la procédure de boîte de dialogue lors de la création de la boîte de dialogue.

Les boîtes de dialogue appartiennent généralement à une classe de fenêtre exclusive prédéfinie. Le système utilise cette classe de fenêtre et sa procédure de fenêtre correspondante pour les boîtes de dialogue modales et sans mode. Lorsque la fonction est appelée, elle crée la fenêtre de la boîte de dialogue, ainsi que les fenêtres des contrôles de la boîte de dialogue, puis envoie les messages sélectionnés à la procédure de boîte de dialogue. Bien que la boîte de dialogue soit visible, la procédure de fenêtre prédéfinie gère tous les messages, en traitant certains messages et en transmettant d’autres à la procédure de boîte de dialogue afin que la procédure puisse effectuer des tâches. Les applications n’ont pas d’accès direct à la classe de fenêtre ou à la procédure de fenêtre prédéfinie, mais elles peuvent utiliser le modèle de boîte de dialogue et la procédure de boîte de dialogue pour modifier le style et le comportement d’une boîte de dialogue.

Fenêtre propriétaire de boîte de dialogue

La plupart des boîtes de dialogue ont une fenêtre propriétaire (ou plus simplement, un propriétaire). Lors de la création de la boîte de dialogue, l’application définit le propriétaire en spécifiant le handle de fenêtre du propriétaire. Le système utilise le propriétaire pour déterminer la position de la boîte de dialogue dans l’ordre Z afin que la boîte de dialogue soit toujours positionnée au-dessus de son propriétaire. En outre, le système peut envoyer des messages à la procédure de fenêtre du propriétaire, en l’informant des événements dans la boîte de dialogue.

Le système masque ou détruit automatiquement la boîte de dialogue chaque fois que son propriétaire est masqué ou détruit. Cela signifie que la procédure de boîte de dialogue ne nécessite aucun traitement spécial pour détecter les modifications apportées à l’état de la fenêtre propriétaire.

Étant donné que la boîte de dialogue classique est utilisée conjointement avec un élément de menu, la fenêtre propriétaire est généralement la fenêtre contenant le menu. Bien qu’il soit possible de créer une boîte de dialogue sans propriétaire, elle n’est pas recommandée. Par exemple, lorsqu’une boîte de dialogue modale n’a pas de propriétaire, le système ne désactive aucune des autres fenêtres de l’application et permet à l’utilisateur de continuer à travailler dans les autres fenêtres, ce qui va à l’inverse de l’objectif de la boîte de dialogue modale.

Lorsqu’une boîte de dialogue sans mode n’a pas de propriétaire, le système ne masque ni ne détruit la boîte de dialogue lorsque d’autres fenêtres de l’application sont masquées ou détruites. Bien que cela ne soit pas contraire à l’objectif de la boîte de dialogue sans mode, cela nécessite que l’application effectue un traitement spécial pour s’assurer que la boîte de dialogue est masquée et détruite aux moments appropriés.

Boîtes de message

Une boîte de message est une boîte de dialogue spéciale qu’une application peut utiliser pour afficher des messages et demander une entrée simple. Une zone de message contient généralement un message texte et un ou plusieurs boutons. Une application crée la zone de message à l’aide de la fonction MessageBox ou MessageBoxEx , en spécifiant le texte ainsi que le nombre et les types de boutons à afficher. Notez qu’il n’existe actuellement aucune différence entre le fonctionnement de MessageBox et messageBoxEx .

Bien que la boîte de message soit une boîte de dialogue, le système prend le contrôle total de la création et de la gestion de la boîte de message. Cela signifie que l’application ne fournit pas de modèle de boîte de dialogue et de procédure de boîte de dialogue. Le système crée son propre modèle en fonction du texte et des boutons spécifiés pour la boîte de message et fournit sa propre procédure de boîte de dialogue.

Une boîte de message est une boîte de dialogue modale que le système crée à l’aide des fonctions internes utilisées par DialogBox . Si l’application spécifie une fenêtre propriétaire lors de l’appel de MessageBox ou MessageBoxEx, le système désactive le propriétaire. Une application peut également demander au système de désactiver toutes les fenêtres de niveau supérieur appartenant au thread actif en spécifiant la valeur MB_TASKMODAL lors de la création de la boîte de dialogue.

Le système peut envoyer des messages au propriétaire, tels que WM_CANCELMODE et WM_ENABLE, comme il le fait lors de la création d’une boîte de dialogue modale. La fenêtre propriétaire doit effectuer toutes les actions demandées par ces messages.

Une boîte de dialogue modale doit être une fenêtre contextuelle avec un menu de fenêtre, une barre de titre et une bordure épaisse ; Autrement dit, le modèle de boîte de dialogue doit spécifier les styles WS_POPUP, WS_SYSMENU, WS_CAPTION et DS_MODALFRAME . Bien qu’une application puisse désigner le style WS_VISIBLE , le système affiche toujours une boîte de dialogue modale, que le modèle de boîte de dialogue spécifie ou non le style WS_VISIBLE . Une application ne doit pas créer de boîte de dialogue modale ayant le style WS_CHILD . Une boîte de dialogue modale avec ce style se désactive, empêchant toute entrée ultérieure d’atteindre l’application.

Une application crée une boîte de dialogue modale à l’aide de la fonction DialogBox ou DialogBoxIndirect . DialogBox nécessite le nom ou l’identificateur d’une ressource contenant un modèle de boîte de dialogue ; DialogBoxIndirect nécessite un handle pour un objet mémoire contenant un modèle de boîte de dialogue. Les fonctions DialogBoxParam et DialogBoxIndirectParam créent également des boîtes de dialogue modales ; elles sont identiques aux fonctions mentionnées précédemment, mais passent un paramètre spécifié à la procédure de boîte de dialogue lors de la création de la boîte de dialogue.

Lors de la création de la boîte de dialogue modale, le système en fait la fenêtre active. La boîte de dialogue reste active jusqu’à ce que la procédure de boîte de dialogue appelle la fonction EndDialog ou que le système active une fenêtre dans une autre application. Ni l’utilisateur ni l’application ne peuvent rendre la fenêtre propriétaire active tant que la boîte de dialogue modale n’est pas détruite.

Lorsque la fenêtre propriétaire n’est pas encore désactivée, le système désactive automatiquement la fenêtre et toutes les fenêtres enfants qui lui appartiennent lorsqu’il crée la boîte de dialogue modale. La fenêtre propriétaire reste désactivée jusqu’à ce que la boîte de dialogue soit détruite. Bien qu’une procédure de boîte de dialogue puisse potentiellement activer la fenêtre propriétaire à tout moment, l’activation du propriétaire contrevient à l’objectif de la boîte de dialogue modale et n’est pas recommandée. Lorsque la procédure de boîte de dialogue est détruite, le système active à nouveau la fenêtre propriétaire, mais uniquement si la boîte de dialogue modale a entraîné la désactivation du propriétaire.

Lorsque le système crée la boîte de dialogue modale, il envoie le message WM_CANCELMODE à la fenêtre (le cas échéant) qui capture actuellement l’entrée de la souris. Une application qui reçoit ce message doit libérer la capture de la souris afin que l’utilisateur puisse déplacer la souris dans la boîte de dialogue modale. Étant donné que le système désactive la fenêtre propriétaire, toutes les entrées de la souris sont perdues si le propriétaire ne parvient pas à relâcher la souris lors de la réception de ce message.

Pour traiter les messages de la boîte de dialogue modale, le système démarre sa propre boucle de messages, prenant le contrôle temporaire de la file d’attente des messages pour l’ensemble de l’application. Lorsque le système récupère un message qui n’est pas explicitement destiné à la boîte de dialogue, il distribue le message dans la fenêtre appropriée. S’il récupère un message WM_QUIT, il le publie dans la file d’attente des messages de l’application afin que la boucle de message main de l’application puisse éventuellement récupérer le message.

Le système envoie le message WM_ENTERIDLE à la fenêtre propriétaire chaque fois que la file d’attente de messages d’application est vide. L’application peut utiliser ce message pour effectuer une tâche en arrière-plan pendant que la boîte de dialogue reste à l’écran. Lorsqu’une application utilise le message de cette façon, l’application doit fréquemment donner le contrôle (par exemple, à l’aide de la fonction PeekMessage ) afin que la boîte de dialogue modale puisse recevoir n’importe quelle entrée utilisateur. Pour empêcher la boîte de dialogue modale d’envoyer les messages WM_ENTERIDLE , l’application peut spécifier le style DS_NOIDLEMSG lors de la création de la boîte de dialogue.

Une application détruit une boîte de dialogue modale à l’aide de la fonction EndDialog . Dans la plupart des cas, la procédure de boîte de dialogue appelle EndDialog lorsque l’utilisateur clique sur Fermer dans le menu de la fenêtre de la boîte de dialogue ou sur le bouton OK ou Annuler dans la boîte de dialogue. La boîte de dialogue peut retourner une valeur par le biais de la fonction DialogBox (ou d’autres fonctions de création) en spécifiant une valeur lors de l’appel de la fonction EndDialog . Le système retourne cette valeur après avoir détruit la boîte de dialogue. La plupart des applications utilisent cette valeur de retour pour déterminer si la boîte de dialogue a terminé sa tâche correctement ou a été annulée par l’utilisateur. Le système ne retourne pas le contrôle de la fonction qui crée la boîte de dialogue tant que la procédure de boîte de dialogue n’a pas appelé la fonction EndDialog .

Boîtes de dialogue sans mode

Une boîte de dialogue sans mode doit être une fenêtre contextuelle comportant un menu de fenêtre, une barre de titre et une bordure fine ; Autrement dit, le modèle de boîte de dialogue doit spécifier les styles WS_POPUP, WS_CAPTION, WS_BORDER et WS_SYSMENU . Le système n’affiche pas automatiquement la boîte de dialogue, sauf si le modèle spécifie le style WS_VISIBLE .

Une application crée une boîte de dialogue sans mode à l’aide de la fonction CreateDialog ou CreateDialogIndirect . CreateDialog nécessite le nom ou l’identificateur d’une ressource contenant un modèle de boîte de dialogue ; CreateDialogIndirect nécessite un handle pour un objet mémoire contenant un modèle de boîte de dialogue. Deux autres fonctions, CreateDialogParam et CreateDialogIndirectParam, créent également des boîtes de dialogue sans mode ; ils passent un paramètre spécifié à la procédure de boîte de dialogue lors de la création de la boîte de dialogue.

CreateDialog et d’autres fonctions de création retournent un handle de fenêtre à la boîte de dialogue. L’application et la procédure de boîte de dialogue peuvent utiliser ce handle pour gérer la boîte de dialogue. Par exemple, si WS_VISIBLE n’est pas spécifié dans le modèle de boîte de dialogue, l’application peut afficher la boîte de dialogue en passant le handle de fenêtre à la fonction ShowWindow .

Une boîte de dialogue sans mode ne désactive pas la fenêtre propriétaire ni n’envoie de messages à celle-ci. Lors de la création de la boîte de dialogue, le système en fait la fenêtre active, mais l’utilisateur ou l’application peut modifier la fenêtre active à tout moment. Si la boîte de dialogue devient inactive, elle reste au-dessus de la fenêtre propriétaire dans l’ordre Z, même si la fenêtre propriétaire est active.

L’application est responsable de la récupération et de la distribution des messages d’entrée dans la boîte de dialogue. La plupart des applications utilisent la boucle de message main pour cela. Toutefois, pour permettre à l’utilisateur de se déplacer vers et de sélectionner des contrôles à l’aide du clavier, l’application doit appeler la fonction IsDialogMessage . Pour plus d’informations sur cette fonction, consultez Interface clavier de boîte de dialogue.

Une boîte de dialogue sans mode ne peut pas retourner une valeur à l’application comme le fait une boîte de dialogue modale, mais la procédure de boîte de dialogue peut envoyer des informations à la fenêtre propriétaire à l’aide de la fonction SendMessage .

Une application doit détruire toutes les boîtes de dialogue sans mode avant de se terminer. Il peut détruire une boîte de dialogue sans mode à l’aide de la fonction DestroyWindow . Dans la plupart des cas, la procédure de boîte de dialogue appelle DestroyWindow en réponse à une entrée utilisateur, par exemple en cliquant sur le bouton Annuler . Si l’utilisateur ne ferme jamais la boîte de dialogue de cette façon, l’application doit appeler DestroyWindow.

DestroyWindow invalide le handle de fenêtre dans la boîte de dialogue, de sorte que tous les appels ultérieurs aux fonctions qui utilisent le handle retournent des valeurs d’erreur. Pour éviter les erreurs, la procédure de boîte de dialogue doit informer le propriétaire que la boîte de dialogue a été détruite. De nombreuses applications conservent une variable globale contenant le handle de la boîte de dialogue. Lorsque la procédure de boîte de dialogue détruit la boîte de dialogue, elle affecte également à la variable globale la valeur NULL, ce qui indique que la boîte de dialogue n’est plus valide.

La procédure de boîte de dialogue ne doit pas appeler la fonction EndDialog pour détruire une boîte de dialogue sans mode.

Modèles de boîte de dialogue

Un modèle de boîte de dialogue est des données binaires qui décrivent la boîte de dialogue, en définissant sa hauteur, sa largeur, son style et les contrôles qu’elle contient. Pour créer une boîte de dialogue, le système charge un modèle de boîte de dialogue à partir des ressources du fichier exécutable de l’application ou utilise le modèle qui lui a été transmis en mémoire globale par l’application. Dans les deux cas, l’application doit fournir un modèle lors de la création d’une boîte de dialogue.

Un développeur crée des ressources de modèle à l’aide d’un compilateur de ressources ou d’un éditeur de boîte de dialogue. Un compilateur de ressources convertit une description de texte en ressource binaire, et un éditeur de boîte de dialogue enregistre une boîte de dialogue construite de manière interactive en tant que ressource binaire.

Notes

Cette vue d’ensemble explique comment créer des ressources de modèle et les ajouter au fichier exécutable de l’application. Pour plus d’informations sur la création de ressources de modèle et leur ajout à un fichier exécutable, consultez la documentation fournie avec vos outils de développement d’applications.

 

Pour créer une boîte de dialogue sans utiliser de ressources de modèle, vous devez créer un modèle en mémoire et le transmettre à la fonction CreateDialogIndirectParam ou DialogBoxIndirectParam , ou à la macro CreateDialogIndirect ou DialogBoxIndirect .

Un modèle de boîte de dialogue en mémoire se compose d’un en-tête qui décrit la boîte de dialogue, suivi d’un ou plusieurs blocs de données supplémentaires qui décrivent chacun des contrôles de la boîte de dialogue. Le modèle peut utiliser le format standard ou le format étendu. Dans un modèle standard, l’en-tête est une structure DLGTEMPLATE suivie de tableaux de longueur variable supplémentaires ; et les données de chaque contrôle se composent d’une structure DLGITEMTEMPLATE suivie de tableaux de longueur variable supplémentaires. Dans un modèle de boîte de dialogue étendue, l’en-tête utilise le format DLGTEMPLATEEX et les définitions de contrôle utilisent le format DLGITEMTEMPLATEEX .

Vous pouvez créer un modèle de mémoire en allouant un objet mémoire globale et en le remplissant avec les définitions d’en-tête et de contrôle standard ou étendues. Un modèle de mémoire est identique dans la forme et le contenu à une ressource de modèle. De nombreuses applications qui utilisent des modèles de mémoire utilisent d’abord la fonction LoadResource pour charger une ressource de modèle en mémoire, puis modifient la ressource chargée pour créer un modèle de mémoire. Pour plus d’informations sur la création d’un modèle de boîte de dialogue en mémoire, consultez Modèles en mémoire.

Les sections suivantes décrivent les styles, les mesures et les autres valeurs utilisés dans un modèle de boîte de dialogue.

Styles de modèle de boîte de dialogue

Chaque modèle de boîte de dialogue spécifie une combinaison de valeurs de style qui définissent l’apparence et les fonctionnalités de la boîte de dialogue. Les valeurs de style peuvent être des styles de fenêtre, tels que WS_POPUP et WS_SYSMENU, et des styles de boîte de dialogue, tels que DS_MODALFRAME. Le nombre et le type de styles d’un modèle dépendent du type et de l’objectif de la boîte de dialogue. Pour obtenir la liste des valeurs, consultez Styles de boîte de dialogue.

Le système transmet tous les styles de fenêtre spécifiés dans le modèle à la fonction CreateWindowEx lors de la création de la boîte de dialogue. Le système peut passer un ou plusieurs styles étendus en fonction des styles de boîte de dialogue spécifiés. Par exemple, lorsque le modèle spécifie DS_MODALFRAME, le système utilise WS_EX_DLGMODALFRAME lors de la création de la boîte de dialogue.

La plupart des boîtes de dialogue sont des fenêtres contextuelles qui ont un menu de fenêtre et une barre de titre. Par conséquent, le modèle standard spécifie les styles WS_POPUP, WS_SYSMENU et WS_CAPTION . Le modèle spécifie également un style de bordure : WS_BORDER pour les boîtes de dialogue sans mode et DS_MODALFRAME pour les boîtes de dialogue modales. Un modèle peut spécifier un type de fenêtre autre que la fenêtre contextuelle (par exemple , WS_OVERLAPPED) s’il crée une fenêtre personnalisée au lieu d’une boîte de dialogue.

Le système affiche toujours une boîte de dialogue modale, que le style WS_VISIBLE soit spécifié ou non. Lorsque le modèle d’une boîte de dialogue sans mode spécifie le style WS_VISIBLE , le système affiche automatiquement la boîte de dialogue lors de sa création. Sinon, l’application est chargée d’afficher la boîte de dialogue à l’aide de la fonction ShowWindow .

Mesures de boîte de dialogue

Chaque modèle de boîte de dialogue contient des mesures qui spécifient la position, la largeur et la hauteur de la boîte de dialogue et des contrôles qu’elle contient. Ces mesures étant indépendantes de l’appareil, une application peut utiliser un seul modèle pour créer la même boîte de dialogue pour tous les types d’appareils d’affichage. Cela garantit qu’une boîte de dialogue aura les mêmes proportions et la même apparence sur tous les écrans, malgré des résolutions et des proportions différentes entre les écrans.

Les mesures d’un modèle de boîte de dialogue sont spécifiées dans les unités de modèle de dialogue. Pour convertir des mesures d’unités de modèle de boîte de dialogue en unités d’écran (pixels), utilisez la fonction MapDialogRect , qui prend en compte la police utilisée par la boîte de dialogue et convertit correctement un rectangle des unités de modèle de dialogue en pixels. Pour les boîtes de dialogue qui utilisent la police système, vous pouvez utiliser la fonction GetDialogBaseUnits pour effectuer vous-même les calculs de conversion, bien que l’utilisation de MapDialogRect soit plus simple.

Le modèle doit spécifier les coordonnées initiales du coin supérieur gauche de la boîte de dialogue. En règle générale, les coordonnées sont relatives au coin supérieur gauche de la zone cliente de la fenêtre propriétaire. Lorsque le modèle spécifie le style DS_ABSALIGN ou que la boîte de dialogue n’a pas de propriétaire, la position est relative à l’angle supérieur gauche de l’écran. Le système définit cette position initiale lors de la création de la boîte de dialogue, mais permet à une application d’ajuster la position avant d’afficher la boîte de dialogue. Par exemple, une application peut récupérer les dimensions de la fenêtre propriétaire, calculer une nouvelle position qui centre la boîte de dialogue dans la fenêtre propriétaire, puis définir la position à l’aide de la fonction SetWindowPos .

Le modèle doit spécifier une largeur et une hauteur de boîte de dialogue qui ne dépassent pas la largeur et la hauteur de l’écran et garantissent que tous les contrôles se trouvent dans la zone cliente de la boîte de dialogue. Bien que le système autorise une boîte de dialogue de n’importe quelle taille, en créer une trop petite ou trop grande peut empêcher l’utilisateur de fournir une entrée, ce qui va à l’encontre de l’objectif de la boîte de dialogue. De nombreuses applications utilisent plusieurs boîtes de dialogue lorsqu’il existe un grand nombre de contrôles. Dans ce cas, la boîte de dialogue initiale contient généralement un ou plusieurs boutons que l’utilisateur peut choisir d’afficher la boîte de dialogue suivante.

Contrôles de boîte de dialogue

Le modèle spécifie la position, la largeur, la hauteur, le style, l’identificateur et la classe de fenêtre pour chaque contrôle de la boîte de dialogue. Le système crée chaque contrôle en passant ces données à la fonction CreateWindowEx . Les contrôles sont créés dans l’ordre dans lequel ils sont spécifiés dans le modèle. Le modèle doit spécifier le nombre, le type et l’ordre appropriés des contrôles pour garantir que l’utilisateur peut entrer l’entrée nécessaire pour terminer la tâche associée à la boîte de dialogue.

Pour chaque contrôle, le modèle spécifie des valeurs de style qui définissent l’apparence et le fonctionnement du contrôle. Chaque contrôle est une fenêtre enfant et doit donc avoir le style WS_CHILD . Pour que le contrôle soit visible lorsque la boîte de dialogue s’affiche, chaque contrôle doit également avoir le style WS_VISIBLE . D’autres styles de fenêtre couramment utilisés sont WS_BORDER pour les contrôles qui ont des bordures facultatives, WS_DISABLED pour les contrôles qui doivent être désactivés lors de la création initiale de la boîte de dialogue, et WS_TABSTOP et WS_GROUP pour les contrôles accessibles à l’aide du clavier. Les styles WS_TABSTOP et WS_GROUP sont utilisés conjointement avec l’interface du clavier de boîte de dialogue décrite plus loin dans cette rubrique.

Le modèle peut également spécifier des styles de contrôle spécifiques à la classe de fenêtre du contrôle. Par exemple, un modèle qui spécifie un contrôle de bouton doit donner un style de contrôle de bouton tel que BS_PUSHBUTTON ou BS_CHECKBOX. Le système transmet les styles de contrôle à la procédure de fenêtre de contrôle via le message WM_CREATE , ce qui permet à la procédure d’adapter l’apparence et le fonctionnement du contrôle.

Le système convertit les coordonnées de position et les mesures de largeur et de hauteur des unités de base de boîte de dialogue en pixels, avant de les transmettre à CreateWindowEx. Lorsque le système crée un contrôle, il spécifie la boîte de dialogue comme fenêtre parente. Cela signifie que le système interprète toujours les coordonnées de position du contrôle comme des coordonnées clientes, par rapport au coin supérieur gauche de la zone cliente de la boîte de dialogue.

Le modèle spécifie la classe de fenêtre pour chaque contrôle. Une boîte de dialogue classique contient des contrôles appartenant aux classes de fenêtre de contrôle prédéfinies, telles que les classes de fenêtre de contrôle de bouton et de modification. Dans ce cas, le modèle spécifie les classes de fenêtre en fournissant les valeurs d’atome prédéfinies correspondantes pour les classes. Lorsqu’une boîte de dialogue contient un contrôle appartenant à une classe de fenêtre de contrôle personnalisée, le modèle donne le nom de cette classe de fenêtre inscrite ou la valeur atom actuellement associée au nom.

Chaque contrôle d’une boîte de dialogue doit avoir un identificateur unique pour le distinguer des autres contrôles. Les contrôles envoient des informations à la procédure de boîte de dialogue via WM_COMMAND messages. Les identificateurs de contrôle sont donc essentiels pour que la procédure détermine quel contrôle a envoyé un message spécifié. La seule exception à cette règle est les identificateurs de contrôle pour les contrôles statiques. Les contrôles statiques ne nécessitent pas d’identificateurs uniques, car ils n’envoient aucun WM_COMMAND messages.

Pour permettre à l’utilisateur de fermer la boîte de dialogue, le modèle doit spécifier au moins un bouton push et lui donner l’identificateur de contrôle IDCANCEL. Pour permettre à l’utilisateur de choisir entre terminer ou annuler la tâche associée à la boîte de dialogue, le modèle doit spécifier deux boutons push, étiquetés OK et Annuler, avec des identificateurs de contrôle IDOK et IDCANCEL, respectivement.

Un modèle spécifie également le texte facultatif et les données de création d’un contrôle. Le texte fournit généralement des étiquettes pour les contrôles de bouton ou spécifie le contenu initial d’un contrôle de texte statique. Les données de création sont un ou plusieurs octets de données que le système transmet à la procédure de fenêtre de contrôle lors de la création du contrôle. Les données de création sont utiles pour les contrôles qui nécessitent plus d’informations sur leur contenu initial ou leur style que celles spécifiées par d’autres données. Par exemple, une application peut utiliser les données de création pour définir le paramètre initial et la plage d’un contrôle de barre de défilement.

Menu de la fenêtre boîte de dialogue

Le système donne à une boîte de dialogue un menu de fenêtre lorsque le modèle spécifie le style WS_SYSMENU . Pour éviter toute entrée inappropriée, le système désactive automatiquement tous les éléments du menu, à l’exception de Déplacer et fermer. L’utilisateur peut cliquer sur Déplacer pour déplacer la boîte de dialogue. Lorsque l’utilisateur clique sur Fermer, le système envoie un WM_COMMAND message à la procédure de boîte de dialogue avec le paramètre wParam défini sur IDCANCEL. Il est identique au message envoyé par le bouton Annuler lorsque l’utilisateur clique dessus. L’action recommandée pour ce message consiste à fermer la boîte de dialogue et à annuler la tâche demandée.

Bien que les autres menus des boîtes de dialogue ne soient pas recommandés, un modèle de boîte de dialogue peut spécifier un menu en fournissant l’identificateur ou le nom d’une ressource de menu. Dans ce cas, le système charge la ressource et crée le menu de la boîte de dialogue. Les applications utilisent généralement des identificateurs de menu ou des noms dans les modèles lors de l’utilisation des modèles pour créer des fenêtres personnalisées plutôt que des boîtes de dialogue.

Polices de boîte de dialogue

Le système utilise la largeur de caractères moyenne de la police de boîte de dialogue pour calculer la position et les dimensions de la boîte de dialogue. Par défaut, le système dessine tout le texte d’une boîte de dialogue à l’aide de la police SYSTEM_FONT .

Pour spécifier une police pour une boîte de dialogue autre que la valeur par défaut, vous devez créer la boîte de dialogue à l’aide d’un modèle de boîte de dialogue. Dans une ressource de modèle, utilisez l’instruction FONT. Dans un modèle de boîte de dialogue, définissez le style DS_SETFONT ou DS_SHELLFONT et spécifiez une taille de point et un nom de police. Même si un modèle de boîte de dialogue spécifie une police de cette manière, le système utilise toujours la police système pour le titre de la boîte de dialogue et les menus de la boîte de dialogue.

Lorsque la boîte de dialogue a le style DS_SETFONT ou DS_SHELLFONT , le système envoie un message WM_SETFONT à la procédure de boîte de dialogue et à chaque contrôle lorsqu’il crée le contrôle. La procédure de boîte de dialogue est chargée d’enregistrer le handle de police passé avec le message WM_SETFONT et de sélectionner le handle dans le contexte de l’appareil d’affichage chaque fois qu’il écrit du texte dans la fenêtre. Les contrôles prédéfinis effectuent cette opération par défaut.

La police système peut varier d’une version à l’autre de Windows. Pour que votre application utilise la police système, quel que soit le système sur lequel elle s’exécute, utilisez DS_SHELLFONT avec la police MS Shell Dlg et utilisez la ressource DIALOGEX au lieu de la ressource DIALOG. Le système mappe cette police de façon à ce que votre boîte de dialogue utilise la police Tahoma. Notez que DS_SHELLFONT n’a aucun effet si la police de type n’est pas MS Shell Dlg.

Modèles en mémoire

Un modèle de boîte de dialogue en mémoire se compose d’un en-tête qui décrit la boîte de dialogue, suivi d’un ou plusieurs blocs de données supplémentaires qui décrivent chacun des contrôles de la boîte de dialogue. Le modèle peut utiliser le format standard ou le format étendu. Dans un modèle standard, l’en-tête est une structure DLGTEMPLATE suivie de tableaux de longueur variable supplémentaires. Les données de chaque contrôle se composent d’une structure DLGITEMTEMPLATE suivie de tableaux de longueur variable supplémentaires. Dans un modèle de boîte de dialogue étendu, l’en-tête utilise le format DLGTEMPLATEEX et les définitions de contrôle utilisent le format DLGITEMTEMPLATEEX .

Pour faire la distinction entre un modèle standard et un modèle étendu, case activée les 16 premiers bits d’un modèle de boîte de dialogue. Dans un modèle étendu, le premier MOT est 0xFFFF ; toute autre valeur indique un modèle standard.

Si vous créez un modèle de boîte de dialogue en mémoire, vous devez vous assurer que chacune des définitions de contrôle DLGITEMTEMPLATE ou DLGITEMTEMPLATEEX est alignée sur les limites DWORD . En outre, toutes les données de création qui suivent une définition de contrôle doivent être alignées sur une limite DWORD . Tous les autres tableaux de longueur variable d’un modèle de boîte de dialogue doivent être alignés sur les limites WORD .

En-tête de modèle

Dans les modèles standard et étendus pour les boîtes de dialogue, l’en-tête contient les informations générales suivantes :

  • Emplacement et dimensions de la boîte de dialogue
  • Styles de fenêtre et de boîte de dialogue pour la boîte de dialogue
  • Nombre de contrôles dans la boîte de dialogue. Cette valeur détermine le nombre de définitions de contrôle DLGITEMTEMPLATE ou DLGITEMTEMPLATEEX dans le modèle.
  • Ressource de menu facultative pour la boîte de dialogue. Le modèle peut indiquer que la boîte de dialogue n’a pas de menu, ou il peut spécifier une valeur ordinale ou une chaîne Unicode terminée par null qui identifie une ressource de menu dans un fichier exécutable.
  • Classe de fenêtre de la boîte de dialogue. Il peut s’agir soit de la classe de boîte de dialogue prédéfinie, soit d’une valeur ordinale ou d’une chaîne Unicode terminée par null qui identifie une classe de fenêtre inscrite.
  • Chaîne Unicode terminée par null qui spécifie le titre de la fenêtre de boîte de dialogue. Si la chaîne est vide, la barre de titre de la boîte de dialogue est vide. Si la boîte de dialogue n’a pas le style WS_CAPTION , le système définit le titre sur la chaîne spécifiée, mais ne l’affiche pas.
  • Si la boîte de dialogue a le style DS_SETFONT , l’en-tête spécifie la taille de point et le nom de police de la police à utiliser pour le texte dans la zone cliente et les contrôles de la boîte de dialogue.

Dans un modèle étendu, l’en-tête DLGTEMPLATEEX spécifie également les informations supplémentaires suivantes :

  • Identificateur de contexte d’aide de la fenêtre de boîte de dialogue lorsque le système envoie un message WM_HELP .
  • Si la boîte de dialogue a le style DS_SETFONT ou DS_SHELLFONT , l’en-tête spécifie le poids de la police et indique si la police est italique.

Définitions de contrôle

Après l’en-tête du modèle se trouve une ou plusieurs définitions de contrôle qui décrivent les contrôles de la boîte de dialogue. Dans les modèles standard et étendus, l’en-tête de boîte de dialogue a un membre qui indique le nombre de définitions de contrôle dans le modèle. Dans un modèle standard, chaque définition de contrôle se compose d’une structure DLGITEMTEMPLATE suivie de tableaux de longueur variable supplémentaires. Dans un modèle étendu, les définitions de contrôle utilisent le format DLGITEMTEMPLATEEX .

Dans les modèles standard et étendus, la définition de contrôle inclut les informations suivantes :

  • Emplacement et dimensions du contrôle.
  • Styles de fenêtre et de contrôle pour le contrôle.
  • Identificateur de contrôle.
  • Classe window du contrôle. Il peut s’agir de la valeur ordinale d’une classe système prédéfinie ou d’une chaîne Unicode terminée par null qui spécifie le nom d’une classe de fenêtre inscrite.
  • Chaîne Unicode terminée par null qui spécifie le texte initial du contrôle ou une valeur ordinale qui identifie une ressource, telle qu’une icône, dans un fichier exécutable.
  • Bloc facultatif de longueur variable de données de création. Lorsque le système crée le contrôle, il transmet un pointeur vers ces données dans le paramètre lParam du message WM_CREATE qu’il envoie au contrôle.

Dans un modèle étendu, la définition de contrôle spécifie également un identificateur de contexte d’aide pour le contrôle lorsque le système envoie un message WM_HELP .