Microsoft Visual C++ .NET Professional Projects - Premier Press

Chapter 4

Working with

Menus, Dialog

Boxes, and

Window Controls

In Chapter 3, you were introduced to the MFC Application Wizard. In this chapter, you will learn to create menus and dialog boxes, and use different win-

dow controls in an application.

Creating Menus

In almost all applications that you have worked with, you have used menus. Hence, you can easily conclude that menus are one of the most commonly used user-interface components. A menu logically groups the functionality that an application provides. In Visual C++, such user-interface components are treated as resources and are stored in a separate file called the resource script file, which has the extension .rc. Corresponding to the .rc file, the wizard creates a resource.h file that defines the resources.

To create a menu for your application, you need to first design the menu using the resource editor and then code your application to display the menu and handle the menu commands.

Creating a Menu Resource

You will now learn how to design a menu using the resource editor. Here are the steps that you need to follow:

1.Select View, Resource View to display the Resource View pane. From the list of resources, select Menu.

2.Select Project, Add Resource to open the Add Resource dialog box, and select Menu.

3.Click the New button. A new menu resource is added to the project.

4.Enter the caption of the menu option.

5.Use the Properties window to edit the menu option’s properties, such as its ID.

NOTE

To display the Properties window, choose View, Properties Window.

After creating the menu resource, you need to code to display the menu.

Code to Display a Menu

MFC allows you to display a menu in two ways: by attaching it directly to the application’s frame window, or by using the CMenu class member functions. The MFC Application Wizard follows the first approach. The following is the code generated by the wizard that loads the application’s menu. I have highlighted the code that loads and displays the menu.

//MenuApp.cpp – File that defines the application class BOOL CMenuAppApp::InitInstance()

{

CWinApp::InitInstance();

CMainFrame* pFrame = new CMainFrame; m_pMainWnd = pFrame;

//create and load the frame with its resources pFrame->LoadFrame(IDR_MAINFRAME, WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE,

NULL, NULL);

pFrame->ShowWindow(SW_SHOW); pFrame->UpdateWindow(); return TRUE;

}

Continuing the discussion about how the wizard handles menus, as listed in the preceding code, the wizard instantiates the CMainFrame class and initializes the variable m_pMainWnd to point to the application’s frame window. Using the LoadFrame member function, it creates and loads the frame window. The first parameter of the function, IDR_MAINFRAME, is the ID of the menu that needs to be displayed. This is the ID of the default menu created by the wizard that you can edit.

When you create an application using the wizard, you have the flexibility to use the default menus provided (or tailor them according to your requirements) or to create new menus, if required. A little time must be spent understanding how this works for SDI and MDI applications:

In an SDI application, the default menu created is IDR_MAINFRAME and is attached to the main window of the application. So, if required, you can either edit this menu or add a new one. To load the new menu, say

IDR_MENU1, you will need to edit the InitInstance function of the application class as follows:

pFrame->LoadFrame(IDR_MENU1, WS_OVERLAPPEDWINDOW | WS_ADDTOTITLE,

NULL,

NULL);

Since SDI applications support a single-frame window, which is the main frame, it can support only a single menu. Hence, at a time, you can either attach the default menu, IDR_MAINFRAME, or the menu that you defined, IDR_MENU1.

In an MDI application, the default menu created by the wizard is IDR_MAINFRAME, which is attached to the application’s main window. In addition, if you recall, an MDI application creates a child window for each new document that you create. For each of these child windows, the wizard creates another menu. You have the option to edit both of these menus or to create a new menu and attach it to the appropriate window. For instance, if you want the new menu to be accessible to both the main and child windows, you can attach the new menu to the main window. On the other hand, if you want to access the menu only from child windows, then you attach the menu to the child window. Here’s the code generated by the wizard that loads the appropriate menu:

CMultiDocTemplate* pDocTemplate;

pDocTemplate = new CMultiDocTemplate(IDR_MDIAppTYPE, RUNTIME_CLASS(CMDIAppDoc), RUNTIME_CLASS(CChildFrame),

// custom MDI child frame

RUNTIME_CLASS(CMDIAppView));

AddDocTemplate(pDocTemplate);

// create main MDI Frame window

CMainFrame* pMainFrame = new CMainFrame; if (!pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;

In the preceding code, IDR_MAINFRAME refers to the menu that will be attached to the main application window, and IDR_MDIAppTYPE refers to the menu that will be attached to the child windows.

Handling Menu

So far, you have looked at the process of adding a menu to your application. However, the work is not complete unless your application can handle the menu. So, the next step will be to enable your application to handle the messages generated when a user makes use of the menu. To accomplish this, obviously, you need to add message handlers. With different classes involved in an MFC application, the next question that arises is, which class will handle the messages? Well, you can designate the frame window class or the application class or the view class to act as the message-handling class. Right from selecting the message-handling class to adding the message handlers can be done quickly and with ease by using the Event Handler Wizard. Here’s what you have to do:

1.Switch to Resource View.

2.Right-click the appropriate menu item.

3.Select Add Event Handler from the shortcut menu. The Event Handler Wizard, as shown in Figure 4-1, starts. The wizard consists of a Message type list, from which you choose the type of message to be trapped, and a Class list, from which you choose the class that will handle the messages. Additionally, you can edit the message handler function name that appears in the Function handler name box.

4.Click the Add and Edit button to add the message handler and edit its code. The message handler is added to the class that is designated as the message-handling class. The function declaration is added to the .h file while the function definition is added to the .cpp file. The wizard also creates the corresponding message map entry.

FIGURE 4-1 The Event Handler Wizard

Creating a Sample Menu

Now you will implement the concepts discussed thus far. You will be creating a simple application (one that is not based on the Document/View architecture) with a sample menu. You will also add the required message handlers to it. Suppose that you want to add a menu option, say Draw, which will provide some drawing functionality for your application. Instead of creating a new menu, you decide to edit the default one. Here’s the way to go:

1.Create an SDI application using the MFC Application Wizard. The application’s name in the sample code is MenuApp.

2.Switch to Resource View and open the default menu, IDR_MAINFRAME, for editing.

3.Add the options shown in Figure 4-2.

4.Right-click each of the options, for example Line, and choose Add Event Handler to start the wizard.

5.From the Class list, select the required class. In the sample code given, the application class, CMenuApp, has been designated as the message-han- dling class.

6.Click on the Add and Edit button. The wizard adds the function declaration in the header file of the view class and generates the body for