GUI ScreenIO Conversion

Our Legacy ScreenIO product users do not have to worry about being abandoned.  

We have provided a conversion tool that will convert not only your Panels, but also your Programs to the new GUI ScreenIO format.  Its fast, and takes care of 98% of the changes you need to get legacy systems up and running in GUI ScreenIO.

What it Does

The converter works in three steps:

Before any of these steps are started you can specify how you want the panels to look, and whether you want to preserve the color that Legacy ScreenIO had, or convert to the standard windows appearance, etc.

The Converter Control Screen:

(You can make these choices and apply them en-mass to all the panels, or you can convert sub-sets of panels using one set of choices and other panels with different options to obtain the best look.)

You can also specify directories where your Panel Source library is located, where your programs are located and where you want the converted application to be stored. 

Step One:  Scan

The converter first scans your source programs determining which programs use which screens, and what hidden function keys appear in the code but are not documented on the panels.  It writes a database in a directory that is used solely for the conversion project and may then be discarded.

Step Two:  Panels

Next it runs though your Panel Source Library and converts each panel to a copybook in the New GUI ScreenIO format.  These can immediately be edited and tweaked with the panel editor.  Those function keys that appeared in the menu line will be converted to Buttons and/or into standard Windows Menu items depending on the choices you made.  There will be one copybook for each panel.  These copybooks contain all the information needed at run time as well as information needed to edit the panels in the editor.  The new GUI ScreenIO does not use of a panel source library, as we found this to be problematic and subject to corruption.

Step Three: Code

Finally, after the Scan and Panel conversion the source code is converted and placed in another subdirectory (with a naming convention guaranteed to prevent overlaying your original source).  The code conversion changes the call to the Legacy ScreenIO to a call to the new screen manager (GS) and adjusts the names of fields in the copybook, as well as the handling of Exit Keys (now called event IDs).

The conversion of the code is about 98% perfect.  There may be some non-standard coding techniques that the converter can not handle, but it will flag these in the code with comments.  Each line the converter changes will remain in the code - we throw nothing away.  We convert the old line to a comment and insert the new line below it.  After the program is tested you can easily delete the old lines with a mass-change via any competent programmers editor.

Clean UP

You will find that the panel conversion does a pretty good job of converting the legacy panels to a graphical form.  You will also discover an open secret about Text Based screens as opposed to GUI Screens:  Graphical user interfaces take more room to show the same amount of data.  The converter spaces things found in the Legacy screen for best fit, but panels will always tend to be bigger in the GUI world. 

You of course can edit the screens with the editor immediately after they are converted.  You can use the alignment feature in the editor to do fine adjustments, as well as drag fields around, re-order panel fields, and selectivly change fonts and colors etc.  All of this is much easier than the editing offered by the legacy product.

You can also go back and re-convert the screens using different options without having to repeat the pre-scan or the code conversion to get a better look and feel.  Just don't delete the database created in the pre-scan step and you can repeat this as often as needed.

Some General Recommendations

As a rule, you will find windows applications make sparse use of color.  This is by design, so that the application takes on the appearance of the users desktop theme.  If you choose to retain the color with the Color options on the screen shown above, your application will look somewhat non standard, but it will function exactly as before, and may appear more to your user's liking initially.  However, in the long term, we have found that removing all color from the screens seems to work better.  You can then go back in and add color where it is needed to call attention to certain features. 

You might be tempted to change screens immediately after conversion. But we recommend you wait till the application is mostly running under GUI ScreenIO before you make extensive changes.   Its easy to get side tracked from the conversion project beautifying screens.  Our advice is to get it up and running making virtually No changes to the screens.  Then go back and fix them to your hearts content, and perhaps start utilizing some of the newer controls (field types) to replace older methods.  For instance you might replace your older browse screens with our listview using our code generator to recreate the program needed to drive listviews.  

Note that the conversion does not create listviews, radio buttons, treeviews, Image controls, or Combo Boxes, or Check boxes as there were no direct equivalent to these in the legacy application.  This assures that your application will run the same after conversion as it did before with 98% of the code changes being handled by the converter.

After the application is running, you may want to convert some fields to the newer types of controls.  For example you might want to change those fields that were used for making selections (usually by typing a single character in them) to check boxes. The code changes for this are minimal.  Mutually exclusive choices can be converted to radio buttons, often throwing away huge chunks of editing code which would be no longer needed as windows makes sure that only one radio button in each group can be selected at a time.  You may want to convert date fields to the date-picker format, which offers a pop-down calendar for selection of the date.

You may want to convert very large or busy panels to property sheets.  With a property sheet there is more than one page (tab) on a panel and you can organize the field by frequency of use such that not ALL of the fields are staring you in the face when the screen pops up, only the important ones.  This conversion is particularly easy, because all you need to do is change the properties of the panel to a property sheet, and then select groups of fields (rubber-band selector) and Delete them (which first copies them to the clipboard for safety) and then click on on of the other tabs in the property sheet and select the "Paste" option.  After this is done, you can re-size the property sheet to a smaller size.  Oh, and the best part:  Your program is none the wiser!  A property sheet is a single panel as far as GUI ScreenIO is concerned, so no programming changes are needed.

Your Main Program will require modification, you have to generate a Main Panel (an empty container that the other panels are subordinate to).  See the Getting started section in the help.

What do Converted panels look like?

Here is an example from a legacy Order Entry system (from a company that shall remain nameless) with both the pre and post conversion images shown.   

Above is the Pre-Conversion Image. 

The post conversion screen is untouched, it comes out of the converter looking exactly as you see here.

Above is the Post Conversion Image as shown in the Panel Editor (the panel editor has an "Execute" function that allows you to show dummy-data in fields, tab around, and exercise the menu and pushbuttons, etc.)

You can see that a little cleanup might be in order, but that the conversion is true to the original.  (We chose to remove color for this conversion).

The Conversion utility is free and is included with GUI ScreenIO.  Unfortunately it only works with our Legacy ScreenIO product.