boolean HelpOnContextCommand::doIt(CommandInterface *ci) { Widget widget; MainWindowHelpCallbackStruct callData; widget = XmTrackingLocate (this->window->getMainWindow(), HelpOnContextCommand::HelpCursor, False); XSync(theApplication->getDisplay(), False); while (widget) { if (XtHasCallbacks(widget, XmNhelpCallback) == XtCallbackHasSome) { callData.reason = DxCR_HELP; callData.event = NULL; callData.widget = widget; XtCallCallbacks (widget, XmNhelpCallback, (XtPointer)&callData); break; } else { widget = XtParent(widget); } } return TRUE; }
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 HelpModeCB( Widget w, caddr_t client_data, caddr_t call_data ) { Widget widget; switch(DtHelpReturnSelectedWidgetId(style.shell, (Cursor)NULL, &widget)) { /* * There are additional cases (e.g. user aborts request) but I * don't feel they warrant an error dialog. */ case DtHELP_SELECT_VALID: while (!XtIsShell(widget)) { if (XtHasCallbacks(widget, XmNhelpCallback) == XtCallbackHasSome) { XtCallCallbacks(widget, XmNhelpCallback, (XtPointer)NULL); return; } widget = XtParent(widget); } break; case DtHELP_SELECT_INVALID: ErrDialog((char *)GETMESSAGE(2, 8, "You must select an item\nwithin the Style Manager."), style.shell); break; } }
void wl_help_context(Widget w, XtPointer closure, XtPointer call) { XmAnyCallbackStruct cbs; Cursor qa; XEvent ev; Widget top; USEUP(closure); USEUP(call); top = wl_top(w); memset((void *)&ev, '\0', sizeof(ev)); qa = XCreateFontCursor(XtDisplay(top), XC_question_arrow); w = XmTrackingEvent(top, qa, False, &ev); while(w != NULL) { if(XtHasCallbacks(w, XmNhelpCallback) != XtCallbackHasSome) { w = XtParent(w); continue; } memset((void *)&cbs, '\0', sizeof(cbs)); cbs.reason = XmCR_HELP; cbs.event = &ev; XtCallCallbacks(w, XmNhelpCallback, (XtPointer)&cbs); w = NULL; } /* * XmTrackingEvent() will take care of resetting the cursor */ XFreeCursor(XtDisplay(top), qa); }
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 */
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 */
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); }
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 */
/* * Procedure Redisplay() is called as the result of an Expose event. * Use the redraw callback to do a full redraw */ static void Redisplay(AngbandWidget wnew, XEvent *xev, Region region) { int x1, x2, y1, y2; int i; term_data *old_td = (term_data*)(Term->data); term_data *td = &data[0]; /* Ignore parameter */ (void) region; /* Hack - Find the term to activate */ for (i = 0; i < num_term; i++) { td = &data[i]; /* Have we found it? */ if (td->widget == wnew) break; /* Paranoia: none of the widgets matched */ if (!td) return; } /* Activate the proper Term */ Term_activate(&td->t); /* Find the bounds of the exposed region */ /* * This probably could be obtained from the Region parameter - * but I don't know anything about XAW. */ x1 = (xev->xexpose.x - wnew->angband.internal_border) /wnew->angband.fontwidth; x2 = (xev->xexpose.x + xev->xexpose.width - wnew->angband.internal_border)/wnew->angband.fontwidth; y1 = (xev->xexpose.y - wnew->angband.internal_border) /wnew->angband.fontheight; y2 = (xev->xexpose.y + xev->xexpose.height - wnew->angband.internal_border)/wnew->angband.fontheight; Term_redraw_section(x1, y1, x2, y2); /* Activate the old term */ Term_activate(&old_td->t); #if 0 if (XtHasCallbacks((Widget)widget, XtNredrawCallback) == XtCallbackHasSome) { XtCallCallbacks((Widget)widget, XtNredrawCallback, NULL); } #endif /* 0 */ }
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 XsComponent::show ( ) { #ifndef NDEBUG // if (XtIsManaged (_base)) // cout << "Re-managing a widget:" << _name << endl; #endif // Make sure the _destroyHandler was installed assert (XtHasCallbacks (_base, XmNdestroyCallback) == XtCallbackHasSome); assert (_base != 0); XtManageChild (_base); }
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); } }
/* * standard help callback */ void wl_help(Widget w, XtPointer closure, XtPointer call) { static int firsttime = TRUE; XtResource hr[] = { { XwlNhelpChapter, XwlCHelpChapter, XtRString, sizeof(String), XtOffsetOf(HELP, chapter), XtRString, NULL }, { XwlNhelpSection, XwlCHelpSection, XtRString, sizeof(String), XtOffsetOf(HELP, section), XtRString, NULL }, { XwlNhelpType, XwlCHelpType, XwlRHelpType, sizeof(WL_HELPFN), XtOffsetOf(HELP, f), XtRString, (XtPointer)"remote" } }; HELP help; WLP_HELP h; USEUP(call); USEUP(closure); if(firsttime) { XtSetTypeConverter(XtRString, XwlRHelpType, string2help, NULL, 0, XtCacheNone, NULL); firsttime = FALSE; } for(; w != NULL; w = XtParent(w)) if(XtHasCallbacks(w, XmNhelpCallback) == XtCallbackHasSome) break; if(w == NULL) return; memset((void *)&help, '\0', sizeof(help)); XtGetApplicationResources(w, &help, &hr[0], XtNumber(hr), NULL, 0); if(help.f == NULL || help.chapter == NULL) return; h.chapter = help.chapter; h.section = help.section; help.f(w, &h); }
static void UnrealizeWidget( Widget widget) { CompositeWidget cw; Cardinal i; WidgetList children; if (!XtIsWidget(widget) || !XtIsRealized(widget)) return; /* If this is the application's popup shell, unmap it? */ /* no, the window is being destroyed */ /* Recurse on children */ if (XtIsComposite (widget)) { cw = (CompositeWidget) widget; children = cw->composite.children; /* Unrealize all children */ for (i = cw->composite.num_children; i != 0; --i) { UnrealizeWidget (children[i-1]); } /* Unmap children that are managed and mapped_when_managed? */ /* No, it's ok to be managed and unrealized as long as your parent */ /* is unrealized. XtUnrealize widget makes sure the "top" widget */ /* is unmanaged, we can ignore all descendents */ } if (XtHasCallbacks(widget, XtNunrealizeCallback) == XtCallbackHasSome) XtCallCallbacks(widget, XtNunrealizeCallback, NULL); /* Unregister window */ XtUnregisterDrawable(XtDisplay(widget), XtWindow(widget)); /* Remove Event Handlers */ /* remove grabs. Happens automatically when window is destroyed. */ /* Destroy X Window, done at outer level with one request */ widget->core.window = None; /* Removing the event handler here saves having to keep track if * the translation table is changed while the widget is unrealized. */ _XtRemoveTranslations(widget); } /* UnrealizeWidget */
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 Boolean ProcessItemHelp( Widget shell ) { Widget selectedWidget; int returnVal; returnVal = DtHelpReturnSelectedWidgetId(shell, NULL, &selectedWidget); switch(returnVal) { case DtHELP_SELECT_VALID: { while (!XtIsShell(selectedWidget)) { if (XtHasCallbacks(selectedWidget, XmNhelpCallback) == XtCallbackHasSome) { XtCallCallbacks(selectedWidget, XmNhelpCallback, NULL); return True; } selectedWidget = XtParent(selectedWidget); } break; } case DtHELP_SELECT_INVALID: return False; case DtHELP_SELECT_ABORT: case DtHELP_SELECT_ERROR: default: break; } return True; }
/* * Function Name: InitializePanel * Description: Checks the resources at start up and sets their * labels and toggles appropriately * Arguments: pane - area containing the buttons and toggles * Returns: Nothing * */ void InitializePanel(Widget pane) { Arg args[10]; Cardinal argcnt; Boolean auto_close; Boolean connect; XmString xmstring; XtCallbackStatus status; Widget lab_temp, tog_temp; argcnt = 0; XtSetArg(args[argcnt], XmNautoClose, &auto_close); argcnt++; XtSetArg(args[argcnt], XmNconnectNodes, &connect); argcnt++; XtGetValues(G_outline, args, argcnt); /* * Initialize Node State Callback Toggle and Label */ lab_temp = XtNameToWidget(pane, "*callback_lab"); if (lab_temp == NULL) { fprintf(stderr, "InitializePane: cannot find callback_lab\n"); exit(1); } tog_temp = XtNameToWidget(pane, "*callback_tog"); if (tog_temp == NULL) { fprintf(stderr, "InitializePane: cannot find callback_tog\n"); exit(1); } status = XtHasCallbacks(G_outline, XmNnodeStateCallback); switch(status) { case XtCallbackHasSome: XmToggleButtonSetState(tog_temp, True, False); xmstring = XmStringCreateSimple("Added"); break; case XtCallbackNoList: case XtCallbackHasNone: default: XmToggleButtonSetState(tog_temp, False, False); xmstring = XmStringCreateSimple("Not Added"); break; } argcnt = 0; XtSetArg(args[argcnt], XmNlabelString, xmstring); argcnt++; XtSetValues(lab_temp, args, argcnt); XmStringFree(xmstring); /* * Initialize Auto Close Toggle */ tog_temp = XtNameToWidget(pane, "*autoclose_tog"); if (tog_temp == NULL) { fprintf(stderr, "InitializePane: cannot find autoclose_tog\n"); exit(1); } XmToggleButtonSetState(tog_temp, auto_close, False); tog_temp = XtNameToWidget(pane, "*connect_tog"); if (tog_temp == NULL) { fprintf(stderr, "InitializePane: cannot find connecct_tog\n"); exit(1); } XmToggleButtonSetState(tog_temp, connect, False); }
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 MotifUI::DoContextualHelp() { Widget context_widget, shell; #ifdef NO_CDE XEvent event; static Cursor cursor = (Cursor) NULL; if (cursor == (Cursor) NULL) cursor = XCreateFontCursor(display, XC_question_arrow); #endif BaseUI *window = this; while (window->UIClass() != MAIN_WINDOW) window = window->Parent(); shell = ((MotifUI *)window)->_w; #ifdef NO_CDE context_widget = XmTrackingEvent(shell, cursor, False, &event); if (event.type == KeyPress || event.type == KeyRelease) { int offset; KeySym keySym; // Look for ESC key press and stop if we get one if (event.xkey.state & ShiftMask) offset = 1; else offset = 0; keySym = XLookupKeysym((XKeyEvent *)&event, offset); if (keySym == XK_Escape) return; } if (context_widget != NULL) { #else int returnVal = DtHelpReturnSelectedWidgetId(shell, NULL, &context_widget); if (returnVal == DtHELP_SELECT_VALID) { #endif XmAnyCallbackStruct cb; cb.reason = XmCR_HELP; #ifdef NO_CDE cb.event = &event; #endif while (context_widget != NULL) { // If there is no help at this widget, back track to find help if (XtHasCallbacks(context_widget, XmNhelpCallback) == XtCallbackHasSome) { XtCallCallbacks(context_widget, XmNhelpCallback, &cb); break; } else context_widget = XtParent(context_widget); } } } void MotifUI::WidgetHelpCB(Widget, XtPointer clientData, XtPointer) { MotifUI * obj = (MotifUI *) clientData; obj->HandleHelpRequest(); }
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 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 */
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 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 */
void show_main_help(Widget w, XtPointer clientData, XtPointer cbs) { int ac; Arg al[10]; Calendar *c = calendar; Props_pu *p = (Props_pu *) c->properties_pu; Widget selWidget = NULL; int status = DtHELP_SELECT_ERROR; ac = 0; XtSetArg(al[ac], DtNhelpType, DtHELP_TYPE_TOPIC); ac++; switch ((int)clientData) { case HELP_OVERVIEW: XtSetArg(al[ac], DtNhelpVolume, "Calendar"); ac++; XtSetArg(al[ac], DtNlocationId, "_HOMETOPIC"); ac++; break; case HELP_USINGHELP: XtSetArg(al[ac], DtNhelpVolume, "Help4Help"); ac++; XtSetArg(al[ac], DtNlocationId, "_HOMETOPIC"); ac++; break; case HELP_TASKS: XtSetArg(al[ac], DtNhelpVolume, "Calendar"); ac++; XtSetArg(al[ac], DtNlocationId, "TASKS"); ac++; break; case HELP_REFERENCE: XtSetArg(al[ac], DtNhelpVolume, "Calendar"); ac++; XtSetArg(al[ac], DtNlocationId, "REFERENCE"); ac++; break; case HELP_ABOUTCALENDAR: XtSetArg(al[ac], DtNhelpVolume, "Help4Help"); ac++; XtSetArg(al[ac], DtNlocationId, "_COPYRIGHT"); ac++; break; case HELP_TOC: XtSetArg(al[ac], DtNhelpVolume, "Calendar"); ac++; XtSetArg(al[ac], DtNlocationId, "TOC"); ac++; break; case HELP_ONITEM: while (!XtIsSubclass(w, applicationShellWidgetClass)) w = XtParent(w); status = DtHelpReturnSelectedWidgetId(w, NULL, &selWidget); switch ((int)status) { case DtHELP_SELECT_ERROR: printf(catgets(c->DT_catd, 1, 350, "Selection Error, cannot continue\n")); break; case DtHELP_SELECT_VALID: while (selWidget != NULL) { if ((XtHasCallbacks(selWidget, XmNhelpCallback) == XtCallbackHasSome)) { XtCallCallbacks((Widget)selWidget, XmNhelpCallback,NULL); break; } else selWidget = XtParent(selWidget); } break; case DtHELP_SELECT_ABORT: return; case DtHELP_SELECT_INVALID: { char *title = XtNewString(catgets(c->DT_catd, 1, 110, "Calendar : Error - Help")); char *text = XtNewString(catgets(c->DT_catd, 1, 352, "You must select a component within your application.")); char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue")); dialog_popup(c->frame, DIALOG_TITLE, title, DIALOG_TEXT, text, BUTTON_IDENT, 1, ident1, DIALOG_IMAGE, p->xm_error_pixmap, NULL); XtFree(ident1); XtFree(text); XtFree(title); return; } } break; default: XtSetArg(al[ac], DtNhelpVolume, "Calendar"); ac++; XtSetArg(al[ac], DtNlocationId, "_HOMETOPIC"); ac++; break; } display_help(c, al, ac); }
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 */