Section 9: Input Processes
Input Processes
Item 9.1
Bug (fixed in APPX 3.0 Beta): In APPX 1.8.4, fields with Modifiable flag blank are never modifiable. They are supposed to be modifiable in Initial Setup or Recovery Processing but not in Live Operations. Fields with Type 4 (Setup) in SP2 are converted with the Modifiable flag set to blank and thus are not modifiable. If this bug has not been fixed, add commands to control input and set 'Modifiable?' to "Y".
Item 9.2
Bug (flagged in V05): In APPX 1.8.4 (thru APPX 3.0.0), if the Modifiable flag for an alternate key field is blank, the field is not open for input during key entry. Key entry can be allowed by setting this flag to "N". (Warning: In APPX 1.8.4, primary keys with Modifiable? "N" are not open for input in key entry but they are in 3.0.) The V05 conversion log will flag SP2 screen items with type="4" (Setup) which may be converted with Modifiable flag blank. If the field is an alternate key, set Modifiable flag to "N" in APPX.
Item 9.3
Bug (fixed in APPX 3.0 Beta): In APPX 1.8.4, commands referencing screen items with appearance numbers do not always work properly. For instance, OK INPUT and NO INPUT do not work right. For some operations the problem is caused by APPX always using appearance #1. Sometimes the use of a constant other than 1 as appearance number causes a compile error (for example, DISPLAY on appearance #2). (See item 8.25 & 10.3.)
Item 9.4
Bug (FYI): In APPX 1.8.4, Pre-Display is not executed upon return from invoking an optional or automatic child process on the same file as the PCF. (Verify, Pre-PCF Update, and Post PCF Update event points are executed before invoking the optional child and Post PCF Read* and Post Child Completion are executed upon return from the child.) This means that commands must be used in Post Child Completion to force redisplay of any common fields. This bug does not affect conversions.
*In INQUIRE mode in APPX 1.8.4, Post PCF Read is not executed upon return from the child and the record is not reread (whereas they are in CHANGE mode). This bug also does not affect conversions.
Item 9.5
Bug (fixed in APPX 3.0 Beta): In APPX 1.8.4 in a two-level input, Pre-Display (i.e., Start of Image) is executed once for each entry level in DATA ADDITION at the higher level and ENTRY LEVEL is incremented properly. However, Pre-Display is executed only once in DATA ADDITION at the lower level and ENTRY LEVEL is always 1. Warning: Since ENTRY LEVEL does not work at the lower level, it may be necessary to define all fields at entry level 1 and use code to control processing (see items 8.20, 9.9, 9.10, and 9.11 too).
Item 9.6
Bug (all lower level processes flagged in V05): In APPX 1.8.4 (thru APPX 3.0.0) in a two-level input, the PDF fields ERRORS and WARNINGS are not reset to zero when dropping to the lower level. This can cause strange behavior on the first line item when an error/warning was encountered on the header record. To avoid this, add the following code to Start of Process for the automatic child process:
SET --- ERRORS = SET --- WARNINGS =
Item 9.7
Bug (FYI): In APPX 1.8.4, if a child input process is constrained on primary key to a single record and it uses a scrolling frame, APPX returns the next record (not the record requested). This bug does not affect conversions.
Item 9.8
Difference (secondary entry 'type 2' fields flagged in V05): In the lower level process of a multi-level function, APPX 3.0 does not honor image commands for a field (such as BLANK, BLINK, BRIGHT, DIM, DISPLAY, NO INPUT, OK INPUT, POSITION) until ENTRY LEVEL reaches the entry level of the field. For instance, contrary to SP2, APPX will not honor a DISPLAY on an entry level 2 field when executing Pre-Display/Verify after initial entry. ENTRY LEVEL does not become 2 until just prior to executing Pre-Display for secondary entry. However, if the entry level 2 field has Auto-Display '1' and a value is set during Pre-Display/Verify, it is displayed when entry level reaches 2 unless BLANK'ed in Pre-Display for that level. Caution: If entry level 2 fields exist, APPX treats non-PCF fields as entry level 2 even though they are defined as entry level 1. Since PCF fields are converted to have Auto-Display '1' but non-PCF fields are converted to have Auto-Display '0', it takes an extra RETURN for values set into non-PCF fields to be displayed in a lower level process. If the non-PCF field is non-modifiable, add code to Pre-Display to display the field IF --- INTERACTIVE PHASE EQ DATA ADDITION AND --- ENTRY LEVEL GE 2. Note that Auto-Display is normally changed to '1' for modifiable non-PCF fields per item 9.48 so they are OK. However, do not change Auto-Display to '1' for non-modifiable non-PCF fields since this causes other differences in behavior. (See items 9.14, 9.22, 9.27, 9.46, & 9.48 too.)
Item 9.9
Bug?/Feature (all 'repeating' windows flagged in V05): APPX 2.3 does not reset ENTRY LEVEL to 1 for a repeating frame when the frame repeats in DATA ADDITION. (See items 8.20, 9.10, and 9.11 too.)
Item 9.10
Difference (flagged in V05): ENTRY LEVEL in APPX pertains only to DATA ADDITION and is undefined and hence unreliable in DATA MODIFICATION, unlike SP2 where (ENTRY) was always 2 in CHANGE mode. To check for the equivalent of SP2 secondary entry, code as follows in APPX: (Addressed by item 8.20; see items 9.9 and 9.11 too).
IF --- ENTRY LEVEL GE 2 AND --- INTERACTIVE PHASE EQ DATA ADDITION OR --- INTERACTIVE PHASE EQ DATA MODIFICATION OR --- INTERACTIVE PHASE EQ DATA INQUIRE
Item 9.11
Difference (all 'repeating' windows flagged in V05): In ADD mode APPX executes Select Image and Pre-Display once for each ENTRY LEVEL whereas SP2 just executes them once. In an attempt to provide compatibility, the conversion program inserts the following code at the beginning of each routine: (See items 8.20, 9.9, and 9.10.)
IF --- INTERACTIVE PHASE EQ DATA ADDITION
AND --- ENTRY LEVEL GT 1
T END
For a repeating frame, however, this code can cause problems given the (item 9.9) behavior of APPX 2.3 which does not reset ENTRY LEVEL to 1 when the frame repeats. This means you would exit before reaching any code to change or reset ALTERNATE IMAGE NUMBER, possibly causing an endless loop. It also means only the first frame execution would have initial entry. (APPX 2.3 does retain the ALTERNATE IMAGE NUMBER so there is no harm done by exiting for a non-repeating frame.)
A more remote problem relates to the unreliability of ENTRY LEVEL in DATA MODIFICATION. Since APPX executes once per ENTRY LEVEL, these routines could be re-executed in DATA MODIFICATION if ENTRY LEVEL happened to get changed. Code like 8.20 if needed to protect against that.
Item 9.12
Action/Difference (all lower level processes flagged in V05; combined event points partially flagged in V05): In APPX there is only one set of process level event points (Set Run-Time Defaults, Post PCF Read, Pre-PCF Update, and Post PCF Update) whereas in SP2 there may be multiple event points for each depending upon the number and nature of windows defined for the current level file. Remember, in SP2, Post Load executes on the first standard window of a file level whereas Pre-Save and Post Save execute on the last standard window of a file level. (See item 9.42 for separate problem regarding Set Default Values.)
Warning: The conversion program combines this code together into the corresponding event point in APPX; such code should be carefully reviewed in multi-frame processes. The conversion program may not flag code that was combined when one event point had no code even though the code may behave differently.
For example, in SP2, if a multi-level function has header window(s), line item window(s), and trailer window(s), the equivalent set of process level event points exists separately for header, line item, and footer windows. In APPX, there is only one set for the higher level file which combines code from the SP2 header and footer windows and a line item set in a different process for the lower level file (the automatic child).
To adjust for this situation, determine if there is code that needs to be conditionally executed in any of these event points. If so, create another process for the higher level file and call it as an automatic child (preferred method). Note that MODE will never be ADD and INTERACTIVE PHASE will never be DATA ADDITION for the child so beware of SP2 code testing (MODE)! Also, beware of any code setting PCF values in Post PCF Read at the higher level since this event point will be executed 3 times, once at the higher level and once when returning from each child. If PCF values are changed, the record will be rewritten. (See item 9.44 too.)
Another less preferred method (assuming there is just one automatic child and no other complicating factors) is do the following:
Create a one-digit numeric work field named WORK PROC LEVEL.
In Start of Process for parent,
SET aaa WORK PROC LEVEL = 0
In Start of Frame for first header frame for parent,
SET aaa WORK PROC LEVEL = 0
In Start of Frame for first footer frame for parent,
SET aaa WORK PROC LEVEL = 2
In Set Run-Time Defaults for parent, test for footer frame by
IF aaa WORK PROC LEVEL EQ 1
In Post PCF Read for parent, test for footer frame by
IF aaa WORK PROC LEVEL EQ 1
In Pre-PCF Update for parent, test for footer frame by
IF aaa WORK PROC LEVEL EQ 2
In Post PCF Update for parent, test for footer frame by
IF aaa WORK PROC LEVEL EQ 2
In End of Process for automatic child
SET aaa WORK PROC LEVEL = 1
IF --- OPTION EQ PREVIOUS ACTIVITY
T SET aaa WORK PROC LEVEL = 0
Item 9.13
Difference (fixed in APPX 3.0 Beta): SP2 allows input during key entry on display type fields (this technique is often used in SP2 for change-only inputs to protect the primary key). For APPX 1.8.4 to allow input, a primary key must have Modifiable? "Y" although an alternate key can have Modifiable? "Y" or "N". Add NO INPUT commands to protect the primary key and change the flag to "Y".
Item 9.14
Difference (flagged in V05): APPX differs from SP2 in regard to image commands in non-image event points. In APPX, these commands (BLANK, BLINK, BRIGHT, DIM, DISPLAY, NO INPUT, OK INPUT, POSITION) have no effect on the image and must be moved to image event points to behave like SP2. (APPX image event points are Pre-Display, Pre-Display/Verify, Option Intercept, and Verify). Such commands are flagged on the Commands conversion log. Warning: When moving commands from Post PCF Read to Pre-Display, commands should be conditional on INTERACTIVE PHASE NE DATA ADDITION. Normally, DISPLAY commands in Set Run-Time Defaults and Post PCF Read need only be deleted as long as the item has Auto-Display '1' (Current Value) on the image. Non-PCF fields are converted to have Auto-Display '0'=None. See comments in item 9.48 before changing any non-PCF fields to Auto-Display '1'. (See items 9.8, 9.25, 9.46, & 9.48.)
Item 9.15
Difference (flagged in V05): APPX handles the cursor option of the POSITION command differently than SP2. For example, the placement of the cursor will be one position to the left on the screen in SP2 than it will be in APPX for the same CURSOR COLUMN. (See item 8.18.)
Item 9.16
Difference (flagged in V05): APPX differs from SP2 in regard to exiting from a lower level. SP2 will exit the input function upon use of PF16 from a lower level whereas APPX will return to the higher level upon use of END from a lower level. Both PF13 Next Section and PF16 End in SP2 were converted to END in APPX. The conversion program flags the use of PF13 and PF16 for inspection. Check usage to see if this difference matters. (See item 2.14.)
For standard TOM transaction entry programs, modify code in Option Intercept of the detail image for the lower level process to read as follows:
IF --- OPTION EQ PREVIOUS ACTIVITY
T ERROR Program Function Key Not Allowed
IF --- OPTION EQ END
T SET --- OPTION = CANCEL
Item 9.17
Difference (all one-record input processes flagged in V05): APPX differs from SP2 in regard to exiting from input on a one-record job file. SP2 would not allow PF16; the operator had to press RETURN or use PF32 to cancel the job. APPX allows the use of END and will continue the job even though the record was not saved. For one-record job files (not one-record permanent files), insert the following code in Option Intercept for the image):
IF --- OPTION EQ END T SET --- OPTION = CANCEL
Item 9.18
Difference (all sequence numbers and/or auto-incrementing flagged in V05): APPX 1.8.4 differs from SP2 in regard to the handling of auto-sequence numbers for a key field. In SP2, the new sequence number is available in Set Default Values. In APPX, it has not yet been assigned and thus is not available in Set Run-Time Defaults. This can cause problems if code exists which tests for specific values or which modifies the sequence number. Move the appropriate code to Pre-Display but remember to test for INTERACTIVE PHASE and ENTRY LEVEL. To list items with automatic sequencing, run the APPX Software, Inc. UTL CS utility "APPX ITEM File List" and enter "Y" to both 'Print DV?' and 'Check for Auto-Sequencing?'.
In the case of the standard TOM applications, this situation also causes a problem. Most transaction entry programs use auto-sequencing on trx number but also default the trx number from a higher level file in Set Default Values. In APPX the auto-incrementing takes place after Set Run-Time Defaults is executed and ignores the programmatic defaulting. To correct the problem:
In the Data Dictionary:
Set the field Default Value to 0001 for the higher level file
(e.g., CPA TIMETRX1 NEXT TRX NO)
In the input process for the lower level file:
Remove the field Auto-Increment factor, set Save As Default? "N", and
set Override DD? "N" for the trx number field on the input screen
(e.g., CPA TIMETRX2 TRANS NO)
Modify the code in Set Run-Time Defaults similar to the following:
IF --- INTERACTIVE PHASE EQ DATA ADDITION
[T SET CPA TIMETRX2 TRANS NO = CPA TIMETRX1 NEXT TRX NO]
Item 9.19
Difference (FYI): In SP2, WARNING/ERROR messages are not issued in CHANGE mode until the operator presses RETURN on a screen. In APPX 1.8.4, they are presented with the initial display of the screen. This can sometimes result in bogus messages. To avoid this, move the code to the Verify event point.
Item 9.20
Difference (FYI): APPX may not always position the cursor in the same manner as SP2 at runtime. For example, SP2 positions the cursor on the field for the first ERROR condition encountered; APPX 1.8.4 positions it for the last ERROR.
Also, if a key field is key protected, SP2 automatically positions the cursor on the next field; APPX 3.0.0 positions the cursor on the key field which is bright even though it is not modifiable (any characters entered overwrite the next field).
Item 9.21
Difference (all display-only windows flagged in V05): APPX may differ from SP2 in the behavior of a display-only window. APPX 2.3 does not honor setting OPTION in Pre-Display of a display-only window. Move this code to Pre-Display of the detail frame.
Also, SP2 executes Access/Verify and Pre-Display in all modes; APPX 2.3 executes Pre-Display/Verify and Pre-Display in all modes except it does not execute Pre-Display/Verify in ADD mode (this may or may not be fixed in APPX 3.0). APPX 3.0 does not execute Pre-Display/Verify (or Verify) in interactive phase DATA ADDITION.
Item 9.22
Difference (all lower level processes flagged in V05): APPX 1.8.4 does not always display higher level fields that were automatically displayed in SP2. For example, it may be necessary to change entry level to 0 in order to automatically display higher level fields in a lower level display-only or detail frame. Remember entry level 0 denotes that an item is always displayable; if it is modifiable, it is always editable too. (See items 9.8, 9.14, 9.21, & 9.27 too.)
Item 9.23
Bug (somewhat fixed in APPX 3.0.0) (flagged in V05): SP2 allows repeating alternate windows to have different sizes. In APPX 1.8.4 alternate images must have the same size for repeating frames. In any case, scrolling alternates behave differently in APPX when they are different sizes. (See items 1.63 & 10.26.)
Item 9.24
Difference: APPX presents zeros in a numeric field at initial entry (unless 'Blank if Zero?'=Y") whereas SP2 always presents blanks. This is not practical to address. However, in the event it is necessary to emulate SP2, set 'Blank if Zero?'="Y" if possible; otherwise, add code in Pre-Display such as:
IF --- INTERACTIVE PHASE EQ DATA ADDITION
AND --- ENTRY LEVEL EQ 1
AND aaa numeric field EQ
T BLANK aaa numeric field
Item 9.25
Difference (flagged in V05): In SP2, OK INPUT can be used to make a work field defined as Type 3 (Display) modifiable. In APPX, OK INPUT only works on a work field which is modifiable and a display-only field is converted to Modifiable? "N". (Both SP2 and APPX will not honor OK INPUT on a PCF field which is not modifiable.) (See items 9.8, 9.14, & 9.46 too.)
Item 9.26
Bug/Difference (flagged in V05): APPX 2.3 (thru 3.0.0) differs from SP2 in its handling of ALTERNATE IMAGE NUMBER. (See item 8.23.)
Item 9.27
Difference (flagged in V05): When there are entry level 2 fields defined on the screen, a user may have to press RETURN an additional time when adding a record in APPX compared to SP2. This should only be a problem in lower level processes. (See items 9.8, 9.14, & 9.22 too.)
Example: In SP2, on the CPA Time Cards trx entry input screen, the account number field is defined as type '2'=Secondary with Auto Access and the account description field is type '3'=Display with Auto-Display '1'=Yes. Then in SP2 Access/Verify there is code to default the account number and display the description, both of which appear on the screen at secondary entry.
In APPX the account description field on the screen is converted to Entry Level '1' with Auto-Display '2'=Lookup. However, the DISPLAY command in Pre-Display/Verify is not honored and only the default account number appears on the screen at secondary entry. Account description only appears after the operator presses RETURN again. To eliminate the extra RETURN, the field must be defined as Auto-Display '0'=None or '1'=Current Value.
Comment: This situation appears to be an example, where entry level 2 fields are defined, of APPX treating a non-PCF field as secondary entry (see item 9.8). Note that no extra RETURN is involved in another situation where all fields are entry level 1 and both account and description are defaulted and displayed in Pre-Display; this works fine.
Item 9.28
Conversion Bug: The conversion utility may convert Data Lookup Type wrong (for example, as CONTINUE when it should be DEFINE). This will cause a compile error.
Item 9.29
Conversion Bug?/Difference (FYI) (signed numeric fields): In SP2 inputs, zero signed numeric fields with decimals display with a leading zero (e.g., 0.00) and negative signed numeric fields display with a leading sign (e.g., -5). In APPX inputs, unless a mask is defined, such fields display without the leading zero (e.g., .00) and with a trailing sign (e.g., 5-). The conversion utility only generates a mask for a signed field in an input if it is zero-filled. This is normally not a problem. (See items 2.11 & 9.30.)
Item 9.30
Conversion Bug?/Difference (unsigned numeric fields): In SP2 inputs, zero unsigned numeric fields with decimals display with a leading zero (e.g., 0.00). Negative unsigned numeric fields display with a leading sign if there is room (e.g., -5); question marks are displayed only if there is not room for the sign in SP2. However, in APPX inputs, since the conversion utility generates a mask with no sign for an unsigned numeric field (e.g., 90), zero fields will display properly but negative values may cause questions marks in APPX where they would not in SP2. (See items 4.24 & 5.12; see items 2.11 & 9.29 too.)
Item 9.31
Difference (flagged in V05): In a SP2 multi-level input, the Initial Access Key for the lower level could be different from the Binding Key without affecting response time. When converted, the SP2 Binding Key becomes the Child PCF Field on the Child Constraint for the Automatic Child and the SP2 Initial Access Key, if specified, becomes either the Default PCF Key in AA for the Automatic Child or the Default PCF Key in the input process created for the automatic child. (Note that the one specified in AA overrides; if none are specified, the primary key is used.) However, if left as converted in APPX, response time may be measured in minutes because APPX must read the entire child PCF file in order to find the records constrained. Since such response will not be acceptable to most users, one alternative is to add an alternate key to the child PCF file which can then be used both in the constraint and as the Default PCF Key.
For example, suppose LEVEL1 file has SSN# as primary key while LEVEL2 file has SSN#/Seq# as primary key and Date/Time Added as an alternate key. If the SP2 input has SSN#/Seq# as the Binding Key with Date/Time Added as the Initial Access Key, add a new alternate key for SSN#/Date/Time Added to LEVEL2 file in APPX. Specify the new key in the constraint and as the Default PCF Key.
Item 9.32
Bug?/Difference (flagged in V05): In SP2, setting (PF KEY) is only valid in Pre-Display and PF Key Intercept but if (PF KEY) is set by commands in Access/Verify, it is initially ignored and then cleared so there is no consequence. In APPX, however, if OPTION is set by commands in Pre-Display/Verify (which is how it converts), it is initially ignored but not ever cleared so it can ultimately change behavior. If found in Access/Verify, delete corresponding code in APPX. (See item 2.14.)
Item 9.33
Bug/Difference: APPX 3.0.0 has some difficulty handling ERROR commands in Post PCF Read compared to SP2 with ERROR commands in Post Load. In SP2 the normal screen is displayed but with no data other than the key entered and the ERROR message. In APPX the key entry screen is displayed with the ERROR message but without the key value. If it happens on a scrolling record, the APPX screen does not display properly. This condition is not practical to address.
Note that WARNING commands are handled properly. If a WARNING is encountered, the record is returned with the WARNING message displayed; the operator may then press RETURN to go on to the next screen, if any.
Item 9.34
Difference (flagged in V05): Since "PF" terminology is not applicable in APPX, modify "PF" text as appropriate. Other SP2 terminology (SPEED and EXPLAIN) is also flagged in V05 after 08/27/96.
Item 9.35
Difference (flagged in V05): SP2 uses PF keys while APPX uses OPTION or other named keys. The conversion utility converts (PF KEY) references to OPTION and flags most situations that are in doubt. However, it is wise to check (PF KEY) conversion in Option Intercept since the log may not catch everything. The V05 conversion log warns to inspect whenever code exists in 'PF Key Intercept' command series. (See item 2.14.)
For example, if the SP2 code was checking for (PF KEY) GT 24, modify code in Option Intercept to read as follows:
IF --- OPTION EQ DIRECT PROCESS 1 OR --- OPTION EQ DIRECT PROCESS 2 OR --- OPTION EQ HELP ITEM OR --- OPTION EQ PRINT SCREEN OR --- OPTION EQ CANCEL
Item 9.36
Difference (flagged in V05): SP2 allows 79 characters for Default Value and Edit Mask whereas APPX only allows 60 characters. If necessary, add commands to edit the field in input processes allowing field entry. Also, if needed, add commands to set default values longer than 60 bytes. (See item 2.16.)
Item 9.37
Difference (all 'Set Default Value' command series flagged in V05): SP2 and APPX handle default values differently in some instances. In SP2, a SET command in Set Default Values will modify the default record buffer whereas a SET command in Set Run-Time Defaults in APPX will not. This may cause different behavior if the SET is conditional and there is no 'Save as Default'.
Also, SP2 will preserve default values modified at a lower level via 'Save as Default' across higher levels whereas APPX will not. For example, in APPX, defaults established via 'Save as Default' for order line items are honored for the current order but are reset from the Data Dictionary when the lower level line item process is called for the next order. (This is due to the nature of SP2 and APPX; SP2 handles higher/lower level file processing within a single function while APPX has a separate process for each file.)
Item 9.38
Difference (all 'Set Default Value' command series flagged in V05): In SP2 you may RESTORE the entire record in Set Default Values but only DISPLAY selected fields for default purposes. In APPX, you should only RESTORE individual fields as needed.
Item 9.39
Bug (all scrolling windows flagged in V05): In APPX 3.0.0, at runtime in a scrolling first-level file maintenance function with 'Read-First?'="N", if you switch from INQUIRE mode to DELETE, you will get "Error - No Record Currently Held" after pressing ACKNOWLEDGE DELETE. You can avoid this error by setting 'Read-First?'="Y".
To emulate SP2 behavior, the conversion utility sets 'Read-First?' to "N" on first-level functions and to "Y" on lower-level functions.
Item 9.40
Bug (flagged in V05): Mod Log does not work in APPX if the input process is invoked as RELATED. Inputs are normally invoked as RELATED from a job step but invoked as DETACHED from a menu item. A good work-around is to run the input from a menu as a DETACHED process or from the job as SUBPROCESS or DETACHED. By the way, Mod Log does work when a default input process is invoked by a user during SCAN. The conversion log flags the use of Mod Log.
Item 9.41
Difference: SP2 allows higher level components of the key to be modifiable at a lower level (although it is not wise to do so). APPX does not since constraints by definition cannot be modified.
Item 9.42
Difference/Conversion EH (all 'Set Default Value' command series flagged in V05): In SP2 there can be a different Set Default Values command series executed for each alternate window whereas in APPX there cannot. The Set Run-Time Defaults event point is defined at the frame level in APPX. The conversion log attempts to flag combined event points but it does not catch them all. Currently, it does not directly flag Set Default Value commands found on alternate windows > 1. The conversion utility will combine the code but the code must be modified to make it conditional based on the conditions used in the SP2 Set Alternate No. command series.
Item 9.43
Difference (FYI): In CHANGE mode, screen edits do not get executed in SP2 unless something is changed. They get executed in APPX even if nothing is changed.
Item 9.44
Bug: APPX 3.0 does not always initialize INCLUDE CHILDREN at 1. If any automatic child of an input is optional, add code to set INCLUDE CHILDREN to 1 at the beginning of Pre-Invocation for each child. Consider this when converting a SP2 footer window to be another automatic child. (See item 9.12.)
Item 9.45
Difference (compile error): A valid SP2 auto-access can cause a compile error ("Invalid Data Lookup specifications - Source Missing" in APPX 3.0 and 3.1. It seems to occur when the number of key segments in the DLU key exceeds the number of key segments in the file key. This can affect input, output, and inquiry processes. The only work-around is to remove the DLU from the image and program the equivalent functionality as detailed in the following paragraphs.
For an overview of DLU items, run the APPX Software, Inc. UTL CS utility "APPX ITEM File List" and enter 'Check for DLU?'="Y". To see lookup items too, also enter 'Lookup?'="Y" (note that the checks for DLU or Lookup are the only checks combined with an OR; the rest use AND). To list items for a single process, enter the process name. (See items 1.52 & 10.28.)
For input processes, do the following (see item 10.28 for output/inquiry processes):
- For all components of the key on the image, change the Data Lookup Type to NONE. Be sure to make note of DLU specifications (whether the file must exist, action if NOF, etc.) and the entry level for the key.
- For all associated lookup fields on the image, change the Auto-Display to 0 (None) and make note of lookup value (null or ?'s) if NOF.
- Add code in Pre-Display/Verify to do the DLU read (consider entry level), issue error/warning and set lookup values as appropriate on F condition, and display lookup fields.
- Add code in Option Intercept as follows:
IF --- OPTION EQ SCAN T AT FIELD <each component of key> TT SCAN <each component of key or group header>
Repeat the AT FIELD/SCAN code for each component of the key on the image.
Note that in SP2, if a user uses PF2 Find Key to retrieve a multi-part key defined with Auto Access, all components of the key are returned. Also, both Auto Access and READ appear to leave the record buffer in the same status on an unsuccessful read (the key fields retain their value from the read while non-key fields have the same values they had prior to the read).
Item 9.46
Action?/Difference/Conversion EH?: In SP2, executing OK INPUT or NO INPUT (and possibly other image commands as well) would force the screen to be re-displayed even though nothing else had changed. In APPX, it doesn't. The conversion log does not flag image commands found in valid image event points. To list such commands, run the APPX Software, Inc. UTL CS utility "APPX STMT 'Format 6' List" and enter the desired op codes. Additionally, record selections can be entered to select certain event points. Image event points are 41-44 (see Section 16 for complete list of event points). (See items 9.8, 9.14, & 9.25 too.)
It may not be practical to address this problem until it is reported by users. However, one solution is to put the OK INPUT/NO INPUT in Option Intercept and set --- OPTION to blanks. This will force the image to be redisplayed immediately without executing other event points (similar to the SP2 technique of setting PF KEY to some unused value such as 17, etc.).
Item 9.47
Bug?/Difference (all 'Set Default Values' command series flagged in V05): APPX may not behave like SP2 if a value is set into a key field in Set Run-Time Defaults. For example, if SP2 Set Default Values executes a SET DATE on a date/time stamp key field with no DISPLAY command and with 'Save as Default?'="N", the default is displayed in ADD mode but not in key entry. In APPX the default is always displayed. To emulate SP2, add code to only set the default if INTERACTIVE PHASE EQ DATA ADDITION. Note that this problem may affect any type of key field.
Item 9.48
Action/Bug/Difference/Conversion EH? (modifiable non-PCF fields flagged in V05 after 08/27/96): The conversion utility converts non-PCF fields as Auto-Display '0' but this may cause APPX to behave differently than SP2 when the non-PCF field is modifiable. For modifiable non-PCF fields, change Auto-Display to '1' and add code in Set Run-Time Defaults to clear any of these fields that have no default value and 'Save as Default?'="N". Do not clear modifiable non-PCF fields that have a default value or that have 'Save as Default?'="Y". CAUTION: Make note to test the function if the modifiable non-PCF field is used as the default key field for a consecutive file (same as initial access key in SP2); this behavior is unknown. (See item 9.8.)
This fix has one known difference for modifiable non-PCF fields not being specifically set in Set Run-Time Defaults. If the modifiable non-PCF field is being changed in Option Intercept and there is no DISPLAY command, neither SP2 nor APPX show the changed value when the screen is redisplayed but APPX does use the changed value as the default value for subsequent records whereas SP2 does not. If there is a DISPLAY command, both SP2 and APPX redisplay the screen with the changed value. The conversion log flags PF Key Intercept command series.
Changing Auto-Display to '1' will also overcome an APPX bug for modifiable non-PCF date fields. If a modifiable non-PCF date field has Auto-Display '0' and there is no DISPLAY command, APPX presents blanks in the display rather than the normal date mask and will not accept input for the date (it gives an invalid date error even though the date entered is valid).
To list modifiable non-PCF fields, run the APPX Software, Inc. UTL CS utility "APPX ITEM File List" and enter 'Check for Modifiable?'="Y", 'Check for Non-PCF Item?'="Y", and 'Print DV?'="Y". If non-standard field names are used and you want to identify the files they belong to, run the APPX Software, Inc. UTL CS utility "APPX FIELD File Col Hdg List".
Item 9.49
Difference (all sequence numbers and/or auto-incrementing flagged in V05) (compile error): SP2 allows a non-key field to be defined as a sequence number with an increment value (contrary to what the manual says) although it probably ignores it. APPX gets a compile error if a non-key field has an auto-increment value. Remove the auto-increment value and flag the process.