XMTEXT(3)

📦

version 2.3.8 · 3 versions

2.3.8 · arch rolling, centos-stream 9, epel 10, fedora 43, fedora 44, nixos 26.05, nixpkgs unstable, opensuse-leap 16.0 (latest)
2.5.2 · alpine 3.24
2.3.8 · debian bookworm, debian trixie, ubuntu jammy, ubuntu noble, ubuntu questing, ubuntu resolute, ubuntu stonking

, in arch rolling, centos-stream 9, epel 10, fedora 43, fedora 44, nixos 26.05, nixpkgs unstable, opensuse-leap 16.0

✨ NAME ✨

Okay bestie, this is XmText — literally The Text widget class. It's a library call, so it's giving Unix manual energy. 💅

✨ SYNOPSIS ✨

#include <Xm/Text.h>

✨ DESCRIPTION ✨

So Text is your go-to for a single-line AND multiline text editor, and you can customize both user and programmatic interfaces with it. It's perfect for single-line string entry, forms entry with verification procedures, and full-window editing. Basically it gives your app a consistent editing system for textual data, and the screen's textual data adjusts to whatever the application writer needs. Slay. ✨

Text has separate callback lists to verify movement of the insert cursor, modification of the text, and changes in input focus. Each callback hands the verification function the widget instance, the event that caused the callback, and a data structure specific to the verification type. From that info, the function can verify if the application thinks this is a legit state change and can signal the widget whether to continue with the action. It's giving gatekeeping but in a good way. 💅

The user interface tailors a new set of translations. The default translations give you key bindings for insert cursor movement, deletion, insertion, and selection of text. So you can keyboard warrior your way through editing. 🔥

Text lets the user select regions of text. Selection follows the model from the Inter-Client Communication Conventions Manual (ICCCM). Text supports primary and secondary selection. It's iconic, no cap. 💖

In some Asian languages, texts are drawn vertically. Also, some characters are displayed with 90-degree clockwise rotation, and other characters are mapped to vertical glyphs that differ from the normal horizaontal glyphs. Info about which characters need rotation or mapping to vertical glyphs lives in the X Locale Database (NLS databases) and is handled by the X library, depending on XNOrientation XOC values. The XmText widget should also handle vertically aligned lines for editing, entering, or selecting texts. Periodt. 💅

The vertical writing feature of the XmText widget turns on when you set the XmTOP_TO_BOTTOM value for the XmNlayoutDirection resource of the XmText widget. When that happens, the horizontal scroll bar shows up on the bottom of the XmText widget and the vertical scroll bar shows up on the left side. It's a whole vibe. 🦋

✨ Mouse Selection ✨

The Text widget lets you edit, insert, and select text. The user can cut, copy, and paste text using the clipboard, primary transfer, or secondary transfer. Text also has a Drag and Drop facility so you can copy or move data within Text or to a different widget. When keyboard focus policy is set to EXPLICIT, the widget that receives focus is the destination widget. In POINTER mode, any keyboard or mouse operation (except secondary selection) in an editable widget makes that widget the destination. It's giving multitasking queen. 👑

If a destination widget becomes insensitive or uneditable, it forfeits its destination status. In EXPLICIT mode, when a widget becomes insensitive, the focus moves to another widget. If that widget is editable, it becomes the destination widget; otherwise, there's no destination widget. The text of any insensitive Text widget is stippled, which shows its state to the user. No cap. 💀

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

Text uses the XmQTnavigator, XmQTspecifyRenderTable, and XmQTscrollFrame traits, and holds the XmQTaccessTextual and XmQTtransfer traits. The widget checks its parent for the XmQTscrollFrame trait. If this trait doesn't exist, then the widget has no scrolling. If the trait does exist, and the ScrollFrame widget hasn't been initialized, the widget creates two navigators and sets up the scrollbars. It's lowkey doing the most. 💅

If an application or widget calls the setValue trait method of XmQTaccessTextual, then XmText will call XmTextSetString to set the string value. Periodt. 🎀

✨ Classes ✨

Text inherits behavior, resources, and traits from Core and XmPrimitive.

The class pointer is xmTextWidgetClass.

The class name is XmText.

It's giving family tree realness. 🌈

✨ Data Transfer Behavior ✨

Text supports transfer of the primary, secondary, and clipboard selections and dragging of selected text from the widget. Text can also be the destination for the primary, secondary, and clipboard selections, and it supports dropping of data being dragged onto the widget. It's giving data exchange realness. 💅

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

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

locale — If the locale target matches the widget's locale, the widget transfers the selected text in the encoding of the locale.
COMPOUND_TEXT — The widget transfers the selected text as type COMPOUND_TEXT.
STRING — The widget transfers the selected text as type STRING.
TEXT — If the selected text is fully convertible to the encoding of the locale, the widget transfers the selected text in the encoding of the locale. Otherwise, the widget transfers the selected text as type COMPOUND_TEXT.
UTF8_STRING — The widget transfers the selected text as type UTF8_STRING.
DELETE — The widget deletes the selected text.
_MOTIF_CLIPBOARD_TARGETS — The widget transfers, as type ATOM, a list of the targets to which the widget can convert data to be placed on the clipboard immediately. If the selected text is fully convertible to STRING, these include STRING; otherwise, they include COMPOUND_TEXT.
_MOTIF_DEFERRED_CLIPBOARD_TARGETS — The widget transfers, as type ATOM, a list of the targets it supports for delayed transfer for the CLIPBOARD selection. This widget currently supplies no targets for _MOTIF_DEFERRED_CLIPBOARD_TARGETS.
_MOTIF_EXPORT_TARGETS — The widget transfers, as type ATOM, a list of the targets to be used as the value of the DragContext's XmNexportTargets in a drag-and-drop transfer. These include COMPOUND_TEXT, UTF8_STRING, the encoding of the locale, STRING, TEXT, BACKGROUND, and FOREGROUND.
_MOTIF_LOSE_SELECTION — The widget takes the following actions:
- When losing the PRIMARY selection, it unhighlights the selected text and calls the XmNlosePrimaryCallback procedures.
- When losing the SECONDARY selection, it removes the secondary selection highlight.
- When losing the _MOTIF_DESTINATION selection, if the widget does not have focus, it changes the cursor to indicate that the widget is no longer the destination.

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

BACKGROUND — The widget transfers XmNbackground as type PIXEL.
CLASS — The widget finds the first shell in the widget hierarchy that has a WM_CLASS property and transfers the contents as text in the current locale.
CLIENT_WINDOW — The widget finds the first shell in the widget hierarchy and transfers its window as type WINDOW.
COLORMAP — The widget transfers XmNcolormap as type COLORMAP.
FOREGROUND — The widget transfers XmNforeground as type PIXEL.
NAME — The widget finds the first shell in the widget hierarchy that has a WM_NAME property and transfers the contents as text in the current locale.
TARGETS — The widget transfers, as type ATOM, a list of the targets it supports. These include the standard targets in this list. These also include COMPOUND_TEXT, UTF8_STRING, the encoding of the locale, STRING, and TEXT.
TIMESTAMP — The widget transfers the timestamp used to acquire the selection as type INTEGER.
_MOTIF_RENDER_TABLE — The widget transfers XmNrenderTable if it exists, or else the default text render table, as type STRING.
_MOTIF_ENCODING_REGISTRY — The widget transfers its encoding registry as type STRING. The value is a list of NULL separated items in the form of tag encoding pairs. This target symbolizes the transfer target for the Motif Segment Encoding Registry. Widgets and applications can use this Registry to register text encoding formats for specified render table tags. Applications access this Registry by calling XmRegisterSegmentEncoding and XmMapSegmentEncoding.

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

The encoding of the locale
TEXT
UTF8_STRING
COMPOUND_TEXT
STRING

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

UTF8_STRING
COMPOUND_TEXT
STRING

✨ New Resources ✨

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

🎀 XmText Resource Set 🎀

okay bestie, this is the whole lineup — every resource XmText has, and it's giving full menu energy 💅. Every single one of these comes at you with five things:

Name — the resource name, the thing you actually type.
Class — the class it rolls with.
Type — what kind of value it wants from you.
Default — what you get if you say absolutely nothing.
Access — how you're allowed to touch it. The codes in this table are C, CSG, and CSG1.

Here we go, one by one, no skipping, we do not leave the girlies behind ✨

XmNactivateCallback — class XmCCallback, type XtCallbackList, default NULL, access C. a callback slot, and it starts out completely empty.
XmNautoShowCursorPosition — class XmCAutoShowCursorPosition, type Boolean, default True, access CSG. yes/no situation, and the default is a big ol' yes.
XmNcursorPosition — class XmCCursorPosition, type XmTextPosition, default 0, access CSG. starts at 0, like every good index.
XmNcursorPositionVisible — class XmCCursorPositionVisible, type Boolean, default dynamic, access CSG. note that the default here is dynamic, not a plain true/false, okay? okay.
XmNdestinationCallback — class XmCCallback, type XtCallbackList, default NULL, access C. another empty callback slot at the start.
XmNeditable — class XmCEditable, type Boolean, default True, access CSG. can you edit it? default says yes 💖
XmNeditMode — class XmCEditMode, type int, default XmSINGLE_LINE_EDIT, access CSG. an int, and out of the box you're in XmSINGLE_LINE_EDIT.
XmNfocusCallback — class XmCCallback, type XtCallbackList, default NULL, access C. callback slot, starts NULL, as the girlies do.
XmNgainPrimaryCallback — class XmCCallback, type XtCallbackList, default NULL, access C. callback slot, NULL default, iconic.
XmNlosePrimaryCallback — class XmCCallback, type XtCallbackList, default NULL, access C. yes bestie, also a callback slot, also NULL.
XmNlosingFocusCallback — class XmCCallback, type XtCallbackList, default NULL, access C. and again: callback slot, NULL default 🫶
XmNmarginHeight — class XmCMarginHeight, type Dimension, default 5, access CSG. a Dimension, default 5.
XmNmarginWidth — class XmCMarginWidth, type Dimension, default 5, access CSG. also a Dimension, also 5. symmetry, we love her.
XmNmaxLength — class XmCMaxLength, type int, default largest integer, access CSG. the default is literally largest integer, so like… go off, no cap 😭
XmNmodifyVerifyCallback — class XmCCallback, type XtCallbackList, default NULL, access C. callback slot, NULL at the start.
XmNmodifyVerifyCallbackWcs — class XmCCallback, type XtCallbackList, default NULL, access C. the Wcs sibling, same deal: callback slot, NULL.
XmNmotionVerifyCallback — class XmCCallback, type XtCallbackList, default NULL, access C. callback slot, NULL, we've been here before 💀
XmtotalLines — class XmCTotalLines, type int, default dynamic, access C. heads up bestie, this one is written XmtotalLines — no N in there — and the default is dynamic. That's exactly how it appears, so don't go "fixing" it, fr fr.
XmNsource — class XmCSource, type XmTextSource, default Default source, access CSG. an XmTextSource, and it defaults to the Default source.
XmNtopCharacter — class XmCTopCharacter, type XmTextPosition, default 0, access CSG. starts at 0.
XmNvalue — class XmCValue, type String, default "", access CSG. a String, defaulting to "" — empty, blank, a clean slate ✨
XmNvalueChangedCallback — class XmCCallback, type XtCallbackList, default NULL, access C. callback slot, NULL default, you know the drill.
XmNvalueWcs — class XmCvalueWcs, type wchar_t *, default (wchar_t *)"", access CSG1. yep, the class really is XmCvalueWcs with a lowercase v, and the default is (wchar_t *)"". Also notice the access is CSG1, not plain CSG — the 1 is doing something, see the note below 👇
XmNverifyBell — class XmCVerifyBell, type Boolean, default dynamic, access CSG. a Boolean with a dynamic default.

1 This resource cannot be set in a resource file.

that little footnote is the whole reason XmNvalueWcs says CSG1 and not just CSG — so if you were about to yeet it into a resource file, don't 🙈

and there's more where that came from, so stay tuned 💖

XmNactivateCallback — the callback list that fires when the user does the thing that calls the activate() action. The struct whose address gets passed along is an XmAnyCallbackStruct, and the reason it sends is XmCR_ACTIVATE. classic activation moment ✨
XmNautoShowCursorPosition — set it to True and the visible text is guaranteed to contain the insert cursor. Cursor moves? The contents of Text may scroll to bring that insertion point into the window. but heads up bestie: setting this to False does not promise Text won't scroll. It's just not obligated to. 🙈
XmNcursorPosition — tells you where in the text the current insert cursor is supposed to sit. It's counted as the number of characters from the beginning of the text, and the first character position is 0 (zero). zero-indexed, as the universe intended 💅
XmNcursorPositionVisible — if the widget has an XmPrintShell as one of its ancestors, the default is False. Otherwise? True. that's it, that's the whole rule 🎀
XmNdestinationCallback — the callback list that fires when the widget is the destination of a transfer operation. The struct address passed to these callbacks is an XmDestinationCallbackStruct, and the reason is XmCR_OK. receiving era 🫶
XmNeditable — True means the user can edit the text string. False means the user is prohibited from editing it. locked down fr fr 🔒
- When XmNeditable is used on a widget, it sets the dropsite to XmDROP_SITE_ACTIVE.
XmNeditMode — which set of keyboard bindings Text is rolling with. The default, XmSINGLE_LINE_EDIT, gives you the key bindings for editing single-line text. XmMULTI_LINE_EDIT gives you the ones for editing multiline text. pick your fighter ⚔️
- > warning: the results of putting a Text widget inside a ScrolledWindow when the Text's XmNeditMode is XmSINGLE_LINE_EDIT are undefined. Not "weird", not "buggy" — undefined. Don't do it. 😭
XmNfocusCallback — the callback list that fires when Text accepts input focus. Struct address passed: XmAnyCallbackStruct. Reason sent: XmCR_FOCUS. she's got focus, she's got main character energy 👑
XmNgainPrimaryCallback — the callback list that fires when an event causes the Text widget to gain ownership of the primary selection. Reason sent: XmCR_GAIN_PRIMARY. won the primary, slay 🌈
XmNlosePrimaryCallback — the callback list that fires when an event causes the Text widget to lose ownership of the primary selection. Reason sent: XmCR_LOSE_PRIMARY. loss arc 😔
XmNlosingFocusCallback — the callback list that fires before Text loses input focus. Struct address passed: XmTextVerifyCallbackStruct. Reason sent: XmCR_LOSING_FOCUS. goodbye kiss before the focus dips 🦋
XmNmarginHeight — the distance between the top edge of the widget window and the text, and also between the bottom edge of the widget window and the text. top AND bottom, equal treatment ✨
XmNmarginWidth — the distance between the left edge of the widget window and the text, and between the right edge of the widget window and the text. left AND right, symmetrical queen 🎀
XmNmaxLength — the maximum length of the text string you can enter into text from the keyboard. This value has to be nonnegative. important: strings entered by using the XmNvalue resource or the XmTextSetString function ignore this resource entirely. the keyboard has rules, the API does not 💅
XmNmodifyVerifyCallback — the callback list that fires before text is deleted from or inserted into Text. Struct address passed: XmTextVerifyCallbackStruct. Reason sent: XmCR_MODIFYING_TEXT_VALUE. When multiple Text widgets share the same source, only the widget that initiates the source change generates XmNmodifyVerifyCallback. only the originator, not the whole friend group 👀
- If both XmNmodifyVerifyCallback and XmNmodifyVerifyCallbackWcs are registered callback lists, the procedure(s) in the XmNmodifyVerifyCallback list is always executed first; and the resulting data — which may have been modified — is passed to the XmNmodifyVerifyCallbackWcs callback routines. pipeline order matters, no cap 🔥
XmNmodifyVerifyCallbackWcs — the callback list that fires before text is deleted from or inserted into Text. Struct address passed: XmTextVerifyCallbackStructWcs. Reason sent: XmCR_MODIFYING_TEXT_VALUE. When multiple Text widgets share the same source, only the widget that initiates the source change generates the XmNmodifyVerifyCallbackWcs. same deal, wide-character edition 🦋
- If both XmNmodifyVerifyCallback and XmNmodifyVerifyCallbackWcs are registered callback lists, the procedure(s) in the XmNmodifyVerifyCallback list is always executed first; and the resulting data — which may have been modified — is passed to the XmNmodifyVerifyCallbackWcs callback routines.
XmNmotionVerifyCallback — the callback list that fires before the insert cursor moves to a new position. Struct address passed: XmTextVerifyCallbackStruct. Reason sent: XmCR_MOVING_INSERT_CURSOR. and btw it is entirely possible for more than one XmNmotionVerifyCallback to be generated from a single action. she multiplies 🙈
XmNsource — the source with which the widget displays text. If no source is specified, the widget creates a default string source. You can use this resource to share text sources between Text widgets. sharing is caring fr fr 🫶
XmNtopCharacter — displays the position of text at the top of the window. Position is counted as the number of characters from the beginning of the text, and the first character position is 0 (zero). zero again, iconic ⭐
- If XmNeditMode is XmMULTI_LINE_EDIT, the line of text containing the top character is displayed at the top of the widget without shifting the text left or right.
- XtGetValues for XmNtopCharacter returns the position of the first character in the line that is displayed at the top of the widget. it gives you the line's first char, not the char you asked about 👀
XmNtotalLines — the number of lines in the text widget buffer (not necessarily visible). The initial value 1 means the text buffer is empty. The number of lines reported takes into account the wordWrap policy — that is, it's not simply the number of newline characters. word wrap counted, bestie 📏
XmNvalue — the string value of the Text widget as a char* data value. Moves the cursor to position 0 unless a value of XmNcursorPosition was explicitly supplied in the argument list. If XmNvalue and XmNvalueWcs are both defined, the value of XmNvalueWcs supersedes that of XmNvalue. XtGetValues returns a copy of the value of the internal buffer, and XtSetValues copies the string values into the internal buffer. char* girlies rise 🔥
XmNvalueChangedCallback — the callback list that fires after text is deleted from or inserted into Text. Struct address passed: XmAnyCallbackStruct. Reason sent: XmCR_VALUE_CHANGED. When multiple Text widgets share the same source, only the widget that initiates the source change generates the XmNvalueChangedCallback. originator-only again, iykyk 💅
- This callback represents a change in the source in the Text, not in the Text widget.
- The XmNvalueChangedCallback should occur only in pairs with an XmNmodifyVerifyCallback — assuming the doit flag in the callback structure of the XmNmodifyVerifyCallback is not set to False. duo or it didn't happen 🎀
XmNvalueWcs — the string value of the Text widget as a wchar_t* data value. Moves the cursor to position 0 unless a value of XmNcursorPosition was explicitly supplied in the argument list. wide-char version, same cursor rules ✨
- > heads up: this resource cannot be specified in a resource file. 🙈
- If XmNvalue and XmNvalueWcs are both defined, the value of XmNvalueWcs supersedes that of XmNvalue. XtGetValues returns a copy of the value of the internal buffer encoded as a wide character string. XtSetValues copies the value of the wide character string into the internal buffer. Wcs stays winning 🏆
XmNverifyBell — whether the bell should sound when the verification returns without continuing the action. The default depends on the value of the ancestor VendorShell's XmNaudibleWarning resource. 🔔 it's giving inherited vibes

XmText Input Resource Set 👑

okay so here's the little resource roster, bestie — name, class, type, default, access. the whole squad 💜

XmNpendingDelete — class XmCPendingDelete, type Boolean, default True, access CSG
XmNselectionArray — class XmCSelectionArray, type XtPointer, default default array, access CSG
XmNselectionArrayCount — class XmCSelectionArrayCount, type int, default 4, access CSG
XmNselectThreshold — class XmCSelectThreshold, type int, default 5, access CSG
XmNpendingDelete — pending delete mode is on when this Boolean value is True. And what even is pending deletion? glad you asked — it's defined as deletion of the selected text when an insertion is made. select, type, gone. periodt 💅
XmNselectionArray — bestie, this one decides what happens when you click the mouse a bunch of times in a row. 🖱️ The value is an array of XmTextScanType elements, and XmTextScanType is an enumeration that lists out the possible actions. Every mouse click you do within a certain window of time after the previous click bumps the index into this array up by one and runs the action defined for that index. (That "multiclick" time? It's set by your operating environment, so it varies from system to system. Generally it's some fraction of a second, iykyk.) The possible actions, in the order they show up in the default array, are:
1. XmSELECT_POSITION, which resets the insert cursor position. ✨
2. XmSELECT_WORD, which selects a word. 🎀
3. XmSELECT_LINE, which selects a line of text. This action sees a line as delimited by hard newline characters. In other words, if word wrap is on (XmNwordWrap is True), it will ignore the newlines that the widget inserted automatically. This one is the default. 👑
4. XmSELECT_OUT_LINE, which selects a line of text. This action sees a line as delimited by hard or soft newline characters. In other words, if word wrap is on (XmNwordWrap is True), the newlines the widget inserted automatically will be treated as delimiting lines. 💅
5. XmSELECT_ALL, which selects all of the text. literally all of it, slay. 🔥
XmNselectionArrayCount — tells you how many elements live in the XmNselectionArray resource. The value must not be negative. 🙅
XmNselectThreshold — the number of pixels of motion required before it selects the next character when you're selecting in click-drag mode. The value must not be negative. This resource also decides whether a drag should start at all, plus how many pixels it takes to start a drag when Btn2Down and Btn1Down are integrated. 🦋

✨ XmText Output Resource Set ✨

okay so here's the full roster of output resources, bestie. each one gets its Name, Class, Type, Default, and Access level, no skips:

XmNblinkRate — Class: XmCBlinkRate, Type: int, Default: 500, Access: CSG
XmNcolumns — Class: XmCColumns, Type: short, Default: dynamic, Access: CSG
XmNcursorPositionVisible — Class: XmCCursorPositionVisible, Type: Boolean, Default: True, Access: CSG
XmNfontList — Class: XmCFontList, Type: XmFontList, Default: dynamic, Access: CSG
XmNrenderTable — Class: XmCRenderTable, Type: XmRenderTable, Default: dynamic, Access: CSG
XmNresizeHeight — Class: XmCResizeHeight, Type: Boolean, Default: False, Access: CSG
XmNresizeWidth — Class: XmCResizeWidth, Type: Boolean, Default: False, Access: CSG
XmNrows — Class: XmCRows, Type: short, Default: dynamic, Access: CSG
XmNwordWrap — Class: XmCWordWrap, Type: Boolean, Default: False, Access: CSG

XmNblinkRate — sets the blink rate of the text cursor, in milliseconds. 🫶 The time in the blink rate relates to both how long the cursor is visible and how long it's invisible — meaning the time it takes to blink the insertion cursor on and off is twice the blink rate. The cursor does not blink when the blink rate is set to 0 (zero). The value must not be negative. 💀
XmNcolumns — sets the initial width of the text window as an integer number of characters. 📐 The width equals the number of characters you specify times the width derived from the font you specified. If the em-space value is available, that's what gets used. If it's not, the width of the numeral "0" is used. And if that's not available either, the maximum width is used. With proportionate fonts, the actual number of characters that fit on any given line may be greater than the value you specified. The value must be greater than 0 (zero). The default value depends on the value of the XmNwidth resource — and if no width is specified, the default is 20. ✨

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

XmNcursorPositionVisible — when the Boolean value is True, it means the insert cursor position is marked by a text cursor. 🎀
XmNfontList — sets the font list used for Text. okay bestie, important: the font list is an obsolete structure and it's kept around only for compatibility with earlier releases of Motif. Use the render table (XmNrenderTable) instead of font lists wherever you possibly can. 🙈 If you specify both, the render table takes precedence. If this value is NULL at initialization, the widget's parent hierarchy gets searched for an ancestor holding the XmQTspecifyRenderTable trait. If such an ancestor is found, the font list is initialized to the XmTEXT_RENDER_TABLE value of the ancestor widget. If no such ancestor is found, the default is implementation dependent.

Text searches the font list for the first occurrence of a font set that has XmFONTLIST_DEFAULT_TAG. If a default element isn't found, the first font set in the font list gets used. And if the list contains no font sets at all, the first font in the font list gets used. Peep XmFontList(3) for more info on a font list structure. 🌸

XmNrenderTable — sets the render table used for deriving a font set or font for rendering text. If you specify both a render table and a font list, the render table takes precedence. 👑 If the value of XmNrenderTable is NULL at initialization, the widget's parent hierarchy gets searched for an ancestor holding the XmQTspecifyRenderTable trait. If such an ancestor is found, the font list is initialized to the XmTEXT_RENDER_TABLE value of the ancestor widget. If no such ancestor is found, the default is implementation dependent.

Text searches the render table for the first occurrence of a rendition that has the tag _MOTIF_DEFAULT_LOCALE. If a default element isn't found, the first rendition in the table gets used. Peep XmRenderTable(3) for more info on the render table structure. 💜

XmNresizeHeight — when the Boolean value is True, it means Text will attempt to resize its height to accommodate all the text contained in the widget. 🔥 And heads up: if the Boolean value is set to True, the text is always displayed, starting from the first position in the source, even if it's instructed otherwise. This attribute is ignored when the application uses a Text widget whose parent is a ScrolledWindow, and when XmNscrollVertical is True.

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

XmNresizeWidth — when the Boolean value is True, it means Text attempts to resize its width to accommodate all the text contained in the widget. This attribute is ignored if XmNwordWrap is True. 🦋

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

XmNrows — sets the initial height of the text window, measured in character heights. 📏 This attribute is ignored if the text widget resource XmNeditMode is XmSINGLE_LINE_EDIT. The value must be greater than 0 (zero). The default value depends on the value of the XmNheight resource — and if no height is specified, the default is 1.

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

XmNwordWrap — when the Boolean value is True, it means lines get broken at word breaks (that is, the text doesn't go off the right edge of the window). 💖 Words are defined as a sequence of characters separated by whitespace, and whitespace is defined as a space, tab, or newline. This attribute is ignored if the text widget resource XmNeditMode is XmSINGLE_LINE_EDIT. Also note: this resource is only valid when the widget is not a scroll one — or, if the widget is a scroll widget, when the XmNscrollHorizontal resource is False. 🙅

And when the Boolean value is True, it means lines get broken at word breaks (that is, when the XmNlayoutDirection resource is XmTOP_TO_BOTTOM, the text doesn't go off the bottom edge of the window). 🌈

ok so these next ones are the scrolling resources — they only wake up and do their thing when your text is chillin' inside a ScrolledWindow. Go peek at the reference page for XmCreateScrolledText if you want the full lore 💅

🌀 XmText Scrolling Resource Set 🌀

XmNscrollHorizontal — class XmCScroll, type Boolean, default True, access CG
XmNscrollLeftSide — class XmCScrollSide, type Boolean, default False, access CG
XmNscrollTopSide — class XmCScrollSide, type Boolean, default False, access CG
XmNscrollVertical — class XmCScroll, type Boolean, default True, access CG

bestie listen 👀 real quick note about that table: if XmNlayoutDirection is XmTOP_TO_BOTTOM, the default is True. yes, actually. that's the plot twist.

XmNscrollHorizontal — when this Boolean is True, it adds a ScrollBar so your user can scroll sideways through the text. it gets forced to False when the Text widget lives in a ScrolledWindow with XmNscrollingPolicy set to XmAUTOMATIC. also, when XmNlayoutDirection is XmTOP_TO_BOTTOM, this attribute is ignored if the XmText widget resource XmNeditMode is XmSINGLE_LINE_EDIT.
XmNscrollLeftSide — when this Boolean is True, it means the vertical ScrollBar should sit on the left side of the scrolled text window. this attribute gets ignored if XmNscrollVertical is False, or if the Text resource XmNeditMode is XmSINGLE_LINE_EDIT.

when XmNlayoutDirection is XmTOP_TO_BOTTOM, this resource is still effective, even if the XmText widget resource XmNeditMode is XmSINGLE_LINE_EDIT. yeah. it really said "rules for thee, not for me" ✨

XmNscrollTopSide — when this Boolean is True, the horizontal ScrollBar gets placed on the top side of the scrolled text window. periodt.

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

XmNscrollVertical — when this Boolean is True, it adds a ScrollBar so your user can scroll up and down through the text. this attribute is ignored if the Text resource XmNeditMode is XmSINGLE_LINE_EDIT. it gets forced to False when the Text widget is placed in a ScrolledWindow with XmNscrollingPolicy set to XmAUTOMATIC.

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

🧬 Inherited Resources 🧬

Text is literally inheriting behavior and resources from its superclasses like the icon it is — tables below, bestie. for a complete description of each resource, go read the reference page for that superclass. i'm just the messenger 🫶

✨ XmPrimitive Resource Set ✨

XmNbottomShadowColor — class XmCBottomShadowColor, type Pixel, default dynamic, access CSG
XmNbottomShadowPixmap — class XmCBottomShadowPixmap, type Pixmap, default XmUNSPECIFIED_PIXMAP, access CSG
XmNconvertCallback — class XmCCallback, type XtCallbackList, default NULL, access C
XmNforeground — class XmCForeground, type Pixel, default dynamic, access CSG
XmNhelpCallback — class XmCCallback, type XtCallbackList, default NULL, access C
XmNhighlightColor — class XmCHighlightColor, type Pixel, default dynamic, access CSG
XmNhighlightOnEnter — class XmCHighlightOnEnter, type Boolean, default False, access CSG
XmNhighlightPixmap — class XmCHighlightPixmap, type Pixmap, default dynamic, access CSG
XmNhighlightThickness — class XmCHighlightThickness, type Dimension, default 2, access CSG
XmNlayoutDirection — class XmCLayoutDirection, type XmDirection, default dynamic, access CG
XmNnavigationType — class XmCNavigationType, type XmNavigationType, default XmTAB_GROUP, access CSG
XmNpopupHandlerCallback — class XmCCallback, type XtCallbackList, default NULL, access C
XmNshadowThickness — class XmCShadowThickness, type Dimension, default 2, access CSG
XmNtopShadowColor — class XmCTopShadowColor, type Pixel, default dynamic, access CSG
XmNtopShadowPixmap — class XmCTopShadowPixmap, type Pixmap, default dynamic, access CSG
XmNtraversalOn — class XmCTraversalOn, type Boolean, default True, access CSG
XmNunitType — class XmCUnitType, type unsigned char, default dynamic, access CSG
XmNuserData — class XmCUserData, type XtPointer, default NULL, access CSG

🌈 Core Resource Set 🌈

XmNaccelerators — class XmCAccelerators, type XtAccelerators, default dynamic, access CSG
XmNancestorSensitive — class XmCSensitive, type Boolean, default dynamic, access G
XmNbackground — class XmCBackground, type Pixel, default dynamic, access CSG
XmNbackgroundPixmap — class XmCPixmap, type Pixmap, default XmUNSPECIFIED_PIXMAP, access CSG
XmNborderColor — class XmCBorderColor, type Pixel, default XtDefaultForeground, access CSG
XmNborderPixmap — class XmCPixmap, type Pixmap, default XmUNSPECIFIED_PIXMAP, access CSG
XmNborderWidth — class XmCBorderWidth, type Dimension, default 0, access CSG
XmNcolormap — class XmCColormap, type Colormap, default dynamic, access CG
XmNdepth — class XmCDepth, type int, default dynamic, access CG
XmNdestroyCallback — class XmCCallback, type XtCallbackList, default NULL, access C
XmNheight — class XmCHeight, type Dimension, default dynamic, access CSG
XmNinitialResourcesPersistent — class XmCInitialResourcesPersistent, type Boolean, default True, access C
XmNmappedWhenManaged — class XmCMappedWhenManaged, type Boolean, default True, access CSG
XmNscreen — class XmCScreen, type Screen *, default dynamic, access CG
XmNsensitive — class XmCSensitive, type Boolean, default True, access CSG
XmNtranslations — class XmCTranslations, type XtTranslations, default dynamic, access CSG
XmNwidth — class XmCWidth, type Dimension, default dynamic, access CSG
XmNx — class XmCPosition, type Position, default 0, access CSG
XmNy — class XmCPosition, type Position, default 0, access CSG

📞 Callback Information 📞

so every single callback gets handed a pointer to this lil structure, okay? here it is:

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

reason — tells you why the callback got invoked. the whole motive, the backstory 🔍
event — points to the XEvent that triggered the callback. the moment that started it all ✨

and NOW 💖 the Text widget also defines a whole new callback structure for use with verification callbacks. heads up though: not all fields are relevant for every callback reason. the application has to look at the reason field first and only use the structure members that are actually valid for that particular reason. don't be out here reading fields that aren't yours bestie 🙈

the values startPos, endPos, and text in the callback structure XmTextVerifyCallbackStruct may be modified when the callback is received — and those changes will be reflected as changes made to the source of the Text widget. (for example, all keystrokes can be converted to spaces or NULL characters when a password is entered into a Text widget. iconic behavior honestly.) but the application programmer should not overwrite the text field — instead, attach data to that pointer. do not touch. just vibe.

so this next structure gets handed to callbacks for XmNlosingFocusCallback, XmNmodifyVerifyCallback, and XmNmotionVerifyCallback:

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

reason — tells you why the callback was invoked 🕵️
event — points to the XEvent that triggered the callback. it can be NULL. for example, changes made to the Text widget programmatically don't have an event that can be passed to the associated callback. no event, no problem, no drama 💅
doit — the vibe check for whether the action that summoned the callback actually goes through. Set doit to False and boom, the action is negated. But bestie, not every action can be cancelled like that. For example, XmCR_LOSING_FOCUS callbacks? If they're produced by mouse clicks, they might be totally beyond the widget's control. 😭
currInsert — shows where the insert cursor is right now. Current location, periodt. 💅
newInsert — where the user is trying to move that insert cursor to. Ambition.
startPos — the starting position of the text to modify. If this callback isn't a modify verification callback, it's literally the same as currInsert.
endPos — the ending position of the text to modify. If no text is replaced or deleted, it's the same as startPos. And if this callback isn't a modify verification callback, it's the same as currInsert. Matching energy.
text — points to a structure of type XmTextBlockRec. This holds the textual information that's about to be inserted.

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

ptr — points to the text to be inserted.
length — specifies the length of the text to be inserted.
format — specifies the format of the text, either XmFMT_8_BIT or XmFMT_16_BIT.

A pointer to the following structure is passed to callbacks for XmNmodifyVerifyCallbackWcs.

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

reason — why the callback was invoked. The reason era. ✨
event — points to the XEvent that triggered the callback. It can be NULL. For example, changes made to the Text widget programmatically don't have an event that can be passed to the associated callback. No event, no problem.
doit — same deal as before: whether the action that invoked the callback is performed. Setting doit to False negates the action. But again, not all actions may be negated. For example, XmCR_LOSING_FOCUS callbacks may be beyond the control of the widget if they are produced by mouse clicks. 💀
currInsert — the current position of the insert cursor.
newInsert — the position at which the user attempts to position the insert cursor.
startPos — the starting position of the text to modify. If the callback is not a modify verification callback, this value is the same as currInsert.
endPos — the ending position of the text to modify. If no text is replaced or deleted, the value is the same as startPos. If the callback is not a modify verification callback, this value is the same as currInsert.
text — points to the following structure of type XmTextBlockRecWcs. This structure holds the textual information to be inserted.

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

wcsptr — points to the wide character text to be inserted.
length — specifies the number of characters to be inserted.

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

XmCR_LOSING_FOCUS — valid fields: reason, event, doit, currInsert, newInsert, startPos, endPos
XmCR_MODIFYING_TEXT_VALUE — valid fields: reason, event, doit, currInsert, newInsert, startPos, endPos, text
XmCR_MOVING_INSERT_CURSOR — valid fields: reason, doit, currInsert, newInsert

A pointer to the following callback structure is passed to the XmNdestinationCallback procedures:

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

reason — indicates why the callback was invoked.
event — points to the XEvent that triggered the callback. It can be NULL.
selection — indicates the selection for which data transfer is being requested. Possible values are CLIPBOARD, PRIMARY, SECONDARY, and _MOTIF_DROP.
operation — indicates the type of transfer operation requested.
- When the selection is PRIMARY or SECONDARY, possible values are XmMOVE, XmCOPY, and XmLINK.
- When the selection is CLIPBOARD, possible values are XmCOPY and XmLINK.
- When the selection is _MOTIF_DROP, possible values are XmMOVE, XmCOPY, XmLINK, and XmOTHER. A value of XmOTHER means that the callback procedure must get further information from the XmDropProcCallbackStruct structure in the destination_data member.
flags — indicates whether or not the destination widget is also the source of the data to be transferred. Possible values:
- XmCONVERTING_NONE — the destination widget is not the source of the data to be transferred.
- XmCONVERTING_SAME — the destination widget is the source of the data to be transferred.
transfer_id — serves as a unique ID to identify the transfer transaction. It's giving transaction passport. 🛂
destination_data — contains information about the destination. When the selection is _MOTIF_DROP, the callback procedures are called by the drop site's XmNdropProc, and destination_data is a pointer to the XmDropProcCallbackStruct structure passed to the XmNdropProc procedure. When the selection is SECONDARY, destination_data is an Atom representing a target recommmended by the selection owner for use in converting the selection. Otherwise, destination_data is NULL.
location_data — contains information about the location where data is to be transferred. The value is always NULL when the selection is CLIPBOARD. If the value is NULL, the data is to be inserted at the widget's cursor position. Otherwise, the value is a pointer to an XPoint structure containing the x- and y-coordinates at the location where the data is to be transferred. Once XmTransferDone procedures start to be called, location_data will no longer be stable. So don't get attached, bestie. 🫠
time — indicates the time when the transfer operation began.

✨ Translations ✨

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

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

∼c s ∼m ∼a <Btn1Down>: extend-start()
c ∼s ∼m ∼a <Btn1Down>: move-destination()
∼c ∼s ∼m ∼a <Btn1Down>: grab-focus()
∼c ∼m ∼a <Btn1Motion>: extend-adjust()
∼c ∼m ∼a <Btn1Up>: extend-end()
<Btn2Down>: process-bdrag()
m ∼a <Btn2Motion>: secondary-adjust()
∼m a <Btn2Motion>: secondary-adjust()
s c <Btn2Up>: link-to()
∼s <Btn2Up>: copy-to()
∼c <Btn2Up>: move-to()
:m <Key><osfPrimaryPaste>: cut-primary()
:a <Key><osfPrimaryPaste>: cut-primary()
:<Key><osfPrimaryPaste>: copy-primary()
:m <Key><osfCut>: cut-primary()
:a <Key><osfCut>: cut-primary()
:<Key><osfCut>: cut-clipboard()
:<Key><osfPaste>: paste-clipboard()
:m <Key><osfCopy>: copy-primary()
:a <Key><osfCopy>: copy-primary()
:<Key><osfCopy>: copy-clipboard()
:s c <Key><osfBeginLine>: beginning-of-file(extend)
:c <Key><osfBeginLine>: beginning-of-file()
:s <Key><osfBeginLine>: beginning-of-line(extend)
:<Key><osfBeginLine>: beginning-of-line()
:s c <Key><osfEndLine>: end-of-file(extend)
:c <Key><osfEndLine>: end-of-file()
:s <Key><osfEndLine>: end-of-line(extend)
:<Key><osfEndLine>: end-of-line()
:s <Key><osfPageLeft>: page-left(extend) (ignored in vertical writing)
:<Key><osfPageLeft>: page-left() (next-page() in vertical writing)
:s c <Key><osfPageUp>: page-left(extend)
:c <Key><osfPageUp>: page-left()
:s <Key><osfPageUp>: previous-page(extend) (ignored in vertical writing)
:<Key><osfPageUp>: previous-page() (page-up() in vertical writing)
:s <Key><osfPageRight>: page-right(extend) (ignored in vertical writing)
:<Key><osfPageRight>: page-right() (previous-page() in vertical writing)
s c <Key><osfPageDown>: page-right(extend) (ignored in vertical writing)
:c <Key><osfPageDown>: page-right()
:s <Key><osfPageDown>: next-page(extend) (ignored in vertical writing)
:<Key><osfPageDown>: next-page() (page-down() in vertical writing)
:<Key><osfClear>: clear-selection()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

:<Key><osfActivate>:
          activate()

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

:<Key><osfHelp>:
          Help()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<Key>:    self-insert()

Okay so here's the tea, bestie 💖 — the Text button event translations get a glow-up when Display's XmNenableBtn1Transfer resource doesn't have a value of XmOFF (aka it's either XmBUTTON2_TRANSFER or XmBUTTON2_ADJUST). This option lets the actions for selection and transfer get integrated on <Btn1>, and the actions for extending the selection can be bound to <Btn2>. The <Btn1> actions we defined up there still apply when the <Btn1> event happens over text that is not selected. But the following actions apply when the <Btn1> event happens over text that is selected:

<Btn1Down>:
          process-bdrag().

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

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

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

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

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

And when Display's XmNenableBtn1Transfer resource has a value of XmBUTTON2_ADJUST, these are the ones that apply:

<Btn2Down>:
          extend-start().

<Btn2Motion>:
          extend-adjust().

<Btn2Up>: extend-end().

✨ Action Routines ✨

The XmText action routines are, like, the whole roster. Here's the lineup 👑

activate() — Calls the callbacks for XmNactivateCallback. Passes the event to the parent.
backward-character(extend) — Moves the insertion cursor one character to the left. Heads up: this action may have different behavior in a right-to-left language environment.

If you call it with an argument of extend, it moves the insertion cursor just like the no-argument case and extends the current selection.

The backward-character() action produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. If called with the extend argument, the backward-character() action may produce calls to the XmNgainPrimaryCallback procedures. See callback description for more info.

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

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

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

The backward-paragraph() action produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. If called with the extend argument, the backward-paragraph() action may produce calls to the XmNgainPrimaryCallback procedures. See callback description for more info.

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

If called with an argument of extend, it moves the insertion cursor like the no-argument case and extends the current selection.

The backward-word() action produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. If called with the extend argument, the backward-word() action may produce calls to the XmNgainPrimaryCallback procedures. See callback description for more info.

beep() — Causes the terminal to beep. That's it, that's the whole job. The beep() action produces no callbacks. Iconic, honestly.
beginning-of-file(extend) — If this action is called with no argument, it moves the insertion cursor to the beginning of the text.

If called with an argument of extend, it moves the insertion cursor like the no-argument case and extends the current selection.

The beginning-of-file() action produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. If called with the extend argument, the beginning-of-file() action may produce calls to the XmNgainPrimaryCallback procedures. See callback description for more info.

beginning-of-line(extend) — If this action is called with no argument, it moves the insertion cursor to the beginning of the line.

If called with an argument of extend, it moves the insertion cursor like the no-argument case and extends the current selection.

The beginning-of-line() action produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. If called with the extend argument, the beginning-of-line() action may produce calls to the XmNgainPrimaryCallback procedures. See callback description for more info.

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

The clear-selection() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE and the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED.

copy-clipboard() — If this widget owns the primary selection, this action copies the selection to the clipboard. It calls the XmNconvertCallback procedures, possibly multiple times, for the CLIPBOARD selection. 🦋
copy-primary() — Copies the primary selection to just before the insertion cursor. This action calls the XmNdestinationCallback procedures for the PRIMARY selection and the XmCOPY operation. It also calls the selection owner's XmNconvertCallback procedures, possibly multiple times, for the PRIMARY selection.

On top of all that, the copy-primary() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, to the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. So many callbacks, she's booked and busy 💅

`copy-to()` 🎀

okay so bestie, if a secondary selection exists, this one copies that secondary selection over to the insertion position of the destination component. and if the primary selection happens to be in the destination widget? it gets deselected. if not, literally no effect on the primary selection, she's fine, she's unbothered. 💅

here's the callback tea:

it calls the destination's XmNdestinationCallback procedures for the SECONDARY</> selection and the XmCOPY operation.
the destination's XmNdestinationCallback procedures or the destination component itself invokes the selection owner's XmNconvertCallback procedures, possibly multiple times, for the SECONDARY</> selection.

but wait — if there's no secondary selection at all, then she copies the primary selection to the pointer position instead. in that case:

it calls the XmNdestinationCallback procedures for the PRIMARY</> selection and the XmCOPY operation.
it calls the selection owner's XmNconvertCallback procedures, possibly multiple times, for the PRIMARY</> selection.

and on top of all that, copy-to() also produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, to the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. oh and if there's no secondary selection, copy-to() may produce calls to the XmNgainPrimaryCallback procedures. see the callback description for more info, iykyk. ✨

`cut-clipboard()` ✂️

if this widget owns the primary selection, this action cuts the selection to the clipboard. slay.

it calls the XmNconvertCallback procedures, possibly multiple times, for the CLIPBOARD selection.
if the transfer is successful, it then calls the XmNconvertCallback procedures for the CLIPBOARD selection and the DELETE target. 🔥

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

`cut-primary()` 💜

cuts the primary selection and pastes it just before the insertion cursor. main character move honestly.

it calls the XmNdestinationCallback procedures for the PRIMARY</> selection and the XmMOVE operation.
it calls the selection owner's XmNconvertCallback procedures, possibly multiple times, for the PRIMARY</> selection.
if the transfer is successful, it then calls the selection owner's XmNconvertCallback procedures for the PRIMARY</> selection and the DELETE target.
cut-primary() may produce calls to the XmNgainPrimaryCallback procedures. see the callback description for more info. 🫶

and also, cut-primary() produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR, the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, and the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED.

`delete-next-character()` 🌸

in normal mode: if there's a nonnull selection, deletes the selection; otherwise, deletes the character following the insertion cursor.

in add mode: if there's a nonnull selection, the cursor is not disjoint from the selection, and XmNpendingDelete is set to True, it deletes the selection; otherwise, it deletes the character following the insertion cursor.

heads up bestie — this may impact the selection. 😭

the delete-next-character() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, and the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED.

`delete-next-word()` 🌈

in normal mode: if there's a nonnull selection, deletes the selection; otherwise, deletes the characters following the insertion cursor to the next space, tab or end-of-line character.

this may impact the selection, and also — this action may have different behavior in a locale other than the C locale. so like, don't be surprised ok?? 💀

the delete-next-word() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, and the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED.

`delete-previous-character()` 🍓

in normal mode: if there's a nonnull selection, deletes the selection; otherwise, deletes the character of text immediately preceding the insertion cursor.

this may impact the selection. 🙈

the delete-previous-character() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR.

`delete-previous-word()` 🦋

in normal mode: if there's a nonnull selection, deletes the selection; otherwise, deletes the characters preceding the insertion cursor to the next space, tab or beginning-of-line character.

this may impact the selection. and same energy as before — this action may have different behavior in a locale other than the C locale. ✨

the delete-previous-word() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR.

`delete-selection()` 🔥

deletes the current selection. that's it, that's the whole vibe. iconic.

the delete-selection() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR.

`delete-to-end-of-line()` 👑

in normal mode: if there's a nonnull selection, deletes the selection; otherwise, deletes the characters following the insertion cursor to the next end of line character.

this may impact the selection, no cap. 💅

the delete-to-end-of-line() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, and the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED.

`delete-to-start-of-line()` ⭐

in normal mode: if there's a nonnull selection, deletes the selection; otherwise, deletes the characters preceding the insertion cursor to the previous beginning-of-line character.

this may impact the selection. fr fr. 😭

the delete-to-start-of-line() action produces calls to the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR.

`deselect-all()` 🧚

deselects the current selection. and like… that's it. the deselect-all() action produces no callbacks. she's lowkey the chillest one here. periodt. 💜

`end-of-file(extend)` 🎀

if this action is called with no argument, it moves the insertion cursor to the end of the text.

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

the end-of-file() action produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. and if it's called with the extend argument, the end-of-file() action may produce calls to the XmNgainPrimaryCallback procedures. see the callback description for more info. 🫶

`end-of-line(extend)` ✨

if this action is called with no argument, it moves the insertion cursor to the end of the line. if called with an argument of extend, it moves the insertion cursor as in the case of no argument, and extends the current selection.

the end-of-line() action produces calls to the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. and if it's called with the extend argument, the end-of-line() action may produce calls to the XmNgainPrimaryCallback procedures. see the callback description for more info. 🌸

extend-adjust() — takes the text from the anchor alllll the way over to wherever your pointer is sitting, and deselects everything outside that range. And the way it handles dragging across multiple lines? iconic. It selects from the anchor to the end of every line the pointer moves over, and up to the pointer position on the current line.

This one calls the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. It may also call the XmNgainPrimaryCallback procedures. Check the callback description for the whole story.

extend-end() — moves the insertion cursor to the pointer's position. This is the one you use to commit the selection, bestie. Once it's run, process-cancel() can't cancel the selection anymore. It's locked in, periodt.

extend-end() calls the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. It may also call the XmNgainPrimaryCallback procedures. See the callback description for more info.

extend-start() — adjusts the anchor using the balance-beam method. Selects text from the anchor to the pointer position and deselects anything outside that range. extend-start() may produce no callbacks at all, but it may also call the XmNgainPrimaryCallback procedures. Callback description, go read it.
forward-character(extend) — nudges the insertion cursor one character to the right. Heads up though, this action may act different in a right-to-left language environment. 🙈

Call it with an argument of extend and it moves the insertion cursor exactly like the no-argument case and extends the current selection. Two birds, one cursor.

forward-character() calls the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. Called with the extend argument, it may also call the XmNgainPrimaryCallback procedures. Callback description has the details.

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

forward-paragraph(extend) — if XmNeditMode is XmMULTI_LINE_EDIT and you call it with no argument, it moves the insertion cursor to the first non-whitespace character after the next blank line. Already chilling at the beginning of a paragraph? Then it moves the insertion cursor to the beginning of the next paragraph. Main character behavior.

If XmNeditMode is XmMULTI_LINE_EDIT and you call it with an argument of extend, it moves the insertion cursor just like the no-argument case and extends the current selection.

forward-paragraph() calls the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. With the extend argument, it may also call the XmNgainPrimaryCallback procedures. Callback description, bestie.

forward-word(extend) — no argument? It moves the insertion cursor to the first whitespace character or end-of-line following the next non-whitespace character. If the insertion cursor is already sitting at the end of a word, it hops to the end of the next word. Fair warning: this action may behave differently in a locale other than the C locale.

Called with an argument of extend, it moves the insertion cursor exactly like the no-argument case and extends the current selection.

forward-word() calls the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. With the extend argument, it may also call the XmNgainPrimaryCallback procedures. See the callback description for more.

grab-focus() — this key binding does whatever the XmNselectionArray says to do, depending on how many times you clicked that mouse. Default selection array ordering, fr fr: one click moves the insertion cursor to the pointer position, two clicks select a word, three clicks select a line of text, four clicks select all the text. And a single click also deselects any selected text and drops the anchor at the pointer position. This action may act different in a locale other than the C locale. 🖱️

grab-focus() calls the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR.

Help() — calls the callbacks for XmNhelpCallback if any of them exist. If this widget has no help callbacks, it goes and calls the help callbacks on the nearest ancestor that has them. family support energy. 🫶
insert-string(string) — if XmNpendingDelete is True and the cursor is not disjoint from the current selection, it deletes the entire selection. Then it inserts string before the insertion cursor. No notes.

insert-string() calls the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. Now, plot twist: with an empty string, no callbacks get called, because nothing actually got modified. BUT — if the insertion position is inside the current selection, insert-string with an empty string will cause the selection to be deselected, and the XmNmotionVerifyCallback procedures to be called with reason values XmCR_MOVING_INSERT_CURSOR, XmCR_MODIFYING_TEXT_VALUE, and XmCR_VALUE_CHANGED. The way that empty string is doing the most. 💀

key-select(right|left) — called with an argument of right, it moves the insertion cursor one character to the right and extends the current selection. Called with left, it moves the insertion cursor one character to the left and extends the current selection. Called with no argument at all? It just extends the current selection. Simple as.

Lowkey important: after a key-select action, the selection still begins at the original anchor, and extends to the position indicated in the action call. If this new position lands on the opposite side of the selection anchor from the previous selection boundary, the original selection gets deselected. bye.

key-select() calls the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR. It may also call the XmNgainPrimaryCallback procedures. See the callback description for more.

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

kill-next-character() — in normal mode: if there's a nonnull selection, it kills the selection; otherwise it kills the character following the insertion cursor and stores that character in the cut buffer. In add mode: if there's a nonnull selection, the cursor is not disjoint from the selection, and XmNpendingDelete is set to True, it deletes the selection; otherwise it kills the character following the insertion cursor and stores the character in the cut buffer. Heads up, this may impact the selection. 😭

The killed text gets stored in CUT_BUFFER0.

kill-next-character() calls the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR.

kill-next-word() — in normal mode: if there's a nonnull selection, it deletes the selection; otherwise it kills the characters following the insertion cursor up to the next space, tab or end-of-line character, and stores those characters in the cut buffer. In add mode: if there's a nonnull selection, the cursor is not disjoint from the selection, and XmNpendingDelete is set to True, it deletes the selection; otherwise it kills the characters following the insertion cursor up to the next space, tab or end-of-line character, and stores the characters in the cut buffer. This may impact the selection. And this action may behave differently in a locale other than the C locale.

The killed text gets stored in CUT_BUFFER0.

kill-next-word() calls the XmNmodifyVerifyCallback procedures with reason value XmCR_MODIFYING_TEXT_VALUE, the XmNvalueChangedCallback procedures with reason value XmCR_VALUE_CHANGED, and the XmNmotionVerifyCallback procedures with reason value XmCR_MOVING_INSERT_CURSOR.

`kill-previous-character()` 💖

In normal mode, if there is a nonnull selection, it deletes the selection; otherwise, it kills the character immediately preceding the insertion cursor and stores the character in the cut buffer.

In add mode, if there is a nonnull selection, the cursor is not disjoint from the selection, and XmNpendingDelete is set to True, it deletes the selection; otherwise, it kills the character immediately preceding the insertion cursor and stores the character in the cut buffer. This may impact the selection.