Newsgroups: cs.softw
From: rus@monolit.kiev.ua (Ruslan Belkin)
Subject: ANNOUNCE: Montly Posting of Widget FAQ
Organization: CS/MONOLIT Network Centre
Date: Thu, 2 Mar 1995 13:30:17 GMT
Message-ID: <D4tEuI.E7p@monolit.kiev.ua>

[ Article crossposted from comp.windows.x,comp.windows.x.intrinsics,comp.windows.x.motif ]
[ Author was cwikla@wri.com ]
[ Posted on Wed, 1 Mar 1995 17:05:14 GMT ]


/*
** $Id: Widget.FAQ,v 1.11 1995/03/01 16:21:00 cwikla Exp $
*/



	This is the widget faq.  I'm hoping to compile a list of all 
available widgets, where they can be found, and a short description. 
(The descriptions are excerpts from either the README, the man page, 
etc...)  

	A much more exciting version of this FAQ, complete with pictures,
links, and more complete documentation is available at 

	http://www.wri.com/~cwikla/widget.html

	Please note that I make no claim as to the fitness of anything 
on this list, nor it's accuracy, though I'll do my best to make sure 
it is as correct as possible.  Locations are based mostly on where I 
found the widgets at the time of this writing.  

	If you know of any widgets that are available but do not appear 
on this list, or if you would like to add your own widget to this 
list, please send me a description, with the following information - 
otherwise I'll have to make it up the best I can.  Send this 
information to cwikla@wri.com.

----------------------------------------------------------------------
WIDGETNAME:
COMPATIBILITY_LIST:
LOCATION:
AUTHOR + EMAIL:
DESCRIPTION:
----------------------------------------------------------------------

Finally, please don't send me mail asking if I know the location of
a specific type widget. If it's not in this list, chances are I
do not.


John L. Cwikla (cwikla@wri.com)

				Please redistribute this article.




Format is the following:

WidgetName: C[A] L[1] A[WHO]
	where C is the compatibility list
	where L is the location
	where A is the author
	where ** denotes shareware (please see source for policy)
	where ++ denotes commercial

Compatibility Key: 
	XT	: Generic Xt widget
	A	: Works with Athena widgets
	M11	: Works with Motif 1.1
	M12	: Works with Motif 1.2
	OL	: Works with OpenLook

Location Key:
	OLD-XORG:	ftp.x.org:/R5contrib
	XORG:		ftp.x.org:/contrib/widgets
	XORG-M:		ftp.x.org:/contrib/widgets/motif
	FWF:		a.cs.uiuc.edu:/pub/FWF/fwf-3.67.tar.Z
	IL:		ftp.cs.umb.edu:/pub/interleaf/CDE
	ICS:	Integrated Computer Solutions (info@ics.com, 617-621-0060)


New widgets added since the last FAQ are denoted by "+)".

Changed widgets/description are denoted by "!)".

Fields I'm uncertain about are denoted with a "?".


---------------------------------------------------------------------
Composite Widgets
---------------------------------------------------------------------

AppPlusS: 
	C[A,M11,M12] 
	L[XORG] 
	A[John L. Cwikla (cwikla@wri.com)

	The AppPlusShell adds the following capabilities to the application 
	shell widget class:
	1) Visual/Colormap control thru resources
	2) EditRes built in (can be turned on/off)
	3) Catches the WM_DELETE_WINDOW
	It also contains a file of functions for creating
	popup/menu shells with correct visuals/colormaps/depths.

Array: 
	C[A] 
	L[FWF] 
	A[Robert Forsman (thoth@cis.ufl.edu)]

	The Array widget is useful for most constraint situations.
	The  programmer has a flexible table containing as many rows
	and columns as necessary.  Each child  occupies  either  one
	cell  or  several  cells  in a rectangular array.  The Array
	widget  has  robust  geometry  management  and  can  usually
	recover from psychotic parental constraints better than most
	constraint widgets.

Board:
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl]

	The Board class adds one thing to the  capabilities  already
	present in the Frame class, viz., location management.
	Location management is an improved version of the standard X
	geometry management. Size and position of a Board widget (or
	subclass) can be given as  a  combination  of  absolute  and
	relative sizes.

++Button Box
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Button Box simplifies the task of putting a row of buttons 
	along the bottom or side of a dialog box by resizing and 
	relocating its children as necessary.

++Color Selector
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Color Selector allows users to select a color from a named 
	list, or to specify a color using RGB sliders. The name and/or 
	the RGB value of the color are displayed dynamically along with 
	the color itself.

++ Combination Box
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Combination Box allows users to select elements from a list 
	and optionally enter values into a text widget. This widget 
	implements the CUA Style Guides Combination Box and Drop Down List 
	functionality, and features a simple, standard, intuitive interface. 
	This mimics the popular Microsoft Windows control.

Common: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl]

	The Common class is not meant to be  instantiated.  It  only
	serves  as the common superclass for a family of widgets, to
	ensure that these  widgets  have  some  common  methods  and
	resources. The Common class defines common types, symbolic
	constants, and type converters  and  it  also  provides  the
	basis for keyboard traversal.  The code for keyboard traver-
	sal is roughly based on that in the Xw widget  set  (created
	by Hewlett Packard), but it uses the accept_focus method.

ComboBox: 
	C[M12] 
	L[IL] 
	A[Interleaf, Inc.]

	MS like combo box.

ComboBox: 
	C[M11,M12] 
	L[XORG-M] 
	A[Harald Albrecht (albrecht@igpm.rwth-aachen.de)]

	MS like combo box. A combo box consists of a text input field 
	with an arrow button besides it. When you click on the arrow 
	button the combo box pops up a list just below its input area. 
	You can now browse in it or pop it down by pressing the arrow 
	button again.  The combo box comes with a comprehensive 
	documentation (over 20 pages of resources and how to use the 
	widget).

++Extended (I18N) List
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Extended (I18N) List contains a scrollable, multi-column 
	list with headers. Users may search the list by entering a string 
	in the Search area at the bottom of the widget. This widget 
	supports lists with multiple columns, variable pitch fonts, 
	pixmaps in the first column (a la OpenLook), and single select 
	and double click callbacks. It provides support for the display 
	of internationalized text.


FileChooser: 
	C[A] 
	L[FWF] 
	A[George Ferguson (ferguson@cs.rochester.edu)]

	XfwfFileChooser provides a list  of  files  in  the  current
	directory, and a dynamically-updated menu of ancestor direc-
	tories. A file can be selected from the list, or a directory
	can  be  selected  from either the list (a sub-directory) or
	the menu  (an  ancestor  directory).  When  a  directory  is
	selected  (from the menu or the list), the list is re-filled
	with the contents of the new directory.  Callback procedures
	are called whenever the selected file or directory changes.

FileComplete: 
	C[A] 
	L[FWF] 
	A[Robert Forsman (thoth@cis.ufl.edu)]

	The file completion widget allows the application  program-
	mer  to  easily provide the user with a familiar, convenient
	and (hopefully) intuitive way to select files from the  Unix
	filesystem. It provides both a list of files and emacs-style 
	filename completion.

FileSelector: 
	C[A] 
	L[FWF] 
	A[Brian Totty, (totty@cs.uiuc.edu)]
	
	XfwfFileSelector is a hierarchical file selector widget that
	allows  a user to move through the directory tree and select
	files.

++Font Selector
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Font Selector allows users to specify a font by choosing 
	a font family, its size, weight, and angle. Advanced features 
	allow a choice of either 75 or 100 dpi fonts, scaled fonts, 
	fixed-width or proportional fonts, ISO8859-1, or XLFD fonts. 
	It dynamically displays the currently selected font and font 
	name, and supports font wildcarding.


Frame: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The Frame widget is a composite widget that accepts just one
	child.	Its  only purpose is to draw a frame around widgets
	that do not have a frame of their own. It  always  uses  the
	size  of its child, with a little extra for the frame. There
	are several types of frames  available,  selectable  with  a
	resource.

Group: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The Group widget is a subclass of RowCol, which  means  that
	it  arranges  its  children  in  rows  and columns. (See the
	RowCol widget for the resources that influence the  layout.)
	The Group widget adds two things to the capabilities already
	present in RowCol, namely a label in  the  upper  left  hand
	corner  and  the  ability to make a number of Toggle buttons
	act as radio buttons.

++Icon Box
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Icon Box lays out its children on a grid and adds new 
	cells automatically when its window is resized. Constraints 
	force each child to be the same size.

IconBox: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	An IconBox widget is surface  on  which  labeled  icons  are
	displayed. The icons and the labels are actually a graphic
	representation of the list of strings that is the  value  of
	the list resource. The user can rearrange the icons by drag-
	ging them with the mouse, he can click  on  them  or  double
	click  and  even select a number of them (selection is indi-
	cated by reversing the colors of the icon). The  application
	will be notified of clicks and selections via callbacks. The
	list resource also indicates whether icons are sensitive  to
	other icons being dropped on them. Icons that are, will give
	visual feedback and cause a callback to be called.

++Icon Button
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Icon Button creates a push button or toggle button that 
	displays either a simple label, a pixmap, or both a label 
	and a pixmap.

MenuBar: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The MenuBar widget is a special kind of  RowCol  widget.  It
	assumes  that all its children are PullDown buttons or other
	widgets that pop up a menu. (But nothing will break if  they
	are  not.) By default, the children are arranged in a row,
	wrapping to the next row if the width is not enough for  all
	of  them.  But  other  arrangements  are  possible,  see the
	resources of the XfwfRowCol(3) widget.

++Outline
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Outline widget displays its children in an outline form 
	with relationships indicated by levels of indentation. These 
	nodes, or levels, may be opened or closed by users, or by the 
	programmer. This widget supports hidden nodes and multiple 
	root nodes.

Pager: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The Pager widget displays one page from a long text. A dog's
	ear in the corner allows flipping pages. This is an alterna-
	tive to scrolled texts, meant for material that is  preferr-
	ably read a page at a time.

++Paned
	C[M12]
	L[ICS]
	A[ICS]
	
	(Part of EnhancementPak)
	The Paned widget manages children within vertical or horizontal 
	panes that can be dynamically resized using sashes that appear 
	between the panes. Note that Motif only handles vertical panes.

++Panner & Porthole
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	Used together the Panner and Porthole widgets create an 
	intuitive way to move a two-dimensional image around on the 
	screen, greatly improving upon the awkward combination of 
	vertical and horizontal scrollbars. Now users can "pan" across 
	an object by dragging the Panner. Based on the Athena Panner 
	and Porthole.

++Pixmap Editor
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	Allows users to create and edit pixmaps.  It provides drawing 
	functions such as draw point, line, circle (filled), rectangle 
	(filled), copy/move area, flood fill, and undo. The image may be 
	resized and scaled, and includes a panner to allow users to 
	scroll the image in two dimensions. The Pixmap Editor imports and 
	exports any XImage or Drawable. This widget doesn't include file 
	I/O, but these routines are publically available on the Intenet.


PEXtWorkstation: 
	C[A?] 
	L[ftp.x.org:/R5contrib]
	A[Rich Thomson (rthomson@dsd.es.com)]

	The widget provides the basic mechanisms of
	a PHIGS workstation and provides callbacks for expose and
	resize events.  Simple management of exposure and resize
	events can also be performed without callbacks, providing
	commonly occuring behaviour for these events. 

Prompt: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The Prompt widget is used for short  (no  more  than  a  few
	lines)  text entry. It can be used in two modes: either with
	or without a template.  If there is a template,  input  will
	be  checked  against  it  and only accepted if it matches. A
	template must be accompanied by a pattern,  that  gives  the
	acceptable  character  classes for each position in the tem-
	plate. A template  can  include  literal  characters,  e.g.,
	"Enter  date:  __-__-__  (DD-MM-YY)" with pattern "99-99-99"
	means that the user may enter only digits on the  `_'  posi-
	tions.

PullDown: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	A PullDown button looks like a normal button, but when it is
	clicked  or  pressed,  a  menu  drops  down. The menu can be
	specified in two ways: as a string or  as  a  widget.  If  a
	string  is  given,  it must be in the correct syntax for the
	XfwfTextMenu widget and a widget will be  created  automati-
	cally.  If  a  widget  is given instead, it must be a widget
	that is able to pop up: in other words: a Shell widget or  a
	subclass of Shell.

RadioGroup: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The RadioGroup widget is  a  simple  specialization  of  the
	Group  widget. It has an extra resource, labels, which holds
	the labels of the toggle buttons that are created  automati-
	cally. For the common case that a Group widget contains only
	radio buttons, the  RadioGroup  widget  is  much  more  con-
	venient.  It  is  also  much less flexible. E.g., it is very
	difficult to change resources of the radio buttons, when the
	defaults are not satisfactory.

RowCol: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The RowCol widget forces all  its  children  into  rows  and
	columns.  The  children  keep  their preferred size, but the
	preferred position is ignored. Resources determine how  many
	rows or columns their should be (or as many as will fit) and
	if the children should be layed out in rows or  in  columns.
	In both methods, the children are placed on a grid, the size
	of which is determined by the width (height) of  the  widest
	(tallest) child.

ScrolledWindow: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The ScrolledWindow widget is a composite widget composed  of
	two  Scrollbars and a Board within a Frame, and presumably a
	grandgrandchild  which  is  a  child  of  the	Board.	The
	grandgrandchild is called the `controlled widget' (CW). Usu-
	ally, the controlled widget is larger than  the  Board,  and
	its  origin  will  have  negative x and y coordinates. It is
	moved about inside the Board by the ScrolledWindow, in reac-
	tion  to the user clicking on the scrollbars. The controlled
	widget is therefore clipped by the Board.

SmartMB: 
	C[M12] 
	L[XORG-M] 
	A[John L. Cwikla (cwikla@wri.com)]
	
	This is the xmSmartMessageBoxWidget.  The basic idea is that 
	I decided that dialogs should be simpler in Motif programs, 
	ie, you shouldn't have to unmanage unwanted widgets just to 
	have a dialog.  Plus, the Template dialog is more voodoo 
	than anything else.  The SmartMessagBox widget manages 
	whatever you tell it to in 4 different ways: as a label, as
	a control widget, as a separator, or as an action widget.  
	You can have up to 1 label, up to 1 control, up to 1 
	separator, and as many action widgets as you'd like.  This 
	is all handled throught constraint resources. Another bonus
	is that any buttons in the action area are spaced the same
	as in Motif dialogs.

SpinButton: 
	C[M12] 
	L[IL] 
	A[Interleaf, Inc.]
	
	Text widget with up/down arrows to select list of choices.

Stack: 
	C[A,M12] 
	L[FWF] 
	A[John L. Cwikla (cwikla@wri.com)]
	
	The stack widget is an X  toolkit  (and  Motif  if  compiled
	right)  compatible  widget that is a subclass of constraint.
	The stack widget allows only one child to be  managed  at  a
	time.

++Stretch
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Stretch widget allows users to select the border it places 
	around its child and drag it to a new size. This widget gives 
	developers support for resizing a window within an application, 
	similar to mwm.

Tabs: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl]
	
	The XfwfTabs widget displays a series of  tabs,  similar  to
	the alphabet tabs along the top of index cards. One tab, the
	front one, is completely visible, the others  are  partially
	hidden  behind  it.  Each of the tabs can be clicked on with
	the mouse.

TextMenu: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl]
	
	The TextMenu widget implements a simple menu, consisting  of
	a  series  of labels. It is called `TextMenu' because it has
	no support for anything other  than  simple  strings  to  be
	displayed.

++Toolbar
	C[M12]
	L[ICS]
	A[ICS]
	
	(Part of EnhancementPak)
	The Toolbar allows developers to create an area below the 
	menubar where the user can add buttons corresponding to 
	frequently-accessed menu items. It also features pop-up labels 
	with a resource-driven timeout feature for user customization, 
	and support for user implemented status bars. This mimics the 
	popular Microsoft Windows control.

++Tree
	C[M12]
	L[ICS]
	A[ICS]

	(Part of EnhancementPak)
	The Tree widget shows the relationship between its children in 
	the form of a graphical tree.  Parents may have multiple 
	children, while each child must have, at most, a single parent.  
	Branches of the tree can be opened or closed by the user or 
	programmer. Hidden nodes and multiple roots are supported.

XbaeCaption: 
	C[M12]
	L[XORG-M] 
	A[Andrew Wason, (aw@bae.bellcore.com)]
	
	XbaeCaption is a simple Motif manager widget used to associate 
	an XmLabel (caption) with it's single child. The label may be 
	either an XmString or Pixmap and can be displayed in any one of 
	twelve positions around the perimeter of the child. XbaeCaption's
	geometry management technique is to simply "shrink wrap" it's
	child and display the caption alongside it.  By using XbaeCaption
	with an XmFrame child, groups of related widgets can be labeled
	similarly to the IBM CUA "Group Box", but with more flexibility.
	XbaeCaption is also useful for associating labels with individual
	XmTextField widgets.

XbaeMatrix: 
	C[M12] 
	L[XORG-M] 
	A[Andrew Wason (aw@bae.bellcore.com)]
	
	XbaeMatrix is a Motif widget which presents an editable array 
	of string data to the user in a scrollable table similar to a
	spreadsheet. The rows and columns of the Matrix may optionally 
	be labeled. Also, a number of "fixed" leading rows or columns 
	may be specified - these behave similarly to the labels. While 
	XbaeMatrix looks and acts like a grid of XmTextField widgets, 
	it actually contains only one XmTextField.  This means that 
	XbaeMatrix widgets with hundreds or thousands of rows have much 
	less overhead than they would if they used an XmTextField for 
	each cell. XbaeMatrix has callbacks for doing field validation 
	and customizing traversal. It allows cells to be assigned 
	independent colors.  It allows rows, columns and regions of 
	cells to be selected (highlighted).  The matrix can be 
	dynamically grown or shrunk by adding and deleting rows and 
	columns at any position.

!) XeFrame: 
	C[XT]
	L[XORG] 
	A[Markku Savela (Markku.Savela@vtt.fi)]

	A constraint widget, modeled a bit after ODA layout object

++XlNumericField:
	C[M12]
	L[http://fas.sfu.ca/cs/people/GradStudents/lantin/personal -
		/XlNumericField/XlNumericField.tar.Z]
	A[Maria Lantin (lantin@cs.sfu.ca)]

	Text field for numeric input.

** XmtChooser: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)]
	
	The XmtChooser widget--a single widget that can appear as a 
	radio box, a check box, a list widget, a palette, or an option 
	menu.  Takes an array of strings or pixmaps to display as the 
	choices, and maintains a single state variable.

** XmtCli: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)]
	
	The XmtCli widget--a "command line interface" with automatic
	prompting and command history.  Has fprintf() and fgets() 
	analogs for porting terminal-based applications.

** XmtHelpBrowser: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)]
	
	Online help--structured document browsing.

** XmtHelpBox: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)]
	
	Online help--context-sensitive help with resource files.

** XmtLayout: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)]
	
	The XmtLayout widget--a general manager widget, using the TeX
	boxes-and-glue layout algorithm.  Layout can be specified with a 
	single string resource.  Simpler than the Form widget, and more 
	flexible than the popular Table widget; includes built in
	support for text and pixmap labels, separators and shadowed 
	frames.

** XmtMenu: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)] 

	The XmtMenu widget--describe a menu with an array of structures,
	or with a single resource in a resource file.

xhdg: 
	C[A] 
	L[XORG] 
	A[Roland Zink (Roland.Zink@informatik.uni-stuttgart.de)]

	The xhdg graph widget automatically layouts a arbitrary graph. 
	All it's child widgets are treated as vertices of the graph 
	except the first. The first widget is treated as the title of 
	the graph. This widget is centered in the top line of the graph 
	widget. Any other widget is positioned according to the edges 
	of the graph, which are inserted through function calls.

++XRT/3d:
	C[M12]
	L[Free Evaluation CD on request from KL Group]
	A[KL Group Inc.  info@klg.com http://www.klg.com/ ]

	XRT/3d for Motif is a sophisticated three-dimensional surface, 
	bar and contour graph widget for X application developers. With 
	XRT/3d, developers can easily build 3-D display and interaction 
	into their Motif applications. XRT/3d provides over 140 resources 
	that control how data will be displayed. It can automatically 
	contour and zone data and handle missing data values. XRT/3d can 
	also produce 4-D graphs. End users can use the mouse to rotate, 
	zoom and shift graphs interactively. XRT/3d can report the exact 
	coordinates clicked on by the user, to allow selection of graph 
	points.  

++XRT/graph
	C[M12]
	L[Free Evaluation CD on request from KL Group]
	A[KL Group Inc.  info@klg.com http://www.klg.com/ ]

	XRT/graph for Motif is a complete and powerful two-dimensional 
	graph widget for X application developers. XRT/graph can 
	display data in virtually any type of 2-D chart or graph 
	including X-Y plots, pie charts, bar charts, stacked bar charts, 
	area graphs, financial graphs and logarithmic scientific charts. 
	XRT/graph has over 200 resources for controlling graph attributes 
	such as automatic time axis annotation, combination graphs, axis 
	controls and double buffering. XRT/graph also supports user 
	feedback routines, which enable users to control their application 
	by selecting and dragging graph elements with the mouse.	

++XRT/table
	C[M12]
	L[Free Evaluation CD on request from KL Group]
	A[KL Group Inc.  info@klg.com http://www.klg.com/ ]

	XRT/table allows developers and end users to easily display and
	manipulate tabular data in OSF/Motif applications. Developers can
	create tables quickly and cost-effectively to display and 
	manipulate structured scrolled lists, information stored in 
	databases, data entry forms and spreadsheet data. Over 120 
	resources allow fine control over table attributes, including 
	fonts, colors, 3-D etching, labeling and sizing. XRT/table 
	supports extensive user interaction including dynamic resizing 
	of rows and columns and selection. Cells support Motif compound 
	strings, images and other Motif widgets. 



------------------------------------------------------------------
Non-Composite Widgets
------------------------------------------------------------------

+) 2DHist:
	C[M11, M12]
	L[ftp://ftp.fnal.gov/pub/plot_widgets]
	A[Konstantin Iorcha (histoscope_support@fnal.gov)]

	Two dimensional histogram (also called lego plot,
	or 3D bar chart).  Plots vertical bars from a two
	dimensional array of floating point values. Users
	can rotate, scale, and pan plot by dragging on
	axes or data.  Extremely fast 3D rendering, can
	handle up to 1000x1000 bins.

+) 3DScat:
	C[M11, M12]
	L[ftp://ftp.fnal.gov/pub/plot_widgets]
	A[Konstantin Iorcha (histoscope_support@fnal.gov)]

	3D scatter plot.  Plots (b&w) dots to represent
	x,y,z coordinates using linear or log scaling.
	Allows users to rotate, pan and scale plot by
	dragging on data or axes.  Can handle large
	numbers of points (around 3 million depending on
	system).  Encapsulated PostScript output.

Alert: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl]
	
	The XfwfAlert widget is  a  pop-up  dialog  box  with  three
	parts:  an  icon  in the top left corner, a text area, and a
	row of buttons along the bottom. Usually the alert widget is
	used  for error messages, warnings and other kinds of infor-
	mational messages. The icon indicates the type  of  message:
	(fatal) error, warning, other message, request for confirma-
	tion, etc. There are some built-in icons  for  these  types.
	Most  alerts will have one or two buttons, e.g., OK and CAN-
	CEL.

Animator: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl]
	
	The animator widget cycles through a series of images  (XIm-
	age  structures).  Each  image  is  displayed  for a certain
	number of milliseconds. After the last image, the  animation
	can either start over or stop with the last image displayed.

Arrow: 
	C[A]
	 L[FWF] 
	A[Bert Bos (bert@let.rug.nl]
	
	The Arrow widget is usually part of  a  composite  scrollbar
	widget.  It  draws  a  triangle  pointing  up, down, left or
	right, depending on the direction resource. It has a  single
	callback,  that is repeatedly called as long as a mouse but-
	ton -- button 1 by default -- is pressed.

Button: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl]
	
	The XfwfButton widget is a simple button with a single call-
	back	activate_callback.  Except  for  that  callback,  all
	resources are inherited from  the  XfwfLabel  widget.  Subc-
	lasses  provide  buttons  of  other, more specialized types.
	XfwfButton inherits its 3D frame from XfwfFrame,  the  loca-
	tion  specification  resources from XfwfBoard and the multi-
	line label from XfwfLabel.

ButtonFaceLib: 
	C[M11,M12] 
	L[XORG-M] 
	A[Harald Albrecht (albrecht@igpm.rwth-aachen.de)] 
	
	A library for creating pictural push buttons and labels. The 
	ButtonFaceLib greatly eases the process of creating such push 
	buttons. You only have to supply pixmaps for the normal, 
	armed and insensitive state and call just one convenience 
	function. If you don't have a pixmap for the armed or 
	insensitive state of push buttons the library creates the 
	pixmaps itself.  The library comes with a predefined set of 
	common buttons like "ok", "abort", "cancel", "retry", "ignore", 
	"yes", "no" and "help".  A special widget "Center" allows for 
	centering widgets in a row or column within another manager 
	widget.  If you want to add a nice touch to you applications to 
	give them a distinct look, you should surely give the 
	ButtonFaceLib a try!

Canvas: 
	C[A] 
	L[FWF] 
	A[Robert Forsman (thoth@cis.ufl.edu)]
	
	The Canvas widget is useful when the program needs an area
	for  drawing  or display and the creation of a custom widget
	would not  be  ``cost-effective''. Examples of this are
	display of an XImage, display of an animation, or display of
	a custom diagram.  The Canvas widget is a gain  over  regis-
	tering  an action proc for an Expose event because the class
	definition takes  advantage  of  the  X  toolkit's  internal
	expose  event compression capabilities to allow the applica-
	tion to send the drawing commands only once for a collection
	of Expose events.

CircularPercentage: 
	C[A] 
	L[FWF] 
	A[Ronald van Loon (rvloon@cv.ruu.nl)]

	CircularPercentage is a widget that draws a  filled  circle,
	with  two  pie  slices  in  different  color to indicate the
	amount of work already completed in some part of an applica-
	tion.

Cmap: 
	C[A,M11,M12] 
	L[XORG, FWF] 
	A[John L. Cwikla (cwikla@wri.com)]
	
	The cmap widget is an X toolkit/Motif compatible widget that
	displays the entries in the colormap of its XtNcolormap
	resource.  It also has an indicator box, and a label
	displaying the rgb components of the indicated box.

EzMenu: 
	C[A] 
	L[FWF] 
	A[Dirk Grunwald, (grunwald@foobar.colorado.edu)]
	
	EzMenu is a simple menu package built by Dirk Grunwald on top of 
	the X11R4 Athena menu widgets.  It allows you to construct menu 
	trees from resource descriptions.

+) H1D:
	C[M11, M12]
	L[ftp://ftp.fnal.gov/pub/plot_widgets]
	A[Jeff Kallenbach, Mark Edel (histoscope_support@fnal.gov)]

	Histogram widget.  Plots vertical bars from a
	vector of values, linear or log scaling.  Users
	can scale and pan plot by dragging on axes or
	data.  Encapsulated PostScript output.

HScrollbar: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The XfwfHScrollbar widget is exactly the same as its  super-
	class,  XfwfScrollbar,  except  for the default value of the
	vertical resource and the fact that it has default  transla-
	tions  for  keyboard  events. It would be a simple matter to
	add  these  translations  in  a  resource  file  or  in	an
	application's  source,  but  having them by default is quite
	convenient.

Hdial: 
	C[A] 
	L[XORG, FWF] 
	A[John L. Cwikla (cwikla@wri.com)]
	
	Based roughly on the one by Doug Young, this dial widget is 
	a half circle and has an arrowhead, selections, label, etc.

Histogram: 
	C[A] 
	L[FWF] 
	A[Brian Totty, (totty@cs.uiuc.edu)]
	
	Histogram displays data in  a  histogram  display  (vertical
	bars).	The widget is flexible in terms of auto-scaling and
	labeling.

Icon: 
	C[A]  
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The XfwfIcon widget displays an image. The  preferred  width
	and height of the widget will be set to the width and height
	of the loaded image, plus space for the  frame.  The  widget
	has a callback activateCallback, that is by default bound to
	a click of the left mouse button.

ImageSelector: 
	C[A] 
	L[FWF] 
	A[Brian Totty, (totty@cs.uiuc.edu)]
	
	ImageSelector is a two  dimensional  grid  of  images.	The
	images  can  bew  viewed  and  selected by the user.  Layout
	options can be specified, as can  graphic  attributes.	The
	selectability  of the images can be controlled, and optional
	textula labelling of the images is supported.

+) ImageView:
	C[XT, M12]
	L[XORG]
	A[John L. Cwikla, (cwikla@wri.com)]

	The worlds first 2 hour widget!  Someone on the net said they
	would like a widget that took an image and would scale it
	to the size of the window.  So I wrote it. Given an ximage
	or pixmap, it scales it to draw itself to the window size.

Label: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The Label class has the capability to display  one  or  more
	lines  of text in a single font. Otherwise it is the same as
	the Board class.  The text can be left, right or center jus-
	tified  and it can be centered vertically or put against the
	top or the bottom of the widget. There is also a resource to
	set tab stops.

Mdial: 
	C[M12] 
	L[FWF] 
	A[John L. Cwikla (cwikla@wri.com)]
	
	Motif-a-like dial widget.

MegaButton:
	C[M12]
	L[XORG-M]
	A[John L. Cwikla (cwikla@wri.com)]

	This is the xmMegaButtonWidget.  It basically allows you
	to have a menu with a SCROLLING array of menu buttons like
	on other windowing systems.  It is not an xmList, but 
	rather, is subclassed from the xmPushButtonWidgetClass -- 
	despite which, the xmMegaButtonWidget can operate in 1 of 
	two modes: As a menu of pushbuttons, or a menu of toggle 
	buttons.

MPEG 
	C[A, ?]
	L[XORG]
	A[Jan Newmarch]

	An MPEG widget based on the Berkeley MPEG player

MultiList: 
	C[A] 
	L[FWF] 
	A[Brian Totty, (totty@cs.uiuc.edu)]
	
	MultiList is a replacement for the Athena List widget, which
	allows  multiple selections to be made.  The aesthetics have
	also been slightly improved: the highlight colors can now be
	selected,  and the selection extends across the entire width
	of the column rather than just the length of the string.

NewToggle: 
	C[M12] 
	L[XORG-M] 
	A[Harald Albrecht (albrecht@igpm.rwth-aachen.de)]
	
	An XmNewToggleButton displays a checkbox whenever it is 
	part of a multiple choice selection. When in exclusive mode 
	the new toggle button widget class draws a round button 
	instead which looks much like the buttons known from old 
	radios.

OptionButton: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The option button is  very  much  like  a  PullDown  button,
	except  that the label of the button is automatically set to
	the label of the last selected menu item.

PieMenu: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	A PieMenu is normally used as a pop-up menu. It is a  circu-
	lar  menu  with labeled pie segements. The menu pops up with
	the mouse pointer in the center. The user  moves  the  mouse
	into  one of the segments and releases the mouse button. The
	advantage of this kind of menu is that -- after  some  prac-
	tice -- it can be used without having to look at the screen.
	The disadvantage is that there is only room for a few items.
	This implementation works with up to 6 items.

PixelEditor: 
	C[A] 
	L[FWF] 
	A[Brian Totty, (totty@cs.uiuc.edu)]
	
	PixelEditor is an X widget to act as a  building  block  for
	image editing applications (icon editors, font editors, pic-
	ture editors, pattern editors, etc.).  It provides a drawing
	grid  of pixels which can be edited with a set of predefined
	drawing  tools  and  region  operations. The application
	interacts  with  the PixelEditor through resources and func-
	tion calls.  The aim of the widget is to implement  most  of
	the  tedious  code necessary for pixel editing applications,
	while leaving the details  of  the  user  interface  (menus,
	toolboxes,  file selection, etc.) to the application writer.
	Hooks are provided to allow the widget to be extended by the
	user.

Rheostat: 
	C[A] 
	L[FWF] 
	A[Joe English (joe@trystero.art.com)]
	
	Rheostat is a round, dial-like valuator widget that  may  be
	used  for  input  or display of integer values.  It comes in
	both vanilla and Motif flavours.  It  is  a  general-purpose
	valuator,  but  it's  especially  useful  for displaying and
	entering angles.  Set *minimumValue and *minimumAngle to  0,
	and  *minimumValue  and  *minimumAngle to 360 to configure a
	Rheostat as an angle valuator.  Compile  with  -DMOTIF=1  to
	get  the  Motif  version. The  class pointer is xfwfRheos-
	tatWidgetClass.

+) Scat:
	C[M11, M12]
	L[ftp://ftp.fnal.gov/pub/plot_widgets]
	A[Mark Edel (histoscope_support@fnal.gov)]

	2D scatter plot.  Plots colored dots to represent
	x,y coordinate pairs using linear or log scaling.
	Allows users to pan and scale plot by dragging on
	data or axes.  Can handle large numbers of points
	(around 3 million depending on system)
	Encapsulated PostScript output.

SciPlot:
	C[XT,M11,M12?]
	L[XORG]
	A[Rob McMullen, (rwmcm@orion.ae.utexas.edu)]

	The SciPlot Widget is a widget capable of plotting cartesian 
	or polar graphs, including logarithmic axes in cartesian plots.  
	The widget is subclassed directly from the Core widget class, 
	which means that it does not depend upon any other widget set.
	It may be freely used with Athena, Motif, or the Open Look/Xview
	widget sets.  (There is optional Motif support that causes 
	the widget to be subclassed from XmPrimitive.  See the man page.)

	Features provided in the widget include automatic scaling, 
	legend drawing, axis labeling, PostScript output, multiple plotted 
	lines, color support, user font specification, dashed lines, 
	symbols drawn at points, logarithmic scales on one or both axes 
	in cartesian plots, and degrees or radians as angles in polar 
	plots.

Scrollbar: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The scrollbar widget helps the user to view data that is too
	large  to  be  displayed  all  at once.  They are often used
	through a ScrolledWindow (see there),  where  they  are  put
	next  to and/or below the widget that contains the data. The
	scrollbar controls which part is  visible.  By  manipulating
	the  scrollbar  the user can move (`scroll') the data within
	the other widget.

ScrolledList: 
	C[A] 
	L[FWF] 
	A[Brian Totty (totty@cs.uiuc.edu)]
	
	ScrolledList is a simple, single column,  scrolled  list  of
	text  items,  where  selections can be made.  The widget has
	callbacks to notify selection changes.  The ScrolledList  is
	build  from the MultiList widget allowing the text highlight
	colors to be changed, and multiple  items  to  be  selected.
	This  is  a  very incomplete widget -- read the RESTRICTIONS
	section below.

Shistogram: 
	C[A] 
	L[FWF] 
	A[John L. Cwikla (cwikla@wri.com)]
	
	The shistogram widget is an X toolkit compatible widget that
	displays  data  in  a  histogram.  The data must be unsigned
	chars (values 0-255).  The widget is  autoscaling,  and  can
	display a title and statistics.

Slider2: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	A Slider2 widget consists of a rectangular area in  which  a
	`thumb'  can  be moved about. A Slider2 is typically used to
	pan or scroll another window; as such  is  can  replace  two
	scrollbars.  The thumb can be dragged with the mouse, or the
	mouse can be clicked next to the thumb, to move  it  in  the
	direction  of  the  mouse. The thumb may contain one or more
	lines of text, although there is usually no  room  for  more
	than one or two words.

ThumbWheel: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	This is a very basic implementation of  a  valuator  (scrol-
	ling)  widget  that  uses  a  thumbwheel  as a metaphor. The
	thumbwheel is placed vertically  by  default.  The  edge  is
	turned towards the viewer and sticking out. It can be turned
	up or down (or  left-right)  with  the  mouse  or  with  the
	up/down arrow keys.

Toggle: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The XfwfToggle is a button that switches states  with  every
	activation (which is by default with every mouse click). The
	states are named `on' and `off'. The states can be indicated
	with  a  $rd$  before  the  label  Two  callbacks report the
	changed state to the application: onCallback is called  when
	the  button switches to `on', offCallback is called when the
	button switches back to `off'.

VScrollbar: 
	C[A] 
	L[FWF] 
	A[Bert Bos (bert@let.rug.nl)]
	
	The XfwfVScrollbar widget is exactly the same as its  super-
	class,  XfwfScrollbar,  except  for  the  fact  that  it has
	default translations for keyboard events. It would be a sim-
	ple  matter  to add these translations in a resource file or
	in an application's source, but having them  by  default  is
	quite convenient.

+) XY:
	C[M11, M12]
	L[ftp://ftp.fnal.gov/pub/plot_widgets]
	A[Mark Edel, Baolin Ren (histoscope_support@fnal.gov)]

	Generic 2D cartesian plot, linear or log scaling,
	encapsulated PostScript output.  Draws several
	styles of lines, markers, strings, and error
	bars.  Allows users to pan and scale plot by
	dragging on data and axes.

!) XeAudio: 
	C[XT]
	L[XORG] 
	A[Markku Savela (Markku.Savela@vtt.fi)]
	
	A Widget that "displays" Audio (only for Sun Sparc, 
	/dev/audio)

!) XeRaster: 
	C[XT]
	L[XORG] 
	A[Markku Savela (Markku.Savela@vtt.fi)]

	An image widget that can display GIF, PBM, JPEG, TIFF.

!) XeText: 
	C[XT]
	L[XORG] 
	A[Markku Savela (Markku.Savela@vtt.fi)]

	A text widget based on ISO 2022 and ISO 6529 standards.

!) XeTextEd: 
	C[XT]
	L[XORG] 
	A[Markku Savela (Markku.Savela@vtt.fi)]

	A text widget subclass of XeText that allows selections and 
	editing.

!) XeVideo: 
	C[XT]
	L[XORG] 
	A[Markku Savela (Markku.Savela@vtt.fi)]

	A video widget, based on Berkeley MPEG decoder (2.0)

++XhMinitel
	C[XT]
	L[epita.fr (hydrix@epita.fr)]
	A[Vianney RANCUREL, (mtds@epita.fr)]

	Videotex emulator widgets; Emulate minitel1, minitel1b, minitel2.
	The widget is designed to support most of terminals control sequences.
	You can easily implement vt100,... widgets (minitel1b also emulates vt100!)
	These widgets are parts of a commercial project.  Ask for hydrix@epita.fr.

XmGauge
	C[M12]
	L[ftp://avahi.inria.fr/pub/widgets/]
	A[Jean-Michel Leon, (leon@sophia.inria.fr)]

	A Motif compatible gauge.


** XmtMsgLine: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)]

	The XmtMsgLine widget--a message line inspired by emacs.  
	Supports synchronous input.

XmtdsTetris
	C[XT]
	L[XORG]
	A[Vianney RANCUREL, (mtds@epita.fr)]

	A complete, nice Tetris widget.

XmtdsElecDisp
	C[XT]
	L[XORG]
	A[Vianney RANCUREL, (mtds@epita.fr)]

	A widget for displaying text like in an elecric bulletin board.

** XmtInputField: 
	C[M11,M12] 
	L[??] 
	A[David Flanagan (david@ora.com)]

	The XmtInputField widget--a text widget with input 
	validation.

xcBarGraphWidgetClass
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	The BarGraph widget is used as a horizontal or vertical 
	bar graph indication of a specified value.  It is a 
	subclass of the Value widget so it can display long 
	integer/hexadecimal/floating point values.  This BarGraph 
	widget is not to be confused with a bar chart widget (i.e., 
	it only displays one value, not many values side-by-side).  
	It looks like a digital 'thermometer', or a traditional 
	graphic equalizer band.  It is used to visually indicate 
	a current value in relation to a specified range.

xcControlWidget:
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

   	The Control widget serves as the superclass for all of 
	the Xc widgets.  It simply stores resources that are 
	common to all of the Xc widget classes (i.e., label, 
	font, colors, etc.).  It also calculates the shade colors
	used in producing the 3D effect.

xcLcdWidgetClass
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	The LCD widget is also a subclass of the Value widget and 
	it emulates the traditional 7-segment LCD display.  It 
	simply takes an application- specified long integer/
	floating point/hexadecimal value and displays each 
	character of the value in 7-segment LCD fashion.

xcLedButtonWidgetClass
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	This widget is a subclass of the Control widget and it 
	is used as an indicator to display an application-
	specified status to the user.  It consists of three 
	graphical elements: the Label, an LED indicator, and 
	an optional State Box that displays an application 
	specified string corresponding to the current LedButton 
	state.

xcSimpleButtonWidget:
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	The SimpleButton widget is similar to Motif's XmPushButton 
	widget.  It's provided in the Xc widget set for those who 
	aren't fortunate to have Motif and still want to have cool 
	looking buttons.

xcSliderWidgetClass
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	The Slider widget is a subclass of the Value widget and it 
	is similar in behavior/functionality to Motif's XmScale 
	widget in that it allows you to manipulate a numeric value 
	over a given range.  The Xc Slider widget differs from the 
	Motif XmScale in that it allows manipulation of real 
	floating point values (not just an integer that is displayed 
	like a float).  Additionally, the Slider widget allows 
	manipulation of values over a broader range (i.e., the range 
	of 'C' long integer and float types).

xcToggleButtonWidgetClass
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	This widget behaves in much the same way as the SimpleButton 
	widget, except that it toggles between an 'on' and 'off' 
	state.  It is made up of two graphical elements: the widget's 
	Label, and an LED indicator.

xcValueWidget:
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	The Value widget is used only for subclassing widgets that
	manipulate long integer/floating point values, and it does
	nothing other than store resource settings common to this
	widget class.

xcValueButtonWidgetClass
	C[XT]
	L[OLD-XORG, Xc-1.3.tar.gz]
	A[Paul Johnston (johnston@spc5.jpl.nasa.gov)]

	The ValueButton widget was created to provide a user-
	interface element that would allow a user to increment/
	decrement an integer, long integer, or floating point value
	by clicking on an Up or Down arrow, and allow an application 
	to access the incremented/decremented value when the user 
	clicks on an Accept button.  One of the many possible uses 
	of such a widget would be to provide an interface element 
	enabling the user to quickly change application 'settings' 
	by using the mouse pointer instead of typing values from the 
	keyboard, thus providing a more logical approach to a user-
	interface (i.e., its more logical to press an up/down arrow 
	to increment/decrement a value instead of typing its new 
	value in some kind of text widget).
--
o  John L. Cwikla                       o                                o
o  X Programmer                         o   I'm not in a bad mood.       o
o  Wolfram Research, Inc.               o   I'm always like this.        o
o  cwikla@wri.com  (217) 398-0700       o                                o
o  http://www.wri.com/~cwikla           o                                o
o  http://www.wri.com/~cwikla/widget    o   The Widget FAQ               o
o  http://www.wri.com/~cwikla/xlopedia  o   The Xlopedia                 o 

--
Ruslan Belkin

at CS/MONOLIT Network Centre (rus@ua.net)

