
CHANGES for Wafe 0.96 (relative to 0.95):

TABLE OF CONTENTS:

 o NEWER COMPONENTS
 o BUG FIXES
 o HYPERTEXT SUPPORT
 o NEW FEATURES
 o BETTER OSF/MOTIF SUPPORT
 o BETTER PERL SUPPORT
 o MORE TCL SAMPLE SCRIPTS


 Highlights:

  *  The new Wafe version has support to run application programs
     on top of Wafe or Wafe on top of an application program
     (for Perl programs by just adding a command line option)
     and makes it easier to link application programs
     alternatively with the Wafe environment.

  *  The number of backslashes in Perl written Wafe applications
     has been drastically reduced, the interface is now simpler
     and cleaner.

  *  The new Wafe version is distributed with XMosaic's HTML
     Widget (HyperText Markup Language) which has certain
     features of HTML+ implemented. Among other things it allows
     to write forms with input fields and check boxes in form of
     easy comprehensible text documents (in SGML syntax)
     together with hypertext references etc. Wafe supports XBM,
     XPM and GIF pictures in HTML Documents. The HTML Widget can
     be used in Athena and OSF/Motif versions of Wafe.

For newbies: Appendix 1 contains the summary: What is Wafe.


RELEASE NOTES:

 o NEWER COMPONENTS

   + based on tcl7.0 (instead of tcl6.7)


 o BUG FIXES

   + several bug fixes for converters in cases where other
     programs used Wafe converters (eg OSF/Motif calling Wafe's
     stringToXmString converter).

   + again a few bug fixes in the plotter widgets 
     (Axis.c and LabelAxis.c)

   + bug fix for the Xaw3d Layout widget.
     The corrected StringToLayout converter (in Xaw3d/Layout.c) 
     is below in Appendix 2: LAYOUT CONVERTER. 

     A version with several changes for Xaw3d can be found on
     ftp.wu-wien.ac.at:pub/src/X11/wafe/Xaw3d-fixes.tar.gz

   + fixed bug for converting Dimensions and pixmaps in Motif
     1.2 (these resources need a different handling; thanks to
     Jan Newmarch for his comments)

   + several code cleanups and improved portability 
     (Thanks to Jim Wight <J.K.Wight@newcastle.ac.uk> for his 
     comments)

   + several improvements in executions speed and memory 
     consumption (nothing dramatical though)

 
 o HYPERTEXT SUPPORT

   Wafe 0.96 supports for XMosaic's hypertext (HTML) widget 
   (from XMosaic 2.0 pre4).

   The source of the HTML widget is distributed together with
   Wafe (thanks to the kind permission of Mark Andreessen of
   NCSA).  Please notice the different Copyright in the html
   specific files.  Sample scripts for Motif and a Athena
   versions are supplied as well.

   The supplied version has certain HTML+ support (i.e.  Forms
   with input fields and check buttons in hypertext documents),
   Support for HTML+ forms under Athena is by yours truly.

   The following commands are available in wafe/mofe to access
   the functionality of the html widget:

        hTMLGetText
        hTMLGetTextAndSelection
        htmlGetHRefs
        hTMLPositionToId
        hTMLIdToPosition
        hTMLAnchorToPosition
        hTMLClearSelection
        hTMLSetSelection
        hTMLSetText
        hTMLSearchText
        hTMLGotoId
        hTMLAnchorToId
        hTMLRetestAnchors

   Wafe supports .xbm, .xpm (based on XMosaic's code) and .gif
   pictures in html documents.


 o NEW FEATURES

   + Widget Class Checking:

     Up to 0.96p3, many routines of the programmatic interface
     simply produce core dumps, when they are called with
     widgets of wrong classes (eg. "listShowCurrent topLevel"
     will produce an unpredictable result, since the widget
     argument must be an Athena List widget).

     Since the routines of the programmatic interface typically
     do not check whether the widgets are of the right class
     (sadly enough) Wafe starts checking widget classes from
     this version on.

     This change effects also widget creation: parent widgets of
     non-shell widgets must be now subclasses of composite.

     For none of the sample programs from the Wafe distribution
     was a change necessary due to widget class checking.


   + Better Resource File Support for Wafe's Converter:

     Values converted by Wafe specific converters can be stated
     in resource files (this includes callback resources, xpm
     resources and XmString resources) and via the Wafe command
     mergeResources. One could now set for Athena applications

          *callback: echo "i am widget <%w>"

     which will be used as a default value for callback
     resources.  Percent code substitution works as well for
     such resources.


   + List of attribute value pairs for widget creation commands,
     setValues (sV) and mergeResources. These list notations
     allow to reduce the number of backslashes in Wafe programs
     dramatically (see below in Appendix 3: ATTRIBUTE LISTS).


   + Error messages show now the source code where error occurs
     whenever possible (without changing the tcl sources).  for
     example, if an error occurs in an callback routine such as

        command l topLevel callback { 
                puts stderr hallo
                puts sderr test
                puts stderr echo 
            }

     the error message will look like:

        Wafe(execCallbackProc): bad file identifier "sderr"
        1:     
        2:    puts stderr hallo
        3: -> puts sderr test
        4:    puts stderr echo 


   + Easier use of Wafe in Interactive Mode (like a shell)

     If wafe is called without command line options, its starts
     in interactive mode and displays the following startup
     message:

        This is Wafe 0.96! (Athena Version, Interactive Mode)

     Wafe behaves like called with the options --d --n


   + Multi line Input in Interactive Mode and Frontend Mode:

     Wafe supports now input of multi line tcl expressions when
     unpaired left curly brackets occur. This makes it easier to
     define procedures etc. In interactive mode and eases
     communication with client applications. Multi line input
     can be interleaved with uninterpreted assignment and client
     output. Note, that too many opening curly brackets will
     cause the Wafe shell to "hang", i.e. to wait for the
     matching closing curly brackets.


   + Using Wafe from C:

     A simple replacement for the Wafe shell is provided with
     this release that demonstrates how Wafe could be used from
     C programs (very similar to using Tcl or Tk from C, it
     clarifies, what's needed to initialize Wafe and how to use
     the Xt Event loop).  This program might be a good basis to
     use Wafe as an Xt extension fore eg. another interpreter
     based language.

     In order to build a binary from w.c, this program should be
     used it place of wafe.c in the current release. A libwafe.a
     and libmofe.a will follow in a future release.


   + New signal handlers:

     Wafe has now a separate signal handler for SIGCLD (that is
     used for controlling the application client in frontend
     Mode) and for other signals, for which TCL signal handlers
     can be registered and unregistered. If the Wafe frontend is
     run on top of the application program, the wafe program can
     now safely execute other external programs (in earlier
     versions, wafe terminated, when the external program
     terminated).


   + New Predefined Variables:

     PID
          process id of current process (similar to [pid] in tcl7.0)

     CHILDPID
          process id of forked application program running as
          a coprocess of Wafe

     FILESEARCHPATH 

          This variable is used locate bitmaps or pixmap files
          for StringToBitmap or StringToPixmap converter and for
          bitmaps/pixmaps/gif files in html documents.

          For example:

             set FILESEARCHPATH /usr/lib/X11/twm/%N:/usr/include/X11/%T/%N
             command c topLevel bitmap ghostview.xpm
             realize

          searches through the given path to locate
          'ghostview.xpm' and will display the picture as label
          of the command widget.
        
          If wafe/mofe is compiled without XPM support, only
          .xbm files will be converted. Wafe provides a
          reasonable default value for FILESEARCHPATH. If the
          environment variable XFILESEARCHPATH is set, its value
          will be used instead of the default. For documentation
          of the percent codes in the FILESEARCHPATH see
          XtResolvePathname in Xt Intrinsics Reference Manual.

   + tclsh like variable names for argc argv and argv0
        
          Wafe followed up the last release the convention that
          predefined, global variables had uppercase names.  To
          provide more similarity to tclsh Wafe defines the
          following global variables:

           * tcl_interactive 
                    flag to indicate whether Wafe is running in
                    interactive mode or not (i.e. not in
                    frontend mode, not as a script; commands are
                    accepted from a terminal)
          
           * argv   list of command line options (not including
                    name of command)

           * argv0  command name
          
           * argc   number of elements in argv

          Wafe's ARGV and ARGC are still available, but will be
          most likely dropped in future version to avoid
          confusion.


   + 2 Modes for Visualization of the "drag" when doing
     a drag'n drop (when compiled with rdd):

      1) .xbm or .xpm files
      2) using an arbitrary transient shell, which
         might contain labels or bitmaps etc depending 
         on the application needs

     For an example see APPENDIX 4.

   + Additional control character (/) for uninterpreted assignment
     full set of primitives for uninterpreted assignment:
 
       =VarName value     assigns value to named tcl variable
       +VarName value     appends value to named tcl variable
       \VarName value     appends value and newline
       /VarName value     appends newline and value (***new***)

     where VarName is a Tcl Variable name and value is a newline
     terminated string

   + New General Commands:

     * kill <process id> <signal Type>
             where <signal Type> is one of
             term, quit, int, hup, pipe, usr1, usr2
        
     * parent <Widget>
             returns name of parent widget

     * widthOfScreen <Widget>
             returns the width of the screen on which <Widget>
             is displayed in pixels

     * heightOfScreen <Widget>
             returns the height of the screen on which <Widget>
             is displayed in pixels

     * resolvePathname <Widget> <Type> <FileName> <Suffix> <Path>
             returns the fully qualified filename of a readable
             File with name <FileName> and the specified <Suffix>
             on the <Path> (see XtResolvePathname in Xt Intrinsics
             documentation), otherwise an empty string

     * setSensitive widget True|False
             sets a widget and its children sensitive/
             insensitive (see XtSetSensitive in Xt Intrinsics
             documentation)

     * setBusy widget True|False
             sets for a shell/widget the busy-cursor and
             inhibits input for all children widgets without
             changing their appearance. If a shell is set busy
             and set non-busy some time later, all the
             sensitivity states before the set-busy command are
             reestablished.

     * realizeWidget <widget1> [<widget2> ..]
             realizes specified widgets

     * raiseWindow <Widget>                     
             raises XtWindow(widget)
        
             For example:           raiseWindow topLevel
             raises the topLevel shell

     * lowerWindow <Widget>                     
             lowers XtWindow(widget)

     * textWidth <Widget> <fontResource> <String>
             returns width of given <String> in pixels using
             font from <fontResource> of the given widget. This
             routine is necessary, as long we have no font to
             string converter.


   + Added Output Converter for getValues to convert Pixels Values
     to Strings
             
        For example, the following command can be used to
        set the background of <someWidget> to the same color
        as the widget of <someOtherWidget>

            sV someWidget background [gV someOtherWidget background]

        Pixels values are converted always into #RRGGBB strings


   + Changed General Commands (backward compatible):

     * register and unregister: 

       in addition to the functionality of register and
       unregister in earlier versions, these command accept now
       the following arguments as well

              register <signal Type> <Tcl Command>
              register <signal Type> DEFAULT
              register <signal Type> IGNORE
              unregister <signal Type> 

       <signal Type> is one of 
              term, quit, int, hup, pipe, usr1, usr2

       <Tcl Command> will be executed when the according signal
       is caught. If a signal is caught during the evaluation of
       a Wafe command, the signal is remembered and the
       according tcl command will be executed after the running
       command. if no tcl signal handler is registered and one
       of the listed signals is caught Wafe's default action
       will take place.


   + Changed Athena Commands (backward compatible):

       * listChange: 

         listChange <widget name> <#items> <longest> <resize> <Type> <args>

         allows for <Type> besides "File" or "Arg" now "List" as
         well, in which case the Tcl list specified as argument
         is used as item list. The following two commands are
         equivalent (assuming that a list widget named "l" was
         created before).

               listChange l 0 0 1 Arg This is a list!
               listChange l 0 0 1 List {This is a list!}
        


 o BETTER OSF/MOTIF SUPPORT

   + percent codes for OSF/Motif callbacks more uniform 
     (see short reference guide)

   + better handling of "pseudo widgets" in OSF/Motif, which
     are Wafe's counterpart for certain convenience routines
     in OSF/Motif. The created widget is now always the
     child widget (for instance mBulletinBoardDialog creates
     a Dialog Shell with a Bulletin Board, the specified name
     references the Bulletin Board, the Dialog Shell can be
     addressed via [parent ...] (see as well under 
     "New General Commands").

     the affected pseudo widgets are 
        mBulletinBoardDialog, mFileSelectionDialog, mFormDialog,
        mInformationDialog, mPromptDialog, mQuestionDialog,
        mSelectionBox, mSelectionDialog, mWarningDialog,
        mWorkingDialog

   + Fixed the XmGraph widget to work with OSF/Motif 1.2

   + New Commands For mofe (OSF/Motif version of Wafe):

        mProcessTraversal
        mListAddItem
        mListAddItems
        mListAddItemUnselected
        mListDeleteAllItems
        mListDeleteItem 
        mListDeleteItems
        mListDeleteItemsPos
        mListDeletePos
        mListDeselectAllItems
        mListDeselectItem
        mListDeselectPos
        mListGetMatchPos
        mListGetSelectedPos
        mListItemExists
        mListItemPos
        mListReplaceItems
        mListReplaceItemsPos
        mListSelectItem
        mListSelectPos 
        mListSetAddMode
        mListSetBottomItem
        mListSetBottomPos
        mListSetHorizPos
        mListSetItem
        mListSetPos
        mScrollBarGetValues
        mScrollBarSetValues
        mAddTabGroup
        mTextClearSelection
        mTextCopy
        mTextCut
        mTextFieldClearSelection
        mTextFieldCopy
        mTextFieldCut
        mTextFieldGetBaseline
        mTextFieldGetLastPosition
        mTextFieldGetSelection
        mTextFieldGetSelectionPosition
        mTextFieldInsert
        mTextFieldPaste
        mTextFieldPosToXY
        mTextFieldRemove
        mTextFieldReplace
        mTextFieldSetAddMode
        mTextFieldSetHighlight
        mTextFieldSetSelection
        mTextFieldShowPosition
        mTextFieldXYToPos
        mTextGetBaseline
        mTextGetLastPosition
        mTextGetSelection
        mTextGetSelectionPosition
        mTextInsert
        mTextPaste
        mTextPosToXY
        mTextRemove
        mTextReplace
        mTextScroll
        mTextSetAddMode
        mTextSetHighlight
        mTextSetSelection
        mTextShowPosition
        mTextXYToPos

     All other functions of the Motif Text and Text Field
     widgets should be achieved using setValues and getValues.
     If something is missing, please drop me a mail.

        
   + Removed spurious tags for conversions from XmString to
     Strings in Motif 1.2

   + More output converter for [getValues ...] for Motif
     resources


 o BETTER PERL SUPPORT

   + wafe.pl:

     The new wafe.pl implementation allows alternatively to run
     Wafe on top of a Perl application or vice versa, to run a
     Perl application on top of Wafe (this change is due to
     Wayne Scott <wscott@ichips.intel.com>).

     If in a Perl program the variable $perlOnTop is set to 1
     before wafe.pl is required, the Perl application is
     executed on top of wafe (the application is started and
     forks wafe as a sub process). If for example, $perlOnTop is
     set on the begin of wafemail, wafemail (and not xwafemail)
     can be executed using the x-frontend.

     the advantages of running the application program on top of
     wafe are:
      *  the application program is free to use stdin/stdout/stderr 
         to whatever it wants to do with it.
      *  the application can be more easily debugged (eg. using the
         Perl debugger)
      *  no link magic or -p parameter is needed.

     disadvantages:
      *  Xt command line arguments (and its abbreviations) have
         to be handled in Perl. I think i have added the most
         important options. if i have missed something relevant,
         please mail.
      *  the application is responsible for signal handling
      *  this approach works only for languages with a good
         operating system interface (such as Perl) where it is
         easy to fork processes etc.

     the following Wafe functionalities work with $perlOnTop=1:
      *  extra communication channel (`tunnel') 
      *  class names per application for X defaults
      *  uninterpreted assignment

     Essentially, the following modification was necessary for
     $perlOnTop in the sample programs distributed with Wafe:

     the commands of reading from Wafe should be modified from
        ...while(<STDIN>) ...
     to
        ...while($_=&wafe'read) ...

     (the modification is typically one line per Wafe
     application).  All commands sent to Wafe must be submitted
     via &Xui().


  + All Perl written Wafe applications of the distribution can
    be executed using $perlOnTop=1


  + All Perl written Wafe applications of the distribution 
    accept -P to toggle $perlOnTop. For example 
       wafemail -P
    and
       xwafmail
    will appear identically on the screen. However, the first
    one will run perl on top of wafe (wafe is the subprocess)
    and the second one will run wafe on top.


  + New Perl variable $WafeBin which defaults to "wafe" (only 
    meaningful in connection with $perlOnTop=1): $WafeBin can 
    be used eg. to write mofe applications with $perlOnTop=1.


  + Primitives in wafe.pl:

     -> &TclSet($name,$value)

        assigns to the tcl variable named in $name the value of
        $value.  no escaping is necessary, $value might contain
        newlines.

     -> &Xui($cmd)

        works now with multi-line Tcl commands and preserves
        newlines.  The commands &UI and &TclProc are obsolete
        and will be dropped in a future release.


  + Cleanup in most perl written applications to reduce
    dramatically the number of backslashes
    (actually all distributed applications are updated, except
    the oracle applications (i have currently no oracle in
    access); i expect no problem here since the changes are
    backward compatible).


  + xwafeftp upgraded to a newer version of ftp.pl 
    (mostly by Wayne Scott <wscott@ichips.intel.com>)




 o MORE TCL SAMPLE SCRIPTS
    
     showRes 
         this file can be sourced from an applications and can
         be used to show for a given widget the names and the
         types of its resources

     htmlBrowse
         sample browser for .html files; a sample document
         wafe.html is provided, which is the the translation of
         Wafe's manual page to html. The motif version is called
         m-htmlBrowse.

     htmltest
         small sample displaying a html form (works under Athena 
         and motif). It uses xpm files from the ctwm3.0 distribution.

     xy.tcl 
         wafe application to show animated graphs using the
         plotter widget set (motif version: m-xy.tcl)

     xpaste
        script to catch the current selection and to display it
        in a asciiText widget. It is quite conveniant to bind in
        a *twm for example Meta Button 2 to this script by
        adding the following line to the *twmrc file.
          Button2 = m : root : !"xpaste &"

     xs
        one line script to print the contents of cut buffer 0 
        to stdout 

     multi-layout.tcl
        script to demonstrate how to change the layout of an
        application dynamically (here by clicking on the
        buttons)

     one-of-many.tcl
        script to demonstrate a one-of-many toggle using 
        the Athena toggle widget class


Appendix 1: WHAT IS WAFE - A CLOSER LOOK

    Wafe (Widget[Athena]front end) is a package that implements
    a symbolic interface to the Athena widgets (X11R5) and
    OSF/Motif.  A typical Wafe application consists of two
    parts: a front-end (Wafe) and an application program which
    runs typically as a separate process. The application
    program can be implemented in an arbitrary programming
    language and talks to the front-end via stdio.  Since Wafe
    (the front-end) was developed using the extensible TCL shell
    (cite John Ousterhout), an application program can
    dynamically submit requests to the front-end to build up the
    graphical user interface; the application can also down-load
    application specific procedures into the front-end, which
    can be executed without interaction with the application
    program.

    In opposite to the described two process frontend approach,
    wafe applications can also be written purely in TCL, in
    which case only one process is needed.

    The distribution contains sample application programs in
    Perl, GAWK, Prolog, TCL, C and Ada talking to the same Wafe
    binary.  Most of the following demo applications are
    implemented in Perl 4.0.36:

       - xwafedesign: interactive design program for wafe applications
       - xwafeftp:    FTP front-end
       - xwafemail:   Mail user front-end with faces, using elm aliases
       - xwafenews:   NNTP based newsreader, using elm aliases
       - xwafegopher: a very simple gopher interface
       - xdirtree:    tree directory browser
       - xprojektor:  white board program for the classroom
       - xbm:         bitmap and pixmap viewer
       - xwafemc:     multiple choice test answering program
       - xruptimes:   rwho monitor like xnetload
       - xnetstats:   network statistics;
                      front-end for netstat -i <interval>
       - xvmstats:    system statistics;
                      front-end for vmstat -i <interval>
       - xiostats:    io statistics;
                      front-end for iostat -i <interval>
       - xwafeping:   pings several machines an show up-status
       - xwafecf:     a simple read only card-filer
       - xwafetel:    a simple read only Oracle front-end for 
                      looking up telephone numbers
       - xwafeora:    a more elaborated Oracle front-end with
                      updates capable to model an entity type
                      with distinct predicate defined subtypes,
                      allowing multi valued attributes (it comes
                      with sample applications "filing
                      management" and "paper base") doing field
                      completion and other funky stuff

       - primfakt.awk:    primfakt program in GAWK using wafe
       - primfakt.prolog: primfakt program in Prolog using wafe
       - primfakt.perl:   primfakt program in Perl using wafe
       - primfakt.c:      primfakt program in C using wafe
       - primfakt.a:      primfakt program in Ada using wafe
       - cprimfakt.c:     native C implementation of primfakt 
                          (single process, without wafe)
       - xprimfakt.tcl:   primfakt program in TCL using wafe 
                          (single process)

       - perlwafe: an example program calling wafe as a subprocess 
         of the application program (normally, it is the other 
         way round).


    HOW CAN WAFE BE USED AS A FRONTEND 

    Suppose you have an application program named "app". If we
    install a link like "ln -s wafe xapp" and execute "xapp ",
    the program "app" is spawn as a subprocess of wafe and
    connects its stdio channels with the front end.  Lines
    written from the application program to stdout are read from
    Wafe. If the line starts with a certain character (such as
    %) Wafe tries to interpret the remainder of the line as TCL
    command.  The standard TCL shell has been extended with new
    commands exploiting the X Toolkit, the Athena widget set,
    the OSF/Motif widget set and the XPM library to build up
    user interfaces with the window system named X.

    In most example programs of the distribution the application
    program is run as a subprocess of wafe, one example
    (perlwafe) shows the opposite constellation where the "link
    magic" is not needed. Since Wafe 0.96, the distributed sample
    Perl programs can be started with Wafe on top (e.g xwafemail
    or wafe --p wafemail) or alternatively with perl on top
    by using the -P option (wafemail -P). This is possible without
    changing the source code of the application.

    ADVANTAGES of Wafe

      -  application program can be written in wide range of 
         programming languages
      -  relatively high level interface to widget applications
      -  single wafe binary for multiple applications
      -  better refresh behavior when application program is busy
      -  click ahead
      -  better separation between user interface and
         application program matters 
      -  no need to hack C code
      -  easier migration from existing ascii based programs to
         X-window applications



    REQUIREMENTS FOR APPLICATION PROGRAMS

    In order to use Wafe in a two process setup, an application
    program must be able to write **LINEBUFFERED** (or
    unbuffered) to stdout (the application program must at least
    be able to flush the buffer) and to read from stdio. The
    application program determines the syntax in which Wafe
    talks back.


    AVAILABILITY

    Wafe was developed on DECstations 5000/200 under Ultrix 4.2
    using X11R5, and has been tested on a SparcStation 1+ under
    SunOS 4.1, RS6000/320 under AIX, on a HP 9000/720 under hpux
    8.05 and under Linux 0.99.10. Wafe can be compiled under
    X11R5 and X11R4. The preferred program-to-program
    communication is done via socketpair, support for PIPES and
    SYS V streams is included for systems without the socktepair
    system call.

    NECESSARY, BUT NOT INCLUDED 

    Most application of the distribution are written in Perl.
    Perl 4.036 is needed to run these applications. Two
    applications will need oraperl.  Only user with an Oracle
    license might find wafeora and wafetel useful. User might
    wish to compile wafe with the 3d Athena Widget library
    Xaw3d-0.6.tar.Z. Pointers to the source can be found in the
    INSTALL file.


    PRERELEASE

    The current distribution is a prerelease (version 0.96). The
    final version (whatever final means) will be posted after we
    got some feedback/suggestions from the network.


    ACKNOWLEDGEMENT

    The Wafe project would have been impossible without the
    availability of software in source form such as

            - X11R5 distribution from the MIT
            - TCL and TK (John Ousterhout)
            - Perl (Larry Wall)
            - XPM-Library (Arnaud Le Hors <lehors@sophia.inria.fr>)
            - dbug-Library (Fred Fish)
            - plotter widget set 
              (Peter Klingebiel <klin@iat.uni-paderborn.de>)
            - XmGraph (Douglas Young)
            - Xaw3d (Kaleb Keithley <kaleb@thyme.jpl.nasa.gov>)
            - rdd2 (Roger Reynolds <rogerr@netcom.com>)
            - oraperl (Kevin Stock <kstock@gouldfr.encore.fr>)
            - ftp.pl package (Alan R. Martello <al@ee.pitt.edu>)
            - chat2.pl package (Randal L. Schwartz <merlyn@ora.com>)
            - nntp.pl package (Randall S. Krebs)
            - XMosaic (Marc Andreessen, NCSA)

    Only the most important packages are listed here.

    Please check, whether the copyrights of the included
    packages are applicable in your situation.

    # Copyright (C) 1992,93 by Gustaf Neumann, Stefan Nusser
    #
    #     Wirtschaftsuniversitaet Wien, 
    #     Abteilung fuer Wirtschaftsinformatik
    #     Augasse 2-6, 
    #     A-1090 Vienna, Austria
    #     neumann@wu-wien.ac.at, nusser@wu-wien.ac.at
    # 
    # Permission to use, copy, modify, and distribute this
    # software and its documentation for any purpose and without
    # fee is hereby granted, provided that the above copyright
    # notice appears in all copies and that both that copyright
    # notice and this permission notice appear in all supporting
    # documentation.  This software is provided "as is" without
    # expressed or implied warranty.

    Every user is permitted to create derivative work to this
    program.  However, all copies of the program and its
    derivative works must contain the above copyright notice. We
    would like to ask every user to supply a copy of any change,
    enhancement or derivative work to the mailing address

            neumann@wu-wien.ac.at

    Thank you in advance.


    Wafe 0.96 can be obtained via anonymous ftp from

            ftp.wu-wien.ac.at:pub/src/X11/wafe/wafe-0.96.tar.gz

    (for people without name server: the ip address is 137.208.3.4)
    A split up version is available from the same directory.

    Donations for statically bound binaries of the OSF/Motif version
    of Wafe (mofe) are accepted.


MAILING LIST:

    In order to subscribe to the Wafe mailing list, send a mail
    with the mailbody

       subscribe Wafe <Your Name>
       help

    to listserv@wu-wien.ac.at. Postings should be sent to
    wafe@wu-wien.ac.at.



Appendix 2:  LAYOUT CONVERTER. 

CvtStringToLayout (dpy, args, num_args, from, to, converter_data)
    Display     *dpy;
    XrmValue    *args;
    Cardinal    *num_args;
    XrmValue    *from, *to;
    XtPointer   *converter_data;
{
    static BoxPtr tmp;
    LayYYsetsource ((char *) from->addr);
    if (!to->addr) to->addr = (XtPointer)&tmp;
    LayYYsetdest ((BoxPtr *) to->addr);
    to->size = sizeof(BoxPtr *);
    if (LayYYparse () == 0)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


Appendix 3:  ATTRIBUTE LISTS

 In order to redurce the number of backslashes in Wafe programs
 Wafe 0.96 supports the following feature: the lists of
 attribute value pairs (resource names and resource values) can
 be written between curly braces, where variable substitutions
 (using $) and command substitutions (using []) are performed,
 as if no curly braces were used.

 instead of writing a script in the form of

        set myLabel "This is a pretty Button"
        set fontSize 14

        command c topLevel \
             background navy \
             foreground yellow \
             label $myLabel \
             font -b&h-lucida-bold-r-*-*-$fontSize-*-*-*-p-*-iso8859-*
        realize

 one can write in Wafe 0.96 as well

        set myLabel "This is a pretty Button"
        set fontSize 14

        command c topLevel {
             background navy 
             foreground yellow 
             label $myLabel 
             font -b&h-lucida-bold-r-*-*-$fontSize-*-*-*-p-*-iso8859-*
        }
        realize

 obtaining same results (both formats are supported).  As
 another example, mergeResources can be written now in the form
 of

         mergeResources topLevel {
             *font -b&h-lucida-bold-r-*-*-14-*-*-*-p-*-iso8859-* 
             *shadowWidth 3 
             *background gainsboro 
             *plotAreaColor gainsboro 
             *plot*background gray 
             *.left chainLeft *.top chainTop 
         }

 Note that internally all newlines within these lists are
 removed. Do not specify resources between curly brackets that
 need the newlines (eg. translations). If someone knows a cheap
 way how to achieve this i would be glad to hear about it.


 Appendix 4: DRAG AND DROP (using Athena Widgets)

     #!/usr/bin/X11/wafe --f

     set FILESEARCHPATH /usr/include/X11/%T/%N:/usr/lib/X11/twm/%N
     ### use pixmap from ctwm distribution
     set dragBitmap arthur.xpm    

     command Johann topLevel label "you can drag me"
     realize

     # create a drag shell
     transientShell dragShell topLevel {
        overrideRedirect true
        allowShellResize true
        mappedWhenManaged false
     }
     label dragLabel dragShell leftBitmap xlogo16

     action Johann override \
         "<Btn1Down>:  exec(rddSetDropData {bist du es 1?}) \
                       set() rddWafeStartAction($dragBitmap)"
     action Johann override {\
         <BtnUp>:     notify() unset() rddWafeDropAction()
         <BtnMotion>: rddWafeDragAction()
         <Btn2Down>:  exec(rddSetDropData {bist du es 2?}) \
                      exec(sV dragLabel label {der Mittlere}) \
                      set() rddWafeStartAction(shell dragShell)
         <Btn3Down>:  exec(rddSetDropData {bist du es 3?}) \
                      exec(sV dragLabel label {die rechte Maustaste}) \
                      set() rddWafeStartAction(shell dragShell)
     }

    rddAddDropHandler Johann {echo message <$DROP>}

===========




