Wafe 0.96 available (long)
Gustaf Neumann
posting contains the Wafe 0.96 release notes. Information about "What is Wafe"
can be found in Appendix 1.
Wafe 0.96 is available via anonymous ftp from
ftp.wu-wien.ac.at:pub/src/X11/wafe/wafe-0.96.tar.gz
Wafe was developed by Stefan Nusser and me at the Vienna University
of Economics and Business Administration and is currently maintained
on my private Linux pc at home.
With kind regards
- Gustaf Neumann
=============================================================
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....@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 <wsc...@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 <wsc...@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 <leh...@sophia.inria.fr>)
- dbug-Library (Fred Fish)
- plotter widget set
(Peter Klingebiel <kl...@iat.uni-paderborn.de>)
- XmGraph (Douglas Young)
- Xaw3d (Kaleb Keithley <ka...@thyme.jpl.nasa.gov>)
- rdd2 (Roger Reynolds <rog...@netcom.com>)
- oraperl (Kevin Stock <kst...@gouldfr.encore.fr>)
- ftp.pl package (Alan R. Martello <a...@ee.pitt.edu>)
- chat2.pl package (Randal L. Schwartz <mer...@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
# neu...@wu-wien.ac.at, nus...@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
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 list...@wu-wien.ac.at. Postings should be sent to
wa...@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>}
===========
--
Gustaf Neumann neu...@watson.ibm.com
Postdoctoral/Visiting Scientist Tel: (914) 784 7086
IBM T.J.Watson Research Center, P.O.Box 704
Yorktown Heights, New York 10598
Gustaf Neumann
Due to a faux pas in my packaging script, libhtmlw (XMosaic's hypertext
widget) was in contrary to the announcement not included in the Wafe 0.96
distribution (wafe-0.96.tar.gz). Ashes over me!
The missing piece can be obtained from
ftp.wu-wien.ac.at:pub/src/X11/wafe/wafe-0.96-libhtmlw.tar.gz
If you want to compile Wafe with the HTML widget, expand this tar
file in the wafe directory such you obtain a directroy structure like
.../wafe
.../wafe/src/...
.../wafe/libhtmlw/...
.../wafe/plotter/...
...
In order to compile libhtmlw with the right compiler flags, "cd" to wafe/src,
"#define HTML" in the Imakefile and issue "xmkmf;make" there.
Best wishes,
-gustaf