routine. • Label/Routine Return — breaks when a label or user-defined routine comes up in the macro, but stops before executing the return from the label call • Line Number — breaks when the macro reaches a specified line number. This is the most common type of breakpoint: It suspends the execution of the macro and activates the Debugger when the specified line number is reached. • Product Call — breaks when the macro makes a call to an application or product • Variable Access — breaks when the macro accesses a variable • Variable Assign — breaks when the macro assigns a value to a variable The Location column indicates the location of the breakpoint in the macro code. The Macro column indicates the macro to which the breakpoint applies. By default, a breakpoint applies to all the macro files that are used by the macro that you are debugging; however, you can limit the breakpoint to a single macro file. The Pass Count column indicates the passcount for the breakpoint, which represents the number of times that the breakpoint conditions can occur before the breakpoint actually takes effect. The passcount decrements each time that the conditions occur, and the breakpoint triggers when the passcount reaches zero. For more information about setting breakpoints, see “To set a breakpoint in a PerfectScript macro” on page 117. Moving between breakpoints You can move between the breakpoints in a macro. For more information about moving between breakpoints, “To move between the breakpoints in a PerfectScript macro” on page 118. Disabling breakpoints You can temporarily disable all breakpoints. In this scenario, no breakpoints are recognized — even if their conditions occur — until all breakpoints are re-enabled, or until the macro ends and the Debugger terminates. For more information about disabling breakpoints, see “To disable all breakpoints in a PerfectScript macro” on page 118. 116 Working with breakpoints while debugging PerfectScript macros Logging events for breakpoints You can log events while debugging macros. The event log records an entry for each event that occurs during debugging; these entries include standard messages (such as “Debugger event logging enabled”) and custom messages for which you supply the comment. You can display the event log for a macro by clicking View ` Event Log or pressing Alt + 9. All breakpoints allow a message to be logged to the event log (if enabled) when that breakpoint is triggered. A breakpoint can be set to log a message, to cause a break in the macro, or both. In the left margin of the Breakpoints list, a hand symbol is displayed. A yellow hand indicates that a breakpoint that causes a break in the macro (and may also log an event message), while a blue hand indicates a breakpoint that logs an event message and does not cause a break in the macro. For more information about creating event logs, see “To log events for the breakpoints in a PerfectScript macro” on page 118. Executing tokens at breakpoints When a macro is stopped at a breakpoint, you can execute any PerfectScript command (or “token”) in a very localized temporary environment. The Debugger displays the commands along with their parameters and types, and it lets you select a command and specify a value for each parameter. When you execute the selected command, its return value is displayed (and assigned to a variable name, if one is specified). Be careful when executing tokens. Some PerfectScript commands cause the internal state of the running macro to change and can therefore cause errors to occur later in the macro. (Most of these commands do not appear in the command list and cannot be selected.) Values cannot be assigned to variables that have the same name as command token names. PerfectScript supports handler DLLs for third-party tokens. All tokens (not just the PerfectScript ones) are passed to the ValidateToken entry point. If the third-party DLL does not accept or approve the token, it can cause PerfectScript to abort the macro. PerfectScript tokens are passed to the HandleToken entry point in the third-party DLLs. For more information about executing tokens, see “To execute a token at a breakpoint in a PerfectScript macro” on page 119. To set a breakpoint in a PerfectScript macro 1 While debugging a macro, do any of the following: • Click Debug ` Breakpoints ` Edit. • Right-click any line in the macro, and then click Edit Breakpoints. • Press Ctrl + B. 2 Choose the type of breakpoint that you want to use from the Type list box, and then click Add. 3 Specify any settings for the breakpoint, and then click Update. Debugging PerfectScript macros 117 You can also Set a line-number breakpoint in a macro Do one of the following: • • • • Remove a breakpoint from a macro Double-click the line in the macro. Select the line in the macro, and click Debug ` Breakpoints ` Add. Select the line in the macro, and press Insert. Right-click the macro, and click Add Breakpoint. Do one of the following: • Double-click the breakpoint in the macro. • Select the breakpoint in the macro, and click Debug ` Breakpoints ` Remove. • Select the breakpoint in the macro, and press Delete. • Right-click the breakpoint in the macro, and click Remove Breakpoint. To move between the breakpoints in a PerfectScript macro • While debugging a macro, do one of the following: • Click Edit ` Find Next Breakpoint (or press Ctrl + N) to go to the next breakpoint. • Click Edit ` Find Previous Breakpoint (or press Ctrl + P) to go to the previous breakpoint. To disable all breakpoints in a PerfectScript macro • While debugging a macro, click Debug ` Breakpoints ` Enable/Disable All Breakpoints. You can also Disable a single line-number breakpoint Do one of the following: • Select the line that contains the breakpoint, and then click Debug ` Breakpoints ` Disable. • Select the line that contains the breakpoint, and then press Space. • Right-click the line that contains the breakpoint, and then click Disable Breakpoint. Enable all breakpoints Click Debug ` Breakpoints ` Enable/Disable All Breakpoints. Enable a single line-number breakpoint Do one of the following: • Select the line that contains the breakpoint, and then click Debug ` Breakpoints ` Enable. • Select the line that contains the breakpoint, and then press Space. • Right-click the line that contains the breakpoint, and then click Enable Breakpoint. To log events for the breakpoints in a PerfectScript macro 1 While debugging a macro, do any of the following: • Click Debug ` Breakpoints ` Edit. • Right-click any line in the macro, and then click Edit Breakpoints. 118 Working with breakpoints while debugging PerfectScript macros • Press Ctrl + B. 2 Select a breakpoint, and on the Actions page, do any of the following: • Enable the Break into debugger check box if you want that breakpoint to cause a break in the macro. • Enable the Log standard event message check box if you want that breakpoint to log a standard event message. • Enable the Log custom message check box, and specify the desired message, if you want that breakpoint to log a custom message. 3 Repeat step 2, as desired. 4 Click Event Log. 5 Enable the Logging enabled check box. 6 Click Save, and then specify a path and filename for the event log. By default, the event log is saved with a .log extension. To execute a token at a breakpoint in a PerfectScript macro 1 While debugging a macro, do one of the following: • Click View ` Execute Token. • Press Alt + 0. 2 Select the PerfectScript token that you want to execute, and then specify any parameter and return values that you want to use. 3 Click Execute to perform the command and display any return value. Be careful when executing tokens. Some PerfectScript commands cause the internal state of the running macro to change and can therefore cause errors to occur later in the macro. (Most of these commands do not appear in the command list and cannot be selected.) Working with variables while debugging PerfectScript macros As explained in “Understanding PerfectScript variables” on page 10, a variable stores a value that can change during the operation of a macro. When the Debugger stops at a breakpoint in a macro (see “Working with breakpoints while debugging PerfectScript macros” on page 115), the Variables list is updated to display, by name, the variables that are accessible to the macro at that location. For each variable, the Variables list provides the pool type (Local, Global or Persistent), value type, and contents. For more information, see “Using the Variables list in the Debugger” on page 107. While debugging a macro, you can use the Variables list to display, watch, and create variables. Displaying variables in macros You can use the Variables list to display all variables, or to display a combination of watched variables, local variables, global variables, and persistent variables. Debugging PerfectScript macros 119 The Variables list displays all variables that are defined at the current step in the macro. As you click the entries in the Label, Function, Procedure list, the variables in the list change to display the local variables that are defined in each step. Even though the Variables list may display multiple variables with the same name, only the most locally scoped variable with that name is accessible to the macro as it executes. For example, if there is both a local variable and a global variable named B, only the local B can be accessed by the macro. After a variable has been declared with the DECLARE, LOCAL, GLOBAL, or PERSIST statement in a macro, that variable appears in the Variables list even though its contents may be undefined. When a macro contains a large number of variables, the Variables list initially displays only the first 100 variables. (In the case of an array, the Variables list displays only the first 100 elements, and of those, the values of only the first 25 elements.) If you want, you can expand or collapse the list of variables. For more information, see “Displaying variables in macros” on page 119. Watching variables in macros If you are interested only in certain macro variables, you can add those variables to the Watch list. When the Watch list is displayed, it replaces the normal Variables list. Only entire arrays or non-array variables can be watched. Individual array elements cannot be watched separately from their corresponding parent array. For more information, see “To watch a variable while debugging a PerfectScript macro” on page 121. Creating variables in macros You can add variables to the macro that you are debugging. You can create new variables in any variable pool (Local, Global, or Persistent). Variables are created with undefined contents, but you can supply the value at any time. For more information, see “To create a variable while debugging a PerfectScript macro” on page 121. To display variables while debugging a PerfectScript macro • Click Variables ` View, and then click any of the following: • All — displays all variables • Watch List — displays only watched variables • Locals — displays only local variables • Globals — displays only global variables • Persistents — displays only persistent variables. A checkmark next to a command indicates that that type of variable is displayed. You can also Sort the Variables list Click a column heading, or click Variables ` Sort By and choose a sorting method. TIP: You can change the sort order of the Variables list from ascending to descending (or from descending to ascending) by clicking the heading of the sorting column. 120 Working with variables while debugging PerfectScript macros You can also Expand collapsed variables or a collapsed array in the Variables list Select the collapsed item, and then click Variables ` Expand. NOTE: Although you can expand the contents of an array, doing so can consume a great deal of time and memory, so a warning prompts whether to expand all elements or just the first 100 elements. TIP: When only the first 100 elements of an array are displayed, a 101st element represents the remaining elements in the array but without their values. You can display the remaining elements by clicking the […] icon next to the 101st element, or by collapsing the array and expanding it again (to display the warning that prompts whether to expand all elements). Collapse expanded variables or an expanded array in the Variables list Select the expanded item, and then click Variables ` Collapse. Refresh the Variables list Click Variables ` Refresh. To watch a variable while debugging a PerfectScript macro • Do one of the following: • Select the macro, and then click Variables ` Watch. • Right-click the variable in the Variables list, and then click Watch. After a variable is added to the Watch list, it is displayed until you remove it from the list, even if the variable ceases to exist (for example, if it is removed in the macro). When a variable ceases to exist, its pool type is displayed as “out of scope.” To create a variable while debugging a PerfectScript macro 1 When the Debugger stops at the desired breakpoint, click Variables ` New. The Create New Variable dialog box appears. 2 Type a name for the variable, enable the option that corresponds to the desired variable type, and then click Create. You can create an array variable by specifying the dimensions of the array after its name. You can also Edit a variable while debugging a macro Select the variable (or select the array that contains the variable, and then select the variable), change the contents of the variable in the Contents box, and then press Enter. NOTE: You cannot change the contents of an alias variable, but you can change the variable that is mapped to the alias. NOTE: If you change the contents of an array, the new value is placed in all of its array elements. However, changing the contents of an array element changes that element only and does not affect the contents of any other array elements. TIP: You can cancel a change by pressing Esc. Debugging PerfectScript macros 121 You can also Remove a variable while debugging a macro Select the variable, click Variables ` Delete, and then click the desired discard option. (You can remove the variable from the Variables list box, or you can remove the contents of the variable but leave it in the Variables list box.) NOTE: Discarding an array variable first resets the contents of all the array elements. TIP: Be careful when discarding variables, in case the macro requires the variable to be defined. Navigating the code while debugging PerfectScript macros While debugging a macro, you have several options for navigating the code. As previously discussed (see “To debug a macro by using the PerfectScript Debugger” on page 109), you can play through a macro during debugging. You can also pause, restart, or stop a macro during debugging. Also as previously discussed (see “Working with breakpoints while debugging PerfectScript macros” on page 115), you can use breakpoints if you want to suspend debugging in places where you want to examine the macro more closely. However, if you prefer, you can navigate macros by stepping through the code, using cursor position, enabling the animation feature. You can also search the macro code if you want to locate a specific item. Stepping through macros You can go through a macro step-by-step. This process is called “stepping through the macro.” The Debugger provides three commands for stepping through a macro: • Step Into — executes the next single statement. If the next statement is a label call or a routine call, then execution steps into the specified label or routine (even if that label or routine is in another macro file, such as a Use file). • Step Over — executes the call of the label or routine without stopping until its completion. The macro stops at the next statement in the current label or routine. • Step Out — executes until the next return is encountered (if a label or routine is entered) For information about this procedure, see “To step through a macro in the PerfectScript Debugger” on page 123. Using cursor position in macros The Debugger provides two commands for going through a macro by using cursor position: • Run to Cursor — continues execution down to the line under the mouse cursor in the Source list • Skip to Cursor — sets the next statement to be executed by the Debugger, without executing any statements between the current point and the new line. This feature lets you skip a series of statements without executing them, or allows for statements to be repeated. 122 Navigating the code while debugging PerfectScript macros For information about this procedure, see “To use cursor position while debugging a PerfectScript macro” on page 123. Animating macros The Debugger lets you animate macros. Animation allows you to step through macros line-by-line, automatically activating the Debugger at each step so that you can check the variables and other calls. Between each command, the Debugger is displayed for the amount of time specified in the Tools ` Settings dialog box. For information about this procedure, see “To animate a macro in the PerfectScript Debugger” on page 123. Searching macros The Debugger lets you search a macro for a specific line number or text string. The Debugger also lets you locate the current line of code when a macro is interrupted. For information about this procedure, see “To search macro code in the PerfectScript Debugger” on page 124. To step through a macro in the PerfectScript Debugger • While debugging a macro, do any of the following: • Click Debug ` Step Into to execute the next single statement. • Click Debug ` Step Over to execute the call of the label or routine without stopping until its completion. • Click Debug ` Step Out to execute the macro until the next return is encountered (if a label or routine is entered). To use cursor position while debugging a PerfectScript macro 1 While debugging a macro, position the cursor by clicking in the Source list. 2 Do one of the following: • Click Debug ` Run to Cursor to continue execution down to the line under the mouse cursor in the Source list. • Click Debug ` Skip to Cursor to set the next statement to be executed by the Debugger, without executing any statements between the current point and the new line. You can use the Skip to Cursor command if you need to skip a series of statements without executing them, or if some statements need to be repeated. However, this feature must be used with extreme caution: Skipping to a line that is not within the same label or routine can cause the internal macro execution state to become invalid and result in execution failure. To animate a macro in the PerfectScript Debugger • In the Debugger, click Debug ` Animate to begin playing the macro by using the specified animation settings. If the macro pauses, click Debug ` Animate to resume automatic play. For information about specifying the Debugger settings for animation and other debugging features, see “Setting up the Debugger” on page 108. Debugging PerfectScript macros 123 To search macro code in the PerfectScript Debugger • While debugging a macro, do any of the following: • To search for a specific line number, click Edit ` Find Line Number (or press Ctrl + G), and then specify the line number. • To search for specific text, click Edit ` Find Text (or press Ctrl + F), and then specify the text and the search options in the Find Text in Source dialog box that appears. • To search for the next instance of text that is specified in the Find Text in Source dialog box, click Find Next (or press F3). • To search for the previous instance of text that is specified in the Find Text in Source dialog box, click Find Previous (or press Shift + F3). For information about searching for breakpoints, see “To move between the breakpoints in a PerfectScript macro” on page 118. You can also Locate the current line of code when a macro is interrupted Click Edit ` Find Current Line. The entire line of code is highlighted in the Source list. Troubleshooting the PerfectScript Debugger The techniques that you use to debug a macro depend on the type of failure that is occurring. This section describes two such types of issues: • macros that stop at error messages • macros that contain faulty callbacks Debugging macros that stop at error messages One of the easiest problems to correct with the Debugger is when a macro terminates due to an error. To discover the cause of such an error, use the Debugger to play the macro as usual. When the macro stops, click Debug on the displayed error-message box to invoke the Debugger and load both the macro and the listing file for the macro compiler. The Debugger displays the following: • the problem line in the macro (see the Source list) • in reverse order, the labels, functions, and procedures that were called to get the macro to that point (see the Call History list) • the contents of the variables in the macro (see the Variables list) At this point, you can examine the source line to determine what the macro was doing when the error occurred. You can also check the contents of the variables that are being used at the current line to see if they contain incorrect, error-causing values. If all the variables at this point in the macro appear to have the correct values, select a previous line in the Call History list, and examine the source line and the contents of the variables at that point. If you find a variable value that seems improper, examine the source code that leads to the problem area. Locate a spot where the variable could have been changed, and double-click the line to set a line-number breakpoint at that spot. 124 Troubleshooting the PerfectScript Debugger Now stop the Debugger by clicking Debug ` Stop Debugging. You cannot continue executing the macro because an error has occurred. Restart the macro by clicking File ` Debug ` Play in PerfectScript. This displays the Debugger immediately before the macro starts. Because you set a line-number breakpoint, click Continue and run the macro until it encounters the line number that contains that breakpoint. When the macro reaches the line with the breakpoint, the Debugger is displayed. Examine the variable contents to verify that the macro is displaying the variable values that you expect. If not, you may need to specify a breakpoint at an earlier location and then restart the macro. You can also skip to the earlier location by clicking a line in the macro source and then clicking Debug ` Skip to Cursor. If everything appears to be working normally, click Step Into to execute the macro one statement at a time. At each step, examine the variables between each statement until something unexpected happens. For example, the contents of a variable may change unexpectedly, or the macro may call the wrong label. At this point, you have probably come to the line where the value of the variable causes the error. If it appears that the error occurs because a variable has the wrong contents, set a “variable assign” breakpoint for that variable by clicking Debug ` Breakpoints ` Edit and then choosing Variable Assign from the Type list box. When the contents of that variable change, a breakpoint occurs and the Debugger is displayed. If the variable is changed too often and too many breakpoints are occurring on the variable, disable the Variable Assign breakpoint and set a line-number breakpoint after most of the variable assignments are done but before the wrong contents are assigned. If the problem in the macro appears to associated with calling a certain product token, set a Product Token Call breakpoint for that product token, or for a related product token that may not be setting the application in the proper state, or for both. If the problem is that the macro is calling a specific label, function, or procedure too often, set a Label Call breakpoint for that label to see when and where it is being called. Debugging macros that contain faulty dialog-box callbacks Debugging dialog-box callbacks is one of the most challenging types of debugging. Many problems with dialog-box callbacks occur because the callback does not reference the callback data closely enough to determine if the exact conditions have occurred before performing the action; consequently, the action is performed at the wrong time (or too many times). A dialog-box callback label is called often, and most of the callbacks are usually not associated with the event of interest. As soon as a callback dialog box is shown, at least two or three callback events occur. These events are associated with the creation of the dialog box, the initialization of the controls, and the initial input focus that is received by the dialog box. One of the difficulties that are associated with debugging callbacks is that when the Debugger becomes active at a breakpoint, the Debugger receives focus over any window that had focus while the macro was running. Therefore, the callback dialog box in the macro also loses focus. When a callback dialog box loses or gains focus, a callback event is generated. If you set a breakpoint in a dialog-box callback label, a lose-focus callback event could occur on the callback dialog box when the Debugger is displayed. Then, when you continue macro execution in the Debugger, a gainfocus callback event could occur. This scenario could cause the breakpoint to stop the Debugger (because the callback label is called for the lose/gain focus of the dialog box), which would, in turn, cause more lose/gain callback events, which could cause another breakpoint, which could cause more lose/gain focus callback events, and so on. Debugging PerfectScript macros 125 The macro interpreter and the Debugger attempt to minimize this cyclic occurrence by determining whether the dialog box is losing or gaining focus because of the Debugger. If so, the focus callback events are not generated. Unfortunately, this explanation cannot always be reliably determined. The best way to prevent error loops is to write the dialog-box callback label so that it carefully examines the callback data array to determine the type of the callback event, and to have it respond only to specific callback event types. (Callbacks usually respond to events that are associated with manipulating a control, which are WM_COMMAND events with element [5] = 273). Next, set a breakpoint on a line of code that does not respond to losing or gaining focus. In this way, the breakpoint does not occur when the dialog box loses or gains focus, circumventing the error cycle. If a callback event occurs for a callback label that is different from any callback label that is currently executing, then the callback event causes the current callback code to be suspended, and the new callback code is called. By restricting this focus to different callback labels from any currently active callback label, you can ensure that a callback can be completed before another callback for that same callback label is allowed to occur. For more information, see “Setting up callbacks for PerfectScript dialog boxes” on page 96. For more information about dialog boxes, see “Creating UI for PerfectScript macros” on page 79. 126 Troubleshooting the PerfectScript Debugger Quattro Pro macros Understanding Quattro Pro macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Working with Quattro Pro macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 Quattro Pro macros 127 128 Quattro Pro macros Understanding Quattro Pro macros Quattro Pro macros are stored in notebook cells. Use this type of macro when a task is performed within Quattro Pro. For details on the differences between Quattro Pro macros and PerfectScript macros, please see “Comparing Quattro Pro macros with PerfectScript” in the main Help file for Quattro Pro. This section contains the following topics: • “Understanding Quattro Pro syntax” on page 129 • “Understanding Quattro Pro macro commands” on page 129 Understanding Quattro Pro syntax For an overview of Quattro Pro syntax, please see “Understanding Quattro Pro macro syntax” in the main Help file for Quattro Pro. See also “Examples of syntax in Quattro Pro macros” in the main Help file for Quattro Pro. For details on the syntax elements used in Quattro Pro macros, please see “Native syntax elements” in the “Quattro Pro Command Reference” section of the Macro Help (psh.chm). For help converting Quattro Pro syntax to other macro languages, see “Converting Quattro Pro macros” on page 131. Understanding Quattro Pro macro commands For details on the commands used in Quattro Pro macros, please see the “Quattro Pro Command Reference” section of the Macro Help (psh.chm). You can browse commands alphabetically, or by category. For help converting Quattro Pro commands to other macro languages, see “Converting Quattro Pro macros” on page 131. Understanding Quattro Pro macros 129 130 Understanding Quattro Pro macro commands Working with Quattro Pro macros You can create and edit Quattro Pro macros, and you can play and debug them. If desired, you can convert Quattro Pro macros to other macro languages. This section contains the following topics: • “Creating and editing Quattro Pro macros” on page 131 • “Playing and debugging Quattro Pro macros” on page 131 • “Converting Quattro Pro macros” on page 131 Creating and editing Quattro Pro macros You can create Quattro Pro macros by recording them or by writing (or “typing”) them. You can also edit Quattro Pro macros. For details, please see “Recording and editing Quattro Pro macros” in the main Help file for Quattro Pro. The main Help file for Quattro Pro also includes the following topics on creating highly specialized Quattro Pro macros: • “Using macros to customize application settings” • “Using macros to display a dialog box” Playing and debugging Quattro Pro macros You can play a Quattro Pro macro by using the menu bar or by using the macro buttons on a customized toolbar. For details, please see “Playing macros” in the main Help file for Quattro Pro. You can use the macro debugger to check for errors in a Quattro Pro macro. The debugger lets you assign all of the following: standard or conditional breakpoints, trace cells, and cells for editing. For details, please see “Debugging Quattro Pro macros” in the main Help file for Quattro Pro. Converting Quattro Pro macros If you want to use a Quattro Pro macro outside its notebook — for example, to automate tasks with several notebooks, or to interact with other WordPerfect Office programs — you must adapt it for use with PerfectScript or VBA. Adapting a Quattro Pro macro for use with PerfectScript In PerfectScript, the following Quattro Pro macro commands must be substituted as follows. Native Quattro Pro command Corresponding PerfectScript command {ABS} AbsoluteReference() {ASSIGN} AssignValue() Working with Quattro Pro macros 131 Any other Quattro Pro macro command — unless otherwise noted in its corresponding Help topic in the “Quattro Pro Command Reference” section of the Macro Help (psh.chm) — can be converted to PerfectScript by using a standard procedure. • To convert a Quattro Pro macro command to PerfectScript Adapting a Quattro Pro macro for use with VBA You can copy Quattro Pro macro script to a VBA code module. For details, please see “To copy Quattro Pro macros to a VBA code module” in the main Help file for Quattro Pro. To convert a Quattro Pro macro command to PerfectScript 1 Remove the opening brace of the command and place it just after command name. Example 1, before: {BlockCopy A1..A20,C10} Example 1, after: BlockCopy{A1..A20,C10} Example 2, before: {DOWN} Example 2, after: DOWN{} 2 Replace the {} braces with () parentheses. Example 1, before: BlockCopy{A1..A20,C10} Example 1, after: BlockCopy(A1..A20,C10) Example 2, before: DOWN{} Example 2, after: DOWN() 3 In the command name, change any periods to underscores. Example, before: Print.Block(A1..A20) Example, after: Print_Block(A1..A20) 4 If the command includes arguments, change each comma separator to a semicolon. 5 If an argument is calculated using a formula, enclose that formula in an Eval() statement. Example, before: BlockFill_Start(+A20*0.25) Example, after: BlockFill_Start(Eval("+A20*0.25")) Eval() 132 works only in PerfectScript macros. Converting Quattro Pro macros VBA macros Understanding VBA macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Getting started with VBA macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 Working with VBA macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 Creating UI for VBA macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Organizing and deploying VBA macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 VBA macros 133 134 VBA macros Understanding VBA macros Microsoft Visual Basic for Applications (more commonly known as VBA) offers a fully integrated development environment (IDE) that provides contextual pop-up lists, syntax highlighting, line-by-line debugging, and visual designer windows. These helpful prompts and aids create a particularly friendly learning environment for inexperienced developers. If VBA 6.3 is installed on your computer, you can access the VBA Editor from within WordPerfect, Quattro Pro, and Presentations. VBA 6.3 is not included with WordPerfect Office X6. To use VBA macros, you must separately install VBA 6.3. Before getting started with VBA in WordPerfect Office X6, it’s important to understand a little bit about VBA in general. This chapter answers the following questions: • “What is VBA?” on page 135 • “What is VBA automation?” on page 136 • “Who is VBA designed for?” on page 136 • “How does VBA compare with other programming languages?” on page 137 • “What are the main elements used in VBA?” on page 138 • “What is an object model?” on page 138 • “How is VBA code structured?” on page 140 What is VBA? VBA is a built-in programming language that can automate repetitive functions and create intelligent solutions in WordPerfect, Quattro Pro, and Presentations. VBA is both a language and an editor. It is not possible to have the language without the editor, nor is it possible to edit VBA in anything but the VB Editor or to run VBA programs without the VB Editor. VBA is developed by Microsoft and is built into almost all of its desktop applications, including Microsoft® Office. VBA is licensed by Microsoft to other companies, including Corel (in CorelDRAW® Graphics Suite, Corel DESIGNER® Technical Suite, and WordPerfect Office), Autodesk, Inc. (in AutoCAD®), and IntelliCAD Technology Consortium (in IntelliCAD®). This makes Corel applications compatible with a wide array of applications that support VBA. For a complete list of applications that support VBA, consult the Microsoft website. It is not necessary for an application to support VBA in order for the WordPerfect Office X6 VBA engine to control that application. That means you can build solutions in WordPerfect Office X6 that access databases specialized content editors, XML documents, and more. Understanding VBA macros 135 What is VBA automation? Most actions that you can do in WordPerfect Office X6 can be done programmatically through VBA. This programmability of is called automation. Automating repetitive tasks can save time and reduce effort, while automating complex tasks can make possible the otherwise impossible. In its simplest form, automation is simply recording a sequence of actions so that you can play them back time and again. The term macro has come to include any code that is accessible to VBA while running within the process, even though some of that code might be far more advanced than a mere set of recorded actions. For the purposes of this guide, a macro refers to VBA functions and subroutines (which are explained in “Building functions and subroutines” on page 141). While it is possible to record a sequence of actions in WordPerfect Office X6, the real power of automation and VBA is that these recordings can be edited to provide conditional and looping execution. Who is VBA designed for? VBA can be used by both non-programmers and programmers alike. VBA for non-programmers VBA is based on the successful Microsoft Visual Basic (VB) programming language. The main difference between VBA and VB is that you cannot create stand-alone executable (EXE) files using VBA, whereas you can with VB. That is to say, using VBA, you can create only programs that run inside the host application (in this case, WordPerfect, Quattro Pro, or Presentations). VB is a “visual” version of the BASIC programming language. This means that it is a very easy language to learn, particularly because it provides visual cues within the editor. Microsoft has added a great deal to the original BASIC language, and it is now a powerful and fast language (although not as powerful as Java™ or C++, nor as quick as C). The aim of this resource is not to teach you how to become a programmer but instead to teach experienced programmers how to apply their skills to developing useful solutions within WordPerfect Office X6. If you are not a programmer, you may find it useful to refer to the many books that have been written about VBA and VB before continuing to read this guide. VBA for programmers VBA is an in-process automation controller. In other words, VBA can be used to control the features of WordPerfect Office X6 that can be automated, and VBA runs efficiently by bypassing the interprocess synchronization mechanisms. However, the automation that the in-process VBA can access can also be accessed by the following: • external out-of-process automation controllers (OLE clients) • applications that are developed in programming languages (such as VB, Visual C++®, Windows® Script Host, and C++) that can be used to develop OLE clients • the VBA engines of other applications 136 What is VBA automation? How does VBA compare with other programming languages? VBA has many similarities with most modern, procedural programming languages, including Java and JavaScript, C and C++, and Windows Script Host. However, VBA runs as an in-process automation controller, whereas the other languages (apart from JavaScript) are used to compile stand-alone applications. VBA vs. Java and JavaScript VBA is similar to Java and JavaScript in that it is a high-level, procedural programming language that has full garbage collection and very little memory-pointer support. (See “Using memory pointers and memory allocation” on page 143 for more information.) In addition, code developed in VBA — much like code developed in Java and JavaScript — supports on-demand compilation and can be executed without being compiled. VBA has another similarity with JavaScript in that it cannot be executed as a standalone application. JavaScript is embedded within Web pages, as a mechanism for manipulating the Web browser’s document object model (or “DOM”). Likewise, VBA programs are executed inside a host environment — in this case, WordPerfect, Quattro Pro, or Presentations — so as to manipulate the host’s object model (which is discussed in “What is an object model?” on page 138). Most VBA applications can be compiled to P-code so as to make them run more quickly, although the difference is hardly noticeable given the sophistication of today’s computer hardware. Java can be similarly compiled; JavaScript, however, cannot. Finally, whereas VBA uses a single equals sign (=) for both comparison and assignment, Java and JavaScript use a single equals sign (=) for assignment and two equals signs (==) for Boolean comparison. (For more information on Boolean comparison and assignment in VBA, see “Using Boolean comparison and assignment” on page 144.) VBA vs. C and C++ Visual Basic — similarly to C and C++ — uses functions. In VB, functions can be used to return a value but subroutines cannot. In C and C++, however, functions are used regardless of whether you want to return a value. (For more information on functions and subroutines, see “Building functions and subroutines” on page 141.) VBA allocates and frees memory “transparently.” In C and C++, however, the developer is responsible for most memory management. This makes using strings in VBA even simpler than using the CString class in C++. Finally, whereas VBA uses a single equals sign (=) for both comparison and assignment, C and C++ use a single equals sign (=) for assignment and two equals signs (==) for Boolean comparison. (For more information on Boolean comparison and assignment in VBA, see “Using Boolean comparison and assignment” on page 144.) VBA vs. Windows Script Host Windows Script Host (WSH) is a useful addition to Windows for doing occasional scripting and automation of Windows tasks. WSH is an out-of-process automation controller that can be used to control WordPerfect Office X6. However, because WSH scripts cannot be compiled (and must be interpreted as they are executed) and must be run out of process, they tend to be slow. WSH is a host for a number of scripting languages, each of which has its own syntax. However, the standard language used by WSH is a macro language resembling Visual Basic, so for standard scripts, the syntax is the same as in VBA. Understanding VBA macros 137 What are the main elements used in VBA? If you’ve ever developed object-oriented code in C++, Borland Delphi, or Java, you’re already familiar with the concepts of “classes,” “objects,” “properties,” and “methods,” but let’s re-examine them in greater detail as they apply to VBA. A class is a description of something. For example, the class “car” is a small vehicle with an engine and four wheels. An object is an instance of a class. If we extend the car metaphor, then the actual, physical car that you go out and purchase for the purposes of driving is an object (that is, an instance of the class “car”). Most classes have properties. For example, the properties of the class “car” are that it is small, it has an engine, and it has four wheels. Every instance of the class “car” (that is, every object in that class) also has properties such as color, speed, and number of seats. Some properties, called “read-only” properties, are fixed by the design of the class; for example, the number of wheels or seats does not (usually) vary from car to car. However, other properties can be changed after the object has been created; for example, the speed of the car can go up and down, and, with a bit of help, its color can be changed. A method is an operation that the object can have performed on itself. In the example of the class “car,” the car can be made to go faster and slower, so two methods for the class are “accelerate” and “decelerate.” Objects are often made up of other smaller objects. For example, a car contains four objects of the class “wheel,” two objects of the class “headlight,” and so on. Each of these child objects has the same properties and methods of its class-type. This parent/child relationship of objects is an important one to recognize, particularly when referencing an individual object. Some classes “inherit” features from their parents. What is an object model? VBA relies on an application’s object model for communicating with that application and modifying its documents. Without an object model, VBA cannot query or change an application’s documents. Object models in software provide a high level of structure to the relationship between parent and child objects. Remember, though, that the object model is the map that the VBA language uses to access the various members — objects, methods, and properties — of a document, and to make changes to those members. Without the object model, it is simply impossible to gain access to the objects in the document. Understanding object hierarchy In any object model, each object is a child of another object, which is a child of another object. Also, each object has child members of its own — properties, objects, and methods. All of this comprises an object hierarchy that is the object model. In order to “drill down” through the layers of hierarchy to get to the object or member that you want, you must use a standard notation. In VBA, as in many object-oriented languages, the notation is to use a period ( . ) to indicate that the object on the right is a member (or child) of the object on the left. It is not usually necessary to use the full hierarchical (or fully qualified) reference to an object or its properties. Some of the object-syntax in the fully qualified reference is mandatory or required; however, other syntax is optional (because a shortcut object for it is available, or because it is implicit or implied), and so it can either be included for clarity or omitted for brevity. 138 What are the main elements used in VBA? A shortcut object is merely a syntactical replacement for the long-hand version of the object. Understanding the PerfectScript and Script classes The object models for WordPerfect, Quattro Pro, and Presentations contain a class called PerfectScript, the methods for which correspond to the PerfectScript product commands for WordPerfect, Quattro Pro, and Presentations (respectively). The object models for WordPerfect and Presentations also contain a class called Script, the methods for which correspond to the PerfectScript programming commands. For guidance on using the methods of the PerfectScript and Script classes, please refer to the macrocommand documentation in the “Macro Command Reference” section of the Macro Help (psh.chm). Understanding the WordPerfect object model The WordPerfect object model breaks down into five main classes: • Application — contains properties that govern the application • Document — contains properties, methods, and events that govern documents • GlobalMacros — contains properties, methods, and events that are used for macro storage • PerfectScript — contains methods that correspond to the PerfectScript product commands for WordPerfect, which are documented in the “WordPerfect Command Reference” section of the Macro Help (psh.chm). • Script — contains methods that correspond to the PerfectScript programming commands, which are documented in the “PerfectScript Command Reference” section of the Macro Help (psh.chm). For information specific to using VBA in WordPerfect, please see “Using macros and other automation features” in the main WordPerfect Help (wpwp.chm). The topic “Using the PerfectScript class to change WordPerfect documents” is particularly useful for creating a VBA macro that uses the PerfectScript class. Understanding the Quattro Pro object model The Quattro Pro object model breaks down into three main classes: • Application — contains properties that govern the application • Document — contains properties and events that govern documents • PerfectScript — contains methods that correspond to the PerfectScript product commands for Quattro Pro, which are documented in the “Quattro Pro Command Reference” section of the Macro Help (psh.chm). For information specific to using VBA in Quattro Pro, please see “Using macros” in the main Quattro Pro Help (qp.chm). The topic “Using the PerfectScript class to change a Quattro Pro document” is particularly useful, as are the VBA examples in “Reference: Using macros.” Understanding the Presentations object model The Presentations object model breaks down into five main classes: • Application — contains properties that govern the application • Document — contains properties, methods, and events that govern documents • GlobalMacros — contains properties, methods, and events that are used for macro storage Understanding VBA macros 139 • PerfectScript — contains methods that correspond to the PerfectScript product commands for Presentations, which are documented in the “Presentations Command Reference” section of the Macro Help (psh.chm). • Script — contains methods that correspond to the PerfectScript programming commands, which are documented in the “PerfectScript Command Reference” section of the Macro Help (psh.chm). For information specific to using VBA in Presentations, please see “Working with VBA macros” in the main Presentations Help (wppr.chm). The topic “Using the PerfectScript class to change slide shows” is particularly useful. How is VBA code structured? Because VBA is a procedural language that shares much in common with all procedural languages, your current knowledge should help you get off to a quick start with VBA. This section examines the following topics on VBA structure and syntax: • Declaring variables • Building functions and subroutines • Ending lines • Including comments • Using memory pointers and memory allocation • Defining scope • Using Boolean comparison and assignment • Using logical and bitwise operators • Providing message boxes and input boxes The VB Editor formats all of the code for you (as discussed in “Formatting code automatically” on page 150). The only custom formatting that you can do is to change the size of the indentations. VBA can create object-oriented classes, although these are a feature of the language and are not discussed in detail in this guide. Declaring variables In VBA, the construction for declaring variables is as follows: Dim foobar As Integer The built-in data types are Byte, Boolean, Integer, Long, Single, Double, String, Variant, and several other less-used types including Date, Decimal, and Object. Variables can be declared anywhere within the body of a function, or at the top of the current module. However, it is generally a good practice to declare a variable before it is used; otherwise, the compiler interprets it as a Variant, and inefficiencies can be incurred at run time. Booleans take False to be zero and True to be any other value, although converting from a Boolean to a Long results in True being converted to a value of –1. To get more information about one of the built-in data types, type it into the code window, select it, and then press F1. 140 How is VBA code structured? Data structures can be built by using the following syntax: Public Type fooType item1 As Integer item2 As String End Type Dim myTypedItem As fooType The items within a variable declared as type fooType are accessed using dot notation: myTypedItem.item1 = 5 Declaring strings Strings in VBA are much simpler than in C. In VBA, strings can be added together, truncated, searched forwards and backwards, and passed as simple arguments to functions. To add two strings together, simply use the concatenation operator (&) or the addition operator (+): Dim string1 As String, string2 As String string2 = string1 & " more text" + " even more text" In VBA, there are many functions for manipulating strings, including InStr(), Left(), Mid(), Right(), Len(), and Trim(). Declaring arrays To declare an array, use parentheses — that is, the ( and ) symbols: Dim barArray (4) As Integer The value defines the index of the last item in the array. Because array indexes are zero-based by default, there are five elements in the preceding sample array (that is, elements 0 thru 4, inclusive). Arrays can be resized by using ReDim. For example, the following code adds an extra element to barArray, but preserves the existing contents of the original five elements: ReDim Preserve barArray (6) Upper and lower bounds for an array can be determined at run time with the functions UBound() and LBound(). Multi-dimensional arrays can be declared by separating the dimension indexes with commas: Dim barArray (4, 3) Building functions and subroutines VBA uses both functions and subroutines (or “subs”). Functions can be used to return a value, whereas subs cannot. In VBA, functions and subs do not need to be declared before they are used, nor before they are defined. In fact, functions and subs need to be declared only if they actually exist in external system dynamic-linked libraries (DLLs). Typical functions in a language such as Java or C++ can be structured as follows: void foo( string stringItem ) { // The body of the function goes here Understanding VBA macros 141 } double bar( int numItem ) { return 23.2; } In VBA, however, functions are structured as in the following example: Public Sub foo (stringItem As String) ' The body of the subroutine goes here End Sub Public Function bar (numItem As Integer) As Double bar = 23.2 End Function To force a function or sub to exit immediately, you can use Exit Function or Exit Sub (respectively). Declaring enumerated types To declare an enumerated type, use the following construction: Public Enum fooEnum ItemOne ItemTwo ItemThree End Enum The first item in an enumerated type is assigned, by default, a value of zero. Ending lines In VBA, each statement must exist on its own line, but no special character is required to denote the end of each line. (This is in contrast to the many programming languages that use the semicolon to separate individual statements.) To break a long VBA statement over two or more lines, each of the lines (other than the last line) must end with an underscore ( _ ) preceded by at least one space: newString = fooFunction ("This is a string", _ 5, 10, 2) It is also possible to combine several statements in a single line by separating them with colons: a = 1 : b = 2 : c = a + b A line cannot end with a colon. Lines that end with a colon are labels used by the Goto statement. Including comments Comments in VBA — similarly to in C++ and Java — can be created only at the end of a line. Comments begin with an apostrophe ( ' ) and terminate at the end of the line. Each line of a multi-line comment must begin with its own apostrophe: a = b ' This is a really interesting piece of code that ' needs so much explanation that I have had to break ' the comment over multiple lines. 142 How is VBA code structured? To comment out large sections of code, use the following code (similarly to in C or C++): #If 0 Then ' That's a zero, not the letter 'oh'. ' All this code will be ignored by ' the compiler at run time! #End If Using memory pointers and memory allocation VBA does not support C-style memory pointers. Memory allocation and garbage collection are automatic and transparent, just as in Java and JavaScript (and some C++ code). Passing values “by reference” and “by value” Most languages, including C++ and Java, pass an argument to a procedure as a copy of the original. If the original must be passed, then one of two things can happen: • a memory pointer is passed that directs to the original in memory • a reference to the original is passed The same is true in VB, except that passing a copy of the original is called passing by value and passing a reference to the original is called passing by reference. By default, function and subroutine parameters are passed by reference. This means that a reference to the original variable is passed in the procedure’s argument, and so changing that argument’s value within the procedure, in effect, changes the original variable’s value as well. This is a great way of returning more than one value from a function or sub. To explicitly annotate the code to indicate that an argument is being passed by reference, you can prefix the argument with ByRef. If you want to prevent the procedure from changing the value of the original variable, you can force the copying of an argument. To do this, prefix the argument with ByVal, as shown in the example that follows. This ByRef/ ByVal functionality is similar to the ability of C and C++ to pass a copy of a variable, or to pass a pointer to the original variable. Private Sub fooFunc (ByVal int1 As Integer, _ ByRef long1 As Long, _ long2 As Long) ' Passed ByRef by default In the preceding example, arguments long1 and long2 are both, by default, passed by reference. Modifying either argument within the body of the function modifies the original variable; however, modifying int1 does not modify the original because it is a copy of the original. Defining scope You can define the scope of a data type or procedure (or even an object). Data types, functions, and subs (and members of classes) that are declared as private are visible only within that module (or file), while functions that are declared as public are visible throughout all the modules; however, you may have to use fully qualified referencing if the modules are almost out of scope — for example, if you are referencing a function in a different project. Unlike C, VBA does not use braces — that is, the { and } symbols — to define local scope. Local scope in VBA is defined by an opening function or sub definition statement (that is, Function or Sub) and a matching End Understanding VBA macros 143 statement (that is, End Function or End Sub). Any variables declared within the function are available only within the scope of the function itself. Using Boolean comparison and assignment In VB, Boolean comparison and assignment are both performed by using a single equals sign (=): If a = b Then c = d This is in contrast to many other languages that use a double equals sign for a Boolean comparison and a single equals sign for assignment: if( a == b ) c = d; The following code, which is valid in C, C++, Java, and JavaScript, is invalid in VBA: if( ( result = fooBar( ) ) == true ) This would have to be written in VBA as the following: result = fooBar( ) If result = True Then For other Boolean comparisons, VBA uses the same operators as other languages (except for the operators for “is equal to” and “is not equal to”). All the Boolean-comparison operators are provided in the following table: Comparison VBA operator C-style operator Is equal to = == Is not equal to <> != Is greater than > > Is less than < < Is greater than or equal to >= >= Is less than or equal to <= <= The result of using one of the Boolean operators is always either True or False. Using logical and bitwise operators In VBA, logical operations are performed by using the keywords And, Not, Or, Xor, Imp, and Eqv, which perform the logical operations AND, NOT, OR, Exclusive-OR, logical implication, and logical equivalence (respectively). These operators also perform Boolean comparisons. The following code shows a comparison written in C or a similar language: if( ( a && b ) || ( c && d ) ) This would be written as follows in VBA: If ( a And b ) Or ( c And d ) Then Alternatively, the above could be written in the following full long-hand form: If ( a And b = True ) Or ( c And d = True ) = True Then 144 How is VBA code structured? The following table provides a comparison of the four common VBA logical and bitwise operators, and the Cstyle logical and bitwise operators used by C, C++, Java, and JavaScript: VBA operator C-style Boolean C-style bitwise operator operator And & && Not ~ ! Or | || Xor ^ Providing message boxes and input boxes You can present simple messages to the user by using the MsgBox function: Dim retval As Long retval = MsgBox("Click OK if you agree.", _ vbOKCancel, "Easy Message") If retval = vbOK Then MsgBox "You clicked OK.", vbOK, "Affirmative" End If You can also get strings from the user by using InputBox function: Dim inText As String inText = InputBox("Input some text:", "type here") If Len(inText) > 0 Then MsgBox "You typed the following: " & inText & "." End If If the user clicks Cancel, the length of the string returned in inText is zero. Understanding VBA macros 145 146 How is VBA code structured? Getting started with VBA macros Now that you understand a bit about VBA, you’re ready to get started with macros. This chapter covers the following topics: • “Using the Visual Basic toolbar” on page 147 • “Using the VB Editor” on page 147 • “Using the Project Explorer in the VB Editor” on page 148 • “Using the Properties window in the VB Editor” on page 149 • “Using the Code window in the VB Editor” on page 150 • “Using the toolbars in the VB Editor” on page 152 • “Using the Object Browser in the VB Editor” on page 152 Using the Visual Basic toolbar WordPerfect and Quattro Pro feature a toolbar that provides easy access to the VB Editor. The Visual Basic toolbar The toolbar buttons provide the following functions: • playing macros • opening the VB Editor • switching the VB Editor between its modes for designing and running macros To display the Visual Basic toolbar in WordPerfect or Quattro Pro 1 Click View ` Toolbars. 2 Enable the Visual Basic check box, and then click OK. Using the VB Editor The VB Editor that is included with VBA is similar to the one included with full Visual Basic. The VB Editor lets you develop code and dialog boxes, browse the object tree and the modules within each project, set individual properties for objects, and debug code. However, it’s important to note that the VB Editor for VBA cannot compile executable (EXE) program files. The VB Editor features several windows and toolbars, all of which are discussed in this section. The three available windows are the Project Explorer (see “Using the Project Explorer in the VB Editor” on page 148), the Properties window (see “Using the Properties window in the VB Editor” on page 149), and the Code window (see “Using the Code window in the VB Editor” on page 150). The four available toolbars (see “Using the toolbars in the VB Editor” on page 152), are the Standard toolbar, the Debug toolbar, the Edit toolbar, and the UserForm toolbar, of which you will use the Standard and Debug toolbars most often. Getting started with VBA macros 147 Standard toolbar Debug toolbar Project Explorer Edit toolbar Code window UserForm toolbar Properties window The VB Editor also lets you access the Object Browser (see “Using the Object Browser in the VB Editor” on page 152). You can invoke the VB Editor from within WordPerfect, Quattro Pro, or Presentations. Although this starts VBA as a new application in Windows, it runs within the WordPerfect, Quattro Pro, or Presentations process. To start the VB Editor • Click Tools ` Visual Basic ` Visual Basic Editor, or press Alt + F11. To switch between the VB Editor and WordPerfect, Quattro Pro, or Presentations, use the Windows taskbar, or press Alt + F11 or Alt + Tab. Using the Project Explorer in the VB Editor The Project Explorer is essential for navigating VBA projects and their constituent documents/objects, forms, modules, and class modules. The Project Explorer with a module selected 148 Using the Project Explorer in the VB Editor Each type of item in the Project Explorer has an icon assigned to it: Icon Meaning project folder document/object form module class module To display or hide the Project Explorer • Click View ` Project Explorer, or press Ctrl + R. Using the Properties window in the VB Editor The Properties window lists all of the editable properties for the currently selected object. Many objects in VBA — including projects, modules, and forms and their controls — have property sheets that can be modified. The Properties window, showing the properties of a form The Properties window is automatically updated when you select an object, or when you change the properties of the selected object by using other methods (for example, by using the mouse to move and resize form controls). Getting started with VBA macros 149 To display or hide the Properties window • Click View ` Properties window, or press F4. Using the Code window in the VB Editor The Code window is where you spend most of your time when working on macros. A standard code editor in the style of Microsoft® Visual Studio®, the Code window lets you format code automatically, color and check syntax automatically, jump to definitions, and use contextual pop-up lists and automatic completion. If you are already familiar with any of the Microsoft Visual Studio editors, the VB Editor Code window will be entirely familiar to you. Formatting code automatically The VB Editor formats code automatically for you — even the capitalization of keywords, functions, subroutines, and variables is taken care of by the VB Editor, irrespective of what you type. You cannot custom-format code, although you can set the indentation for each line, as well as the placing of custom line breaks. When it comes to calling functions and subs, you must adhere to the following rules: • If you are calling a function and you are using the returned value, the parentheses around the parameters are mandatory (just as in most modern programming languages): a = fooFunc (b, c) • However, if the returned value from a function call is being discarded, or if you are calling a sub, the parentheses must be left out (unlike in most other languages): barFunc d, e fooBarSub f • If you prefer always to see the parentheses, use the Call keyword before the function or sub call: Call barFunc (d, e) Call fooBarSub (f) Coloring syntax automatically When you develop code in the Code window, the editor colorizes each word according to its classification: • VBA keywords and programming statements are usually displayed in blue. • Comments are displayed in green. • All other text is displayed in black. This colorization makes the code much easier to read. The Code window also uses the following colorization techniques: • Lines of code containing errors are displayed in red. • Selected text is white on blue. • The line where execution paused for debugging is shown as a yellow highlight. • Breakpoints that you set for debugging purposes are shown as a red dot in the left margin with the code in white on a red background. • Bookmarks (which you set in the code) are indicated by a blue dot in the left margin. 150 Using the Code window in the VB Editor Breakpoints (along with bookmarks) are lost when you quit the application. For more information on them, see “Setting breakpoints” on page 159. You can modify the default colors for syntax highlighting by clicking Tools ` Options, clicking the Editor format tab, and making your changes. Checking syntax automatically Every time you move the cursor out of a line of code, the editor checks the syntax of the code in that line; if it finds an error, it changes the color of the text of that line to red and displays a pop-up a warning. This real-time checking is useful (particularly when you are learning VBA) because it indicates many possible errors in the code without having you run the code. You can disable pop-up warnings by clicking Tools ` Options, clicking the Editor tab, and then disabling the Auto syntax check check box. The VB Editor still checks the syntax and highlights erroneous lines in red, but it stops displaying a warning when you paste text from another line of code. Jumping to definitions You can jump directly to the definition of a variable, procedure, or object by right-clicking the item in the Code window and then clicking Definition. This takes you either to the definition of the variable or function in the code or to the object’s definition in the Object Browser. To return to where you requested the definition, right-click, and then click Last position in the Code window. Using contextual pop-up lists and automatic completion As you write procedures and define variables, the VB Editor adds these items to an internal list that already contains all of its built-in keywords and enumerated values. As you type, the VB Editor presents you with a list of candidate words that you may want to insert at the current position; this list is contextual, so the VB Editor usually presents only the words that are valid for the current position. This list makes code development quicker and more convenient, particularly because you do not need to remember every function and variable name but can instead choose them from the list provided. If you type the first few characters of the word you want to use, the list advances to the nearest candidate that matches the characters you’ve entered. Select the word you want to use, and either type the character that you want to have follow the word (typically a space, line feed, parenthesis, period, or comma) or press Tab or Ctrl + Enter to enter only the word. To force the pop-up menu display, you can press Ctrl + Spacebar. The menu scrolls to the word that most closely matches the characters that you have typed so far. This technique is also useful for filling parameter lists when calling a function or subroutine. If there is only one exact match, the VB Editor inserts the word without popping up the list. To display the pop-up list for the selected keyword at any time without auto-filling it, press Ctrl + J. Getting started with VBA macros 151 Using the toolbars in the VB Editor The VB Editor features four toolbars that you can use to carry out your VBA tasks. The Standard toolbar is the default toolbar. The Standard toolbar The Debug toolbar contains buttons for common debugging tasks (as discussed in “Debugging VBA macros” on page 159). The Debug toolbar The Edit toolbar contains buttons for common editing tasks. The Edit toolbar The UserForm toolbar contains buttons specific to designing forms (as discussed in “Designing dialog boxes for VBA macros” on page 165). The UserForm toolbar You can choose to display or hide each toolbar. To display or hide a toolbar • Click View ` Toolbars, and then click the command that corresponds to the toolbar you want to display or hide. A check mark next to a command indicates that its toolbar is currently displayed. You can “float” a toolbar by dragging it from the menu bar. You can dock a toolbar by dragging it to the menu bar. Using the Object Browser in the VB Editor The Object Browser is one of the most useful tools provided by the VB Editor. The Object Browser displays the entire object model of all referenced components (that is, all ActiveX® or OLE objects that are used by the project) and, most importantly, the object model of WordPerfect, Quattro Pro, or Presentations — all in an easyto-use, structured format. 152 Using the toolbars in the VB Editor Project/ Library list box Help button search controls View definition button Search Results window Copy to Clipboard button Class list Member list Information window navigation buttons The Object Browser window To open the Object Browser, click View ` Object Browser, or press F2. To reference the object models for other applications, click Tools ` References. Referenced components can be accessed by the VBA code. All of the referenced objects — plus the current module — are listed in the Project/Library list box in the upper-left corner of the Object Browser. By default, all of the member classes for the referenced objects are provided in the Class list. It is easier to use the Object Browser when only one project or library is displayed. To display only one project or library, choose it from the Project/Library list box. More detailed information follows about certain Object Browser elements. Using the Class list The Class list shows all of the classes in the current project or library. When you select a class in the Class list, the members of that class are shown in the Member list. Every project or library has an object model that contains a number of member classes. Next to each item in the Class list, an icon depicts its class type: Class icon Type global value module enumerated type Getting started with VBA macros 153 Class icon Type type class module Global values (which apply to the selected project in its entirety) include individual members from enumerated types (such as text paragraph alignments, shape types, and import/export filters). Member classes of an object have their own members. To receive detailed information about a selected item, click the Help button at the top of the Object Browser. Using the Member list The Member list shows all of the properties, methods, and events that are members of the current class. Each member is given an icon according to its type: Class icon Type property implied or default property method event constant Property members may be simple types (such as Booleans, integers, or strings), or they may be a class or enumerated type from the Class list. A property that is based on a class from the Class list inherits all the members of that class. Many classes have a default property, indicated by a blue dot in their icon. The default property is implied if no property name is given when getting or setting the value of the parent object. Methods are commonly known as “member functions” — functions that the class can perform on itself. If the return value of a function is not used, the function call does not take parentheses around the argument list unless the Call keyword is used. Some classes have various events associated with them. By setting up an event handler for a class’s event, when that event occurs in the application, the event’s handler is called. This functionality enables sophisticated applications to be developed that respond automatically to what is happening within the application. 154 Using the Object Browser in the VB Editor The constants listed in the Member list are either members of enumerated types or defined as Public in a module. Enumerated types are used to group related items from a closed list. Using the Information window The Information window gives information about the selected class or class member. This information includes a “prototype” of the member, its parent, and a short description of the member, and it also states whether the member is a read-only property. The Information window The types of any function parameters and properties are given as hyperlinks to the type definition or class itself, if the type is defined within the current object model. To increase the height of the Information window, drag the top border of the window upwards to reveal its contents, or scroll down using the scrolls bar at the right of the window. Using the search controls You can search the object model for a matching string. This is useful for finding a class or member whose name you can only partly remember, or for finding classes and members that have similar names (such as names based on, or containing, the word “open”). Searching an object model To search an object model’s classes and members, type a string into the Search box, and then click the Search button. The Search Results list appears, displaying all of the found matches in alphabetical order. Clicking a found match advances the Class and Member lists to that item and displays its information in the Information window. Getting started with VBA macros 155 Matching class names have a blank Member column in the Search Results window. To hide the Search Results window, click the Hide search results button 156 . Using the Object Browser in the VB Editor Working with VBA macros Now that you know your way around the VBA workspace, you are ready to begin working with macros. This chapter covers the following topics: • “Creating VBA macros” on page 157 • “Running VBA macros” on page 158 • “Debugging VBA macros” on page 159 • “Using the VBA debugging windows” on page 159 For information on the WordPerfect Office X6 object models, see the “What is an object model?” on page 138. Creating VBA macros WordPerfect, Quattro Pro, and Presentations let you create VBA macros. However, WordPerfect Office uses the PerfectScript scripting language natively, and although PerfectScript is a separate editor from VBA, VBA in WordPerfect Office must access the PerfectScript object to write a VBA macro. Traditionally, there are two ways to create a macro: by writing (or “scripting”) it, or by recording it. Detailed information on scripting VBA macros is beyond the scope of the WordPerfect Office documentation. For basic information on creating VBA macros, please see the following Help topics: • WordPerfect Help (wpwp.chm): “Integrating with Microsoft Visual Basic for Applications” • Quattro Pro Help (qp.chm): “Creating VBA macros” • Presentations Help (wppr.chm): “Creating and editing VBA macros” You can record macros in WordPerfect, Quattro Pro, and Presentations; however, you cannot record VBA macros. Macros recorded from within WordPerfect Office are not rendered as VBA code but instead as PerfectScript code. For information on recording PerfectScript macros, see “Recording PerfectScript macros” on page 70. Recording PerfectScript macros can give you a glimpse into the logic of VBA. If you need help getting started with scripting VBA, you may want to start by recording a PerfectScript macro. Creating global macros WordPerfect and Presentations let you create global macros, which can be used in all projects. When you write a global macro, you store it to the application’s Global Macro Storage (GMS) file. The GMS files for WordPerfect and Presentations are WordPerfect**.gms and Presentations**.gms, respectively (where ** represents the version number). The VB Editor stores all of the modules for that project in the application’s GMS file. WordPerfect and Presentations do not support having more than one GMS file. Quattro Pro does not support GMS files. Using modules Each project that you create can contain several modules. The Project Explorer (see “Using the Project Explorer in the VB Editor” on page 148) presents each module type in its own folder. You cannot move a module from Working with VBA macros 157 one folder to another within the same project, but you can drag a module to another project to make a copy of it there. There are four types of modules: • WordPerfect Objects, QuattroPro Objects, or Presentations Objects — used mostly for event handling, contains a single item (ThisDocument, ThisNotebook, and ThisSlideShow, respectively) and should not be used for normal code • forms — used for custom dialog boxes and user interfaces, including the code to control them • modules — used for general code and macros • class modules — used for object-oriented Visual Basic classes (which are not discussed in this guide) To write the macro, you can use the VB Editor. Macros that are developed in the VB Editor can take advantage of full programming control, including conditional execution, looping, and branching. In effect, you can write macros that are programs in their own right. (For the purposes of this guide, however, all VBA code is referred to as a macro even though, in some contexts, a macro is just those parts of that code that can be launched by WordPerfect, Quattro Pro, or Presentations.) Running VBA macros You can run macros either from directly within WordPerfect, Quattro Pro, or Presentations or from within the VB Editor. The WordPerfect Macros dialog box To run a VBA macro from within WordPerfect, Quattro Pro, or Presentations 1 Click Tools ` Visual Basic ` Play. In WordPerfect and Quattro Pro, you can also click the Play button on the Visual Basic toolbar. 2 From the Macros in list box, choose the VBA project in which the recorded macro is stored. 3 Select the macro in the Macro name list. 4 Click Run. To run a VBA macro from within the VB Editor • Click anywhere in the subroutine that forms the macro, and then click Run ` Run macro. 158 Running VBA macros Debugging VBA macros The VB Editor provides strong debugging facilities that are common to language editors. It is possible to set breakpoints and to step through code. You can also make changes to the code while it is running and watch and change variables, but these are advanced techniques that are not discussed in this guide. Setting breakpoints A breakpoint is a marker in a line of code that causes execution to pause. To continue, you must either restart the execution or step through the subsequent lines of code. To set or clear a breakpoint, click the line and then click Debug ` Toggle breakpoint. By default, the line is highlighted in dark red and a red dot is placed in the margin. To clear all breakpoints, click Debug ` Clear all breakpoints. To restart the code after it pauses at a breakpoint, click Run ` Continue. To pause the execution of the code (immediately exiting from all functions and discarding all return values), click Run ` Reset. You can also “run to cursor” — that is, execute the code until it reaches the line that the cursor is on, and then pause at that line. To do this, click the line where you want execution to pause, and then click Debug ` Run to cursor. If the line with the breakpoint (or the cursor when “running to cursor”) is not executed because it is in a conditional (if-then-else) block, the code does not stop at that line. Breakpoints are not saved. They are lost when you close the VB Editor. Stepping through the code When execution pauses at a breakpoint, you can continue through the code one line at a time. This lets you examine the values of individual variables after each line and determine how the code affects the values (and how the values affect the code). This is called “stepping through the code.” To step through the code (one line at a time), click Debug ` Step into. The execution advances to every line in all called functions and subs. To step through each line of the current function or sub but not through the lines of each called function or sub, click Debug ` Step over. The called functions and subs are executed, but not line-by-line. To execute the rest of the current function or sub but pause when the function or sub returns to the point where it was called, click Debug ` Step out. This is a quick way of returning to the point of entry of a function, so as to continue stepping through the calling function’s code. Using the VBA debugging windows There are four windows that are used when debugging code: • the Call Stack window • the Immediate window • the Locals window • the Watches window Working with VBA macros 159 All of these windows provide important information about the state of functions and variables while an application is running. Using the Call Stack window The Call Stack window is a modal dialog box that lists which function calls which function. In long, complicated applications, this is useful for tracing the steps to a particular function being called. To visit a function listed in the window, select the function name and then click Show, or else close the window. To display the Call Stack window, click View ` Call Stack. The Call Stack window Using the Immediate window The Immediate window allows you to type in and run arbitrary lines of code while a macro is paused. This is useful for getting or setting the property of an object in the document, or for setting the value of a variable in the code. To run a piece of code, type it in the Immediate window, and then press Enter. The code is executed immediately. To display the Immediate window, click View ` Immediate window. The Immediate window Using the Locals window The Locals window displays all of the variables and objects that exist within the current scope. Each variable’s type and value are listed in the columns next to the variable’s name. Some variables and objects may have several children, which can be displayed by clicking the expand tree button next to the parent. Many variables let you edit their value by clicking it. 160 Using the VBA debugging windows To display the Locals window, click View ` Locals window. The Locals window Using the Watches window The Watches window is used to watch specific variables or object properties. This is very useful for selecting just one or two values to watch as opposed to having to find the value you want in all the values in the Locals window. The Watches window To add a value to the Watches window, select the variable or object and its property, and then drag the selection onto the Watches window; alternatively, click the item, and then click Debug ` Quick Watch to add the item directly to the Watches window. Working with VBA macros 161 The Add Watch dialog box Select the item you want to watch, select any conditions for this watch, and then click OK. If the condition becomes true, the application pauses to let you examine the code. 162 Using the VBA debugging windows Creating UI for VBA macros An important part of many VBA solutions is the user interface (or “UI”). A well-designed user interface makes the VBA solution so easy to use or so powerful that the user doesn’t hesitate to use it. Most user interfaces for complex VBA solutions are based on a dialog box or form, but simpler user interfaces can be created by using toolbars and buttons (which can, in turn, be enhanced with captions and tooltips, and images or icons). However, regardless of the nature of a user interface, its VBA solution can be made easier to deploy and support by providing the user with some form of help. This chapter covers the following topics: • “Creating dialog boxes for VBA macros” on page 163 • “Coding dialog boxes for VBA macros” on page 165 • “Designing dialog boxes for VBA macros” on page 165 • “Providing help for VBA macros” on page 170 Creating dialog boxes for VBA macros All dialog boxes should abide by the following guidelines: • They should have a meaningful title. • They should provide an obvious functionality for cancelling or closing them. • Their layout should make them easy to use, but they should also provide a Help button from which users can access how-to documentation. • Their every control should feature a ControlTipText string, so that users can receive information about each control by passing the pointer over it. However, there are two kinds dialog boxes: modal and modeless. Modal dialog boxes must be acted upon before the user can resume the macro. The application is locked until the dialog box is dismissed (either by submitting it or by cancelling it). Built-in dialog boxes that you can control with VBA are almost always modal. Modeless dialog boxes do not lock the application, so they can be left open while the user continues working in the application. In this way, they behave like dockers. Before you can code and design dialog box, you must decide whether to make it modal or modeless. Choosing between modal and modeless dialog boxes The kind of dialog box you should provide depends on what you want to achieve. Modal dialog boxes usually have the following features: • an OK button — performs the dialog box’s ultimate action and then hides the dialog box. It is the default button. • a Cancel button — dismisses the dialog box without performing the dialog box’s action. The Close button in the upper-right corner of the dialog box provides the same functionality. Creating UI for VBA macros 163 Some modal dialog boxes require an Apply button that performs the dialog box’s action without making it permanent, such that cancelling the dialog box undoes the action. If the dialog box is in the style of a wizard, it should have a Previous button and a Next button, as well as a Cancel button. On the first page of the sequence, the Previous button should be disabled (that is, have its Enabled property set to False), while on the last page, the Next button should become the Finish button to indicate that the final page has been reached. Modeless dialog boxes usually have the following features: • an Apply or Create button — performs the dialog box’s action and can, in fact, be specially labelled to described the dialog box’s action. This button should be the default. • a Close button –– closes the dialog box. This button is used after the user has applied the desired action. After you have chosen whether your dialog box should be modal or modeless, you are ready to start setting it up. Setting up dialog boxes To set up a customized dialog box for use in your VBA solution, you use the Form Designer in the VB Editor. The Form Designer provides easy access to the tools for coding and designing a form. A blank form in the Form Designer You can access the Form Designer by creating a new, blank form. For information on accessing the User Form toolbar, which you can use when designing a form, see “Using the toolbars in the VB Editor” on page 152. You can test a form at any time by running it. To create a blank form • In the Project Explorer, right-click the project to which you want to add a dialog box, and then click Insert ` UserForm. To change the title of the form, click the form to select it, and then in the Properties window, change the Caption property. 164 Creating dialog boxes for VBA macros It is highly recommended that you give each form a unique, descriptive name. You can do this from the Properties window, but remember to follow the rules for naming variables in VBA. To test a form by running it • Press F5. Coding dialog boxes for VBA macros Custom dialog boxes can be set as either modal or modeless by using the Modal parameter of the form’s Show method. For example, the form frmFooForm can be displayed with the following code: frmFooForm.Show Because the optional parameter Modal has, by default, the value vbModal (or 1), this code creates a modal dialog box. If the Modal parameter is set to vbModeless (or 0), as in the following example, then a modeless dialog box is created: frmFooForm.Show vbModeless To open a dialog box from a macro that is available from within the application itself, you must create a public sub within a VBA module; if a sub exists within a form’s code or within a class module, it cannot be made available from within the application. The sub you create cannot take any parameters. The following example sub would launch frmFooForm as a modeless form: Public Sub showFooForm() frmFooForm.Show vbModeless End Sub When a form loads, it triggers its own UserForm_Initialize event. From this event handler, you should initialize all the controls on the form that must be initialized. It is possible to launch one or more other forms from within the current form by using its Show member function: UserForm2.Show vbModal However, VBA does not return control until all open forms have been unloaded. Designing dialog boxes for VBA macros The Form Designer toolbox is the main utility you’ll use when designing dialog boxes. It lets you add controls to a form by dragging the appropriate control from the toolbox to the form. Creating UI for VBA macros 165 Form Designer toolbox The Form Designer toolbox lets you add the following controls to a form: Icon 166 Control Function Label Lets you provide the user with static text (for example, instructions or captions) TextBox Lets you provide an area into which the user can type text. For more information, see “Text box controls” on page 167. ComboBox Lets you provide a list from which the user can select an item and (optionally) into which the user can also type text. For more information, see “Combination (“combo”) box controls and list box controls” on page 167. ListBox Lets you provide a list from which the user can select multiple items. For more information, see “Combination (“combo”) box controls and list box controls” on page 167. CheckBox Lets you provide a check box that the user can enable (by clicking to insert a check mark into it) or disable (by clicking to remove the check mark from it), or that can be grayed (so as to make it unavailable to the user) OptionButton Lets you provide a “radio button” that is linked to other radio buttons with the same GroupName property, such that the user can enable only one of them at a time ToggleButton Lets you provide a button that the user can click to toggle (such that it does or does not appear pressed) Frame Lets you group items together: items drawn on the frame move with the frame CommandButton Lets you provide a button that the user can click to commit an assigned action. For more information, see “Button controls” on page 168. TabStrip Lets you provide the user with separate views of related controls Designing dialog boxes for VBA macros Icon Control Function MultiPage Lets you provide the user with multiple pages of controls ScrollBar Lets you provide the user with immediate access to a range of values by scrolling SpinButton Lets you enhance another control (such as a TextBox) so that the user can more quickly set that control’s value Image Lets you provide an image. For more information, see “Image (bitmap) controls” on page 170. More detailed information follows for some of these controls. The Form Designer toolbox also features a Pick tool on a form. , which lets you select and move the controls For more information about any one of these controls (or about the other controls supported by VBA), draw the control in a form and then press F1 to display a Help topic for it. Text box controls Text boxes (that is, TextBox controls) are the mainstay of user input. They are simple to use, quick to program, and very flexible. To set the text in a text box when initializing it, set the TextBox control’s Text (default or implicit) property: txtWidth.Text = "3" txtHeight = "1" To get the value of a TextBox control, get its Text property: Call SetSize(txtWidth.Text, txtHeight.Text) Combination (“combo”) box controls and list box controls In a combo box (that is, a ComboBox control), the user can either choose an item from the list or type into the text box. You can prevent users from being able to type into a ComboBox control by setting its Style property to fmStyleDropDownList. In a list box (that is, a ListBox control), the user can choose one or more items (from, typically, between three and ten items). To populate a list of any type, you must call the list’s member function AddItem. This function takes two parameters: the string or numerical value, and the position in the list. The position parameter is optional, so omitting it inserts the item at the last position in the list. For example, the following code populates the list ComboBox1 with four items: ComboBox1.AddItem 1 ComboBox1.AddItem 2 ComboBox1.AddItem 3 ComboBox1.AddItem 0, 0 Creating UI for VBA macros 167 To test which item is selected when the OK button is clicked, test the list’s ListIndex property. To get the value of a selected item’s caption, test the Text property for the ComboBox or ListBox: Dim retList As String retList = ComboBox1.Text Button controls As previously discussed, you can add a button to a form by using the CommandButton control. Click the form to add a default-sized button, or drag to create one to your own specifications. Click the caption to edit it, or select the button and edit its Caption property in the Properties window. You might also want to change the name of the button to something more descriptive, such as buttonOK or buttonCancel. Designing buttons in the Form Designer Most forms have an OK button and a Cancel button. However, no button functions until its form has code for handling the button’s click event. (This is because VBA forms are event-driven.) The Cancel button is the simplest control: it must dismiss the form without doing anything else. To add a cancel action to a Cancel button, double-click the button from within the Form Designer to display its code in the Code window. This creates a new subroutine called cmdCancel_Click: 168 Designing dialog boxes for VBA macros The Code window with code for a Cancel button The following code, if applied to a Cancel button, instructs the form to be dismissed when the button is clicked: Private Sub cmdCancel_Click() Unload Me End Sub If you continue by setting the form’s Cancel property to True, you’ll find that when the user presses Escape, the cmdCancel_Click event is triggered and the code you’ve provided unloads the form. Similarly, you can select the OK button and set its Default property to True, so that when the user presses Enter to activate the form, the OK button’s event handler is called; the OK button’s click-event handler performs the form’s functionality and then unloads the form. If the form is used to set the size of the selected shapes by setting their width and height, then the OK button’s click-event handler could resemble the following code sample (which assumes you have already created two text boxes called txtWidth and txtHeight): Private Sub buttonOK_Click() Me.Hide Call SetSize(txtWidth.Text, txtHeight.Text) Unload Me End Sub From inside the form’s own code module, the form object is implicit, and so all the controls can be simply accessed by name. From other modules, the controls must be accessed via their full name, which would be UserForm1.buttonOK. Creating UI for VBA macros 169 Image (bitmap) controls The Image control is used to place graphics on the form. The image (a bitmap) is contained in the Picture property, so you can either load an RGB image from a file (such as a GIF, JPEG, or Windows Bitmap BMP file) or paste one into the property. At run time, new images can be loaded into the Image control by changing the Picture property — by using the VBA function LoadPicture and providing a path to the new image file — as in the following example: Image1.Picture = LoadPicture("C:\Images\NewImage.gif") Providing help for VBA macros It is highly recommended that you provide users with documentation for your macros. One solution is to provide them with a Readme file or a printed manual. Another option is to build instructions directly into the dialog box, but this uses up valuable on-screen “real estate”. Yet another alternative is to create a Help file, but this requires tools and a fair amount of additional work. For these reasons, you may instead want to provide help in the form of plain-text file. If you create a registry value when the project is installed that points to the location of the file, you can use the following function to open it: Public Sub launchNotepad(file As String) Shell "Notepad.exe" & " " & file, vbNormalFocus End Sub Pass the full path to the text file, such as C:\ReadMe.txt, in the parameter file. A much more powerful — but still easily created — solution is to use HTML. By using HTML, you can include graphics in your documentation, and you can also direct the user to a specific location on the page by using “hash” references (such as index.html#middle). If you know where the HTML file is installed, you can use the following function to open it: ' Put this Declare statement before all Subs and Functions! Declare Function ShellExecute Lib "shell32.dll" _ Alias "ShellExecuteA" (ByVal hwnd As Long, _ ByVal lpOperation As String, ByVal lpFile As String, _ ByVal lpParameters As String, ByVal lpDirectory As String, _ ByVal nShowCmd As Long) As Long Public Sub launchBrowser(url As String) ShellExecute 0, vbNullString, url, vbNullString, vbNullString, 5 End Sub Simply pass the file name (for example, C:\Program Files\ReadMe.htm) or URL in the parameter url. 170 Providing help for VBA macros Organizing and deploying VBA macros When you’ve finished designing your VBA macro, you can make it available to other WordPerfect Office users. This chapter covers the following topics: • “Organizing VBA macros” on page 171 • “Deploying VBA macros” on page 171 Organizing VBA macros To make your VBA macros easy to deploy, it’s a good idea to organize them. The best way to organize and maintain your macros is to use a separate module for each macro, and then group related macros into a single project file. To help the user find the entry point to your macros, it’s a good idea to place all of the public subs into a single module and then instruct the user how to find them; that way, the macros can be called from within WordPerfect, Quattro Pro, or Presentations. Deploying VBA macros You can deploy VBA macros to users for installation by deploying project files. For more information on deploying macros across an organization, network administrators can refer to the Corel WordPerfect Office Deployment Guide included with their purchase of a license SKU. Deploying project files You can explicitly distribute macros as part of a document so that when that document is opened, the user has immediate access to the macros even if they have not installed them. In this way, you can, for example, set up a macro to track how much time has been spent editing the document. You must devise a mechanism for distributing your project files to users for installation. While it is possible to distribute modules on their own, it is much simpler for your users if you distribute project files instead (so that the users do not have to manually integrate the module into their existing project file). To deploy a project file 1 Make the project file available to the users. 2 Instruct the users to install the project file. Organizing and deploying VBA macros 171 172 Deploying VBA macros Glossary A ANSI character set The 256 characters of the American National Standards Institute any data type A data type that accepts more than one data type as input. For example, in the AppActivate (Windows: Any) command, the Windows parameter accepts a window title (string data type) or a window handle (numeric data type). argument A variable, constant, or expression required by a command or function array A set of sequentially indexed elements of the same data type. By default, array indexes are zero-based. automation The process of recording or scripting a macro B Boolean data type A data type that accepts or returns a value of True or False C callback A special function that enables a macro to respond immediately and in specific ways to events, such as enabling a radio button or check box, without waiting until a dialog box is dismissed character expression Also called a string, one or more characters enclosed in quotation marks. This syntax identifies the characters as text, rather than as a variable. class The definition (that is, description) of an object class module A module that contains the definition of a class, including its property and method definitions Glossary 173 Command Browser Also called the Command Inserter, a dialog box that inserts product commands or programming commands (or both) into a macro document command name A description of a command’s action, such as Font, MarginLeft, Advance, or FootnoteOptions Command names can execute product features (“product commands”) or direct the execution of the macro (“programming commands,” such as If, Else, or End If). The Command Inserter lists programming commands and product commands separately, but you can choose which list you want to display. constant A named item that keeps a constant value while a macro is being executed control statement A macro feature that alters the sequential execution of commands collection A set of objects constant A named item that keeps a constant value while a macro is being executed D data type The set of values that a variable can store. A data type represents information that is needed by a parameter or returned by a command (as a “return value”). The available data types are Boolean, enumeration, label, measurement, numeric, string, variant, and any. In the command syntax, data types are displayed in italics. For example, the enumerations for the Rotation parameter of BoxCaptionRotation are Degrees90!, Degrees 180!, Degrees 270!, and None!. Only these enumerations can replace the data type in the command syntax. DLL (Dynamic Link Library) file A library of functions and procedures that can be called from a macro drop-down list A type of list available to a Combo Box control. Also called a “list box.” E enumerated type (enumeration) An option provided by the program — such as a style, type, method, or state — that lists all the possible values for the variables that use it. Also called an “enumerated type.” 174 Glossary Enumerations end with an exclamation point. For example, the DisplayMode parameter accepts only Text!, Graphics!, or FullPage! as an emueration. In WordPerfect, On!, Heading8Style!, and DefFlushRight! are enumerations used by different commands. enumeration data type A data type that accepts an enumeration event A noun that acts as something taking place in an object and that is triggered by an action (such as a click, key press, or system timer). The action is recognized by a form or control. event-driven programming A form of programming, such as Visual Basic for Applications, in which code is executed in response to events. By contrast, in traditional procedural programming, the program starts at line 1 and executes line by line. event handler A subroutine that is programmed to cause the application to respond to a specific event expression An element that represents values. An expression can be arithmetic, numeric, measurement, relational, logical, bitwise, or character (that is, a string). F function A procedure that performs a given task in a macro and that can be used to return a value. A function procedure begins with a Function statement and ends with an End Function statement. In VBA, functions do not need to be declared before they are used, nor before they are defined. G global value A value that applies to a given project in its entirety L label A subroutine similar to a procedure or function. A label generally contains one or more statements followed by Return or Quit. label data type A data type that accepts a label Glossary 175 M macro A scripted or recorded set of actions that can be repeatedly invoked within an application Macro toolbar A toolbar that contains tools for writing and editing macros. It features buttons for saving, compiling, inserting macro commands, and so on. measurement data type A data type that accepts a measurement value in inches, millimeters, picas, WP units, and so on. For example, 72P (points) is equal to 1I (inch) and to 2.54C (centimeters). All measurement return values are returned in WordPerfect units. Necessary unit conversions are done internally when comparing two measurement values. Recorded macros use the units specified in the application preferences. When specifying a measurement value in a product command parameter, WordPerfect units (w) are assumed unless other units are specified in the parameter or with the DefaultUnits command. measurement expression A number followed by a unit of measure (", i, c, m, p, w) method An operation that an object can have performed on itself modal dialog box A dialog box that must be acted upon before the user can resume the macro. The application is locked until the dialog box is dismissed, either by submitting it or by cancelling it. Built-in dialog boxes that you can control with VBA are almost always modal. modeless dialog box A dialog box that does not lock the application, such that it can be left open while the user continues working in the application. In this way, modeless dialog boxes behave like dockers. module A set of declarations followed by procedures N numeric data type A data type that accepts a numeric expression numeric expression Also called a “numeric,” a number (such as the number of seconds, a line number, or an outline level) on which mathematical operations can be performed. Numeric expressions are not enclosed in quotation marks. 176 Glossary O object An instance of a class. An object can be a parent to child objects. object model The hierarchy of objects within an application and their relationship to each other within the paradigm. Each object within an object model is defined by a property, method, or event — or by a combination of each. An object responds to an action through the use of written code. An object model offers a high-level structure of the relationship between parent and child objects. Without an object model, VBA cannot gain access to the objects in the document, nor query or change an application’s documents. For example, the Document object represents the beginning of the object hierarchy in WordPerfect. Starting with the Document object, you can drill down and navigate through the object model until you find the desired object. To reference an object with Visual Basic code, you can separate each level of the object hierarchy with the dot operator ( . ). object-oriented programming A form of programming that emphasizes creating and using objects OLE (Object Linking and Embedding) A feature that copies information from one document to another, “embedding” it through a “live” link. When the original document changes, the embedded copy reflects the changes. OLE object command An item, also called a “method,” that performs tasks on an OLE object in a specific OLE automation server. OLE object commands are specific for each object, such as Excel.Application or Excel.Workbooks. They perform various functions on that object. OLE object commands that return information about an object are called “properties.” Many properties have parameters as well as return values. In addition, many properties can be assigned a value by placing them on the left side of the assignment symbol ( := ), similarly to the name of a variable. operator A symbol or word that performs a function on one or more expressions. Operators compare expressions, link words together, and perform mathematical functions. P parameter An optional command element. For example, InhibitInput (State: Off!) works just the same as InhibitInput (Off!). Glossary 177 Some product commands have no parameters; their syntax is usually written with empty parameters, such as PosScreenUp(). Similarly, some programming commands and WordPerfect system variables have no parameters; their syntax is the command name alone, such as PAUSE and ?FeatureBar. In this documentation, italics indicate parameter names or types to be replaced with data. For example, the syntax of GraphicsLineLength is as follows: GraphicsLineLength (Length: measurement) After you replace measurement with a number, the command might be GraphicsLineLength (Length: 2I) or GraphicsLineLength (2I) Be sure to enclose parameters in parentheses. A missing parenthesis, either opening or closing, is a common error that prevents macros from compiling. Spaces between command names and the opening parenthesis of the parameter section and after semicolons in parameters are optional. You can separate multiple parameters with semicolons ( ; ). If you omit an optional parameter, be sure to include the semicolon in the syntax to keep following parameters in their correct positions, as in this example: AbbreviationExpand (AbbreviationName:; Template: PersonalLibrary!) or AbbreviationExpand (; PersonalLibrary!) You can enclose repeating parameters in braces, as in this example: CASE (: Any; { : Any; : label; Case: Any; : ...} When data is supplied, the command could be CASE (vChoice; { 1; Exclaim; 2; Info; 3; Question; 4; Stop; 5; QuitMacro}; QuitMacro) passing by reference The act of passing an argument to a function or subroutine by using a reference to the original. By default, function and subroutine parameters are passed by reference, but if you want to explicitly annotate the code to indicate that an argument is being passed by reference, you can prefix the argument with ByRef. passing by value The act of passing an argument to a function or subroutine by using a copy of the original. To indicate that you want to pass an argument by value, prefix the argument with ByVal. PerfectScript An application used to record, play, compile, convert, and edit macros. PerfectScript is used to build or edit dialog boxes for macros. product command A command name that is specific to each application (such as WordPerfect or Presentations) and that performs various functions in that application 178 Glossary For example, product commands (such as InitialCodesStyleDlg) can display a dialog box; specify settings such as styles (BorderBottomLine), user preferences (PrefZoom), or attributes (Font); turn features on and off (InhibitInput or TableCellIgnoreCalculation); perform actions such as inserting a file (FileInsert) or code (PrinterCommand), renaming a bookmark (BookmarkRename), converting comments to text (CommentConvert), or moving the insertion point (PosColBottom); or play macros that are included with the application (FontDnShippingMacro). Product commands that report information about the state of an application or feature (that is, provide a “return value”) are sometimes called “system variables.” In WordPerfect, system variables begin with a question mark (for example, ?ColumnWidth). In Presentations, they begin with Env (for example, EnvPaths). Some system variables in Presentations have parameters as well as return values. The most common data types in product commands are string, enumeration, and numeric. product prefix A two-character expression that specifies a product for a macro command programming command A command name that works across applications and that controls or returns information about applications and feature functions. Programming commands generally control macro functions, such as by specifying conditions under which other macro commands or statements operate (CASE, IF ELSE ENDIF, SWITCH ENDSWITCH); repeating macro commands or statements a specified number of times or until certain conditions are met (FOR ENFOR, REPEAT UNTIL, WHILE ENDWHILE); or invoking or jumping to a specified subroutine (“statement block”) with CALL or GO. Programming commands are frequently variables. prompt A dialog box box that displays information for the user property A characteristic of a class. Properties that are fixed by the design of the class are called “read-only.” R relational expression An expression that evaluates parameters with only two possible states: TRUE and FALSE run-time The period during which a macro is executed. Run-time errors occur during macro execution. Run-time options are application start-up settings, such as the macro’s default directory. Glossary 179 S scope The visibility of a data type, procedure, or object shortcut object A syntactical replacement for the long-hand version of an object string Also called a character expression, one or more characters enclosed in double quotation marks. This syntax identifies the characters as text, rather than as a variable. Strings can include numbers. Here is a sample string: Type ("1") and MESSAGEBOX (vStatus; "VAR" + x; "Continue to next variable?" ; IconQuestion! |YesNo!!) string data type A data type that accepts a string The string data type represents text that you provide, such as a filename, a dialog box control name, message box text, or a character sequence to insert into a document. subroutine (sub) A procedure that performs a given task in a macro but that cannot be used to return a value. A subroutine procedure begins with a Sub statement and ends with an End Sub statement. In VBA, subroutines do not need to be declared before they are used, nor before they are defined. syntax The grammar or sequence for assembling commands T toggle command A command that switches between states For example, the WordPerfect Bold command can be On! or Off!. If On! or Off! is not specified, Bold “toggles” between the two states each time it is called; if Bold is Off!, it is turned On!, while if Bold is On!, it is turned Off!. token ID The name of a macro command (such as InvokeDialog) U user-defined dialog box A custom dialog box created with Dialog programming commands that display options for user input 180 Glossary V value set member A value in an enumeration list variable An item that can be created (or “declared”) for the purposes of storing data. The built-in data types are Byte, Boolean, Integer, Long, Single, Double, String, Variant, and several other less-used types including Date, Decimal, and Object. If a variable is not declared before it is used, the compiler interprets it as a Variant. A variable name must begin with a letter but is not case-sensitive. (All variables in this documentation’s examples begin with v.) Variables can include any combination of letters or numbers up to 50 characters. For example, you could “assign” the value C:\COREL\WPO\ to variable vPath, and then substitute the variable for the path in the rest of the macro. You can change the value of a variable. If variable vNmbr equals 5, then the expression vNmbr := vNmbr + 1 results in vNmbr equaling 6. variant data type The data type for all variables that are not declared as another type (such as Dim, Private, Public, or Static). The variant data type has no type-declaration character. Visual Basic for Applications (VBA) A built-in programming language that can automate repetitive functions and create intelligent solutions in WordPerfect, Quattro Pro, and Presentations W window The application area that contains a title bar, menu bar, and application bar, and that may contain a property bar, scroll bar, toolbar, and ruler. The Equation Editor window has separate editing and display areas called “panes.” window handle A unique identifier for a window or control Glossary 181 182 Glossary Index A aligning dialog-box controls . . . . . . . . . . . . . . . . . 95 animating PerfectScript macros . . . . . . . . . . . . . . . 123 PerfectScript macros, settings . . . . . . . . 109 arithmetic expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 35 arithmetic operators using with PerfectScript . . . . . . . . . . . . . 23 arrays, macro collapsing in Variables list . . . . . . . . . . . 121 declaring . . . . . . . . . . . . . . . . . . . . . . . . 141 expanding in Variables list . . . . . . . . . . 121 passing . . . . . . . . . . . . . . . . . . . . . . . . . . 52 precautions for . . . . . . . . . . . . . . . . . . . . 69 working with . . . . . . . . . . . . . . . . . . . . . 18 assignment operators using with PerfectScript . . . . . . . . . . . . . 22 assignment statements using in PerfectScript . . . . . . . . . . . . . . . 42 B bitmap controls using with PerfectScript . . . . . . . . . . . . . 85 using with VBA . . . . . . . . . . . . . . . . . . . 170 bitwise expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 37 bitwise operators using with PerfectScript . . . . . . . . . . . . . 28 using with VBA . . . . . . . . . . . . . . . . . . . 144 Boolean comparison and assignment using with VBA . . . . . . . . . . . . . . . . . . . 144 breakpoints enabling/disabling, in PerfectScript . . . . executing PerfectScript tokens . . . . . . . logging PerfectScript events . . . . . . . . . navigating, in PerfectScript . . . . . . . . . . removing, from PerfectScript . . . . . . . . setting, in PerfectScript . . . . . . . . . . . . Index 118 119 118 118 118 117 using, for PerfectScript debugging . . . . 115 using, for VBA debugging . . . . . . . . . . . 159 button controls using with PerfectScript . . . . . . . . . . . . . . 86 using with VBA . . . . . . . . . . . . . . . . . . . 168 C C vs. VBA . . . . . . . . . . . . . . . . . . . . . . . . . 137 C++ vs. VBA . . . . . . . . . . . . . . . . . . . . . . . . . 137 Call Stack window displaying . . . . . . . . . . . . . . . . . . . . . . . 160 using . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 Callback Queue window display options . . . . . . . . . . . . . . . . . . . 115 callbacks, PerfectScript debugging . . . . . . . . . . . . . . . . . . . . . . . 125 dialog-box setup . . . . . . . . . . . . . . . . . . . 96 looping . . . . . . . . . . . . . . . . . . . . . . . . . . 97 queue, listing . . . . . . . . . . . . . . . . . . . . . 115 understanding . . . . . . . . . . . . . . . . . . . . . 58 calling statements, PerfectScript Call command . . . . . . . . . . . . . . . . . . . . . 59 creating, from subroutines . . . . . . . . . . . 58 Go command . . . . . . . . . . . . . . . . . . . . . 59 subroutines . . . . . . . . . . . . . . . . . . . . . . . 46 subroutines, naming . . . . . . . . . . . . . . . . 59 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 Case conditions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 43 character expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 34 check box controls using with PerfectScript . . . . . . . . . . . . . . 86 closing dialog boxes, with PerfectScript . . . . . . 102 Code window using . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 183 code, PerfectScript displaying dialog boxes . . . . . . . . . . . . . 101 editing . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 navigating while debugging . . . . . . . . . 122 scripting . . . . . . . . . . . . . . . . . . . . . . . . . . 71 searching in Debugger . . . . . . . . . . . . . . 124 writing . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 code, VBA creating dialog boxes . . . . . . . . . . . . . . . 165 formatting automatically . . . . . . . . . . . . 150 stepping through . . . . . . . . . . . . . . . . . . 159 color wheel controls using with PerfectScript . . . . . . . . . . . . . . 87 constant variables using in PerfectScript . . . . . . . . . . . . . . . 16 constants PerfectScript . . . . . . . . . . . . . . . . . . . . . . 21 converting PerfectScript macros . . . . . . . . . . . . . . . . 69 copying dialog box controls . . . . . . . . . . . . . . . . . 93 dialog boxes . . . . . . . . . . . . . . . . . . . . . . 82 Corel SCRIPT recording macros in . . . . . . . . . . . . . . . . 68 counter controls using with PerfectScript . . . . . . . . . . . . . 87 combo box controls using with PerfectScript . . . . . . . . . . . . . . 87 using with VBA . . . . . . . . . . . . . . . . . . . 167 cursor position debugging PerfectScript macros . . . . . . 123 Command Browser displaying . . . . . . . . . . . . . . . . . . . . . . . . 65 Help for macro commands . . . . . . . . . . . 66 inserting macro commands with . . . . . . . 73 D Command Inserter understanding . . . . . . . . . . . . . . . . . . . . . 71 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 command statements using in PerfectScript . . . . . . . . . . . . . . . . 37 comment statements using in PerfectScript . . . . . . . . . . . . . . . . 60 comments, macro PerfectScript . . . . . . . . . . . . . . . . . . . . . . 60 VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 compiling PerfectScript macros . . . . . . . . . . . . . . . . 74 PerfectScript macros, errors . . . . . . . . . . . 74 PerfectScript macros, settings . . . . . . . . . 67 PerfectScript macros, with Debugger . . . 110 understanding compilers . . . . . . . . . . . . . 74 Condition Handlers window display options . . . . . . . . . . . . . . . . . . . 114 conditional statements using in PerfectScript . . . . . . . . . . . . . . . . 42 conditions, PerfectScript Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 184 custom controls using with PerfectScript . . . . . . . . . . . . . 88 date controls using with PerfectScript . . . . . . . . . . . . . 88 DDE Presentations conversations . . . . . . . . . . Quattro Pro conversations . . . . . . . . . . . understanding . . . . . . . . . . . . . . . . . . . . WordPerfect conversations . . . . . . . . . . . Debugger, PerfectScript breakpoints, working with . . . . . . . . . . Call History list . . . . . . . . . . . . . . . . . . . Callback Queue window . . . . . . . . . . . . compiling macros with . . . . . . . . . . . . . Condition Handlers window . . . . . . . . . debugging macros with . . . . . . . . . . . . Dialog List window . . . . . . . . . . . . . . . . getting started . . . . . . . . . . . . . . . . . . . information windows . . . . . . . . . . . . . . Label Table window . . . . . . . . . . . . . . . Macro Header window . . . . . . . . . . . . . Macro Info List window . . . . . . . . . . . . menu . . . . . . . . . . . . . . . . . . . . . . . . . . navigating macro code . . . . . . . . . . . . . Product Table window . . . . . . . . . . . . . settings . . . . . . . . . . . . . . . . . . . . . . . . . Source list . . . . . . . . . . . . . . . . . . . . . . . State line . . . . . . . . . . . . . . . . . . . . . . . stopping with breakpoints . . . . . . . . . . 63 62 62 62 115 106 113 110 113 108 112 105 110 111 114 113 105 122 112 109 106 106 117 Index toolbar . . . . . . . . . . . . . . . . . . . . . . . . . troubleshooting . . . . . . . . . . . . . . . . . . Use File Table window . . . . . . . . . . . . . using . . . . . . . . . . . . . . . . . . . . . . . . . . Variables list . . . . . . . . . . . . . . . . . . . . . variables, working with . . . . . . . . . . . . 106 124 112 105 107 119 debugging PerfectScript callbacks . . . . . . . . . . . . . 125 PerfectScript errors . . . . . . . . . . . . . . . . 124 PerfectScript macros . . . . . . . . . . . . . . . 105 PerfectScript macros, in steps . . . . . . . . 159 PerfectScript macros, navigation . . . . . 122 PerfectScript macros, settings . . . . . . . . . 67 PerfectScript macros, with breakpoints 115 PerfectScript macros, with Debugger . . 108 PerfectScript macros, with details . . . . . 110 PerfectScript macros, with variables . . . 119 VBA macros . . . . . . . . . . . . . . . . . . . . . 159 VBA macros, with breakpoints . . . . . . . 159 VBA macros, with windows . . . . . . . . . 159 declaring arrays, in VBA . . . . . . . . . . . . . . . . . . . . 141 enumerated types, in VBA . . . . . . . . . . 142 strings, in VBA . . . . . . . . . . . . . . . . . . . 141 variables, in PerfectScript . . . . . . . . . . . . 11 variables, in VBA . . . . . . . . . . . . . . . . . . 140 definitions, VBA jumping to . . . . . . . . . . . . . . . . . . . . . . 151 Delphi recording macros in . . . . . . . . . . . . . . . . 68 deploying VBA macros GMS files . . . . . . . . . . . . . . . . . . . . . . . 171 methods for . . . . . . . . . . . . . . . . . . . . . 171 project files . . . . . . . . . . . . . . . . . . . . . . 171 designing dialog boxes using VBA Form Designer . . . . . . . . . . . 165 destroying dialog boxes using PerfectScript . . . . . . . . . . . . . . . . 103 dialog box controls PerfectScript . . . . . . . . . . . . . . . . . . . . . . 84 VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 dialog box controls, PerfectScript adding . . . . . . . . . . . . . . . . . . . . . . . . . . aligning . . . . . . . . . . . . . . . . . . . . . . . . . behaviors . . . . . . . . . . . . . . . . . . . . . . . . copying . . . . . . . . . . . . . . . . . . . . . . . . . . Index 92 95 95 93 default button . . . . . . . . . . . . . . . . . . . . . 96 deleting . . . . . . . . . . . . . . . . . . . . . . . . . . 93 editing . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 focus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 grouping . . . . . . . . . . . . . . . . . . . . . . . . . 95 lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 moving . . . . . . . . . . . . . . . . . . . . . . . . . . 93 positioning . . . . . . . . . . . . . . . . . . . . . . . 94 properties . . . . . . . . . . . . . . . . . . . . . . . . 93 resizing . . . . . . . . . . . . . . . . . . . . . . . . . . 93 selecting multiple . . . . . . . . . . . . . . . . . . 92 selecting single . . . . . . . . . . . . . . . . . . . . 92 setting up . . . . . . . . . . . . . . . . . . . . . . . . 84 tab order . . . . . . . . . . . . . . . . . . . . . . . . . 96 dialog box controls, VBA adding . . . . . . . . . . . . . . . . . . . . . . . . . . 165 dialog boxes PerfectScript . . . . . . . . . . . . . . . . . . . . . . 79 VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 dialog boxes, PerfectScript . . . . . . . . . . . . . . 101 adding . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 callbacks . . . . . . . . . . . . . . . . . . . . . . . . . 96 closing . . . . . . . . . . . . . . . . . . . . . . . . . . 102 controls . . . . . . . . . . . . . . . . . . . . . . . . . . 84 copying . . . . . . . . . . . . . . . . . . . . . . . . . . 82 deleting . . . . . . . . . . . . . . . . . . . . . . . . . . 83 destroying . . . . . . . . . . . . . . . . . . . . . . . 103 displaying . . . . . . . . . . . . . . . . . . . . . . . 101 editing . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 font settings . . . . . . . . . . . . . . . . . . . . . . 83 listing user-created . . . . . . . . . . . . . . . . 114 modal vs. modeless . . . . . . . . . . . . . . . . . 79 properties . . . . . . . . . . . . . . . . . . . . . . . . 83 releasing . . . . . . . . . . . . . . . . . . . . . . . . 102 renaming . . . . . . . . . . . . . . . . . . . . . . . . . 82 saving . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 setting up . . . . . . . . . . . . . . . . . . . . . . . . 80 testing . . . . . . . . . . . . . . . . . . . . . . . . . . 101 understanding . . . . . . . . . . . . . . . . . . . . . 79 dialog boxes, VBA coding . . . . . . . . . . . . . . . . . . . . . . . . . . 165 creating . . . . . . . . . . . . . . . . . . . . . . . . . 163 designing . . . . . . . . . . . . . . . . . . . . . . . . 165 modal vs. modeless . . . . . . . . . . . . . . . . 163 setting up . . . . . . . . . . . . . . . . . . . . . . . 164 Dialog Editor displaying from PerfectScript utility . . . . . 66 185 setting up dialog box controls . . . . . . . . . 84 setting up dialog boxes . . . . . . . . . . . . . . 81 testing dialog boxes . . . . . . . . . . . . . . . . 101 understanding . . . . . . . . . . . . . . . . . . . . . 79 floating VB Editor toolbars . . . . . . . . . . . . . . . . 152 Dialog List window display options . . . . . . . . . . . . . . . . . . . 114 For loops using in PerfectScript . . . . . . . . . . . . . . . 45 discarding variables PerfectScript code . . . . . . . . . . . . . . . . . . 17 PerfectScript debugging . . . . . . . . . . . . 122 Form Designer using . . . . . . . . . . . . . . . . . . . . . . . . . . 165 dismissing dialog boxes using PerfectScript . . . . . . . . . . . . . . . . . 102 docking VB Editor toolbars . . . . . . . . . . . . . . . . . 152 drop-down list controls using with PerfectScript . . . . . . . . . . . . . . 90 Dynamic Data Exchange (DDE) . . . . . . . . . . . . 62 E edit box controls using with PerfectScript . . . . . . . . . . . . . . 88 editing macros PerfectScript . . . . . . . . . . . . . . . . . . . . . . 71 enumerated types declaring, in VBA . . . . . . . . . . . . . . . . . . 142 errors, macro debugging . . . . . . . . . . . . . . . . . . . . . . . 124 run-time . . . . . . . . . . . . . . . . . . . . . . . . . . 76 troubleshooting compiles . . . . . . . . . . . . 74 evaluating to return values . . . . . . . . . . . . . . 41 event logs PerfectScript breakpoints . . . . . . . . . . . . 117 execution points listing PerfectScript labels . . . . . . . . . . . 114 fonts PerfectScript dialog boxes . . . . . . . . . . . 83 formatting PerfectScript macros . . . . . . . . . . . . . . . . 72 VBA code, automatically . . . . . . . . . . . . 150 forms, VBA buttons . . . . . . . . . . . . . . . . . . . . . . . . . combination boxes . . . . . . . . . . . . . . . . creating . . . . . . . . . . . . . . . . . . . . . . . . images . . . . . . . . . . . . . . . . . . . . . . . . . list boxes . . . . . . . . . . . . . . . . . . . . . . . testing . . . . . . . . . . . . . . . . . . . . . . . . . text boxes . . . . . . . . . . . . . . . . . . . . . . . 168 167 164 170 167 165 167 frame controls using with PerfectScript . . . . . . . . . . . . . 89 functions, PerfectScript calling . . . . . . . . . . . . . . . . . . . . . . . . . . . creating . . . . . . . . . . . . . . . . . . . . . . . . . passing arrays to . . . . . . . . . . . . . . . . . . passing variables to . . . . . . . . . . . . . . . . storing . . . . . . . . . . . . . . . . . . . . . . . . . . structuring . . . . . . . . . . . . . . . . . . . . . . . understanding . . . . . . . . . . . . . . . . . . . . variables in . . . . . . . . . . . . . . . . . . . . . . . 53 48 52 51 55 53 48 49 functions, VBA building . . . . . . . . . . . . . . . . . . . . . . . . 141 enumerated types in . . . . . . . . . . . . . . . 142 G expressions, PerfectScript . . . . . . . . . . . . . . . . . 9 constants in . . . . . . . . . . . . . . . . . . . . . . . 21 operators in . . . . . . . . . . . . . . . . . . . . . . . 21 types of . . . . . . . . . . . . . . . . . . . . . . . . . . 32 variables in . . . . . . . . . . . . . . . . . . . . . . . 10 global variables using with PerfectScript . . . . . . . . . . . . . 14 external applications PerfectScript macro access . . . . . . . . . . . . 60 GMS files deploying . . . . . . . . . . . . . . . . . . . . . . . 171 F filename box controls using with PerfectScript . . . . . . . . . . . . . . 89 186 global macros (VBA) creating . . . . . . . . . . . . . . . . . . . . . . . . 157 grid positioning PerfectScript controls with . . 95 group box controls using with PerfectScript . . . . . . . . . . . . . 89 Index grouping dialog box controls, for PerfectScript . . . 95 H Help files macro commands . . . . . . . . . . . . . . . . . . 66 PerfectScript utility . . . . . . . . . . . . . . . . . 66 providing, for VBA macros . . . . . . . . . . 170 horizontal line controls using with PerfectScript . . . . . . . . . . . . . 90 I If conditions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 43 image controls using with VBA . . . . . . . . . . . . . . . . . . . 170 images adding, to VBA forms . . . . . . . . . . . . . . 170 Immediate window displaying . . . . . . . . . . . . . . . . . . . . . . . 160 using . . . . . . . . . . . . . . . . . . . . . . . . . . 160 information windows in Debugger displaying or hiding . . . . . . . . . . . . . . . 114 using . . . . . . . . . . . . . . . . . . . . . . . . . . 110 initializing variables, in PerfectScript . . . . . . . . . . . . 11 input boxes providing, for VBA . . . . . . . . . . . . . . . . 145 J Java vs. VBA . . . . . . . . . . . . . . . . . . . . . . . . . 137 JavaScript recording macros in . . . . . . . . . . . . . . . . 68 vs. VBA . . . . . . . . . . . . . . . . . . . . . . . . . 137 labels, PerfectScript calling . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 creating . . . . . . . . . . . . . . . . . . . . . . . . . . 47 listing at execution point . . . . . . . . . . . . 114 structuring . . . . . . . . . . . . . . . . . . . . . . . . 48 understanding . . . . . . . . . . . . . . . . . . . . . 47 learning PerfectScript macros . . . . . . . . . . . . . . . . 63 line controls using with PerfectScript . . . . . . . . . . . . . . 90 line numbers searching, for PerfectScript . . . . . . . . . . 124 lines of code VBA, ending . . . . . . . . . . . . . . . . . . . . . 142 list box controls using with PerfectScript . . . . . . . . . . . . . . 90 using with VBA . . . . . . . . . . . . . . . . . . . 167 list controls using with PerfectScript . . . . . . . . . . . . . . 90 listing files, PerfectScript generating . . . . . . . . . . . . . . . . . . . . . . . 109 understanding . . . . . . . . . . . . . . . . . . . . 108 local variables using with PerfectScript . . . . . . . . . . . . . . 12 Locals window displaying . . . . . . . . . . . . . . . . . . . . . . . 161 using . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 log files PerfectScript breakpoint events . . . . . . . 117 logical expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 36 logical operators using with PerfectScript . . . . . . . . . . . . . . 26 using with VBA . . . . . . . . . . . . . . . . . . . 144 loop statements using in PerfectScript . . . . . . . . . . . . . . . . 45 keywords, PerfectScript precautions for . . . . . . . . . . . . . . . . . . . . 69 loops, PerfectScript For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 While . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 L M Label Table window display options . . . . . . . . . . . . . . . . . . . 114 macro commands components of . . . . . . . . . . . . . . . . . . . . 38 K Index 187 inserting, in PerfectScript . . . . . . . . . . . . . 73 naming conventions . . . . . . . . . . . . . . . . 39 parameter conventions . . . . . . . . . . . . . . 39 Quattro Pro, converting to PerfectScript 132 return-value conventions . . . . . . . . . . . . . 41 understanding . . . . . . . . . . . . . . . . . . . . . 37 Macro Header window display options . . . . . . . . . . . . . . . . . . . 115 Macro Info List window display options . . . . . . . . . . . . . . . . . . . 115 macro libraries PerfectScript . . . . . . . . . . . . . . . . . . . . . . 55 macro resources PerfectScript . . . . . . . . . . . . . . . . . . . . . . 63 macro statements PerfectScript . . . . . . . . . . . . . . . . . . . . . . . 6 macro structure PerfectScript . . . . . . . . . . . . . . . . . . . . . . . 6 macro syntax PerfectScript . . . . . . . . . . . . . . . . . . . . . . . 6 macros converting to PerfectScript . . . . . . . . . . . 69 glossary of terms . . . . . . . . . . . . . . . . . . 173 native (Quattro Pro) macros . . . . . . . . . . 127 PerfectScript, working with . . . . . . . . . . . . 3 Quattro Pro macros, working with . . . . 127 VBA, working with . . . . . . . . . . . . . . . . . 133 working with . . . . . . . . . . . . . . . . . . . . . . . 1 measurement expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 33 memory allocation VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 memory pointers VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 message boxes providing, for VBA . . . . . . . . . . . . . . . . . 145 migrating PerfectScript macros . . . . . . . . . . . . . . . . 69 modal dialog boxes PerfectScript . . . . . . . . . . . . . . . . . . . . . . 79 VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 modules, VBA . . . . . . . . . . . . . . . . . . . . . . . 157 N native Quattro Pro macros working with . . . . . . . . . . . . . . . . . . . . 127 numeric expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 33 O Object Browser Class list . . . . . . . . . . . . . . . . . . . . . . . . Information window . . . . . . . . . . . . . . . Member list . . . . . . . . . . . . . . . . . . . . . search controls . . . . . . . . . . . . . . . . . . . using . . . . . . . . . . . . . . . . . . . . . . . . . . 153 155 154 155 152 object model, VBA Presentations . . . . . . . . . . . . . . . . . . . . Quattro Pro . . . . . . . . . . . . . . . . . . . . . understanding . . . . . . . . . . . . . . . . . . . WordPerfect . . . . . . . . . . . . . . . . . . . . . 139 139 138 139 object-header information PerfectScript display options . . . . . . . . . 115 objects VBA hierarchy . . . . . . . . . . . . . . . . . . . . 138 OLE Automation understanding . . . . . . . . . . . . . . . . . . . . 60 OLE objects working with . . . . . . . . . . . . . . . . . . . . . 61 opening dialog boxes, with PerfectScript . . . . . . 101 operators arithmetic (PerfectScript) . . . . . . . . . . . . 23 assignment (PerfectScript) . . . . . . . . . . . 22 bitwise (PerfectScript) . . . . . . . . . . . . . . . 28 bitwise (VBA) . . . . . . . . . . . . . . . . . . . . 144 Boolean (VBA) . . . . . . . . . . . . . . . . . . . . 144 logical . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 logical (VBA) . . . . . . . . . . . . . . . . . . . . . 144 PerfectScript . . . . . . . . . . . . . . . . . . . . . . 21 precedence (PerfectScript) . . . . . . . . . . . 30 relational (PerfectScript) . . . . . . . . . . . . . 24 modeless dialog boxes PerfectScript . . . . . . . . . . . . . . . . . . . . . . 79 VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 188 Index toolbar settings . . . . . . . . . . . . . . . . . . . . 68 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 organizing VBA macros . . . . . . . . . . . . . . . . 171 P parameters, PerfectScript syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 understanding . . . . . . . . . . . . . . . . . . . . 39 passing by reference VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 passing by value VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 pausing PerfectScript macros . . . . . . . . . . . . . . . . 76 PerfectScript macros, during debug . . . 110 PerfectScript macros compiling . . . . . . . . . . . . . . . . . . . . . . . . 74 converting from Quattro Pro macros . . 131 creating . . . . . . . . . . . . . . . . . . . . . . . . . 69 debugging . . . . . . . . . . . . . . . . . . . . . . 105 dialog boxes for . . . . . . . . . . . . . . . . . . . 79 editing . . . . . . . . . . . . . . . . . . . . . . . . . . 71 editing, settings . . . . . . . . . . . . . . . . . . . 67 external applications, accessing . . . . . . . 60 formatting . . . . . . . . . . . . . . . . . . . . . . . 72 getting started . . . . . . . . . . . . . . . . . . . . 65 learning resources . . . . . . . . . . . . . . . . . 63 migrating legacy . . . . . . . . . . . . . . . . . . . 69 playing . . . . . . . . . . . . . . . . . . . . . . . . . . 76 recording . . . . . . . . . . . . . . . . . . . . . . . . 70 settings, general . . . . . . . . . . . . . . . . . . . 66 understanding . . . . . . . . . . . . . . . . . . . . . 5 user-friendliness . . . . . . . . . . . . . . . . . . . 77 working with . . . . . . . . . . . . . . . . . . . . . . 3 writing . . . . . . . . . . . . . . . . . . . . . . . . . . 71 PerfectScript syntax macro structure . . . . . . . . . . . . . . . . . . . . 6 macro syntax . . . . . . . . . . . . . . . . . . . . . . 6 PerfectScript utility Command Browser, displaying . . . . . . . . 65 Debugger . . . . . . . . . . . . . . . . . . . . . . . 105 Dialog Editor . . . . . . . . . . . . . . . . . . . . . 79 Dialog Editor, displaying . . . . . . . . . . . . . 66 Help for controls . . . . . . . . . . . . . . . . . . . 66 Help for macro commands . . . . . . . . . . . 66 quitting . . . . . . . . . . . . . . . . . . . . . . . . . 66 settings . . . . . . . . . . . . . . . . . . . . . . . . . . 66 starting . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Index persistent variables PerfectScript . . . . . . . . . . . . . . . . . . . . . . 15 playing PerfectScript macros . . . . . . . . . . . . . . . . 76 PerfectScript macros, errors . . . . . . . . . . . 76 PerfectScript macros, settings . . . . . . . . . 67 VBA macros . . . . . . . . . . . . . . . . . . . . . . 158 pop-up button controls using with PerfectScript . . . . . . . . . . . . . . 86 pop-up list controls using with PerfectScript . . . . . . . . . . . . . . 90 Presentations DDE conversations . . . . . . . . . . . . . . . . . . 63 VBA object model . . . . . . . . . . . . . . . . . 139 procedural macros PerfectScript . . . . . . . . . . . . . . . . . . . . . . . 7 procedures, PerfectScript calling . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 creating . . . . . . . . . . . . . . . . . . . . . . . . . . 48 passing arrays to . . . . . . . . . . . . . . . . . . . 52 passing variables to . . . . . . . . . . . . . . . . . 51 storing . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 structuring . . . . . . . . . . . . . . . . . . . . . . . . 54 understanding . . . . . . . . . . . . . . . . . . . . . 48 variables in . . . . . . . . . . . . . . . . . . . . . . . 49 Product Table window display options . . . . . . . . . . . . . . . . . . . 114 progress indicator controls using with PerfectScript . . . . . . . . . . . . . . 91 Project Explorer displaying . . . . . . . . . . . . . . . . . . . . . . . 149 using . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 project files, VBA deploying . . . . . . . . . . . . . . . . . . . . . . . 171 Properties window displaying . . . . . . . . . . . . . . . . . . . . . . . 150 using . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 push button controls using with PerfectScript . . . . . . . . . . . . . . 86 Q Quattro Pro DDE conversations . . . . . . . . . . . . . . . . . . 62 189 native macro language . . . . . . . . . . . . . 129 VBA object model . . . . . . . . . . . . . . . . . 139 Quattro Pro (native) macros commands, understanding . . . . . . . . . . 129 converting . . . . . . . . . . . . . . . . . . . . . . . 131 creating . . . . . . . . . . . . . . . . . . . . . . . . . 131 debugging . . . . . . . . . . . . . . . . . . . . . . . 131 editing . . . . . . . . . . . . . . . . . . . . . . . . . . 131 playing . . . . . . . . . . . . . . . . . . . . . . . . . . 131 syntax, understanding . . . . . . . . . . . . . . 129 understanding . . . . . . . . . . . . . . . . . . . . 129 working with . . . . . . . . . . . . . . . . . . . . . 127 quitting PerfectScript utility . . . . . . . . . . . . . . . . . 66 R run-time PerfectScript errors . . . . . . . . . . . . . 76 S saving PerfectScript dialog boxes . . . . . . . . . . . 84 scope, VBA . . . . . . . . . . . . . . . . . . . . . . . . . 143 scripting macros PerfectScript . . . . . . . . . . . . . . . . . . . . . . 71 scroll bar controls using with PerfectScript . . . . . . . . . . . . . 91 SDK understanding . . . . . . . . . . . . . . . . . . . . 63 searching PerfectScript code . . . . . . . . . . . . . . . . . 124 radio button controls using with PerfectScript . . . . . . . . . . . . . . 86 selecting PerfectScript controls, multiple . . . . . . . . 92 PerfectScript controls, single . . . . . . . . . 92 radix expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 34 sequential macros PerfectScript . . . . . . . . . . . . . . . . . . . . . . . 7 recording PerfectScript macros . . . . . . . . . . . . . . . . 70 PerfectScript macros, settings . . . . . . . . . 68 shortcut objects, VBA . . . . . . . . . . . . . . . . . 139 region commands PerfectScript dialog boxes . . . . . . . . . . . . 99 sorting variables in Variables list . . . . . . . . . . . . 120 relational expressions PerfectScript . . . . . . . . . . . . . . . . . . . . . . 36 starting PerfectScript utility . . . . . . . . . . . . . . . . . 65 VB Editor . . . . . . . . . . . . . . . . . . . . . . . 148 relational operators PerfectScript . . . . . . . . . . . . . . . . . . . . . . 24 releasing dialog boxes using PerfectScript . . . . . . . . . . . . . . . . . 102 Repeat loops using in PerfectScript . . . . . . . . . . . . . . . . 45 resuming PerfectScript macros . . . . . . . . . . . . . . . . 76 PerfectScript macros, during debug . . . . 110 return values, PerfectScript evaluating . . . . . . . . . . . . . . . . . . . . . . . . 41 handling . . . . . . . . . . . . . . . . . . . . . . . . . 41 understanding . . . . . . . . . . . . . . . . . . . . . 41 running PerfectScript macros . . . . . . . . . . . . . . . . 76 PerfectScript macros, settings . . . . . . . . . 67 VBA macros . . . . . . . . . . . . . . . . . . . . . . 158 190 Software Development Kit (SDK) understanding . . . . . . . . . . . . . . . . . . . . 63 statements, PerfectScript macro assignment . . . . . . . . . . . . . . . . . . . . . . . 42 calling . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 command . . . . . . . . . . . . . . . . . . . . . . . . 37 comment . . . . . . . . . . . . . . . . . . . . . . . . 60 conditional . . . . . . . . . . . . . . . . . . . . . . . 42 expressions in . . . . . . . . . . . . . . . . . . . . . . 9 loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 understanding . . . . . . . . . . . . . . . . . . . . . 6 static text controls using with PerfectScript . . . . . . . . . . . . . 91 stepping through macro code PerfectScript . . . . . . . . . . . . . . . . . . . . . 123 VBA . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 stopping PerfectScript debug . . . . . . . . . . . . . . . 110 PerfectScript debug, with breakpoints . 117 Index PerfectScript macros . . . . . . . . . . . . . . . . 76 strings declaring, in VBA . . . . . . . . . . . . . . . . . 141 structure, PerfectScript . . . . . . . . . . . . . . . . . . 6 subroutines, PerfectScript Call command in . . . . . . . . . . . . . . . . . . . callbacks . . . . . . . . . . . . . . . . . . . . . . . . . calling statements from . . . . . . . . . . . . . functions . . . . . . . . . . . . . . . . . . . . . . . . labels . . . . . . . . . . . . . . . . . . . . . . . . . . . procedures . . . . . . . . . . . . . . . . . . . . . . . understanding . . . . . . . . . . . . . . . . . . . . 59 58 58 48 47 48 46 subroutines, VBA building . . . . . . . . . . . . . . . . . . . . . . . . 141 Switch conditions using in PerfectScript . . . . . . . . . . . . . . . 44 syntax, PerfectScript command names . . . . . . . . . . . . . . . . . . 39 macros . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 parameters . . . . . . . . . . . . . . . . . . . . . . . 40 syntax, VBA checking automatically . . . . . . . . . . . . . 151 coloring automatically . . . . . . . . . . . . . 150 T tab order PerfectScript dialog boxes . . . . . . . . . . . 96 testing PerfectScript dialog boxes . . . . . . . . . . 101 VBA forms . . . . . . . . . . . . . . . . . . . . . . 165 text searching macros for . . . . . . . . . . . . . . 124 text box controls using with VBA . . . . . . . . . . . . . . . . . . . 167 text controls using with PerfectScript . . . . . . . . . . . . . 91 third-party tokens executing, in PerfectScript . . . . . . . . . . 117 tokens, PerfectScript executing . . . . . . . . . . . . . . . . . . . . . . . 117 executing, during debug . . . . . . . . . . . 119 toolbars, PerfectScript settings . . . . . . . . . . . . . . . . . . . . . . . . . . 68 Index toolbars, VBA docking . . . . . . . . . . . . . . . . . . . . . . . . . 152 floating . . . . . . . . . . . . . . . . . . . . . . . . . 152 VB Editor, using . . . . . . . . . . . . . . . . . . . 152 Visual Basic, using . . . . . . . . . . . . . . . . . 147 troubleshooting PerfectScript compiles . . . . . . . . . . . . . . . 74 PerfectScript Debugger . . . . . . . . . . . . . 124 PerfectScript run-time errors . . . . . . . . . . 76 typing macros PerfectScript . . . . . . . . . . . . . . . . . . . . . . 71 U Use File Table window display options . . . . . . . . . . . . . . . . . . . 114 Use files listing . . . . . . . . . . . . . . . . . . . . . . . . . . 114 user interface creating, for PerfectScript macros . . . . . . 79 creating, for VBA macros . . . . . . . . . . . . 163 V variables, PerfectScript collapsing in Variables list . . . . . . . . . . . 121 constant variables . . . . . . . . . . . . . . . . . . 16 creating during debug . . . . . . . . . . . . . . 121 debugging . . . . . . . . . . . . . . . . . . . . . . . 119 declaring . . . . . . . . . . . . . . . . . . . . . . . . . 11 determining existence . . . . . . . . . . . . . . . 16 discarding . . . . . . . . . . . . . . . . . . . . . . . . 17 displaying in macros . . . . . . . . . . . . . . . 120 editing during debug . . . . . . . . . . . . . . 121 expanding in Variables list . . . . . . . . . . . 121 global variables . . . . . . . . . . . . . . . . . . . . 14 initializing . . . . . . . . . . . . . . . . . . . . . . . . 11 local variables . . . . . . . . . . . . . . . . . . . . . 12 passing . . . . . . . . . . . . . . . . . . . . . . . . . . 51 persistent variables . . . . . . . . . . . . . . . . . 15 refreshing in Variables list . . . . . . . . . . . 121 removing during debug . . . . . . . . . . . . . 122 sorting in Variables list . . . . . . . . . . . . . 120 understanding . . . . . . . . . . . . . . . . . . . . . 10 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 watching . . . . . . . . . . . . . . . . . . . . . . . . 121 variables, VBA declaring . . . . . . . . . . . . . . . . . . . . . . . . 140 191 VB Editor automatic completion . . . . . . . . . . . . . . 151 Code window . . . . . . . . . . . . . . . . . . . . 150 contextual pop-up lists . . . . . . . . . . . . . 151 debugging windows . . . . . . . . . . . . . . . 159 Form Designer . . . . . . . . . . . . . . . . . . . . 165 Object Browser . . . . . . . . . . . . . . . . . . . 152 Project Explorer . . . . . . . . . . . . . . . . . . . 148 Properties window . . . . . . . . . . . . . . . . . 149 starting . . . . . . . . . . . . . . . . . . . . . . . . . 148 toolbars . . . . . . . . . . . . . . . . . . . . . . . . . 152 using . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 VBA automation understanding . . . . . . . . . . . . . . . . . . . . 136 VBA macros code structure . . . . . . . . . . . . . . . . . . . . 140 converting from Quattro Pro macros . . . 132 creating . . . . . . . . . . . . . . . . . . . . . . . . . 157 debugging . . . . . . . . . . . . . . . . . . . . . . . 159 deploying . . . . . . . . . . . . . . . . . . . . . . . . 171 dialog boxes for . . . . . . . . . . . . . . . . . . . 163 global macros . . . . . . . . . . . . . . . . . . . . 157 Help creation . . . . . . . . . . . . . . . . . . . . . 170 organizing . . . . . . . . . . . . . . . . . . . . . . . 171 running . . . . . . . . . . . . . . . . . . . . . . . . . 158 understanding . . . . . . . . . . . . . . . . . . . . 135 W Watches window using . . . . . . . . . . . . . . . . . . . . . . . . . . 161 watching variables PerfectScript . . . . . . . . . . . . . . . . . . . . . 121 WCL files understanding . . . . . . . . . . . . . . . . . . . 108 While loops using in PerfectScript . . . . . . . . . . . . . . . 46 Windows Script Host vs. VBA . . . . . . . . . . . . . . . . . . . . . . . . . 137 WordPerfect DDE conversations . . . . . . . . . . . . . . . . . 62 VBA object model . . . . . . . . . . . . . . . . . 139 writing macros PerfectScript . . . . . . . . . . . . . . . . . . . . . . 71 vertical line controls using with PerfectScript . . . . . . . . . . . . . . 90 viewer controls using with PerfectScript . . . . . . . . . . . . . . 91 Visual Basic recording macros in . . . . . . . . . . . . . . . . . 68 Visual Basic for Applications (VBA) macros . . . . . . . . . . . . . . . . . . . . . . . . . . 133 main elements of . . . . . . . . . . . . . . . . . . 138 non-programmers . . . . . . . . . . . . . . . . . 136 operators, bitwise . . . . . . . . . . . . . . . . . 144 operators, Boolean . . . . . . . . . . . . . . . . 144 operators, logical . . . . . . . . . . . . . . . . . . 144 programmers . . . . . . . . . . . . . . . . . . . . . 136 toolbars . . . . . . . . . . . . . . . . . . . . . . . . . 147 understanding . . . . . . . . . . . . . . . . . . . . 135 vs. C and C++ . . . . . . . . . . . . . . . . . . . . 137 vs. Java and JavaScript . . . . . . . . . . . . . . 137 vs. Windows Script Host . . . . . . . . . . . . 137 working with . . . . . . . . . . . . . . . . . . . . . 133 192 Index Corel® WordPerfect® Office X6 Macro Guide Copyright © 2012 Corel Corporation. All rights reserved. Product specifications, pricing, packaging, technical support and information (“specifications”) refer to the retail English version only. The specifications for all other versions (including other language versions) may vary. INFORMATION IS PROVIDED BY COREL ON AN "AS IS" BASIS, WITHOUT ANY OTHER WARRANTIES OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABLE QUALITY, SATISFACTORY QUALITY, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, OR THOSE ARISING BY LAW, STATUTE, USAGE OF TRADE, COURSE OF DEALING OR OTHERWISE. THE ENTIRE RISK AS TO THE RESULTS OF THE INFORMATION PROVIDED OR ITS USE IS ASSUMED BY YOU. COREL SHALL HAVE NO LIABILITY TO YOU OR ANY OTHER PERSON OR ENTITY FOR ANY INDIRECT, INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES WHATSOEVER, INCLUDING, BUT NOT LIMITED TO, LOSS OF REVENUE OR PROFIT, LOST OR DAMAGED DATA OR OTHER COMMERCIAL OR ECONOMIC LOSS, EVEN IF COREL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR THEY ARE FORESEEABLE. COREL IS ALSO NOT LIABLE FOR ANY CLAIMS MADE BY ANY THIRD PARTY. COREL'S MAXIMUM AGGREGATE LIABILITY TO YOU SHALL NOT EXCEED THE COSTS PAID BY YOU TO PURCHASE THE MATERIALS. SOME STATES/COUNTRIES DO NOT ALLOW EXCLUSIONS OR LIMITATIONS OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, SO THE ABOVE LIMITATIONS MAY NOT APPLY TO YOU. Corel, the Corel logo, the Corel balloon logo, Corel DESIGNER, CorelDRAW, Corel SCRIPT, PerfectScript, Presentations, Quattro Pro, QuickCorrect, and WordPerfect are trademarks or registered trademarks of Corel Corporation and/or its subsidiaries in Canada, the U.S., and/or other countries. All other product names and any registered and unregistered trademarks mentioned are used for identification purposes only and remain the exclusive property of their respective owners. This product may incorporate intellectual property owned by Microsoft Corporation. The terms and conditions upon which Microsoft is licensing such intellectual property may be found at http://go.microsoft.com/fwlink/ ?Linkld=52440. 108032