A macro is a script containing instructions that you record and then play back to perform simple or complex tasks. For example, you can record a macro that prints a report. Or you can record a macro that opens a notebook, moves the insertion point to a specified place, and prompts a user to type information.
In this section, you'll learn about
recording and editing Quattro Pro macros
working with macro libraries
recording and editing PerfectScript macros
creating VBA macros
debugging and editing a VBA macro
using the PerfectScript class to change a Quattro Pro document
working in Developer mode
recording macros using relative and absolute cell references
attaching macros to notebooks and buttons
playing macros
debugging Quattro Pro macros
debugging PerfectScript macros
customizing application settings using macros
For more information about using macros, see "Reference: Using macros."
Recording and editing Quattro Pro macros
With Quattro Pro, you can record actions as you perform them. Recording converts actions into macro commands and stores them as labels in a block. Quattro Pro does not record actions keystroke by keystroke. Instead, it translates keystrokes and mouse actions that invoke menu choices into one or more macro commands called command equivalents. This recording method is called logical recording. Macros recorded in this way are more efficient and can run with a customized Quattro Pro menu system. For example, a macro containing commands to print the active notebook runs even when the menu command is not in the active menu bar.
You can also type Quattro Pro macros if you prefer to enter the macro manually. You can type multiple macro commands in the same cell or type each separately in multiple cells. Macro commands are labels, therefore, Quattro Pro does not recognize a syntax error as you type it in; the error occurs only when you try to run the macro. Even a typing error can prevent a macro from running. To save debugging time, pay careful attention to the format of macro commands as you enter them, and record macros whenever possible. For information about macro syntax, see "Understanding Quattro Pro macro syntax."
You can also add a command to a macro script.
Quattro Pro lets you name the macros you record. Cell names make macros more readable and easier to remember. Give names to macros that reflect the tasks they perform. For example, PERCENT could be the name of a macro that changes the numeric format of the current cell to a percentage.
When naming macros, avoid names that are the same as macro command names; otherwise the macro commands are invalid. For example, suppose you name a macro READLN; this is also the name of a predefined macro command for reading a line from a file. If you try to use this command to read a line into cell A6 rather than {READLN A6}, Quattro Pro assumes you are playing the READLN macro rather than the {READLN} command.
To record a Quattro Pro macro
1 Click Tools Macro Record.
2 Enable the Quattro Pro macro option.
If you want to save the macro in an existing macro library, on the status bar, click the notebook name that contains the macro library.
3 Select the cells in which to store the macro.
4 Click OK.
5 Perform the actions in the macro.
6 Click Tools Macro Record.
Notes
You can store a macro on the spreadsheet where you perform the macro or on a spreadsheet specifically assigned to the macro.
At the end of the macro, leave a line blank so the macro terminates without user intervention. Otherwise, the macro interprets labels below it as macro commands.
The recording of a macro is noted by on the Application Bar.
For more information about saving a macro in an existing macro library see "Working with macro libraries."
When you select cells to store the macro in, select a single cell if there is no chance of overwriting data in the cells below (Quattro Pro fills the cells below as necessary). When you select more than one cell, the macro is confined only to those cells, and stops recording when they are full.
To pause or resume recording a Quattro Pro macro
Click Tools Macro Pause.
To type a Quattro Pro macro
1 Click in the first cell where you want to store the macro.
2 Type the macro commands you want.
3 Type {QUIT}.
Note
When you type commands in more than one cell, be sure the entries proceed downward (A1, A2, A3) with no empty cells between them. Each cell must contain a label or a text formula.
Tip
You can also indicate the end of a macro by typing {RETURN} or leaving an empty cell below the last cell of the macro.
To add a command to a macro script
1 Click a spreadsheet containing the macro script.
2 Click the cell above where you want to add the command.
3 Click Insert Insert row.
4 Click OK.
5 Type the new command.
To delete a command from a macro script
1 Click a spreadsheet containing the macro script.
2 Click the row label containing the command you want to delete.
3 Click Edit Delete cells.
To name a Quattro Pro macro
1 Click a spreadsheet containing the macro script.
2 Select the cells containing the macro you want to name.
3 Click Insert Name Name cells.
4 Type the name in the Name box.
Working with macro libraries
The best way to store macros is in a macro library, a special notebook reserved for macros that you can access from any notebook. You can create a library Macro libraries can
simplify linked access
make tracking macros easier
ensure that macros do not interfere with the notebook data and conversely
save disk space by using one set of macros for a group of notebooks
store a set of macros that can be copied into individual notebooks as you need them
create a separate set of macros for each application or type of notebook you work with
You should keep only one macro library open at a time. When two open libraries contain a macro with the same name, it is difficult to predict which macro will play. Quattro Pro searches only open macro libraries for macros; closed libraries are ignored.
You can also create a system notebook. You can use system notebooks to hold application macros and ensure their availability while Quattro Pro is running. You can hide system notebooks. A system notebook, when hidden, stays open even when users close all notebooks.
To create a macro library
1 Click Format Notebook properties.
2 Click the Macro library tab.
3 Enable the Yes option.
4 Click OK.
5 Click File Save.
To create a system notebook
1 Click Format Notebook properties.
2 Click the System tab.
3 Enable the Yes option.
If you also want to designate the notebook as a macro library, click the Macro library tab, and enable the Yes option.
4 Click OK to close the dialog box.
To hide a system notebook
1 Click Format Notebook properties.
2 Click the Password level tab.
3 Enable the Medium option
4 Click OK.
5 In the Enter password dialog box, type a password.
Tip
You can also hide a system notebook by clicking Window Hide.
Recording and editing PerfectScript macros
You can use PerfectScript macros not only with Quattro Pro, but also with other Corel applications such as Corel Presentations and WordPerfect.
PerfectScript is a command-based language that records the results of keystrokes or mouse selections rather than the keystrokes themselves. PerfectScript includes commands that direct the function of the macros. These commands let you create macros that can prompt for user input, make decisions based on conditions in a notebook, access system variables, and so on.
You can record PerfectScript macros. A recorded macro includes only product commands.
You can also type a macro in WordPerfect and play it in Quattro Pro. A typed macro can include non-recordable statements that specify how a macro performs a task. When writing this kind of macro, you specify the conditions for playing assignments, loops, and programming commands.
Once you have created a PerfectScript macro script you can create a .wcl file. The .wcl file is necessary for debugging PerfectScript macros.
In Quattro Pro you can edit a PerfectScript macro in two ways: in WordPerfect or in the PerfectScript Macro Facility.
To record a PerfectScript macro
1 Click Tools Macro Record.
2 Enable the PerfectScript macro option.
3 Type a filename in the Filename box.
4 Click OK.
5 Perform the actions in a task.
Each action is recorded and written as one or more macro commands in the macro file.
6 Click Tools Macro Record.
Notes
The recording of a macro is noted by on the application bar.
You cannot record a PerfectScript macro that pauses for user input. If you want the macro to pause, edit it after recording it.
To pause or resume recording a PerfectScript macro
Click Tools Macro Pause.
To type a PerfectScript macro
1 Start WordPerfect.
2 Click Tools Macro Macro toolbar.
3 Click the Commands button on the Macro toolbar.
4 Choose a command type from the Command type list box.
If the command requires a parameter, choose a parameter from the Parameters list box.
If the command requires an enumeration, choose an enumeration from the Enumerations list box.
5 Type any additional parameters or values in the Command edit box.
6 Click Insert.
7 Click Save & compile on the macro toolbar.
Note
Enumerations are used to set parameter values when parameter values are limited to a specific set of values. For example, the FileClose command lets you close a file. It has a parameter named DoSave? with two enumerations, Yes! and No!.
Tip
You can also type a PerfectScript macro by click Start Programs WordPerfect 11 Utilities PerfectScript 11 and clicking Help Macro command browser.
To create a .wcl file
1 Click Tools Macro Edit.
2 Choose the drive and folder where the macro is stored.
3 Double-click the filename.
WordPerfect opens.
4 Click Options Compile with debug on the macro tools toolbar.
5 Click Save & compile on the macro toolbar.
6 In the PerfectScript compiler listing box, click OK.
Note
The .wcl file defaults to the same location and name as the .wcm file.
Tip
You can open the macro tools toolbar in WordPerfect by clicking View Toolbars, and enabling the Macro tools check box in the Toolbar list.
To edit a PerfectScript in the PerfectScript Macro Facility
1 Click Tools Macro Edit.
2 Choose the drive and folder where the macro is stored.
3 Double-click the filename.
To edit a PerfectScript macro in WordPerfect
1 On the Windows taskbar, click Start Programs WordPerfect 11 Utilities PerfectScript 11.
2 Click File Edit.
3 Choose a drive and folder where the file is stored.
4 Double-click a filename.
This starts WordPerfect and displays the macro commands.
5 Edit the macro.
Creating VBA macros
Quattro Pro lets you start Visual Basic for Applications (VBA) from Quattro Pro. You can display the VBA toolbar, which provides quick access to commands such as playing a macro or starting the VBA Editor.
With VBA, you can create a project macro. You can play a project macro only in the document which was used to create it.
You can create a project VBA macro by creating a public method for the ThisDocument object. The term public refers to the access level. If a method is public, it can be accessed from outside the class. This means that you can call it from the host application. If a method is private, then only methods in the same class can access it. Every public method that belongs to the ThisDocument class is a project macro.
You can copy PerfectScript to a VBA code module. You can also copy Quattro Pro macro script to a VBA code module.
You should always play a macro once you have created it. For more information about playing a PerfectScript macro see "To play a PerfectScript macro."
For more information about VBA, see the Microsoft Visual Basic Help in the Visual Basic Editor.
To start VBA from Quattro Pro
Click Tools Visual Basic Visual Basic Editor.
Note
For more information about VBA, see the Microsoft Visual Basic Help in the Visual Basic Editor.
To display the VBA toolbar
1 Click View Toolbars.
2 Enable the Visual Basic check box in the Toolbar list.
Note
For more information about VBA, see the Microsoft Visual Basic Help in the Visual Basic Editor.
To create a VBA project macro in Quattro Pro
1 Click Tools Visual Basic Visual Basic Editor.
2 In the Project explorer Docker window, double-click the VBAProject (NoteBk1) in the list of categories.
3 Click Insert UserForm.
4 In the Toolbox dialog box, drag any control to the user form.
5 Modify any of the control's attributes, in the Properties Docker window.
6 Double-click a control.
7 In the Notebk1 code module window, type the code that responds to the activation of the control.
8 Open the QuattroPro objects folder in the Project explorer Docker window.
9 Double-click ThisNotebook.
10In the Notebk1 code module window, type the code that adds a new method to the notebook.
To copy PerfectScript to a VBA code module
1 Open the .wcm file containing the PerfectScript macro.
2 Select the macro.
3 Click Edit Copy.
4 Click Tools Visual Basic Visual Basic Editor.
5 In the Project explorer Docker window, double-click VBAProject (NoteBk1) Quattro Pro objects ThisNotebook in the list of categories.
6 In the Notebok1 code module window, type Public Sub and the name of the sub.
7 Within the Public Sub, type Application.PerfectScript.
8 Click Edit Paste.
9 Replace the first brace from the line of code with a period.
10Choose the VBA code that is equivalent to the PerfectScript code from the list.
11Type End with at the end of all the code and within the Public Sub.
To copy Quattro Pro macros to a VBA code module
1 Open the file containing the Quattro Pro macro.
2 Select the macro.
3 Click Edit Copy.
4 Click Tools Visual Basic Visual Basic Editor.
5 In the Project explorer Docker window, double-click VBAProject (NoteBk1) Quattro Pro objects ThisNotebook in the list of categories.
6 In the Notebok1 code module window, type Public Sub and the name of the sub.
7 Within the Public Sub, type Application.PerfectScript.
8 Click Edit Paste.
9 Replace the first brace from the line of code with a period.
10Choose the VBA code that is equivalent to the Quattro Pro code from the list.
11Type End with at the end of your code and within the Public Sub.
To play a VBA macro
1 Click Tools Visual Basic Play.
2 Choose VBAProject(NoteBk) from the Macros in list box.
3 Choose a macro from the Macro name list box.
4 Click Run.
Tip
You can also play a VBA macro by clicking the Play button on the Visual Basic toolbar.
Debugging and editing a VBA macro
You can debug VBA macros. Debugging lets you step through code line by line to ensure that a macro executes properly. For example, if you are at a point in the code where a variable is about to be assigned a value, you can step into this line of code to determine the value of the variable at runtime.
You can also edit a VBA macro. Editing a macro involves going directly to start of the code, whereas debugging lets you step through each line of the code.
To debug a VBA macro
1 Click Tools Visual Basic Play.
2 Choose a macro from the Macro name list box.
3 Click Step into.
4 In Microsoft Visual Basic, click Debug Step into.
5 Modify the code.
Note
After you click Step into, you can position the pointer over a specific variable to determine the value of the variable. For more information about debugging in VBA, see the Microsoft Visual Basic Help in the Visual Basic Editor.
To edit a VBA macro
1 Click Tools Visual Basic Play.
2 Choose a macro from the Macro name list box.
3 Click Edit.
4 Edit the code as necessary.
Note
For more information about editing VBA, see the Microsoft Visual Basic Help in the Visual Basic Editor.
Using the PerfectScript class to change a Quattro Pro document
The PerfectScript class lets you automate specific and repetitive tasks. The members of the PerfectScript class are the product commands used in conjunction with the PerfectScript language. You can change a Quattro Pro document using the PerfectScript class.
To change a Quattro Pro document using the PerfectScript class
1 Click Tools Visual Basic Visual Basic Editor.
2 In the Project explorer Docker window, double-click VBAProject (NoteBk1) Quattro Pro objects ThisNotebook in the list of categories.
3 In the Notebok1 code module window, type Public Sub and the name of the sub.
4 Below End Sub, type Private Sub and the name of the sub.
5 Press ENTER.
You will notice that VBA automatically adds End Sub to you code
6 Within the Private Sub, type PerfectScript. and choose the necessary commands.
7 Within the Public Sub, type the name of the Private Sub.
Notes
If you declare the first method as private, you will not be able to run it from Quattro Pro.
For more information about VBA, see the Microsoft Visual Basic Help in the Visual Basic Editor.
Working in Developer mode
You can start Quattro Pro to work in Developer mode. Developer mode adds special properties to property menus and lets you use the shortcut key Ctrl + M, which varies in function depending on the current program state. In most instances, Ctrl + M restores the standard Quattro Pro application bar and input line. In Developer mode, you can modify property settings or change the title displayed in the Quattro Pro title bar. Additional properties of drawn objects in a chart or map window let you read or change property settings with macro commands, link commands, and spreadsheet functions (Name property). You do not have to be in Developer mode to change or read these property settings; macro commands can always access them.
You can also control whether users can access object property settings.
To start Quattro Pro in Developer mode
1 On the Windows taskbar, click Start Run.
2 Type the Quattro Pro command with its path, followed by a space and /d.
For example, qpw.exe /d.
To modify the title bar in Developer mode
1 Click Tools Settings.
2 In the list of categories, double-click Workspace, Application, and click the Developer options.
3 Type a new title in the Application title box.
To modify the properties of a chart or map object in Developer mode
Click the Property button on the toolbar.
To disable access to property settings in Developer mode
1 Click Tools Settings.
2 In the list of categories, double-click Workspace, Application, and click the Developer options.
3 Enable the No option.
Tip
To enable property settings after disabling them, press Ctrl + M in all states other than debug mode.
Recording macros using relative and absolute cell references
By default, addresses in macro commands use absolute cell addressing like A1 and C6. You can record absolute cell references. However, you can also record macro commands that use relative references so you can play the macro in different parts of a notebook or in different notebooks. For more information on absolute and relative cell addresses, see "Absolute and relative cell addresses."
To record a macro using relative or absolute cell references
1 Click Tools Macro Options.
2 Enable one of the following options:
Relative
Absolute
Attaching macros to notebooks and buttons
Quattro Pro lets you attach macros to notebooks. A macro attached to a notebook can play when you open or close the notebook.
You can also attach a macro to a button. The button plays the macro. You can link a button you create to a macro script.
You can attach a macro to a keystroke. Macros attached to keystrokes are activated when you press the keystroke.
You can use the macro buttons you create to display the dialog boxes you create in Quattro Pro. For information about creating dialog boxes, see "Working with custom dialog boxes and controls."
Once you create a macro button, you can change the button properties by modifying the box type, border color, protection, and button name.
You can also attach a Quattro Pro or PerfectScript macro to a customized a command. For example, you can create a toolbar button and display it on any of the toolbars. When you click the button, the macro executes.
To attach a macro to a notebook
1 Right-click the top-left cell of the macro.
2 Click Name cells.
3 Type one of the following in the Name box:
_nbstartmacro-creates a startup macro that plays when you open the notebook
_nbexitmacro-runs a macro when you close the notebook
any block name (for example, "Fred" could be the name of a macro stored in a block)
4 Click Add.
5 Click Close.
Tip
You can also create a startup macro that plays when you open the notebook by typing \0 (backslash zero).
To create a macro button
1 Click Insert Form control Push button.
2 Click the spreadsheet.
3 Drag the button to position it on the spreadsheet.
You can also
Display a label on a macro button Right-click the button, and click Selection properties. Click the Label text tab. In the Enter text box, type the text you want to display on the button.
Attach a macro button to a URL address Right-click the button, and click Selection properties. Click the Macro tab. Click Link to URL. In the Button URL dialog box, type the URL address in the URL box.
Tips
Clicking the spreadsheet creates a button at the default size. If you want to create a custom size button, drag to create the button.
You can also create a macro button by opening the Form Controls flyout on the Drawing tools toolbar and clicking the Push button tool.
To link a button to a macro
1 Right-click a button, and click Selection properties.
2 Click the Macro tab.
3 In the Enter macro box, type { (an opening brace), the macro command name, and } (a closing brace).
Note
The maximum length for a macro command name is 200 characters.
To attach a macro to a keystroke
1 Select the starting cell of the macro.
2 Click Insert Name Name cells.
3 In the Name box, type ' (an apostrophe) and \ (a backslash), followed by a letter of the alphabet.
4 Click Add.
Note
Macros assigned to keystrokes play by holding down Ctrl + Shift and the letter assigned to the name. Avoid using the same alphabet letters already assigned to shortcuts in the application. For more information on keyboard shortcuts, see "Quattro Pro keyboard shortcuts."
To link a macro button to a dialog box
1 Right-click the macro button, and click Selection properties.
2 Click the Macro tab.
3 Click Execute dialog.
4 In the Execute dialog dialog box, choose a dialog box from the Active dialog list.
5 Type a cell reference in the Result cell box.
After the dialog box is closed, this cell contains 1 or 0. The value 1 means the dialog box was closed by clicking OK; the value 0 means it was closed by clicking Cancel.
6 Type a cell reference in the Values range box:
Specify the cells that contain initial settings for the dialog box. When the dialog box is closed, its final settings are written into these cells.
Tip
You can also select a cell reference by clicking the Range picker tool.
To modify a macro button
1 Right-click a macro button, and click Selection properties.
2 Click one of the following tabs:
Border color-changes the color around the outside of the button
Box type-changes the thickness of the line around the button or applies a shadow effect
Protection-locks the button, preventing users from moving or changing the button when protections are set at the spreadsheet level
Object name-changes the button's name (used when referring to the button in a macro)
Print- enables the printing of chart objects on the spreadsheet.
Label text-changes the name displayed on the label
Macro-changes the button activation, URL link, or dialog box that displays when clicking the button
3 Modify any settings.
To attach a macro to a toolbar button
1 Click Tools Customize.
2 In the list of categories, double-click Workspace, Customize, and click Commands.
3 Choose Macros from the list box.
4 Choose a button graphic from the list.
5 Click the Macro command category tab.
6 Enable one of the following options:
Quattro Pro macro
PerfectScript macro
7 Type the macro in the Enter macro box.
8 Click the Appearance tab, and type a name in the Caption box.
9 Click the General tab, and type text to use as the button's Tool Tip in the Tooltip help box.
To add a macro button to the toolbar area
1 Click Tools Customize.
2 In the list of categories, double-click Workspace, Customize, and click Commands.
3 Choose Macros from the list box.
4 Select a macro button you want to add to the toolbar area.
5 Drag the macro button to the appropriate toolbar.
Playing macros
You can play a Quattro Pro macro from the menu or by using the macro buttons on a customized toolbar. For information about creating customized toolbars, see "Working with toolbars."
Playing a PerfectScript macro is similar to playing a Quattro Pro macro. However, PerfectScript macros cannot be used for startup or exit macros.
You can have a play a macro each time you open or close a notebook. For example, Quattro Pro can enter the current date and time when you open a notebook. You can also play a macro each time you start Quattro Pro.
You may want to have Quattro Pro launch a macro whenever a user opens a particular notebook. When you open a file that contains a PerfectScript or Quattro Pro native startup macro, the macro launches as soon as you open the file. For your convenience, Quattro Pro displays a message alerting you that the file contains this kind of macro. Quattro Pro can have the same macro startup every time a user launches Quattro Pro. You can also design an exit macro to make sure any ongoing operations are completed so you can exit the notebook without problems.
To play a Quattro Pro macro
1 Click Tools Macro Play.
2 Enable the Quattro Pro macro option.
3 Type the location of the macro in the Location box.
Tips
You can also play a Quattro Pro macro by pressing ALT + F2.
If the macro is in another notebook, use full linking syntax to specify the macro location (for example, [LIBRARY]A:C26).
To play a PerfectScript macro
1 Click Tools Macro Play.
2 Enable the PerfectScript macro option.
3 Type a filename in the filename box.
Tip
You can play a PerfectScript macro by pressing Alt + F2.
To play a startup or exit macro in a notebook
1 Select the first cell of a macro.
2 Click Insert Name Name cells.
3 In the Name box, type one of the following:
_NBSTARTMACRO-plays a startup macro when opening the notebook
_NBEXITMACRO-plays an exit macro when closing the notebook
4 Click Add.
5 Click Close.
Note
If a notebook is linked to other notebooks, a Links dialog box displays when you open the notebook. To ensure that _NBSTARTMACRO plays correctly in a notebook that contains links, begin the macro with {ESC}. This cancels the Links dialog box.
To assign an existing macro as the startup macro
1 Click Tools Settings.
2 In the list of categories, double-click Workspace, Application, and click Macro.
3 Type a new name in the Startup box.
Note
If you modify the default startup macro name, existing macros named \0 will no longer play automatically. For example, if you set the startup name to AUTOSTART, macros named \0 do not play automatically; they must be renamed AUTOSTART.
To assign a macro to launch automatically when Quattro Pro launches
1 Click Tools Settings.
2 In the list of categories, double-click Workspace, Application, and click File options.
3 Type the name of the macro in the Autoload file box.
Tip
You can also locate the macro by clicking the Browse button in the Autoload file box.
To stop a macro while it is playing
Click Ctrl+BREAK.
Note
If Ctrl + BREAK has been disabled with {BREAKOFF}, you cannot stop the macro. If you need to use {BREAKOFF} in the macro, add it as a last step after debugging the macro.
Debugging Quattro Pro macros
Once you create a Quattro Pro macro, you can turn on the macro debugger to check for errors in the code. This allows you to
assign standard or conditional breakpoints
assign trace cells
assign cells for editing
You control when debug mode is active and turn it on or off as needed. You can play a macro while in debug mode. You can also edit Quattro Pro macro cells from the debugger.
If you know that most of a macro is correct, you can use breakpoints to play parts of a macro at full speed and step through other parts that may have problems. There are two types of breakpoint:
Standard breakpoints-pause the macro at the breakpoint cell
Conditional breakpoints-pause the macro when the result of a logical formula in the conditional breakpoint cell is true
You can set up to four conditional breakpoints for each notebook. Conditional breakpoints can be extremely valuable. Suppose you have a macro loop that contains date calculations and you want it to pause whenever December is reached. If the date is in cell A5, assign the first conditional breakpoint to a cell containing the following formula:
MONTH(A5)=12
As long as the formula in the condition cell is true (has a value of 1), the macro plays in step-by-step mode. Once the formula is false (has a value of 0), the macro stops playing.
You can set up to four standard breakpoints. Sometimes a problem appears after many repetitions of the same commands in a macro loop. If this is the case, you can set a pass count to indicate how many times to pass through the breakpoint before stopping. The default, 1, stops the macro every time it passes through the breakpoint. Setting it to 2 stops the macro every other pass.
Conditional breakpoints debug a macro using Boolean logic. The debugging process pauses only when a positive result (1) is returned by playing the script.
Macros often affect the contents of one or more cells. By tracing these cells, you can see what the macro is doing. You can specify up to four trace cells whose addresses and current values display during debugging in the debugger window. The debugger updates as the contents of the trace cells change.
To play a Quattro Pro macro in debug mode
1 Click Tools Macro Debugger.
2 Click Tools Macro Play.
3 Enable the Quattro Pro macro option.
4 Type the location of a macro in the Location box.
5 Click in the debugger window to step through each macro command until you find an error.
You can also
Exit macro debug mode Click Tools Macro Debugger.
Stop macro before debugging is finished Click Terminate.
Tip
You can also play a macro in debug mode by pressing Shift + F2.
To set a standard breakpoint in a Quattro Pro macro
1 Click Tools Macro Debugger.
2 Click Tools Macro Play.
3 Enable the Quattro Pro macro option.
4 Type the location of a macro in the Location box.
5 Click OK.
6 Click Breakpoints, and click a breakpoint to set.
7 In the Breakpoint dialog box, type the breakpoint cell reference in the Location box.
8 Type a value in the Pass count box.
9 Click OK, and press the SPACEBAR.
You can also
Remove standard breakpoints Type 0 in the Pass count box.
Clear all trace cells and breakpoints Click Reset.
Tip
You can also resume stepping through the macro by clicking Go.
To set a conditional breakpoint in a Quattro Pro macro
1 Click Tools Macro Debugger.
2 Click Tools Macro Play.
3 Enable the Quattro Pro macro option.
4 Type the location of a macro in the Location box.
5 Click OK.
6 Click Conditional, and click a conditional breakpoint.
7 In the Conditional cell dialog box, type the cell reference in the Location box.
8 Click OK.
9 Press the SPACEBAR.
Tip
You can also resume stepping through the macro by clicking Go.
To set a trace cell for a Quattro Pro macro
1 Click Tools Macro Debugger.
2 Click Tools Macro Play.
3 Enable the Quattro Pro macro option.
4 Type the location of a macro in the Location box.
5 Click OK.
6 Click Trace, and click a trace cell.
7 In the Trace cell dialog box, type the trace cell reference in the Location box.
8 Click OK.
To edit macro cells from the macro debugger
1 Click Tools Macro Debugger.
2 Click Tools Macro Play.
3 Enable the Quattro Pro macro option.
4 Type the location of a macro in the Location box.
5 Click OK.
6 Click Edit.
7 In the Edit cell dialog box, type the edit cell reference in the Cells box.
8 Edit the contents that display in the Content box.
Debugging PerfectScript macros
PerfectScript macros are written with an editor and saved as a source file. The macro compiler creates an object, which it saves in a hidden area of the source (the macro compiler does not create a separate object file). When you save a source file, the object is destroyed. It is recreated each time the source file is compiled. A compiled source file (macro) contains instructions that are executed when you play the macro.
A macro compiler is used to compile or "translate" macros so that WordPerfect Office applications can play them. Macros in PerfectScript are compiled when you record, play, or save them. The tool used for compiling PerfectScript macros is the PerfectScript Debugger.
Compilation errors
Sometimes, when you type or edit a macro, errors are created. For example, if you mistype a word, when you compile the macro, a compile-time syntax error displays a syntax error message. The compiler does not recognize typographical errors and guesses that it is a label's calling statement. When the compiler reaches the end of the file and does not find a corresponding label, it displays a syntax error message. The message contains information about the error and its location. The compiler makes a best guess and may not always be accurate. The compiler identifies syntax errors and suggests solutions.
Common syntax errors are caused by
missing semicolons between parameters
missing parentheses
missing double quotation marks
missing command in a conditional or loop statement
undefined calling statements
using commas between parameters instead of semicolons
Run-time errors
Run-time is the same as execution time. Run-time errors occur while the macro is playing. Referencing a variable that has not been assigned a value causes a run-time error. Run-time error messages identify errors that occur while the macro plays and show where the errors occur.
For users familiar with other programming languages such as Visual Basic or C++, the PerfectScript Debugger has many of the same features and buttons found in those language compilers.
Debugging breakpoints
Use breakpoints to indicate locations in the macro where execution of the macro should be interrupted and suspended, and where the debugger should become active. While the macro executes statements, the debugger is mostly inactive, and the debugger state message line displays the text "Macro is running." However, the debugger is not completely disabled. You can interrupt the macro. This causes the debugger to become active, as if there were a breakpoint at the point where the macro is currently executing. Breakpoint commands are also available while the macro is running, so that you can add and remove breakpoints.
You can stop a macro at any line, DLL call, or other place in the macro. A dialog box displays the labels, functions, procedures, and variables being passed, so that you can check them. All breakpoints allow a message to be logged to the debugger event log.
The PerfectScript Debugger automatically creates three breakpoints: Macro Start, Macro End, and Error. It marks the breakpoints it adds with an exclamation mark (!), which can be removed if desired.
Debug options
When the debugger stops at a macro statement, it stops before the indicated statement executes. The PerfectScript Debugger provides the following options to continue macro execution:
To play a PerfectScript macro in debug mode
1 Click Tools Macro Debugger.
2 Click Tools Macro Play.
3 Enable the PerfectScript macro option.
4 Type a filename in the Filename box.
5 Click OK.
6 In the PerfectScript debug dialog box, click Debug and choose one of the following menu commands:
Continue-continues executing the macro until the next breakpoint
Step into-executes the next statement
Step over-executes the label or routine call without stopping until debugging is complete. This will stop the macro at the next statement in the current label or routine.
Step out-executes the macro until the next return is encountered, if you have entered a routine or label
Run to cursor-executes to the line below the cursor in the macro source list
Skip to cursor-skips a series of statements without executing them; if some statements need to be repeated, sets the next statement to be executed by the Debugger, without executing any statements between the current point and the new line.
Animate-repeats the next Continue or Step command until you stop it, or until the macro ends. Between each command, the Debugger displays for the amount of time you specify in the Settings dialog box.
Notes
Use the Skip to cursor menu command with extreme caution, since skipping to a line that is not within the same label or routine could cause the internal macro execution to become invalid, which will almost certainly result in execution failure.
You need a .wcl file in the same folder as the PerfectScript macro file. For information on creating a .wcl file see "To create a .wcl file."
To set a breakpoint in PerfectScript macros
1 Click Tools Macro Debugger.
2 Click Tools Macro Play.
3 Enable the PerfectScript macro option.
4 Type a filename in the Filename box.
5 Click OK.
6 In the Debugger dialog box, click Debug Breakpoints Edit.
7 In the Edit breakpoints dialog box, click the Location and condition tab.
8 Choose the type of breakpoint you want from the Type list box.
9 Click one of the following buttons:
Add-creates a new breakpoint
Update-updates an existing breakpoint
Tip
You can add a line number breakpoint by double-clicking the line in the macro source list where you want the macro to stop.
Customizing application settings using macros
As the application you create may affect standard settings on the desktop, it is a good idea to save and reset the user's environment settings. You can include extra code in the macro to restore the original settings once the user exits the application. You can also update links to other notebooks and objects using linking parameters.
You can customize macros using self-modifying (or dynamic) macro codes. Self-modifying macros either alter all or part of the macro when playing.
To save and reset application defaults
When you develop a Quattro Pro application, it is usually best to store the user's environment settings.
If you create a custom application in Quattro Pro that changes a user's environment settings, it is a good idea to include macro code that saves the user's current settings and restores them when the user exits the application. You can save the current settings with the following macro commands:
{LET:A1,PROPERTY("Application.Display")}
{LET:A2,PROPERTY("Application.International")}
{LET:A3,PROPERTY("Application.Macro")}
{LET:A4,PROPERTY("Application.File_Options")}
{LET:A5,PROPERTY("Application.General")}
To change the settings, you can use macro commands like the following:
Finally, to restore the settings, use these macro commands:
{Application.Display +:A1}
{Application.International +:A2}
{Application.Macro +:A3}
{Application.File_Options +:A4}
{Application.General +:A5}
To use the active selection within a macro
PROPERTY("Active_Block.Selection") returns the address of the currently selected cells as an address and can be used within macro commands. The following macros set the print selection and create a named cell from the active cells:
To pass linking parameters such as "Open Supporting," "Update References," or "None," you must spell out the entire parameter in the {FileOpen} macro command, as follows:
{FileOpen "TEST.QPW, "Open Supporting"}
{FileOpen "TEST.QPW, "Update References"}
{FileOpen "TEST.QPW, "None"}
To create self-modifying macros
You can use macro commands and text formulas to create self-modifying macros (also called dynamic macros) that alter themselves while playing. For example, to save the active notebook as acctx.qpw, where x is a value stored in cell A5, type the following text formula into a cell:
+"{FileSaveAs ""ACCT"&@STRING(A5,0)&".QPW""}"
The result of this formula plays as a macro command. For example, if cell A5 contains the value 5 from the previous example, Quattro Pro plays {FileSaveAs "ACCT5.QPW"}. If cell A5 changes to 10 and the notebook recalculates, Quattro Pro plays {FileSaveAs "ACCT10.QPW"}.
You can also use macro commands to change a portion of the macro while it is playing. The next example shows a macro that uses {GET} to convert user keystrokes into macro actions:
cell_type b
type_indic {INDICATE UPPER(CELLPOINTER("type"))}
{LET cell_type,cellpointer("type")}
{IF cell_type="l"}{INDICATE LABEL}
{IF cell_type="b"}{INDICATE BLANK}
{IF cell_type="v"}{INDICATE VALUE}{GET next_key}
{IF UPPER(next_key)="{ESC}"}{BRANCH clear_indic}
next_key {Esc}{BRANCH type_indic}
clear_indic {INDICATE}{QUIT}
You can use these concepts to create powerful macros that completely change themselves based on their environment.
Reference: Using macros
There are three types of macros: Quattro Pro native macros, PerfectScript macros, and Visual Basic for Applications (VBA) macros. It is important to understand all three types of macros before choosing a macro that best suits your needs. Some aspects that you can look at are the differences between the macros and the syntax of a macro.
Additional macro resources
For a complete listing and category breakdown of available macro commands, see Quattro Pro Macros Help, which is located in the reference information section of the Quattro Pro online help.
For information about the list of available programming commands, see PerfectScript Programming Macros Help, which can be accessed from the WordPerfect Office Macro Command Center.
The WordPerfect Office Software Developer's Kit (SDK) is a set of tools that lets software developers customize WordPerfect Office applications for commercial or business use. The SDK includes the online Help for the SDK, OLE automation samples, PerfectScript tools, code generation wizards for third-party add-ons, utilities to monitor events, and a file format parsing tool. For information about acquiring a WordPerfect Office Software Developer's Kit, visit Corel Solutions Partners.
Choosing a macro creation tool
Quattro Pro provides several built-in scripting tools to create macros:
Quattro Pro macros are stored in notebook cells. Use this type of macro when a task is performed within Quattro Pro.
PerfectScript macros are stored in a .wcm file. This type of macro is useful when you want to automate tasks with several notebooks or interact with other WordPerfect Office applications, such as WordPerfect. For example, you can update Quattro Pro data in a WordPerfect report. For information about using PerfectScript macros in Quattro Pro, see "Recording and editing PerfectScript macros."
Visual Basic for Applications (VBA) lets you develop scripts that are saved within specific projects using a robust version of the Visual Basic programming language. You can access the VBA Editor from within Quattro Pro. For information about using VBA with Quattro Pro, see "Integrating Visual Basic for Applications with WordPerfect Office."
The simplest way to create a macro is to record the keystrokes in Quattro Pro. You can also write a macro to include non-recordable tasks. For example, you can define a macro to play until a certain event happens or include a comment to prompt users to enter specific data.
Comparing Quattro Pro macros with PerfectScript
Quattro Pro macros and PerfectScript use similar command syntax. There are, however, some major differences in the two scripting tools:
Quattro Pro macros PerfectScript macros
Are stored in notebooks or cells Are stored in .wcm macro files
Are created and edited in the notebook Are created and edited in WordPerfect
Can be played from a library notebook Are played from the source folder
Can use shortcut names for playing Cannot play from shortcut names
Play only in Quattro Pro Play in any WordPerfect Office application
Use blank lines to separate macros Use blank lines to separate commands and subroutines
Use commands and arguments Use commands and parameters (which contain arguments)
The following table presents the major syntactical differences between both macro tools:
Quattro Pro syntax PerfectScript syntax
Command has curly braces No braces around command
No parentheses around argument list Parentheses required around parameter list
Object and property separated by period Object and property separated by underscore
Arguments separated by commas Arguments separated by semicolons
Syntax examples of Quattro Pro macros
Quattro Pro macro syntax uses the following syntax format:
{CONTENTS E15, F15, G15}
The command name CONTENTS is the exact name of the command. Arguments are values providing instructions to the command. Not all macro commands require arguments, but when they do, they require specific information. For example, {BEEP} is a macro command without arguments. Many command equivalents contain a period (.) in their command name , for example {Search.Find "3rd Quarter Profits}.
The command name GraphGallery indicates the feature the command activates. This particular example launches the Chart Gallery and selects a 3-D bar chart with a tangerine color scheme. Some commands are made up of only a command name, such as FileOpenDlg(). Parameters provide more information about the command, such as which options of a feature are active. Parameters are always enclosed in parentheses; for example, Backup(State:On!). A semicolon is the separator mark between parameters in a command.
For more information about Quattro Pro syntax, see "Macro syntax and arguments."
To get more information about recording and attaching macros to toolbars, notebooks, and controls, see "Using macros."
Understanding Quattro Pro macro syntax
Macro commands are like spreadsheet functions: they have specific grammatical rules, or syntax. The basic syntax is
{COMMANDNAME Argument1,Argument2, Argument3,...}
COMMANDNAME is the name of the command.
Arguments are values. Not all macro commands require arguments; when they do, they require a specific type of information.
The following are some examples of macro commands:
{Query.Criteria_Table B27..B29}
{BlockCopy A1,A2..A37}
{Search.Find "3rd Quarter Profits"}
{GETNUMBER "How old are you?",AGE}
{CONTENTS E15,F15,5}
Quattro Pro syntax requires that you type the entire macro command in a single cell. The following syntax rules for macro commands also apply:
QP syntax must include Examples
Opening and closing braces{} {BEEP 3}
COMMANDNAME(space)Argument1 {BlockCopy A1}
Commas or semicolons between arguments {CONTENTS E15,F15,5}
Correct argument types {GETLABEL hello world, A4} where "hello world" is not a valid string type
Quotation marks around punctuation or spaces {GETLABEL "Hello,world",A4}
Type command in upper/lower case GETLABEL = getlabel
One or more commands for each cell {BEEP}{GETLABEL "Hello, world",A4}{QUIT}
If a setting contains spaces, punctuation, or quotation marks, enclose it within double quotation marks (for example, "Prefix, ""Windows Default"",",No").
Understanding arguments
Arguments in macro commands, like those used with spreadsheet functions, require specific information to be supplied with the command. There are four types of arguments: numbers, strings, locations, and conditions.
Number arguments Examples
Any numeric value, entered as a number 2 or 0.45
A formula resulting in a number A3*15
A cell address with a numeric value or formula C10, where C10 contains a number or formula
A named block with a numeric value or formula C10, where C10 contains a valid number or formula
String arguments Examples
A text string, such as an actual string "Corel"
A reference to a cell or block containing a label A1..A4
A property separated by a comma (,) "Currency, 2" (This also applies to command settings separated by a comma)
A formula resulting in a label @UPPER("hello ")
Location arguments Examples
A block name INTEREST refers to a cell block C5-C15
Block coordinates with more than one cell A1,A1..A4 or A..B:C4..D22
A block relative reference of more than one cell []C(0)R(0),[]P(-2):C(0)R(22) or []C(0)R(0)..C(3)R(10)
Coordinates for noncontiguous blocks (A1,B1..B7,C1..C7) or (A1,B:C27..C52)
A label or text formula in any of these options +"A"&"2" which results in A2
Condition arguments Examples
A formula that evaluates to true or false +C4>500
Some commands accept a combination or choice of argument types. For example, {LET} stores either a label or a number in a cell, depending on the argument type.
You can use argument suffixes in a command to specify a value or label entry. Using :string (or :s) assures a label entry, and :value (:v) ensures a value entry (if the entry is a valid number). In the following example, the first example enters the value 7 into a new_block, while the second example enters a label into a new_block:
{LET new_block,3+4:value}
{LET new_block,3+4:string}
For information about PerfectScript syntax, see "Choosing a macro creation tool."
For information about using relative cell references, see "Recording macros using relative and absolute cell references."
Integrating Visual Basic for Applications with WordPerfect Office
You can use Microsoft Visual Basic for Applications (VBA) with WordPerfect Office. VBA is an object-oriented programming language that lets you create VBA macros to automate tasks. You can, for example, create a macro in WordPerfect that changes the color of headings in a spreadsheet. VBA is not part of the typical install of WordPerfect Office. To use VBA, you should do a custom install and enable Microsoft Visual Basic for Applications.
Event-driven programming
Visual Basic for Applications is an event-driven programming language. Most of the code you create is written to respond to an event. An event is an action recognized by VBA; for example, clicking a button or choosing an option from a list box. Unlike traditional procedural programming, in which the program starts at line 1 and executes line by line, event-driven programming executes code in response to events.
The difference between PerfectScript and VBA
Previously, you could use the PerfectScript language only to automate specific tasks. Both product commands and programming commands are used in conjunction with the PerfectScript language. The PerfectScript language is useful for developing simple macros. VBA offers more flexibility and power. When you use VBA to create macros, you are assisted by the Visual Basic compiler. The compiler helps you by providing context-sensitive help when you are coding a VBA macro. You can combine the power of VBA with the PerfectScript product commands to create powerful macros. You have to use the Visual Basic Editor to create VBA macros; however, PerfectScript macros are developed from the WordPerfect Editor. You can access the Visual Basic Editor only when you are working in an active document.
The PerfectScript class
All product commands used in WordPerfect, Quattro Pro, and Corel Presentations can be used in VBA macros. You must call the PerfectScript object to access a product command. An object is an instance of a class. All objects have properties; for example, the name of a document is a property that belongs to the document object. You can set or change an object's properties by calling certain methods. A method performs a specific action, such as inserting a table into a document. You can, for example, close a document by calling the close method, or you can save a document by calling the save method. The term class is a VBA programming term and means a collection of related methods, which are referred to as class members. The product commands are the class members that belong to the PerfectScript class. WordPerfect, Quattro Pro, and Corel Presentations have their own PerfectScript class because the class members, which are the product commands, are different depending on the application.
All members of the PerfectScript class perform a specific action. For more information about product commands, see the macros command list "QP MACRO LIST".
Note
Although there may be some differences, the syntax for the product commands and the PerfectScript members is usually the same.
Working in the VBA Editor
In most cases, the name of the class is the same as the name of the object. WordPerfect Office has a document object. The document object is the host application that is open. In Quattro Pro, the name of the document object is ThisNotebook. In WordPerfect, the name of the document object is ThisDocument. In Corel Presentations, the name of the document object is ThisSlideShow.
You can create a new object, such as a dialog box, which is known as a form. You can add controls, such as a check box or a text box. You can set the object's properties in the property dialog box located in the Visual Basic Editor. You can also set the object's properties at run time by programming a method. For example, you can color a form red when you click on it. For more information about setting an object's properties, see the Microsoft Visual Basic Help in the Visual Basic Editor.
An experienced programmer can work directly with the Windows API (Application Programming Interface) and, for example, be able to determine how much disk space is available or gain access to the system's time and date values. Most VBA users will want to automate specific and repetitive tasks.
Accessing an application from another application's macro
You can access and change an application from another application's macro. For example, you can create and use a Quattro Pro object from a WordPerfect VBA macro. This allows you to change and save a Quattro Pro document from a WordPerfect VBA macro.
Using VBA macros
You can store a VBA macro in the document by saving the document. Once you have saved the document, you can close and reopen the document and access the macro. After you have developed the macro, you should debug it. You can step through each macro line by line. This is a useful exercise to ensure that the macro will have the desired outcome. A project macro is not available if the document is closed. After you have debugged the macro, you can play the macro.
Assigning security
When you open WordPerfect Office documents created by other users, be aware that a document could contain a macro virus. As a screening measure, VBA includes a security mechanism to help manage document security. You determine the security level used when opening or loading documents and add-ins containing embedded VBA macros. The Security dialog box lets you review the assigned security level and your collection of trusted certificates. You can trust a certificate that you know comes from a reputable source. VBA developers can attach their digital signature to a macro that creates a certificate when the document is opened. That a document has a digital signature does not automatically ensure the document is free of viruses, so the onus is on you to find out if the developers scans for viruses before adding their certificate to your trusted sources.
There are three security level settings available: High, Medium and Low. With the High setting, you can open a signed VBA project from a trusted source with the macros enabled. Otherwise, the document is opened with the macros disabled. The default security setting is Medium. A Medium setting indicates that a warning displays if you try to load a VBA document that is not on your trusted source list. You can then choose to open the document with the macros enabled or disabled. The Low setting allows you to open all VBA projects without applying any security (which disables all virus protection).
If you want to create your own certificate (in situations where you do not have formal certification), you can run the seflcert.exe that installs with Visual Basic for Applications. For more information about Visual Basic for Applications security, open the Security dialog box (click Tools Visual Basic Security) and click the What's this Help.
Setting macro breakpoints
The following macro includes a loop that continuously increments a single cell called COUNTER.
counter 0
Is_done +COUNTER>=100
\m {LET counter,0}
again {; increment counter}
{LET counter,counter+1}~
{BRANCH again}
A pass count specifies the number of loops that occur before reaching a breakpoint. If you specify the cell containing {BRANCH again} as the first breakpoint and leave the pass count at 1, the macro stops at the {BRANCH} command each time it goes through the loop. When you click Go, the macro continues, incrementing the counter cell by one. In the top of the debugger window, the selector highlights the {BRANCH} command, indicating that it is the next command.
If you specified a pass count of 5 for the first breakpoint in the above example, then every time you click Go, five loops occur, and the counter increments from 0 to 5, to 10, and so on.
The cell Is_done contains a logical formula. Is_done is false (has a value of 0) until 100 or more loops occur. If this cell is specified as a conditional cell, the macro pauses when the counter reaches 100.
Example of a VBA project macro in Quattro Pro
1 Click Tools Visual Basic Visual Basic Editor.
2 In the Project Docker window double-click VBAProject (NoteBk) in the list of categories.
3 Click Insert User form.
4 Modify the form so that it resembles the following diagram:
5 Change the name of the TextBox control to NameBox as illustrated in the following list:
Command Button - CommandButton1
TextBox - NameBox
6 Double-click the CommandButton1 control to create a new method for the UserForm1 class, and type the following lines of code in the CommandButton1_Click method:
Private Sub CommandButton1_Click()
Dim myname, Msg As String
myname = NameBox
Msg = "Hello " & myname
MsgBox Msg
End
End Sub
This code responds to the event that occurs when the command button is clicked.
7 Open the Quattro Pro objects folder in the Project Docker window.
8 Double-click ThisNotebook.
9 Type the following lines of code in the Notebk1 editor window:
Public Sub ShowForm()
End Sub
This code will add a new method to the ThisDocument class.
10 Type the following line of code in the ShowForm method:
Public Sub ShowForm()
UserForm1.Show
End Sub
Note
If you declare ShowForm as a private method, you will not be able to run the macro from Quattro Pro.
Tip
You can change all of the control's attributes, including the name of the control, in the Properties docker window.
Example of a VBA macro that will manipulate a Quattro Pro document
In the following procedure, a Quattro Pro object, called myQp, will be created. This object will be used to create an inventory table in a Quattro Pro document.
For the purpose of this procedure, a simple inventory table was created in a Quattro Pro document. You can run this macro from WordPerfect. For testing purposes, make sure that Quattro Pro is open. For more information about VBA, see Microsoft Visual Basic Help in the Visual Basic Editor.
1 Open WordPerfect.
2 Click Tools Visual Basic Visual Basic Editor.
3 Double-click on Project (Document1) in the Project explorer Docker window.
4 Click Tools Reference.
5 Enable the Corel - QuattroPro 9 type library check box.
6 Click OK.
7 Open the WordPerfect objects folder in the Project explorer Docker window.
8 Double-click ThisDocument, and type the following line of code in the code module window:
Public Sub CreateQPTable()
End Sub
This code adds a new method to the ThisDocument class.
9 Type the following lines of code in the CreateQPTable method:
Public Sub CreateQPTable()
Dim myQp as Object
Set myQp = CreateObject("QuattroPro.PerfectScript")
If myQp Is Nothing Then
MsgBox "The Quattro Pro Object is invalid", vbCritical
End If
This code creates a Quattro Pro PerfectScript object. After the object is created, it is tested to determine if memory has been allocated to it. A message informs you if the object is invalid.
10 Type the following lines of code in the CreateQPTable method:
Public Sub CreateQPTable()
Dim myQp as Object
Set myQp = CreateObject("QuattroPro.PerfectScript")
If myQp Is Nothing Then
MsgBox "The Quattro Pro Object does not exist", vbCritical
End If
'Populate the Quattro Pro document
myQp.FileNew "FileNew"
myQp.SetCellString "B1", "Jan"
myQp.SetCellString "C1", "Feb"
myQp.SetCellString "D1", "Mar"
myQp.SetCellString "A2", "TVs"
myQp.SetCellString "A3", "VCRs"
myQp.SetCellString "A4", "Radios
End Sub
This code creates a new Quattro Pro document and creates an inventory table.
Notes
Make sure that CreateQPTable is declared public so that you can access this macro from WordPerfect.
Every application has an object. Make sure you reference the right object.
Example of using the PerfectScript class to change a Quattro Pro document
The PerfectScript class lets you automate specific and repetitive tasks. The members of the PerfectScript class are the product commands used in conjunction with the PerfectScript language. The following example creates a project macro.
In the following procedure, a new method, called AddInventory, is added to the ThisDocument class. This macro creates an inventory table, populates the table with specific values, and calculates the values. All PerfectScript class members can be accessed only by calling the PerfectScript object, which must be followed by a ".". You can call the FileSave method, which is a PerfectScript class member, by typing: "PerfectScript.FileSave".
1 Click Tools Visual Basic Visual Basic Editor.
2 In the Project explorer Docker window, double-click VBAProject (NoteBk1) Quattro Pro objects ThisNotebook in the list of categories.
3 Type the following lines of code in the Notebook1 code module window:
Public Sub AddInventory()
End Sub
This code adds a new method, called AddInventory, to the ThisDocument class.
4 Type the following lines of code to create a private method called CreateTable:
Private Sub CreateTable()
PerfectScript.SetCellString "B1", "Jan"
PerfectScript.SetCellString "C1", "Feb"
PerfectScript.SetCellString "D1", "Mar"
PerfectScript.SetCellString "A2", "TVs"
PerfectScript.SetCellString "A3", "VCRs"
PerfectScript.SetCellString "A4", "Radios"
End Sub
This code creates an inventory table.
5 Type the following lines of code to create a private method called AddValues:
Private Sub AddValues()
'Populate the January Column
PerfectScript.SelectBlock "B2"
PerfectScript.PutCell2 "200"
PerfectScript.SelectBlock "B3"
PerfectScript.PutCell2 "250"
PerfectScript.SelectBlock "B4"
PerfectScript.PutCell2 "350"
'Populate the February Column
PerfectScript.SelectBlock "C2"
PerfectScript.PutCell2 "100"
PerfectScript.SelectBlock "C3"
PerfectScript.PutCell2 "280"
PerfectScript.SelectBlock "C4"
PerfectScript.PutCell2 "340"
'Populate the March Column
PerfectScript.SelectBlock "D2"
PerfectScript.PutCell2 "150"
PerfectScript.SelectBlock "D3"
PerfectScript.PutCell2 "230"
PerfectScript.SelectBlock "D4"
PerfectScript.PutCell2 "490"
End Sub
This code adds numeric values to the inventory table.
6 Type the following lines of code to create a private method called CalculateValues:
Private Sub CalculateValues()
'Calculate the January totals
PerfectScript.SelectBlock "B2..B4"
PerfectScript.QuickFunction "SUM", "B5"
'Calculate the February totals
PerfectScript.SelectBlock "C2..C4"
PerfectScript.QuickFunction "SUM", "C5"
'Calculate the March totals
PerfectScript.SelectBlock "D2..D4"
PerfectScript.QuickFunction "SUM", "D5"
PerfectScript.SetCellString "A5", "Totals:"
End Sub
This code adds the values in each column.
7 Type the following lines of code in the AddInventory method to call the private methods:
Public Sub AddInventory()
CreateTable
AddValues
CalculateValues
End Sub
This code calls all of the private methods that you created.
Notes
If you declare AddInventory as a private method, you will not be able to run it from Quattro Pro.
You can access the private methods because you are working in the same class. It is not possible to access a private method from outside of the ThisDocument class.
Example of accessing the system's date and time values
In the following procedure, you have to create a new method called, ShowTime. Next, you will declare two new variables: myTime and myDate. You can use the return value of the Time method to populate the myTime variable. The variable myDate can be populated by the return value of the Date method. You will have to type-cast the two variables-myTime and myDate-into string values. The easiest way to accomplish this is to declare two new string variables: myStrDate and myStrTime. Use the Str method to convert the contents of myDate and myTime into strings. Display the contents of myStrDate and myStrTime in a Message Box.
The following example creates a project macro.
1 Click Tools Visual Basic Visual Basic Editor.
2 In the Project explorer Docker window, double-click VBAProject (NoteBk1) Quattro Pro objects ThisNotebook in the list of categories.
3 Type the following lines of code in the Notebook1 code module window:
Public Sub ShowTime()
End Sub
This code will add a new method to the ThisDocument class.
4 Type the following new code in the ShowTime method to declare two new variables:
Public Sub ShowTime()
Dim myTime
Dim myDate As Date
End Sub
5 Type the following new code in the ShowTime method to populate the myTime and the myDate variables:
Public Sub ShowTime()
Dim myTime
Dim myDate As Date
myTime = Time
myDate = Date
End Sub
6 Type the following new code in the ShowTime method to convert the two variables to string data types:
Public Sub ShowTime()
Dim myTime
Dim myDate As Date
myTime = Time
myDate = Date
Dim myStrTime, myStrDate, Msg As String
myStrDate = Str(myDate)
myStrTime = Str(myTime)
End Sub
7 Type the following new code in the ShowTime method to populate and display the Msg variable:
Public Sub ShowTime()
Dim myTime
Dim myDate As Date
myTime = Time
myDate = Date
Dim myStrTime, myStrDate, Msg As String
myStrDate = Str(myDate)
myStrTime = Str(myTime)
Msg = "The date is " & myStrDate & " and the time is " & myStrTime
MsgBox Msg
End Sub
Notes
Make sure that ShowTime is declared public so that you can access this macro from Quattro Pro.
For the purpose of this procedure, a Message Box was selected to display the date and time; however, you can create a new form and then display the time and date in this form. For more information about VBA, see Microsoft Visual Basic Help in the Visual Basic Editor.
Absolute and relative cell addresses
The following is an example of absolute and relative addressing:
Absolute: []A:A1..D10
Relative: []P(0):C(0)R(0)..C(4)R(10)
When you record with relative references, the macro records cells in relation to each other, rather than recording exact cell addresses. For example, the macro indicates two cells to the right of the selector, rather than a specific cell. The following example shows how to use absolute and relative cell referencing in macros:
Absolute: []$A:$A$1..$D$10
Relative: [][]A:A1..D10
Using relative references increases macro portability (letting you use a macro with different notebooks), but hinders readability, since it is harder to track which cells the macro affects. If macros use the spreadsheet function @CELLPOINTER frequently, you can try relative references.
Relative references specify cells as offset from the cell selector. For example, the cell selector's relative reference is []P(0):C(0)R(0).
Reference Result
([ ]) Specifies that you are referring to the active notebook
P(0): Indicates the number of spreadsheets from the selector (in this case, zero); it is optional (except when selecting an entire row or column)
C(0) Indicates the number of columns from the selector
R(0) Indicates the number of rows from the selector
The cell below the selector is []C(0)R(1), the cell to the right of it is []C(1)R(0), and the cell beneath the selector (on the next spreadsheet) is []P(1):C(0)R(0).
For more information about setting absolute and relative cell references, see "Setting cell addresses."
If [] does not precede a relative reference, the relative reference is offset from the cell containing the macro command, not the cell selector. For example, if {BLANK C(1)R(0)} were stored in A:A16, playing the macro would erase the cell to the right of it (A:B16).
You can precede a relative reference with a colon (:) to affect the same cell, but on the active sheet. For example, if {BLANK :C(1)R(0)} were stored in A:A16, playing it when sheet B is active would erase the cell B:B16.
You can omit C( ) or R( ) to select entire rows or columns. For example, {SELECTBLOCK []P(0):C(0)} selects the column containing the active cell; {SELECTBLOCK []P(0):R(0)} selects the row containing the active cell. To select the three columns to the right of the active cell, use {SELECTBLOCK []P(0):C(1), C(3)}.
Relative references can use negative or positive offsets. For example, if the selector is in cell A2, you could use []C(0)R(-1), C(2)R(1) to specify the cells A1, C3.
