Whenever you interact with Paradox, you generate either an Action or MenuAction constant. For example, when you select a menu item, a constant is sent to the built-in menuAction event. If the constant maps to an Action constant, an equivalent Action constant then is sent to the built-in action event. For example, when you select File | Print, the constant MenuFilePrint is sent to the form’s menuAction event. Since MenuFilePrint maps to the action constant DataPrint, DataPrint is sent to action. In the events action and menuAction, you can trap for nearly every user interaction. In addition, using the action() and menuAction() methods you can invoke or imitate nearly any user interaction by sending Action and MenuAction constants to the built-in action and menuAction events.

Both action() and postAction() performs a specified action. The difference is that action() executes the action right away and postAction() posts an action to an action queue for delayed execution. With postAction(), the action is posted to an action queue at the time of the method call; Paradox waits until a yield occurs—for example, by the current method completing execution or by a call to sleep(). This is an important distinction to keep in mind while executing actions from within your code.

These methods open up a whole bunch of commands. As an ObjectPAL programmer, you’re interested in five action constant classes: ActionDataCommands, ActionEditCommands, ActionFieldCommands, ActionMoveCommands, and ActionSelectCommands. Use these commands with the action() method. The syntax for action constants is as follows:

The constants in the ActionDataCommands category deal with data in a table as a whole, as shown here:

They are used for navigating the pointer in a table, locking a record, posting a record, toggling Edit mode, and positioning the record pointer. Following are three examples:

In general, the constants in the ActionEditCommands category are used for altering data within a field, as shown here:

With these constants, you can copy text to the Clipboard, enter persistent field view, access the help system, and search your text. Following are three examples:

The constants in the ActionFieldCommands category are used for moving between field objects, as shown here:

With these constants, you can invoke and control tab order. You can move the focus forward or backward in the tab order. You can ignore the tab order and move up, down, left, or right. You can even move from one table frame to another. Following are three examples:

The constants in the ActionMoveCommands category are used for positioning within a field object, as shown here:

With these constants, you can move to the beginning or end of a field, move left one word, or scroll a field up or down. In general, these commands behave differently in a Memo field than they do in a set of fields. Following are three examples:

The ActionSelectCommands constants are similar to the ActionMoveCommands constants, but you use them to select data within a field object, as shown here:

With these constants, you can select from the current position to the beginning of the document. Following are three examples:

Browse through the online constants section by selecting View | ObjectPAL Quick Lookup and selecting the Constants tab. Select the categories whose names start with action. These constants are your gateway to more powerful data manipulation and, therefore, to more powerful applications.

In addition to executing action constants, you can trap for them. The basic idea is to use the action event and inspect the eventInfo variable. For example, to trap for when the form enters Edit mode, type lines 3–6 in the page’s action event.

Another method in ObjectPAL that opens up a whole world of power is menuAction(). The menuAction() method enables you to execute any of the MenuCommand constants, shown next. Any time you want to execute or trap a menu-equivalent task, consider using the menuAction() method or menuAction event.

To display the Form Open dialog box, for example, add line 3 to the pushButton event of a button.

Just as you can trap for action constants, you can trap for MenuCommand constants. For example, to trap for the user pressing the Form Maximize button, add lines 3–5 to the menuAction event of a page.

The following table lists the action classes. As you can see, most action events do not bubble. In fact, only ActionDataCommands bubble. You can use eventInfo.actionClass() to return the class of an action event.

Sometimes it is necessary to identify a constant. Either you need to trap for it or you want to execute it. Either way, finding the action constant that maps to a specific task can be daunting. Using constantValueToName() enables you to extract the name of a constant from a number. The syntax for constantValueToName() is as follows:

constantValueToName ( const groupName String, const value AnyType,
var constName String ) Logical

This method is very helpful in developing an application when you want to know which actions are being triggered. The one weakness of this method is that you have to specify the group type. For example, you have to specify ActionDataCommand, ActionMoveCommand, Error, and so on.

The following code snippet from http://prestwood.com/forums/paradox/books/official/files/ID_Actions.fsl demonstrates how to extract the name of an action or error constant from eventInfo, as shown next. For demonstration purposes, this code is called from the action event of the form; this code displays every action generated and every error generated. It uses actionClass() to extract the class of action constant. It also demonstrates using a list object to scroll values. It uses a private custom procedure, which helps make it structured. (For more on structured programming, refer to Appendix A.)

You can follow the actions I took in the illustration above. I first tried to insert a record and couldn’t because I wasn’t in Edit mode. This generated a peNotInEditMode error. I then toggled into Edit mode, moved to the Customer No field, entered a number, moved to the Name field and pasted a name in. Read through the code and see whether you can follow the logic; start from the method prototype line.

The following code calls the custom method. Notice that doDefault is called before eventInfo is passed to the custom method.

You might want to put a variation of the preceding custom method into your standard library—perhaps alter it to return the action constant. After you do this, you can use it from time to time when you code to determine an action constant name that is giving you problems.

To manipulate the font attributes and text of a Memo field use the action() method. The basic technique is to pass the action() method an action constant:

object.action( ActionConstant )

For example, the following selects all the text in a Memo field:

To time stamp and add a note to the end of a Memo field, use lines 3–7.

To time stamp and add a note to the beginning of the Memo field, use lines 3–8.

Steps for using the MenuID form:

1. Select a menu option to generate a menu constant.
2. Put the constant or number in the MenuAction field (the constant is always preferred). You can just click on the constant displayed below the Execute Menu Constant button.
3. Press the button to make sure it works.

The interesting bit of code is in the page’s menuAction event and in the pushButton event of the button. The following is the code in menuAction that traps the menu constants:

The following is the code in the pushButton event of the button that uses a try block to first try to execute a MenuCommand number and then uses a constant.