1403 lines
43 KiB
XML
1403 lines
43 KiB
XML
<?xml version="1.0" encoding="UTF-8" ?>
|
|
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN" "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd">
|
|
|
|
<chapter id='Composite_Widgets_and_Their_Children'>
|
|
<title>Composite Widgets and Their Children</title>
|
|
<para>
|
|
Composite widgets (widgets whose class is a subclass of
|
|
<function>compositeWidgetClass</function>)
|
|
can have an arbitrary number of children.
|
|
Consequently, they are responsible for much more than primitive widgets.
|
|
Their responsibilities (either implemented directly by the widget class
|
|
or indirectly by Intrinsics functions) include:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
Overall management of children from creation to destruction.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Destruction of descendants when the composite widget is destroyed.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Physical arrangement (geometry management) of a displayable subset of
|
|
children (that is, the managed children).
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Mapping and unmapping of a subset of the managed children.
|
|
</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
<para>
|
|
Overall management is handled by the generic procedures
|
|
<xref linkend='XtCreateWidget' xrefstyle='select: title'/>
|
|
and
|
|
<xref linkend='XtDestroyWidget' xrefstyle='select: title'/>.
|
|
<xref linkend='XtCreateWidget' xrefstyle='select: title'/>
|
|
adds children to their parent by calling the parent's insert_child
|
|
procedure.
|
|
<xref linkend='XtDestroyWidget' xrefstyle='select: title'/>
|
|
removes children from their parent by calling the parent's delete_child
|
|
procedure and ensures that all children of a destroyed composite widget
|
|
also get destroyed.
|
|
</para>
|
|
|
|
<para>
|
|
Only a subset of the total number of children is actually managed by
|
|
the geometry manager and hence possibly visible.
|
|
For example, a composite editor widget
|
|
supporting multiple editing buffers might allocate one child
|
|
widget for each file buffer,
|
|
but it might display only a small number of the existing buffers.
|
|
Widgets that are in this displayable subset are called managed widgets
|
|
and enter into geometry manager calculations.
|
|
The other children are called unmanaged widgets
|
|
and, by definition, are not mapped by the Intrinsics.
|
|
</para>
|
|
|
|
<para>
|
|
Children are added to and removed from their parent's managed set by using
|
|
<xref linkend='XtManageChild' xrefstyle='select: title'/>,
|
|
<xref linkend='XtManageChildren' xrefstyle='select: title'/>,
|
|
<xref linkend='XtUnmanageChild' xrefstyle='select: title'/>,
|
|
<xref linkend='XtUnmanageChildren' xrefstyle='select: title'/>,
|
|
and
|
|
<xref linkend='XtChangeManagedSet' xrefstyle='select: title'/>,
|
|
which notify the parent to recalculate the physical layout of its children
|
|
by calling the parent's change_managed procedure.
|
|
The
|
|
<xref linkend='XtCreateManagedWidget' xrefstyle='select: title'/>
|
|
convenience function calls
|
|
<xref linkend='XtCreateWidget' xrefstyle='select: title'/>
|
|
and
|
|
<xref linkend='XtManageChild' xrefstyle='select: title'/>
|
|
on the result.
|
|
</para>
|
|
|
|
<para>
|
|
Most managed children are mapped,
|
|
but some widgets can be in a state where they take up physical space
|
|
but do not show anything.
|
|
Managed widgets are not mapped automatically
|
|
if their <emphasis remap='I'>map_when_managed</emphasis> field is
|
|
<function>False</function>.
|
|
The default is
|
|
<function>True</function>
|
|
and is changed by using
|
|
<xref linkend='XtSetMappedWhenManaged' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<para>
|
|
Each composite widget class declares a geometry manager,
|
|
which is responsible for figuring out where the managed children
|
|
should appear within the composite widget's window.
|
|
Geometry management techniques fall into four classes:
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>Fixed boxes</term>
|
|
<listitem>
|
|
<para>
|
|
Fixed boxes have a fixed number of children created by the parent.
|
|
All these children are managed,
|
|
and none ever makes geometry manager requests.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>Homogeneous boxes</term>
|
|
<listitem>
|
|
<para>
|
|
Homogeneous boxes treat all children equally and apply the same geometry
|
|
constraints to each child.
|
|
Many clients insert and delete widgets freely.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>Heterogeneous boxes</term>
|
|
<listitem>
|
|
<para>
|
|
Heterogeneous boxes have a specific location where each child is placed.
|
|
This location usually is not specified in pixels,
|
|
because the window may be resized, but is expressed rather
|
|
in terms of the relationship between a child
|
|
and the parent or between the child and other specific children.
|
|
The class of heterogeneous boxes is usually a subclass of
|
|
Constraint.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>Shell boxes</term>
|
|
<listitem>
|
|
<para>
|
|
Shell boxes typically have only one child,
|
|
and the child's size is usually
|
|
exactly the size of the shell.
|
|
The geometry manager must communicate with the window manager, if it exists,
|
|
and the box must also accept
|
|
<function>ConfigureNotify</function>
|
|
events when the window size is changed by the window manager.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
</para>
|
|
<sect1 id="Addition_of_Children_to_a_Composite_Widget_The_insert_child_Procedure">
|
|
<title>Addition of Children to a Composite Widget: The insert_child Procedure</title>
|
|
<para>
|
|
To add a child to
|
|
the parent's list of children, the
|
|
<xref linkend='XtCreateWidget' xrefstyle='select: title'/>
|
|
function calls the parent's class routine insert_child.
|
|
The insert_child procedure pointer in a composite widget is of type
|
|
<xref linkend='XtWidgetProc' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtWidgetProc_2'>
|
|
<funcprototype>
|
|
<funcdef>typedef void <function>(*XtWidgetProc)</function></funcdef>
|
|
<paramdef>Widget <parameter>w</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>w</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the newly created child.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
Most composite widgets inherit their superclass's operation.
|
|
The insert_child routine in
|
|
<function>CompositeWidgetClass calls the insert_position procedure</function>
|
|
and inserts the child at the specified position
|
|
in the <emphasis remap='I'>children</emphasis> list, expanding it if necessary.
|
|
</para>
|
|
|
|
<para>
|
|
Some composite widgets define their own insert_child routine
|
|
so that they can order their children in some convenient way,
|
|
create companion controller widgets for a new widget,
|
|
or limit the number or class of their child widgets.
|
|
A composite widget class that wishes
|
|
to allow nonwidget children (see <xref linkend='Nonwidget_Objects' />) must specify a
|
|
<function>CompositeClassExtension</function>
|
|
extension record as described
|
|
in <xref linkend='CompositeClassPart_Structure' />
|
|
and set the <emphasis remap='I'>accepts_objects</emphasis> field in this record to
|
|
<function>True</function>.
|
|
If the
|
|
<function>CompositeClassExtension</function>
|
|
record is not specified or the
|
|
<emphasis remap='I'>accepts_objects</emphasis> field is
|
|
<function>False</function>,
|
|
the composite widget can assume that all its children are of a subclass of Core
|
|
without an explicit subclass test in the insert_child procedure.
|
|
</para>
|
|
|
|
<para>
|
|
If there is not enough room to insert a new child in the <emphasis remap='I'>children</emphasis> array
|
|
(that is, <emphasis remap='I'>num_children</emphasis> is equal to <emphasis remap='I'>num_slots</emphasis>),
|
|
the insert_child procedure must first reallocate the array
|
|
and update <emphasis remap='I'>num_slots</emphasis>.
|
|
The insert_child procedure then places the child at the appropriate position
|
|
in the array and increments the <emphasis remap='I'>num_children</emphasis> field.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1 id="Insertion_Order_of_Children_The_insert_position_Procedure">
|
|
<title>Insertion Order of Children: The insert_position Procedure</title>
|
|
<para>
|
|
Instances of composite widgets sometimes need to specify more about the order in which
|
|
their children are kept.
|
|
For example,
|
|
an application may want a set of command buttons in some logical order
|
|
grouped by function,
|
|
and it may want buttons that represent file names to be kept
|
|
in alphabetical order without constraining the order in which the
|
|
buttons are created.
|
|
</para>
|
|
|
|
<para>
|
|
An application controls the presentation order of a set of children by
|
|
supplying an
|
|
XtNinsertPosition
|
|
resource.
|
|
The insert_position procedure pointer in a composite widget instance is of type
|
|
<xref linkend='XtOrderProc' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtOrderProc'>
|
|
<funcprototype>
|
|
<funcdef>typedef Cardinal <function>(*XtOrderProc)</function></funcdef>
|
|
|
|
<paramdef>Widget <parameter>w</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>w</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the newly created widget.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
Composite widgets that allow clients to order their children (usually
|
|
homogeneous boxes) can call their widget instance's insert_position
|
|
procedure from the class's insert_child procedure to determine where a new
|
|
child should go in its <emphasis remap='I'>children</emphasis> array.
|
|
Thus, a client using a composite class can apply different sorting criteria
|
|
to widget instances of the class, passing in a different insert_position
|
|
procedure resource when it creates each composite widget instance.
|
|
</para>
|
|
|
|
<para>
|
|
The return value of the insert_position procedure
|
|
indicates how many children should go before the widget.
|
|
Returning zero indicates that the widget should go before all other children,
|
|
and returning <emphasis remap='I'>num_children</emphasis> indicates that it should go after all other children.
|
|
The default insert_position function returns <emphasis remap='I'>num_children</emphasis>
|
|
and can be overridden by a specific composite widget's resource list
|
|
or by the argument list provided when the composite widget is created.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1 id="Deletion_of_Children_The_delete_child_Procedure">
|
|
<title>Deletion of Children: The delete_child Procedure</title>
|
|
|
|
<para>
|
|
To remove the child from the parent's <emphasis remap='I'>children</emphasis> list, the
|
|
<xref linkend='XtDestroyWidget' xrefstyle='select: title'/>
|
|
function eventually causes a call to the Composite parent's class delete_child
|
|
procedure.
|
|
The delete_child procedure pointer is of type
|
|
<xref linkend='XtWidgetProc' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='_XtWidgetProc'>
|
|
<funcprototype>
|
|
<funcdef>typedef void <function>(*XtWidgetProc)</function></funcdef>
|
|
<paramdef>Widget <parameter>w</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>w</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the child being deleted.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
|
|
<para>
|
|
Most widgets inherit the delete_child procedure from their superclass.
|
|
Composite widgets that create companion widgets define their own
|
|
delete_child procedure to remove these companion widgets.
|
|
</para>
|
|
</sect1>
|
|
|
|
<sect1 id="Adding_and_Removing_Children_from_the_Managed_Set">
|
|
<title>Adding and Removing Children from the Managed Set</title>
|
|
<para>
|
|
The Intrinsics provide a set of generic routines to permit the addition of
|
|
widgets to or the removal of widgets from a composite widget's managed set.
|
|
These generic routines eventually call the composite widget's change_managed
|
|
procedure if the procedure pointer is non-NULL.
|
|
The change_managed procedure pointer is of type
|
|
<xref linkend='XtWidgetProc' xrefstyle='select: title'/>.
|
|
The widget argument specifies the composite widget whose managed child
|
|
set has been modified.
|
|
</para>
|
|
|
|
<sect2 id="Managing_Children">
|
|
<title>Managing Children</title>
|
|
<para>
|
|
To add a list of widgets to the geometry-managed (and hence displayable)
|
|
subset of their Composite parent, use
|
|
<xref linkend='XtManageChildren' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<para>typedef Widget *WidgetList;</para>
|
|
|
|
<funcsynopsis id='XtManageChildren'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtManageChildren</function></funcdef>
|
|
<paramdef>WidgetList <parameter>children</parameter></paramdef>
|
|
<paramdef>Cardinal <parameter>num_children</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies a list of child widgets. Each child must be of class
|
|
RectObj or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>num_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the number of children in the list.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtManageChildren' xrefstyle='select: title'/>
|
|
function performs the following:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
Issues an error if the children do not all have the same parent or
|
|
if the parent's class is not a subclass of
|
|
<function>compositeWidgetClass</function>.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Returns immediately if the common parent is being destroyed;
|
|
otherwise, for each unique child on the list,
|
|
<xref linkend='XtManageChildren' xrefstyle='select: title'/>
|
|
ignores the child if it already is managed or is being destroyed,
|
|
and marks it if not.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
If the parent is realized and after all children have been marked,
|
|
it makes some of the newly managed children viewable:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
Calls the change_managed routine of the widgets' parent.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Calls
|
|
<xref linkend='XtRealizeWidget' xrefstyle='select: title'/>
|
|
on each previously unmanaged child that is unrealized.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Maps each previously unmanaged child that has <emphasis remap='I'>map_when_managed</emphasis>
|
|
<function>True</function>.
|
|
</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
</listitem>
|
|
</itemizedlist>
|
|
<para>
|
|
Managing children is independent of the ordering of children and
|
|
independent of creating and deleting children.
|
|
The layout routine of the parent
|
|
should consider children whose <emphasis remap='I'>managed</emphasis> field is
|
|
<function>True</function>
|
|
and should ignore all other children.
|
|
Note that some composite widgets, especially fixed boxes, call
|
|
<xref linkend='XtManageChild' xrefstyle='select: title'/>
|
|
from their insert_child procedure.
|
|
</para>
|
|
|
|
<para>
|
|
If the parent widget is realized,
|
|
its change_managed procedure is called to notify it
|
|
that its set of managed children has changed.
|
|
The parent can reposition and resize any of its children.
|
|
It moves each child as needed by calling
|
|
<xref linkend='XtMoveWidget' xrefstyle='select: title'/>,
|
|
which first updates the <emphasis remap='I'>x</emphasis> and <emphasis remap='I'>y</emphasis> fields and which then calls
|
|
<function>XMoveWindow</function>.
|
|
</para>
|
|
|
|
<para>
|
|
If the composite widget wishes to change the size or border width of any of
|
|
its children, it calls
|
|
<xref linkend='XtResizeWidget' xrefstyle='select: title'/>,
|
|
which first updates the
|
|
<emphasis remap='I'>width</emphasis>, <emphasis remap='I'>height</emphasis>, and <emphasis remap='I'>border_width</emphasis>
|
|
fields and then calls
|
|
<function>XConfigureWindow</function>.
|
|
Simultaneous repositioning and resizing may be done with
|
|
<xref linkend='XtConfigureWidget' xrefstyle='select: title'/>;
|
|
see <xref linkend='Widget_Placement_and_Sizing' />.
|
|
</para>
|
|
|
|
<para>
|
|
To add a single child to its parent widget's set of managed children, use
|
|
<xref linkend='XtManageChild' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtManageChild'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtManageChild</function></funcdef>
|
|
<paramdef>Widget <parameter>child</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>child</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the child. Must be of class RectObj or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtManageChild' xrefstyle='select: title'/>
|
|
function constructs a
|
|
<function>WidgetList</function>
|
|
of length 1 and calls
|
|
<xref linkend='XtManageChildren' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<para>
|
|
To create and manage a child widget in a single procedure, use
|
|
<xref linkend='XtCreateManagedWidget' xrefstyle='select: title'/>
|
|
or
|
|
<xref linkend='XtVaCreateManagedWidget' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtCreateManagedWidget'>
|
|
<funcprototype>
|
|
<funcdef>Widget <function>XtCreateManagedWidget</function></funcdef>
|
|
<paramdef>const char * <parameter>name</parameter></paramdef>
|
|
<paramdef>WidgetClass <parameter>widget_class</parameter></paramdef>
|
|
<paramdef>Widget <parameter>parent</parameter></paramdef>
|
|
<paramdef>ArgList <parameter>args</parameter></paramdef>
|
|
<paramdef>Cardinal <parameter>num_args</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>name</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the resource instance name for the created widget.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>widget_class</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the widget class pointer for the created widget. (rC
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>parent</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the parent widget. Must be of class Composite or any
|
|
subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>args</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the argument list to override any other resource specifications.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>num_args</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the number of entries in the argument list.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtCreateManagedWidget' xrefstyle='select: title'/>
|
|
function is a convenience routine that calls
|
|
<xref linkend='XtCreateWidget' xrefstyle='select: title'/>
|
|
and
|
|
<xref linkend='XtManageChild' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtVaCreateManagedWidget'>
|
|
<funcprototype>
|
|
<funcdef>Widget <function>XtVaCreateManagedWidget</function></funcdef>
|
|
<paramdef>const char * <parameter>name</parameter></paramdef>
|
|
<paramdef>WidgetClass <parameter>widget_class</parameter></paramdef>
|
|
<paramdef>Widget <parameter>parent</parameter></paramdef>
|
|
<paramdef>...</paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>name</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the resource instance name for the created widget.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>widget_class</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the widget class pointer for the created widget. (rC
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>parent</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the parent widget. Must be of class Composite or any
|
|
subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
...
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the variable argument list to override any other
|
|
resource specifications.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
<xref linkend='XtVaCreateManagedWidget' xrefstyle='select: title'/>
|
|
is identical in function to
|
|
<xref linkend='XtCreateManagedWidget' xrefstyle='select: title'/>
|
|
with the <emphasis remap='I'>args</emphasis> and <emphasis remap='I'>num_args</emphasis> parameters replaced
|
|
by a varargs list, as described in Section 2.5.1.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2 id="Unmanaging_Children">
|
|
<title>Unmanaging Children</title>
|
|
<para>
|
|
To remove a list of children from a parent widget's managed list, use
|
|
<xref linkend='XtUnmanageChildren' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtUnmanageChildren'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtUnmanageChildren</function></funcdef>
|
|
<paramdef>WidgetList <parameter>children</parameter></paramdef>
|
|
<paramdef>Cardinal <parameter>num_children</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies a list of child widgets. Each child must be of class
|
|
RectObj or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>num_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the number of children.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtUnmanageChildren' xrefstyle='select: title'/>
|
|
function performs the following:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
Returns immediately if the common parent is being destroyed.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Issues an error if the children do not all have the same parent
|
|
or if the parent is not a subclass of
|
|
<function>compositeWidgetClass</function>.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
For each unique child on the list,
|
|
<xref linkend='XtUnmanageChildren' xrefstyle='select: title'/>
|
|
ignores the child if it is unmanaged; otherwise it performs the following:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
Marks the child as unmanaged.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
If the child is realized and the <emphasis remap='I'>map_when_managed</emphasis> field is
|
|
<function>True</function>,
|
|
it is unmapped.
|
|
</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
If the parent is realized and if any children have become unmanaged,
|
|
calls the change_managed routine of the widgets' parent.
|
|
</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
<para>
|
|
<xref linkend='XtUnmanageChildren' xrefstyle='select: title'/>
|
|
does not destroy the child widgets.
|
|
Removing widgets from a parent's managed set is often a temporary banishment,
|
|
and some time later the client may manage the children again.
|
|
To destroy widgets entirely,
|
|
<xref linkend='XtDestroyWidget' xrefstyle='select: title'/>
|
|
should be called instead;
|
|
see <xref linkend='Exiting_from_an_Application' />.
|
|
</para>
|
|
|
|
<para>
|
|
To remove a single child from its parent widget's managed set, use
|
|
<xref linkend='XtUnmanageChild' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtUnmanageChild'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtUnmanageChild</function></funcdef>
|
|
<paramdef>Widget <parameter>child</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>child</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the child. Must be of class RectObj or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtUnmanageChild' xrefstyle='select: title'/>
|
|
function constructs a widget list
|
|
of length 1 and calls
|
|
<xref linkend='XtUnmanageChildren' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<para>
|
|
These functions are low-level routines that are used by generic
|
|
composite widget building routines.
|
|
In addition, composite widgets can provide widget-specific,
|
|
high-level convenience procedures.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2 id="Bundling_Changes_to_the_Managed_Set">
|
|
<title>Bundling Changes to the Managed Set</title>
|
|
<para>
|
|
A client may simultaneously unmanage and manage children
|
|
with a single call to the Intrinsics. In this same call the
|
|
client may provide a callback procedure that can modify the
|
|
geometries of one or more children. The composite widget class
|
|
defines whether this single client call results in separate invocations
|
|
of the change_managed method, one to unmanage and the other to
|
|
manage, or in just a single invocation.
|
|
</para>
|
|
|
|
<para>
|
|
To simultaneously remove from and add to the geometry-managed
|
|
set of children of a composite parent, use
|
|
<xref linkend='XtChangeManagedSet' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtChangeManagedSet'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtChangeManagedSet</function></funcdef>
|
|
<paramdef>WidgetList <parameter>unmanage_children</parameter></paramdef>
|
|
<paramdef>Cardinal <parameter>num_unmanage_children</parameter></paramdef>
|
|
<paramdef>XtDoChangeProc <parameter>do_change_proc</parameter></paramdef>
|
|
<paramdef>XtPointer <parameter>client_data</parameter></paramdef>
|
|
<paramdef>WidgetList <parameter>manage_children</parameter></paramdef>
|
|
<paramdef>Cardinal <parameter>num_manage_children</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>unmanage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the list of widget children to initially remove from the managed set.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>num_unmanage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the number of entries in the <emphasis remap='I'>unmanage_children</emphasis> list.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>do_change_proc</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies a procedure to invoke between unmanaging
|
|
and managing the children, or NULL.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>client_data</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies client data to be passed to the do_change_proc.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>manage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the list of widget children to finally add to the managed set.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>num_manage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the number of entries in the <emphasis remap='I'>manage_children</emphasis> list.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtChangeManagedSet' xrefstyle='select: title'/>
|
|
function performs the following:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
Returns immediately if <emphasis remap='I'>num_unmanage_children</emphasis> and
|
|
<emphasis remap='I'>num_manage_children</emphasis> are both 0.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Issues a warning and returns if the widgets specified in the
|
|
<emphasis remap='I'>manage_children</emphasis> and
|
|
the <emphasis remap='I'>unmanage_children</emphasis> lists do not all have the same parent or if
|
|
that parent is not a subclass of
|
|
<function>compositeWidgetClass</function>.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Returns immediately if the common parent is being destroyed.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
If <emphasis remap='I'>do_change_proc</emphasis> is not NULL and the parent's
|
|
<function>CompositeClassExtension</function>
|
|
<emphasis remap='I'>allows_change_managed_set</emphasis> field is
|
|
<function>False</function>,
|
|
then
|
|
<xref linkend='XtChangeManagedSet' xrefstyle='select: title'/>
|
|
performs the following:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
Calls
|
|
<xref linkend='XtUnmanageChildren' xrefstyle='select: title'/>
|
|
(<emphasis remap='I'>unmanage_children</emphasis>, <emphasis remap='I'>num_unmanage_children</emphasis>).
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Calls the <emphasis remap='I'>do_change_proc</emphasis>.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Calls
|
|
<xref linkend='XtManageChildren' xrefstyle='select: title'/>
|
|
(<emphasis remap='I'>manage_children</emphasis>, <emphasis remap='I'>num_manage_children</emphasis>).
|
|
</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
Otherwise, the following is performed:
|
|
</para>
|
|
<itemizedlist spacing='compact'>
|
|
<listitem>
|
|
<para>
|
|
For each child on the <emphasis remap='I'>unmanage_children</emphasis> list; if the child is
|
|
already unmanaged it is ignored, otherwise it is marked as unmanaged,
|
|
and if it is realized and its <emphasis remap='I'>map_when_managed</emphasis> field is
|
|
<function>True</function>,
|
|
it is unmapped.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
If <emphasis remap='I'>do_change_proc</emphasis> is non-NULL, the procedure is invoked.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
For each child on the <emphasis remap='I'>manage_children</emphasis> list; if the child is already
|
|
managed or is being destroyed, it is ignored; otherwise it is
|
|
marked as managed.
|
|
</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>
|
|
If the parent is realized and after all children have been marked,
|
|
the change_managed method of the parent is invoked, and subsequently
|
|
some of the newly managed children are made viewable by calling
|
|
<xref linkend='XtRealizeWidget' xrefstyle='select: title'/>
|
|
on each previously unmanaged child that is unrealized and
|
|
mapping each previously unmanaged child that has <emphasis remap='I'>map_when_managed</emphasis>
|
|
<function>True</function>.
|
|
</para>
|
|
</listitem>
|
|
</itemizedlist>
|
|
</listitem>
|
|
</itemizedlist>
|
|
<para>
|
|
If no
|
|
<function>CompositeClassExtension</function>
|
|
record is found in the parent's composite class part <emphasis remap='I'>extension</emphasis> field
|
|
with record type
|
|
<emphasis role='strong'>NULLQUARK</emphasis>
|
|
and version greater than 1, and if
|
|
<function>XtInheritChangeManaged</function>
|
|
was specified in the parent's class record during class initialization,
|
|
the value of the <emphasis remap='I'>allows_change_managed_set</emphasis>
|
|
field is inherited from the superclass. The value inherited from
|
|
<function>compositeWidgetClass</function>
|
|
for the <emphasis remap='I'>allows_change_managed_set</emphasis> field is
|
|
<function>False</function>.
|
|
</para>
|
|
|
|
<para>
|
|
It is not an error to include a child in both the <emphasis remap='I'>unmanage_children</emphasis>
|
|
and the <emphasis remap='I'>manage_children</emphasis> lists. The effect of such a call is that
|
|
the child remains managed following the call, but the <emphasis remap='I'>do_change_proc</emphasis> is
|
|
able to affect the child while it is in an unmanaged state.
|
|
</para>
|
|
|
|
<para>
|
|
The <emphasis remap='I'>do_change_proc</emphasis> is of type
|
|
<xref linkend='XtDoChangeProc' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtDoChangeProc'>
|
|
<funcprototype>
|
|
<funcdef>typedef void *<function>XtDoChangeProc</function></funcdef>
|
|
|
|
<paramdef>Widget <parameter>composite_parent</parameter></paramdef>
|
|
<paramdef>WidgetList <parameter>unmange_children</parameter></paramdef>
|
|
<paramdef>Cardinal *<parameter>num_unmanage_children</parameter></paramdef>
|
|
<paramdef>WidgetList <parameter>manage_children</parameter></paramdef>
|
|
<paramdef>Cardinal *<parameter>num_manage_children</parameter></paramdef>
|
|
<paramdef>XtPointer <parameter>client_data</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>composite_parent</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the composite parent whose managed set is being altered.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>unmanage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the list of children just removed from the managed set.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>num_unmanage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the number of entries in the <emphasis remap='I'>unmanage_children</emphasis> list.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>manage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the list of children about to be added to the managed set.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>num_manage_children</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the number of entries in the <emphasis remap='I'>manage_children</emphasis> list.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>client_data</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Passes the client data passed to
|
|
<xref linkend='XtChangeManagedSet' xrefstyle='select: title'/>.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The <emphasis remap='I'>do_change_proc</emphasis> procedure is used by the caller of
|
|
<xref linkend='XtChangeManagedSet' xrefstyle='select: title'/>
|
|
to make changes to one or more children at the point when the
|
|
managed set contains the fewest entries. These changes may
|
|
involve geometry requests, and in this case the caller of
|
|
<xref linkend='XtChangeManagedSet' xrefstyle='select: title'/>
|
|
may take advantage of the fact that the Intrinsics internally grant
|
|
geometry requests made by unmanaged children without invoking
|
|
the parent's geometry manager. To achieve this advantage, if
|
|
the <emphasis remap='I'>do_change_proc</emphasis> procedure
|
|
changes the geometry of a child or of a descendant of a child, then
|
|
that child should be included in the <emphasis remap='I'>unmanage_children</emphasis> and
|
|
<emphasis remap='I'>manage_children</emphasis> lists.
|
|
</para>
|
|
</sect2>
|
|
|
|
<sect2 id="Determining_if_a_Widget_Is_Managed">
|
|
<title>Determining if a Widget Is Managed</title>
|
|
<para>
|
|
To determine the managed state of a given child widget, use
|
|
<xref linkend='XtIsManaged' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtIsManaged'>
|
|
<funcprototype>
|
|
<funcdef>Boolean <function>XtIsManaged</function></funcdef>
|
|
<paramdef>Widget <parameter>w</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>w</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the widget. Must be of class Object or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtIsManaged' xrefstyle='select: title'/>
|
|
function returns
|
|
<function>True</function>
|
|
if the specified widget is of class RectObj or any subclass thereof
|
|
and is managed, or
|
|
<function>False</function>
|
|
otherwise.
|
|
</para>
|
|
</sect2>
|
|
</sect1>
|
|
|
|
<sect1 id="Controlling_When_Widgets_Get_Mapped">
|
|
<title>Controlling When Widgets Get Mapped</title>
|
|
<para>
|
|
A widget is normally mapped if it is managed.
|
|
However,
|
|
this behavior can be overridden by setting the XtNmappedWhenManaged resource
|
|
for the widget when it is created
|
|
or by setting the <emphasis remap='I'>map_when_managed</emphasis> field to
|
|
<function>False</function>.
|
|
</para>
|
|
|
|
<para>
|
|
To change the value of a given widget's <emphasis remap='I'>map_when_managed</emphasis> field, use
|
|
<xref linkend='XtSetMappedWhenManaged' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtSetMappedWhenManaged'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtSetMappedWhenManaged</function></funcdef>
|
|
<paramdef>Widget <parameter>w</parameter></paramdef>
|
|
<paramdef>Boolean <parameter>map_when_managed</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>w</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the widget. Must be of class Core or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>map_when_managed</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies a Boolean value that indicates the new value
|
|
that is stored into the widget's <emphasis remap='I'>map_when_managed</emphasis>
|
|
field.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
If the widget is realized and managed,
|
|
and if <emphasis remap='I'>map_when_managed</emphasis> is
|
|
<function>True</function>,
|
|
<xref linkend='XtSetMappedWhenManaged' xrefstyle='select: title'/>
|
|
maps the window.
|
|
If the widget is realized and managed,
|
|
and if <emphasis remap='I'>map_when_managed</emphasis> is
|
|
<function>False</function>,
|
|
it unmaps the window.
|
|
<xref linkend='XtSetMappedWhenManaged' xrefstyle='select: title'/>
|
|
is a convenience function that is equivalent to (but slightly faster than)
|
|
calling
|
|
<xref linkend='XtSetValues' xrefstyle='select: title'/>
|
|
and setting the new value for the XtNmappedWhenManaged resource
|
|
then mapping the widget as appropriate.
|
|
As an alternative to using
|
|
<xref linkend='XtSetMappedWhenManaged' xrefstyle='select: title'/>
|
|
to control mapping,
|
|
a client may set <emphasis remap='I'>mapped_when_managed</emphasis> to
|
|
<function>False</function>
|
|
and use
|
|
<xref linkend='XtMapWidget' xrefstyle='select: title'/>
|
|
and
|
|
<xref linkend='XtUnmapWidget' xrefstyle='select: title'/>
|
|
explicitly.
|
|
</para>
|
|
|
|
<para>
|
|
To map a widget explicitly, use
|
|
<xref linkend='XtMapWidget' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtMapWidget'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtMapWidget</function></funcdef>
|
|
<paramdef>Widget <parameter>w</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>w</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the widget. Must be of class Core or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
<para>
|
|
To unmap a widget explicitly, use
|
|
<xref linkend='XtUnmapWidget' xrefstyle='select: title'/>.
|
|
</para>
|
|
|
|
<funcsynopsis id='XtUnmapWidget'>
|
|
<funcprototype>
|
|
<funcdef>void <function>XtUnmapWidget</function></funcdef>
|
|
<paramdef>Widget <parameter>w</parameter></paramdef>
|
|
</funcprototype>
|
|
</funcsynopsis>
|
|
|
|
<variablelist>
|
|
<varlistentry>
|
|
<term>
|
|
<emphasis remap='I'>w</emphasis>
|
|
</term>
|
|
<listitem>
|
|
<para>
|
|
Specifies the widget. Must be of class Core or any subclass thereof.
|
|
</para>
|
|
</listitem>
|
|
</varlistentry>
|
|
</variablelist>
|
|
|
|
|
|
</sect1>
|
|
|
|
<sect1 id="Constrained_Composite_Widgets">
|
|
<title>Constrained Composite Widgets</title>
|
|
<para>
|
|
The Constraint
|
|
widget class is a subclass of
|
|
<function>compositeWidgetClass</function>.
|
|
The name is derived from the fact that constraint widgets
|
|
may manage the geometry
|
|
of their children based on constraints associated with each child.
|
|
These constraints can be as simple as the maximum width and height
|
|
the parent will allow the child to occupy or can be as complicated as
|
|
how other children should change if this child is moved or resized.
|
|
Constraint
|
|
widgets let a parent define constraints as resources that are supplied for their children.
|
|
For example, if the
|
|
Constraint
|
|
parent defines the maximum sizes for its children,
|
|
these new size resources are retrieved for each child as if they were
|
|
resources that were defined by the child widget's class.
|
|
Accordingly,
|
|
constraint resources may be included in the argument list or resource file just
|
|
like any other resource for the child.
|
|
</para>
|
|
|
|
<para>
|
|
Constraint
|
|
widgets have all the responsibilities of normal composite widgets
|
|
and, in addition, must process and act upon the constraint information
|
|
associated with each of their children.
|
|
</para>
|
|
|
|
<para>
|
|
To make it easy for widgets and the Intrinsics to keep track of the
|
|
constraints associated with a child,
|
|
every widget has a <emphasis remap='I'>constraints</emphasis> field,
|
|
which is the address of a parent-specific structure that contains
|
|
constraint information about the child.
|
|
If a child's parent does not belong to a subclass of
|
|
<function>constraintWidgetClass</function>,
|
|
then the child's <emphasis remap='I'>constraints</emphasis> field is NULL.
|
|
</para>
|
|
|
|
<para>
|
|
Subclasses of
|
|
Constraint
|
|
can add constraint data to the constraint record defined by their superclass.
|
|
To allow this, widget writers should define the constraint
|
|
records in their private .h file by using the same conventions as used for
|
|
widget records.
|
|
For example, a widget class that needs to maintain a maximum
|
|
width and height for each child might define its constraint record as
|
|
follows:
|
|
</para>
|
|
<programlisting>
|
|
typedef struct {
|
|
Dimension max_width, max_height;
|
|
} MaxConstraintPart;
|
|
typedef struct {
|
|
MaxConstraintPart max;
|
|
} MaxConstraintRecord, *MaxConstraint;
|
|
</programlisting>
|
|
<para>
|
|
A subclass of this widget class that also needs to maintain a minimum size would
|
|
define its constraint record as follows:
|
|
</para>
|
|
<programlisting>
|
|
typedef struct {
|
|
Dimension min_width, min_height;
|
|
} MinConstraintPart;
|
|
typedef struct {
|
|
MaxConstraintPart max;
|
|
MinConstraintPart min;
|
|
} MaxMinConstraintRecord, *MaxMinConstraint;
|
|
</programlisting>
|
|
<para>
|
|
Constraints are allocated, initialized, deallocated, and otherwise maintained
|
|
insofar as possible by the Intrinsics.
|
|
The Constraint class record part has several entries that facilitate this.
|
|
All entries in
|
|
<function>ConstraintClassPart</function>
|
|
are fields and procedures that are defined and implemented by the parent,
|
|
but they are called whenever actions are performed on the parent's children.
|
|
</para>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtCreateWidget' xrefstyle='select: title'/>
|
|
function uses the <emphasis remap='I'>constraint_size</emphasis> field in the parent's class record
|
|
to allocate a constraint record when a child is created.
|
|
<xref linkend='XtCreateWidget' xrefstyle='select: title'/>
|
|
also uses the constraint resources to fill in resource fields in the
|
|
constraint record associated with a child.
|
|
It then calls the constraint initialize procedure so that the parent
|
|
can compute constraint fields that are derived from constraint resources
|
|
and can possibly move or resize the child to conform to the given constraints.
|
|
</para>
|
|
|
|
<para>
|
|
When the
|
|
<xref linkend='XtGetValues' xrefstyle='select: title'/>
|
|
and
|
|
<xref linkend='XtSetValues' xrefstyle='select: title'/>
|
|
functions are executed
|
|
on a child, they use the constraint resources to get the values or
|
|
set the values of constraints associated with that child.
|
|
<xref linkend='XtSetValues' xrefstyle='select: title'/>
|
|
then calls the constraint set_values procedures so that the parent can
|
|
recompute derived constraint fields and move or resize the child
|
|
as appropriate.
|
|
If a
|
|
Constraint
|
|
widget class or any of its superclasses have declared a
|
|
<function>ConstraintClassExtension</function>
|
|
record in the
|
|
<function>ConstraintClassPart</function>
|
|
<emphasis remap='I'>extension</emphasis>
|
|
fields with a record type of
|
|
<emphasis role='strong'>NULLQUARK</emphasis>
|
|
and the <emphasis remap='I'>get_values_hook</emphasis> field in
|
|
the extension record is non-NULL,
|
|
<xref linkend='XtGetValues' xrefstyle='select: title'/>
|
|
calls the get_values_hook
|
|
procedure(s) to allow the parent to return derived constraint fields.
|
|
</para>
|
|
|
|
<para>
|
|
The
|
|
<xref linkend='XtDestroyWidget' xrefstyle='select: title'/>
|
|
function calls the constraint destroy procedure to deallocate any
|
|
dynamic storage associated with a constraint record.
|
|
The constraint record itself must not be deallocated by the constraint
|
|
destroy procedure;
|
|
<xref linkend='XtDestroyWidget' xrefstyle='select: title'/>
|
|
does this automatically.
|
|
</para>
|
|
</sect1>
|
|
</chapter>
|