- •Using Your Sybex Electronic Book
- •Acknowledgments
- •Contents at a Glance
- •Introduction
- •Who Should Read This Book?
- •How About the Advanced Topics?
- •The Structure of the Book
- •How to Reach the Author
- •The Integrated Development Environment
- •The Start Page
- •Project Types
- •Your First VB Application
- •Making the Application More Robust
- •Making the Application More User-Friendly
- •The IDE Components
- •The IDE Menu
- •The Toolbox Window
- •The Solution Explorer
- •The Properties Window
- •The Output Window
- •The Command Window
- •The Task List Window
- •Environment Options
- •A Few Common Properties
- •A Few Common Events
- •A Few Common Methods
- •Building a Console Application
- •Summary
- •Building a Loan Calculator
- •How the Loan Application Works
- •Designing the User Interface
- •Programming the Loan Application
- •Validating the Data
- •Building a Math Calculator
- •Designing the User Interface
- •Programming the MathCalculator App
- •Adding More Features
- •Exception Handling
- •Taking the LoanCalculator to the Web
- •Working with Multiple Forms
- •Working with Multiple Projects
- •Executable Files
- •Distributing an Application
- •VB.NET at Work: Creating a Windows Installer
- •Finishing the Windows Installer
- •Running the Windows Installer
- •Verifying the Installation
- •Summary
- •Variables
- •Declaring Variables
- •Types of Variables
- •Converting Variable Types
- •User-Defined Data Types
- •Examining Variable Types
- •Why Declare Variables?
- •A Variable’s Scope
- •The Lifetime of a Variable
- •Constants
- •Arrays
- •Declaring Arrays
- •Initializing Arrays
- •Array Limits
- •Multidimensional Arrays
- •Dynamic Arrays
- •Arrays of Arrays
- •Variables as Objects
- •So, What’s an Object?
- •Formatting Numbers
- •Formatting Dates
- •Flow-Control Statements
- •Test Structures
- •Loop Structures
- •Nested Control Structures
- •The Exit Statement
- •Summary
- •Modular Coding
- •Subroutines
- •Functions
- •Arguments
- •Argument-Passing Mechanisms
- •Event-Handler Arguments
- •Passing an Unknown Number of Arguments
- •Named Arguments
- •More Types of Function Return Values
- •Overloading Functions
- •Summary
- •The Appearance of Forms
- •Properties of the Form Control
- •Placing Controls on Forms
- •Setting the TabOrder
- •VB.NET at Work: The Contacts Project
- •Anchoring and Docking
- •Loading and Showing Forms
- •The Startup Form
- •Controlling One Form from within Another
- •Forms vs. Dialog Boxes
- •VB.NET at Work: The MultipleForms Project
- •Designing Menus
- •The Menu Editor
- •Manipulating Menus at Runtime
- •Building Dynamic Forms at Runtime
- •The Form.Controls Collection
- •VB.NET at Work: The DynamicForm Project
- •Creating Event Handlers at Runtime
- •Summary
- •The TextBox Control
- •Basic Properties
- •Text-Manipulation Properties
- •Text-Selection Properties
- •Text-Selection Methods
- •Undoing Edits
- •VB.NET at Work: The TextPad Project
- •Capturing Keystrokes
- •The ListBox, CheckedListBox, and ComboBox Controls
- •Basic Properties
- •The Items Collection
- •VB.NET at Work: The ListDemo Project
- •Searching
- •The ComboBox Control
- •The ScrollBar and TrackBar Controls
- •The ScrollBar Control
- •The TrackBar Control
- •Summary
- •The Common Dialog Controls
- •Using the Common Dialog Controls
- •The Color Dialog Box
- •The Font Dialog Box
- •The Open and Save As Dialog Boxes
- •The Print Dialog Box
- •The RichTextBox Control
- •The RTF Language
- •Methods
- •Advanced Editing Features
- •Cutting and Pasting
- •Searching in a RichTextBox Control
- •Formatting URLs
- •VB.NET at Work: The RTFPad Project
- •Summary
- •What Is a Class?
- •Building the Minimal Class
- •Adding Code to the Minimal Class
- •Property Procedures
- •Customizing Default Members
- •Custom Enumerations
- •Using the SimpleClass in Other Projects
- •Firing Events
- •Shared Properties
- •Parsing a Filename String
- •Reusing the StringTools Class
- •Encapsulation and Abstraction
- •Inheritance
- •Inheriting Existing Classes
- •Polymorphism
- •The Shape Class
- •Object Constructors and Destructors
- •Instance and Shared Methods
- •Who Can Inherit What?
- •Parent Class Keywords
- •Derived Class Keyword
- •Parent Class Member Keywords
- •Derived Class Member Keyword
- •MyBase and MyClass
- •Summary
- •On Designing Windows Controls
- •Enhancing Existing Controls
- •Building the FocusedTextBox Control
- •Building Compound Controls
- •VB.NET at Work: The ColorEdit Control
- •VB.NET at Work: The Label3D Control
- •Raising Events
- •Using the Custom Control in Other Projects
- •VB.NET at Work: The Alarm Control
- •Designing Irregularly Shaped Controls
- •Designing Owner-Drawn Menus
- •Designing Owner-Drawn ListBox Controls
- •Using ActiveX Controls
- •Summary
- •Programming Word
- •Objects That Represent Text
- •The Documents Collection and the Document Object
- •Spell-Checking Documents
- •Programming Excel
- •The Worksheets Collection and the Worksheet Object
- •The Range Object
- •Using Excel as a Math Parser
- •Programming Outlook
- •Retrieving Information
- •Recursive Scanning of the Contacts Folder
- •Summary
- •Advanced Array Topics
- •Sorting Arrays
- •Searching Arrays
- •Other Array Operations
- •Array Limitations
- •The ArrayList Collection
- •Creating an ArrayList
- •Adding and Removing Items
- •The HashTable Collection
- •VB.NET at Work: The WordFrequencies Project
- •The SortedList Class
- •The IEnumerator and IComparer Interfaces
- •Enumerating Collections
- •Custom Sorting
- •Custom Sorting of a SortedList
- •The Serialization Class
- •Serializing Individual Objects
- •Serializing a Collection
- •Deserializing Objects
- •Summary
- •Handling Strings and Characters
- •The Char Class
- •The String Class
- •The StringBuilder Class
- •VB.NET at Work: The StringReversal Project
- •VB.NET at Work: The CountWords Project
- •Handling Dates
- •The DateTime Class
- •The TimeSpan Class
- •VB.NET at Work: Timing Operations
- •Summary
- •Accessing Folders and Files
- •The Directory Class
- •The File Class
- •The DirectoryInfo Class
- •The FileInfo Class
- •The Path Class
- •VB.NET at Work: The CustomExplorer Project
- •Accessing Files
- •The FileStream Object
- •The StreamWriter Object
- •The StreamReader Object
- •Sending Data to a File
- •The BinaryWriter Object
- •The BinaryReader Object
- •VB.NET at Work: The RecordSave Project
- •The FileSystemWatcher Component
- •Properties
- •Events
- •VB.NET at Work: The FileSystemWatcher Project
- •Summary
- •Displaying Images
- •The Image Object
- •Exchanging Images through the Clipboard
- •Drawing with GDI+
- •The Basic Drawing Objects
- •Drawing Shapes
- •Drawing Methods
- •Gradients
- •Coordinate Transformations
- •Specifying Transformations
- •VB.NET at Work: Plotting Functions
- •Bitmaps
- •Specifying Colors
- •Defining Colors
- •Processing Bitmaps
- •Summary
- •The Printing Objects
- •PrintDocument
- •PrintDialog
- •PageSetupDialog
- •PrintPreviewDialog
- •PrintPreviewControl
- •Printer and Page Properties
- •Page Geometry
- •Printing Examples
- •Printing Tabular Data
- •Printing Plain Text
- •Printing Bitmaps
- •Using the PrintPreviewControl
- •Summary
- •Examining the Advanced Controls
- •How Tree Structures Work
- •The ImageList Control
- •The TreeView Control
- •Adding New Items at Design Time
- •Adding New Items at Runtime
- •Assigning Images to Nodes
- •Scanning the TreeView Control
- •The ListView Control
- •The Columns Collection
- •The ListItem Object
- •The Items Collection
- •The SubItems Collection
- •Summary
- •Types of Errors
- •Design-Time Errors
- •Runtime Errors
- •Logic Errors
- •Exceptions and Structured Exception Handling
- •Studying an Exception
- •Getting a Handle on this Exception
- •Finally (!)
- •Customizing Exception Handling
- •Throwing Your Own Exceptions
- •Debugging
- •Breakpoints
- •Stepping Through
- •The Local and Watch Windows
- •Summary
- •Basic Concepts
- •Recursion in Real Life
- •A Simple Example
- •Recursion by Mistake
- •Scanning Folders Recursively
- •Describing a Recursive Procedure
- •Translating the Description to Code
- •The Stack Mechanism
- •Stack Defined
- •Recursive Programming and the Stack
- •Passing Arguments through the Stack
- •Special Issues in Recursive Programming
- •Knowing When to Use Recursive Programming
- •Summary
- •MDI Applications: The Basics
- •Building an MDI Application
- •Built-In Capabilities of MDI Applications
- •Accessing Child Forms
- •Ending an MDI Application
- •A Scrollable PictureBox
- •Summary
- •What Is a Database?
- •Relational Databases
- •Exploring the Northwind Database
- •Exploring the Pubs Database
- •Understanding Relations
- •The Server Explorer
- •Working with Tables
- •Relationships, Indices, and Constraints
- •Structured Query Language
- •Executing SQL Statements
- •Selection Queries
- •Calculated Fields
- •SQL Joins
- •Action Queries
- •The Query Builder
- •The Query Builder Interface
- •SQL at Work: Calculating Sums
- •SQL at Work: Counting Rows
- •Limiting the Selection
- •Parameterized Queries
- •Calculated Columns
- •Specifying Left, Right, and Inner Joins
- •Stored Procedures
- •Summary
- •How About XML?
- •Creating a DataSet
- •The DataGrid Control
- •Data Binding
- •VB.NET at Work: The ViewEditCustomers Project
- •Binding Complex Controls
- •Programming the DataAdapter Object
- •The Command Objects
- •The Command and DataReader Objects
- •VB.NET at Work: The DataReader Project
- •VB.NET at Work: The StoredProcedure Project
- •Summary
- •The Structure of a DataSet
- •Navigating the Tables of a DataSet
- •Updating DataSets
- •The DataForm Wizard
- •Handling Identity Fields
- •Transactions
- •Performing Update Operations
- •Updating Tables Manually
- •Building and Using Custom DataSets
- •Summary
- •An HTML Primer
- •HTML Code Elements
- •Server-Client Interaction
- •The Structure of HTML Documents
- •URLs and Hyperlinks
- •The Basic HTML Tags
- •Inserting Graphics
- •Tables
- •Forms and Controls
- •Processing Requests on the Server
- •Building a Web Application
- •Interacting with a Web Application
- •Maintaining State
- •The Web Controls
- •The ASP.NET Objects
- •The Page Object
- •The Response Object
- •The Request Object
- •The Server Object
- •Using Cookies
- •Handling Multiple Forms in Web Applications
- •Summary
- •The Data-Bound Web Controls
- •Simple Data Binding
- •Binding to DataSets
- •Is It a Grid, or a Table?
- •Getting Orders on the Web
- •The Forms of the ProductSearch Application
- •Paging Large DataSets
- •Customizing the Appearance of the DataGrid Control
- •Programming the Select Button
- •Summary
- •How to Serve the Web
- •Building a Web Service
- •Consuming the Web Service
- •Maintaining State in Web Services
- •A Data-Driven Web Service
- •Consuming the Products Web Service in VB
- •Summary
THE LISTBOX, CHECKEDLISTBOX, AND COMBOBOX CONTROLS 275
If you search for “SAC”, for example, and the control begins with a string like “SAC” or “sac” or “sAc”, the program will return the index of the item in the list and will report an exact match. If no exact match can be found, the program will return something like “SACDEF”, if such a string exists on the control, as a near match. If none of the strings on the control starts with the characters SAC, the search will fail.
Populating the List
The Populate List button creates 10,000 random items with the help of the Random class. First, it generates a random value in the range 1 through 20, which is the length of the string (not all strings have the same length). Then the code (shown in Listing 6.14) generates as many random characters as the length of the string and builds the string. This random number is in the range from 65 to 91; these are the ANSI values of the uppercase characters.
Listing 6.14: Populating a List with Random Strings
Protected Sub PopulateButton_Click(ByVal sender As Object, _ ByVal e As System.EventArgs)
Dim wordLen As Integer
Dim NWords As Integer = 9999 Dim rnd As System.Random rnd = New System.Random() Dim rndChar As Char
Dim thisWord As String Dim i, j As Integer For i = 0 To NWords
wordLen = CInt(rnd.NextDouble * 20 + 1) thisWord = “”
For j = 0 To wordLen
rndchar = Chr(65 + CInt(rnd.Next, 25)) thisWord = thisWord & rndChar
Next ListBox1.Items.Add(thisWord)
Next End Sub
The ComboBox Control
The ComboBox control is similar to the ListBox control in the sense that it contains multiple items of which the user may select one, but it typically occupies less space on-screen. The ComboBox is practically an expandable ListBox control, which can grow when the user wants to make a selection and retract after the selection is made. Normally, the ComboBox control displays one line with the selected item. The real difference, however, between ComboBox and ListBox controls is that the ComboBox allows the user to specify items that don’t exist in the list. Moreover, the Text property of the ComboBox is read-only at runtime, and you can locate an item by assigning a value to the control’s Text property.
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |
276 Chapter 6 BASIC WINDOWS CONTROLS
Three types of ComboBox controls are available in Visual Basic.NET. The value of the control’s Style property, whose values are shown in Table 6.3, determines which box is used.
Table 6.3: Styles of the ComboBox Control
Value |
Effect |
DropDown |
(Default) The control is made up of a drop-down list and a text box. The user can select |
|
an item from the list or type a new one in the text box. |
DropDownList |
This style is a drop-down list, from which the user can select one of its items but can’t |
|
enter a new one. |
Simple |
The control includes a text box and a list that doesn’t drop down. The user can select |
|
from the list or type in the text box. |
|
|
The ComboBoxStyles project in this chapter’s folder on the CD (see Figure 6.9) demonstrates the three styles of the ComboBox control. It’s a common element of the Windows interface, and its properties and methods are identical to those of the ListBox control. Load the ComboBoxStyles project in the Visual Basic IDE and experiment with the three styles of the ComboBox control.
Figure 6.9
The ComboBoxStyles project demonstrates the various styles of the ComboBox control.
The DropDown and Simple ComboBox controls allow the user to select an item from the list or enter a new one in the edit box of the control.
The DropDownList ComboBox is similar to a ListBox control in the sense that it restricts the user to selecting an item, but not entering a new one. However, it takes much less space on the form than a ListBox. When the user wants to make a selection, the DropDownList expands to display more items. After the user has made a selection, the list contracts to a single line again.
Most of the properties and methods of the ListBox control also apply to the ComboBox control. The Items collection gives you access to the control’s items, and the SelectedIndices and SelectedItems collections give you access to the items in the current selection. If the control allows only a single item to be selected, then use the properties SelectedIndex and SelectedItem. You can also use the FindString and FindStringExact methods to locate any items in the control.
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |
THE LISTBOX, CHECKEDLISTBOX, AND COMBOBOX CONTROLS 277
There’s one aspect worth mentioning, regarding the operation of the control. Although the edit box at the top allows you to enter a new string, the new string doesn’t become a new item. It remains there until you select another item or you clear the edit box.
The most common use of the ComboBox control as a lookup table. The ComboBox control takes up very little space on the form, but it can be expanded at will. You can save even more space, when the ComboBox is contracted, by setting it to a width that’s too small for the longest item. Use the DropDownWidth property, which is the width of the segment of the control that’s dropped down. By default, this property is equal to the Width property. Figure 6.10 shows a ComboBox control with a couple of unusually long items. The control is wide enough to display the default selection. When the user clicks the arrow to expand the control, the drop-down section of the control is wider than the default width, so that the long items can be read. The control on the left is shown in its normal state, with a width of 130 pixels. The drop-down segment of the control is 240 pixels wide. You will have to experiment a little to find the ideal value of the DropDownWidth property.
Figure 6.10
The ComboBox control’s Width and DropDownWidth properties
Although the ComboBox control allows users to enter text in the control’s edit box, it doesn’t provide a simple mechanism for adding new items at runtime. Let’s say you provide a ComboBox with city names. Users can type the first few characters and very quickly locate the desired item. But what if you want to allow users to add new city names? You can provide this feature with two simple techniques. The simpler one is to place a button with an ellipsis (three periods) right next to the control. When users want to add a new item to the control, they can click the button and be prompted for the new item.
A more elegant approach is to examine the control’s Text property as soon as it loses focus. If the string entered by the user doesn’t match an item on the control, then you must add a new item to the control’s Items collection and select the new item from within your code. The FlexComboBox project on the CD demonstrates how to use both techniques in your code. The main form of the project, which is shown in Figure 6.11, is a simple data-entry screen. It’s not the best data-entry form, but it’s meant for demonstration purposes.
Figure 6.11
The FlexComboBox project demonstrates two techniques for adding new items to a ComboBox at runtime.
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |
278 Chapter 6 BASIC WINDOWS CONTROLS
The ComboBox that displays countries isn’t updateable; it’s populated at design time and can’t accept new items, so you must populate it with all the country names. The ComboBox that displays cities is updateable. You can either enter a city name and press the Tab key to move to another control, or click the button next to the control to be prompted for a new city name. The application will let you enter any city/country combination. You should provide code to limit the cities within the selected country, but this is a non-trivial task. You also need to store the new city names entered on the first ComboBox control to a file (or a database table), so that users will find them there the next time they execute the application. I’m not going to make the application really elaborate; I’ll only add the code to demonstrate how to add new items to a ComboBox control at runtime.
The button with the ellipsis next to the City ComboBox control prompts the user for the new item with the InputBox() function. Then it searches the Items collection of the control with the Items.IndexOf method, and if the new item isn’t found, it’s added to the control. Then the code selects the new item in the list. To do so, it sets the control’s SelectedIndex property to the value returned by the Items.Add method, or the value returned by the Items.IndexOf method, depending on whether the item was located, or added to the list. Listing 6.15 shows the code behind the button with the ellipsis.
Listing 6.15: Adding a New Item to the ComboBox Control at Runtime
Private Sub Button1_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles Button1.Click
Dim itm As String
itm = InputBox(“Enter new item”, “New Item”) If itm <> “” Then AddElement(itm)
End Sub
The AddElement() subroutine, which accepts a string as argument and adds it to the control, is shown in Listing 6.16. As you will see, the same subroutine will be used by the second method for adding items to the control at runtime.
Listing 6.16: The AddElement() Subroutine
Sub AddElement(ByVal newItem As String) Dim idx As Integer
If Not ComboBox1.Items.Contains(newItem) Then idx = ComboBox1.Items.Add(newItem)
Else
idx = ComboBox1.Items.IndexOf(newItem) End If
ComboBox1.SelectedIndex = idx End Sub
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |