2. Dialog windows

2.1 Modal and modeless dialog windows

In the dialog windows users have more possibilities to interact with applications. That interaction between dialog window and user is provided by special control elements.

Control elements: button, control button – check box, selector button – radio button, list – list box, edit control – edit box, combined list – combo box, scrolling trace – scroll bar, static element.

In MFC all control elements are described in classes, inherited from CWnd. Therefore, every element has own access to same functions, as any other type of window. These are such classes: CButton – provides buttons, check boxes, radio buttons, CListBox – list boxes, CEdit – edit boxes, CComboBox - combo boxes, CScrollBox – scroll bars, Cstatic -static elements.

Generally, dialog windows are divided into to class – modal and modeless. The feature of such division is very simple: in modal windows there is an expectation for user activity, before program can continue it’s working.

The modeless dialog window isn’t interrupts the user working.

Mainly, the dialog windows are created by resource editor usage. In that manner, user can manually locate the position of control elements as to his wish. But there is also an special scenario language for that elements.

The dialog windows are defined by CDialog class(his parent class is CWnd). All windows are instances of CDialog or other classes, usually originated from CDialog.

CDialog::CDialog( LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL );

CDialog::CDialog( UINT nIDTemplate, CWnd* pParentWnd = NULL );

CDialog::CDialog( );

Here, lpszTemplateName   Contains a null-terminated string that is the name of dialog-box template resource.

nIDTemplate   Contains the ID number of a dialog-box template resource.

pParentWnd   Points to the parent or owner window object (of type CWnd) to which the dialog object belongs. If it is NULL, the dialog object's parent window is set to the main application window.

To construct a resource-based modal dialog box, call either public form of the constructor. One form of the constructor provides access to the dialog resource by template name. The other constructor provides access by template ID number, usually with an IDD_ prefix (for example, IDD_DIALOG1).

To construct a modal dialog box from a template in memory, first invoke the parameters, protected constructor and then call InitModalIndirect.

After you construct a modal dialog box with one of the above methods, call DoModal.

To construct a modeless dialog box, use the protected form of the CDialog constructor. The constructor is protected because you must derive your own dialog-box class to implement a modeless dialog box. Construction of a modeless dialog box is a two-step process. First call the constructor; then call the Create member function to create a resource-based dialog box, or call CreateIndirect to create the dialog box from a template in memory.

Message processing for dialog windows

We said,that CDialog is originated from CWnd, so every dialog window is usual window with corresponding properties. So dialog window has the same mechanism to react on messages. We should add, that messages processing is oriented not to the main window, so every dialog window should have its own message map and own handlers.

Generally, every element in the dialog window has own identifier. If element is activated by user, the message WM_COMMAND will be send to the dialog window. To process the message, we need to assign macro command ON_COMMAND().

The most of control elements are generating special identifier, therefore there will be selected a handler.

On modal dialog window closing, there are sent messages IDCANCEL, IDOK. For that messages, MFC assumes inbuilt handlers OnCancel and OnOK, which are not included to the messages map, while user can redefine them himself.

CDialog::OnCancel(); CDialog::OnOK();

Call this member function to terminate a modal dialog box. This member function returns nResult as the return value of DoModal. You must use the EndDialog function to complete processing whenever a modal dialog box is created.

Other mechanism exists for modeless dialog windows. If you implement the OK button in a modeless dialog box, you must override the OnOK member function and call DestroyWindow from within it. Don't call the base-class member function, because it calls EndDialog, which makes the dialog box invisible but does not destroy it.

For a modeless dialog box, you must provide your own public constructor in your dialog class. To create a modeless dialog box, call your public constructor and then call the dialog object's Create member function to load the dialog resource. You can call Create either during or after the constructor call. If the dialog resource has the property WS_VISIBLE, the dialog box appears immediately. If not, you must call its ShowWindow member function.

Modeless dialog boxes are normally created and owned by a parent view or frame window — the application's main frame window or a document frame window. The default OnClose handler calls DestroyWindow, which destroys the dialog-box window. If the dialog box stands alone, with no pointers to it or other special ownership semantics, you should override PostNcDestroy to destroy the C++ dialog object. You should also override OnCancel and call DestroyWindow from within it. If not, the owner of the dialog box should destroy the C++ object when it is no longer necessary.

If we have special class for modeless windows CModeLess and its object in class CMainWin – ml, the creation of modeless window can be produced in following way:

void CMainWin::OnUnModal()

{int a1=ml.Create(IDD_DIALOG2,this); // Create() function usage with identifier IDD_DIALOG2

if(a1)MessageBox("Modeless dialog is successful");

else MessageBox("Modeless dialog is unsuccessful");

ml.ShowWindow(SW_SHOWNORMAL);

}

void CModeLess::OnCancel()

{DestroyWindow();} // closing of modeless window by DestroyWindow function.

The example of program with dialog window

Below you can see an example of dialog window creation.

That example shows dialog window with two buttons: Red and Green.

The view of dialog window is created by Resource Editor. Every resource has own identifier. That identifier is a reference to resource object, here it’s a dialog window.

First of all, we need to create a class of our dialog window, inherited from CDialog. That listing will be positioned into the header file (*.h).

Listing 2.1 The example of dialog class

class CSampleDialog : public CDialog

{public:

CSampleDialog(UINT id, CWnd *Owner): CDialog(id, Owner);

// it’s an argument passing from constructor CSampleDialog to CDialog

afx_msg void OnRed(); // first handler in dialog window

afx_msg void OnGreen(); // second handler in dialog window

DECLARE_MESSAGE_MAP()

};

So we have constructor of dialog window (which has reference to the parent class), handlers declaration and the declaration of messages map.

BEGIN_MESSAGE_MAP(CSampleDialog, CDialog)

ON_COMMAND(IDD_RED, OnDialog)

ON_COMMAND(IDD_GREEN, OnGreent)

END_MESSAGE_MAP()

Certainly, our dialog should be called from some element of basic window (described by CMainWin class), so let’s make special item to call that dialog with identifier.

Listing 2.1 The example of main window class

class CMainWin : public CFrameWnd

{public:

CMainWin();

afx_msg void OnExit(); // first handler in dialog window

afx_msg void OnDialog(); // second handler in dialog window

DECLARE_MESSAGE_MAP() };

The constructor for main window is in Listing 2.3:

Listing 2.3 Constructor for main window of the program.

CMainWin::CMainWin()

{Create(NULL, ”Demonstrate Dialog Boxes”, WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE(IDR_MENU1));

}

One of two menu items is a dialog calling. That menu item should be linked to the handler to call the dialog window. It’s done in the message map:

BEGIN_MESSAGE_MAP(CMainWin, CFrameWnd)

ON_COMMAND(IDM_DIALOG, OnDialog)

ON_COMMAND(IDM_EXIT, OnExit)

END_MESSAGE_MAP()

Now, we only need to write the handlers:

Listing 2.4 Main window messages handlers.

afx_msg void CMainWin::OnDialog()

{CSampleDialog diagOb(IDD_DIALOG1,this);

// the creation of dialog window object by CSampleDialog constructor usage;

diagOb.DoModal();} // dialog window activation;

afx_msg void CMainWin::OnExit()

{int response;

response=MessageBox(“Quit the program?”,”Exit”,MB_YESNO);

if(response==IDYES) SendMessage(WM_CLOSE);}

The handlers of dialog window message map have very simple form:

afx_msg void CSampleDialog::OnRed(){MessageBox(“Red”,”Color Selected”);}

afx_msg void CSampleDialog::OnGreen(){MessageBox(“Green”,”Color Selected”);}

The dialog window initialization

Sometimes, the variables and control elements are initialized before dialog window opening (before that window become visible on the screen). For that, Windows automatically sends WM_INITDIALOG message. On such message reception, MFC call function OnInitDialog() – the standard CDialog handler of such prototype:

BOOL CDialog::OnInitDialog();

So, as this handler is standard, it isn’t need to include it to the message map. But before you should call function CDialog::OnInitDialog();

Some later, we’ll consider some features of Dialog window initialization for real control elements usage.