How to use DialogBoxParam?

Question

I have a pre-made template resource dialog, and I want to use DialogBoxParam to display it, but I can't find any good examples over the internet. The dialog is a simple login dialog, so can someone explain how to build my lpDialogFunc and what to put in dwInitParam?

Answer 1

You've tagged this question as C++, but havn't specified any particular framework (such as ATL or MFC).

So, in the spirit of providing a c++ / OOP answer to the question, without using a framework, the first thing to do is to create a class to wrap the dialog box, as well as provide a way for the dialog proc to reliably retrieve the pointer to the class. The windows API is a C API and cannot call class members directly so it is necessary to create static methods that can then retrieve the classes this pointer from somewhere.

class MyDialog {
  HWND _dlg;
public:
  int RunModal(HINSTANCE resModule, UINT resId,HWND parent){
    return DialogBoxParam(resModule,MAKEINTRESOURCE(resId),parent,&StaticDialogProc,(LPARAM)this);
  }
protected:
  static INT_PTR CALLBACK StaticDialogProc(HWND hwndDlg,UINT uMsg,WPARAM wParam,LPARAM lParam){
    MyDialog* self;
    if(uMsg == WM_INITDIALOG){
      self = (MyDialog*)lParam;
      self->_dlg = hwndDlg;
      SetWindowLongPtr(hwndDlg,DWLP_USER,lParam);
    }
    else
      self = (MyDialog*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);

    if(self)
      return self->DialogProc(uMsg,wParam,lParam);

    return FALSE;
  }

  virtual UINT_PTR DialogProc(UINT uMsg,WPARAM wParam,LPARAM lParam){
    switch(uMsg){
    case WM_INITDIALOG:
      OnInitDialog();
      break;
    case WM_COMMAND:
      OnCommand(LOWORD(wParam),HIWORD(wParam),(HWND)lParam);
      break;
    default:
      return FALSE;
    }
    return TRUE;
  }

  virtual void OnInitDialog(){
  }
  virtual void OnCommand(int id, USHORT notifyCode,HWND control){
    EndDialog(_hdlg,id);
  }
};

Now, there are hundreds of window messages that Windows can send to a dialog. Add handlers for each message to DialogProc and call a specific virtual function so derived classes can handle the message differently by overriding the virtual.

The critical messages to handle are usually WM_INITDIALOG which is sent as soon as the dialog is created, so is an ideal time to initialize any controls on the dialog - to populate drop down controls, or SetWindowText to initielize text boxes with default values. and WM_COMMAND, which is sent by controls like buttons, when they are clicked, passing in their id, and this is where you would handle the OK and CANCEL buttons.

Once DialogBoxParam returns, the dialog and all its child controls has been destroyed, so you would typically extract all the input fields in the OnCommand handler and store them in class members before calling EndDialog.

Answer 2

Another use case for the second part of the question: "what to put in dwInitParam"?

If you prefer OO programming and do not want to use the global scope for your dialog box, you can pass this to the formal parameter dwInitParam.

Obtaining a pointer to the caller:

template< typename CallerT >
inline CallerT *GetDialogCaller(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {

    if (WM_INITDIALOG != uMsg) {
        // Retrieves information about the specified window.
        // 1. A handle to the window and, indirectly, the class to which the window belongs.
        // 2. Retrieves the user data associated with the window.
        return reinterpret_cast< CallerT * >(GetWindowLongPtr(hwndDlg, GWLP_USERDATA));
    }

    CallerT * const caller = reinterpret_cast< CallerT * >(lParam);

    // Changes an attribute of the specified window.
    // 1. A handle to the window and, indirectly, the class to which the window belongs.
    // 2. Sets the user data associated with the window.
    // 3. The replacement value.
    SetWindowLongPtr(hwndDlg, GWLP_USERDATA, reinterpret_cast< LONG_PTR >(caller));

    return caller;
}

Delegating the message to the caller:

class Widget {

public:

    static INT_PTR CALLBACK DialogProcDelegate(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {

        // Retrieve a pointer to the instance of Widget
        // that called DialogBoxParam.
        Widget * const widget = GetDialogCaller< Widget>(hwndDlg, uMsg, wParam, lParam);

        // Delegate the message handling.
        return widget->DialogProc(hwndDlg, uMsg, wParam, lParam);
    }

    INT_PTR Show() const {
        return DialogBoxParam(nullptr, MAKEINTRESOURCE(IDD_WIDGET_SETTINGS), nullptr, DialogProcDelegate, reinterpret_cast< LPARAM >(this));
    }

private:

    INT_PTR DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {

        // Note that this method is not affected by our approach,
        // i.e. this method will still receive a WM_INITDIALOG.
        switch (uMsg) {
            ...
        }

        return FALSE;
    }
};

The alternative puts the caller in global scope and is restricted to a single caller for all dialog boxes.

Answer 3

you can do something like this. The dwInitParam Specifies the value to pass to the dialog box in the lParam parameter of the WM_INITDIALOG message. You can pass any value or simply pass NULL

INT_PTR CALLBACK editDlg(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam) {

        switch (msg) {
            case WM_INITDIALOG:                  
                return 1;
            break;
        }
        return 0;
    }

if(DialogBoxParam(hInst,MAKEINTRESOURCE(IDD_EDIT),hwndMain,editDlg,NULL)==IDOK) 
{
}