aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/Xaw/Form.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/Xaw/Form.c')
-rw-r--r--nx-X11/lib/Xaw/Form.c1110
1 files changed, 1110 insertions, 0 deletions
diff --git a/nx-X11/lib/Xaw/Form.c b/nx-X11/lib/Xaw/Form.c
new file mode 100644
index 000000000..1d162407b
--- /dev/null
+++ b/nx-X11/lib/Xaw/Form.c
@@ -0,0 +1,1110 @@
+/* $Xorg: Form.c,v 1.4 2001/02/09 02:03:43 xorgcvs Exp $ */
+
+/***********************************************************
+
+Copyright 1987, 1988, 1994, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 Open Group 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 Open Group.
+
+
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear 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 advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+/* $XFree86: xc/lib/Xaw/Form.c,v 1.20 2001/02/05 22:38:04 paulo Exp $ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+#include <X11/Xmu/CharSet.h>
+#include <X11/Xmu/Converters.h>
+#include <X11/Xaw/FormP.h>
+#include <X11/Xaw/XawInit.h>
+#include "Private.h"
+
+/*
+ * Class Methods
+ */
+static void XawFormChangeManaged(Widget);
+static void XawFormClassInitialize(void);
+static void XawFormClassPartInitialize(WidgetClass);
+static void XawFormConstraintInitialize(Widget, Widget, ArgList, Cardinal*);
+static Boolean XawFormConstraintSetValues(Widget, Widget, Widget,
+ ArgList, Cardinal*);
+static XtGeometryResult XawFormGeometryManager(Widget, XtWidgetGeometry*,
+ XtWidgetGeometry*);
+static void XawFormInitialize(Widget, Widget, ArgList, Cardinal*);
+#ifndef OLDXAW
+static void XawFormRealize(Widget, Mask*, XSetWindowAttributes*);
+static void XawFormRedisplay(Widget, XEvent*, Region);
+#endif
+static XtGeometryResult XawFormQueryGeometry(Widget, XtWidgetGeometry*,
+ XtWidgetGeometry*);
+static void XawFormResize(Widget);
+static Boolean XawFormSetValues(Widget, Widget, Widget, ArgList, Cardinal*);
+static Boolean Layout(FormWidget, unsigned int, unsigned int, Bool);
+
+/*
+ * Prototypes
+ */
+static void _CvtStringToEdgeType(XrmValuePtr, Cardinal*,
+ XrmValuePtr, XrmValuePtr);
+static Bool ChangeFormGeometry(Widget, Bool, unsigned int, unsigned int,
+ Dimension*, Dimension*);
+Boolean CvtEdgeTypeToString(Display*, XrmValuePtr, Cardinal*,
+ XrmValuePtr, XrmValuePtr, XtPointer*);
+static void LayoutChild(Widget);
+static int TransformCoord(int, unsigned int, unsigned int, XtEdgeType);
+static void ResizeChildren(Widget);
+
+/*
+ * Initialization
+ */
+#ifndef OLDXAW
+static XtActionsRec actions[] = {
+ {"set-values", XawSetValuesAction},
+ {"get-values", XawGetValuesAction},
+ {"declare", XawDeclareAction},
+ {"call-proc", XawCallProcAction},
+};
+#endif
+
+static XrmQuark QchainLeft, QchainRight, QchainTop, QchainBottom, Qrubber;
+
+#define default_value -99999
+#define Offset(field) XtOffsetOf(FormRec, form.field)
+static XtResource resources[] = {
+ {
+ XtNdefaultDistance,
+ XtCThickness,
+ XtRInt,
+ sizeof(int),
+ Offset(default_spacing),
+ XtRImmediate,
+ (XtPointer)4
+ },
+#ifndef OLDXAW
+ {
+ XawNdisplayList,
+ XawCDisplayList,
+ XawRDisplayList,
+ sizeof(XawDisplayList*),
+ Offset(display_list),
+ XtRImmediate,
+ NULL
+ },
+#endif
+};
+#undef Offset
+
+#define defEdge XtRubber
+
+#define Offset(field) XtOffsetOf(FormConstraintsRec, form.field)
+static XtResource formConstraintResources[] = {
+ {
+ XtNtop,
+ XtCEdge,
+ XtREdgeType,
+ sizeof(XtEdgeType),
+ Offset(top),
+ XtRImmediate,
+ (XtPointer)defEdge
+ },
+ {
+ XtNbottom,
+ XtCEdge,
+ XtREdgeType,
+ sizeof(XtEdgeType),
+ Offset(bottom),
+ XtRImmediate,
+ (XtPointer)defEdge
+ },
+ {
+ XtNleft,
+ XtCEdge,
+ XtREdgeType,
+ sizeof(XtEdgeType),
+ Offset(left),
+ XtRImmediate,
+ (XtPointer)defEdge
+ },
+ {
+ XtNright,
+ XtCEdge,
+ XtREdgeType,
+ sizeof(XtEdgeType),
+ Offset(right),
+ XtRImmediate,
+ (XtPointer)defEdge
+ },
+ {
+ XtNhorizDistance,
+ XtCThickness,
+ XtRInt,
+ sizeof(int),
+ Offset(dx),
+ XtRImmediate,
+ (XtPointer)default_value
+ },
+ {
+ XtNfromHoriz,
+ XtCWidget,
+ XtRWidget,
+ sizeof(Widget),
+ Offset(horiz_base),
+ XtRWidget,
+ NULL
+ },
+ {
+ XtNvertDistance,
+ XtCThickness,
+ XtRInt,
+ sizeof(int),
+ Offset(dy),
+ XtRImmediate,
+ (XtPointer)default_value
+ },
+ {
+ XtNfromVert,
+ XtCWidget,
+ XtRWidget,
+ sizeof(Widget),
+ Offset(vert_base),
+ XtRWidget,
+ NULL
+ },
+ {
+ XtNresizable,
+ XtCBoolean,
+ XtRBoolean,
+ sizeof(Boolean),
+ Offset(allow_resize),
+ XtRImmediate,
+ (XtPointer)False
+ },
+};
+#undef Offset
+
+FormClassRec formClassRec = {
+ /* core */
+ {
+ (WidgetClass)&constraintClassRec, /* superclass */
+ "Form", /* class_name */
+ sizeof(FormRec), /* widget_size */
+ XawFormClassInitialize, /* class_initialize */
+ XawFormClassPartInitialize, /* class_part_init */
+ False, /* class_inited */
+ XawFormInitialize, /* initialize */
+ NULL, /* initialize_hook */
+#ifndef OLDXAW
+ XawFormRealize, /* realize */
+ actions, /* actions */
+ XtNumber(actions), /* num_actions */
+#else
+ XtInheritRealize, /* realize */
+ NULL, /* actions */
+ 0, /* num_actions */
+#endif
+ resources, /* resources */
+ XtNumber(resources), /* num_resources */
+ NULLQUARK, /* xrm_class */
+ True, /* compress_motion */
+ True, /* compress_exposure */
+ True, /* compress_enterleave */
+ False, /* visible_interest */
+ NULL, /* destroy */
+ XawFormResize, /* resize */
+#ifndef OLDXAW
+ XawFormRedisplay, /* expose */
+#else
+ XtInheritExpose, /* expose */
+#endif
+ XawFormSetValues, /* set_values */
+ NULL, /* set_values_hook */
+ XtInheritSetValuesAlmost, /* set_values_almost */
+ NULL, /* get_values_hook */
+ NULL, /* accept_focus */
+ XtVersion, /* version */
+ NULL, /* callback_private */
+ NULL, /* tm_table */
+ XawFormQueryGeometry, /* query_geometry */
+ XtInheritDisplayAccelerator, /* display_accelerator */
+ NULL, /* extension */
+ },
+ /* composite */
+ {
+ XawFormGeometryManager, /* geometry_manager */
+ XawFormChangeManaged, /* change_managed */
+ XtInheritInsertChild, /* insert_child */
+ XtInheritDeleteChild, /* delete_child */
+ NULL, /* extension */
+ },
+ /* constraint */
+ {
+ formConstraintResources, /* subresourses */
+ XtNumber(formConstraintResources), /* subresource_count */
+ sizeof(FormConstraintsRec), /* constraint_size */
+ XawFormConstraintInitialize, /* initialize */
+ NULL, /* destroy */
+ XawFormConstraintSetValues, /* set_values */
+ NULL, /* extension */
+ },
+ /* form */
+ {
+ Layout, /* layout */
+ },
+};
+
+WidgetClass formWidgetClass = (WidgetClass)&formClassRec;
+
+/*
+ * Implementation
+ */
+#ifndef OLDXAW
+static void
+XawFormRealize(Widget w, Mask *mask, XSetWindowAttributes *attr)
+{
+ XawPixmap *pixmap;
+
+ (*formWidgetClass->core_class.superclass->core_class.realize)(w, mask, attr);
+
+ if (w->core.background_pixmap > XtUnspecifiedPixmap) {
+ pixmap = XawPixmapFromXPixmap(w->core.background_pixmap, XtScreen(w),
+ w->core.colormap, w->core.depth);
+ if (pixmap && pixmap->mask)
+ XawReshapeWidget(w, pixmap);
+ }
+}
+
+static void
+XawFormRedisplay(Widget w, XEvent *event, Region region)
+{
+ FormWidget xaw = (FormWidget)w;
+
+ if (xaw->form.display_list)
+ XawRunDisplayList(w, xaw->form.display_list, event, region);
+}
+#endif
+
+/*ARGSUSED*/
+static void
+_CvtStringToEdgeType(XrmValuePtr args, Cardinal *num_args,
+ XrmValuePtr fromVal, XrmValuePtr toVal)
+{
+ static XtEdgeType edgeType;
+ XrmQuark q;
+ char name[12];
+
+ XmuNCopyISOLatin1Lowered(name, (char*)fromVal->addr, sizeof(name));
+ q = XrmStringToQuark(name);
+
+ if (q == QchainLeft)
+ edgeType = XtChainLeft;
+ else if (q == QchainRight)
+ edgeType = XtChainRight;
+ else if (q == QchainTop)
+ edgeType = XtChainTop;
+ else if (q == QchainBottom)
+ edgeType = XtChainBottom;
+ else if (q == Qrubber)
+ edgeType = XtRubber;
+ else {
+ XtStringConversionWarning(fromVal->addr, XtREdgeType);
+ toVal->size = 0;
+ toVal->addr = NULL;
+ return;
+ }
+
+ toVal->size = sizeof(XtEdgeType);
+ toVal->addr = (XPointer)&edgeType;
+}
+
+/*ARGSUSED*/
+Boolean
+CvtEdgeTypeToString(Display *dpy, XrmValuePtr args, Cardinal *num_args,
+ XrmValuePtr fromVal, XrmValuePtr toVal, XtPointer *data)
+{
+ static String buffer;
+ Cardinal size;
+
+ switch (*(XtEdgeType *)fromVal->addr) {
+ case XtChainLeft:
+ buffer = XtEchainLeft;
+ break;
+ case XtChainRight:
+ buffer = XtEchainRight;
+ break;
+ case XtChainTop:
+ buffer = XtEchainTop;
+ break;
+ case XtChainBottom:
+ buffer = XtEchainBottom;
+ break;
+ case XtRubber:
+ buffer = XtErubber;
+ break;
+ default:
+ XawTypeToStringWarning(dpy, XtREdgeType);
+ toVal->addr = NULL;
+ toVal->size = 0;
+ return (False);
+ }
+
+ size = strlen(buffer) + 1;
+ if (toVal->addr != NULL) {
+ if (toVal->size < size) {
+ toVal->size = size;
+ return (False);
+ }
+ strcpy((char *)toVal->addr, buffer);
+ }
+ else
+ toVal->addr = (XPointer)buffer;
+ toVal->size = sizeof(String);
+
+ return (True);
+}
+
+static void
+XawFormClassInitialize(void)
+{
+ static XtConvertArgRec parentCvtArgs[] = {
+ {XtBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.parent),
+ sizeof(Widget)}
+ };
+
+ char name[12];
+
+ XawInitializeWidgetSet();
+ XmuNCopyISOLatin1Lowered(name, XtEchainLeft, sizeof(name));
+ QchainLeft = XrmStringToQuark(name);
+ XmuNCopyISOLatin1Lowered(name, XtEchainRight, sizeof(name));
+ QchainRight = XrmStringToQuark(name);
+ XmuNCopyISOLatin1Lowered(name, XtEchainTop, sizeof(name));
+ QchainTop = XrmStringToQuark(name);
+ XmuNCopyISOLatin1Lowered(name, XtEchainBottom, sizeof(name));
+ QchainBottom = XrmStringToQuark(name);
+ XmuNCopyISOLatin1Lowered(name, XtErubber, sizeof(name));
+ Qrubber = XrmStringToQuark(name);
+
+ XtAddConverter(XtRString, XtREdgeType, _CvtStringToEdgeType, NULL, 0);
+ XtSetTypeConverter(XtREdgeType, XtRString, CvtEdgeTypeToString,
+ NULL, 0, XtCacheNone, NULL);
+ XtSetTypeConverter(XtRString, XtRWidget, XmuNewCvtStringToWidget,
+ parentCvtArgs, XtNumber(parentCvtArgs), XtCacheNone,
+ NULL);
+ XtSetTypeConverter(XtRWidget, XtRString, XmuCvtWidgetToString,
+ NULL, 0, XtCacheNone, NULL);
+}
+
+static void
+XawFormClassPartInitialize(WidgetClass cclass)
+{
+ FormWidgetClass c = (FormWidgetClass)cclass;
+ FormWidgetClass super = (FormWidgetClass)c->core_class.superclass;
+
+ if (c->form_class.layout == XtInheritLayout)
+ c->form_class.layout = super->form_class.layout;
+}
+
+/*ARGSUSED*/
+static void
+XawFormInitialize(Widget request, Widget cnew,
+ ArgList args, Cardinal *num_args)
+{
+ FormWidget fw = (FormWidget)cnew;
+
+ fw->form.old_width = fw->form.old_height = 0;
+ fw->form.no_refigure = False;
+ fw->form.needs_relayout = False;
+ fw->form.resize_in_layout = True;
+ fw->form.resize_is_no_op = False;
+}
+
+/*
+ * Function:
+ * ChangeFormGeometry
+ *
+ * Parameters:
+ * w - Form widget
+ * query_only - is only a query?
+ * width - new width and height
+ * height - ""
+ * ret_width - actual size the form is allowed to resize to (return)
+ * ret_height - ""
+ *
+ * Description:
+ * Ask the parent to change the form widget's geometry.
+ *
+ * Returns:
+ * True of children may always be resized
+ */
+static Bool
+ChangeFormGeometry(Widget w, Bool query_only,
+ unsigned int width, unsigned int height,
+ Dimension *ret_width, Dimension *ret_height)
+{
+ FormWidget fw = (FormWidget)w;
+ Boolean always_resize_children;
+ XtGeometryResult result;
+ XtWidgetGeometry request, return_request;
+
+ /*
+ * If we are already at the desired size then there is no need
+ * to ask our parent of we can change size
+ */
+ if (width == XtWidth(fw) && height == XtHeight(fw))
+ return (True);
+
+ request.width = width;
+ request.height = height;
+ request.request_mode = CWWidth | CWHeight;
+ if (query_only)
+ request.request_mode |= XtCWQueryOnly;
+
+ /*
+ * Do no invoke the resize rules if our size changes here
+ */
+ fw->form.resize_is_no_op = True;
+
+ result = XtMakeGeometryRequest(w, &request, &return_request);
+ if (result == XtGeometryAlmost) {
+ request = return_request;
+ (void)XtMakeGeometryRequest(w, &request, &return_request);
+ always_resize_children = False;
+ }
+ else
+ always_resize_children = result == XtGeometryYes;
+
+ fw->form.resize_is_no_op = False;
+
+ if (ret_width != NULL)
+ *ret_width = request.width;
+ if (ret_height != NULL)
+ *ret_height = request.height;
+
+ return (always_resize_children);
+}
+
+/*
+ * Function:
+ * Layout
+ *
+ * Parameters:
+ * fw - Form widget
+ * width - unused
+ * height - ""
+ * force_relayout - will force the children to be moved, even if some
+ * go past the edge of the form
+ *
+ * Description:
+ * Moves all the children around.
+ *
+ * Returns:
+ * True if the children are allowed to move from their
+ * current locations to the new ones.
+ */
+/*ARGSUSED*/
+static Boolean
+Layout(FormWidget fw, unsigned int width, unsigned int height,
+ Bool force_relayout)
+{
+ int num_children = fw->composite.num_children;
+ WidgetList children = fw->composite.children;
+ Widget *childP;
+ Dimension maxx, maxy;
+ Boolean ret_val;
+
+ for (childP = children; childP - children < num_children; childP++) {
+ FormConstraints form = (FormConstraints)(*childP)->core.constraints;
+ form->form.layout_state = LayoutPending;
+ }
+
+ maxx = maxy = 1;
+ for (childP = children; childP - children < num_children; childP++) {
+ if (XtIsManaged(*childP)) {
+ FormConstraints form;
+ Position x, y;
+
+ form = (FormConstraints)(*childP)->core.constraints;
+
+ LayoutChild(*childP);
+
+ x = form->form.new_x + XtWidth(*childP)
+ + (XtBorderWidth(*childP) << 1);
+ if (x > (int)maxx)
+ maxx = x;
+
+ y = form->form.new_y + XtHeight(*childP)
+ + (XtBorderWidth(*childP) << 1);
+ if (y > (int)maxy)
+ maxy = y;
+ }
+ }
+
+ fw->form.preferred_width = (maxx += fw->form.default_spacing);
+ fw->form.preferred_height = (maxy += fw->form.default_spacing);
+
+ if (fw->form.resize_in_layout) {
+ Boolean always_resize_children;
+
+ always_resize_children =
+ ChangeFormGeometry((Widget)fw, False, maxx, maxy, NULL, NULL);
+
+#ifdef OLDXAW
+ fw->form.old_width = fw->core.width;
+ fw->form.old_height = fw->core.height;
+#endif
+
+ if (force_relayout)
+ ret_val = True;
+ else
+ ret_val = always_resize_children ||
+ (XtWidth(fw) >= maxx && XtHeight(fw) >= maxy);
+
+ if (ret_val)
+ ResizeChildren((Widget)fw);
+ }
+ else
+ ret_val = False;
+
+ fw->form.needs_relayout = False;
+
+ return (ret_val);
+}
+
+/*
+ * Function:
+ * ResizeChildren
+ *
+ * Parameters:
+ * w - form widget
+ *
+ * Description:
+ * Resizes all children to new_x and new_y.
+ */
+static void
+ResizeChildren(Widget w)
+{
+ FormWidget fw = (FormWidget)w;
+ int num_children = fw->composite.num_children;
+ WidgetList children = fw->composite.children;
+ Widget *childP;
+
+ for (childP = children; childP - children < num_children; childP++) {
+ FormConstraints form;
+ Position x, y;
+
+ if (!XtIsManaged(*childP))
+ continue;
+
+ form = (FormConstraints)(*childP)->core.constraints;
+
+ if (fw->form.old_width && fw->form.old_height) {
+ x = TransformCoord(form->form.new_x, fw->form.old_width,
+ XtWidth(fw), form->form.left);
+ y = TransformCoord(form->form.new_y, fw->form.old_height,
+ XtHeight(fw), form->form.top);
+ }
+ else {
+ x = form->form.new_x;
+ y = form->form.new_y;
+ }
+
+ if (fw->form.no_refigure) {
+ /*
+ * I am changing the widget wrapper w/o modifing the window. This is
+ * risky, but I can get away with it since I am the parent of this
+ * widget, and he must ask me for any geometry changes
+ *
+ * The window will be updated when no_refigure is set back to False
+ */
+ XtX(*childP) = x;
+ XtY(*childP) = y;
+ }
+ else
+ XtMoveWidget(*childP, x, y);
+ }
+}
+
+static void
+LayoutChild(Widget w)
+{
+ FormConstraints form = (FormConstraints)w->core.constraints;
+ Widget ref;
+
+ switch (form->form.layout_state) {
+ case LayoutPending:
+ form->form.layout_state = LayoutInProgress;
+ break;
+ case LayoutDone:
+ return;
+ case LayoutInProgress: {
+ String subs[2];
+ Cardinal num_subs = 2;
+ subs[0] = w->core.name;
+ subs[1] = w->core.parent->core.name;
+
+ XtAppWarningMsg(XtWidgetToApplicationContext(w),
+ "constraintLoop", "xawFormLayout", "XawToolkitError",
+ "constraint loop detected while laying out "
+ "child '%s' in FormWidget '%s'",
+ subs, &num_subs);
+ } return;
+ }
+
+ form->form.new_x = form->form.dx;
+ form->form.new_y = form->form.dy;
+ if ((ref = form->form.horiz_base) != NULL) {
+ FormConstraints ref_form = (FormConstraints)ref->core.constraints;
+
+ LayoutChild(ref);
+ form->form.new_x += ref_form->form.new_x + XtWidth(ref) +
+ (XtBorderWidth(ref) << 1);
+ }
+ if ((ref = form->form.vert_base) != NULL) {
+ FormConstraints ref_form = (FormConstraints)ref->core.constraints;
+
+ LayoutChild(ref);
+ form->form.new_y += ref_form->form.new_y + XtHeight(ref) +
+ (XtBorderWidth(ref) << 1);
+ }
+
+ form->form.layout_state = LayoutDone;
+}
+
+static int
+TransformCoord(int loc, unsigned int old, unsigned int cnew, XtEdgeType type)
+{
+ if (type == XtRubber) {
+ if ((int)old > 0)
+ loc = (int)(loc * ((double)cnew / (double)old));
+ }
+ else if (type == XtChainBottom || type == XtChainRight)
+ loc += (int)cnew - (int)old;
+
+ return (loc);
+}
+
+static void
+XawFormResize(Widget w)
+{
+ FormWidget fw = (FormWidget)w;
+ WidgetList children = fw->composite.children;
+ int num_children = fw->composite.num_children;
+ Widget *childP;
+ int x, y;
+ int width, height;
+ Boolean unmap = XtIsRealized(w) && w->core.mapped_when_managed &&
+ XtIsManaged(w);
+
+ if (unmap)
+ XtUnmapWidget(w);
+
+ if (!fw->form.resize_is_no_op)
+ for (childP = children; childP - children < num_children; childP++) {
+ FormConstraints form = (FormConstraints)(*childP)->core.constraints;
+
+ if (!XtIsManaged(*childP))
+ continue;
+
+#ifndef OLDXAW
+ x = TransformCoord(form->form.virtual_x, fw->form.old_width,
+ XtWidth(fw), form->form.left);
+ y = TransformCoord(form->form.virtual_y, fw->form.old_height,
+ XtHeight(fw), form->form.top);
+ width = TransformCoord(form->form.virtual_x +
+ form->form.virtual_width +
+ (XtBorderWidth(*childP) << 1),
+ fw->form.old_width, XtWidth(fw),
+ form->form.right) -
+ (x + (XtBorderWidth(*childP) << 1));
+ height = TransformCoord(form->form.virtual_y +
+ form->form.virtual_height +
+ (XtBorderWidth(*childP) << 1),
+ fw->form.old_height, XtHeight(fw),
+ form->form.bottom) -
+ (y + (XtBorderWidth(*childP) << 1));
+#else
+ x = TransformCoord(XtX(*childP), fw->form.old_width,
+ XtWidth(fw), form->form.left);
+ y = TransformCoord(XtY(*childP), fw->form.old_height,
+ XtHeight(fw), form->form.top);
+ width = TransformCoord(XtX(*childP) + form->form.virtual_width +
+ (XtBorderWidth(*childP) << 1),
+ fw->form.old_width, XtWidth(fw),
+ form->form.right) -
+ (x + (XtBorderWidth(*childP) << 1));
+ height = TransformCoord(XtY(*childP) + form->form.virtual_height +
+ (XtBorderWidth(*childP) << 1),
+ fw->form.old_height, XtHeight(fw),
+ form->form.bottom) -
+ (y + (XtBorderWidth(*childP) << 1));
+ form->form.virtual_width = width;
+ form->form.virtual_height = height;
+#endif
+
+ width = width < 1 ? 1 : width;
+ height = height < 1 ? 1 : height;
+
+ XtConfigureWidget(*childP, x, y, width, height,
+ XtBorderWidth(*childP));
+ }
+
+ if (unmap)
+ XtMapWidget(w);
+
+#ifdef OLDXAW
+ fw->form.old_width = XtWidth(fw);
+ fw->form.old_height = XtHeight(fw);
+#endif
+}
+
+/*ARGSUSED*/
+static XtGeometryResult
+XawFormGeometryManager(Widget w, XtWidgetGeometry *request,
+ XtWidgetGeometry *reply)
+{
+ Dimension old_width, old_height;
+ FormWidget fw = (FormWidget)XtParent(w);
+ FormConstraints form = (FormConstraints)w->core.constraints;
+ XtWidgetGeometry allowed;
+ XtGeometryResult ret_val;
+
+ if ((request->request_mode & (unsigned)~(XtCWQueryOnly | CWWidth | CWHeight))
+ || !form->form.allow_resize) {
+ /* If GeometryManager is invoked during a SetValues call on a child
+ * then it is necessary to compute a new layout if ConstraintSetValues
+ * allowed any constraint changes
+ */
+ if (fw->form.needs_relayout)
+ (*((FormWidgetClass)fw->core.widget_class)->form_class.layout)
+ (fw, 0, 0, True);
+ return (XtGeometryNo);
+ }
+
+ if (request->request_mode & CWWidth)
+ allowed.width = request->width;
+ else
+ allowed.width = XtWidth(w);
+
+ if (request->request_mode & CWHeight)
+ allowed.height = request->height;
+ else
+ allowed.height = XtHeight(w);
+
+ if (allowed.width == XtWidth(w) && allowed.height == XtHeight(w)) {
+ /* If GeometryManager is invoked during a SetValues call on a child
+ * then it is necessary to compute a new layout if ConstraintSetValues
+ * allowed any constraint changes
+ */
+ if (fw->form.needs_relayout)
+ (*((FormWidgetClass)fw->core.widget_class)->form_class.layout)
+ (fw, 0, 0, True);
+ return (XtGeometryNo);
+ }
+
+ /*
+ * Remember the old size, and then set the size to the requested size
+ */
+ old_width = XtWidth(w);
+ old_height = XtHeight(w);
+ XtWidth(w) = allowed.width;
+ XtHeight(w) = allowed.height;
+
+ if (request->request_mode & XtCWQueryOnly) {
+ Boolean always_resize_children;
+ Dimension ret_width, ret_height;
+
+ fw->form.resize_in_layout = False;
+
+ (*((FormWidgetClass)fw->core.widget_class)->form_class.layout)
+ (fw, XtWidth(w), XtHeight(w), False);
+
+ /*
+ * Reset the size of this child back to what it used to be
+ */
+ XtWidth(w) = old_width;
+ XtHeight(w) = old_height;
+
+ fw->form.resize_in_layout = True;
+
+ always_resize_children = ChangeFormGeometry(w, True,
+ fw->form.preferred_width,
+ fw->form.preferred_height,
+ &ret_width, &ret_height);
+
+ if (always_resize_children
+ || (ret_width >= fw->form.preferred_width
+ && ret_height >= fw->form.preferred_height))
+ ret_val = XtGeometryYes;
+ else
+ ret_val = XtGeometryNo;
+ }
+ else {
+ if ((*((FormWidgetClass)fw->core.widget_class)->form_class.layout)
+ (fw, XtWidth(w), XtHeight(w), False)) {
+ Widget *childP;
+ int num_children = fw->composite.num_children;
+ WidgetList children = fw->composite.children;
+
+ if (fw->form.no_refigure) {
+ /*
+ * I am changing the widget wrapper w/o modifing the window.
+ * This is risky, but I can get away with it since I am the
+ * parent of this widget, and he must ask me for any geometry
+ * changes
+ *
+ * The window will be updated when no_refigure is set back
+ * to False
+ */
+ form->form.deferred_resize = True;
+ ret_val = XtGeometryDone;
+ }
+ else
+ ret_val = XtGeometryYes;
+
+ /*
+ * Resets everything.
+ */
+ fw->form.old_width = XtWidth(fw);
+ fw->form.old_height = XtHeight(fw);
+ for (childP = children; childP - children < num_children; childP++) {
+ Widget nw = *childP;
+
+ if (XtIsManaged(nw)) {
+ FormConstraints nform = (FormConstraints)nw->core.constraints;
+
+#ifndef OLDXAW
+ nform->form.virtual_x = XtX(nw);
+ nform->form.virtual_y = XtY(nw);
+#endif
+ nform->form.virtual_width = XtWidth(nw);
+ nform->form.virtual_height = XtHeight(nw);
+ }
+ }
+ }
+ else {
+ XtWidth(w) = old_width;
+ XtHeight(w) = old_height;
+ ret_val = XtGeometryNo;
+ }
+ }
+
+ return (ret_val);
+}
+
+/*ARGSUSED*/
+static Boolean
+XawFormSetValues(Widget current, Widget request, Widget cnew,
+ ArgList args, Cardinal *num_args)
+{
+#ifndef OLDXAW
+ FormWidget f_old = (FormWidget)current;
+ FormWidget f_new = (FormWidget)cnew;
+
+ if (f_old->core.background_pixmap != f_new->core.background_pixmap) {
+ XawPixmap *opix, *npix;
+
+ opix = XawPixmapFromXPixmap(f_old->core.background_pixmap, XtScreen(f_old),
+ f_old->core.colormap, f_old->core.depth);
+ npix = XawPixmapFromXPixmap(f_new->core.background_pixmap, XtScreen(f_new),
+ f_new->core.colormap, f_new->core.depth);
+ if ((npix && npix->mask) || (opix && opix->mask))
+ XawReshapeWidget(cnew, npix);
+ }
+#endif /* OLDXAW */
+
+ return (False);
+}
+
+/* ARGSUSED */
+static void
+XawFormConstraintInitialize(Widget request, Widget cnew,
+ ArgList args, Cardinal *num_args)
+{
+ FormConstraints form = (FormConstraints)cnew->core.constraints;
+ FormWidget fw = (FormWidget)cnew->core.parent;
+
+#ifndef OLDXAW
+ form->form.virtual_x = XtX(cnew);
+ form->form.virtual_y = XtY(cnew);
+#endif
+ form->form.virtual_width = XtWidth(cnew);
+ form->form.virtual_height = XtHeight(cnew);
+
+ if (form->form.dx == default_value)
+ form->form.dx = fw->form.default_spacing;
+
+ if (form->form.dy == default_value)
+ form->form.dy = fw->form.default_spacing;
+
+ form->form.deferred_resize = False;
+}
+
+/*ARGSUSED*/
+static Boolean
+XawFormConstraintSetValues(Widget current, Widget request, Widget cnew,
+ ArgList args, Cardinal *num_args)
+{
+ FormConstraints cfc = (FormConstraints)current->core.constraints;
+ FormConstraints nfc = (FormConstraints)cnew->core.constraints;
+
+ if (cfc->form.top != nfc->form.top || cfc->form.bottom != nfc->form.bottom
+ || cfc->form.left != nfc->form.left || cfc->form.right != nfc->form.right
+ || cfc->form.dx != nfc->form.dx || cfc->form.dy != nfc->form.dy
+ || cfc->form.horiz_base != nfc->form.horiz_base
+ || cfc->form.vert_base != nfc->form.vert_base) {
+ FormWidget fp = (FormWidget)XtParent(cnew);
+
+ /* If there are no subclass ConstraintSetValues procedures remaining
+ * to be invoked, and if there is no geometry request about to be
+ * made, then invoke the new layout now; else defer it
+ */
+ if (XtClass(XtParent(cnew)) == formWidgetClass
+ && XtX(current) == XtX(cnew)
+ && XtY(current) == XtY(cnew)
+ && XtWidth(current) == XtWidth(cnew)
+ && XtHeight(current) == XtHeight(cnew)
+ && XtBorderWidth(current) == XtBorderWidth(cnew))
+ Layout(fp, 0, 0, True);
+ else
+ fp->form.needs_relayout = True;
+ }
+
+ return (False);
+}
+
+static void
+XawFormChangeManaged(Widget w)
+{
+ FormWidget fw = (FormWidget)w;
+ FormConstraints form;
+ WidgetList children, childP;
+ int num_children = fw->composite.num_children;
+ Widget child;
+
+ (*((FormWidgetClass)w->core.widget_class)->form_class.layout)
+ (fw, XtWidth(w), XtHeight(w), True);
+
+ fw->form.old_width = XtWidth(w);
+ fw->form.old_height = XtHeight(w);
+ for (children = childP = fw->composite.children;
+ childP - children < num_children;
+ childP++) {
+ child = *childP;
+ if (!XtIsManaged(child))
+ continue;
+ form = (FormConstraints)child->core.constraints;
+#ifndef OLDXAW
+ form->form.virtual_x = XtX(child);
+ form->form.virtual_y = XtY(child);
+#endif
+ form->form.virtual_width = XtWidth(child);
+ form->form.virtual_height = XtHeight(child);
+ }
+}
+
+static XtGeometryResult
+XawFormQueryGeometry(Widget widget, XtWidgetGeometry *request,
+ XtWidgetGeometry *reply)
+{
+ FormWidget w = (FormWidget)widget;
+
+ reply->width = w->form.preferred_width;
+ reply->height = w->form.preferred_height;
+ reply->request_mode = CWWidth | CWHeight;
+
+ if ((request->request_mode & (CWWidth | CWHeight)) == (CWWidth | CWHeight)
+ && request->width == reply->width
+ && request->height == reply->height)
+ return (XtGeometryYes);
+ else if (reply->width == XtWidth(w) && reply->height == XtHeight(w))
+ return (XtGeometryNo);
+
+ return (XtGeometryAlmost);
+}
+
+/*
+ * Public routines
+ */
+/*
+ * Set or reset figuring (ignored if not realized)
+ */
+void
+XawFormDoLayout(Widget w,
+#if NeedWidePrototypes
+ Bool force
+#else
+ Boolean force
+#endif
+)
+{
+ Widget *childP;
+ FormWidget fw = (FormWidget)w;
+ int num_children = fw->composite.num_children;
+ WidgetList children = fw->composite.children;
+
+ if ((fw->form.no_refigure = !force) == True || !XtIsRealized(w))
+ return;
+
+ for (childP = children; childP - children < num_children; childP++) {
+ Widget nw = *childP;
+
+ if (XtIsManaged(nw)) {
+ FormConstraints form = (FormConstraints)nw->core.constraints;
+
+ /*
+ * Xt Configure widget is too smart, and optimizes out
+ * my changes
+ */
+ XMoveResizeWindow(XtDisplay(nw), XtWindow(nw),
+ XtX(nw), XtY(nw), XtWidth(nw), XtHeight(nw));
+
+ if (form)
+ if (form->form.deferred_resize &&
+ XtClass(nw)->core_class.resize != NULL) {
+ (*(XtClass(nw)->core_class.resize))(nw);
+ form->form.deferred_resize = False;
+ }
+ }
+ }
+}