static void
apply_prefs_cb(XtPointer arg)
{
struct topic_info *info = (struct topic_info *)arg;
struct prefs_choice *prefs = (struct prefs_choice *)info->data;
size_t i;
Widget colorsel;
if (get_widget_by_name(&colorsel, globals.widgets.top_level, Xdvi_COLOR_DIALOG_NAME, False)) {
XtPopdown(XtParent(colorsel));
}
/* pop down dependent windows */
TRACE_GUI((stderr, "window count: %lu\n", (unsigned long)prefs->depwin_cnt));
for (i = 0; i < prefs->depwin_cnt; i++) {
TRACE_GUI((stderr, "popping down %lu: %p", (unsigned long)i, (void *)(prefs->depwin[i])));
if (XtIsRealized(prefs->depwin[i])) {
XtCallCallbacks(prefs->depwin[i], XmNcancelCallback, NULL);
XSync(DISP, True); /* wait for server to catch up */
if (XtIsRealized(prefs->depwin[i])) {
TRACE_GUI((stderr, "calling XmNokCallback of %lu: %p", (unsigned long)i, (void *)(prefs->depwin[i])));
XtCallCallbacks(prefs->depwin[i], XmNokCallback, NULL);
}
}
}
free(prefs->depwin);
prefs->depwin = NULL;
prefs->depwin_cnt = 0;
if (prefs->db == NULL) /* callback invoked multiple times? */
return;
merge_into_user_db(prefs->db); /* this destroys prefs->db */
prefs->db = NULL;
/* remember some current values */
free(globals.curr_paper);
if (resource.paper != NULL)
globals.curr_paper = xstrdup(resource.paper);
free(globals.curr_editor);
if (resource.editor != NULL)
globals.curr_editor = xstrdup(resource.editor);
free(globals.curr_browser);
if (resource.browser != NULL)
globals.curr_browser = xstrdup(resource.browser);
/* fprintf(stderr, "set curr_browser to: |%s|\n", globals.curr_browser); */
/* fprintf(stderr, "set curr_editor to: |%s|\n", globals.curr_editor); */
if (get_xdvi_window_id(False, NULL) && save_user_preferences(False)) {
/* if other instances of xdvi are running, make them reread the
changed preferences by writing them to ~/.xdvirc.tmp and having
them read that file; otherwise they would overwrite the file if
user quits them after the current instance.
*/
get_xdvi_window_id(False, reread_prefs_cb);
}
}
static void
revert_prefs_cb(XtPointer arg)
{
struct topic_info *info = (struct topic_info *)arg;
struct prefs_choice *prefs = (struct prefs_choice *)info->data;
size_t i;
/* pop down dependent windows */
TRACE_GUI((stderr, "window count: %lu", (unsigned long)prefs->depwin_cnt));
for (i = 0; i < prefs->depwin_cnt; i++) {
TRACE_GUI((stderr, "popping down %lu: %p", (unsigned long)i, (void *)(prefs->depwin[i])));
if (XtIsRealized(prefs->depwin[i])) {
XtCallCallbacks(prefs->depwin[i], XmNcancelCallback, NULL);
XSync(DISP, True); /* wait for server to catch up */
if (XtIsRealized(prefs->depwin[i])) {
TRACE_GUI((stderr, "calling XmNokCallback of %lu: %p", (unsigned long)i, (void *)(prefs->depwin[i])));
XtCallCallbacks(prefs->depwin[i], XmNokCallback, NULL);
}
}
}
free(prefs->depwin);
prefs->depwin = NULL;
prefs->depwin_cnt = 0;
if (prefs->db == NULL) { /* callback invoked multiple times, or prefs not changed */
return;
}
revert_resources();
XrmDestroyDatabase(prefs->db);
prefs->db = NULL;
}
static void notify_act(Widget w, XEvent *event, String *params, Cardinal *n)
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
TF();
if( ! c->isflip ) {
c->msg.cmd = MSG_FIRE;
XtCallCallbacks( w, XtNcallback, (XtPointer) & c->msg );
}
else {
if( c->msg.state == STATE_ARMED ) {
c->msg.state = STATE_SELECTED;
c->msg.cmd = MSG_FIRE;
XtCallCallbacks( w, XtNcallback, (XtPointer) & c->msg );
}
else {
c->msg.state = STATE_ARMED;
/* make virtual keyboard visible */
vis_setup_slider_t msg;
msg.min = c->msg.min_value;
msg.max = c->msg.max_value;
msg.cur = c->msg.value;
sig_send( w, VIS_SETUP_SLIDER, &msg );
}
}
expose(w, NULL, 0);
}
static void
panner_cb(Widget widget, XtPointer closure, XtPointer report_ptr)
{
XawPannerReport *report = (XawPannerReport *)report_ptr;
static int orig_x = 0, orig_y = 0;
int x = report->slider_x;
int y = report->slider_y;
static Dimension w, h;
static Arg arg_wh_clip[] = {
{XtNwidth, (XtArgVal) &w},
{XtNheight, (XtArgVal) &h},
};
UNUSED(closure);
XtGetValues(globals.widgets.clip_widget, arg_wh_clip, XtNumber(arg_wh_clip));
fprintf(stderr, "w: %d, h: %d, globals.page.w: %d, globals.page.h: %d\n",
w, h, globals.page.w, globals.page.h);
XtVaSetValues(widget,
XtNsliderWidth, w, XtNsliderHeight, h,
XtNcanvasWidth, globals.page.w, XtNcanvasHeight, globals.page.h,
NULL);
fprintf(stderr, "panner moved: %d, %d\n", report->slider_x, report->slider_y);
if (globals.widgets.x_bar != NULL)
XtCallCallbacks(globals.widgets.x_bar, XtNscrollProc, cast_int_to_XtPointer(x - orig_x));
if (globals.widgets.y_bar != NULL)
XtCallCallbacks(globals.widgets.y_bar, XtNscrollProc, cast_int_to_XtPointer(y - orig_y));
orig_x = x;
orig_y = y;
}
/*
** Cancel a block drag operation
*/
void CancelBlockDrag(TextWidget tw)
{
textBuffer *buf = tw->text.textD->buffer;
textBuffer *origBuf = tw->text.dragOrigBuf;
selection *origSel = &origBuf->primary;
int modRangeStart = -1, origModRangeEnd, bufModRangeEnd;
char *repText;
dragEndCBStruct endStruct;
/* If the operation was a move, make the modify range reflect the
removal of the text from the starting position */
if (tw->text.dragSourceDeleted != 0)
trackModifyRange(&modRangeStart, &bufModRangeEnd, &origModRangeEnd,
tw->text.dragSourceDeletePos, tw->text.dragSourceInserted,
tw->text.dragSourceDeleted);
/* Include the insert being undone from the last step in the modified
range. */
trackModifyRange(&modRangeStart, &bufModRangeEnd, &origModRangeEnd,
tw->text.dragInsertPos, tw->text.dragInserted, tw->text.dragDeleted);
/* Make the changes in the buffer */
repText = BufGetRange(origBuf, modRangeStart, origModRangeEnd);
BufReplace(buf, modRangeStart, bufModRangeEnd, repText);
XtFree(repText);
/* Reset the selection and cursor position */
if (origSel->rectangular)
BufRectSelect(buf, origSel->start, origSel->end, origSel->rectStart,
origSel->rectEnd);
else
BufSelect(buf, origSel->start, origSel->end);
TextDSetInsertPosition(tw->text.textD, buf->cursorPosHint);
XtCallCallbacks((Widget)tw, textNcursorMovementCallback, NULL);
tw->text.emTabsBeforeCursor = 0;
/* Free the backup buffer */
BufFree(origBuf);
/* Indicate end of drag */
tw->text.dragState = DRAG_CANCELED;
/* Call finish-drag calback */
endStruct.startPos = 0;
endStruct.nCharsDeleted = 0;
endStruct.nCharsInserted = 0;
endStruct.deletedText = NULL;
XtCallCallbacks((Widget)tw, textNdragEndCallback, (XtPointer)&endStruct);
}
void warpCanvasRotCb(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
MAPaintImageWinStruct *winStruct = (MAPaintImageWinStruct *) client_data;
XmPushButtonCallbackStruct
*cbs = (XmPushButtonCallbackStruct *) call_data;
if( cbs->event->xbutton.state & Mod1Mask ){
winStruct->rot -= 1;
}
else {
winStruct->rot += 1;
}
while( winStruct->rot < 0 ){
winStruct->rot += 4;
}
winStruct->rot %= 4;
if( winStruct == &(warpGlobals.ovly) ){
warpSetOvlyXImages(winStruct, 0);
warpSetOvlyXImages(winStruct, 1);
warpSetOvlyXImage(winStruct);
}
else {
warpSetXImage(winStruct);
}
XtCallCallbacks(winStruct->canvas, XmNexposeCallback, call_data);
return;
}
Boolean
_XmTextModifyVerify(XmTextWidget initiator,
XEvent *event,
XmTextPosition *start,
XmTextPosition *end,
XmTextPosition *cursorPos,
XmTextBlock block,
XmTextBlock newblock,
Boolean *freeBlock)
{
XmTextVerifyCallbackStruct cbs;
cbs.reason = XmCR_MODIFYING_TEXT_VALUE;
cbs.event = event;
cbs.doit = True;
cbs.currInsert = *cursorPos;
cbs.newInsert = *cursorPos;
cbs.startPos = *start;
cbs.endPos = *end;
cbs.text = block;
if (Text_ModifyVerifyCallback(initiator))
{
XtCallCallbacks((Widget)initiator, XmNmodifyVerifyCallback, &cbs);
}
return(cbs.doit);
}
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);
}
/*!
* \ingroup HGU_GL
* \brief Trackball animation time-out procedure which calls any
* trackball callbacks and then if the trackball is in
* it's animation mode reregisters itself as a time-out
* procedure.
* \param clientData Used to pass the trackball instance.
* \param id Timeout function id.
*/
static void HGUglwCanvasTbAnimateFn(XtPointer clientData, XtIntervalId *id)
{
Widget givenW;
HGUglwCanvasTbWidget tbW;
HGUglwCanvasTbPart *ctb;
HGUglwCanvasCallbackStruct cb;
givenW = (Widget )clientData;
tbW = (HGUglwCanvasTbWidget )clientData;
ctb = &(tbW->hguGLwCanvasTb);
WLZ_VTX_3_ADD(ctb->translateCurrent, ctb->translateCurrent,
ctb->translateDelta);
ctb->rotateCurrent = HGUglQuatProduct(ctb->rotateCurrent, ctb->rotateDelta);
cb.reason = HGUglw_CR_TRACKBALL;
cb.event = &(ctb->tbEvent);
cb.width = tbW->core.width;
cb.height = tbW->core.height;
cb.glxCtx = tbW->hguGLwCanvas.glxCtx;
XtCallCallbacks((Widget )tbW, HGUglwNtrackballCallback, &cb);
if(ctb->trackballMode != HGUglwCANVASTB_MODE_ANIMATION)
{
ctb->animateFnId = 0;
}
else
{
ctb->animateFnId = XtAppAddTimeOut(XtWidgetToApplicationContext(givenW),
ctb->animateInterval,
HGUglwCanvasTbAnimateFn,
clientData);
}
}
/************************************************************************
* Function: void update_slider_value() *
* Purpose: Callback function used to update the the scale value *
* in response to a value input in the text field *
* All the XmNvalueChangedCallbacks are called *
* Returns: *
* Arguments:
************************************************************************/
static void update_slider_value(Widget text,
Widget scale,
XmAnyCallbackStruct *cbs)
{
short points;
int val, min, max, oldval;
HGU_XmSliderFunc func;
String string;
XmScaleCallbackStruct scale_cbs;
XtVaGetValues(text, XmNvalue, &string, NULL);
XtVaGetValues(scale, XmNdecimalPoints, &points,
XmNminimum, &min, XmNmaximum, &max,
XmNuserData, &func, NULL);
val = slider_scale_value(string, points, min, max, func);
XtVaGetValues(scale, XmNvalue, &oldval, NULL);
if( val == oldval ){
return;
}
val = (val > min) ? val : min;
val = (val < max) ? val : max;
XtVaSetValues(scale, XmNvalue, val, NULL);
scale_cbs.reason = XmCR_VALUE_CHANGED;
scale_cbs.event = (cbs == NULL) ? NULL : cbs->event;
scale_cbs.value = val;
XtCallCallbacks( scale, XmNvalueChangedCallback, &scale_cbs );
}
static void
CanvasResize(Widget w)
{
if (!XtIsRealized(w))
return;
XtCallCallbacks(w, XtNcanvasResizeCallback, (XtPointer) w);
}
/*
** Complete a block text drag operation
*/
void FinishBlockDrag(TextWidget tw)
{
dragEndCBStruct endStruct;
int modRangeStart = -1, origModRangeEnd, bufModRangeEnd;
char *deletedText;
/* Find the changed region of the buffer, covering both the deletion
of the selected text at the drag start position, and insertion at
the drag destination */
trackModifyRange(&modRangeStart, &bufModRangeEnd, &origModRangeEnd,
tw->text.dragSourceDeletePos, tw->text.dragSourceInserted,
tw->text.dragSourceDeleted);
trackModifyRange(&modRangeStart, &bufModRangeEnd, &origModRangeEnd,
tw->text.dragInsertPos, tw->text.dragInserted,
tw->text.dragDeleted);
/* Get the original (pre-modified) range of text from saved backup buffer */
deletedText = BufGetRange(tw->text.dragOrigBuf, modRangeStart,
origModRangeEnd);
/* Free the backup buffer */
BufFree(tw->text.dragOrigBuf);
/* Return to normal drag state */
tw->text.dragState = NOT_CLICKED;
/* Call finish-drag calback */
endStruct.startPos = modRangeStart;
endStruct.nCharsDeleted = origModRangeEnd - modRangeStart;
endStruct.nCharsInserted = bufModRangeEnd - modRangeStart;
endStruct.deletedText = deletedText;
XtCallCallbacks((Widget)tw, textNdragEndCallback, (XtPointer)&endStruct);
XtFree(deletedText);
}
void _XtPopup(
Widget widget,
XtGrabKind grab_kind,
_XtBoolean spring_loaded)
{
register ShellWidget shell_widget = (ShellWidget) widget;
if (! XtIsShell(widget)) {
XtAppErrorMsg(XtWidgetToApplicationContext(widget),
"invalidClass","xtPopup",XtCXtToolkitError,
"XtPopup requires a subclass of shellWidgetClass",
(String *)NULL, (Cardinal *)NULL);
}
if (! shell_widget->shell.popped_up) {
XtGrabKind call_data = grab_kind;
XtCallCallbacks(widget, XtNpopupCallback, (XtPointer)&call_data);
shell_widget->shell.popped_up = TRUE;
shell_widget->shell.grab_kind = grab_kind;
shell_widget->shell.spring_loaded = spring_loaded;
if (shell_widget->shell.create_popup_child_proc != NULL) {
(*(shell_widget->shell.create_popup_child_proc))(widget);
}
if (grab_kind == XtGrabExclusive) {
XtAddGrab(widget, TRUE, spring_loaded);
} else if (grab_kind == XtGrabNonexclusive) {
XtAddGrab(widget, FALSE, spring_loaded);
}
XtRealizeWidget(widget);
XMapRaised(XtDisplay(widget), XtWindow(widget));
} else
XRaiseWindow(XtDisplay(widget), XtWindow(widget));
} /* _XtPopup */
void warpCanvasMagCb(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
MAPaintImageWinStruct *winStruct = (MAPaintImageWinStruct *) client_data;
XmPushButtonCallbackStruct
*cbs = (XmPushButtonCallbackStruct *) call_data;
if( cbs->event->xbutton.state & (Mod1Mask|Mod2Mask|ControlMask|ShiftMask) ){
if( winStruct->mag > 0.25 ){
winStruct->mag /= 2.0;
}
}
else {
if( winStruct->mag < 8.0 ){
winStruct->mag *= 2.0;
}
}
if( winStruct == &(warpGlobals.ovly) ){
warpSetOvlyXImages(winStruct, 0);
warpSetOvlyXImages(winStruct, 1);
warpSetOvlyXImage(winStruct);
}
else {
warpSetXImage(winStruct);
}
XtCallCallbacks(winStruct->canvas, XmNexposeCallback, call_data);
return;
}
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
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 ui_menu_update_all(void)
{
int i;
for (i = 0; i < num_checkmark_menu_items; i++) {
XtCallCallbacks(checkmark_menu_items[i], XtNcallback, (XtPointer)!NULL);
}
}
/* ARGSUSED */
static void Redisplay(Widget w, XEvent *event, Region region)
/* unused */
{
/* This isn't correct - we need to call the callback with region. */
XtCallCallbacks(w, XtNexposeCallback, (caddr_t) event);
}
static void
Activate(Widget W, XtPointer client_data, XtPointer call_data)
{
#ifdef DEBUG
printf("NumEntry - Activate(%s) - %s\n", XtName(W), XtName(XtParent(W)));
#endif
DoMath(XtParent(W));
XtCallCallbacks(XtParent(W), XmNactivateCallback, call_data);
}
void
ObjectHelp(
Widget w,
XtPointer clientData,
XtPointer callData )
{
XtCallCallbacks((Widget)clientData, XmNhelpCallback, NULL);
}
/*ARGSUSED*/
static void
draw_it(XtPointer client_data, XtIntervalId *id)
{
StripChartWidget w = (StripChartWidget)client_data;
double value;
if (w->strip_chart.update > 0)
w->strip_chart.interval_id =
XtAppAddTimeOut(XtWidgetToApplicationContext((Widget)w),
w->strip_chart.update * MS_PER_SEC,draw_it,
client_data);
if (w->strip_chart.interval >= XtWidth(w))
MoveChart((StripChartWidget)w, True);
/* Get the value, stash the point and draw corresponding line */
if (w->strip_chart.get_value == NULL)
return;
XtCallCallbacks((Widget)w, XtNgetValue, (XtPointer)&value);
/*
* Keep w->strip_chart.max_value up to date, and if this data
* point is off the graph, change the scale to make it fit
*/
if (value > w->strip_chart.max_value) {
w->strip_chart.max_value = value;
if (XtIsRealized((Widget)w) &&
w->strip_chart.max_value > w->strip_chart.scale) {
XClearWindow(XtDisplay(w), XtWindow(w));
w->strip_chart.interval = repaint_window(w, 0, XtWidth(w));
}
}
w->strip_chart.valuedata[w->strip_chart.interval] = value;
if (XtIsRealized((Widget)w)) {
int y = (int)(XtHeight(w) - XtHeight(w) * value
/ w->strip_chart.scale);
XFillRectangle(XtDisplay(w), XtWindow(w), w->strip_chart.fgGC,
w->strip_chart.interval, y,
1, XtHeight(w) - y);
/*
* Fill in the graph lines we just painted over
*/
if (w->strip_chart.points != NULL) {
w->strip_chart.points[0].x = w->strip_chart.interval;
XDrawPoints(XtDisplay(w), XtWindow(w), w->strip_chart.hiGC,
w->strip_chart.points, w->strip_chart.scale - 1,
CoordModePrevious);
}
XFlush(XtDisplay(w)); /* Flush output buffers */
}
w->strip_chart.interval++; /* Next point */
}
/************************************************************************
* Function: Widget HGU_XmCreateHorizontalFuncSlider() *
* Purpose: Same as HGU_XmCreateHorizontalSlider() except that the *
* scale is determined by the input function. The only *
* constraint on the function is that it must accept *
* an argument in the range 0-1 and return a float value *
* in the range 0-1. A second argument is a flag to request*
* the direct function or its inverse. The direct function *
* maps the scale proportional value ie: *
* (scale_val-minval) / (maxval-minval) on to the *
* required proportional times 10**decimalPoints ie. *
* (true_val*10**decimalPoints - minval)/(maxval-minval). *
************************************************************************/
static void UpdateFromText(
Widget w,
XEvent *event,
String *params,
Cardinal *num_params)
{
XtCallCallbacks(w, XmNactivateCallback, NULL);
return;
}
/*
* 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 */
}
/* action procedures */
static void inputAxes (XtcwpAxesWidget w, XEvent *event,
char *args[], int nargs)
{
XtcwpAxesCallbackStruct cb;
args += 0*(nargs); /* keep compiler happy */
/* call callback */
fillCallbackStruct(w,XtcwpCR_INPUT,event,NULL,&cb);
XtCallCallbacks ((Widget) w,XtNinputCallback,&cb);
}
static void
LosingFocus(Widget W, XtPointer client_data, XtPointer call_data)
{
#ifdef DEBUG
printf("NumEntry - LosingFocus(%s) - >%s<\n", XtName(W), NumEntry_Value(XtParent(W)));
#endif
AutoRepeat(W, False);
DoMath(XtParent(W));
XtCallCallbacks(XtParent(W), XmNlosingFocusCallback, call_data);
}
static void
update_button(Widget button, Pixel pix)
{
struct color_button_info *cinfo;
static XmDrawnButtonCallbackStruct cbs;
XtVaGetValues(button, XmNuserData, &cinfo, NULL);
cinfo->pixel = pix;
cbs.reason = XmCR_EXPOSE;
XtCallCallbacks(button, XmNexposeCallback, &cbs);
}
/* ARGSUSED */
void
closeCB(
Widget w,
caddr_t client_data,
caddr_t call_data )
{
Editor *pPad = (Editor *)client_data;
/* call the callback for Exit within the File Menu pulldown */
XtCallCallbacks(pPad->ExitWid, XmNactivateCallback, (XtPointer)pPad);
}
/*
* Implementation
*/
static void
GripAction(Widget widget, XEvent *event, String *params, Cardinal *num_params)
{
XawGripCallDataRec call_data;
call_data.event = event;
call_data.params = params;
call_data.num_params = *num_params;
XtCallCallbacks(widget, XtNcallback, (XtPointer)&call_data);
}
void write_obj_cb(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
if( write_obj_dialog ){
XtManageChild( write_obj_dialog );
XtPopup( XtParent(write_obj_dialog), XtGrabNone );
/* kludge to update the file selections */
XtCallCallbacks(write_obj_dialog, XmNmapCallback, call_data);
}
return;
}
static void
CanvasExpose(Widget w, XEvent * event, Region region)
{
CanvasExposeDataRec data;
data.w = w;
data.event = event;
data.region = region;
if (!XtIsRealized(w))
return;
XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer) &data);
}