Figure 1-1: Use the Tools menu’s Import and Export Settings command to change the Visual Studio configuration.
Figure 1-2: Initially the IDE looks more or less like this.
Figure 1-3: The File menu holds commands that deal with the solution and its files.
Figure 1-4: The New Project dialog box lets you start various kinds of new projects.
Figure 1-5: The Open File dialog box lets you select files to view and edit.
Figure 1-6: The File Export Template command displays this dialog box to help you create project or items templates that you can easily use in other projects.
Figure 1-7: The Edit menu holds commands that deal with manipulating text and other objects.
Figure 1-8: The View menu lets you show and hide IDE windows and toolbars.
Figure 1-9: The View menu’s Property Pages command displays an application’s property pages.
Figure 1-10: The Project menu lets you add files and references to the currently selected project.
Figure 1-11: The Project menu’s Add New Item command lets you add a wide variety of items to the project.
Figure 1-12: Use the Add Reference dialog box to add references to libraries.
Figure 1-13: Use the Add Web Reference dialog to add references to web services.
Figure 1-14: Property pages let you set a project’s properties.
Figure 1-15: The Compile tab contains important properties for controlling code generation.
Figure 1-16: The Projects and Solutions folder’s VB Defaults page lets you set default values for Option Explicit and Option Strict.
Figure 1-17: The Build menu lets you compile projects.
Figure 1-18: The Publish Wizard helps you deploy an application.
Figure 1-19: The Run Code Analysis command displays potential problems in an application.
Figure 1-20: The Debug menu contains commands for debugging an application.
Figure 1-21: The QuickWatch dialog box lets you examine an object’s properties and optionally set a new watch on it.
Figure 1-22: The Watch window lets you easily track expression values.
Figure 1-23: The Exceptions dialog box lets you determine how Visual Basic handles uncaught exceptions.
Figure 1-24: The Debug menu’s Windows submenu contains commands that display debugging-related windows.
Figure 1-25: The Locals window displays the values of variables defined in the local context.
Figure 1-26: The Breakpoints window helps you manage breakpoints.
Figure 1-27: The Autos window displays the variables used in the current code statement and the threestatements before and the three after.
Figure 1-28: The Call Stack window shows which routines have called which to get to the program’s current point of execution.
Figure 1-29: The Threads window displays information about the program’s threads of execution.
Figure 1-30: The Modules window displays information about the modules used by the program.
Figure 1-31: The Breakpoint Condition dialog box lets you specify a condition that determines whether Visual Studio stops at the breakpoint.
Figure 1-32: The Breakpoint Hit Count dialog box lets you make a breakpoint’s activation depend on the number of times the code has reached it.
Figure 1-33: The When Breakpoint Is Hit dialog box lets you determine what actions Visual Basic takes when the breakpoint is activated.
Figure 1-34: The Data menu holds commands that deal with datasets.
Figure 1-35: The Format menu contains commands for formatting and arranging controls on a form.
Figure 1-36: The Tools menu contains miscellaneous commands and commands that modify the IDE.
Figure 1-37: This dialog helps convert Visual Basic 6 code into Visual Basic 2005 code.
Figure 1-38: The Macros submenu contains commands for recording and executing macros.
Figure 1-39: The Macro Explorer lets you edit, run, and delete macros.
Figure 1-40: The Customize dialog box’s Toolbars tab lets you determine which toolbars are visible.
Figure 1-41: The Customize dialog box’s Commands tab lets you add commands to toolbars and menus.
Figure 1-42: Right-click the menu and toolbar commands to change their appearances.
Figure 1-43: You can use the Visual Studio simple button editor to change a command’s button.
Figure 1-44: The Options dialog’s Keyboard section lets you view and modify keyboard shortcuts.
Figure 1-45: The Options dialog box lets you specify IDE options.
Figure 1-46: The Test menu displays commands that control Visual Studio’s testing tools.
Figure 1-47: The Add New Test dialog box lets you define new tests for the application.
Figure 1-48: The Window menu displays commands that control the Visual Studio windows.
Figure 1-49: The Community menu provides Internet links for Visual Studio developers.
Figure 1-50: The Help menu contains commands that give you help.
Figure 1-51: Use the IDE’s docking icons to help you dock windows.
Figure 1-52: The Toolbox window can display tools by name or icon.
Figure 1-53: Use the Choose Toolbox Items dialog box to select the tools in the Toolbox.
Figure 1-54: The Visual Basic code editor provides many features, including line numbers and icons that indicate breakpoints and bookmarks.
Figure 1-55: The code editor outlines namespaces, classes and their methods, modules and their methods, and regions.
Figure 1-56: You can hover the mouse over a variable at run time to see its value.
Figure 1-57: IntelliSense displays a list of properties and methods that you might be trying to type.
Figure 1-58: IntelliSense displays information about a method’s parameters.
Figure 1-59: If the code editor can figure out what’s wrong, it displays a suggestion indicator.
Figure 1-60: The error suggestion dialog box proposes likely solutions to an error.
Figure 1-61: When you select a code snippet, a pop-up describes it.
Figure 1-62: Values that you should replace in a snippet are highlighted.
Figure 1-63: The Code Snippets Manager lets you add and remove snippet directories.
Chapter 2: Controls in General
Figure 2-1: Visual Basic provides a rich assortment of controls.
Figure 2-2: Some components provide data for graphical controls.
Figure 2-3: Hover the mouse over a toolbox icon to see the tool’s description.
Figure 2-4: When you click and drag on a form, Visual Basic selects only controls with the same container.
Figure 2-5: The Properties window lets you change a control’s properties at design time.
Figure 2-6: The Properties window lets you change even complex properties at design time.
Figure 2-7: The Font property displays a dialog box that lets you set the font’s properties.
Figure 2-8: Some properties provide an enumerated list of allowed values.
Figure 2-9: Some properties, such as Anchor, provide specialized editors to let you select their values.
Figure 2-10: This dialog box lets you load images into an ImageList control at design time.
Figure 2-11: This dialog box lets you edit a TabControl’s tab pages.
Figure 2-12: A TabControl displays the images stored in an ImageList component on its tabs.
Figure 2-13: The objects in the ListView control’s Items collection each have a SubItems property, which is also a collection.
Figure 2-14: The Location property is on the IntelliSense Common tab but the Left property is not.
Figure 2-15: This dialog box uses Anchor properties to make its TextBox controls use whatever space is available on the form.
Figure 2-16: The bottom ListView control resizes itself to use up any extra verticalspace on the form.
Figure 2-17: Controls with Anchor set to Bottom remain centered as a group.
Figure 2-18: Docked controls are arranged according to their stacking order.
Figure 2-19: Click the Properties window’s Events button to see a list of a control’smost commonly used events.
Figure 2-20: To create an event handler in the code window, select a control from the left drop-down, and then select an event from the right drop-down.
Figure 2-21: The Validating event fires when the focus moves to a control that has CausesValidation set to True.
Chapter 3: Program and Module Structure
Figure 3-1: A solution contains one or more projects that contain files.
Figure 3-2: These property pages let you define project’s resources, settings, and general configuration.
Figure 3-3: The Assembly Information dialog box lets you define basic project information such astitle, copyright, and version number.
Figure 3-4: A single file can contain multiple Class and Module statements.
Figure 3-5: Click the Compile tab’s Advanced Compile Options button to set compilation constants.
Figure 3-6: Use the Advanced Compiler Settings dialog box to define compilation constants.
Figure 3-7: Use the Configuration Manager to select a Debug or Release build.
Figure 3-8: Debug.Assert displays an error message if a Boolean expression is False.
Figure 3-9: You can use the Configuration Manager to create your own configurations.
Figure 3-10: The project’s Application property page lets you view or change the project’s root namespace.
Figure 3-11: The Object Browser displays an item’s XML summary and remarks sections.
Chapter 4: Data Types, Variables, and Constants
Figure 4-1: Visual Basic creates a drop-down entry for variables declared WithEvents.
Figure 4-2: When you select an object declared WithEvents in the left drop-down, Visual Basic fills the right drop-down list with events you might want to catch.
Chapter 8: Error Handling
Figure 8-1: When a program crashes, the message it generates tells you the type of exception it raised.
Figure 8-2: An ArgumentException object generates its Message value from the description and parameter name passed to its constructor.
Figure 8-3: You can use the Object Browser to find exception classes.
Chapter 9: Introduction to Windows Forms Controls
Figure 9-1: Visual Basic provides a large number of standard controls for Windows forms.
Figure 9-2: FlowLayoutPanel places controls close together. TableLayoutPanel arranges controls in a grid.
Figure 9-3: The PropertyGrid control displays an object’s properties.
Chapter 10: Forms
Figure 10-1: A form with Opacity set to 66% allows the Visual Basic IDE to show through.
Figure 10-2: A form’s TransparencyKey property lets you make shaped forms such as this one with a hole in it.
Figure 10-3: TransparencyKey applies to the form’s client and nonclient areas, as well as its controls.
Figure 10-4: The TransparencyKey property lets you make shaped forms such as this one.
Figure 10-5: The Cursors class defines standard cursors.
Figure 10-6: An application can use a NotifyIcon control to display status icons in the system tray.
Figure 10-7: An SDI application displays separate documents in separate forms.
Figure 10-8: An MDI application displays documents in forms contained within an MDI container form.
Figure 10-9: The MenuStrip’s MdiWindowListItem property determines which menu item displays an MDI child list.
Figure 10-10: An MRU list makes it easier for users to reopen the files they have used most recently.
Figure 10-11: A wizard guides the user through the steps of some complicated task.
Figure 10-12: This wizard uses buttons instead of tabs to move through its pages of data.
Chapter 11: Database Controls and Objects
Figure 11-1: When using Microsoft Access databases on 64-bit computers, set the target CPU to x86.
Figure 11-2: The Data Source Configuration Wizard lets you add or configure data sources.
Figure 11-3: Pick the data connection or click New Connection to create a new one.
Figure 11-4: Use the Add Connection dialog box to create a data connection.
Figure 11-5: Use the Change Data Source dialog box to select a new kind of database.
Figure 11-6: The Add Connection dialog box looks like this for SQL Server databases.
Figure 11-7: Select the new connection in the Data Source Configuration Wizard.
Figure 11-8: Decide whether you want to include the connection string in the configuration file.
Figure 11-9: Select the database objects that you want included in the data source.
Figure 11-10: The Data Source Configuration Wizard adds a database schema to Solution Explorer.
Figure 11-11: The Schema Editor shows the tables defined by the schema and their relationships.
Figure 11-12: Use this dialog box to edit relationships among data source tables.
Figure 11-13: The Data Sources window lists the new data source.
Figure 11-14: Drag and drop a table from the Data Sources window onto the form to create a simple DataGridView.
Figure 11-15: Drag and drop table columns onto a form to create a record-oriented view instead of a grid.
Figure 11-16: Use the drop-down in the Data Sources window to give a table a different display style.
Figure 11-17: Visual Basic uses DataSet, TableAdapter, BindingSource, and BindingNavigator components to manage a DataGridView display.
Figure 11-18: Visual Basic uses DataSet, TableAdapter, BindingSource, and BindingNavigator objects to display data. BindingSource
Figure 11-19: An application uses connection, data adapter, and DataSet objects to move data to and from the database.
Figure 11-20: You can use the Data Sources window to generate a connection string.
Figure 11-21: The Data Source Configuration Wizard can show you a database’s connection string.
Figure 11-22: The Data Adapter Configuration Wizard helps you define a data adapter.
Figure 11-23: Select the method the data adapter will use to manipulate database data.
Figure 11-24: Enter an SQL SELECT statement or click the Query Builder button.
Figure 11-25: You can use the Query Builder to interactively define the data that a data adapter selects.
Figure 11-26: The Data Adapter Configuration Wizard displays a summary of the tasks it will perform.
Figure 11-27: The DataGrid control marks a DataRow that has a nonblank RowError.
Figure 11-28: Different DataView objects can show different views of the same data.
Figure 11-29: You can bind a simple control property to a data source at design time.
Figure 11-30: This program’s buttons use a CurrencyManager to let the user add, delete, and navigate through a table’s records.
Figure 11-31: Set the ComboBox’s DataSource property to the UserTypes table.
Figure 11-32: Set the BindingSource object’s DataSource to the ComputerUsersDataSet.
Figure 11-33: Set the BindingSource object’s SelectedValue to the UsersBindingSource object’s UserType field.
Figure 11-34: At runtime, the ComboBox displays the field bound to its DisplayMember property while updating the field bound to its SelectedValue property.
Figure 11-35: The steps for binding a ListBox are the same as those for binding a ComboBox.
Chapter 12: Custom Controls
Figure 12-1: Visual Basic lets you preview controls in the UserControl Test Container.
Figure 12-2: Use the Customize Toolbox dialog box to add your control to the Toolbox.
Figure 12-4: The ColorScroller control lets the user select a color interactively by dragging scroll bars.
Figure 12-5: The form designer displays components in the component tray below the form.
Figure 12-6: You can add existing components to a new component.
Figure 12-7: Use the Inheritance Picker to make a control that inherits from an existing UserControl.
Figure 12-8: Use the Signing tab to sign an assembly.
Chapter 13: Drag and Drop, and the Clipboard
Figure 13-1: This program drags and drops data in Text, RTF, and HTML formats.
Chapter 14: UAC Security
Figure 14-1: Buttons that launch actions that require privilege elevation should display the UAC shield.
Chapter 15: OOP Concepts
Figure 15-1: You can derive classes from other classes to form quite complex inheritance relationships.
Chapter 16: Classes and Structures
Figure 16-1: A structure contains the data, while a class object contains a reference that points to data.
Figure 16-2: An array of class objects contains small references to data, many of which may be Nothing. An array of structures takes up a significant amount of memory.
Figure 16-3: Assigning one class reference to another makes them both point to the same object. Assigning one structure variable to another makes a new copy of the data.
Figure 16-4: If a variable in a class is declared Shared, all instances of a class share the same value.
Figure 16-5: A shared method can only access other shared variables and methods.
Chapter 17: Namespaces
Figure 17-1: The Imports statement greatly simplifies the code that draws this dashed rectangle.
Figure 17-2: Use the My Project References tab to import namespaces for every module in a project.
Figure 17-3: The Application tab shows the project’s root namespace.
Figure 17-4: IntelliSense displays curly braces {} to the left of namespaces such as FinanceStuff and JobClasses.
Figure 17-5: Visual Basic may search all over the namespace hierarchy to resolve a declaration.
Chapter 18: Collection Classes
Figure 18-1: Variable arrays are faster than array classes.
Figure 18-2: Binary search quickly locates a target value in an array.
Figure 18-3: Each item in a linked list keeps a reference to the next item in the list.
Figure 18-4: Adding and removing items from a linked list is relatively easy.
Figure 18-5: A Hashtable maps key values into buckets.
Figure 18-6: A Stack lets you remove items in last-in, first-out (LIFO) order.
Figure 18-7: In a queue, items are removed in first-in, first-out (FIFO) order.
Figure 18-8: A Queue stores its items in a circular array.
Chapter 20: Drawing Basics
Figure 20-1: This program uses SolidBrush and Pen objects to draw an orange circle with a wide blue outline.
Figure 20-2: The LineCap enumeration determines how a line’s endpoint is drawn.
Figure 20-3: The LineJoin enumeration determines how lines are joined.
Figure 20-4: The HatchStyle enumeration determines how a HatchBrush fills an area.
Figure 20-5: An InstalledFontCollection object provides access to an array of FontFamily objects representing the fonts installed on the system.
Figure 20-6: Anti-aliasing (top) makes characters appear smoother.
Figure 20-7: The DrawBezier method draws a smooth curve defined by four control points.
Figure 20-8: The DrawBeziers method draws a series of Bézier curves with common end points.
Figure 20-9: The DrawClosedCurve method draws a smooth curve connecting a series points.
Figure 20-10: The DrawClosedCurve method’s tension parameter determines how tightly the curve bends.
Figure 20-11: The DrawPath method draws the outline defined by a GraphicsPath object.
Figure 20-12: The Graphics object’s SmoothingMode property controls anti-aliasing for lines, curves, and filled shapes.
Figure 20-13: The Graphics object’s TextRenderingHint property controls anti-aliasing for text.
Figure 20-14: The Graphics object’s InterpolationMode property controls anti-aliasing for shrunk or enlarged images.
Figure 20-15: This program draws arrows scaled, translated, and rotated.
Figure 20-16: A translation followed by a rotation (A1 and A2) is not the same as a rotation followed by a translation (B1 and B2).
Figure 20-17: To scale an object at a point other than the origin, translate it to the origin, scale it, and then translate it back.
Figure 20-18: This program uses the MapRectangles subroutine to map a smiley face in world coordinates into a rectangle in device coordinates.
Figure 20-19: The MapRectangles subroutine can stretch a drawing by different amounts vertically and horizontally.
Figure 20-20: The MapRectangles subroutine can flip a drawing’s Y coordinates so that they increase upward instead of downward.
Figure 20-21: This program saves and restores the Graphics object’s state containing a scaling and translation, adding an extra rotation as needed.
Figure 20-22: Paint event handlers that adjust their drawings based on the form’s size may produce unexpected results.
Chapter 21: Brushes, Pens, and Paths
Figure 21-1: The LineCap enumeration determines how a line’s endpoints are drawn.
Figure 21-2: The LineJoin enumeration determines how lines are joined.
Figure 21-3: A Pen class’s Alignment property determines whether the line is drawn on or inside its theoretical perfectly thin line.
Figure 21-4: A Pen class’s CompoundArray property lets you draw lines that are striped lengthwise.
Figure 21-5: When building a custom line cap, X increases to the line’s left and Y increases in the line’s direction.
Figure 21-6: This program uses a CustomLineCap that draws an X at the end of lines.
Figure 21-7: The white circles show where the Pen class’s transformed tip was as it drew the large black circle.
Figure 21-8: The TextureBrush class’s WrapMode property determines how the brush tiles its image.
Figure 21-9: This star is filled with a TextureBrush that is scaled and rotated.
Figure 21-10: The HatchStyle enumeration determines which of 54 patterns a HatchBrush uses to fill an area.
Figure 21-11: LinearGradientBrush objects can produce all these effects and more.
Figure 21-12: PathGradientBrush objects can produce all these effects and more.
Figure 21-13: A program can use a Graphics object’s FillPath and DrawPath methods to fill and draw a GraphicsPath object.
Figure 21-14: A program can use a GraphicsPath to define a form’s Region.
Figure 21-15: A program can use a GraphicsPath object to define a clipping region.
Figure 21-16: The GraphicsPath object’s FillMode property determines how areas between the lines are filled.
Chapter 22: Text
Figure 22-1: Text doesn’t begin exactly at the starting point passed to the DrawString method.
Figure 22-3: The DrawString method can use a layout rectangle and a StringFormat object to format text.
Figure 22-4: The NoClip and LineLimit flags change how a StringFormat object handles the text’s last displayed line.
Figure 22-5: Setting the StringFormat object’s FormatFlags property to DirectionVertical produces vertical text.
Figure 22-6: Transformations can produce text rotated at any angle.
Figure 22-7: The SetTabStops method lets you easily align text.
Figure 22-8: The StringFormat object’s Trimming property determines how text is trimmed.
Figure 22-9: You can use the Graphics object’s MeasureString method to see how big a string will be when drawn in a particular font.
Figure 22-10: The Graphics object’s MeasureCharacterRanges method shows where ranges of characters will be drawn in a string.
Figure 22-11: Characters do not always stay within their assigned regions.
Figure 22-12: How text is positioned depends on many font metrics, including internal leading, ascent, descent, and external leading.
Figure 22-13: The FontFamily and Font classes provide the methods you need to calculate font metrics.
Chapter 23: Image Processing
Figure 23-1: Program Scribble automatically redisplays its image when the form is hidden and exposed.
Figure 23-2: This program uses GetPixel and SetPixel to invert an image’s pixel values.
Figure 23-3: Program MakeMetafile creates a metafile and then draws two copies of it.
Chapter 24: Printing
Figure 24-1: The PrintPreviewDialog control lets the user zoom in and out, and view the printout’s various pages.
Figure 24-2: The PrintDialog control lets the user send a printout to a printer.
Figure 24-3: The e.PageBounds and e.MarginBounds parameters give the paper’s printable area and margins.
Figure 24-4: This preview shows text broken across pages with a gutter and displaying page numbers along the outside edges.
Figure 24-5: Subroutine CenterPictureInMargins makes it easy to center a picture within a printed page.
Figure 24-6: Subroutine FitPictureToMargins makes it easy to center a picture within a printed page, making it as large as possible without distortion.
Figure 24-7: A program can use subroutine FitPictureToMargins to make a picture fit a PictureBox as well as a printed page.
Chapter 25: Reporting
Figure 25-1: To run reports on 64-bit computers, you can set the target CPU to x86.
Figure 25-2: This report displays students’ test scores.
Figure 25-3: To create a report, select the Crystal Report template.
Figure 25-4: Select the report type from the Crystal Reports Gallery.
Figure 25-5: The Standard Report Creation Wizard’s Data step lets you define the report’s data source.
Figure 25-6: Select the tables that you want to use in the report.
Figure 25-7: Use the Link page to define links between tables.
Figure 25-8: Use the Fields page to select the fields displayed by the report.
Figure 25-9: Use the Grouping page to determine how the report groups records.
Figure 25-10: The Summaries page lets you add summary information to the report.
Figure 25-11: Use the Group Sorting page to sort the items in groups.
Figure 25-12: Indicate the kind of chart you want to add to the report, if any.
Figure 25-13: Use the Record Selection page to filter the records included in the report.
Figure 25-14: The Report Style page lets you pick report formatting options.
Figure 25-15: You can modify the report in the development environment.
Figure 25-16: This dialog box lets you change a report’s data source.
Figure 25-17: The initial report may need some formatting changes.
Figure 25-18: Use the Group Expert to add, remove, and rearrange groups
Figure 25-19: Use the Change Group Options command to modify a group’s properties.
Figure 25-20: The Formula Workshop helps you define formulas for the report.
Figure 25-21: The rearranged report is much easier to read.
Chapter 26: Windows Presentation Foundation
Figure 26-1: This Button contains a Grid that holds three labels.
Figure 26-2: The Windows SDK adds .NET Framework 3.0 projects to the New Project dialog box.
Figure 26-3: The IDE looks almost the same for Windows Forms and WPF applications.
Figure 26-4: XAML code can make a gradient background while the Properties window cannot.
Figure 26-5: Solution Explorer does not list Visual Basic source files by default.
Figure 26-6: Use the Solution Explorer Show All Files button to find Visual Basic files.
Figure 26-7: This program uses resources to simplify maintenance.
Figure 26-8: Templates let you change the appearance and behavior of objects such as buttons.
Figure 26-9: Buttons can be rotated and scaled vertically and horizontally by using RotateTransform and ScaleTransform.
Figure 26-10: WPF includes objects to draw shapes such as lines, polygons, and ellipses.
Figure 26-11: The Path object can draw Bezier curves.
Figure 26-12: Program GrowingButtons uses Visual Basic code to animate buttons.
Figure 26-13: This FlowDocumentReader is using book reading mode.
Figure 26-14: The DocumentViewer provides the user with control over the page.
Chapter 27: Configuration and Resources
Figure 27-1: In Windows XP, click the Advanced tab to see the Environment Variables button.
Figure 27-2: Use this Windows XP dialog box to add, modify, and delete environment variables.
Figure 27-3: In Windows Vista, use the Advanced tab to see the Environment Variables button.
Figure 27-4: Use this Windows Vista dialog box to add, modify, and delete environment variables in Windows Vista.
Figure 27-5: Use this page to define application settings.
Figure 27-6: Use the drop-down list to assign a setting to the dynamic property.
Figure 27-7: The Resources tab contains image and other resources used by the application.
Figure 27-8: If you double-click on a resource, Visual Studio opens it in an appropriate editor.
Figure 27-9: The string resource view lets you edit string resources in a grid.
Figure 27-10: The file Resources.Designer.vb contains strongly typed properties that fetch resource values.
Figure 27-11: Visual Studio saves resources for different languages in separate resource files.
Figure 27-12: Locale-specific resource files include values for specific controls.
Chapter 29: File-System Objects
Figure 29-1: My.Computer.FileSystem.SpecialDirectories returns paths to special directories.
Chapter 30: Windows Workflow Foundation
Figure 30-1: This flowchart shows a simple bug-tracking workflow.
Figure 30-2: This flowchart shows a simplified bug-tracking workflow.
Chapter 32: Useful Namespaces
Figure 32-1: The Regex object’s Matches method returns a collection describing the places where a string matches a regular expression.
Figure 32-2: The Regex object can replace matching strings with a new string.
Figure 32-3: Program DesFile encrypts and decrypts files.
Figure 32-4: Changing even a single character in the password makes decryption produce an unintelligible result.
Figure 32-5: This program uses reflection to learn about its form’s properties.
Figure 32-6: This application uses reflection to display another application’s resources.
Figure 32-7: This Direct3D application displays a rotating octahedron.
Figure 32-8: When using Direct3D on 64-bit computers, set the target CPU to x86.
Appendix A: Useful Control Properties, Methods, and Events
Figure A-1: The DisplayRectangle property gives the area in which you should normally place items within a control.
Appendix G: Standard Controls and Components
Figure G-1: Visual Basic provides a large number of standard components and controls for Windows forms.
Figure G-2: The ColorDialog component enables the user to select a color.
Figure G-3: The ComboBox provides three different styles: Simple, DropDown, and DropDownList.
Figure G-4: The DateTimePicker control lets the user select a date and time.
Figure G-5: The FlowLayoutPanel control can arrange its contents from left to right, right to left, top-down, or bottom-up.
Figure G-6: The FolderBrowserDialog component lets the user select a directory.
Figure G-7: The FontDialog component lets the user select a font.
Figure G-8: The ListView control can display five views.
Figure G-9: Use the ListViewItem Collection Editor to define a ListView control’s items at design time.
Figure G-10: Use the ListViewSubItem Collection Editor to define a ListView item’s subitems.
Figure G-11: Use the ColumnHeader Collection Editor to define the columns a ListView displays in Detail mode.
Figure G-12: The MonthCalendar control lets the user select dates or a range of dates.
Figure G-13: The MonthCalendar control can display more than one month at a time.
Figure G-14: The NotifyIcon component displays an icon in the system tray.
Figure G-15: The OpenFileDialog component lets the user select a file.
Figure G-16: The PageSetupDialog component lets the user specify printing settings.
Figure G-17: The PrintDialog component lets the user specify printing options.
Figure G-18: The PrintPreviewControl control displays a print preview within your form.
Figure G-19: The PrintPreviewDialog component lets you easily display a full-featured print preview dialog box.
Figure G-20: The PropertyGrid control displays an object’s properties.
Figure G-21: This SplitContainer control divides an area vertically or horizontally.
Figure G-22: The StatusStrip control allows a program to display status information.
Figure G-23: The Items Collection Editor lets you edit the objects contained within a StatusStrip control.
Figure G-24: A TabControl lets you easily display pages of related data.
Figure G-25: Use the TabPage Collection Editor to define a TabControl’s tabs.
Figure G-26: In this example, the TableLayoutPanel control displays two columns of controls arranged in a grid.
Figure G-27: The ToolStrip component contains tools the user may want to use frequently.
Figure G-28: You can use the Items Collection Editor to define a ToolStrip’s tools at design time.
Figure G-29: The ToolStripContainer control lets the user rearrange ToolStrip controls at runtime.
Figure G-30: The TreeView control displays hierarchical data graphically.
Figure G-31: The TreeNode Editor lets you edit a TreeView control’s data at design time.
Appendix R: The My Namespace
Figure R-1: Click the Assembly Information button to view and set assembly information.
Figure R-2: Use this dialog box to enter information that the program can later retrieve using My.Application.AssemblyInfo.