fDIALOG

Quick Data

General Description

This class is not a wrapper for any specific thing - rather, it is a class that can manage dialog boxes. It's support is currently rudimentry, and you'll have to do a bit extra to get your job done. This object is a little bit more complicated than some others, so look for the sample source code at the end to see how this one works.

Many thanks go to theForger (http://www.winprog.org) for the parts in his tutorial about dialogs. From the tutorial I learned about the Dialog Message queue, and how to write dialogs into resource files. Thanks!

Methods

Sample Code

The following snippet gives a basic idea of how to use this component.

//The dialog message queue's function prototype...
BOOL CALLBACK DlgProc(HWND Handle, UINT Message,
                      WPARAM wParam, LPARAM lParam);

//Then inside a function...
//First we start by loading the dialog.
fDIALOG Dialog;
Dialog.LoadDialog(NULL, DIALOG_ID);

//Then we can display it (modal display in this
//example).

Dialog.SetDlgProc(DlgProc);
Dialog.ExecuteModal(Window.GetHandle());

//Now we go on and do other things. But in the
//dialog message queue...
BOOL CALLBACK DlgProc(HWND Handle, UINT Message,
                      WPARAM wParam, LPARAM lParam)
     {
     switch (Message)
            {
            case WM_INITDIALOG:
                 //This occurs when the dialog is being created.
                 //Initialise the dialog here, now.
                 //An example follows...
                 Dialog.LobbyHandle(Handle);
                 Dialog.AssimiliateButton(&Button, IDOK);
                 Button.OnClick = &ButtonOkClick;
                 break;
            case WM_COMMAND:
                 //If you have assimiliated controls, then
                 //pass along the message queue here (ie.
                 //if you have a GUI controller).
                 //You would do this as follows:
                 DOPASSALONG
                 //Otherwise, you'll check wParam against 
                 //the ID's you assigned your controls, eg.
                 if (wParam == IDOK) Dialog.CloseDialogModal(Handle);
                 //(The above line checked for the button
                 // that was assigned IDOK as an ID)
                 //Or, if a non-modal dialog,
                 Dialog.LobbyHandle(Handle);
                 if (wParam == IDOK) Dialog.CloseDialog(Handle);
                 break;
            };
     //You can intercept any other message you want - some other
     //good ones would be WM_CLOSE (when the user clicks the 'X'
     //button in the top right hand corner). You do not need to return
     //DefWindowProc(), just TRUE if you process a message. Anything that
     //you don't handle, Windows will.
     };

//Now, finally, how do you design a dialog? In the resource file. You
//Might end up with the following... (any line starting with > is not
//an explanatory line)

Basic stuff first... Dialog ID, the word DIALOG, x pos,y pos, width, height.
>ABOUTDLG DIALOG 0, 0, 155, 102
The extra (primary) style for the dialog (in this example, it's a stay
on top option)
>EXSTYLE WS_EX_STAYONTOP
Then the style of window for the dialog (secondary style)
>STYLE DS_MODALFRAME | DS_3DLOOK | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
Then the caption of the dialog box, followed by the font.
>CAPTION "This is my About Box"
>FONT 8, "MS Sans Serif"
Then the controls on the dialog. Like this:
CONTROL "Caption", ControlID, "Class", Style, x,y, Width, Height.
(Note: putting -1 as the ID means that you don't need to access that
 object again. Useful for static's that don't need to change - less
 ID's to worry about.)
>{
>   CONTROL "&OK", IDOK, "BUTTON", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 6, 83, 50, 14
>   CONTROL "&Cancel", IDCANCEL, "BUTTON", BS_PUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 95, 83, 50, 14
>   CONTROL "About This Program", -1, "button", BS_GROUPBOX | WS_CHILD | WS_VISIBLE | WS_GROUP, 5, 5, 144, 73
>   CONTROL "An example program.", -1, "static", SS_CENTER | WS_CHILD | WS_VISIBLE, 27, 27, 100, 50
>}

//So all up, minus explanation lines, it would look like this...
ABOUTDLG DIALOG 0, 0, 155, 102
EXSTYLE WS_EX_STAYONTOP
STYLE DS_MODALFRAME | DS_3DLOOK | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "This is my About Box"
FONT 8, "MS Sans Serif"
{
   CONTROL "&OK", IDOK, "BUTTON", BS_DEFPUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 6, 83, 50, 14
   CONTROL "&Cancel", IDCANCEL, "BUTTON", BS_PUSHBUTTON | BS_CENTER | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 95, 83, 50, 14
   CONTROL "About This Program", -1, "button", BS_GROUPBOX | WS_CHILD | WS_VISIBLE | WS_GROUP, 5, 5, 144, 73
   CONTROL "An example program.", -1, "static", SS_CENTER | WS_CHILD | WS_VISIBLE, 27, 27, 100, 50
}

//Now you should be able to create dialogs. About one more note:
//you may need to #include "windows.h" inside your resource file,
//so that the resource compiler is able to work out what the
//styles mean (ie. WS_VISIBLE is a number, and it's defined
//inside windows.h).

//One last note, and an interesting little thing to keep in mind.
//Let's say that you have an about dialog - all you have is a whole
//heap of static controls, and one button: ok. Isn't it a pain
//to add another DlgProc just for that? Well, don't. Inside dialog.h
//is this code:
BOOL CALLBACK F_SimpleDlgProc(HWND Handle, UINT Message, WPARAM wParam, LPARAM lParam)
     {
     if (Message == WM_INITDIALOG) return TRUE;
     if (Message == WM_COMMAND)
        {
        if (wParam == IDOK) EndDialog(Handle, 0);
        return TRUE;
	}
     };

//What this code does is implement a small dialog handler for you
//and it is intended for dialogs with only one button with an ID
//of IDOK. So create your dialog, set the ID of the OK/Close button
//to IDOK (1), and then make the Dialog Proc F_SimpleDlgProc. 
//Simple! No more extra DlgProcs just for an about box! Hopefully
//you'll find this useful.