Utilisation des boîtes de dialogue courantes

Article
06/13/2023

Cette section décrit les tâches qui appellent des boîtes de dialogue courantes :

Choisir une couleur
Choix d’une police
Ouverture d’un fichier
Affichage de la boîte de dialogue Imprimer
Utilisation de la feuille de propriétés Print
Configuration de la page imprimée
Recherche de texte

Choisir une couleur

Cette rubrique décrit l’exemple de code qui affiche une boîte de dialogue Couleur afin qu’un utilisateur puisse sélectionner une couleur. L’exemple de code initialise d’abord une structure CHOOSECOLOR , puis appelle la fonction ChooseColor pour afficher la boîte de dialogue. Si la fonction retourne TRUE, indiquant que l’utilisateur a sélectionné une couleur, l’exemple de code utilise la couleur sélectionnée pour créer un nouveau pinceau uni.

Cet exemple utilise la structure CHOOSECOLOR pour initialiser la boîte de dialogue comme suit :

Initialise le membre lpCustColors avec un pointeur vers un tableau statique de valeurs. Les couleurs du tableau sont initialement noires, mais le tableau statique conserve les couleurs personnalisées créées par l’utilisateur pour les appels ChooseColor suivants.
Définit l’indicateur CC_RGBINIT et initialise le membre rgbResult pour spécifier la couleur initialement sélectionnée lorsque la boîte de dialogue s’ouvre. Si elle n’est pas spécifiée, la sélection initiale est noire. L’exemple utilise la variable statique rgbCurrent pour conserver la valeur sélectionnée entre les appels à ChooseColor.
Définit l’indicateur CC_FULLOPEN afin que l’extension de couleurs personnalisées de la boîte de dialogue soit toujours affichée.

CHOOSECOLOR cc;                 // common dialog box structure 
static COLORREF acrCustClr[16]; // array of custom colors 
HWND hwnd;                      // owner window
HBRUSH hbrush;                  // brush handle
static DWORD rgbCurrent;        // initial color selection

// Initialize CHOOSECOLOR 
ZeroMemory(&cc, sizeof(cc));
cc.lStructSize = sizeof(cc);
cc.hwndOwner = hwnd;
cc.lpCustColors = (LPDWORD) acrCustClr;
cc.rgbResult = rgbCurrent;
cc.Flags = CC_FULLOPEN | CC_RGBINIT;
 
if (ChooseColor(&cc)==TRUE) 
{
    hbrush = CreateSolidBrush(cc.rgbResult);
    rgbCurrent = cc.rgbResult; 
}

Choix d’une police

Cette rubrique décrit l’exemple de code qui affiche une boîte de dialogue Police afin qu’un utilisateur puisse choisir les attributs d’une police. L’exemple de code initialise d’abord une structure CHOOSEFONT , puis appelle la fonction ChooseFont pour afficher la boîte de dialogue.

Cet exemple montre comment définir l’indicateur CF_SCREENFONTS pour spécifier que la boîte de dialogue doit afficher uniquement les polices d’écran. Il définit l’indicateur CF_EFFECTS pour afficher les contrôles qui permettent à l’utilisateur de sélectionner des options de barré, de soulignement et de couleur.

Si ChooseFont retourne TRUE, indiquant que l’utilisateur a cliqué sur le bouton OK , la structure CHOOSEFONT contient des informations qui décrivent les attributs de police et de police sélectionnés par l’utilisateur, y compris les membres de la structure LOGFONT pointées par le membre lpLogFont . Le membre rgbColors contient la couleur de texte sélectionnée. L’exemple de code utilise ces informations pour définir la police et la couleur du texte pour le contexte d’appareil associé à la fenêtre propriétaire.

HWND hwnd;                // owner window
HDC hdc;                  // display device context of owner window

CHOOSEFONT cf;            // common dialog box structure
static LOGFONT lf;        // logical font structure
static DWORD rgbCurrent;  // current text color
HFONT hfont, hfontPrev;
DWORD rgbPrev;

// Initialize CHOOSEFONT
ZeroMemory(&cf, sizeof(cf));
cf.lStructSize = sizeof (cf);
cf.hwndOwner = hwnd;
cf.lpLogFont = &lf;
cf.rgbColors = rgbCurrent;
cf.Flags = CF_SCREENFONTS | CF_EFFECTS;

if (ChooseFont(&cf)==TRUE)
{
    hfont = CreateFontIndirect(cf.lpLogFont);
    hfontPrev = SelectObject(hdc, hfont);
    rgbCurrent= cf.rgbColors;
    rgbPrev = SetTextColor(hdc, rgbCurrent);
 .
 .
 .
}

Ouverture d’un fichier

Notes

À compter de Windows Vista, la boîte de dialogue Fichier commun a été remplacée par la boîte de dialogue Élément commun lorsqu’elle est utilisée pour ouvrir un fichier. Nous vous recommandons d’utiliser l’API Common Item Dialog au lieu de l’API Common File Dialog. Pour plus d’informations, consultez Boîte de dialogue Élément commun.

Cette rubrique décrit l’exemple de code qui affiche une boîte de dialogue Ouvrir afin qu’un utilisateur puisse spécifier le lecteur, le répertoire et le nom d’un fichier à ouvrir. L’exemple de code initialise d’abord une structure OPENFILENAME , puis appelle la fonction GetOpenFileName pour afficher la boîte de dialogue.

Dans cet exemple, le membre lpstrFilter est un pointeur vers une mémoire tampon qui spécifie deux filtres de noms de fichiers que l’utilisateur peut sélectionner pour limiter les noms de fichiers affichés. La mémoire tampon contient un tableau de chaînes à double null dans lequel chaque paire de chaînes spécifie un filtre. Le membre nFilterIndex spécifie que le premier modèle est utilisé lors de la création de la boîte de dialogue.

Cet exemple montre comment définir les indicateurs OFN_PATHMUSTEXIST et OFN_FILEMUSTEXIST dans le membre Flags . Ces indicateurs permettent à la boîte de dialogue de vérifier, avant de retourner, que le chemin d’accès et le nom de fichier spécifiés par l’utilisateur existent réellement.

La fonction GetOpenFileName retourne TRUE si l’utilisateur clique sur le bouton OK et que le chemin d’accès et le nom de fichier spécifiés existent. Dans ce cas, la mémoire tampon pointée vers par le membre lpstrFile contient le chemin d’accès et le nom du fichier. L’exemple de code utilise ces informations dans un appel à la fonction pour ouvrir le fichier.

Bien que cet exemple ne définisse pas l’indicateur OFN_EXPLORER, il affiche toujours la boîte de dialogue Ouvrir de style Explorer par défaut. Toutefois, si vous souhaitez fournir une procédure de hook ou un modèle personnalisé et que vous souhaitez l’interface utilisateur Explorer, vous devez définir l’indicateur OFN_EXPLORER.

Notes

Dans le langage de programmation C, une chaîne placée entre guillemets est terminée par null.

OPENFILENAME ofn;       // common dialog box structure
char szFile[260];       // buffer for file name
HWND hwnd;              // owner window
HANDLE hf;              // file handle

// Initialize OPENFILENAME
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwnd;
ofn.lpstrFile = szFile;
// Set lpstrFile[0] to '\0' so that GetOpenFileName does not 
// use the contents of szFile to initialize itself.
ofn.lpstrFile[0] = '\0';
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = "All\0*.*\0Text\0*.TXT\0";
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

// Display the Open dialog box. 

if (GetOpenFileName(&ofn)==TRUE) 
    hf = CreateFile(ofn.lpstrFile, 
                    GENERIC_READ,
                    0,
                    (LPSECURITY_ATTRIBUTES) NULL,
                    OPEN_EXISTING,
                    FILE_ATTRIBUTE_NORMAL,
                    (HANDLE) NULL);

Affichage de la boîte de dialogue Imprimer

Cette rubrique décrit l’exemple de code qui affiche une boîte de dialogue Imprimer afin qu’un utilisateur puisse sélectionner les options d’impression d’un document. L’exemple de code initialise d’abord une structure PRINTDLG , puis appelle la fonction PrintDlg pour afficher la boîte de dialogue.

Cet exemple montre comment définir l’indicateur PD_RETURNDC dans le membre Flags de la structure PRINTDLG . PrintDlg retourne ainsi un handle de contexte d’appareil à l’imprimante sélectionnée dans le membre hDC. Vous pouvez utiliser le handle pour restituer la sortie sur l’imprimante.

Lors de l’entrée, l’exemple de code définit les membres hDevMode et hDevNames sur NULL. Si la fonction retourne TRUE, ces membres retournent des handles aux structures DEVNAMES qui contiennent l’entrée utilisateur et des informations sur l’imprimante. Vous pouvez utiliser ces informations pour préparer la sortie à envoyer à l’imprimante sélectionnée.

PRINTDLG pd;
HWND hwnd;

// Initialize PRINTDLG
ZeroMemory(&pd, sizeof(pd));
pd.lStructSize = sizeof(pd);
pd.hwndOwner   = hwnd;
pd.hDevMode    = NULL;     // Don't forget to free or store hDevMode.
pd.hDevNames   = NULL;     // Don't forget to free or store hDevNames.
pd.Flags       = PD_USEDEVMODECOPIESANDCOLLATE | PD_RETURNDC; 
pd.nCopies     = 1;
pd.nFromPage   = 0xFFFF; 
pd.nToPage     = 0xFFFF; 
pd.nMinPage    = 1; 
pd.nMaxPage    = 0xFFFF; 

if (PrintDlg(&pd)==TRUE) 
{
    // GDI calls to render output. 

    // Delete DC when done.
    DeleteDC(pd.hDC);
}

Utilisation de la feuille de propriétés Print

Cette rubrique décrit l’exemple de code qui affiche une feuille de propriétés Imprimer afin qu’un utilisateur puisse sélectionner les options d’impression d’un document. L’exemple de code initialise d’abord une structure PRINTDLGEX , puis appelle la fonction PrintDlgEx pour afficher la feuille de propriétés.

L’exemple de code définit l’indicateur PD_RETURNDC dans le membre Flags de la structure PRINTDLG . Cela entraîne la fonction PrintDlgEx à renvoyer un handle de contexte d’appareil à l’imprimante sélectionnée dans le membre hDC .

Lors de l’entrée, l’exemple de code définit les membres hDevMode et hDevNames sur NULL. Si la fonction retourne S_OK, ces membres retournent des handles aux structures DEVNAMES contenant l’entrée utilisateur et des informations sur l’imprimante. Vous pouvez utiliser ces informations pour préparer la sortie à envoyer à l’imprimante sélectionnée.

Une fois l’opération d’impression terminée, l’exemple de code libère les mémoires tampons DEVMODE, DEVNAMES et PRINTPAGERANGE et appelle la fonction DeleteDC pour supprimer le contexte de l’appareil.

// hWnd is the window that owns the property sheet.
HRESULT DisplayPrintPropertySheet(HWND hWnd)
{
    HRESULT hResult;
    PRINTDLGEX pdx = {0};
    LPPRINTPAGERANGE pPageRanges = NULL;

    // Allocate an array of PRINTPAGERANGE structures.
    pPageRanges = (LPPRINTPAGERANGE) GlobalAlloc(GPTR, 10 * sizeof(PRINTPAGERANGE));
    if (!pPageRanges)
        return E_OUTOFMEMORY;

    //  Initialize the PRINTDLGEX structure.
    pdx.lStructSize = sizeof(PRINTDLGEX);
    pdx.hwndOwner = hWnd;
    pdx.hDevMode = NULL;
    pdx.hDevNames = NULL;
    pdx.hDC = NULL;
    pdx.Flags = PD_RETURNDC | PD_COLLATE;
    pdx.Flags2 = 0;
    pdx.ExclusionFlags = 0;
    pdx.nPageRanges = 0;
    pdx.nMaxPageRanges = 10;
    pdx.lpPageRanges = pPageRanges;
    pdx.nMinPage = 1;
    pdx.nMaxPage = 1000;
    pdx.nCopies = 1;
    pdx.hInstance = 0;
    pdx.lpPrintTemplateName = NULL;
    pdx.lpCallback = NULL;
    pdx.nPropertyPages = 0;
    pdx.lphPropertyPages = NULL;
    pdx.nStartPage = START_PAGE_GENERAL;
    pdx.dwResultAction = 0;
    
    //  Invoke the Print property sheet.
    
    hResult = PrintDlgEx(&pdx);

    if ((hResult == S_OK) && pdx.dwResultAction == PD_RESULT_PRINT) 
    {
        // User clicked the Print button, so use the DC and other information returned in the 
        // PRINTDLGEX structure to print the document.
    }

    if (pdx.hDevMode != NULL) 
        GlobalFree(pdx.hDevMode); 
    if (pdx.hDevNames != NULL) 
        GlobalFree(pdx.hDevNames); 
    if (pdx.lpPageRanges != NULL)
        GlobalFree(pPageRanges);

    if (pdx.hDC != NULL) 
        DeleteDC(pdx.hDC);

    return hResult;
}

Configuration de la page imprimée

Cette rubrique décrit l’exemple de code qui affiche une boîte de dialogue Mise en page afin qu’un utilisateur puisse sélectionner les attributs de la page imprimée, tels que le type de papier, la source du papier, l’orientation de la page et les marges de page. L’exemple de code initialise d’abord une structure PAGESETUPDLG , puis appelle la fonction PageSetupDlg pour afficher la boîte de dialogue.

Cet exemple montre comment définir l’indicateur PSD_MARGINS dans le membre Flags et utiliser le membre rtMargin pour spécifier les valeurs de marge initiales. Il définit l’indicateur PSD_INTHOUSANDTHSOFINCHES pour s’assurer que la boîte de dialogue exprime les dimensions de marge en millièmes de pouce.

Lors de l’entrée, l’exemple de code définit les membres hDevMode et hDevNames sur NULL. Si la fonction retourne TRUE, la fonction utilise ces membres pour renvoyer des handles aux structures DEVNAMES contenant l’entrée utilisateur et des informations sur l’imprimante. Vous pouvez utiliser ces informations pour préparer la sortie à envoyer à l’imprimante sélectionnée.

L’exemple suivant active également une procédure de crochet PagePaintHook pour personnaliser le dessin du contenu de l’exemple de page.

PAGESETUPDLG psd;    // common dialog box structure
HWND hwnd;           // owner window

// Initialize PAGESETUPDLG
ZeroMemory(&psd, sizeof(psd));
psd.lStructSize = sizeof(psd);
psd.hwndOwner   = hwnd;
psd.hDevMode    = NULL; // Don't forget to free or store hDevMode.
psd.hDevNames   = NULL; // Don't forget to free or store hDevNames.
psd.Flags       = PSD_INTHOUSANDTHSOFINCHES | PSD_MARGINS | 
                  PSD_ENABLEPAGEPAINTHOOK; 
psd.rtMargin.top = 1000;
psd.rtMargin.left = 1250;
psd.rtMargin.right = 1250;
psd.rtMargin.bottom = 1000;
psd.lpfnPagePaintHook = PaintHook;

if (PageSetupDlg(&psd)==TRUE)
{
    // check paper size and margin values here.
}

L’exemple suivant montre un exemple de procédure de crochet PagePaintHook qui dessine le rectangle de marge dans la zone de page de l’exemple :

BOOL CALLBACK PaintHook(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) 
{ 
    LPRECT lprc; 
    COLORREF crMargRect; 
    HDC hdc, hdcOld; 
 
    switch (uMsg) 
    { 
        // Draw the margin rectangle. 
        case WM_PSD_MARGINRECT: 
            hdc = (HDC) wParam; 
            lprc = (LPRECT) lParam; 
 
            // Get the system highlight color. 
            crMargRect = GetSysColor(COLOR_HIGHLIGHT); 
 
            // Create a dash-dot pen of the system highlight color and 
            // select it into the DC of the sample page. 
            hdcOld = SelectObject(hdc, CreatePen(PS_DASHDOT, .5, crMargRect)); 
 
            // Draw the margin rectangle. 
            Rectangle(hdc, lprc->left, lprc->top, lprc->right, lprc->bottom); 
 
            // Restore the previous pen to the DC. 
            SelectObject(hdc, hdcOld); 
            return TRUE; 
 
        default: 
            return FALSE; 
    } 
    return TRUE; 
}

Recherche de texte

Cette rubrique décrit l’exemple de code qui affiche et gère une boîte de dialogue Rechercher afin que l’utilisateur puisse spécifier les paramètres d’une opération de recherche. La boîte de dialogue envoie des messages à la procédure de fenêtre afin que vous puissiez effectuer l’opération de recherche.

Le code d’affichage et de gestion d’une boîte de dialogue Remplacer est similaire, sauf qu’il utilise la fonction ReplaceText pour afficher la boîte de dialogue. La boîte de dialogue Remplacer envoie également des messages en réponse aux clics de l’utilisateur sur les boutons Remplacer et Remplacer tout .

Pour utiliser la boîte de dialogue Rechercher ou remplacer , vous devez effectuer trois tâches distinctes :

Obtenez un identificateur de message pour le message inscrit FINDMSGSTRING .
Affichez la boîte de dialogue.
Traitez les messages FINDMSGSTRING lorsque la boîte de dialogue est ouverte.

Lorsque vous initialisez votre application, appelez la fonction RegisterWindowMessage pour obtenir un identificateur de message pour le message inscrit FINDMSGSTRING .

UINT uFindReplaceMsg;  // message identifier for FINDMSGSTRING 

uFindReplaceMsg = RegisterWindowMessage(FINDMSGSTRING);

Pour afficher une boîte de dialogue Rechercher , initialisez d’abord une structure FINDREPLACE , puis appelez la fonction FindText . Notez que la structure FINDREPLACE et la mémoire tampon de la chaîne de recherche doivent être une variable globale ou statique afin qu’elle ne sorte pas de l’étendue avant la fermeture de la boîte de dialogue. Vous devez définir le membre hwndOwner pour spécifier la fenêtre qui reçoit les messages inscrits. Après avoir créé la boîte de dialogue, vous pouvez la déplacer ou la manipuler à l’aide du handle retourné.

FINDREPLACE fr;       // common dialog box structure
HWND hwnd;            // owner window
CHAR szFindWhat[80];  // buffer receiving string
HWND hdlg = NULL;     // handle to Find dialog box

// Initialize FINDREPLACE
ZeroMemory(&fr, sizeof(fr));
fr.lStructSize = sizeof(fr);
fr.hwndOwner = hwnd;
fr.lpstrFindWhat = szFindWhat;
fr.wFindWhatLen = 80;
fr.Flags = 0;

hdlg = FindText(&fr);

Lorsque la boîte de dialogue est ouverte, votre boucle de message main doit inclure un appel à la fonction IsDialogMessage. Passez un handle à la boîte de dialogue en tant que paramètre dans l’appel IsDialogMessage . Cela garantit que la boîte de dialogue traite correctement les messages du clavier.

Pour surveiller les messages envoyés à partir de la boîte de dialogue, votre procédure de fenêtre doit case activée pour le message inscrit FINDMSGSTRING et traiter les valeurs transmises dans la structure FINDREPLACE comme dans l’exemple suivant.

LPFINDREPLACE lpfr;

if (message == uFindReplaceMsg)
{ 
    // Get pointer to FINDREPLACE structure from lParam.
    lpfr = (LPFINDREPLACE)lParam;

    // If the FR_DIALOGTERM flag is set, 
    // invalidate the handle that identifies the dialog box. 
    if (lpfr->Flags & FR_DIALOGTERM)
    { 
        hdlg = NULL; 
        return 0; 
    } 

    // If the FR_FINDNEXT flag is set, 
    // call the application-defined search routine
    // to search for the requested string. 
    if (lpfr->Flags & FR_FINDNEXT) 
    {
        SearchFile(lpfr->lpstrFindWhat,
                   (BOOL) (lpfr->Flags & FR_DOWN), 
                   (BOOL) (lpfr->Flags & FR_MATCHCASE)); 
    }

    return 0; 
}

Partager via