[Pipet Devel] constructing the command-line

J.W. Bizzaro bizzaro at bc.edu
Sun Jun 6 08:21:00 EDT 1999


As the development continues, it appears the users will be able to construct
their own gui's by connecting loci together.  This will involve the use of an
XML similar to Damon Chaplin's Glade XML, which was really made just to save

Here is an example of Glade XML.  It's simply a button placed in a container and
in a window.

<?xml version="1.0"?>






Note: James Henstridge already made a Python script to generate a PyGTK gui from
Glade XML.

You can see that the widgets here are Gtk widgets; of course, this is for Gtk. 
But let's say we make higher level, composite widgets (the "megawidgets" I've
been talking about).  Instead simple gui widgets, some of Loci's composite
widgets will generate the options of a command-line.  (Some composite widgets
will be biowidgets of a sort.)

For example, in the build phase we start off with a windowlet/locus containing a
composite widget that is an option to choose the name of a program.  This may
simply have a text entry box where the user can type in the name.

Next, the user can add a flag option.  A new locus appears, and they are
presented with a pull down list of all flags, -a to -Z.  Underneath that is a
text entry box that goes with the flag, because sometimes a flag option expects
a term to be added.

And the user can actually specify types and ranges for any option.  Say the
program that the gui is being built for requires an integer after the -n flag. 
In the build phase, the user can set this using some radio button or something.

At this point the user will see several composite widgets, each with its own
locus, all connected with lines.  Selecting the parent locus (the first one
made), the user can pull down a menu and cause them all to be merged into a
functional, gui representation of a command-line.  Now that the locus is out of
the build phase, only the options that were not previously set are visible.

I mentioned a couple months ago that there are some programs meant to wrap
command-lines in a gui.  GGUI is one that uses wizards:


I also found TkWorld, which is like GGUI:


But Loci is not meant to be just a command-line generator.  It will do this, but
much more will be included.  For one, Loci will keep biodata in a standardized
XML format.  This will require conversion utilities: one for LocusML ->
program-format, and one for program-format -> LocusML.  This is because, unlike
simple UNIX shell utilities, most bioinfo programs have specific format

Another issue I don't believe is addressed so nicely by GGUI and TkWorld, is
piping.  Loci's loci will, by the nature of the bioinfo programs used, make
extensive use of piping or connecting output to input.  And this is supposed to
occur seamlessly over the Internet; not something normally done in the UNIX

So what will the resultant gui XML look like?  I think that when the loci are
combined, the XML's can be concatonated.  And the user can take them back apart,
recombine them as they wish, and even save/store them.  A really neat result is
that a user can make some unique concoction and then send it across the Internet
to someone else using Loci.  Rapid locus development and sharing will be
important to Loci's success.

Well, if you read this far, thank you.

J.W. Bizzaro                  mailto:bizzaro at bc.edu
Boston College Chemistry      http://www.uml.edu/Dept/Chem/Bizzaro/

More information about the Pipet-Devel mailing list