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 */
