Authors: M.Ballintijn(1), J.J.Bunn(1), O.Couet(1), I.Gaponenko(2), P.Lecointe(1)
(1) CERN (2) BINP
This document describes the KUIP2TCL Starter Kit, which is a package of routines for converting applications with a KUIP-based user interface into Tk/Tcl-based applications.
The KUIP package was developed in the Applications Software and Databases Group at CERN with the intention of providing a user toolkit for interactive applications programming. The PAW program uses KUIP to provide both command line and Motif-based user interfaces.
In recent years, several Public Domain user interface packages have become available, the most famous of these being Tk/Tcl, which now enjoys enormous popularity. The Tk/Tcl package interfaces to the X-Windows system to provide the user with very convenient and easy means of creating widgets and integrating existing applications code.
The functionality of Tk/Tcl exceeds that of KUIP, and sports a multitude of add-on packages such as tkWWW, ObjectTcl, [incr Tcl], and so on. Tk/Tcl is available for most Unix platforms, for VMS, and for Windows ('95, NT and 3.1).
Why convert from KUIP to Tk/Tcl?
Why would one want to convert a KUIP-based application to Tk/Tcl? There are several reasons:
Tk/Tcl does, however, have some disadvantages compared with KUIP. These include lack of command line editing and break handling in the standard distribution, for example.
The KUIP Command Definition File (CDF)
One strength of KUIP is that it requires the applications programmer to descriptively specify the commands in the package. The description is kept in one or more CDFs, and conforms to a regular syntax. This syntax describes the individual commands, their arguments, types, options, together with their position in the command tree hierarchy. In addition, lines of "Guidance" are included that KUIP uses as online help text. Each command in the CDF is tagged with a so-called "Action Routine", which is the name of a Fortran or C module that is called whenever the command is invoked. It is the action routine which carries out the command in the application's environment.
The KUIP2TCL scheme
The principal idea here is to take the application's CDF and convert it to Tcl command definitions. This can be done automatically by a program which reads the CDF and writes the Tcl C code. The Tcl code includes logic which, when the user invokes a command, takes care of retrieving the arguments and default values, before making them available to the action command.
Once the Tcl C code has been automatically generated from the CDF, it can be called in the initialisation phase of Tk/Tcl (i.e. in TclAppinit). This instantly makes available all the application's commands at the command line.
The commands are available in two forms: either in the usual KUIP form (e.g. HIS/PLOT) or in the new form (e.g. Histogram_Plot). The conversion between the KUIP form and the new form is achieved by a special version of the "unknown" Tcl command, which attempts to resolve a command typed by the user by matching (globbing) against the set of available commands.
A simple help is available, that pops up the "guidance" text and command parameters in a top level Tk window whenever the user gives "?" as the first parameter of a command, or when the user types "help" followed by the name of a command.
The KUIP replacement routines
Existing KUIP-based applications use routines such as KUGETI (get Integer), KUGETR (get Real) etc. in the action routines to obtain the argument tokens for each command typed by the user. The KUIP2TCL package allows the use of such code without change, by providing a new set of functions KUGETI, KUGETR etc. that instead retrieve the arguments from Tcl. (In addition, the KUIP vector routines have been replaced by a set using C mallocs, so removing the previous ZEBRA Common size restriction.) The KUIP replacement routines are intended to be a full drop-in replacement for the existing KUIP package (but see below under "Restrictions").
The TREE Widget
The KUIP2TCL package offers new functionality over KUIP with the provision of a command tree widget that allows a graphical exploration of the application's command hierarchy, and windowed display of each command's help text. The tree widget may also be run as a stand-alone program for exploring command trees generated from CDF files.
To convert a KUIP-based application to Tk/Tcl, the following steps need to be taken:
An example of KUIP application conversion
The KUIP2TCL package includes an example KUIP Fortran application that has commands to initialise and generate uniformly distributed random numbers in a given range. The example shows how this may be converted to a Tk/Tcl application with a set of buttons and text boxes, together with the command line interface.
KUIP2TCL is a starter kit, and it is not expected that it will perform a complete conversion in all cases. The application programmer will usually have to do some extra work before the Tk/Tcl version is ready for "Prime Time". In particular, the following limitations are noted:
We have successfully used KUIP2TCL to generate a Tk/Tcl version of PAW: the KUIP replacement routines provided are those which we required to make this conversion.
KUIP2TCL is provided in versions for HP/UX, SGI Irix, OpenVMS and Windows/NT,95.