MFC Dialogs: Building Interactive User Interfaces

A comprehensive guide to creating and managing dialog boxes in your MFC applications.

Dialog boxes are fundamental to providing user interaction in Windows desktop applications. Microsoft Foundation Classes (MFC) offers robust support for creating and managing dialogs, enabling you to easily build sophisticated user interfaces.

Types of Dialogs in MFC

MFC primarily supports two types of dialogs:

Modal Dialogs: These dialogs require the user to interact with them and close them before they can return to the parent window. They are used for tasks that demand immediate attention or input.
Modeless Dialogs: These dialogs allow the user to switch between the dialog and the parent window without closing the dialog. They are useful for tasks that can be performed in the background or for providing persistent controls.

Creating a Dialog Resource

Dialogs are typically created using the Visual Studio resource editor:

Open your MFC project in Visual Studio.
Navigate to the Resource View.
Right-click on Dialog and select Insert Dialog.
Use the toolbox to drag and drop controls (buttons, edit boxes, checkboxes, etc.) onto the dialog template.
Double-click on each control to set its properties, including its ID.

Creating a Dialog Class

After defining the dialog resource, you need to create a corresponding C++ class:

In Resource View, right-click on your newly created dialog resource.
Select Add Class....
Choose MFC Class and click Next.
Enter a class name (e.g., CMyCustomDialog). The base class should be CDialog or CDialogEx.
Click Finish.

This will generate a header (.h) and an implementation (.cpp) file for your dialog class.

Displaying a Modal Dialog

To display a modal dialog, you typically instantiate your dialog class and call its DoModal() method. This method returns an integer value indicating how the dialog was closed (e.g., IDOK or IDCANCEL).

Example: Displaying a Modal Dialog

                
// In your main frame or document class where you want to show the dialog
#include "MyCustomDialog.h" // Include your dialog header

void CMyMainFrame::OnShowMyDialog()
{
    CMyCustomDialog dialog; // Create an instance of your dialog class
    INT_PTR nResponse = dialog.DoModal(); // Show the dialog modally

    if (nResponse == IDOK)
    {
        // User clicked OK. Process the data entered in the dialog.
        // You can access member variables of the dialog class here.
        CString enteredText = dialog.m_editBoxContent;
        MessageBox(_T("User entered: ") + enteredText, _T("Dialog Result"));
    }
    else if (nResponse == IDCANCEL)
    {
        // User clicked Cancel.
    }
}
                
            

Displaying a Modeless Dialog

Modeless dialogs are created using the Create() method instead of DoModal(). After creation, you need to manage its lifecycle, often by handling its destruction and ensuring it doesn't interfere with the main application message loop.

Example: Displaying a Modeless Dialog

                
// In your main frame or document class
#include "MyCustomDialog.h" // Include your dialog header

CMyCustomDialog* pMyModelessDialog = nullptr; // Pointer to the dialog

void CMyMainFrame::OnShowModelessDialog()
{
    if (pMyModelessDialog == nullptr || !pMyModelessDialog->m_hWnd)
    {
        pMyModelessDialog = new CMyCustomDialog();
        // The second parameter is the parent window. NULL means it's a top-level window.
        // The third parameter is the dialog resource ID.
        if (!pMyModelessDialog->Create(IDD_MY_CUSTOM_DIALOG, this))
        {
            TRACE0("Failed to create modeless dialog!\n");
            delete pMyModelessDialog;
            pMyModelessDialog = nullptr;
            return;
        }
    }
    pMyModelessDialog->ShowWindow(SW_SHOW);
    pMyModelessDialog->SetForegroundWindow(); // Bring it to the front
}

// You might also need to handle the dialog's destruction
// For example, in your CWinApp derived class or main frame
void CMyMainFrame::OnDestroy()
{
    // Clean up the modeless dialog if it's still alive
    if (pMyModelessDialog != nullptr && pMyModelessDialog->m_hWnd)
    {
        pMyModelessDialog->DestroyWindow();
        delete pMyModelessDialog;
        pMyModelessDialog = nullptr;
    }
    CFrameWnd::OnDestroy();
}
                
            

Data Exchange (DDX) and Validation (DDV)

MFC's Dialog Data Exchange (DDX) and Dialog Data Validation (DDV) mechanisms simplify the process of transferring data between dialog controls and your dialog class's member variables. These are implemented within the DoDataExchange() method.

DDX automatically gets data from controls into variables or sets control values from variables.

DDV allows you to validate the data entered by the user.

Example: DDX/DDV Implementation

                
// In MyCustomDialog.cpp

void CMyCustomDialog::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CMyCustomDialog)
    DDX_Text(pDX, IDC_EDIT_MY_TEXT, m_editBoxContent); // Maps IDC_EDIT_MY_TEXT to m_editBoxContent
    DDX_Text(pDX, IDC_EDIT_MY_NUMBER, m_numberValue);   // Maps IDC_EDIT_MY_NUMBER to m_numberValue

    // DDV_MinMaxInt(pDX, m_numberValue, 0, 100); // Example validation for m_numberValue
    // DDV_MaxChars(pDX, m_editBoxContent, 50); // Example validation for m_editBoxContent
    //}}AFX_DATA_MAP
}
                
            

You need to declare the member variables (e.g., CString m_editBoxContent;, int m_numberValue;) in your dialog class's header file.

Dialog Message Handling

You can handle messages sent to your dialog, such as button clicks, using message maps, similar to other MFC windows.

Example: Handling Button Clicks

                
// In MyCustomDialog.h
// ...
public:
    // Generated message map functions
    //{{AFX_MSG(CMyCustomDialog)
    virtual BOOL OnInitDialog(); // For initialization
    afx_msg void OnClickedButtonOk(); // Handler for OK button
    afx_msg void OnClickedButtonCancel(); // Handler for Cancel button
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()

    // Member variables for DDX
public:
    CString m_editBoxContent;
    int m_numberValue;
// ...

// In MyCustomDialog.cpp
BEGIN_MESSAGE_MAP(CMyCustomDialog, CDialogEx)
    //{{AFX_MSG_MAP(CMyCustomDialog)
    ON_COMMAND(IDOK, OnClickedButtonOk) // Map IDOK command to handler
    ON_COMMAND(IDCANCEL, OnClickedButtonCancel) // Map IDCANCEL command to handler
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

BOOL CMyCustomDialog::OnInitDialog()
{
    CDialogEx::OnInitDialog();
    // Initialize controls here
    // For example, load default values into edit boxes
    m_editBoxContent = _T("Default Text");
    m_numberValue = 50;
    UpdateData(FALSE); // Update controls with member variable values
    return TRUE; // Return TRUE if you want to set focus to a control
}

void CMyCustomDialog::OnClickedButtonOk()
{
    UpdateData(TRUE); // Get data from controls into member variables (runs DDX/DDV)
    if (ValidateData()) // Custom validation function
    {
        EndDialog(IDOK); // Close the dialog with IDOK
    }
}

void CMyCustomDialog::OnClickedButtonCancel()
{
    EndDialog(IDCANCEL); // Close the dialog with IDCANCEL
}

BOOL CMyCustomDialog::ValidateData()
{
    // Implement your custom validation logic here
    if (m_numberValue < 10) {
        MessageBox(_T("Number must be at least 10."), _T("Validation Error"), MB_ICONERROR);
        GetDlgItem(IDC_EDIT_MY_NUMBER)->SetFocus();
        return FALSE;
    }
    return TRUE;
}
                
            

Tip: Use the Class Wizard (or the context menu in Visual Studio's code editor) to automatically generate message handlers for controls like buttons.

Conclusion

Mastering MFC dialogs is crucial for building effective and user-friendly Windows applications. By leveraging resource editors, dialog classes, DDX/DDV, and message handling, you can create dynamic and interactive interfaces with ease.