Jason C. Perez
OEM Systembuilder Philippines Group

Microsoft Philippines Group

MSDN Philippines Group

November 2006

Summary: Introduces you to the concept of Multiple Document Interface (MDI) and how to create menus within an MDI application. (20 printed pages)

Objectives

· Learn to create MDI parent forms

· Learn to create MDI child forms

· Learn to create and use menus

Assumptions

The following should be true for you to get the most out of this document:

· You are familiar with Microsoft® Visual Studio® .NET

· You are familiar with designing forms and other user interfaces

Contents

MDI Overview
Create an MDI Project
Creating Menus
Working with MDI Child Forms
Creating Shortcut Menus
Manipulating Menus at Run Time
How Did the Code Work?
Summary

MDI Overview

This document introduces you to the concept of Multiple Document Interface (MDI) and how to create menus within an MDI application. You will learn to create an MDI application in Microsoft Visual Studio .NET and learn why you might want to use this type of interface. You will learn about child forms that are contained within the MDI application, and learn to create shortcut, or context-sensitive, menus.

MDI is a popular interface because it allows you to have multiple documents (or forms) open in one application. Examples of MDI applications include Microsoft Word, Microsoft Excel, Microsoft PowerPoint®, and even the Visual Studio integrated development environment itself. Each application consists of one (or more) parent windows, each containing an MDI client area—the area where the child forms (or documents) will be displayed. Code you write displays as many instances of each of the child forms that you want displayed, and each child form can only be displayed within the confines of the parent window—this means you can't drag the child forms outside the MDI container. Figure 1 shows a basic MDI application in use.

Normal checked menus work individually, and are independent of other menu items.

You may have a need to treat a group of menu items as a dependent set. In this case, selecting one item from the group forces all the other items in the group to be deselected. Although Visual Studio .NET doesn't provide a way to make this happen for you, it does supply the RadioCheck property of menu items that at least provides a visual indication. Rather than seeing a normal check, menu items with their RadioCheck property set to True display a dot when they're selected. It's still up to your code to deselect all the other items in your menu group, once the user selects a menu item.

To demonstrate this behavior, modify properties and add code so that the four window management menu items (Cascade, Tile Horizontal, Tile Vertical, Arrange Icons) work as a group. To do that, follow these steps:

1. With frmMain open in Design view, select the Window>Center Child Form menu item.

2. Right-click, and on the shortcut menu, click Insert Separator, which inserts a separator item above the selected item.

3. Click on the Window>Cascade menu item, then at the same time, press Ctrl and click the other four window management items on the menu, selecting all four.

4. In the Properties window, set the RadioCheck property for the four selected menu items to True.

5. Add the following procedure to the frmMain class:

6. Private Sub RadioCheck_Click( _

7. ByVal sender As System.Object, _

8. ByVal e As System.EventArgs) _

9. Handles mnuWArrange.Click, mnuWCascade.Click, _

10. mnuWHorizontal.Click, mnuWVertical.Click

11. mnuWArrange.Checked = False

12. mnuWCascade.Checked = False

13. mnuWHorizontal.Checked = False

14. mnuWVertical.Checked = False

15. CType(sender, MenuItem).Checked = True

End Sub

16. Run the project, create some Product forms, and use the Window menu items to arrange the children. As you use the Cascade, Tile Horizontal, and other menu items, you should see a circle next to the most recently selected item. Figure 6 shows the results of adding this new feature.

Figure 6. Setting a menu item's RadioCheck property to True shows a dot, rather than a check, next to selected items

How Did the Code Work?

It may seem odd that you managed to add new functionality to four menu items without modifying their event procedures at all. This example took advantage of a new feature in Visual Basic .NET—you can hook up as many event handlers to a specific event as you need, using the Handles clause on a procedure. Here, you provided a new procedure (RadioCheck_Click) that handles Click events for each of the four menu items you want to have work together.

Here are the important issues:

· The procedure you want to call must match the procedure signature of the standard Click event for menu items. That is, it must receive two parameters (one as System.Object, the other as System.EventArgs) and return nothing at all. (It must be a Sub, in other words.)

· You must add a Handles clause for each event you want to handle. In this case, you're handling the Click event of four different menu items.

· Within the procedure, you can use the first parameter (named sender, in this example) to figure out which object triggered the event. This example first sets each of the four items to be unchecked, and then checks the item that triggered the event.

It's also interesting to note how the RadioCheck_Click procedure set the RadioCheck property of the object it received as its first parameter. To convert the Object variable into a MenuItem type, the code calls the CType function, indicating the variable to convert, and the result type (MenuItem):

CType(sender, MenuItem).Checked = True

You'll use CType a lot in Visual Basic .NET. This important function allows you to convert variables from one type to another. Because Visual Basic .NET is so strictly typed (it's always careful about the specific data types you're working with, unlike Visual Basic 6.0), you'll often need to use this function to convert variables into a specific data type.

NoteIt's important to note that when you use the Handles clause as you did here to add event handlers, you cannot control the order in which those events get handled. Visual Basic .NET does supply a different mechanism, the AddHandler statement, which gives you more control. Using the Handles clause is simpler, however, and if you don't care about the order in which the procedures handle the event (in this case, you don't), it's an easier way to add extra functionality.

Summary

In this document you have learned to build an MDI application using several techniques that you find in professional Windows applications. You also learned to create and manipulate menus. Whether or not you choose to use the MDI paradigm will depend on the complexity of your application and how many forms will need to be displayed at one time.

About the Authors

For More Information just visit http://groups.msn.com/microsoftphilippines, http://groups.msn.com/oemsystembuilderphilippines.