FreeBSD Manual Pages

home | help

XbaeMatrix(3x) xbae XbaeMatrix(3x)

NAME
XbaeMatrix - The Bellcore Application Environment (BAE) XbaeMatrix widget
class.

SYNOPSIS
#include <Xbae/Matrix.h>

DESCRIPTION
XbaeMatrix presents an editable array of string data to the user in a
scrollable grid-like format similar to a spreadsheet. Non editable pixmaps
can also be displayed on the matrix. The rows and columns of the Matrix
may optionally be labeled. Also, a number of fixed leading or trailing
rows or columns may be specified - these behave similarly to the labels.
While XbaeMatrix looks and acts like a grid of XmText widgets, it actually
contains only one XmText. This means that XbaeMatrix widgets with hundreds
or thousands of rows have much less overhead than they would if they used
an XmText for each cell.

Clicking on a cell with Button1 will edit the cell. While a cell is being
edited, Tab and Shift-Tab will edit the cell to the right or left respec-
tively. The osfUp and osfDown keys will edit the cell above or below.
Ctrl-Tab and Shift-Ctrl-Tab will traverse out of the Matrix and into the
next or previous tab groups.

The osfCancel key will cancel any edits made to a cell. The osfActivate
key will commit any edits made to a cell and store them in the Matrix.
When traversing from another tab group into the Matrix, the focus will go
to whichever cell is currently being edited. If no cells are being edited,
then the upper left most visible non-fixed cell will be edited.

The column sizes may be dynamically resized by pressing the Shift-Button2
combination when over a column boundary, similar to the behaviour of some
popular spreadsheets. After a column has been resized in this manner, the
XbaeMatrix calls the callbacks on the XmNresizeColumnCallback callback list
for post processing.

If the Matrix is resized until it is too small to display all of the cells
in a given dimension, then it will display a ScrollBar for that dimension.
The horizontal ScrollBar will scroll the cells and column labels, but not
the row labels, fixed columns or trailing fixed columns. The vertical
ScrollBar will scroll the cells and row labels, but not the column labels,
fixed rows or trailing fixed rows.

For the application programmer, XbaeMatrix provides callbacks to assist in
data validation. The callbacks on the XmNmodifyVerifyCallback callback
list are called before text is inserted into, or deleted from, a cell.
This callback list can be used to force user input to match a certain pat-
tern (e.g. a date format). Similarly, the XmNvalueChangedCallback is
called after text is inserted or deleted.

When a cell is edited (by clicking on it or tabbing into it), the XmNleave-
CellCallback callbacks are called for the previous cell being edited, if
any. The application can verify the data entered in that cell and disallow
editing of the new cell if the data is invalid. If the data was valid,
then the XmNenterCellCallback callbacks for the new cell are called. These
callbacks can be used to specify the editability of the new cell.

The XmNtraverseCellCallback callbacks are also called when the user at-
tempts to edit a new cell and when the matrix gains or looses focus. This
allows the application to override the default traversal behavior of Xbae-
Matrix.

The XmNdefaultActionCallback is provided to allow a double click action in
a cell to perform some function.

Motif's Drag and Drop functionality can be achieved via the XmNprocessDrag-
Callback.

For large amounts of data, the overhead of assigning data to the widget can
be avoided using the XmNdrawCellCallback. This callback also allows user
defined pixmaps to be placed in a certain cell. When using this callback,
data for string fields can be written back to the application by using the
XmNwriteCellCallback.

Classes
XbaeMatrix inherits behavior and resources from the Core, Composite, Con-
straint, and XmManager widget classes.
The class pointer is xbaeMatrixWidgetClass.
The class name is XbaeMatrix.

New Resources
The following table lists the new resources defined by XbaeMatrix. The
codes in the ``Access'' column indicate whether the given resource can be
set at creation time (C), or set by using XtSetValues (S), or retrieved by
using XtGetValues (G).

+---------------------------------------------------------------------------------------+
| XbaeMatrix Resource Set |
+--------------------------+---------------------+---------------+---------------+------+
| Name Class Type Default Access |
+--------------------------+---------------------+---------------+---------------+------+
| XmNallowColumnResize XmCAllowResize Boolean True CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNallowRowResize XmCAllowResize Boolean True CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNaltRowCount XmCAltRowCount int 1 CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNboldLabels XmCBoldLabels Boolean False CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNbuttonLabels XmCButtonLabels Boolean False CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNbuttonLabelBackground XmCColor Pixel dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcalcCursorPosition XmCCalcCursorPosition Boolean False CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellBackgrounds XmCColors PixelTable NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellHighlightThicknessXmCHighlightThickness Dimension dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellMarginHeight XmCMarginHeight Dimension dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellMarginWidth XmCMarginWidth Dimension dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellShadowThickness XmCShadowThickness Dimension 2 CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellShadowType XmCShadowType unsigned char XmSHADOW_OUT CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellShadowTypes XmCCellShadowTypes unsigned char **NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcellUserData XmCCellUserData XtPointer ** NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNclipWindow XmCClipWindow Widget NULL G |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcells XmCCells CellTable NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolors XmCColors PixelTable NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnAlignments XmCAlignments AlignmentArray dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnButtonLabels XmCButtonLabels BooleanArray NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnLabelAlignments XmCAlignments AlignmentArray dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnLabelColor XmCColor Pixel dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnLabels XmCLabels StringArray NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnMaxLengths XmCColumnMaxLengths MaxLengthArray NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnShadowTypes XmCShadowTypes unsigned char * NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnUserData XmCUserDatas XtPointer * NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnWidthInPixels XmCColumnWidthInPixelsBoolean False CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumnWidths XmCColumnWidths WidthArray NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNcolumns XmCColumns int 0 CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNdefaultActionCallback XmCCallback XtCallbackList NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNdoubleClickInterval XmCDoubleClickIntervalint dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNdrawCellCallback XmCCallback Callback NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNenterCellCallback XmCCallback Callback NULL CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNevenRowBackground XmCBackground Pixel dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNfill XmCFill Boolean False CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNhorzFill XmCHorzFill Boolean False CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNvertFill XmCVertFill Boolean False CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNfixedColumns XmCFixedColumns Dimension 0 CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNfixedRows XmCFixedRows Dimension 0 CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNfontList XmCFontList FontList fixed CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNgridLineColor XmCColor Pixel dynamic CSG |
+--------------------------+---------------------+---------------+---------------+------+
| XmNgridType XmCGridType GridType XmGRID_CELL_LINECSG |
+--------------------------+---------------------+---------------+---------------+------+
+--------------------------+---------------------+---------------+---------------+------+
+-------------------------------------------------------------------------------------------------------------+
| XbaeMatrix Resource Set (continued) |
+------------------------------------+------------------------------+---------------+------------------+------+
| Name Class Type Default Access |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNhighlightedCells XmCHighlightedCells HighlightTable *dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNhorizontalScrollBar XmCHorizontalScrollBar Widget NULL G |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNhorizontalScrollBarDisplayPolicyXmCMatrixScrollBarDisplayPolicyunsigned char XmDISPLAY_AS_NEEDEDCSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNlabelActivateCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNlabelFont XmCFontList FontList dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNleaveCellCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNleftColumn XmCLeftColumn int 0 CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNmodifyVerifyCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNmultiLineCell XmCMultiLineCell Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNnonFixedDetachedLeft XmCNonFixedDetachedLeft Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNnonFixedDetachedTop XmCNonFixedDetachedTop Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNoddRowBackground XmCBackground Pixel dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNprocessDragCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrenderTable XmCRenderTable RenderTable NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNresizeCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNresizeColumnCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNreverseSelect XmCReverseSelect Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowButtonLabels XmCButtonLabels BooleanArray NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowHeightInPixels XmCRowHeightInPixels Boolean True CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowHeights XmCColumnWidths WidthArray NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowLabelAlignment XmCAlignment Alignment XmALIGNMENT_END CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowLabelColor XmCColor Pixel dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowLabelWidth XmCRowLabelWidth Short dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowLabels XmCLabels StringArray NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowShadowTypes XmCShadowTypes unsigned char * NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrowUserData XmCUserDatas XtPointer * NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNrows XmCRows int 0 CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNscrollBarPlacement XmCScrollBarPlacement unsigned char XmBOTTOM_RIGHT CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNselectCellCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNselectScrollVisible XmCSelectScrollVisible Boolean True CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNselectedBackground XmCColor Pixel dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNselectedCells XmCSelectedCells BooleanTable dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNselectedForeground XmCColor Pixel dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNshadowType XmCShadowType unsigned char XmSHADOW_IN CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNshowArrows XmCShowArrows Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNspace XmCSpace Dimension dynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtextBackground XmCBackground Pixel XmUNSPECIFIED_PIXELCSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtextBackgroundIsCell XmCTextBackgroundIsCell Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtextField XmCTextField Widget NULL G |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtextShadowThickness XmCTextShadowThickness Dimension 0 CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtextTranslations XmCTranslations TranslationTabledynamic CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtopRow XmCTopRow int 0 CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtrackcellCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtrailingAttachedBottom XmCTrailingAttachedBottom Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtrailingAttachedRight XmCTrailingAttachedRight Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtrailingFixedColumns XmCTrailingFixedColumns Dimension 0 CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtrailingFixedRows XmCTrailingFixedRows Dimension 0 CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtraverseCellCallback XmCCallback Callback NULL CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
| XmNtraverseFixedCells XmCTraverseFixedCells Boolean False CSG |
+------------------------------------+------------------------------+---------------+------------------+------+
+------------------------------------+------------------------------+---------------+------------------+------+
+--------------------------------------------------------------------------------------------------------+
| XbaeMatrix Resource Set (continued) |
+----------------------------------+------------------------------+------------+------------------+------+
| Name Class Type Default Access |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNuseXbaeInput XmCUseXbaeInput Boolean False CSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNvalueChangedCallback XmCCallback Callback NULL CSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNverticalScrollBar XmCVerticalScrollBar Widget NULL G |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNverticalScrollBarDisplayPolicyXmCMatrixScrollBarDisplayPolicyunsigned charXmDISPLAY_AS_NEEDEDCSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNvisibleColumns XmCVisibleColumns Dimension 0 CSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNvisibleRows XmCVisibleRows Dimension 0 CSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNwrapType XmCWrapType Boolean XbaeWrapNone CSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNwriteCellCallback XmCCallback Callback NULL CSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNxmColumnLabels XmCXmLabels XmString * NULL CSG |
+----------------------------------+------------------------------+------------+------------------+------+
| XmNxmRowLabels XmCXmLabels XmString * NULL CSG |
+----------------------------------+------------------------------+------------+------------------+------+
+----------------------------------+------------------------------+------------+------------------+------+

This resource cannot be specified in a resource file

XmNallowColumnResize
If True, allows the columns to be dynamically resized via the Re-
sizeColumns() action. The default value is to allow column resizing.

XmNallowRowResize
If True, allows the rows to be dynamically resized via the Resize-
Rows() action. The default value is to allow row resizing.

XmNaltRowCount
Specifies the number of rows to use for each of the XmNevenRowBack-
ground and XmNoddRowBackround colors. This resource is ignored if XmN-
evenRowBackground and XmNoddRowBackround are not used.

XmNboldLabels
Overstrikes the row and column labels to create a bold font appearance
when True.

XmNbuttonLabels
When set to True, the labels will be drawn with a shadow around them
similar to an XmPushButton widget. A ButtonPress event generated on
the labels, when XmNbuttonLabels is True will cause the label to re-
verse the shadow and take on a pushed in appearance. A ButtonRelease
event on the same label will invoke callbacks on the XmNlabelActivate-
Callback, list. The default value is False.

XmNbuttonLabelBackground
Specifies a Pixel value in which to draw the XmNbuttonLabels.

XmNcalcCursorPosition
If set to True, the insertion position on the text field is calculated
with respect to where the pointer was clicked in the cell. The de-
fault value is False. The insertion position will be overridden if
the position member of the XbaeEnterCellCallbackStruct is set to a
valid position.

XmNcellBackgrounds
Points to an array of pointers to rows. Each row is an array of Pixel
values, one for each column in that row. This data structure is the
same as that for XmNcells, except each entry is a Pixel instead of a
String. The background of a cell will be drawn in the color specified
for that cell. If XmNcellBackgrounds is NULL, backgrounds will be
drawn using the color specified by XmNbackground. This resource is
copied. XmNcellBackgrounds may be specified in a resource file but
due to the two dimensional nature of the XbaeMatrix widget, it must be
done by terminating each line with a \n character. If the XbaeMatrix
widget had XmNrows set to 5 and XmNcolumns set to 5, XmNcellBack-
grounds would be specified as:

*mw.cellBackgrounds: blue, white, blue, white, blue\n\
white, blue, white, blue, white\n\
blue, white, blue, white, blue\n\
white, blue, white, blue, white\n\
blue, white, blue, white, blue\n
Care must be taken when specifying these values in a resource file as
an incorrect format can produce undesirable results.

XmNcellHighlightThickness
Specifies the XmNhighlightThickness resource of the XmText cell edit
widget. This resource is also used to compute the size of each cell.
See the description of XmNhighlightThickness in XmText(3X).

XmNcellMarginHeight
Specifies the XmNmarginHeight resource of the XmText widget. This re-
source is also used to compute the size of each cell. See the descrip-
tion of XmNmarginHeight in XmText(3X).

XmNcellMarginWidth
Specifies the XmNmarginWidth resource of the XmText cell edit widget.
This resource is also used to compute the size of each cell. See the
description of XmNmarginWidth in XmText(3X).

XmNcellShadowThickness
Specifies the XmNshadowThickness resource of the XmText cell edit wid-
get. This resource is also used to compute the size of each cell. See
the description of XmNshadowThickness in XmText(3X).

XmNcellShadowType
Specifies the type of shadow drawn around each cell. Possible values
for this resource are XmSHADOW_OUT, XmSHADOW_IN, XmSHADOW_ETCHED_OUT,
and XmSHADOW_ETCHED_IN. The default shadow type is XmSHADOW_OUT.

XmNcellShadowTypes
Specifies on a per cell basis, the XmNcellShadowType. Values for the
resource are the same as for XmNcellShadowType. This resource is
copied.

XmNcellUserData
Points to an array of pointers to individual user defined data areas
associated with each cell. The data should be set using XbaeMa-
trixSetCellUserData() and retrieved using XbaeMatrixGetCellUserData().
This resource cannot be specified in a resource file and is copied.

XmNcells
Points to an array of pointers to rows. Each row is an array of
String, one for each column in that row. For example, the cells for a
2x3 Matrix could be set up as follows:

String rows[2][3] =
{
"00", "01", "02",
"10", "11", "12"
};
String *cells[2];
cells[0] = &rows[0][0];
cells[1] = &rows[1][0];

Now cells could be used as the XmNcells resource. If XmNcells is NULL,
XbaeMatrix will not generate an internal table of empty Strings. This
implies that if XmNcells is NULL, no cells have been set. This re-
source is copied. See the discussion in XmNcellBackgrounds for how to
specify XmNcells in a resource file.

XmNclipWindow
The widget ID of the clip window. The clip window is the widget that
contains the non-fixed region of cells. This resource can not be set
to a new value.

XmNcolors
Points to an array of pointers to rows. Each row is an array of Pixel
values, one for each column in that row. This data structure is the
same as that for XmNcells, except each entry is a Pixel instead of a
String. The text in a cell will be drawn in the color specified for
that cell. If XmNcolors is NULL, text will be drawn using the color
specified by XmNforeground. This resource is copied. See the discus-
sion in XmNcellBackgrounds for how to specify XmNcolors in a resource
file.

XmNcolumnAlignments
Points to an array of alignments (unsigned char), one for each column.
Each element can be one of XmALIGNMENT_BEGINNING, XmALIGNMENT_CENTER
or XmALIGNMENT_END. This specifies the alignment of the text or
pixmap in each cell of that column. See the description of XmNalign-
ment for XmLabel(3X). If XmNcolumnAlignments is NULL, each column
will default to XmALIGNMENT_BEGINNING. This resource is copied.

XmNcolumnButtonLabels
An array of Booleans that tells the XbaeMatrix which column labels
should be drawn as a button. Each Boolean can be specified as a
Boolean string or integer. In order to use this resource, XmNbuttonLa-
bels should be set to False.

XmNcolumnLabelAlignments
Points to an array of alignments (unsigned char), one for each column
label. Each element can be one of XmALIGNMENT_BEGINNING, XmALIGN-
MENT_CENTER or XmALIGNMENT_END. This specifies the alignment of the
text of each column label. See the description of XmNalignment for Xm-
Label(3X). If XmNcolumnLabelAlignments is NULL, each column label
will default to XmALIGNMENT_BEGINNING. This resource is copied.

XmNcolumnLabelColor
Specifies a Pixel value in which to draw the XmNcolumnLabels.

XmNcolumnLabels
Points to an array of Strings to be drawn above each column. Each
String may have embedded newline characters, in which case the label
will be drawn on multiple lines. If there is a XmNxmColumnLabels de-
fined for this coluumn it will be displayed in place of the XmNcolumn-
Labels. If XmNcolumnLabels and XmNxmColumnLabels are NULL, no labels
will be drawn. This resource is copied.

XmNcolumnMaxLengths
Points to an array of int, one for each column. These specify the max-
imum length of a String which can be entered in the cells in that col-
umn. See the description of the XmText(3X) XmNmaxLength resource. If
XmNcolumnMaxLengths is NULL or an element of the array is equal to 0,
then the corresponding width from XmNcolumnWidths is used. This re-
source is copied.

XmNcolumnShadowTypes
Specifies on a per column basis, the XmNcellShadowType. Values for
the resource are the same as for XmNcellShadowType. This resource is
copied.

XmNcolumnUserData
Points to a user defined data area associated with a particular col-
umn. The data should be set using XbaeMatrixSetColumnUserData() and
retrieved using XbaeMatrixGetColumnUserData(). This resource cannot
be specified in a resource file.

XmNcolumnWidthInPixels
Specifies wether the elements of XmNcolumnWidths are measured in pix-
els or characters.

XmNcolumnWidths
Points to an array of short, one for each column. These specify the
visible width of the cells in each column. See the description of the
XmText(3X) XmNcolumns resource. This resource is copied.

XmNcolumns
Specifies the total number of columns of cells. XmNcolumns must be at
least one. If the number of columns is changed via XtSetValues, then
XmNcolumnMaxLengths must change or be NULL, XmNcolumnLabels must
change or be NULL, XmNcolumnAlignments must change or be NULL and XmN-
columnLabelAlignments must change or be NULL. The preferred way to
dynamically change the number of columns is to use XbaeMatrixAdd-
Columns() or XbaeMatrixDeleteColumns().

XmNdefaultActionCallback
Specifies a list of callbacks to be called when a double click occurs
in a cell. A pointer to an XbaeMatrixDefaultActionCallbackStruct is
passed to the callbacks. Events are reported to the cell in which the
double click occurs regardless of whether or not a callback exists.
This callback is called by the DefaultAction() action and is NULL by
default. The XmNdefaultActionCallback is ideal for popping up a dia-
log or other window when a double click occurs.

XmNdoubleClickInterval
Specifies the amount of time between mouse clicks before it is consid-
ered a double click. A double click is defined to be the time between
the realease of the mouse button and subsequent press in the same
cell. The default value is inherited from the display.

XmNdrawCellCallback
Specifies a list of callbacks to be called when a cell needs to be
drawn. A pointer to an XbaeMatrixDrawCellCallbackStruct is passed to
the callbacks. The application can specify what to put in a cell by
modifying the callback struct's data fields. When the application
callback returns to the widget code, the type field will determine
what the widget draws on the screen. If the value is XbaeString, then
the regular string drawing function for the widget will be called with
the value the applicaton assigned to the string field in the struct.
If the value is XbaeStringFree the widget also calls XtFree on the
string when it is not needed anymore. Else, if the value is
XbaePixmap, the widget will do an XCopyPlane(), in the case of a sin-
gle plane bitmap, or XCopyArea(), in the case of a color pixmap. The
width and height of cell is passed in the struct so the application
can know how big to make the pixmap. In no case will a copy of the
string or the pixmap value be made. The widget also uses the XmNcolum-
nAlignments resource to determine the horizontal alignment of the
Pixmap. To have an editable array of data when the XmNdrawCellCall-
back is used and the cell is of type XbaeString or XbaeStringFree, use
the XmNwriteCellCallback.

XmNenterCellCallback
Specifies a list of callbacks to be called immediately before a cell
is to be edited. This callback list is called by the EditCell() ac-
tion. A pointer to an XbaeMatrixEnterCellCallbackStruct is passed to
the callbacks. The application can specify the editability of specific
cells using this callback list as well as specifying configuration op-
tions for the XmText.

XmNevenRowBackground
Specifies a background cell Pixel value to use on even rows. This al-
lows the matrix to look like computer paper. For wider bands of color,
increase the size of XmNaltRowCount.

XmNfill
If True, controls whether the matrix should fill all of its available
space when additional space if available, or if it should simply size
itself as large as necessary, regardless of any additonal available
space.

XmNhorzFill
If True, controls whether the matrix should highlight available space
on the right of the selected cell(s) when the selected cell(s) are in
the last column of the matrix.

XmNvertFill
If True, controls whether the matrix should highlight available space
below the selected cell(s) when the selected cell(s) are in the last
row of the Matrix.

XmNfixedColumns
Specifies the number of leading columns (starting from the left col-
umn) which should not be horizontally scrollable. XmNfixedColumns
must be less than XmNcolumns-XmNtrailingFixedColumns. Cells in fixed
columns are not editable unless XmNtraverseFixedCells is set to True.

XmNfixedRows
Specifies the number of leading rows (starting from the top row) which
should not be vertically scrollable. XmNfixedRows must be less than
XmNrows-XmNtrailingFixedRows. Cells in fixed rows are not editable
unless XmNtraverseFixedCells is set to True.

XmNfontList
If the value of XmNrenderTable is NULL this resource specifies the
font list to be used for the text displayed in the cells and the Xm-
Text cell edit widget. See XmFontListCreate(3X) to create a font list.
This resource is copied. The preferred way of specifying a font for
the table is in a resource file.

When drawing a cell, the matrix uses the first entry with the tag Xm-
FONTLIST_DEFAULT_TAG if no tag has been set on the cell using XbaeMa-
trixSetCellTag. If a tag has been set on the cell the first entry
with a matching tag is used.

XmNgridLineColor
Specifies the color in which the grid line should be drawn if XmNgrid-
Type is set to XmGRID_CELL_LINE, XmGRID_ROW_LINE or XmGRID_COL-
UMN_LINE. The default is that of XmNforeground.

XmNgridType
Sets the way the matrix grid is drawn. The grid types available in-
clude XmGRID_NONE, XmGRID_CELL_LINE, XmGRID_CELL_SHADOW, Xm-
GRID_ROW_LINE, XmGRID_ROW_SHADOW, XmGRID_COLUMN_LINE and XmGRID_COL-
UMN_SHADOW. All of the grid types vary the way the shadow or line is
drawn around the cell. XmGRID_ROW_LINE, XmGRID_ROW_SHADOW, Xm-
GRID_COLUMN_LINE, and XmGRID_COLUMN_SHADOW only draw a border around
the rows and columns, giving a more tabular rather than spreadsheet
appearance. The default is XmGRID_CELL_LINE which draws a solid line
around the cells.

XmNhighlightedCells
Points to an array of pointers to rows. Each row is an array of un-
signed char values, one for each column in that row. This data struc-
ture is the same as that for XmNcells, except each entry is an un-
signed char instead of a String. Each entry in the array will have a
value that is either HighlightNone, HighlightCell, HighlightRow, High-
lightColumn, HighlightOther or the bitwise OR of those values, depend-
ing on the value of XmNgridType and which call was used to highlight
the cell. A cell will be drawn as highlighted if the corresponding
unsigned char does not have the value HighlightNone. If XmNhighlight-
edCells is NULL, XbaeMatrix then no cells have been highlighted. This
resource is copied, and cannot be specified in a resource file.

XmNhorizontalScrollBar
The widget ID of the horizontal XmScrollBar. This resource exists
only for those applications that need to tie another scrollbar to the
matrix's for synchronized scrolling. This resource can not be set to
a new value.

XmNhorizontalScrollBarDisplayPolicy
Determines when to display a horizontal scrollbar in the matrix. Pos-
sible values are XmDISPLAY_NONE, which makes the matrix never display
the scrollbar, XmDISPLAY_AS_NEEDED, which makes the matrix display the
scrollbar when the list is too large, and XmDISPLAY_STATIC, which
makes the matrix always display the scrollbar.

XmNlabelFont
If the value of XmNrenderTable is NULL this resource specifies the
font list to be used for the text displayed in row and column labels.
If XmNlabelFont is not specified, the value of XmNfontList is used for
the label fonts. See XmFontListCreate(3X) to create a font list. This
resource is copied. The preferred way of specifying a font for the
labels is in a resource file.

When drawing a label, the matrix uses the first entry with the tag Xm-
FONTLIST_DEFAULT_TAG.

XmNlabelActivateCallback
Specifies a list of callbacks to be called after a button label has
been pressed. A pointer to an XbaeMatrixLabelActivateCallbackStruct
is passed to the callbacks on this list.

XmNleaveCellCallback
Specifies a list of callbacks to be called immediately after a cell
has been edited. This callback list is called by the EditCell() and
CommitEdit() actions. A pointer to an XbaeMatrixLeaveCellCallback-
Struct is passed to the callbacks. The application can perform cell
specific data checks using this callback list.

XmNleftColumn
Allows the programmer to specify the first non fixed column to appear
on the leftmost side of the matrix. This resource compliments the Xm-
NtopRow resource. See the discussion of XmNtopRow for more details.

XmNmodifyVerifyCallback
Specifies a list of callbacks to be called before text is deleted from
or inserted into the XmText cell edit widget. A pointer to an XbaeMa-
trixModifyVerifyCallbackStruct is passed to the callbacks. See the de-
scription of the XmText(3X) XmNmodifyVerifyCallback resource.

XmNmultiLineCell
is a boolean (default False) which specifies whether the matrix dis-
plays more than one line of text in a cell, when appropriate.

XmNnonFixedDetachedLeft
Indicated that empty space should be displayed after the fixed rows.
This resource only has effect when XmNfill is true and XmNfixedRows is
greater than zero.

XmNnonFixedDetachedTop
Indicated that empty space should be displayed after the fixed
columns. This resource only has effect when XmNfill is true and XmN-
fixedColumns is greater than zero.

XmNoddRowBackground
Specifies a background cell color to use on odd rows. This allows the
matrix to look like computer paper. For wider bands of color, increase
the size of XmNaltRowCount.

XmNprocessDragCallback
Specifies a list of callbacks to be called from the ProcessDrag() ac-
tion A pointer to an XbaeMatrixProcessDragCallbackStruct will be
passed to the callbacks. The application can use this callback list to
perform particular processing during a drag.

XmNrenderTable
Specifies the render table used to derive a font set or a font to draw
the text displayed in the cells, the XmText cell edit widget and the
labels.

When drawing a cell, the matrix uses the first entry with the tag _MO-
TIF_DEFAULT_LOCALE if no tag has been set on the cell using XbaeMa-
trixSetCellTag. If a tag has been set on the cell the first entry
with a matching tag is used.

When drawing a label, the matrix uses the first entry with the tag
"labels". If there is no such entry the first entry with the tag _MO-
TIF_DEFAULT_LOCALE is used.

XmNresizeCallback
Specifies a list of callbacks to be called when the matrix is resized.

XmNresizeColumnCallback
Specifies a list of callbacks to be called when a column is dynami-
cally resized by the user.

XmNreverseSelect
Overrides the default XmNselectedForeground and XmNselectedBackground
and draws a selected cell in the colours specified by XmNcellBack-
grounds and XmNcolors for the particular cell. If these values are
not set then the default colours will be used.

XmNrowButtonLabels
An array of Booleans that tells the XbaeMatrix which row labels should
be drawn as a button. Each Boolean can be specified as a Boolean
string or integer. In order to use this resource, XmNbuttonLabels
should be set to False.

XmNrowLabelAlignment
Specifies the alignment of the row labels. It can be one of XmALIGN-
MENT_BEGINNING, XmALIGNMENT_CENTER or XmALIGNMENT_END. See the de-
scription of XmNalignment for XmLabel(3X). XmNrowLabelAlignment de-
faults to XmALIGNMENT_END.

XmNrowLabelColor
Specifies a Pixel value in which to draw the XmNrowLabels.

XmNrowLabelWidth
Specifies the width of the row labels. XmNrowLabelWidth defaults to
the width of the longest row label.

XmNrowLabels
Points to an array of Strings to be drawn to the left of each row.
Each String may have embedded newline characters, in which case the
label will be drawn on multiple lines. If there is a XmNxmRowLabels
defined for this row it will be displayed in place of the XmNrowLa-
bels. If XmNrowLabels and XmNxmRowLabels are NULL, no labels will be
drawn. This resource is copied.

XmNrowHeightInPixels
Specifies wether the elements of XmNrowHeights are measured in pixels
or lines.

XmNrowHeights
Points to an array of short, one for each row. These specify the visi-
ble height of the cells in each row. This resource is copied.

XmNrowShadowTypes
Specifies on a per row basis, the XmNcellShadowType. Values for the
resource are the same as for XmNcellShadowType. This resource is
copied.

XmNrowUserData
Points to a user defined data area associated with a particular row.
The data should be set using XbaeMatrixSetRowUserData() and retrieved
using XbaeMatrixGetRowUserData(). This resource cannot be specified
in a resource file.

XmNrows
Specifies the total number of rows of cells. XmNrows must be at least
one. If the number of rows is changed via XtSetValues, then XmNrowLa-
bels must change or be NULL. The preferred way to dynamically change
the number of rows is to use XbaeMatrixAddRows() or XbaeMa-
trixDeleteRows().

XmNscrollBarPlacement
Determines where the scrollbars will be drawn. See the discussion of
XmNscrollBarPlacement in XmScrolledWindow(3) for a complete discussion
on this resource.

XmNselectCellCallback
Specifies a list of callbacks to be called from the SelectCell() ac-
tion. A pointer to an XbaeMatrixSelectCellCallbackStruct will be
passed to the callbacks. The application can use this callback list to
perform selection/deselection of cells using the provided widget meth-
ods.

XmNselectScrollVisible
Specifies whether the matrix will scroll to make the selected cell
visible. This flag is only checked when cells are selected program-
matically, as when the user selects a cell with the mouse, it will al-
ready be visible.

XmNselectedBackground
Allows the background of selected cells in XmNselectedCells to be
specified.

XmNselectedCells
Points to an array of pointers to rows. Each row is an array of
Boolean values, one for each column in that row. This data structure
is the same as that for XmNcells, except each entry is a Boolean in-
stead of a String. A cell will be drawn as selected if the correspond-
ing Boolean is True. If XmNselectedCells is NULL, then no cells have
been selected. This resource is copied. It cannot be specified in a
resource file.

XmNselectedForeground
Allows the foreground of selected cells in XmNselectedCells to be
specified.

XmNshadowType
Specifies the type of shadow drawn around the border of the matrix.
Possible values for this resource are XmSHADOW_OUT, XmSHADOW_IN,
XmSHADOW_ETCHED_OUT, and XmSHADOW_ETCHED_IN. The default shadow type
is XmSHADOW_OUT.

XmNshowArrows
Specifies whether arrows should be drawn when data in a cell has been
obscured due to the value of XmNcolumnWidths.

XmNspace
Specifies the distance that separates the ScrollBars from the cell
grid. The default value is 4 pixels.

XmNtextBackground
Specifies the background of the XmText cell edit widget. This can be
used to make the XmText stand out against a uniformly colored matrix.

XmNtextBackgroundIsCell
Specifies if the background of the XmText cell edit widget defaults to
the core background of the matrix or the background of the cell being
edited when XmNtextBackground has the value XmUNSPECIFIED_PIXEL.

XmNtextField
The widget ID of the XmText. This resource cannot be set to a new
value.

XmNtextShadowThickness
Specifies the XmNshadowThickness of the XmText. Interesting effects
can be achieved by setting the XmNcellHighlightThickness to 0 and re-
placing the highlight with an indented shadow.

XmNtextTranslations
Specifies the XmNtranslations resource of the XmText cell edit widget.
See the description of XmNtranslations in XmText(3X).

XmNtopRow
Specifies the row which should be displayed at the top of the non-
fixed rows. XmNtopRow is specified relative to the first non-fixed
row, so (XmNfixedRows + XmNtopRow) is the actual row number which will
be moved to the top. If (XmNtopRow > (XmNrows - (<number of rows visi-
ble> + XmNfixedRows), then the actual row which will be moved to the
top is (XmNrows - (<number of rows visible> + XmNfixedRows).

XmNtrackCellCallback
specifies a list of callbacks to be called when the mouse pointer is
being moved.

XmNtrailingAttachedBottom
Indicated that any trailing fixed rows should be attached to the bot-
tom of the matrix. This resource only has effect when XmNfill is true
and XmNtrailingFixedRows is greater than zero.

XmNtrailingAttachedRight
Indicated that any trailing fixed columns should be attached to the
right of the matrix. This resource only has effect when XmNfill is
true and XmNtrailingFixedColumns is greater than zero.

XmNtrailingFixedColumns
Specifies the number of trailing columns (starting from the right col-
umn) which should not be horizontally scrollable. XmNtrailingFixed-
Columns must be less than XmNcolumns-XmNfixedColumns. Cells in trail-
ing fixed columns are not editable unless XmNtraverseFixedCells is set
to True.

XmNtrailingFixedRows
Specifies the number of trailing rows (starting from the bottom row)
which should not be vertically scrollable. XmNtrailingFixedRows must
be less than XmNrows-XmNfixedRows. Cells in trailing fixed rows are
not editable unless XmNtraverseFixedCells is set to True.

XmNtraverseCellCallback
Specifies a list of callbacks to be called before a new cell is
edited. These callbacks are called by the EditCell() action and when
XbaeMatrix receives or looses focus. A pointer to an XbaeMatrixTraver-
seCellCallbackStruct is passed to the callbacks. The application can
specify the next cell which should be edited via this callback list,
thereby performing custom traversal.

XmNtraverseFixedCells
If True, this resource allows fixed cells and columns to be edited.
The default is to not allow fixed rows or columns to be edited.

XmNuseXbaeInput
This boolean value determines whether to use XbaeInput or XmTextField
as the widget used for editing cells. Default is not to use XbaeIn-
put.

XmNvalueChangedCallback
Specifies a list of callbacks to be called after text is deleted from
or inserted into the XmText cell edit widget. A pointer to an XbaeMa-
trixValueChangedCallbackStruct is passed to the callbacks. See the de-
scription of the XmText(3X) XmNvalueChangedCallback resource.

XmNverticalScrollBar
The widget ID of the vertical XmScrollBar. This resource exists only
for those applications that need to tie another scrollbar to the ma-
trix's for synchronized scrolling. This resource can not be set to a
new value.

XmNverticalScrollBarDisplayPolicy
Determines when to display a horizontal scrollbar in the matrix. Pos-
sible values and their effects are listed under XmNhorizontalScroll-
BarDisplayPolicy.

XmNvisibleColumns
Specifies the number of non-fixed columns which should be visible. The
widget will request a size which will allow XmNvisibleColumns columns
to be displayed. The programmer should take into allowance any XmN-
fixedColumns that are specified. This feature becomes even more ap-
parent if the number of XmNfixedColumns changes at runtime as the
value may need to be adjusted to avoid a warning.

XmNvisibleRows
Specifies the number of rows which should be visible at any one time.
The widget will request a size which will allow XmNvisibleRows rows to
be displayed.

XmNwrapType
When XmNmultiLineCell is true this resource specifies how to break the
lines. When set to XbaeWrapNone, lines are broken on newlines only.
When set to XbaeWrapContinuous, long lines are further broken up so
they fit in their cell. When set to XbaeWrapWord the breaking of long
lines occures preferably on spaces.

XmNwriteCellCallback
Specifies a list of callbacks to be called when a cell value
changes and an XmNdrawCellCallback is defined. A pointer to an Xbae-
MatrixWriteCellCallbackStruct is passed to the callbacks. The XmN-
writeCellCallback allows data to be written back into the applica-
tion's data structure and must be defined for an editable XbaeMatrix
with an XmNdrawCellCallback.

XmNxmRowLabels
Points to an array of XmStrings to be drawn to the left of each row.
If XmNxmRowLabels is NULL, XmNrowLabels will be used. This resource is
copied.

XmNxmColumnLabels
Points to an array of XmStrings to be drawn above each column. If Xm-
NxmColumnLabels is NULL, XmNcolumnLabels will be used. This resource
is copied.

Inherited Resources
The following table lists the resources which XbaeMatrix inherits from it's
superclasses XmManager, Compositeand Core. For a complete description of
each resource, refer to the man page for that superclass. The codes in the
``Access'' column indicate whether the given resource can be set at cre-
ation time (C), or set by using XtSetValues (S), or retrieved by using
XtGetValues (G).

+---------------------------------------------------------------------------------------+
| XmManager Resource Set |
+----------------------+--------------------+----------------+-------------------+------+
| Name Class Type Default Access |
+----------------------+--------------------+----------------+-------------------+------+
| XmNbottomShadowColor XmCBottomShadowColor Pixel dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNbottomShadowPixmapXmCBottomShadowPixmapPixmap XmUNSPECIFIED_PIXMAPCSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNforeground XmCForeground Pixel dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNhighlightColor XmCHighlightColor Pixel dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNhighlightPixmap XmCHighlightPixmap Pixmap dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNinitialFocus XmCInitialFocus Widget NULL CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNnavigationType XmCNavigationType XmNavigationType XmTAB_GROUP CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNshadowThickness XmCShadowThickness Dimension dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNstringDirection XmCStringDirection XmStringDirectiondynamic CG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNtopShadowColor XmCTopShadowColor Pixel dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNtopShadowPixmap XmCTopShadowPixmap Pixmap dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNtraversalOn XmCTraversalOn Boolean True CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNunitType XmCUnitType unsigned char dynamic CSG |
+----------------------+--------------------+----------------+-------------------+------+
| XmNuserData XmCUserData XtPointer NULL CSG |
+----------------------+--------------------+----------------+-------------------+------+

+----------------------------------------------------------------------------------------------------+
| Core Resource Set |
+------------------------------+----------------------------+-------------+-------------------+------+
| Name Class Type Default Access |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNaccelerators XmCAccelerators XtAcceleratorsNULL CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNancestorSensitive XmCSensitive Boolean dynamic G |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNbackground XmCBackground Pixel dynamic CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNbackgroundPixmap XmCPixmap Pixmap XmUNSPECIFIED_PIXMAPCSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNborderColor XmCBorderColor Pixel XtDefaultForeground CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNborderPixmap XmCPixmap Pixmap XmUNSPECIFIED_PIXMAPCSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNborderWidth XmCBorderWidth Dimension 1 CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNcolormap XmCColormap Colormap dynamic CG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNdepth XmCDepth int dynamic CG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNdestroyCallback XmCCallback XtCallbackListNULL C |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNheight XmCHeight Dimension dynamic CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNinitialResourcesPersistentXmCInitialResourcesPersistentBoolean True C |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNmappedWhenManaged XmCMappedWhenManaged Boolean True CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNscreen XmCScreen Screen dynamic CG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNsensitive XmCSensitive Boolean True CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNtranslations XmCTranslations XtTranslationsdynamic CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNwidth XmCWidth Dimension dynamic CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNx XmCPosition Position 0 CSG |
+------------------------------+----------------------------+-------------+-------------------+------+
| XmNy XmCPosition Position 0 CSG |
+------------------------------+----------------------------+-------------+-------------------+------+

Callback Information
XbaeMatrixAnyCallbackStruct
A callback struct that is suitable for all callbacks that require the
reason, event, row and column to be available. Any callback called
may therefore cast the third parameter to the following struct in
XbaeMatrix and can rest assured that evrything in it will be avail-
able.

typedef struct
{
XbaeReasonType reason;
int row;
int column;
XEvent *event;
} XbaeMatrixAnyCallbackStruct;

Each of the members are set to the appropriate struct for the call-
back.

If this idea is a little foreign to you, recommended reading is K&R II
page 213.

XmNdefaultActionCallback
Callbacks on the XmNdefaultActionCallback list are called when the De-
faultAction() action occurs. The application can bind the DefaultAc-
tion() action to any pointer based event. When a double click occurs
on this pointer event, DefaultAction() will call the callbacks on the
XmNdefaultActionCallback list. A pointer to the following structure is
passed to each callback on the XmNdefaultActionCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
} XbaeMatrixDefaultActionCallbackStruct;

reason Set to XbaeDefaultActionReason .

event The event that invoked this callback.

row The row number of the cell in which the double click oc-
curred.

column The column number of the cell in which the double click oc-
curred.

event

If an application has an XmNdefaultActionCallback, then the callbacks
on the list will be called when the user clicks twice in a cell within
XmNdoubleClickInterval, enabling some action to occur for the particu-
lar cell.

XmNdrawCellCallback
Callbacks on the XmNdrawCellCallback list are called when the widget
needs to draw a cell. A pointer to the following structure is passed
to each callback on the XmNdrawCellCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
int width;
int height;
XbaeCellType type;
String string;
Pixmap pixmap;
Pixmap mask;
Pixel foreground;
Pixel background;
int depth;
} XbaeMatrixDrawCellCallbackStruct;

reason Set to XbaeDrawCellReason.

event Always set to NULL

row The row number of the cell that needs to be drawn.

column The column number of the cell that needs to be drawn.

width The width of the cell that needs to be drawn.

height The height of the cell that needs to be drawn.

type The type of ``data'' the programmer wants drawn in the cell,
or which field should be looked at for data to draw: string
or pixmap.

string The string to draw if type is set to XbaeString or
XbaeStringFree.

pixmap The pixmap to copy if type is set to XbaePixmap. It will be
clipped to width by height if necessary.

mask A mask for the pixmap as obtained from the XPM library.
mask is only necessary when pixmap has a depth greater than
one.

foregroundThe foreground color of the cell.

backgroundThe background color of the cell.

depth The depth of the pixmap image (in bits per pixel).

If the application adds this callback, when the XbaeMatrix determines
that a cell at (row, column) needs to be redrawn, the normal cell
drawing mechanism will be skipped and this callback called so the ap-
plication can tell the widget what to put in the cell.

The type field is defaulted to XbaeString and no cacheing or saving of
the string or pixmap is done.

If the application sets type to XbaePixmap, the width, height and
depth of the returned pixmap will be calculated with a call to XGetGe-
ometry(). If the programmer wishes to supply the width, height and
depth there is a marked improvement as a round trip to the X server is
avoided. Note that all geometry parameters must be supplied to ensure
successful display of the pixmap.

If a mask is also provided, it will be used to display the pixmap
transparently. Pixmaps drawn in cells also respect the value of XmN-
columnAlignments.

By defining an XmNdrawCellCallback the need for the storage of the
XbaeMatrix data within the matrix is eliminated and can prove to be
advantageous for memory usage.

To write the data back to the application, use the XmNwriteCellCall-
back described below.

XmNenterCellCallback
Callbacks on the XmNenterCellCallback list are called from the Edit-
Cell() action just before a cell is edited to determine it's editabil-
ity. A pointer to the following structure is passed to each callback
on the XmNenterCellCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
int position;
String pattern;
Boolean auto_fill;
Boolean convert_case;
Boolean overwrite_mode;
Boolean select_text;
Boolean map;
Cardinal num_params;
String *params;
Boolean doit;
} XbaeMatrixEnterCellCallbackStruct;

reason Set to XbaeEnterCellReason.

event The event that invoked the callback.

row The row number of the cell about to be edited.

column The column number of the cell about to be edited.

position The location of the cursor in the text field. The default
is to place the cursor at the end of the string in the cell.

pattern A pattern for the XbaeInput widget (see XbaeInput(3)). The
default is to not specify a pattern.

auto_fill Used in conjunction with the setting of the pattern to allow
literals in the pattern to be automatically inserted.

convert_case
If the pattern specifies an upper or lower case letter, the
character typed in the position can automatically be con-
verted to the appropriate case when set to True. The de-
fault is to not convert the case of the typed letter.

overwrite_mode
Normally, the cursor appears as the familiar I caret. By
setting overwrite_mode to True, the text field will go into
overwrite mode where keystrokes replace the character under-
neath the block cursor.

select_text
Indicates whether the text in the cell should be highlighted
(only valid if doit is set to True also.

map Tells the matrix if the XmText should be mapped onto the
cell. Only makes sense if doit is set to False.

num_paramsThe number of String parameters passed to the EditCell() ac-
tion.

params An array containing the num_params String parameters passed
to the EditCell() action.

doit Indicates whether or not this cell is editable. Setting doit
to False will make this cell not editable. The default value
is True.

If the application determines that the cell at (row, column) is not
editable, it should set the doit flag to False. If the map flag is
also set to False, XbaeMatrix will not place the XmText cell editor on
the cell. If map is left as True, the XmText will be placed on the
cell but the user will not be able to add or delete characters from
it. If the application leaves doit as True, then the TextField will be
editable. In addition, if select_text is set to True, the text in the
cell will be selected via XmTextSetSelection. Assuming XmNpend-
ingDelete for the XmText is also True, the selected text will be
deleted as soon as the next text insertion occurs.

XmNlabelActivateCallback
Callbacks on the XmNlabelActivateCallback list are called after a but-
ton label has been activated via a mouse click. A pointer to the fol-
lowing structure is passed to each callback on the XmNlabelActivate-
Callback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
Boolean row_label;
String label;
} XbaeMatrixLabelActivateCallbackStruct;

reason Set to XbaeLabelActivateReason.

event The event that invoked this callback.

row The row number of the button label or -1 if the button was a
column label.

column The column number of the button label or -1 if the button
was a row label.

row_label If the button label that invoked the callback is a row la-
bel, then this value is set to True. If it was a column la-
bel then it is set to False.

label The label on the button that was pressed.

When the XbaeMatrix receives a ButtonRelease event on the same button
label that it received a ButtonPress event, the XmNlabelActivateCall-
back is called to allow the programmer to respond to the event. The
callback has been provided to emulate some popular spreadsheets on the
market.

XmNleaveCellCallback
Callbacks on the XmNleaveCellCallback list are called from the Edit-
Cell() and CommitEdit() actions just before the edit to the current
cell is committed. The application can validate the changes made to
the cell, and allow or disallow them. A pointer to the following
structure is passed to each callback on the XmNleaveCellCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row, column;
String value;
Boolean doit;
} XbaeMatrixLeaveCellCallbackStruct;

reason Set to XbaeLeaveCellReason.

event The event that invoked this callback.

row The row number of the cell being edited.

column The column number of the cell being edited.

value Contains the new data which will be stored in this cell if
doit is True. The memory pointed to by value may be modi-
fied, or if the new contents are larger than the current
contents, then value should be set to point to a larger
piece of allocated memory.

doit Indicates whether the edits applied to this cell should ac-
tually be stored into XbaeMatrix. Setting doit to False
will cause the changes to be discarded and the cell will re-
tain its original value. The default value is True.

If the application determines that the value entered in the cell at
(row, column) is not valid, it should set the doit flag to False. This
will prevent the changes from being stored in the cell. The TextField
edit widget will remain on the current cell. If the application leaves
doit as True, then the changes made to the cell will be committed and
the TextField will move to the next cell or be unmapped. The applica-
tion can also modify the String in value, e.g. to force a String to be
all upper case.

XmNmodifyVerifyCallback
Callbacks on the XmNmodifyVerifyCallback list are called while a cell
is being edited. The callbacks are called before text is inserted into
or deleted from the TextField edit widget. A pointer to the following
structure is passed to each callback on the XmNmodifyVerifyCallback
list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
XmTextVerifyCallbackStruct *verify;
const char *prev_text;
} XbaeMatrixModifyVerifyCallbackStruct;

reason Set to XbaeModifyVerifyReason.

event Always set to NULL.

row The row number of the cell being edited.

column The column number of the cell being edited.

verify The contents of this structure and its use are documented in
the XmText(3X) man page.

prev_text The contents of the cell as seen by this user before the new
text. If other text has already been entered, this value
will not match the official XbaeMatrix value of the cell.
This pointer and the string should not be modified.

XmNprocessDragCallback
Callbacks on the XmNprocessDragCallback list are called from the
ProcessDrag() action. The application can bind the ProcessDrag() ac-
tion to any pointer based event, though by default it is bound to the
Button2Down event. When this event occurs, ProcessDrag() will call
the callbacks on the XmNprocessDragCallback list. A pointer to the
following structure is passed to each callback on the XmNprocessDrag-
Callback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
String string;
XbaeCellType type;
Pixmap pixmap;
Pixmap mask;
Cardinal num_params;
String *params;
} XbaeMatrixProcessDragCallbackStruct;

reason Set to XbaeProcessDragReason.

event The XEvent which invoked the ProcessDrag() action.

row The row number of the cell where the drag was initiated..

column The column number of the cell where the drag was initiated..

string The string in the cell where the drag was initiated if type
is XbaeString or XbaeStringFree. This is provided as a con-
venience to the application.

type The type of the cell in which the drag was initiated.

pixmap The pixmap in the cell where the drag was initiated if type
is XbaePixmap. This is provided as a convenience to the ap-
plication.

mask A mask for the pixmap as obtained from the XPM library.
mask is only necessary when pixmap has a depth greater than
one. Also provided as a convenience to the application.

num_paramsThe number of String parameters passed to the ProcessDrag()
action.

params An array containing the num_params String parameters passed
to the ProcessDrag() action.

The application can use the XmNprocessDragCallback list to implement
particular processing for Motif's drag-and-drop.

XmNresizeCallback
Callbacks on the XmNresizeCallback list are called when the XbaeMatrix
widget is resized. A pointer to the following structure is passed to
each callback on the XmNresizeCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
Dimension width;
Dimension height;
} XbaeMatrixResizeCallbackStruct;

reason Set to XbaeResizeReason.

event Always set to NULL

row Set to the number of rows in the matrix (provided for conve-
nience).

column Set to the number of colums in the matrix (provided for con-
venience).

width The new width of the XbaeMatrix widget.

height The new height of the XbaeMatrix widget.

The application can use the XmNresizeCallback to adjust such resources
as XmNcolumnWidths, XmNvisibleColumns and XmNvisibleRows when the wid-
get containing an XbaeMatrix widget is resized.

XmNresizeColumnCallback
Callbacks on the XmNresizeColumnCallback list are called when a column
of the XbaeMatrix widget is dynamically resized by the user. A
pointer to the following structure is passed to each callback on the
XmNresizeColumnCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
int which;
int columns;
short *column_widths;
} XbaeMatrixResizeColumnCallbackStruct;

reason Set to XbaeResizeColumnReason.

event The XEvent that ended the resize. The event will be of type
XButtonReleasedEvent.

row The row in which the ResizeColumn() action began.

column The column in which the ResizeColumn() action began (and
ended).

which The column that was resized in the ResizeColumn() action.

columns The number of columns in the XbaeMatrix widget.

column_widths
The widths of each column as they stand after the ResizeCol-
umn() action.

The application can use the XmNresizeColumnCallback to perform post
processing after a column has been resized. By adjusting the values
contained in column_widths the XbaeMatrix widget will use the values
upon return from the callback. Changing the number of columns in the
matrix in the XmNresizeColumnCallback should be used carefully as it
may cause unexpected results.

XmNselectCellCallback
Callbacks on the XmNselectCellCallback list are called from the Se-
lectCell() action. The application can bind the SelectCell() action to
any pointer based event. When this event occurs, SelectCell() will
call the callbacks on the XmNselectCellCallback list. A pointer to the
following structure is passed to each callback on the XmNselectCell-
Callback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
Boolean **selected_cells;
String **cells;
Cardinal num_params;
String *params;
} XbaeMatrixSelectCellCallbackStruct;

reason Set to XbaeSelectCellReason.

event The XEvent which invoked the SelectCell() action.

row The row number of the cell which was selected.

column The column number of the cell which was selected.

selected_cells
The value of the XmNselectedCells resource. This is provided
as a convenience to the application and will be NULL if no
cells have yet been selected.

cells The value of the XmNcells resource. This is provided as a
convenience to the application and will be NULL if no cells
have been specified or the XmNdrawCellCallback is being
used.

num_paramsThe number of String parameters passed to the SelectCell()
action.

params An array containing the num_params String parameters passed
to the SelectCell() action.

The application can use the XmNselectCellCallback list to implement
it's own selection model. The XbaeMatrixSelectCellCallbackStruct con-
tains the array of String parameters passed to the SelectCell() action
which invoked this callback. By binding the SelectCell() action to
various events via the translation manager, and using String action
parameters to distinguish them, the application can implement various
selection models. For example, the following translations could be
used to implement a model in which a modifier key indicates whether a
single cell or an entire row should be selected. The callbacks on the
XmNselectCellCallback list would examine the parameter and take the
appropriate action.

#override\n\
Shift<Btn1Down>: SelectCell(cell)\n\
Ctrl<Btn1Down>: SelectCell(row)

The callbacks on the XmNselectCellCallback list can also be used in
other ways, e.g. to pop up a cell specific menu.

NOTE: If no cells have been selected, the value of selected_cells will
be NULL. The same applies for cells. Care must be taken so as not to
dereference these members of the callback struct.

XmNtrackCellCallback
Callbacks on the XmNtrackCellCallback list are being called by the
HandleTracking() action, which is triggered by pointer motion. One of
the purposes of this callback list is to figure out from which cell to
which cell the pointer is being moved. A pointer to the XbaeMatrix-
TrackCellCallbackStruct structure is being passed. Its fields are de-
fined as :

typedef struct _XbaeMatrixTrackCellCallbackStruct
{
XbaeReasonType reason;
XEvent *event;
int row, column;
int prev_row, prev_column;
Position pointer_x, pointer_y;
} XbaeMatrixTrackCellCallbackStruct;

reason Set to XbaeSelectCellReason.

event The XEvent which invoked the HandleTracking() action.

row This is the row number that the pointer is currently in.

column This is the column number that the pointer is currently in.

prev_row The row that the pointer was previously in.

prev_column
The column that the pointer was previously in.

pointer_x The x position of the pointer.

pointer_y The y position of the pointer.

XmNtraverseCellCallback
Callbacks on the XmNtraverseCellCallback list are called from the Ed-
itCell() action and when XbaeMatrix receives or looses focus. The ap-
plication can customize cell traversal using these callbacks. XbaeMa-
trix has a default traversal order, outlined below, which the applica-
tion can override. A pointer to the following structure is passed to
each callback on the XmNtraverseCellCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
int next_row;
int next_column;
int fixed_rows;
int fixed_columns;
int trailing_fixed_rows;
int trailing_fixed_columns;
int num_rows;
int num_columns;
String param;
XrmQuark qparam;
} XbaeMatrixTraverseCellCallbackStruct;

reason Set to XbaeTraverseCellReason.

event The event that invoked this callback.

row The row number of the cell currently being edited.

column The column number of the cell currently being edited.

next_row The row number of the next cell to be edited, this can be
changed by the application.

next_column
The column number of the next cell to be edited, this can be
changed by the application.

fixed_rowsThe value of the XmNfixedRows resource. This is provided as
a convenience for the application in calculating the
next_row and next_column fields.

fixed_columns
The value of the XmNfixedColumns resource. This is provided
as a convenience for the application in calculating the
next_row and next_column fields.

trailing_fixed_rows
The value of the XmNtrailingFixedRows resource. This is pro-
vided as a convenience for the application in calculating
the next_row and next_column fields.

trailing_fixed_columns
The value of the XmNtrailingFixedColumns resource. This is
provided as a convenience for the application in calculating
the next_row and next_column fields.

num_rows The value of the XmNrows resource. This is provided as a
convenience for the application in calculating the next_row
and next_column fields.

num_columns
The value of the XmNcolumns resource. This is provided as a
convenience for the application in calculating the next_row
and next_column fields.

param The String value of the parameter passed to the EditCell()
action.

qparam The XrmQuark value of the parameter passed to the EditCell()
action.

The EditCell() action takes an arbitrary parameter which it passes
through to the callbacks on the XmNtraverseCellCallback list in both
String and XrmQuark forms. The EditCell() action recognizes five spe-
cial parameters which it uses to implement it's default cell traver-
sal. These parameters and their corresponding traversal results are:

Pointer Set next_row and next_column to the cell underneath the
mouse pointer.

Left If we are currently editing cell (XmNfixedRows, XmNfixed-
Columns), then do not move. Otherwise move one column to the
left, if that column is less than XmNfixedColumns , then
move up to the last column of the row above.

Right If we are currently editing cell (XmNrows - 1, XmNcolumns -
1), then do not move. Otherwise move one column to the
right, if that column is greater than or equal to XmNcolumns
, then move down to column XmNfixedColumns of the row below.

Up Move up one row. If that row is less than XmNfixedRows ,
then move to the last row.

Down Move down one row. If that row is greater than or equal to
XmNrows , then move to row XmNfixedRows.

If the EditCell() action recognizes one of these special parameters,
it calculates the new cell to be edited accordingly and stores the re-
sults in the next_row and next_column fields of the XbaeMatrixTraver-
seCellCallbackStruct. If EditCell() does not recognize it's parame-
ter, it sets next_row and next_column to the current row and column.
It also stores a String and XrmQuark version of it's parameter in the
param and qparam fields. EditCell() then calls the callbacks on the
XmNtraverseCellCallback list. These callbacks can examine the parame-
ter and recalculate the next_row and next_column fields appropriately.
The application can override the default calculation for the special
parameters, or it can define an entirely new parameter with a corre-
sponding new calculation. It would do this by binding EditCell() with
a new application specific parameter to an event in a translation ta-
ble. It is expected that application callbacks will use the XrmQuark
version of the parameter for efficiency reasons (by statically creat-
ing the new XrmQuarks and comparing them against the incoming qparam).

When XbaeMatrix receives the focus it will also call the XmNtraverse-
CellCallback callbacks before returning to the current cell or the up-
per left most visible cell if no cell is currently edited. The XbaeMa-
trixTraverseCellCallbackStruct will have param and qparm set to Focus.
If there is no current cell row and column will be set to -1.

When XbaeMatrix looses the focus it will also call the XmNtraverse-
CellCallback with param and qparm set to LoosingFocus.

XmNvalueChangedCallback
Callbacks on the XmNvalueChangedCallback list are called while a cell
is being edited. The callbacks are called after text is inserted into
or deleted from the TextField edit widget. A pointer to the following
structure is passed to each callback on the XmNvalueChangedCallback
list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
} XbaeMatrixValueChangedCallbackStruct;

reason Set to XbaeValueChangedReason.

event The event that triggered this callback.

row The row number of the cell being edited.

column The column number of the cell being edited.

XmNwriteCellCallback
Callbacks (although it probably only makes sense to have one) on the
XmNwriteCellCallback list are called when the widget needs to write
data to a cell, but only when XmNdrawCellCallback is defined. A
pointer to the following structure is passed to each callback on the
XmNwriteCellCallback list:

typedef struct
{
XbaeReasonType reason;
XEvent *event;
int row;
int column;
XbaeCellType type;
String string;
Pixmap pixmap;
Pixmap mask;
} XbaeMatrixWriteCellCallbackStruct;

reason Set to XbaeWriteCellReason.

event Always set to NULL

row The row number of the cell that needs to be written.

column The column number of the cell that needs to be written.

type The type of ``data'' contained in the cell, either
XbaeString or XbaePixmap.

string The string to store if type is set to XbaeString.

pixmap The pixmap to store if type is set to XbaePixmap. (maybe a
little meaningless unless you can edit a pixmap in a cell)

mask A mask for the pixmap as obtained from the XPM library.
mask is only necessary when pixmap has a depth greater than
one.

If the application adds this callback, when the XbaeMatrix is editable
and has been assigned an XmNdrawCellCallback, data on the widget can
be edited and stored back in the application's data structure. Only
if an XmNdrawCellCallback has been assigned to the XbaeMatrix widget,
will the XmNwriteCellCallback be called.

At the moment, pixmap and mask will be sent to the XmNwriteCellCall-
back as NULL.

Translations
XbaeMatrix inherits translations from XmManager. In addition, XbaeMatrix
uses the following translation:
:<Btn1Up>: DefaultAction()\n\
:<Btn1Down>: DefaultAction() EditCell(Pointer)\n\
:Shift<Btn2Down>: ResizeColumns()\n\
:<Btn2Down>: ProcessDrag()\n\
:<Btn1Motion>: HandleMotion() HandleTracking()()\n\
:<Motion>: HandleTracking()()\n\
:<Btn4Down>: ScrollRows(-50)()\n\
:<Btn5Down>: ScrollRows( 50)()

XbaeMatrix installs the following default XmNtextTranslations on the
TextField edit widget:
#override\n\
Shift ~Ctrl ~Meta ~Alt <Key>Tab: EditCell(Left)\n\
~Ctrl ~Meta ~Alt <Key>Tab: EditCell(Right)\n\
<Key>osfUp: EditCell(Up)\n\
<Key>osfDown: EditCell(Down)\n\
<Key>osfActivate: CommitEdit(False)\n\
~Shift ~Meta ~Alt <Key>Return: CommitEdit(False)\n\
<Key>osfCancel: CommitEdit(False)\n\
Shift Ctrl ~Meta ~Alt <Key>Tab: TraversePrev()\n\
Ctrl ~Meta ~Alt <Key>Tab: TraverseNext()\n\
<Key>osfPageDown: PageDown()\n\
<Key>osfPageUp: PageUp()\n

Action Routines
CancelEdit()
If the single parameter to CancelEdit() is the String True, then it
unmaps the edit TextField, discarding any changes which were made to
the cell being edited. If the parameter is False, then CancelEdit()
restores the edit TextField to the original contents of the cell,
discarding any changes made to the cell being edited. The TextField
is not unmapped.

CommitEdit()
CommitEdit() first calls any callbacks on the XmNleaveCellCallback
list to determine if the changes made to the current cell are valid.
If they are, it then saves any changes made to the cell into the
cell. If the callbacks on the XmNleaveCellCallback list return that
the changes are not valid, CommitEdit() does nothing.

If the changes are valid, CommitEdit() examines it's one parameter,
which must be the string True or False. If the parameter is True,
then the edit TextField is unmapped. If it is False, then the
TextField is not unmapped.

DefaultAction()
DefaultAction() sets up a mechanism for determining whether two suc-
cessive mouse clicks form a double click. The DefaultAction()
should normally be used in conjunction with other pointer based
events and provides a mechanism for acting on double clicks in a
cell.

EditCell()
EditCell() edits a new cell. EditCell() first calculates the new
cell to edit based on it's single parameter. It then calls the call-
backs on the XmNtraverseCellCallback list to allow them to specify a
different cell to edit (see the discussion of XmNtraverseCellCall-
back above). EditCell() then calls the callbacks on the XmNleave-
CellCallback list to determine if the changes made to the current
cell are valid. If they are, it then saves any changes made to the
cell into the cell. If the changes are not valid, EditCell() does
nothing further.

If the changes are valid, EditCell() attempts to scroll the new cell
to be edited so that it is fully visible. If the new cell is in a
fixed row or column, EditCell() returns and does nothing further
(these cells are not editable). Otherwise, EditCell() calls the
callbacks on the XmNenterCellCallback list to determine if the new
cell is editable. It then moves the XmText edit widget to the new
cell, setting it's editability based on the return from the XmNen-
terCellCallback callbacks.

ProcessDrag()
ProcessDrag() calls the callbacks on the XmNprocessDragCallback
list, passing them a pointer to a XbaeMatrixProcessDragCallback-
Struct.

ResizeColumns()
Allows the user to dynamically resize the column widths, provided
that XmNallowColumnResize is True.

ScrollRows()
ScrollRows() makes the rows of the matrix scroll by the pixel amount
specified by it's argument.

ScrollColumns()
ScrollColumns() makes the columns of the matrix scroll by the pixel
amount specified by it's argument.

SelectCell()
SelectCell() calls the callbacks on the XmNselectCellCallback list,
passing them a pointer to a XbaeMatrixSelectCellCallbackStruct.
This structure will contain the String parameters passed to the Se-
lectCell() action, among other things (see the discussion of XmNse-
lectCellCallback above).

TraverseNext()
TraverseNext() will traverse out of the Matrix and into the next tab
group.

TraversePrev()
TraversePrev() will traverse out of the Matrix and into the previous
tab group.

PageDown()
PageDown() causes the Matrix to scroll down a full page. The text
widget is placed on the first non fixed row of the new page.

PageUp()
PageUp() causes the Matrix to scroll up a full page. The text wid-
get is placed on the first non fixed row of the new page.

Type Converters
In addition to the standard type converters registered by Xt and Motif,
XbaeMatrix registers the following additional type converters:

CvtStringToStringArray()
Converts a comma separated list of Strings to an array of String
pointers, one for each substring. Commas in the list may be escaped
with the character `\'. This converter allows the XmNrowLabels and
XmNcolumnLabels resources to be specified in resource files.

CvtStringToWidthArray()
Converts a comma separated list of numeric Strings to an array of
short integers. This converter allows the XmNcolumnWidths resource
to be specified in resource files.

CvtStringToMaxLengthArray()
Converts a comma separated list of numeric Strings to an array of
integers. This converter allows the XmNcolumnMaxLengths resource to
be specified in resource files.

CvtStringToAlignmentArray()
Converts a comma separated list of alignments to an array of un-
signed chars. This converter allows the XmNcolumnLabelAlignments and
XmNcolumnAlignments resources to be specified in resource files.

CvtStringToGridType()
Converts a single string as discussed in XmNgridType to a grid type
value. This converter allows XmNgridType to be specified in re-
source files.

CvtStringToMatrixScrollBarDisplayPolicy()
Converts a single string as discussed in XmNhorizontalScrollBarDis-
playPolicy and XmNverticalScrollBarDisplayPolicy to a display policy
value. This converter allows XmNhorizontalScrollBarDisplayPolicy
and XmNverticalScrollBarDisplayPolicy to be specified in resource
files.

CvtStringToCellTable()
Converts a comma separated list of Strings with \n delimited rows to
a two dimensional array of String pointers. This converter allows
the XmNcells resource to be specified in resource files.

CvtStringToPixelTable()
Converts a comma separated list of color names with \n delimited
rows to a two dimensional array of Pixel values. This converter al-
lows the XmNcellBackgroundsandXmNcolors resources to be specified in
resource files.

CvtStringToBooleanArray()
Converts a comma separated list of string or numeric values to an
array of Booleans. The converter recongnises a comma separated list
of values. Each value is parsed such that if the first character is
This converter allows the XmNcolumnButtonLabels and XmNrowButtonLa-
bels resources to be specified in resource files.

Public Functions
The following external entry points to XbaeMatrix class methods are de-
fined:

XbaeCreateMatrix()

Widget XbaeCreateMatrix()
Widget parent;
String name;
ArgList arglist;
Cardinal argcount;

parent Specifies the parent widget ID.

name Specifies the name of the created widget

arglist Specifies the argument list

argcount Specifies the number of attribute/value pairs in the argu-
ment list (arglist)

XbaeCreateMatrix() creates an unmanaged instance of an XbaeMatrix
widget and returns the associated widget ID.

XbaeMatrixAddColumns()

void XbaeMatrixAddColumns()
Widget w;
int position;
String *columns;
String *labels;
short *widths;
int *max_lengths;
unsigned char *alignments;
unsigned char *label_alignments;
Pixel *colors;
int num_columns;

w An XbaeMatrix widget.

position The column position before which to add the new columns.
Must be greater than or equal to zero, and less than or
equal to XmNcolumns.

columns Points to an ordinary two dimensional array of String, or
NULL. These Strings will be used to modify the XmNcells
resource to populate the new columns. Each row in the ar-
ray must have XmNrows elements and represents one of the
new columns. columns must have num_columns rows. If
columns is NULL, empty columns will be added.

labels Points to an array of String, or NULL. These Strings will
be used as the XmNcolumnLabels for the new columns. The
labels array must have num_columns elements. If labels is
NULL, and XmNcolumnLabels is set, then blank column labels
will be used.

widths Points to an array of short or NULL. These values will be
used as the XmNcolumnWidths for the new columns. The
widths array must have num_columns elements. if widths is
NULL then a default width will be used for the new
columns.

max_lengths
Points to an array of int, or NULL. These values will be
used as the XmNcolumnMaxLengths for the new columns. The
max_lengths array must have num_columns elements. If
max_lengths is NULL, then the corresponding value from
widths will be used.

alignmentsPoints to an array of unsigned char, or NULL. These val-
ues will be used as the XmNcolumnAlignments for the new
columns. The alignments array must have num_columns ele-
ments. If alignments is NULL, then XmALIGNMENT_BEGINNING
will be used.

label_alignments
Points to an array of unsigned char, or NULL. These val-
ues will be used as the XmNcolumnLabelAlignments for the
new column labels. The label_alignments array must have
num_columns elements. If label_alignments is NULL, then
XmALIGNMENT_BEGINNING will be used.

colors Points to an array of Pixel, or NULL. These values will
be used to set the corresponding columns in the XmNcolors
table for the new columns. The colors array must have
num_columns elements. If colors is NULL, then XmNfore-
ground will be used.

num_columns
The number of columns which are being added to the widget.

XbaeMatrixAddColumns() allows the application developer to dynami-
cally add new columns anywhere in the Matrix. The columns will be
added before the column specified in position. Columns are numbered
starting at zero. To append new columns onto the end of the Matrix,
specify position as the total number of columns. Most of the argu-
ments to XbaeMatrixAddColumns() may be specified as NULL. Default
values will be used by the widget.

If the programmer attempts to add columns using XbaeMatrixAdd-
Columns() when there are no rows, it will result in a warning mes-
sage. There must be at least one row in the XbaeMatrix widget to
add columns.

To maintain backward compatability, the cell backgrounds cannot be
set in a call to XbaeMatrixAddColumns() and must be set (if so de-
sired) in a separate call to XtVaSetValues().

XbaeMatrixAddRows()

void XbaeMatrixAddRows()
Widget w;
int position;
String *rows;
String *labels;
Pixel *colors;
int num_rows;

w An XbaeMatrix widget.

position The row position before which to add the new rows. Must be
greater than or equal to zero, and less than or equal to
XmNrows.

rows Points to an ordinary two dimensional array of String, or
NULL. These Strings will be used to modify the XmNcells
resource to populate the new rows. Each row in the array
must have XmNcolumns elements and represents one of the
new rows. rows must have num_rows rows. If rows is NULL,
empty rows will be added.

labels Points to an array of String, or NULL. These Strings will
be used as the XmNrowLabels for the new rows. The labels
array must have num_rows elements. If labels is NULL, and
XmNrowLabels is set, then blank row labels will be used

colors Points to an array of Pixel, or NULL. These values will
be used to set the corresponding rows in the XmNcolors ta-
ble for the new rows. The colors array must have num_rows
elements. If colors is NULL, then XmNforeground will be
used.

num_rows The number of rows which are being added to the widget.

XbaeMatrixAddRows() allows the application developer to dynamically
add new rows anywhere in the Matrix. The rows will be added before
the row specified in position. Rows are numbered starting at zero.
To append new rows onto the end of the Matrix, specify position as
the total number of rows.

To maintain backward compatability, the cell backgrounds cannot be
set in a call to XbaeMatrixAddRows() and must be set (if so desired)
in a separate call to XtVaSetValues().

XbaeMatrixCancelEdit()

void XbaeMatrixCancelEdit()
Widget w;
Boolean unmap;

w An XbaeMatrix widget.

unmap Specifies whether the TextField cell edit widget should be
unmapped after the edit is canceled.

XbaeMatrixCancelEdit() allows the application developer to program-
matically cancel a cell edit in progress, discarding any changes
made by the user. This function unmaps the TextField edit widget if
the unmap flag is True. If unmap is False, the contents of the
TextField are restored to their original value, and the TextField is
not unmapped.

XbaeMatrixCommitEdit()

Boolean XbaeMatrixCommitEdit()
Widget w;
Boolean unmap;

w An XbaeMatrix widget.

unmap Specifies whether the TextField cell edit widget should be
unmapped after an edit is successfully committed.

XbaeMatrixCommitEdit() can be used by the application developer to
programmatically commit an edit, saving any changes made by the
user. This will cause the callbacks on the XmNleaveCellCallback
list to be called to verify that the changes the user made are
valid. If the changes are valid, then they are saved into the cell
and if the unmap flag is True, the TextField widget will be un-
mapped.

XbaeMatrixDeleteColumns()

void XbaeMatrixDeleteColumns()
Widget w;
int position;
int num_columns;

w An XbaeMatrix widget.

position The column position at which to begin deleting columns.
Must be greater than or equal to zero, and (position +
num_columns) must be less than or equal to XmNcolumns.

num_columns
The number of columns to delete from the widget.

XbaeMatrixDeleteColumns() allows the application developer to dynam-
ically delete columns from anywhere in the Matrix. Columns will be
deleted starting at the column specified by position.

XbaeMatrixDeleteRows()

void XbaeMatrixDeleteRows()
Widget w;
int position;
int num_rows;

w An XbaeMatrix widget.

position The row position at which to begin deleting rows. Must be
greater than or equal to zero, and (position + num_rows)
must be less than or equal to XmNrows.

num_rows The number of rows to delete from the widget.

XbaeMatrixDeleteRows() allows the application developer to dynami-
cally delete rows from anywhere in the Matrix. Rows will be deleted
starting at the row specified by position.

XbaeMatrixDeselectAll()

void XbaeMatrixDeselectAll()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixDeselectAll() allows the application developer to program-
matically deselect all cells. XbaeMatrixDeselectAll() redraws the
cells in normal video. All Booleans in the XmNselectedCells array
will be set to False.

XbaeMatrixDeselectCell()

void XbaeMatrixDeselectCell()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to deselect.

column The column of the cell to deselect.

XbaeMatrixDeselectCell() allows the application developer to pro-
grammatically deselect a cell. XbaeMatrixDeselectCell() redraws the
cell in normal video. The corresponding Boolean in the XmNselected-
Cells array will be set to False.

XbaeMatrixDeselectColumn()

void XbaeMatrixDeselectColumn()
Widget w;
int column;

w An XbaeMatrix widget.

column The column to deselect.

XbaeMatrixDeselectColumn() allows the application developer to pro-
grammatically deselect a column. XbaeMatrixDeselectColumn() draws
the column in normal video. The corresponding Booleans in the XmNse-
lectedCells array will be set to False.

XbaeMatrixDeselectRow()

void XbaeMatrixDeselectRow()
Widget w;
int row;

w An XbaeMatrix widget.

row The row to deselect.

XbaeMatrixDeselectRow() allows the application developer to program-
matically deselect a row. XbaeMatrixDeselectRow() draws the row in
reverse video (or selectedForeground / selectedBackground if set).
The corresponding Booleans in the XmNselectedCells array will be set
to False.

XbaeMatrixDisableRedisplay()

int XbaeMatrixDisableRedisplay()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixDisableRedisplay() and XbaeMatrixEnableRedisplay() allow
an application to make multiple changes to a matrix without immedi-
ate visual updates. When multiple changes are made with redisplay
enabled, visual flashing often occurs. These routines help elimi-
nate this problem.

XbaeMatrixEditCell()

void XbaeMatrixEditCell()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to be edited.

column The column of the cell to be edited.

XbaeMatrixEditCell()

allows the application developer to programmatically force a spe-
cific cell to be edited. This function will first attempt to commit
the edit in the current cell. If the XmNleaveCellCallback callbacks
disallow this commit, then XbaeMatrixEditCell() will return. Other-
wise the specified cell is scrolled until it is visible. If the
specified cell is in a fixed row or column, it cannot be edited and
XbaeMatrixEditCell() will return. Next, the callbacks on the XmNen-
terCellCallback callback list are called for the specified cell to
determine it's editability. Then the TextField edit widget is mapped
on top of the specified cell.

XbaeMatrixEnableRedisplay()

int XbaeMatrixEnableRedisplay()
Widget w;
Boolean redisplay;

w An XbaeMatrix widget.

redisplay Force the matrix to redisplay if True and no other calls
to XbaeMatrixDisableRedisplay() have been made.

XbaeMatrixEventToXY()

Boolean XbaeMatrixEventToXY()
Widget w;
XEvent *event;
int *x;
int *y;

w An XbaeMatrix widget.

event An X event structure pointer, usually from an XEven-
tHandler function.

x The translated x coordinate.

y The translated y coordinate.

XbaeMatrixEventToXY enables the programmer to determine the x and y
values of a given event with respect to the XbaeMatrix widget. The
returned values are also adjusted to allow for the XbaeClip widget.

XbaeMatrixFirstSelectedCell()

void XbaeMatrixFirstSelectedCell()
Widget w;
int *row;
int *column;

w An XbaeMatrix widget.

row The first selected row.

column The first selected column.

XbaeMatrixFirstSelectedCell() allows the application developer to
find out which cell is the first selected. The function traverses
the XbaeMatrix widget in a left to right, top to bottom manner to
determine this value. If no cell is selected, row and column are
set to -1.

XbaeMatrixFirstSelectedColumn()

int XbaeMatrixFirstSelectedColumn()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixFirstSelectedColumn() returns the column number of the
first selected column in the XbaeMatrix widget. The function tra-
verses the matrix from column 0. A column must be entirely selected
for the column to be considered selected. If no column is selected
then -1 is returned.

XbaeMatrixFirstSelectedRow()

int XbaeMatrixFirstSelectedRow()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixFirstSelectedRow() returns the row number of the first se-
lected row in the XbaeMatrix widget. The function traverses the ma-
trix from row 0. A row must be entirely selected for the row to be
considered selected. If no row is selected then -1 is returned.

XbaeMatrixGetCell()

String XbaeMatrixGetCell()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell whose value should be retrieved.

column The column of the cell whose value should be retrieved.

XbaeMatrixGetCell() returns the String value stored in the specified
cell. This String should not be freed. To examine many cells, it is
more efficient to do an XtGetValues() on XmNcells and examine the
values in that array.

XbaeMatrixGetCellBackground()

Pixel XbaeMatrixGetCellBackground()
Widget w;
int row;
int column;

w A XbaeMatrix widget.

row The row of the cell whose background color should be re-
trieved.

column The column of the cell whose background color should be
retrieved.

XbaeMatrixGetCellColor()

Pixel XbaeMatrixGetCellColor()
Widget w;
int row;
int column;

w A XbaeMatrix widget.

row The row of the cell whose foreground color should be re-
trieved.

column The column of the cell whose foreground color should be
retrieved.

XbaeMatrixGetCellPixmap()

int XbaeMatrixGetCellPixmap()
Widget w;
int row;
int column;
Pixmap *pixmap;
Pixmap *mask;

w A XbaeMatrix widget.

row The row of the cell whose pixmap and mask should be re-
trieved.

column The column of the cell whose pixmap and mask should be re-
trieved.

pixmap A pointer to a Pixmap variable, in which the function will
store the cell's pixmap.

mask A pointer to a Pixmap variable, in which the function will
store the cell's pixmap mask.

XbaeMatrixGetCellTag()

XmStringTag XbaeMatrixGetCellTag()
Widget w;
int row;
int column;

w A XbaeMatrix widget.

row The row of the cell whose tag should be retrieved.

column The column of the cell tag should be retrieved.

XbaeMatrixGetCellTag returns the font tag of the indicated cell. The
application should not modify or free the returned value.
XbaeMatrixGetCellUserData()

XtPointer XbaeMatrixGetCellUserData()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell whose data should be retrieved.

column The column of the cell whose data should be retrieved.

XbaeMatrixGetCellUserData() returns a pointer to the data assigned
to the cell in the given coordinates. The data should be set using
XbaeMatrixSetCellUserData(). If no data is found to be associated
with the particular cell, NULL is returned.

XbaeMatrixGetColumnWidth()

int XbaeMatrixGetColumnWidth()
Widget w;
int column;

w An XbaeMatrix widget.

column The column whose width we're querying.

XbaeMatrixGetColumnWidth() is a convenient way to query a column
width.

XbaeMatrixGetColumnLabel()

String XbaeMatrixGetColumnLabel()
Widget w;
int column;

w An XbaeMatrix widget.

column The column of the label that should be retrieved.

XbaeMatrixGetColumnLabel() returns a pointer to the label of the
given column. If no column labels exist or the given column is not
a valid column NULL is returned. If no data is found to be associ-
ated with the particular column, NULL is returned.

XbaeMatrixGetColumnUserData()

XtPointer XbaeMatrixGetColumnUserData()
Widget w;
int column;

w An XbaeMatrix widget.

column The column of the cell whose data should be retrieved.

XbaeMatrixGetColumnUserData() returns a pointer to the data assigned
to the given column. The data should be set using XbaeMatrixSet-
ColumnUserData(). If no data is found to be associated with the
particular column, NULL is returned.

XbaeMatrixGetCurrentCell()

void XbaeMatrixGetCurrentCell()
Widget w;
int *row;
int *column;

w An XbaeMatrix widget.

row The row of the cell the ``cursor'' or TextField is in.

column The column of the cell the ``cursor'' or TextField is in.

XbaeMatrixGetCurrentCell() allows the application developer to de-
termine what cell is being edited or has focus.

XbaeMatrixGetEventRowColumn()

int XbaeMatrixGetEventRowColumn()
Widget w;
XEvent *event;
int *row;
int *column;

w An XbaeMatrix widget.

event An X event structure pointer. This is usually from an
XEventHandler function. It can be either a button or a
key event.

row The row of the cell the ``cursor'' or TextField is in.

column The column of the cell the ``cursor'' or TextField is in.

XbaeMatrixGetEventRowColumn() allows the application developer to
determine what cell corresponds to an (x, y) in an event. If the
(x, y) of the event is a legal cell, row and column are set and True
is returned. However, if the (x, y) is not over a cell, False is
returned, and row and column will have undefined values.

XbaeMatrixGetNumSelected()

int XbaeMatrixGetNumSelected()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixGetNumSelected() returns the number of cells that are cur-
rently selected in the given matrix. The widget maintains an inter-
nal variable as cells are selected and deselected so a complete tra-
versal of the widget is avoided.

XbaeMatrixGetRowHeight()

int XbaeMatrixGetRowHeight()
Widget w;
int row;

w An XbaeMatrix widget.

row The row whose height we query.

XbaeMatrixGetRowHeight() is a convenient way to query a row height.

XbaeMatrixGetRowLabel()

String XbaeMatrixGetRowLabel()
Widget w;
int row;

w An XbaeMatrix widget.

row The row of the label that should be retrieved.

XbaeMatrixGetRowLabel() returns a pointer to the label of the given
row. If no row labels exist or the given row is not a valid row
NULL is returned.

XbaeMatrixGetRowUserData()

XtPointer XbaeMatrixGetRowUserData()
Widget w;
int row;

w An XbaeMatrix widget.

row The row of the cell whose data should be retrieved.

XbaeMatrixGetRowUserData() returns a pointer to the data assigned to
the given row. The data should be set using XbaeMatrixSetRowUser-
Data(). If no data is found to be associated with the particular
row, NULL is returned.

XbaeMatrixGetXmColumnLabel()

XmString XbaeMatrixGetXmColumnLabel()
Widget w;
int column;

w An XbaeMatrix widget.

column The column of the xmLabel that should be retrieved.

XbaeMatrixGetXmColumnLabel() returns a pointer to the xmLabel of the
given column. If no xmColumnLabels exist or the given column is not
a valid column NULL is returned. If no data is found to be associ-
ated with the particular column, NULL is returned.

XbaeMatrixGetXmRowLabel()

XmString XbaeMatrixGetXmRowLabel()
Widget w;
int row;

w An XbaeMatrix widget.

row The row of the xmLabel that should be retrieved.

XbaeMatrixGetXmRowLabel() returns a pointer to the xmLabel of the
given row. If no xmRowLabels exist or the given row is not a valid
row NULL is returned. If no data is found to be associated with the
particular row, NULL is returned.

XbaeMatrixHighlightCell()

void XbaeMatrixHighlightCell()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to highlight.

column The column of the cell to highlight.

XbaeMatrixHighlightCell() allows the application developer to pro-
grammatically highlight a cell. XbaeMatrixHighlightCell() draws the
highlight around the cell. The corresponding unsigned char in the
XmNhighlightedCells array will be have its HighlightCell bit set.

XbaeMatrixHighlightColumn()

void XbaeMatrixHighlightColumn()
Widget w;
int column;

w An XbaeMatrix widget.

column The column to highlight.

XbaeMatrixHighlightColumn() allows the application developer to pro-
grammatically highlight a column. XbaeMatrixHighlightColumn() draws
the highlight around the column if XmNgridType is XmGRID_COL-
UMN_SHADOW or from around each cell in the column otherwise. The
corresponding unsigned chars in the XmNhighlightedCells array will
be have its HighlightColumn or HighlightOther bit set, depending on
whether XmNgridType is set to XmGRID_COLUMN_SHADOW or not.

XbaeMatrixHighlightRow()

void XbaeMatrixHighlightRow()
Widget w;
int row;

w An XbaeMatrix widget.

row The row to highlight.

XbaeMatrixHighlightRow() allows the application developer to pro-
grammatically highlight a row. XbaeMatrixHighlightRow() draws the
highlight around the row if XmNgridType is XmGRID_ROW_SHADOW or from
around each cell in the row otherwise. The corresponding unsigned
chars in the XmNhighlightedCells array will be have its HighlightRow
or HighlightOther bit set, depending on whether XmNgridType is set
to XmGRID_ROW_SHADOW or not.

XbaeMatrixIsCellSelected()

Boolean XbaeMatrixIsCellSelected()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to check.

column The column of the cell to check.

XbaeMatrixIsCellSelected() allows the application developer to de-
termine whether or not a particular cell is selected. The function
returns True if the cell is selected and False otherwise.

XbaeMatrixIsCellVisible()

Boolean XbaeMatrixIsCellVisible()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to check.

column The column of the cell to check.

XbaeMatrixIsCellVisible() allows the application developer to deter-
mine whether or not a particular cell is in the visible area of the
XbaeMatrix widget. The function returns True if the cell is visible
and False otherwise.

XbaeMatrixIsColumnSelected()

Boolean XbaeMatrixIsColumnSelected()
Widget w;
int column;

w An XbaeMatrix widget.

column The column of the matrix to check.

XbaeMatrixIsColumnSelected() allows the application developer to de-
termine whether or not a particular column is selected. The function
returns True if the column is selected and False otherwise. A column
must be selected in its entirety for XbaeMatrixIsColumnSelected() to
return True.

XbaeMatrixIsColumnVisible()

Boolean XbaeMatrixIsColumnVisible()
Widget w;
int column;

w An XbaeMatrix widget.

column The column of the matrix to check.

XbaeMatrixIsColumnVisible() allows the application developer to de-
termine whether or not a particular column is in the visible area of
the XbaeMatrix widget. The function returns True if the column is
visible and False otherwise.

XbaeMatrixIsRowSelected()

Boolean XbaeMatrixIsRowSelected()
Widget w;
int row;

w An XbaeMatrix widget.

row The row of the matrix to check.

XbaeMatrixIsRowSelected() allows the application developer to deter-
mine whether or not a particular row is selected. The function re-
turns True if the row is selected and False otherwise. A row must be
selected in its entirety for XbaeMatrixIsRowSelected() to return
True.

XbaeMatrixIsRowVisible()

Boolean XbaeMatrixIsRowVisible()
Widget w;
int row;

w An XbaeMatrix widget.

row The row of the matrix to check.

XbaeMatrixIsRowVisible() allows the application developer to deter-
mine whether or not a particular row is in the visible area of the
XbaeMatrix widget. The function returns True if the row is visible
and False otherwise.

XbaeMatrixMakeCellVisible()

int XbaeMatrixMakeCellVisible()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row to scroll into the visible area of the matrix.

column The column to scroll into the visible area of the matrix.

XbaeMatrixMakeCellVisible() allows a cell to be programatically
scrolled into the visible area of the XbaeMatrix widget. By calling
this function, the XmNselectScrollVisible resource is ignored. For
a more accurate cell location after scrolling, the programmer should
use the XmNleftColumnandXmNtopRow resources.

XbaeMatrixNumRows()

int XbaeMatrixNumRows()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixNumRows() returns the number of rows in the given matrix.

XbaeMatrixNumColumns()

int XbaeMatrixNumColumns()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixNumColumns() returns the number of columns in the given
matrix.

XbaeMatrixNumRows()

int XbaeMatrixNumRows()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixNumRows() returns the number of rows in the given matrix.

XbaeMatrixRefresh()

void XbaeMatrixRefresh()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixRefresh() allows the application developer to force the
widget to redraw itself. This might be used when the programmer
knows the widget's values have changed, but the widget has not de-
tected the change. For example, the quickest way to swap the values
of 2 rows would be to do an XtGetValues on XmNcells, swap the values
of the 2 rows, and then do an XtSetValues on XmNcells with the same
StringTable variable. Because of the way the Intrinsics work, the
widget will not see this change and will display the old values un-
til a redraw is preformed because of a resize or scroll event (as-
suming no other change in the XtSetValues caused a redraw). Calling
XbaeMatrixRefresh() will cause the correct values to be drawn and
overcome this limitation in the Intrinsics. While this function
should rarely be needed, it is provided ``just in case''.

XbaeMatrixRefreshCell()

void XbaeMatrixRefreshCell()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to redraw.

column The column of the cell to redraw.

XbaeMatrixRefreshCell() allows the application developer to redraw a
specific cell of the matrix. This function is particularly useful
when used with the XbaeMatrixDrawCellCallback as it allows updates
of the data without an explicit expose event.

XbaeMatrixRefreshColumn()

void XbaeMatrixRefreshColumn()
Widget w;
int column;

w An XbaeMatrix widget.

column The column of the matrix to redraw.

XbaeMatrixRefreshColumn() allows the application developer to effi-
ciently redraw a specific column
of the matrix.

XbaeMatrixRefreshRow()

void XbaeMatrixRefreshRow()
Widget w;
int row;

w An XbaeMatrix widget.

row The row of the matrix to redraw.

XbaeMatrixRefreshRow() allows the application developer to effi-
ciently redraw a specific row
of the matrix.

XbaeMatrixRowColToXY()

int XbaeMatrixRowColToXY()
Widget w;
int row;
int column;
int *x;
int *y;

w An XbaeMatrix widget.

row The row the of the cell in question.

column The column the of the cell in question.

x The x coordinate returned that represents the left coordi-
nates of the given cell.

y The y coordinate returned that represents the upper coor-
dinates of the given cell.

XbaeMatrixRowColToXY() allows the application developer to determine
the coordinates of the upper left corner of a given cell. If the
given widget is not an XbaeMatrix widget, False will be returned and
the values of x and y will be undefined. This function is useful
for drag and drop calculations.

XbaeMatrixSelectAll()

void XbaeMatrixSelectAll()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixSelectAll() allows the application developer to program-
matically select all cells. XbaeMatrixSelectAll() redraws the cells
in reverse video. All Booleans in the XmNselectedCells array will be
set to True.

XbaeMatrixSelectCell()

void XbaeMatrixSelectCell()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to select.

column The column of the cell to select.

XbaeMatrixSelectCell() allows the application developer to program-
matically select a cell. XbaeMatrixSelectCell() first scrolls the
specified cell until it is visible, and then draws the cell in re-
verse video (or selectedForeground / selectedBackground if set).
The corresponding Boolean in the XmNselectedCells array will be set
to True.

XbaeMatrixSelectColumn()

void XbaeMatrixSelectColumn()
Widget w;
int column;

w An XbaeMatrix widget.

column The column to select.

XbaeMatrixSelectColumn() allows the application developer to pro-
grammatically select a column. XbaeMatrixSelectColumn() first
scrolls the specified column until it is visible, and then draws the
column in reverse video (or selectedForeground / selectedBackground
if set). The corresponding Booleans in the XmNselectedCells array
will be set to True.

XbaeMatrixSelectRow()

void XbaeMatrixSelectRow()
Widget w;
int row;

w An XbaeMatrix widget.

row The row to select.

XbaeMatrixSelectRow() allows the application developer to program-
matically select a row. XbaeMatrixSelectRow() first scrolls the
specified row until it is visible, and then draws the row in reverse
video (or selectedForeground / selectedBackground if set). The cor-
responding Booleans in the XmNselectedCells array will be set to
True.

XbaeMatrixSetCell()

void XbaeMatrixSetCell()
Widget w;
int row;
int column;
const String value;

w An XbaeMatrix widget.

row The row of the cell whose value should be set.

column The column of the cell whose value should be set.

value The new value to set this cell to.

XbaeMatrixSetCell() allows the application developer to programmati-
cally set the value of the specified cell. To set the values of many
cells, it may be more efficient to do an XtSetValues() on the XmN-
cells resource.

XbaeMatrixSetCellBackground()

void XbaeMatrixSetCellBackground()
Widget w;
int row;
int column;
Pixel color;

w An XbaeMatrix widget.

row The row of the cell whose backgroundshould be set.

column The column of the cell whose background should be set.

color The new color to which to set this cell's background.

XbaeMatrixSetCellBackground() is a convenient way to specify and
modify the XmNcellBackgrounds resource when changing the background
of a single cell. If XmNcellBackgrounds is NULL, then XbaeMatrixSet-
CellBackground() will create a Pixel table initialized to XmNfore-
ground except for the cell specified in it's arguments. If XmNcell-
Backgrounds is not NULL, then XbaeMatrixSetCellBackground() will
changed the specified cell in that resource to the specified color.

XbaeMatrixSetCellColor()

void XbaeMatrixSetCellColor()
Widget w;
int row;
int column;
Pixel color;

w An XbaeMatrix widget.

row The row of the cell whose color should be set.

column The column of the cell whose color should be set.

color The new color to which to set this cell.

XbaeMatrixSetCellColor() is a convenient way to specify and modify
the XmNcolors resource when changing the color of a single cell. If
XmNcolors is NULL, then XbaeMatrixSetCellColor() will create a Pixel
table initialized to XmNforeground except for the cell specified in
it's arguments. If XmNcolors is not NULL, then XbaeMatrixSetCell-
Color() will changed the specified cell in that resource to the
specified color.

XbaeMatrixSetCellPixmap()

void XbaeMatrixSetCellPixmap()
Widget w;
int row;
int column;
Pixmap pixmap;
Pixmap mask;

w A XbaeMatrix widget.

row The row of the cell whose pixmap and mask should be set.

column The column of the cell whose pixmap and mask should be
set.

pixmap the function will store the contents of this Pixmap vari-
able

mask the function will store the contents of this variable as
the pixmap mask

XbaeMatrixSetCellPixmap will set the pixmap and the associated mask
of the indicated cell. If the row or column are out of bounds, or
the widget is not an XbaeMatrix widget, then nothing is changed;
this erroneous condition is silently ignored.

XbaeMatrixSetCellShadow()

void XbaeMatrixSetCellShadow()
Widget w;
int row;
int column;
unsigned char shadow_type;

w An XbaeMatrix widget.

row The row of the cell whose shadow should be set.

column The column of the cell whose shadow should be set.

shadow_type
The value to which to set the cells shadow

XbaeMatrixSetShadow() allows the application developer to program-
matically set the shadow of a specified cell.

XbaeMatrixSetCellTag()

void XbaeMatrixSetCellTag()
Widget w;
int row;
int column;
XmStringTag tag;

w An XbaeMatrix widget.

row The row of the cell whose tag should be set.

column The column of the cell whose tag should be set.

tag The value to which to set the cells tag

XbaeMatrixSetTag() allows the application developer to programmati-
cally set the font tag of a specified cell. This value is copied
(quarkified).

XbaeMatrixSetCellUserData()

void XbaeMatrixSetCellUserData()
Widget w;
int row;
int column;
XtPointer data;

w An XbaeMatrix widget.

row The row of the cell whose value should be set.

column The column of the cell whose value should be set.

data A pointer to a user defined data area.

XbaeMatrixSetCellUserData() allows the application developer to pro-
grammatically set the user data of a specified cell. To set the data
value of many cells, it may be more efficient to do an XtSetValues()
on the XmNcellUserData resource. This resource is copied.

XbaeMatrixSetCellWidget()

void XbaeMatrixSetCellWidget(w, row, column, widget)
Widget w;
int row;
int column;
Widget widget;

XbaeMatrixSetCellWidget() is a function to attach a widget to a ma-
trix cell. The cell is selected by specifying its row and column ,
widget is the cell widget to be associated with that cell. XbaeMa-
trix will manage the cell widget's position and size so it is dis-
played inside the cell at all times, including when scrolling.

Using a NULL widget removes the link between a widget and its cell.
Only one widget can be in a cell, a widget should also be in only
one cell at a time.

XbaeMatrixSetCellWidget()

void XbaeMatrixSetCellWidget(w, row, column, widget)
Widget w;
int row;
int column;
Widget widget;

Using a NULL widget removes the link between a widget and its cell.
Only one widget can be in a cell, a widget should also be in only
one cell at a time.

XbaeMatrixSetColumnBackgrounds()

void XbaeMatrixSetColumnBackgrounds()
Widget w;
int position;
Pixel *colors;
int num_colors;

w An XbaeMatrix widget.

position The column position at which to begin applying the new
backgrounds. Must be greater than or equal to zero, and
(position + num_colors) must be less than or equal to XmN-
columns.

colors Points to an array of Pixel. These specify the backgrounds
for the cells in the specified columns. The colors array
must have num_colors elements.

num_colorsThe number of colors in the colors array.

XbaeMatrixSetColumnBackgrounds() is a convenient way to specify and
modify the XmNcellBackgrounds resource when setting the background
of an entire column or columns. If XmNcellBackgrounds is NULL, then
XbaeMatrixSetColumnBackgrounds() will create a Pixel table initial-
ized to XmNforeground except for the columns specified in it's argu-
ments. If XmNcellBackgrounds is not NULL, then XbaeMatrixSetColumn-
Backgrounds() will changed the specified columns in that resource to
the specified colors.

XbaeMatrixSetColumnColors()

void XbaeMatrixSetColumnColors()
Widget w;
int position;
Pixel *colors;
int num_colors;

w An XbaeMatrix widget.

position The column position at which to begin applying the new
colors. Must be greater than or equal to zero, and (posi-
tion + num_colors) must be less than or equal to XmN-
columns.

colors Points to an array of Pixel. These specify the colors for
the cells in the specified columns. The colors array must
have num_colors elements.

num_colorsThe number of colors in the colors array.

XbaeMatrixSetColumnColors() is a convenient way to specify and mod-
ify the XmNcolors resource when setting the color of an entire col-
umn or columns. If XmNcolors is NULL, then XbaeMatrixSetColumnCol-
ors() will create a Pixel table initialized to XmNforeground except
for the columns specified in it's arguments. If XmNcolors is not
NULL, then XbaeMatrixSetColumnColors() will changed the specified
columns in that resource to the specified colors.

XbaeMatrixSetColumnWidth()

void XbaeMatrixSetColumnWidth()
Widget w;
int column;
int width;

w An XbaeMatrix widget.

column The column whose width we'll be changing.

width The new width of this column. A column width can be 0 to
hide a column.

XbaeMatrixSetColumnWidth() is a convenient way to change the width
of a column without the need to allocate an array with column width
numbers. Passing -1 as the new width will reset the column width to
the default value.

XbaeMatrixSetColumnLabel()

void XbaeMatrixSetColumnLabel()
Widget w;
int column;
String value;

w An XbaeMatrix widget.

column The column of the label is to be set.

value The new value of the label.

XbaeMatrixSetColumnLabel() allows the application developer to pro-
grammatically change the label of a specified column.

XbaeMatrixSetColumnShadow()

void XbaeMatrixSetColumnShadow()
Widget w;
int column;
unsidned char shadow_type;

w An XbaeMatrix widget.

column The column for which the shadow to be set.

shadow_type
The new value of the shadow.

XbaeMatrixSetColumnShadow() allows the application developer to pro-
grammatically change the shadow of a specified column.

XbaeMatrixSetColumnUserData()

void XbaeMatrixSetColumnUserData()
Widget w;
int column;
XtPointer data;

w An XbaeMatrix widget.

column The column whose value should be set.

data A pointer to a user defined data area.

XbaeMatrixSetColumnUserData() allows the application developer to
programmatically associate user data for the specified column.

XbaeMatrixSetRowBackgrounds()

void XbaeMatrixSetRowBackgrounds()
Widget w;
int position;
Pixel *colors;
int num_colors;

w An XbaeMatrix widget.

position The row position at which to begin applying the new col-
ors. Must be greater than or equal to zero, and (position
+ num_colors) must be less than or equal to XmNrows.

colors Points to an array of Pixel. These specify the backgrounds
for the cells in the specified rows. The colors array must
have num_colors elements.

num_colorsThe number of colors in the colors array.

XbaeMatrixSetRowBackgrounds() is a convenient way to specify and
modify the XmNcellBackgrounds resource when setting the background
of an entire row or rows. If XmNcellBackgrounds is NULL, then Xbae-
MatrixSetRowBackgrounds() will create a Pixel table initialized to
XmNforeground except for the rows specified in it's arguments. If
XmNcellBackgrounds is not NULL, then XbaeMatrixSetRowBackgrounds()
will changed the specified rows in that resource to the specified
colors.

XbaeMatrixSetRowColors()

void XbaeMatrixSetRowColors()
Widget w;
int position;
Pixel *colors;
int num_colors;

w An XbaeMatrix widget.

position The row position at which to begin applying the new col-
ors. Must be greater than or equal to zero, and (position
+ num_colors) must be less than or equal to XmNrows.

colors Points to an array of Pixel. These specify the colors for
the cells in the specified rows. The colors array must
have num_colors elements.

num_colorsThe number of colors in the colors array.

XbaeMatrixSetRowColors() is a convenient way to specify and modify
the XmNcolors resource when setting the color of an entire row or
rows. If XmNcolors is NULL, then XbaeMatrixSetRowColors() will cre-
ate a Pixel table initialized to XmNforeground except for the rows
specified in it's arguments. If XmNcolors is not NULL, then XbaeMa-
trixSetRowColors() will changed the specified rows in that resource
to the specified colors.

XbaeMatrixSetRowHeight()

void XbaeMatrixSetRowHeight()
Widget w;
int row;
int height;

w An XbaeMatrix widget.

row The row whose height we'll be changing.

height The new height of this row. A row height can be 0 to hide
a row.

XbaeMatrixSetRowHeight() is a convenient way to change the height of
a row without the need to allocate an array with row height numbers.
Passing -1 as the new height will reset the row's height to the de-
fault value.

XbaeMatrixSetRowLabel()

void XbaeMatrixSetRowLabel()
Widget w;
int row;
String value;

w An XbaeMatrix widget.

row The row of the label is to be set.

value The new value of the label.

XbaeMatrixSetRowLabel() allows the application developer to program-
matically change the label of the specified row.

XbaeMatrixSetRowShadow()

void XbaeMatrixSetRowShadow()
Widget w;
int column;
unsigned char shadow_type;

w An XbaeMatrix widget.

row The row whose shadow should be set.

shadow_type
The value of the new shadow.

XbaeMatrixSetRowShadow() allows the application developer to pro-
grammatically change the shadow for the specified row.

XbaeMatrixSetRowUserData()

void XbaeMatrixSetRowUserData()
Widget w;
int column;
XtPointer data;

w An XbaeMatrix widget.

row The row whose value should be set.

data A pointer to a user defined data area.

XbaeMatrixSetRowUserData() allows the application developer to pro-
grammatically associate user data for the specified row.

XbaeMatrixSetXmColumnLabel()

void XbaeMatrixSetXmColumnLabel()
Widget w;
int column;
XmString value;

w An XbaeMatrix widget.

column The column of the xmLabel is to be set.

value The new value of the xmLabel.

XbaeMatrixSetXmColumnLabel() allows the application developer to
programmatically change the xmLabel of a specified column.

XbaeMatrixSetXmRowLabel()

void XbaeMatrixSetXmRowLabel()
Widget w;
int row;
XmString value;

w An XbaeMatrix widget.

row The row of the xmLabel is to be set.

value The new value of the xmLabel.

XbaeMatrixSetXmRowLabel() allows the application developer to pro-
grammatically change the xmLabel of a specified row.

XbaeMatrixSortColumns()

void XbaeMatrixSortColumns()
Widget w;
int (*proc)(Widget, int, int, void *);
void *user_data;

w An XbaeMatrix widget.

proc a pointer to a function that can compare columns.

user_data a pointer the application can use for its own needs.

XbaeMatrixSortColumns allows you to sort the columns in the XbaeMa-
trix widget according to criteria determined by the proc function.
The proc function should have the above signature and functionality
as demanded by the qsort(3) function. It will be called with a the
matrix being sorted, the indices of two columns to compare and the
user_data pointer XbaeMatrixSortColumns was called with. It should
return -1, 0, or 1 as appropriate. It is guaranteed that the matrix
does not change while sorting and the necessary reordering will only
take place after the last call to proc has been made.

XbaeMatrixSortRows()

void XbaeMatrixSortRows()
Widget w;
int (*proc)(Widget, int, int, void *);
void *user_data;

w An XbaeMatrix widget.

proc a pointer to a function that can compare rows.

user_data a pointer the application can use for its own needs.

XbaeMatrixSortRows allows you to sort the rows in the XbaeMatrix
widget according to criteria determined by the proc function. The
proc function should have the above signature and functionality as
demanded by the qsort(3) function. It will be called with the ma-
trix being sorted, the indices of two rows to compare and the
user_data pointer XbaeMatrixSortRows was called with. It should re-
turn -1, 0, or 1 as appropriate. It is guaranteed that the matrix
does not change while sorting and the necessary reordering will only
take place after the last call to proc has been made.

XbaeMatrixUnhighlightAll()

void XbaeMatrixUnhighlightAll()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixUnhighlightAll() allows the application developer to pro-
grammatically unhighlight all cells. XbaeMatrixUnhighlightAll()
erases the highlight from all cells. All unsigned chars in the XmN-
highlightedCells array will be set to HighlightNone.

XbaeMatrixUnhighlightCell()

void XbaeMatrixUnhighlightCell()
Widget w;
int row;
int column;

w An XbaeMatrix widget.

row The row of the cell to unhighlight.

column The column of the cell to unhighlight.

XbaeMatrixUnhighlightCell() allows the application developer to pro-
grammatically unhighlight a cell. XbaeMatrixUnhighlightCell()
erases the highlight from the cell. The corresponding unsigned char
in the XmNhighlightedCells array will be have its HighlightCell bit
cleared.

XbaeMatrixUnhighlightColumn()

void XbaeMatrixUnhighlightColumn()
Widget w;
int column;

w An XbaeMatrix widget.

column The column to unhighlight.

XbaeMatrixUnhighlightColumn() allows the application developer to
programmatically unhighlight a column. XbaeMatrixUnhighlightCol-
umn() erases the highlight from around the column if XmNgridType is
XmGRID_COLUMN_SHADOW or from around each cell in the column other-
wise. The corresponding unsigned chars in the XmNhighlightedCells
array will be have its HighlightColumn or HighlightOther bit
cleared, depending on whether XmNgridType is set to XmGRID_COL-
UMN_SHADOW or not.

XbaeMatrixUnhighlightRow()

void XbaeMatrixUnhighlightRow()
Widget w;
int row;

w An XbaeMatrix widget.

row The row to unhighlight.

XbaeMatrixUnhighlightRow() allows the application developer to pro-
grammatically unhighlight a row. XbaeMatrixUnhighlightRow() erases
the highlight from around the row if XmNgridType is Xm-
GRID_ROW_SHADOW or from around each cell in the row otherwise. The
corresponding unsigned chars in the XmNhighlightedCells array will
be have its HighlightRow or HighlightOther bit cleared, depending on
whether XmNgridType is set to XmGRID_ROW_SHADOW or not.

XbaeMatrixVisibleCells()

int XbaeMatrixVisibleCells()
Widget w;
int *top_row;
int *bottom_row;
int *left_column;
int *right_column;

w An XbaeMatrix widget.

top_row The first row that is currently visible in the matrix.

bottom_rowThe last row that is currently visible in the matrix.

left_column
The leftmost column that is currently visible in the ma-
trix.

right_column
The rightmost column that is currently visible in the ma-
trix.

XbaeMatrixVisibleCells() allows the the application developer to ob-
tain the currently visible portion of the XbaeMatrix w.

XbaeMatrixVisibleColumns()

int XbaeMatrixVisibleColumns()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixVisibleColumns() allows the the application developer to
programmatically check how many columns are currently displayed in
the XbaeMatrix w. A partially visible column will be declared an
entire column.

XbaeMatrixVisibleRows()

int XbaeMatrixVisibleRows()
Widget w;

w An XbaeMatrix widget.

XbaeMatrixVisibleRows() allows the the application developer to pro-
grammatically check how many rows are currently displayed in the
XbaeMatrix w. A partially visible row will be declared an entire
row.

XbaeGetVersionNum()

int XbaeGetVersionNum()

XbaeGetVersionNum() is a function that returns the numeric represen-
tation of the version of the Xbae library that your program is work-
ing with. This is the run-time version of the Xbae widgets, where
XbaeVersion is a macro that represents the compile-time version.

The numeric representation is a simple calculation based on the ma-
jor, minor, and pico numbers representing an Xbae widget release.
E.g. version 4.8.1 would be represented as 40801.

Releases prior to 4.8.0 didn't have this functionality.

XbaeGetVersionText()

char * XbaeGetVersionText()

XbaeGetVersionText() is a function that returns the textual repre-
sentation of the version of the Xbae library that your program is
working with. This is the run-time version of the Xbae widgets,
where XbaeVersionTxt is a macro that represents the compile-time
version.

Additional Behavior
Using XtSetValues to set the Matrix's XmNwidth resource to 0 will cause it
to recompute it's horizontal size. It will request a new size which results
in XmNvisibleColumns columns being displayed. If XmNvisibleColumns is 0,
then it will request a new size such that it does not need a horizontal
ScrollBar (full horizontal size).

Using XtSetValues to set the Matrix's XmNheight resource to 0 will cause it
to recompute it's vertical size. It will request a new size which results
in XmNvisibleRows rows being displayed. If XmNvisibleRows is 0, then it
will request a new size such that it does not need a vertical ScrollBar
(full vertical size).

An XtSetValues on XmNvisibleRows will cause the Matrix to request a new
size which results in XmNvisibleRows non-fixed rows being displayed, only
if the new value is different than the old one.

An XtSetValues on XmNvisibleColumns will cause the Matrix to request a new
size which results in the first XmNvisibleColumns non-fixed columns being
displayed, only if the new value is different than the old one.

An XtSetValues on any other resource will not result in a request for a new
size. Setting other resources in conjunction with setting XmNwidth and/or
XmNheight to 0 allows for more control of the Matrix's geometry.

An XtSetValues setting XmNrowLabelWidth to 0 will cause XmNrowLabelWidth to
be set to the width of the longest row label.

Virtual Bindings
The bindings for virtual keys are vendor specific. For information about
bindings for virtual buttons and keys, see VirtualBindings(3X).

AUTHOR
Andrew Wason (aw@bae.bellcore.com) of Bellcore, Piscataway NJ, wrote the
original version of the Xbae widgets. His final release of the widgets was
version 3.8.

Kevin Brannen (kbrannen@metronet.com) took over maintainership following
Andrew Wason's departure and released version 4.0.

Andrew Lister (lister@db.com) maintained from 1995 to 1999.

SPECIAL THANKS
Andrew Wason for the original idea and source code.
Jay Schmidgall for his contributions.
Nick Banyard for providing the multibyte extensions.
Callum Gibson for the pattern parsing in the XbaeInput widget.
Sascha Goebel for debugging the scroll-per-pixel code.
Tobias Oed for lots of code cleanup and debugging.
The people from Arcad Systemhaus for code submission for XbaeMatrixSort and
a couple of related functionalities, and easier pixmap support.

RELEASE
This document describes XbaeMatrix, version 4.60.4.

SEE ALSO
Core(3X), Composite(3X), XmManager(3X), XmScrollBar(3X), XbaeInput(3X), Xm-
Text(3X)

Notice of Limitation
Bellcore, previous and current maintainers of the Xbae widgets (collec-
tively 'authors') provide this information solely to professionals who have
the appropriate degree of experience to understand and interpret its con-
tents in accordance with generally accepted engineering or other profes-
sional standards and applicable regulations. No recommendations as to prod-
ucts or vendors is made or should be implied.

While the information contained herein has been prepared from sources
deemed to be reliable, the authors reserve the right to revise the informa-
tion without notice, but has no obligation to do so. Unless the recipient
has been expressly granted a license by Bellcore under separate applicable
written agreement with Bellcore, no license, expressed or implied, is
granted under any patents, copyrights or other intellectual property
rights. Use of the information is at your discretion and shall not be
deemed an inducement by Bellcore to infringe any existing or later-issued
patent, copyrights or other intellectual property right.

THE AUTHORS MAKE NO REPRESENTATIONS AND EXTENDS NO WARRANTIES, EXPRESS OR
IMPLIED, WITH RESPECT TO THE INFORMATION, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY PARTICULAR
PURPOSE, AND THE WARRANTY AGAINST INFRINGEMENT OF PATENTS OR OTHER INTEL-
LECTUAL PROPERTY RIGHTS. THE INFORMATION IS PROVIDED ``AS IS'', AND IN NO
EVENT SHALL THE AUTHORS OR ANY OF ITS AFFILIATES BE LIABLE FOR ANY DAMAGES,
INCLUDING ANY LOST PROFITS OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES RE-
LATING TO THE INFORMATION.

The above no warranty extends to all additions and contributions. No con-
tributor shall be held liable; this work is provided ``as is''. If this is
a problem for you, then don't use this software.

4.60.4 2026-06-11 XbaeMatrix(3x)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=XbaeMatrix&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help

Header And Logo

Peripheral Links

Site Navigation

FreeBSD Manual Pages

Header And Logo

Peripheral Links

Search

Site Navigation

FreeBSD Manual Pages