XMCONTAINER(3)

📦
version 2.3.8 · 3 versions
, in arch rolling, centos-stream 9, epel 10, fedora 43, fedora 44, nixos 26.05, nixpkgs unstable, opensuse-leap 16.0

💅 XmContainer — The Container widget class 💅

okay bestie, welcome to the library call manual for XmContainer. this is the whole vibe, no skips, fr fr. 🫶

🌸 NAME 🌸

XmContainer — The Container widget class. periodt. 👑

🦋 SYNOPSIS 🦋

#include <Xm/Container.h>

💖 DESCRIPTION 💖

okay so Container manages child widgets that have the ContainerItem trait. no cap. These child widgets can be viewed in several different layout formats, selected using different selection types and techniques, and directly manipulated by the user. main character behavior. 💅

Three different formats or views are supported by the Container. They are specified via the XmNentryViewType resource:

  • XmLARGE_ICON
  • XmSMALL_ICON
  • XmANY_ICON

Three different layout types are supported by the Container. They are specified by the XmNlayoutType resource:

  • XmSPATIAL
  • XmOUTLINE
  • XmDETAIL

In the XmSPATIAL layout type, several other resources (XmNspatialStyle, XmNspatialIncludeModel, XmNspatialSnapModel) control the positioning of the items within the Container; an application programmer can specify these resources so that the Container strictly enforces the position of each item or so that the Container positions items according to constraint resources specified for each item. The user, however, can alter the position of an item in the XmSPATIAL layout type within the Container by direct manipulation; for example, by pressing BTransfer over the item and then dragging and releasing BTransfer over some location within the Container. iconic drag energy. ✨

In the XmOUTLINE layout type, the Container controls the positioning of the items. Items within the Container can have parent-child relationships between them. Each item's XmNentryParent resource can specify another item in the same Container as its parent; items with a non-NULL value for XmNentryParent can only be displayed in the XmOUTLINE layout type. In the XmOUTLINE layout type, items are positioned in a tree configuration with connecting lines drawn to illustrate the relationships. Items are positioned top to bottom in the order specified by XmNpositionIndex within their parent. Container positions a PushButton next to each item that has a parent relationship to other items. The PushButton contains a pixmap to illustrate whether the child items are shown or not; the user can activate the PushButton to toggle between showing or hiding the child items. Direct manipulation to alter the position of the item is not supported in the XmOUTLINE layout type. Note that the XmNtraversalOn resource of the PushButtons created by Container are set to False. no touchy. 🙈

The XmDETAIL layout type is the same as XmOUTLINE, except that each item can also display additional information as rows in columns with column headers specified in the XmNdetailColumnHeading resources. In each item row, the item's detail information (see the reference page on XmIconGadget for a description of the XmNentryDetail resource) is displayed. Items are positioned top to bottom in the order specified by XmNpositionIndex within the parent. details on details. 🍓

🎀 Selection 🎀

When a child widget of the container is selected, the container specifies that the item should display the appropriate visual information to the user via the ContainerItem trait. The application program is notified of selection changes through XmNselectionCallback. callback cutie. 💖

The container uses four selection policies:

  • Single
  • Browse
  • Multiple
  • Extended

In Single Select and Browse Select modes, only one item can be selected at a time. Pressing BSelect on an item selects it and deselects any other selected item. Pressing BSelect over an empty space in the Container deselects all items. In Browse Select, dragging BSelect moves the selection as the pointer is moved. one at a time, bestie. 💅

In Multiple Select and Extended Select modes, any number of items can be selected at the same time. In Multiple Select, pressing and dragging BSelect or BExtend to specify an item, range of items, or group of discontiguous items causes the selection states of those items to be toggled. In Extended Select, pressing and dragging BSelect to indicate an item, range of items, or group of discontiguous items selects those items and deselects all others. Pressing and dragging BExtend in Extended Select to indicate an item, range of items, or discontiguous group of items causes the selection states of those items to be toggled. multi-select main character energy. ✨

Several techniques are available to indicate an item, range of items, or group of discontiguous items in the Multiple Select and Extended Select modes.

In the XmSPATIAL and XmOUTLINE layout types, the XmNselectionTechnique resource specifies the techniques to be used to indicate items. The default specification of XmTOUCH_OVER allows both the Random-Swipe and Marquee techniques to be used when XmNlayoutStyle is XmSPATIAL. The default specification of XmTOUCH_OVER allows the Range-Swipe, Range-Click, and Marquee techniques to be used when XmNlayoutStyle is XmOUTLINE. defaults ate. 🔥

Discontiguous groups of items can be selected using the Random-Swipe technique. In the Random-Swipe technique, pressing BSelect (or BExtend) over an item and dragging BSelect over other items selects all of those items. Only those items that pointer passed over are selected.

In the Range-Swipe technique, the user presses BSelect (or BExtend) over the first item and releases BSelect over the last item; all items within the range between the first and last item are selected whether the pointer actually passed over them or not. In the Range-Click technique, the user presses and releases BSelect (or BExtend) over the first item and then presses and releases BExtend over the last item. range game strong. 🌈

In the Marquee technique, pressing BSelect (or BExtend) over a blank space within the Container indicates the starting point of a Marquee rectangle. Dragging BSelect draws a Marquee rectangle (rubberband line) between the starting point and current pointer. All items completely within the Marquee rectangle are selected. rubberband line, literally. 💜

Specifying XmTOUCH_ONLY for XmNselectionTechnique enforces the Random-Swipe technique even when BSelect (or BExtend) is pressed over a blank space. Similarly, specifying XmMARQUEE enforces the Marquee technique even when BSelect (or BExtend) is pressed over an item; since the item over which the press occurs is only partially included in the Marquee rectangle, it is not selected. XmMARQUEE_EXTEND_START and XmMARQUEE_EXTEND_BOTH enforce the Marquee technique and also cause the rectangle to extend automatically around the first item indicated and, for XmMARQUEE_EXTEND_BOTH, the last item. marquee rules, no cap. 🎀

In the XmDETAIL layout type, the Range-Swipe and Range-Click techniques are available to indicate a range of items for selection.

Container uses the XmQTcontainerItem, XmQTscrollFrame, and XmQTspecifyRenderTable traits and holds the XmQTcontainer and XmQTtransfer traits. trait queen. 👑

📦 Data Transfer Behavior 📦

Container supports dragging of selected items from the widget. Depending on the value of XmNprimaryOwnership, Container can also support primary selection. drag and drop, but make it fashion. 💅

As a source of data, Container 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 items in the encoding of the locale. The value for each item transferred, except the last, includes a trailing separator. Each item value is the XmNlabelString of the item.
  • COMPOUND_TEXT — The widget transfers the selected items as type COMPOUND_TEXT. The value for each item transferred, except the last, includes a trailing separator. Each item value is the XmNlabelString of the item.
  • DELETE — The widget deletes the selected items.
  • PIXMAP — The widget transfers a list of the pixmap IDs of the selected items as type DRAWABLE.
  • STRING — The widget transfers the selected items as type STRING. The value for each item transferred, except the last, includes a trailing separator. Each item value is the XmNlabelString of the item.
  • TEXT — If the selected items are fully convertible to the encoding of the locale, the widget transfers the selected items in the encoding of the locale. Otherwise, the widget transfers the selected items as type COMPOUND_TEXT. The value for each item transferred, except the last, includes a trailing separator. Each item value is the XmNlabelString of the item.
  • _MOTIF_CLIPBOARD_TARGETS — The widget transfers, as type ATOM, a list of the targets it supports for immediate transfer for the CLIPBOARD selection. These include _MOTIF_COMPOUND_STRING and PIXMAP. If the selected items are fully convertible to STRING, these also include STRING; otherwise, they also include COMPOUND_TEXT and UTF8_STRING.
  • _MOTIF_COMPOUND_STRING — The widget transfers the selected items as a compound string in Byte Stream format. The value for each item transferred, except the last, includes a trailing separator. Each item value is the XmNlabelString of the item.
  • UTF8_STRING — The widget transfers the selected items as type UTF8_STRING. The value for each item transferred, except the last, includes a trailing separator. Each item value is the XmNlabelString of the item.
  • _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_DRAG_OFFSET — The widget transfers a list of two 16-bit numbers, of type INTEGER, representing an x and y offset for an item being dragged. This offset is calculated so that, if the offset were added to the x and y coordinates at the drop site, and the dragged pixmap placed at that position, it would correspond to the position the user would expect the pixmap to placed at, based on the drag icon used at the drop site.
  • _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 _MOTIF_COMPOUND_STRING, PIXMAP, COMPOUND_TEXT, the encoding of the locale, STRING, TEXT, BACKGROUND, FOREGROUND, and UTF8_STRING.

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

  • BACKGROUND — The widget transfers XmNbackground as type PIXEL.
  • CLASS — the widget hunts down the first shell in the widget hierarchy that's got a WM_CLASS property, and hands the contents over as text in the current locale. 💅
  • CLIENT_WINDOW — the widget finds that same first shell in the hierarchy and transfers its window as type WINDOW.
  • COLORMAP — the widget transfers XmNcolormap as type COLORMAP. slay.
  • FOREGROUND — the widget transfers XmNforeground as type PIXEL.
  • NAME — same detective work as CLASS, bestie: it 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 a list of the targets it supports, as type ATOM. That list includes the standard targets in this very list ✨ <span>and</span> it also includes _MOTIF_COMPOUND_STRING, PIXMAP, COMPOUND_TEXT, the encoding of the locale, STRING, TEXT, and UTF8_STRING.
  • 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.

Okay so as a destination for data? Container is lowkey picky 🙈 it supports only the dropping of items being dragged from the same widget. Subclasses and the XmNdestinationCallback procedures are the ones responsible for any other data transfers to the widget. no cap.

🧬 Classes 🧬

Container inherits behavior, resources, and traits from the Core, Composite, Constraint, and XmManager classes. iconic lineage fr fr 👑

  • The class pointer is xmContainerWidgetClass.
  • The class name is XmContainer.

✨ 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 whether 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).

bestie write this down: C = creation time, S = XtSetValues, G = XtGetValues, N/A = not applicable. that's the whole vibe check for the access column 💖

so here's the tea on the XmContainer resource set, bestie — every single knob you can turn, listed out with its class, type, default and access mode. Memorise these, they're your whole personality now. ✨

For each one: the Name is what you pass in, the Class is what resource files and XtSetArg fallbacks see, the Type is what it actually is, the Default is what you get when you say nothing (which is a choice too, no judgement), and Access tells you when you're allowed to touch it — CSG means set at creation, set later, or get; C means creation time only, so set it in your arg list or don't set it at all 💅.

  • XmNautomaticSelection — class XmCAutomaticSelection, type unsigned char, default XmAUTO_SELECT, access CSG. The vibe of how selection behaves automatically. 🦋
  • XmNcollapsedStatePixmap — class XmCCollapsedStatePixmap, type Pixmap, default dynamic, access CSG. The lil picture for a collapsed outline entry. 🎀
  • XmNconvertCallback — class XmCCallback, type XtCallbackList, default NULL, access C. Creation-time-only callback list for conversion stuff. ⭐
  • XmNdefaultActionCallback — class XmCCallback, type XtCallbackList, default NULL, access C. What fires when someone double-clicks a thing with main character energy. 🔥
  • XmNdestinationCallback — class XmCCallback, type XtCallbackList, default NULL, access C. The destination side of a drag, and again: C means creation only, so don't come at it later. 🙈
  • XmNdetailColumnHeading — class XmCDetailColumnHeading, type XmStringTable, default NULL, access CSG. The heading strings for your detail columns. ✨
  • XmNdetailColumnHeadingCount — class XmCDetailColumnHeadingCount, type Cardinal, default 0, access CSG. How many headings you just handed over. Count them, queen. 🔢
  • XmNdetailOrder — class XmCDetailOrder, type Cardinal *, default NULL, access CSG. A pointer to the order the detail columns get laid out in. 🧚
  • XmNdetailOrderCount — class XmCDetailOrderCount, type Cardinal, default dynamic, access CSG. How many entries are in that order array. ✨
  • XmNdetailTabList — class XmCDetailTabList, type XmTabList, default NULL, access CSG. Tab stops for the detail view, so your columns don't look unhinged. 💜
  • XmNentryViewType — class XmCEntryViewType, type unsigned char, default XmANY_ICON, access CSG. What kind of view the entries get. 🍓
  • XmNexpandedStatePixmap — class XmCExpandedStatePixmap, type Pixmap, default dynamic, access CSG. The glow-up version of the collapsed pixmap: shown when an outline entry is open. 🌸
  • XmNfontList — class XmCFontList, type XmFontList, default NULL, access CSG. Your fonts. Aesthetics are not optional. 🎀
  • XmNlargeCellHeight — class XmCCellHeight, type Dimension, default dynamic, access CSG. The tall-girl cell height. 😭
  • XmNlargeCellWidth — class XmCCellWidth, type Dimension, default dynamic, access CSG. The wide-girl cell width. 💅
  • XmNlayoutType — class XmCLayoutType, type unsigned char, default XmSPATIAL, access CSG. How the container arranges its children. 🦋
  • XmNmarginHeight — class XmCMarginHeight, type Dimension, default 0, access CSG. Breathing room top and bottom. 🌈
  • XmNmarginWidth — class XmCMarginWidth, type Dimension, default 0, access CSG. Breathing room left and right. ✨
  • XmNoutlineButtonPolicy — class XmCOutlineButtonPolicy, type unsigned char, default XmOUTLINE_BUTTON_PRESENT, access CSG. Whether those lil outline buttons show up at all. 👑
  • XmNoutlineChangedCallback — class XmCCallback, type XtCallbackList, default NULL, access C. Fires when the outline changes — and yes, C, creation time only, I said what I said. 🔥
  • XmNoutlineColumnWidth — class XmCOutlineColumnWidth, type Dimension, default dynamic, access CSG. How wide the outline column gets. ⭐
  • XmNoutlineIndentation — class XmCOutlineIndentation, type Dimension, default 40, access CSG. How far each nesting level gets pushed in. Forty. Not a typo, that's the default. 🧚
  • XmNoutlineLineStyle — class XmCLineStyle, type unsigned char, default XmSINGLE, access CSG. The line style connecting your outline tree. 💜
ngl bestie, notice how the callback ones are all C and everything else is CSG. That's not a coincidence, that's a rule — callbacks get wired up at creation or they get nothing. 🫶

and we're not done yet, there's more coming so don't go anywhere 💖

Okay bestie, here's the rest of that resource table, no skips, no crumbs left behind. Every row, every column, exactly as it was:

  • XmNprimaryOwnership — class XmCprimaryOwnership, type unsigned char, default XmOWN_POSSIBLE_MULTIPLE, access CSG
  • XmNrenderTable — class XmCRenderTable, type XmRenderTable, default dynamic, access CSG
  • XmNselectColor — class XmCSelectColor, type Pixel, default dynamic, access CSG
  • XmNselectedObjects — class XmCSelectedObjects, type WidgetList, default NULL, access SG
  • XmNselectedObjectCount — class XmCSelectedObjectCount, type unsigned int, default 0, access SG
  • XmNselectionCallback — class XmCCallback, type XtCallbackList, default NULL, access C
  • XmNselectionPolicy — class XmCSelectionPolicy, type unsigned char, default XmEXTENDED_SELECT, access CSG
  • XmNselectionTechnique — class XmCSelectionTechnique, type unsigned char, default XmTOUCH_OVER, access CSG
  • XmNsmallCellHeight — class XmCCellHeight, type Dimension, default dynamic, access CSG
  • XmNsmallCellWidth — class XmCCellWidth, type Dimension, default dynamic, access CSG
  • XmNspatialIncludeModel — class XmCSpatialIncludeModel, type unsigned char, default XmAPPEND, access CSG
  • XmNspatialResizeModel — class XmCSpatialResizeModel, type unsigned char, default XmGROW_MINOR, access CSG
  • XmNspatialSnapModel — class XmCSpatialSnapModel, type unsigned char, default XmNONE, access CSG
  • XmNspatialStyle — class XmCSpatialStyle, type unsigned char, default XmGRID, access CSG

And now the part you actually came for: the resource deep dives. Grab a snack, this is the good stuff. 🍓

✨ XmNautomaticSelection

The vibe check on when selection callbacks actually fire. Does the Container invoke selection callbacks the instant each item gets selected (or toggled), or does it stay quiet until the user has wrapped up their selection actions — like, say, released the mouse button? It takes one of these two values:

  • XmAUTO_SELECT — fires selection callbacks automatically the moment each item is selected or toggled. This can also be the value TRUE.
  • XmNO_AUTO_SELECT — delays selection callbacks until the user has finished their selection actions. This can also be the value FALSE.

✨ XmNcollapsedStatePixmap

Which lil' picture shows up when a branch is closed. This specifies the pixmap to display on a PushButton sitting next to a Container item that has child items, and it only matters when XmNoutlineButtonPolicy is XmOUTLINE_BUTTON_PRESENT. XmNcollapsedStatePixmap is basically the icon saying "hey, the child items are not displayed right now." If you set it to XmUNSPECIFIED_PIXMAP, a default pixmap showing an arrow pointing up gets used instead. 🦋

✨ XmNconvertCallback

For when somebody asks the Container to hand over a selection. This specifies a list of callbacks called when the Container is asked to convert a selection. The type of the structure whose address gets passed to these callbacks is XmConvertCallbackStruct. The reason is XmCR_OK.

✨ XmNdefaultActionCallback

The double-click moment. Iconic. This specifies a list of callbacks to call when the user double-clicks an item, or presses <Enter> or <Return> while over an item. The callback structure is XmContainerSelectCallbackStruct. The reason is XmCR_DEFAULT_ACTION.

✨ XmNdestinationCallback

Container as the receiving end of a transfer, periodt. This specifies a list of callbacks called when the Container is the destination of a transfer operation. The type of the structure whose address is passed to these callbacks is XmDestinationCallbackStruct. The reason is XmCR_OK.

✨ XmNdetailColumnHeading

Column labels for the detail layout, bestie. This specifies a table of XmStrings to display as the headings to columns. If it's NULL, or if XmNlayoutType is not XmDETAIL, then no heading gets displayed at all. 🙈

✨ XmNdetailColumnHeadingCount

Just the headcount for the heading table. This specifies a count of XmStrings in the table specified for XmNdetailColumnHeading.

✨ XmNdetailOrder

Which column goes where, and in what order. This specifies an array of Cardinals that indicate which column detail information, and in which order, each Container child will display its detail information. Heads up: this resource is ignored if XmNlayoutType is not XmDETAIL. If it's NULL, the default behavior is determined by XmNdetailOrderCount.

✨ XmNdetailOrderCount

How many entries are in that order array. This specifies a count of Cardinals in the array specified for XmNdetailOrder. If XmNdetailOrder is NULL and XmNdetailOrderCount is not 0, then each Container child displays its detail information in order from column 1 to the XmNdetailOrderCount column number. If XmNdetailOrderCount is 0, then a default gets calculated from the detail order count information of each item accessed via the ContainerItem trait.

✨ XmNdetailTabList

Where each column starts in the detail layout. This indicates an XmTabList specifying the start of each column in the XmDETAIL layout. If this resource is set to NULL, then Container calculates an XmTabList for you. This resource is ignored if XmNlayoutType is not XmDETAIL. 💅

✨ XmNentryViewType

One view type to rule all the Container children. This specifies the view type for all Container children. The view type is specified for each item via the ContainerItem trait. It takes one of these values:

  • XmANY_ICON — no specification is made for Container children. Children just use their own default specifications.
  • XmLARGE_ICON — the view type for all children is XmLARGE_ICON.
  • XmSMALL_ICON — the view type for all children is XmSMALL_ICON.
  • XmNexpandedStatePixmap — the pixmap that shows up on a PushButton sitting next to a Container item that has child items, but only when XmNoutlineButtonPolicy is XmOUTLINE_BUTTON_PRESENT. It's basically saying "hey bestie, the children are out and visible rn." If you set it to XmUNSPECIFIED_PIXMAP, you get a default pixmap of an arrow pointing down. ✨
  • XmNfontList — the fontlist tied to XmContainer. Okay so real talk, the fontlist is an obsolete construct and has been superseded by the render table. It's only still here for compatibility with earlier versions of Motif and for apps that don't easily support render tables. The default fontlist is derived from the default render table, and if you specify both a fontlist and a render table, the render table takes precedence. 💅
  • XmNlargeCellHeight — the height of a cell for XmGRID or XmCELLS spatial style when XmNentryViewType is XmLARGE_ICON or XmANY_ICON.
  • XmNlargeCellWidth — the width of a cell for XmGRID or XmCELLS spatial style when XmNentryViewType is XmLARGE_ICON or XmANY_ICON.
  • XmNlayoutType — the policy for laying out child widgets inside the Container. It can be one of these values:
    • XmDETAIL — displays items the same way as when the resource is XmOUTLINE, except every item also shows detail information next to it.
    • XmOUTLINE — displays items in a tree configuration, in XmNpositionIndex within XmNentryParent order, with connecting lines drawn to show their parent-child relationships. 🌳
    • XmSPATIAL — displays items according to XmNspatialStyle. Items with XmNentryParent values are not displayed.
  • XmNmarginHeight — the margin spacing at the top and bottom of the Container.
  • XmNmarginWidth — the margin spacing at the left and right sides of the Container.
  • XmNoutlineButtonPolicy — says whether or not to show buttons so users can expand and collapse the display of items. It can be one of these values:
    • XmOUTLINE_BUTTON_ABSENT — do not display the outline buttons.
    • XmOUTLINE_BUTTON_PRESENT — display the outline buttons.
  • XmNoutlineChangedCallback — a list of callbacks to call when an item's XmNoutlineState changes. The callback structure is XmContainerOutlineCallbackStruct. The reason is XmCR_COLLAPSED or XmCR_EXPANDED, depending on the new value of XmNoutlineState.
  • XmNoutlineColumnWidth — the width of the first column displayed when XmNlayoutType is XmDETAIL. And when XmNlayoutType is XmOUTLINE, it's the preferred width of the Container (without the margins). If you don't specify it, Container will determine a default value equal to the widest space necessary to display an item's pixmap and XmNoutlineIndentation. 🎀
  • XmNoutlineIndentation — the distance to indent for the display of child items when XmNlayoutType is XmOUTLINE or XmDETAIL.
  • XmNoutlineLineStyle — says whether to draw lines between items that have parent-child relationships when XmNlayoutType is XmOUTLINE or XmDETAIL. It can be one of these values:
    • XmNO_LINE — draws no line.
    • XmSINGLE — draws a line one pixel wide.
  • XmNprimaryOwnership — says whether Container takes ownership of the primary selection when a selection is made inside it. This resource can take these values:
    • XmOWN_NEVER — never takes ownership.
    • XmOWN_ALWAYS — always takes ownership.
    • XmOWN_MULTIPLE — only takes ownership if more than one element has been selected.
    • XmOWN_POSSIBLE_MULTIPLE — only takes ownership if more than one element can be selected at a time.
  • XmNrenderTable — the XmRenderTable that gets inherited by all children of the Container. The default is implementation dependent. If both a render table and a fontlist are specified, the render table will take precedence. 👑
  • XmNselectColor — a Pixel that can be accessed by children of the Container and used to indicate that the child is in a selected state. Along with a Pixel value, you can also specify these symbolic values:
    • XmDEFAULT_SELECT_COLOR — a color between the background and the bottom shadow color.
    • XmREVERSED_GROUND_COLORS — forces the select color to the foreground color and causes the default color of any text rendered over the select color to be the background color.
    • HIGHLIGHT_COLOR — forces the fill color to use the highlight color.
  • XmNselectedObjectCount — the number of widgets in the selected items list. The value must be the number of items in XmNselectedObjects.
  • XmNselectedObjects — an array of widgets that represents the Container items currently selected, either by the user or by the application.

If the application sets XmNselectedObjects to an array of widgets, those array elements that are valid Container items are selected.

  • XmNselectionCallback — a list of callbacks to call when an item is selected. The callback structure is XmContainerSelectCallbackStruct. The reason is XmCR_SINGLE_SELECT, XmCR_BROWSE_SELECT, XmCR_MULTIPLE_SELECT, or XmCR_EXTENDED_MULTIPLE, depending on XmNselectionPolicy.
  • XmNselectionPolicy — defines how the selection action gets interpreted. This can be one of these values:
    • XmSINGLE_SELECT — allows only single selections.
    • XmBROWSE_SELECT — allows "drag and browse" selections.
    • XmMULTIPLE_SELECT — allows multiple selections.
    • XmEXTENDED_SELECT — allows extended selections.
  • XmNselectionTechnique — the selection technique to use when the Container displays items in a 2-dimensional layout (XmNentryViewType is XmLARGE_ICON or XmSMALL_ICON). In the XmDETAIL layout, the XmNselectionTechnique resource is treated as XmTOUCH_ONLY. Either way, it can be one of these values:
    • XmMARQUEE — uses the Marquee technique only.
    • XmMARQUEE_EXTEND_START — uses the Marquee technique only and extends the Marquee rectangle around any item under the Marquee start point.
    • XmMARQUEE_EXTEND_BOTH — uses the Marquee technique only and extends the Marquee rectangle around any items under the Marquee start and end points.
    • XmTOUCH_ONLY — uses the Random-Swipe technique only if XmNlayoutType is XmSPATIAL. Otherwise, uses the Range-Swipe and Range-Click techniques.
    • XmTOUCH_OVER — if the selection action begins over an item and XmNlayoutType is XmSPATIAL, uses the Random-Swipe technique. If the selection action begins over an item and XmNlayoutType is XmOUTLINE or XmDETAIL, uses the Range-Swipe and Range-Click techniques. Uses the Marquee technique if the select action begins over an unoccupied area in the Container.
  • XmNsmallCellHeight — the height of a cell for XmGRID or XmCELLS spatial style when XmNentryViewType is XmSMALL_ICON.
  • XmNsmallCellWidth — the width of a cell for XmGRID or XmCELLS spatial style when XmNentryViewType is XmSMALL_ICON.
  • XmNspatialIncludeModel — the layout of an item when the item is managed in the Container when XmNlayoutType is XmSPATIAL and XmNspatialStyle is XmGRID or XmCELLS. It can be one of these values:
    • XmAPPEND — places the item after the last occupied cell according to XmNlayoutDirection.
    • XmCLOSEST — places the item in the free cell closest to the position specified by XmNx and XmNy.
    • XmFIRST_FIT — places the item in the first free cell according to XmNlayoutDirection.
  • XmNspatialResizeModel — how Container will attempt to grow its dimensions when XmNlayoutType is XmSPATIAL and XmNspatialStyle is XmGRID or XmCELLS and there aren't enough cells to contain a new Container item. It can be one of these values:
    • XmGROW_BALANCED — Container will request both width and height growth from its parent.
    • XmGROW_MAJOR — Container will request growth in its major dimension from its parent. Container's major dimension is width when the precedence of XmNlayoutDirection is horizontal, and height when vertical.
    • XmGROW_MINOR — Container will request growth in its minor dimension from its parent. Container's minor dimension is height when the precedence of XmNlayoutDirection is horizontal, and width when vertical.
  • XmNspatialSnapModel — how Container will position an item within the cell layout when XmNlayoutType is XmSPATIAL and XmNspatialStyle is XmGRID or XmCELLS. It can be one of these values:
    • XmCENTER — center the items as follows, depending on the value of XmNentryViewType:
  • XmLARGE_ICON — bestie the child is centered in the cell horizontally and baseline-aligned vertically ✨
  • XmSMALL_ICON — the child is centered in the cell vertically on its baseline, and lined up with the left or right of the cell horizontally, depending on whatever XmNlayoutDirection is giving 💅
  • XmSNAP_TO_GRID — drops the item at the upper-left or upper-right corner of the cell(s), depending on the value of XmNlayoutDirection. it's giving "snap into place" fr fr 🎀
  • XmNONE — positions the item according to the position specified by XmNx and XmNy. and if that position isn't within the coordinates of the cell(s)? then it positions the item at the upper-left or upper-right corner of the cell(s), depending on the value of XmNlayoutDirection. lowkey a little chaotic but okay 💀

XmNspatialStyle

Specifies the layout of Container items when XmNlayoutType is XmSPATIAL. It can have one of the following values:

  • XmCELLS — lays out items within a grid of same-size cells. each item occupies as many cells as required to contain the item dimensions. no cap, it takes up the space it needs 💖
  • XmGRID — lays out items within a grid of same-size cells, but each item occupies only one cell. items that are larger than the cell size may overlap other items 🙈 (yes bestie, the overlap is real, that's literally what it says)
  • XmNONE — lays out items according to XmNx and XmNy. that's it, that's the vibe.

✨ XmContainer Constraint Resource Set ✨

okay so here's the whole resource set, laid out (pun intended 🫶) — same info, just cuter:

  • XmNentryParent — Class: XmCWidget, Type: Widget, Default: NULL, Access: CSG
  • XmNoutlineState — Class: XmCOutlineState, Type: unsigned char, Default: XmCOLLAPSED, Access: CSG
  • XmNpositionIndex — Class: XmCPositionIndex, Type: int, Default: dynamic, Access: CSG

XmNentryParent

Specifies the widget that is this item's logical parent. A value of NULL means "this is a root-level item," aka main character energy with no parent 👑.

Parent-child info is displayed only when the XmNlayoutPolicy is XmOUTLINE or XmDETAIL. otherwise bestie, it's just not showing up, periodt.

XmNoutlineState

Specifies whether to display child items when XmNlayoutPolicy is XmOUTLINE or XmDETAIL. It can have one of the following values:

  • XmCOLLAPSED — does not display child items. keeping it hidden, keeping it mysterious 🎀
  • XmEXPANDED — displays child items. the children have entered the chat 🌸

XmNpositionIndex

Specifies the order of items in the Container for display. When XmNlayoutType is XmOUTLINE or XmDETAIL, items are displayed in XmNpositionIndex order within XmNentryParent.

Items that have an XmNentryParent resource are ignored when XmNlayoutType is XmSPATIAL. like, ignored ignored 💀

If XmNpositionIndex is not specified, it defaults to the XmNpositionIndex value plus 1 of the item with the highest XmNpositionIndex that has the same XmNentryParent, if such an item exists; otherwise, it defaults to 0. okay so it just queues itself up right after the last one, or starts at zero if there's nobody there yet. so organized, we love a self-sorting icon ✨

🌈 Inherited Resources 🌈

Container inherits behavior and resources from the superclasses described in the following tables. For a complete description of each resource, refer to the reference page for that superclass. yes bestie, you gotta go read the superclass pages too — the lore is deep 🦋

okay so the XmManager Resource Set? it's giving organized, it's giving everything. the columns are Name, Class, Type, Default, and Access. and bestie, we are doing <em>all</em> of them. no skips. 💅

  • XmNbottomShadowColor — Class: XmCBottomShadowColor • Type: Pixel • Default: dynamic • Access: CSG
  • XmNbottomShadowPixmap — Class: XmCBottomShadowPixmap • Type: Pixmap • Default: XmUNSPECIFIED_PIXMAP • Access: CSG
  • 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
  • XmNhighlightPixmap — Class: XmCHighlightPixmap • Type: Pixmap • Default: dynamic • Access: CSG
  • XmNinitialFocus — Class: XmCInitialFocus • Type: Widget • Default: NULL • 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: 0 • Access: CSG
  • XmNstringDirection — Class: XmCStringDirection • Type: XmStringDirection • Default: dynamic • Access: CG
  • 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

and that's the whole set, no cap. every single resource accounted for, exactly as the original table says. 💖✨

✨ Composite Resource Set ✨

okay bestie, this is the lil family of resources that every composite widget rolls with 💅 here's the whole lineup, no gatekeeping:

  • XmNchildren — class XmCReadOnly, type WidgetList, default NULL, access G. it's giving "here's the whole friend group" 🫶
  • XmNinsertPosition — class XmCInsertPosition, type XtOrderProc, default NULL, access CSG
  • XmNnumChildren — class XmCReadOnly, type Cardinal, default 0, access G. literally just "how many besties are in the group chat" 💀

👑 Core Resource Set 👑

and THIS one?? the whole entire core set, every last one, presented with zero skips because we don't do that here ✨:

  • 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 💌

Okay bestie, this is the part where you find out exactly what shows up in your callback when the Container pings you. A pointer to this lil struct gets passed to callbacks for XmNoutlineChangedCallback:

typedef struct
{
        int reason;
        XEvent * event;
        Widget item;
        unsigned char new_outline_state;
} XmContainerOutlineCallbackStruct;
  • reason — tells you why the callback got called, periodt.
  • event — points at the XEvent that triggered the callback. Ngl, it can be NULL.
  • item — the container item that got affected by the event. 👀
  • new_outline_state — the next XmNoutlineState for item. And here's the cute part: you, the user, can actually change this value inside the callback. slay.

A pointer to this next structure is what gets passed to callbacks for XmNdefaultActionCallback and XmNselectionCallback:

typedef struct
{
        int reason;
        XEvent * event;
        WidgetList selected_items;
        int selected_item_count;
        unsigned char auto_selection_type;
} XmContainerSelectCallbackStruct;
  • reason — specifies the reason for the callback. It corresponds to the XmNselectionPolicy at the time the selection was made, or it indicates that the default action should be taken.
  • event — points to the XEvent that triggered the callback. It can be NULL. (yes, again, we love a nullable pointer 💅)
  • selected_items — a list of items selected at the time of the event that caused the callback. 🚨 IMPORTANT bestie: this field points to temporary storage space that gets reused after the callback finishes. So if your app needs to keep that list, you must copy it into your own data space. Do not hold onto it. Not even for a sec.
  • selected_item_count — how many items are in the selected_items list. This number has to be positive or 0 (zero).
  • auto_selection_type — tells you the cause of the selection when XmNautomaticSelection is XmAUTO_SELECT. The valid values are, and I need you to focus:
    • XmAUTO_UNSET — returned when XmNautomaticSelection is XmNO_AUTO_SELECT.
    • XmAUTO_BEGIN — indicates the beginning of automatic selection.
    • XmAUTO_MOTION — indicates that there is a button drag selection.
    • XmAUTO_CANCEL — indicates that the new selection is canceled.
    • XmAUTO_NO_CHANGE — indicates that the currently selected item matches the initial item.
    • XmAUTO_CHANGE — indicates that the currently selected item does not match the initial item.

Next up: a pointer to this structure is passed to the XmNconvertCallback procedures. 🦋

typedef struct
{
        int reason;
        XEvent  *event;
        Atom selection;
        Atom target;
        XtPointer source_data;
        XtPointer location_data;
        int flags;
        XtPointer parm;
        int parm_format;
        unsigned long parm_length;
        int status;
        XtPointer value;
        Atom type;
        int format;
        unsigned long length;
} XmConvertCallbackStruct;
  • 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 conversion is being requested. Possible values are CLIPBOARD, PRIMARY, SECONDARY, and _MOTIF_DROP.
  • target — indicates the conversion target.
  • source_data — contains info about the selection source. When the selection is _MOTIF_DROP, source_data is the DragContext. Otherwise, it's NULL.
  • location_data — contains info about the location of data to be converted. If the value is NULL, the data being transferred is the widget's current selection. Otherwise, it's the widget ID of the item being transferred, or the widget ID of the Container if all items are being transferred.
  • flags — indicates the status of the conversion. Here are the possible values:
    • XmCONVERTING_NONE — this flag is currently unused. 💀
    • XmCONVERTING_PARTIAL — the target widget was able to be converted, but some data was lost. 😭
    • XmCONVERTING_SAME — the conversion target is the source of the data to be transferred.
    • XmCONVERTING_TRANSACT — this flag is currently unused. (unused flag count: 2, iconic behaviour honestly)
  • parm — contains parameter data for this target. If there's no parameter data, the value is NULL.

When selection is CLIPBOARD and target is _MOTIF_CLIPBOARD_TARGETS or _MOTIF_DEFERRED_CLIPBOARD_TARGETS, the value is the requested operation (XmCOPY, XmMOVE, or XmLINK).

  • parm_format — specifies whether the data in parm should be viewed as a list of char, short, or long quantities. Possible values are 0 (when parm is NULL), 8 (when the data in parm should be viewed as a list of chars), 16 (when the data in parm should be viewed as a list of shorts), or 32 (when the data in parm should be viewed as a list of longs).
⚠️ Okay this one trips people up so listen: parm_format symbolizes a data type, not the number of bits in each list element. For example, on some machines, a parm_format of 32 means that the data in parm should be viewed as a list of 64-bit quantities, not 32-bit quantities. ikykyk. 🤯
  • parm_length — the number of elements of data in parm, where each element has the size specified by parm_format. When parm is NULL, the value is 0.
  • status — an IN/OUT member that specifies the status of the conversion. Its initial value is XmCONVERT_DEFAULT. The callback procedure can set this member to one of the following values:
    • XmCONVERT_DEFAULT — the widget class conversion procedure, if any, is called after the callback procedures return. If the widget class conversion procedure produces any data, it overwrites the data provided by the callback procedures in the value member.
    • XmCONVERT_MERGE — the widget class conversion procedure, if any, is called after the callback procedures return. If the widget class conversion procedure produces any data, it appends its data to the data provided by the callback procedures in the value member. This value is intended for use with targets that result in lists of data, such as TARGETS.
    • XmCONVERT_DONE — the callback procedure has successfully finished the conversion. The widget class conversion procedure, if any, is not called after the callback procedures return.
    • XmCONVERT_REFUSE — the callback procedure has terminated the conversion process without completing the requested conversion. The widget class conversion procedure, if any, is not called after the callback procedures return.
  • value — an IN/OUT parameter that contains any data the callback procedure produces as a result of the conversion. Its initial value is NULL. If the callback procedure sets this member, it must make sure the type, format, and length members correspond to the data in value. And heads up: the callback procedure is responsible for allocating — but not for freeing — memory when it sets this member.
  • type — an IN/OUT parameter that indicates the type of the data in the value member. Its initial value is INTEGER.
  • format — an IN/OUT parameter that specifies whether the data in value should be viewed as a list of char, short, or long quantities. Its initial value is 8. The callback procedure can set this member to 8 (for a list of char), 16 (for a list of short), or 32 (for a list of long).
  • length — an IN/OUT member that specifies the number of elements of data in value, where each element has the size symbolized by format. Its initial value is 0 (zero).

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, possible values are XmMOVE, XmCOPY, and XmLINK.
    • When the selection is SECONDARY or 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 in the destination_data member.
  • flags — tells you whether the destination widget is also the source of the data being transferred. (Iconic little identity-crisis moment, we love it 💅.) Possible values:
    • XmCONVERTING_NONE — nope, the destination widget is not the source of the data being transferred.
    • XmCONVERTING_SAME — yep bestie, the destination widget is the source of the data being transferred.
  • transfer_id — serves as a unique ID that identifies the transfer transaction. Think of it as the transaction's little receipt number 🧾, iykyk.
  • destination_data — holds the deets about the destination. So:
    • 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 that got 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 — holds info about where the data is going to be transferred. This value is always NULL when the selection is SECONDARY or CLIPBOARD. If the value is NULL, the data gets inserted at the widget's cursor position. Otherwise the value is a pointer to an XPoint structure holding the x and y coordinates of the spot where the data is to be transferred. 🫶
Heads up: once XmTransferDone procedures start being called, location_data will no longer be stable. So don't be clingy with that pointer, bestie 😭.
  • time — indicates the time when the transfer operation began. ⏰

✨ Translations ✨

The XmContainer translations are listed below.

The following key names are listed in the X standard key event translation table syntax. This format is the one Motif uses to specify the widget actions that correspond to a given key. There's a brief overview of the format over in VirtualBindings(3). For the complete description of the format, please refer to the X Toolkit Instrinsics Documentation. 📚

  • ∼c ∼s ∼m ∼a <Btn1Down>: → ContainerBeginSelect()
  • <Btn1Motion>: → ContainerButtonMotion()
  • ∼c ∼s ∼m ∼a <Btn1Up>: → ContainerEndSelect()
  • c ∼s ∼m ∼a <Btn1Down>: → ContainerBeginToggle()
  • c ∼s ∼m ∼a <Btn1Up>: → ContainerEndToggle()
  • ∼c s ∼m ∼a <Btn1Down>: → ContainerBeginExtend()
  • ∼c s ∼m ∼a <Btn1Up>: → ContainerEndExtend()
  • c s ∼m ∼a <Btn1Down>: → ContainerBeginExtend()
  • c s ∼m ∼a <Btn1Up>: → ContainerEndExtend()
  • ∼c ∼s ∼m ∼a <Btn2Down>: → ContainerStartTransfer(Copy)
  • c s ∼m ∼a <Btn2Down>: → ContainerStartTransfer(Link)
  • ∼c s ∼m ∼a <Btn2Down>: → ContainerStartTransfer(Move)
  • ∼m ∼a <Btn2Up>: → ContainerEndTransfer()
  • :c s a <Key><osfInsert>: → ContainerPrimaryLink()
  • :c s m <Key><osfInsert>: → ContainerPrimaryLink()
  • :a <Key><osfInsert>: → ContainerPrimaryCopy()
  • :m <Key><osfInsert>: → ContainerPrimaryCopy()
  • :s a <Key><osfDelete>: → ContainerPrimaryMove()
  • :s m <Key><osfDelete>: → ContainerPrimaryMove()
  • :<Key><osfCancel>: → ContainerCancel()
  • :s <Key><osfSelect>: → ContainerExtend()
  • :<Key><osfSelect>: → ContainerSelect()
  • :<Key><osfSelectAll>: → ContainerSelectAll()
  • :<Key><osfDeselectAll>: → ContainerDeselectAll()
  • :<Key><osfAddMode>: → ContainerToggleMode()
  • :<Key><osfActivate>: → ContainerActivate()
  • s ∼c ∼m ∼a <Key>space: → ContainerExtend()
  • ∼s ∼c ∼m ∼a <Key>space: → ContainerSelect()
  • ∼s ∼c ∼m ∼a <Key>Return: → ContainerActivate()
  • ∼s c ∼m ∼a <Key>slash: → ContainerSelectAll()
  • ∼s c ∼m ∼a <Key>backslash: → ContainerDeselectAll()
  • :c s <Key><osfBeginLine>: → ContainerExtendCursor(First)
  • :c s <Key><osfEndLine>: → ContainerExtendCursor(Last)
  • :c <Key><osfBeginLine>: → ContainerMoveCursor(First)
  • :c <Key><osfEndLine>: → ContainerMoveCursor(Last)
  • :c <Key><osfLeft>: → ContainerExpandOrCollapse(Left)
  • :c <Key><osfRight>: → ContainerExpandOrCollapse(Right)
  • :s <Key><osfUp>: → ContainerExtendCursor(Up)
  • :s <Key><osfDown>: → ContainerExtendCursor(Down)
  • :s <Key><osfLeft>: → ContainerExtendCursor(Left)
  • :s <Key><osfRight>: → ContainerExtendCursor(Right)
  • :<Key><osfUp>: → ContainerMoveCursor(Up)
  • :<Key><osfDown>: → ContainerMoveCursor(Down)
  • :<Key><osfLeft>: → ContainerMoveCursor(Left)
  • :<Key><osfRight>: → ContainerMoveCursor(Right)
  • s ∼m ∼a <Key>Tab: → ManagerGadgetPrevTabGroup()
  • ∼s ∼m ∼a <Key>Tab: → ManagerGadgetNextTabGroup()

The Container button event translations get modified when Display's XmNenableBtn1Transfer resource does not have a value of XmOFF — in other words, when it's either XmBUTTON2_TRANSFER or XmBUTTON2_ADJUST. This option lets the actions for selection and transfer be integrated onto <Btn1>, and the actions for extending the selection can be bound to <Btn2>. 🌈

The actions for <Btn1> that are defined in the preceding list still apply when the <Btn1> event occurs over text that is not selected. The following actions apply when the <Btn1> event occurs over text that is selected:

  • ~c ~s ~m ~a <Btn1Down>: → ContainerHandleBtn1Down(ContainerBeginSelect,Copy)
  • c ~s ~m ~a <Btn1Down>: → ContainerHandleBtn1Down(ContainerBeginToggle,Copy)
  • c s ~m ~a <Btn1Down>: → ContainerHandleBtn1Down(ContainerNoop,Link)
  • ~c s ~m ~a <Btn1Down>: → ContainerHandleBtn1Down(ContainerBeginExtend,Move)
  • <Btn1Motion>: → ContainerHandleBtn1Motion(ContainerButtonMotion)
  • ~c ~s ~m ~a <Btn1Up>: → ContainerHandleBtn1Up(ContainerEndSelect)
  • c ~s ~m ~a <Btn1Up>: → ContainerHandleBtn1Up(ContainerEndToggle)
  • ~c s ~m ~a <Btn1Up>: → ContainerHandleBtn1Up(ContainerEndExtend)
  • c s ~m ~a <Btn1Down>: → ContainerHandleBtn1Down(ContainerBeginExtend)
  • c s ~m ~a <Btn1Up>: → ContainerHandleBtn1Up(ContainerEndExtend)

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

  • ~c ~s ~m ~a <Btn2Down>: → ContainerHandleBtn2Down(ContainerStartTransfer,Copy)
  • c s ~m ~a <Btn2Down>: → ContainerHandleBtn2Down(ContainerStartTransfer,Link)
  • ~c s ~m ~a <Btn2Down>: → ContainerHandleBtn2Down(ContainerStartTransfer,Move)
  • <Btn2Motion>: → ContainerHandleBtn2Motion(ContainerButtonMotion)
  • ~m ~a <Btn2Up>: → ContainerHandleBtn2Up(ContainerEndTransfer)

🎀 Action Routines 🎀

The Container action routines are described below. The current selections are always shown with the background color specified by the XmNselectColor resource. 👑

  • ContainerActivate(): — this action calls XmNdefaultActionCallback with reason XmCR_DEFAULT_ACTION.
  • ContainerBeginExtend(): — simply returns if XmNselectionPolicy is XmSINGLE_SELECT or XmBROWSE_SELECT. Also simply returns if XmNlayoutType is XmSPATIAL.

Otherwise, this action sets the selection state of all items between the anchor item and the item under the pointer to the selection state of the anchor item. The location cursor gets moved to the item under the pointer. And if XmNautomaticSelection is XmAUTO_SELECT, the XmNselectionCallback(s) is called with either XmCR_MULTIPLE_SELECT or XmCR_EXTENDED_SELECT as the reason, depending on XmNselectionPolicy, and with auto_selection_type set to XmAUTO_CHANGE.

  • ContainerBeginSelect(): — if this is a second ContainerBeginSelect() action that has occurred within the time specified by the display's multiclick time, this action calls XmNdefaultActionCallback with reason XmCR_DEFAULT_ACTION and returns. 🖱️

Otherwise, the processing depends on the value of XmNselectionPolicy, like so:

  • XmSINGLE_SELECT — this action deselects all items and toggles the item (if any) under the pointer.
  • XmBROWSE_SELECT — this action deselects all items and toggles the item (if any) under the pointer. That item is now the anchor item for further selection. If XmNautomaticSelection is XmAUTO_SELECT and a change in any item's selection state is made, the XmNselectionCallback(s) is called with reason XmCR_BROWSE_SELECT and auto_selection_type XmAUTO_BEGIN.
  • XmMULTIPLE_SELECT — if the pointer is over an item and XmNselectionTechnique is not XmMARQUEE, this action toggles the selection state of that item. The item becomes the anchor item for further selection. If XmNselectionTechnique is XmMARQUEE, XmMARQUEE_EXTEND_START, or XmMARQUEE_EXTEND_BOTH, this action sets the start point for the Marquee rectangle. If XmNselectionTechnique is XmMARQUEE_EXTEND_START or XmMARQUEE_EXTEND_BOTH and the pointer is over an item, this action draws the Marquee rectangle around the item. If XmNautomaticSelection is XmAUTO_SELECT, the XmNselectionCallback(s) is called with reason XmCR_MULTIPLE_SELECT and auto_selection_type XmAUTO_BEGIN.
  • XmEXTENDED_SELECT — all items are first deselected. Processing is then identical to the case where XmNselectionPolicy is XmMULTIPLE_SELECT, except that XmCR_EXTENDED_SELECT is the callback reason given if XmNselectionCallback is called.
  • ContainerBeginToggle(): — simply returns if XmNselectionPolicy is XmSINGLE_SELECT or XmBROWSE_SELECT.

Otherwise — like, if the pointer is hovering over an item and XmNselectionTechnique is not XmMARQUEE — this action toggles the selection state of that item. 🎀 That item now becomes the anchor item for whatever selection comes next. But if XmNselectionTechnique is XmMARQUEE, XmMARQUEE_EXTEND_START, or XmMARQUEE_EXTEND_BOTH, this action sets the start point for the Marquee rectangle instead. And if XmNselectionTechnique is XmMARQUEE_EXTEND_START or XmMARQUEE_EXTEND_BOTH and the pointer is over an item, this action draws the Marquee rectangle around that item. 🦋 And if XmNautomaticSelection is XmAUTO_SELECT, the XmNselectionCallback(s) get called with either XmCR_MULTIPLE_SELECT or XmCR_EXTENDED_SELECT as the reason (whichever one depends on XmNselectionPolicy), and with auto_selection_type set to XmAUTO_BEGIN.

  • ContainerButtonMotion() — bestie, what this does is entirely down to XmNselectionPolicy. Here's the breakdown:
    • XmSINGLE_SELECT — this action literally just returns to the caller. That's it, that's the whole vibe. 💀
    • XmBROWSE_SELECT — it simply returns if this action follows a ContainerBeginExtend() action or a ContainerBeginToggle() action. But if the pointer is no longer over the current anchor item, this action toggles the current anchor item, and then toggles the item under the pointer (if there even is one) and makes it the new anchor item for further processing. If XmNautomaticSelection is XmAUTO_SELECT and a change in any item's selection state actually got made, the XmNselectionCallback(s) is called with reason XmCR_BROWSE_SELECT and auto_selection_type XmAUTO_MOTION.
    • XmMULTIPLE_SELECT — if a previous action already set a Marquee rectangle start point, this action draws the Marquee rectangle between the current pointer position and the Marquee start point. If XmNselectionTechnique is XmMARQUEE_EXTEND_BOTH and the pointer is over an item, the end point of the Marquee rectangle gets extended to include that item. Then the selection states of all items inside the Marquee rectangle get toggled to match the state of the anchor item. ✨

If no Marquee rectangle start point is set and the pointer is over an item, what happens next depends on the XmNlayoutType resource. The anchor item from the previous action is what gets used. If XmNlayoutType is XmSPATIAL, the selection state of the item under the pointer gets toggled to match the selection state of the anchor item. If XmNlayoutType is XmOUTLINE or XmDETAIL, the selection state of all items between the anchor item and the item under the pointer get toggled to match the selection state of the anchor item.

If XmNautomaticSelection is XmAUTO_SELECT and a change in any item's selection state got made, the XmNselectionCallback(s) is called with reason XmCR_MULTIPLE_SELECT and auto_selection_type XmAUTO_MOTION.

  • XmEXTENDED_SELECT — processing here is identical to the XmNselectionPolicy is XmMULTIPLE_SELECT case, except that XmCR_EXTENDED_SELECT is the callback reason given if XmNselectionCallback gets called. 👑
  • ContainerCancel() — if a selection is in progress, this action restores the selection states of all items back to whatever they were before the selection began. Time travel but make it legal. 🧚 If XmNautomaticSelection is True and a change in any item's selection state is made, the XmNselectionCallback is called with reason XmCR_BROWSE_SELECT, XmMULTIPLE_SELECT, or XmCR_EXTENDED_SELECT — depending on the XmNselectionPolicy resource — and auto_selection_type XmAUTO_CANCEL.
  • ContainerDeselectAll() — deselects every single item, no survivors, and calls XmNselectionCallback with a reason depending on XmNselectionPolicy. 💅
  • ContainerEndExtend() — simply returns if XmNselectionPolicy is XmSINGLE_SELECT or XmBROWSE_SELECT. Also simply returns if XmNlayoutType is XmSPATIAL. Like, it's out, it's not doing this today.

Otherwise, if XmNautomaticSelection is XmNO_AUTO_SELECT, XmNselectionCallback(s) is called with either XmCR_MULTIPLE_SELECT or XmCR_EXTENDED_SELECT as the reason, depending on XmNselectionPolicy. If XmNautomaticSelection is XmAUTO_SELECT and no change is made in any item's selection state by this action, XmNselectionCallback(s) is called with either XmCR_MULTIPLE_SELECT or XmCR_EXTENDED_SELECT as the reason depending on XmNselectionPolicy, and auto_selection_type XmAUTO_CHANGE. And if XmNautomaticSelection is XmAUTO_SELECT and this action makes no change in any item's selection state, XmNselectionCallback(s) is called with either XmCR_MULTIPLE_SELECT or XmCR_EXTENDED_SELECT as the reason depending on XmNselectionPolicy, and auto_selection_type XmAUTO_NO_CHANGE.

  • ContainerEndSelect() — again, all about XmNselectionPolicy:
    • XmSINGLE_SELECT — this action calls XmNselectionCallback with reason XmCR_SINGLE_SELECT. Simple, clean, iconic. ✨
    • XmBROWSE_SELECT — if the pointer is no longer over the current anchor item, this action toggles the current anchor item, and then toggles the item under the pointer (if any). If XmNautomaticSelection is XmNO_AUTO_SELECT, the XmNselectionCallback(s) is called with reason XmCR_BROWSE_SELECT. If XmNautomaticSelection is XmAUTO_SELECT and a change in any item's selection state is made, XmNselectionCallback(s) is called with reason XmCR_BROWSE_SELECT and auto_selection_type XmAUTO_CHANGE. And if XmNautomaticSelection is XmAUTO_SELECT and no change is made in any item's selection state by this action, XmNselectionCallback(s) is called with reason XmCR_BROWSE_SELECT and auto_selection_type XmAUTO_NO_CHANGE.
    • XmMULTIPLE_SELECT — this action first performs the same processing as the ContainerButtonMotion() action, except that XmNselectionCallback does not get called. If XmNautomaticSelection is XmNO_AUTO_SELECT, the XmNselectionCallback(s) is called with reason XmCR_MULTIPLE_SELECT. If XmNautomaticSelection is XmAUTO_SELECT and a change in any item's selection state is made, the XmNselectionCallback(s) is called with reason XmCR_MULTIPLE_SELECT and auto_selection_type XmAUTO_CHANGE. And if XmNautomaticSelection is XmAUTO_SELECT and this action makes no change in any item's selection state, XmNselectionCallback(s) is called with reason XmCR_MULTIPLE_SELECT and auto_selection_type XmAUTO_NO_CHANGE.
    • XmEXTENDED_SELECT — this action first performs the same processing as the ContainerButtonMotion() action, except that XmNselectionCallback is not called. If XmNautomaticSelection is XmNO_AUTO_SELECT, the XmNselectionCallback(s) is called with reason XmCR_EXTENDED_SELECT. If XmNautomaticSelection is XmAUTO_SELECT and a change in any item's selection state is made, XmNselectionCallback(s) is called with reason XmCR_EXTENDED_SELECT and auto_selection_type XmAUTO_CHANGE. And if XmNautomaticSelection is XmAUTO_SELECT and this action makes no change in any item's selection state, XmNselectionCallback(s) is called with reason XmCR_EXTENDED_SELECT and auto_selection_type XmAUTO_NO_CHANGE.
  • ContainerEndToggle() — simply returns if XmNselectionPolicy is XmSINGLE_SELECT or XmBROWSE_SELECT. But if XmNselectionPolicy is XmMULTIPLE_SELECT or XmEXTENDED_SELECT, this action performs the exact same processing as the ContainerEndSelect() action. Copy-paste energy, but on purpose. 🫶
  • ContainerEndTransfer():: — if the elapsed time since a ContainerStartTransfer() action happened exceeds the time span specified by the display's multiclick time, this action just returns. Otherwise, the ContainerPrimaryCopy(), ContainerPrimaryLink(), or ContainerPrimaryMove() action gets invoked, depending on the value of the operation parameter that ContainerStartTransfer() saved. 🍓
  • ContainerExpandOrCollapse(Left|Right|Collapse|Expand) — this action changes the value of the XmNoutlineState of the current focus widget. If the argument value is Collapse or Left, the XmNoutlineState resource value is set to XmCOLLAPSED. If the argument value is Expand or Right, the XmNoutlineState resource value is set to XmEXPANDED. 🌸

If the argument is Left or Right and the layout is right to left, then the setting of the XmNoutlineState value is reversed from what the preceding paragraph just said. Yes, really. 🙈

And it simply returns if XmNlayoutType is XmSPATIAL.

  • ContainerExtend() — yep, XmNselectionPolicy again, bestie:

If the selection policy is XmSINGLE_SELECT or XmBROWSE_SELECT, this action returns. If XmNlayoutType is XmSPATIAL, this action returns.

If the selection policy is XmMULTIPLE_SELECT, this action sets the selection state of all items between the anchor item and the location cursor to the selection state of the anchor item. 💜

so if the selection policy is XmEXTENDED_SELECT and the Container is in Normal Mode, this action deselects all items and selects all items between the anchor item and the location cursor. If the selection policy is XmEXTENDED_SELECT and the Container is in Add Mode, this action sets the selection state of all items between the anchor item and the location cursor to the selection state of the anchor item.

XmNselectionCallback is called with reason XmCR_MULTIPLE_SELECT or XmCR_EXTENDED_SELECT depending on XmNselectionPolicy.

okay bestie, here's the rest of the action lore, no cap:

  • ContainerExtendCursor(Left|Right|Up|Down): — Processing depends on the value of XmNselectionPolicy, as follows:
    • If the selection policy is XmSINGLE_SELECT or XmBROWSE_SELECT, this action returns. If XmNlayoutType is XmSPATIAL, this action returns.
    • This action moves the location cursor one item in the indicated direction, if possible. If the value of the argument string is First or Last, this action moves the location cursor to the indicated item. For other values of the argument string, the location cursor is not affected.
    • If the selection policy is XmMULTIPLE_SELECT, this action sets the selection state of all items between the anchor item and the location cursor to the selection state of the anchor item.
    • If the selection policy is XmEXTENDED_SELECT and the Container is in Normal Mode, this action deselects all items and selects all items between the anchor item and the location cursor. If the selection policy is XmEXTENDED_SELECT and the Container is in Add Mode, this action sets the selection state of all items between the anchor item and the location cursor to the selection state of the anchor item.
    • XmNselectionCallback is called with reason XmCR_MULTIPLE_SELECT or XmCR_EXTENDED_SELECT depending on XmNselectionPolicy.
  • ContainerHandleBtn1Down(string) — When Display's XmNenableBtn1Transfer resource is not XmOFF, the actions for selection and transfer are integrated on <Btn1>. If the pointer is over an unselected item or background, the item is first selected before the transfer is started. Otherwise, if the item is already selected, the transfer is started. The value of string can be one of the following actions:
    • ContainerBeginSelect,Copy
    • ContainerBeginToggle,Copy
    • ContainerNoop,Link
    • ContainerBeginExtend,Move
  • ContainerHandleBtn1Motion(string) — When Display's XmNenableBtn1Transfer resource is not XmOFF, the actions for selection and transfer are integrated on <Btn1>. When this action is invoked, and a selection is in progress, a drag is performed. Otherwise, the default action as specified in string is performed. The value of string can be ContainerButtonMotion.
  • ContainerHandleBtn1Up(string) — If a Button 1 transfer was in progress, then when this action is invoked, that transfer is cancelled. Otherwise, the default action as specified in string is performed. The value of string can be one of the following actions:
    • ContainerEndSelect
    • ContainerEndToggle
    • ContainerEndExtend
  • ContainerHandleBtn2Down(string) — When Display's XmNenableBtn1Transfer resource has a value of XmBUTTON2_ADJUST, the actions for extending selection are bound on <Btn2>. Otherwise, the action that is performed depends on the value of string, which can be one of the following actions:
    • ContainerStartTransfer,Copy
    • ContainerStartTransfer,Link
    • ContainerStartTransfer,Move
  • ContainerHandleBtn2Motion(string) — When Display's XmNenableBtn1Transfer resource is not XmBUTTON2_ADJUST, and a selection is in progress, a drag is performed. Otherwise, the default action that is performed depends on the value of string, which can be ContainerButtonMotion.
  • ContainerHandleBtn2Up(string) — When Display's XmNenableBtn1Transfer resource has a value of XmBUTTON2_ADJUST, this action ends an extend. Otherwise, the action that is performed depends on the value of string, which can be ContainerEndTransfer.
  • ContainerMoveCursor(Left|Right|Up|Down|First|Last): — If the argument is Left, Right, Up, or Down, this action moves the location cursor one item in the indicated direction, if possible. If the value of the argument string is First or Last, this action moves the location cursor to the indicated item. Any other arguments are ignored.
    • If XmNselectionPolicy is XmBROWSE_SELECT, or if XmNselectionPolicy is XmEXTENDED_SELECT and the Container is in Normal Mode, this action deselects all items, selects the item at the location cursor, and calls XmNselectionCallback with the reason depending on XmNselectionPolicy.
  • ContainerPrimaryCopy(): — This action requests that primary selection data be copied to the Container. This action calls the XmNdestinationCallback procedures for the PRIMARY selection and the XmCOPY operation. By default, the Container does not do any transfer, and copying the selection is the responsibility of the XmNdestinationCallback procedures.
  • ContainerPrimaryLink(): — This action requests that primary selection data be linked to the Container. This action calls the XmNdestinationCallback procedures for the PRIMARY selection and the XmLINK operation. By default, the Container does not do any transfer, and linking the selection is the responsibility of the XmNdestinationCallback procedures.
  • ContainerPrimaryMove(): — This action requests that primary selection data be copied to the Container and deleted from the primary source. This action calls the XmNdestinationCallback procedures for the PRIMARY selection and the XmMOVE operation. By default, the Container does not do any transfer, and moving the selection is the responsibility of the XmNdestinationCallback procedures. If the transfer is successful, this action then calls the selection owner's XmNconvertCallback procedures for the PRIMARY selection and the DELETE target.
  • ContainerSelect(): — Processing depends on the value of XmNselectionPolicy, as follows:
    • If the selection policy is XmSINGLE_SELECT or XmBROWSE_SELECT, this action deselects all items and selects the item at the location cursor.
    • If the selection policy is XmMULTIPLE_SELECT, this action toggles the selection state of the item at the location cursor. This item becomes the anchor item for further selections.
    • If the selection policy is XmEXTENDED_SELECT and the Container is in Normal Mode, this action deselects all items and selects the item at the location cursor. If the selection policy is XmEXTENDED_SELECT and the Container is in Add Mode, this action toggles the selection state of the item at the location cursor. The selected/toggled item becomes the anchor item for further selections.
    • XmNselectionCallback is called with the reason depending on XmNselectionPolicy.
  • ContainerSelectAll(): — If XmNselectionPolicy is XmSINGLE_SELECT or XmBROWSE_SELECT, this action deselects all items and selects the item at the location cursor position.
    • If XmNselectionPolicy is XmMULTIPLE_SELECT or XmEXTENDED_SELECT, this action selects all items.
    • XmNselectionCallback is called with the reason depending on the value of XmNselectionCallback.
  • ContainerStartTransfer(Copy|Move|Link): — This action saves the event and the operation specified in the argument string for use by subsequent actions. If no ContainerEndTransfer() actions occur within the time span specified by the display's multiclick time and if XmNlayoutType is XmSPATIAL, this action creates a DragContext and starts a drag transfer by using string to specify the transfer operation. If no argument string is specified, Copy is the default value.
    • Unless default drag and drop behavior has been overridden by a XmNconvertCallback procedure, if the drop operation occurs within the Container, then the item(s) being dragged are relocated at the position of the drop operation. If the item targeted by the Drag operation is not in the selected state, then only that item is moved. If the item is in the selected state, however, all items in the selected state are moved.
  • ContainerToggleMode(): — If XmNselectionPolicy is XmEXTENDED_SELECT, this action toggles the Container between Normal Mode and Add Mode.

✨ Additional Behavior ✨

The Container widget has the following additional behavior:

  • <Btn1Down>(2+) — If a button click is followed by another button click within the time span specified by the display's multiclick time, the Container interprets that as a double-click and calls the XmNdefaultActionCallback callbacks.
  • <FocusIn>: — If the focus policy is explicit, sets the focus and draws the location cursor.
  • <FocusOut>: — If the focus policy is explicit, removes the focus and erases the location cursor.

🦋 Virtual Bindings 🦋

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

Source/version: XmContainer(library call) — and the date? The original footer didn't show one, but it's giving timeless icon behavior, bestie. 💅✨

📦 where this page comes from