home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / lib / Xt / VarGet.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-13  |  8.2 KB  |  309 lines
  1. /* $XConsortium: VarGet.c,v 1.17 91/06/13 18:07:07 converse Exp $ */
  2. /*
  3.  
  4. Copyright 1985, 1986, 1987, 1988, 1989 by the
  5. Massachusetts Institute of Technology
  6.  
  7. Permission to use, copy, modify, and distribute this
  8. software and its documentation for any purpose and without
  9. fee is hereby granted, provided that the above copyright
  10. notice appear in all copies and that both that copyright
  11. notice and this permission notice appear in supporting
  12. documentation, and that the name of M.I.T. not be used in
  13. advertising or publicity pertaining to distribution of the
  14. software without specific, written prior permission.
  15. M.I.T. makes no representations about the suitability of
  16. this software for any purpose.  It is provided "as is"
  17. without express or implied warranty.
  18.  
  19. */
  20.  
  21. #include "IntrinsicI.h"
  22. #include "VarargsI.h"
  23. #include "StringDefs.h"
  24.  
  25. static String XtNxtGetTypedArg = "xtGetTypedArg";
  26.  
  27. #if NeedVarargsPrototypes
  28. void
  29. XtVaGetSubresources(
  30.     Widget widget,
  31.     XtPointer base,
  32.     _Xconst char* name,
  33.     _Xconst char* class,
  34.     XtResourceList resources,
  35.     Cardinal num_resources,
  36.     ...)
  37. #else
  38. /*VARARGS6*/
  39. void XtVaGetSubresources(widget, base, name, class, resources, num_resources, va_alist)
  40.     Widget widget;
  41.     XtPointer base;
  42.     String name;
  43.     String class;
  44.     XtResourceList resources;
  45.     Cardinal num_resources;
  46.     va_dcl
  47. #endif
  48. {
  49.     va_list                 var;
  50.     ArgList                 args;
  51.     Cardinal                num_args;
  52.     int                total_count, typed_count;
  53.  
  54.     Va_start(var, num_resources);
  55.     _XtCountVaList(var, &total_count, &typed_count);
  56.     va_end(var);
  57.      
  58.     Va_start(var, num_resources);
  59.           
  60.     _XtVaToArgList(widget, var, total_count, &args, &num_args);
  61.  
  62.     XtGetSubresources(widget, base, name, class, resources, num_resources, 
  63.     args, num_args);
  64.  
  65.     if (num_args != 0) {
  66.     XtFree((XtPointer)args);
  67.     }    
  68.  
  69.     va_end(var);
  70. }
  71.  
  72.  
  73. #if NeedVarargsPrototypes
  74. void
  75. XtVaGetApplicationResources(Widget widget, XtPointer base, XtResourceList resources, Cardinal num_resources, ...)
  76. #else
  77. /*VARARGS4*/
  78. void XtVaGetApplicationResources(widget, base, resources, num_resources, va_alist)
  79.     Widget widget;
  80.     XtPointer base;
  81.     XtResourceList resources;
  82.     Cardinal num_resources;
  83.     va_dcl
  84. #endif
  85. {
  86.     va_list                 var;
  87.     ArgList                 args; 
  88.     Cardinal                num_args; 
  89.     int                total_count, typed_count;
  90.  
  91.     Va_start(var,num_resources);
  92.     _XtCountVaList(var, &total_count, &typed_count);
  93.     va_end(var);
  94.     
  95.     Va_start(var,num_resources); 
  96.  
  97.     _XtVaToArgList(widget, var, total_count, &args, &num_args);
  98.                                 
  99.     XtGetApplicationResources(widget, base, resources, num_resources, 
  100.     args, num_args); 
  101.  
  102.     if (num_args != 0) {
  103.     XtFree((XtPointer)args);
  104.     }    
  105.  
  106.     va_end(var);         
  107. } 
  108.  
  109.  
  110. static void
  111. _XtGetTypedArg(widget, typed_arg, resources, num_resources)
  112.     Widget              widget;
  113.     XtTypedArgList    typed_arg;
  114.     XtResourceList      resources;
  115.     Cardinal            num_resources;
  116. {
  117.     String              from_type = NULL;
  118.     Cardinal        from_size = 0;
  119.     XrmValue            from_val, to_val;
  120.     register int        i;
  121.     Arg            arg;
  122.     XtPointer        value;
  123.  
  124.     /* note we presume that the XtResourceList to be un-compiled */
  125.  
  126.     for (i = 0; i < num_resources; i++) {
  127.         if (StringToName(typed_arg->name) == StringToName(resources[i].resource_name)) {
  128.             from_type = resources[i].resource_type;
  129.         from_size = resources[i].resource_size;
  130.             break;
  131.         }
  132.     }    
  133.  
  134.     if (i == num_resources) {
  135.     XtAppWarningMsg(XtWidgetToApplicationContext(widget),
  136.             "unknownType", XtNxtGetTypedArg, XtCXtToolkitError,
  137.             "Unable to find type of resource for conversion",
  138.             (String *)NULL, (Cardinal *)NULL);
  139.      return;
  140.     }
  141.  
  142.     value = ALLOCATE_LOCAL(from_size);
  143.     if (value == NULL) _XtAllocError(NULL);
  144.     XtSetArg(arg, typed_arg->name, value);
  145.     XtGetValues(widget, &arg, 1);
  146.  
  147.     from_val.size = from_size;
  148.     from_val.addr = (XPointer)value;
  149.     to_val.addr = (XPointer)typed_arg->value;
  150.     to_val.size = typed_arg->size;
  151.  
  152.     if (!XtConvertAndStore(widget, from_type, &from_val,
  153.                typed_arg->type, &to_val)) {
  154.     if (to_val.size > typed_arg->size) {
  155.         String params[2];
  156.         Cardinal num_params = 2;
  157.         params[0] = typed_arg->type;
  158.         params[1] = XtName(widget);
  159.         XtAppWarningMsg(XtWidgetToApplicationContext(widget),
  160.         "insufficientSpace", XtNxtGetTypedArg, XtCXtToolkitError,
  161.         "Insufficient space for converted type '%s' in widget '%s'",
  162.         params, &num_params);
  163.     }
  164.     else {
  165.         String params[3];
  166.         Cardinal num_params = 3;
  167.         params[0] = from_type;
  168.         params[1] = typed_arg->type;
  169.         params[2] = XtName(widget);
  170.         XtAppWarningMsg(XtWidgetToApplicationContext(widget),
  171.         "conversionFailed", XtNxtGetTypedArg, XtCXtToolkitError,
  172.         "Type conversion (%s to %s) failed for widget '%s'",
  173.         params, &num_params);
  174.     }
  175.     }
  176.     DEALLOCATE_LOCAL(value);
  177. }
  178.  
  179. static int
  180. _XtGetNestedArg(widget, avlist, args, resources, num_resources)
  181.     Widget              widget;
  182.     XtTypedArgList    avlist;
  183.     ArgList             args;
  184.     XtResourceList      resources;
  185.     Cardinal            num_resources;
  186. {
  187.     int         count = 0;
  188.  
  189.     for (; avlist->name != NULL; avlist++) {
  190.         if (avlist->type != NULL) {
  191.         _XtGetTypedArg(widget, avlist, resources, num_resources);
  192.         } else if(strcmp(avlist->name, XtVaNestedList) == 0) {
  193.             count += _XtGetNestedArg(widget, (XtTypedArgList)avlist->value,
  194.                      args, resources, num_resources);
  195.         } else {
  196.             (args+count)->name = avlist->name;
  197.             (args+count)->value = avlist->value;
  198.             ++count;
  199.         }
  200.     }   
  201.  
  202.     return(count);
  203. }
  204.  
  205. #if NeedVarargsPrototypes
  206. void
  207. XtVaGetValues(Widget widget, ...)
  208. #else
  209. /*VARARGS1*/
  210. void XtVaGetValues(widget, va_alist)
  211.     Widget widget;
  212.     va_dcl
  213. #endif
  214. {
  215.     va_list        var;
  216.     String          attr;
  217.     ArgList            args;
  218.     XtTypedArg        typed_arg;
  219.     XtResourceList      resources = (XtResourceList)NULL;
  220.     Cardinal            num_resources;
  221.     int            count, total_count, typed_count;
  222.  
  223.     Va_start(var,widget);
  224.  
  225.     _XtCountVaList(var, &total_count, &typed_count);
  226.  
  227.     if (total_count != typed_count) {
  228.         args = (ArgList)XtMalloc((unsigned)((total_count - typed_count) 
  229.                 * sizeof(Arg)));
  230.     }
  231.     else args = NULL;        /* for lint; really unused */
  232.     va_end(var);
  233.  
  234.     Va_start(var,widget);
  235.     for(attr = va_arg(var, String), count = 0 ; attr != NULL;
  236.             attr = va_arg(var, String)) {
  237.     if (strcmp(attr, XtVaTypedArg) == 0) {
  238.         typed_arg.name = va_arg(var, String);
  239.         typed_arg.type = va_arg(var, String);
  240.         typed_arg.value = va_arg(var, XtArgVal);
  241.         typed_arg.size = va_arg(var, int);
  242.  
  243.         if (resources == NULL) {
  244.         XtGetResourceList(XtClass(widget), &resources,&num_resources);
  245.         }
  246.  
  247.         _XtGetTypedArg(widget, &typed_arg, resources, num_resources);
  248.     } else if (strcmp(attr, XtVaNestedList) == 0) {
  249.         if (resources == NULL) {
  250.         XtGetResourceList(XtClass(widget),&resources, &num_resources);
  251.         }
  252.  
  253.         count += _XtGetNestedArg(widget, va_arg(var, XtTypedArgList),
  254.                      (args+count), resources, num_resources);
  255.     } else {
  256.         args[count].name = attr;
  257.         args[count].value = va_arg(var, XtArgVal);
  258.         count ++;
  259.     }
  260.     }
  261.     va_end(var);
  262.  
  263.     if (resources != (XtResourceList)NULL) { 
  264.     XtFree((XtPointer)resources); 
  265.     }
  266.  
  267.     if (total_count != typed_count) {
  268.     XtGetValues(widget, args, count);
  269.     XtFree((XtPointer)args);
  270.     }
  271. }
  272.  
  273. #if NeedVarargsPrototypes
  274. void
  275. XtVaGetSubvalues(XtPointer base,XtResourceList  resources, Cardinal num_resources, ...)
  276. #else
  277. /*VARARGS3*/
  278. void XtVaGetSubvalues(base, resources, num_resources, va_alist)
  279.     XtPointer base;
  280.     XtResourceList  resources;
  281.     Cardinal num_resources;
  282.     va_dcl
  283. #endif
  284. {
  285.     va_list    var;
  286.     ArgList        args;
  287.     Cardinal       num_args;
  288.     int        total_count, typed_count;        
  289.  
  290.     Va_start(var,num_resources);
  291.  
  292.     _XtCountVaList(var, &total_count, &typed_count);
  293.  
  294.     if (typed_count != 0) {
  295.     XtWarning("XtVaTypedArg is an invalid argument to XtVaGetSubvalues()\n");
  296.     }
  297.     va_end(var);
  298.  
  299.     Va_start(var,num_resources);
  300.     _XtVaToArgList((Widget)NULL, var, total_count, &args, &num_args);
  301.     va_end(var);
  302.  
  303.     XtGetSubvalues(base, resources, num_resources, args, num_args);
  304.  
  305.     if (num_args != 0) {
  306.         XtFree((XtPointer)args);
  307.     }    
  308. }
  309.