/*!
This function is a reimplementation of QWidget::showEvent(). The
reimplemented function handles the given \a event by ensuring that the
dialog widget is managed and hidden.
*/
void QtMotifDialog::showEvent(QShowEvent *event)
{
if (!event->spontaneous()) {
// tell motif about modality
Arg args[1];
XtSetArg( args[0], XmNdialogStyle,
(testAttribute(Qt::WA_ShowModal)
? XmDIALOG_FULL_APPLICATION_MODAL :
XmDIALOG_MODELESS));
XtSetValues( d->shell, args, 1 );
XtSetMappedWhenManaged( d->shell, False );
if ( d->dialog ) {
XtManageChild( d->dialog );
XSync(x11Info().display(), FALSE);
XSync(QtMotif::display(), FALSE);
} else if ( !parentWidget() ) {
adjustSize();
QApplication::sendPostedEvents(this, QEvent::Resize);
Widget p = XtParent( d->shell ), s = p;
while ( s != NULL && !XtIsShell( s ) ) // find the shell
s = XtParent( s );
if ( p && s ) {
int offx = ( ( XtWidth( p ) - width() ) / 2 );
int offy = ( ( XtHeight( p ) - height() ) / 2 );
move( XtX ( s ) + offx, XtY( s ) + offy );
}
}
XtSetMappedWhenManaged( d->shell, True );
}
QDialog::showEvent(event);
}
void KXtWidget::init(const char* name, WidgetClass widget_class,
Widget parent, QWidget* qparent,
ArgList args, Cardinal num_args,
bool managed)
{
need_reroot=FALSE;
xtparent = 0;
if (parent ) {
Q_ASSERT(!qparent);
xtw = XtCreateWidget(name, widget_class, parent, args, num_args);
if ( widget_class == qWidgetClass )
((QWidgetRec*)xtw)->qwidget.qxtwidget = this;
xtparent = parent;
if (managed)
XtManageChild(xtw);
} else {
Q_ASSERT(!managed);
String n, c;
XtGetApplicationNameAndClass(qt_xdisplay(), &n, &c);
xtw = XtAppCreateShell(n, c, widget_class, qt_xdisplay(),
args, num_args);
if ( widget_class == qWidgetClass )
((QWidgetRec*)xtw)->qwidget.qxtwidget = this;
}
if ( qparent ) {
XtResizeWidget( xtw, 100, 100, 0 );
XtSetMappedWhenManaged(xtw, False);
XtRealizeWidget(xtw);
XSync(qt_xdisplay(), False); // I want all windows to be created now
XReparentWindow(qt_xdisplay(), XtWindow(xtw), qparent->winId(), x(), y());
XtSetMappedWhenManaged(xtw, True);
need_reroot=TRUE;
}
Arg reqargs[20];
Cardinal nargs=0;
XtSetArg(reqargs[nargs], XtNx, x()); nargs++;
XtSetArg(reqargs[nargs], XtNy, y()); nargs++;
XtSetArg(reqargs[nargs], XtNwidth, width()); nargs++;
XtSetArg(reqargs[nargs], XtNheight, height()); nargs++;
//XtSetArg(reqargs[nargs], "mappedWhenManaged", False); nargs++;
XtSetValues(xtw, reqargs, nargs);
//#### destroy(); MLK
if (!parent || XtIsRealized(parent))
XtRealizeWidget(xtw);
}
bool wxPopupWindow::Create( wxWindow *parent, int flags )
{
if( !wxPopupWindowBase::Create( parent, flags ) )
return false;
SetParent( parent );
if( parent )
parent->AddChild( this );
Widget popup = XtVaCreatePopupShell( "shell",
overrideShellWidgetClass,
(Widget)wxTheApp->GetTopLevelWidget(),
NULL );
m_mainWidget = (WXWidget)popup;
wxAddWindowToTable( (Widget) m_mainWidget, this );
DoSetSizeIntr( -1, -1, 100, 100, 0, true );
XtSetMappedWhenManaged( popup, False );
XtRealizeWidget( popup );
XtManageChild ( popup );
/*
XtTranslations ptr;
XtOverrideTranslations (popup,
ptr = XtParseTranslationTable ("<Configure>: resize()"));
XtFree ((char *) ptr);
*/
return true;
}
void
awt_util_hide(Widget w)
{
if (w == NULL) {
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
JNU_ThrowNullPointerException(env,"NullPointerException");
return;
}
XtSetMappedWhenManaged(w, False);
}
WXWidget wxCreateTopLevelRealizedWidget( WXDisplay* WXUNUSED(display) )
{
Widget rTlw = XtVaCreateWidget( "dummy_widget", topLevelShellWidgetClass,
(Widget)wxTheApp->GetTopLevelWidget(),
NULL );
XtSetMappedWhenManaged( rTlw, False );
XtRealizeWidget( rTlw );
return (WXWidget)rTlw;
}
/*!
\internal
Sets the dialog widget for the QtMotifDialog to \a w.
*/
void QtMotifDialog::insertChild( Widget w )
{
if ( d->dialog != NULL && d->dialog != w ) {
qWarning( "QtMotifDialog::insertChild: cannot insert widget since one child\n"
" has been inserted already." );
return;
}
d->dialog = w;
XtSetMappedWhenManaged( d->shell, True );
}
/*!
\internal
Wraps the Motif dialog by setting the X window for the
QtMotifDialog to the X window id of the dialog shell.
*/
void QtMotifDialog::realize( Widget w )
{
// use the winid of the dialog shell, reparent any children we have
if ( XtWindow( w ) != winId() ) {
XSync(QtMotif::display(), FALSE);
XtSetMappedWhenManaged( d->shell, False );
// save the window title
QString wtitle = windowTitle();
if (wtitle.isEmpty()) {
char *t = 0;
XtVaGetValues(w, XtNtitle, &t, NULL);
wtitle = QString::fromLocal8Bit(t);
}
setWindowTitle(QString()); // make sure setWindowTitle() works below
QString icontext = windowIconText();
if (icontext.isEmpty()) {
char *iconName = 0;
XtVaGetValues(w, XtNiconName, &iconName, NULL);
icontext = QString::fromLocal8Bit(iconName);
}
setWindowIconText(QString()); // make sure setWindowTitle() works below
Window newid = XtWindow(w);
QObjectList list = children();
for (int i = 0; i < list.size(); ++i) {
QWidget *widget = qobject_cast<QWidget*>(list.at(i));
if (!widget || widget->isWindow()) continue;
XReparentWindow(widget->x11Info().display(), widget->winId(), newid,
widget->x(), widget->y());
}
QApplication::syncX();
create( newid, true, true );
// restore the window title and icon text
if (!wtitle.isEmpty())
setWindowTitle(wtitle);
if (!icontext.isEmpty())
setWindowIconText(icontext);
// if this dialog was created without a QWidget parent, then the transient
// for will be set to the root window, which is not acceptable.
// instead, set it to the window id of the shell's parent
if ( ! parent() && XtParent( d->shell ) )
XSetTransientForHint(x11Info().display(), newid, XtWindow(XtParent(d->shell)));
}
QtMotif::registerWidget( this );
}
Widget
XmPrintSetup(
Widget video_widget,
Screen *print_screen,
String print_shell_name,
ArgList args,
Cardinal num_args)
{
String video_name, video_class ;
Widget pappshell ;
Widget print_shell;
Display *print_display = DisplayOfScreen(print_screen);
/* get to the video app root shell */
while(!XtIsApplicationShell(video_widget))
video_widget = XtParent(video_widget);
if (!video_widget) return NULL;
XtGetApplicationNameAndClass(XtDisplay(video_widget),
&video_name, &video_class);
/* we want to be able to specify things like:
dtpad.print*textFontList: somefont
dtpad.print*background:white
so we create a first shell unrealized and them a popup
named "print".
*/
pappshell = XtVaAppCreateShell(video_name, video_class,
applicationShellWidgetClass,
print_display,
XmNscreen, print_screen,
NULL);
/* then create the XmPrintShell */
print_shell = XtCreatePopupShell(print_shell_name,
xmPrintShellWidgetClass,
pappshell, args, num_args);
/* Add callback to destroy application Shell parent. */
XtAddCallback(print_shell, XmNdestroyCallback,
_XmDestroyParentCallback, (XtPointer) NULL) ;
/* we're mapping/unmapping at start/end page time */
XtSetMappedWhenManaged(print_shell, False);
/* realize the shell now, so that XmPrintPopupPDM works dy default */
XtRealizeWidget(print_shell);
return print_shell ;
}
BOOL CWnd::xd_show_window(int nCmdShow)
{
// Changes the visibility state of a child widget
// by mapping or unmapping it or a child gadget by
// managing or unmanaging it.
Boolean wasvisible = TRUE;
Boolean gadget = XmIsGadget(_xd_rootwidget);
if (gadget)
wasvisible = XtIsManaged(_xd_rootwidget);
else
XtVaGetValues(_xd_rootwidget, XmNmappedWhenManaged, &wasvisible, NULL);
switch(nCmdShow)
{
case SW_HIDE: if (gadget)
XtUnmanageChild(_xd_rootwidget);
else
XtSetMappedWhenManaged(_xd_rootwidget, FALSE);
break;
case SW_RESTORE: if (gadget)
XtManageChild(_xd_rootwidget);
else
XtSetMappedWhenManaged(_xd_rootwidget, TRUE);
break;
case SW_SHOW: XtManageChild(_xd_rootwidget);
break;
default: cerr << "CWnd::ShowWindow: Only SW_HIDE and SW_RESTORE supported for child windows" << endl;
}
return wasvisible;
}
void
awt_util_show(Widget w)
{
/*
extern Boolean scrollBugWorkAround;
*/
if (w == NULL) {
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
JNU_ThrowNullPointerException(env,"NullPointerException");
return;
}
XtSetMappedWhenManaged(w, True);
/*
XXX: causes problems on 2.5
if (!scrollBugWorkAround) {
awt_setWidgetGravity(w, StaticGravity);
}
*/
}
// Relacement for Qt function - add Xt stuff for top-level widgets
Window qt_XCreateWindow( const QWidget* qw, Display *display, Window parent,
int x, int y, uint w, uint h,
int borderwidth, int depth,
uint windowclass, Visual *visual,
ulong valuemask, XSetWindowAttributes *attributes )
{
// ### This isA will not work - we are still in QWidget's constructor.
if ( qw->isTopLevel() && !qw->isA("QNPWidget") ) {
// ### not sure it is good to use name() and className().
bool cmap = valuemask & CWColormap;
Widget xtw = XtVaAppCreateShell( qw->name(), qw->className(),
applicationShellWidgetClass, display,
XtNx, x, XtNy, y, XtNwidth, w, XtNheight, h,
XtNborderWidth, borderwidth, XtNdepth, depth,
XtNvisual, visual,
cmap ? XtNcolormap : 0, cmap ? attributes->colormap : 0,
0, 0 );
// Ensure it has a window, and get it.
XtSetMappedWhenManaged( xtw, FALSE );
XtRealizeWidget( xtw );
Window xw = XtWindow( xtw );
// Set the attributes (directly)
XChangeWindowAttributes( display, xw, valuemask, attributes );
// Inform us on enter/leave
XtAddEventHandler( xtw, EnterWindowMask, TRUE, enter_event_handler, 0 );
XtAddEventHandler( xtw, LeaveWindowMask, TRUE, leave_event_handler, 0 );
// Return Xt's window for the widget
return xw;
} else {
Window window = XCreateWindow( display, parent, x, y, w, h, borderwidth, depth,
windowclass, visual, valuemask, attributes );
return window;
}
}
void
WmPanelistShow (Widget w)
{
SwitchData * switch_data;
Dimension switch_rc_height;
Dimension switch_button_height;
Dimension width = XtWidth(panel.shell);
Dimension height = XtHeight(panel.shell);
Position x = XtX(panel.shell);
Position y = XtY(panel.shell);
Dimension screen_width;
Display * display;
CompositeWidget cw;
Widget * widget_list;
DtWmHints vHints;
String shell_geometry = NULL;
char geometry_buffer[32];
XSizeHints hints;
long supplied;
int i;
Arg al[20];
int ac;
/* Find the switch data for later processing */
switch_data = NULL;
for (i = 0; i < panel.box_data_count; i++)
{
if (panel.box_data[i]->switch_data != NULL)
{
switch_data = panel.box_data[i]->switch_data;
break;
}
}
/* Realize the shell so that it is sized properly for later */
/* positioning and child repositioning. */
XtRealizeWidget (panel.shell);
/* See if a geometry has been set. */
ac = 0;
XtSetArg (al[ac], XmNgeometry, &shell_geometry); ac++;
XtGetValues (panel.shell, al, ac);
/* If the shell has no default geometry, construct a default */
/* which will center the panel along the bottom of the display */
width = XtWidth (panel.shell);
screen_width = WidthOfScreen (XtScreen (panel.shell));
display = XtDisplay (panel.shell);
if (shell_geometry == NULL)
{
Position x;
char geometry_buffer[32];
if (panel.element_values[PANEL_GEOMETRY].string_value != NULL)
{
shell_geometry = panel.element_values[PANEL_GEOMETRY].parsed_value;
}
else
{
x = (screen_width > width) ? (Position)(screen_width - width) / 2 : 0;
sprintf (geometry_buffer, "+%d-0", x);
shell_geometry = geometry_buffer;
}
XtSetArg (al[0], XmNgeometry, shell_geometry);
XtSetValues (panel.shell, al, 1);
}
/* Adjust the positions of the buttons within the switch */
/* so that they are spaced nicely. */
if (switch_data != NULL)
{
UpdateSwitchGeometry (switch_data->box_data);
/* Reposition or adjust the front panel if it is either off */
/* the right edge of the screen or larger than the screen */
if (width > screen_width)
{
Arg al[1];
while (width > screen_width &&
panel.switch_row_count < switch_data->switch_count)
{
panel.switch_row_count++;
XtSetArg (al[0], XmNnumColumns, panel.switch_row_count);
XtSetValues (switch_data->rc, al, 1);
width = XtWidth (panel.shell);
}
}
}
SetGeometry (panel.shell, shell_geometry, &x, &y);
WorkspaceAdjustPanelPosition (x, y, XtWidth (panel.shell),
XtHeight (panel.shell));
/* Set hints to avoid interactive placement */
if (XGetWMNormalHints(display, XtWindow(panel.shell),
&hints, &supplied) != 0)
{
hints.flags |= USPosition|USSize;
XSetWMNormalHints(display, XtWindow(panel.shell), &hints);
}
/* Set the shells icon and title for when it is minimized */
if (switch_data != NULL)
{
int current_workspace = switch_data->active_switch;
XtSetArg (al[0], XmNiconName, switch_data->switch_names[current_workspace]);
XtSetArg (al[1], XmNtitle, switch_data->switch_names[current_workspace]);
XtSetValues (panel.shell, al, 2);
}
/* Set panel's window manager hints. */
vHints.flags = DtWM_HINTS_BEHAVIORS;
vHints.behaviors = DtWM_BEHAVIOR_PANEL;
_DtWsmSetDtWmHints (XtDisplay(panel.shell), XtWindow (panel.shell), &vHints);
/* Set the subpanel's transientShell to update transientFor and */
/* Set the subpanel hints. */
vHints.behaviors |= DtWM_BEHAVIOR_SUBPANEL;
vHints.flags |= DtWM_HINTS_ATTACH_WINDOW;
vHints.attachWindow = XtWindow (panel.shell);
for (i = 0, widget_list = M_PopupList (panel.shell);
i < M_NumPopups (panel.shell); i++)
{
cw = (CompositeWidget) widget_list[i];
ac = 0;
XtSetArg (al[ac], XmNtransientFor, NULL); ac++;
XtSetValues ((Widget) cw, al, ac);
ac = 0;
XtSetArg (al[ac], XmNtransientFor, panel.shell); ac++;
XtSetValues ((Widget) cw, al, ac);
if (M_NumChildren (cw) > 0)
{
XtRealizeWidget ((M_Children (cw))[0]);
_DtWsmSetDtWmHints (XtDisplay (panel.shell),
XtWindow (widget_list[i]), &vHints);
}
}
/* Set the push recall list and count into the window manager's */
/* screen global data. */
PushRecallSetData ();
/* Set up the callback ot the workspace management API for */
/* catching changes in workspace configuration. */
DtWsmAddWorkspaceModifiedCallback(panel.shell,
WorkspaceModifyCB, (XtPointer)switch_data);
/* Get the front panel displayed */
XtSetMappedWhenManaged (panel.shell, True);
XtPopup (panel.shell, XtGrabNone);
/* Restore the session information */
SessionRestoreData ();
/* Set up the window and geometry information for the embedded clients */
for (i = 0; i < panel.embedded_client_count; i++)
EmbeddedClientSetGeometry (&(((WmFpEmbeddedClientList) panel.embedded_client_list)[i]));
/* Set the embedded client list and count into the window manager's */
/* screen global data. */
EmbeddedClientSetData ();
}
int do_hello_world( int argc, char *argv[], const char *printername, const char *toFile, const char *sample_string )
{
XtAppContext app;
Widget toplevel,
shell,
print_shell,
hello;
long dpi_x = 0L,
dpi_y = 0L;
char fontname[256]; /* BUG: is this really big enougth ? */
XFontStruct *textFont;
XmFontList textFontList;
Cardinal n;
Arg args[10];
MyPrintCallbackData mpcd;
if( doPrint )
{
/* Get printer, either by "name" (foobar) or "name@display" (foobar@gaja:5) */
if( XpuGetPrinter(printername, &pdpy, &pcontext) != 1 )
Error(("XpuGetPrinter failure.\n"));
/* Configure the print context (paper size, title etc.)
* We must do this before creating any Xt widgets - otherwise they will
* make wrong assuptions about fonts, resultions etc. ...
*/
XpuSetJobTitle(pdpy, pcontext, "Simple Xprint XawPrintShell widget demo");
/* Configuration done, set the context */
XpSetContext(pdpy, pcontext);
/* Get default printer resolution */
if( XpuGetResolution(pdpy, pcontext, &dpi_x, &dpi_y) != 1 )
{
fprintf(stderr, "No default resolution for printer '%s'\n", printername);
XpuClosePrinterDisplay(pdpy, pcontext);
return(EXIT_FAILURE);
}
pscreen = XpGetScreenOfContext(pdpy, pcontext);
}
else
{
pdpy = XOpenDisplay(NULL);
if( !pdpy )
Error(("XOpenDisplay failure.\n"));
dpi_x = dpi_y = 0L;
pscreen = XDefaultScreenOfDisplay(pdpy);
}
toplevel = XawOpenApplication(&app,
pdpy, pscreen,
"xpawprintshelldemo", "XpXawPrintShellDemo",
applicationShellWidgetClass,
&argc, argv);
if( !toplevel )
Error(("XawOpenApplication failure.\n"));
if( doPrint )
{
n = 0;
/* Override any geometry resource settings as XawPrintShell adjusts it's size
* to the current page siue when |XawPrintLAYOUTMODE_DRAWABLEAREA| or
* |XawPrintLAYOUTMODE_PAGESIZE| are used. */
XtSetArg(args[n], XtNgeometry, "+0+0"); n++;
XtSetArg(args[n], XawNlayoutMode, XawPrintLAYOUTMODE_DRAWABLEAREA); n++;
print_shell = XtCreatePopupShell("myprintshell",
xawPrintShellWidgetClass,
toplevel, args, n);
/* we're mapping/unmapping at start/end page time */
XtSetMappedWhenManaged(print_shell, False);
shell = print_shell;
}
else
{
shell = toplevel;
}
sprintf(fontname, "-adobe-courier-medium-r-normal--40-*-%ld-%ld-*-*-iso8859-1", dpi_x, dpi_y);
textFont = XLoadQueryFont(pdpy, fontname);
if( !textFont )
{
sprintf(fontname, "-*-*-*-*-*-*-*-160-%ld-%ld-*-*-iso8859-1", dpi_x, dpi_y);
textFont = XLoadQueryFont(pdpy, fontname);
}
if( !textFont )
Error(("XLoadQueryFont failure.\n"));
textFontList = XmFontListCreate(textFont, XmSTRING_DEFAULT_CHARSET);
n = 0;
/* Make sure the cursor is off, current Xprt servers do not seem to like
* blinking cursors that much... ;-/ */
XtSetArg(args[n], XmNcursorPositionVisible, False); n++;
XtSetArg(args[n], XmNvalue, sample_string); n++;
XtSetArg(args[n], XmNfontList, textFontList); n++;
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
hello = XmCreateText(shell, "mytext", args, n);
if( !hello )
Error(("XmCreateText failure.\n"));
XtManageChild(hello);
XtRealizeWidget(toplevel);
XtRealizeWidget(shell);
if( doPrint )
{
int num_total_rows;
short num_visible_rows;
int num_pages;
pdpy = XtDisplay(toplevel);
pdrawable = XtWindow(toplevel);
if( !pdpy || !pdrawable )
Error(("No display.\n"));
/* Make sure that the Xt machinery is really using the right screen (assertion) */
if( XpGetScreenOfContext(XtDisplay(toplevel), pcontext) != XtScreen(toplevel) )
Error(("Widget's screen != print screen. BAD.\n"));
/* Get number of rows visible per page and the number of total rows
* in the whole text widget... */
n = 0;
XtSetArg(args[n], XmNrows, &num_visible_rows); n++ ;
XtSetArg(args[n], XmNtotalLines, &num_total_rows); n++ ;
XtGetValues(hello, args, n);
/* Take away one row to match the one-line overlapping used by the
* "next-page" action proc */
num_visible_rows -= 1;
/* Calculate the number of pages */
num_pages = (num_total_rows+num_visible_rows-1) / num_visible_rows;
Log(("Printing %d pages (num_total_rows=%d, num_visible_rows=%d)...\n",
num_pages, num_total_rows, num_visible_rows));
/* Prepare our own context data for the print shell callbacks */
mpcd.num_pages = num_pages;
mpcd.printshell_content = hello;
mpcd.num_visible_rows = num_visible_rows;
mpcd.appcontext = app;
/* Setup the print shell callbacks... */
XtAddCallback(print_shell, XawNpageSetupCallback, PrintOnePageCB, (XtPointer)&mpcd);
XtAddCallback(print_shell, XawNstartJobCallback, PrintStartJobCB, NULL);
XtAddCallback(print_shell, XawNendJobCallback, PrintEndJobCB, (XtPointer)&mpcd);
/* ... and finally start the print job. */
if( toFile )
{
printtofile_handle = XpuStartJobToFile(pdpy, pcontext, toFile);
if( !printtofile_handle )
{
perror("XpuStartJobToFile failure");
Error(("XpuStartJobToFile failure."));
}
}
else
{
XpuStartJobToSpooler(pdpy);
}
}
XtAppMainLoop(app);
if( doPrint )
{
if( toFile )
{
if( XpuWaitForPrintFileChild(printtofile_handle) != XPGetDocFinished )
{
fprintf(stderr, "%s: Error while printing to file.\n", ProgramName);
}
}
PrintSpoolerCommandResults(pdpy, pcontext);
/* We have to use XpDestroyContext() and XtCloseDisplay() instead
* of XpuClosePrinterDisplay() to make libXt happy... */
if( pcontext != None )
XpDestroyContext(pdpy, pcontext);
XtCloseDisplay(pdpy);
}
return EXIT_SUCCESS;
}
static void
ComputeLayout(Widget widget, Bool query, Bool destroy_scrollbars)
{
ViewportWidget w = (ViewportWidget)widget;
Widget child = w->viewport.child;
Widget clip = w->viewport.clip;
ViewportConstraints constraints =
(ViewportConstraints)clip->core.constraints;
Bool needshoriz, needsvert;
int clip_width, clip_height;
XtWidgetGeometry intended;
if (child == NULL)
return;
clip_width = XtWidth(w);
clip_height = XtHeight(w);
intended.request_mode = CWBorderWidth;
intended.border_width = 0;
if (w->viewport.forcebars) {
needsvert = w->viewport.allowvert;
needshoriz = w->viewport.allowhoriz;
ComputeWithForceBars(widget, query, &intended,
&clip_width, &clip_height);
}
else {
Dimension prev_width, prev_height;
XtGeometryMask prev_mode;
XtWidgetGeometry preferred;
needshoriz = needsvert = False;
/*
* intended.{width,height} caches the eventual child dimensions,
* but we don't set the mode bits until after we decide that the
* child's preferences are not acceptable
*/
if (!w->viewport.allowhoriz)
intended.request_mode |= CWWidth;
if (XtWidth(child) < clip_width)
intended.width = clip_width;
else
intended.width = XtWidth(child);
if (XtHeight(child) < clip_height)
intended.height = clip_height;
else
intended.height = XtHeight(child);
if (!w->viewport.allowvert)
intended.request_mode |= CWHeight;
if (!query) {
preferred.width = XtWidth(child);
preferred.height = XtHeight(child);
}
do { /* while intended != prev */
if (query) {
(void)XtQueryGeometry(child, &intended, &preferred);
if (!(preferred.request_mode & CWWidth))
preferred.width = intended.width;
if (!(preferred.request_mode & CWHeight))
preferred.height = intended.height;
}
prev_width = intended.width;
prev_height = intended.height;
prev_mode = intended.request_mode;
/*
* note that having once decided to turn on either bar
* we'll not change our mind until we're next resized,
* thus avoiding potential oscillations
*/
#define CheckHoriz() \
if (w->viewport.allowhoriz && \
preferred.width > clip_width) { \
if (!needshoriz) { \
Widget bar; \
\
needshoriz = True; \
if ((bar = w->viewport.horiz_bar) == NULL) \
bar = CreateScrollbar(w, True); \
clip_height -= XtHeight(bar) + XtBorderWidth(bar); \
if (clip_height < 1) \
clip_height = 1; \
} \
intended.width = preferred.width; \
}
CheckHoriz();
if (w->viewport.allowvert && preferred.height > clip_height) {
if (!needsvert) {
Widget bar;
needsvert = True;
if ((bar = w->viewport.vert_bar) == NULL)
bar = CreateScrollbar(w, False);
clip_width -= XtWidth(bar) + XtBorderWidth(bar);
if (clip_width < 1)
clip_width = 1;
CheckHoriz();
}
intended.height = preferred.height;
}
if (!w->viewport.allowhoriz || preferred.width < clip_width) {
intended.width = clip_width;
intended.request_mode |= CWWidth;
}
if (!w->viewport.allowvert || preferred.height < clip_height) {
intended.height = clip_height;
intended.request_mode |= CWHeight;
}
} while (intended.request_mode != prev_mode
|| (intended.request_mode & CWWidth
&& intended.width != prev_width)
|| (intended.request_mode & CWHeight
&& intended.height != prev_height));
}
if (XtIsRealized(clip))
XRaiseWindow(XtDisplay(clip), XtWindow(clip));
XtMoveWidget(clip,
needsvert ? w->viewport.useright ? 0 :
XtWidth(w->viewport.vert_bar)
+ XtBorderWidth(w->viewport.vert_bar) : 0,
needshoriz ? w->viewport.usebottom ? 0 :
XtHeight(w->viewport.horiz_bar)
+ XtBorderWidth(w->viewport.horiz_bar) : 0);
XtResizeWidget(clip, clip_width, clip_height, 0);
if (w->viewport.horiz_bar != NULL) {
Widget bar = w->viewport.horiz_bar;
if (!needshoriz) {
constraints->form.vert_base = NULL;
if (destroy_scrollbars) {
XtDestroyWidget(bar);
w->viewport.horiz_bar = NULL;
}
}
else {
int bw = XtBorderWidth(bar);
XtResizeWidget(bar, clip_width, XtHeight(bar), bw);
XtMoveWidget(bar,
needsvert && !w->viewport.useright
? XtWidth(w->viewport.vert_bar) : -bw,
w->viewport.usebottom
? XtHeight(w) - XtHeight(bar) - bw : -bw);
XtSetMappedWhenManaged(bar, True);
}
}
if (w->viewport.vert_bar != NULL) {
Widget bar = w->viewport.vert_bar;
if (!needsvert) {
constraints->form.horiz_base = NULL;
if (destroy_scrollbars) {
XtDestroyWidget(bar);
w->viewport.vert_bar = NULL;
}
}
else {
int bw = bar->core.border_width;
XtResizeWidget(bar, XtWidth(bar), clip_height, bw);
XtMoveWidget(bar,
w->viewport.useright
? XtWidth(w) - XtWidth(bar) - bw : -bw,
needshoriz && !w->viewport.usebottom
? XtHeight(w->viewport.horiz_bar) : -bw);
XtSetMappedWhenManaged(bar, True);
}
}
if (child != NULL) {
XtResizeWidget(child, intended.width, intended.height, 0);
MoveChild(w, needshoriz ? XtX(child) : 0, needsvert ? XtY(child) : 0);
}
SendReport (w, XawPRAll);
}
