List of Figures


Chapter 1: IDE

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 image from book 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-3: Visual Basic automatically provides collection editors for collection properties.
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-2: DrawString automatically processes Tab characters and Carriage Return/Line Feed pairs.
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.




Visual Basic 2005 with  .NET 3.0 Programmer's Reference
Visual Basic 2005 with .NET 3.0 Programmer's Reference
ISBN: 470137053
EAN: N/A
Year: 2007
Pages: 417

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net