August/September 1998: Volume 8 Number 2

Migrating to Windows | Multi-user programming in PFXplus | Put your Powerflex programs on the Internet | Powerflex news

Migrating to Windows

(The source code for the PSAMPLE.PFX program mentioned in this article can be found on the download page of this Web site.)

This case study will demonstrate a most remarkable thing. In it we shall convert a character-based PFXplus program into a PFXplus for Windows 32-bit G-mode Plus program, as if by waving a magic wand!

What makes this magic possible is that programs running in G-mode Plus have a genuine Windows graphical look and feel, but the underlying code is essentially unchanged. Program flow between controls is still procedural but becomes event-driven while a control has focus. You do not have to rewrite your programs, and you do not have to learn lots of new ways of doing things. Best of all: you get there fast.

Before beginning the conversion, you need some preparation and the most important preparation is: prepare yourself. Windows programs are not just MS-DOS programs with pictures. There are conventions to be followed and concepts to be understood, even if PFXplus does the hard bits for you. We recommend that you use Windows software yourself exclusively such as a Windows editor, Explorer and other Windows tools.

Windows programs are different in several ways. A Windows program must be totally driveable by mouse, except for actual data entry. It uses menus, buttons and a toolbar for control, rather than function keys. If it has function keys, they are as well as, not instead of mouse control.

Windows programs use forms (Dialogs) and Controls which correspond to PFXplus images and windows. Your data appears exclusively in controls. You cannot write anywhere else on a form, so direct screen access is not possible.

A Windows program does not use color in the way that many C-mode (character mode) programs do. Windows allows users to set their own color scheme in the Desktop Appearance Settings. You must go along with that, although you can use small amounts of colors in strategic locations, like using red to indicate a negative balance.

Clearly, before beginning the conversion, the original C-mode program should be made to satisfy a number of criteria.

Basic Criteria

  • The user interface must use only images and windows, no panels or direct screen, mouse or keyboard addressing. Remove, replace or rewrite code using CLEARXY, GET_SCREEN, GOTOXY, INKEY, INPUT, KEYCHECK, SET_SCREEN, SHOW, SHOWLN, SET_TERMTYPE or any panel or mouse commands. Use only ACCEPT or ENTRY for keyboard input.


  • Warning and status messages should appear in the status bar or in a pop-up message box. Replace code using GOTOXY and SHOW or other console output with a Windows-compatible system such as NFYSTAT (standard with PFXplus).


  • The program must be mouse driveable. Add code like this so that mouse key-faking will work.
    KEYPROC KEY.FIELD
    KEYPROC KEY.UP
    BACKFIELD
    RETURN 
  • The program should exit in accordance with standard Windows behavior. Add code like this so that the program exits on ALT+F4, and ESCAPE too if you like.
    KEYPROC KEY.EXIT
    KEYPROC KEY.ESCAPE // optional
    ABORT 
  • Add buttons to replace "magic" function keys and special characters. Remember that everything must be mouse-driveable otherwise it isn't true Windows


  • SCREENMODE color will stop working. If you must use color, use COLOR_WINDOW and Windows colors from WHCOLOR.PFI to produce a true Windows appearance.


  • Avoid tight processing loops with no keyboard input, as they prevent proper screen updating. During lengthy procedures, check the keyboard frequently using INKEY$.


  • The program must be written for multiple users. Windows is a multi-user environment.


  • The program should not use words that conflict with PFXplus for Windows reserved words such as SCREEN and MENU.


  • Displayed images should have PAGE SET AT 0 0. Actual image positions are controlled by the form object definitions, which will be demonstrated later.

Factors Making Conversion Easier

The following factors will make conversion to Windows easier and help to produce better results.

  • Use of PFXplus features that correspond with built-in controls in PFXplus for Windows, such as push buttons, radio buttons, multiline edits, list boxes and combo boxes.


  • Screen prompts and controls arranged in neat columns will be interpreted into more aesthetically pleasing graphical screens than if the screens are cluttered to begin with.


  • Use of ENTERGROUP, ENTERMODE, ENTRY blocks and KEYPROCs, and a basic layout similar to the sample programs such as GMEM3.PFX will make conversion easier.

The program used in this case study is called PSAMPLE.PFX. This program is based on GPAY1.PFX, one of the sample programs which comes standard with PFXplus. GPAY1.PFX should exist in your SAMPLE directory. PSAMPLE.PFX consists of one main image and two sub-images. The sub-images overlay each other in the lower section of the main image, depending on the value of the Type of Payment field.

The source code for PSAMPLE.PFX is available now by e-mail from Powerflex Corporation at pfxinfo@pfxcorp.com. If you do not have access to Internet e-mail, you may wish to follow the step by step guide using GPAY1.PFX. Most of the sample programs referred to in this article are available with PFXplus version 4.2 or later.

Using GPAY1.PFX

For those who will be following the Case Study using GPAY1.PFX, here is an explanation of some of the code in this program which may be unfamiliar to you. Before proceeding, copy and rename GPAY1.PFX to PSAMPLE.PFX.

The following standard code extract checks whether a Windows operating system is running, and that there is a supporting Windows resource file for the program.

switch
when not $OS_WINDOWS
error ERNOTIMP "GPAY1 requires Powerflex for Windows"
abort
when (get_env("UiMode") == "C") MsgError "GPAY1"
("Resource file not found ("+get_env("sResourceBinExt")+")")
abort
endswitch 

It is possible to substitute the following lines of code with the code KEYPROC KEY.EXIT which is invoked by ALT+F4 and the Close control button.

// events on DESKTOP
event (EVS_ALT+EVA_F4)
if AskYesNo("GPAY1", "Really Quit?") system.
end_event 

For the purposes of this example, most of this code will need to be removed so that the program can be run in character mode without any problems.

Pre-conversion

Before we begin the conversion process, the following modifications to the configuration file PFX.INI are required.

Certain configuration items need to be added to PFX.INI which are required for the Resource Converter MKRES, built into PFCN. MKRES processes section [MKRN].

[MKRN]
;Sets the compiler to use to convert RC code to binary
sResCompiler=.\pfx4\rc32\rc.exe
;Set the standard include files for the resource compiler
sWindowsHeader=.\pfx4\rc32\winresrc.h
sResLinker=.\pfx4\rc32\link.exe
;Sets the operation mode to G-mode Plus
iGUILevel=4 

We recommend the following additions to the [PFL] section to set PFXplus up to run in G-mode Plus.

[PFLW PFLWD PFLND PFLN]
;Sets the operation mode to G-mode Plus
iGmodePlus=4
iGuiColorMode=   4 

Steps to Conversion

  1. Compile the program.

    Use PFCN to compile.

    >PFCN PSAMPLE

    PFCN can be used to compile both C-mode and Windows programs. Compilation without the /R switch will create a PTC file. Compilation with the /R switch will create a PTC file and Windows Resource PR3 file too.

    The program should look like the figure below when run under Windows (in C-mode).

    Screen Example for Credit Payment Type

    Screen example
  2. Compile the program with the /R switch.

    Use PFCN and invoke MKRES using the /R switch to create the Resource File (PR3 file).

    >PFCN PSAMPLE /R 

    This will produce the files PSAMPLE.PTC and PSAMPLE.PR3.

  3. Run the program in Windows.

    >PFLND PSAMPLE 

    In one easy step, we have converted the character images into three-dimensional graphical Windows screens (i.e. the program now runs in G-mode Plus).

    The following results are produced.

    Screen Example for Credit Payment Type

    Credit payment image 2

    The images pgCheck and pgCredit should appear as siblings of the main form, pgPayment. However, as we can see from the figure above, these images have been interpreted as separate Windows pop-up forms (the default), because the resource compiler has not been informed of the correct form hierarchy.

    We must provide the necessary information to the resource compiler, by adding FORM and SUBFORM objects to the source code. Arranged in the appropriate hierarchy, these objects will inform the resource compiler that pgCheck and pgCredit are subforms or children of the main form, and should therefore appear as siblings of the main form, not as separate forms.

  4. Add Objects to the source code.

    To add objects, we need to use the file WINSTD.PFI, which includes most of the code you are likely to need.

    + It is a good idea to insert this at the beginning of your program, so you can see at a glance which files are included when you open it.

    All modifications to source code are printed in Bold.

    #use WINSTD
    FORM oPayment {SCREEN=pgPayment, CAPTION= "PaymentsEntry",X=0,Y=0};
    begin
    SUBFORM oCheck {SCREEN=pgCheck, X=0,Y=135,height=70, width=360}
    SUBFORMoCredit{SCREEN=pgCredit,X=0,Y=135, height=70, width=360}
    END_OBJECT
    page pgPayment at 0 0
    page set pgCheck at 13 0
    page set pgCredit at 13 0 

    The object definitions are inserted before the PAGE and PAGE SET commands and after the windows have been named. Screen positions set in the object definition will override the positions set by PAGE AT. To avoid any confusion set the PAGE AT coordinates to 0 0. This code is required by the compiler so do not remove it.

    page set pgCheck at 0 0
    page set pgCredit at 0 0

    Note that oPayment, oCheck and oCredit are the names allocated to the FORM object and SUBFORM objects respectively. The naming convention used is the image name preceded by "o" for Object. This is not compulsory, but is suggested for clarity.

    + It is a good idea to adopt the practice of naming every object from the beginning, in case it needs to be referenced in any way from a Windows point of view, in future.

    The X Y coordinates indicate the positioning of the subforms relative to the main form. The default 0, 0 will centre the main form on the desktop.

    It is not necessary to add any objects belonging to any of the forms (e.g. controls), unless you want to edit their properties or subsequently reference them. The resource compiler recognises these as controls because they exist in the source code as windows in the images.

  5. Recompile the program and run it.

    >PFCN PSAMPLE /R
    >PFLND PSAMPLE 

    This produces the following results.

    Screen Example for Credit Payment Type

    Credit payment image 3

    At this point the subforms are not being paged over each other or cleared correctly. In Windows paging one image over another does not produce the same effect as it does in the character based version. Using PAGE on its own under Windows has the same effect as CLEARSCREEN, PAGE. To produce the same effect under Windows as PAGE does in the character versions, we use PAGE SAVE. An image that has been displayed using PAGE SAVE should be removed using PAGE CLEAR.

    + PAGE SAVE has the effect of saving the section of the form which will be covered to memory and then PAGEing the new form on top. PAGE CLEAR will restore the section of the form which was covered (which has the effect of clearing the top form).

    + In Windows, the main form is not repaged to clear subforms. The subforms are PAGE SAVEd and PAGE CLEARed as required.

    The SelectPage procedure needs to be modified accordingly.

    procedure SelectPage
    switch
    when IsCheck()
    page clear pgCredit
    page save pgCheck
    when IsCredit()
    page clear pgCheck
    page save pgCredit
    otherwise
    page clear pgCheck
    page clear pgCredit
    endswitch
    end_procedure 

    The subforms are now displayed and cleared appropriately.

    At this stage we have a fully functional program with a graphical appearance, by simply adding the above code to the existing source code. All other procedural code has remained intact and fully functional.

  6. Add Pop-Up Dialogs.

    To add Windows messaging to the program, use NFYSTAT which is designed to give access to standard Windows message box dialogs. Load the module at the beginning of the program.

    LOAD_MODULE NFYSTATW
    keyproc key.delete
    if QueryYesNo("Do you wish to delete this record?")==ID_YES begin
    lock
    delete PAYMENT
    clear PAYMENT
    unlock
    entclear
    end
    electPage
    return LoopAgain 

    This causes the following pop-up box to appear when SHIFT+F7 is pressed or Edit|Delete is selected from the menus.

    edit/delete image

    Refer to the program GMEMNFY.PFX in your SAMPLE directory for further examples of NFYSTAT.

    The normal Windows method of exiting a program, either by clicking the Close control button, pressing ALT+F4 or selecting Exit from a menu, will activate KEYPROC KEY.EXIT. In accordance with this we could add the following code.

    keyproc Key.Exit
    if QueryYesNo("Do you wish to exit?")== ID_YES abort
    entagain
    return 

    It is not consistent with normal Windows behavior to exit a program using the ESCAPE key therefore the following code should be removed. However, feel free to leave it in if you prefer.

    keyproc Key.Escape
    abort
    return 
  7. Add Menus, Toolbars and Status Bars.

    There are two ways of adding menus, a toolbar and a status bar to your program. You can hard-code them directly into your programs. Refer to the sample programs in PFXplus Sampler for examples of hard-coded menus, toolbar and status bar.

    The other and preferred way is to use the Common Controls Architecture tools, which come standard with PFXplus version 4.22 and later and make life much easier.

    The next article in this series will demonstrate how to use CCA tools to add menus, a toolbar and a status bar to your programs and achieve the following results. Don't miss it!

    CCA result image

    Compare this with the original character mode screen. What a difference!

There you have it!

PSAMPLE.PFX is now a fully functional G-mode Plus program with a genuine Microsoft Windows user interface. But if you want all the bells and whistles that go along with it, keep your eye out for the next article in this series.

Now go do the same thing to your programs!

Top of Page

Multi-User Programming in PFXplus

David Bennett - Powerflex Corporation - Director Technical Services

Are you getting frequent problems with corrupt data, read errors, multi-user timeouts and the like? You can blame the network and you can blame your users, but it just could be that your multi-user code has not been written correctly. This article shows you how to do it right.

With machine speed constantly on the increase, multi-user-safe programming is more important now than ever before. Code that seemed to work well in the past may no longer be good enough. Faster processors and bigger disks mean more data being moved and less time to do it in, so more chance of problems and less tolerance for errors. If the code just worked in the past, chances are it will not work in the future. You need to get it right, now!

Check your environment

PFXplus supports multi-user programming in every environment you are likely to be using. Everything is multi-user, from Windows for Workgroups, through Windows 95 and 98, to Windows/NT, Netware and Unix.

If you are running Windows 95 or 98 on a Windows/NT Server network, there are some things you must do to make the network perform reliably. We recommend using only Windows 95B (OSR2) or later, and you must disable opportunistic locking on the server. Contact our office for details.

To ensure you are running in Multi-user Mode, make sure that the configuration item bMultiuser is set to true in your PFX.INI. Then type in, compile and run the program in Listing 1 (see below). It should print out

Multiuser=TRUE Userno=1

Run the program on additional work-stations. Each should come up with a different value for UserNo, up to the maximum shown on your licence.

If that works, you can be sure multi-user operation is active. Now for the code.

To get good results, you must have a very clear understanding of the principles of transaction processing and you must apply the correct lock/unlock transaction control in your code. There is no other way to ensure it will be multi-user safe.

Transactions

A transaction arises when there is:

  • A write to a database file which depends on something previously read, or

  • A group of writes to the database which must not be split.

In either case, there is a risk of inconsistency in the result if other data in the database has changed during the time it has taken to write the transaction. This demonstrates a need for exclusive control of any data affecting the transaction while it is executed.

Using the PFXplus statements LOCK/REREAD and UNLOCK, it is possible to ensure that data will not be modified by another program while the data files are locked during a transaction write. This will be successful if the program uses correct locking procedure.

Correct Locking Procedures

To use the LOCK/REREAD and UNLOCK statements correctly we must apply them in the following sequence.

  1. Lock all files in transaction

  2. Reread or clear all locked file buffers

  3. Recalculate values which depend on re-read file buffers

  4. Move values into file buffers

  5. Save records from file buffers

  6. Release lock

These steps are more fully explained below.

First lock all needed files. LOCK applies to all open files, which is certainly enough. For better performance and reduced contention between programs, keep all files READ_ONLY and set them to DEFAULT just before doing the LOCK. For example:

FILE_MODE  filename  READ_ONLY

Just before LOCK change to

FILE_MODE  filename  DEFAULT

After UNLOCK, change back to READ_ONLY

Re-read or clear all locked file buffers. REREAD conveniently does a LOCK and REREAD of all active file buffers i.e. those in which a record has been found. It helps to ensure that fields you won't change are left alone.

Buffers that you aren't going to re-read should be cleared, to avoid data "leakage" from outside the transaction. They will become new records when saved.

Recalculate values which depend on re-read file buffers. Obvious, really, since those values may have just changed. Always assume the worst. It will happen anyway!

Move values into file buffers. The preferred way is to use ENTUPDATE otherwise if you wish, a long list of moves.

Save the records.

Finally, UNLOCK. Put all the files back to READ_ONLY.

Listing 2 (see below) gives an example. This is a patient booking system with three files. In this case we are marking a patient as NOSHOW in the BOOKING file, and incrementing the NOSHOW count in the PATIENT record. We don't use ATTEND, so leave it READ_ONLY.

It is assumed that the correct records were found previously.

Here we re-read them, make suitable changes and save them back again.

That's how the code should look. Between LOCK or REREAD and UNLOCK, remember:

  • DO keep the code short, straight, and easy to understand.

  • DON'T do any user interaction, unrelated database accesses, CHAIN, GOSUB or anything complicated or likely to fail.

Answers to Common Questions

Q. Do I always have to LOCK?
No, not always, but it is a very good habit to have.

When adding a new record which does not relate to any other, just CLEAR, MOVE and SAVERECORD are sufficient. The same goes if you are completely overwriting the previous contents and the record has no indexes (so no old keys to remove). These are the exceptions, so lock if in doubt.

Q. Do I have to REREAD?
No, not always, but it is a very good idea to get into the habit.

When going into a transaction, you must make absolutely certain that every record buffer involved either gets cleared or refreshed from disk. REREAD is an easy and reliable way to do that, but you can do it manually if you prefer.

Q. What about DELETEs?
Yes, you must still REREAD to make sure that you own the current version of that record, before you can safely delete it.

Q. Can I use ENTER and ENTERGROUP?
Yes, you can. These macros are skillfully designed for true transactional updates at all times.

Nothing is ever moved into the file buffer until after a LOCK and REREAD. ENTRY does not move data into the file buffer, ever. The ENTUPDATE statement (part of ENTER and ENTERGROUP) moves all data into the file buffer for all active ENTRY statements (see PFXplus manual).

Q. Can I tell whether anyone else changed the record?
Not easily. This capability is not easy to provide, so you must write programs as if it could happen any moment.

Other Solutions

If you are confident that your code is multi-user proof and you continue to experience problems such as read errors and corrupt data, it may be a good idea to check your power supplies, network cabling and equipment for unreliability, and to ensure operators are not rebooting or switching power off inappropriately.

Multi-user timeout errors may occur more frequently on slower machines because they may require more time to lock, update and unlock files. Increasing the number of tries might fix the problem. The two configuration items iLockTimeout and iLockRetry can be set in PFX.INI to do this.

Listing 1: Test for Multi-User Operation

// program to test for Multi-user Mode
showln "Multiuser=" MULTIUSER ;
" Userno=" $USERNO

Listing 2: Sample Transaction Update

open patient
file_mode patient read_only
open booking
file_mode booking read_only
open attend
file_mode attend read_only
// mark patient as "no-show"
file_mode patient default
file_mode booking default
reread
if status patient ;
and status booking begin
move (patient.noshow_count+1) ;
to patient.noshow_count
move NOSHOW to booking.status
save patient
save booking
end
else error 500 "update failed"
unlock
file_mode patient read_only
file_mode booking read_only 

Top of Page

Put Your Powerflex Programs on the Internet

(The source code for the sample programs mentioned in this article can be found on the download page of this Web site.)

Max Thomson - Powerflex Corporation - Australia

Have you been asked by one of your customers if your software will allow them to access their data over the Internet? Did you know that the 32-bit Powerflex GUI runtime can be used to provide this functionality and all the user needs is a standard Web Browser (such as Netscape or Internet Explorer) on their machine?

First, you will need to learn the basics of HTML coding. Check out the resources on the Internet. There are also many books on this topic and if you find an interesting page on the web you can save it to a file and use a text editor to see how it is done.

Secondly, your web server will need to run a copy of the PERL programming system. If you haven't come across PERL before, you can find it at WWW.PERL.ORG or WWW.PERL.COM.

On the Web server machine you will need:

  1. A copy of the 32-bit Powerflex runtime.

  2. An installed a copy of the PERL programming language.

  3. A PFXplus program which can read the incoming request from the user and provide a suitable response to the user.

  4. Permission on the server to allow the execution of server scripting.

This article provides a description of all the source code needed to allow a user to interrogate the sample member database over the Internet. The following files are provided. The details are specific to Microsoft's Internet Information Server (IIS) running in Windows/NT server 4.0, but with minimum changes, can be made to work on any Internet Server.

GETMEMB.HTM - Web Page that provides a link to a PERL program.

PFXCGI.PL - PERL program to link the Web server with your program.

MEMBCGI.PFX - Program to read and write to the PERL files.

The source code is too long to publish in full here. If you are interested, e-mail us and we will e-mail the code back to you. (Alternatively, see this Web site's download page.)

The Web Page GETMEMB.HTM

The web browser makes a request for a particular web page by asking for a known document (such as the document WWW.PFXCORP.COM/INDEX.HTML). This page would usually be HTML-encoded and would contain a header, body and footer. You might like to open GETMEMB.HTM in a text editor to see an example of a simple HTML-encoded page. However sometimes the requested document may look like WWW.MYSERVER.COM/SCRIPTS/PFXCGI.PL?MEMBCGI. This is not a standard web page but a request for the web server to run a CGI web server script (PFXCGI.PL) passing it an argument of MEMBCGI.

The PERL Script Program PFXCGI.PL

The provided PERL script reads the information after the '?' in the page request and assumes it to be the name of a PFXplus program, in this case MEMBCGI. The web browser can provide additional data to the server such as the contents of input data fields typed into the web page by the user. The PERL program reads data which has been passed to it using the POST method and writes it into a temporary file. It then calls the PFXplus runtime to start up the MEMBCGI program and passes it a filename where the results of the MEMBCGI program should be written and the filename of browser data.

The Powerflex Program MEMCGI

The MEMBCGI program screen looks like this.

membcgi program screen

It can get the filename of the file where it needs to write the response to the browser from its first argument and if there is a second argument it will be the filename of any incoming data from the browser. Both incoming data from the browser and data written out to the browser must be HTML-encoded.

A typical incoming data stream may be

MaxRows=10&Index=2&SubGo=Do+Query

which is the result from a web page containing three named input controls.

The program MEMBCGI.PFX has procedures which can decode this type of input string.

The output string must contain a standard HTML header and footer and the sample program contains images that can be output to provide this. It also provides write statements to show how to construct various HTML lines to the output file. After writing the HTML footer to the output file, the PFXplus program must then exit to give control back to the PERL script, which then passes the page back to the browser.

Setting up the Sample

The following steps are required to set up the sample program.

  1. Install PERL on the Web server.

  2. Copy GETMEMB.HTM into the folder with your other web pages.

  3. Compile the program MEMBCGI.PFX and copy the PTC file into the /SCRIPTS area of the web server.

  4. Copy PFXCGI.PL into the /SCRIPTS area of the web server and configure your web sever software to allow execution of scripts.

  5. Ensure that the 32-bit runtime PFLND.EXE and associated runtime files (PFX.INI, PFXFILES.TAB, PFERRORS.DAT) are in the /SCRIPTS area or can be found on the web server path.

  6. Ensure that the pfx.ini has an sDataPath pointing to the member database (MEMBER.DAT, MEMBER.K*) and that the PFX.INI specifies that the logo is switched off (bNoLogo=T).

Note that other than compiling MEMBCGI, all these steps must done on the web server.

In the client browser, set the requested page to GETMEMB.HTM. Use the link on that page to access the member data.

To avoid setup problems, ensure that the correct permissions are set to allow execute access of the script. If the correct permission is not set or the server cannot find the PERL or PFXplus program or the web user account does not have permission to write into the scripts area, the client browser may receive 'Page not found' or 'Permission denied' errors. If the PFXplus or PERL script doesn't function correctly, the user may not receive anything at all. Check for the creation of and the contents of the temporary files (called PFxxx.xxx.xxx.xxx found in the /SCRIPTS area) to see the request progress.

Developer Tips

When you change the name of the PFXplus program you wish to run (say to MYPROG.PFX), you will need to change the string PFXCGI?MEMBCGI to PFXCGI.PL?MYPROG in both the web page that calls the program for the first time (GETMEMB.HTM) and in the HTML header image in your program.

When developing your own program it is very useful to take a copy of the expected input from the temporary file created by the PERL script, call it TMPFILE.INP, and directly run your program by using the command

PFLND myprog tmpfile.out tmpfile.inp.

It is then possible to view errors and the program output (in TMPFILE.OUT) without running it through your web server.

For clarity, the sample code provided does not check for errors, such as inability to open the database. When your program is running as a script any error that you have not trapped within your program may cause the PFXplus program to terminate with no or incomplete output. The client browser will then be left without any indication as to what has happened.

You should not have to change the PERL program unless you wish to run your PFXplus program somewhere other than in the /SCRIPTS area. To do this change:

$prog = "PFLND " . $part1 . " " . $inname;

to

$prog = "c:\\myproject\\PFLND " . $part1 . " "  . $inname;

If you were to implement this sample on your server the whole Internet could read your member data. In a real world application you may need to provide some security perhaps by passwords and user ID.

You may like to investigate the use of HTML hidden input fields and/or cookies in web pages. These techniques allow you to keep track of the various pages an individual user has and is allowed to view.

Summing Up

Using the sample programs described here, a limited knowledge of HTML and the PFXplus Windows runtime, you can provide your customers with access to their data over an Intranet or the Internet.

With the ever-increasing interest in the Internet, providing this type of access in your programs could well make your product a winner over the opposition.

Top of Page

Powerflex News


We Welcome Two New Employees

We welcome two new members of staff to the happy team at Powerflex Corporation. Christine Charalambous and Stephen Smith.

Stephen has been employed in the role of Release Manager. He has a background in accounts and financial services, as well as being self-employed. He has also traveled extensively and lived in Asia. His main interests are bushwalking as well as computers and reading newspapers. He enjoys getting out in the country whenever he can.

Christine completed a Computer Science degree at Monash and went on to work as a programmer for a number of years before making the decision to move into something a little more people-oriented. She is enjoying her new and varied role in technical support and sales as well as dabbling in some writing for POWERlines.

Powerflex Technical Forum

You are invited to our upcoming Technical Forum. It will be held on Thursday 8th October at the Tower Hotel, corner Camberwell Rd and Burwood Rd, Hawthorn, at 6.00pm.

We hope you will take this opportunity to meet with our staff and other Powerflex developers to discuss any ideas or problems you would like to share.

New Version of Software Protection

Powerflex Corporation has released version 2.00 of the Software Protection program. This product uses a powerful combination of registration and on-disk copy protection to protect your software from unauthorised duplication and use by your customers. It is easily incorporated into existing programs and is available for DOS and now Win32.

New Release of PFXplus+SQL

Announcing the release of PFXplus+SQL version 4.30; the first complete release of this product. PFXplus+SQL is an optional add-on for PFXplus 4.30, adding the ability to store PFXplus data files as SQL tables. This release supports IBM DB2, MS SQL Server, Oracle and Sybase Adaptive Server. Only Microsoft SQL Server 6.5 using ODBC support is enabled at this time.

New Features Added to CCA

Since the last release of PFXplus, new features have been added to the Common Controls Architecture including Look Up tables with optional multiple selection. Contact us for a free PFX Sampler demonstration disk.

PFXplus for LINUX is Coming

PFXplus for LINUX is on its way. Those wanting to express their interest can do so by contacting Powerflex Corporation or your local dealer.

Current Versions of Powerflex release software

Powerflex Developer's Kit 4.23

Powerflex Runtimes 4.23

Powerflex SCO, RS/6000 4.11

Powerflex HP 9000, Motorola 4.11

Powerflex Siemens, DEC 4.11

Powerflex Toolbox Source Code 2.63

PFXC-lib MSDOS 4.20

PFXC-lib Xenix/Unix 3.21

PFXC-lib for Windows 4.30

PFXsort for DOS, DOS-386, Win32 4.30

PFXbrowse 32-bit with Btrieve 2.00

PFX Software Protection 2.00

For further information contact, Powerflex Corporation or your local dealer.

Top of Page