1XmText(library call)                                      XmText(library call)
2
3
4

NAME

6       XmText — The Text widget class
7

SYNOPSIS

9       #include <Xm/Text.h>
10

DESCRIPTION

12       Text  provides  a single-line and multiline text editor for customizing
13       both user and programmatic interfaces. It can be used  for  single-line
14       string entry, forms entry with verification procedures, and full-window
15       editing.  It provides an application with a consistent  editing  system
16       for  textual data. The screen's textual data adjusts to the application
17       writer's needs.
18
19       Text provides separate callback lists to verify movement of the  insert
20       cursor,  modification  of the text, and changes in input focus. Each of
21       these callbacks provides the  verification  function  with  the  widget
22       instance, the event that caused the callback, and a data structure spe‐
23       cific to the verification type. From this information, the function can
24       verify  if  the  application  considers  this  to be a legitimate state
25       change and can signal the widget whether to continue with the action.
26
27       The user interface tailors a  new  set  of  translations.  The  default
28       translations provide key bindings for insert cursor movement, deletion,
29       insertion, and selection of text.
30
31       Text allows the user to select regions of text.  Selection is based  on
32       the  model specified in the Inter-Client Communication Conventions Man‐
33       ual (ICCCM). Text supports primary and secondary selection.
34
35       In some Asian languages, texts are drawn vertically. Also, some charac‐
36       ters are displayed with 90-degree clockwise rotation, and other charac‐
37       ters are mapped to vertical glyphs that differ from the normal  horiza‐
38       ontal  glyphs.   Information about which characters require rotation or
39       mapping to vertical glyphs is specified in the X Locale  Database  (NLS
40       databases)  and  handled  by  X library, depending on XNOrientation XOC
41       values.  XmText widget should also handle the vertically aligned  lines
42       as for editing, entering, or selecting texts.
43
44       The  vertical  writing feature of the XmText widget is enabled when the
45       XmTOP_TO_BOTTOM value is specified for the XmNlayoutDirection  resource
46       of  the  XmText widget. In that case, the horizontal scroll bar is dis‐
47       played on the bottom of the XmText widget and the vertical  scroll  bar
48       is displayed on the left side.
49
50   Mouse Selection
51       The  Text widget allows text to be edited, inserted, and selected.  The
52       user can cut, copy, and paste text  by  using  the  clipboard,  primary
53       transfer,  or  secondary  transfer.  Text also provides a Drag and Drop
54       facility that enables the user to copy or move data within Text or to a
55       different  widget.   When keyboard focus policy is set to EXPLICIT, the
56       widget that receives focus is the destination widget. In POINTER  mode,
57       any  keyboard  or  mouse  operation  (except secondary selection) in an
58       editable widget establishes that widget as the destination.
59
60       If a destination widget becomes insensitive or uneditable, it  forfeits
61       its  destination status. In EXPLICIT mode, when a widget becomes insen‐
62       sitive, the focus moves to another widget. If that widget is  editable,
63       it  becomes  the destination widget; otherwise, there is no destination
64       widget. The text of any insensitive Text widget is stippled, indicating
65       its state to the user.
66
67       The  insertion  cursor,  displayed  as  an I-beam, shows where input is
68       inserted. Input is inserted just before the insertion cursor.
69
70       Text uses the XmQTnavigator,  XmQTspecifyRenderTable,  and  XmQTscroll‐
71       Frame  traits, and holds the XmQTaccessTextual and XmQTtransfer traits.
72       The widget checks its parent for the  XmQTscrollFrame  trait.  If  this
73       trait  does  not  exist, then the widget has no scrolling. If the trait
74       does exist, and the ScrollFrame widget has not  been  initialized,  the
75       widget creates two navigators and sets up the scrollbars.
76
77       If  an application or widget calls the setValue trait method of XmQTac‐
78       cessTextual, then XmText will call XmTextSetString to  set  the  string
79       value.
80
81   Classes
82       Text  inherits  behavior,  resources, and traits from Core and XmPrimi‐
83       tive.
84
85       The class pointer is xmTextWidgetClass.
86
87       The class name is XmText.
88
89   Data Transfer Behavior
90       Text supports transfer of the primary, secondary, and clipboard  selec‐
91       tions  and dragging of selected text from the widget.  Text can also be
92       the destination for the primary, secondary, and  clipboard  selections,
93       and it supports dropping of data being dragged onto the widget.
94
95       When  the  XmNconvertCallback  procedures are called, the location_data
96       member of the XmConvertCallbackStruct member is NULL  if  the  selected
97       text  is being transferred.  If the entire text, not the selected text,
98       is being transferred, the value of this member is the widget ID of  the
99       Text widget.
100
101       As a source of data, Text supports the following targets and associated
102       conversions of data to these targets:
103
104       locale    If the locale target matches the widget's locale, the  widget
105                 transfers the selected text in the encoding of the locale.
106
107       COMPOUND_TEXT
108                 The widget transfers the selected text as type COMPOUND_TEXT.
109
110       STRING    The widget transfers the selected text as type STRING.
111
112       TEXT      If  the selected text is fully convertible to the encoding of
113                 the locale, the widget transfers the  selected  text  in  the
114                 encoding  of the locale.  Otherwise, the widget transfers the
115                 selected text as type COMPOUND_TEXT.
116
117       UTF8_STRING
118                 The widget transfers the selected text as type UTF8_STRING.
119
120       DELETE    The widget deletes the selected text.
121
122       _MOTIF_CLIPBOARD_TARGETS
123                 The widget transfers, as type ATOM, a list of the targets  to
124                 which  the  widget can convert data to be placed on the clip‐
125                 board immediately.  If the selected text is fully convertible
126                 to STRING, these include STRING; otherwise, they include COM‐
127                 POUND_TEXT.
128
129       _MOTIF_DEFERRED_CLIPBOARD_TARGETS
130                 The widget transfers, as type ATOM, a list of the targets  it
131                 supports  for  delayed  transfer for the CLIPBOARD selection.
132                 This   widget   currently    supplies    no    targets    for
133                 _MOTIF_DEFERRED_CLIPBOARD_TARGETS.
134
135       _MOTIF_EXPORT_TARGETS
136                 The  widget transfers, as type ATOM, a list of the targets to
137                 be used as the value of the DragContext's XmNexportTargets in
138                 a   drag-and-drop  transfer.   These  include  COMPOUND_TEXT,
139                 UTF8_STRING, the encoding of the locale, STRING, TEXT,  BACK‐
140                 GROUND, and FOREGROUND.
141
142       _MOTIF_LOSE_SELECTION
143                 The widget takes the following actions:
144
145                    ·  When  losing the PRIMARY selection, it unhighlights the
146                       selected text and calls the XmNlosePrimaryCallback pro‐
147                       cedures.
148
149                    ·  When  losing  the  SECONDARY  selection, it removes the
150                       secondary selection highlight.
151
152                    ·  When losing the _MOTIF_DESTINATION  selection,  if  the
153                       widget  does  not  have focus, it changes the cursor to
154                       indicate that the widget is no longer the destination.
155
156       As a source of data, Text also supports the  following  standard  Motif
157       targets:
158
159       BACKGROUND
160                 The widget transfers XmNbackground as type PIXEL.
161
162       CLASS     The widget finds the first shell in the widget hierarchy that
163                 has a WM_CLASS property and transfers the contents as text in
164                 the current locale.
165
166       CLIENT_WINDOW
167                 The  widget finds the first shell in the widget hierarchy and
168                 transfers its window as type WINDOW.
169
170       COLORMAP  The widget transfers XmNcolormap as type COLORMAP.
171
172       FOREGROUND
173                 The widget transfers XmNforeground as type PIXEL.
174
175       NAME      The widget finds the first shell in the widget hierarchy that
176                 has  a WM_NAME property and transfers the contents as text in
177                 the current locale.
178
179       TARGETS   The widget transfers, as type ATOM, a list of the targets  it
180                 supports.   These  include the standard targets in this list.
181                 These also include COMPOUND_TEXT, UTF8_STRING,  the  encoding
182                 of the locale, STRING, and TEXT.
183
184       TIMESTAMP The widget transfers the timestamp used to acquire the selec‐
185                 tion as type INTEGER.
186
187       _MOTIF_RENDER_TABLE
188                 The widget transfers XmNrenderTable if it exists, or else the
189                 default text render table, as type STRING.
190
191       _MOTIF_ENCODING_REGISTRY
192                 The  widget  transfers  its encoding registry as type STRING.
193                 The value is a list of NULL separated items in  the  form  of
194                 tag encoding pairs.  This target symbolizes the transfer tar‐
195                 get for the Motif Segment  Encoding  Registry.   Widgets  and
196                 applications  can use this Registry to register text encoding
197                 formats for specified render table tags.  Applications access
198                 this   Registry   by  calling  XmRegisterSegmentEncoding  and
199                 XmMapSegmentEncoding.
200
201       As a destination for data, Text chooses a target and  requests  conver‐
202       sion of the selection to that target.  If the encoding of the locale is
203       present in the list of available targets, Text chooses a requested tar‐
204       get from the available targets in the following order of preference:
205
206          1. The encoding of the locale
207
208          2. TEXT
209
210          4. UTF8_STRING
211
212          3. COMPOUND_TEXT
213
214          4. STRING
215
216       If  the  encoding of the locale is not present in the list of available
217       targets, Text chooses a requested target from the available targets  in
218       the following order of preference:
219
220          4. UTF8_STRING
221
222          1. COMPOUND_TEXT
223
224          2. STRING
225
226   New Resources
227       The  following table defines a set of widget resources used by the pro‐
228       grammer to specify data. The programmer can also set the resource  val‐
229       ues  for  the  inherited  classes to set attributes for this widget. To
230       reference a resource by name or by class in a .Xdefaults  file,  remove
231       the  XmN or XmC prefix and use the remaining letters. To specify one of
232       the defined values for a resource in a .Xdefaults file, remove  the  Xm
233       prefix and use the remaining letters (in either lowercase or uppercase,
234       but include any underscores between words).  The codes  in  the  access
235       column  indicate if the given resource can be set at creation time (C),
236       set by using XtSetValues (S), retrieved by using XtGetValues (G), or is
237       not applicable (N/A).
238
239       ┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐
240       │                           │             XmText Resourc│e Set            │                    │        │
241Name                       Class                     Type           Default            Access 
242       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
243       │XmNactivateCallback        │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
244       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
245       │XmNautoShowCursorPosition  │ XmCAutoShowCursorPosition │ Boolean        │ True               │ CSG    │
246       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
247       │XmNcursorPosition          │ XmCCursorPosition         │ XmTextPosition │ 0                  │ CSG    │
248       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
249       │XmNcursorPositionVisible   │ XmCCursorPositionVisible  │ Boolean        │ dynamic            │ CSG    │
250       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
251       │XmNdestinationCallback     │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
252       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
253       │XmNeditable                │ XmCEditable               │ Boolean        │ True               │ CSG    │
254       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
255       │XmNeditMode                │ XmCEditMode               │ int            │ XmSINGLE_LINE_EDIT │ CSG    │
256       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
257       │XmNfocusCallback           │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
258       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
259       │XmNgainPrimaryCallback     │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
260       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
261       │XmNlosePrimaryCallback     │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
262       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
263       │XmNlosingFocusCallback     │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
264       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
265       │XmNmarginHeight            │ XmCMarginHeight           │ Dimension      │ 5                  │ CSG    │
266       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
267       │XmNmarginWidth             │ XmCMarginWidth            │ Dimension      │ 5                  │ CSG    │
268       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
269       │XmNmaxLength               │ XmCMaxLength              │ int            │ largest integer    │ CSG    │
270       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
271       │XmNmodifyVerifyCallback    │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
272       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
273       │XmNmodifyVerifyCallbackWcs │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
274       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
275       │XmNmotionVerifyCallback    │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
276       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
277       │XmtotalLines               │ XmCTotalLines             │ int            │ dynamic            │ C      │
278       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
279       │XmNsource                  │ XmCSource                 │ XmTextSource   │ Default source     │ CSG    │
280       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
281       │XmNtopCharacter            │ XmCTopCharacter           │ XmTextPosition │ 0                  │ CSG    │
282       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
283       │XmNvalue                   │ XmCValue                  │ String         │ ""                 │ CSG    │
284       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
285       │XmNvalueChangedCallback    │ XmCCallback               │ XtCallbackList │ NULL               │ C      │
286       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
287       │XmNvalueWcs                │ XmCvalueWcs               │ wchar_t *      │ (wchar_t *)""      │ CSG1   │
288       ├───────────────────────────┼───────────────────────────┼────────────────┼────────────────────┼────────┤
289       │XmNverifyBell              │ XmCVerifyBell             │ Boolean        │ dynamic            │ CSG    │
290       └───────────────────────────┴───────────────────────────┴────────────────┴────────────────────┴────────┘
291       1 This resource cannot be set in a resource file.
292
293       XmNactivateCallback
294                 Specifies  the list of callbacks that is called when the user
295                 invokes an event that calls the activate() action.  The  type
296                 of  the structure whose address is passed to this callback is
297                 XmAnyCallbackStruct.  The reason  sent  by  the  callback  is
298                 XmCR_ACTIVATE.
299
300       XmNautoShowCursorPosition
301                 Ensures that the visible text contains the insert cursor when
302                 set to True.  If the insert cursor changes, the  contents  of
303                 Text  may  scroll  in order to bring the insertion point into
304                 the window.  Setting this resource to  False,  however,  does
305                 not ensure that Text will not scroll.
306
307       XmNcursorPosition
308                 Indicates  the  position in the text where the current insert
309                 cursor is to be located.  Position is determined by the  num‐
310                 ber  of characters from the beginning of the text.  The first
311                 character position is 0 (zero).
312
313       XmNcursorPositionVisible
314                 If the widget has an XmPrintShell as one  of  its  ancestors,
315                 then the default value is False; otherwise, it is True.
316
317       XmNdestinationCallback
318                 Specifies  a  list of callbacks called when the widget is the
319                 destination of a transfer operation.  The type of the  struc‐
320                 ture whose address is passed to these callbacks is XmDestina‐
321                 tionCallbackStruct.  The reason is XmCR_OK.
322
323       XmNeditable
324                 When set to True, indicates that the user can edit  the  text
325                 string.  Prohibits the user from editing the text when set to
326                 False.
327
328                 When XmNeditable is used on a widget it sets the dropsite  to
329                 XmDROP_SITE_ACTIVE.
330
331       XmNeditMode
332                 Specifies  the  set  of  keyboard bindings used in Text.  The
333                 default, XmSINGLE_LINE_EDIT, provides the set of key bindings
334                 to  be  used  in editing single-line text.  XmMULTI_LINE_EDIT
335                 provides the set of key bindings to be used in editing multi‐
336                 line text.
337
338                 The  results of placing a Text widget inside a ScrolledWindow
339                 when the Text's XmNeditMode is XmSINGLE_LINE_EDIT  are  unde‐
340                 fined.
341
342       XmNfocusCallback
343                 Specifies  the  list  of  callbacks  called when Text accepts
344                 input focus. The type  of  the  structure  whose  address  is
345                 passed  to  this callback is XmAnyCallbackStruct.  The reason
346                 sent by the callback is XmCR_FOCUS.
347
348       XmNgainPrimaryCallback
349                 Specifies the list of callbacks called when an  event  causes
350                 the  Text  widget to gain ownership of the primary selection.
351                 The reason sent by the callback is XmCR_GAIN_PRIMARY.
352
353       XmNlosePrimaryCallback
354                 Specifies the list of callbacks called when an  event  causes
355                 the  Text  widget to lose ownership of the primary selection.
356                 The reason sent by the callback is XmCR_LOSE_PRIMARY.
357
358       XmNlosingFocusCallback
359                 Specifies the list of  callbacks  called  before  Text  loses
360                 input  focus.   The  type  of  the structure whose address is
361                 passed to this callback is  XmTextVerifyCallbackStruct.   The
362                 reason sent by the callback is XmCR_LOSING_FOCUS.
363
364       XmNmarginHeight
365                 Specifies  the  distance  between  the top edge of the widget
366                 window and the text, and between the bottom edge of the  wid‐
367                 get window and the text.
368
369       XmNmarginWidth
370                 Specifies  the  distance  between the left edge of the widget
371                 window and the text, and between the right edge of the widget
372                 window and the text.
373
374       XmNmaxLength
375                 Specifies  the  maximum length of the text string that can be
376                 entered into text from the keyboard. This value must be  non‐
377                 negative.   Strings  that  are  entered by using the XmNvalue
378                 resource  or  the  XmTextSetString   function   ignore   this
379                 resource.
380
381       XmNmodifyVerifyCallback
382                 Specifies the list of callbacks called before text is deleted
383                 from or inserted into Text.  The type of the structure  whose
384                 address  is  passed to this callback is XmTextVerifyCallback‐
385                 Struct.  The reason sent  by  the  callback  is  XmCR_MODIFY‐
386                 ING_TEXT_VALUE.   When  multiple  Text widgets share the same
387                 source, only the widget that initiates the source change will
388                 generate XmNmodifyVerifyCallback.
389
390                 If  both XmNmodifyVerifyCallback and XmNmodifyVerifyCallback‐
391                 Wcs are registered callback lists, the  procedure(s)  in  the
392                 XmNmodifyVerifyCallback  list  is  always executed first; and
393                 the resulting data, which may have been modified,  is  passed
394                 to the XmNmodifyVerifyCallbackWcs callback routines.
395
396       XmNmodifyVerifyCallbackWcs
397                 Specifies the list of callbacks called before text is deleted
398                 from or inserted into Text. The type of the  structure  whose
399                 address  is  passed to this callback is XmTextVerifyCallback‐
400                 StructWcs. The reason sent by the  callback  is  XmCR_MODIFY‐
401                 ING_TEXT_VALUE.   When  multiple  Text widgets share the same
402                 source, only the widget that initiates the source change will
403                 generate the XmNmodifyVerifyCallbackWcs.
404
405                 If  both XmNmodifyVerifyCallback and XmNmodifyVerifyCallback‐
406                 Wcs are registered callback lists, the  procedure(s)  in  the
407                 XmNmodifyVerifyCallback  list  is  always executed first; and
408                 the resulting data, which may have been modified,  is  passed
409                 to the XmNmodifyVerifyCallbackWcs callback routines.
410
411       XmNmotionVerifyCallback
412                 Specifies the list of callbacks called before the insert cur‐
413                 sor is moved to a new position.  The type  of  the  structure
414                 whose address is passed to this callback is XmTextVerifyCall‐
415                 backStruct.  The reason sent by  the  callback  is  XmCR_MOV‐
416                 ING_INSERT_CURSOR.   It  is possible for more than one XmNmo‐
417                 tionVerifyCallback to be generated from a single action.
418
419       XmNsource Specifies the source with which the widget displays text.  If
420                 no  source  is specified, the widget creates a default string
421                 source.  This resource can be  used  to  share  text  sources
422                 between Text widgets.
423
424       XmNtopCharacter
425                 Displays  the  position  of  text  at  the top of the window.
426                 Position is determined by the number of characters  from  the
427                 beginning  of  the  text.   The first character position is 0
428                 (zero).
429
430                 If the XmNeditMode is XmMULTI_LINE_EDIT,  the  line  of  text
431                 that  contains  the  top character is displayed at the top of
432                 the widget without shifting the text left or  right.   XtGet‐
433                 Values  for XmNtopCharacter returns the position of the first
434                 character in the line that is displayed at  the  top  of  the
435                 widget.
436
437       XmNtotalLines
438                 Indicates  the number of lines in the text widget buffer (not
439                 necessarily visible). The initial value 1 means the text buf‐
440                 fer is empty. The number of lines reported takes into account
441                 the wordWrap policy (that is, it's not simply the  number  of
442                 newline characters.
443
444       XmNvalue  Specifies the string value of the Text widget as a char* data
445                 value.  Moves the cursor to position 0 unless a value of XmN‐
446                 cursorPosition  was explicitly supplied in the argument list.
447                 If XmNvalue and XmNvalueWcs are both defined,  the  value  of
448                 XmNvalueWcs  supersedes that of XmNvalue. XtGetValues returns
449                 a copy of the value of the internal  buffer  and  XtSetValues
450                 copies the string values into the internal buffer.
451
452       XmNvalueChangedCallback
453                 Specifies  the list of callbacks called after text is deleted
454                 from or inserted into Text.  The type of the structure  whose
455                 address  is  passed  to this callback is XmAnyCallbackStruct.
456                 The reason sent by the callback is XmCR_VALUE_CHANGED.   When
457                 multiple  Text widgets share the same source, only the widget
458                 that initiates the source change will  generate  the  XmNval‐
459                 ueChangedCallback.  This  callback represents a change in the
460                 source in the Text, not  in  the  Text  widget.  The  XmNval‐
461                 ueChangedCallback should occur only in pairs with an XmNmodi‐
462                 fyVerifyCallback, assuming that the doit flag in the callback
463                 structure of the XmNmodifyVerifyCallback is not set to False.
464
465       XmNvalueWcs
466                 Specifies  the  string value of the Text widget as a wchar_t*
467                 data value.  Moves the cursor to position 0 unless a value of
468                 XmNcursorPosition  was  explicitly  supplied  in the argument
469                 list.
470
471                 This resource cannot be specified in a resource file.
472
473                 If XmNvalue and XmNvalueWcs are both defined,  the  value  of
474                 XmNvalueWcs supersedes that of XmNvalue.  XtGetValues returns
475                 a copy of the value of the internal buffer encoded as a  wide
476                 character  string.  XtSetValues  copies the value of the wide
477                 character string into the internal buffer.
478
479       XmNverifyBell
480                 Specifies whether the bell should sound when the verification
481                 returns  without  continuing the action.  The default depends
482                 on the value of the ancestor VendorShell's  XmNaudibleWarning
483                 resource.
484
485                 ┌─────────────────────────────────────────────────────────────────────────────────────┐
486XmText Input Resource Set                               
487Name                     Class                    Type        Default         Access 
488                 │XmNpendingDelete         XmCPendingDelete         Boolean     True            CSG    │
489                 │XmNselectionArray        XmCSelectionArray        XtPointer   default array   CSG    │
490                 │XmNselectionArrayCount   XmCSelectionArrayCount   int         4               CSG    │
491                 │XmNselectThreshold       XmCSelectThreshold       int         5               CSG    │
492                 └─────────────────────────────────────────────────────────────────────────────────────┘
493       XmNpendingDelete
494                 Indicates  that  pending  delete  mode is on when the Boolean
495                 value is True.  Pending deletion is defined  as  deletion  of
496                 the selected text when an insertion is made.
497
498       XmNselectionArray
499                 Defines  the  actions for multiple mouse clicks. The value of
500                 the  resource  is  an  array  of   XmTextScanType   elements.
501                 XmTextScanType is an enumeration indicating possible actions.
502                 Each mouse click performed within some time of  the  previous
503                 mouse click increments the index into this array and performs
504                 the defined action for that index. (This "multiclick" time is
505                 specified by the operating environment, and varies among dif‐
506                 ferent systems. In general, it is usually set to  some  frac‐
507                 tion  of  a  second.)  The possible actions in the order they
508                 occur in the default array are as follows:
509
510                    3. XmSELECT_POSITION, which resets the insert cursor posi‐
511                       tion.
512
513                    4. XmSELECT_WORD, which selects a word.
514
515                    5. XmSELECT_LINE,  which  selects  a  line  of  text. This
516                       action sees a line as delimited by hard newline charac‐
517                       ters.  In  other  words, if the word wrap feature is on
518                       (XmNwordWrap is True), this will  ignore  the  newlines
519                       automatically  inserted  by  the  widget.  This  is the
520                       default.
521
522                    6. XmSELECT_OUT_LINE, which selects a line of  text.  This
523                       action sees a line as delimited by hard or soft newline
524                       characters. In other words, if the word wrap feature is
525                       on  (XmNwordWrap  is  True), the newlines automatically
526                       inserted by the widget will be  treated  as  delimiting
527                       lines.
528
529                    7. XmSELECT_ALL, which selects all of the text.
530
531       XmNselectionArrayCount
532                 Indicates  the  number  of  elements in the XmNselectionArray
533                 resource.  The value must not be negative.
534
535       XmNselectThreshold
536                 Specifies the number of pixels of motion that is required  to
537                 select  the  next character when selection is performed using
538                 the click-drag mode of selection.  The value must not be neg‐
539                 ative.  This resource also specifies whether a drag should be
540                 started and the  number  of  pixels  to  start  a  drag  when
541                 Btn2Down and Btn1Down are integrated.
542
543                 ┌───────────────────────────────────────────────────────────────────────────────────────┐
544XmText Output Resource Set                               
545Name                       Class                      Type            Default   Access 
546                 │XmNblinkRate               XmCBlinkRate               int             500       CSG    │
547                 │XmNcolumns                 XmCColumns                 short           dynamic   CSG    │
548                 │XmNcursorPositionVisible   XmCCursorPositionVisible   Boolean         True      CSG    │
549                 │XmNfontList                XmCFontList                XmFontList      dynamic   CSG    │
550                 │XmNrenderTable             XmCRenderTable             XmRenderTable   dynamic   CSG    │
551                 │XmNresizeHeight            XmCResizeHeight            Boolean         False     CSG    │
552                 │XmNresizeWidth             XmCResizeWidth             Boolean         False     CSG    │
553                 │XmNrows                    XmCRows                    short           dynamic   CSG    │
554                 │XmNwordWrap                XmCWordWrap                Boolean         False     CSG    │
555                 └───────────────────────────────────────────────────────────────────────────────────────┘
556       XmNblinkRate
557                 Specifies  the blink rate of the text cursor in milliseconds.
558                 The time indicated in the blink rate relates to the time  the
559                 cursor  is visible and the time the cursor is invisible (that
560                 is, the time it takes to blink the insertion  cursor  on  and
561                 off  is twice the blink rate). The cursor does not blink when
562                 the blink rate is set to 0 (zero).  The  value  must  not  be
563                 negative.
564
565       XmNcolumns
566                 Specifies  the initial width of the text window as an integer
567                 number of characters. The width equals the number of  charac‐
568                 ters  specified  by  this resource multiplied by the width as
569                 derived from the specified font. If  the  em-space  value  is
570                 available,  it  is used. If not, the width of the numeral "0"
571                 is used. If this is not available, the maximum width is used.
572                 For proportionate fonts, the actual number of characters that
573                 fit on a given line may be greater than the value  specified.
574                 The  value  must  be greater than 0 (zero). The default value
575                 depends on the value of the XmNwidth resource.  If  no  width
576                 is specified the default is 20.
577
578                 When  the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, and
579                 if  the  XmText  widget  resource   XmNeditMode   is   XmSIN‐
580                 GLE_LINE_EDIT,  this  attribute  is  ignored.  If no width is
581                 specified, the default is 1.
582
583       XmNcursorPositionVisible
584                 Indicates that the insert cursor position is marked by a text
585                 cursor when the Boolean value is True.
586
587       XmNfontList
588                 Specifies the font list to be used for Text. The font list is
589                 an obsolete structure and is retained only for  compatibility
590                 with earlier releases of Motif. Use the render table (XmNren‐
591                 derTable) instead of font lists wherever  possible.  If  both
592                 are specified, the render table will take precedence. If this
593                 value is NULL at initialization, the parent hierarchy of  the
594                 widget  is searched for an ancestor that holds the XmQTspeci‐
595                 fyRenderTable trait. If such an ancestor is found,  the  font
596                 list  is  initialized to the XmTEXT_RENDER_TABLE value of the
597                 ancestor widget. If no such ancestor is found, the default is
598                 implementation dependent.
599
600                 Text  searches  the  font  list for the first occurrence of a
601                 font set that has XmFONTLIST_DEFAULT_TAG. If a  default  ele‐
602                 ment  is  not  found,  the first font set in the font list is
603                 used. If the list contains no font sets, the  first  font  in
604                 the  font  list will be used. Refer to XmFontList(3) for more
605                 information on a font list structure.
606
607       XmNrenderTable
608                 Specifies the render table to be used in deriving a font  set
609                 or font for rendering text. If both a render table and a font
610                 list are specified, the render table will take precedence. If
611                 the  value  of  XmNrenderTable is NULL at initialization, the
612                 parent hierarchy of the widget is searched  for  an  ancestor
613                 that  holds  the  XmQTspecifyRenderTable  trait.  If  such an
614                 ancestor is found,  the  font  list  is  initialized  to  the
615                 XmTEXT_RENDER_TABLE  value of the ancestor widget. If no such
616                 ancestor is found, the default is implementation dependent.
617
618                 Text searches the render table for the first occurrence of  a
619                 rendition  that  has  the  tag  _MOTIF_DEFAULT_LOCALE.  If  a
620                 default element is not found, the first rendition in the  ta‐
621                 ble  is  used. Refer to XmRenderTable(3) for more information
622                 on the render table structure.
623
624       XmNresizeHeight
625                 Indicates that Text will attempt  to  resize  its  height  to
626                 accommodate  all  the  text  contained in the widget when the
627                 Boolean value is True. If the Boolean value is set  to  True,
628                 the  text  is always displayed, starting from the first posi‐
629                 tion in  the  source,  even  if  instructed  otherwise.  This
630                 attribute  is ignored when the application uses a Text widget
631                 whose parent is a ScrolledWindow and  when  XmNscrollVertical
632                 is True.
633
634                 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
635                 resource indicates that  the  text  attempts  to  resize  its
636                 height  to  accommodate  all the text contained in the widget
637                 when the Boolean value is True. This attribute is ignored  if
638                 XmNwordWrap is True.
639
640       XmNresizeWidth
641                 Indicates  that Text attempts to resize its width to accommo‐
642                 date all the text contained in the widget  when  the  Boolean
643                 value  is  True.  This attribute is ignored if XmNwordWrap is
644                 True.
645
646                 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
647                 attribute  is  still  effective  even if XmNwordWrap is True.
648                 Also, this attribute is ignored when the application  uses  a
649                 text  widget  whose parent is a ScrolledWindow and XmNscroll‐
650                 Horizaontal is True.
651
652       XmNrows   Specifies the initial height of the text window  measured  in
653                 character heights. This attribute is ignored if the text wid‐
654                 get resource XmNeditMode is  XmSINGLE_LINE_EDIT.   The  value
655                 must  be greater than 0 (zero).  The default value depends on
656                 the value of the XmNheight resource.  If no height is  speci‐
657                 fied, the default is 1.
658
659                 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
660                 attribute is still  effective,  even  if  the  XmText  widget
661                 resource  XmNeditMode  is XmSINGLE_LINE_EDIT. If no height is
662                 specified, the default is 20.
663
664       XmNwordWrap
665                 Indicates that lines are to be broken at  word  breaks  (that
666                 is,  the  text  does not go off the right edge of the window)
667                 when the Boolean value is  True.   Words  are  defined  as  a
668                 sequence of characters separated by whitespace. Whitespace is
669                 defined as a  space,  tab,  or  newline.  This  attribute  is
670                 ignored  if  the  text  widget resource XmNeditMode is XmSIN‐
671                 GLE_LINE_EDIT.  Note that this resource is  only  valid  when
672                 the widget is not a scroll one, or, if the widget is a scroll
673                 widget, that the XmNscrollHorizontal resource is False.
674
675                 Indicates that lines are to be broken at  word  breaks  (that
676                 is,  when the XmNlayoutDirection resource is XmTOP_TO_BOTTOM,
677                 the text does not go off the bottom edge of the window)  when
678                 the Boolean value is True.
679
680       The  following  resources  are  used  only  when  text  is created in a
681       ScrolledWindow. See the reference page for XmCreateScrolledText.
682
683       ┌─────────────────────────────────────────────────────────────────┐
684XmText Scrolling Resource Set                   
685Name                  Class           Type      Default   Access 
686       │XmNscrollHorizontal   XmCScroll       Boolean   True      CG     │
687       │XmNscrollLeftSide     XmCScrollSide   Boolean   False     CG     │
688       │XmNscrollTopSide      XmCScrollSide   Boolean   False     CG     │
689       │XmNscrollVertical     XmCScroll       Boolean   True      CG     │
690       └─────────────────────────────────────────────────────────────────┘
691       Note in connection with  this  table  that  if  the  XmNlayoutDirection
692       resource is XmTOP_TO_BOTTOM, the default is True.
693
694       XmNscrollHorizontal
695                 Adds  a ScrollBar that allows the user to scroll horizontally
696                 through text when the Boolean value is True.   This  resource
697                 is  forced  to  False  when  the  Text  widget is placed in a
698                 ScrolledWindow with XmNscrollingPolicy set to XmAUTOMATIC.
699
700                 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
701                 attribute  is  ignored if the XmText widget resource XmNedit‐
702                 Mode is XmSINGLE_LINE_EDIT.
703
704       XmNscrollLeftSide
705                 Indicates that the vertical ScrollBar should be placed on the
706                 left  side of the scrolled text window when the Boolean value
707                 is True. This attribute is ignored  if  XmNscrollVertical  is
708                 False or the Text resource XmNeditMode is XmSINGLE_LINE_EDIT.
709
710                 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
711                 resource is  still  effective,  even  if  the  XmText  widget
712                 resource XmNeditMode is XmSINGLE_LINE_EDIT.
713
714       XmNscrollTopSide
715                 Indicates  that  the horizontal ScrollBar should be placed on
716                 the top side of the scrolled text  window  when  the  Boolean
717                 value is True.
718
719                 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
720                 attribute is ignored if XmNscrollHorizontal is False  or  the
721                 Xmtext resource XmNeditMode is XmSINGLE_LINE_EDIT.
722
723       XmNscrollVertical
724                 Adds  a  ScrollBar  that allows the user to scroll vertically
725                 through text when the Boolean value is True.  This  attribute
726                 is  ignored  if  the  Text  resource  XmNeditMode  is  XmSIN‐
727                 GLE_LINE_EDIT.  This resource is forced  to  False  when  the
728                 Text  widget is placed in a ScrolledWindow with XmNscrolling‐
729                 Policy set to XmAUTOMATIC.
730
731                 When the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, this
732                 resource  is  still  effective,  even  if  the  XmText widget
733                 resource XmNeditMode is XmSINGLE_LINE_EDIT.
734
735   Inherited Resources
736       Text inherits behavior and resources from the superclasses described in
737       the  following  tables.   For  a complete description of each resource,
738       refer to the reference page for that superclass.
739
740       ┌───────────────────────────────────────────────────────────────────────────────────────────────────┐
741XmPrimitive Resource Set                                      
742Name                      Class                   Type               Default                Access 
743       │XmNbottomShadowColor      XmCBottomShadowColor    Pixel              dynamic                CSG    │
744       │XmNbottomShadowPixmap     XmCBottomShadowPixmap   Pixmap             XmUNSPECIFIED_PIXMAP   CSG    │
745       │XmNconvertCallback        XmCCallback             XtCallbackList     NULL                   C      │
746       │XmNforeground             XmCForeground           Pixel              dynamic                CSG    │
747       │XmNhelpCallback           XmCCallback             XtCallbackList     NULL                   C      │
748       │XmNhighlightColor         XmCHighlightColor       Pixel              dynamic                CSG    │
749       │XmNhighlightOnEnter       XmCHighlightOnEnter     Boolean            False                  CSG    │
750       │XmNhighlightPixmap        XmCHighlightPixmap      Pixmap             dynamic                CSG    │
751       │XmNhighlightThickness     XmCHighlightThickness   Dimension          2                      CSG    │
752       │XmNlayoutDirection        XmCLayoutDirection      XmDirection        dynamic                CG     │
753       │XmNnavigationType         XmCNavigationType       XmNavigationType   XmTAB_GROUP            CSG    │
754       │XmNpopupHandlerCallback   XmCCallback             XtCallbackList     NULL                   C      │
755       │XmNshadowThickness        XmCShadowThickness      Dimension          2                      CSG    │
756       │XmNtopShadowColor         XmCTopShadowColor       Pixel              dynamic                CSG    │
757       │XmNtopShadowPixmap        XmCTopShadowPixmap      Pixmap             dynamic                CSG    │
758       │XmNtraversalOn            XmCTraversalOn          Boolean            True                   CSG    │
759       │XmNunitType               XmCUnitType             unsigned char      dynamic                CSG    │
760       │XmNuserData               XmCUserData             XtPointer          NULL                   CSG    │
761       └───────────────────────────────────────────────────────────────────────────────────────────────────┘
762       ┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
763Core Resource Set                                                
764Name                            Class                           Type             Default                Access 
765       │XmNaccelerators                 XmCAccelerators                 XtAccelerators   dynamic                CSG    │
766       │XmNancestorSensitive            XmCSensitive                    Boolean          dynamic                G      │
767       │XmNbackground                   XmCBackground                   Pixel            dynamic                CSG    │
768       │XmNbackgroundPixmap             XmCPixmap                       Pixmap           XmUNSPECIFIED_PIXMAP   CSG    │
769       │XmNborderColor                  XmCBorderColor                  Pixel            XtDefaultForeground    CSG    │
770       │XmNborderPixmap                 XmCPixmap                       Pixmap           XmUNSPECIFIED_PIXMAP   CSG    │
771       │XmNborderWidth                  XmCBorderWidth                  Dimension        0                      CSG    │
772       │XmNcolormap                     XmCColormap                     Colormap         dynamic                CG     │
773       │XmNdepth                        XmCDepth                        int              dynamic                CG     │
774       │XmNdestroyCallback              XmCCallback                     XtCallbackList   NULL                   C      │
775       │XmNheight                       XmCHeight                       Dimension        dynamic                CSG    │
776       │XmNinitialResourcesPersistent   XmCInitialResourcesPersistent   Boolean          True                   C      │
777       │XmNmappedWhenManaged            XmCMappedWhenManaged            Boolean          True                   CSG    │
778       │XmNscreen                       XmCScreen                       Screen *         dynamic                CG     │
779       │XmNsensitive                    XmCSensitive                    Boolean          True                   CSG    │
780       │XmNtranslations                 XmCTranslations                 XtTranslations   dynamic                CSG    │
781       │XmNwidth                        XmCWidth                        Dimension        dynamic                CSG    │
782       │XmNx                            XmCPosition                     Position         0                      CSG    │
783       │XmNy                            XmCPosition                     Position         0                      CSG    │
784       └───────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
785   Callback Information
786       A pointer to the following structure is passed to each callback:
787
788       typedef struct
789       {
790               int reason;
791               XEvent * event;
792       } XmAnyCallbackStruct;
793
794       reason    Indicates why the callback was invoked
795
796       event     Points to the XEvent that triggered the callback
797
798       The Text widget defines a new callback structure for use with verifica‐
799       tion  callbacks.  Note that not all fields are relevant for every call‐
800       back reason. The application must first look at the  reason  field  and
801       use  only  the structure members that are valid for the particular rea‐
802       son.  The values startPos, endPos, and text in the  callback  structure
803       XmTextVerifyCallbackStruct   may  be  modified  when  the  callback  is
804       received, and these changes will be reflected as changes  made  to  the
805       source  of  the  Text  widget. (For example, all keystrokes can be con‐
806       verted to spaces or NULL characters when a password is entered  into  a
807       Text  widget.) The application programmer should not overwrite the text
808       field, but should attach data to that pointer.
809
810       A pointer to the following structure is passed to callbacks for XmNlos‐
811       ingFocusCallback, XmNmodifyVerifyCallback, and XmNmotionVerifyCallback:
812
813       typedef struct
814       {
815               int reason;
816               XEvent * event;
817               Boolean doit;
818               XmTextPosition currInsert, newInsert;
819               XmTextPosition startPos, endPos;
820               XmTextBlock text;
821       } XmTextVerifyCallbackStruct, *XmTextVerifyPtr;
822
823       reason    Indicates why the callback was invoked.
824
825       event     Points  to the XEvent that triggered the callback.  It can be
826                 NULL. For example, changes made to the Text  widget  program‐
827                 matically  do  not  have  an  event that can be passed to the
828                 associated callback.
829
830       doit      Indicates whether the action that  invoked  the  callback  is
831                 performed.   Setting  doit to False negates the action.  Note
832                 that not all actions may be negated. For  example,  XmCR_LOS‐
833                 ING_FOCUS  callbacks  may be beyond the control of the widget
834                 if they are produced by mouse clicks.
835
836       currInsert
837                 Indicates the current position of the insert cursor.
838
839       newInsert Indicates the position at which the user attempts to position
840                 the insert cursor.
841
842       startPos  Indicates the starting position of the text to modify. If the
843                 callback is not a modify verification callback, this value is
844                 the same as currInsert.
845
846       endPos    Indicates  the  ending  position of the text to modify. If no
847                 text is replaced or deleted, the value is the same as  start‐
848                 Pos.  If  the callback is not a modify verification callback,
849                 this value is the same as currInsert.
850
851       text      Points to a structure of type XmTextBlockRec. This  structure
852                 holds the textual information to be inserted.
853
854       typedef struct
855       {
856               char *ptr;
857               int length;
858               XmTextFormat format;
859       } XmTextBlockRec, *XmTextBlock;
860
861              ptr       Points to the text to be inserted.
862
863              length    Specifies the length of the text to be inserted.
864
865              format    Specifies  the  format of the text, either XmFMT_8_BIT
866                        or XmFMT_16_BIT.
867
868       A pointer to the following structure is passed to callbacks for XmNmod‐
869       ifyVerifyCallbackWcs.
870
871       typedef struct
872       {
873               int reason;
874               XEvent *event;
875               Boolean doit;
876               XmTextPosition currInsert, newInsert;
877               XmTextPosition startPos, endPos;
878               XmTextBlockWcs text;
879       } XmTextVerifyCallbackStructWcs, *XmTextVerifyPtrWcs;
880
881       reason    Indicates why the callback was invoked.
882
883       event     Points  to the XEvent that triggered the callback.  It can be
884                 NULL. For example, changes made to the Text  widget  program‐
885                 matically  do  not  have  an  event that can be passed to the
886                 associated callback.
887
888       doit      Indicates whether the action that  invoked  the  callback  is
889                 performed.   Setting  doit to False negates the action.  Note
890                 that not all actions may be negated. For  example,  XmCR_LOS‐
891                 ING_FOCUS  callbacks  may be beyond the control of the widget
892                 if they are produced by mouse clicks.
893
894       currInsert
895                 Indicates the current position of the insert cursor.
896
897       newInsert Indicates the position at which the user attempts to position
898                 the insert cursor.
899
900       startPos  Indicates the starting position of the text to modify. If the
901                 callback is not a modify verification callback, this value is
902                 the same as currInsert.
903
904       endPos    Indicates  the  ending  position of the text to modify. If no
905                 text is replaced or deleted, the value is the same as  start‐
906                 Pos.  If  the callback is not a modify verification callback,
907                 this value is the same as currInsert.
908
909       text      Points to the following structure of type  XmTextBlockRecWcs.
910                 This structure holds the textual information to be inserted.
911
912       typedef struct
913       {
914               wchar_t *wcsptr;
915               int length;
916       } XmTextBlockRecWcs, *XmTextBlockWcs;
917
918              wcsptr    Points to the wide character text to be inserted.
919
920              length    Specifies the number of characters to be inserted.
921
922       The following table describes the reasons for which the individual ver‐
923       ification callback structure fields are  valid.  Note  that  the  event
924       field will never be valid for XmCR_MOVING_INSERT_CURSOR.
925
926       ┌────────────────────────────────────────────────────────────────┐
927Reason                      Valid Fields                        
928       │XmCR_LOSING_FOCUS           reason,  event,  doit,  currInsert,
929newInsert, startPos, endPos
930       │XmCR_MODIFYING_TEXT_VALUE   reason,  event,  doit,  currInsert,
931newInsert, startPos, endPos, text
932       │XmCR_MOVING_INSERT_CURSOR   reason, doit, currInsert, newInsert
933       └────────────────────────────────────────────────────────────────┘
934       A  pointer to the following callback structure is passed to the XmNdes‐
935       tinationCallback procedures:
936
937       typedef struct
938       {
939               int reason;
940               XEvent  *event;
941               Atom selection;
942               XtEnum operation;
943               int flags;
944               XtPointer transfer_id;
945               XtPointer destination_data;
946               XtPointer location_data;
947               Time time;
948       } XmDestinationCallbackStruct;
949
950       reason    Indicates why the callback was invoked.
951
952       event     Points to the XEvent that triggered the callback.  It can  be
953                 NULL.
954
955       selection Indicates  the  selection  for  which  data transfer is being
956                 requested.  Possible  values  are  CLIPBOARD,  PRIMARY,  SEC‐
957                 ONDARY, and _MOTIF_DROP.
958
959       operation Indicates the type of transfer operation requested.
960
961                    ·  When  the  selection  is PRIMARY or SECONDARY, possible
962                       values are XmMOVE, XmCOPY, and XmLINK.
963
964                    ·  When the selection is CLIPBOARD,  possible  values  are
965                       XmCOPY and XmLINK.
966
967                    ·  When  the selection is _MOTIF_DROP, possible values are
968                       XmMOVE,  XmCOPY,  XmLINK,  and  XmOTHER.   A  value  of
969                       XmOTHER means that the callback procedure must get fur‐
970                       ther  information  from  the   XmDropProcCallbackStruct
971                       structure in the destination_data member.
972
973       flags     Indicates  whether  or not the destination widget is also the
974                 source of the data to be transferred.  Following are the pos‐
975                 sible values:
976
977                 XmCONVERTING_NONE
978                           The  destination  widget  is  not the source of the
979                           data to be transferred.
980
981                 XmCONVERTING_SAME
982                           The destination widget is the source of the data to
983                           be transferred.
984
985       transfer_id
986                 Serves as a unique ID to identify the transfer transaction.
987
988       destination_data
989                 Contains  information about the destination.  When the selec‐
990                 tion is _MOTIF_DROP, the callback procedures  are  called  by
991                 the  drop  site's  XmNdropProc,  and  destination_data  is  a
992                 pointer to the XmDropProcCallbackStruct structure  passed  to
993                 the  XmNdropProc procedure.  When the selection is SECONDARY,
994                 destination_data is an Atom  representing  a  target  recomm‐
995                 mended  by  the  selection  owner  for  use in converting the
996                 selection.  Otherwise, destination_data is NULL.
997
998       location_data
999                 Contains information about the location where data is  to  be
1000                 transferred.   The value is always NULL when the selection is
1001                 CLIPBOARD.  If the value is NULL, the data is to be  inserted
1002                 at  the  widget's cursor position.  Otherwise, the value is a
1003                 pointer to an XPoint structure containing the x- and y- coor‐
1004                 dinates  at the location where the data is to be transferred.
1005                 Once XmTransferDone procedures  start  to  be  called,  loca‐
1006                 tion_data will no longer be stable.
1007
1008       time      Indicates the time when the transfer operation began.
1009
1010   Translations
1011       The  XmText  translations  are  described  in  the following list.  The
1012       actions represent the effective behavior of the associated events,  and
1013       they may differ in a right-to-left language environment.
1014
1015       The following key names are listed in the X standard key event transla‐
1016       tion table syntax.  This format is the one used by Motif to specify the
1017       widget  actions  corresponding to a given key.  A brief overview of the
1018       format is provided under VirtualBindings(3).  For a  complete  descrip‐
1019       tion  of the format, please refer to the X Toolkit Instrinsics Documen‐
1020       tation.
1021
1022       ∼c s ∼m ∼a <Btn1Down>:
1023                 extend-start()
1024
1025       c ∼s ∼m ∼a <Btn1Down>:
1026                 move-destination()
1027
1028       ∼c ∼s ∼m ∼a <Btn1Down>:
1029                 grab-focus()
1030
1031       ∼c ∼m ∼a <Btn1Motion>:
1032                 extend-adjust()
1033
1034       ∼c ∼m ∼a <Btn1Up>:
1035                 extend-end()
1036
1037       <Btn2Down>:
1038                 process-bdrag()
1039
1040       m ∼a <Btn2Motion>:
1041                 secondary-adjust()
1042
1043       ∼m a <Btn2Motion>:
1044                 secondary-adjust()
1045
1046       s c <Btn2Up>:
1047                 link-to()
1048
1049       ∼s <Btn2Up>:
1050                 copy-to()
1051
1052       ∼c <Btn2Up>:
1053                 move-to()
1054
1055       :m <Key><osfPrimaryPaste>:
1056                 cut-primary()
1057
1058       :a <Key><osfPrimaryPaste>:
1059                 cut-primary()
1060
1061       :<Key><osfPrimaryPaste>:
1062                 copy-primary()
1063
1064       :m <Key><osfCut>:
1065                 cut-primary()
1066
1067       :a <Key><osfCut>:
1068                 cut-primary()
1069
1070       :<Key><osfCut>:
1071                 cut-clipboard()
1072
1073       :<Key><osfPaste>:
1074                 paste-clipboard()
1075
1076       :m <Key><osfCopy>:
1077                 copy-primary()
1078
1079       :a <Key><osfCopy>:
1080                 copy-primary()
1081
1082       :<Key><osfCopy>:
1083                 copy-clipboard()
1084
1085       :s c <Key><osfBeginLine>:
1086                 beginning-of-file(extend)
1087
1088       :c <Key><osfBeginLine>:
1089                 beginning-of-file()
1090
1091       :s <Key><osfBeginLine>:
1092                 beginning-of-line(extend)
1093
1094       :<Key><osfBeginLine>:
1095                 beginning-of-line()
1096
1097       :s c <Key><osfEndLine>:
1098                 end-of-file(extend)
1099
1100       :c <Key><osfEndLine>:
1101                 end-of-file()
1102
1103       :s <Key><osfEndLine>:
1104                 end-of-line(extend)
1105
1106       :<Key><osfEndLine>:
1107                 end-of-line()
1108
1109       :s <Key><osfPageLeft>:
1110                 page-left(extend) (ignored in vertical writing)
1111
1112       :<Key><osfPageLeft>:
1113                 page-left() (next-page() in vertical writing)
1114
1115       :s c <Key><osfPageUp>:
1116                 page-left(extend)
1117
1118       :c <Key><osfPageUp>:
1119                 page-left()
1120
1121       :s <Key><osfPageUp>:
1122                 previous-page(extend) (ignored in vertical writing)
1123
1124       :<Key><osfPageUp>:
1125                 previous-page() (page-up() in vertical writing)
1126
1127       :s <Key><osfPageRight>:
1128                 page-right(extend) (ignored in vertical writing)
1129
1130       :<Key><osfPageRight>:
1131                 page-right() (previous-page() in vertical writing)
1132
1133       s c <Key><osfPageDown>:
1134                 page-right(extend) (ignored in vertical writing)
1135
1136       :c <Key><osfPageDown>:
1137                 page-right()
1138
1139       :s <Key><osfPageDown>:
1140                 next-page(extend) (ignored in vertical writing)
1141
1142       :<Key><osfPageDown>:
1143                 next-page() (page-down() in vertical writing)
1144
1145       :<Key><osfClear>:
1146                 clear-selection()
1147
1148       :<Key><osfBackSpace>:
1149                 delete-previous-character()
1150
1151       :s m <Key><osfDelete>:
1152                 cut-primary()
1153
1154       :s a <Key><osfDelete>:
1155                 cut-primary()
1156
1157       :s <Key><osfDelete>:
1158                 cut-clipboard()
1159
1160       :c <Key><osfDelete>:
1161                 delete-to-end-of-line()
1162
1163       :<Key><osfDelete>:
1164                 delete-next-character()
1165
1166       :c m <Key><osfInsert>:
1167                 copy-primary()
1168
1169       :c a <Key><osfInsert>:
1170                 copy-primary()
1171
1172       :s <Key><osfInsert>:
1173                 paste-clipboard()
1174
1175       :c <Key><osfInsert>:
1176                 copy-clipboard()
1177
1178       :s <Key><osfSelect>:
1179                 key-select()
1180
1181       :<Key><osfSelect>:
1182                 set-anchor()
1183
1184       :<Key><osfSelectAll>:
1185                 select-all()
1186
1187       :<Key><osfDeselectAll>:
1188                 deselect-all()
1189
1190       :<Key><osfActivate>:
1191                 activate()
1192
1193       :<Key><osfAddMode>:
1194                 toggle-add-mode()
1195
1196       :<Key><osfHelp>:
1197                 Help()
1198
1199       :<Key><osfCancel>:
1200                 process-cancel()
1201
1202       :s c <Key><osfLeft>:
1203                 backward-word(extend) ( forward-paragraph(extend) in vertical
1204                 writing)
1205
1206       :c <Key><osfLeft>:
1207                 backward-word() (forward-paragraph() in vertical writing)
1208
1209       :s <Key><osfLeft>:
1210                 key-select(left) (process-shift-left() in vertical writing)
1211
1212       :<Key><osfLeft>:
1213                 backward-character() (process-left() in vertical writing)
1214
1215       :s c <Key><osfRight>:
1216                 forward-word(extend)  (backward-paragraph(extend) in vertical
1217                 writing)
1218
1219       :c <Key><osfRight>:
1220                 forward-word() (backward-paragraph() in vertical writing)
1221
1222       :s <Key><osfRight>:
1223                 key-select(right) (process-shift-right in vertical writing)
1224
1225       :<Key><osfRight>:
1226                 forward-character() (process-right() in vertical writing)
1227
1228       :s c <Key><osfUp>:
1229                 backward-paragraph(extend) (backward-word(extend) in vertical
1230                 writing)
1231
1232       :c <Key><osfUp>:
1233                 backward-paragraph() (backward-word() in vertical writing)
1234
1235       :s <Key><osfUp>:
1236                 process-shift-up() (key-select(up) in vertical writing)
1237
1238       :<Key><osfUp>:
1239                 process-up() (backward-character() in vertical writing)
1240
1241       :s c <Key><osfDown>:
1242                 forward-paragraph(extend)  (forward-word(extend)  in vertical
1243                 writing)
1244
1245       :c <Key><osfDown>:
1246                 forward-paragraph() (forward-word() in vertical writing)
1247
1248       :s <Key><osfDown>:
1249                 process-shift-down() (key-select(down) in vertical writing)
1250
1251       :<Key><osfDown>:
1252                 process-down() (forward-character() in vertical writing)
1253
1254       c ∼m ∼a <Key>slash:
1255                 select-all()
1256
1257       c ∼m ∼a <Key>backslash:
1258                 deselect-all()
1259
1260       s c ∼m ∼a <Key>Tab:
1261                 prev-tab-group()
1262
1263       ∼s c ∼m ∼a <Key>Tab:
1264                 next-tab-group()
1265
1266       s ∼c ∼m ∼a <Key>Tab:
1267                 process-tab(Prev)
1268
1269       ∼s ∼c ∼m ∼a <Key>Tab:
1270                 process-tab(Next)
1271
1272       ∼s c ∼m ∼a <Key>Return:
1273                 activate()
1274
1275       ∼s ∼c ∼m ∼a <Key>Return:
1276                 process-return()
1277
1278       ∼s c ∼m ∼a <Key>space:
1279                 set-anchor()
1280
1281       s c ∼m ∼a <Key>space:
1282                 key-select()
1283
1284       s ∼c ∼m ∼a <Key>space:
1285                 self-insert()
1286
1287       <Key>:    self-insert()
1288
1289       The Text button event translations are modified when  Display's  XmNen‐
1290       ableBtn1Transfer  resource  does  not  have  a value of XmOFF (in other
1291       words, it  is  either  XmBUTTON2_TRANSFER  or  XmBUTTON2_ADJUST).  This
1292       option  allows  the actions for selection and transfer to be integrated
1293       on <Btn1>, and the actions for extending the selection can be bound  to
1294       <Btn2>.  The actions for <Btn1> that are defined above still apply when
1295       the <Btn1> event occurs over text that is not selected.  The  following
1296       actions apply when the <Btn1> event occurs over text that is selected:
1297
1298       <Btn1Down>:
1299                 process-bdrag().
1300
1301       <Shift><Btn1Down>:
1302                 process-bdrag().
1303
1304       <Ctrl><Btn1Down>:
1305                 process-bdrag().
1306
1307       <Btn1Down><Shift><Btn1Up>:
1308                 grab-focus(), extend-end.
1309
1310       <Shift><Btn1Down><Shift><Btn1Up>:
1311                 extend-start(), extend-end().
1312
1313       <Ctrl><Btn1Down><Shift><Btn1Up>:
1314                 move-destination().
1315
1316       When  Display's  XmNenableBtn1Transfer  resource  has a value of XmBUT‐
1317       TON2_ADJUST, the following actions apply:
1318
1319       <Btn2Down>:
1320                 extend-start().
1321
1322       <Btn2Motion>:
1323                 extend-adjust().
1324
1325       <Btn2Up>: extend-end().
1326
1327   Action Routines
1328       The XmText action routines are
1329
1330       activate():
1331                 Calls the  callbacks  for  XmNactivateCallback.   Passes  the
1332                 event to the parent.
1333
1334       backward-character(extend):
1335                 Moves  the  insertion cursor one character to the left.  This
1336                 action may have different behavior in  a  right-to-left  lan‐
1337                 guage environment.
1338
1339                 If  called  with  an  argument of extend, moves the insertion
1340                 cursor as in the case of no argument and extends the  current
1341                 selection.
1342
1343                 The  backward-character() action produces calls to the XmNmo‐
1344                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1345                 ING_INSERT_CURSOR.   If  called with the extend argument, the
1346                 backward-character() action may produce calls to the XmNgain‐
1347                 PrimaryCallback  procedures.   See  callback  description for
1348                 more information.
1349
1350                 In vertical writing, if XmNeditMode is XmSINGLE_LINE_EDIT and
1351                 XmNnavigationType  is  XmNONE, traverses to the widget to the
1352                 left in the tab group. If XmNeditMode  is  XmMULTI_LINE_EDIT,
1353                 moves  the insertion cursor to the next line in the same col‐
1354                 umn.
1355
1356       backward-paragraph(extend):
1357                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
1358                 with  no  argument,  moves  the insertion cursor to the first
1359                 non-whitespace character following the first  previous  blank
1360                 line  or  beginning  of the text.  If the insertion cursor is
1361                 already at the beginning of a paragraph, moves the  insertion
1362                 cursor to the beginning of the previous paragraph.
1363
1364                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
1365                 with an argument of extend, moves the insertion cursor as  in
1366                 the case of no argument and extends the current selection.
1367
1368                 The  backward-paragraph() action produces calls to the XmNmo‐
1369                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1370                 ING_INSERT_CURSOR.   If  called with the extend argument, the
1371                 backward-paragraph() action may produce calls to the XmNgain‐
1372                 PrimaryCallback  procedures.   See  callback  description for
1373                 more information.
1374
1375       backward-word(extend):
1376                 If this action is called with no argument, moves  the  inser‐
1377                 tion  cursor  to the first non-whitespace character after the
1378                 first whitespace character to the left or after the beginning
1379                 of  the  line.   If  the  insertion  cursor is already at the
1380                 beginning of a word, moves the insertion cursor to the begin‐
1381                 ning  of  the  previous word.  This action may have different
1382                 behavior in a locale other than the C locale.
1383
1384                 If called with an argument of  extend,  moves  the  insertion
1385                 cursor  as in the case of no argument and extends the current
1386                 selection.
1387
1388                 The backward-word() action produces calls to  the  XmNmotion‐
1389                 VerifyCallback   procedures   with   reason  value  XmCR_MOV‐
1390                 ING_INSERT_CURSOR.  If called with the extend  argument,  the
1391                 backward-word() action may produce calls to the XmNgainPrima‐
1392                 ryCallback procedures.  See  callback  description  for  more
1393                 information.
1394
1395       beep():   Causes  the  terminal to beep.  The beep() action produces no
1396                 callbacks.
1397
1398       beginning-of-file(extend):
1399                 If this action is called with no argument, moves  the  inser‐
1400                 tion cursor to the beginning of the text.
1401
1402                 If  called  with  an  argument of extend, moves the insertion
1403                 cursor as in the case of no argument and extends the  current
1404                 selection.
1405
1406                 The  beginning-of-file()  action produces calls to the XmNmo‐
1407                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1408                 ING_INSERT_CURSOR.   If  called with the extend argument, the
1409                 beginning-of-file() action may produce calls to the  XmNgain‐
1410                 PrimaryCallback  procedures.   See  callback  description for
1411                 more information.
1412
1413       beginning-of-line(extend):
1414                 If this action is called with no argument, moves  the  inser‐
1415                 tion cursor to the beginning of the line.
1416
1417                 If  called  with  an  argument of extend, moves the insertion
1418                 cursor as in the case of no argument and extends the  current
1419                 selection.
1420
1421                 The  beginning-of-line()  action produces calls to the XmNmo‐
1422                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1423                 ING_INSERT_CURSOR.   If  called with the extend argument, the
1424                 beginning-of-line() action may produce calls to the  XmNgain‐
1425                 PrimaryCallback  procedures.   See  callback  description for
1426                 more information.
1427
1428       clear-selection():
1429                 Clears the current  selection  by  replacing  each  character
1430                 except <Return> with a <space> character.
1431
1432                 The  clear-selection()  action produces calls to the XmNmodi‐
1433                 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
1434                 ING_TEXT_VALUE  and  the  XmNvalueChangedCallback  procedures
1435                 with reason value XmCR_VALUE_CHANGED.
1436
1437       copy-clipboard():
1438                 If this widget owns the primary selection, this action copies
1439                 the  selection  to the clipboard.  This action calls the XmN‐
1440                 convertCallback procedures, possibly multiple times, for  the
1441                 CLIPBOARD selection.
1442
1443       copy-primary():
1444                 Copies  the  primary  selection  to just before the insertion
1445                 cursor.  This action calls the XmNdestinationCallback  proce‐
1446                 dures for the PRIMARY selection and the XmCOPY operation.  It
1447                 calls the selection  owner's  XmNconvertCallback  procedures,
1448                 possibly multiple times, for the PRIMARY selection.
1449
1450                 In  addition, the copy-primary() action produces calls to the
1451                 XmNmodifyVerifyCallback   procedures   with   reason    value
1452                 XmCR_MODIFYING_TEXT_VALUE,   to  the  XmNvalueChangedCallback
1453                 procedures with reason value XmCR_VALUE_CHANGED, and  to  the
1454                 XmNmotionVerifyCallback    procedures   with   reason   value
1455                 XmCR_MOVING_INSERT_CURSOR.
1456
1457       copy-to():
1458                 If a secondary selection exists, this action copies the  sec‐
1459                 ondary selection to the insertion position of the destination
1460                 component.  If the primary selection is  in  the  destination
1461                 widget,  it will be deselected. Otherwise, there is no effect
1462                 on the primary selection.
1463
1464                 This action calls  the  destination's  XmNdestinationCallback
1465                 procedures  for the SECONDARY selection and the XmCOPY opera‐
1466                 tion.  The destination's XmNdestinationCallback procedures or
1467                 the   destination  component  itself  invokes  the  selection
1468                 owner's  XmNconvertCallback  procedures,  possibly   multiple
1469                 times, for the SECONDARY selection.
1470
1471                 If no secondary selection exists, this action copies the pri‐
1472                 mary selection to the pointer position.   This  action  calls
1473                 the  XmNdestinationCallback procedures for the PRIMARY selec‐
1474                 tion and  the  XmCOPY  operation.   It  calls  the  selection
1475                 owner's   XmNconvertCallback  procedures,  possibly  multiple
1476                 times, for the PRIMARY selection.
1477
1478                 In addition, the copy-to() action produces calls to the  XmN‐
1479                 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
1480                 FYING_TEXT_VALUE, to the  XmNvalueChangedCallback  procedures
1481                 with  reason  value XmCR_VALUE_CHANGED, and to the XmNmotion‐
1482                 VerifyCallback  procedures  with   reason   value   XmCR_MOV‐
1483                 ING_INSERT_CURSOR.   If  there is no secondary selection, the
1484                 copy-to() action may produce calls to the XmNgainPrimaryCall‐
1485                 back  procedures.  See callback description for more informa‐
1486                 tion.
1487
1488       cut-clipboard():
1489                 If this widget owns the primary selection, this  action  cuts
1490                 the  selection  to the clipboard.  This action calls the XmN‐
1491                 convertCallback procedures, possibly multiple times, for  the
1492                 CLIPBOARD  selection.   If  the  transfer is successful, this
1493                 action then calls the XmNconvertCallback procedures  for  the
1494                 CLIPBOARD selection and the DELETE target.
1495
1496                 In addition, the cut-clipboard() action produces calls to the
1497                 XmNmodifyVerifyCallback   procedures   with   reason    value
1498                 XmCR_MODIFYING_TEXT_VALUE,  and  the  XmNvalueChangedCallback
1499                 procedures with reason value XmCR_VALUE_CHANGED.
1500
1501       cut-primary():
1502                 Cuts the primary selection and  pastes  it  just  before  the
1503                 insertion  cursor.  This action calls the XmNdestinationCall‐
1504                 back procedures for the  PRIMARY  selection  and  the  XmMOVE
1505                 operation.  It calls the selection owner's XmNconvertCallback
1506                 procedures, possibly multiple times, for the  PRIMARY  selec‐
1507                 tion.   If the transfer is successful, this action then calls
1508                 the selection owner's XmNconvertCallback procedures  for  the
1509                 PRIMARY  selection  and the DELETE target.  The cut-primary()
1510                 action may produce calls to the XmNgainPrimaryCallback proce‐
1511                 dures.  See callback description for more information.
1512
1513                 In  addition,  the cut-primary() action produces calls to the
1514                 XmNmotionVerifyCallback   procedures   with   reason    value
1515                 XmCR_MOVING_INSERT_CURSOR, the XmNmodifyVerifyCallback proce‐
1516                 dures with reason value  XmCR_MODIFYING_TEXT_VALUE,  and  the
1517                 XmNvalueChangedCallback    procedures   with   reason   value
1518                 XmCR_VALUE_CHANGED.
1519
1520       delete-next-character():
1521                 In normal mode, if there is a nonnull selection, deletes  the
1522                 selection;  otherwise,  deletes  the  character following the
1523                 insertion cursor.  In add mode, if there is a nonnull  selec‐
1524                 tion, the cursor is not disjoint from the selection, and XmN‐
1525                 pendingDelete is set to True, deletes the  selection;  other‐
1526                 wise,  deletes  the character following the insertion cursor.
1527                 This may impact the selection.
1528
1529                 The delete-next-character() action produces calls to the XmN‐
1530                 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
1531                 FYING_TEXT_VALUE, and the XmNvalueChangedCallback  procedures
1532                 with reason value XmCR_VALUE_CHANGED.
1533
1534       delete-next-word():
1535                 In  normal mode, if there is a nonnull selection, deletes the
1536                 selection; otherwise, deletes the  characters  following  the
1537                 insertion  cursor to the next space, tab or end-of-line char‐
1538                 acter.  In add mode, if there is  a  nonnull  selection,  the
1539                 cursor  is  not  disjoint  from  the  selection, and XmNpend‐
1540                 ingDelete is set to True, deletes the  selection;  otherwise,
1541                 deletes  the characters following the insertion cursor to the
1542                 next space, tab or end-of-line character.   This  may  impact
1543                 the  selection.  This action may have different behavior in a
1544                 locale other than the C locale.
1545
1546                 The delete-next-word() action produces calls to the  XmNmodi‐
1547                 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
1548                 ING_TEXT_VALUE, and  the  XmNvalueChangedCallback  procedures
1549                 with reason value XmCR_VALUE_CHANGED.
1550
1551       delete-previous-character():
1552                 In  normal mode, if there is a nonnull selection, deletes the
1553                 selection; otherwise, deletes the character of  text  immedi‐
1554                 ately  preceding the insertion cursor.  In add mode, if there
1555                 is a nonnull selection, the cursor is not disjoint  from  the
1556                 selection,  and  XmNpendingDelete is set to True, deletes the
1557                 selection; otherwise, deletes the character of  text  immedi‐
1558                 ately  preceding  the  insertion cursor.  This may impact the
1559                 selection.
1560
1561                 The delete-previous-character() action produces calls to  the
1562                 XmNmodifyVerifyCallback    procedures   with   reason   value
1563                 XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback proce‐
1564                 dures  with  reason  value XmCR_VALUE_CHANGED, and the XmNmo‐
1565                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1566                 ING_INSERT_CURSOR.
1567
1568       delete-previous-word():
1569                 In  normal mode, if there is a nonnull selection, deletes the
1570                 selection; otherwise, deletes the  characters  preceding  the
1571                 insertion  cursor to the next space, tab or beginning-of-line
1572                 character. In add mode, if there is a nonnull selection,  the
1573                 cursor  is  not  disjoint  from  the  selection, and XmNpend‐
1574                 ingDelete is set to True, deletes the  selection;  otherwise,
1575                 deletes  the characters preceding the insertion cursor to the
1576                 next space, tab  or  beginning-of-line  character.  This  may
1577                 impact the selection. This action may have different behavior
1578                 in a locale other than the C locale.
1579
1580                 The delete-previous-word() action produces calls to the  XmN‐
1581                 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
1582                 FYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with
1583                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1584                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1585
1586       delete-selection():
1587                 Deletes the current selection.
1588
1589                 The delete-selection() action produces calls to the  XmNmodi‐
1590                 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
1591                 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
1592                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1593                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1594
1595       delete-to-end-of-line():
1596                 In normal mode, if there is a nonnull selection, deletes  the
1597                 selection;  otherwise,  deletes  the characters following the
1598                 insertion cursor to the next end of line character.   In  add
1599                 mode, if there is a nonnull selection, the cursor is not dis‐
1600                 joint from the selection,  and  XmNpendingDelete  is  set  to
1601                 True,  deletes  the selection; otherwise, deletes the charac‐
1602                 ters following the insertion cursor to the next end  of  line
1603                 character.  This may impact the selection.
1604
1605                 The delete-to-end-of-line() action produces calls to the XmN‐
1606                 modifyVerifyCallback procedures with reason value  XmCR_MODI‐
1607                 FYING_TEXT_VALUE,  and the XmNvalueChangedCallback procedures
1608                 with reason value XmCR_VALUE_CHANGED.
1609
1610       delete-to-start-of-line():
1611                 In normal mode, if there is a nonnull selection, deletes  the
1612                 selection;  otherwise,  deletes  the characters preceding the
1613                 insertion cursor to the previous beginning-of-line character.
1614                 In  add  mode, if there is a nonnull selection, the cursor is
1615                 not disjoint from the selection, and XmNpendingDelete is  set
1616                 to  True, deletes the selection; otherwise, deletes the char‐
1617                 acters preceding the insertion cursor to the previous  begin‐
1618                 ning-of-line character.  This may impact the selection.
1619
1620                 The  delete-to-start-of-line()  action  produces calls to the
1621                 XmNmodifyVerifyCallback   procedures   with   reason    value
1622                 XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback proce‐
1623                 dures with reason value XmCR_VALUE_CHANGED,  and  the  XmNmo‐
1624                 tionVerifyCallback  procedures  with  reason  value XmCR_MOV‐
1625                 ING_INSERT_CURSOR.
1626
1627       deselect-all():
1628                 Deselects the current selection.  The  deselect-all()  action
1629                 produces no callbacks.
1630
1631       end-of-file(extend):
1632                 If  this  action is called with no argument, moves the inser‐
1633                 tion cursor to the end of the text.
1634
1635                 If called with an argument of  extend,  moves  the  insertion
1636                 cursor  as in the case of no argument and extends the current
1637                 selection.
1638
1639                 The end-of-file() action produces calls to the XmNmotionVeri‐
1640                 fyCallback    procedures    with   reason   value   XmCR_MOV‐
1641                 ING_INSERT_CURSOR.  If called with the extend  argument,  the
1642                 end-of-file()  action  may produce calls to the XmNgainPrima‐
1643                 ryCallback procedures.  See  callback  description  for  more
1644                 information.
1645
1646       end-of-line(extend):
1647                 If  this  action is called with no argument, moves the inser‐
1648                 tion cursor to the end of the line.  If called with an  argu‐
1649                 ment  of extend, moves the insertion cursor as in the case of
1650                 no argument and extends the current selection.
1651
1652                 The end-of-line() action produces calls to the XmNmotionVeri‐
1653                 fyCallback    procedures    with   reason   value   XmCR_MOV‐
1654                 ING_INSERT_CURSOR.  If called with the extend  argument,  the
1655                 end-of-line()  action  may produce calls to the XmNgainPrima‐
1656                 ryCallback procedures.  See  callback  description  for  more
1657                 information.
1658
1659       extend-adjust():
1660                 Selects text from the anchor to the pointer position and des‐
1661                 elects text outside that range.  Moving the pointer over sev‐
1662                 eral  lines  selects  text from the anchor to the end of each
1663                 line the pointer moves over and up to the pointer position on
1664                 the current line.
1665
1666                 The  extend-adjust()  action produces calls to the XmNmotion‐
1667                 VerifyCallback  procedures  with   reason   value   XmCR_MOV‐
1668                 ING_INSERT_CURSOR.   The  extend-adjust()  action may produce
1669                 calls to the XmNgainPrimaryCallback procedures.  See callback
1670                 description for more information.
1671
1672       extend-end():
1673                 Moves  the  insertion  cursor to the position of the pointer.
1674                 The extend-end() action is  used  to  commit  the  selection.
1675                 After  this  action  has  been done, process-cancel() will no
1676                 longer cancel the selection.
1677
1678                 The extend-end() action produces calls to the  XmNmotionVeri‐
1679                 fyCallback    procedures    with   reason   value   XmCR_MOV‐
1680                 ING_INSERT_CURSOR.  The extend-end() action may produce calls
1681                 to   the  XmNgainPrimaryCallback  procedures.   See  callback
1682                 description for more information.
1683
1684       extend-start():
1685                 Adjusts the anchor using the  balance-beam  method.   Selects
1686                 text  from  the  anchor to the pointer position and deselects
1687                 text outside that range.  The extend-start() action may  pro‐
1688                 duce  no  callbacks,  however,  the extend-start() action may
1689                 produce calls to the XmNgainPrimaryCallback procedures.   See
1690                 callback description for more information.
1691
1692       forward-character(extend):
1693                 Moves  the insertion cursor one character to the right.  This
1694                 action may have different behavior in  a  right-to-left  lan‐
1695                 guage environment.
1696
1697                 If  called  with  an  argument of extend, moves the insertion
1698                 cursor as in the case of no argument and extends the  current
1699                 selection.
1700
1701                 The  forward-character()  action produces calls to the XmNmo‐
1702                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1703                 ING_INSERT_CURSOR.   If  called with the extend argument, the
1704                 forward-character() action may produce calls to the  XmNgain‐
1705                 PrimaryCallback  procedures.   See  callback  description for
1706                 more information.
1707
1708                 In vertical writing, if XmNeditMode is XmSINGLE_LINE_EDIT and
1709                 XmNnavigationType  is  XmNONE, traverses to the widget to the
1710                 right in the tab group. If XmNeditMode is  XmMULTI_LINE_EDIT,
1711                 moves  the  insertion cursor to the previous line in the same
1712                 column.
1713
1714       forward-paragraph(extend):
1715                 If XmNeditMode  is  XmMULTI_LINE_EDIT,  and  this  action  is
1716                 called  with  no  argument, moves the insertion cursor to the
1717                 first non-whitespace character following the next blank line.
1718                 If  the  insertion  cursor  is  already at the beginning of a
1719                 paragraph, moves the insertion cursor to the beginning of the
1720                 next paragraph.
1721
1722                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
1723                 with an argument of extend, moves the insertion cursor as  in
1724                 the case of no argument and extends the current selection.
1725
1726                 The  forward-paragraph()  action produces calls to the XmNmo‐
1727                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1728                 ING_INSERT_CURSOR.   If  called with the extend argument, the
1729                 forward-paragraph() action may produce calls to the  XmNgain‐
1730                 PrimaryCallback  procedures.   See  callback  description for
1731                 more information.
1732
1733       forward-word(extend):
1734                 If this action is called with no argument, moves  the  inser‐
1735                 tion  cursor to the first whitespace character or end-of-line
1736                 following the next non-whitespace character.  If  the  inser‐
1737                 tion cursor is already at the end of a word, moves the inser‐
1738                 tion cursor to the end of the next  word.   This  action  may
1739                 have different behavior in a locale other than the C locale.
1740
1741                 If  called  with  an  argument of extend, moves the insertion
1742                 cursor as in the case of no argument and extends the  current
1743                 selection.
1744
1745                 The forward-word() action produces calls to the XmNmotionVer‐
1746                 ifyCallback   procedures   with   reason   value    XmCR_MOV‐
1747                 ING_INSERT_CURSOR.   If  called with the extend argument, the
1748                 forward-word() action may produce calls to the  XmNgainPrima‐
1749                 ryCallback  procedures.   See  callback  description for more
1750                 information.
1751
1752       grab-focus():
1753                 This key binding performs the action defined in the XmNselec‐
1754                 tionArray,  depending on the number of multiple mouse clicks.
1755                 The default selection array ordering is one click to move the
1756                 insertion  cursor  to  the  pointer  position,  two clicks to
1757                 select a word, three clicks to select a  line  of  text,  and
1758                 four  clicks  to  select all text.  A single click also dese‐
1759                 lects any selected text and sets the anchor  at  the  pointer
1760                 position.   This  action  may  have  different  behavior in a
1761                 locale other than the C locale.
1762
1763                 The grab-focus() action produces calls to the  XmNmotionVeri‐
1764                 fyCallback    procedures    with   reason   value   XmCR_MOV‐
1765                 ING_INSERT_CURSOR.
1766
1767       Help():   Calls the callbacks for XmNhelpCallback  if  any  exist.   If
1768                 there  are  no  help  callbacks  for this widget, this action
1769                 calls the help callbacks for the nearest  ancestor  that  has
1770                 them.
1771
1772       insert-string(string):
1773                 If  XmNpendingDelete  is  True and the cursor is not disjoint
1774                 from the current selection,  deletes  the  entire  selection.
1775                 Inserts string before the insertion cursor.
1776
1777                 The  insert-string()  action  produces  calls to the XmNmodi‐
1778                 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
1779                 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
1780                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1781                 back  procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1782                 Note that, in the case of an empty string, no callbacks  will
1783                 be  called,  since  no modification will have been done. How‐
1784                 ever, if the insertion position is inside the current  selec‐
1785                 tion,  insert-string  with  an  empty  string  will cause the
1786                 selection to be deselected, and  the  XmNmotionVerifyCallback
1787                 procedures   to   be   called  with  reason  value  XmCR_MOV‐
1788                 ING_INSERT_CURSOR,       XmCR_MODIFYING_TEXT_VALUE,       and
1789                 XmCR_VALUE_CHANGED.
1790
1791       key-select(right|left):
1792                 If called with an argument of right, moves the insertion cur‐
1793                 sor one character to the right and extends the current selec‐
1794                 tion.   If  called with an argument of left, moves the inser‐
1795                 tion cursor one character to the left and extends the current
1796                 selection.   If  called with no argument, extends the current
1797                 selection.
1798
1799                 Note that after a key-select action, the selection will still
1800                 begin at the original anchor, and will extend to the position
1801                 indicated in the action call. If this new position is on  the
1802                 opposite  side  of  the  selection  anchor  from the previous
1803                 selection boundary, the  original  selection  will  be  dese‐
1804                 lected.
1805
1806                 The  key-select() action produces calls to the XmNmotionVeri‐
1807                 fyCallback   procedures   with   reason    value    XmCR_MOV‐
1808                 ING_INSERT_CURSOR.  The key-select() action may produce calls
1809                 to  the  XmNgainPrimaryCallback  procedures.   See   callback
1810                 description for more information.
1811
1812                 In vertical writing, if called with the argument left, and if
1813                 XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion  cursor
1814                 to the next line in the same column.  In vertical writing, if
1815                 called  with  the  argument  right,  and  if  XmNeditMode  is
1816                 XmMULTI_LINE_EDIT, moves the insertion cursor to the previous
1817                 line in the same column.)
1818
1819       kill-next-character():
1820                 In normal mode, if there is a nonnull  selection,  kills  the
1821                 selection;  otherwise,  kills  the  character  following  the
1822                 insertion cursor and stores the character in the cut  buffer.
1823                 In  add  mode, if there is a nonnull selection, the cursor is
1824                 not disjoint from the selection, and XmNpendingDelete is  set
1825                 to  True, deletes the selection; otherwise, kills the charac‐
1826                 ter following the insertion cursor and stores  the  character
1827                 in the cut buffer.  This may impact the selection.
1828
1829                 The killed text is stored in CUT_BUFFER0.
1830
1831                 The  kill-next-character()  action produces calls to the XmN‐
1832                 modifyVerifyCallback procedures with reason value  XmCR_MODI‐
1833                 FYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with
1834                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1835                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1836
1837       kill-next-word():
1838                 In  normal mode, if there is a nonnull selection, deletes the
1839                 selection; otherwise,  kills  the  characters  following  the
1840                 insertion  cursor to the next space, tab or end-of-line char‐
1841                 acter, and stores the characters in the cut  buffer.  In  add
1842                 mode, if there is a nonnull selection, the cursor is not dis‐
1843                 joint from the selection,  and  XmNpendingDelete  is  set  to
1844                 True,  deletes the selection; otherwise, kills the characters
1845                 following the insertion cursor to the next space, tab or end-
1846                 of-line  character, and stores the characters in the cut buf‐
1847                 fer. This may impact the selection. This action may have dif‐
1848                 ferent behavior in a locale other than the C locale.
1849
1850                 The killed text is stored in CUT_BUFFER0.
1851
1852                 The  kill-next-word()  action  produces calls to the XmNmodi‐
1853                 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
1854                 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
1855                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1856                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1857
1858       kill-previous-character():
1859                 In  normal mode, if there is a nonnull selection, deletes the
1860                 selection; otherwise, kills the character immediately preced‐
1861                 ing  the insertion cursor and stores the character in the cut
1862                 buffer.  In add mode, if there is a  nonnull  selection,  the
1863                 cursor  is  not  disjoint  from  the  selection, and XmNpend‐
1864                 ingDelete is set to True, deletes the  selection;  otherwise,
1865                 kills  the character immediately preceding the insertion cur‐
1866                 sor and stores the character in the  cut  buffer.   This  may
1867                 impact the selection.
1868
1869                 The killed text is stored in CUT_BUFFER0.
1870
1871                 The  kill-previous-character()  action  produces calls to the
1872                 XmNmodifyVerifyCallback   procedures   with   reason    value
1873                 XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback proce‐
1874                 dures with reason value XmCR_VALUE_CHANGED,  and  the  XmNmo‐
1875                 tionVerifyCallback  procedures  with  reason  value XmCR_MOV‐
1876                 ING_INSERT_CURSOR.
1877
1878       kill-previous-word():
1879                 In normal mode, if there is a nonnull selection, deletes  the
1880                 selection;  otherwise,  kills  the  characters  preceding the
1881                 insertion cursor up to the next space, tab  or  beginning-of-
1882                 line  character, and stores the characters in the cut buffer.
1883                 In add mode, if there is a nonnull selection, the  cursor  is
1884                 not  disjoint from the selection, and XmNpendingDelete is set
1885                 to True, deletes the selection; otherwise, kills the  charac‐
1886                 ters preceding the insertion cursor up to the next space, tab
1887                 or beginning-of-line character, and stores the characters  in
1888                 the  cut  buffer.  This may impact the selection. This action
1889                 may have different behavior in a  locale  other  than  the  C
1890                 locale.
1891
1892                 The killed text is stored in CUT_BUFFER0.
1893
1894                 The kill-previous-word() action produces calls to the XmNmod‐
1895                 ifyVerifyCallback procedures with reason  value  XmCR_MODIFY‐
1896                 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
1897                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1898                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1899
1900       kill-selection():
1901                 Kills  the currently selected text and stores the text in the
1902                 cut buffer.
1903
1904                 The killed text is stored in CUT_BUFFER0.
1905
1906                 The kill-selection() action produces calls  to  the  XmNmodi‐
1907                 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
1908                 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
1909                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1910                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1911
1912       kill-to-end-of-line():
1913                 In normal mode, if there is a nonnull selection, deletes  the
1914                 selection;  otherwise,  kills  the  characters  following the
1915                 insertion cursor to the next end-of-line character and stores
1916                 the characters in the cut buffer.  In add mode, if there is a
1917                 nonnull selection, the cursor is not disjoint from the selec‐
1918                 tion, and XmNpendingDelete is set to True, deletes the selec‐
1919                 tion; otherwise, kills the characters following the insertion
1920                 cursor to the next end of line character and stores the char‐
1921                 acters in the cut buffer.  This may impact the selection.
1922
1923                 The killed text is stored in CUT_BUFFER0.
1924
1925                 The kill-to-end-of-line() action produces calls to  the  XmN‐
1926                 modifyVerifyCallback  procedures with reason value XmCR_MODI‐
1927                 FYING_TEXT_VALUE, and the XmNvalueChangedCallback  procedures
1928                 with  reason  value  XmCR_VALUE_CHANGED.   In  the case where
1929                 there is a non-null selection to be deleted, this action  may
1930                 also  produce calls to the XmNmotionVerifyCallback procedures
1931                 with reason value XmCR_MOVING_INSERT_CURSOR.
1932
1933       kill-to-start-of-line():
1934                 In normal mode, if there is a nonnull selection, deletes  the
1935                 selection;  otherwise,  kills  the  characters  preceding the
1936                 insertion cursor to the next beginning-of-line character  and
1937                 stores  the  characters  in  the cut buffer.  In add mode, if
1938                 there is a nonnull selection, the cursor is not disjoint from
1939                 the  selection,  and XmNpendingDelete is set to True, deletes
1940                 the selection; otherwise, kills the characters preceding  the
1941                 insertion  cursor to the next beginning-of-line character and
1942                 stores the characters in the cut buffer.  This may impact the
1943                 selection.
1944
1945                 The killed text is stored in CUT_BUFFER0.
1946
1947                 The kill-to-start-of-line() action produces calls to the XmN‐
1948                 modifyVerifyCallback procedures with reason value  XmCR_MODI‐
1949                 FYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with
1950                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
1951                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
1952
1953       link-primary():
1954                 Places a link to the primary selection just before the inser‐
1955                 tion cursor.  This action  calls  the  XmNdestinationCallback
1956                 procedures  for  the  PRIMARY selection and the XmLINK opera‐
1957                 tion.  The Text widget itself performs no transfers; the XmN‐
1958                 destinationCallback  procedures are responsible for inserting
1959                 the link to the primary selection and for taking any  related
1960                 actions.
1961
1962       link-to():
1963                 If a secondary selection exists, this action places a link to
1964                 the secondary selection at the insertion position of the des‐
1965                 tination component.  This action calls the destination's XmN‐
1966                 destinationCallback procedures for  the  SECONDARY  selection
1967                 and the XmLINK operation.
1968
1969                 If  no  secondary selection exists, this action places a link
1970                 to the primary  selection  at  the  pointer  position.   This
1971                 action  calls  the  XmNdestinationCallback procedures for the
1972                 PRIMARY selection and the XmLINK operation.
1973
1974                 The Text widget itself performs no transfers; the XmNdestina‐
1975                 tionCallback  procedures  are  responsible  for inserting the
1976                 link to the primary or secondary selection and for taking any
1977                 related actions.
1978
1979       move-destination():
1980                 Moves  the  insertion  cursor to the pointer position without
1981                 changing any existing current selection.  If there is a  cur‐
1982                 rent  selection,  sets  the widget as the destination widget.
1983                 This also moves the widget focus to match the insertion  cur‐
1984                 sor.
1985
1986                 The  move-destination()  action  produces calls to the XmNmo‐
1987                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
1988                 ING_INSERT_CURSOR.
1989
1990       move-to():
1991                 If  a  secondary selection exists, this action moves the sec‐
1992                 ondary selection to the insertion position of the destination
1993                 component.   If the secondary selection is in the destination
1994                 widget, and the secondary selection and the primary selection
1995                 overlap, the result is undefined.  This action calls the des‐
1996                 tination's XmNdestinationCallback  procedures  for  the  SEC‐
1997                 ONDARY selection and the XmMOVE operation.  The destination's
1998                 XmNdestinationCallback procedures or the  destination  compo‐
1999                 nent  itself invokes the selection owner's XmNconvertCallback
2000                 procedures, possibly multiple times, for the SECONDARY selec‐
2001                 tion.   If the transfer is successful, this action then calls
2002                 the selection owner's XmNconvertCallback procedures  for  the
2003                 SECONDARY selection and the DELETE target.
2004
2005                 If  no secondary selection exists, this action moves the pri‐
2006                 mary selection to the pointer position.   This  action  calls
2007                 the  XmNdestinationCallback procedures for the PRIMARY selec‐
2008                 tion and  the  XmMOVE  operation.   It  calls  the  selection
2009                 owner's   XmNconvertCallback  procedures,  possibly  multiple
2010                 times, for the PRIMARY selection.  If the  transfer  is  suc‐
2011                 cessful, this action then calls the selection owner's XmNcon‐
2012                 vertCallback procedures for the  PRIMARY  selection  and  the
2013                 DELETE target.
2014
2015                 The  move-to()  action produces calls to the XmNmodifyVerify‐
2016                 Callback   procedures   with   reason   value    XmCR_MODIFY‐
2017                 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
2018                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
2019                 back  procedures with reason value XmCR_MOVING_INSERT_CURSOR.
2020                 If there is no secondary selection, the move-to() action  may
2021                 produce  calls to the XmNgainPrimaryCallback procedures.  See
2022                 callback description for more information.
2023
2024       newline():
2025                 If XmNpendingDelete is True and the cursor  is  not  disjoint
2026                 from  the  current  selection,  deletes the entire selection.
2027                 Inserts a newline before the insertion cursor.
2028
2029                 The newline() action produces calls to  the  XmNmodifyVerify‐
2030                 Callback    procedures   with   reason   value   XmCR_MODIFY‐
2031                 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
2032                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
2033                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
2034
2035       newline-and-backup():
2036                 If XmNpendingDelete is True and the cursor  is  not  disjoint
2037                 from  the  current  selection,  deletes the entire selection.
2038                 Inserts a newline just before the insertion cursor and  repo‐
2039                 sitions  the  insertion  cursor to the end of the line before
2040                 the newline.
2041
2042                 The newline-and-backup() action produces calls to the XmNmod‐
2043                 ifyVerifyCallback  procedures  with reason value XmCR_MODIFY‐
2044                 ING_TEXT_VALUE, and  the  XmNvalueChangedCallback  procedures
2045                 with reason value XmCR_VALUE_CHANGED.
2046
2047       newline-and-indent():
2048                 If  XmNpendingDelete  is  True and the cursor is not disjoint
2049                 from the current selection,  deletes  the  entire  selection.
2050                 Inserts  a  newline  and  then  the same number of whitespace
2051                 characters as at the beginning of the previous line.
2052
2053                 The newline-and-indent() action produces calls to the XmNmod‐
2054                 ifyVerifyCallback  procedures  with reason value XmCR_MODIFY‐
2055                 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
2056                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
2057                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
2058
2059       next-line():
2060                 Moves the insertion cursor to the next line.
2061
2062                 The next-line() action produces calls to the XmNmotionVerify‐
2063                 Callback procedures with reason value XmCR_MOVING_INSERT_CUR‐
2064                 SOR.
2065
2066       next-page(extend):
2067                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2068                 with  no  argument,  moves  the  insertion cursor forward one
2069                 page.
2070
2071                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2072                 with  an argument of extend, it moves the insertion cursor as
2073                 in the case of no argument and extends the current selection.
2074
2075                 The next-page() action produces calls to the XmNmotionVerify‐
2076                 Callback procedures with reason value XmCR_MOVING_INSERT_CUR‐
2077                 SOR.  If called with the  extend  argument,  the  next-page()
2078                 action may produce calls to the XmNgainPrimaryCallback proce‐
2079                 dures.  See callback description for more information.
2080
2081                 In vertical writing, scrolls the viewing window down one page
2082                 of text.
2083
2084       next-tab-group():
2085                 Traverses to the next tab group.
2086
2087                 The  next-tab-group() action produces no callbacks, unless it
2088                 results in the widget losing focus, in which case,  the  XmN‐
2089                 losingFocusCallback  procedures  are called with reason value
2090                 XmCR_LOSING_FOCUS.
2091
2092       page-left(extend):
2093                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2094                 with no argument, moves the insertion cursor back one page.
2095
2096                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2097                 with an argument of extend, it moves the insertion cursor  as
2098                 in the case of no argument and extends the current selection.
2099
2100                 The page-left() action produces calls to the XmNmotionVerify‐
2101                 Callback procedures with reason value XmCR_MOVING_INSERT_CUR‐
2102                 SOR.   If  called  with  the extend argument, the page-left()
2103                 action may produce calls to the XmNgainPrimaryCallback proce‐
2104                 dures.  See callback description for more information.
2105
2106       page-right(extend):
2107                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2108                 with no argument, moves  the  insertion  cursor  forward  one
2109                 page.
2110
2111                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2112                 with an argument of extend, it moves the insertion cursor  as
2113                 in the case of no argument and extends the current selection.
2114
2115                 The  page-right() action produces calls to the XmNmotionVeri‐
2116                 fyCallback   procedures   with   reason    value    XmCR_MOV‐
2117                 ING_INSERT_CURSOR.   If  called with the extend argument, the
2118                 page-right() action may produce calls  to  the  XmNgainPrima‐
2119                 ryCallback  procedures.   See  callback  description for more
2120                 information.
2121
2122       paste-clipboard():
2123                 Pastes the contents of the  clipboard  before  the  insertion
2124                 cursor.   This action calls the XmNdestinationCallback proce‐
2125                 dures for the CLIPBOARD selection and the XmCOPY operation.
2126
2127                 The paste-clipboard() action produces calls to  the  XmNmodi‐
2128                 fyVerifyCallback  procedures  with  reason value XmCR_MODIFY‐
2129                 ING_TEXT_VALUE, the XmNvalueChangedCallback  procedures  with
2130                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
2131                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
2132
2133       prev-tab-group():
2134                 Traverses to the previous tab group.
2135
2136                 The prev-tab-group() action produces no callbacks, unless  it
2137                 results  in  the widget losing focus, in which case, the XmN‐
2138                 losingFocusCallback procedures are called with  reason  value
2139                 XmCR_LOSING_FOCUS.
2140
2141       previous-line():
2142                 Moves the insertion cursor to the previous line.
2143
2144                 The  previous-line()  action produces calls to the XmNmotion‐
2145                 VerifyCallback  procedures  with   reason   value   XmCR_MOV‐
2146                 ING_INSERT_CURSOR.
2147
2148       previous-page(extend):
2149                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2150                 with no argument, moves the insertion cursor back one page.
2151
2152                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2153                 with  an argument of extend, it moves the insertion cursor as
2154                 in the case of no argument and extends the current selection.
2155
2156                 The previous-page() action produces calls to  the  XmNmotion‐
2157                 VerifyCallback   procedures   with   reason  value  XmCR_MOV‐
2158                 ING_INSERT_CURSOR.  If called with the extend  argument,  the
2159                 previous-page() action may produce calls to the XmNgainPrima‐
2160                 ryCallback procedures.  See  callback  description  for  more
2161                 information.
2162
2163                 In  vertical  writing, if called without an argument, scrolls
2164                 the viewing window up one page of text.
2165
2166       process-bdrag()
2167                 If the pointer is within the selection, this action starts  a
2168                 drag  operation for the selection.  This action sets the XmN‐
2169                 convertProc of the DragContext to a function that  calls  the
2170                 XmNconvertCallback  procedures,  possibly multiple times, for
2171                 the _MOTIF_DROP selection.
2172
2173                 If no selection exists or the pointer is outside  the  selec‐
2174                 tion,  this action prepares to start a secondary selection at
2175                 the pointer position.
2176
2177              Note:
2178
2179                        Note that when dragging a  secondary  selection  to  a
2180                        different  widget, focus will shift momentarily to the
2181                        second widget, and then back to the  original  widget.
2182                        This  will  generate  callbacks to the XmNlosingFocus‐
2183                        Callback procedures as focus is lost (by each  widget)
2184                        as  well  as  callbacks to the XmNfocusCallback proce‐
2185                        dures as focus is regained.
2186
2187       process-cancel():
2188                 Cancels the current  extend-adjust(),  secondary-adjust()  or
2189                 process-bdrag()  operation  and leaves the selection state as
2190                 it was before the operation; otherwise, and if the parent  is
2191                 a manager, passes the event to the parent.
2192
2193       process-down(extend):
2194                 If  XmNeditMode  is XmSINGLE_LINE_EDIT, and XmNnavigationType
2195                 is XmNONE, traverses to the widget below the current  one  in
2196                 the tab group.
2197
2198                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2199                 with an argument of extend, moves the insertion cursor as  in
2200                 the case of no argument and extends the current selection.
2201
2202                 In this case, the action will produce the XmNlosingFocusCall‐
2203                 back callbacks with reason value XmCR_LOSING_FOCUS.
2204
2205                 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
2206                 sor down one line.
2207
2208                 The process-down() action produces calls to the XmNmotionVer‐
2209                 ifyCallback   procedures   with   reason   value    XmCR_MOV‐
2210                 ING_INSERT_CURSOR.
2211
2212                 In vertical writing, moves the insertion cursor one character
2213                 down.
2214
2215       process-home():
2216                 Moves the insertion cursor to the beginning of the line.
2217
2218                 The process-home() action produces calls to the XmNmotionVer‐
2219                 ifyCallback    procedures   with   reason   value   XmCR_MOV‐
2220                 ING_INSERT_CURSOR.
2221
2222       process-return():
2223                 If XmNeditMode is XmSINGLE_LINE_EDIT, calls the callbacks for
2224                 XmNactivateCallback,  and  if the parent is a manager, passes
2225                 the   event   to   the    parent.     If    XmNeditMode    is
2226                 XmMULTI_LINE_EDIT, inserts a newline.
2227
2228                 The  process-return() action during single-line edit produces
2229                 calls to the XmNactivateCallback procedures with reason value
2230                 XmCR_ACTIVATE.   During   multi-line  editing,  the  process-
2231                 return() action produces calls to the XmNmodifyVerifyCallback
2232                 procedures  with  reason value XmCR_MODIFYING_TEXT_VALUE, the
2233                 XmNvalueChangedCallback   procedures   with   reason    value
2234                 XmCR_VALUE_CHANGED,  and  the  XmNmotionVerifyCallback proce‐
2235                 dures with reason value XmCR_MOVING_INSERT_CURSOR.
2236
2237       process-shift-down():
2238                 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
2239                 sor  down  one  line  and  selects.  If XmNeditMode is XmSIN‐
2240                 GLE_LINE_EDIT, this action behaves like process-up() in  XmS‐
2241                 INGLE_LINE_EDIT.  Refer to the process-up() action.
2242
2243                 The  process-shift-down() action produces calls to the XmNmo‐
2244                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
2245                 ING_INSERT_CURSOR.
2246
2247                 In  vertical  writing,  if called with the argument up, moves
2248                 the insertion cursor one character up and extends the current
2249                 selection. If called with the argument down, moves the inser‐
2250                 tion cursor one character down and extends the current selec‐
2251                 tion.
2252
2253       process-shift-up():
2254                 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
2255                 sor up  one  line  and  selects.  If  XmNeditMode  is  XmSIN‐
2256                 GLE_LINE_EDIT,  this action behaves like process-up() in XmS‐
2257                 INGLE_LINE_EDIT.  Refer to the process-up() action.
2258
2259                 The process-shift-up() action produces calls  to  the  XmNmo‐
2260                 tionVerifyCallback  procedures  with  reason  value XmCR_MOV‐
2261                 ING_INSERT_CURSOR.
2262
2263                 In vertical writing, if called with the  argument  up,  moves
2264                 the insertion cursor one character up and extends the current
2265                 selection. If called with the argument down, moves the inser‐
2266                 tion cursor one character down and extends the current selec‐
2267                 tion.
2268
2269       process-tab(Prev|Next):
2270                 If XmNeditMode is XmSINGLE_LINE_EDIT, traverses to  the  next
2271                 tab group if the direction argument is Next, or to the previ‐
2272                 ous tab group if the direction is  Prev.  If  XmNeditMode  is
2273                 XmMULTI_LINE_EDIT,  and  the  direction  is  Next, the action
2274                 inserts  a  tab.  The  Prev  direction  has  no  effect  with
2275                 XmMULTI_LINE_EDIT.  In the Text widget, there is a preset tab
2276                 stop at every eighth columns.
2277
2278                 The process-tab() action under  multi-line  editing  produces
2279                 calls  to  the XmNmotionVerifyCallback procedures with reason
2280                 value XmCR_MOVING_INSERT_CURSOR. Under  single-line  editing,
2281                 the  action  produces  no callbacks, unless it results in the
2282                 widget losing focus, in which case,  the  XmNlosingFocusCall‐
2283                 back  procedures  are  called  with  reason  value  XmCR_LOS‐
2284                 ING_FOCUS.
2285
2286       process-up(extend):
2287                 If XmNeditMode is XmSINGLE_LINE_EDIT and XmNnavigationType is
2288                 XmNONE,  traverses to the widget above the current one in the
2289                 tab group.
2290
2291                 If XmNeditMode is XmMULTI_LINE_EDIT, moves the insertion cur‐
2292                 sor up one line.
2293
2294                 If XmNeditMode is XmMULTI_LINE_EDIT and this action is called
2295                 with an argument of extend, moves the insertion cursor as  in
2296                 the case of no argument and extends the current selection.
2297
2298                 The  process-up()  action  under  multi-line editing produces
2299                 calls to the XmNmotionVerifyCallback procedures  with  reason
2300                 value  XmCR_MOVING_INSERT_CURSOR.  Under single-line editing,
2301                 the action produces no callbacks unless  it  results  in  the
2302                 widget  losing  focus, in which case, the XmNlosingFocusCall‐
2303                 back  procedures  are  called  with  reason  value  XmCR_LOS‐
2304                 ING_FOCUS.
2305
2306                 In vertical writing, moves the insertion cursor one character
2307                 up.
2308
2309       redraw-display():
2310                 Redraws the contents of the text window.
2311
2312                 The redraw-display() action produces no callbacks.
2313
2314       scroll-cursor-vertically(percentage):
2315                 Scrolls the line containing the insertion  cursor  vertically
2316                 to an intermediate position in the visible window based on an
2317                 input percentage. A value of 0 indicates the top of the  win‐
2318                 dow; a value of 100, the bottom of the window. If this action
2319                 is called with no argument, the line containing the insertion
2320                 cursor is scrolled vertically to a new position designated by
2321                 the y position of the event passed to the routine.
2322
2323                 The scroll-cursor-vertically action produces no callbacks.
2324
2325       scroll-one-line-down():
2326                 Scrolls the text area down one line.
2327
2328                 The scroll-one-line-down() action produces no callbacks.
2329
2330       scroll-one-line-up():
2331                 Scrolls the text area up one line.
2332
2333                 The scroll-one-line-up() action produces no callbacks.
2334
2335       secondary-adjust():
2336                 Extends the secondary selection to the pointer position.
2337
2338                 The secondary-adjust() action produces no callbacks.
2339
2340       secondary-notify():
2341                 Copies the secondary selection to the insertion cursor of the
2342                 destination widget.
2343
2344                 The  secondary-notify() action produces calls to the XmNmodi‐
2345                 fyVerifyCallback procedures with  reason  value  XmCR_MODIFY‐
2346                 ING_TEXT_VALUE,  and  the  XmNvalueChangedCallback procedures
2347                 with reason value XmCR_VALUE_CHANGED.
2348
2349       secondary-start():
2350                 Marks the beginning of a secondary selection.
2351
2352                 The secondary-start() action produces no callbacks.
2353
2354       select-adjust():
2355                 Moves the current selection.  The  amount  of  text  selected
2356                 depends  on  the  number of mouse clicks, as specified by the
2357                 XmNselectionArray resource.
2358
2359                 The select-adjust() action may produce no callbacks, however,
2360                 it  may  produce  calls  to the XmNgainPrimaryCallback proce‐
2361                 dures.  See callback description for more information.
2362
2363       select-all():
2364                 Selects all text.
2365
2366                 The select-all() action may produce calls to the  XmNgainPri‐
2367                 maryCallback procedures.
2368
2369       select-end():
2370                 Moves  the  current  selection.   The amount of text selected
2371                 depends on the number of mouse clicks, as  specified  by  the
2372                 XmNselectionArray resource.
2373
2374                 The select-end() action produces no callbacks.
2375
2376       select-start():
2377                 Marks the beginning of a new selection region.
2378
2379                 The  select-start()  action may produce calls to the XmNgain‐
2380                 PrimaryCallback procedures.
2381
2382       self-insert():
2383                 If XmNpendingDelete is True and the cursor  is  not  disjoint
2384                 from  the  current  selection,  deletes the entire selection.
2385                 Inserts the character associated with the key pressed at  the
2386                 insertion cursor.
2387
2388                 The self-insert() action produces calls to the XmNmodifyVeri‐
2389                 fyCallback  procedures   with   reason   value   XmCR_MODIFY‐
2390                 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
2391                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
2392                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
2393
2394       set-anchor():
2395                 Resets  the anchor point for extended selections.  Resets the
2396                 destination of secondary selection actions.
2397
2398                 The set-anchor() action produces no callbacks.
2399
2400       set-insertion-point():
2401                 Sets the insertion position to  the  position  of  the  mouse
2402                 pointer.
2403
2404                 The set-insertion-point() action produces calls to the XmNmo‐
2405                 tionVerifyCallback procedures  with  reason  value  XmCR_MOV‐
2406                 ING_INSERT_CURSOR.  Note that if the mouse pointer is already
2407                 over the position of the insertion cursor,  the  cursor  will
2408                 not be moved, and no callbacks will be produced.
2409
2410       set-selection-hint():
2411                 Sets the text source and location of the current selection.
2412
2413                 The set-selection-hint() action produces no callbacks.
2414
2415       toggle-add-mode():
2416                 Toggles the state of Add Mode.
2417
2418                 The toggle-add-mode() action produces no callbacks.
2419
2420       toggle-overstrike():
2421                 Toggles  the  state  of  the text insertion mode. By default,
2422                 characters typed into the Text widget  are  inserted  at  the
2423                 position of the insertion cursor. In overstrike mode, charac‐
2424                 ters entered into the Text widget replace the characters that
2425                 directly  follow  the  insertion cursor.  In overstrike mode,
2426                 when the end of a line is reached, characters are appended to
2427                 the end of the line.
2428
2429                 The  following traversal actions generate no callbacks unless
2430                 they result in the loss of focus by the widget  in  question,
2431                 as  when XmNnavigationType is XmNONE. In this case, they pro‐
2432                 duce calls to  the  XmNlosingFocusCallback  procedures,  with
2433                 reason value XmCR_FOCUS_MOVED.
2434
2435       traverse-home():
2436                 Traverses to the first widget in the tab group.
2437
2438       traverse-next():
2439                 Traverses to the next widget in the tab group.
2440
2441       traverse-prev():
2442                 Traverses to the previous widget in the tab group.
2443
2444       unkill(): Restores  last  killed  text to the position of the insertion
2445                 cursor (or whatever is currently in  the  CUT_BUFFER0).   The
2446                 inserted text appears before the insertion cursor.
2447
2448                 The  unkill()  action  produces calls to the XmNmodifyVerify‐
2449                 Callback   procedures   with   reason   value    XmCR_MODIFY‐
2450                 ING_TEXT_VALUE,  the  XmNvalueChangedCallback procedures with
2451                 reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCall‐
2452                 back procedures with reason value XmCR_MOVING_INSERT_CURSOR.
2453
2454   Additional Behavior
2455       This widget has the following additional behavior:
2456
2457       <FocusIn>:
2458                 Draws  the  insertion cursor as solid and starts blinking the
2459                 cursor.
2460
2461       <FocusOut>:
2462                 Displays the insertion cursor as a stippled I-beam unless  it
2463                 is the destination widget and stops the cursor from blinking.
2464
2465   Virtual Bindings
2466       The  bindings  for  virtual  keys are vendor specific.  For information
2467       about bindings for virtual buttons and keys, see VirtualBindings(3).
2468
2470       Core(3),   XmCreateScrolledText(3),   XmCreateText(3),   XmFontList(3),
2471       XmFontListAppendEntry(3),    XmPrimitive(3),   XmTextClearSelection(3),
2472       XmTextCopy(3),  XmTextCopyLink(3),   XmTextCut(3),   XmTextEnableRedis‐
2473       play(3),    XmTextDisableRedisplay(3),    XmTextField(3),   XmTextFind‐
2474       String(3), XmTextFindStringWcs(3),  XmTextGetBaseline(3),  XmTextGetEd‐
2475       itable(3),   XmTextGetInsertionPosition(3),   XmTextGetLastPosition(3),
2476       XmTextGetMaxLength(3), XmTextGetSelection(3), XmTextGetSelectionWcs(3),
2477       XmTextGetSelectionPosition(3),  XmTextGetSource(3), XmTextGetString(3),
2478       XmTextGetStringWcs(3), XmTextGetSubstring(3), XmTextGetSubstringWcs(3),
2479       XmTextGetTopCharacter(3),      XmTextInsert(3),     XmTextInsertWcs(3),
2480       XmTextPaste(3),   XmTextPasteLink(3),   XmTextPosToXY(3),   XmTextPosi‐
2481       tion(3),    XmTextRemove(3),   XmTextReplace(3),   XmTextReplaceWcs(3),
2482       XmTextScroll(3),       XmTextSetAddMode(3),       XmTextSetEditable(3),
2483       XmTextSetHighlight(3),     XmTextSetInsertionPosition(3),    XmTextSet‐
2484       MaxLength(3),  XmTextSetSelection(3),  XmTextSetSource(3),   XmTextSet‐
2485       String(3), XmTextSetStringWcs(3), XmTextSetTopCharacter(3), XmTextShow‐
2486       Position(3), XmTextXYToPos(3),  XmVaCreateText(3),  and  XmVaCreateMan‐
2487       agedText(3).
2488
2489
2490
2491                                                          XmText(library call)
Impressum