OS/2 Shareware BBS: 10 Tools/10-Tools.zip/GPFDMD.ZIP/GPFDMTXT.ZIP/GPFDEMO.TXT

Text File | 1992-08-17 | 37KB | 1,747 lines

Introduction





Welcome to Gpf, demo version.



This product is a powerful  OS/2 Presentation Manager
application design tool and standard language code generator.
Using a deceptively easy to use built in WYSIWYG window editor
Gpf permits visual design of a complete Graphical User Interface
complete with the navigation logic.  Additional functions have
been added which ease the creation of a complete application
including SQL code generation and simple integration of custom
logic and user defined objects.



Unlike other products which may require learning and using a
proprietary 4GL or generate only rudimentary code skeletons that
require extensive user editing to create useful applications,
Gpf generates finished standard "C" language source.  No further
editing is required, of course the code is clean, modular,  and
well commented, so editing is not precluded.  Standard language
also means no runtime or royalties are required to use the
generated output.



Links to user functions are defined from within the Gpf  editor,
 and the generated code need never be touched before
compilation.  Common actions (messages) between controls and
windows are simply selected from ACTION-FROM-TO lists, including
the mentioned User Functions.  The ability to read OS/2 DataBase
Manager tables from within Gpf makes it possible to create
simple, complete applications without a single line of user
code.  When custom logic is required user function objects are
defined in "C" and may be interchanged and intermixed with Gpf
built in functions.



Gpf greatly simplifies the installation of Information Messages
and a Help System for your application.  Help panels can be
quickly created for any object you've created, including the
text, a CONTENTS title, and an INDEX title.  The Gpf GENERATOR
will create a complete .IPF file for you, in correct
hierarchical order.   Of course proper "hooks" to the system
Help Manager are automatically appended.



The complete Gpf Editor is included with this demo,  so you may
see the full benefits of this tool and the speed with which
complex GUI's can be created.  Please review the following
sections,  install Gpf on your hard drive,  and go through the
Guided Tour.





Differences Between Demo and Full versions





The Demo version:



does not save any of your work between sessions



has the ANIMATOR disabled, as this function requires a saved file



does not include the code GENERATOR



LIB and INCLUDE sub-directories are not included, required by
the GENERATOR only



utility GPFRES.EXE is not included, which converts existing .RES
files to the Gpf binary format







What is included with this Demo Version



In addition to this document, a demo software distribution
diskette is enclosed.  This diskette is a 3-1/2" disk, in DS/HD
(1.4 MB) format.  The diskette is not copy protected and you may
create and distribute as many local

copies as you desire, including this documentation.  YOU MAY NOT
upload and install this software onto a public or private BBS,
without express written permission from Gpf Systems.  [Your LAN
is not considered to be a BBS.]



The distribution diskette is organized with an hierarchical
directory structure.  This will be copied to your hard drive, in
total, by the INSTALL program.



What you will need to run this demo



Software requirements are:



OS/2 version 2.0 or later



DataBase Manager (OS/2 Extended Services) up and running,  if
you wish to create an application which makes use of the SQL
facilities.



Note: the SAMPLE.ORC example, in sub-directory SAMPLE32,
utilizes OS/2 DataBase Manager.



Hardware requirements are:



An Intel 80386 or 80486 or other OS/2 2.x compatible PC or
workstation



a hard drive with approximately 2 MBytes of available space



6 MBytes system memory (8 MBytes recommended)



a mouse



a VGA or 8514 video system

Installing the Demo





Installation may be accomplished from the Workplace Shell
Desktop or from an OS/2 Command line.



1. From the Desktop open the disk drive containing the Gpf demo
diskette by double clicking on the appropriate icon, Drive A or
Drive B.



2. Expand the root directory listing by double-clicking on its
icon.



3. Double-click on entry INSTALL.CMD.



4. The INSTALL program is a full PM program (written with Gpf,
of course), and will load itself and present an opening screen.
Dismiss the About screen if your Desktop is not configured to do
this automatically.



5. Select menu item Installation, Setup.



6. Accept or edit entries in the secondary screen, as desired.
These entries represent source and destination directories.  At
this time it is important to note  or change the group into
which Gpf  will be installed so you can find the Gpf Icons.  If
you do not have any groups defined Gpf will create one. It is
also important to remember whether you have opted to create a
CONFIG.NEW or modify CONFIG.SYS.  Help is available if needed.



7. Press Ok.  You will be returned to the entry screen, from
which you can monitor installation progress.



8. When done with the install, Gpf will print some information
in the progress window.  Make note of the contents, and exit
this program.



9.  If you have opted to create CONFIG.NEW save your existing
CONFIG.SYS and then rename CONFIG.NEW to CONFIG.SYS.  If you
opted to modify CONFIG.SYS the install program has already made
a backup  copy of CONFIG.SYS.   You may inspect the
modifications to your CONFIG.SYS (or CONFIG.NEW) and ensure they
are satisfactory.



10. Remove the diskette and conduct an orderly shutdown, then
re-boot your system.



11. The Gpf Demo program has been placed in the Group you
selected during the install.



A Guided Tour



Starting Gpf



The installation process has added a Gpf entry into your GROUP-
MAIN.  Find it and double click on the entry. Dismiss the About
screen if your Desktop is not configured to do this
automatically.







Using Gpf- a short guided tour



The purpose of this tour is to show you some of Gpf's
capabilities, and the speed with which an integrated application
can be created.  If you have been using some other tool to
design your PM interfaces don't be misled by how easy Gpf is to
use.  You really are building a complete user interface, not
just a skeleton which you must later fill in.



Gpf is organized into three areas wherein most of the work is
accomplished.  The first is the Gpf editor menu, from which you
create and manipulate the objects which go into your interface.
The second is the WYSIWYG representation of the windows and
objects made via the Gpf editor.  The third area is a set of
definition screens which define the properties for a given
object.  In general your screen will typically display either
the first two or the third.



Definition screens are entered in one of two ways:  a.) when you
use the create menu to make an object, you will be automatically
transferred to its definition screen as soon as the object is
placed (dropped), unless you have changed this default.  b.)
from the WYSIWYG mode, double click on any object to see/modify
the definition for that object.



Definition screens are exited in one of two ways:  a.) press the
Cancel button if you've made some changes and then decided not
to have them implemented  b.) press the Ok button if no changes
were made, or the changes are desired.



In brief, creation of a user interface with Gpf is the
sequential  performance of these steps:



define (or register) auxiliary items, such as presentation
parameters, icons, and user code



design all the screens (including information messages and HELP
entries)



define all the actions to associate with controls, including
links to your (user) code. In essence, define the logical flow
of your program, and its integration with the GUI



test/animate proper operation



install the help panels



process all the generated code



The demo version allows all of the above except the last step,
as the code generator is not present on the diskette.  The
ANIMATE function is also not active, as that requires SAVING
your work file and all SAVE function are disabled in the demo.
Note that GpfRun (the Animator) is available from the desktop or
Command line to permit animation of the samples provided.



Creating an Interface



Starting a new design



    From the Gpf editor main screen, select File + New...



The program property screen appears. The only required field is
the "Main Source Name".  Enter any name here, then duplicate it
in the "TaskList Title" field.  Ignore all other fields/controls
and press on "Ok".





















































The DEFAULT main entry screen appears, and has the logical name
of "MainWindow" (as listed in the WINDOW option on the edit menu
bar, and in its definition screen which we will visit shortly).
Unless re-defined later, this will be the primary screen of any
created application, the first a user will see.  We will now
modify it.



















NOTE:    the mouse cursor will change shape as an aid to
identifying the current mode and current field. The general
cursor is simply a large arrow; but if you drag it slowly over
the menu bar it will momentarily change to an index finger.
While in this shape, a mouse click will place you in menu bar
edit.  Or clicking once while it is in its general shape will
cause it to change to a hollow cross; this is the object
selection cursor, and the current object outline is emphasized.
Double clicking on an object with this cursor will place you in
a definition screen hierarchy for that object.







The current screen (or any object, for that matter) can be
resized or moved at any time.  Gpf marks the current object by
making that object's border dark gray in color.  Ensure that
"MainWindow"  is the current object by placing the cursor in the
middle of it and clicking the left mouse button once.  (If you
accidentally double click on the button you will not only select
the screen but you will also be placed in a definition dialog
for it.  No harm done,  just press the Cancel button to return.)
 Press and hold down the left mouse button while dragging the
screen to your display's center.   At this point you are
changing the initial size and location of the entry screen of
the application you are creating.





Editing the default MAIN screen



With the cursor in the middle of the new screen, double click on
the left mouse button.  The "styles" definition dialog will
appear.





Edit the "Title" field by placing the cursor in that field and
clicking once.  Delete the default text and replace it with an
appropriate string, such as "Demo Test Screen- Main".  This text
will be filled in on the MainWindow title bar [You can, at any
time, click on the "Ok"  button to view the results of any
selections; re-enter by double click, as before].  Experiment
all you like and examine the results. The only change needed for
this tour is the alteration of the title text.



Press "Ok" to return to the main editor screen, and the view of
the screen being generated .



From the "Toolkit" menu, select "TEST" (notice that all other
menu options will be disabled).  In this mode you can view some
of the actions associated with defined controls, such as
drop-down menus.



Click on "File" and then "Help" menu selections.  This will show
you the default sub-menus attached to these choices. We will
edit one or two.  Click on the system button (upper left), then
on the minimize (down arrow) button in the upper right.  To
restore, double click on the icon.





Exit the test mode by clicking on "Toolkit", then "Test".





A number of differing approaches may be used when building a
design with Gpf.  In this tutorial we will build a design in a
bottom up manner, that is we will create a number of simple
objects and combine them to complete the design.  This is easy
and logical since Gpf allows for the creation and maintenance of
lists of PM objects.  These objects may then be used and reused
in conjunction with standard objects and controls to create a
design of any level of complexity.



Create Presentation Objects



Create two objects by pressing on "Object", then "Presentation
Object...".

Presentation objects  are named sets of visual attributes which
can be attached to buttons, frames, listboxes, etc.  We will be
able to assign these attributes to controls and frames created
later.



In the "Presentation Parameters" screen press the "Add" button
to add to displayed list of Presentation Parameters;  you should
be presented with the Presentation Parameter definition screen
(see fig.)









edit the Name field to "PresOptions"



scroll through and select "18.Helv" in Font Name Size



scroll through and select "Clr_Blue" in Background Color



scroll through and select "Clr_Yellow" in Foreground Color



scroll through and select "Clr_DarkBlue" in Border Color







press the "Ok" button; the set of attributes just created now
appears in the list



press "Add" again



edit the Name field to "Danger"



scroll through and select "14.Helv" in Font Name Size



scroll through and select "Clr_Red" in Background Color



scroll through and select "Clr_Yellow" in Foreground Color



scroll through and select "Clr_Pink" in Border Color



press on "Ok" button,  in two screens.  You are back in the top
screen.





Register a bitmap & icon object



press "Object", then "Icon/Bitmap/Pointer Object...."



press on "Add Object"



press "BitMap" radio button, in the File type field



select,  in the directory field,  your Gpf
drive:\directory\SAMPLE32. The SAMPLE32 directory is a
sub-directory of your Gpf directory, created during the INSTALL
process.  Depending on how you organized your installation, you
may need to select several items in succession;  check the Path
field as you "build" the full path name.



highlight (single click) SAMPLE4.BMP  in the File Name list box



in the "Name" field change the default name (Icon1) to
FileCabinet



press "Ok" .  The item is now listed (registered), and you can
see its image in the list.







press "Add Object" again



press the Icon pushbutton



create the path name,  as before, to your Gpf
drive:\directory\SAMPLE



select any entry in File Name, such as SAMPLE2.ICO





press "Ok" in succeeding screens until you are back at the top
(original) level





create a User Object



press "Object", then "User Function Object..."

User Function Objects  are named custom application code pieces
or methods.  These objects are used along with Gpf built in
actions to allow the creation of complete applications without
need to modify the generated source files.



in the USER FUNCTION screen, press on "Add"; a two-field screen
appears



edit the Name field to "MyCode", then press the Tab key (NOT
return), or click on the edit screen with the mouse;  you are
now in a simple text editor



enter any typical code, such as "CallMyFunction();".   Syntax
rules will not be enforced, but of course would be important in
the full version of Gpf,  which would insert this code in
generated files.



press "Ok" to return to the preceding screen. Note that MyCode
now appears in the list of registered functions.



press on "Ok" again;  you should be at the top level



Just as we have registered and created these objects, we could
build lists of User Controls and Message Boxes for use in our
design.  Since we now have a few items to work with let's begin
our design.



Editing the Menu Bar



Place the cursor on the menu bar (it will change shape to an
"index" finger) and click.  The "Selection ActionBar" dialog for
this window is activated.



in the select window, double click on the "ActionBarHelp" entry.
The new  dialog allows you to define some additional properties
for this item.



in the styles box click on the "Button Separator" checkbox, a
tick mark should appear, indicating an active option



press the arrow in the "Accelerator Key" box, then scroll down
and click on the "F1" entry.



press "OK" to return to the "Selection ActionBar" dialog



press the "+" button by the "ActionBarHelp" entry to expand the
Pulldown menu list



with the mouse (or arrow keys) select the "PullDownKeysHelp"
line, then press on the "Destroy" button.  Confirm this action
when presented with a message.  This item is now deleted.



with the mouse (or the arrow keys) select "ActionBarFile", then
press on "Add Sibling" , you again find yourself in the "Menu
options" definition screen

The effect of add sibling is to create another item immediately
following the select item and at the same level. As we will see
later, add children will add an item at a lower level, in this
case a pulldown.



edit the "Name" field to "Options".  This will be the logical ID
for this item; for this and other objects this is the name by
which it can be accessed,  e.g. by hypertext links in the Help
System.



edit the "Text" field to read "~Options".

The tilde preceding the 'O' will cause this letter to be
underscored, such that in the compiled application an 'Alt-O'
keystroke will invoke this menu.



in "Submenu Presentation" drop down list, select "PresOptions",
defined earlier.



press "OK" to return to the "ActionBar Selection" dialog,
"ActionBar1"  which we just created should be highlighted



press "Add Children", in this case we will define a pulldown









edit the "Name" field to "OptionsSearch"



edit the "Text" field to "~Search"



select "Danger" from the "Submenu Presentation" box



press "OK"  to accept and return



press the "Add Children" button to create yet another level of
menus; i.e. a submenu





edit "Text" to "By ~Name"



press "Ok"







press "Add Sibling" to add another submenu to "OptionsSearch"
pulldown



edit "Text" to "By ~Attribute"



press "Ok" to return to the "Selection ActionBar" dialog





Now let's create another pulldown just to complete the menu.



select the "OptionsSearch" pulldown we just created using the
mouse (or cursor keys)



press "Add Sibling"  to add another pulldown









on the "Menu Options" dialog edit the "Name" field to
"OptionDestroy"



edit  the "Text" field to "~Delete"



press "OK" to return



press  "Add Children"; to create a submenu



on right hand side of the "Menu Options" dialog, locate the
"Type" box and click on the BitMap button.  The down-arrow box
in the combo box will become active, next to the (default) name
NULL.



click on the down-arrow, activating the selection window.  All
registered (we only did one) bitmaps will be listed.



click (select) the last entry.  The bitmap will appear in the
display area.



press "OK" to complete the submenu



press "OK" again to complete the menu definition and return the
WYSIWYG editor, note the changes to the Menu Bar.

















Adding a button control.







Press on "Create" menu item, then select "Button" from the
pulldown,



Select PushButton from the  Button submenu. [ Figure 7]



Drag the created object to the bottom-center of your Main
Window, perhaps an inch up from the bottom border.



Click on the left mouse button to drop it. You will be placed in
the Button Control Styles window,

































edit the Text field to read "~Panic"; this is the button label



in the Presentation box, scroll through and select "Danger", as
in



press "Ok",  which will return you to the editor and main menu

















place the cursor on the new PANIC button and click once, left
button;  the border of the button should change to gray,
indicating that this is now the 'current' object.

Slowly drag the cursor around the object, and note how the
cursor will change shape as you traverse the object borders.
In this manner you can  re-size the border(s) in any cardinal
direction; the behavior here is similar to that of PM
sizable-border objects.  To simply move the object, without
sizing, place the 'hollow-cross' cursor in the middle of the
button, then press and hold down the left button.  The cursor
will change to quad arrows. With the button still depressed, you
can drag the object anywhere within the client area and drop it
by releasing the mouse button.  Experiment a little,  moving and
re-sizing the button.



More fundamental changes to this object can be performed by a
quick  double-click on that object, which will take you back to
the initial definition screen for that object.  All such screens
can be exited by successive presses on "Ok".



Although not strictly part of this "guided tour", you can
similarly create an instance of every object listed in the
"Create" submenu. You may also duplicate an object by dragging
its shadow with the right mouse button.  When positioned and
released a copy of the object will be created.   It wouldn't
hurt to experiment a bit.  An object can always be removed by
double-clicking on it, then pressing on "Destroy" in its primary
definition screen [you will be asked to verify your intent by a
message screen; press "Yes"].  The definition screens will give
you a good idea of the sorts of attributes which are
controllable for each object.



By now you should have noticed the general Gpf design
methodology; new objects are always begun from the "Create"
menu, dropped on the screen, and their attributes set/modified
from the definition screen for that object.  There are two ways
to get to an object's definition screen:



- when you first create an object, you are taken to that screen
immediately upon initially locating the object on the screen
under construction. (Note that this is a default option which
may be turned off from the "Options" menu.



- from the graphical screen, double click the cursor in the
center of any existing object.





Adding a ListBox control



using the mouse select "Listbox" from the create menu



drop the listbox in the upper half of the screen being built.
You will immediately be taken to the underlying definition screen



in the "Control Styles" group box, click "Horz Scroll Bar" to
the ON state.  Press "OK" to return to the edit screen



re-size the list box so that it occupies a majority of the
client area, similar to the figure below



The completed screen can be placed in Test mode. Check all
functions, particularly the alterations and additions to the
menu bar.



select "Test" from the Toolkit menu using the mouse











The system menu is operable, as are the minimize/maximize
buttons, and the sizable border.  A bit later we will show you
how to add intelligence to the controls we've created so far.



return from Test mode by again selecting "Test" from the Toolkit
menu









Secondary Windows and Extended Help



Creating more windows and/or secondary (child) windows with Gpf
is as simple as creating another control.  Once created, the
window is manipulated and filled in just as the default entry
screen we have been working on.  Just as with any control, when
we create a new window we will be placed in its definition
screen.



In the Gpf Editor main menu, click on "Window".  The selection
"MainWindow" will appear, along with a checkmark indicating that
it is visible.

This pulldown offers a list of all windows in the current
design.  The tick or checkmark by any window indicates that the
window is shown and available to work on.   Via this mechanism
windows may be toggled on and off to keep the screen from
becoming cluttered.  Since we have created only one window so
far, the list is somewhat short, i.e. a single entry.



click on "MainWindow" to toggle it off (it will remain in memory
and can always be brought back with the same steps), giving you
a clean screen to work with.



select "Window/Dialog..." from the  Create menu; A new window
with a set of standard default styles will be created.





in both the Parent and Owner fields, select MainWindow instead
of the current choice, DESKTOP



edit the "Title" field to "Child Window"



click the "System Menu" checkbox OFF



click the "APPL Modal" checkbox OFF



click the "Information Msg" checkbox ON



click both "Horz Scroll Bar" and "Vert Scroll Bar" checkboxes ON



in Border Styles, select "Dialog Border"



press "OK"















click on "Window" in the Gpf Editor main menu to activate the
Window menu - notice that now both windows are listed.

The MainWindow can be displayed by itself, but the secondary
cannot; this is due to PM ownership rules. Click on the
secondary window name... if visible, it will vanish, and vice
versa.  Make sure it is invisible, then click on MainWindow
until it is visible.





Up to this point we have been ignoring key buttons in the
definition windows: EntryHelp, Associate, Destroy, and Action.
These are critical to the final application, but unfortunately
their effects cannot be simulated in TEST mode (in other words
with this version).  However, the definition phase can be walked
through, and the effects described.



NOTE:  the Associate button, used for OS/2 DataBase Manager
table reads, is disabled unless the application was defined to
have a DBM tie from the outset (see File- Properties menu.)



double click on the MainWindow object anywhere in the client
area or title bar (not the PANIC button or the Listbox!!)



press on "EntryHelp".  A window with four main sections appears:











The HelpTitle and HelpIndex fields can be edited to meaningful
titles if desired; their effect is the inclusion of these titles
in the general, system HELP screens with your name, instead of
the default sequential names assigned by Gpf.



The large central box is a multiple line entry dialog box, into
which you can enter the text you want to associate with the HELP
screen for the current object. The user, when F1 is pressed,
will see this text in a PM HELP screen.  It can also be accessed
via TITLE\INDEX from higher level system HELP utilities.



The Information Message field can be edited with abbreviated
help information, along the lines of a prompt. This text will
appear at the bottom of the screen if that screen had the
Information Msg checkbox selected during screen definition.









Edit these fields as you please, but keep in mind that you will
not be able to see any results when you return to higher levels.
[The ANIMATOR in the FULL version would allow you to see
Information Messages, and would also prepare the complete HELP
files as required by the IPF utilities.  These would be
automatically processed when you GENERATE or COMPILE, and linked
in to your application.  Sorry... there are limits to the DEMO.]



press "OK" to return to the window definition screen



press "OK" again to return to the Gpf main menu

Linking Screens and Program Logic



This section describes the method employed by Gpf to install
Actions (program flow) to and between the screens and controls
created in preceding steps.  It is very important that all
desired objects are defined, or else they will not appear in the
lists Gpf uses to help you with this major step.



ensure you are in the top level screen and that MainWindow is
visible.  Turn off the secondary window from the Window menu
item, if necessary.



double click on the PANIC button in order to enter its primary
definition screen.



press on "Action".

You are now being presented with a list of action anchor points
or events to which you may attach actions.  Since a button is a
simple control the only anchor point is "Click [Button]".  Other
controls offer more anchor points appropriate to their
functionality.



press on the "View\Modify Action On..." button

you will be presented with an empty list of actions to be
performed on the Button Click



press on "AddTop", which is where we will define what is to
occur when the user presses on the PANIC button.

You are now presented with a list of actions and objects to act
upon.  From this list we choose the functions to invoke when the
button is clicked.







scroll down the "Action" list to the bottom entry, "User
Function"



click on "User Function" ; note that the "Object column now
lists all the user objects we have created (again a somewhat
short list)



click on the "MyCode" entry in the Object list.

You have just created a link between Gpf code and your code,
which can be in-line or an external function call.   [But how
does Gpf resolve function prototyping to external functions ??
Easy... if there exists (in your source directory) a '.H' header
file, of the same name as the set of screens you are creating,
it will automatically be "#included" into the source file being
created by Gpf.  Into this header file, which can include other
files, you would place all GLOBALS\EXTERNALS etc.]



press "OK", in each screen until you return to the Gpf main menu
level and the WYSIWYG Editor



select the application Menu Bar (the pointer will change to an
index finger; click at that point).



press the "+" by  the "ActionBarFile" ("File") entry to expand
the menu view



select the "PullDownExit" ("Exit") by either clicking on the
entry to highlight it then pressing "View/Modify" or simply
double click "PullDownExit"



press on "Action"



press on "View/Modify Action On..." (or double click "Click
[Menu]")



ensure the list of action includes  "Quit  Application   #".  If
not you may use "Add Top", "Add", or "Update to invoke the
Action list and select "Quit Application"



press "OK" on each action screen until you have returned to the
"Menu options" screen



press "OK" to return to the "Selection ActionBar" screen



expand the "ActionBar1" ("Options") entry this time (as opposed
to the "ActionBarFile" just done)



double click on the "OptionsDestroy" ("Delete") entry.



double click  on "SubMenu 1",



press "Action"

We are defining what will happen when the user presses on the
bitmap.



double click "Click [Menu]" or press "View Modify..."



press on "AddTop" on the list of actions screen



in the Action list select screen, select "Window Show(visible)"



in the window list on the action list select screen, select
"Window1"



accept each screen by pressing "OK"  until you return to the Gpf
main menu and editor



At this point you have created a link between the two generated
screens.  In ANIMATE mode (not present) you would be able to see
the second screen appear when you selected that particular
option from the menu bar. Of course, user code is inescapable at
some point unless you are simply creating an interface during a
conceptual phase, or preparing an executive  presentation.
However, how this would be done has already been shown in one
instance; all else is mostly a repetition of the same steps.



press "Test" in the "Toolkit" pulldown menu







 The Gpf Editor has been placed in test mode and the pulldowns
are being examined.













If you have faithfully followed all the instructions in this
tutorial, this is how you design should appear in test mode.
You may want to experiment some more with the more complicated
CUA 91 controls; i.e. Notebook, ValueSet, etc. now that you
understand the basic methodology used by Gpf.  The more powerful
controls are created and modified just as we have seen, they
just have many more options.



























 Sample Pre-defined Interface



This is included on your disk for inspection purposes, as an
example which shows more complicated features and/or
hierarchies. The file of interest is SAMPLE.ORC, located in the
SAMPLE32 sub-directory under Gpf.

From the Gpf Main Menu:



Click on FILES, then on OPEN.



change the DRIVE\DIRECTORY field to the SAMPLE32 sub-directory.



double click on SAMPLE.ORC



NOTE:  if Extended Services DataBase Manager is not running, you
may get warning  messages. It is OK to say YES to the
"Destroy,.... etc." message window; the change will not be
saved. [NOTE: this sample application interacts with the system
SQL functions. It assumes you have at some point run SQLSAMPL as
part of learning DBM. This utility creates a sample database,
used by our demo].



The primary reason for inclusion of this set of screens is to
show you how a more complex set of screens can be
interconnected, both with Actions, and with Association(s) to  a
Database.  Examine the definition screens,  particularly the
Action option.  You can edit these as well,  though any
modifications performed by you will not be saved;  but you can
edit the windows and simulate them under TEST.  When you Exit,
or perform any operation which asks you if you want to Save the
current file (SAMPLE), answer NO.



Also included is the C source code generated from this
application.   As this is an SQL application the source file is
suffixed ".SQC".  SAMPLE.SQC has been included to provide you
the opportunity to evaluate the quality of Gpf generated code.



GPFRUN.EXE - The Animator



GpfRun  is the Gpf Animator program.  Though the demo will not
allow you to call this program from the editor you may use it to
animate the sample .ORC files shipped with the demo.   Paths for
GpfRun are not set automatically by the demo installation.  If
you wish to use this program you must assure that it has access
to the directory containing your .ORC files.  The program may
then be invoked from the OS/2 desktop or command line with an
ORC as the argument.



What else can Gpf do, beyond the DEMO version ?



create dynamic, position sensitive messages. [the DEMO version
allows you to create these, but not view the results; the
Animate function is able to show these.]



create a full Extended HELP system, screen leve, or down to
control object level.



interfacing to system DATA BASES created by DBM. Gpf logs and
presents for selection ALL data bases found on the system.



save all your work



read existing  .ORC and .RES files.



generate all application-specific intermediate and source code
files



automate the LINK/COMPILE cycle



the ANIMATOR is fully integrated into the editor, which permits
inspection of the complete  interface without compilations.



create and link message screens (INFO, ERROR, WARNING, etc.).



incremental code development.



Where Does One Go From Here ?



Contact Gpf Systems regarding price and delivery.



The Gpf product is shipped in two versions:



DEMO-- the product you have. This version is functional to the
point of saving: all work is volatile and will vanish when you
power down or exit the editor.  However, you can create
arbitrarily complex user interfaces exactly as in the full Gpf
version.  The TEST mode can be invoked,  allowing a high level
check of control operations.



A full version, price dependent on volume.



FULL-- combines the demo with save facilities, the code
generators, and a comprehensive set of sample designs.  The
ANIMATOR is also supplied, permitting a higher level of
simulation (such as HELP system, information messages, etc.)



Both versions have the identical user interface. The experience
gained by using one is directly applicable to the other.  For
all further information:



    Gpf Systems, Inc.



    30 Falls Road



    P.O. Box 414



    Moodus, CT  06469



    Tel: [phone]      Fax: [phone]



    Sales: [phone]