You are here: APPX Wiki>APPX Web>APPX41xReleaseNotes (08 Oct 2026, AdminUser)Edit Attach

APPX 4.1 release notes

Release notes for APPX 4.1.0 through 4.1.b, newest first. They were published on www.appx.com and moved here in October 2026. To move between releases, see Upgrade paths. Every release is listed in the Release history.

Releases on this page

APPX 4.1 release notes

APPX 4.1.b

The APPX 4.1.b Patch Release addresses the following items:

Enhancement: Support for DISAM added
Bug #810: CISAM/DISAM restructure fails across file systems
Bug #863: In CISAM/DISAM, REWRITE returns T but doesn't really rewrite
Bug #906: Mod logs don't display occurrences correctly
Bug #907: Mod logs show deleted record values in wrong column
Bug #934: Constrained Read silently skips records
ECR #6844: SQL Restructure unreliable
ECR #6905: (Enhancement) Enable large file support on Linux

Enhancement: Support for DISAM added

Support for the DISAM file system has been added as a valid Data Access Method Interface in APPX.

Bug #810: CISAM/DISAM restructure fails across file systems

If you restructured a CISAM (or DISAM) file located in a different file system than the restructure work directory (Newdata), then the restructure indicated that it ran successfully but the file will be missing.
This has been fixed.

Bug #863: In CISAM/DISAM, REWRITE statement returns T but doesn't really rewrite

In CISAM (or DISAM) files, REWRITE of PCF record in 'footer' frame of update process returned a T indicating success but the record was not really rewritten.
This has been fixed.

Bug #906: Mod logs don't display occurrences correctly

If the PCF for a process contained any multi-occurrence fields, the modification log entries for a CHANGE operation were incorrect. The mod log seemed to skip every other occurrence, and the values shown were associated with the wrong occurrence numbers.
This has been fixed.

Bug #907: Mod logs show deleted record values in wrong column

The modification log entries generated for a DELETE showed the PCF values in the 'New' column instead of in the 'Old' column.
This has been fixed.

Bug #934: Constrained Read silently skips records

NOTE: This was originally reported as just a problem with BEG READ/END READ, but in fact it happened with any kind of child constraint.
If task 'A' had a hold on a record in file 1 (but not the first record) and task 'B' was doing a constrained Read with Hold on the same file (e.g., an UPDATE with child constraints), the record held by the other task would be completely skipped by the Read, with no warning, error or held condition indicated.
This has been fixed.

ECR #6844: SQL Restructure unreliable

Tables stored in SQL Server 7.0 or SQL Server 2000 could not be reliably restructured. Parts of the restructure succeeded, but often the original table had been dropped and the contents were store in the temporary table.
This has been fixed.

ECR #6905: (Enhancement) Enable large file support on Linux

This has been enabled.

APPX 4.1.a

Run-time

( #2824 ) An input process that did not have a PCF could not be run in Recovery Processing. If the process or any other process in its process family requested a modification log, an error message ("can't locate pcf cap") would appear. This has been corrected so that an input process without a PCF can now run in recovery processing.

( #4604 ) APPX will now only attempt to lookup and display user IDs for record locks if the track locks FMS control is set for the file.

( #5680 ) When a record was locked, user was getting a "held by" message with a large number in place of a Process ID or User ID:

 Waiting for lock held by session -2147483565 in I:...ORDER2.dat

If "Track Locks" is specified (ecr #5432), the "Waiting for lock" message specifies the User ID holding the record. If not, the message specifies the Process ID holding the record.

( #6408 ) When running a query more than once within the same job, you could get the error message "Can't scratch work file" if the PCF of the query was large and the set of selected records was large enough to overflow a memory-based sort. This has been corrected - large result sets should no longer cause this error message to appear.

( #6508 ) A memory leak existed in the Appx EM loader. If an EM was found in the EM cache, it was validated. If the validation failed, the new EM was loaded, but the original (invalid) EM remained in the cache. When the new EM was written into cache, an 'already-on-file' occurred and the new EM could have been lost. This has been corrected so that EMs will load and validate properly.

( #6527 ) The Appx/Sybase interface was not converting a numeric field correctly when the field contained more than 12 digits. This has been corrected so that numeric fields of more that 12 digits convert properly.

( #6528 ) The Appx/Sybase interface was not converting date key segments correctly. This has been corrected so that date key segments convert properly.

( #6529 ) The Appx/Sybase interface would occasionally fail to create all indexes when a table was created. This has been corrected so that all required indexes are properly created.

( #6530 ) The AppxODBC Server tried to execute File Level Event Points on both ends of an AppxNET connection. The client side crashed because not enough of the engine had been initialized. It was determined that logically the client end of an AppxNet connection should not be firing File Level Event Points. Those event points should only be fired on the server where the data lives. So, we now only fire File Level Event Points on the AppxNet server and this bug no longer exists.

( #6531 ) Prior to 4.1.a, an AppxNET connection would stay connected until the client session ended. Starting with 4.1.a, an AppxNET connection is torn down when the last file that uses that connection is closed. If you find that this is a performance penalty, you can set APPX PERSIST NETIO to force net connections to be persistent.

( #6534 ) You can now SCAN for ODBC and DB2 data sources on the FMS attributes screen.

( #6574 ) When copied from 4.1.3. to 4.1.6, 4.1.9, or 4.1.a, an INPUT process could get an 'Invalid Resource ID type (32)' error. This has been corrected so that the error no longer displays and the process will run properly.

( #6630 ) When using PASS and RECEIVE to pass a field from one routine to another, if the field was NOT shared, a memory leak occurred. This has been corrected so that no memory is leaked in this case.

( #6642 ) SCAN'ing an ODBC Data source from FMS Group maintenance could generate a random failure. The SCAN completed successfully, but some time later, one of two Appx threads could have crashed (depending on system load and timing). This has been corrected so that scanning for ODBC data sources no longer causes this condition.

( #6663 ) When submitting a process to background on the AS/400, the background job ran to completion, but the process never exited. After finishing the job, the background process hung (consuming all available CPU time). This has been corrected so that background processes now exit properly on the AS/400 platform.

( #6673 ) The GCS product registration is no longer required on any platform. The Graphical Client interface is now automatically enabled as part of the base Appx license.

( #6681 ) Setting the APPX FAKE TIME environment variable can result in incorrect date values. This failure was caused by an uninitialized variable so the failure is random - in most cases, the correct date is used; in a few cases, an incorrect date is used. This has been corrected.

Designer

( #2826 ) Ending a Subroutine that had been called via a GOSUB command with an END command rather than RETURN would cause what appears to be a memory leak. This problem also occurred when calling a Subroutine which was defined by a LABEL within the Event Point. When "END"ing from a subroutine in this way, Appx failed to clear the RETURN stack (that is the memory area which is used to store the pointer back to the calling GOSUB statement). This caused the process to slowly increase its RESIDENT memory. (It was very noticeable in large QUERY, UPDATE & OUTPUT processes.)

This has been corrected but there is a related ECR 6678 that also details a similar memory leak. If the related ECR has not been fixed, you will still see memory being consumed and you will probably want to make sure you have the proper RETURN statements where needed.

( #2948 ) Token fields in query select records now work properly. Token tables associate alphanumeric token values with numeric token IDs. The token value is displayed to the user, but the token ID is actually stored in data files. When a token field is used in either an Enduser Selection or Designer Selection, designers can now enter token values on the right side of the selection, and the selections will function properly when the query executes.

( #6211 ) A SET statement that refers to a field in 0AD, 0LA, 0DB, or 0SA can cause the error "can't open element file - system directory record is missing" at the time the process is compiled.

This error only occurs if the SET statement is contained in an application whose version is something other than '00'. One or both of the fields referenced in the SET statement must be a group header in order for the error to occur.

This has been corrected.

( #6328 ) 4.1.a now lets you access the first 32K of an ODBC memo field. Appx has a per-field limit of 32K and a per-record limit of 32K. If a memo field has more data than fits into a field, Appx truncates the data (unless the user does a read with hold, in which case it should give an error).

Rules:

1) Memo fields (in Access®, SQL Server®, Oracle, ...) can be arbitrarily long.

2) Appx alpha fields can be a max. of 32K.

3) When we READ long RDBMS data into a short Appx field, we silently truncate (there wouldn't be any way to manipulate the data in an Appx field).

4) When we READ with hold, implying that you might REWRITE, we generate an error, preventing possible data loss in the database.

( #6532 ) The RDBMS interfaces would occasionally fail to interpret END AT constraints properly resulting in garbage being sent to the RDBMS server. This has been corrected so that END AT constraints are interpreted properly.

( #6533 ) The Unix flavors of Appx now support the unixODBC driver manager. You should be able to connect Appx to MySQL, PostgreSQL and other Unix-based RDBMS packages. You must install the unixODBC driver manager (www.unixodbc.org) and the appropriate ODBC driver for your backend database.

( #6640 ) The --- STATUS CODE pdf is already being set by any I/O statement that returns a T/F flag. If the statement returns a 'F', --- STATUS CODE is set to a token that reveals he cause of the error.

The BEG/END READ statements should also set the --- STATUS CODE pdf.

Enhancement

( #6631 ) The current Appx print script ran very slowly on the AS/400, taking 3 minutes to queue a single report. Each time Appx Print ran a command that was not a built-in shell function, it would start up a new AS/400 shell environment. This has been corrected by moving the Appx Print functionality into an Appx subroutine that runs instead of Appx Print on the AS/400.

External

( #5258 ) When stopping and attempting to restart the appxd and WinAppxD connection managers, the connection manager port was not being released until all running Appx Client and AppxNet sessions had ended. This resulted in an error "can't bind local address" and appxd/winappxd would refuse to restart. This has been corrected so that when appxd/winappxd is trying to restart, it is able to gain access to the port address even though there are still active client connections.

( #5391 ) Prior to this release, exporting and importing a WIDGET design file could corrupt the Font Scale on some widgets. This was a problem with our data dictionary definition of this field in our WIDGET file. This has been corrected.

Important Note: This incorrect definition also exists within the WIDGET structure files for all of the applications on an existing system . For this fix to be applied to all of your current applications, you must remove and re-create the WIDGET structure files for your apps. To do this, for each application on your system, you must:

1) Remove the WIDGET structure file: $APPXPATH/VV/AAA/Struct/WIDGET.dat where VV is the version and AAA is the appl ID. FMS override paths will effect this location.

!!! Make sure you are removing the WIDGET.dat file from your Struct directory and not your Data directory. Also do not remove the Struct/WIDGET.dat files from the $APPXPATH/00/0* directories. They have already been updated and your system may not run without them.

2) Run APPX and select System Admin -> Databases/Appl -> Design File Mgmt.

3) Enter the Appl ID and Version.

4) Run File Selection and pick the WIDGET file.

5) Run Create Files. It should say File Already Exists for the WIDGET file.

( #6088 ) Appx now supports files up to 4GB in size on HP/UX, AIX, and Solaris platforms. All other Unix/Linux platforms are currently limited to 2GB files. The Windows® platform is also limited to 2GB files.

GUI Client

( #6615 ) The backspace key did not function in the java client in the Image Editor. This has been fixed so that the backspace key does work in the Image Editor again.

( #6616 ) Client side printing did not work properly when two reports printed back to back in the same job. The first report was not printed and the second report printed twice. This has been corrected so that multiple reports generated from the same job are correctly printed at the client printer.

Microsoft, Windows, Windows Server, Windows 2000, Windows Server 2000, Windows Server 2003, Windows 98, Windows NT 4, Internet Explorer, Windows Vista, Windows XP, Windows 7, Microsoft SQL Server, Microsoft Access and Microsoft Excel are registered trademarks of Microsoft Corporation. All other products may be trademarks or registered trademarks of their respective companies.

APPX 4.1.9

Run-time

If you had your own disposition process in a non-00 version, --- token fields (like PRINT MODE) would not SCAN correctly. You would receive an empty scan list or perhaps it would just pop back to an earlier process. This has been corrected. (#5218)

If you had your own disposition process in a non-00 version and you try to add any --- token fields (such as PRINT MODE) to the image, APPX wouldn't create an EM for the process. It would cause an exception and return to the parent. This has been corrected. (#6081)

If you are running Appx under a temporary registration, you now see a splash screen that describes the license and displays your registration expiration date. Prior to 4.1.9, this splash screen made it difficult to run a startup job whose names was specified on the Appx command line. (#6275)

If you are running Appx under a temporary registration, the usual in-progress message now includes license and expiration information. During the first two hours of any Appx session, you will see the old-style in-progress message. After the first two hours, the in-progress message will include license and expiration information. (#6280)

The in-progress message that we display when running under a temporary registration shows an incorrect expiration date - it always shows the current date. This has been corrected. (#6281)

If you are running under a temporary registration, the Progress message you see while running a job or output process includes extra license-specific text (and your expiration date). Currently, the Progress message is formatted once at system startup and does not change during an Appx session. This means that, under a temporary registration, you will always see the first Progress message displayed. This has been corrected. (#6282)

Designer

If in a non-00 version application, you try to SET a group field in any of the APPX 0apps, you would receive the error "Can't open element file - Error - System Directory Record is Missing". This has been corrected. (#6211)

If you had your own disposition process in a non-00 version and you try to add any --- date fields to the image (such as a PRINT PDF) you would get the following error - CV.C.1438, "cv bld sitm - missing dap". This has been corrected. (#6216)

APPX 4.1.8

Run-time

When executing a query process, the cursor is positioned correctly (in Record Selection) when the first relation is non-modifiable. (#5683)
The Windows® print spooler interface has been reverted to version 4.0.a because of numerous security violation problems. (#5843)
Starting with release 4.1.6, you can now SCAN for system login id's while maintaining the System Administration USER file. We also validate the system login id that you enter against the OS provided login list. Under Windows, we validate the login id against the local security database - even if you are using a domain or Active Directory. This has been partially fixed - we still validate user id's against the local security database (when you are adding users to the 0SA USER file), but an unknown system user id will now cause a WARNING rather than an ERROR. (#6152)
After the fix for #5948 was checked in, a related bug appeared. The engine was apparently not using the correct profile when checking security classes for the startup process. Prior to the fix for #5948, the net effect was that you always had privileges to run your startup process - after to #5948, you never had privileges to run a protected startup process. This has been corrected. (#6224)
If you already have a Java runtime installed on your Linux box, and then install Appx, the Appx client may find your original JRE instead of finding the one required by Appx. This has been corrected in appx-4.1.8-2.i386.rpm (note that this is 4.1.8 build number 2). (#6225)

GUI Client

GUI Widgets attached to numeric fields can now be resized. If you define a numeric item on an image and switch the widget type to Slider or Progress Bar, you are able to drag out ) the size of the widget. Widgets now retain their edited sizes. (#6148)

APPX 4.1.6

WARNING: Appx 4.1.6 includes a GUI Demo application. It will be installed as Application DMO, Version 00, and Database DMO. If this application ID, Version, and Database is already in use on your system, you will need to back it up, upgrade to Appx 4.1.6, then restore your DMO application and/or database.

Important Notes

Starting with AppxODBC version 4.1.6, you should be able to connect to remote data sources without the hassle of defining environment variables.

When you run asql (to import table definitions), you are now prompted for the remote host information. asql now stores this information along with the imported table definitions. (You are prompted for a remote host name, port number, user name, and password - asql stores the host name and port number - each ODBC client will prompt you for the username and password).

When you use an ODBC client (such as Access or Crystal Reports) to connect to Appx-hosted data, the AppxODBC driver connects to the remote host identified to asql.

You should no longer define the APPX_DATA_SERVER or APPX_UID environment variables (they will be ignored).

NOTE: you must connect to the remote data server at least once using the 4.1.6 version of asql before this will work.
In support of some of the new features in APPX 4.1, we compiled using newer OS levels on some platforms. Below is a list of the platforms and OS levels that we were required to upgrade. We can't guarantee that APPX 4.1 will run on older versions of these operating systems. Any other platforms were compiled with the same OS levels we have used in the past.
- AIX 4.3.3
- DG/UX R4.20 (Intel)
- HP/UX 11
- Linux RedHat 6.2 Kernel 2.2.14-5.0 (Intel)
- NCR SRV4 MP-RAS Version/Release 03.02.00.39
- SCO OpenServer Enterprise System (ver 5.0.4p)
- Solaris 8 - SunOS 5.8
It is very important to note that you will not be able to downgrade an application once it has been converted to release 4.1. In 4.1, we have changed the format for the I/O-related ILF statements. These changes are not backward compatible.
You cannot convert applications between Intel and RISC byte-ordering at the same time that you upgrade from a previous release to release 4.1. If you need to move an application from an Intel machine to a RISC machine, you must export the application from the Intel machine and import the application on the RISC machine using the same Appx release. Once you have changed byte-ordering, you can then upgrade that application to release 4.1. Note that you can upgrade the application first, then change byte-ordering. You just can't do both operations in one step.
The release 4.1 Sybase database interface is now in beta. If you would like to help us beta test this interface, please contact APPX Software.
The structures of some design files have changed in 4.1. A restructure of these design files is not required. We have provided a utility in System Administration, Database/Applications, Design File Management which you can use to clean up a few of the attributes in each of your applications. This utility will clear out the new "PCF Partial-record I/O" specification (in Processes/Additional Attributes), it will create some new design files (WIDGET, RESOURCE, and RESNAMES), and will convert any old-style box-drawing specifications into the format supported by release 4.1. (Note: if you don't use this utility on each of your applications, you will need to create the new design files yourself and you will receive warning messages when you try to edit a process which has random data in the PCF Partial-record I/O field.)
We have made very significant changes to the Appx/RDBMS interfaces. You should become familiar with these changes before you install this release. In particular, record locking has been re-implemented to provide better performance and this can change the way your applications will work in a multi-user environment.

Bugs Fixed in Patch Release 4.1.6

Run-time

In Application Design, when running 3-Utilities, 6-Toolbox, 3-Create Executable Modules, if there are errors and a listing is produced, the listing now has the correct application id printed at the top. (#3473)
SCAN on the cached instance of a file does properly return values from the selected record. (#5339)
In earlier versions of 4.1.x, if a "direct process 2" menu was specified, but it did not currently exist, then when the underlying process was invoked, the following error could be produced - "Error - An internal error has been detected, proceed with caution!". This has been corrected. (Note: problem still exists in 4.1.6b4, fixed after that.) (#5733)
Release 4.1.6 now supports a variety of new registration types. (#5962)
Oracle version 8.x servers seem to have a bug which manifests itself as occasional "ORA-01013 - user requested cancel of current operation" errors. This error (ORA-01013) is normally produced when one of the following occurs: 1) The user presses the Ctrl-C key (actually, the process receives a SIGINT) 2) The application (Appx) calls the OCIBreak() function to cancel an operation. Neither of these is happening - Oracle considers this a bug. To try to recover from this problem, the Appx/Oracle interface has been modified to retry a query operation if an ORA-01013 is encountered. You can control the number of retries by setting the APPX CANCEL RETRIES environment variable to a number greater than 0. Important note - the default is 0 meaning that Appx will NOT retry queries which produced an ORA-01013 error. You must set APPX CANCEL RETRIES to a number greater than zero in order to force Appx to retry failed queries. (#5969)
The GUI client now supports a "-title=" command line argument which can be used to set the contents of the titlebar. (#6019)
Appx for Windows® (since release 4.1.x) will allow you to login even if the case of your user id does not exactly match the case of a System User ID in the 0SA USER file (this is by design). The --- USER ID field will is set (and the user ID will display at the bottom of the screen). (#6090)
Some enhancements have been made to the initial system administration files which are created as part of a new installation of APPX.
- In the System Parameters record, "Auto Select All Files" and "Design Xfer Retain Audit Default" will both be defaulted to "Y".
- Instead of creating a #IU user record, you will be prompted for the user info for the initial System Administrator record.
- A default client side printer is added.
- Forms records are added for common printing configurations on Windows printers.
(#6099)

Designer

In release 4.1.x, the internal format of I/O ILF statements was changed to support partial-record I/O. The Change All References utilities now correctly handle the "Hold" and "Fail" flags of these statements, as they convert the statements from the old to new formats. (#5975)
When performing I/O against the --- WIDGET file (in an application whose version is not "00"), the ILF editor no longer produces a FileNotFound error. (#5991)
The 0AD VERSION file now contains APPXPATH but, APPXPATH is not in VERSION TYPE's list of TOKEN values, so it is not possible to directly read this record from the VERSION file. This has been corrected. (#5998)
When using the mouse to move an item to a new location, the image editor correctly sets the item's size. (#6001)
The design transfer API no longer gives the error "Source Process Same As Dest Process" if you are in application ABC and you attempt to transfer a process from ABC to another version of ABC. (#6014)
Dragging a widget so that part of that widget hangs off the right or bottom edge of the window caused the widget to disappear in the image editor. It was no longer visible nor selectable. This has been corrected. (#6024)
When opening a design file whose FMS location has been modified using $(ver), the $(ver) part of the pathname is no longer set to '00'. (#6036)
Deleting a menu process does not result in orphaned GUI attributes for items on the menu's image. (#6040)
All Item types can now be defined as a LABEL control in the GUI Attributes of an image item. The specifications, "Text Position", "Icon Position", and "Resource" are now accessible when LABEL control is selected. (#6045)
When using the APPX Client, and adding a menu process, or an input image, a default row text title bar will no longer be automatically generated. The default row text title bar will be generated when using the character mode client or the Windows client. (#6046)
Occasionally, a "Can't Write LFN record - already on file" error would be generated. This was sometimes followed by other error messages and eventually a complete crash. This has been corrected. (#6047)
The "Text Position" and "Icon Position" attributes of an ALPHA Item are editable if the item's GUI control is LABEL. These specifications are now correctly retained. (#6052)
The query processor (introduced in 4.1) was changed to use internal memory based files instead of disk files. This can cause a query to use significantly more memory than in prior releases. It is usually more efficient for the O/S virtual memory manager to handle paging this file to disk than to have APPX do so.

This process can now be controlled with the following environment variables:

APPX DISK SORT THRESHOLD - controls the amount of memory that APPX will use to store the final internal work file. If the size of the file exceeds the threshold, the entire file will be written to disk.

The default value is 2 * APPX RUN MEM.

The default value for APPX RUN MEM is 1/2 Meg. (#6053)
The values for the "Grand Totals" popup of a toolbox generated query process are not different from those for a manually added query process. (#6064)
Using option 94 to browse to the target of a GOSUB statement - if the cursor was positioned to the right of the GOSUB keyword, prompted for an Event Point (using the External Copy context process). Option-94 (browse) will now ignore the cursor column as long as the cursor is positioned on a line which contains a GOSUB statement. (#6102)
The ILF browse feature (option 94 in the ILF editor) will prompt you for a location if the engine can't infer where you want to go (based on the cursor position). (For example, position your cursor on the word 'SET' in a SET statement and press option 94). If you END or CANCEL from this prompt, you no longer lose the changes you have made to your event point. (#6103)
If you code an I/O statement (such as READ, WRITE, READNEXT, etc.) and the name of the file you want to manipulate is the same as the name of a work field, the ILF editor will not complain with a "File Not Found" error message. You can save your ILF statements. (#6104)

External

Appx print now works with 'lp' (as it already did), 'lpr' which Linux uses, and 'ulp'. There's now one appx print script that works with all three spoolers. appx print looks for these in the current PATH, looking for 'ulp' first, if not found 'lp', if not found, 'lpr'. This can be forced by setting the environment variable APPX LP CMD. appx print also does more error checking and logging . It still creates a /tmp/appx print.last file of just the last print request but includes much more information.
appx print now supports the use of "filters". These are triggered by the --- PRINT FORMAT pdf. So, you can define a print filter for a PRINTER defined in APPX. (#5836)

GUI Client

If you send a keyboard timeout value and start entering text into a text field, the keystrokes reset the timer. Also, when the timer fires, all changes to the text field are not lost. (#5986)
When using the keyboard to select a token value from a listbox in the java client, the search is now done alphabetically instead of in the order the tokens exist in the list. (#5989)
When using the POSITION or CURSOR ROW / CURSOR COL to set the focus to a text field widget, the focus is being set properly to the text field. (#5994)
When the Java client detects that the server has gone away, it will now display a popup dialog box stating the error and waiting for the user to acknowledge the dialog box before terminating. (#6000)
When using F11 in the Image editor under the Java client does not show 'Y' and 'N' values instead of checkboxes. (#6002)
The APPX Java client can now be run on a MAC. (#6049)
All objects will now align properly to the grid in the image editor. (#6050)
Using the [?] help tool on the titlebar now shows the help window properly. Also, mouse clicks no longer reselect another scrolling record from the background screen. (#6091)
If you call up a GUI image in the image editor in inquire mode and have some custom boxes on the screen the boxes are now properly displayed. (#6097)
Panning now works properly in the client. (#5438)
Using the Toolbox option in the Image Editor to edit the list of optional processes now displays the list of processes with the proper Optional Child widgets. (#5581)

APPX 4.1.5

Occasionally, switching applications ID's while using Application design could cause an "attempting to free freed memory" or "attempting to free unallocated memory" message. This has been corrected. (#2657, 2996, 3371)
Boxes now show as the proper color and font the first time they appear on a menu. (#5560)
After returning from using either opt-93 or opt-94 to drill into a child process in another application a memory corruption error could occur. This could also occur if any file level event points were defined for a file which was accessed in multiple databases within a given process family. The error would result in either a C-assert type message indicating a memory corruption or perhaps silently throw an exception to the stack dump. This has been corrected. (#5931)
A tokenized field which is also scannable will now display as a listbox with an
associated scan indicator. (#5933)
A job containing more than one related or subprocess queries (either as direct children or as descendents of child jobs) where at least one of the query PCF files has file event points, no longer generates an "attempting to free freed memory" error near the end of the process. (#5936)
A few errors have been corrected which resulted in innocuous complaints from Purify. (#5937)
When embedding the java applet into a web page, you can control the color of the unused applet background so it more closely matches the rest of your web page. You do this with a new java applet parameter of "appletBg" and you set it to an HTML type hex color value. "#FFFFFF" would be white. (#5940)
When using the keyboard to select a value from a token type listbox control, you can now enter multiple characters of the value you would like. The listbox will search out the token value that matches the series of characters entered. The list will reselect token values as you type. The status area of the window will show you what characters you have typed. The backspace key will clear the entered characters from the search and restore the token value to what it was before the search. (#5941)
If you tried to pick a menu item from the right-click menu that happened to be on a pullout menu then appx would run the wrong process. This has been fixed. (#5944)
If you use Occurrence numbers on fields on the RHS of a QUERY Designer Selection (and presumably User Selection), the QUERY logfile indicates that occurrence# 1 is always used (rather than occurrence numbers coded >1). Data run thru the QUERY indicates that the field indexed by Occurrence>1 is using a variable value indexed by Occurrence=1 instead. This only occurred in cases where the constraint was used for an indexed Establish PCF Range event point (note - the designer would have to set the BEG AT/END AT flags manually in order for this error to occur). This has been corrected. (#5945)
When changing the value of a date field, you can press the delete key near the end of the field and then enter a new value. (#5947)
An APPX System Administrator typically does not have a Security Profile specified. If one is specified, it is honorod for all activities that are governed by a security profile. If a non existing profile was specified, it was ignored for an administrator. This has been changed. Now if a non existing profile is specified for an administrator, APPX will behave as if the profile granted no rights. (#5948)
If you declare a SAVEPNT and then try to ROLLBACK to that SAVEPNT, all changes no longer are rolled back. This was caused because the ROLLBACK (to savepoint) statement had an extra character (1) in front of the savepoint name. (#5949)
When accessing data stored in Oracle (and using primary key values to identify each row), you no longer receive a spurious error message "Invalid RID type" if Appx needs to recover a lost record lock. (#5950)
Oracle version 8.x servers seem to have a bug which manifests itself as occasional "ORA-01013 - user requested cancel of current operation" errors. This error (ORA-01013) is normally produced when one of the following occurs: 1) The user presses the Ctrl-C key (actually, the process receives a SIGINT) 2) The application (Appx) calls the OCIBreak() function to cancel an operation. Neither of these is happening - Oracle considers this a bug. To try to recover from this problem, the Appx/Oracle interface has been modified to retry a query operation if an ORA-01013 is encounterd. You can control the number of retries by setting the APPX CANCEL RETRIES environment variable to a number greater than 0. Important note - the default is 0 meaning that Appx will NOT retry queries which produced an ORA-01013 error. You must set APPX CANCEL RETRIES to a number greater than zero in order to force Appx to retry failed queries. (#5969)
A box widget now shows the border correctly when using an override label text, label font, and border color. (#5977)
The Java Client now paints the screen less often. This can enhance performance since drawing the screen components is the most expensive operation that occurs in a GUI application. (#5978)
When running a scrolling input process with a screen size of more than 21 rows, the outlines around each scrolling region is now drawn for all rows, including regions below row 21. (#5979)
TextArea, HtmlArea, RtfArea type widgets now honors the Micro Adjust settings. Also, the TextArea widget now honors Transparent Background, Font Style, and Background Color settings. (#5980)
When loading the Java Client via a browser, sometimes it is desirable to launch the client non-embedded but have control over removing the MenuBar and ToolBar and also be able to set the window title. This makes for a much cleaner look while preserving the information in the statusbar. This can now be done with the following new java client arguments. -hideMenubar=1, -hideToolbar=1, -title="Window Title Text". (#5981)
The java client interprets the meaning of the Enabled? widget specification to mean 'Y' as "Enable the widget", 'N' as "Disable the widget", and 'null' as "If the widget is not in the active frame, disable it". This causes problems with the use of the ENABLE and DISABLE ILF verbs. If you use ILF code to ENABLE and DISABLE a button widget, then when a child process is run, the button does not auto-disable since the Enable? widget spec was left in a 'Y' state. In this case, you are forced to read the widget record and manually set the Enabled? flag to 'null'. So, the clients understanding of this Enabled? flag is being changed to reflect the following new rules. A value of 'Y' will mean "Enable the widget if it is on the active frame", 'N' will mean "Disable the widget", and 'null' will mean "Disable the widget if it is not on the active frame". (#5984)
If you define a pulldown menu as optional child 222, the menu option will now run when selected. (#5985)
If you send a keyboard timeout value and start entering text into a text field, the keystrokes now reset the timer. (#5986)

APPX 4.1.4

Important Notes

In support of some of the new features in APPX 4.1, we compiled using newer OS levels on some platforms. Below is a list of the platforms and OS levels that we were required to upgrade. We can't guarantee that APPX 4.1 will run on older versions of these operating systems. Any other platforms were compiled with the same OS levels we have used in the past.
- AIX 4.3.3
- DG/UX R4.20 (Intel)
- HP/UX 11
- Linux RedHat 6.2 Kernel 2.2.14-5.0 (Intel)
- NCR SRV4 MP-RAS Version/Release 03.02.00.39
- SCO OpenServer Enterprise System (ver 5.0.4p)
- Solaris 8 - SunOS 5.8
It is very important to note that you will not be able to downgrade an application once it has been converted to release 4.1. In 4.1, we have changed the format for the I/O-related ILF statements. These changes are not backward compatible.
You cannot convert applications between Intel and RISC byte-ordering at the same time that you upgrade from a previous release to release 4.1. If you need to move an application from an Intel machine to a RISC machine, you must export the application from the Intel machine and import the application on the RISC machine using the same Appx release. Once you have changed byte-ordering, you can then upgrade that application to release 4.1. Note that you can upgrade the application first, then change byte-ordering. You just can't do both operations in one step.
The release 4.1 Sybase database interface is now in beta. If you would like to help us beta test this interface, please contact APPX Software.
The structures of some design files have changed in 4.1. A restructure of these design files is not required. We have provided a utility in System Administration, Database/Applications, Design File Management which you can use to clean up a few of the attributes in each of your applications. This utility will clear out the new "PCF Partial-record I/O" specification (in Processes/Additional Attributes), it will create some new design files (WIDGET, RESOURCE, and RESNAMES), and will convert any old-style box-drawing specifications into the format supported by release 4.1. (Note: if you don't use this utility on each of your applications, you will need to create the new design files yourself and you will receive warning messages when you try to edit a process which has random data in the PCF Partial-record I/O field.)
We have made very significant changes to the Appx/RDBMS interfaces. You should become familiar with these changes before you install this release. In particular, record locking has been re-implemented to provide better performance and this can change the way your applications will work in a multi-user environment.

Bugs Fixed in Patch Release 4.1.4(a)

GUI Client

Clicking the Close Box on the outer java client window will now try to close the client session. Currently the way it does this is 1) if the client has not logged into a server session yet, it just closes the client session, 2) if there is an active server session running, the client will send a CANCEL keystroke to the server. This means that you might have to click the close box several times to completely get out of APPX. This will be further enhanced later when the client ahs a better way of closing a server session that does not require it backing out via the menu tree. (#4449)
When setting the interactive timeout value, the java client does not fire properly when the timeout occurs. It appears to do nothing and the log files shows that it encountered an exception. This has been fixed so that the timeout does fire properly when the timer expires. (#5928)
When using the java client to transfer files, the progress slider sticks at zero percent complete until the transfer is done. This has been foxed so that the progress slider updates as the transfer is proceeding. (#5929)
When the server asks the java client to run a local command, the client does not normally wait for the command to complete before returning control to the server. To force the client to wait, you can now add a /W or /w to the end of the command string and the client will run the command (after removing the /w) and wait for it to exit before giving control back to the server process. (#5930)

Bugs Fixed in Patch Release 4.1.4

When adding a frame Display Only defaults to 'Y'. While in add mode to add the image, if a modifiable item is added to the image APPX will then reset the Display Only flag to N when the image editor is exited. This was occurring when the image was first added only. It will now also occur if an existing image is modified. (#1847)
Occurrence numbers will now be respected when used with the PASS statement. This was fixed in 4.1 but did not make it into the release notes. (#2470)
In earlier releases of Appx, a user who was not a System Administrator could use the BROWSE feature (of an output process) to gain access to the User list, Database list, Printer list, etc. within System Administration. This has been corrected. (#4149)
When printing technical documentation for output processes, the Global Pre-Display event point was not being included. This has been corrected. (#5436)
Options 91-94 have been added to the child "Use Query" popup. This allows jumping directly to the query from the Use Query screen. (#5507)
When generating a scrolling input from the toolbox menu, if the process to be generated already existed, it was not being cleared properly prior to generation of the new process. This has been corrected. (#5511)
On an image item, if you specified a DLU which referenced a file in another application, you could incorrectly receive a "file not found error". This has been corrected. (#5515)
When a titlebar is entered from the Window Options while in the image editor it does not appear on the image when the widget is saved. You must exit and re-enter the image to see it. This has been corrected. (#5517)
The Border Color specification in GUI Attributes was not being retained properly. This has been corrected. (#5650)
When you manually add a field to the Image Editor from a non-PCF file (after the key to the other file is added with DLU properly configured), the Image Editor is smart enough to default the Auto Display value in Additional Attributes to a type 2 (display look-up, blank if NOF). If you add via the Data Palette (rather than manually), the editor will now provide the same default. (#5652)
The "Item Repeat", toolbox option in the image editor did not repeat the GUI Attributes for any repeated item. This has been corrected. (#5698)
When entering a value for a tokenized field (at runtime), Appx is too forgiving of misspellings. For example, assume that you have a field whose valid token values are: ALABAMA, ALASKA, ARKANSAS, COLORADO Currently, if you enter a value of A, Appx would assume that you meant ALABAMA. If you enter AR, Appx would assume that you meant ARKANSAS. However, if you enter a value of B, Appx would (incorrectly) assume that you wanted COLORADO (since that is the first token greater-than or equal-to B in alphabetical order). The user should receive an error if he has not entered a prefix of a valid token - you must enter a valid prefix of a token. (#5809)
When a two-part data lookup (on, for example, an INPUT) ought to be defined with a "Define", followed by a "Continue", but is instead defined with two "Defines" in a row, you would receive a mysterious error message when the EM built. This has been corrected. (#3990)
Starting with release 4.1.4, the System User ID (in the System Administration USER file) is not case sensitive under Windows®. (#5162)
When defining a shortcut key for a menu item, the character that you choose for the shortcut must appear within the label. (#5307)
In Inquire mode all widgets are "disabled" which caused their contents to be displayed with a very light gray font. This made the screen very difficult to read in Inquire mode. (#5352)
If you had a scrolling input and each record was more than one row in size, the Java Client didn't draw it's 'box' big enough. (This is the box outline that the client draws around records as you use the cursor up/down keys.) (#5378)
At run time, an alpha field defined as a label seemed to inherit a white background even though no background color was specified. (#5497)
If you specifed a widget type of "LABEL" for an alpha field, then you could not see the field on the image while in the image editor. (#5498)
Descending keys in Oracle do not display the expected records in an input process. This has been corrected. (#5524)
Cut/Copy/Paste and Move in the image editor have been improved. Operating on multiple objects should no longer cause Appx to crash. (#5534)
Using the ILF Editor with the Java Client: When you tred to Search within the ILF editor, the cursor positioned one character to the left of the box in which the search string was to be entered. (#5542)
When you displayed an OUTPUT to the screen, if any literal text such as "1) Customer Number One" was present, it displays as a button. (#5549)
Sometimes logging off the server using the Java Client ended abnormally. When this happened, the last things on the MS-DOS log was: "terminating exception < 16 hex digit address > received on thread" (#5573)
SQL Server® provides multi-user integrity through record locking. One of the consequences of this is that if you update a row in SQL Server, that row is locked until you commit. If your update changed any indexes, those index pages are locked until you commit. The locks prevent other users from modifying your changes until after you commit, but unlike other (more APPX-friendly) databases, the locks also prevent other users from reading the data that you have changed. If you run into this problem, the symptom will be that you are doing a READ *without hold* and the READ hangs for some period of time (until the other user COMMITs). You can change this behavior on a file-by-file basis by enabling the READ UNCOMMITTED feature of SQL Server. If you turn on READ UNCOMMITTED, you can READ (without hold) data modified by another user, but not yet committed. In most cases, this won't cause you any troubles (since your applications never do a rollback). As soon as you start using the ROLLBACK statement in APPX, you will want to revisit the READ UNCOMMITTED flag to determine if it is still appropriate. (#5589)
Sliders widgets have a spec for Snap to Tick Marks. If you turned on tick marks for the slider it always snaped. If you said not to snap it still snaped to the tick marks. (#5641)
A TOKEN field with a Raw Text widget type no longer prompts for an OPTION to send. (#5642)
The Java Client was not making any sound in resonse to the APPX server requesting a BEEP. The client now responds to server BEEP requests. (#5644)
When using the Data Palette, the cursor icon seemed to always be an hourglass instead of a pointer (although it worked OK). (#5649)
In the java client, if you resized the window in only one direction (horizontal or vertical) the client would not adjust the font and client window to the new size. (#5660)
A query process will (once again) read PCF records with hold if the process contains a REWRITE or DELETE statement which refers to the PCF. (#5681)
The Java Client had some old code that would convert buttons to text if the GUI interface was turned off. We do not support running GUI applications on character screens at this time so this code was removed. (#5687)
The appx.idx and appx.fis files could be corrupted if a copy of AppxODBC failed to terminate properly. This has been corrected. (#5729)
A query process will (once again) read the PCF hold hold if the process contains a REWRITE or DELETE statement which refers to the PCF. (#5730)
Cosmetic changes have been made to various System Administration processes. (#5766)
Cosmetic changes have been made to various System Administration processes. (#5768)
Executing a query process which constrains a prefix of a key can result in fatal errors. This occurs when the constraints specify a "GT" or "GE" without a matching "LT" or "LE". It also occurs when the constraints specify a "LT" or "LE" without a matching "GE" or "GT". (#5840)
Several memory leaks related to the Appx/RDBMS interfaces have been resolved. (#5910)
A memory leak related to the "In-progress" message of an Update process has been corrected (#5911)
If you modify the PCF of a scrolling input process and the PCF REWRITE fails (possibly because of an already-on-file, or record-not-held condition), the input process can crash. This has been corrected. (#5912)
The FMS editors for Sybase, Oracle, and ODBC have been separated. There are now three different FMS editors, each asking for information specific to an FMS type. (#5917)

Run-time

When invoking a process with child constraints, and utilizing a multi-part key field in the child's PCF where the key's segments are not in the order that the underlying fields appear in the record (this can be done by using SYNONYM's) - it was possible for the child to incorrectly act as if there were no records matching the constraint. This has been fixed. (#3275)
After "appx -k" keymapping, the keyboard cursor (arrow) keys don't function. This has been corrected. (#3631)
A memory leak related to the CALL statement has been fixed. (#5124)
SCAN on the cached instance of a file does not return values from the selected record. (#5339)
The java client would lockup sometimes when resizing its window via the mouse. (#5380)
If you have a process that displays a scrolling screen with multiple records on the screen and widgets defined. Only the first record's widgets were displayed. (#5381)
In the java client, pulldown menus disappeared from the menu bar if you press return while sitting on a menu. (#5386)
The java client sometimes locked up in the image editor with "Exception occurred during event dispatching, java.lang.NullPointerException: Null Pointer or Access Violation" and same message plus "java.lang.ArrayIndexOutOf BoundsException" (#5419)
When a token field with a control type of RAW TEXT was scanned, the drop down list of values was not attached to the bottom of the field. (#5479)
Java client date fields do not save changes to the field if you change a digit in the existing date or blank out the date. This has been corrected. (#5484)
With the Java Client, Auto Tabout did not work on color field widgets. (#5485)
(#5486)
The java client will now correctly run as an applet inside of the Internet Explorer 5 browser. (#5554)
Trying to do a local print while running the client in the a browser would not print. (#5556)
When running the java client in a browser, sometimes the widgets on the titlebars of the popup windows were missing. This would be the close button, the checkmark button, the help button, and the popup title text. (#5557)
In the Java Client, if you had your edit caret in a password field, pressing the ENTER key was ignored. (#5587)
In the Java Client, if you had a scrolling record display with a combobox in the scrolling area, if your focus was sitting on the combobox, the Page Up anf Page Down keys were ignored. (#5588)
If you specifed "Icon Position" for a button on a menu it was too persistent. If you edited the GUI Attributes for another button that previously had no "Icon Position" specified, the Icon Position from the first button would be filled in on the second button, when the GUI Attributes screen was displayed. (#5665)
When an input that is defined for more than 80 columns is run on a 21x80 screen the client locked up when trying to paint a field (in this case an image) that started before column 80 and extends past column 80. (#5669)
The APPX 4.1.3 keymapping utility (appx -k) would give a seg fault under AIX (and possibly other unix platforms). This has been corrected. (#5708)
The right click menu didn't support separators well in the java client. If you tried to use a separator in the menu, the menu would not appear at all. (#5734)
The locking model previously used when storing/accessing data in MS SQLServer will no longer work. SQL Server 7.x changes the way record locking and cursor models work. The locking model for MS SQLServer has been rewritten in 4.1.4 (#5781)
When executing a query process where one of the selection criteria partially constrains an alpha field (i.e. a prefix of the field is constrained), the resulting select statement contains garbage. We now pad the ending constraints with high-values when executing a query of this form. (#5782)
Attempting to create a SQL Server (or Oracle, DB2, or Sybase) table which contains a space in the table name ("Open Transactions" for example) resulted in a parse error. This has been corrected. (#5789)
If you execute a WRITE statement against file 'A' in one process, then invoke a different process and execute a WRITE statement to the same file (without closing the file in between), the second WRITE statement can insert garbage data. This has been corrected. (#5790)
Referencing a cross application date domain, which had date and time components, could result in the error - PCBLD.C.205 "bad seg file write - Error - Already on File", when an EM for a process was created. This has been corrected. If you are experiencing this error, it may be necessary to initialize the 4 compiled DD files for the application and to Process the data dictionary. (#5833)
If you designed an input or menu frame starting on row 21 and you designed buttons on the image, at runtime, the buttons did not show on the client screen. (#5842)
If you try to SCAN against a key which contains multiple occurrences, you will get varying results, depending on which native file manager is being used to store the file. If you store the file in an RDBMS, you will probably not see any records displayed. A SQL log would show an invalid select statement (the select statement would include garbage for occurrences other than the first). This has been corrected. (#5846)
If you have a file which contains a synonym of a key segment, the field will show up twice in a SCAN display (assuming that you are scanning against the aliased key). This has been corrected. (#5847)
On Linux systems, the ethernet hardware (or MAC) address can now be used as a serial number for registration purposes. (#5891)
The Appx/Oracle interface can use two different methods for uniquely identifying a record (row). Appx can remember either the ROWID or the primary-key values for each row. Various problems arise when trying to use the ROWID as a record identifier. Starting with release 4.1.4, the default record identifier will now be the primary-key for each row. (#5894)
If the engine calls the Win32 GetUserName() function twice, the second invocation will cause a GPF. This has been corrected. (#5895)
Cancelling a query process causes a "Unable to open required file" message. The message should be friendlier. You now see a message which informs you that the user has cancelled the query process. (#5896)
If you exceed your licensed user count, any users which try to login while there are no licenses available will crash after viewing the "License Count Exceeded" message. This crash can cause the USAGE file to be locked. This has been corrected. (#5901)

Designer

Starting with release 4.1.4, Windows users can use the SCAN option to select System Printer ID's (when defining Printers), System User ID's (when defining Users), and ODBC Data sources (when defining an ODBC FMS group). (#3319)
Upon exporting, it is possible to get an mu.c.3266 - "bad msk file write - error - already on file". This is known to happen if you run an Export, interrupt it somewhere in the middle (perhaps as result of another cassert), and then rerun the Export without first exiting and reentering APPX. This has been corrected. (#3354)
While stepping thru ILF code, it seemed the highlighting that indicates the current line got 'stuck' after a TRAP was executed. (#4356)
The Appx/MS SQL Server interface will now define a column to be of type "datetime" if the Appx data dictionary specifes a DATE field with components "CC" through "th". Also, a DATE field with components "CC" through "nn" will map to a "smalldatetime" column. (#4411)
If you had a scrolling image that was 1x80, whose only modifiable fields were checkboxes, it could not be edited. (#5408)
When in the image editor and moving fields up and down, the fields sometimes ended up in the wrong place, widgets missing, etc. (#5420)
The java client lockup when a checkbox was dragged and dropped onto the right hand side of a box widget. (#5421)
The java client locked up when a button widget was dragged off the bottom of the screen. (#5423)
In some cases, you could not manually enter a color value into a field defined as a Color Chooser. You could use the attached button to pop up the color chooser control and select a color. But, you could not enter a color using the keyboard. This has been fixed. (#5424)
When code is added to a file level event point, the event point name does not get the visual cue of turning green in the list of event points. (#5474)
With the Java Client and the Image Editor, when both the tab level and tab group were set on a field, APPX did not respond after the image was saved. (#5480)
With the Appx Client, the page up and page down keys did not always work on the optional process list. (#5483)
If you were to copy and paste a label widget from the image of one process onto the image of a different process. The label widget appeared on the image but was not able to be modified. When the image was saved the label showed up back on the original processes image. (#5490)
With the Java Cleint the cursor could not be seen in token/validation fields when running under the Web Look. (#5491)
Using the java client, if you selected multiple items and tried to move them to another area of the image, the moves failed. The failure only occured if the items had related widgets. The symptom was that the items moved back to their original position, though the widgets seemed to be moved to the new positions. (#5659)
The PASS and RECEIVE statements can now be used to pass and receive literal (constant) values. (#5688)
Using the Java Client, the image editor had trouble SCANning by Field. You were not positioned on the Starting value. When entering the field name the first SPACEBAR was interpreted as Enter by the SCAN processor. (#5690)
Under the java client silders and buttons didn't make it through a Cut/Copy Paste operation. (#5695)
In the java client and doing a group Cut/Copy/Paste operation which had an item that had a GUI Widget (Slider, etc) would "drop" whole items. (#5700)
If a label extended beyond the right hand side of the frame, but most of it was within the frame, then the label would not be visible during design. It would appear at run-time. (#5744)
Under Windows, the appxd program should load c:>appx.env and c:appxd.env - this makes it much easier to consolidate environment variable assignments. (#5778)
When stepping through statements in the ILF debugger, the PASS and RECEIVE statements should display the current values of the referenced fields. The END LOOP statement should do the same. (#5779)
The ILF editor should auto-correct the common mis-spelling of the RECEIVE verb (i.e. it should correct RECIEVE to RECEIVE). (#5780)
The Appx/Sybase interface been updated to Sybase version 12. (#5783)
Executing a SET statement, where the source field is a group header and the destination field is a multi-occurence alpha, will wipe out all occurrences in the destination field. (The SET statement is acting like there is a group header around the destination field). This has been corrected. (#5793)
The ASQL program (AppxODBC schema importer) now displays a progress dialog when connecting to the Appx data dictionary. This can be helpful when using AppxODBC over AppxNET with a slow connection. (#5812)
When in the Image Editor, the java client would not always respond to keystrokes or mouse clicks. (#5855)
Moving buttons too far to the left so that they are off the left edge of the screen locked the image editor. (#5859)
If you add a large (see below) text field to the end of a record, set "Variable Record Length" to 'Y' for that record (to force a quick restructure), then try to restructure, a failure occurs. ('large' in this case means long enough to cause the record length to increase beyond the next 1000 byte boundary). This has been corrected. (#5861)
If you paint an item over the top of a characteristic, then double-click on the item to edit its properties, you will be prompted to define a box. This has been corrected. (#5875)
The RESIDENT? flag on the CALL statement is not honored. If you execute a CALL statement with the RESIDENT? flag set to 'N', the external library (DLL) is not unloaded after the CALL completes. This has been corrected for release 4.1.4 - however you must set the environment variable "APPX HONOR RESIDENT FLAGS=1" to force Appx to unload the external library. In a future release, we will remove the need for this environment variable. You should examine all of the CALL statements in each of your applications to determine whether the RESIDENT? flag is properly specified. (#5880)
Deleting an item in the image editor, then ending back to the process management menu, then going back to the image editor and deleting another item can cause an unrecoverable memory reference error or a freeing freed memory error. This has been corrected. (#5886)
APPXPATH can now be found in the --- VERSION file. This value can be used to find the system administration (and 0-app) files. (#5887)
When editing the Establish PCF Range event point of a query process, the ILF editor incorrectly said that you were editing the Set Default Values event point. This has been corrected. (#5888)
Under Windows, the WinAppxD server (connection manager) will now read environment variables from the c:appx.env and c:appxd.env files. (#5889)
Using the 4.1.4 (and higher) version of appxd and WinAppxD (the Appx connection manager), you can reject either interactive or AppxNET/AppxODBC login requests. To reject interactive logins, define the following environment variable: "APPXD REJECT INTERACTIVE=1" To reject AppxNET (and AppxODBC) logins, define the following environment variable: "APPXD REJECT FMS CONNECTS=1". (#5890)
The CNV TEXT statement is not paying attention to NULL values. If you try to CNV TEXT a tokenized field (to text format), the result will either be a "-1" or "??". This has been corrected, but only for CNV TEXT statements which manipulate an entire record. (#5892)
The import/export format for some of the file I/O statements is incorrect in release 4.1.x. The result is that you may have difficulty importing design files which were exported prior to release 4.1.4. This has been corrected in release 4.1.4 (#5893)
When you make changes to an RDBMS-hosted data file and you are running in COMPATIBILITY (commit) mode, your changes are not committed to the database until all record locks have been relinquished. If you are using Oracle ROWID's as record identifiers, a lock held on an Oracle row will not be noticed when Appx tries to decide whether or not a COMMIT can occur. This has been corrected in release 4.1.4 - holding a lock on a row identified by it's ROWID will veto any compatible-mode commit requests. (#5897)
There are some cases where Appx fails to commit the last set of changes made during an Appx session. This can happen in any commit mode. Appx now commits all changes to the server when an Appx session ends. (#5898)
When using the "Create Executable Modules" option from the Application Design Toolbox, you cannot print a listing of all process compilation errors. Also, if you try to navigate to the source of process compilation error, you will see a screen which displays a "0" as the only data. This has been corrected. (#5899)
The Appx/Oracle interface will now include optimizer (index) hints when producing select statements. These hints can be disabled by setting the following environment variable: "APPX NO INDEX HINTS=1". (#5900)
Executing a query (process) against an RDBMS-hosted table can result in an erroneous "No Lines Output" message. This can happen when an alpha key segment is partially constrained and the key segment is stored in a VARCHAR column. This has been corrected - we will now pad the "END AT" constraint with high-alpha values. (#5902)
Starting with release 4.1.4, the Appx license server will resume it's cleanup of "ghosted" sessions. Prior to release 4.1.4, you had to define the "APPX LS GHOSTS" environment variable to cause the license server to cleanup after failed sessions. You can prevent ghost cleanup now by defining the environment variable: "APPX LS NO GHOSTS=1". ASI recommends that you accept the default. (#5904)
When an internal error (or other GPF-type fault) is encountered, Appx for Windows produces a stack dump entry in the appx.stk file. Prior to release 4.1.4, a Windows bug made these stack dump files less useful than they might otherwise be. Starting with release 4.1.4, the stack dumps produced by Appx contain information which can help ASI determine the cause of an error. (#5905)
When using ASQL (to import table definitions into AppxODBC), you now receive a more understandable (hopefully) login dialog. This dialog explains which fields must be provided for each configuration and allows you to restrict the set of files presented by ASQL (by application and database). (Note that the ability to filter by application and database was added as a performance enhancement, not as security feature). (#5906)
On some screen resolutions, the icons used by ASQL (such as the open and closed folder icons) are not loaded properly - this can result in an empty list of databases/applications/tables. This has been corrected. (#5907)
If you execute a data-lookup against a record which is secured against you, you can still view the contents of the record (or at least the fields which are displayed from that record). This can happen when you execute a data-lookup against a file which contains a record-access security field. IMPORTANT NOTE: This bug has been addressed in release 4.1.4, however, to ensure that the fix does not adversely affect existing applications, you must define the following environment variable before Appx will honor security classes for data-lookup operations: "APPX HONOR DLU ACCESS=1". In a future release, we will remove the need for this environment variable - you should examine your applications now to ensure that this change will not adversely affect you in the future. (#5908)
Accessing an RDBMS-hosted file which contains a date field as the last field in the record can cause memory corruption errors. This has been corrected. (#5909)
If you define a work field whose name does not start with "WORK", Appx defaults the descriptive name and column headings incorrectly. This has been corrected. (#5915)
If you are viewing an event point in INQUIRE mode and another user (or another session) tries to view or edit that event point, he will be greeted with a "This record already held by another user" message. This has been corrected - viewing an event point in INQUIRE mode will not lock the entire event point. (#5916)

Enhancement

Running using the java client, when a logic field has the control type set to check box or toggle button the image editor will not tab into the field. (#5478)
Using the Java client it was impossible to select any item starting at 1,1. Also if you press insert in column 1 the text shown was moved one position to the right (after an ENTER!) but the original character in cloumn 1 was still there. The Java client also appeared to have trouble creating buttons for option numbers of more than one digit long starting in column 1. (#5706)
The "table naming scheme" field at the fms group level or at the sysdir level can contain a '$' followed by certain keywords. However, if a $ is actually part of the table name there is no way to include it. The parser would look for a valid keyword and not finding one it would reject the '$' and complain of an invalid keyword. This has been corrected. (#5885)

External

Two bugs fixed in AppxODBC:
- When importing a table using asql, the script built will now ignore APPX keys which are on substring fields. This is not supported by AppxODBC.
- The presence of an index which was a "prefix" of another index, would sometimes cause incorrect results to be returned in queries against the table. This has been corrected. The table should be re-imported using asql to take advantage of this fix.
(#4547)
In AppxODBC, when creating the table definition using the asql program, the column name is derived by removing the file name prefix from the field name. If this resulted in a column name starting with a digit it caused an error. This has been fixed by not removing the file name in this case. (#5418)
The script built by asql to import a table definition was not picking up a descending key if the key field was an Appx group header field. This has been corrected. (#5437)
When using AppxODBC in conjunction with the environment variable, "APPX DATA SERVER" to access, via ODBC, data from a remote APPX server, it was required to also set the environment variable, "APPX UID". This has been changed. Now AppxODBC will automatically generate the "APPX UID" variable from the userid/password specified in either:
- The ODBC client program's login dialog
- The AppxODBC Data Source
If the userid/password from both of those locations is blank, then the "APPX UID" setting from either the current environment or an appx.env file will be respected. (#5452)
In AppxODBC, when importing a table definition with the asql program, the generated script will include 2 additional statements:
- CREATE PUBLIC SYNONYM - this is so that other UserIDs which connect to AppxODBC can access the table without explicitly specifying the schema name.
- GRANT ALL PRIVILEGES - grants access to the table definition to all users.
The intent of this is that when multiple UserIDs are connecting to AppxODBC, each user will have access to the table definitions. This does not necessarily mean that each user will have access to the actual data contained in the files. That can be controlled by the standard APPX security mechanism. (#5454)
Two files used with AppxODBC, appx.fis and appx.idx, were stored in the root directory of the C drive. They are now stored in the appx.dbs directory (the directory created by mdcreate). For an existing installation, they will be automatically moved on the first use of the new AppxODBC driver. (#5863)

GUI Client

If you use the mouse to drag a rubber band around a group of widgets and try to move them, several things happen. 1) The "select" borders around the widgets flicker, turn odd colors, and some don't show a select border at all. 2) When you start dragging, the widgets move faster than the mouse and at different speeds. 3) When you release the mouse to complete the move, the widgets wind up all over the screen at random locations and sometimes the server just locks up. This does not happen if you use the CTRL key and click each widget to do the multi-select. This has been corrected. (#5477)
If you set the TABABLE flag on an item with a widget, the widget was not tabable when it is disabled. (#5723)
In the Image Editor, if you selected 2 widgets and click one of the toolbar buttons to "make them the same size", sometimes the widgets would snap to the correct size, then immediately jump back to their original sizes. (#5724)
Items with a widget type of Label could cause the label widget to grab the keyboard focus and then block any keystrokes from being processed. (#5788)
In the Java Client you can now user the FR (SCAN) key while positioned on a ListBox type of control to trigger an APPX Scan operation. This is handy for Token or Validation Table type fields that show as ListBox controls. Clicking the down arrow only expands the list. If you have a Data Lookup or are in Key Entry phase and want to lookup a PCF record, F2 will force the file scan to take place. (#5879)
In some cases, clicking a button on one screen and then clicking a button on the next screen without moving the mouse between the button click on the first screen adn the button click on the second screen would result in the srong button being triggered. (#5881)
After creating a new widget in the Image Editor, the Lasso Tool is reselected automatically. (#5882)
On some popup scroller screens that had no default button defined, the titlebar checkmark button was not getting the default button focus. This meant that if you pressed ENTER then you got no response since ENTER just fires the default button. (#5883)
Sometimes, the display of a token value was not showing the correct value. APPX was storing and executing it correctly, but the visual presentation of the value could have been wrong. (#5884)
To enable the java client to run on a browser, it needs to have a static location to store cache files. To provide this, the Java Client now creates and uses a /tmp/cache directory on the client machine to store all cache files. (#5913)
Customers outside of North America need to be able to enter accented characters into APPX GUI fields. This is now possible by using a non-US keyboard definition under windows and entering the proper accept character and then the character to be accented. This combination will enter the character with the appropriate accent. (#5914)

APPX 4.1.3

Bugs Fixed in Patch Release 4.1.3

When SETting a TEXT field equal to a Group of fields specified by a GROUP HEADER, if the destination length - source length > 256, the leftover pad bytes will no longer contain garbage. (#5450)
Executing a query, followed by an update, followed by a query, followed by an update no longer produces an ORA-01007 if the two update processes are using different partial-record I/O fields. (#5458)
Executing a REWRITE using a partial-record does not cause an ORA-24345 error when the rewrite occurs on a PCF which is constrained by a query and the query uses the entire record. (#5459)
A query which constrains the leading part of an alpha field (using GE and LE) will pick up records where the field begins with the specified value. The query was including the trailing blanks when comparing key values. (#5463)
Mixing partial-record I/O with data lookups will not cause a data lookup to fail. When reading a partial record and then trying to do a data lookup to the same file, the data lookup would inherit the partial-record group from the READ statement. If the partial-record group did not include the required display fields, the data lookup appeared to fail. (#5468)
Using an Alpha field defined with a Graphical Attributes type of PICTURE does not cause Appx system errors at runtime.

APPX 4.1.2

Bugs Fixed in Patch Release 4.1.2

Run-time

In System Administration, Security, Users, Documentation Rights, the ability to grant rights is being respected in all cases. Specifying both an application and a version was correctly working. Specifying an application with a blank version (granting rights to all versions of the app) was not working. Specifying a blank application and a blank version (granting rights to all applications) was not working. (#5368)
Windows® supports a number of different calling conventions. The two most frequently used are " stdcall" and " cdecl". The Appx CALL statement supports both of these calling conventions. Normally, the CALL statement can determine which calling convention to use based on the name of the function - if the function name contains an "@", we use the " stdcall" calling convention, otherwise we use the " cdecl" calling convention. We have found that most of the Win32 API functions (such as Sleep) are stdcall functions even though the function name is not decorated with a "@". This means that Appx cannot always determine the appropriate calling convention. Starting with release 4.1.2, you must include a trailing "@" if you are trying to call a stdcall function which does not follow the normal Windows naming standard. This means that a call to the Sleep function should be coded "kernel32.dll,Sleep@" (#5376)
Deleting a record from an Oracle table, where the record has a date segement in the primary key and the date segment is NULL, can cause a "No more records" error when using the APPX RDBMS NDK environment variable. If APPX RDBMS NDK is set to "00010101000000", the record would have been stored with a key value of "Jan. 1st, 0001 midnight". This has been corrected in release 4.1.2 (#5399)

Designer

The TRACE Review is working properly. Also after adding a "key control" to a field you will still be positioned on the field and if you press enter, data from the last field in the file will not be brought up. (#5369)
On Windows platforms, the T/F flags are displayed properly in the ILF debugger. (#5370)
On a screen with 24 rows, the ILF editor scan for keyword is working properly. It will display the statement keywords and will return the chosen one to the new statement. (#5372)
An update process, which is constrained by a query, will not fail with a "Record Not Held" error. This occured if the update process had two (or more) frames and an automatic child was invoked from one of the leading frames. The update processor was supposed to re-read (with HOLD) the PCF record when the child process ends (and the next frame begins), but the re-read was failing. So, when a REWRITE or DELETE statement was subsequently executed, the PCF record was not held. (#5395)
A query process which constrains a key containing a synonym will not incorrectly return 0 records. This occured if the key was defined by a group header, the group contained two or more fields, and the fields were not physically contiguous within the record buffer. (#5396)
A SET statement which refers to at least one group-header field does not produce incorrect results if one (or both) of the groups contains a field with multiple occurrences. (#5397)
Using the ORacle8 OCI together with an Oracle7 server can result in an error when trying to update a file which contains more than 255 columns. The error is "ORA-01745: invalid host/bind variable name". The actual number of columns does not have to exceed 255, it's the number of columns being updated pluse the number of segments in the primary key. SWS reports that using the OCIBindByName() function with alpha parameter markers will work around this problem. 4.1.2 will use OCIBindByName() unless the APPX NUMBER PARAMS environment variable is defined. (#5398)
Trying to perform partial-record I/O against a multi-occurrence field will operate against the first occurrence - all other occurrences will be ignored. In 4.1.2, a group which contains a multi-occurrence field will operate on all occurrences. If you want partial-record I/O to operate on all occurrences of a multi-occurrence field, you can wrap the field in a group. (#5400)
Defining a group which contains a synonym does not produce the error message "Group Contains Both Synonym and Referenced Field". The occured when the sequence number of the synonym is greater than 65535. (#5416)

External

The script built by asql to import a table definition now picks up a descending key even if the key field was an Appx group header field. (#5437)

APPX 4.1.2 Significant Issues

SET Statement and Group Header fields (fixed with release 4.1.2)
A condition exists in the SET statement that causes data to be lost when setting a GROUP HEADER type field to another GROUP HEADER field when the GROUP HEADER includes a multi-occurrance field. Only the first occurrance of the multi-occurrance field is set into the target group. All occurrances above 1 are left unset.
Error on REWRITE (fixed with release 4.1.2)
- A condition exists in Updates and Outputs that can cause APPX to fail on a REWRITE with the following message:
  - Error - No Record Currently Held
- This error seems to only affect multi-level updates and outputs and only then the "footer frames" for the update or output at the highest level and only then if there is a "Use Query" involved.
- If the process has a "Use Query" and the "header frame" executes an automatic process that rewrites the PCF record of the parent process and one of the following frames of the parent process contains a REWRITE to the PCF record without first executing a READ with hold the error will occur. Previous releases of APPX and applications converted from SPEED II allowed this type of update without an explicit READ with hold.
- APPX is failing to restore the hold on the PCF record after returning from a lower level process. This is possibly a side effect of the significant performance enhancements which were made to the Query processor. APPX will investigate to see if there is a way to restore the previous behavior.
- The workaround is to add a READ with Hold so that the hold is restored.

APPX 4.1.1

Bugs Fixed in Patch Release 4.1.1

"wm write reg() - wdgt write failed - Error - Already on File" in Java Client when auto generated buttons were defined on the scrolling image area. (#5346)
When defining a date field YMD as a Calendar/Clock control with a modifiable value of "?" indicating that it should only be modifiable during Initial Setup, In change mode the date is in fact, non-modifiable. However, the calendar button still displayed to the right of the field as active. If you clicked on it and pick a date, the date was stored in the record. (#5361)
Executing a query against a consecutive file does not causes CASSERT - "attempting to allocate 0 bytes". (#5356)
When executing a query process, if the query is constrained by child constraints, or the process which uses the query is constrained by child constraints, the child constraints are ignored. This has been corrected in release 4.1.1. (#5357)
You can now force Appx to create all alpha fields as VARCHAR columns in an Oracle database - see the FMS Attributes dialog for more information. (#5365)
A bug in the Oracle/Appx interface caused both of the following symptoms: 1) Attempting to modify the same record twice within a process occassionally resulted in a "record not on file" error. 2) Two BEG/END READ loops, with an embedded REWRITE statement, would result in the second loop taking nearly 10 times as long to complete. The error log would should that the REWRITE statement resulted in a "Integrity Constraint Violation" which gets translated to an "Already on File" error. (#5367)
A job process called, USER DEFAULTS, has been added to the --- application. This job can be invoked from your application to provide users with the ability to change their own printer and log defaults. It can be invoked with any invocation method, but using subprocess will cause it to overlay the current image. (#5362)
A process has been added which can be used to programmatically add users to the APPX user's file. An example of how to use this can be found in the 1EX subroutine, ADD USER API (EXAMPLE). (#5363)
All known Image Editor errors related to Widget Already On File errors and other minor Image Editor fixes.

Known Outstanding Issues

If you use ILF code to update widgets with the --- WIDGET file, these changes remain in effect until the EM is removed from memory and reloaded from disk. This reload only happens when an EM must be rebuilt, you exit the APPX session, or the EM is pushed out of memory and must be reloaded. To deal with this issues, just make sure you set both side of a test. Don't assume a widget will have a certain value and only set it on the exception condition. Always set it.
The PRINTER file in 0SA has System ID defined as a Unique Alternate key. This is going to cause a problem when defining local printers for client side printing. This means that only one printer can be defined with a blank System ID. The Blank system id indicates that the default printer is to be used.
It also means that no two users can have the same "named" printer. Essentially, you cannot define user-specific PRINTER records. So, if two users both have a local printer named "HP Laserjet 4", they will need to both user the same printer definition record or one of them will need to change the name of the printer as defined on their client PC.

Designer

If you edit a process description, an Em rebuild is not triggered for processes which access that process via an optional child which means that the "Process" pull-down menu item will not reflect the new process description.
An Xref on ILF Statements presents a screen of statements to choose from. This list does not include some of the new statements which were added in release 4.1.

Enhancement

You can control the frequency of COMMIT operations when importaing data into an RDBMS. Set the APPX IMPORT COMMIT environment variable to the number of records you would like to import before commiting changes to the database. The default value for commit frequency is 1. You can drastically reduce the amount of time required to import large tables by setting this environment variable to a large number (1000 or more). We have not provided a way to control the commit frequency for RDBMS restructures.

GUI Client

When scanning with the Java client, a single click will select a record and return it to the data entry screen unless the desired record is the first record listed on the scan screen. In that case, a double click is required. The first record is already "selected" when the scan screen is initially displayed.
The At Appearance clause of the ENABLE/DISABLE commands seems to be ignored. Only the last appearance of widgets with the same name are being acted on.

Items Fixed or Added in this Release

Restructuring a file, then without exiting APPX running processes utilizing that file would sometimes give the error "Cannot write to cache, invalid prototype record". This has been corrected. (# 318)
Performing a QUERY on a very large file could result in a PBUTIL.3231 "oops - Error - Position Undefined" on the subsequent OUTPUT or UPDATE process. The query processor has been completely rewritten for 4.1, so this problem no longer exists. (#2873)
Cached I/O - APPX 4.1 introduces the ability to create and access cached instances of files in memory. This can result in significant reductions in File I/O during posting and reporting processes. See this document for further explanation and an example of the use of this feature. (#5024)
Printing to the O/S print spooler thru appx print can intermittently die at occasional customer sites, due to operating system anamolies.
In 4.1, we are publishing source code for a compiled version of 'appx print' (appx print.c), that can be customized and compiled by distributors and endusers, to deal with these anamolies when they occur. (#5079)
Starting with release 4.1.0, you no longer need a GCS registration to start a local copy of an Appx server (when using an Appx client). (#5196)
Starting with 4.1.0, if you try to start an Appx client and you don't have a valid GCS registration, the client will still start, but it will display a screen telling the user that a GCS registration is not present. (#5244)
You can position the cursor on the file name portion of a READ statement (or any other I/O statements) and invoke OPTION 94. You will immediately be taken to the DD constrained to that file, where you'll have access to the file event points. (#5269)

Run-time

When editting the Date Mask override under System Administration's "Applications" editor, if you enter the string, am, to indicate that am/pm should be displayed, it was erroneously saved with double quotes surrounding the am. This was also occurring in the "Languages" editor. This has been corrected in both places. (#2598)
The APPX Client now displays multi-line APPX text fields as Windows® type text controls. The text cursor stays within the text field until you are done entering and editing the entire text field. Since it is a "true" text control, all of the standard Windows editing features are available including the ability to cut & past the entire field. (#2640)
When using option-99 to invoke a menu process, from which an input process was invoked, when eventually ending the menu process it was possible to receive "Error - Missing or Invalid Process Definition Record". This has been corrected. (#3557)
Release 4.1 increases the maximum APPX/IO file size on the following platforms:
- AIX & Solaris increased to 4 Gb from 2 Gb
- Windows increased to 2 Gb from 1 Gb
(#3639)
SET statements involving GROUP HEADER fields which contain SYNONYM's will now respect the fact that the component fields may not be contiguous. Other ECR's resolved by this fix are: 3608, 4392, 4745, 4991.
Two minor issues to point out regarding GROUP HEADER fields which are made up of fields which are not contiguous:
- The GROUP HEADER may not appear to have the correct contents when viewed in the debugger.
- A SET into the GROUP HEADER can not be a constant, but must be a field.
(#3746)
On a Disposition screen, the "Printer ID" and "Form ID" fields are scannable. >From the scan screen the default processes can be accessed for editing these files. These default processes are now accessible only to APPX security administrators. (#4059)
The Java client will now display a scan indicator for image items which are scanable due to a SCAN statement. For this to occur, the field must be mentioned in both an AT FIELD statement and on the left hand side of a SCAN statement. A scan indicator will also be present for key fields during the KEY ENTRY phase, indicating a PCF scan is available. (#4620)
You could not scan from Query Setup, Record Selection if your query process is defined in an application with a version other than '00'. This has been corrected. (#4758)
Restructure of a file could incorrectly generate "Can't write LFN record - Error - Already on file". This has been corrected. (#4803)
In certain instances a query/output could generate "Error - Cannot Access Required File; Unable to translate message: 37 (200450,0)". This problem has been corrected. (#4804)
An error, "Error - DEFINE Statement Error" could sometimes occur when using Scan. This has been corrected. (#4874)
A Data Lookup scan on a non-modifiable item would result in a "mm alloc() - zero bytes requested" error. This has been corrected. Now a data lookup scan, a statement scan, or a token scan, if performed on a non-modifiable item will display the scan screen but not return a selected value to the screen. (#5063)
The new (4.0) scan processor would not display a field from the scan file if the field's contents exceed the defined maximum width of the scan record (132). The old scan processor (3.5 and prior) would truncate this field. This behavior has been corrected for certain field types. Fields which are type alpha, substring, or format, will now be displayed and truncated in this situation. (#5136)
Using the Win32 client, you could not paste accented characters. This has been corrected. (#5203)

Designer

The "Print Totals" question on the field level AA popup, will now be used to default the item level "Auto-Total Type" field on output images. (#2113)
On automatic and optional children the "AA" indicator was not being set properly with respect to the "Default Mode" field. It was also not being set at all for the "Hidden Child" field. These have been corrected. (#2807)
If design transfer was used to overwrite part of a process (by transferring either a frame or an image), this did not update the destination process' date changed. Thus the EM for that process was not obsoleted by the transfer. This has been corrected. (#3105)
Change All References of a Domain had several problems. It wasn't working properly if you changed from a local domain to a foreign domain. Also, the domain itself (not the references to it) will now only be changed if the following conditions are met:
- From App Id & To App Id must both be equal to the Source App Id.
- The To domain must not already exist.
(#3140)
Using END to exit the image editor would always update the audit info of the image, frame, and process. This has been corrected. The image editor will now cause audit info to be updated after END'g only when changes have been made. (#3467)
Design transfer of processes has a new option, "Retain Audit Info". This can be used to retain the audit info of the source rather than to set it to the transfer date. See the field's help text for more information. (#3468)
After doing a design transfer, the input screen will now be repeated for an additional transfer rather than ending. The field values will also be preserved for subsequent transfers. (#4431)
If a Restructure operation failed for some reason, subsequent Restructures coul d fail with errors like "Element file write - error already on file". This has been corrected. Failed Restructures will now do a better job of cleanup. This fix also remedies the problem described in ECR #4966. (#4570)
If two fields on an image had a statement scan defined, it was possible to scan on one of them and have the selected value be returned into both fields. This has been corrected. (#4667)
Year 2000 dates were displaying incorrectly on some of the technical documentation reports. This has been corrected. (#4711)
An "IPC Listings" menu has been added to the Toolbox, "Source Analysis" menu. IPC (Inter Process Communication) fields are internal fields which control the sharing characteristics of APPX design elements. The utilities on this menu can find and fix exceptions from standard values. (#4794)
When defining a box, a box type of "NONE" is now available. This can be used to remove an existing box. Box placement on the image will now be adjusted if the row/column where the box starts is moved by inserting or deleting rows/columns. Note that the size of a box can not yet be changed by inserting or deleting rows/columns, but the location can be changed. (#4820)
"Quick Restructures" have been added. For a file which is defined in the data dictionary as variable length (file level AA popup), fields added at the end of the record will not require a regular restructure. The restructure process must still be run, but only the file header will be processed, not each individual record. (#4832)
An image where a field appeared multiple times, each of which had DLU's coded to different files, could result in not being able to SCAN on these fields. This has been corrected. (#4870)
When adding fields to a file, the Display Sequence will no longer default to "1". (#4887)
An exit confirmation screen has been added to the Interactive Cross Reference to reduce the chance of accidently exiting and having to then re-run the cross reference. (#4906)
On Intel platforms, using the "Convert Field to Domain" option on a token field would lose the token records. They would remain under the old name and be orphaned. This has been corrected. (#4927)
The "Renumber Fields" option available from the File level toolbox and also from the Application Design Toolbox can cause problems with the File level "Record Protection" fields. The record protection fields are stored at the file level by their sequence number. These utilities were not updating these sequence numbers. This has been corrected. (#4928)
The "Renumber Fields in This File" option in the File level toolbox was supposed to renumber a single file only. It was incorrectly renumbering other files also, beginning with the current file. This has been corrected. (#4930)
On optional children the "AA" indicator was not being set properly with respect to the "Invocation Type" field. This has been corrected. (#4931)
A Query generated from one of the Toolbox "Process Generation" utilities, did not have it's "Enduser Selection's" additional attributes fields generated properly. They were different then if you added a selection record manually. This has been corrected. (#4937)
The frame level toolbox option to generate a column heading frame in input processes is now also available for output processes. (#4943)
The "Reference Browser" utility has been added to the process level, toolbox menu. This utility provides a convenient tool to list each design component referenced by the selected process. The results are similar to the "Interactive Cross Reference", and provide for "jumping" to the references and to the referenced item itself. One use of this is to identify the files used by a process and to optionally edit the file level event points for those files. (#4971)
The Cross Reference utilities now has an option to include ILF statements which have been commented out. (#4978)
In the System Administration, Users file, the "System Id" column has been retitled to "0/S Login Id". This title better describes the field. (#5014)
The ILF code generated in a comma delimited update to handle multi-occurrance fields was not being generated properly on Intel platorms. This has been corrected. (#5017)
A new utility, "Recalculate Dictionary Hash ID's", has been added to the Language Translation menus in both System Admiistration and Application Design. You should run this job if you edit certain fields in any language record for which entries are present in the dictionary. See help text for more info. (#5053)
While editing a field, using option-2 to view the "Data Lookup" popup, then proceeding with three RETURN's could unnecessarily bring up the "Key Control" popup. This has been corrected. (#5074)
When adding optional or automatic children to a process, the warning of "This Process is Invoking Itself" was not respecting the application id of the child. This has been corrected. (#5129)
Using "Change All References" on a field name where the utility would change the references and the field itself to a new name, would result in token records being orphaned under the old field name. This has been corrected. (#5188)
Boxes were originally implemented as CHR records in 4.0. With 4.1 they have been re-implemented as records in the WIDGET file. CHR boxes can be converted to WIDGET boxes by running a new utility on the Source Analysis Menu. (#5234)
If you made a change in the ILF editor, then decided to discard the changes by pressing CANCEL, the changes were correctly discarded, but the audit info was still updated. This has been corrected. (#5235)
Design transfer of domains now provides for processing the data dictionary. It's not technically necessary if transferring a new domain into the destination application. But if replacing an existing domain, processing the data dictionary should be done to update fields dependent on the domain. (#5255)
--- subroutine processes have been created to simplify the usage of some of the more popular rt function calls. For examples on how to use them, see the following subroutines in the 1EX application.
- GET CMD LINE PARM (EXAMPLE)
- GET ENV VAR (EXAMPLE)
- GET FILE FROM CLIENT (EXAMPLE)
- LOAD URL ON CLIENT (EXAMPLE)
- SEND FILE TO CLIENT (EXAMPLE)
- STREAM FILE (EXAMPLE)
(#5296)
A Design Transfer API has been added. This is for developers who want to issue transfer requests from within their applications. See the 1EX/00, subroutine process, DESIGN XFER API (EXAMPLE) for more information. (#5297)

Enhancement

Query processes will now respect key fields in the PCF. This can significantly increase query performance by reducing the number of records which the query needs to process. (#4199)
A "Copy Fields" option has been added to the field level Toolbox menu. It can be used to copy one or more fields into the currently selected file. Fields can be copied from the same file or a different file. (#4830)
Event points can now be defined at the file level. ILF in these event points will be executed by APPX at appropriate points based on file access by processes. The new event points and when they are executed are as follows:
- FILE OPEN, immediately after APPX opens the file
- POST READ, immediately after APPX reads a record
- PRE UPDATE, just before APPX writes or rewrites a record
- POST UPDATE, just after APPX writes, rewrites, or deletes a record
- FILE CLOSE, will happen when the file is last closed.
Access to the file level event points for the PCF has been integrated into the "Rules" popups for processes, frames, and images. (#4836)
An "Identity" system administration file has been added. An Identity is used to store login information for various external interfaces. An Identity can exist for each FMS Group/User combination.
File maintenance for Identities is available as an option when editing "Users" or when editing "File System Groups". (#4849)
In "Database Management", "File Specifications", there is a new optional child, "Field Overrides". Field Overrides are used by the RDBMS interfaces (Oracle, Sybase, ODBC, etc.). With Field Overrides an administrator can specify field level parameters (such as column name and data type) to be used by the engine in communicating with the RDBMS. (#4853)
The FMS Control String (which was accessible in System Administration for FMS Groups and in Data Base Management for individual files) has been retitled. It is now referred to as FMS Group Attributes and as File Attributes, respectively.
Additionally, the attributes are now prompted for as individual specifications instead of as a control string for certain FMS Types (Oracle, Sybase, ODBC, APPX/Net).
The older control string is still supported, but the specification based entries is the preferred method of providing this information. (#4857)
AppxODBC will now enforce the following APPX security features.(Not in first beta.) (#4919)
- File & Field level read security code
- File & Field level modify security code
- Record Access Protection
- Record Delete Protection
- Record Key Protection
There is a new field in "System Parameters" called "Auto Select All Files". By setting this to "N", Database Management, Design File Management, and System Administration File Management, will default to no files selected and present the file selection screen, instead of automatically selecting all files. (Not in first beta.) (#5021)
File level event points should now execute when files are accessed using AppxODBC. (#5089)
The field "Require Table Value?" has been added to the AA popup of an alpha or format field/domain whenever a validation table is present. Setting it to "N" will cause the validation table to be "advisory only". This means that when editing the field, SCAN will present the validation table and allow selection, however the user can make an entry into the field which is not defined in the validation table. (#5177)
Two new environment variables have been added to aid in debugging situations: (#5182)
- APPX IO LOG=filename causes AppxIO to log all file I/O.
- APPX FMT IO LOG=1 causes the IO log to be formatted for human readability. The human readable format has numeric result codes from I/Os. They are keys to the 0LA MESSAGE file.
- Keystrokes and process names are included in the IO log as well.

External

APPX for SCO and LINUX didn't honor shadow-passwords, generating an 'Incorrect Login Information' error. This has been corrected. (#4848)
A debugging statement ('whoami') not supported by all flavors of UNIX was commented out of appx print. (#4959)
The 0UT application, distributed with APPX release 4.1, introduces the following features:
- Importing table definitions from certain back end databases
- Importing file definitions from a text file
- Generating an APPX data dictionary from these imported definitions
- Generating a template application from a data dictionary
Additional information is available in a separate document and in the online help of the 0UT application. (#4979)
Sample subroutines dealing with upper/lower case conversions have been added to the 1EX/00 application. See the subroutine, CNV EXAMPLE, for information. (#5004)

APPX 4.1.0

Important Notes

In support of some of the new features in APPX 4.1, we compiled using newer OS levels on some platforms. Below is a list of the platforms and OS levels that we were required to upgrade. We cannot guarantee that APPX 4.1 will run on older versions of these operating systems. Any other platforms were compiled with the same OS levels we have used in the past.
- Solaris 8 - SunOS 5.8
- AIX 4.3.3
- NCR SRV4 MP-RAS Version/Release 03.02.00.39
It is very important to note that you will not be able to downgrade an application once it has been converted to release 4.1. In 4.1, we have changed the format for the I/O-related ILF statements. These changes are not backward compatible.
You cannot convert applications between Intel and RISC byte-ordering at the same time that you upgrade from a previous release to release 4.1. If you need to move an application from an Intel machine to a RISC machine, you must export the application from the Intel machine and import the application on the RISC machine using the same Appx release. Once you have changed byte-ordering, you can then upgrade that application to release 4.1. Note that you can upgrade the application first, then change byte-ordering. You just can't do both operations in one step.
APPX now supports Oracle 8 by default. We do still support Oracle 7 but you will need to use the Oracle 8 client software provided by Oracle. If you want to connect to an Oracle 7 server, you must set the environment variable APPX_ORACLE7_SERVER=1 before running APPX.
Release 4.1 does not support the Sybase database interface. We are not dropping support for Sybase and will issue an update in the near future which implements new features and performance improvements for Sybase.
The structures of some design files have changed in 4.1. A restructure of these design files is not required. We have provided a utility in System Administration, Database/Applications, Design File Management which you can use to clean up a few of the attributes in each of your applications. This utility will clear out the new "PCF Partial-record I/O" specification (in Processes/Additional Attributes), it will create some new design files (WIDGET, RESOURCE, and RESNAMES), and will convert any old-style box-drawing specifications into the format supported by release 4.1. (Note: if you don't use this utility on each of your applications, you will need to create the new design files yourself and you will receive warning messages when you try to edit a process which has random data in the PCF Partial-record I/O field.)
We have made very significant changes to the Appx/RDBMS interfaces. You should become familiar with these changes before you install this release. In particular, record locking has been re-implemented to provide better performance and this can change the way your applications will work in a multi-user environment.

Known Outstanding Cosmetic Issues

In some cases, after exiting Option-Help, the screen is mistakenly panned up one row.
When entering a color specification using the Java client, you can see the RGB value for that string and the field also changes it's background to display the selected color. If the color you choose is similar to the color used to display foreground text, you will not be able to see the RGB value. For example, choosing the RGB value for blank will result in black text displaying in a black background.
The buttons in Cross-Reference (All) aren't lined up properly.
If you choose the Database management option from the toolbox (in query processes), the buttons are not all the same size.
When using the auto generated output processes, the edit field/item generation seq screen has extra Y/N boxes under the "Query ?" field that extend beyond the last field listed for the file the report is being generated for.
The process level toolbox menu has some buttons that are shorter than others. Doesn't look neat.
If you select Additional Attributes when you are in the Frames level of the Input Process Editor, the titlebar in the background changes it's text to read "Fram".
After running create file in design file management, there are leftover white and black cursor look-alikes in the lower left hand corner.
The range check for an Alpha field (in Additional attributes, when you are adding a field)is squished by the scan indicator. The blanks allowed indicator is truncated by the scan indicator. There is an extra box at the bottom of the popup (near Translate).
In Enduser Selections, when adding a query, the buttons at the bottom are not well aligned.
For a date field - the binos to select the date types to store overlap the word "thru". It also looks like the field that defaults to CC is smaller than the one that defaults to DD. In additional attributes, the storage type "packed Decimal" is truncated, but there is plenty of room to write it out. There are also binos on the left scan and a scan arrow on the right side.
Using the "Move Rows" option in the image editor will cause all GUI attributes to be lost for the row (or rows) being moved.
When running the Java Client with the -font=fixed option, in Application Design, the "Process Management" menu title is truncated to "Process Manage...".
The Java Client displays hidden Y/N fields. An example can be found by looking at a DOMAIN for a numeric field where the checkbox for seq number is displayed as disabled with no label to the left of it. Another example of this can be found when you press INQUIRE on the image editor to view/edit the field attributes.
The image editor displays widgets which are defined as a checkbox with random values. Sometimes it displays checked, sometimes it displays with a ? and sometimes it displays blank.

Other Known Outstanding Issues

If you use ILF code to update widgets with the --- WIDGET file, these changes remain in effect until the EM is removed from memory and reloaded from disk. This reload only happens when an EM must be rebuilt, you exit the APPX session, or the EM is pushed out of memory and must be reloaded. To deal with this issues, just make sure you set both side of a test. Don't assume a widget will have a certain value and only set it on the exception condition. Always set it.

The PRINTER file in 0SA has System ID defined as a Unique Alternate key. This is going to cause a problem when defining local printers for client side printing. This means that only one printer can be defined with a blank System ID. The Blank system id indicates that the default printer is to be used.

It also means that no two users can have the same "named" printer. Essentially, you cannot define user-specific PRINTER records. So, if two users both have a local printer named "HP Laserjet 4", they will need to both user the same printer definition record or one of them will need to change the name of the printer as defined on their client PC.
The BROWSE button on the Local login tab is not fully implemented - when you change directories, the list of file in the new directory will not be displayed.
It has been reported that a menu built with design buttons and a drop down menu "feels slower" than an Auto-GUI menu.

Run-time

SCAN on the cached instance of a file does not return values from the selected record.

Designer

If you edit a process description, an Em rebuild is not triggered for processes which access that process via an optional child which means that the "Process" pull-down menu item will not reflect the new process description.
If you Add a named resource through the Gui Attributes screen (by scanning and choosing the option to add), after the resource has been added, it isn't selectable from the list by use of mouse. It does behave normally if you type in the name.
If you have multiple date fields on an image, but only one uses a date/calendar chooser, when you invoke the process, all the date fields call for data entry via date choosers.
When adding a border to a picture, the Border Color option isn't working.
When adding a named resource - the file chooser won't take you "Up one level" to search for a file throughout the machine.
In the Java client when entering an In Progress Message for a job process - When all the spaces available in the field are used, the cursor erases what has been entered and returns to the start of the field.
In an input process where a work field painted on the image contains the text of a generated button, and the work field has read security rights upon it so that the button should only appear for certain users, the Java client displays the button for all users.
An Xref on ILF Statements presents a screen of statements to choose from. This list does not include some of the new statements which were added in release 4.1.

Enhancement

You can control the frequency of COMMIT operations when importaing data into an RDBMS. Set the APPX IMPORT COMMIT environment variable to the number of records you would like to import before commiting changes to the database. The default value for commit frequency is 1. You can drastically reduce the amount of time required to import large tables by setting this environment variable to a large number (1000 or more). We have not provided a way to control the commit frequency for RDBMS restructures.

GUI Client

The GUI Client option to Always Dock Scrollbar does not seem to work.
When scanning with the Java client, a single click will select a record and return it to the data entry screen unless the desired record is the first record listed on the scan screen. In that case, a double click is required. The first record is already "selected" when the scan screen is initially displayed.
When using the image editor's "Paint a box or line" tool, it does not seem possible to paint a line.
The At Appearance clause of the ENABLE/DISABLE commands seems to be ignored. Only the last appearance of widgets with the same name are being acted on.
A left click to select a widget on the image editor followed quickly by a right click to show the popup menu executes a double click and also displays the popup menu.
The "Invis?" attribute does not seem to be honored for a button widget when set to N. Setting it in the WIDGET record also does not work.
The help "?" always appears on the title bar of a menu even when you specify that it should not.

Items Fixed or Added in this Release

Restructuring a file, then running processes utilizing that file without exiting APPX does not give the error "Cannot write to cache, invalid prototype record". (#318)
Performing a QUERY on a very large file does not result in a PBUTIL.3231 "oops - Error - Position Undefined" on the subsequent OUTPUT or UPDATE process. (#2873)
Cached I/O - APPX 4.1 introduces the ability to create and access cached instances of files in memory. This can result in significant reductions in File I/O during posting and reporting processes. See this document for further explanation and an example of the use of this feature. (#5024)
Printing to the O/S print spooler thru appx print can intermittently die at occasional customer sites, due to operating system anamolies.
In 4.1, we are publishing source code for a compiled version of 'appx print' (appx print.c), that can be customized and compiled by distributors and endusers, to deal with these anamolies when they occur. (#5079)
Starting with release 4.1.0, you no longer need a GCS registration to start a local copy of an Appx server (when using an Appx client). (#5196)
Starting with 4.1.0, if you try to start an Appx client and you don't have a valid GCS registration, the client will still start, but it will display a screen telling the user that a GCS registration is not present. (#5244)
You can position the cursor on the file name portion of a READ statement (or any other I/O statements) and invoke OPTION 94. You will immediately be taken to the DD constrained to that file, where you'll have access to the file event points. (#5269)

Run-time

When editting the Date Mask override under System Administration's "Applications" editor, if you enter the string, am, to indicate that am/pm should be displayed, it was erroneously saved with double quotes surrounding the am. This was also occurring in the "Languages" editor. This has been corrected in both places. (#2598)
The APPX Client now displays multi-line APPX text fields as Windows® type text controls. The text cursor stays within the text field until you are done entering and editing the entire text field. Since it is a "true" text control, all of the standard Windows editing features are available including the ability to cut & past the entire field. (#2640)
When using option-99 to invoke a menu process, from which an input process was invoked, when eventually ending the menu process it was possible to receive "Error - Missing or Invalid Process Definition Record". This has been corrected. (#3557)
Release 4.1 increases the maximum APPX/IO file size on the following platforms: (#3639)
- AIX & Solaris increased to 4 Gb from 2 Gb
- Windows increased to 2 Gb from 1 Gb
SET statements involving GROUP HEADER fields which contain SYNONYM's will now respect the fact that the component fields may not be contiguous.
Two minor issues to point out regarding GROUP HEADER fields which are made up of fields which are not contiguous:
- The GROUP HEADER may not appear to have the correct contents when viewed in the debugger.
- A SET into the GROUP HEADER can not be a constant, but must be a field.
(#3746, 3608, 4392, 4745, 4991)
On a Disposition screen, the "Printer ID" and "Form ID" fields are scannable. From the scan screen the default processes can be accessed for editing these files. These default processes are now accessible only to APPX security administrators. (#4059)
The Java client will now display a scan indicator for image items which are scanable due to a SCAN statement. For this to occur, the field must be mentioned in both an AT FIELD statement and on the left hand side of a SCAN statement. A scan indicator will also be present for key fields during the KEY ENTRY phase, indicating a PCF scan is available. (#4620)
You can now scan from Query Setup, Record Selection even if your query process is defined in an application with a version other than '00'. (#4758)
Restructure of a file does not incorrectly generate "Can't write LFN record - Error - Already on file". (#4803)
In certain instances a query/output could generate "Error - Cannot Access Required File; Unable to translate message: 37 (200450,0)". This problem has been corrected. (#4804)
An error, "Error - DEFINE Statement Error" could sometimes occur when using Scan. This has been corrected. (#4874)
A data lookup scan, a statement scan, or a token scan, if performed on a non-modifiable item will display the scan screen but not return a selected value to the screen. (#5063)
The new (4.0) scan processor would not display a field from the scan file if the field's contents exceed the defined maximum width of the scan record (132). The old scan processor (3.5 and prior) would truncate this field. This behavior has been corrected for certain field types. Fields which are type alpha, substring, or format, will now be displayed and truncated in this situation. (#5136)
Using the Win32 client, you can paste accented characters. (#5203)

Designer

The "Print Totals" question on the field level AA popup, will now be used to default the item level "Auto-Total Type" field on output images. (#2113)
On automatic and optional children the "AA" indicator was not being set properly with respect to the "Default Mode" field. It was also not being set at all for the "Hidden Child" field. These have been corrected. (#2807)
If design transfer was used to overwrite part of a process (by transferring either a frame or an image), this did not update the destination process' date changed. Thus the EM for that process was not obsoleted by the transfer. This has been corrected. (#3105)
Change All References of a Domain had several problems. It wasn't working properly if you changed from a local domain to a foreign domain. Also, the domain itself (not the references to it) will now only be changed if the following conditions are met: (#3140)
- From App Id & To App Id must both be equal to the Source App Id.
- The To domain must not already exist.
Using END to exit the image editor would always update the audit info of the image, frame, and process. This has been corrected. The image editor will now cause audit info to be updated after END'g only when changes have been made. (#3467)
Design transfer of processes has a new option, "Retain Audit Info". This can be used to retain the audit info of the source rather than to set it to the transfer date. See the field's help text for more information. (#3468)
After doing a design transfer, the input screen will now be repeated for an additional transfer rather than ending. The field values will also be preserved for subsequent transfers. (#4431)
If a Restructure operation failed for some reason, subsequent Restructures could fail with errors like "Element file write - error already on file". This has been corrected. Failed Restructures will now do a better job of cleanup. (#4966 and #4570)
If two fields on an image had a statement scan defined, it was possible to scan on one of them and have the selected value be returned into both fields. This has been corrected. (#4667)
Year 2000 dates are displayed incorrectly on all technical documentation reports. (#4711)
An "IPC Listings" menu has been added to the Toolbox, "Source Analysis" menu. IPC (Inter Process Communication) fields are internal fields which control the sharing characteristics of APPX design elements. The utilities on this menu can find and fix exceptions from standard values. (#4794)
When defining a box, a box type of "NONE" is now available. This can be used to remove an existing box. Box placement on the image will now be adjusted if the row/column where the box starts is moved by inserting or deleting rows/columns. Note that the size of a box can not yet be changed by inserting or deleting rows/columns, but the location can be changed. (#4820)
"Quick Restructures" have been added. For a file which is defined in the data dictionary as variable length (file level AA popup), fields added at the end of the record will not require a regular restructure. The restructure process must still be run, but only the file header will be processed, not each individual record. (#4832)
An image where a field appeared multiple times, each of which had DLU's coded to different files, could result in not being able to SCAN on these fields. This has been corrected. (#4870)
When adding fields to a file, the Display Sequence will no longer default to "1". (#4887)
An exit confirmation screen has been added to the Interactive Cross Reference to reduce the chance of accidently exiting and having to then re-run the cross reference. (#4906)
On Intel platforms, using the "Convert Field to Domain" option on a token field will not lose the token records. (#4927)
The "Renumber Fields" option available from the File level toolbox and also from the Application Design Toolbox can cause problems with the File level "Record Protection" fields. The record protection fields are stored at the file level by their sequence number. These utilities are now updating these sequence numbers. This has been corrected. (#4928)
The "Renumber Fields in This File" option in the File level toolbox was supposed to renumber a single file only. It was incorrectly renumbering other files also, beginning with the current file. This has been corrected. (#4930)
On optional children the "AA" indicator is now being set properly with respect to the "Invocation Type" field. (#4931)
A Query generated from one of the Toolbox "Process Generation" utilities, did not have it's "Enduser Selection's" additional attributes fields generated properly. They were different then if you added a selection record manually. This has been corrected. (#4937)
The frame level toolbox option to generate a column heading frame in input processes is now also available for output processes. (#4943)
The "Reference Browser" utility has been added to the process level, toolbox menu. This utility provides a convenient tool to list each design component referenced by the selected process. The results are similar to the "Interactive Cross Reference", and provide for "jumping" to the references and to the referenced item itself. One use of this is to identify the files used by a process and to optionally edit the file level event points for those files. (#4971)
The Cross Reference utilities now has an option to include ILF statements which have been commented out. (#4978)
In the System Administration, Users file, the "System Id" column has been retitled to "0/S Login Id". This title better describes the field. (#5014)
The ILF code generated in a comma delimited update to handle multi-occurrance fields was not being generated properly on Intel platorms. This has been corrected. (#5017)
A new utility, "Recalculate Dictionary Hash ID's", has been added to the Language Translation menus in both System Admiistration and Application Design. You should run this job if you edit certain fields in any language record for which entries are present in the dictionary. See help text for more info. (#5053)
While editing a field, using option-2 to view the "Data Lookup" popup, then proceeding with three RETURN's could unnecessarily bring up the "Key Control" popup. This has been corrected. (#5074)
When adding optional or automatic children to a process, the warning of "This Process is Invoking Itself" was not respecting the application id of the child. This has been corrected. (#5129)
Using "Change All References" on a field name where the utility would change the references and the field itself to a new name, would result in token records being orphaned under the old field name. This has been corrected. (#5188)
Boxes were originally implemented as CHR records in 4.0. With 4.1 they have been re-implemented as records in the WIDGET file. CHR boxes can be converted to WIDGET boxes by running a new utility on the Source Analysis Menu. (#5234)
If you made a change in the ILF editor, then decided to discard the changes by pressing CANCEL, the changes were correctly discarded, but the audit info was still updated. This has been corrected. (#5235)
Design transfer of domains now provides for processing the data dictionary. It's not technically necessary if transferring a new domain into the destination application. But if replacing an existing domain, processing the data dictionary should be done to update fields dependent on the domain. (#5255)
--- subroutine processes have been created to simplify the usage of some of the more popular rt function calls. For examples on how to use them, see the following subroutines in the 1EX application.
- GET CMD LINE PARM (EXAMPLE)
- GET ENV VAR (EXAMPLE)
- GET FILE FROM CLIENT (EXAMPLE)
- LOAD URL ON CLIENT (EXAMPLE)
- SEND FILE TO CLIENT (EXAMPLE)
- STREAM FILE (EXAMPLE)
(#5296)
A Design Transfer API has been added. This is for developers who want to issue transfer requests from within their applications. See the 1EX/00, subroutine process, DESIGN XFER API (EXAMPLE) for more information. (#5297)

Enhancement

Query processes will now respect key fields in the PCF. This can significantly increase query performance by reducing the number of records which the query needs to process. (#4199)
A "Copy Fields" option has been added to the field level Toolbox menu. It can be used to copy one or more fields into the currently selected file. Fields can be copied from the same file or a different file. (#4830)
Event points can now be defined at the file level. ILF in these event points will be executed by APPX at appropriate points based on file access by processes. The new event points and when they are executed are as follows:
- FILE OPEN, immediately after APPX opens the file
- POST READ, immediately after APPX reads a record
- PRE UPDATE, just before APPX writes or rewrites a record
- POST UPDATE, just after APPX writes, rewrites, or deletes a record
- FILE CLOSE, will happen when the file is last closed.
Access to the file level event points for the PCF has been integrated into the "Rules" popups for processes, frames, and images. (#4836)
An "Identity" system administration file has been added. An Identity is used to store login information for various external interfaces. An Identity can exist for each FMS Group/User combination.
File maintenance for Identities is available as an option when editing "Users" or when editing "File System Groups". (#4849)
In "Database Management", "File Specifications", there is a new optional child, "Field Overrides". Field Overrides are used by the RDBMS interfaces (Oracle, Sybase, ODBC, etc.). With Field Overrides an administrator can specify field level parameters (such as column name and data type) to be used by the engine in communicating with the RDBMS. (#4853)
The FMS Control String (which was accessible in System Administration for FMS Groups and in Data Base Management for individual files) has been retitled. It is now referred to as FMS Group Attributes and as File Attributes, respectively.
Additionally, the attributes are now prompted for as individual specifications instead of as a control string for certain FMS Types (Oracle, Sybase, ODBC, APPX/Net).

The older control string is still supported, but the specification based entries is the preferred method of providing this information. (#4857)
AppxODBC will now enforce the following APPX security features.
- File & Field level read security code
- File & Field level modify security code
- Record Access Protection
- Record Delete Protection
- Record Key Protection
(Not in first beta.) (#4919)
There is a new field in "System Parameters" called "Auto Select All Files". By setting this to "N", Database Management, Design File Management, and System Administration File Management, will default to no files selected and present the file selection screen, instead of automatically selecting all files. (Not in first beta.) (#5021)
File level event points should now execute when files are accessed using AppxODBC. (#5089)
The field "Require Table Value?" has been added to the AA popup of an alpha or format field/domain whenever a validation table is present. Setting it to "N" will cause the validation table to be "advisory only". This means that when editing the field, SCAN will present the validation table and allow selection, however the user can make an entry into the field which is not defined in the validation table. (#5177)
Two new environment variables have been added to aid in debugging situations:
- APPX IO LOG=filename
  causes AppxIO to log all file I/O.
- APPX FMT IO LOG=1
  causes the IO log to be formatted for human readability. The human readable format has numeric result codes from I/Os. They are keys to the 0LA MESSAGE file.
  
  Keystrokes and process names are included in the IO log as well.
(#5182)

External

APPX for SCO and LINUX didn't honor shadow-passwords, generating an 'Incorrect Login Information' error. This has been corrected. (#4848)
A debugging statement ('whoami') not supported by all flavors of UNIX was commented out of appx print. (#4959)
The 0UT application, distributed with APPX release 4.1, introduces the following features:
- Importing table definitions from certain back end databases
- Importing file definitions from a text file
- Generating an APPX data dictionary from these imported definitions
- Generating a template application from a data dictionary
Additional information is available in a separate document and in the online help of the 0UT application. (#4979)
Sample subroutines dealing with upper/lower case conversions have been added to the 1EX/00 application. See the subroutine, CNV EXAMPLE, for information. (#5004

APPX 4.1.0 new features

GUI Design

Graphical specifications are now a first-class part of the Appx development environment. Your application can include pictures, buttons, wallpapers, boxes and lines, multiple fonts, multiple colors, and menus. You can also define the preferred representation for each on-screen item - for example, you might want to represent a numeric field as a progress bar.

Appx applications can now include pictures in a number of locations. The Appx client understands GIF, animated GIF, JPEG, or BMP picture formats. You can specify an icon for each frame or image. You can paint a picture anywhere within an image (using the drag-and-drop image editor). You can paint a picture onto any button. In fact, you can assign multiple pictures for each button - a picture to be displayed when the button is enabled, a picture to be displayed when the button is disabled, a selected picture, and a rollover picture. You can control the border style for pictures (and of course your buttons). Choose from no border, a simple line, or multiple 3D border styles (raised, etched, beveled, etc.).

In addition to buttons and pictures, you can specify an icon for each frame and image (this icon appears in the upper-left-hand corner of the frame). You can even define a wallpaper (background picture) for each frame and image. Or, just specify a background color.

And buttons can contain text as well. You can control the placement of the text within the button, the color of the text, and the font.

You can now mix fonts within an application. You can assign a font to each item, each label (what used to be called "background text"), each button, and to the titlebars of each frame and image. In addition to selecting the name of the font, you can control the style (italic, bold, or normal), the size of the font (relative to a baseline), and the color (both foreground and background).

We have changed the Appx color model from a 16-choice model into a true RGB model - anywhere you can specify a color (for example, the background color for an image), you can choose the red, green, and blue components. And, of course, if you are using a graphically enabled client, you can just point at the color you want within a color wheel.

You can draw boxes and lines to help group items together - again, you can control the border style, the colors, and the font (including style and size) used to title the box. You can also control the placement of the (optional) title within the box.

Release 4.1 also allows you to assign graphical specifications to your data. You can assign a preferred representation to each item. For numeric fields, you can specify raw text, slider, or a progress bar. For alpha fields, you can specify raw text, password, file chooser, color chooser, or picture. Date items can be represented by raw text, or by a clock/calendar control. And logic fields can be displayed as raw text, checkboxes, or toggle buttons (with or without pictures).

Of course you can specify the colors, fonts, and font styles for each item as well.

Painting an alpha field as a picture lets you store a picture in your data files. You can store the picture bits themselves, or you can store a file name or URL. See Resources below for more information.

Appx can add some design elements automatically. For example, Appx will build toolbars, pulldown menus, and popup (right-click) menus from the optional children defined in each process. By default, all optional children will appear on the Process menu. If you wish, you can also place optional children on a toolbar and in the popup menu. You can specify the name of the menu, the name of the toolbar, the color of the entry in the menu, the font (and style) of the menu entry, and the mnemonic (shortcut). You can also define toolbar icons (for enabled, disabled, rollover, etc.). You can define the placement of the label within the toolbar (and of course the color, font, and font style).

Appx also adds scan indicators for all scannable items. For tokenized fields, lookup tables, and suggestion tables (see below), Appx displays a drop-down listbox.

You have complete control over all graphical elements through ILF code. Prior to executing the Pre-Display event point, Appx fills the --- WIDGET memory file with all of the graphical specifications that the user is about to see. You can adjust the records in the WIDGET file using READ and REWRITE statements, or using some new convenience statements (ENABLE and DISABLE for example). We will be adding more convenience statements in the future.

Your application can use Named Resources to group pictures together. A Resource is a named collection of pictures - each picture within a resource has a state: enabled, disabled, rollover, wallpaper, etc.. You can store each picture in a different location - Appx supports the following location types:

Client File

The resource is stored on the client, in a file whose name you specify.

Client URL

The resource is found by the client, using a URL which you specify (such as https://www.appx.com/appx.gif

Server File

The resource is stored within a file on the host (and cached on the client).

Server URL

The resource is found by the server, using a URL which you specify.

Design

The resource is stored in your application's Resource directory, in a file whose name you specify.

Using a client-side resource gives the best performance, but the resource must be accessible from the client machine. Using a server-side resource makes it easier to distribute your application, but each resource must be sent to each client as needed (the resources are cached on the client though). You can use either a Server URL or a Client URL depending on which machine is behind a firewall. Using a location type of Design means that the resource becomes part of your application (as opposed to being part of your data).

Example - Wallpaper

APPX allows you to design GUI menus using various types of GUI widgets and features. You can design a menu to have the following types of GUI characteristics:

A custom titlebar for the menu frame
A specified border style around the menu frame
A wallpaper graphic or background color within the menu frame
Buttons on the menu image
Boxes and Lines on the menu image
Labels (text) on the menu image
Pictures on the menu image
Pulldown menus
Toolbar buttons
Popup menu (right click at runtime)

Wallpaper can be specified by specifying a background color for the menu image or by specifying a background graphic for the menu image. Wallpaper is specified by selecting GUI Attributes at the process level of an APPX menu - you provide a resource name and a tiling mode:

Resource

The resource name is used to identify the resource for the wallpaper graphic which you would like to appear on the menu image. The "WALLPAPER" State of the named resource identifies the wallpaper graphic file. Allowable file types are jpg, bmp, and gif.

Tiling Mode

A tiling mode may be specified to deal with a wallpaper graphic file which is not the same size as the menu image. You may choose from the following list:

TILE - Tile the wallpaper graphic to fill the menu image
EXPAND - Expand or shrink the wallpaper graphic to fit the menu image
CENTER - Center the wallpaper graphic within the menu image

The remaining options position the wallpaper graphic at the specified compass points on the menu image.

NORTH
EAST
SOUTH
WEST
NORTHEAST
NORTHWEST
SOUTHEAST
SOUTHWEST

Example - Menu Titlebar

Before you design a custom Title Bar, you should first remove the title text and the inverse attributes which you or APPX may have previously set on the first row of the image. This can be done by positioning the cursor on row 1 and using Option 6 to delete the row. Option 7 can then be used to insert a blank row if necessary to shift everything back down. Removing row 1 will prevent the Auto-GUI feature of APPX from generating a title bar for you.

A title bar is designed by selecting GUI Attributes at the process level of an APPX menu.

On the GUI Attributes screen, you provide the titlebar text and a resource name, and you can control the set of buttons to appear in the titlebar.

Titlebar Text

The titlebar text will appear on the title bar.

Resource

The resource name is used to identify the resource for the icon which you would like to appear on the titlebar. The ENABLED state of the named resource identifies the icon file.

Show Buttons

The show buttons is used to identify which default buttons you would like to appear on the titlebar. Default buttons you can define are:

Check "Ok" if you want an OK button to appear on the right hand side of the titlebar.
Check "Close" if you want a close button to appear on the right hand side of the titlebar.

On the Additional GUI Attributes screen you provide a font name, the font style and scale, and colors for the titlebar.

Font Name

You may select from any of the fonts listed. User defined fonts are not currently supported.

Font Style

You may select from any of the font styles listed:

Bold
Bold Italic
Italic
Regular

Font Scale

Font scale may be specified as a percentage of the base font size.

Color - foreground and background:

Colors may be specified for the titlebar foreground (text) and the titlebar background.

RDBMS Interfaces

Release 4.1 gives you significant increases in performance and flexibility when storing data in an RDBMS.

After extensive exploration, we have identified the major performance problems in prior releases of Appx. The three largest factors in determining Appx/RDBMS performance are COMMIT frequency, table width, and statement caching.

Statement Caching

When your application requests an I/O operation (READ, WRITE, or REWRITE for example), Appx translates each request into an SQL statement and sends that statement to the RDBMS server. Starting with release 4.1, Appx uses parameterized SQL statements to minimize the amount of network traffic and SQL parsing required. This means, for example, that the first time you WRITE a record to an RDBMS, Appx creates a statement of the form "INSERT table VALUES ( :1, :2, :3)", then sends that statement to the server. If your application executes another WRITE statement to the same table, we reuse the cached INSERT statement, providing new values.

When we reuse a cached statement, the database won't have to parse the statement, query it's own data dictionary, or compute a new query plan. Also, we don't have to send the text of the statement across the client/server connection.

Commit Frequency

Prior to release 4.1, Appx committed each change as soon as the change was made. This is extremely expensive. With release 4.1, you have control over commit frequency. We have added a new PDF (pre-defined-field) called --- COMMIT MODE which controls how often Appx will commit your changes. The values for --- COMMIT MODE are:

COMPATIBLE: When --- COMMIT MODE is set to COMPATIBLE, Appx will commit your changes as soon as all locks have been freed. This mode provides maximum compatibility between AppxIO files and RDBMS tables. The default value for --- COMMIT MODE is COMPATIBLE.
PCF CYCLE: When --- COMMIT MODE is set to PCF CYCLE, Appx will commit your changes for each record processed from the PCF. In most cases, the commit will occur following the Post PCF Update event point.
END: When --- COMMIT MODE is set to END, Appx will commit changes when your process ends.
MANUAL: Setting --- COMMIT MODE to MANUAL will tell Appx that it should not automatically commit changes - instead, you must commit your changes using the COMMIT statement.

In addition to the --- COMMIT MODE pre-defined field, you can also specify a commit mode for each process (in Additional Attributes). The --- COMMIT MODE pdf will be set based on the commit mode for your process.

If you change the --- COMMIT MODE pdf, the change will take affect at the next COMMIT or ROLLBACK.

There are three new ILF statements which allow you more control over transaction processing:

COMMIT: This statement will cause an immediate commit of all changes made to the tables stored within an RDBMS. All record locks will be forfeited.
ROLLBACK: Executing a ROLLBACK will cause the RDBMS to discard all changes made during the current transaction. Again, all record locks are forfeited.
SAVEPNT: This statement allows you to establish a savepoint within a transaction. The ROLLBACK statement can refer to a save point. If you include a savepoint name in a ROLLBACK statement, changes made since that savepoint are discarded, but changes made prior to the savepoint are not discarded.

Partial-record I/O

In order to correct the performance problems associated with very wide tables, we have modified the READ, READNEXT, BEG READ, END READ, WRITE, and REWRITE statements. Prior to release 4.1, you specified a file name as the first operand to these statements. Now, you can specify either a file name or a field name. If you specify a file name, Appx will operate on the entire record. If you specify a field name, the above I/O statement will operate on the named field - if the field is a group header, the I/O will be performed on all members of the group.

We have also added support for partial-record I/O to the process-control-file for each process. You can tell Appx which PCF fields to deal with by setting the Partial-Record I/O field in Additional Attributes for each process.

You can use this new capability to limit the amount of data transferred between Appx and an RDBMS. For example, if you know that a particular section of ILF code needs to update only one or two fields within a record, you can change the I/O statements to refer only to those fields.

Before:

 BEG READ TPA EMPLOYEE HOLD 1 KEY EMPLOYEE KEY COMPUTE TPA EMPLOYEE SALARY * 1.1 REWRITE TPA EMPLOYEE END READ TPA EMPOYEE

After:

 BEG READ TPA EMPLOYEE KEY + SALARY HOLD 1 BY EMPLOYEE KEY COMPUTE TPA EMPLOYEE SALARY * 1.1 REWRITE TPA EMPLOYEE SALARY END READ TPA EMPLOYEE KEY + SALARY

Using the partial-record form of the I/O statements can greatly improve performance when storing data in an RDBMS.

When you WRITE a single field (or a group field), Appx will write NULL values into the remainder of the record. When you READ (or READNEXT, or BEG READ) a partial record, the remainder of the record will contain NULL values. If you REWRITE a partial record, the remainder of the record will not be modified.

The READNEXT statement allows you to enter a field name (rather than a file name), however, that field name is not really used to restrict the set of fields retrieved from the RDBMS server. Consider that Appx is generating SQL statements on the fly - when you execute a BEG/END READ statement, Appx generates a "select from table where and ". Executing that select statement causes the RDBMS to generate a recordset - the recordset contains all of selected columns for each of the selected records. The READNEXT statement (and in fact the END READ statement) cannot change the recordset - it can only fetch the next row from that recordset. So, the fieldname supplied to a READNEXT statement (or an END READ) statement is for documentation purposes only: you cannot use a READNEXT statement to change which columns are present in the recordset.

Even thought the END READ statement now allows specification of a field name, this is for documentation and consistency purposes only and is not actually used other than to indirectly identify the file name so that the END READ can be associated with the appropriate corresponding BEG READ statement.

REWRITE statements also allow specification of a file name or a field name. If you specify a field name, only the name field or group of fields will be updated. All other values in the record being updated will be unchanged. The field name specified on a REWRITE statement does not need to be the same as the field name specified on the READ statement which read the record. So, you could read the entire record with hold by specifying a file name on the read statement and then update a single field by specifying that field name on the REWRITE statement. Or, you could read a group of fields and then rewrite a different group of fields (presumably a smaller group of fields within the group originally read but not necessarily).

Partial-Record I/O will read only the field or group of fields specified. The key field specified on the READ statement will not be read unless the key field is included in the group of fields specified on the READ statement. If you need the key field to be read, remember that a SYNONYM for the key field can easily be included in any group that you may define in the Data Dictionary. The primary purpose of implementing Partial-Record I/O is to increase performance by only reading and writing the fields which are actually needed. If APPX always included the key field values on a READ, then we would be slowing down performance in those cases where the key fields are not specifically needed by the process.

Note: In release 4.1, AppxIO files will not support partial record I/O. The partial record I/O statements will still function, but they will function on the entire record. Also, a partial record READ-type statement will not set the remainder of the record to NULL values.

Column Level Overrides

Starting with this release, you have more control over the way Appx stores data in an RDBMS - you can override the choices normally made by Appx to affect the data types, column names, and "nullability" for each column in each table. When you create a table in, for example, and Oracle database, you can view (and edit) column-level overrides from within Database Management: choose "File Specifications", then "Field Overrides". Here, you will see a list of all of the fields (columns) in your file and you can the column name, data type, and "nullability" for each field.

Specification-based File Attributes

While you are in Database Management/File Specifications, you may also notice that we changed "FMS Control String" to "File Attributes". Each file management system (Oracle, Sybase, AppxIO, etc.) understands a different set of file attributes. In earlier release, you had to enter a complex specification to control how Appx interfaced with the back-end database. Now, we prompt you for the required information using a fill in the blanks format. For example, if you choose to store a file in an Oracle database, we will ask you for the server name, a table naming scheme, and other information which is used to properly size tables with Oracle.

Identities

When Appx needs to connect to another server (either an RDBMS or AppxNET server), it must provide a username and password to that server. We have introduced a new system administration facility called Identities, which allow you to specify a username/password pair for each user, each file system group, or each user/file system group pair.

Identities give you more flexibility in controlling login information. There are two types of identities - default identities and unique identities. A unique identity is tied to a three-character Appx User ID. When you connect to an RDBMS (or AppxNET server), Appx tries to find an unique identity for your user id - if it finds one, it provides the username and password to Oracle. If Appx can't find a unique identity for your user id, it looks for a default identity, and if it finds one, it provides the username and password to the RDBMS. If Appx can't find a default identity, you can't login to the server.

For example, you might have elevated privileges when logging into Oracle, so the identity record for your Appx User ID specifies that you should connect to Oracle using your own username and password. You might give unique identities to two or three other privileged users. Then, you can also define a default identity - that identity is used for all other users and would specify a username of defaultappxuser. This default identity means that all other users will identify themselves to Oracle using the same username.

You can view the identities defined for each user by going to System Administration, Security, then Users - choose Identities.

You can view the identities defined for a specific file system group by going to System Administration, Configuration, File System Groups - again, choose Identities.

These are two different views of the same list.

In order to use identities, you must create a File System Group and assign each file to that group.

Oracle Table sizing options

Using specification-based file options, you can control the storage clause used when Appx creates a table in an Oracle database. You can specify the following options:

tablespace
initial
next
pctincrease
minextents
maxextents
pctfree
pctused
freelists
freelist groups
initrans
maxtrans

These options correspond to the storage clause of the Oracle create table statement. Estimating initial table sizes properly can give you a large performance boost.

File Caching

With release 4.1, you can now specify that you want some of your files to be cached in memory, rather than retrieving the records from disk (or from and RDBMS server) each time they are required. This can give you a big performance boost - especially when you run a process which accesses the same data over and over again (looking up data in code tables during a long-running update process, for example).

Currently, you must use ILF statement to control caching - in a future release, we will add cache-related specifications in the data dictionary and at the process level so that you don't have to write as much ILF code.

CREATE Statement

The CREATE statement can now be used to programmatically create and open a cached instance of a file. Specifying a CACHE option other than 'NONE' causes a cached instance of a file to be created in memory and opened instead of the normal disk instance of the file. The value of the CACHE option determines how the cached instance of the file is populated. If --- NEXT DATABASE is specified for a CREATE statement which is to create a cached file, then the value of next database determines the source database for loading the cache. Otherwise the current database is used to determine the source of the file which is used to load the cache.

 CREATE ___ ________ SHARE? _ FAIL _ CACHE _______ (1) (2) (3) (4) (5)

Application ID
File Name
Share Y/N?
Fail Type
Cache type

CACHE TYPE:

NONE: Create and open the file as a normal, non-cached file.
NO LOAD: Create and open the cached instance of the file but do not load any records into the cache file (use the WRITE statement to populate the cache).
LOAD: Create and open the cached instance of the file and load cache file from the disk instance of file.
AUTO: (Currently same as LOAD) Create and open the cached instance of the file. Dynamically populate the cache from the disk instance of the file as records are individually read.

OPEN Statement

A new parameter has been added to the OPEN statement which allows you to open either the cached instance of a file or the disk instance of the file. If CACHE=Y and the cached instance of the file does not exist, then the OPEN statement will fail. So, a CREATE statement must be used to create the cached instance of a file before the OPEN statement can be used to open it. If --- NEXT DATABASE is specified in conjunction with CACHE=Y, then --- NEXT DATABASE is cleared and ignored.

 OPEN ___ ________ SHARE? _ FAIL _ CACHE? _ (1) (2) (3) (4) (5)

Application ID
File Name
Share Y/N?
Fail Type
Cache Y/N?

SCRATCH Statement

A new parameter has been added to the SCRATCH statement which allows you to scratch either the cached instance of a file or the disk instance of the file. If --- NEXT DATABASE is specified in conjunction with CACHE=Y, then --- NEXT DATABASE is cleared and ignored.

 SCRATCH ___ ________ FAIL _ CACHE? _ (1) (2) (3) (4)

Application ID
File Name
Fail Type
Cache Y/N?

CLOSE Statement

The CLOSE statement closes the currently opened instance of a file, either disk or cache.

Like memory files, there can be only a single instance of a cached file. There is not a separate instance of a cached file for each database.

Once you have opened the cached instance of a file, all I/O which follows will reference the cached instance of the file, not the disk instance.

If you execute a CREATE statement with CACHE=NO LOAD, then you can load the file yourself, perhaps with a subset of the records. One possible use of this would be to effectively constrain a DLU.

If you rewrite, delete, or write records to the cached instance of the file, the disk instance of the file will not be updated. If the disk instance of the file changes after you create and load the cached instance of the file, the cached instance of the file will not automatically include these changes.

Cached files were conceived as a performance enhancement for "read only" files which are stored as tables in databases. However, they should prove to be useful in many other applications as well!

Here is some example code which shows how to manually populate a cache with selected records:

 * * This code creates a cached instance of the SALESREP file and * loads it with the "Inside" salesreps * * Create a cache instance of the SALESREP file * CREATE CCA SALESREP SHARE? Y FAIL 0 CACHE NOLOAD * * Open the disk instance of the file * OPEN CCA SALESREP SHARE? Y FAIL 0 CACHE? N * * Read all of the SALESREP records * BEG READ CCA SALESREP HOLD 0 KEY IS SALESREP SALESPERSON * * Add only the inside salesreps to the cache * IF CCA SALESREP INSIDE EQ Y T OPEN CCA SALESREP SHARE? Y FAIL 0 CACHE? Y T WRITE CCA SALESREP FAIL 0 T OPEN CCA SALESREP SHARE? Y FAIL 0 CACHE? N * END READ CCA SALESREP * * open the cached instance - all references within * the process will now use the cached instance * OPEN CCA SALESREP SHARE? Y FAIL 0 CACHE? Y

File Level Event Points

You can now attach ILF code to files. There are five new event points available to you when you define a file in the Appx data dictionary.

File Open
File Close
Post Read
Pre Update
Post Update

These event points are executed each time you perform I/O to a file - no matter where the I/O occurs. You can now localize complex update rules into a single location and be assured that your code will execute for every update. You can also use these event points to give values to computed fields.

File level event points execute within the context of a file-level process. This process shares very little data with other processes. In fact, the only thing shared between a file-level process and the "foreground" process is the PCF record buffer. For example, in the Post Read event point, you have access to the contents of the record just retrieved. If you make changes to the record buffer, those changes will be reflected in the foreground process. In the Pre Update event point, you have access to the PCF record buffer as delivered by the foreground process.

The file level event points will execute in conjunction with APPX/ODBC file I/O. For example, if you read a record via APPX/ODBC, the Post Read event point for the file will execute. If you write a record via APPX/ODBC, then the Pre Update event point will execute just before the record is written and the Post Update event point will execute just after the record is written.

An APPX process that is performing I/O against stored in an external database such as SQL Server® will cause the file level event points to execute. This is in keeping with the premise that an APPX application should be able to produce the same result regardless of the FMS used to store the data.

However, if an outside process accesses a file which APPX has stored in an external file management system such as SQL Server, the file level event points will not execute. There is no way for APPX to know that an external I/O has occurred.

Quick Restructures

The Appx restructure facility has been improved in order to reduce the amount of time required to restructure large files. Before performing a restructure, we now analyze the changes made to the file and ask the file storage system (AppxIO, an RDBMS, etc.) whether it knows how to apply those changes. If so, we ask the storage system to perform the restructure. If not, Appx falls back to it's old method of copying each record from the original file to a new file (converting from old to new format along the way), then renaming the new file.

The AppxIO storage system supports quick restructures and can handle the following types of changes without having to process each record:

Adding a new field (or fields) to the end of the record
Increasing the length of the last field in the record (if the last field is an alpha)
Changing a file from fixed-length to variable-length records

(Note that you must change your file to allow variable-length records before AppxIO can use the quick restructure strategy for the above changes - you can do this in the Additional Attributes dialog for your file).

In the future, AppxIO will also allow you to add and delete indexes (keys) without reverting to the copy/rename strategy.

The Oracle storage interface also supports quick restructures and can handle the following changes without having to process each record:

Adding a new field (or fields) to the end of the record
Adding a new key
Deleting an old key
Changing the structure of an existing key
Changing a file from fixed-length to variable-length records

(Note that you must change your file to allow variable-length records before Oracle can use the quick restructure strategy for the above changes - you can do this in the Additional Attributes dialog for your file).

Fast Queries

Release 4.1 introduces significant improvements in the Appx query processor.

In past releases, Appx used a "read all records" strategy for most queries. (You could force Appx to read a restricted range of PCF records in some cases using child constraints, but that technique cannot be used in many situations).

The new query processor will utilize existing indexes (keys) when evaluating a query. After processing the selection expression, Appx will determine which constraints can be used to establish an indexed range read. Once all of the candidates have been identified, we assign a weight to each constraint according to it's usefulness and then select the candidate with the greatest weight. Various factors are used when applying weights including:

How much of the key is constrained
Whether or not the key allows duplicate values
The BEG AT and END AT flags specified by the designer
Whether or not the key can be used to order the result set

After selecting an index, Appx produces an event point which will process the PCF records in a manner which is (usually) more optimal than the "read all records" strategy. This new event point is called the Establish Range event point and can be overridden by the application designer. If you override the Establish Range event point, Appx will not generate one at runtime.

We have also made changes to the sorting strategy used in the query processor. Appx tries to perform all sort operations in memory, but, when the number of records in the result set reaches a certain threshold, some of the sort operations are moved to disk. In 4.1, we have increased the threshold - this may still cause disk I/O, but that I/O will move through the operating systems virtual memory manager, rather than the file manager, resulting in higher performance.

Also, Appx will now skip the sort phase of a query if the records returned by the Establish Range event point are already in the desired order.

If you decide to write your own Establish Range event point (rather than having Appx generate one for you), there are a few details you will need. First, you probably want your event point to be in the form of one or more BEG READ/END READ loops. Then, within each loop, you must GOSUB the --- PROCESS QUERY RECORD process. Below is a sample Establish Range event point:

 * Process first range of records SET TAP VENDOR NO = 10 BEG AT TAP VENDOR IN TAP VENDOR NO END AT TAP VENDOR IN TAP VENDOR NO BEG READ TAP VENDOR HOLD 0 KEY IS VENDOR NO GOSUB --- PROCESS QUERY RECORD END READ TAP VENDOR * Process next range of records SET TAP VENDOR NO = 200 BEG AT TAP VENDOR IN TAP VENDOR NO SET TAP VENDOR NO = 500 END AT TAP VENDOR IN TAP VENDOR NO BEG READ TAP VENDOR HOLD 0 KEY IS VENDOR NO GOSUB --- PROCESS QUERY RECORD END READ TAP VENDOR

(you can find this example in the 1EX/00 QUERY (ESTABLISH PCF RANGE) subroutine process).

Data Dictionary Importer

The APPX data dictionary importer is used to import data definitions from an external source and build an APPX data dictionary of files and fields.

Once the data dictionary for an application is built, a "template application" can be generated.

The template application consists of toolbox-generated inputs, outputs, and updates (for comma delimited exports) placed onto a basic menu structure.General Features

Table and column names can quickly be defaulted to APPX standards for file and field names.
Indexes are recognized and generated as APPX key fields.
Multi-column indexes generated as synonym fields with surrounding group header/trailer.
Single column foreign key constraints are generated as field level DLU's (Oracle only).

Limitations

Oracle

Table definitions are importable, but views are currently not importable.

Data Dictionary Builder

Currently, we do not check for, or scratch existing files or fields in the application. This is currently the responsibility of the designer. The best way to avoid conflicts (and loss of data) is to generate the data dictionary into an empty application.

Application Generator

We does not check for or scratch existing processes in the application. This is currently the responsibility of the designer. Again, avoid collisions by generating processes into an empty application.

RECEIVE statement

The RECEIVE statement works with the PASS statement to implement true subroutines. Here is an example of the PASS and RECEIVE statements in action:

 PASS TAR CUSTOMER NAME FIELD SHARED? N PASS TAR WORK STRING LENGTH FIELD SHARED? Y GOSUB :COMPUTE STRING LENGTH * * WORK STRING LENGTH now contains the length of TAR CUSTOMER NAME * ... LABEL :COMPUTE STRING LENGTH * RECEIVE --- TEMP 2K RECEIVE --- AI * CNV BIN --- TEMP 1 = 0 APPEND --- TEMP 2K 0 --- TEMP 1 IF --- TEMP 2K IN --- TEMP 1 SET --- AI = --- TEXT AT POSITION COMPUTE --- AI - 1 RETURN

After executing the first RECEIVE statement, the --- TEMP 2K field will contain the value of the TAR CUSTOMER field. After executing the second RECEIVE statement, --- AI will contain the value of TAR WORK STRING LENGTH (although that's not terribly important right now). We compute the string length by appending a null character to --- TEMP 2K, then using IF/IN to find the position of that character (which is returned in --- TEXT AT POSITION).

More magic occurs when we execute the RETURN statement. First, since TAR CUSTOMER NAME was not shared, we restore the value of TAR CUSTOMER NAME string (just in case our subroutine messed it up), then we restore the value of the --- TEMP 2K field (we took a snapshot of both fields when we executed the RECEIVE statement). Next, we copy the value of --- AI into TAR WORK STRING LENGTH, providing the return value for this subroutine, and restore the value of --- AI.

The net result is that the variables that we RECEIVED inside the subroutine are restored to their original values (so you can use any variables that you want without having to worry about changing the caller's data), and the caller now has the data that he wants - in this case, the length of the string passed as the first parameter.

Note that the data types of the PASS and RECEIVE fields don't have to match. We use the same rules as the SET statement to convert from the PASS field into the RECEIVE field (and to convert back again for "out" parameters).

The RECEIVE statement can be used in two locations:

inside a LABEL'ed subroutine - values are restored when the RETURN is executed
inside Start Of Process - values are restored when the process ends

Also note that the RECEIVE statement returns a T/F flag. It returns a T if a matching PASS statement was found, and a F if not. If you RECEIVE without a PASS statement, you are essentially declaring a local variable - that field will contain it's initial value and it will be restored when the subroutine (or event point or process) ends.

Miscellaneous Fixes and Enhancements

We have increased the maximum file size for AppxIO files from 1GB to 2GB under Windows®, and from 2GB to 4GB for AIX and Solaris - no changes or restructures are required to enable this enhancement.

You can now specify that an alpha lookup table should be used as a suggestion table. Using a suggestion table allows the user to scan for a list of suggestions, but he can still enter a value which does not appear in the list.

We have added a Recalculate Hash ID's facility to the Language Translation menu. You can used this feature whenever you make changes to the definition of a language - it is not necessary to recalculate hash ID's when changing a translation, only when changing the base characteristics of a language (such as upper/lower case map).

The Win32 client will now Cut and Paste accented characters

The SET statement has been fixed so that it is safe to assign to (or from) a group which contains synonyms.

Topic revision: r3 - 08 Oct 2026, AdminUser - This page was cached on 08 Oct 2026 - 12:14.

APPX

Webs
APPX
Main
Sandbox
System