Exemple #1
0
static Widget
CreatePulldown(char* name, char mnemonic,
	       Widget parent, menu_info *info, 
	       WidgetList array, Cardinal size)
{
  int i;
  Widget cascade_button, pulldown;
  Arg args[10];
  char buffer[128];

  sprintf(buffer,"%s_pulldown", name);
  pulldown = XmCreatePulldownMenu(parent, buffer, NULL, 0);

  i = 0;
  if (mnemonic != 0) {
    XtSetArg(args[i], XmNmnemonic, mnemonic); 
    i++;
  }
  XtSetArg(args[i], XmNsubMenuId, pulldown); i++;
  cascade_button = XmCreateCascadeButtonGadget(parent, name, args, i);
  XtManageChild(cascade_button);

  if (strcmp(name, "Help") == 0)
    XtVaSetValues(parent, XmNmenuHelpWidget, cascade_button, NULL, NULL);

  /* Create menu items,  special exception for the first item 
     in the View menu,  which is a cascadebutton*/
  for(i = 0; i < size; i++) {
    if (info[i].is_separator)
      array[i] = XmCreateSeparatorGadget(pulldown, info[i].label, NULL, 0);
    else
      array[i] = CreateMenuButton(pulldown, info[i].label, 
				  info[i].mnemonic,
				  info[i].accelerator,
				  info[i].acc_text,
				  (info != view_pulldown && i != 0) 
				  ? xmPushButtonGadgetClass : 
				    xmCascadeButtonGadgetClass
				  );

    if (info[i].managed)
      XtManageChild(array[i]);
  }

  return(pulldown);
}
Exemple #2
0
static Widget CreateCascadeGadget(char *label, char mnemonic,
                                  Widget submenu, Widget parent)
{
    Widget widget;
    register int n;
    Arg args[MAX_ARGS];
    XmString tcs;

    n = 0;
    tcs = XmStringLtoRCreate(label, XmSTRING_DEFAULT_CHARSET);
    XtSetArg(args[n], XmNlabelString, tcs);
    n++;
    XtSetArg(args[n], XmNmnemonic, mnemonic);
    n++;
    XtSetArg(args[n], XmNsubMenuId, submenu);
    n++;
    widget = XmCreateCascadeButtonGadget(parent, label, args, n);
    XtManageChild(widget);
    XmStringFree(tcs);

    return(widget);
}
Exemple #3
0
Widget XmCreateCascadeButtonGadget_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateCascadeButtonGadget(parent, name, arglist, argcount);}
Exemple #4
0
Widget
_DtCreateMenuSystem(
        Widget parent,
        char * menuBarName,
        XtCallbackProc helpCallback,
        XtPointer helpData,
        Boolean createSharedComponents,
        MenuDesc * menuDesc,
        int numMenuComponents,
        void (*getMenuDataProc)(),
        void (*setMenuSensitivity)(),
        void (*restoreMenuSensitivity)() )

{
   int n;
   int i;
   Arg args[20];
   Widget menubar;
   Widget lastCascadeBtn = NULL;
   Widget lastMenuPane = NULL;
   char lastMenuPaneType = MENU_PANE;
   Boolean firstMenuPane = True;
   Widget child;
   XmString labelString;
   int pulldownIndex = 1;
   int menuPaneIndex = 1;
   int menuBtnIndex = 1;

   /* Use our own menu control functions, if none specified */
   if (setMenuSensitivity == NULL)
      setMenuSensitivity = _DtGlobalSetMenuSensitivity;
   if (restoreMenuSensitivity == NULL)
      restoreMenuSensitivity = _DtGlobalRestoreMenuSensitivity;

   /*  Create the pulldown menu  */
   n = 0;
   XtSetArg(args[n], XmNorientation, XmHORIZONTAL);	n++;
   XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);	n++;
   XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);	n++;
   XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);	n++;
   menubar = XmCreateMenuBar(parent, menuBarName, args, n);
   XtManageChild(menubar);
   if (helpCallback)
      XtAddCallback(menubar, XmNhelpCallback, helpCallback, helpData);

   for (i = 0; i < numMenuComponents; i++)
   {
      n = 0;

      switch (menuDesc[i].type)
      {
         case MENU_PULLDOWN_BUTTON:
         {
            labelString = XmStringCreateLocalized(menuDesc[i].label);
            XtSetArg(args[n], XmNlabelString, labelString);   n++;
            if (menuDesc[i].mnemonic)
            {
               XtSetArg(args[n], XmNmnemonic, menuDesc[i].mnemonic[0]);   n++;
            }
            XtSetArg(args[n], XmNmarginWidth, 6);   n++;
            child = XmCreateCascadeButtonGadget(menubar, menuDesc[i].name, 
                                                args, n);
            if (menuDesc[i].helpCallback)
            {
               XtAddCallback(child, XmNhelpCallback, 
                             menuDesc[i].helpCallback, menuDesc[i].helpData);
            }
            if (menuDesc[i].isHelpBtn)
            {
               XtSetArg(args[0], XmNmenuHelpWidget, child);
               XtSetValues(menubar, args, 1);
            }
            XtManageChild(child);
            XmStringFree(labelString);
            lastCascadeBtn = menuDesc[i].widget = child;
            pulldownIndex++;
            break;
         }

         case SHARED_MENU_PANE:
         case MENU_PANE:
         {
            if (createSharedComponents || (menuDesc[i].type == MENU_PANE))
            {
               child = XmCreatePulldownMenu(menubar, menuDesc[i].name, NULL, 0);

               if (firstMenuPane)
               {
                  XtAddCallback(XtParent(child), XmNpopupCallback, 
                                setMenuSensitivity, 
                                (XtPointer)getMenuDataProc);
                  XtAddCallback(XtParent(child), XmNpopdownCallback, 
                                restoreMenuSensitivity, 
                                (XtPointer)getMenuDataProc);
                  firstMenuPane = False;
               }

               if (menuDesc[i].helpCallback)
               {
                  XtAddCallback(child, XmNhelpCallback, 
                             menuDesc[i].helpCallback, menuDesc[i].helpData);
               }

               menuDesc[i].widget = child;
            }

            lastMenuPane = menuDesc[i].widget;
            lastMenuPaneType = menuDesc[i].type;
            XtSetArg(args[0], XmNsubMenuId, lastMenuPane);
            XtSetValues(lastCascadeBtn, args, 1);
            menuBtnIndex = 1;
            menuPaneIndex++;
            break;
         }

         case MENU_TOGGLE_BUTTON:
         case MENU_BUTTON:
         {
            /* Need to always make btns for non-shared menupanes */
            if ((createSharedComponents) || (lastMenuPaneType == MENU_PANE))
            {
               child = CreateMenuBtn (lastMenuPane, 
                                      (menuDesc[i].type == MENU_BUTTON),
                                      menuDesc + i, menuBtnIndex);
               XtManageChild(child);
               menuDesc[i].widget = child;
            }
            menuBtnIndex++;
            break;
         }

         case MENU_SEPARATOR:
         {
            /* Need to always make components for non-shared menupanes */
            if ((createSharedComponents) || (lastMenuPaneType == MENU_PANE))
            {
               child = XmCreateSeparatorGadget(lastMenuPane, menuDesc[i].name, 
                                               NULL, 0);
               XtManageChild(child);
               menuDesc[i].widget = child;
            }
            break;
         }
      }
   }


   return(menubar);
}