XmText man page on RedHat

Man page or keyword search:  
man Server   29550 pages
apropos Keyword Search (all sections)
Output format
RedHat logo
[printable version]

XmText(library call)					  XmText(library call)

NAME
       XmText — The Text widget class

SYNOPSIS
       #include <Xm/Text.h>

DESCRIPTION
       Text  provides  a single-line and multiline text editor for customizing
       both user and programmatic interfaces. It can be used  for  single-line
       string entry, forms entry with verification procedures, and full-window
       editing.	 It provides an application with a consistent  editing	system
       for  textual data. The screen's textual data adjusts to the application
       writer's needs.

       Text provides separate callback lists to verify movement of the	insert
       cursor,	modification  of the text, and changes in input focus. Each of
       these callbacks provides the  verification  function  with  the	widget
       instance, the event that caused the callback, and a data structure spe‐
       cific to the verification type. From this information, the function can
       verify  if  the	application  considers	this  to be a legitimate state
       change and can signal the widget whether to continue with the action.

       The user interface tailors a  new  set  of  translations.  The  default
       translations provide key bindings for insert cursor movement, deletion,
       insertion, and selection of text.

       Text allows the user to select regions of text.	Selection is based  on
       the  model specified in the Inter-Client Communication Conventions Man‐
       ual (ICCCM). Text supports primary and secondary selection.

       In some Asian languages, texts are drawn vertically. Also, some charac‐
       ters are displayed with 90-degree clockwise rotation, and other charac‐
       ters are mapped to vertical glyphs that differ from the normal  horiza‐
       ontal  glyphs.	Information about which characters require rotation or
       mapping to vertical glyphs is specified in the X Locale	Database  (NLS
       databases)  and	handled	 by  X library, depending on XNOrientation XOC
       values.	XmText widget should also handle the vertically aligned	 lines
       as for editing, entering, or selecting texts.

       The  vertical  writing feature of the XmText widget is enabled when the
       XmTOP_TO_BOTTOM value is specified for the XmNlayoutDirection  resource
       of  the	XmText widget. In that case, the horizontal scroll bar is dis‐
       played on the bottom of the XmText widget and the vertical  scroll  bar
       is displayed on the left side.

   Mouse Selection
       The  Text widget allows text to be edited, inserted, and selected.  The
       user can cut, copy, and paste text  by  using  the  clipboard,  primary
       transfer,  or  secondary	 transfer.  Text also provides a Drag and Drop
       facility that enables the user to copy or move data within Text or to a
       different  widget.   When keyboard focus policy is set to EXPLICIT, the
       widget that receives focus is the destination widget. In POINTER	 mode,
       any  keyboard  or  mouse	 operation  (except secondary selection) in an
       editable widget establishes that widget as the destination.

       If a destination widget becomes insensitive or uneditable, it  forfeits
       its  destination status. In EXPLICIT mode, when a widget becomes insen‐
       sitive, the focus moves to another widget. If that widget is  editable,
       it  becomes  the destination widget; otherwise, there is no destination
       widget. The text of any insensitive Text widget is stippled, indicating
       its state to the user.

       The  insertion  cursor,	displayed  as  an I-beam, shows where input is
       inserted. Input is inserted just before the insertion cursor.

       Text uses the XmQTnavigator,  XmQTspecifyRenderTable,  and  XmQTscroll‐
       Frame  traits, and holds the XmQTaccessTextual and XmQTtransfer traits.
       The widget checks its parent for the  XmQTscrollFrame  trait.  If  this
       trait  does  not	 exist, then the widget has no scrolling. If the trait
       does exist, and the ScrollFrame widget has not  been  initialized,  the
       widget creates two navigators and sets up the scrollbars.

       If  an application or widget calls the setValue trait method of XmQTac‐
       cessTextual, then XmText will call XmTextSetString to  set  the	string
       value.

   Classes
       Text  inherits  behavior,  resources, and traits from Core and XmPrimi‐
       tive.

       The class pointer is xmTextWidgetClass.

       The class name is XmText.

   Data Transfer Behavior
       Text supports transfer of the primary, secondary, and clipboard	selec‐
       tions  and dragging of selected text from the widget.  Text can also be
       the destination for the primary, secondary, and	clipboard  selections,
       and it supports dropping of data being dragged onto the widget.

       When  the  XmNconvertCallback  procedures are called, the location_data
       member of the XmConvertCallbackStruct member is NULL  if	 the  selected
       text  is being transferred.  If the entire text, not the selected text,
       is being transferred, the value of this member is the widget ID of  the
       Text widget.

       As a source of data, Text supports the following targets and associated
       conversions of data to these targets:

       locale	 If the locale target matches the widget's locale, the	widget
		 transfers the selected text in the encoding of the locale.

       COMPOUND_TEXT
		 The widget transfers the selected text as type COMPOUND_TEXT.

       STRING	 The widget transfers the selected text as type STRING.

       TEXT	 If  the selected text is fully convertible to the encoding of
		 the locale, the widget transfers the  selected	 text  in  the
		 encoding  of the locale.  Otherwise, the widget transfers the
		 selected text as type COMPOUND_TEXT.

       UTF8_STRING
		 The widget transfers the selected text as type UTF8_STRING.

       DELETE	 The widget deletes the selected text.

       _MOTIF_CLIPBOARD_TARGETS
		 The widget transfers, as type ATOM, a list of the targets  to
		 which	the  widget can convert data to be placed on the clip‐
		 board immediately.  If the selected text is fully convertible
		 to STRING, these include STRING; otherwise, they include COM‐
		 POUND_TEXT.

       _MOTIF_DEFERRED_CLIPBOARD_TARGETS
		 The widget transfers, as type ATOM, a list of the targets  it
		 supports  for	delayed	 transfer for the CLIPBOARD selection.
		 This	widget	 currently    supplies	  no	targets	   for
		 _MOTIF_DEFERRED_CLIPBOARD_TARGETS.

       _MOTIF_EXPORT_TARGETS
		 The  widget transfers, as type ATOM, a list of the targets to
		 be used as the value of the DragContext's XmNexportTargets in
		 a   drag-and-drop  transfer.	These  include	COMPOUND_TEXT,
		 UTF8_STRING, the encoding of the locale, STRING, TEXT,	 BACK‐
		 GROUND, and FOREGROUND.

       _MOTIF_LOSE_SELECTION
		 The widget takes the following actions:

		    ·  When  losing the PRIMARY selection, it unhighlights the
		       selected text and calls the XmNlosePrimaryCallback pro‐
		       cedures.

		    ·  When  losing  the  SECONDARY  selection, it removes the
		       secondary selection highlight.

		    ·  When losing the _MOTIF_DESTINATION  selection,  if  the
		       widget  does  not  have focus, it changes the cursor to
		       indicate that the widget is no longer the destination.

       As a source of data, Text also supports the  following  standard	 Motif
       targets:

       BACKGROUND
		 The widget transfers XmNbackground as type PIXEL.

       CLASS	 The widget finds the first shell in the widget hierarchy that
		 has a WM_CLASS property and transfers the contents as text in
		 the current locale.

       CLIENT_WINDOW
		 The  widget finds the first shell in the widget hierarchy and
		 transfers its window as type WINDOW.

       COLORMAP	 The widget transfers XmNcolormap as type COLORMAP.

       FOREGROUND
		 The widget transfers XmNforeground as type PIXEL.

       NAME	 The widget finds the first shell in the widget hierarchy that
		 has  a WM_NAME property and transfers the contents as text in
		 the current locale.

       TARGETS	 The widget transfers, as type ATOM, a list of the targets  it
		 supports.   These  include the standard targets in this list.
		 These also include COMPOUND_TEXT, UTF8_STRING,	 the  encoding
		 of the locale, STRING, and TEXT.

       TIMESTAMP The widget transfers the timestamp used to acquire the selec‐
		 tion as type INTEGER.

       _MOTIF_RENDER_TABLE
		 The widget transfers XmNrenderTable if it exists, or else the
		 default text render table, as type STRING.

       _MOTIF_ENCODING_REGISTRY
		 The  widget  transfers	 its encoding registry as type STRING.
		 The value is a list of NULL separated items in	 the  form  of
		 tag encoding pairs.  This target symbolizes the transfer tar‐
		 get for the Motif Segment  Encoding  Registry.	  Widgets  and
		 applications  can use this Registry to register text encoding
		 formats for specified render table tags.  Applications access
		 this	Registry   by  calling	XmRegisterSegmentEncoding  and
		 XmMapSegmentEncoding.

       As a destination for data, Text chooses a target and  requests  conver‐
       sion of the selection to that target.  If the encoding of the locale is
       present in the list of available targets, Text chooses a requested tar‐
       get from the available targets in the following order of preference:

	  1. The encoding of the locale

	  2. TEXT

	  4. UTF8_STRING

	  3. COMPOUND_TEXT

	  4. STRING

       If  the	encoding of the locale is not present in the list of available
       targets, Text chooses a requested target from the available targets  in
       the following order of preference:

	  4. UTF8_STRING

	  1. COMPOUND_TEXT

	  2. STRING

   New Resources
       The  following table defines a set of widget resources used by the pro‐
       grammer to specify data. The programmer can also set the resource  val‐
       ues  for	 the  inherited	 classes to set attributes for this widget. To
       reference a resource by name or by class in a .Xdefaults	 file,	remove
       the  XmN or XmC prefix and use the remaining letters. To specify one of
       the defined values for a resource in a .Xdefaults file, remove  the  Xm
       prefix and use the remaining letters (in either lowercase or uppercase,
       but include any underscores between words).  The codes  in  the	access
       column  indicate if the given resource can be set at creation time (C),
       set by using XtSetValues (S), retrieved by using XtGetValues (G), or is
       not applicable (N/A).

       ┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐
       │			   │		 XmText Resource Set		│		     │	      │
       │Name			   │ Class		       │ Type		│ Default	     │ Access │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNactivateCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNautoShowCursorPosition  │ XmCAutoShowCursorPosition │ Boolean	│ True		     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNcursorPosition	   │ XmCCursorPosition	       │ XmTextPosition │ 0		     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNcursorPositionVisible   │ XmCCursorPositionVisible  │ Boolean	│ dynamic	     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNdestinationCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNeditable		   │ XmCEditable	       │ Boolean	│ True		     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNeditMode		   │ XmCEditMode	       │ int		│ XmSINGLE_LINE_EDIT │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNfocusCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNgainPrimaryCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNlosePrimaryCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNlosingFocusCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNmarginHeight		   │ XmCMarginHeight	       │ Dimension	│ 5		     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNmarginWidth		   │ XmCMarginWidth	       │ Dimension	│ 5		     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNmaxLength		   │ XmCMaxLength	       │ int		│ largest integer    │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNmodifyVerifyCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNmodifyVerifyCallbackWcs │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNmotionVerifyCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmtotalLines		   │ XmCTotalLines	       │ int		│ dynamic	     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNsource		   │ XmCSource		       │ XmTextSource	│ Default source     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNtopCharacter		   │ XmCTopCharacter	       │ XmTextPosition │ 0		     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNvalue		   │ XmCValue		       │ String		│ ""		     │ CSG    │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNvalueChangedCallback	   │ XmCCallback	       │ XtCallbackList │ NULL		     │ C      │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNvalueWcs		   │ XmCvalueWcs	       │ wchar_t *	│ (wchar_t *)""	     │ CSG1   │
       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
       │XmNverifyBell		   │ XmCVerifyBell	       │ Boolean	│ dynamic	     │ CSG    │
       └───────────────────────────┴───────────────────────────┴────────────────┴────────────────────┴────────┘
       1 This resource cannot be set in a resource file.

       XmNactivateCallback
		 Specifies  the list of callbacks that is called when the user
		 invokes an event that calls the activate() action.  The  type
		 of  the structure whose address is passed to this callback is
		 XmAnyCallbackStruct.  The reason  sent	 by  the  callback  is
		 XmCR_ACTIVATE.

       XmNautoShowCursorPosition
		 Ensures that the visible text contains the insert cursor when
		 set to True.  If the insert cursor changes, the  contents  of
		 Text  may  scroll  in order to bring the insertion point into
		 the window.  Setting this resource to	False,	however,  does
		 not ensure that Text will not scroll.

       XmNcursorPosition
		 Indicates  the	 position in the text where the current insert
		 cursor is to be located.  Position is determined by the  num‐
		 ber  of characters from the beginning of the text.  The first
		 character position is 0 (zero).

       XmNcursorPositionVisible
		 If the widget has an XmPrintShell as one  of  its  ancestors,
		 then the default value is False; otherwise, it is True.

       XmNdestinationCallback
		 Specifies  a  list of callbacks called when the widget is the
		 destination of a transfer operation.  The type of the	struc‐
		 ture whose address is passed to these callbacks is XmDestina‐
		 tionCallbackStruct.  The reason is XmCR_OK.

       XmNeditable
		 When set to True, indicates that the user can edit  the  text
		 string.  Prohibits the user from editing the text when set to
		 False.

		 When XmNeditable is used on a widget it sets the dropsite  to
		 XmDROP_SITE_ACTIVE.

       XmNeditMode
		 Specifies  the	 set  of  keyboard bindings used in Text.  The
		 default, XmSINGLE_LINE_EDIT, provides the set of key bindings
		 to  be	 used  in editing single-line text.  XmMULTI_LINE_EDIT
		 provides the set of key bindings to be used in editing multi‐
		 line text.

		 The  results of placing a Text widget inside a ScrolledWindow
		 when the Text's XmNeditMode is XmSINGLE_LINE_EDIT  are	 unde‐
		 fined.

       XmNfocusCallback
		 Specifies  the	 list  of  callbacks  called when Text accepts
		 input focus. The type	of  the	 structure  whose  address  is
		 passed	 to  this callback is XmAnyCallbackStruct.  The reason
		 sent by the callback is XmCR_FOCUS.

       XmNgainPrimaryCallback
		 Specifies the list of callbacks called when an	 event	causes
		 the  Text  widget to gain ownership of the primary selection.
		 The reason sent by the callback is XmCR_GAIN_PRIMARY.

       XmNlosePrimaryCallback
		 Specifies the list of callbacks called when an	 event	causes
		 the  Text  widget to lose ownership of the primary selection.
		 The reason sent by the callback is XmCR_LOSE_PRIMARY.

       XmNlosingFocusCallback
		 Specifies the list of	callbacks  called  before  Text	 loses
		 input	focus.	 The  type  of	the structure whose address is
		 passed to this callback is  XmTextVerifyCallbackStruct.   The
		 reason sent by the callback is XmCR_LOSING_FOCUS.

       XmNmarginHeight
		 Specifies  the	 distance  between  the top edge of the widget
		 window and the text, and between the bottom edge of the  wid‐
		 get window and the text.

       XmNmarginWidth
		 Specifies  the	 distance  between the left edge of the widget
		 window and the text, and between the right edge of the widget
		 window and the text.

       XmNmaxLength
		 Specifies  the	 maximum length of the text string that can be
		 entered into text from the keyboard. This value must be  non‐
		 negative.   Strings  that  are	 entered by using the XmNvalue
		 resource  or  the  XmTextSetString   function	 ignore	  this
		 resource.

       XmNmodifyVerifyCallback
		 Specifies the list of callbacks called before text is deleted
		 from or inserted into Text.  The type of the structure	 whose
		 address  is  passed to this callback is XmTextVerifyCallback‐
		 Struct.  The reason sent  by  the  callback  is  XmCR_MODIFY‐
		 ING_TEXT_VALUE.   When	 multiple  Text widgets share the same
		 source, only the widget that initiates the source change will
		 generate XmNmodifyVerifyCallback.

		 If  both XmNmodifyVerifyCallback and XmNmodifyVerifyCallback‐
		 Wcs are registered callback lists, the	 procedure(s)  in  the
		 XmNmodifyVerifyCallback  list	is  always executed first; and
		 the resulting data, which may have been modified,  is	passed
		 to the XmNmodifyVerifyCallbackWcs callback routines.

       XmNmodifyVerifyCallbackWcs
		 Specifies the list of callbacks called before text is deleted
		 from or inserted into Text. The type of the  structure	 whose
		 address  is  passed to this callback is XmTextVerifyCallback‐
		 StructWcs. The reason sent by the  callback  is  XmCR_MODIFY‐
		 ING_TEXT_VALUE.   When	 multiple  Text widgets share the same
		 source, only the widget that initiates the source change will
		 generate the XmNmodifyVerifyCallbackWcs.

		 If  both XmNmodifyVerifyCallback and XmNmodifyVerifyCallback‐
		 Wcs are registered callback lists, the	 procedure(s)  in  the
		 XmNmodifyVerifyCallback  list	is  always executed first; and
		 the resulting data, which may have been modified,  is	passed
		 to the XmNmodifyVerifyCallbackWcs callback routines.

       XmNmotionVerifyCallback
		 Specifies the list of callbacks called before the insert cur‐
		 sor is moved to a new position.  The type  of	the  structure
		 whose address is passed to this callback is XmTextVerifyCall‐
		 backStruct.  The reason sent by  the  callback	 is  XmCR_MOV‐
		 ING_INSERT_CURSOR.   It  is possible for more than one XmNmo‐
		 tionVerifyCallback to be generated from a single action.

       XmNsource Specifies the source with which the widget displays text.  If
		 no  source  is specified, the widget creates a default string
		 source.  This resource can be	used  to  share	 text  sources
		 between Text widgets.

       XmNtopCharacter
		 Displays  the	position  of  text  at	the top of the window.
		 Position is determined by the number of characters  from  the
		 beginning  of	the  text.   The first character position is 0
		 (zero).

		 If the XmNeditMode is XmMULTI_LINE_EDIT,  the	line  of  text
		 that  contains	 the  top character is displayed at the top of
		 the widget without shifting the text left or  right.	XtGet‐
		 Values	 for XmNtopCharacter returns the position of the first
		 character in the line that is displayed at  the  top  of  the
		 widget.

       XmNtotalLines
		 Indicates  the number of lines in the text widget buffer (not
		 necessarily visible). The initial value 1 means the text buf‐
		 fer is empty. The number of lines reported takes into account
		 the wordWrap policy (that is, it's not simply the  number  of
		 newline characters.

       XmNvalue	 Specifies the string value of the Text widget as a char* data
		 value.	 Moves the cursor to position 0 unless a value of XmN‐
		 cursorPosition	 was explicitly supplied in the argument list.
		 If XmNvalue and XmNvalueWcs are both defined,	the  value  of
		 XmNvalueWcs  supersedes that of XmNvalue. XtGetValues returns
		 a copy of the value of the internal  buffer  and  XtSetValues
		 copies the string values into the internal buffer.

       XmNvalueChangedCallback
		 Specifies  the list of callbacks called after text is deleted
		 from or inserted into Text.  The type of the structure	 whose
		 address  is  passed  to this callback is XmAnyCallbackStruct.
		 The reason sent by the callback is XmCR_VALUE_CHANGED.	  When
		 multiple  Text widgets share the same source, only the widget
		 that initiates the source change will	generate  the  XmNval‐
		 ueChangedCallback.  This  callback represents a change in the
		 source in the Text, not  in  the  Text	 widget.  The  XmNval‐
		 ueChangedCallback should occur only in pairs with an XmNmodi‐
		 fyVerifyCallback, assuming that the doit flag in the callback
		 structure of the XmNmodifyVerifyCallback is not set to False.

       XmNvalueWcs
		 Specifies  the	 string value of the Text widget as a wchar_t*
		 data value.  Moves the cursor to position 0 unless a value of
		 XmNcursorPosition  was	 explicitly  supplied  in the argument
		 list.

		 This resource cannot be specified in a resource file.

		 If XmNvalue and XmNvalueWcs are both defined,	the  value  of
		 XmNvalueWcs supersedes that of XmNvalue.  XtGetValues returns
		 a copy of the value of the internal buffer encoded as a  wide
		 character  string.  XtSetValues  copies the value of the wide
		 character string into the internal buffer.

       XmNverifyBell
		 Specifies whether the bell should sound when the verification
		 returns  without  continuing the action.  The default depends
		 on the value of the ancestor VendorShell's  XmNaudibleWarning
		 resource.

		 ┌─────────────────────────────────────────────────────────────────────────────────────┐
		 │			       XmText Input Resource Set			       │
		 │Name			   Class		    Type	Default		Access │
		 │XmNpendingDelete	   XmCPendingDelete	    Boolean	True		CSG    │
		 │XmNselectionArray	   XmCSelectionArray	    XtPointer	default array	CSG    │
		 │XmNselectionArrayCount   XmCSelectionArrayCount   int		4		CSG    │
		 │XmNselectThreshold	   XmCSelectThreshold	    int		5		CSG    │
		 └─────────────────────────────────────────────────────────────────────────────────────┘
       XmNpendingDelete
		 Indicates  that  pending  delete  mode is on when the Boolean
		 value is True.	 Pending deletion is defined  as  deletion  of
		 the selected text when an insertion is made.

       XmNselectionArray
		 Defines  the  actions for multiple mouse clicks. The value of
		 the  resource	is  an	array  of   XmTextScanType   elements.
		 XmTextScanType is an enumeration indicating possible actions.
		 Each mouse click performed within some time of	 the  previous
		 mouse click increments the index into this array and performs
		 the defined action for that index. (This "multiclick" time is
		 specified by the operating environment, and varies among dif‐
		 ferent systems. In general, it is usually set to  some	 frac‐
		 tion  of  a  second.)	The possible actions in the order they
		 occur in the default array are as follows:

		    3. XmSELECT_POSITION, which resets the insert cursor posi‐
		       tion.

		    4. XmSELECT_WORD, which selects a word.

		    5. XmSELECT_LINE,  which  selects  a  line	of  text. This
		       action sees a line as delimited by hard newline charac‐
		       ters.  In  other	 words, if the word wrap feature is on
		       (XmNwordWrap is True), this will	 ignore	 the  newlines
		       automatically  inserted	by  the	 widget.  This	is the
		       default.

		    6. XmSELECT_OUT_LINE, which selects a line of  text.  This
		       action sees a line as delimited by hard or soft newline
		       characters. In other words, if the word wrap feature is
		       on  (XmNwordWrap	 is  True), the newlines automatically
		       inserted by the widget will be  treated	as  delimiting
		       lines.

		    7. XmSELECT_ALL, which selects all of the text.

       XmNselectionArrayCount
		 Indicates  the	 number	 of  elements in the XmNselectionArray
		 resource.  The value must not be negative.

       XmNselectThreshold
		 Specifies the number of pixels of motion that is required  to
		 select	 the  next character when selection is performed using
		 the click-drag mode of selection.  The value must not be neg‐
		 ative.	 This resource also specifies whether a drag should be
		 started and the  number  of  pixels  to  start	 a  drag  when
		 Btn2Down and Btn1Down are integrated.

		 ┌───────────────────────────────────────────────────────────────────────────────────────┐
		 │				XmText Output Resource Set				 │
		 │Name			     Class			Type		Default	  Access │
		 │XmNblinkRate		     XmCBlinkRate		int		500	  CSG	 │
		 │XmNcolumns		     XmCColumns			short		dynamic	  CSG	 │
		 │XmNcursorPositionVisible   XmCCursorPositionVisible	Boolean		True	  CSG	 │
		 │XmNfontList		     XmCFontList		XmFontList	dynamic	  CSG	 │
		 │XmNrenderTable	     XmCRenderTable		XmRenderTable	dynamic	  CSG	 │
		 │XmNresizeHeight	     XmCResizeHeight		Boolean		False	  CSG	 │
		 │XmNresizeWidth	     XmCResizeWidth		Boolean		False	  CSG	 │
		 │XmNrows		     XmCRows			short		dynamic	  CSG	 │
		 │XmNwordWrap		     XmCWordWrap		Boolean		False	  CSG	 │
		 └───────────────────────────────────────────────────────────────────────────────────────┘
       XmNblinkRate
		 Specifies  the blink rate of the text cursor in milliseconds.
		 The time indicated in the blink rate relates to the time  the
		 cursor	 is visible and the time the cursor is invisible (that
		 is, the time it takes to blink the insertion  cursor  on  and
		 off  is twice the blink rate). The cursor does not blink when
		 the blink rate is set to 0 (zero).  The  value	 must  not  be
		 negative.

       XmNcolumns
		 Specifies  the initial width of the text window as an integer
		 number of characters. The width equals the number of  charac‐
		 ters  specified  by  this resource multiplied by the width as
		 derived from the specified font. If  the  em-space  value  is
		 available,  it	 is used. If not, the width of the numeral "0"
		 is used. If this is not available, the maximum width is used.
		 For proportionate fonts, the actual number of characters that
		 fit on a given line may be greater than the value  specified.
		 The  value  must  be greater than 0 (zero). The default value
		 depends on the value of the XmNwidth resource.	 If  no	 width
		 is specified the default is 20.

		 When  the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, and
		 if  the  XmText  widget  resource   XmNeditMode   is	XmSIN‐
		 GLE_LINE_EDIT,	 this  attribute  is  ignored.	If no width is
		 specified, the default is 1.

       XmNcursorPositionVisible
		 Indicates that the insert cursor position is marked by a text
		 cursor when the Boolean value is True.

       XmNfontList
		 Specifies the font list to be used for Text. The font list is
		 an obsolete structure and is retained only for	 compatibility
		 with earlier releases of Motif. Use the render table (XmNren‐
		 derTable) instead of font lists wherever  possible.  If  both
		 are specified, the render table will take precedence. If this
		 value is NULL at initialization, the parent hierarchy of  the
		 widget	 is searched for an ancestor that holds the XmQTspeci‐
		 fyRenderTable trait. If such an ancestor is found,  the  font
		 list  is  initialized to the XmTEXT_RENDER_TABLE value of the
		 ancestor widget. If no such ancestor is found, the default is
		 implementation dependent.

		 Text  searches	 the  font  list for the first occurrence of a
		 font set that has XmFONTLIST_DEFAULT_TAG. If a	 default  ele‐
		 ment  is  not	found,	the first font set in the font list is
		 used. If the list contains no font sets, the  first  font  in
		 the  font  list will be used. Refer to XmFontList(3) for more
		 information on a font list structure.

       XmNrenderTable
		 Specifies the render table to be used in deriving a font  set
		 or font for rendering text. If both a render table and a font
		 list are specified, the render table will take precedence. If
		 the  value  of	 XmNrenderTable is NULL at initialization, the
		 parent hierarchy of the widget is searched  for  an  ancestor
		 that  holds  the  XmQTspecifyRenderTable  trait.  If  such an
		 ancestor is found,  the  font	list  is  initialized  to  the
		 XmTEXT_RENDER_TABLE  value of the ancestor widget. If no such
		 ancestor is found, the default is implementation dependent.

		 Text searches the render table for the first occurrence of  a
		 rendition  that  has  the  tag	 _MOTIF_DEFAULT_LOCALE.	 If  a
		 default element is not found, the first rendition in the  ta‐
		 ble  is  used. Refer to XmRenderTable(3) for more information
		 on the render table structure.

       XmNresizeHeight
		 Indicates that Text will attempt  to  resize  its  height  to
		 accommodate  all  the	text  contained in the widget when the
		 Boolean value is True. If the Boolean value is set  to	 True,
		 the  text  is always displayed, starting from the first posi‐
		 tion in  the  source,	even  if  instructed  otherwise.  This
		 attribute  is ignored when the application uses a Text widget
		 whose parent is a ScrolledWindow and  when  XmNscrollVertical
		 is True.

		 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
		 resource indicates that  the  text  attempts  to  resize  its
		 height	 to  accommodate  all the text contained in the widget
		 when the Boolean value is True. This attribute is ignored  if
		 XmNwordWrap is True.

       XmNresizeWidth
		 Indicates  that Text attempts to resize its width to accommo‐
		 date all the text contained in the widget  when  the  Boolean
		 value	is  True.  This attribute is ignored if XmNwordWrap is
		 True.

		 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
		 attribute  is	still  effective  even if XmNwordWrap is True.
		 Also, this attribute is ignored when the application  uses  a
		 text  widget  whose parent is a ScrolledWindow and XmNscroll‐
		 Horizaontal is True.

       XmNrows	 Specifies the initial height of the text window  measured  in
		 character heights. This attribute is ignored if the text wid‐
		 get resource XmNeditMode is  XmSINGLE_LINE_EDIT.   The	 value
		 must  be greater than 0 (zero).  The default value depends on
		 the value of the XmNheight resource.  If no height is	speci‐
		 fied, the default is 1.

		 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
		 attribute is still  effective,	 even  if  the	XmText	widget
		 resource  XmNeditMode	is XmSINGLE_LINE_EDIT. If no height is
		 specified, the default is 20.

       XmNwordWrap
		 Indicates that lines are to be broken at  word	 breaks	 (that
		 is,  the  text	 does not go off the right edge of the window)
		 when the Boolean value is  True.   Words  are	defined	 as  a
		 sequence of characters separated by whitespace. Whitespace is
		 defined as a  space,  tab,  or	 newline.  This	 attribute  is
		 ignored  if  the  text	 widget resource XmNeditMode is XmSIN‐
		 GLE_LINE_EDIT.	 Note that this resource is  only  valid  when
		 the widget is not a scroll one, or, if the widget is a scroll
		 widget, that the XmNscrollHorizontal resource is False.

		 Indicates that lines are to be broken at  word	 breaks	 (that
		 is,  when the XmNlayoutDirection resource is XmTOP_TO_BOTTOM,
		 the text does not go off the bottom edge of the window)  when
		 the Boolean value is True.

       The  following  resources  are  used  only  when	 text  is created in a
       ScrolledWindow. See the reference page for XmCreateScrolledText.

       ┌─────────────────────────────────────────────────────────────────┐
       │		 XmText Scrolling Resource Set			 │
       │Name		      Class	      Type	Default	  Access │
       │XmNscrollHorizontal   XmCScroll	      Boolean	True	  CG	 │
       │XmNscrollLeftSide     XmCScrollSide   Boolean	False	  CG	 │
       │XmNscrollTopSide      XmCScrollSide   Boolean	False	  CG	 │
       │XmNscrollVertical     XmCScroll	      Boolean	True	  CG	 │
       └─────────────────────────────────────────────────────────────────┘
       Note in connection with	this  table  that  if  the  XmNlayoutDirection
       resource is XmTOP_TO_BOTTOM, the default is True.

       XmNscrollHorizontal
		 Adds  a ScrollBar that allows the user to scroll horizontally
		 through text when the Boolean value is True.	This  resource
		 is  forced  to	 False	when  the  Text	 widget is placed in a
		 ScrolledWindow with XmNscrollingPolicy set to XmAUTOMATIC.

		 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
		 attribute  is	ignored if the XmText widget resource XmNedit‐
		 Mode is XmSINGLE_LINE_EDIT.

       XmNscrollLeftSide
		 Indicates that the vertical ScrollBar should be placed on the
		 left  side of the scrolled text window when the Boolean value
		 is True. This attribute is ignored  if	 XmNscrollVertical  is
		 False or the Text resource XmNeditMode is XmSINGLE_LINE_EDIT.

		 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
		 resource is  still  effective,	 even  if  the	XmText	widget
		 resource XmNeditMode is XmSINGLE_LINE_EDIT.

       XmNscrollTopSide
		 Indicates  that  the horizontal ScrollBar should be placed on
		 the top side of the scrolled text  window  when  the  Boolean
		 value is True.

		 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
		 attribute is ignored if XmNscrollHorizontal is False  or  the
		 Xmtext resource XmNeditMode is XmSINGLE_LINE_EDIT.

       XmNscrollVertical
		 Adds  a  ScrollBar  that allows the user to scroll vertically
		 through text when the Boolean value is True.  This  attribute
		 is  ignored  if  the  Text  resource  XmNeditMode  is	XmSIN‐
		 GLE_LINE_EDIT.	 This resource is forced  to  False  when  the
		 Text  widget is placed in a ScrolledWindow with XmNscrolling‐
		 Policy set to XmAUTOMATIC.

		 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
		 resource  is  still  effective,  even	if  the	 XmText widget
		 resource XmNeditMode is XmSINGLE_LINE_EDIT.

   Inherited Resources
       Text inherits behavior and resources from the superclasses described in
       the  following  tables.	 For  a complete description of each resource,
       refer to the reference page for that superclass.

       ┌───────────────────────────────────────────────────────────────────────────────────────────────────┐
       │				     XmPrimitive Resource Set					   │
       │Name			  Class			  Type		     Default		    Access │
       │XmNbottomShadowColor	  XmCBottomShadowColor	  Pixel		     dynamic		    CSG	   │
       │XmNbottomShadowPixmap	  XmCBottomShadowPixmap	  Pixmap	     XmUNSPECIFIED_PIXMAP   CSG	   │
       │XmNconvertCallback	  XmCCallback		  XtCallbackList     NULL		    C	   │
       │XmNforeground		  XmCForeground		  Pixel		     dynamic		    CSG	   │
       │XmNhelpCallback		  XmCCallback		  XtCallbackList     NULL		    C	   │
       │XmNhighlightColor	  XmCHighlightColor	  Pixel		     dynamic		    CSG	   │
       │XmNhighlightOnEnter	  XmCHighlightOnEnter	  Boolean	     False		    CSG	   │
       │XmNhighlightPixmap	  XmCHighlightPixmap	  Pixmap	     dynamic		    CSG	   │
       │XmNhighlightThickness	  XmCHighlightThickness	  Dimension	     2			    CSG	   │
       │XmNlayoutDirection	  XmCLayoutDirection	  XmDirection	     dynamic		    CG	   │
       │XmNnavigationType	  XmCNavigationType	  XmNavigationType   XmTAB_GROUP	    CSG	   │
       │XmNpopupHandlerCallback	  XmCCallback		  XtCallbackList     NULL		    C	   │
       │XmNshadowThickness	  XmCShadowThickness	  Dimension	     2			    CSG	   │
       │XmNtopShadowColor	  XmCTopShadowColor	  Pixel		     dynamic		    CSG	   │
       │XmNtopShadowPixmap	  XmCTopShadowPixmap	  Pixmap	     dynamic		    CSG	   │
       │XmNtraversalOn		  XmCTraversalOn	  Boolean	     True		    CSG	   │
       │XmNunitType		  XmCUnitType		  unsigned char	     dynamic		    CSG	   │
       │XmNuserData		  XmCUserData		  XtPointer	     NULL		    CSG	   │
       └───────────────────────────────────────────────────────────────────────────────────────────────────┘
       ┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
       │					      Core Resource Set						       │
       │Name				Class				Type		 Default		Access │
       │XmNaccelerators			XmCAccelerators			XtAccelerators	 dynamic		CSG    │
       │XmNancestorSensitive		XmCSensitive			Boolean		 dynamic		G      │
       │XmNbackground			XmCBackground			Pixel		 dynamic		CSG    │
       │XmNbackgroundPixmap		XmCPixmap			Pixmap		 XmUNSPECIFIED_PIXMAP	CSG    │
       │XmNborderColor			XmCBorderColor			Pixel		 XtDefaultForeground	CSG    │
       │XmNborderPixmap			XmCPixmap			Pixmap		 XmUNSPECIFIED_PIXMAP	CSG    │
       │XmNborderWidth			XmCBorderWidth			Dimension	 0			CSG    │
       │XmNcolormap			XmCColormap			Colormap	 dynamic		CG     │
       │XmNdepth			XmCDepth			int		 dynamic		CG     │
       │XmNdestroyCallback		XmCCallback			XtCallbackList	 NULL			C      │
       │XmNheight			XmCHeight			Dimension	 dynamic		CSG    │
       │XmNinitialResourcesPersistent	XmCInitialResourcesPersistent	Boolean		 True			C      │
       │XmNmappedWhenManaged		XmCMappedWhenManaged		Boolean		 True			CSG    │
       │XmNscreen			XmCScreen			Screen *	 dynamic		CG     │
       │XmNsensitive			XmCSensitive			Boolean		 True			CSG    │
       │XmNtranslations			XmCTranslations			XtTranslations	 dynamic		CSG    │
       │XmNwidth			XmCWidth			Dimension	 dynamic		CSG    │
       │XmNx				XmCPosition			Position	 0			CSG    │
       │XmNy				XmCPosition			Position	 0			CSG    │
       └───────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
   Callback Information
       A pointer to the following structure is passed to each callback:

       typedef struct
       {
	       int reason;
	       XEvent * event;
       } XmAnyCallbackStruct;

       reason	 Indicates why the callback was invoked

       event	 Points to the XEvent that triggered the callback

       The Text widget defines a new callback structure for use with verifica‐
       tion  callbacks.	 Note that not all fields are relevant for every call‐
       back reason. The application must first look at the  reason  field  and
       use  only  the structure members that are valid for the particular rea‐
       son.  The values startPos, endPos, and text in the  callback  structure
       XmTextVerifyCallbackStruct   may	 be  modified  when  the  callback  is
       received, and these changes will be reflected as changes	 made  to  the
       source  of  the	Text  widget. (For example, all keystrokes can be con‐
       verted to spaces or NULL characters when a password is entered  into  a
       Text  widget.) The application programmer should not overwrite the text
       field, but should attach data to that pointer.

       A pointer to the following structure is passed to callbacks for XmNlos‐
       ingFocusCallback, XmNmodifyVerifyCallback, and XmNmotionVerifyCallback:

       typedef struct
       {
	       int reason;
	       XEvent * event;
	       Boolean doit;
	       XmTextPosition currInsert, newInsert;
	       XmTextPosition startPos, endPos;
	       XmTextBlock text;
       } XmTextVerifyCallbackStruct, *XmTextVerifyPtr;

       reason	 Indicates why the callback was invoked.

       event	 Points	 to the XEvent that triggered the callback.  It can be
		 NULL. For example, changes made to the Text  widget  program‐
		 matically  do	not  have  an  event that can be passed to the
		 associated callback.

       doit	 Indicates whether the action that  invoked  the  callback  is
		 performed.   Setting  doit to False negates the action.  Note
		 that not all actions may be negated. For  example,  XmCR_LOS‐
		 ING_FOCUS  callbacks  may be beyond the control of the widget
		 if they are produced by mouse clicks.

       currInsert
		 Indicates the current position of the insert cursor.

       newInsert Indicates the position at which the user attempts to position
		 the insert cursor.

       startPos	 Indicates the starting position of the text to modify. If the
		 callback is not a modify verification callback, this value is
		 the same as currInsert.

       endPos	 Indicates  the	 ending	 position of the text to modify. If no
		 text is replaced or deleted, the value is the same as	start‐
		 Pos.  If  the callback is not a modify verification callback,
		 this value is the same as currInsert.

       text	 Points to a structure of type XmTextBlockRec. This  structure
		 holds the textual information to be inserted.

       typedef struct
       {
	       char *ptr;
	       int length;
	       XmTextFormat format;
       } XmTextBlockRec, *XmTextBlock;

	      ptr	Points to the text to be inserted.

	      length	Specifies the length of the text to be inserted.

	      format	Specifies  the	format of the text, either XmFMT_8_BIT
			or XmFMT_16_BIT.

       A pointer to the following structure is passed to callbacks for XmNmod‐
       ifyVerifyCallbackWcs.

       typedef struct
       {
	       int reason;
	       XEvent *event;
	       Boolean doit;
	       XmTextPosition currInsert, newInsert;
	       XmTextPosition startPos, endPos;
	       XmTextBlockWcs text;
       } XmTextVerifyCallbackStructWcs, *XmTextVerifyPtrWcs;

       reason	 Indicates why the callback was invoked.

       event	 Points	 to the XEvent that triggered the callback.  It can be
		 NULL. For example, changes made to the Text  widget  program‐
		 matically  do	not  have  an  event that can be passed to the
		 associated callback.

       doit	 Indicates whether the action that  invoked  the  callback  is
		 performed.   Setting  doit to False negates the action.  Note
		 that not all actions may be negated. For  example,  XmCR_LOS‐
		 ING_FOCUS  callbacks  may be beyond the control of the widget
		 if they are produced by mouse clicks.

       currInsert
		 Indicates the current position of the insert cursor.

       newInsert Indicates the position at which the user attempts to position
		 the insert cursor.

       startPos	 Indicates the starting position of the text to modify. If the
		 callback is not a modify verification callback, this value is
		 the same as currInsert.

       endPos	 Indicates  the	 ending	 position of the text to modify. If no
		 text is replaced or deleted, the value is the same as	start‐
		 Pos.  If  the callback is not a modify verification callback,
		 this value is the same as currInsert.

       text	 Points to the following structure of type  XmTextBlockRecWcs.
		 This structure holds the textual information to be inserted.

       typedef struct
       {
	       wchar_t *wcsptr;
	       int length;
       } XmTextBlockRecWcs, *XmTextBlockWcs;

	      wcsptr	Points to the wide character text to be inserted.

	      length	Specifies the number of characters to be inserted.

       The following table describes the reasons for which the individual ver‐
       ification callback structure fields are	valid.	Note  that  the	 event
       field will never be valid for XmCR_MOVING_INSERT_CURSOR.

       ┌────────────────────────────────────────────────────────────────┐
       │Reason			    Valid Fields			│
       │XmCR_LOSING_FOCUS	    reason,  event,  doit,  currInsert, │
       │			    newInsert, startPos, endPos		│
       │XmCR_MODIFYING_TEXT_VALUE   reason,  event,  doit,  currInsert, │
       │			    newInsert, startPos, endPos, text	│
       │XmCR_MOVING_INSERT_CURSOR   reason, doit, currInsert, newInsert │
       └────────────────────────────────────────────────────────────────┘
       A  pointer to the following callback structure is passed to the XmNdes‐
       tinationCallback procedures:

       typedef struct
       {
	       int reason;
	       XEvent  *event;
	       Atom selection;
	       XtEnum operation;
	       int flags;
	       XtPointer transfer_id;
	       XtPointer destination_data;
	       XtPointer location_data;
	       Time time;
       } XmDestinationCallbackStruct;

       reason	 Indicates why the callback was invoked.

       event	 Points to the XEvent that triggered the callback.  It can  be
		 NULL.

       selection Indicates  the	 selection  for	 which	data transfer is being
		 requested.  Possible  values  are  CLIPBOARD,	PRIMARY,  SEC‐
		 ONDARY, and _MOTIF_DROP.

       operation Indicates the type of transfer operation requested.

		    ·  When  the  selection  is PRIMARY or SECONDARY, possible
		       values are XmMOVE, XmCOPY, and XmLINK.

		    ·  When the selection is CLIPBOARD,	 possible  values  are
		       XmCOPY and XmLINK.

		    ·  When  the selection is _MOTIF_DROP, possible values are
		       XmMOVE,	XmCOPY,	 XmLINK,  and  XmOTHER.	  A  value  of
		       XmOTHER means that the callback procedure must get fur‐
		       ther  information  from	the   XmDropProcCallbackStruct
		       structure in the destination_data member.

       flags	 Indicates  whether  or not the destination widget is also the
		 source of the data to be transferred.	Following are the pos‐
		 sible values:

		 XmCONVERTING_NONE
			   The	destination  widget  is	 not the source of the
			   data to be transferred.

		 XmCONVERTING_SAME
			   The destination widget is the source of the data to
			   be transferred.

       transfer_id
		 Serves as a unique ID to identify the transfer transaction.

       destination_data
		 Contains  information about the destination.  When the selec‐
		 tion is _MOTIF_DROP, the callback procedures  are  called  by
		 the  drop  site's  XmNdropProc,  and  destination_data	 is  a
		 pointer to the XmDropProcCallbackStruct structure  passed  to
		 the  XmNdropProc procedure.  When the selection is SECONDARY,
		 destination_data is an Atom  representing  a  target  recomm‐
		 mended	 by  the  selection  owner  for	 use in converting the
		 selection.  Otherwise, destination_data is NULL.

       location_data
		 Contains information about the location where data is	to  be
		 transferred.	The value is always NULL when the selection is
		 CLIPBOARD.  If the value is NULL, the data is to be  inserted
		 at  the  widget's cursor position.  Otherwise, the value is a
		 pointer to an XPoint structure containing the x- and y- coor‐
		 dinates  at the location where the data is to be transferred.
		 Once XmTransferDone procedures	 start	to  be	called,	 loca‐
		 tion_data will no longer be stable.

       time	 Indicates the time when the transfer operation began.

   Translations
       The  XmText  translations  are  described  in  the following list.  The
       actions represent the effective behavior of the associated events,  and
       they may differ in a right-to-left language environment.

       The following key names are listed in the X standard key event transla‐
       tion table syntax.  This format is the one used by Motif to specify the
       widget  actions	corresponding to a given key.  A brief overview of the
       format is provided under VirtualBindings(3).  For a  complete  descrip‐
       tion  of the format, please refer to the X Toolkit Instrinsics Documen‐
       tation.

       ∼c s ∼m ∼a <Btn1Down>:
		 extend-start()

       c ∼s ∼m ∼a <Btn1Down>:
		 move-destination()

       ∼c ∼s ∼m ∼a <Btn1Down>:
		 grab-focus()

       ∼c ∼m ∼a <Btn1Motion>:
		 extend-adjust()

       ∼c ∼m ∼a <Btn1Up>:
		 extend-end()

       <Btn2Down>:
		 process-bdrag()

       m ∼a <Btn2Motion>:
		 secondary-adjust()

       ∼m a <Btn2Motion>:
		 secondary-adjust()

       s c <Btn2Up>:
		 link-to()

       ∼s <Btn2Up>:
		 copy-to()

       ∼c <Btn2Up>:
		 move-to()

       :m <Key><osfPrimaryPaste>:
		 cut-primary()

       :a <Key><osfPrimaryPaste>:
		 cut-primary()

       :<Key><osfPrimaryPaste>:
		 copy-primary()

       :m <Key><osfCut>:
		 cut-primary()

       :a <Key><osfCut>:
		 cut-primary()

       :<Key><osfCut>:
		 cut-clipboard()

       :<Key><osfPaste>:
		 paste-clipboard()

       :m <Key><osfCopy>:
		 copy-primary()

       :a <Key><osfCopy>:
		 copy-primary()

       :<Key><osfCopy>:
		 copy-clipboard()

       :s c <Key><osfBeginLine>:
		 beginning-of-file(extend)

       :c <Key><osfBeginLine>:
		 beginning-of-file()

       :s <Key><osfBeginLine>:
		 beginning-of-line(extend)

       :<Key><osfBeginLine>:
		 beginning-of-line()

       :s c <Key><osfEndLine>:
		 end-of-file(extend)

       :c <Key><osfEndLine>:
		 end-of-file()

       :s <Key><osfEndLine>:
		 end-of-line(extend)

       :<Key><osfEndLine>:
		 end-of-line()

       :s <Key><osfPageLeft>:
		 page-left(extend) (ignored in vertical writing)

       :<Key><osfPageLeft>:
		 page-left() (next-page() in vertical writing)

       :s c <Key><osfPageUp>:
		 page-left(extend)

       :c <Key><osfPageUp>:
		 page-left()

       :s <Key><osfPageUp>:
		 previous-page(extend) (ignored in vertical writing)

       :<Key><osfPageUp>:
		 previous-page() (page-up() in vertical writing)

       :s <Key><osfPageRight>:
		 page-right(extend) (ignored in vertical writing)

       :<Key><osfPageRight>:
		 page-right() (previous-page() in vertical writing)

       s c <Key><osfPageDown>:
		 page-right(extend) (ignored in vertical writing)

       :c <Key><osfPageDown>:
		 page-right()

       :s <Key><osfPageDown>:
		 next-page(extend) (ignored in vertical writing)

       :<Key><osfPageDown>:
		 next-page() (page-down() in vertical writing)

       :<Key><osfClear>:
		 clear-selection()

       :<Key><osfBackSpace>:
		 delete-previous-character()

       :s m <Key><osfDelete>:
		 cut-primary()

       :s a <Key><osfDelete>:
		 cut-primary()

       :s <Key><osfDelete>:
		 cut-clipboard()

       :c <Key><osfDelete>:
		 delete-to-end-of-line()

       :<Key><osfDelete>:
		 delete-next-character()

       :c m <Key><osfInsert>:
		 copy-primary()

       :c a <Key><osfInsert>:
		 copy-primary()

       :s <Key><osfInsert>:
		 paste-clipboard()

       :c <Key><osfInsert>:
		 copy-clipboard()

       :s <Key><osfSelect>:
		 key-select()

       :<Key><osfSelect>:
		 set-anchor()

       :<Key><osfSelectAll>:
		 select-all()

       :<Key><osfDeselectAll>:
		 deselect-all()

       :<Key><osfActivate>:
		 activate()

       :<Key><osfAddMode>:
		 toggle-add-mode()

       :<Key><osfHelp>:
		 Help()

       :<Key><osfCancel>:
		 process-cancel()

       :s c <Key><osfLeft>:
		 backward-word(extend) ( forward-paragraph(extend) in vertical
		 writing)

       :c <Key><osfLeft>:
		 backward-word() (forward-paragraph() in vertical writing)

       :s <Key><osfLeft>:
		 key-select(left) (process-shift-left() in vertical writing)

       :<Key><osfLeft>:
		 backward-character() (process-left() in vertical writing)

       :s c <Key><osfRight>:
		 forward-word(extend)  (backward-paragraph(extend) in vertical
		 writing)

       :c <Key><osfRight>:
		 forward-word() (backward-paragraph() in vertical writing)

       :s <Key><osfRight>:
		 key-select(right) (process-shift-right in vertical writing)

       :<Key><osfRight>:
		 forward-character() (process-right() in vertical writing)

       :s c <Key><osfUp>:
		 backward-paragraph(extend) (backward-word(extend) in vertical
		 writing)

       :c <Key><osfUp>:
		 backward-paragraph() (backward-word() in vertical writing)

       :s <Key><osfUp>:
		 process-shift-up() (key-select(up) in vertical writing)

       :<Key><osfUp>:
		 process-up() (backward-character() in vertical writing)

       :s c <Key><osfDown>:
		 forward-paragraph(extend)  (forward-word(extend)  in vertical
		 writing)

       :c <Key><osfDown>:
		 forward-paragraph() (forward-word() in vertical writing)

       :s <Key><osfDown>:
		 process-shift-down() (key-select(down) in vertical writing)

       :<Key><osfDown>:
		 process-down() (forward-character() in vertical writing)

       c ∼m ∼a <Key>slash:
		 select-all()

       c ∼m ∼a <Key>backslash:
		 deselect-all()

       s c ∼m ∼a <Key>Tab:
		 prev-tab-group()

       ∼s c ∼m ∼a <Key>Tab:
		 next-tab-group()

       s ∼c ∼m ∼a <Key>Tab:
		 process-tab(Prev)

       ∼s ∼c ∼m ∼a <Key>Tab:
		 process-tab(Next)

       ∼s c ∼m ∼a <Key>Return:
		 activate()

       ∼s ∼c ∼m ∼a <Key>Return:
		 process-return()

       ∼s c ∼m ∼a <Key>space:
		 set-anchor()

       s c ∼m ∼a <Key>space:
		 key-select()

       s ∼c ∼m ∼a <Key>space:
		 self-insert()

       <Key>:	 self-insert()

       The Text button event translations are modified when  Display's	XmNen‐
       ableBtn1Transfer	 resource  does	 not  have  a value of XmOFF (in other
       words, it  is  either  XmBUTTON2_TRANSFER  or  XmBUTTON2_ADJUST).  This
       option  allows  the actions for selection and transfer to be integrated
       on <Btn1>, and the actions for extending the selection can be bound  to
       <Btn2>.	The actions for <Btn1> that are defined above still apply when
       the <Btn1> event occurs over text that is not selected.	The  following
       actions apply when the <Btn1> event occurs over text that is selected:

       <Btn1Down>:
		 process-bdrag().

       <Shift><Btn1Down>:
		 process-bdrag().

       <Ctrl><Btn1Down>:
		 process-bdrag().

       <Btn1Down><Shift><Btn1Up>:
		 grab-focus(), extend-end.

       <Shift><Btn1Down><Shift><Btn1Up>:
		 extend-start(), extend-end().

       <Ctrl><Btn1Down><Shift><Btn1Up>:
		 move-destination().

       When  Display's	XmNenableBtn1Transfer  resource	 has a value of XmBUT‐
       TON2_ADJUST, the following actions apply:

       <Btn2Down>:
		 extend-start().

       <Btn2Motion>:
		 extend-adjust().

       <Btn2Up>: extend-end().

   Action Routines
       The XmText action routines are

       activate():
		 Calls the  callbacks  for  XmNactivateCallback.   Passes  the
		 event to the parent.

       backward-character(extend):
		 Moves	the  insertion cursor one character to the left.  This
		 action may have different behavior in	a  right-to-left  lan‐
		 guage environment.

		 If  called  with  an  argument of extend, moves the insertion
		 cursor as in the case of no argument and extends the  current
		 selection.

		 The  backward-character() action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 backward-character() action may produce calls to the XmNgain‐
		 PrimaryCallback  procedures.	See  callback  description for
		 more information.

		 In vertical writing, if XmNeditMode is XmSINGLE_LINE_EDIT and
		 XmNnavigationType  is	XmNONE, traverses to the widget to the
		 left in the tab group. If XmNeditMode	is  XmMULTI_LINE_EDIT,
		 moves	the insertion cursor to the next line in the same col‐
		 umn.

       backward-paragraph(extend):
		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with  no  argument,  moves  the insertion cursor to the first
		 non-whitespace character following the first  previous	 blank
		 line  or  beginning  of the text.  If the insertion cursor is
		 already at the beginning of a paragraph, moves the  insertion
		 cursor to the beginning of the previous paragraph.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with an argument of extend, moves the insertion cursor as  in
		 the case of no argument and extends the current selection.

		 The  backward-paragraph() action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 backward-paragraph() action may produce calls to the XmNgain‐
		 PrimaryCallback  procedures.	See  callback  description for
		 more information.

       backward-word(extend):
		 If this action is called with no argument, moves  the	inser‐
		 tion  cursor  to the first non-whitespace character after the
		 first whitespace character to the left or after the beginning
		 of  the  line.	  If  the  insertion  cursor is already at the
		 beginning of a word, moves the insertion cursor to the begin‐
		 ning  of  the	previous word.	This action may have different
		 behavior in a locale other than the C locale.

		 If called with an argument of	extend,	 moves	the  insertion
		 cursor	 as in the case of no argument and extends the current
		 selection.

		 The backward-word() action produces calls to  the  XmNmotion‐
		 VerifyCallback	  procedures   with   reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.  If called with the extend	argument,  the
		 backward-word() action may produce calls to the XmNgainPrima‐
		 ryCallback procedures.	 See  callback	description  for  more
		 information.

       beep():	 Causes	 the  terminal to beep.	 The beep() action produces no
		 callbacks.

       beginning-of-file(extend):
		 If this action is called with no argument, moves  the	inser‐
		 tion cursor to the beginning of the text.

		 If  called  with  an  argument of extend, moves the insertion
		 cursor as in the case of no argument and extends the  current
		 selection.

		 The  beginning-of-file()  action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 beginning-of-file() action may produce calls to the  XmNgain‐
		 PrimaryCallback  procedures.	See  callback  description for
		 more information.

       beginning-of-line(extend):
		 If this action is called with no argument, moves  the	inser‐
		 tion cursor to the beginning of the line.

		 If  called  with  an  argument of extend, moves the insertion
		 cursor as in the case of no argument and extends the  current
		 selection.

		 The  beginning-of-line()  action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 beginning-of-line() action may produce calls to the  XmNgain‐
		 PrimaryCallback  procedures.	See  callback  description for
		 more information.

       clear-selection():
		 Clears the current  selection	by  replacing  each  character
		 except <Return> with a <space> character.

		 The  clear-selection()	 action produces calls to the XmNmodi‐
		 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
		 ING_TEXT_VALUE	 and  the  XmNvalueChangedCallback  procedures
		 with reason value XmCR_VALUE_CHANGED.

       copy-clipboard():
		 If this widget owns the primary selection, this action copies
		 the  selection	 to the clipboard.  This action calls the XmN‐
		 convertCallback procedures, possibly multiple times, for  the
		 CLIPBOARD selection.

       copy-primary():
		 Copies	 the  primary  selection  to just before the insertion
		 cursor.  This action calls the XmNdestinationCallback	proce‐
		 dures for the PRIMARY selection and the XmCOPY operation.  It
		 calls the selection  owner's  XmNconvertCallback  procedures,
		 possibly multiple times, for the PRIMARY selection.

		 In  addition, the copy-primary() action produces calls to the
		 XmNmodifyVerifyCallback   procedures	with   reason	 value
		 XmCR_MODIFYING_TEXT_VALUE,   to  the  XmNvalueChangedCallback
		 procedures with reason value XmCR_VALUE_CHANGED, and  to  the
		 XmNmotionVerifyCallback    procedures	 with	reason	 value
		 XmCR_MOVING_INSERT_CURSOR.

       copy-to():
		 If a secondary selection exists, this action copies the  sec‐
		 ondary selection to the insertion position of the destination
		 component.  If the primary selection is  in  the  destination
		 widget,  it will be deselected. Otherwise, there is no effect
		 on the primary selection.

		 This action calls  the	 destination's	XmNdestinationCallback
		 procedures  for the SECONDARY selection and the XmCOPY opera‐
		 tion.	The destination's XmNdestinationCallback procedures or
		 the   destination  component  itself  invokes	the  selection
		 owner's  XmNconvertCallback  procedures,  possibly   multiple
		 times, for the SECONDARY selection.

		 If no secondary selection exists, this action copies the pri‐
		 mary selection to the pointer position.   This	 action	 calls
		 the  XmNdestinationCallback procedures for the PRIMARY selec‐
		 tion and  the	XmCOPY	operation.   It	 calls	the  selection
		 owner's   XmNconvertCallback  procedures,  possibly  multiple
		 times, for the PRIMARY selection.

		 In addition, the copy-to() action produces calls to the  XmN‐
		 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
		 FYING_TEXT_VALUE, to the  XmNvalueChangedCallback  procedures
		 with  reason  value XmCR_VALUE_CHANGED, and to the XmNmotion‐
		 VerifyCallback	 procedures  with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  there is no secondary selection, the
		 copy-to() action may produce calls to the XmNgainPrimaryCall‐
		 back  procedures.  See callback description for more informa‐
		 tion.

       cut-clipboard():
		 If this widget owns the primary selection, this  action  cuts
		 the  selection	 to the clipboard.  This action calls the XmN‐
		 convertCallback procedures, possibly multiple times, for  the
		 CLIPBOARD  selection.	 If  the  transfer is successful, this
		 action then calls the XmNconvertCallback procedures  for  the
		 CLIPBOARD selection and the DELETE target.

		 In addition, the cut-clipboard() action produces calls to the
		 XmNmodifyVerifyCallback   procedures	with   reason	 value
		 XmCR_MODIFYING_TEXT_VALUE,  and  the  XmNvalueChangedCallback
		 procedures with reason value XmCR_VALUE_CHANGED.

       cut-primary():
		 Cuts the primary selection and	 pastes	 it  just  before  the
		 insertion  cursor.  This action calls the XmNdestinationCall‐
		 back procedures for the  PRIMARY  selection  and  the	XmMOVE
		 operation.  It calls the selection owner's XmNconvertCallback
		 procedures, possibly multiple times, for the  PRIMARY	selec‐
		 tion.	 If the transfer is successful, this action then calls
		 the selection owner's XmNconvertCallback procedures  for  the
		 PRIMARY  selection  and the DELETE target.  The cut-primary()
		 action may produce calls to the XmNgainPrimaryCallback proce‐
		 dures.	 See callback description for more information.

		 In  addition,	the cut-primary() action produces calls to the
		 XmNmotionVerifyCallback   procedures	with   reason	 value
		 XmCR_MOVING_INSERT_CURSOR, the XmNmodifyVerifyCallback proce‐
		 dures with reason value  XmCR_MODIFYING_TEXT_VALUE,  and  the
		 XmNvalueChangedCallback    procedures	 with	reason	 value
		 XmCR_VALUE_CHANGED.

       delete-next-character():
		 In normal mode, if there is a nonnull selection, deletes  the
		 selection;  otherwise,	 deletes  the  character following the
		 insertion cursor.  In add mode, if there is a nonnull	selec‐
		 tion, the cursor is not disjoint from the selection, and XmN‐
		 pendingDelete is set to True, deletes the  selection;	other‐
		 wise,	deletes	 the character following the insertion cursor.
		 This may impact the selection.

		 The delete-next-character() action produces calls to the XmN‐
		 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
		 FYING_TEXT_VALUE, and the XmNvalueChangedCallback  procedures
		 with reason value XmCR_VALUE_CHANGED.

       delete-next-word():
		 In  normal mode, if there is a nonnull selection, deletes the
		 selection; otherwise, deletes the  characters	following  the
		 insertion  cursor to the next space, tab or end-of-line char‐
		 acter.	 In add mode, if there is  a  nonnull  selection,  the
		 cursor	 is  not  disjoint  from  the  selection, and XmNpend‐
		 ingDelete is set to True, deletes the	selection;  otherwise,
		 deletes  the characters following the insertion cursor to the
		 next space, tab or end-of-line character.   This  may	impact
		 the  selection.  This action may have different behavior in a
		 locale other than the C locale.

		 The delete-next-word() action produces calls to the  XmNmodi‐
		 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
		 ING_TEXT_VALUE, and  the  XmNvalueChangedCallback  procedures
		 with reason value XmCR_VALUE_CHANGED.

       delete-previous-character():
		 In  normal mode, if there is a nonnull selection, deletes the
		 selection; otherwise, deletes the character of	 text  immedi‐
		 ately	preceding the insertion cursor.	 In add mode, if there
		 is a nonnull selection, the cursor is not disjoint  from  the
		 selection,  and  XmNpendingDelete is set to True, deletes the
		 selection; otherwise, deletes the character of	 text  immedi‐
		 ately	preceding  the	insertion cursor.  This may impact the
		 selection.

		 The delete-previous-character() action produces calls to  the
		 XmNmodifyVerifyCallback    procedures	 with	reason	 value
		 XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback proce‐
		 dures	with  reason  value XmCR_VALUE_CHANGED, and the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.

       delete-previous-word():
		 In  normal mode, if there is a nonnull selection, deletes the
		 selection; otherwise, deletes the  characters	preceding  the
		 insertion  cursor to the next space, tab or beginning-of-line
		 character. In add mode, if there is a nonnull selection,  the
		 cursor	 is  not  disjoint  from  the  selection, and XmNpend‐
		 ingDelete is set to True, deletes the	selection;  otherwise,
		 deletes  the characters preceding the insertion cursor to the
		 next space, tab  or  beginning-of-line	 character.  This  may
		 impact the selection. This action may have different behavior
		 in a locale other than the C locale.

		 The delete-previous-word() action produces calls to the  XmN‐
		 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
		 FYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       delete-selection():
		 Deletes the current selection.

		 The delete-selection() action produces calls to the  XmNmodi‐
		 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
		 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       delete-to-end-of-line():
		 In normal mode, if there is a nonnull selection, deletes  the
		 selection;  otherwise,	 deletes  the characters following the
		 insertion cursor to the next end of line character.   In  add
		 mode, if there is a nonnull selection, the cursor is not dis‐
		 joint from the selection,  and	 XmNpendingDelete  is  set  to
		 True,	deletes	 the selection; otherwise, deletes the charac‐
		 ters following the insertion cursor to the next end  of  line
		 character.  This may impact the selection.

		 The delete-to-end-of-line() action produces calls to the XmN‐
		 modifyVerifyCallback procedures with reason value  XmCR_MODI‐
		 FYING_TEXT_VALUE,  and the XmNvalueChangedCallback procedures
		 with reason value XmCR_VALUE_CHANGED.

       delete-to-start-of-line():
		 In normal mode, if there is a nonnull selection, deletes  the
		 selection;  otherwise,	 deletes  the characters preceding the
		 insertion cursor to the previous beginning-of-line character.
		 In  add  mode, if there is a nonnull selection, the cursor is
		 not disjoint from the selection, and XmNpendingDelete is  set
		 to  True, deletes the selection; otherwise, deletes the char‐
		 acters preceding the insertion cursor to the previous	begin‐
		 ning-of-line character.  This may impact the selection.

		 The  delete-to-start-of-line()	 action	 produces calls to the
		 XmNmodifyVerifyCallback   procedures	with   reason	 value
		 XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback proce‐
		 dures with reason value XmCR_VALUE_CHANGED,  and  the	XmNmo‐
		 tionVerifyCallback  procedures	 with  reason  value XmCR_MOV‐
		 ING_INSERT_CURSOR.

       deselect-all():
		 Deselects the current selection.  The	deselect-all()	action
		 produces no callbacks.

       end-of-file(extend):
		 If  this  action is called with no argument, moves the inser‐
		 tion cursor to the end of the text.

		 If called with an argument of	extend,	 moves	the  insertion
		 cursor	 as in the case of no argument and extends the current
		 selection.

		 The end-of-file() action produces calls to the XmNmotionVeri‐
		 fyCallback    procedures    with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.  If called with the extend	argument,  the
		 end-of-file()	action	may produce calls to the XmNgainPrima‐
		 ryCallback procedures.	 See  callback	description  for  more
		 information.

       end-of-line(extend):
		 If  this  action is called with no argument, moves the inser‐
		 tion cursor to the end of the line.  If called with an	 argu‐
		 ment  of extend, moves the insertion cursor as in the case of
		 no argument and extends the current selection.

		 The end-of-line() action produces calls to the XmNmotionVeri‐
		 fyCallback    procedures    with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.  If called with the extend	argument,  the
		 end-of-line()	action	may produce calls to the XmNgainPrima‐
		 ryCallback procedures.	 See  callback	description  for  more
		 information.

       extend-adjust():
		 Selects text from the anchor to the pointer position and des‐
		 elects text outside that range.  Moving the pointer over sev‐
		 eral  lines  selects  text from the anchor to the end of each
		 line the pointer moves over and up to the pointer position on
		 the current line.

		 The  extend-adjust()  action produces calls to the XmNmotion‐
		 VerifyCallback	 procedures  with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.   The  extend-adjust()  action may produce
		 calls to the XmNgainPrimaryCallback procedures.  See callback
		 description for more information.

       extend-end():
		 Moves	the  insertion	cursor to the position of the pointer.
		 The extend-end() action is  used  to  commit  the  selection.
		 After	this  action  has  been done, process-cancel() will no
		 longer cancel the selection.

		 The extend-end() action produces calls to the	XmNmotionVeri‐
		 fyCallback    procedures    with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.  The extend-end() action may produce calls
		 to   the  XmNgainPrimaryCallback  procedures.	 See  callback
		 description for more information.

       extend-start():
		 Adjusts the anchor using the  balance-beam  method.   Selects
		 text  from  the  anchor to the pointer position and deselects
		 text outside that range.  The extend-start() action may  pro‐
		 duce  no  callbacks,  however,	 the extend-start() action may
		 produce calls to the XmNgainPrimaryCallback procedures.   See
		 callback description for more information.

       forward-character(extend):
		 Moves	the insertion cursor one character to the right.  This
		 action may have different behavior in	a  right-to-left  lan‐
		 guage environment.

		 If  called  with  an  argument of extend, moves the insertion
		 cursor as in the case of no argument and extends the  current
		 selection.

		 The  forward-character()  action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 forward-character() action may produce calls to the  XmNgain‐
		 PrimaryCallback  procedures.	See  callback  description for
		 more information.

		 In vertical writing, if XmNeditMode is XmSINGLE_LINE_EDIT and
		 XmNnavigationType  is	XmNONE, traverses to the widget to the
		 right in the tab group. If XmNeditMode is  XmMULTI_LINE_EDIT,
		 moves	the  insertion cursor to the previous line in the same
		 column.

       forward-paragraph(extend):
		 If XmNeditMode	 is  XmMULTI_LINE_EDIT,	 and  this  action  is
		 called	 with  no  argument, moves the insertion cursor to the
		 first non-whitespace character following the next blank line.
		 If  the  insertion  cursor  is	 already at the beginning of a
		 paragraph, moves the insertion cursor to the beginning of the
		 next paragraph.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with an argument of extend, moves the insertion cursor as  in
		 the case of no argument and extends the current selection.

		 The  forward-paragraph()  action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 forward-paragraph() action may produce calls to the  XmNgain‐
		 PrimaryCallback  procedures.	See  callback  description for
		 more information.

       forward-word(extend):
		 If this action is called with no argument, moves  the	inser‐
		 tion  cursor to the first whitespace character or end-of-line
		 following the next non-whitespace character.  If  the	inser‐
		 tion cursor is already at the end of a word, moves the inser‐
		 tion cursor to the end of the next  word.   This  action  may
		 have different behavior in a locale other than the C locale.

		 If  called  with  an  argument of extend, moves the insertion
		 cursor as in the case of no argument and extends the  current
		 selection.

		 The forward-word() action produces calls to the XmNmotionVer‐
		 ifyCallback   procedures   with   reason   value    XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 forward-word() action may produce calls to the	 XmNgainPrima‐
		 ryCallback  procedures.   See	callback  description for more
		 information.

       grab-focus():
		 This key binding performs the action defined in the XmNselec‐
		 tionArray,  depending on the number of multiple mouse clicks.
		 The default selection array ordering is one click to move the
		 insertion  cursor  to	the  pointer  position,	 two clicks to
		 select a word, three clicks to select a  line	of  text,  and
		 four  clicks  to  select all text.  A single click also dese‐
		 lects any selected text and sets the anchor  at  the  pointer
		 position.   This  action  may	have  different	 behavior in a
		 locale other than the C locale.

		 The grab-focus() action produces calls to the	XmNmotionVeri‐
		 fyCallback    procedures    with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.

       Help():	 Calls the callbacks for XmNhelpCallback  if  any  exist.   If
		 there	are  no	 help  callbacks  for this widget, this action
		 calls the help callbacks for the nearest  ancestor  that  has
		 them.

       insert-string(string):
		 If  XmNpendingDelete  is  True and the cursor is not disjoint
		 from the current selection,  deletes  the  entire  selection.
		 Inserts string before the insertion cursor.

		 The  insert-string()  action  produces	 calls to the XmNmodi‐
		 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
		 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back  procedures with reason value XmCR_MOVING_INSERT_CURSOR.
		 Note that, in the case of an empty string, no callbacks  will
		 be  called,  since  no modification will have been done. How‐
		 ever, if the insertion position is inside the current	selec‐
		 tion,	insert-string  with  an	 empty	string	will cause the
		 selection to be deselected, and  the  XmNmotionVerifyCallback
		 procedures   to   be	called	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR,	  XmCR_MODIFYING_TEXT_VALUE,	   and
		 XmCR_VALUE_CHANGED.

       key-select(right|left):
		 If called with an argument of right, moves the insertion cur‐
		 sor one character to the right and extends the current selec‐
		 tion.	 If  called with an argument of left, moves the inser‐
		 tion cursor one character to the left and extends the current
		 selection.   If  called with no argument, extends the current
		 selection.

		 Note that after a key-select action, the selection will still
		 begin at the original anchor, and will extend to the position
		 indicated in the action call. If this new position is on  the
		 opposite  side	 of  the  selection  anchor  from the previous
		 selection boundary, the  original  selection  will  be	 dese‐
		 lected.

		 The  key-select() action produces calls to the XmNmotionVeri‐
		 fyCallback   procedures   with	  reason    value    XmCR_MOV‐
		 ING_INSERT_CURSOR.  The key-select() action may produce calls
		 to  the  XmNgainPrimaryCallback  procedures.	See   callback
		 description for more information.

		 In vertical writing, if called with the argument left, and if
		 XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion	cursor
		 to the next line in the same column.  In vertical writing, if
		 called	 with  the  argument  right,  and  if  XmNeditMode  is
		 XmMULTI_LINE_EDIT, moves the insertion cursor to the previous
		 line in the same column.)

       kill-next-character():
		 In normal mode, if there is a nonnull	selection,  kills  the
		 selection;  otherwise,	 kills	the  character	following  the
		 insertion cursor and stores the character in the cut  buffer.
		 In  add  mode, if there is a nonnull selection, the cursor is
		 not disjoint from the selection, and XmNpendingDelete is  set
		 to  True, deletes the selection; otherwise, kills the charac‐
		 ter following the insertion cursor and stores	the  character
		 in the cut buffer.  This may impact the selection.

		 The killed text is stored in CUT_BUFFER0.

		 The  kill-next-character()  action produces calls to the XmN‐
		 modifyVerifyCallback procedures with reason value  XmCR_MODI‐
		 FYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       kill-next-word():
		 In  normal mode, if there is a nonnull selection, deletes the
		 selection; otherwise,	kills  the  characters	following  the
		 insertion  cursor to the next space, tab or end-of-line char‐
		 acter, and stores the characters in the cut  buffer.  In  add
		 mode, if there is a nonnull selection, the cursor is not dis‐
		 joint from the selection,  and	 XmNpendingDelete  is  set  to
		 True,	deletes the selection; otherwise, kills the characters
		 following the insertion cursor to the next space, tab or end-
		 of-line  character, and stores the characters in the cut buf‐
		 fer. This may impact the selection. This action may have dif‐
		 ferent behavior in a locale other than the C locale.

		 The killed text is stored in CUT_BUFFER0.

		 The  kill-next-word()	action	produces calls to the XmNmodi‐
		 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
		 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       kill-previous-character():
		 In  normal mode, if there is a nonnull selection, deletes the
		 selection; otherwise, kills the character immediately preced‐
		 ing  the insertion cursor and stores the character in the cut
		 buffer.  In add mode, if there is a  nonnull  selection,  the
		 cursor	 is  not  disjoint  from  the  selection, and XmNpend‐
		 ingDelete is set to True, deletes the	selection;  otherwise,
		 kills	the character immediately preceding the insertion cur‐
		 sor and stores the character in the  cut  buffer.   This  may
		 impact the selection.

		 The killed text is stored in CUT_BUFFER0.

		 The  kill-previous-character()	 action	 produces calls to the
		 XmNmodifyVerifyCallback   procedures	with   reason	 value
		 XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback proce‐
		 dures with reason value XmCR_VALUE_CHANGED,  and  the	XmNmo‐
		 tionVerifyCallback  procedures	 with  reason  value XmCR_MOV‐
		 ING_INSERT_CURSOR.

       kill-previous-word():
		 In normal mode, if there is a nonnull selection, deletes  the
		 selection;  otherwise,	 kills	the  characters	 preceding the
		 insertion cursor up to the next space, tab  or	 beginning-of-
		 line  character, and stores the characters in the cut buffer.
		 In add mode, if there is a nonnull selection, the  cursor  is
		 not  disjoint from the selection, and XmNpendingDelete is set
		 to True, deletes the selection; otherwise, kills the  charac‐
		 ters preceding the insertion cursor up to the next space, tab
		 or beginning-of-line character, and stores the characters  in
		 the  cut  buffer.  This may impact the selection. This action
		 may have different behavior in a  locale  other  than	the  C
		 locale.

		 The killed text is stored in CUT_BUFFER0.

		 The kill-previous-word() action produces calls to the XmNmod‐
		 ifyVerifyCallback procedures with reason  value  XmCR_MODIFY‐
		 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       kill-selection():
		 Kills	the currently selected text and stores the text in the
		 cut buffer.

		 The killed text is stored in CUT_BUFFER0.

		 The kill-selection() action produces calls  to	 the  XmNmodi‐
		 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
		 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       kill-to-end-of-line():
		 In normal mode, if there is a nonnull selection, deletes  the
		 selection;  otherwise,	 kills	the  characters	 following the
		 insertion cursor to the next end-of-line character and stores
		 the characters in the cut buffer.  In add mode, if there is a
		 nonnull selection, the cursor is not disjoint from the selec‐
		 tion, and XmNpendingDelete is set to True, deletes the selec‐
		 tion; otherwise, kills the characters following the insertion
		 cursor to the next end of line character and stores the char‐
		 acters in the cut buffer.  This may impact the selection.

		 The killed text is stored in CUT_BUFFER0.

		 The kill-to-end-of-line() action produces calls to  the  XmN‐
		 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
		 FYING_TEXT_VALUE, and the XmNvalueChangedCallback  procedures
		 with  reason  value  XmCR_VALUE_CHANGED.   In	the case where
		 there is a non-null selection to be deleted, this action  may
		 also  produce calls to the XmNmotionVerifyCallback procedures
		 with reason value XmCR_MOVING_INSERT_CURSOR.

       kill-to-start-of-line():
		 In normal mode, if there is a nonnull selection, deletes  the
		 selection;  otherwise,	 kills	the  characters	 preceding the
		 insertion cursor to the next beginning-of-line character  and
		 stores	 the  characters  in  the cut buffer.  In add mode, if
		 there is a nonnull selection, the cursor is not disjoint from
		 the  selection,  and XmNpendingDelete is set to True, deletes
		 the selection; otherwise, kills the characters preceding  the
		 insertion  cursor to the next beginning-of-line character and
		 stores the characters in the cut buffer.  This may impact the
		 selection.

		 The killed text is stored in CUT_BUFFER0.

		 The kill-to-start-of-line() action produces calls to the XmN‐
		 modifyVerifyCallback procedures with reason value  XmCR_MODI‐
		 FYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       link-primary():
		 Places a link to the primary selection just before the inser‐
		 tion cursor.  This action  calls  the	XmNdestinationCallback
		 procedures  for  the  PRIMARY selection and the XmLINK opera‐
		 tion.	The Text widget itself performs no transfers; the XmN‐
		 destinationCallback  procedures are responsible for inserting
		 the link to the primary selection and for taking any  related
		 actions.

       link-to():
		 If a secondary selection exists, this action places a link to
		 the secondary selection at the insertion position of the des‐
		 tination component.  This action calls the destination's XmN‐
		 destinationCallback procedures for  the  SECONDARY  selection
		 and the XmLINK operation.

		 If  no	 secondary selection exists, this action places a link
		 to the primary	 selection  at	the  pointer  position.	  This
		 action	 calls	the  XmNdestinationCallback procedures for the
		 PRIMARY selection and the XmLINK operation.

		 The Text widget itself performs no transfers; the XmNdestina‐
		 tionCallback  procedures  are	responsible  for inserting the
		 link to the primary or secondary selection and for taking any
		 related actions.

       move-destination():
		 Moves	the  insertion	cursor to the pointer position without
		 changing any existing current selection.  If there is a  cur‐
		 rent  selection,  sets	 the widget as the destination widget.
		 This also moves the widget focus to match the insertion  cur‐
		 sor.

		 The  move-destination()  action  produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.

       move-to():
		 If  a	secondary selection exists, this action moves the sec‐
		 ondary selection to the insertion position of the destination
		 component.   If the secondary selection is in the destination
		 widget, and the secondary selection and the primary selection
		 overlap, the result is undefined.  This action calls the des‐
		 tination's XmNdestinationCallback  procedures	for  the  SEC‐
		 ONDARY selection and the XmMOVE operation.  The destination's
		 XmNdestinationCallback procedures or the  destination	compo‐
		 nent  itself invokes the selection owner's XmNconvertCallback
		 procedures, possibly multiple times, for the SECONDARY selec‐
		 tion.	 If the transfer is successful, this action then calls
		 the selection owner's XmNconvertCallback procedures  for  the
		 SECONDARY selection and the DELETE target.

		 If  no secondary selection exists, this action moves the pri‐
		 mary selection to the pointer position.   This	 action	 calls
		 the  XmNdestinationCallback procedures for the PRIMARY selec‐
		 tion and  the	XmMOVE	operation.   It	 calls	the  selection
		 owner's   XmNconvertCallback  procedures,  possibly  multiple
		 times, for the PRIMARY selection.  If the  transfer  is  suc‐
		 cessful, this action then calls the selection owner's XmNcon‐
		 vertCallback procedures for the  PRIMARY  selection  and  the
		 DELETE target.

		 The  move-to()	 action produces calls to the XmNmodifyVerify‐
		 Callback   procedures	 with	reason	 value	  XmCR_MODIFY‐
		 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back  procedures with reason value XmCR_MOVING_INSERT_CURSOR.
		 If there is no secondary selection, the move-to() action  may
		 produce  calls to the XmNgainPrimaryCallback procedures.  See
		 callback description for more information.

       newline():
		 If XmNpendingDelete is True and the cursor  is	 not  disjoint
		 from  the  current  selection,	 deletes the entire selection.
		 Inserts a newline before the insertion cursor.

		 The newline() action produces calls to	 the  XmNmodifyVerify‐
		 Callback    procedures	  with	 reason	  value	  XmCR_MODIFY‐
		 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       newline-and-backup():
		 If XmNpendingDelete is True and the cursor  is	 not  disjoint
		 from  the  current  selection,	 deletes the entire selection.
		 Inserts a newline just before the insertion cursor and	 repo‐
		 sitions  the  insertion  cursor to the end of the line before
		 the newline.

		 The newline-and-backup() action produces calls to the XmNmod‐
		 ifyVerifyCallback  procedures	with reason value XmCR_MODIFY‐
		 ING_TEXT_VALUE, and  the  XmNvalueChangedCallback  procedures
		 with reason value XmCR_VALUE_CHANGED.

       newline-and-indent():
		 If  XmNpendingDelete  is  True and the cursor is not disjoint
		 from the current selection,  deletes  the  entire  selection.
		 Inserts  a  newline  and  then	 the same number of whitespace
		 characters as at the beginning of the previous line.

		 The newline-and-indent() action produces calls to the XmNmod‐
		 ifyVerifyCallback  procedures	with reason value XmCR_MODIFY‐
		 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       next-line():
		 Moves the insertion cursor to the next line.

		 The next-line() action produces calls to the XmNmotionVerify‐
		 Callback procedures with reason value XmCR_MOVING_INSERT_CUR‐
		 SOR.

       next-page(extend):
		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with  no  argument,  moves  the  insertion cursor forward one
		 page.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with  an argument of extend, it moves the insertion cursor as
		 in the case of no argument and extends the current selection.

		 The next-page() action produces calls to the XmNmotionVerify‐
		 Callback procedures with reason value XmCR_MOVING_INSERT_CUR‐
		 SOR.  If called with the  extend  argument,  the  next-page()
		 action may produce calls to the XmNgainPrimaryCallback proce‐
		 dures.	 See callback description for more information.

		 In vertical writing, scrolls the viewing window down one page
		 of text.

       next-tab-group():
		 Traverses to the next tab group.

		 The  next-tab-group() action produces no callbacks, unless it
		 results in the widget losing focus, in which case,  the  XmN‐
		 losingFocusCallback  procedures  are called with reason value
		 XmCR_LOSING_FOCUS.

       page-left(extend):
		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with no argument, moves the insertion cursor back one page.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with an argument of extend, it moves the insertion cursor  as
		 in the case of no argument and extends the current selection.

		 The page-left() action produces calls to the XmNmotionVerify‐
		 Callback procedures with reason value XmCR_MOVING_INSERT_CUR‐
		 SOR.	If  called  with  the extend argument, the page-left()
		 action may produce calls to the XmNgainPrimaryCallback proce‐
		 dures.	 See callback description for more information.

       page-right(extend):
		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with no argument, moves  the  insertion  cursor  forward  one
		 page.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with an argument of extend, it moves the insertion cursor  as
		 in the case of no argument and extends the current selection.

		 The  page-right() action produces calls to the XmNmotionVeri‐
		 fyCallback   procedures   with	  reason    value    XmCR_MOV‐
		 ING_INSERT_CURSOR.   If  called with the extend argument, the
		 page-right() action may produce calls	to  the	 XmNgainPrima‐
		 ryCallback  procedures.   See	callback  description for more
		 information.

       paste-clipboard():
		 Pastes the contents of the  clipboard	before	the  insertion
		 cursor.   This action calls the XmNdestinationCallback proce‐
		 dures for the CLIPBOARD selection and the XmCOPY operation.

		 The paste-clipboard() action produces calls to	 the  XmNmodi‐
		 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
		 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       prev-tab-group():
		 Traverses to the previous tab group.

		 The prev-tab-group() action produces no callbacks, unless  it
		 results  in  the widget losing focus, in which case, the XmN‐
		 losingFocusCallback procedures are called with	 reason	 value
		 XmCR_LOSING_FOCUS.

       previous-line():
		 Moves the insertion cursor to the previous line.

		 The  previous-line()  action produces calls to the XmNmotion‐
		 VerifyCallback	 procedures  with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.

       previous-page(extend):
		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with no argument, moves the insertion cursor back one page.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with  an argument of extend, it moves the insertion cursor as
		 in the case of no argument and extends the current selection.

		 The previous-page() action produces calls to  the  XmNmotion‐
		 VerifyCallback	  procedures   with   reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.  If called with the extend	argument,  the
		 previous-page() action may produce calls to the XmNgainPrima‐
		 ryCallback procedures.	 See  callback	description  for  more
		 information.

		 In  vertical  writing, if called without an argument, scrolls
		 the viewing window up one page of text.

       process-bdrag()
		 If the pointer is within the selection, this action starts  a
		 drag  operation for the selection.  This action sets the XmN‐
		 convertProc of the DragContext to a function that  calls  the
		 XmNconvertCallback  procedures,  possibly multiple times, for
		 the _MOTIF_DROP selection.

		 If no selection exists or the pointer is outside  the	selec‐
		 tion,	this action prepares to start a secondary selection at
		 the pointer position.

	      Note:

			Note that when dragging a  secondary  selection	 to  a
			different  widget, focus will shift momentarily to the
			second widget, and then back to the  original  widget.
			This  will  generate  callbacks to the XmNlosingFocus‐
			Callback procedures as focus is lost (by each  widget)
			as  well  as  callbacks to the XmNfocusCallback proce‐
			dures as focus is regained.

       process-cancel():
		 Cancels the current  extend-adjust(),	secondary-adjust()  or
		 process-bdrag()  operation  and leaves the selection state as
		 it was before the operation; otherwise, and if the parent  is
		 a manager, passes the event to the parent.

       process-down(extend):
		 If  XmNeditMode  is XmSINGLE_LINE_EDIT, and XmNnavigationType
		 is XmNONE, traverses to the widget below the current  one  in
		 the tab group.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with an argument of extend, moves the insertion cursor as  in
		 the case of no argument and extends the current selection.

		 In this case, the action will produce the XmNlosingFocusCall‐
		 back callbacks with reason value XmCR_LOSING_FOCUS.

		 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
		 sor down one line.

		 The process-down() action produces calls to the XmNmotionVer‐
		 ifyCallback   procedures   with   reason   value    XmCR_MOV‐
		 ING_INSERT_CURSOR.

		 In vertical writing, moves the insertion cursor one character
		 down.

       process-home():
		 Moves the insertion cursor to the beginning of the line.

		 The process-home() action produces calls to the XmNmotionVer‐
		 ifyCallback	procedures   with   reason   value   XmCR_MOV‐
		 ING_INSERT_CURSOR.

       process-return():
		 If XmNeditMode is XmSINGLE_LINE_EDIT, calls the callbacks for
		 XmNactivateCallback,  and  if the parent is a manager, passes
		 the   event   to   the	   parent.     If    XmNeditMode    is
		 XmMULTI_LINE_EDIT, inserts a newline.

		 The  process-return() action during single-line edit produces
		 calls to the XmNactivateCallback procedures with reason value
		 XmCR_ACTIVATE.	  During   multi-line  editing,	 the  process-
		 return() action produces calls to the XmNmodifyVerifyCallback
		 procedures  with  reason value XmCR_MODIFYING_TEXT_VALUE, the
		 XmNvalueChangedCallback   procedures	with   reason	 value
		 XmCR_VALUE_CHANGED,  and  the	XmNmotionVerifyCallback proce‐
		 dures with reason value XmCR_MOVING_INSERT_CURSOR.

       process-shift-down():
		 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
		 sor  down  one	 line  and  selects.  If XmNeditMode is XmSIN‐
		 GLE_LINE_EDIT, this action behaves like process-up() in  XmS‐
		 INGLE_LINE_EDIT.  Refer to the process-up() action.

		 The  process-shift-down() action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.

		 In  vertical  writing,	 if called with the argument up, moves
		 the insertion cursor one character up and extends the current
		 selection. If called with the argument down, moves the inser‐
		 tion cursor one character down and extends the current selec‐
		 tion.

       process-shift-up():
		 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
		 sor up	 one  line  and	 selects.  If  XmNeditMode  is	XmSIN‐
		 GLE_LINE_EDIT,	 this action behaves like process-up() in XmS‐
		 INGLE_LINE_EDIT.  Refer to the process-up() action.

		 The process-shift-up() action produces calls  to  the	XmNmo‐
		 tionVerifyCallback  procedures	 with  reason  value XmCR_MOV‐
		 ING_INSERT_CURSOR.

		 In vertical writing, if called with the  argument  up,	 moves
		 the insertion cursor one character up and extends the current
		 selection. If called with the argument down, moves the inser‐
		 tion cursor one character down and extends the current selec‐
		 tion.

       process-tab(Prev|Next):
		 If XmNeditMode is XmSINGLE_LINE_EDIT, traverses to  the  next
		 tab group if the direction argument is Next, or to the previ‐
		 ous tab group if the direction is  Prev.  If  XmNeditMode  is
		 XmMULTI_LINE_EDIT,  and  the  direction  is  Next, the action
		 inserts  a  tab.  The	Prev  direction	 has  no  effect  with
		 XmMULTI_LINE_EDIT.  In the Text widget, there is a preset tab
		 stop at every eighth columns.

		 The process-tab() action under	 multi-line  editing  produces
		 calls	to  the XmNmotionVerifyCallback procedures with reason
		 value XmCR_MOVING_INSERT_CURSOR. Under	 single-line  editing,
		 the  action  produces	no callbacks, unless it results in the
		 widget losing focus, in which case,  the  XmNlosingFocusCall‐
		 back  procedures  are	called	with  reason  value  XmCR_LOS‐
		 ING_FOCUS.

       process-up(extend):
		 If XmNeditMode is XmSINGLE_LINE_EDIT and XmNnavigationType is
		 XmNONE,  traverses to the widget above the current one in the
		 tab group.

		 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
		 sor up one line.

		 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
		 with an argument of extend, moves the insertion cursor as  in
		 the case of no argument and extends the current selection.

		 The  process-up()  action  under  multi-line editing produces
		 calls to the XmNmotionVerifyCallback procedures  with	reason
		 value	XmCR_MOVING_INSERT_CURSOR.  Under single-line editing,
		 the action produces no callbacks unless  it  results  in  the
		 widget	 losing	 focus, in which case, the XmNlosingFocusCall‐
		 back  procedures  are	called	with  reason  value  XmCR_LOS‐
		 ING_FOCUS.

		 In vertical writing, moves the insertion cursor one character
		 up.

       redraw-display():
		 Redraws the contents of the text window.

		 The redraw-display() action produces no callbacks.

       scroll-cursor-vertically(percentage):
		 Scrolls the line containing the insertion  cursor  vertically
		 to an intermediate position in the visible window based on an
		 input percentage. A value of 0 indicates the top of the  win‐
		 dow; a value of 100, the bottom of the window. If this action
		 is called with no argument, the line containing the insertion
		 cursor is scrolled vertically to a new position designated by
		 the y position of the event passed to the routine.

		 The scroll-cursor-vertically action produces no callbacks.

       scroll-one-line-down():
		 Scrolls the text area down one line.

		 The scroll-one-line-down() action produces no callbacks.

       scroll-one-line-up():
		 Scrolls the text area up one line.

		 The scroll-one-line-up() action produces no callbacks.

       secondary-adjust():
		 Extends the secondary selection to the pointer position.

		 The secondary-adjust() action produces no callbacks.

       secondary-notify():
		 Copies the secondary selection to the insertion cursor of the
		 destination widget.

		 The  secondary-notify() action produces calls to the XmNmodi‐
		 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
		 ING_TEXT_VALUE,  and  the  XmNvalueChangedCallback procedures
		 with reason value XmCR_VALUE_CHANGED.

       secondary-start():
		 Marks the beginning of a secondary selection.

		 The secondary-start() action produces no callbacks.

       select-adjust():
		 Moves the current selection.  The  amount  of	text  selected
		 depends  on  the  number of mouse clicks, as specified by the
		 XmNselectionArray resource.

		 The select-adjust() action may produce no callbacks, however,
		 it  may  produce  calls  to the XmNgainPrimaryCallback proce‐
		 dures.	 See callback description for more information.

       select-all():
		 Selects all text.

		 The select-all() action may produce calls to the  XmNgainPri‐
		 maryCallback procedures.

       select-end():
		 Moves	the  current  selection.   The amount of text selected
		 depends on the number of mouse clicks, as  specified  by  the
		 XmNselectionArray resource.

		 The select-end() action produces no callbacks.

       select-start():
		 Marks the beginning of a new selection region.

		 The  select-start()  action may produce calls to the XmNgain‐
		 PrimaryCallback procedures.

       self-insert():
		 If XmNpendingDelete is True and the cursor  is	 not  disjoint
		 from  the  current  selection,	 deletes the entire selection.
		 Inserts the character associated with the key pressed at  the
		 insertion cursor.

		 The self-insert() action produces calls to the XmNmodifyVeri‐
		 fyCallback  procedures	  with	 reason	  value	  XmCR_MODIFY‐
		 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

       set-anchor():
		 Resets	 the anchor point for extended selections.  Resets the
		 destination of secondary selection actions.

		 The set-anchor() action produces no callbacks.

       set-insertion-point():
		 Sets the insertion position to	 the  position	of  the	 mouse
		 pointer.

		 The set-insertion-point() action produces calls to the XmNmo‐
		 tionVerifyCallback procedures	with  reason  value  XmCR_MOV‐
		 ING_INSERT_CURSOR.  Note that if the mouse pointer is already
		 over the position of the insertion cursor,  the  cursor  will
		 not be moved, and no callbacks will be produced.

       set-selection-hint():
		 Sets the text source and location of the current selection.

		 The set-selection-hint() action produces no callbacks.

       toggle-add-mode():
		 Toggles the state of Add Mode.

		 The toggle-add-mode() action produces no callbacks.

       toggle-overstrike():
		 Toggles  the  state  of  the text insertion mode. By default,
		 characters typed into the Text widget	are  inserted  at  the
		 position of the insertion cursor. In overstrike mode, charac‐
		 ters entered into the Text widget replace the characters that
		 directly  follow  the	insertion cursor.  In overstrike mode,
		 when the end of a line is reached, characters are appended to
		 the end of the line.

		 The  following traversal actions generate no callbacks unless
		 they result in the loss of focus by the widget	 in  question,
		 as  when XmNnavigationType is XmNONE. In this case, they pro‐
		 duce calls to	the  XmNlosingFocusCallback  procedures,  with
		 reason value XmCR_FOCUS_MOVED.

       traverse-home():
		 Traverses to the first widget in the tab group.

       traverse-next():
		 Traverses to the next widget in the tab group.

       traverse-prev():
		 Traverses to the previous widget in the tab group.

       unkill(): Restores  last	 killed	 text to the position of the insertion
		 cursor (or whatever is currently in  the  CUT_BUFFER0).   The
		 inserted text appears before the insertion cursor.

		 The  unkill()	action	produces calls to the XmNmodifyVerify‐
		 Callback   procedures	 with	reason	 value	  XmCR_MODIFY‐
		 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
		 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
		 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.

   Additional Behavior
       This widget has the following additional behavior:

       <FocusIn>:
		 Draws	the  insertion cursor as solid and starts blinking the
		 cursor.

       <FocusOut>:
		 Displays the insertion cursor as a stippled I-beam unless  it
		 is the destination widget and stops the cursor from blinking.

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

RELATED
       Core(3),	  XmCreateScrolledText(3),   XmCreateText(3),	XmFontList(3),
       XmFontListAppendEntry(3),    XmPrimitive(3),   XmTextClearSelection(3),
       XmTextCopy(3),  XmTextCopyLink(3),   XmTextCut(3),   XmTextEnableRedis‐
       play(3),	   XmTextDisableRedisplay(3),	 XmTextField(3),   XmTextFind‐
       String(3), XmTextFindStringWcs(3),  XmTextGetBaseline(3),  XmTextGetEd‐
       itable(3),   XmTextGetInsertionPosition(3),   XmTextGetLastPosition(3),
       XmTextGetMaxLength(3), XmTextGetSelection(3), XmTextGetSelectionWcs(3),
       XmTextGetSelectionPosition(3),  XmTextGetSource(3), XmTextGetString(3),
       XmTextGetStringWcs(3), XmTextGetSubstring(3), XmTextGetSubstringWcs(3),
       XmTextGetTopCharacter(3),      XmTextInsert(3),	   XmTextInsertWcs(3),
       XmTextPaste(3),	 XmTextPasteLink(3),   XmTextPosToXY(3),   XmTextPosi‐
       tion(3),	   XmTextRemove(3),   XmTextReplace(3),	  XmTextReplaceWcs(3),
       XmTextScroll(3),	      XmTextSetAddMode(3),	 XmTextSetEditable(3),
       XmTextSetHighlight(3),	  XmTextSetInsertionPosition(3),    XmTextSet‐
       MaxLength(3),  XmTextSetSelection(3),  XmTextSetSource(3),   XmTextSet‐
       String(3), XmTextSetStringWcs(3), XmTextSetTopCharacter(3), XmTextShow‐
       Position(3), XmTextXYToPos(3),  XmVaCreateText(3),  and	XmVaCreateMan‐
       agedText(3).

							  XmText(library call)
[top]

List of man pages available for RedHat

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net