void quitCallback (Widget w, XtPointer clientData, XtPointer callData)
{
XtVaSetValues (quit, XmNsensitive, False, NULL);
XtMapWidget (no);
XtMapWidget (yes);
}
static void
map_move_points(xgobidata *xg, Boolean movepts)
{
if (movepts)
{
XtMapWidget(xg->movepts_mouse);
XtMapWidget(mp_panel);
}
else
{
XtUnmapWidget(xg->movepts_mouse);
XtUnmapWidget(mp_panel);
}
}
/*
* handler for week view menu item.
*/
void
week_button (Widget widget, XtPointer data, XtPointer cbs)
{
Calendar *c = calendar;
if (c->view->glance == weekGlance)
return;
switch (c->view->glance) {
case dayGlance:
c->view->glance = weekGlance;
cleanup_after_dayview(c);
paint_weekview(c, NULL);
break;
case yearGlance:
c->view->glance = weekGlance;
cleanup_after_yearview(c);
XtMapWidget(c->canvas);
break;
case monthGlance:
c->view->glance = weekGlance;
cleanup_after_monthview(c);
break;
default:
break;
}
}
static void
sched_add (Widget w NOTUSED, XtPointer client_data,
XtPointer call_data NOTUSED)
{
PgmState *pgm = client_data;
void *n;
if (pgm->sched_idx == XAW_LIST_NONE)
return;
n = realloc (pgm->r_sch, sizeof (RsEntry) * (pgm->r_sch_sz + 1));
if (n)
{
pgm->r_sch = n;
rsClearEntry (pgm->r_sch + pgm->r_sch_sz);
pgm->sched_idx = pgm->r_sch_sz;
pgm->r_sch_sz++;
schedChanged (pgm);
XtUnmapWidget (pgm->sched_form);
XtMapWidget (pgm->ed_sched_form);
schedEdDisplay (pgm);
// if(clientRecSched(pgm->sock,pgm->r_sch,pgm->r_sch_sz,pgm->pr_sch,pgm->pr_sch_sz))
// {
// }
// rsDestroy(pgm->r_sch,pgm->r_sch_sz);
// rsDestroy(pgm->pr_sch,pgm->pr_sch_sz);
// schedLoad(pgm);
// message(a,"REC_SCHED failed\n");
}
// schedChanged(pgm);
}
void PopupCallback(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
Widget widget;
Widget *children;
int numChildren;
if( w || call_data ) {
/* to satisfy IRIX646 compiler */
}
widget = (Widget) client_data;
if( XtIsShell( widget ) ) {
XtVaGetValues(widget, XtNchildren, &children,
XtNnumChildren, &numChildren, NULL);
if( numChildren ) {
XtManageChild(*children);
XtMapWidget(*children);
}
XtPopup( widget, XtGrabNone );
}
}
void Container::DoEndUpdate()
{
XtRemoveEventHandler(XtParent(_workArea), ExposureMask, FALSE,
&Container::UpdateAreaMessage, (XtPointer) this);
StringFree(_xm_update_message);
if (XtIsRealized(_workArea))
XClearArea(display, XtWindow(XtParent(_workArea)), 0, 0, 0, 0, TRUE);
_xm_update_message = NULL;
if (_container_type == SCROLLED_WORK_AREA ||
_container_type == WORK_AREA ||
_container_type == SCROLLED_ICON_LIST ||
_container_type == ICON_LIST)
{
if (XtIsRealized(_workArea))
XtMapWidget(_workArea);
GuiWorkAreaEnableRedisplay(_workArea);
XmDropSiteEndUpdate(XtParent(_workArea));
}
else
{
XtManageChild(_workArea);
if (_container_type == SCROLLED_HORIZONTAL_ROW_COLUMN)
XtAppAddTimeOut(appContext, 500, ResizeTimeOut, this);
}
}
bool wxDialog::Show( bool show )
{
if( !wxWindowBase::Show( show ) )
return false;
m_isShown = show;
if (show)
{
if (!wxUSE_INVISIBLE_RESIZE)
XtMapWidget(XtParent((Widget) m_mainWidget));
else
XtManageChild((Widget)m_mainWidget) ;
XRaiseWindow( XtDisplay( (Widget)m_mainWidget ),
XtWindow( (Widget)m_mainWidget) );
}
else
{
if (!wxUSE_INVISIBLE_RESIZE)
XtUnmapWidget(XtParent((Widget) m_mainWidget));
else
XtUnmanageChild((Widget)m_mainWidget) ;
XFlush(XtDisplay((Widget)m_mainWidget));
XSync(XtDisplay((Widget)m_mainWidget), False);
}
return true;
}
/*
* handler for button to switch to day view.
*/
extern void
day_button (Widget widget, XtPointer data, XtPointer cbs)
{
Calendar *c = calendar;
if (c->view->glance == dayGlance)
return;
XtUnmapWidget(c->canvas);
invalidate_cache(c);
switch (c->view->glance) {
case weekGlance:
c->view->glance = dayGlance;
cleanup_after_weekview(c);
break;
case yearGlance:
c->view->glance = dayGlance;
cleanup_after_yearview(c);
break;
case monthGlance:
c->view->glance = dayGlance;
cleanup_after_monthview(c);
break;
default:
break;
}
init_mo(c);
(void)init_dayview(c);
XtMapWidget(c->canvas);
}
/*-------------------------------------------------------------------------*/
void qmonQueuePopup(Widget w, XtPointer cld, XtPointer cad)
{
lList *alp = NULL;
DENTER(GUI_LAYER, "qmonQueuePopup");
/* set busy cursor */
XmtDisplayBusyCursor(w);
qmonMirrorMultiAnswer(CQUEUE_T | EXECHOST_T | CENTRY_T, &alp);
if (alp) {
qmonMessageBox(w, alp, 0);
lFreeList(&alp);
/* set busy cursor */
XmtDisplayDefaultCursor(w);
DEXIT;
return;
}
if (!qmon_queue) {
qmonCreateQueueControl(AppShell);
/*
** create queue customize dialog
*/
/* qmonCreateQCU(qmon_queue, NULL); */
/*
** set the close button callback
** set the icon and icon name
*/
XmtCreatePixmapIcon(qmon_queue, qmonGetIcon("toolbar_queue"), None);
XtVaSetValues(qmon_queue, XtNiconName, "qmon:Queue Control", NULL);
XmtAddDeleteCallback(qmon_queue, XmDO_NOTHING, qmonQueuePopdown, NULL);
XtAddEventHandler(qmon_queue, StructureNotifyMask, False,
SetMinShellSize, NULL);
XtAddEventHandler(qmon_queue, StructureNotifyMask, False,
SetMaxShellSize, (XtPointer) SHELL_WIDTH);
}
xmui_manage(qmon_queue);
/* ForceUpdate(qmon_queue); */
updateQueueList();
#if 0
/*
** workaround for display problem of DrawingArea under some WMs
*/
XtUnmapWidget(queue_da);
XtMapWidget(queue_da);
#endif
/* set busy cursor */
XmtDisplayDefaultCursor(w);
DEXIT;
}
static void
map_plot1d(Boolean on)
{
if (on)
XtMapWidget(plot1d_panel);
else
XtUnmapWidget(plot1d_panel);
}
static void
switch_dlg_back (Widget w, XtPointer client_data, XtPointer call_data)
{
PgmState *pgm = client_data;
switch_dlg_purge_pos (pgm);
XtUnmapWidget (pgm->switch_form);
XtMapWidget (pgm->setup_form);
}
static void
display_monthpanels(Calendar *c)
{
Day *d = (Day *)c->view->day_info;
char buf[BUFSIZ];
int lastyear = year(get_eot());
int firstyear = year(get_bot());
int panel_year;
int panel_month;
XtManageChild(d->panel_form);
XtVaGetValues(d->month_panels[1],
XmNyear, &panel_year,
XmNmonth, &panel_month,
NULL);
if ((panel_year == firstyear) && (panel_month == 1)) {
XtUnmapWidget(d->month_panels[0]);
XtMapWidget(d->month_panels[2]);
sprintf(buf, "%s", catgets(c->DT_catd, 1, 623, "Calendar does not display dates prior to January 1, 1970"));
set_message(c->message_text, buf);
}
else if ((panel_year == lastyear) && (panel_month == 12)) {
XtMapWidget(d->month_panels[0]);
XtUnmapWidget(d->month_panels[2]);
sprintf(buf, "%s", catgets(c->DT_catd, 1, 624, "Calendar does not display dates after December 31, 2037"));
set_message(c->message_text, buf);
}
else {
XtMapWidget(d->month_panels[0]);
XtMapWidget(d->month_panels[2]);
set_message(c->message_text, "");
}
/* switch canvas to attach using its XmNleftPosition value */
/* THIS IS THE RIGHT THIS TO DO, BUT ONLY AFTER REMOVING THE
CODE THAT DRAWS THE OLD MO_BOXES. FOR NOW, WE JUST MANAGE THE
MONTHPANELS ON TOP OF THAT PART OF THE CANVAS - dac
XtVaSetValues(c->canvas,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 40,
NULL);
*/
}
static void
sched_back (Widget w NOTUSED, XtPointer client_data,
XtPointer call_data NOTUSED)
{
PgmState *pgm = client_data;
sched_purge (pgm);
XtUnmapWidget (pgm->sched_form);
XtMapWidget (pgm->main_form);
}
static void
MakePrompt(Widget centerw, const char *prompt,
MakePromptFunc func, const char *def)
{
static Arg dialogArgs[] = {
{XtNlabel, 0},
{XtNvalue, 0},
};
Arg valueArgs[1];
Arg centerArgs[2];
Position source_x, source_y;
Position dest_x, dest_y;
Dimension center_width, center_height;
Dimension prompt_width, prompt_height;
Widget valueWidget;
CancelAction ((Widget)NULL, (XEvent *) 0, (String *) 0, (Cardinal *) 0);
promptShell = XtCreatePopupShell ("promptShell", transientShellWidgetClass,
toplevel, NULL, (Cardinal) 0);
dialogArgs[0].value = (XtArgVal)prompt;
dialogArgs[1].value = (XtArgVal)def;
promptDialog = XtCreateManagedWidget( "promptDialog", dialogWidgetClass,
promptShell, dialogArgs, XtNumber (dialogArgs));
XawDialogAddButton(promptDialog, "accept", NULL, (XtPointer) 0);
XawDialogAddButton(promptDialog, "cancel", NULL, (XtPointer) 0);
valueWidget = XtNameToWidget (promptDialog, "value");
if (valueWidget) {
XtSetArg (valueArgs[0], (String)XtNresizable, TRUE);
XtSetValues (valueWidget, valueArgs, 1);
/*
* as resizable isn't set until just above, the
* default value will be displayed incorrectly.
* rectify the situation by resetting the values
*/
XtSetValues (promptDialog, dialogArgs, XtNumber (dialogArgs));
}
XtSetKeyboardFocus (promptDialog, valueWidget);
XtSetKeyboardFocus (toplevel, valueWidget);
XtRealizeWidget (promptShell);
/*
* place the widget in the center of the "parent"
*/
XtSetArg (centerArgs[0], XtNwidth, ¢er_width);
XtSetArg (centerArgs[1], XtNheight, ¢er_height);
XtGetValues (centerw, centerArgs, 2);
XtSetArg (centerArgs[0], XtNwidth, &prompt_width);
XtSetArg (centerArgs[1], XtNheight, &prompt_height);
XtGetValues (promptShell, centerArgs, 2);
source_x = (center_width - prompt_width) / 2;
source_y = (center_height - prompt_height) / 3;
XtTranslateCoords (centerw, source_x, source_y, &dest_x, &dest_y);
XtSetArg (centerArgs[0], XtNx, dest_x);
XtSetArg (centerArgs[1], XtNy, dest_y);
XtSetValues (promptShell, centerArgs, 2);
XtMapWidget(promptShell);
promptfunction = func;
}
void font_box_switch_to_stand (Widget widget, font_box_data * client, XtPointer motif)
{
if (client->is_stand_mode) return;
XtUnmapWidget (XtParent (client->non_stand_list));
XtMapWidget (client->frame);
client->current_font_name = client->stand_fonts_list [client->current_stand_font]->name;
client->is_stand_mode = 1;
font_box_show_font (client);
}
void hide_widget(QSP_ARG_DECL Screen_Obj *sop, int yesno)
{
#ifdef HAVE_MOTIF
// ?? BUG? should we warn for redundant calls?
if( yesno )
XtUnmapWidget(sop->so_obj);
else
XtMapWidget(sop->so_obj);
#endif // HAVE_MOTIF
}
void iupdrvSetVisible(Ihandle* ih, int visible)
{
Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
if (!widget) widget = ih->handle;
if (visible)
XtMapWidget(widget);
else
XtUnmapWidget(widget);
}
static void
fav_list_dlg_back (Widget w NOTUSED, XtPointer client_data,
XtPointer call_data NOTUSED)
{
PgmState *pgm = client_data;
fav_list_dlg_purge_fav (pgm);
fav_list_dlg_purge_favlist (pgm);
XtUnmapWidget (pgm->favlist_form);
XtMapWidget (pgm->main_form);
}
static void
XawViewportChangeManaged(Widget widget)
{
ViewportWidget w = (ViewportWidget)widget;
int num_children = w->composite.num_children;
Widget child, *childP;
int i;
child = NULL;
for (childP = w->composite.children,
i = 0; i < num_children;
childP++, i++) {
if (XtIsManaged(*childP)
&& *childP != w->viewport.clip
&& *childP != w->viewport.horiz_bar
&& *childP != w->viewport.vert_bar) {
child = *childP;
break;
}
}
if (child != w->viewport.child) {
w->viewport.child = child;
if (child != NULL) {
XtResizeWidget(child, XtWidth(child), XtHeight(child), 0);
if (XtIsRealized(widget)) {
ViewportConstraints constraints =
(ViewportConstraints)child->core.constraints;
if (!XtIsRealized(child)) {
Window window = XtWindow(w);
XtMoveWidget(child, 0, 0);
w->core.window = XtWindow(w->viewport.clip);
XtRealizeWidget(child);
w->core.window = window;
constraints->viewport.reparented = True;
}
else if (!constraints->viewport.reparented) {
XReparentWindow(XtDisplay(w), XtWindow(child),
XtWindow(w->viewport.clip), 0, 0);
constraints->viewport.reparented = True;
if (child->core.mapped_when_managed)
XtMapWidget(child);
}
}
GetGeometry(widget, XtWidth(child), XtHeight(child));
(*((ViewportWidgetClass)w->core.widget_class)->form_class.layout)
((FormWidget)w, XtWidth(w), XtHeight(w), True /* True? */);
}
}
#ifdef notdef
(*Superclass->composite_class.change_managed)(widget);
#endif
}
void
ScrollBarOn(XtermWidget xw, Bool init)
{
TScreen *screen = TScreenOf(xw);
if (screen->fullVwin.sb_info.width || IsIcon(screen))
return;
TRACE(("ScrollBarOn(init %s)\n", BtoS(init)));
if (init) { /* then create it only */
if (screen->scrollWidget == 0) {
/* make it a dummy size and resize later */
screen->scrollWidget = CreateScrollBar(xw,
-ScrollBarBorder(xw),
-ScrollBarBorder(xw),
5);
if (screen->scrollWidget == NULL) {
Bell(xw, XkbBI_MinorError, 0);
}
}
} else if (!screen->scrollWidget || !XtIsRealized((Widget) xw)) {
Bell(xw, XkbBI_MinorError, 0);
Bell(xw, XkbBI_MinorError, 0);
} else {
ResizeScrollBar(xw);
xtermAddInput(screen->scrollWidget);
XtRealizeWidget(screen->scrollWidget);
TRACE_TRANS("scrollbar", screen->scrollWidget);
screen->fullVwin.sb_info.rv_cached = False;
screen->fullVwin.sb_info.width = (screen->scrollWidget->core.width
+ BorderWidth(screen->scrollWidget));
TRACE(("setting scrollbar width %d = %d + %d\n",
screen->fullVwin.sb_info.width,
screen->scrollWidget->core.width,
BorderWidth(screen->scrollWidget)));
ScrollBarDrawThumb(screen->scrollWidget);
DoResizeScreen(xw);
#ifdef SCROLLBAR_RIGHT
updateRightScrollbar(xw);
#endif
XtMapWidget(screen->scrollWidget);
update_scrollbar();
if (screen->visbuf) {
xtermClear(xw);
Redraw();
}
}
}
void iupdrvTabsSetCurrentTab(Ihandle* ih, int pos)
{
Ihandle* child = IupGetChild(ih, pos);
Ihandle* prev_child = IupGetChild(ih, iupdrvTabsGetCurrentTab(ih));
Widget child_manager = (Widget)iupAttribGet(child, "_IUPTAB_CONTAINER");
Widget prev_child_manager = (Widget)iupAttribGet(prev_child, "_IUPTAB_CONTAINER");
XtMapWidget(child_manager);
if (prev_child_manager) XtUnmapWidget(prev_child_manager);
XtVaSetValues(ih->handle, XmNcurrentPageNumber, pos, NULL);
}
// Create menubar
bool wxMenuBar::CreateMenuBar(wxFrame* parent)
{
m_parent = parent; // bleach... override it!
PreCreation();
m_parent = NULL;
if (m_mainWidget)
{
XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
/*
if (!XtIsManaged((Widget) m_mainWidget))
XtManageChild((Widget) m_mainWidget);
*/
XtMapWidget((Widget) m_mainWidget);
return true;
}
Widget menuBarW = XmCreateMenuBar ((Widget) parent->GetMainWidget(),
wxMOTIF_STR("MenuBar"), NULL, 0);
m_mainWidget = (WXWidget) menuBarW;
size_t menuCount = GetMenuCount();
for (size_t i = 0; i < menuCount; i++)
{
wxMenu *menu = GetMenu(i);
wxString title(m_titles[i]);
menu->SetButtonWidget(menu->CreateMenu (this, menuBarW, menu, i, title, true));
if (strcmp (wxStripMenuCodes(title), "Help") == 0)
XtVaSetValues ((Widget) menuBarW, XmNmenuHelpWidget, (Widget) menu->GetButtonWidget(), NULL);
// tear off menu support
#if (XmVersion >= 1002)
if ( menu->IsTearOff() )
{
XtVaSetValues(GetWidget(menu),
XmNtearOffModel, XmTEAR_OFF_ENABLED,
NULL);
Widget tearOff = XmGetTearOffControl(GetWidget(menu));
wxDoChangeForegroundColour((Widget) tearOff, m_foregroundColour);
wxDoChangeBackgroundColour((Widget) tearOff, m_backgroundColour, true);
}
#endif
}
PostCreation();
XtVaSetValues((Widget) parent->GetMainWidget(), XmNmenuBar, (Widget) m_mainWidget, NULL);
XtRealizeWidget ((Widget) menuBarW);
XtManageChild ((Widget) menuBarW);
SetMenuBarFrame(parent);
return true;
}
static void
sched_edit (Widget w NOTUSED, XtPointer client_data,
XtPointer call_data NOTUSED)
{
PgmState *pgm = client_data;
if (pgm->sched_idx == XAW_LIST_NONE)
return;
XtUnmapWidget (pgm->sched_form);
XtMapWidget (pgm->ed_sched_form);
schedEdDisplay (pgm);
}
/*
** ManageDialogCenteredOnPointer is used in place of XtManageChild for
** popping up a dialog to enable the dialog to be centered under the
** mouse pointer. Whether it pops up the dialog centered under the pointer
** or in its default position centered over the parent widget, depends on
** the value set in the SetPointerCenteredDialogs call.
*/
void ManageDialogCenteredOnPointer(Widget dialogChild)
{
Widget shell = XtParent(dialogChild);
Window root, child;
unsigned int mask;
unsigned int width, height, borderWidth, depth;
int x, y, winX, winY, maxX, maxY;
Boolean mappedWhenManaged;
/* If this feature is not enabled, just manage the dialog */
if (!PointerCenteredDialogsEnabled) {
XtManageChild(dialogChild);
return;
}
/* Temporarily set value of XmNmappedWhenManaged
to stop the dialog from popping up right away */
XtVaGetValues(shell, XmNmappedWhenManaged, &mappedWhenManaged, 0);
XtVaSetValues(shell, XmNmappedWhenManaged, False, 0);
/* Manage the dialog */
XtManageChild(dialogChild);
/* Get the pointer position (x, y) */
XQueryPointer(XtDisplay(shell), XtWindow(shell), &root, &child,
&x, &y, &winX, &winY, &mask);
/* Translate the pointer position (x, y) into a position for the new
window that will place the pointer at its center */
XGetGeometry(XtDisplay(shell), XtWindow(shell), &root, &winX, &winY,
&width, &height, &borderWidth, &depth);
width += 2 * borderWidth;
height += 2 * borderWidth;
x -= width/2;
y -= height/2;
/* Ensure that the dialog remains on screen */
maxX = XtScreen(shell)->width - width;
maxY = XtScreen(shell)->height - height;
if (x < 0) x = 0;
if (x > maxX) x = maxX;
if (y < 0) y = 0;
if (y > maxY) y = maxY;
/* Set desired window position in the DialogShell */
XtVaSetValues(shell, XmNx, x, XmNy, y, NULL);
/* Map the widget */
XtMapWidget(shell);
/* Restore the value of XmNmappedWhenManaged */
XtVaSetValues(shell, XmNmappedWhenManaged, mappedWhenManaged, 0);
}
void iupdrvDialogSetVisible(Ihandle* ih, int visible)
{
if (visible)
{
XtMapWidget(ih->handle);
XRaiseWindow(iupmot_display, XtWindow(ih->handle));
while (!iupdrvDialogIsVisible(ih)); /* waits until window get mapped */
}
else
{
/* if iupdrvIsVisible reports hidden, then it should be minimized */
if (!iupdrvIsVisible(ih)) /* can NOT hide a minimized window, so map it first. */
{
XtMapWidget(ih->handle);
XRaiseWindow(iupmot_display, XtWindow(ih->handle));
while (!iupdrvDialogIsVisible(ih)); /* waits until window get mapped */
}
XtUnmapWidget(ih->handle);
while (iupdrvDialogIsVisible(ih)); /* waits until window gets unmapped */
}
}
void show_panel(QSP_ARG_DECL Panel_Obj *po)
{
#ifdef HAVE_MOTIF
if( PANEL_MAPPED(po) ){
sprintf(ERROR_STRING,"show_panel: panel %s is already mapped!?",PO_NAME(po));
WARN(ERROR_STRING);
return;
}
// On the mac (and linux???), when we unshow, and re-show a panel,
// it moves down by the thickness of the top of the window???
posn_panel(po);
/* if widget has already been realized, then just map it; otherwise
realize it and set the flag */
if (!(po->po_realized)) {
XtRealizeWidget(po->po_frame_obj);
po->po_realized = 1;
#ifdef FOOBAR
/* This must be the first time we see this thing - lets
* reset the positions of all the screen objects...
*/
lp=po->po_children;
np=lp->l_head;
while(np!=NO_NODE){
sop=np->n_data;
if( sop != NULL ){
reposition(sop);
}
np=np->n_next;
}
#endif /* FOOBAR */
} else {
XtMapWidget(po->po_frame_obj);
}
/* Now wait until it really is mapped */
#ifdef CAUTIOUS
if( ! XtIsRealized(po->po_frame_obj) )
NERROR1("CAUTIOUS: show_panel: object not realized!?");
#endif /* CAUTIOUS */
/* get the window id */
while( ! panel_mapped(po) )
;
po->po_flags |= PANEL_SHOWN;
#endif /* HAVE_MOTIF */
} /* end show_panel */
static void
ChangeNoResize(Widget w, XtPointer client_data,
XtPointer call_data)
{
Cardinal n;
Arg args[MAX_ARGS];
n = 0;
XtSetArg(args[n], XmNnoResize, True); n++;
XtSetValues(BBoard1, args, n);
XtUnmapWidget(toplevelShell);
XtMapWidget(toplevelShell);
}
bool wxDialog::Show( bool show )
{
if( !wxWindowBase::Show( show ) )
return false;
if ( !show && IsModal() )
EndModal(wxID_CANCEL);
m_isShown = show;
if (show)
{
if (CanDoLayoutAdaptation())
DoLayoutAdaptation();
// this usually will result in TransferDataToWindow() being called
// which will change the controls values so do it before showing as
// otherwise we could have some flicker
InitDialog();
}
if (show)
{
#if !wxUSE_INVISIBLE_RESIZE
XtMapWidget(XtParent((Widget) m_mainWidget));
#else
XtManageChild((Widget)m_mainWidget) ;
#endif
XRaiseWindow( XtDisplay( (Widget)m_mainWidget ),
XtWindow( (Widget)m_mainWidget) );
}
else
{
#if !wxUSE_INVISIBLE_RESIZE
XtUnmapWidget(XtParent((Widget) m_mainWidget));
#else
XtUnmanageChild((Widget)m_mainWidget) ;
#endif
XFlush(XtDisplay((Widget)m_mainWidget));
XSync(XtDisplay((Widget)m_mainWidget), False);
}
return true;
}
static void MapChildren(
CompositePart *cwp)
{
Cardinal i;
WidgetList children;
register Widget child;
children = cwp->children;
for (i = 0; i < cwp->num_children; i++) {
child = children[i];
if (XtIsWidget (child)) {
if (child->core.managed && child->core.mapped_when_managed) {
XtMapWidget (children[i]);
}
}
}
} /* MapChildren */
void HGU_XmMapDialogCb(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
Widget dialog=(Widget) client_data;
if( dialog ) {
XtManageChild(dialog);
XtPopup(XtParent(dialog), XtGrabNone);
XtMapWidget(XtParent(dialog));
if( XmIsFileSelectionBox(dialog) == True ) {
XmFileSelectionDoSearch(dialog, NULL);
}
}
return;
}
