/* * Motif * * Copyright (c) 1987-2012, The Open Group. All rights reserved. * * These libraries and programs are free software; you can * redistribute them and/or modify them under the terms of the GNU * Lesser General Public License as published by the Free Software * Foundation; either version 2 of the License, or (at your option) * any later version. * * These libraries and programs are distributed in the hope that * they will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public * License along with these librararies and programs; if not, write * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth * Floor, Boston, MA 02110-1301 USA */ /* * HISTORY */ #ifdef HAVE_CONFIG_H #include #endif #ifdef REV_INFO #ifndef lint static char rcsid[] = "$XConsortium: VaSimple.c /main/11 1995/10/25 20:26:43 cde-sun $" #endif #endif /* * (c) Copyright 1987, 1988, 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */ #include #include #include #include "MessagesI.h" #include "VaSimpleI.h" #include "XmI.h" #ifndef va_dcl #define va_dcl int va_alist; #endif #define XMBUTTONS_ARGS_PER_LIST 5 #define XMCASCADE_ARGS_PER_LIST 3 #define XMTITLE_ARGS_PER_LIST 1 #define XMSEPARATOR_ARGS_PER_LIST 0 #define _XmINVALID_BUTTON_TYPE 0xff #define MESSAGE1 _XmMMsgVaSimple_0000 #define MESSAGE2 _XmMMsgVaSimple_0001 #define MESSAGE3 _XmMMsgVaSimple_0002 /******** Static Function Declarations ********/ static XmButtonType _XmVaBType_to_XmBType( String symbol) ; static void _XmCountNestedList( XtTypedArgList avlist, int *total_count, int *typed_count) ; static int _XmTypedArgToArg( Widget widget, XtTypedArgList typed_arg, ArgList arg_return, XtResourceList resources, Cardinal num_resources) ; static int _XmNestedArgtoArg( Widget widget, XtTypedArgList avlist, ArgList args, XtResourceList resources, Cardinal num_resources) ; static int _XmNestedArgtoTypedArg( XtTypedArgList args, XtTypedArgList avlist) ; static void _XmVaProcessEverything( Widget widget, va_list var, XmButtonTypeTable *buttonTypes, XmStringTable *buttonStrings, XmKeySymTable *buttonMnemonics, String **buttonAccelerators, XmStringTable *buttonAcceleratorText, int button_count, ArgList *args, int num_args) ; /******** End Static Function Declarations ********/ static XmButtonType _XmVaBType_to_XmBType( String symbol ) { if (strcmp(symbol, XmVaPUSHBUTTON) == 0) return (XmPUSHBUTTON); else if (strcmp(symbol, XmVaTOGGLEBUTTON) == 0) return (XmTOGGLEBUTTON); else if (strcmp(symbol, XmVaCHECKBUTTON) == 0) return (XmCHECKBUTTON); else if (strcmp(symbol, XmVaRADIOBUTTON) == 0) return (XmRADIOBUTTON); else if (strcmp(symbol, XmVaCASCADEBUTTON) == 0) return (XmCASCADEBUTTON); else if (strcmp(symbol, XmVaSEPARATOR) == 0) return (XmSEPARATOR); else if (strcmp(symbol, XmVaDOUBLE_SEPARATOR) == 0) return (XmDOUBLE_SEPARATOR); else if (strcmp(symbol, XmVaTITLE) == 0) return (XmTITLE); else return (_XmINVALID_BUTTON_TYPE); } /* * Given a nested list, _XmCountNestedList() returns counts of the * total number of attribute-value pairs and the count of those * attributes that are typed. The list is counted recursively. */ static void _XmCountNestedList( XtTypedArgList avlist, int *total_count, int *typed_count ) { for (; avlist->name != NULL; avlist++) { if (strcmp(avlist->name, XtVaNestedList) == 0) { _XmCountNestedList((XtTypedArgList)avlist->value, total_count, typed_count); } else { if (avlist->type != NULL) { ++(*typed_count); } ++(*total_count); } } } /* * Function: XmeCountVaList * * Description: Takes a variable list and returns the number of total * items in it. This is a much simplified version of * _XmCountVaList. It is intended to be used in convience * creation routines for widgets both inside and outside the * toolkit. * * Input: al - a variable lenth list, at the beginning of the list. * * Output: the number of items in it before the last NULL * */ int XmeCountVaListSimple(va_list al) { int d1, d2, d3, count; _XmCountVaList(al, &d1, &d2, &d3, &count); return count; } /* * Given a variable length attribute-value list, _XmCountVaList() * returns counts of the total number of attribute-value pairs, * and the count of the number of those attributes that are typed. * The list is counted recursively. */ void _XmCountVaList( va_list var, int *button_count, int *args_count, int *typed_count, int *total_count ) { String attr; int i; *button_count = 0; *args_count = 0; *typed_count = 0; *total_count = 0; for(attr = va_arg(var, String) ; attr != NULL; attr = va_arg(var, String)) { /* Count typed Args */ if (strcmp(attr, XtVaTypedArg) == 0) { (void)va_arg(var, String); (void)va_arg(var, String); (void)va_arg(var, XtArgVal); (void)va_arg(var, int); ++(*total_count); ++(*typed_count); } else if (strcmp(attr, XtVaNestedList) == 0) { _XmCountNestedList(va_arg(var, XtTypedArgList), total_count, typed_count); } else { /* Count valid VaBUTTONS (done here because of the variable arg length) */ if (strcmp(attr, XmVaCASCADEBUTTON) == 0) { for (i = 1; i < XMCASCADE_ARGS_PER_LIST; i++) (void)va_arg(var, XtArgVal); ++(*total_count); ++(*button_count); } else if ((strcmp(attr, XmVaSEPARATOR) == 0) || (strcmp(attr, XmVaDOUBLE_SEPARATOR) == 0)) { ++(*total_count); ++(*button_count); } else if (strcmp(attr, XmVaTITLE) == 0){ (void)va_arg(var, XtArgVal); ++(*total_count); ++(*button_count); /* Check matches other known VaBUTTONS */ } else if (_XmVaBType_to_XmBType(attr) != _XmINVALID_BUTTON_TYPE) { for (i = 1; i < XMBUTTONS_ARGS_PER_LIST; i++) (void)va_arg(var, XtArgVal); ++(*total_count); ++(*button_count); /* Else it's a simple Arg */ } else { (void)va_arg(var, XtArgVal); ++(*args_count); ++(*total_count); } } } } /* * _XmTypedArgToArg() invokes a resource converter to convert the * passed typed arg into a name/value pair and stores the name/value * pair in the passed Arg structure. It returns 1 if the conversion * succeeded and 0 if the conversion failed. */ static int _XmTypedArgToArg( Widget widget, XtTypedArgList typed_arg, ArgList arg_return, XtResourceList resources, Cardinal num_resources ) { String to_type = NULL; XrmValue from_val, to_val; register int i; if (widget == NULL) { XtAppWarningMsg(XtWidgetToApplicationContext(widget), "nullWidget", "xtConvertVarTArgList", "XtToolkitError", MESSAGE1, (String *)NULL, (Cardinal *)NULL); return(0); } /* again we assume that the XtResourceList is un-compiled */ for (i = 0; i < num_resources; i++) { if (StringToName(typed_arg->name) == StringToName(resources[i].resource_name)) { to_type = resources[i].resource_type; break; } } if (to_type == NULL) { XtAppWarningMsg(XtWidgetToApplicationContext(widget), "unknownType", "xtConvertVarTArgList", "XtToolkitError", MESSAGE2, (String *)NULL, (Cardinal *)NULL); return(0); } to_val.addr = NULL; from_val.size = typed_arg->size; if ((strcmp(typed_arg->type, XtRString) == 0) || (typed_arg->size > sizeof(XtArgVal))) { from_val.addr = (XPointer)typed_arg->value; } else { from_val.addr = (XPointer)&typed_arg->value; } _XmProcessLock(); XtConvert(widget, typed_arg->type, &from_val, to_type, &to_val); if (to_val.addr == NULL) { _XmProcessUnlock(); XtAppWarningMsg(XtWidgetToApplicationContext(widget), "conversionFailed", "xtConvertVarToArgList", "XtToolkitError", MESSAGE3, (String *)NULL, (Cardinal *)NULL); return(0); } arg_return->name = typed_arg->name; if (strcmp(to_type, XtRString) == 0) { arg_return->value = (XtArgVal) to_val.addr; } else { if (to_val.size == sizeof(long)) arg_return->value = (XtArgVal) *(long *)to_val.addr; else if (to_val.size == sizeof(int)) arg_return->value = (XtArgVal) *(int *)to_val.addr; else if (to_val.size == sizeof(short)) arg_return->value = (XtArgVal) *(short *)to_val.addr; else if (to_val.size == sizeof(char)) arg_return->value = (XtArgVal) *(char *)to_val.addr; else arg_return->value = *(XtArgVal *)to_val.addr; } _XmProcessUnlock(); return(1); } /* * _XmNestedArgtoArg() converts the passed nested list into * an ArgList/count. */ static int _XmNestedArgtoArg( Widget widget, XtTypedArgList avlist, ArgList args, XtResourceList resources, Cardinal num_resources ) { int count = 0; for (; avlist->name != NULL; avlist++) { if (avlist->type != NULL) { /* If widget is NULL, the typed arg is ignored */ if (widget != NULL) { /* this is a typed arg */ count += _XmTypedArgToArg(widget, avlist, (args+count), resources, num_resources); } } else if (strcmp(avlist->name, XtVaNestedList) == 0) { count += _XmNestedArgtoArg(widget, (XtTypedArgList)avlist->value, (args+count), resources, num_resources); } else { (args+count)->name = avlist->name; (args+count)->value = avlist->value; ++count; } } return(count); } static int _XmNestedArgtoTypedArg( XtTypedArgList args, XtTypedArgList avlist ) { int count = 0; for (; avlist->name != NULL; avlist++) { if (avlist->type != NULL) { (args+count)->name = avlist->name; (args+count)->type = avlist->type; (args+count)->size = avlist->size; (args+count)->value = avlist->value; ++count; } else if(strcmp(avlist->name, XtVaNestedList) == 0) { count += _XmNestedArgtoTypedArg((args+count), (XtTypedArgList)avlist->value); } else { (args+count)->name = avlist->name; (args+count)->type = NULL; (args+count)->value = avlist->value; ++count; } } return(count); } /* * Given a variable argument list, _XmVaToTypedArgList() returns * the equivalent TypedArgList. _XmVaToTypedArgList() handles nested * lists. * Note: _XmVaToTypedArgList() does not do type conversions. */ void _XmVaToTypedArgList( va_list var, int max_count, XtTypedArgList *args_return, Cardinal *num_args_return ) { XtTypedArgList args = NULL; String attr; int count; args = (XtTypedArgList) XtMalloc((unsigned)(max_count * sizeof(XtTypedArg))); for(attr = va_arg(var, String), count = 0 ; attr != NULL; attr = va_arg(var, String)) { if (strcmp(attr, XtVaTypedArg) == 0) { args[count].name = va_arg(var, String); args[count].type = va_arg(var, String); args[count].value = va_arg(var, XtArgVal); args[count].size = va_arg(var, int); ++count; } else if (strcmp(attr, XtVaNestedList) == 0) { count += _XmNestedArgtoTypedArg(&args[count], va_arg(var, XtTypedArgList)); } else { args[count].name = attr; args[count].type = NULL; args[count].value = va_arg(var, XtArgVal); ++count; } } *args_return = args; *num_args_return = count; } static void _XmVaProcessEverything( Widget widget, va_list var, XmButtonTypeTable *buttonTypes, XmStringTable *buttonStrings, XmKeySymTable *buttonMnemonics, String **buttonAccelerators, XmStringTable *buttonAcceleratorText, int button_count, ArgList *args, int num_args ) { XtTypedArg typed_args; String attr; int count, bcount; *args = (ArgList) XtMalloc(num_args * sizeof(Arg)); /* Process the routine specific args */ *buttonTypes = (XmButtonTypeTable) XtMalloc((unsigned)(button_count * sizeof(XmButtonType *))); *buttonStrings = (XmStringTable) XtMalloc((unsigned)(button_count * sizeof(XmString *))); *buttonMnemonics = (XmKeySymTable) XtMalloc((unsigned)(button_count * sizeof(KeySym *))); *buttonAccelerators = (String *) XtMalloc((unsigned)(button_count * sizeof(String *))); *buttonAcceleratorText = (XmStringTable) XtMalloc((unsigned)(button_count * sizeof(XmString *))); bcount = 0; for(attr = va_arg(var, String), count = 0 ; attr != NULL; attr = va_arg(var, String)) { if (strcmp(attr, XtVaTypedArg) == 0) { typed_args.name = va_arg(var, String); typed_args.type = va_arg(var, String); typed_args.value = va_arg(var, XtArgVal); typed_args.size = va_arg(var, int); count += _XmTypedArgToArg(widget, &typed_args, &(*args)[count], NULL, 0); } else if (strcmp(attr, XtVaNestedList) == 0) { count += _XmNestedArgtoArg(widget, va_arg(var, XtTypedArgList), &(*args)[count], NULL, 0); } else if ((strcmp(attr, XmVaSEPARATOR) == 0) || (strcmp(attr, XmVaDOUBLE_SEPARATOR) == 0)) { (*buttonTypes)[bcount] = _XmVaBType_to_XmBType(attr); (*buttonStrings)[bcount] = (XmString) NULL; (*buttonMnemonics)[bcount] = (KeySym) NULL; (*buttonAccelerators)[bcount] = (String) NULL; (*buttonAcceleratorText)[bcount] = (XmString) NULL; ++bcount; } else if (strcmp(attr, XmVaTITLE) == 0){ (*buttonTypes)[bcount] = _XmVaBType_to_XmBType(attr); (*buttonStrings)[bcount] = va_arg(var, XmString); (*buttonMnemonics)[bcount] = (KeySym) NULL; (*buttonAccelerators)[bcount] = (String) NULL; (*buttonAcceleratorText)[bcount] = (XmString) NULL; ++bcount; } else if (strcmp(attr, XmVaCASCADEBUTTON) == 0) { (*buttonTypes)[bcount] = _XmVaBType_to_XmBType(attr); (*buttonStrings)[bcount] = va_arg(var, XmString); (*buttonMnemonics)[bcount] = va_arg(var, KeySym); (*buttonAccelerators)[bcount] = (String) NULL; (*buttonAcceleratorText)[bcount] = (XmString) NULL; ++bcount; } else if (_XmVaBType_to_XmBType(attr) != _XmINVALID_BUTTON_TYPE) { (*buttonTypes)[bcount] = _XmVaBType_to_XmBType(attr); (*buttonStrings)[bcount] = va_arg(var, XmString); (*buttonMnemonics)[bcount] = va_arg(var, KeySym); (*buttonAccelerators)[bcount] = va_arg(var, String); (*buttonAcceleratorText)[bcount] = va_arg(var, XmString); ++bcount; } else { (*args)[count].name = attr; (*args)[count].value = va_arg(var, XtArgVal); ++count; } } } Widget XmVaCreateSimpleMenuBar(Widget parent, String name, ...) { #define MB_EXTRA_ARGS 1 va_list var; register Widget widget; ArgList args; int button_count, args_count, typed_count, total_count; int n, num_args; XmButtonTypeTable menuBarButtonTypes; XmStringTable menuBarStrings; XmKeySymTable menuBarMnemonics; String * menuBarAccelerators; XmStringTable menuBarAcceleratorText; _XmWidgetToAppContext(parent); _XmAppLock(app); /* Count number of arg (arg in this case means number of arg groups) */ Va_start(var,name); _XmCountVaList(var, &button_count, &args_count, &typed_count, &total_count); va_end(var); /* Convert into a normal ArgList */ Va_start(var,name); num_args = args_count + (XMCASCADE_ARGS_PER_LIST + MB_EXTRA_ARGS); _XmVaProcessEverything(parent, var, &menuBarButtonTypes, &menuBarStrings, &menuBarMnemonics, &menuBarAccelerators, &menuBarAcceleratorText, button_count, &args, num_args); n = args_count; XtSetArg (args[n], XmNbuttonCount, button_count); n++; XtSetArg (args[n], XmNbuttonType, menuBarButtonTypes); n++; XtSetArg (args[n], XmNbuttons, menuBarStrings); n++; XtSetArg (args[n], XmNbuttonMnemonics, menuBarMnemonics); n++; widget = XmCreateSimpleMenuBar(parent, name, args, n); if (args != NULL) { XtFree((char *)args); } if (menuBarButtonTypes != NULL) { XtFree((char *)menuBarButtonTypes); } if (menuBarStrings != NULL) { XtFree((char *)menuBarStrings); } if (menuBarMnemonics != NULL) { XtFree((char *)menuBarMnemonics); } if (menuBarAccelerators != NULL) { XtFree((char *)menuBarAccelerators); } if (menuBarAcceleratorText != NULL) { XtFree((char *)menuBarAcceleratorText); } va_end(var); _XmAppUnlock(app); return (widget); } Widget XmVaCreateSimplePulldownMenu(Widget parent, String name, int post_from_button, XtCallbackProc callback, ...) { #define PD_EXTRA_ARGS 3 va_list var; register Widget widget; Arg *args; int button_count, args_count, typed_count, total_count; int n, num_args; XmButtonTypeTable pulldownMenuButtonTypes; XmStringTable pulldownMenuStrings; XmKeySymTable pulldownMenuMnemonics; String * pulldownMenuAccelerators; XmStringTable pulldownMenuAcceleratorText; _XmWidgetToAppContext(parent); _XmAppLock(app); /* Count number of arg (arg in this case means number of arg groups) */ Va_start(var,callback); _XmCountVaList(var, &button_count, &args_count, &typed_count, &total_count); va_end(var); /* Convert into a normal ArgList */ Va_start(var,callback); num_args = args_count + (XMBUTTONS_ARGS_PER_LIST + PD_EXTRA_ARGS); _XmVaProcessEverything(parent, var, &pulldownMenuButtonTypes, &pulldownMenuStrings, &pulldownMenuMnemonics, &pulldownMenuAccelerators, &pulldownMenuAcceleratorText, button_count, &args, num_args); n = args_count; XtSetArg (args[n], XmNsimpleCallback, callback); n++; XtSetArg (args[n], XmNpostFromButton, post_from_button); n++; XtSetArg (args[n], XmNbuttonCount, button_count); n++; XtSetArg (args[n], XmNbuttonType, pulldownMenuButtonTypes); n++; XtSetArg (args[n], XmNbuttons, pulldownMenuStrings); n++; XtSetArg (args[n], XmNbuttonMnemonics, pulldownMenuMnemonics); n++; XtSetArg (args[n], XmNbuttonAccelerators, pulldownMenuAccelerators); n++; XtSetArg (args[n], XmNbuttonAcceleratorText, pulldownMenuAcceleratorText); n++; widget = XmCreateSimplePulldownMenu(parent, name, args, n); if (args != NULL) { XtFree((char *)args); } if (pulldownMenuButtonTypes != NULL) { XtFree((char *)pulldownMenuButtonTypes); } if (pulldownMenuStrings != NULL) { XtFree((char *)pulldownMenuStrings); } if (pulldownMenuMnemonics != NULL) { XtFree((char *)pulldownMenuMnemonics); } if (pulldownMenuAccelerators != NULL) { XtFree((char *)pulldownMenuAccelerators); } if (pulldownMenuAcceleratorText != NULL) { XtFree((char *)pulldownMenuAcceleratorText); } va_end(var); _XmAppUnlock(app); return (widget); } Widget XmVaCreateSimplePopupMenu(Widget parent, String name, XtCallbackProc callback, ...) { #define PU_EXTRA_ARGS 2 va_list var; register Widget widget; Arg *args; int button_count, args_count, typed_count, total_count; int n, num_args; XmButtonTypeTable popupMenuButtonTypes; XmStringTable popupMenuStrings; XmKeySymTable popupMenuMnemonics; String * popupMenuAccelerators; XmStringTable popupMenuAcceleratorText; _XmWidgetToAppContext(parent); _XmAppLock(app); /* Count number of arg (arg in this case means number of arg groups) */ Va_start(var,callback); _XmCountVaList(var, &button_count, &args_count, &typed_count, &total_count); va_end(var); /* Convert into a normal ArgList */ Va_start(var,callback); num_args = args_count + (XMBUTTONS_ARGS_PER_LIST + PU_EXTRA_ARGS); _XmVaProcessEverything(parent, var, &popupMenuButtonTypes, &popupMenuStrings, &popupMenuMnemonics, &popupMenuAccelerators, &popupMenuAcceleratorText, button_count, &args, num_args); n = args_count; XtSetArg (args[n], XmNsimpleCallback, callback); n++; XtSetArg (args[n], XmNbuttonCount, button_count); n++; XtSetArg (args[n], XmNbuttonType, popupMenuButtonTypes); n++; XtSetArg (args[n], XmNbuttons, popupMenuStrings); n++; XtSetArg (args[n], XmNbuttonMnemonics, popupMenuMnemonics); n++; XtSetArg (args[n], XmNbuttonAccelerators, popupMenuAccelerators); n++; XtSetArg (args[n], XmNbuttonAcceleratorText, popupMenuAcceleratorText); n++; widget = XmCreateSimplePopupMenu(parent, name, args, n); if (args != NULL) { XtFree((char *)args); } if (popupMenuButtonTypes != NULL) { XtFree((char *)popupMenuButtonTypes); } if (popupMenuStrings != NULL) { XtFree((char *)popupMenuStrings); } if (popupMenuMnemonics != NULL) { XtFree((char *)popupMenuMnemonics); } if (popupMenuAccelerators != NULL) { XtFree((char *)popupMenuAccelerators); } if (popupMenuAcceleratorText != NULL) { XtFree((char *)popupMenuAcceleratorText); } va_end(var); _XmAppUnlock(app); return (widget); } Widget XmVaCreateSimpleOptionMenu(Widget parent, String name, XmString option_label, KeySym option_mnemonic, int button_set, XtCallbackProc callback, ...) { #define OM_EXTRA_ARGS 5 va_list var; register Widget widget; Arg *args; int button_count, args_count, typed_count, total_count; int n, num_args; XmButtonTypeTable optionMenuButtonTypes; XmStringTable optionMenuStrings; XmKeySymTable optionMenuMnemonics; String * optionMenuAccelerators; XmStringTable optionMenuAcceleratorText; _XmWidgetToAppContext(parent); _XmAppLock(app); /* Count number of arg (arg in this case means number of arg groups) */ Va_start(var,callback); _XmCountVaList(var, &button_count, &args_count, &typed_count, &total_count); va_end(var); /* Convert into a normal ArgList */ Va_start(var,callback); num_args = args_count + (XMBUTTONS_ARGS_PER_LIST + OM_EXTRA_ARGS); _XmVaProcessEverything(parent, var, &optionMenuButtonTypes, &optionMenuStrings, &optionMenuMnemonics, &optionMenuAccelerators, &optionMenuAcceleratorText, button_count, &args, num_args); n = args_count; XtSetArg (args[n], XmNsimpleCallback, callback); n++; XtSetArg (args[n], XmNoptionLabel, option_label); n++; XtSetArg (args[n], XmNoptionMnemonic, option_mnemonic); n++; XtSetArg (args[n], XmNbuttonSet, button_set); n++; XtSetArg (args[n], XmNbuttonCount, button_count); n++; XtSetArg (args[n], XmNbuttonType, optionMenuButtonTypes); n++; XtSetArg (args[n], XmNbuttons, optionMenuStrings); n++; XtSetArg (args[n], XmNbuttonMnemonics, optionMenuMnemonics); n++; XtSetArg (args[n], XmNbuttonAccelerators, optionMenuAccelerators); n++; XtSetArg (args[n], XmNbuttonAcceleratorText, optionMenuAcceleratorText); n++; widget = XmCreateSimpleOptionMenu(parent, name, args, n); if (args != NULL) { XtFree((char *)args); } if (optionMenuButtonTypes != NULL) { XtFree((char *)optionMenuButtonTypes); } if (optionMenuStrings != NULL) { XtFree((char *)optionMenuStrings); } if (optionMenuMnemonics != NULL) { XtFree((char *)optionMenuMnemonics); } if (optionMenuAccelerators != NULL) { XtFree((char *)optionMenuAccelerators); } if (optionMenuAcceleratorText != NULL) { XtFree((char *)optionMenuAcceleratorText); } va_end(var); _XmAppUnlock(app); return (widget); } Widget XmVaCreateSimpleRadioBox(Widget parent, String name, int button_set, XtCallbackProc callback, ...) { #define RB_EXTRA_ARGS 3 va_list var; register Widget widget; Arg *args; int button_count, args_count, typed_count, total_count; int n, num_args; XmButtonTypeTable radioBoxButtonTypes; XmStringTable radioBoxStrings; XmKeySymTable radioBoxMnemonics; String * radioBoxAccelerators; XmStringTable radioBoxAcceleratorText; _XmWidgetToAppContext(parent); _XmAppLock(app); /* Count number of arg (arg in this case means number of arg groups) */ Va_start(var,callback); _XmCountVaList(var, &button_count, &args_count, &typed_count, &total_count); va_end(var); /* Convert into a normal ArgList */ Va_start(var,callback); num_args = args_count + (XMBUTTONS_ARGS_PER_LIST + RB_EXTRA_ARGS); _XmVaProcessEverything(parent, var, &radioBoxButtonTypes, &radioBoxStrings, &radioBoxMnemonics, &radioBoxAccelerators, &radioBoxAcceleratorText, button_count, &args, num_args); n = args_count; XtSetArg (args[n], XmNsimpleCallback, callback); n++; XtSetArg (args[n], XmNbuttonSet, button_set); n++; XtSetArg (args[n], XmNbuttonCount, button_count); n++; XtSetArg (args[n], XmNbuttonType, radioBoxButtonTypes); n++; XtSetArg (args[n], XmNbuttons, radioBoxStrings); n++; XtSetArg (args[n], XmNbuttonMnemonics, radioBoxMnemonics); n++; XtSetArg (args[n], XmNbuttonAccelerators, radioBoxAccelerators); n++; XtSetArg (args[n], XmNbuttonAcceleratorText, radioBoxAcceleratorText); n++; widget = XmCreateSimpleRadioBox(parent, name, args, n); if (args != NULL) { XtFree((char *)args); } if (radioBoxButtonTypes != NULL) { XtFree((char *)radioBoxButtonTypes); } if (radioBoxStrings != NULL) { XtFree((char *)radioBoxStrings); } if (radioBoxMnemonics != NULL) { XtFree((char *)radioBoxMnemonics); } if (radioBoxAccelerators != NULL) { XtFree((char *)radioBoxAccelerators); } if (radioBoxAcceleratorText != NULL) { XtFree((char *)radioBoxAcceleratorText); } va_end(var); _XmAppUnlock(app); return (widget); } Widget XmVaCreateSimpleCheckBox(Widget parent, String name, XtCallbackProc callback, ...) { #define CB_EXTRA_ARGS 2 va_list var; register Widget widget; Arg *args; int button_count, args_count, typed_count, total_count; int n, num_args; XmButtonTypeTable checkBoxButtonTypes; XmStringTable checkBoxStrings; XmKeySymTable checkBoxMnemonics; String * checkBoxAccelerators; XmStringTable checkBoxAcceleratorText; _XmWidgetToAppContext(parent); _XmAppLock(app); /* Count number of arg (arg in this case means number of arg groups) */ Va_start(var,callback); _XmCountVaList(var, &button_count, &args_count, &typed_count, &total_count); va_end(var); /* Convert into a normal ArgList */ Va_start(var,callback); num_args = args_count + (XMBUTTONS_ARGS_PER_LIST + CB_EXTRA_ARGS); _XmVaProcessEverything(parent, var, &checkBoxButtonTypes, &checkBoxStrings, &checkBoxMnemonics, &checkBoxAccelerators, &checkBoxAcceleratorText, button_count, &args, num_args); n = args_count; XtSetArg (args[n], XmNsimpleCallback, callback); n++; XtSetArg (args[n], XmNbuttonCount, button_count); n++; XtSetArg (args[n], XmNbuttonType, checkBoxButtonTypes); n++; XtSetArg (args[n], XmNbuttons, checkBoxStrings); n++; XtSetArg (args[n], XmNbuttonMnemonics, checkBoxMnemonics); n++; XtSetArg (args[n], XmNbuttonAccelerators, checkBoxAccelerators); n++; XtSetArg (args[n], XmNbuttonAcceleratorText, checkBoxAcceleratorText); n++; widget = XmCreateSimpleCheckBox(parent, name, args, n); if (args != NULL) { XtFree((char *)args); } if (checkBoxButtonTypes != NULL) { XtFree((char *)checkBoxButtonTypes); } if (checkBoxStrings != NULL) { XtFree((char *)checkBoxStrings); } if (checkBoxMnemonics != NULL) { XtFree((char *)checkBoxMnemonics); } if (checkBoxAccelerators != NULL) { XtFree((char *)checkBoxAccelerators); } if (checkBoxAcceleratorText != NULL) { XtFree((char *)checkBoxAcceleratorText); } va_end(var); _XmAppUnlock(app); return (widget); } /* * Function: XmeVLCreateWidget * * Description: Creates a widget of WidgetClass wc using a va_list of * arguments. Intended for generic use in Widget convience * functions. Intended for use by future widget writers * subclassing widgets. * * Input: name - The widget name * WidgetClass - The class of the widget * parent - a widget that is a parent * managed - if True the widget will be managed, if false it will not * al - a variable argument list of type va_list from stdarg.h * count - an integer value indicating the number of things in al * Output: * a returned widget if one can be created, NULL on error. */ Widget XmeVLCreateWidget( char *name, WidgetClass wc, Widget parent, Boolean managed, va_list al, int count) { Widget w; ArgList args; int n; String attr; _XmWidgetToAppContext(parent); _XmAppLock(app); /* The size as specified from count */ args = (ArgList)XtMalloc(count * sizeof(Arg)); /* * go through each element and copy the name and the value * (remember the value might be a pointer) to the value field */ for (attr = va_arg(al, String), n = 0; attr != NULL; attr = va_arg(al, String), n++) { args[n].name = attr; args[n].value = va_arg(al, XtArgVal); } va_end(al); /* Create the widget managed or not */ if (managed)w = XtCreateManagedWidget(name, wc, parent, args, n); else w = XtCreateWidget(name, wc, parent, args, n); /* * Just free the arg list, not the values in it, that is taken care * of elseware */ XtFree((char *)args); _XmAppUnlock(app); return(w); }