Table 6-1 defines some of the properties common to most types that inherit from Control.

Button.Bounds =
   new Rectangle (10,10,50,60)

.Hand    .Cross   UpArrow      Default
.Beam    .Arrow   WaitCursor

As we saw in the earlier example, the size of a control is determined by the Size object, which is a member of the System.Drawing namespace:

button1.Size = new Size(80,40);  // (width, height)
button2.Size = button1.Size;     // Assign size to second button

A control can be resized during runtime by assigning a new Size object to it. This code snippet demonstrates how the Click event handler method can be used to change the size of the button when it is clicked:

private void button1_Click(object sender, System.EventArgs e)
{
   MessageBox.Show("Up and Running");
   Button button1 = (Button) sender;  //Cast object to Button
   button1.Size = new Size(90,20);    //Dynamically resize

The System.Drawing.Point object can be used to assign a control's location. Its arguments set the x and y coordinates—in pixels—of the upper-left corner of a control. The x coordinate is the number of pixels from the left side of the container. The y coordinate is the number of pixels from the top of the container.

button1.Location = new Point(20,40);  // (x,y) coordinates

It is important to recognize that this location is relative to the control's container. Thus, if a button is inside a GroupBox, the button's location is relative to it and not the form itself. A control's Location also can be changed at runtime by assigning a new Point object.

Another approach is to set the size and location in one statement using the Bounds property:

button1.Bounds = new Rectangle(20,40, 100,80);

A Rectangle object is created with its upper-left corner at the x,y coordinates (20,40) and its lower-right coordinates at (100,80). This corresponds to a width of 80 pixels and a height of 40 pixels.

The Dock property is used to attach a control to one of the edges of its container. By default, most controls have docking set to none; some exceptions are the StatusStrip/StatusBar that is set to Bottom and the ToolStrip/ToolBar that is set to Top. The options, which are members of the DockStyle enumeration, are Top, Bottom, Left, Right, and Fill. The Fill option attaches the control to all four corners and resizes it as the container is resized. To attach a TextBox to the top of a form, use

TextBox1.Dock = DockStyle.Top;

Figure 6-3 illustrates how docking affects a control's size and position as the form is resized. This example shows four text boxes docked, as indicated.

Figure 6-3. Control resizing and positioning using the Dock property

Resizing the form does not affect the size of controls docked on the left or right. However, controls docked to the top and bottom are stretched or shrunk horizontally so that they take all the space available to them.

Core Note

The Form class and all other container controls have a DockPadding property that can be set to control the amount of space (in pixels) between the container's edge and the docked control.

The Anchor property allows a control to be placed in a fixed position relative to a combination of the top, left, right, or bottom edge of its container. Figure 6-4 illustrates the effects of anchoring.

Figure 6-4. How anchoring affects the resizing and positioning of controls

The distance between the controls' anchored edges remains unchanged as the form is stretched. The PictureBox (1) is stretched horizontally and vertically so that it remains the same distance from all edges; the Panel (2) control maintains a constant distance from the left and bottom edge; and the Label (3), which is anchored only to the top, retains its distance from the top, left, and right edges of the form.

The code to define a control's anchor position sets the Anchor property to values of the AnchorStyles enumeration (Bottom, Left, None, Right, Top). Multiple values are combined using the OR ( | ) operator:

btnPanel.Anchor = (AnchorStyles.Bottom | AnchorStyles.Left);

Tab order defines the sequence in which the input focus is given to controls when the Tab key is pressed. The default sequence is the order in which the controls are added to the container.

The tab order should anticipate the logical sequence in which users expect to input data and thus guide them through the process. The form in Figure 6-5 represents such a design: The user can tab from the first field down to subsequent fields and finally to the button that invokes the final action.

Figure 6-5. Tab order for controls on a form

Observe two things in the figure: First, even though labels have a tab order, they are ignored and never gain focus; and second, controls in a container have a tab order that is relative to the container—not the form.

A control's tab order is determined by the value of its TabIndex property:

TextBox1.TabIndex = 0;  //First item in tab sequence

In VS.NET, you can set this property directly with the Property Manager, or by selecting ViewTabOrder and clicking the boxes over each control to set the value. If you do not want a control to be included in the tab order, set its TabStop value to false. This does not, however, prevent it from receiving focus from a mouse click.

When a form is loaded, the input focus is on the control (that accepts mouse or keyboard input) with the lowest TabIndex value. During execution, the focus can be given to a selected control using the Focus method:

if(textBox1.CanFocus)
{ textBox1.Focus(); }

All controls on a form are contained in a Controls collection. By enumerating through this collection, it is possible to examine each control, identify it by name and type, and modify properties as needed. One common use is to clear the value of selected fields on a form in a refresh operation. This short example examines each control in Figure 6-5 and displays its name and type:

int ctrlCt = this.Controls.Count;   //  8
foreach (Control ct in this.Controls)
{
   object ob = ct.GetType();
   MessageBox.Show(ob.ToString());  //Displays type as string
   MessageBox.Show(ct.Name);
}

There are several things to be aware of when enumerating control objects:

void IterateThroughControls(Control parent)
{
   foreach (Control c in parent.Controls)
   {
      MessageBox.Show(c.ToString());
      if(c.HasChildren)
      {
         IterateThroughControls(c);
      }
   }
}

Applying this code to Figure 6-5 results in all controls on the main form being listed hierarchically. A control is listed followed by any child it may have.

In addition to the familiar Click and DoubleClick events, all Windows Forms controls inherit the MouseHover, MouseEnter, and MouseLeave events. The latter two are fired when the mouse enters and leaves the confines of a control. They are useful for creating a MouseOver effect that is so common to Web pages.

To illustrate this, let's consider an example that changes the background color on a text box when a mouse passes over it. The following code sets up delegates to call OnMouseEnter and OnMouseLeave to perform the background coloring:

TextBox userID = new TextBox();
userID.MouseEnter += new EventHandler(OnMouseEnter);
userID.MouseLeave += new EventHandler(OnMouseLeave);

The event handler methods match the signature of the EventHandler delegate and cast the sender parameter to a Control type to access its properties.

private void OnMouseEnter(object sender, System.EventArgs e){
   Control ctrl = (Control) sender;
   ctrl.BackColor= Color.Bisque;
} 
private void OnMouseLeave(object sender, System.EventArgs e){
   Control ctrl = (Control) sender;
   ctrl.BackColor= Color.White;
}

Core Note

It is possible to handle events by overriding the default event handlers of the base Control class. These methods are named using the pattern Oneventname—for example, OnMouseDown, OnMouseMove, and so on. To be consistent with .NET, the delegate approach is recommended over this. It permits a control to specify multiple event handlers for an event, and it also permits a single event handler to process multiple events.

The delegates for the MouseDown, MouseUp, and MouseMove events take a second argument of the MouseEventArgs type rather than the generic EventArgs type. This type reveals additional status information about a mouse via the properties shown in Table 6-3.

The properties in this table are particularly useful for applications that must track mouse movement across a form. Prime examples are graphics programs that rely on mouse location and button selection to control onscreen drawing. To illustrate, Listing 6-3 is a simple drawing program that draws a line on a form's surface, beginning at the point where the mouse key is pressed and ending where it is raised. To make it a bit more interesting, the application draws the line in black if the left button is dragged, and in red if the right button is dragged.

using System;
using System.Windows.Forms;
using System.Drawing;
class MyWinApp
{
   static void Main() {
   Form mainForm = new DrawingForm();
   Application.Run(mainForm);  
   }
}
// User Form derived from base class Form
class DrawingForm:Form
{
   Point lastPoint = Point.Empty; // Save coordinates
   public Pen myPen;      //Defines color of line
   public DrawingForm()
   {
      this.Text = "Drawing Pad";
      // reate delegates to call MouseUp and MouseDown
      this.MouseDown += new MouseEventHandler(OnMouseDown);
      this.MouseUp   += new MouseEventHandler(OnMouseUp);
   }
   private void OnMouseDown(object sender, MouseEventArgs e)
   {
      myPen = (e.Button==MouseButtons.Right)? Pens.Red:
            Pens.Black;
      lastPoint.X = e.X;
      lastPoint.Y = e.Y;
   }

   private void OnMouseUp(object sender, MouseEventArgs e)
   {
      // Create graphics object
      Graphics g = this.CreateGraphics(); 
      if (lastPoint != Point.Empty) 
         g.DrawLine(myPen, lastPoint.X,lastPoint.Y,e.X,e.Y);
      lastPoint.X = e.X;
      lastPoint.Y = e.Y;
      g.Dispose();
   }
}

Even without an understanding of .NET graphics, the role of the graphics-related classes should be self-evident. A Graphics object is created to do the actual drawing using its DrawLine method. The parameters for this method are the Pen object that defines the color and the coordinates of the line to be drawn. When a button is pressed, the program saves the coordinate and sets myPen based on which button is pressed: a red pen for the right button and black for the left. When the mouse button is raised, the line is drawn from the previous coordinate to the current location. The MouseEventArgs object provides all the information required to do this.

Keyboard events are also handled by defining a delegate to call a custom event handling method. Two arguments are passed to the event handler: the sender argument identifies the object that raised the event and the second argument contains fields describing the event. For the KeyPress event, this second argument is of the KeyPressEventArgs type. This type contains a Handled field that is set to true by the event handling routine to indicate it has processed the event. Its other property is KeyChar, which identifies the key that is pressed.

KeyChar is useful for restricting the input that a field accepts. This code segment demonstrates how easy it is to limit a field's input to digits. When a non-digit is entered, Handled is set to true, which prevents the form engine from displaying the character. Otherwise, the event handling routine does nothing and the character is displayed.

private void OnKeyPress(object sender,  KeyPressEventArgs e)
{
   if (! char.IsDigit(e.KeyChar)) e.Handled = true;
}

The KeyPress event is only fired for printable character keys; it ignores non-character keys such as Alt or Shift. To recognize all keystrokes, it is necessary to turn to the KeyDown and KeyUp events. Their event handlers receive a KeyEventArgs type parameter that identifies a single keystroke or combination of keystrokes. Table 6-4 lists the important properties provided by KeyEventArgs.

A few things to note:

The preceding code segment showed how to use KeyPress to ensure a user presses only number keys (0–9). However, it does not prevent one from pasting non-numeric data using the Ctrl-V key combination. A solution is to use the KeyDown event to detect this key sequence and set a flag notifying the KeyPress event handler to ignore the attempt to paste.

In this example, two event handlers are registered to be called when a user attempts to enter data into a text box using the keyboard. KeyDown is invoked first, and it sets paste to true if the user is pushing the Ctrl-V key combination. The KeyPress event handler uses this flag to determine whether to accept the key strokes.

private bool paste;

//Register event handlers for TextBox t.
//They should be registered in this order,
//because the last registered is the
//first executed
t.KeyPress += new KeyPressEventHandler(OnKeyPress);
t.KeyDown  += new KeyEventHandler(OnKeyDown);

private void OnKeyDown(object sender, KeyEventArgs e)
{
if (e.Modifiers == Keys.Control  && e.KeyCode == Keys.V)
{
   paste=true; //Flag indicating paste attempt
   string msg = string.Format("Modifier: {0} 
KeyCode: {1}
       
KeyData: {2}", e.Modifiers.ToString(),
        e.KeyCode.ToString(), e.KeyData.ToString());
   MessageBox.Show(msg);      //Display property values
}

private void OnKeyPress(object sender, KeyPressEventArgs e)
{
   if (paste==true)  e.Handled = true;
}

This program displays the following values for the selected KeyEventArgs properties when Ctrl-V is pressed:

Modifier:  Control
KeyCode:   V
KeyData:   Control, V

A form's opacity property determines its level of transparency. Values ranges from 0 to 1.0, where anything less than 1.0 results in partial transparency that allows elements beneath the form to be viewed. Most forms work best with a value of 1.0, but adjusting opacity can be an effective way to display child or TopMost forms that hide an underlying form. A common approach is to set the opacity of such a form to 1.0 when it has focus, and reduce the opacity when it loses focus. This technique is often used with search windows that float on top of the document they are searching.

Let's look at how to set up a form that sets its opacity to 1 when it is active and to .8 when it is not the active form. To do this, we take advantage of the Deactivate and Activated events that are triggered when a form loses or gains focus. We first set up the delegates to call the event handling routines:

this.Deactivate += new System.EventHandler(Form_Deactivate);
this.Activated  += new System.EventHandler(Form_Activate);

The code for the corresponding event handlers is trivial:

void Form_Deactivate(object sender, EventArgs e)
{   this.Opacity= .8;   }

void Form_Activate(object sender, EventArgs e)
{   this.Opacity= 1;   }

Opacity affects the transparency of an entire form. There is another property, TransparencyKey, which can be used to make only selected areas of a form totally transparent. This property designates a pixel color that is rendered as transparent when the form is drawn. The effect is to create a hole in the form that makes any area below the form visible. In fact, if you click a transparent area, the event is recognized by the form below.

The most popular use of transparency is to create non-rectangular forms. When used in conjunction with a border style of FormBorderStyle.None to remove the title bar, a form of just about any geometric shape can be created. The next example illustrates how to create and use the cross-shaped form in Figure 6-7.

Figure 6-7. Form using transparency to create irregular appearance

The only requirement in creating the shape of the form is to lay out the transparent areas in the same color as the transparency key color. Be certain to select a color that will not be used elsewhere on the form. A standard approach is to set the back color of the form to the transparency key color, and draw an image in a different color that it will appear as the visible form.

To create the form in Figure 6-7, place Panel controls in each corner of a standard form and set their BackColor property to Color.Red. The form is created and displayed using this code:

CustomForm myForm = new CustomForm();
myForm.TransparencyKey = Color.Red;
myForm.FormBorderStyle= FormBorderStyle.None;
myForm.Show();

This achieves the effect of making the panel areas transparent and removing the title bar. With the title bar gone, it is necessary to provide a way for the user to move the form. This is where the mouse event handling discussed earlier comes to the rescue.

At the center of the form is a multiple arrow image displayed in a PictureBox that the user can click and use to drag the form. Listing 6-4 shows how the MouseDown, MouseUp, and MouseMove events are used to implement form movement.

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
public class CustomForm : Form    
{
   private Point lastPoint = Point.Empty;  //Save mousedown
   public CustomForm()
   {
      InitializeComponent();  // set up form
      //Associate mouse events with pictureBox
      pictureBox1.MouseDown += new MouseEventHandler(
            OnMouseDown);
      pictureBox1.MouseUp   += new MouseEventHandler(OnMouseUp);
      pictureBox1.MouseMove += new MouseEventHandler(
            OnMouseMove);
   }
   private void OnMouseDown(object sender, MouseEventArgs e)
   {
      lastPoint.X = e.X;
      lastPoint.Y = e.Y;
   }

   private void OnMouseUp(object sender, MouseEventArgs e)
   {
      lastPoint = Point.Empty;
   } 

   //Move the form in response to the mouse being dragged
   private void OnMouseMove(object sender, MouseEventArgs e)
   {
      if (lastPoint != Point.Empty) 
      {
         //Move form in response to mouse movement
         int xInc = e.X - lastPoint.X;
         int yInc = e.Y - lastPoint.Y;
         this.Location = new Point(this.Left + xInc, 
                       this.Top+yInc);
      }
   }
   // Close Window
   private void button1_Click(object sender, System.EventArgs e)
   {
      this.Close();
   }
}

The logic is straightforward. When the user clicks the PictureBox, the coordinates are recorded as lastPoint. As the user moves the mouse, the Location property of the form is adjusted to reflect the difference between the new coordinates and the original saved location. When the mouse button is raised, lastPoint is cleared. Note that a complete implementation should also include code to handle form resizing.

When one form creates another form, there are coding requirements on both sides. The created form must set up code in its constructor to perform initialization and create controls. In addition, delegates should be set up to call event handling routines. If using Visual Studio.NET, any user initialization code should be placed after the call to InitializeComponent.

For the class that creates the new form object, the most obvious task is the creation and display of the object. A less obvious task may be to ensure that only one instance of the class is created because you may not want a new object popping up each time a button on the original form is clicked. One way to manage this is to take advantage of the Closed event that occurs when a created form is closed (another way, using OwnedForms, is discussed shortly). If the form has not been closed, a new instance is not created. The code that follows illustrates this.

An EventHandler delegate is set up to notify a method when the new form, opForm, is closed. A flag controls what action occurs when the button to create or display the form is pushed. If an instance of the form does not exist, it is created and displayed; if it does exist, the Form.Activate method is used to give it focus.

//Next statement is at beginning of form's code
public opaque opForm; 
bool closed = true;   //Flag to indicate if opForm exists
//Create new form or give focus to existing one
private void button1_Click(object sender, System.EventArgs e)
{
   if (closed)
   {
      closed = false;
      opForm = new opaque();
      //Call OnOpClose when new form closes
      opForm.Closed += new EventHandler(OnOpClose);
      opForm.Show();     //Display new form object
   } else {
      opForm.Activate();  //Give focus to form
   }
}
//Event handler called when child form is closed
private void OnOpClose(object sender, System.EventArgs e)
{
   closed = true;   //Flag indicating form is closed
}

A form becomes active when it is first shown or later, when the user clicks on it or moves to it using an Alt-Tab key to iterate through the task bar. This fires the form's Activated event. Conversely, when the form loses focus—through closing or deselection—the Deactivate event occurs. In the next code segment, the Deactivate event handler changes the text on a button to Resume and disables the button; the Activated event handler re-enables the button.

this.Deactivate += new System.EventHandler(Form_Deactivate);
this.Activated  += new System.EventHandler(Form_Activate);
//
void Form_Deactivate(object sender, EventArgs e) 
{   button1.Enabled = false;   
    button1.Text = "Resume";      }
void Form_Activate(object sender, EventArgs e)
{   button1.Enabled = true;   }

The Closing event occurs as a form is being closed and provides the last opportunity to perform some cleanup duties or prevent the form from closing. This event uses the CancelEventHandler delegate to invoke event handling methods. The delegate defines a CancelEventArgs parameter that contains a Cancel property, which is set to true to cancel the closing. In this example, the user is given a final prompt before the form closes:

this.Closing += new CancelEventHandler(Form_Closing);
void Form_Closing(object sender, CancelEventArgs e)
{
   if(MessageBox.Show("Are you sure you want to Exit?", "",
      MessageBoxButtons.YesNo) == DialogResult.No)
   {
      //Cancel the closing of the form
      e.Cancel = true;
   }
}

When the button on DocForm is clicked, the application either creates a new instance of SearchForm or passes control to an existing instance. In both cases, it first checks its text box and passes any highlighted text (SelectedText) to the SearchForm object via its SearchPhrase property (see Listing 6-5). Techniques described in earlier examples are used to create the object and set up a delegate to notify the DocForm object when the search form object closes.

private void btnSearch_Click(object sender, System.EventArgs e) {
   //Create instance of search form if it does not exist
   if (closed) 
   {
      closed= false;
      searchForm = new SearchForm();   //Create instance
      searchForm.TopMost = true;
      searchForm.Closed += new EventHandler(onSearchClosed);
      searchForm.StartPosition = FormStartPosition.Manual;
      searchForm.DesktopLocation = new Point(this.Right-200, 
            this.Top-20);
      searchForm.SearchPhrase = documentText.SelectedText;
      searchForm.Show();
   } else {
      searchForm.SearchPhrase = documentText.SelectedText;
      searchForm.Activate();
   }
}
private void onSearchClosed(object sender, System.EventArgs e) 
{   closed= true;   }

Listing 6-6 displays the code executed when the Find Next button is clicked. The search for the next occurrence of the search string can proceed up the document using the LastIndexOf method or down the document using IndexOf. Logic is also included to ignore or recognize case sensitivity.

private void btnFind_Click(object sender, System.EventArgs e) 
{
   int ib;      //Index to indicate position of match
   string myBuff = DocForm.myText.Text; //Text box contents
   string searchText= this.txtSearch.Text;  //Search string
   int ln = searchText.Length;          //Length of search string
   if (ln>0) 
   {
      //Get current location of selected text
      int selStart = DocForm.myText.SelectionStart;
      if (selStart >= DocForm.myText.Text.Length) 
      {   
         ib = 0; 
      } else {
         ib = selStart + ln;
      }
      if (!this.chkCase.Checked) //Case-insensitive search
      {
         searchText = searchText.ToUpper();
         myBuff = myBuff.ToUpper();
      }
      if (this.radDown.Checked)ib = 
            myBuff.IndexOf(searchText,ib);
      if (this.radUp.Checked && ib>ln-1)ib = 
                 myBuff.LastIndexOf(searchText,ib-2,ib-1);
      if (ib >= 0)        //Highlight text on main form
      {
         DocForm.myText.SelectionStart = ib;
         DocForm.myText.SelectionLength = txtSearch.Text.Length;
      }
   }
}

The MessageBox class uses its Show method to display a message box that may contain text, buttons, and even an icon. The Show method includes these overloads:

Syntax:

static DialogResult Show(string msg) 
static DialogResult Show(string msg, string caption) 
static DialogResult Show(string msg, string caption, 
      MessageBoxButtons buttons)
static DialogResult Show(string msg, string caption,
      MessageBoxButtons buttons, MessageBoxIcon icon, 
      MessageBoxDefaultButton defBtn)

DialogResult. The method returns one of the enum members Abort, Cancel, Ignore, No, None, OK, Retry, and Yes.

MessageBoxIcon. This enumeration places an icon on the message box. Members include Asterisk, Error, Exclamation, Hand, Information, None, Question, Stop, and Warning.

MessageBoxButtons. This is an enumeration with values that determine which buttons are displayed in the message box. Its members are AbortRetryIgnore, OK, OKCancel, RetryCancel, YesNo, and YesNoCancel. The buttons correspond to the text in the member name. For example, YesNo results in a form with a Yes and No button.

MessageBoxDefaultButton. This an enumeration that defines the default button on the screen. Its members are Button1, Button2, and Button3.

Figure 6-9, which is created with the following statement, provides a visual summary of these parameter options:

MessageBox.Show("OK to Close", "Game Status",  
      MessageBoxButtons.YesNoCancel,MessageBoxIcon.Question,
      MessageBoxDefaultButton.Button2 );

Figure 6-9. MessageBox.Show example

Clicking one of the three buttons returns a value of DialogResult.Yes, DialogResult.No, or DialogResult.Cancel, respectively.

The ShowDialog method permits you to create a custom form that is displayed in modal mode. It is useful when you need a dialog form to display a few custom fields of information. Like the MessageBox, it uses buttons to communicate with the user.

The form used as the dialog box is a standard form containing any controls you want to place on it. Although not required, the form's buttons are usually implemented to return a DialogResult enum value. The following code handles the Click event for the two buttons shown on the form in Figure 6-10:

private void buttonOK_Click(object sender, System.EventArgs e)
{ this.DialogResult = DialogResult.OK; }
private void buttonCancel_Click(object sender, System.EventArgs e)
{ this.DialogResult = DialogResult.Cancel; }

Figure 6-10. Creating a menu with VS.NET

To complete the form, we also need to set a default button and provide a way for the form to be cancelled if the user presses the Esc key. This is done by setting the form's AcceptButton and CancelButton properties in the form's constructor.

AcceptButton = buttonOK;      //Button to receive default focus
CancelButton = buttonCancel;  //Fires when Esc pushed

The code that creates and displays the form is similar to previous examples. The only difference is that the new form instance calls its ShowDialog method and returns a DialogResult type result.

customer cust = new customer();
cust.MinimizeBox = false;
cust.MaximizeBox = false;
if (cust.ShowDialog() == DialogResult.OK) 
{  MessageBox.Show("Returns OK"); }
else
{  MessageBox.Show("Returns Cancel"); }

A discussion of MDI forms is incomplete without considering the requirements for a menu to manage the windows within the container. Minimally, an MDI parent menu should contain a File section for creating and retrieving forms and a Windows section that lists all child forms and permits form selection.

A basic menu is constructed from two classes: the MainMenu class that acts as a container for the whole menu structure and the MenuItem class that represents the menu items in the menu. Both of these classes expose a MenuItems collection property that is used to create the menu hierarchy by adding subitems to each class that represent the menu options. After the menu items are in place, the next step is to tie them to appropriate event handling routines using the familiar delegate approach. Let's step through an example that demonstrates how to create the menu system shown in Figure 6-12. Afterwards, we'll look at creating the menu in Visual Studio.NET. It is certainly much quicker and easier to use VS.NET, but it is less flexible if you need to create menus at runtime.

Figure 6-12. MDI Form menu

The first step is to declare the main menu object and the menu items as class variables. (To avoid repetition, code for all menu items is not shown.)

private MainMenu mainMenu1;
private MenuItem menuItem1;   //File
private MenuItem menuItem2;   //Edit
private MenuItem menuItem3;   //Window
private MenuItem menuItem4;   //File - New

The main menu and menu items are created inside the class constructor:

this.mainMenu1 = new System.Windows.Forms.MainMenu();
this.menuItem1 = new System.Windows.Forms.MenuItem("File");
this.menuItem2 = new System.Windows.Forms.MenuItem("Edit");
this.menuItem3 = new System.Windows.Forms.MenuItem("Window");
this.menuItem4 = new System.Windows.Forms.MenuItem("New");

Next, the menu hierarchy is established by adding menu items to the main menu object to create the menu bar. The menu bar items then have menu items added to their MenuItems collection, which creates the drop-down menu.

//Add menu items to main menu object
this.mainMenu1.MenuItems.AddRange(new 
      System.Windows.Forms.MenuItem[] {
         this.menuItem1,
         this.menuItem2,
         this.menuItem3});
//Add menu item below File   
this.menuItem1.MenuItems.Add(this.menuItem4);
//Add menu items to Window menu item
this.menuItem3.MdiList = true;    //Causes child forms to display
this.menuItem3.MenuItems.AddRange(new
System.Windows.Forms.MenuItem[] {this.menuItem5,
      this.menuItem6, this.menuItem7, this.menuItem8});
//Set menu on form
this.Menu = this.mainMenu1;

The main points to observe in this code are:

The final step is to set up event handling code that provides logic to support the menu operations. Here is the code to define a delegate and method to support an event fired by clicking the File–New menu item. The code creates a new instance of invForm each time this menu item is clicked.

//Following is defined in constructor
MenuItem4.Click += new System.EventHandler(menuItem4_Click);

private void menuItem4_Click(object sender, System.EventArgs e)
{
   invForm myForm = new invForm();
   myForm.MdiParent = this;
   mdiCt += mdiCt;   //Count number of forms created
   myForm.Text= "Invoice" + mdiCt.ToString();
   myForm.Show();
}

The Window option on the menu bar has submenu items that let you rearrange the child forms within the MDI container. The LayoutMdi method of a form makes implementing this almost trivial. After setting up delegates in the usual manner, create the event handling routines:

private void menuItem6_Click(object sender, System.EventArgs e){
   this.LayoutMdi(MdiLayout.ArrangeIcons);
}

private void menuItem6_Click(object sender, System.EventArgs e){
   this.LayoutMdi(MdiLayout.Cascade);
}

private void menuItem7_Click(object sender, System.EventArgs e){
   this.LayoutMdi(MdiLayout.TileHorizontal);
}

private void menuItem8_Click(object sender, System.EventArgs e){
   this.LayoutMdi(MdiLayout.TileVertical);
}

The methods reorder the window by passing the appropriate MdiLayout enumeration value to the LayoutMdi method.

With the Form Designer open, double click the MainMenu icon in the Toolbox window. Two things happen: An icon appears in the component tray at the bottom and a menu template appears docked to the top of the form. Type the menu item titles into the cells that appear (see Figure 6-13). The top horizontal row of cells represents the menu bar; by moving vertically, you create drop-down menu items below the top-level items. After typing in the item name, double click the cell to create a Click event for the menu item. VS.NET creates the delegate and method stub automatically.

Figure 6-13. Creating a menu with VS.NET

Use the Property Window (press F4), which displays properties of the active cell, to change the default names assigned to menu items and set any other values.

Creating a context menu is similar to creating a MainMenu. If using VS.NET, you drag the ContextMenu control to the form and visually add menu items. If coding by hand, you create an instance of the ContextMenu class and add menu items using the MenuItems.Add method. Following is a sampling of the code used to create the menu. Note that a single method handles the Click event on each menu item.

private ContextMenu contextMenu1;  //Context menu 
private TextBox txtSearch;         //Text box that will use menu
// Following is in constructor
contextMenu1 = new ContextMenu();
// Add menu items and event handler using Add method
contextMenu1.MenuItems.Add("Azure Background", 
      new System.EventHandler(this.menuItem_Click));
contextMenu1.MenuItems.Add("White Background", 
      new System.EventHandler(this.menuItem_Click));
contextMenu1.MenuItems.Add("Beige Background", 
      new System.EventHandler(this.menuItem_Click));

The completed menu is attached to a control by setting the control's ContextMenu property to the context menu:

//Associate text box with a context menu
this.txtSearch.ContextMenu = this.contextMenu1;

A right-click on txtSearch causes the menu to pop up. Click one of the menu items and this event handling routine is called:

private void menuItem_Click(object sender, System.EventArgs e)
{
   //Sender identifies specific menu item selected
   MenuItem conMi = (MenuItem) sender;
   string txt = conMi.Text;
   //SourceControl is control associated with this event
   if(txt == "Azure Background")        this.contextMenu1.SourceControl.BackColor = Color
.Azure;
   if(txt == "White Background")        this.contextMenu1.SourceControl.BackColor = Color
.White;
   if(txt == "Beige Background")        this.contextMenu1.SourceControl.BackColor = Color
.Beige;
}

The two most important things to note in this example are that the argument sender identifies the selected menu item and that the context menu property SourceControl identifies the control associated with the event. This capability to identify the control and the menu item enables one method to handle events from any control on the form or any menu item in the context menu.

Suppose the base form contains a button that responds to a click by calling event handler code to close the form. However, in your derived form, you want to add some data verification checks before the form closes. One's instinct is to add a delegate and event handler method to respond to the button Click event in the derived form. However, this does not override the original event handler in the base form, and both event handling routines get called. The solution is to restructure the original event handler to call a virtual method that can be overridden in the derived form. Here is sample code for the base form:

private void btn1_Clicked(object sender, System.EventArgs e)
{
   ButtonClicks();   // Have virtual method do actual work
}
protected virtual void ButtonClicks()
{
   this.Close();
}

The derived form simply overrides the virtual method and includes its own code to handle the event:

protected override void ButtonClicks() {
   // Code to perform any data validation
   this.Close();
}

To create an inherited form using Visual Studio, open a project containing the form to serve as the base and compile it. Then, select Project-Add Inherited Form from the menu. Give the new form a name and open it. Next, an Inheritance Picker dialog box appears that lists the eligible base forms. Use the Browse feature to display forms that are in external libraries.

Select a base form and the new inherited form appears in the designer window. All of the controls on the form are marked with a plus (+), and you will find that only properties on the form itself are exposed. At this point, you can add controls or modify existing ones using the techniques just described.