void _XtPopup(
Widget widget,
XtGrabKind grab_kind,
_XtBoolean spring_loaded)
{
register ShellWidget shell_widget = (ShellWidget) widget;
if (! XtIsShell(widget)) {
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidClass","xtPopup",XtCXtToolkitError,
"XtPopup requires a subclass of shellWidgetClass",
(String *)NULL, (Cardinal *)NULL);
}
if (! shell_widget->shell.popped_up) {
XtGrabKind call_data = grab_kind;
XtCallCallbacks(widget, XtNpopupCallback, (XtPointer)&call_data);
shell_widget->shell.popped_up = TRUE;
shell_widget->shell.grab_kind = grab_kind;
shell_widget->shell.spring_loaded = spring_loaded;
if (shell_widget->shell.create_popup_child_proc != NULL) {
(*(shell_widget->shell.create_popup_child_proc))(widget);
}
if (grab_kind == XtGrabExclusive) {
XtAddGrab(widget, TRUE, spring_loaded);
} else if (grab_kind == XtGrabNonexclusive) {
XtAddGrab(widget, FALSE, spring_loaded);
}
XtRealizeWidget(widget);
XMapRaised(XtDisplay(widget), XtWindow(widget));
} else
XRaiseWindow(XtDisplay(widget), XtWindow(widget));
} /* _XtPopup */
Boolean CvtStringToWidget(Display *display,
XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *)
{
// Convert first arg into parent
if (*num_args != 1)
{
XtAppErrorMsg(XtDisplayToApplicationContext(display),
"wrongParameters", "CvtStringToWidget",
"XtToolkitError",
"String to Widget conversion needs parent arg",
(String *)0, (Cardinal *)0);
}
Widget parent = *(Widget *) args[0].addr;
// Get widget
const string value = str(fromVal, false);
Widget w = XtNameToWidget(parent, value.chars());
if (w == 0)
{
XtDisplayStringConversionWarning(display, fromVal->addr, XtRWidget);
return False;
}
done(Widget, w);
}
void XtCreateWindow(
Widget widget,
unsigned int window_class,
Visual *visual,
XtValueMask value_mask,
XSetWindowAttributes *attributes)
{
XtAppContext app = XtWidgetToApplicationContext(widget);
LOCK_APP(app);
if (widget->core.window == None) {
if (widget->core.width == 0 || widget->core.height == 0) {
Cardinal count = 1;
XtAppErrorMsg(app,
"invalidDimension", "xtCreateWindow", XtCXtToolkitError,
"Widget %s has zero width and/or height",
&widget->core.name, &count);
}
widget->core.window =
XCreateWindow (
XtDisplay (widget),
(widget->core.parent ?
widget->core.parent->core.window :
widget->core.screen->root),
(int)widget->core.x, (int)widget->core.y,
(unsigned)widget->core.width, (unsigned)widget->core.height,
(unsigned)widget->core.border_width, (int) widget->core.depth,
window_class, visual, value_mask, attributes);
}
UNLOCK_APP(app);
} /* XtCreateWindow */
static void
XmuFreeXftColor (XtAppContext app, XrmValuePtr toVal, XtPointer closure,
XrmValuePtr args, Cardinal *num_args)
{
Screen *screen;
Colormap colormap;
XftColor *color;
if (*num_args != 2)
{
XtAppErrorMsg (app,
"freeXftColor", "wrongParameters",
"XtToolkitError",
"Freeing an XftColor requires screen and colormap arguments",
(String *) NULL, (Cardinal *)NULL);
return;
}
screen = *((Screen **) args[0].addr);
colormap = *((Colormap *) args[1].addr);
color = (XftColor *) toVal->addr;
XftColorFree (DisplayOfScreen (screen),
DefaultVisual (DisplayOfScreen (screen),
XScreenNumberOfScreen (screen)),
colormap, color);
}
static Boolean
XmuCvtStringToXftColor(Display *dpy,
XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *converter_data)
{
char *spec;
XRenderColor renderColor;
XftColor xftColor;
Screen *screen;
Colormap colormap;
if (*num_args != 2)
{
XtAppErrorMsg (XtDisplayToApplicationContext (dpy),
"cvtStringToXftColor", "wrongParameters",
"XtToolkitError",
"String to render color conversion needs screen and colormap arguments",
(String *) NULL, (Cardinal *)NULL);
return False;
}
screen = *((Screen **) args[0].addr);
colormap = *((Colormap *) args[1].addr);
spec = (char *) fromVal->addr;
if (strcasecmp (spec, XtDefaultForeground) == 0)
{
renderColor.red = 0;
renderColor.green = 0;
renderColor.blue = 0;
renderColor.alpha = 0xffff;
}
else if (strcasecmp (spec, XtDefaultBackground) == 0)
{
renderColor.red = 0xffff;
renderColor.green = 0xffff;
renderColor.blue = 0xffff;
renderColor.alpha = 0xffff;
}
else if (!XRenderParseColor (dpy, spec, &renderColor))
return False;
if (!XftColorAllocValue (dpy,
DefaultVisual (dpy,
XScreenNumberOfScreen (screen)),
colormap,
&renderColor,
&xftColor))
return False;
donestr (XftColor, xftColor, XtRXftColor);
}
void XtGetValues(
register Widget w,
register ArgList args,
register Cardinal num_args)
{
WidgetClass wc;
int targ;
XtAppContext app = XtWidgetToApplicationContext(w);
if (num_args == 0) return;
if ((args == NULL) && (num_args != 0)) {
XtAppErrorMsg(app,
"invalidArgCount","xtGetValues",XtCXtToolkitError,
"Argument count > 0 on NULL argument list in XtGetValues",
(String *)NULL, (Cardinal *)NULL);
}
LOCK_APP(app);
wc = XtClass(w);
LOCK_PROCESS;
/* Get widget values */
targ = GetValues((char*)w, (XrmResourceList *) wc->core_class.resources,
wc->core_class.num_resources, args, num_args);
UNLOCK_PROCESS;
if (targ != -1 && XtIsWidget(w)) {
XtTranslations translations = _XtGetTranslationValue(w);
_XtCopyToArg((char*)&translations, &args[targ].value,
sizeof(XtTranslations));
}
/* Get constraint values if necessary */
/* constraints may be NULL if constraint_size==0 */
if (XtParent(w) != NULL && !XtIsShell(w) && XtIsConstraint(XtParent(w)) &&
w->core.constraints) {
ConstraintWidgetClass cwc
= (ConstraintWidgetClass) XtClass(XtParent(w));
LOCK_PROCESS;
GetValues((char*)w->core.constraints,
(XrmResourceList *)(cwc->constraint_class.resources),
cwc->constraint_class.num_resources, args, num_args);
UNLOCK_PROCESS;
}
/* Notify any class procedures that we have performed get_values */
CallGetValuesHook(wc, w, args, num_args);
/* Notify constraint get_values if necessary */
if (XtParent(w) != NULL && !XtIsShell(w) && XtIsConstraint(XtParent(w)))
CallConstraintGetValuesHook(XtClass(XtParent(w)), w, args,num_args);
UNLOCK_APP(app);
} /* XtGetValues */
Boolean
neXtawcvtStringToTilePixmap(
Display *display,
XrmValue * args,
Cardinal *num_args,
XrmValuePtr from,
XrmValuePtr to,
XtPointer *converter_data)
{
String file = (String) from->addr;
XpmAttributes attr;
Pixmap pixmap, mask;
Window win;
if (*num_args != 2)
XtAppErrorMsg(XtDisplayToApplicationContext(display),
"cvtStringToTilePixmap", "wrongParameters",
"XtToolkitError",
"String to TilePixmap conversion needs screen and colormap arguments",
(String *) NULL, (Cardinal *) NULL);
win = RootWindow(display,
XScreenNumberOfScreen(*((Screen **) args[0].addr)));
attr.colormap = *((Colormap *) args[1].addr);
attr.valuemask = XpmSize | XpmReturnPixels | XpmColormap;
if (XpmReadFileToPixmap(display, win, file, &pixmap, &mask,
&attr) != XpmSuccess) {
XtDisplayStringConversionWarning(display, file, XtRTilePixmap);
return False;
}
if (mask != None)
XFreePixmap(display, mask);
if (to->addr != NULL) {
if (to->size < sizeof(Pixmap)) {
to->size = sizeof(Pixmap);
XtDisplayStringConversionWarning(display, file, XtRTilePixmap);
return False;
}
*(Pixmap *) (to->addr) = pixmap;
} else {
static Pixmap s_pixmap;
s_pixmap = pixmap;
to->addr = (XtPointer) &s_pixmap;
}
to->size = sizeof(Pixmap);
return True;
}
void XtPopdown(
Widget widget)
{
/* Unmap a shell widget if it is mapped, and remove from grab list */
Widget hookobj;
ShellWidget shell_widget = (ShellWidget) widget;
XtGrabKind grab_kind;
if (! XtIsShell(widget)) {
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidClass","xtPopdown",XtCXtToolkitError,
"XtPopdown requires a subclass of shellWidgetClass",
(String *)NULL, (Cardinal *)NULL);
}
#ifndef X_NO_XT_POPDOWN_CONFORMANCE
if (!shell_widget->shell.popped_up)
return;
#endif
grab_kind = shell_widget->shell.grab_kind;
XWithdrawWindow(XtDisplay(widget), XtWindow(widget),
XScreenNumberOfScreen(XtScreen(widget)));
if (grab_kind != XtGrabNone)
XtRemoveGrab(widget);
shell_widget->shell.popped_up = FALSE;
XtCallCallbacks(widget, XtNpopdownCallback, (XtPointer)&grab_kind);
hookobj = XtHooksOfDisplay(XtDisplay(widget));
if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
XtChangeHookDataRec call_data;
call_data.type = XtHpopdown;
call_data.widget = widget;
XtCallCallbackList(hookobj,
((HookObject)hookobj)->hooks.changehook_callbacks,
(XtPointer)&call_data);
}
} /* XtPopdown */
/*
* Function:
* ConvertCursor
*
* Parameters:
* w - simple widget
*
* Description:
* Converts a name to a new cursor.
*/
static void
ConvertCursor(Widget w)
{
SimpleWidget simple = (SimpleWidget) w;
XrmValue from, to;
Cursor cursor = None;
if (simple->simple.cursor_name == NULL)
return;
from.addr = (XPointer)simple->simple.cursor_name;
from.size = strlen((char *)from.addr) + 1;
to.size = sizeof(Cursor);
to.addr = (XPointer)&cursor;
if (XtConvertAndStore(w, XtRString, &from, XtRColorCursor, &to))
simple->simple.cursor = cursor;
else
XtAppErrorMsg(XtWidgetToApplicationContext(w),
"convertFailed","ConvertCursor","XawError",
"Simple: ConvertCursor failed.",
NULL, NULL);
}
/* ARGSUSED */
static Boolean
_XawCvtStringToPixmap(Display *dpy, XrmValuePtr args, Cardinal *nargs,
XrmValuePtr from, XrmValuePtr to, XtPointer *data)
{
static Pixmap pixmap;
Window win;
XpmAttributes attr;
XpmColorSymbol colors[1];
if (*nargs != 3)
XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
"_XawCvtStringToPixmap", "wrongParameters", "XtToolkitError",
"_XawCvtStringToPixmap needs screen, colormap, and background_pixel",
(String *) NULL, (Cardinal *) NULL);
if (strcmp(from->addr, "None") == 0)
{
pixmap = None;
DONE(Pixmap, &pixmap);
return (True);
}
if (strcmp(from->addr, "ParentRelative") == 0)
{
pixmap = ParentRelative;
DONE(Pixmap, &pixmap);
return (True);
}
win = RootWindowOfScreen(*((Screen **) args[0].addr));
attr.colormap = *((Colormap *) args[1].addr);
attr.closeness = 32768; /* might help on 8-bpp displays? */
attr.valuemask = XpmColormap | XpmCloseness;
colors[0].name = NULL;
colors[0].value = "none";
colors[0].pixel = *((Pixel *) args[2].addr);
attr.colorsymbols = colors;
attr.numsymbols = 1;
attr.valuemask |= XpmColorSymbols;
if (XpmReadFileToPixmap(dpy, win, (String) from->addr,
&pixmap, NULL, &attr) != XpmSuccess)
{
if ((pixmap = XmuLocateBitmapFile(*((Screen **) args[0].addr),
(char *)from->addr, NULL, 0, NULL, NULL, NULL, NULL)) == None)
{
XtDisplayStringConversionWarning(dpy, (String) from->addr,
XtRPixmap);
return (False);
}
}
if (to->addr == NULL)
to->addr = (XtPointer) & pixmap;
else
{
if (to->size < sizeof(Pixmap))
{
to->size = sizeof(Pixmap);
XtDisplayStringConversionWarning(dpy, (String) from->addr,
XtRPixmap);
return (False);
}
*((Pixmap *) to->addr) = pixmap;
}
to->size = sizeof(Pixmap);
return (True);
}
static void UnmanageChildren(
WidgetList children,
Cardinal num_children,
Widget parent,
Cardinal* num_unique_children,
Boolean call_change_managed,
String caller_func)
{
Widget child;
Cardinal i;
XtWidgetProc change_managed = NULL;
Bool parent_realized = False;
*num_unique_children = 0;
if (XtIsComposite((Widget) parent)) {
LOCK_PROCESS;
change_managed = ((CompositeWidgetClass) parent->core.widget_class)
->composite_class.change_managed;
UNLOCK_PROCESS;
parent_realized = XtIsRealized((Widget)parent);
} else {
XtAppErrorMsg(XtWidgetToApplicationContext((Widget)parent),
"invalidParent",caller_func, XtCXtToolkitError,
"Attempt to unmanage a child when parent is not Composite",
(String *) NULL, (Cardinal *) NULL);
}
for (i = 0; i < num_children; i++) {
child = children[i];
if (child == NULL) {
XtAppWarningMsg(XtWidgetToApplicationContext(parent),
XtNinvalidChild,caller_func,XtCXtToolkitError,
"Null child passed to XtUnmanageChildren",
(String *)NULL, (Cardinal *)NULL);
return;
}
if (child->core.parent != parent) {
XtAppWarningMsg(XtWidgetToApplicationContext(parent),
"ambiguousParent",caller_func,XtCXtToolkitError,
"Not all children have same parent in UnmanageChildren",
(String *)NULL, (Cardinal *)NULL);
} else
if (child->core.managed) {
(*num_unique_children)++;
CALLGEOTAT(_XtGeoTrace(child,"Child \"%s\" is marked unmanaged\n",
XtName(child)));
child->core.managed = FALSE;
if (XtIsWidget(child)
&& XtIsRealized(child)
&& child->core.mapped_when_managed)
XtUnmapWidget(child);
else
{ /* RectObj child */
Widget pw = child->core.parent;
RectObj r = (RectObj) child;
while ((pw!=NULL) && (!XtIsWidget(pw))) pw = pw->core.parent;
if ((pw!=NULL) && XtIsRealized (pw))
XClearArea (XtDisplay (pw), XtWindow (pw),
r->rectangle.x, r->rectangle.y,
r->rectangle.width + (r->rectangle.border_width << 1),
r->rectangle.height + (r->rectangle.border_width << 1),
TRUE);
}
}
}
if (call_change_managed && *num_unique_children != 0 &&
change_managed != NULL && parent_realized) {
CALLGEOTAT(_XtGeoTrace((Widget)parent,
"Call parent: \"%s\"[%d,%d]'s changemanaged proc\n",
XtName((Widget)parent),
parent->core.width,parent->core.height));
(*change_managed) (parent);
}
} /* UnmanageChildren */
static void RealizeWidget(
Widget widget)
{
XtValueMask value_mask;
XSetWindowAttributes values;
XtRealizeProc realize;
Window window;
Display* display;
String class_name;
Widget hookobj;
if (!XtIsWidget(widget) || XtIsRealized(widget)) return;
display = XtDisplay(widget);
_XtInstallTranslations(widget);
ComputeWindowAttributes (widget, &value_mask, &values);
LOCK_PROCESS;
realize = widget->core.widget_class->core_class.realize;
class_name = widget->core.widget_class->core_class.class_name;
UNLOCK_PROCESS;
if (realize == NULL)
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidProcedure","realizeProc",XtCXtToolkitError,
"No realize class procedure defined",
(String *)NULL, (Cardinal *)NULL);
else {
CALLGEOTAT(_XtGeoTrace(widget,"Call \"%s\"[%d,%d]'s realize proc\n",
XtName(widget),
widget->core.width, widget->core.height));
(*realize) (widget, &value_mask, &values);
}
window = XtWindow(widget);
hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
if (XtHasCallbacks(hookobj,XtNchangeHook) == XtCallbackHasSome) {
XtChangeHookDataRec call_data;
call_data.type = XtHrealizeWidget;
call_data.widget = widget;
XtCallCallbackList(hookobj,
((HookObject)hookobj)->hooks.changehook_callbacks,
(XtPointer)&call_data);
}
#ifndef NO_IDENTIFY_WINDOWS
if (_XtGetPerDisplay(display)->appContext->identify_windows) {
int len_nm, len_cl;
char *s;
len_nm = widget->core.name ? strlen(widget->core.name) : 0;
len_cl = strlen(class_name);
s = __XtMalloc((unsigned) (len_nm + len_cl + 2));
s[0] = '\0';
if (len_nm)
strcpy(s, widget->core.name);
strcpy(s + len_nm + 1, class_name);
XChangeProperty(display, window,
XInternAtom(display, "_MIT_OBJ_CLASS",
False),
XA_STRING, 8, PropModeReplace, (unsigned char *) s,
len_nm + len_cl + 2);
XtFree(s);
}
#endif
#ifdef notdef
_XtRegisterAsyncHandlers(widget);
#endif
/* (re)register any grabs extant in the translations */
_XtRegisterGrabs(widget);
/* reregister any grabs added with XtGrab{Button,Key} */
_XtRegisterPassiveGrabs(widget);
XtRegisterDrawable (display, window, widget);
_XtExtensionSelect(widget);
if (XtIsComposite (widget)) {
Cardinal i;
CompositePart *cwp = &(((CompositeWidget)widget)->composite);
WidgetList children = cwp->children;
/* Realize all children */
for (i = cwp->num_children; i != 0; --i) {
RealizeWidget (children[i-1]);
}
/* Map children that are managed and mapped_when_managed */
if (cwp->num_children != 0) {
if (ShouldMapAllChildren(cwp)) {
XMapSubwindows (display, window);
} else {
MapChildren(cwp);
}
}
}
/* If this is the application's popup shell, map it */
if (widget->core.parent == NULL && widget->core.mapped_when_managed) {
XtMapWidget (widget);
}
} /* RealizeWidget */
void XtChangeManagedSet(
WidgetList unmanage_children,
Cardinal num_unmanage,
XtDoChangeProc do_change_proc,
XtPointer client_data,
WidgetList manage_children,
Cardinal num_manage)
{
WidgetList childp;
Widget parent;
int i;
Cardinal some_unmanaged;
Boolean call_out;
CompositeClassExtension ext;
XtAppContext app;
Widget hookobj;
XtChangeHookDataRec call_data;
if (num_unmanage == 0 && num_manage == 0)
return;
/* specification doesn't state that library will check for NULL in list */
childp = num_unmanage ? unmanage_children : manage_children;
app = XtWidgetToApplicationContext(*childp);
LOCK_APP(app);
parent = XtParent(*childp);
childp = unmanage_children;
for (i = num_unmanage; --i >= 0 && XtParent(*childp) == parent; childp++);
call_out = (i >= 0);
childp = manage_children;
for (i = num_manage; --i >= 0 && XtParent(*childp) == parent; childp++);
if (call_out || i >= 0) {
XtAppWarningMsg(app, "ambiguousParent", XtNxtChangeManagedSet,
XtCXtToolkitError, "Not all children have same parent",
(String *)NULL, (Cardinal *)NULL);
}
if (! XtIsComposite(parent)) {
UNLOCK_APP(app);
XtAppErrorMsg(app, "invalidParent", XtNxtChangeManagedSet,
XtCXtToolkitError,
"Attempt to manage a child when parent is not Composite",
(String *) NULL, (Cardinal *) NULL);
}
if (parent->core.being_destroyed) {
UNLOCK_APP(app);
return;
}
call_out = False;
if (do_change_proc) {
ext = (CompositeClassExtension)
XtGetClassExtension(parent->core.widget_class,
XtOffsetOf(CompositeClassRec,
composite_class.extension),
NULLQUARK, XtCompositeExtensionVersion,
sizeof(CompositeClassExtensionRec));
if (!ext || !ext->allows_change_managed_set)
call_out = True;
}
UnmanageChildren(unmanage_children, num_unmanage, parent,
&some_unmanaged, call_out, XtNxtChangeManagedSet);
hookobj = XtHooksOfDisplay(XtDisplay(parent));
if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
call_data.type = XtHunmanageSet;
call_data.widget = parent;
call_data.event_data = (XtPointer) unmanage_children;
call_data.num_event_data = num_unmanage;
XtCallCallbackList(hookobj,
((HookObject)hookobj)->hooks.changehook_callbacks,
(XtPointer) &call_data);
}
if (do_change_proc)
(*do_change_proc)(parent, unmanage_children, &num_unmanage,
manage_children, &num_manage, client_data);
call_out = (some_unmanaged && !call_out);
ManageChildren(manage_children, num_manage, parent, call_out,
XtNxtChangeManagedSet);
if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
call_data.type = XtHmanageSet;
call_data.event_data = (XtPointer) manage_children;
call_data.num_event_data = num_manage;
XtCallCallbackList(hookobj,
((HookObject)hookobj)->hooks.changehook_callbacks,
(XtPointer) &call_data);
}
UNLOCK_APP(app);
} /* XtChangeManagedSet */
static void ManageChildren(
WidgetList children,
Cardinal num_children,
Widget parent,
Boolean call_change_managed,
String caller_func)
{
#define MAXCHILDREN 100
Widget child;
Cardinal num_unique_children, i;
XtWidgetProc change_managed = NULL;
WidgetList unique_children;
Widget cache[MAXCHILDREN];
Bool parent_realized = False;
if (XtIsComposite((Widget) parent)) {
LOCK_PROCESS;
change_managed = ((CompositeWidgetClass) parent->core.widget_class)
->composite_class.change_managed;
UNLOCK_PROCESS;
parent_realized = XtIsRealized((Widget)parent);
} else {
XtAppErrorMsg(XtWidgetToApplicationContext((Widget)parent),
"invalidParent",caller_func, XtCXtToolkitError,
"Attempt to manage a child when parent is not Composite",
(String *) NULL, (Cardinal *) NULL);
}
/* Construct new list of children that really need to be operated upon. */
if (num_children <= MAXCHILDREN) {
unique_children = cache;
} else {
unique_children = (WidgetList) __XtMalloc(num_children * sizeof(Widget));
}
num_unique_children = 0;
for (i = 0; i < num_children; i++) {
child = children[i];
if (child == NULL) {
XtAppWarningMsg(XtWidgetToApplicationContext((Widget)parent),
XtNinvalidChild,caller_func,XtCXtToolkitError,
"null child passed to ManageChildren",
(String *)NULL, (Cardinal *)NULL);
if (unique_children != cache) XtFree((char *) unique_children);
return;
}
#ifdef DEBUG
if (!XtIsRectObj(child)) {
String params[2];
Cardinal num_params = 2;
params[0] = XtName(child);
params[1] = child->core.widget_class->core_class.class_name;
XtAppWarningMsg(XtWidgetToApplicationContext((Widget)parent),
"notRectObj",caller_func,XtCXtToolkitError,
"child \"%s\", class %s is not a RectObj",
params, &num_params);
continue;
}
#endif /*DEBUG*/
if (child->core.parent != parent) {
XtAppWarningMsg(XtWidgetToApplicationContext((Widget)parent),
"ambiguousParent",caller_func,XtCXtToolkitError,
"Not all children have same parent in XtManageChildren",
(String *)NULL, (Cardinal *)NULL);
} else if (! child->core.managed && !child->core.being_destroyed) {
unique_children[num_unique_children++] = child;
CALLGEOTAT(_XtGeoTrace(child,
"Child \"%s\"[%d,%d] is marked managed\n",
XtName(child),
child->core.width,child->core.height));
child->core.managed = TRUE;
}
}
if ((call_change_managed || num_unique_children != 0) && parent_realized) {
/* Compute geometry of new managed set of children. */
if (change_managed != NULL) {
CALLGEOTAT(_XtGeoTrace((Widget)parent,
"Call parent: \"%s\"[%d,%d]'s changemanaged\n",
XtName((Widget)parent),
parent->core.width,parent->core.height));
(*change_managed) ((Widget)parent);
}
/* Realize each child if necessary, then map if necessary */
for (i = 0; i < num_unique_children; i++) {
child = unique_children[i];
if (XtIsWidget(child)) {
if (! XtIsRealized(child)) XtRealizeWidget(child);
if (child->core.mapped_when_managed) XtMapWidget(child);
} else { /* RectObj child */
Widget pw = child->core.parent;
RectObj r = (RectObj) child;
while ((pw!=NULL) && (!XtIsWidget(pw)))
pw = pw->core.parent;
if (pw != NULL)
XClearArea (XtDisplay (pw), XtWindow (pw),
r->rectangle.x, r->rectangle.y,
r->rectangle.width + (r->rectangle.border_width << 1),
r->rectangle.height + (r->rectangle.border_width << 1),
TRUE);
}
}
}
if (unique_children != cache) XtFree((char *) unique_children);
} /* ManageChildren */
XtGeometryResult
_XtMakeGeometryRequest (
Widget widget,
XtWidgetGeometry *request,
XtWidgetGeometry *reply,
Boolean * clear_rect_obj)
{
XtWidgetGeometry junk;
XtGeometryHandler manager = (XtGeometryHandler) NULL;
XtGeometryResult returnCode;
Widget parent = widget->core.parent;
Boolean managed, parentRealized, rgm = False;
XtConfigureHookDataRec req;
Widget hookobj;
*clear_rect_obj = FALSE;
CALLGEOTAT(_XtGeoTrace(widget,
"\"%s\" is making a %sgeometry request to its parent \"%s\".\n",
XtName(widget),
((request->request_mode & XtCWQueryOnly))? "query only ":"",
(XtParent(widget))?XtName(XtParent(widget)):"Root"));
CALLGEOTAT(_XtGeoTab(1));
if (XtIsShell(widget)) {
ShellClassExtension ext;
LOCK_PROCESS;
for (ext = (ShellClassExtension)((ShellWidgetClass)XtClass(widget))
->shell_class.extension;
ext != NULL && ext->record_type != NULLQUARK;
ext = (ShellClassExtension)ext->next_extension);
if (ext != NULL) {
if ( ext->version == XtShellExtensionVersion
&& ext->record_size == sizeof(ShellClassExtensionRec)) {
manager = ext->root_geometry_manager;
rgm = True;
} else {
String params[1];
Cardinal num_params = 1;
params[0] = XtClass(widget)->core_class.class_name;
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidExtension", "xtMakeGeometryRequest",
XtCXtToolkitError,
"widget class %s has invalid ShellClassExtension record",
params, &num_params);
}
} else {
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"internalError", "xtMakeGeometryRequest",
XtCXtToolkitError,
"internal error; ShellClassExtension is NULL",
NULL, NULL);
}
managed = True;
parentRealized = TRUE;
UNLOCK_PROCESS;
} else { /* not shell */
if (parent == NULL)
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidParent","xtMakeGeometryRequest",
XtCXtToolkitError,
"non-shell has no parent in XtMakeGeometryRequest",
(String *)NULL, (Cardinal *)NULL);
managed = XtIsManaged(widget);
parentRealized = XtIsRealized(parent);
if (XtIsComposite(parent))
{
LOCK_PROCESS;
manager = ((CompositeWidgetClass) (parent->core.widget_class))
->composite_class.geometry_manager;
UNLOCK_PROCESS;
}
}
#if 0
/*
* The Xt spec says that these conditions must generate
* error messages (not warnings), but many Xt applications
* and toolkits (including parts of Xaw, Motif and Netscape)
* depend on the previous Xt behaviour. Thus, these tests
* should probably remain disabled.
*/
if (parentRealized && managed) {
if (parent && !XtIsComposite(parent))
{
/*
* This shouldn't ever happen, we only test for this to pass
* VSW5. Normally managing the widget will catch this, but VSW5
* does some really screwy stuff to get here.
*/
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidParent", "xtMakeGeometryRequest",
XtCXtToolkitError,
"XtMakeGeometryRequest - parent not composite",
(String *)NULL, (Cardinal *)NULL);
}
else if (manager == (XtGeometryHandler) NULL)
{
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidGeometryManager","xtMakeGeometryRequest",
XtCXtToolkitError,
"XtMakeGeometryRequest - parent has no geometry manager",
(String *)NULL, (Cardinal *)NULL);
}
}
#else
if (!manager)
managed = False;
#endif
if (widget->core.being_destroyed) {
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,
"It is being destroyed, just return XtGeometryNo.\n"));
return XtGeometryNo;
}
/* see if requesting anything to change */
req.changeMask = 0;
if (request->request_mode & CWStackMode
&& request->stack_mode != XtSMDontChange) {
req.changeMask |= CWStackMode;
CALLGEOTAT(_XtGeoTrace(widget,
"Asking for a change in StackMode!\n"));
if (request->request_mode & CWSibling) {
XtCheckSubclass(request->sibling, rectObjClass,
"XtMakeGeometryRequest");
req.changeMask |= CWSibling;
}
}
if (request->request_mode & CWX
&& widget->core.x != request->x) {
CALLGEOTAT(_XtGeoTrace(widget,
"Asking for a change in x: from %d to %d.\n",
widget->core.x, request->x));
req.changeMask |= CWX;
}
if (request->request_mode & CWY
&& widget->core.y != request->y) {
CALLGEOTAT(_XtGeoTrace(widget,
"Asking for a change in y: from %d to %d.\n",
widget->core.y, request->y));
req.changeMask |= CWY;
}
if (request->request_mode & CWWidth
&& widget->core.width != request->width) {
CALLGEOTAT(_XtGeoTrace(widget,"Asking for a change in width: from %d to %d.\n",
widget->core.width, request->width));
req.changeMask |= CWWidth;
}
if (request->request_mode & CWHeight
&& widget->core.height != request->height) {
CALLGEOTAT(_XtGeoTrace(widget,
"Asking for a change in height: from %d to %d.\n",
widget->core.height, request->height));
req.changeMask |= CWHeight;
}
if (request->request_mode & CWBorderWidth
&& widget->core.border_width != request->border_width) {
CALLGEOTAT(_XtGeoTrace(widget,
"Asking for a change in border_width: from %d to %d.\n",
widget->core.border_width, request->border_width));
req.changeMask |= CWBorderWidth;
}
if (! req.changeMask) {
CALLGEOTAT(_XtGeoTrace(widget,
"Asking for nothing new,\n"));
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,
"just return XtGeometryYes.\n"));
return XtGeometryYes;
}
req.changeMask |= (request->request_mode & XtCWQueryOnly);
if ( !(req.changeMask & XtCWQueryOnly) && XtIsRealized(widget) ) {
/* keep record of the current geometry so we know what's changed */
req.changes.x = widget->core.x ;
req.changes.y = widget->core.y ;
req.changes.width = widget->core.width ;
req.changes.height = widget->core.height ;
req.changes.border_width = widget->core.border_width ;
}
if (!managed || !parentRealized) {
CALLGEOTAT(_XtGeoTrace(widget,
"Not Managed or Parent not realized.\n"));
/* Don't get parent's manager involved--assume the answer is yes */
if (req.changeMask & XtCWQueryOnly) {
/* He was just asking, don't change anything, just tell him yes */
CALLGEOTAT(_XtGeoTrace(widget,"QueryOnly request\n"));
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,"just return XtGeometryYes.\n"));
return XtGeometryYes;
} else {
CALLGEOTAT(_XtGeoTrace(widget,
"Copy values from request to widget.\n"));
/* copy values from request to widget */
if (request->request_mode & CWX)
widget->core.x = request->x;
if (request->request_mode & CWY)
widget->core.y = request->y;
if (request->request_mode & CWWidth)
widget->core.width = request->width;
if (request->request_mode & CWHeight)
widget->core.height = request->height;
if (request->request_mode & CWBorderWidth)
widget->core.border_width = request->border_width;
if (!parentRealized) {
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,"and return XtGeometryYes.\n"));
return XtGeometryYes;
}
else returnCode = XtGeometryYes;
}
} else {
/* go ask the widget's geometry manager */
CALLGEOTAT(_XtGeoTrace(widget,
"Go ask the parent geometry manager.\n"));
if (reply == (XtWidgetGeometry *) NULL) {
returnCode = (*manager)(widget, request, &junk);
} else {
returnCode = (*manager)(widget, request, reply);
}
}
/*
* If Unrealized, not a XtGeometryYes, or a query-only then we are done.
*/
if ((returnCode != XtGeometryYes) ||
(req.changeMask & XtCWQueryOnly) || !XtIsRealized(widget)) {
#ifdef XT_GEO_TATTLER
switch(returnCode) {
case XtGeometryNo:
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryNo.\n",
(XtParent(widget))?XtName(XtParent(widget)):"Root"));
/* check for no change */
break ;
case XtGeometryDone:
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryDone.\n",
(XtParent(widget))?XtName(XtParent(widget)):"Root"));
/* check for no change in queryonly */
break ;
case XtGeometryAlmost:
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryAlmost.\n",
(XtParent(widget))?XtName(XtParent(widget)):"Root"));
CALLGEOTAT(_XtGeoTab(1));
CALLGEOTAT(_XtGeoTrace(widget,"Proposal: width %d height %d.\n",
(reply)?reply->width:junk.width,
(reply)?reply->height:junk.height));
CALLGEOTAT(_XtGeoTab(-1));
/* check for no change */
break ;
case XtGeometryYes:
if (req.changeMask & XtCWQueryOnly) {
CALLGEOTAT(_XtGeoTrace(widget,
"QueryOnly specified, no configuration.\n"));
}
if (!XtIsRealized(widget)) {
CALLGEOTAT(_XtGeoTrace(widget,
"\"%s\" not realized, no configuration.\n",
XtName(widget)));
}
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryYes.\n",
(XtParent(widget))?XtName(XtParent(widget)):"Root"));
break ;
}
#endif
return returnCode;
}
CALLGEOTAT(_XtGeoTab(-1));
CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryYes.\n",
(XtParent(widget))?XtName(XtParent(widget)):"Root"));
if (XtIsWidget(widget)) { /* reconfigure the window (if needed) */
if (rgm) return returnCode;
if (req.changes.x != widget->core.x) {
req.changeMask |= CWX;
req.changes.x = widget->core.x;
CALLGEOTAT(_XtGeoTrace(widget,
"x changing to %d\n",widget->core.x));
}
if (req.changes.y != widget->core.y) {
req.changeMask |= CWY;
req.changes.y = widget->core.y;
CALLGEOTAT(_XtGeoTrace(widget,
"y changing to %d\n",widget->core.y));
}
if (req.changes.width != widget->core.width) {
req.changeMask |= CWWidth;
req.changes.width = widget->core.width;
CALLGEOTAT(_XtGeoTrace(widget,
"width changing to %d\n",widget->core.width));
}
if (req.changes.height != widget->core.height) {
req.changeMask |= CWHeight;
req.changes.height = widget->core.height;
CALLGEOTAT(_XtGeoTrace(widget,
"height changing to %d\n",widget->core.height));
}
if (req.changes.border_width != widget->core.border_width) {
req.changeMask |= CWBorderWidth;
req.changes.border_width = widget->core.border_width;
CALLGEOTAT(_XtGeoTrace(widget,
"border_width changing to %d\n",
widget->core.border_width));
}
if (req.changeMask & CWStackMode) {
req.changes.stack_mode = request->stack_mode;
CALLGEOTAT(_XtGeoTrace(widget,"stack_mode changing\n"));
if (req.changeMask & CWSibling) {
if (XtIsWidget(request->sibling))
req.changes.sibling = XtWindow(request->sibling);
else
req.changeMask &= ~(CWStackMode | CWSibling);
}
}
#ifdef XT_GEO_TATTLER
if (req.changeMask) {
CALLGEOTAT(_XtGeoTrace(widget,
"XConfigure \"%s\"'s window.\n",
XtName(widget)));
} else {
CALLGEOTAT(_XtGeoTrace(widget,
"No window configuration needed for \"%s\".\n",
XtName(widget)));
}
#endif
XConfigureWindow(XtDisplay(widget), XtWindow(widget),
req.changeMask, &req.changes);
}
else { /* RectObj child of realized Widget */
*clear_rect_obj = TRUE;
CALLGEOTAT(_XtGeoTrace(widget,
"ClearRectObj on \"%s\".\n",XtName(widget)));
ClearRectObjAreas((RectObj)widget, &req.changes);
}
hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));;
if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) {
req.type = XtHconfigure;
req.widget = widget;
XtCallCallbackList(hookobj,
((HookObject)hookobj)->hooks.confighook_callbacks,
(XtPointer)&req);
}
return returnCode;
} /* _XtMakeGeometryRequest */