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);
}
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);
}
/* This public function retrieves the widget saved by _XmSetDestination. */
Widget XmGetDestination (Display *display)
{
XmDisplay dd = (XmDisplay) XmGetXmDisplay(display);
Widget w = (Widget)NULL;
_XmDisplayToAppContext(display);
_XmAppLock(app);
if ((XmDisplay)NULL != dd)
w = ((XmDisplayInfo *)(dd->display.displayInfo))->destinationWidget;
_XmAppUnlock(app);
return w;
}
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);
}
Widget
XmMainWindowSep3(
Widget w )
{
XmMainWindowWidget mw = (XmMainWindowWidget) w;
Widget separator;
_XmWidgetToAppContext(w);
_XmAppLock(app);
separator = (Widget) mw->mwindow.Sep3;
_XmAppUnlock(app);
return separator;
}
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);
}
}
XtEnum
XmPrintPopupPDM(Widget print_shell,
Widget transient_for_video_shell)
{
Atom pdm_selection;
Atom type;
unsigned char * value;
int length;
int format;
Atom PDM_START ;
Display * display_used ;
PDMSelectData * pdm_select_data ;
Widget widget_for_selection ;
XtAppContext app;
unsigned long old_timeout;
/* get parameter for PDM_START from libXp
ask conversion using XtSetSelectionParameters,
and then call XtGetSelectionValue, which registers a
XtSelectionCallbackProc that will wait for failure (no pdm
owner, or timeout) or success.
Phase 2 of the pdm (clientmessage) will be handled by a
event handler set up from the selection callback on success */
if (!XpGetPdmStartParams (XtDisplay(print_shell),
XtWindow(print_shell),
XpGetContext(XtDisplay(print_shell)),
XtDisplay(transient_for_video_shell),
XtWindow(transient_for_video_shell), &display_used,
&pdm_selection, &type, &format, &value, &length))
return XmPDM_NOTIFY_FAIL;
/* only support XPDMDISPLAY = "print" or "video" */
if (display_used == XtDisplay(print_shell))
widget_for_selection = print_shell ;
else
if (display_used == XtDisplay(transient_for_video_shell))
widget_for_selection = transient_for_video_shell ;
else
return XmPDM_NOTIFY_FAIL ;
XtSetSelectionParameters(widget_for_selection, pdm_selection,
type, (XtPointer)value, length, format);
XFree(value);
pdm_select_data = (PDMSelectData *) XtMalloc(sizeof(PDMSelectData));
pdm_select_data->pdm_selection = pdm_selection ;
pdm_select_data->transient_for_video_shell = transient_for_video_shell ;
pdm_select_data->print_shell = (XmPrintShellWidget) print_shell ;
/* need this one in all cases */
PDM_START = XInternAtom(XtDisplay(widget_for_selection),
XmIPDM_START, False);
app = XtWidgetToApplicationContext(widget_for_selection);
/* twenty minutes */
#define REALLY_LONG_TIMEOUT (2 * 60 * 1000)
_XmAppLock(app);
old_timeout = XtAppGetSelectionTimeout(app);
XtAppSetSelectionTimeout(app, REALLY_LONG_TIMEOUT);
XtGetSelectionValue(widget_for_selection,
pdm_selection,
PDM_START,
PDMSelectionProc,
(XtPointer)pdm_select_data,
XtLastTimestampProcessed(
XtDisplay(widget_for_selection)));
XtAppSetSelectionTimeout(app, old_timeout);
_XmAppUnlock(app);
/* put up a InputOnly window on top of the dialog,
so that the end-user cannot muck around with the print setup
dialog hile the PDM is trying to come up.
This is removed in PDMSelectionProc */
pdm_select_data->transient_for_input_only_window =
XCreateWindow(XtDisplay(transient_for_video_shell),
XtWindow(transient_for_video_shell),
0, 0,
XtWidth(transient_for_video_shell),
XtHeight(transient_for_video_shell),
0, CopyFromParent, InputOnly, CopyFromParent,
0, NULL);
XMapRaised(XtDisplay(transient_for_video_shell),
pdm_select_data->transient_for_input_only_window);
return XmPDM_NOTIFY_SUCCESS ;
}
String
XmGetIconFileName(
Screen *screen,
String imageInstanceName,
String imageClassName,
String hostPrefix,
unsigned int size)
{
Display *display = DisplayOfScreen(screen);
String fileName = NULL;
String names[2];
String names_w_size[2];
XmConst char *bPath, *iPath;
Cardinal i;
Boolean useColor;
Boolean useMask;
Boolean useIconFileCache;
Boolean absolute = 0;
XtFilePredicate testFileFunc;
String homedir = NULL ;
static String iconPath = NULL;
static String bmPath = NULL;
static XmHashTable iconNameCache = NULL;
char stackString[MAX_DIR_PATH_LEN];
#define B_SUB 0
#define P_SUB 1
#define M_SUB 2
#define H_SUB 3
SubstitutionRec iconSubs[] = {
{'B', NULL}, /* bitmap name */
{'P', NULL}, /* alternate bitmap name BC */
{'M', NULL}, /* magnitude */
{'H', NULL}, /* host prefix */
};
XtAppContext app;
app = XtDisplayToApplicationContext(display);
_XmAppLock(app);
/* start by asking some screen state */
(void)XmeGetIconControlInfo(screen,
&useMask, /* not used here */
&useColor,
&useIconFileCache);
_XmProcessLock();
/* generate the icon paths once per application: iconPath and bmPath */
if (!iconNameCache) {
Boolean junkBoolean;
iconNameCache = _XmAllocHashTable(100,
CompareIconNames, HashIconName);
cacheList.numDirs =
cacheList.maxDirs = 0;
cacheList.dirs = NULL;
homedir = XmeGetHomeDirName();
strcpy(stackString, homedir) ;
if (useColor) {
iconPath = _XmOSInitPath(NULL, "XMICONSEARCHPATH", &junkBoolean);
}
else {
iconPath = _XmOSInitPath(NULL, "XMICONBMSEARCHPATH", &junkBoolean);
}
/* 1.2 path as a fallback */
bmPath = _XmOSInitPath(NULL, "XBMLANGPATH", &junkBoolean);
}
switch (size) {
case XmTINY_ICON_SIZE:
iconSubs[M_SUB].substitution = ".t";
break;
case XmSMALL_ICON_SIZE:
iconSubs[M_SUB].substitution = ".s";
break;
case XmMEDIUM_ICON_SIZE:
iconSubs[M_SUB].substitution = ".m";
break;
case XmLARGE_ICON_SIZE:
iconSubs[M_SUB].substitution = ".l";
break;
case XmUNSPECIFIED_ICON_SIZE:
iconSubs[M_SUB].substitution = NULL;
break;
}
iconSubs[H_SUB].substitution = hostPrefix;
if (useIconFileCache)
testFileFunc = TestIconFile;
else
testFileFunc = NULL;
names[0] = imageInstanceName;
names[1] = imageClassName;
names_w_size[0] = names_w_size[1] = (String)NULL;
/** loop over the two names */
for (i = 0; i < 2; i++) {
if (names[i] == NULL)
continue;
if ((absolute = _XmOSAbsolutePathName(names[i], &names[i],
stackString)) != FALSE) {
iPath = ABSOLUTE_IPATH;
bPath = ABSOLUTE_PATH;
}
else {
iPath = iconPath;
bPath = bmPath;
}
iconSubs[B_SUB].substitution = names[i];
iconSubs[P_SUB].substitution = names[i];
/* need to add size suffix if size is specified */
if (size != XmUNSPECIFIED_ICON_SIZE) {
int basenameLen = strlen(names[i]);
int sizeLen = strlen(iconSubs[M_SUB].substitution);
char * ext_name = XtMalloc(basenameLen + sizeLen + 1);
/* XmosP.h takes care of bcopy translation */
memmove(&ext_name[0], names[i], basenameLen);
memmove(&ext_name[basenameLen],
iconSubs[M_SUB].substitution, sizeLen);
ext_name[basenameLen + sizeLen] = '\0';
names_w_size[i] = ext_name;
} else
names_w_size[i] = NULL;
/*
* try to see if its already in the image cache
*/
if (_XmInImageCache(names[i]))
fileName = XtNewString(names[i]);
/*
* optimization to check all expansions in cache
*/
if (!fileName) {
DtIconNameEntry iNameEntry;
DtIconNameEntryRec iNameData ;
iNameData.key_name = (names_w_size[i])?names_w_size[i]:names[i];
iNameEntry = (DtIconNameEntry)
_XmGetHashEntry(iconNameCache, (XmHashKey)&iNameData);
if (iNameEntry) {
int dirLen, leafLen;
dirLen = strlen(iNameEntry->dirName);
leafLen = strlen(iNameEntry->leafName);
fileName = XtMalloc(dirLen + leafLen + 2);
memmove(&fileName[0],
iNameEntry->dirName,
dirLen);
#ifdef FIX_1427
if (dirLen == 0) {
memmove(&fileName[dirLen], iNameEntry->leafName, leafLen);
fileName[dirLen + leafLen] = '\0';
} else {
#endif
fileName[dirLen] = '/';
memmove(&fileName[dirLen + 1],
iNameEntry->leafName,
leafLen);
fileName[dirLen + leafLen + 1] = '\0';
#ifdef FIX_1427
}
#endif
}
}
if (fileName) {
/*
* CDExc20823 (memory leak): free names_w_size[i]
* if it is not NULL.
* NOTE: This code could be reorganized to do
* _XmInImageCache() at the top of this loop
* so we could avoid unnecessary malloc's for
* names_w_size, but I wanted to minimize the
* code impact of this defect for now.
*/
for (i = 0; i < 2; i++)
{
if (names_w_size[i] != (String)NULL)
XtFree(names_w_size[i]);
}
_XmProcessUnlock();
_XmAppUnlock(app);
return fileName;
}
/*******************************
* first try XPM and then XBM
******************************/
fileName =
XtResolvePathname(display, "icons", NULL,
NULL, iPath, iconSubs,
XtNumber(iconSubs),
(XtFilePredicate) testFileFunc);
if (fileName == NULL) {
fileName =
XtResolvePathname(display, "bitmaps", NULL,
NULL, bPath, iconSubs,
XtNumber(iconSubs),
(XtFilePredicate) testFileFunc);
}
if (fileName)
break;
}
_XmProcessUnlock();
if (fileName && !absolute) {
/* register it in name cache */
DtIconNameEntry iNameEntry;
String name_used = (names_w_size[i])? names_w_size[i] : names[i] ;
/** alloc a icon cache entry **/
iNameEntry = (DtIconNameEntry) XtMalloc(sizeof(DtIconNameEntryRec));
iNameEntry->key_name = XtNewString(name_used);
#ifndef XTHREADS
if (useIconFileCache)
{
iNameEntry->dirName = XtNewString(GdirName);
iNameEntry->leafName = XtNewString(GleafName);
}
else
#endif
{
String dirName;
String filePtr;
String suffixPtr;
int dirNameLen;
_XmOSFindPathParts(fileName, &filePtr, &suffixPtr);
if (fileName == filePtr)
dirNameLen = 0;
else {
/* take the slash into account */
dirNameLen = filePtr - fileName - 1;
}
dirName = (String)XtMalloc(dirNameLen + 1);
strncpy(dirName, fileName, dirNameLen);
dirName[dirNameLen] = '\0';
iNameEntry->dirName = dirName;
iNameEntry->leafName = XtNewString(filePtr);
}
_XmProcessLock();
_XmAddHashEntry(iconNameCache, (XmHashKey)iNameEntry,
(XtPointer)iNameEntry);
_XmProcessUnlock();
}
/*
* CDExc20823 (memory leak): free names_w_size[i] if not NULL.
*/
for (i = 0; i < 2; i++)
{
if (names_w_size[i] != (String)NULL)
XtFree(names_w_size[i]);
}
_XmAppUnlock(app);
return fileName;
}
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);
}
