Partager via

Utilisation des boîtes de dialogue courantes

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

Choix d’une couleur

Cette rubrique décrit un 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 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 un 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. Cela définit l’indicateur CF_EFFECTS pour afficher les contrôles qui permettent à l’utilisateur de sélectionner des options telles que le barré, le souligné et les couleurs.

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 de texte pour le contexte de l’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

Remarque

À 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 Boîte de dialogue Élément commun au lieu de l’API Boîte de dialogue Fichier commun. Pour plus d’informations, consultez Boîte de dialogue Élément commun.

Cette rubrique décrit un 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 fichier que l’utilisateur peut sélectionner pour limiter les noms de fichiers affichés. La mémoire tampon contient un tableau de chaînes terminées 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 Indicateurs . Ces indicateurs font en sorte que la boîte de dialogue vérifie, avant de revenir, 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 le chemin d’accès et le nom de fichier spécifiés existent. Dans ce cas, la mémoire tampon pointée 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éfinit pas l’indicateur OFN_EXPLORER , il affiche toujours la boîte de dialogue Ouvrir du style Explorateur par défaut. Toutefois, si vous souhaitez fournir une procédure de hook ou un modèle personnalisé et que vous souhaitez utiliser l’interface utilisateur de l’Explorateur, vous devez définir l’indicateur OFN_EXPLORER .

Remarque

Dans le langage de programmation C, une chaîne 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 un exemple de code qui affiche une boîte de dialogue Imprimer afin qu’un utilisateur puisse sélectionner des 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 définit le drapeau PD_RETURNDC dans le membre Flags de la structure PRINTDLG. Cela provoque le retour par PrintDlg d’un handle de contexte d’appareil vers l’imprimante sélectionnée dans le membre hDC. Vous pouvez utiliser le handle pour afficher 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 les 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 d'impression

Cette rubrique décrit un exemple de code qui affiche une feuille de propriétés Imprimer afin qu’un utilisateur puisse sélectionner des 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. Ainsi, la fonction PrintDlgEx retourne un handle de contexte de périphérique pour 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 les 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 un 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, comme le type de papier, la source de papier, l’orientation de 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 retourner des handles aux structures DEVNAMES contenant l’entrée utilisateur et les informations sur l’imprimante. Vous pouvez utiliser ces informations pour préparer la sortie à envoyer à l’imprimante sélectionnée.

L’exemple suivant permet également à une procédure de hook PagePaintHook de 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 hook PagePaintHook qui dessine le rectangle de marge dans l’exemple de zone de page :

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 de pouvoir 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 utilisateur sur les boutons Remplacer et Remplacer tous .

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

  1. Obtenez un identificateur de message pour le message inscrit FINDMSGSTRING .
  2. Affichez la boîte de dialogue.
  3. 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 principale 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 clavier.

Pour surveiller les messages envoyés à partir de la boîte de dialogue, votre procédure de fenêtre doit vérifier le message inscrit FINDMSGSTRING et traiter les valeurs passées 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; 
}
  • Last updated on