1111 lines
30 KiB
Plaintext
1111 lines
30 KiB
Plaintext
|
.\" $Xorg: CH06,v 1.3 2000/08/17 19:42:45 cpqbld Exp $
|
||
|
|
.\" Copyright \(co 1985, 1986, 1987, 1988, 1991, 1994
|
||
|
|
.\" X Consortium
|
||
|
|
.\"
|
||
|
|
.\" Permission is hereby granted, free of charge, to any person obtaining
|
||
|
|
.\" a copy of this software and associated documentation files (the
|
||
|
|
.\" "Software"), to deal in the Software without restriction, including
|
||
|
|
.\" without limitation the rights to use, copy, modify, merge, publish,
|
||
|
|
.\" distribute, sublicense, and/or sell copies of the Software, and to
|
||
|
|
.\" permit persons to whom the Software is furnished to do so, subject to
|
||
|
|
.\" the following conditions:
|
||
|
|
.\"
|
||
|
|
.\" The above copyright notice and this permission notice shall be included
|
||
|
|
.\" in all copies or substantial portions of the Software.
|
||
|
|
.\"
|
||
|
|
.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||
|
|
.\" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
|
|
.\" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||
|
|
.\" IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||
|
|
.\" OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||
|
|
.\" ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||
|
|
.\" OTHER DEALINGS IN THE SOFTWARE.
|
||
|
|
.\"
|
||
|
|
.\" Except as contained in this notice, the name of the X Consortium shall
|
||
|
|
.\" not be used in advertising or otherwise to promote the sale, use or
|
||
|
|
.\" other dealings in this Software without prior written authorization
|
||
|
|
.\" from the X Consortium.
|
||
|
|
.\"
|
||
|
|
.\" Copyright \(co 1985, 1986, 1987, 1988, 1991, 1994
|
||
|
|
.\" Digital Equipment Corporation, Maynard, Massachusetts.
|
||
|
|
.\"
|
||
|
|
.\" Permission to use, copy, modify and distribute this documentation for any
|
||
|
|
.\" purpose and without fee is hereby granted, provided that the above copyright
|
||
|
|
.\" notice appears in all copies and that both that copyright notice and this
|
||
|
|
.\" permission notice appear in supporting documentation, and that the name of
|
||
|
|
.\" Digital not be used in in advertising or publicity pertaining
|
||
|
|
.\" to distribution of the software without specific, written prior permission.
|
||
|
|
.\" Digital makes no representations about the suitability of the
|
||
|
|
.\" software described herein for any purpose.
|
||
|
|
.\" It is provided ``as is'' without express or implied warranty.
|
||
|
|
.\"
|
||
|
|
\&
|
||
|
|
.sp 1
|
||
|
|
.ce 3
|
||
|
|
\s+1\fBChapter 6\fP\s-1
|
||
|
|
|
||
|
|
\s+1\fBGeometry Management\fP\s-1
|
||
|
|
.sp 2
|
||
|
|
.nr H1 6
|
||
|
|
.nr H2 0
|
||
|
|
.nr H3 0
|
||
|
|
.nr H4 0
|
||
|
|
.nr H5 0
|
||
|
|
.LP
|
||
|
|
.XS
|
||
|
|
Chapter 6 \(em Geometry Management
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
.IN "geometry_manager procedure"
|
||
|
|
.IN "Geometry Management"
|
||
|
|
.IN "Configure Window"
|
||
|
|
A widget does not directly control its size and location;
|
||
|
|
rather, its parent is responsible for controlling them.
|
||
|
|
Although the position of children is usually left up to their parent,
|
||
|
|
the widgets themselves often have the best idea of their optimal sizes
|
||
|
|
and, possibly, preferred locations.
|
||
|
|
.LP
|
||
|
|
To resolve physical layout conflicts between sibling widgets and between
|
||
|
|
a widget and its parent, the \*(xI provide the geometry management mechanism.
|
||
|
|
Almost all
|
||
|
|
composite
|
||
|
|
widgets have a geometry manager specified in the \fIgeometry_manager\fP field
|
||
|
|
in the widget class record that is responsible for the size, position, and
|
||
|
|
stacking order of the widget's children.
|
||
|
|
The only exception is fixed boxes,
|
||
|
|
which create their children themselves and can ensure that
|
||
|
|
their children will never make a geometry request.
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
Initiating Geometry Changes
|
||
|
|
.LP
|
||
|
|
.XS
|
||
|
|
\*(SN Initiating Geometry Changes
|
||
|
|
.XE
|
||
|
|
Parents, children, and clients each initiate geometry changes differently.
|
||
|
|
Because a parent has absolute control of its children's geometry,
|
||
|
|
it changes the geometry directly by calling
|
||
|
|
.PN XtMove\%Widget ,
|
||
|
|
.PN XtResizeWidget ,
|
||
|
|
or
|
||
|
|
.PN XtConfigureWidget .
|
||
|
|
A child must ask its parent for a geometry change by calling
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
or
|
||
|
|
.PN XtMakeResizeRequest .
|
||
|
|
An application or other client code initiates a geometry change by calling
|
||
|
|
.PN XtSetValues
|
||
|
|
on the appropriate geometry fields,
|
||
|
|
thereby giving the widget the opportunity to modify or reject the client
|
||
|
|
request before it gets propagated to the parent and the opportunity
|
||
|
|
to respond appropriately to the parent's reply.
|
||
|
|
.LP
|
||
|
|
When a widget that needs to change its size, position, border width,
|
||
|
|
or stacking depth asks its parent's geometry manager to make the desired
|
||
|
|
changes,
|
||
|
|
the geometry manager can allow the request, disallow the request, or
|
||
|
|
suggest a compromise.
|
||
|
|
.LP
|
||
|
|
When the geometry manager is asked to change the geometry of a child,
|
||
|
|
the geometry manager may also rearrange and resize any or all
|
||
|
|
of the other children that it controls.
|
||
|
|
The geometry manager can move children around freely using
|
||
|
|
.PN XtMoveWidget .
|
||
|
|
When it resizes a child (that is, changes the width, height, or
|
||
|
|
border width) other than the one making the request,
|
||
|
|
it should do so by calling
|
||
|
|
.PN XtResizeWidget .
|
||
|
|
The requesting child may be given special treatment; see Section 6.5.
|
||
|
|
It can simultaneously move and resize a child with a single call to
|
||
|
|
.PN XtConfigureWidget .
|
||
|
|
.LP
|
||
|
|
Often, geometry managers find that they can satisfy a request only if
|
||
|
|
they can reconfigure a widget that they are not in control of; in particular,
|
||
|
|
the
|
||
|
|
composite
|
||
|
|
widget may want to change its own size.
|
||
|
|
In this case,
|
||
|
|
the geometry manager makes a request to its parent's geometry manager.
|
||
|
|
Geometry requests can cascade this way to arbitrary depth.
|
||
|
|
.LP
|
||
|
|
Because such cascaded arbitration of widget geometry can involve extended
|
||
|
|
negotiation,
|
||
|
|
windows are not actually allocated to widgets at application
|
||
|
|
startup until all widgets are satisfied with their geometry;
|
||
|
|
see Sections 2.5 and 2.6.
|
||
|
|
.NT Notes
|
||
|
|
.IP 1. 5
|
||
|
|
The \*(xI treatment of stacking requests is deficient in several areas.
|
||
|
|
Stacking requests for unrealized widgets are granted but will have no effect.
|
||
|
|
In addition, there is no way to do an
|
||
|
|
.PN XtSetValues
|
||
|
|
that will generate a stacking geometry request.
|
||
|
|
.IP 2. 5
|
||
|
|
After a successful geometry request (one that returned
|
||
|
|
.PN XtGeometryYes ),
|
||
|
|
a widget does not know whether its resize procedure has been called.
|
||
|
|
Widgets should have resize procedures that can be called more than once
|
||
|
|
without ill effects.
|
||
|
|
.NE
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
General Geometry Manager Requests
|
||
|
|
.XS
|
||
|
|
\*(SN General Geometry Manager Requests
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
When making a geometry request, the child specifies an
|
||
|
|
.PN XtWidgetGeometry
|
||
|
|
structure.
|
||
|
|
.LP
|
||
|
|
.IN "XtGeometryMask"
|
||
|
|
.KS
|
||
|
|
.sM
|
||
|
|
.Ds 0
|
||
|
|
.TA .5i 3i
|
||
|
|
.ta .5i 3i
|
||
|
|
typedef unsigned long XtGeometryMask;
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
XtGeometryMask request_mode;
|
||
|
|
Position x, y;
|
||
|
|
Dimension width, height;
|
||
|
|
Dimension border_width;
|
||
|
|
Widget sibling;
|
||
|
|
int stack_mode;
|
||
|
|
} XtWidgetGeometry;
|
||
|
|
.De
|
||
|
|
.eM
|
||
|
|
.KE
|
||
|
|
.LP
|
||
|
|
To make a general geometry manager request from a widget, use
|
||
|
|
.PN XtMakeGeometryRequest .
|
||
|
|
.LP
|
||
|
|
.IN "XtMakeGeometryRequest" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
XtGeometryResult XtMakeGeometryRequest(\fIw\fP, \fIrequest\fP, \
|
||
|
|
\fIreply_return\fP)
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIrequest\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIreply_return\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1i
|
||
|
|
Specifies the widget making the request. \*(rI
|
||
|
|
.IP \fIrequest\fP 1i
|
||
|
|
Specifies the desired widget geometry (size, position, border width,
|
||
|
|
and stacking order).
|
||
|
|
.IP \fIreply_return\fP 1i
|
||
|
|
Returns the allowed widget size, or may be NULL
|
||
|
|
if the requesting widget is not interested in handling
|
||
|
|
.PN XtGeometryAlmost .
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
Depending on the condition,
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
performs the following:
|
||
|
|
.IP \(bu 5
|
||
|
|
If the widget is unmanaged or the widget's parent is not realized,
|
||
|
|
it makes the changes and returns
|
||
|
|
.PN XtGeometryYes .
|
||
|
|
.IP \(bu 5
|
||
|
|
If the parent's class is not a subclass of
|
||
|
|
.PN compositeWidgetClass
|
||
|
|
or the parent's \fIgeometry_manager\fP field is NULL,
|
||
|
|
it issues an error.
|
||
|
|
.IP \(bu 5
|
||
|
|
If the widget's \fIbeing_destroyed\fP field is
|
||
|
|
.PN True ,
|
||
|
|
it returns
|
||
|
|
.PN XtGeometryNo .
|
||
|
|
.IP \(bu 5
|
||
|
|
If the widget \fIx\fP, \fIy\fP, \fIwidth\fP, \fIheight\fP, and
|
||
|
|
\fIborder_width\fP fields are
|
||
|
|
all equal to the requested values,
|
||
|
|
it returns
|
||
|
|
.PN XtGeometryYes ;
|
||
|
|
otherwise, it calls the parent's geometry_manager procedure
|
||
|
|
with the given parameters.
|
||
|
|
.IP \(bu 5
|
||
|
|
If the parent's geometry manager returns
|
||
|
|
.PN XtGeometryYes
|
||
|
|
and if
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
is not set in \fIrequest->request_mode\fP
|
||
|
|
and if the widget is realized,
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
calls the
|
||
|
|
.PN XConfigureWindow
|
||
|
|
Xlib function to reconfigure the widget's window (set its size, location,
|
||
|
|
and stacking order as appropriate).
|
||
|
|
.IP \(bu 5
|
||
|
|
If the geometry manager returns
|
||
|
|
.PN XtGeometryDone ,
|
||
|
|
the change has been approved and actually has been done.
|
||
|
|
In this case,
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
does no configuring and returns
|
||
|
|
.PN XtGeometryYes .
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
never returns
|
||
|
|
.PN XtGeometryDone .
|
||
|
|
.IP \(bu 5
|
||
|
|
Otherwise,
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
just returns the resulting value from the parent's geometry manager.
|
||
|
|
.LP
|
||
|
|
Children of primitive widgets are always unmanaged; therefore,
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
always returns
|
||
|
|
.PN XtGeometryYes
|
||
|
|
when called by a child of a primitive widget.
|
||
|
|
.LP
|
||
|
|
The return codes from geometry managers are
|
||
|
|
.IN "XtGeometryResult"
|
||
|
|
.LP
|
||
|
|
.KS
|
||
|
|
.sM
|
||
|
|
.Ds 0
|
||
|
|
.TA .5i 1.75i
|
||
|
|
.ta .5i 1.75i
|
||
|
|
typedef enum {
|
||
|
|
XtGeometryYes,
|
||
|
|
XtGeometryNo,
|
||
|
|
XtGeometryAlmost,
|
||
|
|
XtGeometryDone
|
||
|
|
} XtGeometryResult;
|
||
|
|
.De
|
||
|
|
.eM
|
||
|
|
.KE
|
||
|
|
.LP
|
||
|
|
The \fIrequest_mode\fP definitions are from
|
||
|
|
.Pn < X11/X.h >.
|
||
|
|
.LP
|
||
|
|
.sM
|
||
|
|
.TS
|
||
|
|
lw(.5i) lw(2.5i) lw(.75i).
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN CWX
|
||
|
|
T} T{
|
||
|
|
(1<<0)
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN CWY
|
||
|
|
T} T{
|
||
|
|
(1<<1)
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN CWWidth
|
||
|
|
T} T{
|
||
|
|
(1<<2)
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN CWHeight
|
||
|
|
T} T{
|
||
|
|
(1<<3)
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN CWBorderWidth
|
||
|
|
T} T{
|
||
|
|
(1<<4)
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN CWSibling
|
||
|
|
T} T{
|
||
|
|
(1<<5)
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN CWStackMode
|
||
|
|
T} T{
|
||
|
|
(1<<6)
|
||
|
|
T}
|
||
|
|
.TE
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
The \*(xI also support the following value.
|
||
|
|
.LP
|
||
|
|
.sM
|
||
|
|
.TS
|
||
|
|
lw(.5i) lw(2.5i) lw(.75i).
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
T} T{
|
||
|
|
(1<<7)
|
||
|
|
T}
|
||
|
|
.TE
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
indicates that the corresponding geometry request is only a query
|
||
|
|
as to what would happen if this geometry request were made
|
||
|
|
and that no widgets should actually be changed.
|
||
|
|
.LP
|
||
|
|
.PN XtMakeGeometryRequest ,
|
||
|
|
like the
|
||
|
|
.PN XConfigureWindow
|
||
|
|
Xlib function, uses \fIrequest_mode\fP to determine which fields in the
|
||
|
|
.PN XtWidgetGeometry
|
||
|
|
structure the caller wants to specify.
|
||
|
|
.LP
|
||
|
|
The \fIstack_mode\fP definitions are from
|
||
|
|
.Pn < X11/X.h >:
|
||
|
|
.LP
|
||
|
|
.sM
|
||
|
|
.TS
|
||
|
|
lw(.5i) lw(2.5i) lw(.75i).
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN Above
|
||
|
|
T} T{
|
||
|
|
0
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN Below
|
||
|
|
T} T{
|
||
|
|
1
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN TopIf
|
||
|
|
T} T{
|
||
|
|
2
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN BottomIf
|
||
|
|
T} T{
|
||
|
|
3
|
||
|
|
T}
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN Opposite
|
||
|
|
T} T{
|
||
|
|
4
|
||
|
|
T}
|
||
|
|
.TE
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
The \*(xI also support the following value.
|
||
|
|
.LP
|
||
|
|
.sM
|
||
|
|
.TS
|
||
|
|
lw(.5i) lw(2.5i) lw(.75i).
|
||
|
|
T{
|
||
|
|
#define
|
||
|
|
T} T{
|
||
|
|
.PN XtSMDontChange
|
||
|
|
T} T{
|
||
|
|
5
|
||
|
|
T}
|
||
|
|
.TE
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
For definition and behavior of
|
||
|
|
.PN Above ,
|
||
|
|
.PN Below ,
|
||
|
|
.PN TopIf ,
|
||
|
|
.PN BottomIf ,
|
||
|
|
and
|
||
|
|
.PN Opposite ,
|
||
|
|
see Section 3.7 in \fI\*(xL\fP.
|
||
|
|
.PN XtSMDontChange
|
||
|
|
indicates that the widget wants its current stacking order preserved.
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
Resize Requests
|
||
|
|
.XS
|
||
|
|
\*(SN Resize Requests
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
To make a simple resize request from a widget, you can use
|
||
|
|
.PN XtMakeResizeRequest
|
||
|
|
as an alternative to
|
||
|
|
.PN XtMakeGeometryRequest .
|
||
|
|
.LP
|
||
|
|
.IN "XtMakeResizeRequest" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
XtGeometryResult XtMakeResizeRequest(\fIw\fP, \fIwidth\fP, \fIheight\fP, \
|
||
|
|
\fIwidth_return\fP, \fIheight_return\fP)
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
Dimension \fIwidth\fP, \fIheight\fP;
|
||
|
|
.br
|
||
|
|
Dimension *\fIwidth_return\fP, *\fIheight_return\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1i
|
||
|
|
Specifies the widget making the request. \*(rI
|
||
|
|
.IP \fIwidth\fP 1i
|
||
|
|
Specify the desired widget width and height.
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIheight\fP 1i
|
||
|
|
.IP \fIwidth_return\fP 1i
|
||
|
|
Return the allowed widget width and height.
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIheight_return\fP 1i
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
The
|
||
|
|
.PN XtMakeResizeRequest
|
||
|
|
function, a simple interface to
|
||
|
|
.PN XtMakeGeometryRequest ,
|
||
|
|
creates an
|
||
|
|
.PN XtWidgetGeometry
|
||
|
|
structure and specifies that width and height should change
|
||
|
|
by setting \fIrequest_mode\fP to
|
||
|
|
.PN CWWidth
|
||
|
|
\fB|\fP
|
||
|
|
.PN CWHeight .
|
||
|
|
The geometry manager is free to modify any of the other window attributes
|
||
|
|
(position or stacking order) to satisfy the resize request.
|
||
|
|
If the return value is
|
||
|
|
.PN XtGeometryAlmost ,
|
||
|
|
\fIwidth_return\fP and \fIheight_return\fP contain a compromise width and height.
|
||
|
|
If these are acceptable,
|
||
|
|
the widget should immediately call
|
||
|
|
.PN XtMakeResizeRequest
|
||
|
|
again and request that the compromise width and height be applied.
|
||
|
|
If the widget is not interested in
|
||
|
|
.PN XtGeometryAlmost
|
||
|
|
replies,
|
||
|
|
it can pass NULL for \fIwidth_return\fP and \fIheight_return\fP.
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
Potential Geometry Changes
|
||
|
|
.XS
|
||
|
|
\*(SN Potential Geometry Changes
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
Sometimes a geometry manager cannot respond to
|
||
|
|
a geometry request from a child without first making a geometry request
|
||
|
|
to the widget's own parent (the original requestor's grandparent).
|
||
|
|
If the request to the grandparent would allow the parent to satisfy the
|
||
|
|
original request,
|
||
|
|
the geometry manager can make the intermediate geometry request
|
||
|
|
as if it were the originator.
|
||
|
|
On the other hand,
|
||
|
|
if the geometry manager already has determined that the original request
|
||
|
|
cannot be completely satisfied (for example, if it always denies
|
||
|
|
position changes),
|
||
|
|
it needs to tell the grandparent to respond to the intermediate request
|
||
|
|
without actually changing the geometry
|
||
|
|
because it does not know if the child will accept the compromise.
|
||
|
|
To accomplish this, the geometry manager uses
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
in the intermediate request.
|
||
|
|
.LP
|
||
|
|
When
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
is used, the geometry manager needs to cache
|
||
|
|
enough information to exactly reconstruct the intermediate request.
|
||
|
|
If the grandparent's response to the intermediate query was
|
||
|
|
.PN XtGeometryAlmost ,
|
||
|
|
the geometry manager needs to cache the entire
|
||
|
|
reply geometry in the event the child accepts the parent's compromise.
|
||
|
|
.LP
|
||
|
|
If the grandparent's response was
|
||
|
|
.PN XtGeometryAlmost ,
|
||
|
|
it may also be necessary to cache the entire reply geometry from
|
||
|
|
the grandparent when
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
is not used.
|
||
|
|
If the geometry manager is still able to satisfy the original request,
|
||
|
|
it may immediately accept the grandparent's compromise
|
||
|
|
and then act on the child's request.
|
||
|
|
If the grandparent's compromise geometry is insufficient to allow
|
||
|
|
the child's request and if the geometry manager is willing to offer
|
||
|
|
a different compromise to the child,
|
||
|
|
the grandparent's compromise should not be accepted until the child
|
||
|
|
has accepted the new compromise.
|
||
|
|
.LP
|
||
|
|
Note that a compromise geometry returned with
|
||
|
|
.PN XtGeometryAlmost
|
||
|
|
is guaranteed only for the next call to the same widget;
|
||
|
|
therefore, a cache of size 1 is sufficient.
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
Child Geometry Management: The geometry_manager Procedure
|
||
|
|
.XS
|
||
|
|
\*(SN Child Geometry Management: The geometry_manager Procedure
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
The geometry_manager procedure pointer in a composite widget class is of type
|
||
|
|
.PN XtGeometryHandler .
|
||
|
|
.LP
|
||
|
|
.IN "XtGeometryHandler" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
typedef XtGeometryResult (*XtGeometryHandler)(Widget, XtWidgetGeometry*, \
|
||
|
|
XtWidgetGeometry*);
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIrequest\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIgeometry_return\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1.2i
|
||
|
|
Passes the widget making the request.
|
||
|
|
.IP \fIrequest\fP 1.2i
|
||
|
|
Passes the new geometry the child desires.
|
||
|
|
.IP \fIgeometry_return\fP 1.2i
|
||
|
|
Passes a geometry structure in which the geometry manager may store a
|
||
|
|
compromise.
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
A class can inherit its superclass's geometry manager during class
|
||
|
|
initialization.
|
||
|
|
.LP
|
||
|
|
A bit set to zero in the request's \fIrequest_mode\fP
|
||
|
|
field means that the child widget
|
||
|
|
does not care about the value of the corresponding field,
|
||
|
|
so the geometry manager can change this field as it wishes.
|
||
|
|
A bit set to 1 means that the child wants that geometry element set
|
||
|
|
to the value in the corresponding field.
|
||
|
|
.LP
|
||
|
|
If the geometry manager can satisfy all changes requested
|
||
|
|
and if
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
is not specified,
|
||
|
|
it updates the widget's \fIx\fP, \fIy\fP, \fIwidth\fP, \fIheight\fP,
|
||
|
|
and \fIborder_width\fP fields
|
||
|
|
appropriately.
|
||
|
|
Then, it returns
|
||
|
|
.PN XtGeometryYes ,
|
||
|
|
and the values pointed to by the \fIgeometry_return\fP argument are undefined.
|
||
|
|
The widget's window is moved and resized automatically by
|
||
|
|
.PN XtMakeGeometryRequest .
|
||
|
|
.LP
|
||
|
|
Homogeneous composite widgets often find it convenient to treat the widget
|
||
|
|
making the request the same as any other widget, including reconfiguring
|
||
|
|
it using
|
||
|
|
.PN XtConfigureWidget
|
||
|
|
or
|
||
|
|
.PN XtResizeWidget
|
||
|
|
as part of its layout process, unless
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
is specified.
|
||
|
|
If it does this,
|
||
|
|
it should return
|
||
|
|
.PN XtGeometryDone
|
||
|
|
to inform
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
that it does not need to do the configuration itself.
|
||
|
|
.NT
|
||
|
|
To remain
|
||
|
|
compatible with layout techniques used in older widgets (before
|
||
|
|
.PN XtGeometryDone
|
||
|
|
was added to the \*(xI), a geometry manager should avoid using
|
||
|
|
.PN XtResizeWidget
|
||
|
|
or
|
||
|
|
.PN XtConfigureWidget
|
||
|
|
on the child making
|
||
|
|
the request because the layout process of the child may be in an
|
||
|
|
intermediate state in which it is not prepared to handle a call to its
|
||
|
|
resize procedure. A self-contained widget set may choose this
|
||
|
|
alternative geometry management scheme, however, provided that it
|
||
|
|
clearly warns widget developers of the compatibility consequences.
|
||
|
|
.NE
|
||
|
|
.LP
|
||
|
|
Although
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
resizes the widget's window
|
||
|
|
(if the geometry
|
||
|
|
manager returns
|
||
|
|
.PN XtGeometryYes ),
|
||
|
|
it does not call the widget class's resize procedure.
|
||
|
|
The requesting widget must perform whatever
|
||
|
|
resizing calculations are needed explicitly.
|
||
|
|
.LP
|
||
|
|
If the geometry manager disallows the request,
|
||
|
|
the widget cannot change its geometry.
|
||
|
|
The values pointed to by \fIgeometry_return\fP are undefined,
|
||
|
|
and the geometry manager returns
|
||
|
|
.PN XtGeometryNo .
|
||
|
|
.LP
|
||
|
|
Sometimes the geometry manager cannot satisfy the request exactly
|
||
|
|
but may be able to satisfy a similar request.
|
||
|
|
That is,
|
||
|
|
it could satisfy only a subset of the requests (for example,
|
||
|
|
size but not position) or a lesser request
|
||
|
|
(for example, it cannot make the child as big as the
|
||
|
|
request but it can make the child bigger than its current size).
|
||
|
|
In such cases,
|
||
|
|
the geometry manager fills in the structure pointed to by
|
||
|
|
\fIgeometry_return\fP with the actual changes
|
||
|
|
it is willing to make, including an appropriate \fIrequest_mode\fP mask, and returns
|
||
|
|
.PN XtGeometryAlmost .
|
||
|
|
If a bit in \fIgeometry_return->request_mode\fP is zero,
|
||
|
|
the geometry manager agrees not to change the corresponding value
|
||
|
|
if \fIgeometry_return\fP is used immediately
|
||
|
|
in a new request.
|
||
|
|
If a bit is 1,
|
||
|
|
the geometry manager does change that element to the corresponding
|
||
|
|
value in \fIgeometry_return\fP.
|
||
|
|
More bits may be set in \fIgeometry_return->request_mode\fP
|
||
|
|
than in the original request if
|
||
|
|
the geometry manager intends to change other fields should the
|
||
|
|
child accept the compromise.
|
||
|
|
.LP
|
||
|
|
When
|
||
|
|
.PN XtGeometryAlmost
|
||
|
|
is returned,
|
||
|
|
the widget must decide if the compromise suggested in \fIgeometry_return\fP
|
||
|
|
is acceptable.
|
||
|
|
If it is, the widget must not change its geometry directly;
|
||
|
|
rather, it must make another call to
|
||
|
|
.PN XtMakeGeometryRequest .
|
||
|
|
.LP
|
||
|
|
If the next geometry request from this child uses the
|
||
|
|
\fIgeometry_return\fP values filled in by the geometry manager with an
|
||
|
|
.PN XtGeometryAlmost
|
||
|
|
return and if there have been no intervening geometry requests on
|
||
|
|
either its parent or any of its other children,
|
||
|
|
the geometry manager must grant the request, if possible.
|
||
|
|
That is, if the child asks immediately with the returned geometry,
|
||
|
|
it should get an answer of
|
||
|
|
.PN XtGeometryYes .
|
||
|
|
However,
|
||
|
|
dynamic behavior in
|
||
|
|
the user's window manager may affect the final outcome.
|
||
|
|
.LP
|
||
|
|
To return
|
||
|
|
.PN XtGeometryYes ,
|
||
|
|
the geometry manager frequently rearranges the position of other managed
|
||
|
|
children by calling
|
||
|
|
.PN XtMoveWidget .
|
||
|
|
However, a few geometry managers may sometimes change the
|
||
|
|
size of other managed children by calling
|
||
|
|
.PN XtResizeWidget
|
||
|
|
or
|
||
|
|
.PN XtConfigureWidget .
|
||
|
|
If
|
||
|
|
.PN XtCWQueryOnly
|
||
|
|
is specified,
|
||
|
|
the geometry manager must return data describing
|
||
|
|
how it would react to this geometry
|
||
|
|
request without actually moving or resizing any widgets.
|
||
|
|
.LP
|
||
|
|
Geometry managers must not assume that the \fIrequest\fP
|
||
|
|
and \fIgeometry_return\fP arguments point to independent storage.
|
||
|
|
The caller is permitted to use the same field for both,
|
||
|
|
and the geometry manager must allocate its own temporary storage,
|
||
|
|
if necessary.
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
Widget Placement and Sizing
|
||
|
|
.XS
|
||
|
|
\*(SN Widget Placement and Sizing
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
To move a sibling widget of the child making the geometry request,
|
||
|
|
the parent uses
|
||
|
|
.PN XtMoveWidget .
|
||
|
|
.LP
|
||
|
|
.IN "XtMoveWidget" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
void XtMoveWidget(\fIw\fP, \fIx\fP, \fIy\fP)
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
Position \fIx\fP;
|
||
|
|
.br
|
||
|
|
Position \fIy\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1i
|
||
|
|
Specifies the widget. \*(rI
|
||
|
|
.IP \fIx\fP 1i
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIy\fP 1i
|
||
|
|
Specify the new widget x and y coordinates.
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
The
|
||
|
|
.PN XtMoveWidget
|
||
|
|
function returns immediately if the specified geometry fields
|
||
|
|
are the same as the old values.
|
||
|
|
Otherwise,
|
||
|
|
.PN XtMoveWidget
|
||
|
|
writes the new \fIx\fP and \fIy\fP values into the object
|
||
|
|
and, if the object is a widget and is realized, issues an Xlib
|
||
|
|
.PN XMoveWindow
|
||
|
|
call on the widget's window.
|
||
|
|
.sp
|
||
|
|
.LP
|
||
|
|
To resize a sibling widget of the child making the geometry request,
|
||
|
|
the parent uses
|
||
|
|
.PN XtResizeWidget .
|
||
|
|
.LP
|
||
|
|
.IN "XtResizeWidget" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
void XtResizeWidget(\fIw\fP, \fIwidth\fP, \fIheight\fP, \fIborder_width\fP)
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
Dimension \fIwidth\fP;
|
||
|
|
.br
|
||
|
|
Dimension \fIheight\fP;
|
||
|
|
.br
|
||
|
|
Dimension \fIborder_width\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1i
|
||
|
|
Specifies the widget. \*(rI
|
||
|
|
.IP \fIwidth\fP 1i
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIheight\fP 1i
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIborder_width\fP 1i
|
||
|
|
Specify the new widget size.
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
The
|
||
|
|
.PN XtResizeWidget
|
||
|
|
function returns immediately if the specified geometry fields
|
||
|
|
are the same as the old values.
|
||
|
|
Otherwise,
|
||
|
|
.PN XtResizeWidget
|
||
|
|
writes the new \fIwidth\fP, \fIheight\fP, and \fIborder_width\fP values into
|
||
|
|
the object and, if the object is a widget and is realized, issues an
|
||
|
|
.PN XConfigureWindow
|
||
|
|
call on the widget's window.
|
||
|
|
.LP
|
||
|
|
If the new width or height is different from the old values,
|
||
|
|
.PN XtResizeWidget
|
||
|
|
calls the object's resize procedure to notify it of the size change.
|
||
|
|
.sp
|
||
|
|
.LP
|
||
|
|
To move and resize the sibling widget of the child making the geometry request,
|
||
|
|
the parent uses
|
||
|
|
.PN XtConfigureWidget .
|
||
|
|
.LP
|
||
|
|
.IN "XtConfigureWidget" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
void XtConfigureWidget(\fIw\fP, \fIx\fP, \fIy\fP, \fIwidth\fP, \fIheight\fP, \
|
||
|
|
\fIborder_width\fP)
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
Position \fIx\fP;
|
||
|
|
.br
|
||
|
|
Position \fIy\fP;
|
||
|
|
.br
|
||
|
|
Dimension \fIwidth\fP;
|
||
|
|
.br
|
||
|
|
Dimension \fIheight\fP;
|
||
|
|
.br
|
||
|
|
Dimension \fIborder_width\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1i
|
||
|
|
Specifies the widget. \*(rI
|
||
|
|
.IP \fIx\fP 1i
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIy\fP 1i
|
||
|
|
Specify the new widget x and y coordinates.
|
||
|
|
.IP \fIwidth\fP 1i
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIheight\fP 1i
|
||
|
|
.br
|
||
|
|
.ns
|
||
|
|
.IP \fIborder_width\fP 1i
|
||
|
|
Specify the new widget size.
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
The
|
||
|
|
.PN XtConfigureWidget
|
||
|
|
function returns immediately if the specified new geometry fields
|
||
|
|
are all equal to the current values.
|
||
|
|
Otherwise,
|
||
|
|
.PN XtConfigureWidget
|
||
|
|
writes the new \fIx\fP, \fIy\fP, \fIwidth\fP, \fIheight\fP,
|
||
|
|
and \fIborder_width\fP values
|
||
|
|
into the object and, if the object is a widget and is realized, makes an Xlib
|
||
|
|
.PN XConfigureWindow
|
||
|
|
call on the widget's window.
|
||
|
|
.LP
|
||
|
|
If the new width or height is different from its old value,
|
||
|
|
.PN XtConfigureWidget
|
||
|
|
calls the object's resize procedure to notify it of the size change;
|
||
|
|
otherwise, it simply returns.
|
||
|
|
.sp
|
||
|
|
.LP
|
||
|
|
To resize a child widget that already has the new values of its width,
|
||
|
|
height, and border width, the parent uses
|
||
|
|
.PN XtResizeWindow .
|
||
|
|
.LP
|
||
|
|
.IN "XtResizeWindow" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
void XtResizeWindow(\fIw\fP)
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1i
|
||
|
|
Specifies the widget. \*(cI
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
The
|
||
|
|
.PN XtResizeWindow
|
||
|
|
function calls the
|
||
|
|
.PN XConfigureWindow
|
||
|
|
Xlib function to make the window of the specified widget match its width,
|
||
|
|
height, and border width.
|
||
|
|
This request is done unconditionally because there is no
|
||
|
|
inexpensive way to tell if these
|
||
|
|
values match the current values.
|
||
|
|
Note that the widget's resize procedure is not called.
|
||
|
|
.LP
|
||
|
|
There are very few times to use
|
||
|
|
.PN XtResizeWindow ;
|
||
|
|
instead, the parent should use
|
||
|
|
.PN XtResizeWidget .
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
Preferred Geometry
|
||
|
|
.XS
|
||
|
|
\*(SN Preferred Geometry
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
Some parents may be willing to adjust their layouts to accommodate the
|
||
|
|
preferred geometries of their children.
|
||
|
|
They can use
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
to obtain the preferred geometry
|
||
|
|
and, as they see fit, can use or ignore any portion of the response.
|
||
|
|
.sp
|
||
|
|
.LP
|
||
|
|
To query a child widget's preferred geometry, use
|
||
|
|
.PN XtQueryGeometry .
|
||
|
|
.LP
|
||
|
|
.IN "XtQueryGeometry" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
XtGeometryResult XtQueryGeometry(\fIw\fP, \fIintended\fP, \
|
||
|
|
\fIpreferred_return\fP)
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIintended\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIpreferred_return\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1.1i
|
||
|
|
Specifies the widget. \*(rI
|
||
|
|
.IP \fIintended\fP 1.1i
|
||
|
|
Specifies the new geometry the parent plans to give to the child, or
|
||
|
|
NULL.
|
||
|
|
.IP \fIpreferred_return\fP 1.1i
|
||
|
|
Returns the child widget's preferred geometry.
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
To discover a child's preferred geometry,
|
||
|
|
the child's parent stores the new
|
||
|
|
geometry in the corresponding fields of
|
||
|
|
the intended structure, sets the corresponding bits in \fIintended.request_mode\fP,
|
||
|
|
and calls
|
||
|
|
.PN XtQueryGeometry .
|
||
|
|
The parent should set only those fields that are important to it so
|
||
|
|
that the child can determine whether it may be able to attempt changes to
|
||
|
|
other fields.
|
||
|
|
.LP
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
clears all bits in the \fIpreferred_return->request_mode\fP
|
||
|
|
field and checks the
|
||
|
|
\fIquery_geometry\fP field of the specified widget's class record.
|
||
|
|
If \fIquery_geometry\fP is not NULL,
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
calls the query_geometry procedure and passes as arguments the
|
||
|
|
specified widget, \fIintended\fP, and \fIpreferred_return\fP structures.
|
||
|
|
If the \fIintended\fP argument is NULL,
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
replaces it with a pointer to an
|
||
|
|
.PN XtWidgetGeometry
|
||
|
|
structure with \fIrequest_mode\fP equal to zero before calling the
|
||
|
|
query_geometry procedure.
|
||
|
|
.NT
|
||
|
|
If
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
is called from within a geometry_manager
|
||
|
|
procedure for the widget that issued
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
or
|
||
|
|
.PN XtMakeResizeRequest ,
|
||
|
|
the results
|
||
|
|
are not guaranteed to be consistent with the requested changes. The
|
||
|
|
change request passed to the geometry manager takes precedence over
|
||
|
|
the preferred geometry.
|
||
|
|
.NE
|
||
|
|
.sp
|
||
|
|
.LP
|
||
|
|
The query_geometry procedure pointer is of type
|
||
|
|
.PN XtGeometryHandler .
|
||
|
|
.LP
|
||
|
|
.IN "query_geometry procedure" "" "@DEF@"
|
||
|
|
.sM
|
||
|
|
.FD 0
|
||
|
|
typedef XtGeometryResult (*XtGeometryHandler)(Widget, XtWidgetGeometry*, \
|
||
|
|
XtWidgetGeometry*);
|
||
|
|
.br
|
||
|
|
Widget \fIw\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIrequest\fP;
|
||
|
|
.br
|
||
|
|
XtWidgetGeometry *\fIpreferred_return\fP;
|
||
|
|
.FN
|
||
|
|
.IP \fIw\fP 1.2i
|
||
|
|
Passes the child widget whose preferred geometry is required.
|
||
|
|
.IP \fIrequest\fP 1.2i
|
||
|
|
Passes the geometry changes that the parent plans to make.
|
||
|
|
.IP \fIpreferred_return\fP 1.2i
|
||
|
|
Passes a structure in which the child returns its preferred geometry.
|
||
|
|
.LP
|
||
|
|
.eM
|
||
|
|
.IN "query_geometry procedure"
|
||
|
|
The query_geometry procedure is expected to examine the bits set in
|
||
|
|
\fIrequest->request_mode\fP, evaluate the preferred geometry of the widget,
|
||
|
|
and store the result in \fIpreferred_return\fP
|
||
|
|
(setting the bits in \fIpreferred_return->request_mode\fP corresponding
|
||
|
|
to those geometry fields that it cares about).
|
||
|
|
If the proposed geometry change is acceptable without modification,
|
||
|
|
the query_geometry procedure should return
|
||
|
|
.PN XtGeometryYes .
|
||
|
|
If at least one field in \fIpreferred_return\fP
|
||
|
|
with a bit set in \fIpreferred_return->request_mode\fP
|
||
|
|
is different
|
||
|
|
from the corresponding field in \fIrequest\fP
|
||
|
|
or if a bit was set in \fIpreferred_return->request_mode\fP
|
||
|
|
that was not set in the request,
|
||
|
|
the query_geometry procedure should return
|
||
|
|
.PN XtGeometryAlmost .
|
||
|
|
If the preferred geometry is identical to the current geometry,
|
||
|
|
the query_geometry procedure should return
|
||
|
|
.PN XtGeometryNo .
|
||
|
|
.NT
|
||
|
|
The query_geometry procedure may assume
|
||
|
|
that no
|
||
|
|
.PN XtMakeResizeRequest
|
||
|
|
or
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
is in progress
|
||
|
|
for the specified widget; that is, it is not required to construct
|
||
|
|
a reply consistent with the requested geometry if such a request
|
||
|
|
were actually outstanding.
|
||
|
|
.NE
|
||
|
|
.LP
|
||
|
|
After calling the query_geometry procedure
|
||
|
|
or if the \fIquery_geometry\fP field is NULL,
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
examines all the unset bits in \fIpreferred_return->request_mode\fP
|
||
|
|
and sets the corresponding fields in \fIpreferred_return\fP
|
||
|
|
to the current values from the widget instance.
|
||
|
|
If
|
||
|
|
.PN CWStackMode
|
||
|
|
is not set,
|
||
|
|
the \fIstack_mode\fP field is set to
|
||
|
|
.PN XtSMDontChange .
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
returns the value returned by the query_geometry procedure or
|
||
|
|
.PN XtGeometryYes
|
||
|
|
if the \fIquery_geometry\fP field is NULL.
|
||
|
|
.LP
|
||
|
|
Therefore, the caller can interpret a return of
|
||
|
|
.PN XtGeometryYes
|
||
|
|
as not needing to evaluate the contents of the reply and, more important,
|
||
|
|
not needing to modify its layout plans.
|
||
|
|
A return of
|
||
|
|
.PN XtGeometryAlmost
|
||
|
|
means either that both the parent and the child expressed interest
|
||
|
|
in at least one common field and the child's preference does not match
|
||
|
|
the parent's intentions or that the child expressed interest in a field that
|
||
|
|
the parent might need to consider.
|
||
|
|
A return value of
|
||
|
|
.PN XtGeometryNo
|
||
|
|
means that both the parent and the child expressed interest in a field and
|
||
|
|
that the child suggests that the field's current value in the widget instance
|
||
|
|
is its preferred value.
|
||
|
|
In addition, whether or not the caller ignores the return value or the
|
||
|
|
reply mask, it is guaranteed that the \fIpreferred_return\fP structure contains complete
|
||
|
|
geometry information for the child.
|
||
|
|
.LP
|
||
|
|
Parents are expected to call
|
||
|
|
.PN XtQueryGeometry
|
||
|
|
in their layout routine and wherever else the information is significant
|
||
|
|
after change_managed has been called.
|
||
|
|
The first time it is invoked,
|
||
|
|
the changed_managed procedure may assume that the child's current geometry
|
||
|
|
is its preferred geometry.
|
||
|
|
Thus, the child is still responsible for storing values
|
||
|
|
into its own geometry during its initialize procedure.
|
||
|
|
|
||
|
|
.NH 2
|
||
|
|
Size Change Management: The resize Procedure
|
||
|
|
.XS
|
||
|
|
\*(SN Size Change Management: The resize Procedure
|
||
|
|
.XE
|
||
|
|
.LP
|
||
|
|
A child can be resized by its parent at any time.
|
||
|
|
Widgets usually need to know when they have changed size
|
||
|
|
so that they can lay out their displayed data again to match the new size.
|
||
|
|
When a parent resizes a child, it calls
|
||
|
|
.PN XtResizeWidget ,
|
||
|
|
which updates the geometry fields in the widget,
|
||
|
|
configures the window if the widget is realized,
|
||
|
|
and calls the child's resize procedure to notify the child.
|
||
|
|
The resize procedure pointer is of type
|
||
|
|
.PN XtWidgetProc .
|
||
|
|
.IN "resize procedure" "" "@DEF@"
|
||
|
|
.LP
|
||
|
|
If a class need not recalculate anything when a widget is resized,
|
||
|
|
it can specify NULL for the \fIresize\fP field in its class record.
|
||
|
|
This is an unusual case and should occur only for widgets
|
||
|
|
with very trivial display semantics.
|
||
|
|
The resize procedure takes a widget as its only argument.
|
||
|
|
The \fIx\fP, \fIy\fP, \fIwidth\fP, \fIheight\fP,
|
||
|
|
and \fIborder_width\fP fields of the widget contain the new values.
|
||
|
|
The resize procedure should recalculate the layout of internal data
|
||
|
|
as needed.
|
||
|
|
(For example, a centered Label in a window that changes size
|
||
|
|
should recalculate the starting position of the text.)
|
||
|
|
The widget must obey resize as a command and must not treat it as a request.
|
||
|
|
A widget must not issue an
|
||
|
|
.PN XtMakeGeometryRequest
|
||
|
|
or
|
||
|
|
.PN XtMakeResizeRequest
|
||
|
|
call from its resize procedure.
|
||
|
|
.bp
|