This chapter continues our study of GUIs. We start with menus, which present users with logically organized commands (or options). We show how to develop menus with the tools provided by Visual Studio. Next, we discuss how to input and display dates and times using the MonthCalendar and DateTimePicker controls. We also introduce LinkLabels—powerful GUI components that enable the user to access one of several destinations, such as a file on the current machine or a web page, by simply clicking the mouse.

We demonstrate how to manipulate a list of values via a ListBox and how to combine several checkboxes in a CheckedListBox. We also create drop-down lists using ComboBoxes and display data hierarchically with a TreeView control. You’ll learn two other important GUI elements—tab controls and multiple document interface (MDI) windows. These components enable you to create real-world programs with sophisticated GUIs.

Visual Studio provides many GUI components, several of which are discussed in this (and the previous) chapter. You can also design custom controls and add them to the ToolBox, as we demonstrate in this chapter’s last example. The techniques presented here form the groundwork for creating more substantial GUIs and custom controls.

Menus provide groups of related commands for Windows applications. Although these commands depend on the program, some—such as Open and Save—are common to many applications. Menus are an integral part of GUIs, because they organize commands without “cluttering” the GUI.

In Fig. 15.1, an expanded menu from the Visual C# IDE lists various commands (called menu items), plus submenus (menus within a menu). The top-level menus appear in the left portion of the figure, whereas any submenus or menu items are displayed to the right. The menu that contains a menu item is called that menu item’s parent menu. A menu item that contains a submenu is considered to be the parent of that submenu.

Figure 15.1. Menus, submenus and menu items.

Menus can have Alt key shortcuts (also called access shortcuts, keyboard shortcuts or hotkeys), which are accessed by pressing Alt and the underlined letter—for example, Alt F typically expands the File menu. Menu items can have shortcut keys as well (combinations of Ctrl, Shift, Alt, F1, F2, letter keys, and so on). Some menu items display checkmarks, usually indicating that multiple options on the menu can be selected at once.

To create a menu, open the Toolbox and drag a MenuStrip control onto the Form. This creates a menu bar across the top of the Form (below the title bar) and places a MenuStrip icon in the component tray. To select the MenuStrip, click this icon. You can now use Design mode to create and edit menus for your application. Menus, like other controls, have properties and events, which can be accessed through the Properties window.

To add menu items to the menu, click the Type Here TextBox (Fig. 15.2) and type the menu item’s name. This action adds an entry to the menu of type ToolStripMenuItem. After you press the Enter key, the menu item name is added to the menu. Then more Type Here TextBoxes appear, allowing you to add items underneath or to the side of the original menu item (Fig. 15.3).

Figure 15.2. Editing menus in Visual Studio.

Figure 15.3. Adding ToolStripMenuItems to a MenuStrip.

To create an access shortcut, type an ampersand (&) before the character to be underlined. For example, to create the File menu item with the letter F underlined, type &File. To display an ampersand, type &&. To add other shortcut keys (e.g., <Ctrl> F9) for menu items, set the ShortcutKeys property of the appropriate ToolStripMenuItems. To do this, select the down arrow to the right of this property in the Properties window. In the window that appears (Fig. 15.4), use the CheckBoxes and drop-down list to select the shortcut keys. When you are finished, click elsewhere on the screen. You can hide the shortcut keys by setting property ShowShortcutKeys to false, and you can modify how the shortcut keys are displayed in the menu item by modifying property ShortcutKeyDisplayString.

Figure 15.4. Setting a menu item’s shortcut keys.

Look-and-Feel Observation 15.1

Buttons can have access shortcuts. Place the & symbol immediately before the desired character in the Button's text. To press the button by using its access key in the running application, the user presses Alt and the underlined character. If the underline is not visible when the application runs, press the Alt key to display the underlines.

You can remove a menu item by selecting it with the mouse and pressing the Delete key. Menu items can be grouped logically by separator bars, which are inserted by right clicking the menu and selecting Insert > Separator or by typing “-” for the text of a menu item.

In addition to text, Visual Studio allows you to easily add TextBoxes and ComboBoxes (drop-down lists) as menu items. When adding an item in Design mode, you may have noticed that before you enter text for a new item, you are provided with a drop-down list. Clicking the down arrow (Fig. 15.5) allows you to select the type of item to add—Menu-Item (of type ToolStripMenuItem, the default), ComboBox (of type ToolStripComboBox) and TextBox (of type ToolStripTextBox). We focus on ToolStripMenuItems. [Note: If you view this drop-down list for menu items that are not on the top level, a fourth option appears, allowing you to insert a separator bar.]

Figure 15.5. Menu-item options.

ToolStripMenuItems generate a Click event when selected. To create an empty Click event handler, double click the menu item in Design mode. Common actions in response to these events include displaying dialogs and setting properties. Common menu properties and a common event are summarized in Fig. 15.6.

Look-and-Feel Observation 15.2

It is a convention to place an ellipsis (...) after the name of a menu item (e.g., Save As...) that requires the user to provide more information—typically through a dialog. A menu item that produces an immediate action without prompting the user for more information (e.g., Save) should not have an ellipsis following its name.

Class MenuTestForm (Fig. 15.7) creates a simple menu on a Form. The Form has a top-level File menu with menu items About (which displays a MessageBox) and Exit (which terminates the program). The program also includes a Format menu, which contains menu items that change the format of the text on a Label. The Format menu has submenus Color and Font, which change the color and font of the text on a Label.

Example 15.7. Menus for changing text font and color.

 1   // Fig. 15.7: MenuTestForm.cs
 2   // Using Menus to change font colors and styles.
 3   using System;
 4   using System.Drawing;
 5   using System.Windows.Forms;
 6
 7   namespace MenuTest
 8   {
 9      // our Form contains a Menu that changes the font color
10      // and style of the text displayed in Label
11      public partial class MenuTestForm : Form
12      {
13         // constructor
14         public MenuTestForm()
15         {
16            InitializeComponent();
17         } // end constructor
18
19         // display MessageBox when About ToolStripMenuItem is selected
20         private void aboutToolStripMenuItem_Click(
21            object sender, EventArgs e )
22         {
23            MessageBox.Show( "This is an example
of using menus.", "About",
24               MessageBoxButtons.OK, MessageBoxIcon.Information );
25         } // end method aboutToolStripMenuItem_Click
26
27         // exit program when Exit ToolStripMenuItem is selected
28         private void exitToolStripMenuItem_Click(
29            object sender, EventArgs e )
30         {
31            Application.Exit();
32         } // end method exitToolStripMenuItem_Click
33
34         // reset checkmarks for Color ToolStripMenuItems
35         private void ClearColor()
36         {
37            // clear all checkmarks
38            blackToolStripMenuItem.Checked = false;
39            blueToolStripMenuItem.Checked = false; 
40            redToolStripMenuItem.Checked = false;  
41            greenToolStripMenuItem.Checked = false;
42         } // end method ClearColor
43
44         // update Menu state and color display black
45         private void blackToolStripMenuItem_Click(
46            object sender, EventArgs e )
47         {
48            // reset checkmarks for Color ToolStripMenuItems
49            ClearColor();
50
51            // set color to Black
52            displayLabel.ForeColor = Color.Black;
53            blackToolStripMenuItem.Checked = true;
54         } // end method blackToolStripMenuItem_Click
55
56         // update Menu state and color display blue
57         private void blueToolStripMenuItem_Click(
58            object sender, EventArgs e )
59         {
60            // reset checkmarks for Color ToolStripMenuItems
61            ClearColor();
62
63            // set color to Blue
64            displayLabel.ForeColor = Color.Blue;
65            blueToolStripMenuItem.Checked = true;
66         } // end method blueToolStripMenuItem_Click
67
68         // update Menu state and color display red
69         private void redToolStripMenuItem_Click(
70            object sender, EventArgs e )
71         {
72            // reset checkmarks for Color ToolStripMenuItems
73            ClearColor();
74
75            // set color to Red
76            displayLabel.ForeColor = Color.Red;
77            redToolStripMenuItem.Checked = true;
78         } // end method redToolStripMenuItem_Click
79
80         // update Menu state and color display green
81         private void greenToolStripMenuItem_Click(
82            object sender, EventArgs e )
83         {
84            // reset checkmarks for Color ToolStripMenuItems
85            ClearColor();
86
87            // set color to Green
88            displayLabel.ForeColor = Color.Green;
89            greenToolStripMenuItem.Checked = true;
90         } // end method greenToolStripMenuItem_Click
91
92         // reset checkmarks for Font ToolStripMenuItems
93         private void ClearFont()
94         {
95            // clear all checkmarks
96            timesToolStripMenuItem.Checked = false;  
97            courierToolStripMenuItem.Checked = false;
98            comicToolStripMenuItem.Checked = false;  
99         } // end method ClearFont
100
101        // update Menu state and set Font to Times New Roman
102        private void timesToolStripMenuItem_Click(
103           object sender, EventArgs e )
104        {
105           // reset checkmarks for Font ToolStripMenuItems
106           ClearFont();
107
108           // set Times New Roman font
109           timesToolStripMenuItem.Checked = true;
110           displayLabel.Font = new Font( "Times New Roman", 14,
111              displayLabel.Font.Style );
112        } // end method timesToolStripMenuItem_Click
113
114        // update Menu state and set Font to Courier
115        private void courierToolStripMenuItem_Click(
116           object sender, EventArgs e )
117        {
118           // reset checkmarks for Font ToolStripMenuItems
119           ClearFont();
120
121           // set Courier font
122           courierToolStripMenuItem.Checked = true;
123           displayLabel.Font = new Font( "Courier", 14,
124              displayLabel.Font.Style );
125        } // end method courierToolStripMenuItem_Click
126
127        // update Menu state and set Font to Comic Sans MS
128        private void comicToolStripMenuItem_Click(
129           object sender, EventArgs e )
130        {
131           // reset checkmarks for Font ToolStripMenuItems
132           ClearFont();
133
134           // set Comic Sans font
135           comicToolStripMenuItem.Checked = true;
136           displayLabel.Font = new Font( "Comic Sans MS", 14,
137              displayLabel.Font.Style );
138        } // end method comicToolStripMenuItem_Click
139
140        // toggle checkmark and toggle bold style
141        private void boldToolStripMenuItem_Click(
142           object sender, EventArgs e )
143        {
144           // toggle checkmark
145           boldToolStripMenuItem.Checked = !boldToolStripMenuItem.Checked;
146
147           // use Xor to toggle bold, keep all other styles
148           displayLabel.Font = new Font( displayLabel.Font
149              displayLabel.Font.Style ^ FontStyle.Bold );
150        } // end method boldToolStripMenuItem_Click
151
152        // toggle checkmark and toggle italic style
153        private void italicToolStripMenuItem_Click(
154           object sender, EventArgs e )
155        {
156           // toggle checkmark
157           italicToolStripMenuItem.Checked =
158              !italicToolStripMenuItem.Checked;
159
160           // use Xor to toggle italic, keep all other styles
161           displayLabel.Font = new Font( displayLabel.Font
162              displayLabel.Font.Style ^ FontStyle.Italic );
163        } // end method italicToolStripMenuItem_Click
164     } // end class MenuTestForm
165  } // end namespace MenuTest

a)

b)

c)

d)

e)

f)

Color Submenu Events

We made the items in the Color submenu (Black, Blue, Red and Green) mutually exclusive—the user can select only one at a time (we explain how we did this shortly). To indicate that a menu item is selected, we will set each Color menu item’s Checked property to true. This causes a check to appear to the left of a menu item.

Each Color menu item has its own Click event handler. The method handler for color Black is blackToolStripMenuItem_Click (lines 45–54). Similarly, the event handlers for colors Blue, Red and Green are blueToolStripMenuItem_Click (lines 57–66), redToolStripMenuItem_Click (lines 69–78) and greenToolStripMenuItem_Click (lines 81–90), respectively. Each Color menu item must be mutually exclusive, so each event handler calls method ClearColor (lines 35–42) before setting its corresponding Checked property to true. Method ClearColor sets the Checked property of each color ToolStripMenuItem to false, effectively preventing more than one menu item from being selected at a time. In the designer, we initially set the Black menu item’s Checked property to true, because at the start of the program, the text on the Form is black.

Software Engineering Observation 15.1

The mutual exclusion of menu items is not enforced by the MenuStrip, even when the Checked property is true. You must program this behavior.

Many applications must perform date and time calculations. The .NET Framework provides two controls that allow an application to retrieve date and time information—the MonthCalendar and DateTimePicker (Section 15.4) controls.

The MonthCalendar (Fig. 15.8) control displays a monthly calendar on the Form. The user can select a date from the currently displayed month or can use the provided arrows to navigate to another month. When a date is selected, it is highlighted. Multiple dates can be selected by clicking dates on the calendar while holding down the Shift key. The default event for this control is the DateChanged event, which is generated when a new date is selected. Properties are provided that allow you to modify the appearance of the calendar, how many dates can be selected at once, and the minimum date and maximum date that may be selected. MonthCalendar properties and a common MonthCalendar event are summarized in Fig. 15.9.

Figure 15.8. MonthCalendar control.

The DateTimePicker control (see output of Fig. 15.11) is similar to the MonthCalendar control but displays the calendar when a down arrow is selected. The DateTimePicker can be used to retrieve date and time information from the user. A DateTimePicker’s Value property stores a DateTime object, which always contains both date and time information. You can retrieve the date information from the DateTime object by using property Date, and you can retrieve only the time information by using the TimeOfDay property.

The DateTimePicker is also more customizable than a MonthCalendar control—more properties are provided to edit the look and feel of the drop-down calendar. Property Format specifies the user’s selection options using the DateTimePickerFormat enumeration. The values in this enumeration are Long (displays the date in long format, as in Thursday, July 10, 2010), Short (displays the date in short format, as in 7/10/2010), Time (displays a time value, as in 5:31:02 PM) and Custom (indicates that a custom format will be used). If value Custom is used, the display in the DateTimePicker is specified using property CustomFormat. The default event for this control is ValueChanged, which occurs when the selected value (whether a date or a time) is changed. DateTimePicker properties and a common event are summarized in Fig. 15.10.

Figure 15.11 demonstrates using a DateTimePicker to select an item’s drop-off time. Many companies use such functionality—several online DVD rental companies specify the day a movie is sent out and the estimated time that it will arrive at your home. The user selects a drop-off day, then an estimated arrival date is displayed. The date is always two days after drop-off, three days if a Sunday is reached (mail is not delivered on Sunday).

Example 15.11. Demonstrating DateTimePicker.

 1   // Fig. 15.11: DateTimePickerForm.cs
 2   // Using a DateTimePicker to select a drop-off time.
 3   using System;
 4   using System.Windows.Forms;
 5
 6   namespace DateTimePickerTest
 7   {
 8      // Form lets user select a drop-off date using a DateTimePicker
 9      // and displays an estimated delivery date
10      public partial class DateTimePickerForm : Form
11      {
12         // constructor
13         public DateTimePickerForm()
14         {
15            InitializeComponent();
16         } // end constructor
17
18         private void dateTimePickerDropOff_ValueChanged(
19            object sender, EventArgs e )
20         {
21            DateTime dropOffDate = dateTimePickerDropOff.Value;
22
23            // add extra time when items are dropped off around Sunday
24            if ( dropOffDate.DayOfWeek == DayOfWeek.Friday ||
25               dropOffDate.DayOfWeek == DayOfWeek.Saturday ||
26               dropOffDate.DayOfWeek == DayOfWeek.Sunday )
27
28               //estimate three days for delivery
29               outputLabel.Text =
30                  dropOffDate.AddDays( 3 ).ToLongDateString();
31            else
32               // otherwise estimate only two days for delivery
33               outputLabel.Text =
34                  dropOffDate.AddDays( 2 ).ToLongDateString();
35         } // end method dateTimePickerDropOff_ValueChanged
36
37         private void DateTimePickerForm_Load( object sender, EventArgs e )
38         {
39            // user cannot select days before today
40            dateTimePickerDropOff.MinDate = DateTime.Today;
41
42            // user can only select days of this year
43            dateTimePickerDropOff.MaxDate = DateTime.Today.AddYears( 1 );
44         } // end method DateTimePickerForm_Load
45      } // end class DateTimePickerForm
46   } // end namespace DateTimePickerTest

a)

b)

c)

d)

The DateTimePicker (dropOffDateTimePicker) has its Format property set to Long, so the user can select a date and not a time in this application. When the user selects a date, the ValueChanged event occurs. The event handler for this event (lines 18–35) first retrieves the selected date from the DateTimePicker’s Value property (line 21). Lines 24–26 use the DateTime structure’s DayOfWeek property to determine the day of the week on which the selected date falls. The day values are represented using the DayOfWeek enumeration. Lines 29–30 and 33–34 use DateTime’s AddDays method to increase the date by three days or two days, respectively. The resulting date is then displayed in Long format using method ToLongDateString.

In this application, we do not want the user to be able to select a drop-off day before the current day, or one that is more than a year into the future. To enforce this, we set the DateTimePicker’s MinDate and MaxDate properties when the Form is loaded (lines 40 and 43). Property Today returns the current day, and method AddYears (with an argument of 1) is used to specify a date one year in the future.

Let’s take a closer look at the output. This application begins by displaying the current date (Fig. 15.11(a)). In Fig. 15.11(b), we selected the 30th of July. In Fig. 15.11(c), the estimated arrival date is displayed as the 2nd of August. Figure 15.11(d) shows that the 30th, after it is selected, is highlighted in the calendar.

The LinkLabel control displays links to other resources, such as files or web pages (Fig. 15.12). A LinkLabel appears as underlined text (colored blue by default). When the mouse moves over the link, the pointer changes to a hand; this is similar to the behavior of a hyperlink in a web page. The link can change color to indicate whether it is not yet visited, previously visited or active. When clicked, the LinkLabel generates a LinkClicked event (see Fig. 15.13). Class LinkLabel is derived from class Label and therefore inherits all of class Label’s functionality.

Figure 15.12. LinkLabel control in running program.

Look-and-Feel Observation 15.3

A LinkLabel is the preferred control for indicating that the user can click a link to jump to a resource such as a web page, though other controls can perform similar tasks.

Class LinkLabelTestForm (Fig. 15.14) uses three LinkLabels to link to the C: drive, the Deitel website (www.deitel.com) and the Notepad application, respectively. The Text properties of the LinkLabel’s cDriveLinkLabel, deitelLinkLabel and notepadLinkLabel describe each link’s purpose.

Example 15.14. LinkLabels used to link to a drive, a web page and an application.

 1   // Fig. 15.14: LinkLabelTestForm.cs
 2   // Using LinkLabels to create hyperlinks.
 3   using System;
 4   using System.Windows.Forms;
 5
 6   namespace LinkLabelTest
 7   {
 8      // Form using LinkLabels to browse the C:drive,
 9      // load a web page and run Notepad
10      public partial class LinkLabelTestForm : Form
11      {
12         // constructor
13         public LinkLabelTestForm()
14         {
15            InitializeComponent();
16         } // end constructor
17
18         // browse C:drive
19         private void cDriveLinkLabel_LinkClicked( object sender,
20            LinkLabelLinkClickedEventArgs e )
21         {
22            // change LinkColor after it has been clicked
23            driveLinkLabel.LinkVisited = true;         
24                                                       
25            System.Diagnostics.Process.Start( @"C:" );
26         } // end method cDriveLinkLabel_LinkClicked
27
28         // load www.deitel.com in web browser
29         private void deitelLinkLabel_LinkClicked( object sender,
30            LinkLabelLinkClickedEventArgs e )
31         {
32            // change LinkColor after it has been clicked
33            deitelLinkLabel.LinkVisited = true;                         
34                                                                        
35            System.Diagnostics.Process.Start( "http://www.deitel.com" );
36         } // end method deitelLinkLabel_LinkClicked
37
38         // run application Notepad
39         private void notepadLinkLabel_LinkClicked( object sender,
40            LinkLabelLinkClickedEventArgs e )
41         {
42            // change LinkColor after it has been clicked
43            notepadLinkLabel.LinkVisited = true;          
44                                                          
45            // program called as if in run                
46            // menu and full path not needed              
47            System.Diagnostics.Process.Start( "notepad" );
48         } // end method driveLinkLabel_LinkClicked
49      } // end class LinkLabelTestForm
50   } // end namespace LinkLabelTest

The event handlers for the LinkLabels call method Start of class Process (namespace System.Diagnostics), which allows you to execute other programs, or load documents or web sites from an application. Method Start can take one argument, the file to open, or two arguments, the application to run and its command-line arguments. Method Start’s arguments can be in the same form as if they were provided for input to the Windows Run command (Start > Run...). For applications that are known to Windows, full path names are not needed, and the file extension often can be omitted. To open a file of a type that Windows recognizes (and knows how to handle), simply use the file’s full path name. For example, if you a pass the method a .doc file, Windows will open it in Microsoft Word (or whatever program is registered to open .doc files, if any). The Windows operating system must be able to use the application associated with the given file’s extension to open the file.

The event handler for cDriveLinkLabel’s LinkClicked event browses the C: drive (lines 19–26). Line 23 sets the LinkVisited property to true, which changes the link’s color from blue to purple (the LinkVisited colors can be configured through the Properties window in Visual Studio). The event handler then passes @"C:" to method Start (line 25), which opens a Windows Explorer window. The @ symbol that we placed before "C:" indicates that all characters in the string should be interpreted literally—this is known as a verbatim string. Thus, the backslash within the string is not considered to be the first character of an escape sequence. This simplifies strings that represent directory paths, since you do not need to use \ for each character in the path.

The event handler for deitelLinkLabel’s LinkClicked event (lines 29–36) opens the web page www.deitel.com in the user’s default web browser. We achieve this by passing the web-page address as a string (line 35), which opens the web page in a new web browser window or tab. Line 33 sets the LinkVisited property to true.

The event handler for notepadLinkLabel's LinkClicked event (lines 39–48) opens the Notepad application. Line 43 sets the LinkVisited property to true so that the link appears as a visited link. Line 47 passes the argument "notepad" to method Start, which runs notepad.exe. In line 47, neither the full path nor the .exe extension is required—Windows automatically recognizes the argument given to method Start as an executable file.

The ListBox control allows the user to view and select from multiple items in a list. ListBoxes are static GUI entities, which means that users cannot directly edit the list of items. The user can be provided with TextBoxes and Buttons with which to specify items to be added to the list, but the actual additions must be performed in code. The CheckedListBox control (Section 15.7) extends a ListBox by including CheckBoxes next to each item in the list. This allows users to place checks on multiple items at once, as is possible with CheckBox controls. (Users also can select multiple items from a ListBox by setting the ListBox’s SelectionMode property, which is discussed shortly.) Figure 15.15 displays a ListBox and a CheckedListBox. In both controls, scrollbars appear if the number of items exceeds the ListBox’s viewable area.

Figure 15.15. ListBox and CheckedListBox on a Form.

Figure 15.16 lists common ListBox properties and methods and a common event. The SelectionMode property determines the number of items that can be selected. This property has the possible values None, One, MultiSimple and MultiExtended (from the SelectionMode enumeration)—the differences among these settings are explained in Fig. 15.16. The SelectedIndexChanged event occurs when the user selects a new item.

Both the ListBox and CheckedListBox have properties Items, SelectedItem and SelectedIndex. Property Items returns a collection of the list items. Collections are a common way to manage lists of objects in the .NET framework. Many .NET GUI components (e.g., ListBoxes) use collections to expose lists of internal objects (e.g., items in a ListBox). We discuss collections further in Chapter 23. The collection returned by property Items is represented as an object of type ListBox.ObjectCollection. Property SelectedItem returns the ListBox’s currently selected item. If the user can select multiple items, use collection SelectedItems to return all the selected items as a ListBox.SelectedObjectColection. Property SelectedIndex returns the index of the selected item—if there could be more than one, use property SelectedIndices, which returns a ListBox.SelectedIndexColection. If no items are selected, property SelectedIndex returns -1. Method GetSelected takes an index and returns true if the corresponding item is selected.

Adding Items to ListBoxes and CheckedListBoxes

To add items to a ListBox or to a CheckedListBox, we must add objects to its Items collection. This can be accomplished by calling method Add to add a string to the ListBox’s or CheckedListBox’s Items collection. For example, we could write

myListBox.Items.Add( myListItem );

to add string myListItem to ListBox myListBox. To add multiple objects, you can either call method Add multiple times or call method AddRange to add an array of objects. Classes ListBox and CheckedListBox each call the submitted object’s ToString method to determine the Label for the corresponding object’s entry in the list. This allows you to add different objects to a ListBox or a CheckedListBox that later can be returned through properties SelectedItem and SelectedItems.

Alternatively, you can add items to ListBoxes and CheckedListBoxes visually by examining the Items property in the Properties window. Clicking the ellipsis button opens the String Collection Editor, which contains a text area for adding items; each item appears on a separate line (Fig. 15.17). Visual Studio then writes code to add these strings to the Items collection inside method InitializeComponent.

Figure 15.17. String Collection Editor.

Figure 15.18 uses class ListBoxTestForm to add, remove and clear items from ListBox displayListBox. Class ListBoxTestForm uses TextBox inputTextBox to allow the user to type in a new item. When the user clicks the Add Button, the new item appears in displayListBox. Similarly, if the user selects an item and clicks Remove, the item is deleted. When clicked, Clear deletes all entries in displayListBox. The user terminates the application by clicking Exit.

Example 15.18. Program that adds, removes and clears ListBox items.

 1   // Fig. 15.18: ListBoxTestForm.cs
 2   // Program to add, remove and clear ListBox items
 3   using System;
 4   using System.Windows.Forms;
 5
 6   namespace ListBoxTest
 7   {
 8      // Form uses a TextBox and Buttons to add,
 9      // remove, and clear ListBox items
10      public partial class ListBoxTestForm : Form
11      {
12         // constructor
13         public ListBoxTestForm()
14         {
15            InitializeComponent();
16         } // end constructor
17
18         // add new item to ListBox (text from input TextBox)
19         // and clear input TextBox
20         private void addButton_Click( object sender, EventArgs e )
21         {
22            displayListBox.Items.Add( inputTextBox.Text );
23            inputTextBox.Clear();
24         } // end method addButton_Click
25
26         // remove item if one is selected
27         private void removeButton_Click( object sender, EventArgs e )
28         {
29            // check whether item is selected, remove if    
30            if ( displayListBox.SelectedIndex != -1 )       
31               displayListBox.Items.RemoveAt(               
32                  displayListBox.SelectedIndex );           
33         } // end method removeButton_Click
34
35         // clear all items in ListBox
36         private void clearButton_Click( object sender, EventArgs e )
37         {
38            displayListBox.Items.Clear();
39         } // end method clearButton_Click
40
41         // exit application
42         private void exitButton_Click( object sender, EventArgs e )
43         {
44            Application.Exit();
45         } // end method exitButton_Click
46      } // end class ListBoxTestForm
47   } // end namespace ListBoxTest

a)

b)

c)

d)

The addButton_Click event handler (lines 20–24) calls method Add of the Items collection in the ListBox. This method takes a string as the item to add to displayListBox. In this case, the string used is the user input from the inputTextBox (line 22). After the item is added, inputTextBox.Text is cleared (line 23).

The removeButton_Click event handler (lines 27–33) uses method RemoveAt to remove an item from the ListBox. Event handler removeButton_Click first uses property SelectedIndex to determine which index is selected. If SelectedIndex is not –1 (i.e., an item is selected), lines 31–32 remove the item that corresponds to the selected index.

The clearButton_Click event handler (lines 36–39) calls method Clear of the Items collection (line 38). This removes all the entries in displayListBox. Finally, event handler exitButton_Click (lines 42–45) terminates the application by calling method Application.Exit (line 44).

The CheckedListBox control derives from ListBox and displays a CheckBox with each item. Items can be added via methods Add and AddRange or through the String Collection Editor. CheckedListBoxes allow multiple items to be checked, but item selection is more restrictive. The only values for the SelectionMode property are None and One. One allows a single selection, whereas None allows no selections. Because an item must be selected to be checked, you must set the SelectionMode to be One if you wish to allow users to check items. Thus, toggling property SelectionMode between One and None effectively switches between enabling and disabling the user’s ability to check list items. Common properties, a method and an event of CheckedListBoxes appear in Fig. 15.19.

Common Programming Error 15.1

The IDE displays an error message if you attempt to set the SelectionMode property to MultiSimple or MultiExtended in the Properties window of a CheckedListBox. If this value is set programmatically, a runtime error occurs.

Event ItemCheck occurs whenever a user checks or unchecks a CheckedListBox item. Event-argument properties CurrentValue and NewValue return CheckState values for the current and new state of the item, respectively. A comparison of these values allows you to determine whether the CheckedListBox item was checked or unchecked. The CheckedListBox control retains the SelectedItems and SelectedIndices properties (it inherits them from class ListBox). However, it also includes properties CheckedItems and CheckedIndices, which return information about the checked items and indices.

In Fig. 15.20, class CheckedListBoxTestForm uses a CheckedListBox and a ListBox to display a user’s selection of books. The CheckedListBox allows the user to select multiple titles. In the String Collection Editor, items were added for some Deitel books: C, C++, Java™, Internet & WWW, VB 2008, Visual C++ and Visual C# 2008 (the acronym HTP stands for “How to Program”). The ListBox (named displayListBox) displays the user’s selection. In the screenshots accompanying this example, the CheckedListBox appears to the left, the ListBox on the right.

Example 15.20. CheckedListBox and ListBox used in a program to display a user selection.

 1   // Fig. 15.20: CheckedListBoxTestForm.cs
 2   // Using a CheckedListBox to add items to a display ListBox
 3   using System;
 4   using System.Windows.Forms;
 5
 6   namespace CheckedListBoxTest
 7   {
 8      // Form uses a checked ListBox to add items to a display ListBox
 9      public partial class CheckedListBoxTestForm : Form
10      {
11         // constructor
12         public CheckedListBoxTestForm()
13         {
14            InitializeComponent();
15         } // end constructor
16
17         // item about to change
18         // add or remove from display ListBox
19         private void itemCheckedListBox_ItemCheck(
20            object sender, ItemCheckEventArgs e )
21         {
22            // obtain reference of selected item
23            string item = itemCheckedListBox.SelectedItem.ToString();
24
25            // if item checked, add to ListBox
26            // otherwise remove from ListBox
27            if ( e.NewValue == CheckState.Checked )
28               displayListBox.Items.Add( item );
29            else
30               displayListBox.Items.Remove( item );
31         } // end method itemCheckedListBox_ItemCheck
32      } // end class CheckedListBoxTestForm
33   } // end namespace CheckedListBoxTest

a)

b)

c)

d)

When the user checks or unchecks an item in itemCheckedListBox_ItemCheck, an ItemCheck event occurs and event handler itemCheckedListBox_ItemCheck (lines 19–31) executes. An if...else statement (lines 27–30) determines whether the user checked or unchecked an item in the CheckedListBox. Line 27 uses the NewValue property to determine whether the item is being checked (CheckState.Checked). If the user checks an item, line 28 adds the checked entry to the ListBox displayListBox. If the user unchecks an item, line 30 removes the corresponding item from displayListBox. This event handler was created by selecting the CheckedListBox in Design mode, viewing the control’s events in the Properties window and double clicking the ItemCheck event. The default event for a CheckedListBox is a SelectedIndexChanged event.

The ComboBox control combines TextBox features with a drop-down list—a GUI component that contains a list from which a value can be selected. A ComboBox usually appears as a TextBox with a down arrow to its right. By default, the user can enter text into the TextBox or click the down arrow to display a list of predefined items. If a user chooses an element from this list, that element is displayed in the TextBox. If the list contains more elements than can be displayed in the drop-down list, a scrollbar appears. The maximum number of items that a drop-down list can display at one time is set by property MaxDropDownItems. Figure 15.21 shows a sample ComboBox in three different states.

Figure 15.21. ComboBox demonstration.

As with the ListBox control, you can add objects to collection Items programmatically, using methods Add and AddRange, or visually, with the String Collection Editor. Figure 15.22 lists common properties and a common event of class ComboBox.

Look-and-Feel Observation 15.4

Use a ComboBox to save space on a GUI. A disadvantage is that, unlike with a ListBox, the user cannot see available items without expanding the drop-down list.

Property DropDownStyle determines the type of ComboBox and is represented as a value of the ComboBoxStyle enumeration, which contains values Simple, DropDown and DropDownList. Option Simple does not display a drop-down arrow. Instead, a scrollbar appears next to the control, allowing the user to select a choice from the list. The user also can type in a selection. Style DropDown (the default) displays a drop-down list when the down arrow is clicked (or the down arrow key is pressed). The user can type a new item in the ComboBox. The last style is DropDownList, which displays a drop-down list but does not allow the user to type in the TextBox.

The ComboBox control has properties Items (a collection), SelectedItem and SelectedIndex, which are similar to the corresponding properties in ListBox. There can be at most one selected item in a ComboBox. If no items are selected, then SelectedIndex is -1. When the selected item changes, a SelectedIndexChanged event occurs.

Class ComboBoxTestForm (Fig. 15.23) allows users to select a shape to draw—circle, ellipse, square or pie (in both filled and unfilled versions)—by using a ComboBox. The ComboBox in this example is uneditable, so the user cannot type in the TextBox.

Example 15.23. ComboBox used to draw a selected shape.

 1   // Fig. 15.23: ComboBoxTestForm.cs
 2   // Using ComboBox to select a shape to draw.
 3   using System;
 4   using System.Drawing;
 5   using System.Windows.Forms;
 6
 7   namespace ComboBoxTest
 8   {
 9      // Form uses a ComboBox to select different shapes to draw
10      public partial class ComboBoxTestForm : Form
11      {
12         // constructor
13         public ComboBoxTestForm()
14         {
15            InitializeComponent();
16         } // end constructor
17
18         // get index of selected shape, draw shape
19         private void imageComboBox_SelectedIndexChanged(
20            object sender, EventArgs e )
21         {
22            // create graphics object, Pen and SolidBrush
23            Graphics myGraphics = base.CreateGraphics();
24
25            // create Pen using color DarkRed
26            Pen myPen = new Pen( Color.DarkRed );
27
28            // create SolidBrush using color DarkRed
29            SolidBrush mySolidBrush = new SolidBrush( Color.DarkRed );
30
31            // clear drawing area, setting it to color white
32            myGraphics.Clear( Color.White );
33
34            // find index, draw proper shape
35            switch ( imageComboBox.SelectedIndex )
36            {
37               case 0: // case Circle is selected
38                  myGraphics.DrawEllipse( myPen, 50, 50, 150, 150 );
39                  break;
40               case 1: // case Rectangle is selected
41                  myGraphics.DrawRectangle( myPen, 50, 50, 150, 150 );
42                  break;
43               case 2: // case Ellipse is selected
44                  myGraphics.DrawEllipse( myPen, 50, 85, 150, 115 );
45                  break;
46               case 3: // case Pie is selected
47                  myGraphics.DrawPie( myPen, 50, 50, 150, 150, 0, 45 );
48                  break;
49               case 4: // case Filled Circle is selected
50                  myGraphics.FillEllipse( mySolidBrush, 50, 50, 150, 150 );
51                  break;
52               case 5: // case Filled Rectangle is selected
53                  myGraphics.FillRectangle( mySolidBrush, 50, 50, 150,
54                     150 );
55                  break;
56               case 6: // case Filled Ellipse is selected
57                  myGraphics.FillEllipse( mySolidBrush, 50, 85, 150, 115 );
58                  break;
59               case 7: // case Filled Pie is selected
60                  myGraphics.FillPie( mySolidBrush, 50, 50, 150, 150, 0,
61                     45 );
62                  break;
63            } // end switch
64
65            myGraphics.Dispose(); // release the Graphics object
66         } // end method imageComboBox_SelectedIndexChanged
67      } // end class ComboBoxTestForm
68   } // end namespace ComboBoxTest

a)

b)

c)

d)

Look-and-Feel Observation 15.5

Make lists (such as ComboBoxes) editable only if the program is designed to accept user-submitted elements. Otherwise, the user might try to enter a custom item that is improper for the purposes of your application.

After creating ComboBox imageComboBox, make it uneditable by setting its DropDownStyle to DropDownList in the Properties window. Next, add items Circle, Square, Ellipse, Pie, Filled Circle, Filled Square, Filled Ellipse and Filled Pie to the Items collection using the String Collection Editor. Whenever the user selects an item from imageComboBox, a SelectedIndexChanged event occurs and event handler imageComboBox_SelectedIndexChanged (lines 19–66) executes. Lines 23–29 create a Graphics object, a Pen and a SolidBrush, which are used to draw on the Form. The Graphics object (line 23) allows a pen or brush to draw on a component, using one of several Graphics methods. The Pen object (line 26) is used by methods DrawEllipse, DrawRectangle and DrawPie (lines 38, 41, 44 and 47) to draw the outlines of their corresponding shapes. The SolidBrush object (line 29) is used by methods FillEllipse, FillRectangle and FillPie (lines 50, 53–54, 57 and 60–61) to fill their corresponding solid shapes. Line 32 colors the entire Form White, using Graphics method Clear.

The application draws a shape based on the selected item’s index. The switch statement (lines 35–63) uses imageComboBox.SelectedIndex to determine which item the user selected. Graphics method DrawEllipse (line 38) takes a Pen, and the x- and y-coordinates of the upper-left corner, the width and height of the bounding box in which the ellipse will be displayed. The origin of the coordinate system is in the upper-left corner of the Form; the x-coordinate increases to the right, and the y-coordinate increases downward. A circle is a special case of an ellipse (with the width and height equal). Line 38 draws a circle. Line 44 draws an ellipse that has different values for width and height.

Class Graphics method DrawRectangle (line 41) takes a Pen, the x- and y-coordinates of the upper-left corner and the width and height of the rectangle to draw. Method DrawPie (line 47) draws a pie as a portion of an ellipse. The ellipse is bounded by a rectangle. Method DrawPie takes a Pen, the x- and y- coordinates of the upper-left corner of the rectangle, its width and height, the start angle (in degrees) and the sweep angle (in degrees) of the pie. Angles increase clockwise. The FillEllipse (lines 50 and 57), FillRectangle (line 53–54) and FillPie (line 60–61) methods are similar to their unfilled counterparts, except that they take a Brush (e.g., SolidBrush) instead of a Pen. Some of the drawn shapes are illustrated in the screenshots of Fig. 15.23.

The TreeView control displays nodes hierarchically in a tree. Traditionally, nodes are objects that contain values and can refer to other nodes. A parent node contains child nodes, and the child nodes can be parents to other nodes. Two child nodes that have the same parent node are considered sibling nodes. A tree is a collection of nodes, usually organized in a hierarchical manner. The first parent node of a tree is the root node (a TreeView can have multiple roots). For example, the file system of a computer can be represented as a tree. The top-level directory (perhaps C:) would be the root, each subfolder of C: would be a child node and each child folder could have its own children. TreeView controls are useful for displaying hierarchical information, such as the file structure that we just mentioned. We cover nodes and trees in greater detail in Chapter 21, Data Structures. Figure 15.24 displays a sample TreeView control on a Form.

Figure 15.24. TreeView displaying a sample tree.

A parent node can be expanded or collapsed by clicking the plus box or minus box to its left. Nodes without children do not have these boxes.

The nodes in a TreeView are instances of class TreeNode. Each TreeNode has a Nodes collection (type TreeNodeCollection), which contains a list of other TreeNodes—known as its children. The Parent property returns a reference to the parent node (or null if the node is a root node). Figure 15.25 and Fig. 15.26 list the common properties of TreeViews and TreeNodes, common TreeNode methods and a common TreeView event.

To add nodes to the TreeView visually, click the ellipsis next to the Nodes property in the Properties window. This opens the TreeNode Editor (Fig. 15.27), which displays an empty tree representing the TreeView. There are Buttons to create a root and to add or delete a node. To the right are the properties of current node. Here you can rename the node.

Figure 15.27. TreeNode Editor.

To add nodes programmatically, first create a root node. Create a new TreeNode object and pass it a string to display. Then call method Add to add this new TreeNode to the TreeView’s Nodes collection. Thus, to add a root node to TreeView myTreeView, write

myTreeView.Nodes.Add( new TreeNode( rootLabel) );

where myTreeView is the TreeView to which we are adding nodes, and rootLabel is the text to display in myTreeView. To add children to a root node, add new TreeNodes to its Nodes collection. We select the appropriate root node from the TreeView by writing

myTreeView.Nodes[ myIndex ]

where myIndex is the root node’s index in myTreeView’s Nodes collection. We add nodes to child nodes through the same process by which we added root nodes to myTreeView. To add a child to the root node at index myIndex, write

myTreeView.Nodes[ myIndex].Nodes.Add( new TreeNode( ChildLabel ) );

Class TreeViewDirectoryStructureForm (Fig. 15.28) uses a TreeView to display the contents of a directory chosen by the user. A TextBox and a Button are used to specify the directory. First, enter the full path of the directory you want to display. Then click the Button to set the specified directory as the root node in the TreeView. Each subdirectory of this directory becomes a child node. This layout is similar to that used in Windows Explorer. Folders can be expanded or collapsed by clicking the plus or minus boxes that appear to their left.

Example 15.28. TreeView used to display directories.

 1   // Fig. 15.28: TreeViewDirectoryStructureForm.cs
 2   // Using TreeView to display directory structure.
 3   using System;
 4   using System.Windows.Forms;
 5   using System.IO;
 6
 7   namespace TreeViewDirectoryStructure
 8   {
 9      // Form uses TreeView to display directory structure
10      public partial class TreeViewDirectoryStructureForm : Form
11      {
12         string substringDirectory; // store last part of full path name
13
14         // constructor
15         public TreeViewDirectoryStructureForm()
16         {
17            InitializeComponent();
18         } // end constructor
19
20         // populate current node with subdirectories
21         public void PopulateTreeView(
22             string directoryValue, TreeNode parentNode )
23         {
24            // array stores all subdirectories in the directory
25            string[] directoryArray =
26               Directory.GetDirectories( directoryValue );
27
28            // populate current node with subdirectories
29            try
30            {
31               // check to see if any subdirectories are present
32               if ( directoryArray.Length != 0 )
33               {
34                  // for every subdirectory, create new TreeNode,
35                  // add as a child of current node and recursively
36                  // populate child nodes with subdirectories
37                  foreach ( string directory in directoryArray )
38                  {
39                     // obtain last part of path name from the full path
40                     // name by calling the GetFileNameWithoutExtension
41                     // method of class Path
42                     substringDirectory =
43                        Path.GetFileNameWithoutExtension( directory );
44
45                     // create TreeNode for current directory
46                     TreeNode myNode = new TreeNode( substringDirectory );
47
48                     // add current directory node to parent node
49                     parentNode.Nodes.Add( myNode );
50
51                     // recursively populate every subdirectory
52                     PopulateTreeView( directory, myNode );
53                  } // end foreach
54               } // end if
55            } //end try
56
57            // catch exception
58            catch ( UnauthorizedAccessException )
59            {
60               parentNode.Nodes.Add( "Access denied" );
61            } // end catch
62         } // end method PopulateTreeView
63
64         // handles enterButton click event
65         private void enterButton_Click( object sender, EventArgs e )
66         {
67            // clear all nodes
68            directoryTreeView.Nodes.Clear();
69
70            // check if the directory entered by user exists
71            // if it does, then fill in the TreeView,
72            // if not, display error MessageBox
73            if ( Directory.Exists( inputTextBox.Text ) )
74            {
75               // add full path name to directoryTreeView
76               directoryTreeView.Nodes.Add( inputTextBox.Text );
77
78               // insert subfolders
79               PopulateTreeView(
80                  inputTextBox.Text, directoryTreeView.Nodes[ 0 ] );
81            }
82            // display error MessageBox if directory not found
83            else
84               MessageBox.Show( inputTextBox.Text + " could not be found.",
85                  "Directory Not Found", MessageBoxButtons.OK,
86                  MessageBoxIcon.Error );
87         } // end method enterButton_Click
88      } // end class TreeViewDirectoryStructureForm
89   } // end namespace TreeViewDirectoryStructure

a)

b)

When the user clicks the enterButton, all the nodes in directoryTreeView are cleared (line 68). Then, if the directory exists (line 73), the path entered in inputTextBox is used to create the root node. Line 76 adds the directory to directoryTreeView as the root node, and lines 79–80 call method PopulateTreeView (lines 21–62), which takes a directory (a string) and a parent node. Method PopulateTreeView then creates child nodes corresponding to the subdirectories of the directory it receives as an argument.

Method PopulateTreeView (lines 21–62) obtains a list of subdirectories, using method GetDirectories of class Directory (namespace System.IO) in lines 25–26. Method GetDirectories takes a string (the current directory) and returns an array of strings (the subdirectories). If a directory is not accessible for security reasons, an UnauthorizedAccessException is thrown. Lines 58–61 catch this exception and add a node containing “Access denied” instead of displaying the subdirectories.

If there are accessible subdirectories, lines 42–43 use method GetFileNameWithoutExtension of class Path to increase readability by shortening the full path name to just the directory name. The Path class provides functionality for working with strings that are file or directory paths. Next, each string in the directoryArray is used to create a new child node (line 46). We use method Add (line 49) to add each child node to the parent. Then method PopulateTreeView is called recursively on every subdirectory (line 52), which eventually populates the TreeView with the entire directory structure. Our recursive algorithm may cause a delay when the program loads large directories. However, once the folder names are added to the appropriate Nodes collection, they can be expanded and collapsed without delay. In the next section, we present an alternate algorithm to solve this problem.

The ListView control is similar to a ListBox in that both display lists from which the user can select one or more items (an example of a ListView can be found in Fig. 15.31). ListView is more versatile and can display items in different formats. For example, a ListView can display icons next to the list items (controlled by its SmallImageList, LargeImageList or StateImageList properties) and show the details of items in columns. Property MultiSelect (a bool) determines whether multiple items can be selected. CheckBoxes can be included by setting property CheckBoxes (a bool) to true, making the ListView’s appearance similar to that of a CheckedListBox. The View property specifies the layout of the ListBox. Property Activation determines the method by which the user selects a list item. The details of these properties and the ItemActivate event are explained in Fig. 15.29.

ListView allows you to define the images used as icons for ListView items. To display images, an ImageList component is required. Create one by dragging it to a Form from the ToolBox. Then, select the Images property in the Properties window to display the Image Collection Editor (Fig. 15.30). Here you can browse for images that you wish to add to the ImageList, which contains an array of Images. Adding images this way embeds them into the application (like resources), so they do not need to be included separately with the published application. They’re not however part of the project. In this example, we added images to the ImageList programmatically rather than using the Image Collection Editor so that we could use image resources. After creating an empty ImageList, add the file and folder icon images to the project as resources. Next, set property SmallImageList of the ListView to the new ImageList object. Property SmallImageList specifies the image list for the small icons. Property LargeImageList sets the ImageList for large icons. The items in a ListView are each of type ListViewItem. Icons for the ListView items are selected by setting the item’s ImageIndex property to the appropriate index.

Figure 15.30. Image Collection Editor window for an ImageList component.

Class ListViewTestForm (Fig. 15.31) displays files and folders in a ListView, along with small icons representing each file or folder. If a file or folder is inaccessible because of permission settings, a MessageBox appears. The program scans the contents of the directory as it browses, rather than indexing the entire drive at once.

Example 15.31. ListView displaying files and folders.

 1   // Fig. 15.31: ListViewTestForm.cs
 2   // Displaying directories and their contents in ListView.
 3   using System;
 4   using System.Windows.Forms;
 5   using System.IO;
 6
 7   namespace ListViewTest
 8   {
 9      // Form contains a ListView which displays
10      // folders and files in a directory
11      public partial class ListViewTestForm : Form
12      {
13         // store current directory
14         string currentDirectory = Directory.GetCurrentDirectory();
15
16         // constructor
17         public ListViewTestForm()
18         {
19            InitializeComponent();
20         } // end constructor
21
22         // browse directory user clicked or go up one level
23         private void browserListView_Click( object sender, EventArgs e )
24         {
25            // ensure an item is selected
26            if ( browserListView.SelectedItems.Count != 0 )
27            {
28               // if first item selected, go up one level
29               if ( browserListView.Items[ 0 ].Selected )
30               {
31                  // create DirectoryInfo object for directory
32                  DirectoryInfo directoryObject =
33                     new DirectoryInfo( currentDirectory );
34
35                  // if directory has parent, load it
36                  if ( directoryObject.Parent != null )
37                  {
38                     LoadFilesInDirectory(
39                        directoryObject.Parent.FullName );
40                  } // end if
41               } // end if
42
43               // selected directory or file
44               else
45               {
46                  // directory or file chosen
47                  string chosen = browserListView.SelectedItems[ 0 ].Text;
48
49                  // if item selected is directory, load selected directory
50                  if ( Directory.Exists(
51                     Path.Combine( currentDirectory, chosen ) ) )
52                  {
53                     LoadFilesInDirectory(
54                        Path.Combine( currentDirectory, chosen ) );
55                  } // end if
56               } // end else
57
58               // update displayLabel
59               displayLabel.Text = currentDirectory;
60            } // end if
61         } // end method browserListView_Click
62
63         // display files/subdirectories of current directory
64         public void LoadFilesInDirectory( string currentDirectoryValue )
65         {
66            // load directory information and display
67            try
68            {
69               // clear ListView and set first item
70               browserListView.Items.Clear();                 
71               browserListView.Items.Add( "Go Up One Level" );
72
73               // update current directory
74               currentDirectory = currentDirectoryValue;
75               DirectoryInfo newCurrentDirectory =
76                  new DirectoryInfo( currentDirectory );
77
78               // put files and directories into arrays
79               DirectoryInfo[] directoryArray =
80                  newCurrentDirectory.GetDirectories();
81               FileInfo[] fileArray = newCurrentDirectory.GetFiles();
82
83               // add directory names to ListView
84               foreach ( DirectoryInfo dir in directoryArray )
85               {
86                  // add directory to ListView
87                  ListViewItem newDirectoryItem =          
88                     browserListView.Items.Add( dir.Name );
89
90                  newDirectoryItem.ImageIndex = 0;  // set directory image
91               } // end foreach
92
93               // add file names to ListView
94               foreach ( FileInfo file in fileArray )
95               {
96                  // add file to ListView
97                  ListViewItem newFileItem =                
98                     browserListView.Items.Add( file.Name );
99
100                 newFileItem.ImageIndex = 1; // set file image
101              } // end foreach
102           } // end try
103
104           // access denied
105           catch ( UnauthorizedAccessException )
106           {
107              MessageBox.Show( "Warning: Some fields may not be " +
108                 "visible due to permission settings",
109                 "Attention", 0, MessageBoxIcon.Warning );
110           } // end catch
111        } // end method LoadFilesInDirectory
112
113        // handle load event when Form displayed for first time
114        private void ListViewTestForm_Load( object sender, EventArgs e )
115        {
116           // add icon images to ImageList
117           fileFolderImageList.Images.Add( Properties.Resources.folder );
118           fileFolderImageList.Images.Add( Properties.Resources.file );  
119
120           // load current directory into browserListView
121           LoadFilesInDirectory( currentDirectory );
122           displayLabel.Text = currentDirectory;
123        } // end method ListViewTestForm_Load
124     } // end class ListViewTestForm
125  } // end namespace ListViewTest

a)

b)

c)

Method browserListView_Click

Method browserListView_Click (lines 23–61) responds when the user clicks control browserListView. Line 26 checks whether anything is selected. If a selection has been made, line 29 determines whether the user chose the first item in browserListView. The first item in browserListView is always Go Up One Level; if it is selected, the program attempts to go up a level. Lines 32–33 create a DirectoryInfo object for the current directory. Line 36 tests property Parent to ensure that the user is not at the root of the directory tree. Property Parent indicates the parent directory as a DirectoryInfo object; if no parent directory exists, Parent returns the value null. If a parent directory does exist, lines 38–39 pass the parent directory’s full name to LoadFilesInDirectory.

If the user did not select the first item in browserListView, lines 44–56 allow the user to continue navigating through the directory structure. Line 47 creates string chosen and assigns it the text of the selected item (the first item in collection SelectedItems). Lines 50–51 determine whether the user selected a valid directory (rather than a file). Using the Combine method of class Path, the program combines strings currentDirectory and chosen to form the new directory path. The Combine method automatically adds a backslash (), if necessary, between the two pieces. This value is passed to the Exists method of class Directory. Method Exists returns true if its string parameter is a valid directory. If so, the program passes the string to method LoadFilesInDirectory (lines 53–54). Finally, displayLabel is updated with the new directory (line 59).

This program loads quickly, because it indexes only the files in the current directory. A small delay may occur when a new directory is loaded. In addition, changes in the directory structure can be shown by reloading a directory. The previous program (Fig. 15.28) may have a large initial delay, as it loads an entire directory structure. This type of tradeoff is typical in the software world.

Software Engineering Observation 15.2

When designing applications that run for long periods of time, you might choose a large initial delay to improve performance throughout the rest of the program. However, in applications that run for only short periods, developers often prefer fast initial loading times and small delays after each action.

The TabControl creates tabbed windows, such as those in Visual Studio (Fig. 15.32). This enables you to specify more information in the same space on a Form and group displayed data logically. TabControls contain TabPage objects, which are similar to Panels and GroupBoxes in that TabPages also can contain controls. You first add controls to the TabPage objects, then add the TabPages to the TabControl. Only one TabPage is displayed at a time. To add objects to the TabPage and the TabControl, write