Boolean
XmTextFindString(Widget w,
XmTextPosition start,
char* search_string,
XmTextDirection direction,
XmTextPosition *position)
{
XmSourceData data;
Boolean ret_val;
_XmWidgetToAppContext(w);
if (XmIsTextField(w)) return False;
_XmAppLock(app);
data = ((XmTextWidget)w)->text.source->data;
if (start > data->length)
start = data->length;
else if (start < 0)
start = 0;
if (direction == XmTEXT_BACKWARD)
ret_val = _XmTextFindStringBackwards(w, start, search_string, position);
else
ret_val = _XmTextFindStringForwards(w, start, search_string, position);
_XmAppUnlock(app);
return (ret_val);
}
/****************************************************************
*
* XmeReplyToQueryGeometry.
*
* This is the generic handling of Almost, No and Yes replies
* based on the intended values and the given desirs.
*
* This can be used by any widget that really only care about is
* width and height dimension. It just has to compute its desired size
* using its own private layout routine and resources before calling
* this one that will deal with the Xt reply value cuisine.
*
****************/
XtGeometryResult
XmeReplyToQueryGeometry(Widget widget,
XtWidgetGeometry * intended,
XtWidgetGeometry * desired)
{
_XmWidgetToAppContext(widget);
/* the caller should have set desired width and height*/
desired->request_mode = (CWWidth | CWHeight) ;
/* Accept any x, y, border and stacking. If the proposed
geometry matches the desired one, and the parent intends
to use these values (flags are set in intended),
return Yes. Otherwise, the parent intends to use values for
width and height that differ from the desired size, return No
if the desired is the current and Almost if the desired size
is different from the current size */
if ((IsWidth(intended)) &&
(intended->width == desired->width) &&
(IsHeight(intended)) &&
(intended->height == desired->height)) {
return XtGeometryYes ;
}
_XmAppLock(app);
if ((desired->width == XtWidth(widget)) &&
(desired->height == XtHeight(widget))) {
_XmAppUnlock(app);
return XtGeometryNo ;
}
_XmAppUnlock(app);
return XtGeometryAlmost ;
}
Boolean
XmTextFindStringWcs(Widget w,
XmTextPosition start,
wchar_t* wc_string,
XmTextDirection direction,
XmTextPosition *position)
{
wchar_t *tmp_wc;
char *string;
int num_chars = 0;
Boolean return_val = False;
XmTextWidget tw = (XmTextWidget) w;
int wcs_ret_val = 0;
_XmWidgetToAppContext(w);
_XmAppLock(app);
if (!XmIsTextField(w)) {
for (num_chars = 0, tmp_wc = wc_string; *tmp_wc != (wchar_t)0L;
num_chars++) tmp_wc++;
string = XtMalloc ((unsigned) (num_chars + 1) * (int)tw->text.char_size);
wcs_ret_val = wcstombs(string, wc_string,
(num_chars + 1) * (int)tw->text.char_size);
if (wcs_ret_val >= 0)
return_val = XmTextFindString(w, start, string, direction, position);
XtFree(string);
_XmAppUnlock(app);
return(return_val);
} else {
_XmAppUnlock(app);
return False;
}
}
Widget
XmGetDragContext(
Widget w,
Time time )
{
XmDisplay xmDisplay;
XmDragContext matchedDC = NULL, dc = NULL;
Cardinal i;
_XmWidgetToAppContext(w);
_XmAppLock(app);
xmDisplay = (XmDisplay)XmGetXmDisplay(XtDisplay(w));
for(i = 0; i < xmDisplay->composite.num_children; i++)
{
dc = (XmDragContext)(xmDisplay->composite.children[i]);
if ((XmIsDragContext((Widget) dc)) && (CHECK_TIME(dc, time)) &&
((!matchedDC) ||
(matchedDC->drag.dragStartTime
< dc->drag.dragStartTime)) &&
!dc->core.being_destroyed)
matchedDC = dc;
}
_XmAppUnlock(app);
return((Widget)matchedDC);
}
Widget
XmCreateSimplePulldownMenu(
Widget parent,
String name,
ArgList args,
Cardinal arg_count )
{
Widget rc;
XmSimpleMenuRec mr;
int n, i;
Arg local_args[3];
WidgetList buttons;
Cardinal num_buttons;
_XmWidgetToAppContext(parent);
_XmAppLock(app);
XtGetSubresources(parent, &mr, name, XmCSimplePulldownMenu,
SimpleMenuResources, XtNumber(SimpleMenuResources),
args, arg_count);
rc = XmCreatePulldownMenu(parent, name, args, arg_count);
EvaluateConvenienceStructure(rc, &mr);
if (mr.post_from_button >= 0)
{
n = 0;
XtSetArg(local_args[n], XtNchildren, &buttons); n++;
XtSetArg(local_args[n], XtNnumChildren, &num_buttons); n++;
XtGetValues(parent, local_args, n);
if (!num_buttons)
{
/* error condition */
_XmAppUnlock(app);
return(rc);
}
else
{
for (i = 0; i < num_buttons; i++)
{
if (((XmIsCascadeButtonGadget(buttons[i])) ||
(XmIsCascadeButton(buttons[i])))
&&
(i == mr.post_from_button))
break;
}
if ( i < num_buttons)
{
n = 0;
XtSetArg(local_args[n], XmNsubMenuId, rc); n++;
XtSetValues(buttons[i], local_args, n);
}
}
}
_XmAppUnlock(app);
return(rc);
}
Widget
XmMainWindowSep3(
Widget w )
{
XmMainWindowWidget mw = (XmMainWindowWidget) w;
Widget separator;
_XmWidgetToAppContext(w);
_XmAppLock(app);
separator = (Widget) mw->mwindow.Sep3;
_XmAppUnlock(app);
return separator;
}
Boolean
XmWidgetGetBaselines(
Widget wid,
Dimension **baselines,
int *line_count)
{
_XmWidgetToAppContext(wid);
_XmAppLock(app);
if (XmIsPrimitive(wid))
{
XmPrimitiveClassExt *wcePtr;
WidgetClass wc = XtClass(wid);
wcePtr = _XmGetPrimitiveClassExtPtr(wc, NULLQUARK);
if (*wcePtr && (*wcePtr)->widget_baseline)
{
_XmAppUnlock(app);
return( (*((*wcePtr)->widget_baseline))
(wid, baselines, line_count)) ;
}
}
else if (XmIsGadget(wid))
{
XmGadgetClassExt *wcePtr;
WidgetClass wc = XtClass(wid);
wcePtr = _XmGetGadgetClassExtPtr(wc, NULLQUARK);
if (*wcePtr && (*wcePtr)->widget_baseline)
{
_XmAppUnlock(app);
return( (*((*wcePtr)->widget_baseline))
(wid, baselines, line_count)) ;
}
}
_XmAppUnlock(app);
return (False);
}
Boolean
XmWidgetGetDisplayRect(
Widget wid,
XRectangle *displayrect)
{
_XmWidgetToAppContext(wid);
_XmAppLock(app);
if (XmIsPrimitive(wid))
{
XmPrimitiveClassExt *wcePtr;
WidgetClass wc = XtClass(wid);
wcePtr = _XmGetPrimitiveClassExtPtr(wc, NULLQUARK);
if (*wcePtr && (*wcePtr)->widget_display_rect)
(*((*wcePtr)->widget_display_rect)) (wid, displayrect);
_XmAppUnlock(app);
return (True);
}
else if (XmIsGadget(wid))
{
XmGadgetClassExt *wcePtr;
WidgetClass wc = XtClass(wid);
wcePtr = _XmGetGadgetClassExtPtr(wc, NULLQUARK);
if (*wcePtr && (*wcePtr)->widget_display_rect)
(*((*wcePtr)->widget_display_rect)) (wid, displayrect);
_XmAppUnlock(app);
return (True);
}
else {
_XmAppUnlock(app);
return (False);
}
}
Widget
XmCreateSimplePopupMenu(
Widget parent,
String name,
ArgList args,
Cardinal arg_count )
{
Widget rc;
XmSimpleMenuRec mr;
_XmWidgetToAppContext(parent);
_XmAppLock(app);
XtGetSubresources(parent, &mr, name, XmCSimplePopupMenu,
SimpleMenuResources, XtNumber(SimpleMenuResources),
args, arg_count);
rc = XmCreatePopupMenu(parent, name, args, arg_count);
EvaluateConvenienceStructure( rc, &mr);
_XmAppUnlock(app);
return(rc);
}
/************************************************************************
*
* XmIsMotifWMRunning
*
************************************************************************/
Boolean
XmIsMotifWMRunning(
Widget shell )
{
Atom motif_wm_info_atom;
Atom actual_type;
int actual_format;
unsigned long num_items, bytes_after;
PropMotifWmInfo *prop = 0;
Window root = RootWindowOfScreen(XtScreen(shell));
_XmWidgetToAppContext(shell);
_XmAppLock(app);
motif_wm_info_atom = XInternAtom(XtDisplay(shell),
_XA_MOTIF_WM_INFO,
FALSE);
_XmProcessLock();
XGetWindowProperty (XtDisplay(shell),
root,
motif_wm_info_atom,
0, (long)PROP_MOTIF_WM_INFO_ELEMENTS,
FALSE, motif_wm_info_atom,
&actual_type, &actual_format,
&num_items, &bytes_after,
(unsigned char **) &prop);
_XmProcessUnlock();
if ((actual_type != motif_wm_info_atom) ||
(actual_format != 32) ||
(num_items < PROP_MOTIF_WM_INFO_ELEMENTS))
{
if (prop != 0) XFree((char *)prop);
_XmAppUnlock(app);
return (FALSE);
}
else
{
Window wm_window = (Window) prop->wmWindow;
Window top, parent, *children;
unsigned int num_children;
Boolean returnVal;
Cardinal i;
if (XQueryTree(XtDisplay(shell),
root, &top, &parent,
&children, &num_children))
{
i = 0;
while ((i < num_children) && (children[i] != wm_window))
i++;
returnVal = (i == num_children) ? FALSE : TRUE;
}
else
returnVal = FALSE;
if (prop) XFree((char *)prop);
if (children) XFree((char *)children);
_XmAppUnlock(app);
return (returnVal);
}
}
Widget
XmCreateSimpleOptionMenu(
Widget parent,
String name,
ArgList args,
Cardinal arg_count )
{
Widget rc, sub_rc;
XmSimpleMenuRec mr;
int n, i, button_count;
Arg local_args[5];
WidgetList buttons;
Cardinal num_buttons;
_XmWidgetToAppContext(parent);
_XmAppLock(app);
XtGetSubresources(parent, &mr, name, XmCSimpleOptionMenu,
SimpleMenuResources, XtNumber(SimpleMenuResources),
args, arg_count);
rc = XmCreateOptionMenu(parent, name, args, arg_count);
sub_rc = XmCreatePulldownMenu(parent, name, args, arg_count);
EvaluateConvenienceStructure(sub_rc, &mr);
n = 0;
if (mr.option_label)
{
XtSetArg(local_args[n], XmNlabelString, mr.option_label); n++;
}
if (mr.option_mnemonic)
{
XtSetArg(local_args[n], XmNmnemonic, mr.option_mnemonic); n++;
}
XtSetArg(local_args[n], XmNsubMenuId, sub_rc); n++;
XtSetValues(rc, local_args, n);
if (mr.button_set >= 0)
{
n = 0;
XtSetArg(local_args[n], XtNchildren, &buttons); n++;
XtSetArg(local_args[n], XtNnumChildren, &num_buttons); n++;
XtGetValues(sub_rc, local_args, n);
if (!num_buttons)
{
/* error condition */
_XmAppUnlock(app);
return(rc);
}
else
{
button_count = 0;
for (i = 0; i < num_buttons; i++)
{ /* count only PushB */
if ((XmIsPushButtonGadget(buttons[i])) ||
(XmIsPushButton(buttons[i])))
{
if (button_count == mr.button_set)
break;
button_count++;
}
}
if ( i < num_buttons)
{
n = 0;
XtSetArg(local_args[n], XmNmenuHistory, buttons[i]); n++;
XtSetValues(rc, local_args, n);
}
}
}
_XmAppUnlock(app);
return(rc);
}
