void XtPopup (Widget widget, XtGrabKind grab_kind) { Widget hookobj; switch (grab_kind) { case XtGrabNone: case XtGrabExclusive: case XtGrabNonexclusive: break; default: XtAppWarningMsg( XtWidgetToApplicationContext(widget), "invalidGrabKind","xtPopup",XtCXtToolkitError, "grab kind argument has invalid value; XtGrabNone assumed", (String *)NULL, (Cardinal *)NULL); grab_kind = XtGrabNone; } _XtPopup(widget, grab_kind, FALSE); hookobj = XtHooksOfDisplay(XtDisplay(widget)); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHpopup; call_data.widget = widget; call_data.event_data = (XtPointer)grab_kind; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } } /* XtPopup */
void XtUnrealizeWidget ( Widget widget) { Window window; Widget hookobj; WIDGET_TO_APPCON(widget); LOCK_APP(app); window = XtWindow(widget); if (! XtIsRealized (widget)) { UNLOCK_APP(app); return; } if (widget->core.managed && widget->core.parent != NULL) XtUnmanageChild(widget); UnrealizeWidget(widget); if (window != None) XDestroyWindow(XtDisplay(widget), window); hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHunrealizeWidget; call_data.widget = widget; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } UNLOCK_APP(app); } /* XtUnrealizeWidget */
void XtRemoveAllCallbacks( Widget widget, _Xconst char* name) { InternalCallbackList *callbacks; Widget hookobj; XtAppContext app = XtWidgetToApplicationContext(widget); LOCK_APP(app); callbacks = FetchInternalList(widget, name); if (!callbacks) { XtAppWarningMsg(app, XtNinvalidCallbackList,XtNxtRemoveAllCallback,XtCXtToolkitError, "Cannot find callback list in XtRemoveAllCallbacks", (String *)NULL, (Cardinal *)NULL); UNLOCK_APP(app); return; } _XtRemoveAllCallbacks(callbacks); hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHremoveAllCallbacks; call_data.widget = widget; call_data.event_data = (XtPointer) name; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } UNLOCK_APP(app); } /* XtRemoveAllCallbacks */
void XtResizeWindow( Widget w) { XtConfigureHookDataRec req; Widget hookobj; WIDGET_TO_APPCON(w); LOCK_APP(app); if (XtIsRealized(w)) { req.changes.width = w->core.width; req.changes.height = w->core.height; req.changes.border_width = w->core.border_width; req.changeMask = CWWidth | CWHeight | CWBorderWidth; XConfigureWindow(XtDisplay(w), XtWindow(w), (unsigned) req.changeMask, &req.changes); hookobj = XtHooksOfDisplay(XtDisplayOfObject(w));; if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) { req.type = XtHconfigure; req.widget = w; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.confighook_callbacks, (XtPointer)&req); } } UNLOCK_APP(app); } /* XtResizeWindow */
XtGeometryResult XtMakeGeometryRequest ( Widget widget, XtWidgetGeometry *request, XtWidgetGeometry *reply) { Boolean junk; XtGeometryResult r; XtGeometryHookDataRec call_data; Widget hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)); WIDGET_TO_APPCON(widget); LOCK_APP(app); if (XtHasCallbacks(hookobj, XtNgeometryHook) == XtCallbackHasSome) { call_data.type = XtHpreGeometry; call_data.widget = widget; call_data.request = request; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.geometryhook_callbacks, (XtPointer)&call_data); call_data.result = r = _XtMakeGeometryRequest(widget, request, reply, &junk); call_data.type = XtHpostGeometry; call_data.reply = reply; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.geometryhook_callbacks, (XtPointer)&call_data); } else { r = _XtMakeGeometryRequest(widget, request, reply, &junk); } UNLOCK_APP(app); return ((r == XtGeometryDone) ? XtGeometryYes : r); }
/* * _XmAddCloseConnectionCallback registers a callback on the widget w * that is triggered by a close-down on the connection the widget is * belonging to. */ static void _XmAddCloseConnectionCallback(Widget w, XtCallbackProc callback) { #if XtSpecificationRelease >= 6 XtAddCallback(XtHooksOfDisplay(XtDisplay(w)), XmNdestroyCallback, callback, (XtPointer)w); #endif }
XtGeometryResult XtMakeResizeRequest( Widget widget, _XtDimension width, _XtDimension height, Dimension *replyWidth, Dimension *replyHeight) { XtWidgetGeometry request, reply; XtGeometryResult r; XtGeometryHookDataRec call_data; Boolean junk; Widget hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)); WIDGET_TO_APPCON(widget); LOCK_APP(app); request.request_mode = CWWidth | CWHeight; request.width = width; request.height = height; if (XtHasCallbacks(hookobj, XtNgeometryHook) == XtCallbackHasSome) { call_data.type = XtHpreGeometry; call_data.widget = widget; call_data.request = &request; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.geometryhook_callbacks, (XtPointer)&call_data); call_data.result = r = _XtMakeGeometryRequest(widget, &request, &reply, &junk); call_data.type = XtHpostGeometry; call_data.reply = &reply; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.geometryhook_callbacks, (XtPointer)&call_data); } else { r = _XtMakeGeometryRequest(widget, &request, &reply, &junk); } if (replyWidth != NULL) { if (r == XtGeometryAlmost && reply.request_mode & CWWidth) *replyWidth = reply.width; else *replyWidth = width; } if (replyHeight != NULL) { if (r == XtGeometryAlmost && reply.request_mode & CWHeight) *replyHeight = reply.height; else *replyHeight = height; } UNLOCK_APP(app); return ((r == XtGeometryDone) ? XtGeometryYes : r); } /* XtMakeResizeRequest */
void _XtAddShellToHookObj( Widget shell) { /* app_con is locked when this function is called */ HookObject ho = (HookObject) XtHooksOfDisplay(XtDisplay(shell)); if (ho->hooks.num_shells == ho->hooks.max_shells) { ho->hooks.max_shells += SHELL_INCR; ho->hooks.shells = (WidgetList)XtRealloc((char*)ho->hooks.shells, ho->hooks.max_shells * sizeof (Widget)); } ho->hooks.shells[ho->hooks.num_shells++] = shell; XtAddCallback(shell, XtNdestroyCallback, DeleteShellFromHookObj, (XtPointer)ho); }
void XtPopupSpringLoaded ( Widget widget) { Widget hookobj; _XtPopup(widget, XtGrabExclusive, True); hookobj = XtHooksOfDisplay(XtDisplay(widget)); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHpopupSpringLoaded; call_data.widget = widget; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } }
void XtUnmanageChildren ( WidgetList children, Cardinal num_children) { Widget parent, hookobj; Cardinal ii; #ifdef XTHREADS XtAppContext app; #endif if (num_children == 0) return; if (children[0] == NULL) { XtWarningMsg(XtNinvalidChild,XtNxtUnmanageChildren,XtCXtToolkitError, "Null child found in argument list to unmanage", (String *)NULL, (Cardinal *)NULL); return; } #ifdef XTHREADS app = XtWidgetToApplicationContext(children[0]); #endif LOCK_APP(app); parent = children[0]->core.parent; if (parent->core.being_destroyed) { UNLOCK_APP(app); return; } UnmanageChildren(children, num_children, parent, &ii, (Boolean)True, XtNxtUnmanageChildren); hookobj = XtHooksOfDisplay(XtDisplayOfObject(children[0])); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHunmanageChildren; call_data.widget = parent; call_data.event_data = (XtPointer) children; call_data.num_event_data = num_children; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } UNLOCK_APP(app); } /* XtUnmanageChildren */
void XtSetMappedWhenManaged( Widget widget, _XtBoolean mapped_when_managed) { Widget hookobj; WIDGET_TO_APPCON(widget); LOCK_APP(app); if (widget->core.mapped_when_managed == mapped_when_managed) { UNLOCK_APP(app); return; } widget->core.mapped_when_managed = mapped_when_managed; hookobj = XtHooksOfDisplay(XtDisplay(widget)); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHsetMappedWhenManaged; call_data.widget = widget; call_data.event_data = (XtPointer) (unsigned long) mapped_when_managed; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } if (! XtIsManaged(widget)) { UNLOCK_APP(app); return; } if (mapped_when_managed) { /* Didn't used to be mapped when managed. */ if (XtIsRealized(widget)) XtMapWidget(widget); } else { /* Used to be mapped when managed. */ if (XtIsRealized(widget)) XtUnmapWidget(widget); } UNLOCK_APP(app); } /* XtSetMappedWhenManaged */
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 */
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 XtSetWMColormapWindows( Widget widget, Widget *list, Cardinal count) { Window *data; Widget *checked, *top, *temp, hookobj; Cardinal i, j, checked_count; Boolean match; Atom xa_wm_colormap_windows; WIDGET_TO_APPCON(widget); LOCK_APP(app); if ( !XtIsRealized(widget) || (count == 0) ) { UNLOCK_APP(app); return; } top = checked = (Widget *) __XtMalloc( (Cardinal) sizeof(Widget) * count); /* * The specification calls for only adding the windows that have unique * colormaps to the property to this function, so we will make a pass through * the widget list removing all the widgets with non-unique colormaps. * * We will also remove any unrealized widgets from the list at this time. */ for (checked_count = 0, i = 0; i < count; i++) { if (!XtIsRealized(list[i])) continue; *checked = list[i]; match = FALSE; /* * Don't check first element for matching colormap since there is nothing * to check it against. */ if (checked != top) for (j = 0, temp = top; j < checked_count ; j++, temp++) if ( (*temp)->core.colormap == (*checked)->core.colormap) { match = TRUE; break; } /* * If no colormap was found to match then add this widget to the linked list. */ if (!match) { checked++; checked_count++; } } /* * Now that we have the list of widgets we need to convert it to a list of * windows and set the property. */ data = (Window *) __XtMalloc( (Cardinal) sizeof(Window) * checked_count); for ( i = 0 ; i < checked_count ; i++) data[i] = XtWindow(top[i]); xa_wm_colormap_windows = XInternAtom(XtDisplay(widget), "WM_COLORMAP_WINDOWS", FALSE); XChangeProperty(XtDisplay(widget), XtWindow(widget), xa_wm_colormap_windows, XA_WINDOW, 32, PropModeReplace, (unsigned char *) data, (int) i); hookobj = XtHooksOfDisplay(XtDisplay(widget)); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHsetWMColormapWindows; call_data.widget = widget; call_data.event_data = (XtPointer) list; call_data.num_event_data = count; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } XtFree( (char *) data); XtFree( (char *) top); UNLOCK_APP(app); }
void XtConfigureWidget( Widget w, _XtPosition x, _XtPosition y, _XtDimension width, _XtDimension height, _XtDimension borderWidth) { XtConfigureHookDataRec req; Widget hookobj; XWindowChanges old; WIDGET_TO_APPCON(w); CALLGEOTAT(_XtGeoTrace(w, "\"%s\" is being configured by its parent \"%s\"\n", XtName(w), (XtParent(w))?XtName(XtParent(w)):"Root")); CALLGEOTAT(_XtGeoTab(1)); LOCK_APP(app); req.changeMask = 0; if ((old.x = w->core.x) != x) { CALLGEOTAT(_XtGeoTrace(w,"x move from %d to %d\n",w->core.x, x)); req.changes.x = w->core.x = x; req.changeMask |= CWX; } if ((old.y = w->core.y) != y) { CALLGEOTAT(_XtGeoTrace(w,"y move from %d to %d\n",w->core.y, y)); req.changes.y = w->core.y = y; req.changeMask |= CWY; } if ((old.width = w->core.width) != width) { CALLGEOTAT(_XtGeoTrace(w, "width move from %d to %d\n",w->core.width, width)); req.changes.width = w->core.width = width; req.changeMask |= CWWidth; } if ((old.height = w->core.height) != height) { CALLGEOTAT(_XtGeoTrace(w, "height move from %d to %d\n",w->core.height, height)); req.changes.height = w->core.height = height; req.changeMask |= CWHeight; } if ((old.border_width = w->core.border_width) != borderWidth) { CALLGEOTAT(_XtGeoTrace(w,"border_width move from %d to %d\n", w->core.border_width,borderWidth )); req.changes.border_width = w->core.border_width = borderWidth; req.changeMask |= CWBorderWidth; } if (req.changeMask != 0) { if (XtIsRealized(w)) { if (XtIsWidget(w)) { CALLGEOTAT(_XtGeoTrace(w, "XConfigure \"%s\"'s window\n",XtName(w))); XConfigureWindow(XtDisplay(w), XtWindow(w), req.changeMask, &req.changes); } else { CALLGEOTAT(_XtGeoTrace(w, "ClearRectObj called on \"%s\"\n",XtName(w))); ClearRectObjAreas((RectObj)w, &old); } } hookobj = XtHooksOfDisplay(XtDisplayOfObject(w));; if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) { req.type = XtHconfigure; req.widget = w; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.confighook_callbacks, (XtPointer)&req); } { XtWidgetProc resize; LOCK_PROCESS; resize = XtClass(w)->core_class.resize; UNLOCK_PROCESS; if ((req.changeMask & (CWWidth | CWHeight)) && resize != (XtWidgetProc) NULL) { CALLGEOTAT(_XtGeoTrace(w,"Resize proc is called.\n")); (*resize)(w); } } } else { CALLGEOTAT(_XtGeoTrace(w,"No change in configuration\n")); } CALLGEOTAT(_XtGeoTab(-1)); UNLOCK_APP(app); } /* XtConfigureWidget */
void XtRemoveCallbacks ( Widget widget, _Xconst char* name, XtCallbackList xtcallbacks) { InternalCallbackList *callbacks; Widget hookobj; int i; InternalCallbackList icl; XtCallbackList cl, ccl, rcl; XtAppContext app = XtWidgetToApplicationContext(widget); LOCK_APP(app); callbacks = FetchInternalList(widget, name); if (!callbacks) { XtAppWarningMsg(app, XtNinvalidCallbackList,XtNxtRemoveCallback,XtCXtToolkitError, "Cannot find callback list in XtRemoveCallbacks", (String *)NULL, (Cardinal *)NULL); UNLOCK_APP(app); return; } icl = *callbacks; if (!icl) { UNLOCK_APP(app); return; } i = icl->count; cl = ToList(icl); if (icl->call_state) { icl->call_state |= _XtCBFreeAfterCalling; icl = (InternalCallbackList)__XtMalloc(sizeof(InternalCallbackRec) + sizeof(XtCallbackRec) * i); icl->count = i; icl->call_state = 0; } ccl = ToList(icl); while (--i >= 0) { *ccl++ = *cl; for (rcl=xtcallbacks; rcl->callback; rcl++) { if (cl->callback == rcl->callback && cl->closure == rcl->closure) { ccl--; icl->count--; break; } } cl++; } if (icl->count) { icl = (InternalCallbackList) XtRealloc((char *)icl, (sizeof(InternalCallbackRec) + sizeof(XtCallbackRec) * icl->count)); icl->is_padded = 0; *callbacks = icl; } else { XtFree((char *)icl); *callbacks = NULL; } hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget)); if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) { XtChangeHookDataRec call_data; call_data.type = XtHremoveCallbacks; call_data.widget = widget; call_data.event_data = (XtPointer) name; XtCallCallbackList(hookobj, ((HookObject)hookobj)->hooks.changehook_callbacks, (XtPointer)&call_data); } UNLOCK_APP(app); } /* XtRemoveCallbacks */
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 */
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 */