Exemple #1
0
/****************************************************************
 *
 * 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 ;
}
Exemple #2
0
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);

}
Exemple #3
0
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;
  }
}
Exemple #4
0
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);
}
Exemple #5
0
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);
}
Exemple #6
0
/* 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;
}
Exemple #7
0
Widget 
XmMainWindowSep3(
        Widget w )
{
    XmMainWindowWidget   mw = (XmMainWindowWidget) w;
    Widget separator;
    _XmWidgetToAppContext(w);

    _XmAppLock(app);
    separator = (Widget) mw->mwindow.Sep3;
    _XmAppUnlock(app);

    return separator;
}
Exemple #8
0
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);
}
Exemple #9
0
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);
    }
}
Exemple #10
0
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);
}
Exemple #11
0
/************************************************************************
 *
 *  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);
      }
}
Exemple #12
0
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 ;
}
Exemple #13
0
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;
}
Exemple #14
0
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);
}