If you know the name of the macro you want to work with, use this method to open the Visual Basic Editor and the macro at the same time. This example uses Word to open the Transpose_Word_Right macro that you recorded in Chapter 1:

Figure 2.1. The Visual Basic Editor with the Transpose_Word_Right macro open in the Code window

To open the Visual Basic Editor directly, follow these steps:

It's important to remember is that if you don't see the Properties window, press F4. More on this important window shortly.

After opening the Visual Basic Editor directly, use the Project Explorer pane (shown on the left side in Figure 2.1) to navigate to your macro. You also use the Project Explorer to navigate among open projects and modules when you're working in the Visual Basic Editor.

To navigate to the Transpose_Word_Right macro, follow these steps:

If the module contains more than one macro, you'll also need to select the macro you want to work with—in this case, the Transpose_Word_Right macro. (If you've recorded only the Transpose_Word_Right macro, only this macro appears in the Code window.) To select a macro, use one of these methods:

Figure 2.2. If the module contains two or more macros, scroll to the macro you want to edit, or select it from this Procedure drop-down list.

The Project Explorer is the tool for navigating among the various objects in the Visual Basic Editor. Figure 2.3 shows the Project Explorer for a Visual Basic Editor session with Word as the host application.

Figure 2.3. Use the Project Explorer to navigate to the module you want to work with.

Depending on the host application and its capabilities, each project can contain some or all of the following elements:

For most host applications, each open document and template is considered a separate project and is displayed as a root in the project tree. The project tree also contains any global macro storage container—such as the Normal.dotm template in Word, or the Personal Macro Workbook in Excel—and any add-ins that are loaded.

As an example, in Figure 2.3, Normal.dotm is identified as Normal, and the active document is identified as Project (2): a document named 2.

You navigate the Project Explorer in the same way that you navigate the Windows Explorer folder tree: Click the boxed plus sign to the left of a project item to expand the view and display the items contained in the project, and click the resulting boxed minus sign to collapse the view and hide the items again. Double-click a module to display its code in the Code window. Double-click a user form to display it in the Code window.

The Visual Basic Editor displays the Project Explorer by default, and because the Project Explorer provides fast and efficient navigation among the various elements of your VBA projects, it's usually easiest to keep it displayed unless you're short on screen space or you're working for long periods in the Code window and don't need to switch to other elements.

To close the Project Explorer, click its close button (the x button in its title bar). To display the Project Explorer again, press Ctrl+R or choose View

In Figure 2.3, three buttons appear on a toolbar at the top of the Project Explorer:

Code is merely a synonym for programming—the series of commands you type in to make the computer behave a certain way. Code is sometimes called programming code or source code.

Remember that the words used in programming—the terms such as MsgBox or End employed by a computer programming language such as VBA—are referred to by a variety of synonyms: statements, keywords, commands, and so on. In this book, I'll simply use the generic term commands.

For example, selecting the ThisDocument object for a Word document and clicking the View Object button displays the actual Word document in the Word window. Selecting the Sheet1 object in an Excel workbook and clicking the View Object button displays that worksheet in the Excel workbook in the Excel window.

The left part of Figure 2.4 shows the Project Explorer for an application session sorted by folder view, and the right part shows the Project Explorer for the same situation in contents view. Whether you spend more time in folder view or contents view will depend on the size of your screen, the number of objects you put in any given project, and the way your mind works, not necessarily in that order. For many purposes, you'll want to toggle between folder view and contents view to locate objects most easily.

Figure 2.4. Folder view (left) displays the objects separated into folders beneath the projects that contain them. Contents view (right) displays only the objects and the projects that contain them.

Apart from navigating to the items you need to work with, you can perform the following tasks with the Project Explorer:

The Visual Basic Editor provides a full Object Browser for working with objects in VBA. You'll look at the Object Browser in detail in Chapter 8, "Finding the Objects, Methods, and Properties You Need," and when you examine the object models for the various applications in the final part of the book. But, in the meantime, take a quick look at Figure 2.5, which shows the Object Browser for a Word VBA session. The Document object is selected in the left-hand panel, and a list of its properties appears in the right-hand panel.

Figure 2.5. The Object Browser provides a quick way to look up objects and their properties. Here, you can see the properties contained in the Document object.

You'll find that a number of these properties immediately make sense from your knowledge of Word documents. For example, the AttachedTemplate property tells you which template the document is currently attached to. Likewise, the Bookmarks property contains information on any bookmarks in the document. The property information is displayed at the bottom of the Object Browser.

You'll do most of the actual work of testing and editing your macros in the Visual Basic Editor's Code window. (Since code is written in plain text, you could simply write it in Notepad, then paste it into the code editor for testing and debugging. But the Visual Basic Editor offers so many useful programming tools that only the brilliant few can easily get good results by trying to wing it without any assistance from the editor.)

The Visual Basic Editor provides a Code window for each open project, for each document section within the project that can contains code, and for each code module and user form in the project. Each Code window is identified by the project name, the name of the module within the project, and the word Code in parentheses. Figure 2.6 shows the Visual Basic Editor Code window with the Transpose_Word_Right macro open in it.

As you can see from the figure, two drop-down list boxes appear just below the title bar of the Code window:

Figure 2.6. You edit macros in the Code window.

The Visual Basic Editor Code window provides a half-dozen features that help you edit code efficiently and accurately, as discussed in the following sections.

Complete Word

The Complete Word feature can complete the word you're typing into the Code window, once you've typed enough letters to distinguish that word from any other. If you haven't typed enough letters to distinguish the word, the Visual Basic Editor gives you the closest possibilities (see Figure 2.7). You can either "type down" (continue typing to narrow the selection) or scroll through the displayed list to find the one you want.

Figure 2.7. The Complete Word feature automatically completes a term when you've typed enough to identify it. If you haven't typed enough, you can choose from a short list.

The easiest way to activate Complete Word when you're typing code is to press Ctrl+spacebar. You can also choose Edit

Figure 2.8. The Edit toolbar contains features used when working in the Code window.

Quick Info

The Quick Info feature displays a ScreenTip showing syntax information about the currently selected variable, function, method, statement, or procedure. (Selected here just means the word in the code that's under or adjacent to the insertion point, the blinking cursor.) If you type in a command like MsgBox and then press the spacebar, the ScreenTip pops up to help you complete typing in the command. The tip shows both the required and optional elements of that command. Optional elements are enclosed in square brackets.

Figure 2.9 shows an example of a Quick Info ScreenTip.

Figure 2.9. Use the Editor's Quick Info feature to see a VB language command's syntax or a quick readout of status.

To display Quick Info, use one of these methods:

• Just type a space following a VB command. For example, type msgbox (space).

• Right-click a VB command and choose Quick Info from the shortcut menu.

• Position the insertion point in the command and press Ctrl+I.

• Position the insertion point in the term and choose Edit

  

• If you're typing in actual commands from the VBA language (as opposed to, say, variables or objects), the easiest way to see Quick Info is just to type the command's name (such as MsgBox), then press the spacebar key. Note that VB doesn't pay any attention to capitalization, so you can type in msgbox or MsgBox or whatever variation you wish. Once you finish typing in the line of code (by pressing Enter), the editor will automatically capitalize the command the standard way: MsgBox.

Auto List Members

Many VB commands have properties (qualities) or methods (behaviors). For example, a message box can display various icons (such as question mark, exclamation point, and so on) to cue the user about the purpose of the message (question, warning, etc.). This set of icons is a property of the message box object. And this property is specified right after the text message in the line of code. Therefore, when I type a comma to indicate that I'm now going to specify the icon for my message box, the Auto List Members feature opens a drop-down list of the choices available. As you can see in Figure 2.10, I'm choosing vbOKOnly, but there are several other possible choices, such as vbOKCancel, vbQuestion, and so on.

This allows you to quickly complete the line of code. Auto List Members is switched on by default and automatically shows when you type a period in an object description or a comma, parentheses, or other punctuation in a line of code. Notice in Figure 2.10 that I've typed in a message box command followed by the text Hello, World! and then a comma. As soon as I typed the comma, the list of properties appeared.

Alternatively, you can display the list box by clicking the Auto List Members button on the Edit toolbar.

To use Auto List Members to insert your choice into your code, follow these steps:

1. Press the down arrow key to scroll down to the property or method, or scroll down with the mouse (see Figure 2.10). You can also type the first few letters of the property or method's name to jump to it.

2. Enter the property or method into the code by doing one of the following:

   1. Press Tab, or double-click the property or method, if you want to continue adding more to this line of code after entering the property or method. (There might be additional optional properties you want to specify on this line.)

   2. Press Enter if you want to start a new line after entering the property or method.

Figure 2.10. Use the Auto List Members command to enter code items quickly and accurately.

List Constants

The List Constants feature displays a pop-up list box containing constants for a property you've typed so that you can quickly complete the expression. List Constants is switched on by default. Alternatively, you can display the list box by clicking the List Constants button on the Edit toolbar.

To use List Constants (see Figure 2.11), follow these steps:

1. Press ↓ to scroll down to the constant, type its first letter (or first few letters), or scroll down with the mouse.

2. Enter the constant in the code by doing the following:

   1. Press Tab, or double-click the constant, if you want to continue working on the same line after entering the constant.

   2. Press Enter if you want to start a new line after entering the constant.

Figure 2.11. The List Constants feature saves you time and effort, especially when typing complex constant names.

Data Tips

The Data Tips feature displays a ScreenTip containing the value of a variable the mouse pointer moves over when the Visual Basic Editor is in Break mode (a mode you use for testing and debugging macros, described later in this book). Figure 2.12 shows an example. The Data Tips feature is switched on by default, but you can switch it, and other features, off by choosing Tools

Figure 2.12. Use the Data Tips feature to check the value of a variable when you're running code.

The Visual Basic Editor provides a Properties window you can use to view and modify the properties of an object in VBA, such as a project, a module or class module, a user form, or a control (a button or check box in a dialog box, for example). If the Properties window isn't visible in the Editor, press F4.

The drop-down list at the top of the Properties window lets you pick the object whose properties you want to view or modify. The Alphabetic option displays an alphabetical list of the properties in the item, and the Categorized option presents a list of the properties broken down into categories. Generally, I find the categorization less than useful because many properties don't really fit neatly into any particular category.

Figure 2.13 shows the Alphabetic option with the properties for an Excel workbook on the left and the Categorized page on the right. (Showing the Categorized page for the Excel workbook or worksheet isn't very helpful because all of the properties belong to a Misc. category—miscellaneous. There's no categorization here at all.)

Figure 2.13. Use the Properties window to view the properties of a project, a user form, module, class module, or a control.

Many of the workbook properties are easy to grasp. For example, if the HasRoutingSlip property is set to False, it means the workbook does not have an email routing slip attached to it, and if the Saved property is set to True, that indicates that the workbook does not contain any unsaved changes. You'll meet the properties for user forms in Chapter 14 and Chapter 15.

The Visual Basic Editor displays the Properties window by default, but you can close it by clicking its close button (the x button). To display the Properties window again, press F4 or choose View

To change a property, click the cell containing the property's name. If a down arrow button appears in the value cell, click it to choose a new value from a drop-down list. If no button appears, click the value cell to display the blinking insertion cursor and type in a new value.

You'll be able to choose different values from drop-down lists, depending on the type of property. For a True/False property, you'll be limited to those two choices in the drop-down list. For a text property such as Name, you can enter any valid VBA name.

By default, the Properties window is docked below the Project Explorer. You can adjust the relative heights of the Properties window or the Project Explorer window by dragging the border between them. Or you can widen both at once by dragging the border to their right. If you undock the Properties window, you can resize it by dragging its borders or corners to display more properties or to shrink the window so it takes up less space in the Visual Basic Editor. Undock interior windows (also called panes, such as the Properties pane) by dragging it by its title bar or by double-clicking its title bar. Redock by double-clicking its title bar or dragging it back into position.

Beyond the Project Explorer, the Code window, and the Properties window, the Visual Basic Editor includes a number of other windows that it doesn't display by default. Two of the key windows are the Object Browser (which you met earlier in this chapter) and the Immediate window, which you'll use during the discussion of the VBA language in Chapter 5.

The Immediate window, shown in Figure 2.14, is a small, unadorned window you can use as a virtual scratch pad to enter lines of code you want to test without entering them in an actual macro itself. When you type a line of code into the Immediate window and press the Enter key, the Visual Basic Editor executes that code.

Figure 2.14. Use the Immediate window for on-the-fly work and information.

To display the Immediate window, press Ctrl+G or choose View

Sub ShowDebug()

Dim x As Integer
x = 12

Debug.Print x

End Sub

To begin choosing editor and view preferences, choose Tools

Figure 2.17. The Editor page of the Options dialog box.

Editor Format Page Options

The Editor Format page of the Options dialog box, shown in Figure 2.18, controls how code appears in the Visual Basic Editor.

Figure 2.18. The Editor Format page of the Options dialog box.

By default, comments in your code are rendered in green. This helps you easily recognize that type of text in the code window. You can change the default colors for various types of text by choosing a type of text in the Code Colors list box and then specifying its colors and typeface (font). You have control over Foreground, Background, and Indicator via drop-down lists. However, I find the default choices sensible, so I don't change them.

Here's what the Code Colors choices mean:

Normal Text

Takes care of much of the text in a typical procedure. You'll probably want to make this a conventional color (such as black, the default).

Selection Text

Affects the color of selected (highlighted) text.

Syntax Error Text

Affects the color VBA uses for offending lines. The default color is red.

Execution Point Text

Affects the color VBA uses for the line currently being executed in Break mode. You'll usually want to make this a highlighter color (like the fluorescent yellow the Visual Basic Editor uses as the default) so you can immediately see the current line.

Breakpoint Text

Affects the color in which VBA displays breakpoints (points where code execution is forced to stop).

Comment Text

Affects the color of comment lines. The default color is dark green.

Keyword Text

Affects the color of keywords (words recognized as part of the VBA language). Recall that in this book I'm using the term command for the words in the VBA language.

Such text accounts for a sizable portion of each procedure. You may want to display keywords in a different color than normal text because some people find it helpful to be able to distinguish keywords without needing to read the entire code. The default color is dark blue, which is a good choice—not so intrusive that the page looks like confetti yet not so hard to see that you can't quickly visualize the underlying syntax of a line of code.

Identifier Text

Affects the color VBA uses for identifiers. Identifiers include the names of variables, constants, and procedures you define.

Bookmark Text

Affects the color VBA uses for the bookmarks in your code.

Call Return Text

Affects the color VBA uses for calls to other procedures. By default, the Visual Basic Editor uses lime green for call return text.

You can change the font and size of all the types of text in the Code window by using the Font and Size drop-down lists on the Editor Format page. You can also prevent the display of the margin indicator bar (the zone in which items such as the Next Statement and Breakpoint icons appear) by clearing the Margin Indicator Bar check box. (Usually, these icons are helpful, but removing this bar slightly increases the code area on screen.)

General Page Options

The General page of the Options dialog box contains several categories of settings. The following sections discuss them in groups. I always leave these options set to the default settings, which are shown in Figure 2.19.

Figure 2.19. The General page of the Options dialog box.

Form Grid Settings Group Box

The Form Grid Settings options control how the Visual Basic Editor handles user forms:

• The Show Grid check box controls whether the Visual Basic Editor displays a grid pattern of dots on the user form in Design mode to help you place and align controls. This check box is selected by default.

• The Width and Height text boxes set the spacing of the dots that make up the grid. You can set any value from 2 points to 60 points (the default setting is 6 points). If you display the grid onscreen, you'll see the dots; if you don't display the grid, it still affects the Align Controls To Grid feature, discussed next. Experiment and find the coarseness of grid that you find easiest to work with.

• The Align Controls To Grid check box governs whether the Visual Basic Editor automatically snaps the edges of controls you place or move to the nearest grid line. This option lets you place controls in approximately the right positions rapidly and easily, but it prevents you from making extremely fine positional adjustments. The grid enforces certain positions, and you might find it frustrating when trying to improve the layout of controls you've already placed on a user form. (If so, one option is to clear the Align Controls To Grid check box; another is to leave it selected but to decrease the size of the grid—to allow finer adjustments.)

The Edit and Continue Group Box

The Edit And Continue group box contains only one control—the Notify Before State Loss check box. This option controls whether the Visual Basic Editor warns you, when you're running code, if you try to take an action that requires VBA to reset the values of all variables in the module.

Error Trapping Group Box

The Error Trapping group box contains three option buttons you use to specify how VBA handles errors that occur when you're running code:

Break On All Errors

Tells VBA to enter Break mode when it encounters any error, no matter whether an error handler (a section of code designed to handle errors) is active or whether the code is in a class module. Break On All Errors is useful for pinpointing where errors occur, which helps you track them down and remove them. But if you've included an error handler in your code, you probably won't need this option.

Break In Class Module

Arguably the most useful option for general use. When VBA encounters an unhandled error in a class module (a module that defines a type of object), VBA enters Break mode at the offending line of code.

Break On Unhandled Errors

The default setting, this is useful when you've constructed an error handler to deal with predictable errors in the current module. If there is an error handler, VBA allows the handler to trap the error and doesn't enter Break mode; but if there is no handler for the error generated, VBA enters Break mode on the offending line of code. An unhandled error in a class module, however, causes the project to enter Break mode on the line of code that invoked the offending procedure of the class, thus enabling you to identify (and alter) the line that caused the problem.

Compile Group Box

The Compile group box controls when VBA compiles the code for a project into executable code. Before any code can be executed, it needs to be compiled, but not all the code in a project must necessarily be compiled before the Visual Basic Editor can start executing the first parts of the code.

You can select the Compile On Demand check box if you want VBA to compile the code only as needed. VBA compiles the code in the procedure you're running before starting to execute that procedure, but it doesn't compile code in other procedures in the same module unless the procedure you're running calls them (transfers execution to them, a technique you'll learn later in this book).

As a result, execution of the procedure you run first in a module can begin as soon as VBA finishes compiling the code for that procedure. If the procedure then calls another procedure in the module, VBA compiles the code for the second procedure when the first procedure calls it, not when you begin running the first procedure.

Compile On Demand is usually a good option. It's especially useful when you're building a number of procedures in a module and have unfinished code lying around in some of them. In contrast, if you clear the Compile On Demand check box, VBA compiles all the code in all the procedures in the module before starting to execute the procedure you want to run. This means that not only does the procedure start a little later (more code takes more time to compile, though most computers today are so fast you won't notice), but any language error or compile error in any procedure in the entire module prevents you from running and testing the current procedure, even if the code in that procedure contains no errors. This is a problem when you've only sketched in some of the procedures, so they remain unfinished.

Suppose you have a module named Compilation that contains two procedures, GoodCode and BadCode, which look like this:

Sub GoodCode()
  MsgBox "This code is working."
End Sub

Sub BadCode()
  Application.Delete
End Sub

GoodCode simply displays a message box to indicate that it's working, whereas BadCode contains an invalid statement (Application objects don't have a Delete method). GoodCode runs without causing a problem, but BadCode causes an error every time.

If you try to run GoodCode with Compile On Demand switched on, the procedure runs fine: VBA compiles only the programming in the GoodCode procedure, finds no errors, and runs it. But if you try to run GoodCode with Compile On Demand switched off, VBA also compiles the code in BadCode before starting to run GoodCode—and VBA stops with a compile error at the bogus Application.Delete statement. This thorough checking before running any code is good for finished modules that work together, but it can slow you down and be annoying when you're just "sketching" code—experimenting with code in a module.

On the other hand, you can see the advantage of compiling all the code in the module when GoodCode calls BadCode, as in the third line of this version of the procedure:

Sub GoodCode()
  MsgBox "This code is working."
  BadCode
End Sub

Here, compiling the code in BadCode before starting to run GoodCode is a good idea because doing so prevents GoodCode from running if BadCode contains an error. If you run this version of GoodCode with Compile On Demand switched on, VBA compiles GoodCode and starts to run it, displaying the message box in the second line. The BadCode call in the third line then causes VBA to compile BadCode, at which point VBA stops with the compile error. You don't want this to happen in the middle of a complex procedure; in such a case, you'd want Compile On Demand switched off.

The Background Compile check box, which is enabled only when the Compile On Demand check box is selected, controls whether the Visual Basic Editor uses idle CPU time to compile further code while it's running the code that it has already compiled. Keep Background Compile switched on unless you notice and are bothered by any slowing of the execution of your code. With current computer speeds, and if your projects aren't huge, you'll likely be unaware of any bothersome difference in execution rate.

Show ToolTips and Collapse Proj. Hides Windows

The final two options on the General page of the Options dialog box are Show ToolTips and Collapse Proj. Hides Windows. Also known as ScreenTips, ToolTips are text descriptions that appear when you hover the mouse pointer over a button or icon. The Show ToolTips check box controls whether the Visual Basic Editor displays ToolTips for its toolbar buttons. ToolTips tend to be useful unless you're desperate to save the memory and processor cycles they consume—which is very unlikely.

The Collapse Proj. Hides Windows check box controls whether the Visual Basic Editor hides the Code window and other project windows that you collapse in the Project Explorer's tree. This check box is selected by default, and in general it's a useful choice. When you collapse a project in the Project Explorer, the Visual Basic Editor hides any Code windows or user form windows belonging to that project and removes them from the list that appears on the Window menu. When you expand the project again, the Visual Basic Editor displays the windows in their previous positions and restores them to the Window menu's list.

You can reposition the various windows (or panes) within the Visual Basic Editor. Your layout depends largely on the size and resolution of your screen and your personal preferences, but here are a couple of suggestions:

Figure 2.20. The Docking page of the Options dialog box.

The Visual Basic Editor supports the same toolbar and menu bar customizations as the classic, pre-Ribbon Microsoft applications used to offer, such as Office 2003.

However, since the Ribbon was introduced in Office 2007, the lone toolbar is the Quick Access Toolbar, and there are no menus on the main application. But the Visual Basic Editor retains the older interface style—enabling you to customize its menus and toolbars in the classic fashion.

To customize the Visual Basic Editor, choose View

You can customize the Visual Basic Editor's toolbars, menus, and context menus to suit the way you work. Above all, if you use the context menus, be sure to customize them so they provide the commands you need.

In particular, you may want to add two key commands to the context menus: Comment Block and Uncomment Block. The Comment Block command adds a comment apostrophe (') to the beginning of each line of code in a multiline block of text you select. This transforms these lines into a multiline comment that VBA won't execute.

Figure 2.21. Use the Customize dialog box to customize the Visual Basic Editor's menus, toolbars, and context menus.

The Uncomment Block command reverses the process. It removes the first comment apostrophe from each command in the selected block. This makes the lines executable. (Any line that was commented before you employed the Comment Block command helpfully remains commented after you run the Uncomment Block command. Run the Uncomment Block command again and you remove further commenting.)

These commands are available from the Edit toolbar in the normal configuration of the Visual Basic Editor, but you'll probably find it more convenient to make them available at all times from the Code window's context menu.

The Visual Basic Editor offers the context menus listed in Table 2.1. To customize a context menu, right-click anywhere within the toolbars and menus area. Then choose Customize from the shortcut menu. Now click the Toolbars tab in the Customize dialog box.

Select the Shortcut Menus check box in the Toolbars list on the Toolbars page of the Customize dialog box. Then click the Commands tab in the Customize dialog box and drag the command you want from the Commands page to the context menu (see Figure 2.22).

Figure 2.22. Use the Shortcut Menus toolbar to put key commands on the context menus in the Visual Basic Editor.

Here are a couple of suggestions for customizing the Visual Basic Editor:

You can also customize the Toolbox, a special pane that contains controls for building user forms and that can be made visible only when a user form is visible in the Code window. (Chapter 14, "Creating Simple Custom Dialog Boxes," and Chapter 15, "Creating Complex Dialog Boxes," show you how to build user forms.)

You can customize the Toolbox by adding and removing controls and adding new Toolbox pages of your own. Some programmers put their most-used controls on the Toolbox, all on one page, to save themselves time. These controls can include customized variations on the regular Toolbox controls, and by putting them on the Toolbox, you avoid having to customize them again.

For example, many dialog boxes you create need an OK button that dismisses the dialog box, implements some code, and then continues execution of the procedure. Each OK button needs its Name property set to cmdOK, its Caption property set to OK, its Default property set to True, and its Height and Width properties set to a size smaller than the clunky dimensions the Visual Basic Editor assigns by default. Once you've thus customized a command button by modifying all these properties, you can place a copy of the special button on the Toolbox and easily just reuse it for subsequent forms. This saves time. Another candidate for this kind of customization is the TextBox. The default TextBox displays only a single line and uses a nearly unreadable font size of 8. To avoid having to modify these default properties each time you use a textbox, create a custom textbox that has multiple lines and is set to a font size of 11.

Another reason to customize the Toolbox is to add advanced controls that extend the things you can do with dialog boxes and user forms.

Adding Controls to the Toolbox

The first way you'll probably want to add controls to the Toolbox is directly from a user form. For example, once you've created your custom OK and Cancel buttons, or a TextBox, you can copy them from the user form to the Toolbox so you can reuse them in any user forms you subsequently create.

To copy one of your custom controls from a displayed user form to the Toolbox, just drag it and drop it, as shown in Figure 2.23. (Chapter 14 shows you how to put controls onto user forms you create yourself.)

Microsoft and other vendors also provide a variety of prewritten controls you can add to your Toolbox. To add these controls, follow these steps:

1. Right-click in the Toolbox page where you want to add controls. (You'll learn how to add new pages to the Toolbox in the section "Adding Pages to the Toolbox" a little later in this chapter.)

2. Choose Additional Controls from the context menu to display the Additional Controls dialog box shown in Figure 2.24.

3. In the Available Controls list box, click the check boxes for the controls you want to add to the Toolbox, and then click the OK button.

Once you are finished, if you would like to collapse the list to only the currently selected items, click the Selected Items Only check box in the Show group box.

Figure 2.23. The quickest way to add a control to the Toolbox is to drag it there from a user form.

Figure 2.24. In the Additional Controls dialog box, select the check boxes for the controls you want to add, and then click the OK button.

Depending on your computer and what software is installed on it, you may find a variety of interesting and useful controls. There are numerous controls, but these are among the most noteworthy:

• A PDF Reader from Adobe

• Apple's QuickTime

• The Windows Media Player

Some of these controls can add important functionality to your macros. You can also search the Internet for additional specialized controls like calendars, security locks, and so on. Adding prebuilt controls can save you lots of time because you simply drag and drop functionality onto your user forms—functionality that doesn't require you to spend days writing code.

You can move a control from one page of the Toolbox to another by dragging it from the page it's on and moving the mouse pointer (still dragging) over the tab of the destination page to display that page. Then, move the mouse pointer down (again, still dragging) into the body of that page and drop the control.