GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


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
       respectively.  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   pattern   (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
       XmNleaveCellCallback 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
       attempts to edit a new cell and when the matrix gains or looses  focus.
       This  allows the application to override the default traversal behavior
       of XbaeMatrix.

       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
       XmNprocessDragCallback.

       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,
       Constraint, 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                               │
       ├────────────────────────┬─────────────────────┬───────────────┬───────────────┬─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       ├────────────────────────┼─────────────────────┼───────────────┼───────────────┼─────┤
       └────────────────────────┴─────────────────────┴───────────────┴───────────────┴─────┘
       ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────┐
       │                                   XbaeMatrix Resource Set (continued)                                    │
       ├──────────────────────────────────┬──────────────────────────────┬───────────────┬──────────────────┬─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       ├──────────────────────────────────┼──────────────────────────────┼───────────────┼──────────────────┼─────┤
       └──────────────────────────────────┴──────────────────────────────┴───────────────┴──────────────────┴─────┘
       ┌─────────────────────────────────────────────────────────────────────────────────────────────────────┐
       │                                XbaeMatrix Resource Set (continued)                                  │
       ├────────────────────────────────┬──────────────────────────────┬────────────┬──────────────────┬─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       ├────────────────────────────────┼──────────────────────────────┼────────────┼──────────────────┼─────┤
       └────────────────────────────────┴──────────────────────────────┴────────────┴──────────────────┴─────┘
       This resource cannot be specified in a resource file

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

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

       XmNaltRowCount
            Specifies   the   number   of   rows   to  use  for  each  of  the
            XmNevenRowBackground and XmNoddRowBackround colors. This  resource
            is  ignored if XmNevenRowBackground 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  reverse  the  shadow  and  take  on  a  pushed  in
            appearance.   A  ButtonRelease event on the same label will invoke
            callbacks on the XmNlabelActivateCallback, 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 default 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 
  character.   If  the  XbaeMatrix  widget  had
            XmNrows set to 5 and XmNcolumns set to 5, XmNcellBackgrounds would
            be specified as:

            *mw.cellBackgrounds:   blue, white, blue, white, blue
\
                                   white, blue, white, blue, white
\
                                   blue, white, blue, white, blue
\
                                   white, blue, white, blue, white
\
                                   blue, white, blue, white, blue

             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
            resource  is  also  used to compute the size of each cell. See the
            description 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
            widget.  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
            XbaeMatrixSetCellUserData()        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  resource  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  discussion 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   XmNalignment   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,
            XmNbuttonLabels 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,
            XmALIGNMENT_CENTER   or   XmALIGNMENT_END.    This  specifies  the
            alignment of the text of each column label. See the description of
            XmNalignment  for  XmLabel(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 defined for this coluumn it will be displayed in
            place    of   the   XmNcolumnLabels.    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
            maximum length of a String which can be entered in  the  cells  in
            that  column.  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 resource 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
            column.       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
            pixels 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 XmNcolumnLabelAlignments must change or be
            NULL.  The preferred way  to  dynamically  change  the  number  of
            columns      is      to      use     XbaeMatrixAddColumns()     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 dialog or other
            window when a double click occurs.

       XmNdoubleClickInterval
            Specifies  the  amount  of  time between mouse clicks before it is
            considered 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  single   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
            XmNcolumnAlignments resource to determine the horizontal alignment
            of the Pixmap.  To  have  an  editable  array  of  data  when  the
            XmNdrawCellCallback  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()       action.       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 options for
            the XmText.

       XmNevenRowBackground
            Specifies a background cell Pixel value to use on even rows.  This
            allows  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
            column)   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
            XmText 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
            XmFONTLIST_DEFAULT_TAG  if  no  tag has been set on the cell using
            XbaeMatrixSetCellTag.  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
            XmNgridType  is  set  to  XmGRID_CELL_LINE,   XmGRID_ROW_LINE   or
            XmGRID_COLUMN_LINE.  The default is that of XmNforeground.

       XmNgridType
            Sets  the  way the matrix grid is drawn.  The grid types available
            include   XmGRID_NONE,    XmGRID_CELL_LINE,    XmGRID_CELL_SHADOW,
            XmGRID_ROW_LINE,    XmGRID_ROW_SHADOW,    XmGRID_COLUMN_LINE   and
            XmGRID_COLUMN_SHADOW.  All of the grid  types  vary  the  way  the
            shadow  or  line  is  drawn  around  the  cell.   XmGRID_ROW_LINE,
            XmGRID_ROW_SHADOW,  XmGRID_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
            unsigned char values, one for each column in that row.  This  data
            structure  is  the same as that for XmNcells, except each entry is
            an unsigned char instead of a String. Each entry in the array will
            have   a   value  that  is  either  HighlightNone,  HighlightCell,
            HighlightRow, HighlightColumn, HighlightOther or the bitwise OR of
            those values, depending 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 XmNhighlightedCells 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.
            Possible 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
            XmFONTLIST_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
            XbaeMatrixLeaveCellCallbackStruct 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  XmNtopRow  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
            XbaeMatrixModifyVerifyCallbackStruct  is  passed to the callbacks.
            See the  description  of  the  XmText(3X)  XmNmodifyVerifyCallback
            resource.

       XmNmultiLineCell
            is  a  boolean  (default False) which specifies whether the matrix
            displays 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
            XmNfixedColumns 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()
            action 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
            _MOTIF_DEFAULT_LOCALE if no tag has been set  on  the  cell  using
            XbaeMatrixSetCellTag.  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
            _MOTIF_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
            dynamically resized by the user.

       XmNreverseSelect
            Overrides     the      default      XmNselectedForeground      and
            XmNselectedBackground  and  draws  a  selected cell in the colours
            specified by XmNcellBackgrounds 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
            XmALIGNMENT_BEGINNING, XmALIGNMENT_CENTER or XmALIGNMENT_END.  See
            the     description     of     XmNalignment    for    XmLabel(3X).
            XmNrowLabelAlignment defaults 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 XmNrowLabels.  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
            visible 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
            XmNrowLabels  must  change  or  be  NULL.   The  preferred  way to
            dynamically   change   the   number   of   rows    is    to    use
            XbaeMatrixAddRows() or XbaeMatrixDeleteRows().

       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()
            action.  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 methods.

       XmNselectScrollVisible
            Specifies whether the matrix will scroll to make the selected cell
            visible.  This flag  is  only  checked  when  cells  are  selected
            programmatically,  as when the user selects a cell with the mouse,
            it will already 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 instead of a String. A cell will be drawn as  selected  if
            the  corresponding  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 replacing 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 visible> + 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
            bottom 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
            column)   which   should   not   be    horizontally    scrollable.
            XmNtrailingFixedColumns    must    be    less   than   XmNcolumns-
            XmNfixedColumns.  Cells in trailing 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
            XbaeMatrixTraverseCellCallbackStruct 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 XbaeInput.

       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
            XbaeMatrixValueChangedCallbackStruct is passed to  the  callbacks.
            See  the  description  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 matrix'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.
            Possible   values   and   their   effects   are    listed    under
            XmNhorizontalScrollBarDisplayPolicy.

       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 XmNfixedColumns that are  specified.   This  feature
            becomes  even  more  apparent  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
            XbaeMatrixWriteCellCallbackStruct is passed to the callbacks.  The
            XmNwriteCellCallback allows data  to  be  written  back  into  the
            application'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
            XmNxmColumnLabels  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  creation  time  (C),  or  set  by  using
       XtSetValues (S), or retrieved by using XtGetValues (G).

       ┌────────────────────────────────────────────────────────────────────────────────────┐
       │                              XmManager Resource Set                                │
       ├────────────────────┬────────────────────┬────────────────┬───────────────────┬─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       ├────────────────────┼────────────────────┼────────────────┼───────────────────┼─────┤
       └────────────────────┴────────────────────┴────────────────┴───────────────────┴─────┘
       ┌──────────────────────────────────────────────────────────────────────┐
       │                       Composite Resource Set                         │
       ├──────────────────┬───────────────────┬─────────────┬─────────┬───────┤
       │Name              │ Class             │Type         │Default  │Access │
       ├──────────────────┼───────────────────┼─────────────┼─────────┼───────┤
       │XmNchildren       │ XmCReadOnly       │WidgetList   │NULL     │G      │
       ├──────────────────┼───────────────────┼─────────────┼─────────┼───────┤
       │XmNinsertPosition │ XmCInsertPosition │XtOrderProc  │NULL     │CSG    │
       ├──────────────────┼───────────────────┼─────────────┼─────────┼───────┤
       │XmNnumChildren    │ XmCReadOnly       │Cardinal     │0        │G      │
       └──────────────────┴───────────────────┴─────────────┴─────────┴───────┘
       ┌─────────────────────────────────────────────────────────────────────────────────────────────────┐
       │                                       Core Resource Set                                         │
       ├────────────────────────────┬────────────────────────────┬─────────────┬───────────────────┬─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       ├────────────────────────────┼────────────────────────────┼─────────────┼───────────────────┼─────┤
       └────────────────────────────┴────────────────────────────┴─────────────┴───────────────────┴─────┘

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 available.

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

            Each  of  the  members  are  set to the appropriate struct for the
            callback.

            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
            DefaultAction() action  occurs.   The  application  can  bind  the
            DefaultAction()  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
                      occurred.

            column    The column number of the cell in which the double  click
                      occurred.

            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 particular 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.

            foreground
                      The foreground color of the cell.

            background
                      The 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 application 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
            XGetGeometry().   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
            XmNcolumnAlignments.

            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
            XmNwriteCellCallback described below.

       XmNenterCellCallback
            Callbacks  on  the  XmNenterCellCallback  list are called from the
            EditCell() action just before a cell is edited to  determine  it's
            editability.  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
                      converted to the appropriate case when set to True.  The
                      default 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 underneath 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_params
                      The number of String parameters passed to the EditCell()
                      action.

            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  XmNpendingDelete 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
            button label has been activated via a mouse click.  A  pointer  to
            the  following  structure  is  passed  to  each  callback  on  the
            XmNlabelActivateCallback 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
                      label,  then  this  value  is  set to True.  If it was a
                      column label 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
            XmNlabelActivateCallback 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
            EditCell()  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
                      modified,  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
                      actually be stored into  XbaeMatrix.   Setting  doit  to
                      False  will  cause  the  changes to be discarded and the
                      cell will retain 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 application 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()
            action  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 XmNprocessDragCallback 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 convenience 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 application.

            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_params
                      The  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
                      convenience).

            column    Set to the number of colums in the matrix (provided  for
                      convenience).

            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 widget 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
                      ResizeColumn() 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
            SelectCell() 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 XmNselectCellCallback 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_params
                      The   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  contains  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
\
                            Shift<Btn1Down>:   SelectCell(cell)
\
                            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  XbaeMatrixTrackCellCallbackStruct  structure is being passed.
            Its fields are defined 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
            EditCell() action and when XbaeMatrix receives  or  looses  focus.
            The   application   can   customize  cell  traversal  using  these
            callbacks.  XbaeMatrix has a  default  traversal  order,  outlined
            below,  which  the  application  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_rows
                      The 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
                      provided  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 special parameters which it uses to  implement  it's  default
            cell traversal. 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,
                      XmNfixedColumns), 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 results in the next_row and next_column fields of
            the XbaeMatrixTraverseCellCallbackStruct.  If EditCell() does  not
            recognize  it's parameter, 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 parameter 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
            corresponding  new  calculation.   It  would  do  this  by binding
            EditCell() with a new application specific parameter to  an  event
            in a translation table.  It is expected that application callbacks
            will use the XrmQuark version  of  the  parameter  for  efficiency
            reasons  (by  statically  creating the new XrmQuarks and comparing
            them against the incoming qparam).

            When  XbaeMatrix  receives  the  focus  it  will  also  call   the
            XmNtraverseCellCallback  callbacks before returning to the current
            cell or the upper left most visible cell if no cell  is  currently
            edited.  The  XbaeMatrixTraverseCellCallbackStruct 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
            XmNtraverseCellCallback 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
            XmNwriteCellCallback as NULL.

Translations

       XbaeMatrix  inherits  translations  from   XmManager.    In   addition,
       XbaeMatrix uses the following translation:

       :<Btn1Up>:                 DefaultAction()
\
       :<Btn1Down>:               DefaultAction() EditCell(Pointer)
\
       :Shift<Btn2Down>:          ResizeColumns()
\
       :<Btn2Down>:               ProcessDrag()
\
       :<Btn1Motion>:             HandleMotion() HandleTracking()()
\
       :<Motion>:                 HandleTracking()()
\
       :<Btn4Down>:               ScrollRows(-50)()
<Btn5Down>:

       XbaeMatrix  installs  the  following default XmNtextTranslations on the
       TextField edit widget:

       #override
\
       Shift ~Ctrl ~Meta ~Alt <Key>Tab:   EditCell(Left)
\
       ~Ctrl ~Meta ~Alt <Key>Tab:         EditCell(Right)
\
       <Key>osfUp:                        EditCell(Up)
\
       <Key>osfDown:                      EditCell(Down)
\
       <Key>osfActivate:                  CommitEdit(False)
\
       ~Shift ~Meta ~Alt <Key>Return:     CommitEdit(False)
\
       <Key>osfCancel:                    CommitEdit(False)
\
       Shift Ctrl ~Meta ~Alt <Key>Tab:    TraversePrev()
\
       Ctrl ~Meta ~Alt <Key>Tab:          TraverseNext()
\
       <Key>osfPageDown:                  PageDown()
\
       <Key>osfPageUp:                    PageUp()

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
              successive   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
              callbacks  on  the XmNtraverseCellCallback list to allow them to
              specify  a  different  cell  to  edit  (see  the  discussion  of
              XmNtraverseCellCallback   above).   EditCell()  then  calls  the
              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 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 XmNenterCellCallback callbacks.

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

       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 SelectCell()  action,  among
              other   things  (see  the  discussion  of  XmNselectCellCallback
              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
              widget 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
              unsigned      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 resource files.

       CvtStringToMatrixScrollBarDisplayPolicy()
              Converts     a     single     string     as     discussed     in
              XmNhorizontalScrollBarDisplayPolicy                          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  
  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 
 delimited
              rows to a two dimensional array of Pixel values. This  converter
              allows   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  XmNrowButtonLabels  resources  to  be
              specified in resource files.

Public Functions

       The  following  external  entry  points to XbaeMatrix class methods are
       defined:

       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
                        argument 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  array  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.

              alignments
                        Points to an array of unsigned char, or  NULL.   These
                        values will be used as the XmNcolumnAlignments for the
                        new  columns.   The   alignments   array   must   have
                        num_columns  elements.  If  alignments  is  NULL, then
                        XmALIGNMENT_BEGINNING will be used.

              label_alignments
                        Points to an array of unsigned char, or  NULL.   These
                        values  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 XmNforeground will be used.

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

              XbaeMatrixAddColumns()   allows  the  application  developer  to
              dynamically 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 arguments to XbaeMatrixAddColumns() may  be
              specified as NULL.  Default values will be used by the widget.

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

              To maintain backward compatibility, the cell backgrounds  cannot
              be  set  in a call to XbaeMatrixAddColumns() and must be set (if
              so desired) 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 table 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 compatibility, 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
              programmatically  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 unmapped.

       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
              dynamically  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
              dynamically  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
              programmatically  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
              programmatically  deselect  a  cell.    XbaeMatrixDeselectCell()
              redraws  the  cell in normal video. The corresponding Boolean in
              the XmNselectedCells 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
              programmatically  deselect a column.  XbaeMatrixDeselectColumn()
              draws the column in normal video. The corresponding Booleans  in
              the XmNselectedCells 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
              programmatically 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 immediate visual updates. When multiple changes are made
              with redisplay enabled, visual  flashing  often  occurs.   These
              routines help eliminate 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
              specific 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.  Otherwise  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 XmNenterCellCallback 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.

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

       XbaeMatrixEventToXY()

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

              w         An XbaeMatrix widget.

              event     An   X   event  structure  pointer,  usually  from  an
                        XEventHandler 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
              traverses  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
              selected row in the XbaeMatrix widget.  The  function  traverses
              the  matrix 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
                        retrieved.

              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
                        retrieved.

              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
                        retrieved.

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

              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
              associated 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
              XbaeMatrixSetColumnUserData().   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
              determine 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
              currently selected in the given matrix.  The widget maintains an
              internal variable as cells are  selected  and  deselected  so  a
              complete traversal 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
              XbaeMatrixSetRowUserData().   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 associated  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
              programmatically  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
              programmatically           highlight          a          column.
              XbaeMatrixHighlightColumn()  draws  the  highlight  around   the
              column  if  XmNgridType  is  XmGRID_COLUMN_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
              programmatically  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
              determine  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
              determine 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
              determine  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
              determine  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
              determine whether or not  a  particular  row  is  selected.  The
              function   returns  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
              determine 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 detected 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 until  a  redraw  is
              preformed because of a resize or scroll event (assuming 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
              efficiently 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
              efficiently 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
                        coordinates of the given cell.

              y         The  y  coordinate  returned that represents the upper
                        coordinates 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
              programmatically   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
              programmatically select a  cell.   XbaeMatrixSelectCell()  first
              scrolls  the  specified cell until it is visible, and then draws
              the   cell   in   reverse   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
              programmatically   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
              programmatically  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 corresponding 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
              programmatically 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 XmNcells 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
              XbaeMatrixSetCellBackground()  will   create   a   Pixel   table
              initialized  to  XmNforeground  except for the cell specified in
              it's  arguments.  If  XmNcellBackgrounds  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  XbaeMatrixSetCellColor() 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
                        variable

              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
              programmatically 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
              programmatically  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
              programmatically  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
              matrix  cell.   The  cell  is selected by specifying its row and
              column , widget is the cell widget to be  associated  with  that
              cell.   XbaeMatrix  will  manage  the cell widget's position and
              size so it is displayed 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;

              XbaeMatrixSetCellWidget()  is a function to attach a widget to a
              matrix cell.  The cell is selected by  specifying  its  row  and
              column  ,  widget  is the cell widget to be associated with that
              cell.  XbaeMatrix will manage the  cell  widget's  position  and
              size  so it is displayed 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.

       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 XmNcolumns.

              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_colors
                        The 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 initialized to XmNforeground except for the columns
              specified in it's arguments. If XmNcellBackgrounds is not  NULL,
              then XbaeMatrixSetColumnBackgrounds() 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
                        (position + num_colors) must be less than or equal  to
                        XmNcolumns.

              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_colors
                        The number of colors in the colors array.

              XbaeMatrixSetColumnColors()  is  a convenient way to specify and
              modify the XmNcolors resource  when  setting  the  color  of  an
              entire   column   or   columns.   If  XmNcolors  is  NULL,  then
              XbaeMatrixSetColumnColors()   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
              programmatically 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
              programmatically 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
                        colors.  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_colors
                        The 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 XbaeMatrixSetRowBackgrounds()  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
                        colors.  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_colors
                        The 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 create a Pixel  table  initialized
              to   XmNforeground   except  for  the  rows  specified  in  it's
              arguments.    If     XmNcolors     is     not     NULL,     then
              XbaeMatrixSetRowColors() 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 default 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
              programmatically 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
              programmatically 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
              programmatically 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
              programmatically 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
              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  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 matrix being sorted, the indices of two rows  to
              compare  and the user_data pointer XbaeMatrixSortRows 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.

       XbaeMatrixUnhighlightAll()

              void XbaeMatrixUnhighlightAll()
                       Widget         w;

              w         An XbaeMatrix widget.

              XbaeMatrixUnhighlightAll()  allows  the application developer to
              programmatically         unhighlight         all          cells.
              XbaeMatrixUnhighlightAll()  erases the highlight from all cells.
              All unsigned chars in the XmNhighlightedCells 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
              programmatically          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.
              XbaeMatrixUnhighlightColumn()  erases  the highlight from around
              the column if XmNgridType is XmGRID_COLUMN_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  cleared,  depending on
              whether XmNgridType is set to XmGRID_COLUMN_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
              programmatically  unhighlight a row.  XbaeMatrixUnhighlightRow()
              erases the highlight from  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
              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_row
                        The last row that is currently visible in the matrix.

              left_column
                        The  leftmost  column that is currently visible in the
                        matrix.

              right_column
                        The rightmost column that is currently visible in  the
                        matrix.

              XbaeMatrixVisibleCells() allows the the application developer to
              obtain 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
              programmatically 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
              representation  of  the  version  of  the Xbae library that your
              program is working 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
              major,  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
              representation  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),
       XmText(3X)

Notice of Limitation

       Bellcore,   previous  and  current  maintainers  of  the  Xbae  widgets
       (collectively   'authors')   provide   this   information   solely   to
       professionals   who  have  the  appropriate  degree  of  experience  to
       understand and interpret its  contents  in  accordance  with  generally
       accepted  engineering  or  other  professional standards and applicable
       regulations. No recommendations as to products 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
       information  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 INTELLECTUAL 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 RELATING TO THE INFORMATION.

       Copyright 1991, 1992 Bellcore.
       Copyright 1995-99 Andrew Lister All Rights Reserved.
       Copyright 1999-2002 LessTif Developers

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



  All copyrights belong to their respective owners. Other content (c) 2014-2018, GNU.WIKI. Please report site errors to webmaster@gnu.wiki.
Page load time: 0.061 seconds. Last modified: November 04 2018 12:49:43.