home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / tcl / tclmotif.1 / tclmotif / tm.1.2 / src / tmResources.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-03  |  27.8 KB  |  1,118 lines
  1.  
  2. /*
  3.  * TmResources.c --
  4.  *    This module contains the functions to implement resource
  5.  *    handling such as getValues, setValues, and resources
  6.  *
  7.  * Copyright 1993 Jan Newmarch, University of Canberra.
  8.  * Permission to use, copy, modify, and distribute this
  9.  * software and its documentation for any purpose and without
  10.  * fee is hereby granted, provided that the above copyright
  11.  * notice appear in all copies.  The author
  12.  * makes no representations about the suitability of this
  13.  * software for any purpose.  It is provided "as is" without
  14.  * express or implied warranty.
  15.  */
  16.  
  17. #include "tm.h"
  18. #include "tmFuncs.h"
  19. #include <Xm/Xm.h>
  20. #include <Xm/List.h>
  21. #include <Xm/Text.h>
  22.  
  23. /* this is a hack because some converters need info about what
  24.    types they are converting, and Xt does not give such info.
  25.    So we need to place this in globals before calling converters.
  26.    This is to replace the earlier, worse, Tm_MaybeSetTableSize
  27.  */
  28. char *Tm_Resource = NULL;
  29.  
  30.  
  31. /*
  32.  *--------------------------------------------------------------
  33.  *
  34.  * CopyToArgs --
  35.  *
  36.  *    copy to arg of correct size
  37.  *    borrowed from _XtCopyToArgs from Xt lib
  38.  *
  39.  * Results:
  40.  *
  41.  *    new value (of whatever type) stored in dst
  42.  *
  43.  * Side effects:
  44.  *
  45.  *--------------------------------------------------------------
  46.  */
  47. static void 
  48. CopyToArg(src, dst, size)
  49.     char* src;
  50.     XtArgVal *dst;
  51.     register unsigned int size;
  52. {
  53.     if (! (*dst)) {
  54.         if      (size == sizeof(long))     *dst = (XtArgVal)*(long*)src;
  55.         else if (size == sizeof(short))    *dst = (XtArgVal)*(short*)src;
  56.         else if (size == sizeof(char))     *dst = (XtArgVal)*(char*)src;
  57.         else if (size == sizeof(XtPointer)) *dst = (XtArgVal)*(XtPointer*)src;
  58.         else if (size == sizeof(char*))    *dst = (XtArgVal)*(char**)src;
  59.         else if (size == sizeof(XtArgVal)) *dst = *(XtArgVal*)src;
  60.         else bcopy((char*)src, (char*)dst, (int)size);
  61.     }
  62. } 
  63.  
  64. /*
  65.  *--------------------------------------------------------------
  66.  *
  67.  * These functions are all to handle resources that got created
  68.  * and need to be reclaimed
  69.  *
  70.  *--------------------------------------------------------------
  71.  */
  72.  
  73. static Tm_FreeResourceType *Tm_FreeResources = NULL;
  74. static int Tm_FreeResourcesCount;
  75. static int Tm_MaxFreeResourcesCount;
  76.  
  77. typedef struct Tm_FreeResourceStackElmt {
  78.     Tm_FreeResourceType *freeResources;
  79.     int            freeResourcesCount;
  80.     int         maxFreeResourcesCount;
  81. } Tm_FreeResourceStackElmt;
  82.  
  83. static int Tm_FreeResourceStackDepth = 0;
  84. static Tm_FreeResourceStackElmt *Tm_FreeResourceStack = NULL;
  85.  
  86. /*
  87.  *--------------------------------------------------------------
  88.  *
  89.  * Tm_InitFreeResourceList
  90.  *
  91.  *    initialise the list of resources for which space must
  92.  *    be reclaimed after XtSet/GetValues
  93.  *
  94.  *    to allow this to be reentrant, place old entries on stack
  95.  *
  96.  *--------------------------------------------------------------
  97.  */
  98. void Tm_InitFreeResourceList(size)
  99.     int size;
  100. {
  101.  
  102.     /* store any old values if there were any */
  103.     if (Tm_FreeResourceStackDepth > 0) {
  104.     Tm_FreeResourceStack = (Tm_FreeResourceStackElmt *)
  105.         XtRealloc((char *)Tm_FreeResourceStack,
  106.             Tm_FreeResourceStackDepth * 
  107.             sizeof(Tm_FreeResourceStackElmt));
  108.     Tm_FreeResourceStack[Tm_FreeResourceStackDepth - 1].freeResources = 
  109.                 Tm_FreeResources;
  110.     Tm_FreeResourceStack[Tm_FreeResourceStackDepth - 1].freeResourcesCount =
  111.                 Tm_FreeResourcesCount;
  112.     Tm_FreeResourceStack[Tm_FreeResourceStackDepth - 1].maxFreeResourcesCount =
  113.                 Tm_MaxFreeResourcesCount;
  114.  
  115.     }
  116.     Tm_FreeResourceStackDepth++;
  117.  
  118.     if (size <= 0)
  119.     size = 1;
  120.     Tm_FreeResources = (Tm_FreeResourceType *)
  121.             XtMalloc(size * sizeof(Tm_FreeResourceType));
  122.     Tm_FreeResourcesCount = 0;
  123.     Tm_MaxFreeResourcesCount = size;
  124. }
  125.  
  126.  
  127. /*
  128.  *--------------------------------------------------------------
  129.  *
  130.  *  Tm_AddToFreeResourceList
  131.  *
  132.  *    add some data and its corresponding free proc to the list
  133.  *
  134.  *--------------------------------------------------------------
  135.  */
  136. void  Tm_AddToFreeResourceList(data, free)
  137.     char *data;
  138.     Tm_FreeProc free;
  139. {
  140.     /* we only setup the list for adding during a Tm_Set/GetValues
  141.        sequence. We init at the start and free at the end. This
  142.        func gets called by various resource converters. However,
  143.        Motif (or someone else) may be calling our converter outside
  144.        of the Tm_Get/SetValues. We have to assume that they are doing
  145.        their own garbage collect, so need to make sure that we don't
  146.        add for their calls
  147.      */
  148.     if (Tm_FreeResources == NULL)
  149.     return;
  150.  
  151.     /* things like XmStringTables may add many elmts. Grow if needed */
  152.     if (Tm_FreeResourcesCount >= Tm_MaxFreeResourcesCount) {
  153.     Tm_MaxFreeResourcesCount *= 2;
  154.     Tm_FreeResources = (Tm_FreeResourceType *) 
  155.                 XtRealloc((char *)Tm_FreeResources,
  156.                     Tm_MaxFreeResourcesCount * 
  157.                     sizeof(Tm_FreeResourceType));
  158.     }
  159.     Tm_FreeResources[Tm_FreeResourcesCount].data = data;
  160.     Tm_FreeResources[Tm_FreeResourcesCount++].free = free;
  161. }
  162.  
  163.  
  164. /*
  165.  *--------------------------------------------------------------
  166.  * Tm_FreeResourceList
  167.  *
  168.  *    call the free proc on each data elmt of the list
  169.  *
  170.  *--------------------------------------------------------------
  171.  */
  172. void Tm_FreeResourceList()
  173. {
  174.     int n;
  175.     char *data;
  176.     Tm_FreeProc free;
  177.  
  178.     for (n = 0; n < Tm_FreeResourcesCount; n++) {
  179.     free =  Tm_FreeResources[n].free;
  180.     data = Tm_FreeResources[n].data;
  181.     (free) (data);
  182.     }
  183.     XtFree((char *) Tm_FreeResources);
  184.     Tm_FreeResources = NULL;
  185.  
  186.     Tm_FreeResourceStackDepth--;
  187.     if (Tm_FreeResourceStackDepth < 1)
  188.     return;
  189.  
  190.     /* nested calls to Tm_InitFreeResourceList are unwinding - 
  191.        restore values from the stack
  192.      */
  193.     Tm_FreeResources =
  194.         Tm_FreeResourceStack[Tm_FreeResourceStackDepth - 1].freeResources;
  195.     Tm_FreeResourcesCount =
  196.         Tm_FreeResourceStack[Tm_FreeResourceStackDepth - 1].freeResourcesCount;
  197.     Tm_MaxFreeResourcesCount =
  198.         Tm_FreeResourceStack[Tm_FreeResourceStackDepth - 1].maxFreeResourcesCount;
  199. }
  200.  
  201. /*
  202.  *--------------------------------------------------------------
  203.  *
  204.  * Tm_ConvertValue --
  205.  *
  206.  *    convert a value from one format to another
  207.  *
  208.  * Results:
  209.  *
  210.  *    new value (of whatever type) stored in "new_value"
  211.  *
  212.  * Side effects:
  213.  *
  214.  *--------------------------------------------------------------
  215.  */
  216.  
  217. Boolean
  218. Tm_ConvertValue(w, fromType, fromValue, fromSize,
  219.            toType, toValue, toSize)
  220.     Widget w;
  221.     char *fromType;
  222.     char *fromValue;
  223.     unsigned int fromSize;
  224.     char *toType;
  225.     XtArgVal *toValue;
  226.     unsigned int toSize;
  227. {
  228.     XrmValue from, to;
  229.  
  230.     if (strcmp(fromType, toType) == 0) {
  231.     *toValue = (XtArgVal) fromValue;
  232.     return TRUE;
  233.     }
  234.  
  235.     from.size = fromSize;
  236.     from.addr = fromValue;
  237.     to.size = toSize;
  238.     to.addr = XtMalloc(toSize);
  239. /*
  240.     to.addr = NULL;
  241. */
  242.  
  243.     if (!XtConvertAndStore(w, fromType, &from, toType, &to))  {
  244.     fprintf(stderr, "failed conversion %s to %s\n",
  245.                 fromType, toType);
  246.     return FALSE;
  247.     }
  248.     *toValue = 0;
  249.     CopyToArg(to.addr, toValue, to.size);
  250.     XtFree(to.addr);
  251.  
  252.     return TRUE;
  253. }
  254.  
  255. /*
  256.  *--------------------------------------------------------------
  257.  *
  258.  * Tm_ConvertValueFromString --
  259.  *
  260.  *    convert a value from its Tcl string format to the one
  261.  *    the widget wants.
  262.  *
  263.  * Results:
  264.  *
  265.  *    new value (of whatever type) stored in "new_value"
  266.  *
  267.  * Side effects:
  268.  *
  269.  *--------------------------------------------------------------
  270.  */
  271.  
  272. Boolean
  273. Tm_ConvertValueFromString(w, resources, num_resources,
  274.         resource, orig_value, new_value)
  275.     Widget w;
  276.     XtResourceList resources;
  277.     int num_resources;
  278.     char *resource;
  279.     char *orig_value;
  280.     XtArgVal *new_value;
  281. {
  282.     int n;
  283.     XrmValue from, converted;
  284.     XtArgVal tmpval;
  285.     Boolean result;
  286.  
  287. #   ifdef DEBUG
  288.     fprintf(stderr, "converting from string \"%s\" of type %s\n", orig_value, resource);
  289. #   endif
  290.  
  291.     for (n = 0; n < num_resources; n++) {
  292.     if (strcmp(resource, resources->resource_name) == 0) {
  293.         break;
  294.     }
  295.     resources++;
  296.     }
  297.     if (n == num_resources) {
  298.     return FALSE;
  299.     }
  300.  
  301.     /* we have a match - convert and install the resource */
  302.     Tm_Resource = resource;
  303.     result = Tm_ConvertValue(w, XtRString, orig_value,
  304.                 strlen(orig_value)+1,
  305.                 resources->resource_type,
  306.                 new_value,
  307.                 resources->resource_size);
  308.     return result;
  309. }
  310.  
  311. /*
  312.  *--------------------------------------------------------------
  313.  *
  314.  * Tm_ConvertValueFromStringQuark --
  315.  *
  316.  *    convert a value from its Tcl string format to the one
  317.  *    the widget wants. In this form the resources have been
  318.  *    quark'ed so we don't have string compares but int ones
  319.  *
  320.  * Results:
  321.  *
  322.  *    new value (of whatever type) stored in "new_value"
  323.  *
  324.  * Side effects:
  325.  *
  326.  *--------------------------------------------------------------
  327.  */
  328.  
  329. Boolean
  330. Tm_ConvertValueFromStringQuark(w, resources, num_resources,
  331.         resource, orig_value, new_value)
  332.     Widget w;
  333.     XtResourceList resources;
  334.     int num_resources;
  335.     char *resource;
  336.     char *orig_value;
  337.     XtArgVal *new_value;
  338. {
  339.     int n;
  340.     XrmValue from, converted;
  341.     XtArgVal tmpval;
  342.     int resourceQ;
  343.  
  344.     resourceQ = XrmStringToQuark(resource);
  345. #   ifdef DEBUG
  346.     fprintf(stderr, "converting from string \"%s\" of type %s\n",
  347.             orig_value, resource);
  348. #   endif
  349.     for (n = 0; n < num_resources; n++) {
  350.     if (resourceQ == (int) resources->resource_name) {
  351.         break;
  352.     }
  353.     resources++;
  354.     }
  355.     if (n == num_resources) {
  356.     return FALSE;
  357.     }
  358.  
  359.     /* we have a match - convert and install the resource */
  360.     /* special case - same type */
  361.     if (strcmp(XrmQuarkToString((int) resources->resource_type), XtRString) == 0) {
  362.     *new_value =  (XtArgVal) orig_value;
  363.     return TRUE;
  364.     }
  365.     from.size = strlen(orig_value) + 1;
  366.     from.addr = orig_value;
  367.     converted.size = resources->resource_size;
  368.     converted.addr = NULL;
  369.  
  370.     if (!XtConvertAndStore(w, XtRString, &from,
  371.         XrmQuarkToString((int) resources->resource_type), &converted)) {
  372.     return FALSE;
  373.     }
  374.     *new_value = 0;
  375.     CopyToArg(converted.addr, new_value, converted.size);
  376. /* for now
  377.     XtFree(converted.addr);
  378. */
  379. /*
  380.     bzero(new_value, sizeof(XtArgVal));
  381.     bcopy(converted.addr, new_value, converted.size);
  382.     *new_value = *(XtArgVal *) (converted.addr);
  383. */
  384.     
  385.     return TRUE;
  386. }
  387.         
  388.  
  389. /*
  390.  *--------------------------------------------------------------
  391.  *
  392.  * Tm_MaybeSetStringTableSize --
  393.  *
  394.  *    Hack for Motif XmStringTables.
  395.  *    Motif *sometimes* NULL terminates its XmStringTables
  396.  *    most times doesnt.
  397.  *    XmStringGet...() sometimes returns False on running off
  398.  *    the end of a table, sometimes crashes
  399.  *    _XmStringIsXmString() sometimes returns False on running off
  400.  *    the end of a table, sometimes crashes
  401.  *    i.e. there is no internal way of finding the size of one
  402.  *    of these things. So we have to check if we have one and
  403.  *    then look up the resource that tells us the size :-(
  404.  *
  405.  * Results:
  406.  *
  407.  * Side effects:
  408.  *
  409.  *    Sets global vbl Tm_XmStringTableSize
  410.  *--------------------------------------------------------------
  411.  */
  412.  
  413. static void
  414. Tm_MaybeSetStringTableSize(w, resource)
  415.     Widget w;
  416.     String resource;
  417. {
  418.     extern int Tm_XmStringTableSize;
  419.     WidgetClass class;
  420.     Arg arg;
  421.     char *size_resource;
  422.  
  423. #if 0
  424.     class = XtClass(w);
  425.     if (class == xmListWidgetClass) {
  426.     if (strcmp (resource, XmNitems) == 0) {
  427.         size_resource = XmNitemCount;
  428.     } else
  429.     if (strcmp (resource, XmNselectedItems) == 0) {
  430.         size_resource = XmNselectedItemCount;
  431.     } else
  432.     return;
  433.     } else
  434.     return;
  435.  
  436.     /* Sigh, we have a StringTable, find its size */
  437.     XtSetArg(arg, size_resource, &Tm_XmStringTableSize);
  438.     XtGetValues(w, &arg, 1);
  439. #endif
  440. }
  441.  
  442. /*
  443.  *--------------------------------------------------------------
  444.  *
  445.  * Tm_CovertResourceToString --
  446.  *    convert a single resource to a string
  447.  *
  448.  * Results:
  449.  *
  450.  * Side effects:
  451.  *
  452.  *--------------------------------------------------------------
  453.  */
  454.  
  455. Boolean
  456. Tm_ConvertResourceToString(w, resource, resource_size, resource_type, value)
  457.     Widget w;
  458.     char *resource;
  459.     Cardinal resource_size;
  460.     String resource_type;
  461.     char **value;
  462. {
  463.     XrmValue from, converted;
  464.     Arg args[1];
  465.  
  466.     Tm_MaybeSetStringTableSize(w, resource);
  467.  
  468.     from.size = resource_size;
  469.     from.addr = (XtPointer) XtMalloc(from.size);
  470.     XtSetArg(args[0], resource, from.addr);
  471.     XtGetValues(w, args, 1);
  472.     
  473.     /* special case - same type */
  474.     if (strcmp(resource_type, XtRString) == 0) {
  475.     *value =  XtNewString(*(char **) from.addr);
  476.     /* check if it is Text's value */
  477.     if (XtIsSubclass(w, xmTextWidgetClass) &&
  478.         strcmp(resource, XmNvalue) == 0)  {
  479.         XtFree(*(char **) from.addr);
  480.     }
  481.     XtFree(from.addr);
  482.  
  483.     /* allow this to be gc later */
  484.     Tm_AddToFreeResourceList(*value, (Tm_FreeProc) XtFree);
  485.  
  486.     return TRUE;
  487.     }
  488.  
  489.     converted.addr = NULL;
  490.     if (!XtConvertAndStore(w, resource_type, &from,
  491.             XtRString, &converted)) {
  492.     XtFree(from.addr);
  493.     return FALSE;
  494.     }
  495.     bzero(value, sizeof(XtArgVal));
  496.     bcopy(converted.addr, value, converted.size);
  497.     
  498.     XtFree(from.addr);
  499.     return TRUE;
  500. }
  501.  
  502. /*
  503.  *--------------------------------------------------------------
  504.  *
  505.  * Tm_ConvertValueToString --
  506.  *
  507.  *    converts from the internal widget form to a string for Tcl
  508.  *
  509.  * Results:
  510.  *
  511.  * Side effects:
  512.  *
  513.  *--------------------------------------------------------------
  514.  */
  515.  
  516. Boolean
  517. Tm_ConvertValueToString(w, resources, num_resources,
  518.         resource, new_value)
  519.     Widget w;
  520.     XtResourceList resources;
  521.     int num_resources;
  522.     char *resource;
  523.     char **new_value;
  524. {
  525.     int n;
  526.  
  527.     for (n = 0; n < num_resources; n++) {
  528.     if (strcmp(resource, resources->resource_name) == 0) {
  529.         break;
  530.     }
  531.     resources++;
  532.     }
  533.     if (n == num_resources) {
  534.     return FALSE;
  535.     }
  536.  
  537.     Tm_Resource = resource;
  538.     return Tm_ConvertResourceToString(w, resource,
  539.         resources->resource_size, resources->resource_type, new_value);
  540.  
  541. }
  542.         
  543. /*
  544.  *--------------------------------------------------------------
  545.  *
  546.  * Tm_ConvertSubValueFromString --
  547.  *
  548.  *    convert a value from its Tcl string format to the one
  549.  *    the widget wants.
  550.  *
  551.  * Results:
  552.  *
  553.  *    new value (of whatever type) stored in "new_value"
  554.  *
  555.  * Side effects:
  556.  *
  557.  *--------------------------------------------------------------
  558.  */
  559.  
  560. static Boolean
  561. Tm_ConvertSubValueFromString(w, sec_resources, num_sec_resources,
  562.         resource, orig_value, new_value)
  563.     Widget w;
  564.     XmSecondaryResourceData *sec_resources;
  565.     int num_sec_resources;
  566.     char *resource;
  567.     char *orig_value;
  568.     XtArgVal *new_value;
  569. {
  570.     int n, length;
  571.  
  572.     for (n = 0; n < num_sec_resources; n++) {
  573.            if (Tm_ConvertValueFromString(w, sec_resources[n]->resources, 
  574.             sec_resources[n]->num_resources, resource,
  575.                orig_value, new_value)) {
  576.         return True;
  577.     }
  578.     }
  579.     return False;
  580. }
  581.         
  582. /*
  583.  *--------------------------------------------------------------
  584.  *
  585.  * Tm_ConvertSubValueToString --
  586.  *
  587.  *    converts from the internal widget form to a string for Tcl
  588.  *
  589.  * Results:
  590.  *
  591.  * Side effects:
  592.  *
  593.  *--------------------------------------------------------------
  594.  */
  595.  
  596. static Boolean
  597. Tm_ConvertSubValueToString(w, sec_resources, num_sec_resources,
  598.         resource, new_value)
  599.     Widget w;
  600.     XmSecondaryResourceData *sec_resources;
  601.     int num_sec_resources;
  602.     char *resource;
  603.     char **new_value;
  604. {
  605.     int n, length;
  606.  
  607.     for (n = 0; n < num_sec_resources; n++) {
  608.            if (Tm_ConvertValueToString(w, sec_resources[n]->resources, 
  609.             sec_resources[n]->num_resources, resource,
  610.                new_value)) {
  611.         return True;
  612.     }
  613.     }
  614.     return False;
  615. }
  616.  
  617. /*
  618.  *--------------------------------------------------------------
  619.  *
  620.  * Tm_FreeSecondaryResources --
  621.  *
  622.  *    Motif gives us a copy of these, so we have to tidy up
  623.  *
  624.  * Results:
  625.  *
  626.  * Side effects:
  627.  *
  628.  *--------------------------------------------------------------
  629.  */
  630.  
  631. void
  632. Tm_FreeSecondaryResources(sec_resources, num_sec_resources)
  633.     XmSecondaryResourceData *sec_resources;
  634.     int num_sec_resources;
  635. {
  636.     int n;
  637.  
  638.     for (n = 0; n < num_sec_resources; n++) {
  639.     XtFree((char *) sec_resources[n]->resources);
  640.     XtFree((char *) sec_resources[n]);
  641.     }
  642.  
  643.     if (num_sec_resources > 0) {
  644.         XtFree((char *) sec_resources);
  645.     }
  646. }
  647.  
  648. /*
  649.  *--------------------------------------------------------------
  650.  *
  651.  * Tm_SetValues --
  652.  *
  653.  *    set resource values on a widget
  654.  *
  655.  * Results:
  656.  *     a tcl result
  657.  *
  658.  * Side effects:
  659.  *
  660.  *--------------------------------------------------------------
  661.  */
  662.  
  663. int
  664. Tm_SetValues(pathName, interp, w, parent, class, argv, argc, args, num_args)
  665.     char *pathName;
  666.     Tcl_Interp *interp;
  667.     Widget w;
  668.     Widget parent;
  669.     WidgetClass class;
  670.     char **argv;
  671.     int argc;
  672.     Arg args[];
  673.     int *num_args;
  674. {
  675.     XtResourceList resources, constraint_resources;
  676. #ifndef MOTIF11
  677.     XmSecondaryResourceData *sec_resources;
  678.     int num_sec_resources;
  679. #endif
  680.     Cardinal num_resources;
  681.     Cardinal num_constraint_resources;
  682.     int num_values = 0;
  683.     XrmValue from, converted;
  684.     XtArgVal new_value;
  685.     char *resource;
  686.     char *value;
  687.     Tm_ClientData *client_data;
  688.  
  689.     *num_args = 0;
  690.  
  691.     if (argc > TM_MAXARGS*2) {
  692.     return TCL_ERROR;
  693.     }
  694.  
  695.     XtGetResourceList(class, &resources, &num_resources);
  696. #ifndef MOTIF11
  697.     num_sec_resources = XmGetSecondaryResourceData(class, &sec_resources);
  698. #endif
  699.     if (parent != NULL && XtIsConstraint(parent)) {
  700.     XtGetConstraintResourceList(XtClass(parent), 
  701.         &constraint_resources, &num_constraint_resources);
  702.     } else {
  703.     num_constraint_resources = 0;
  704.     }
  705.  
  706.     while (argc >= 2) {
  707.     if (argv[0][0] != '-') {
  708.         sprintf(interp->result, "illegal setValues option \"%50s\"", argv[0]);
  709.         return TCL_ERROR;
  710.     }
  711.     resource = argv[0]+1;
  712.         value = argv[1];
  713.  
  714.         /* we cant allow callbacks to be converted - too messy */
  715.         if (strstr(resource, "Callback") != NULL) {
  716.         sprintf(interp->result, "setValues doesn't support callbacks.\
  717. Use \"%s\" method\n", resource);
  718.           return TCL_ERROR;
  719.         }
  720.  
  721.         if (Tm_ConvertValueFromString(w, resources, num_resources,
  722.         resource, value, &new_value)) {
  723.             XtSetArg(args[num_values], resource, new_value);
  724.         num_values++;
  725.     } else
  726.         if (num_constraint_resources > 0 &&
  727.         Tm_ConvertValueFromString(w, constraint_resources, 
  728.                 num_constraint_resources, resource,
  729.                 value, &new_value)) {
  730.             XtSetArg(args[num_values], resource, new_value);
  731.         num_values++;
  732.     } else 
  733. #ifndef MOTIF11
  734.         if (num_sec_resources > 0 &&
  735.         Tm_ConvertSubValueFromString(w, sec_resources, 
  736.                 num_sec_resources, resource,
  737.                 value, &new_value)) {
  738.             XtSetArg(args[num_values], resource, new_value);
  739.         num_values++;
  740.     } else
  741. #endif
  742.     {
  743.         sprintf(interp->result, "Conversion from String to \"%50s\" failed\n",
  744.                                 resource);
  745.         return TCL_ERROR;
  746.     }
  747.     argc -= 2;
  748.     argv += 2;
  749.     }
  750.  
  751. #ifndef MOTIF11
  752.     if (num_sec_resources > 0)
  753.     Tm_FreeSecondaryResources(sec_resources, num_sec_resources);
  754. #endif /* MOTIF11 */
  755.     if (num_resources > 0) 
  756.     XtFree((char *) resources);
  757.     if (num_constraint_resources > 0) 
  758.     XtFree((char *) constraint_resources);
  759.  
  760.     *num_args = num_values;
  761.     return TCL_OK;
  762. }
  763.  
  764. /*
  765.  *--------------------------------------------------------------
  766.  *
  767.  * Tm_GetValues --
  768.  *
  769.  *    get the resource values out of a widget
  770.  *
  771.  * Results:
  772.  *    a tcl result
  773.  *
  774.  * Side effects:
  775.  *
  776.  *--------------------------------------------------------------
  777.  */
  778.  
  779. int
  780. Tm_GetValues(pathName, interp, w, class, argv, argc)
  781.     char *pathName;
  782.     Tcl_Interp *interp;
  783.     Widget w;
  784.     WidgetClass class;
  785.     char **argv;
  786.     int argc;
  787. {
  788.     XtResourceList resources, constraint_resources;
  789. #ifndef MOTIF11
  790.     XmSecondaryResourceData *sec_resources;
  791.     int num_sec_resources;
  792. #endif
  793.     Cardinal num_resources;
  794.     Cardinal num_constraint_resources;
  795.     int num_values = 0;
  796.     XrmValue from, converted;
  797.     char *new_value;
  798. #   define MAXARGS 100
  799.     char *resource;
  800.     Tm_ClientData *client_data;
  801.     Widget parent;
  802.  
  803.     if (argc > MAXARGS*2) {
  804.     return TCL_ERROR;
  805.     }
  806.  
  807.     parent = XtParent(w);    /* this is NULL for w == "." */
  808.     XtGetResourceList(class, &resources, &num_resources);
  809.  
  810. #ifndef MOTIF11
  811.     num_sec_resources = XmGetSecondaryResourceData(class, &sec_resources);
  812. #endif
  813.   
  814.     if (parent != NULL && XtIsConstraint(parent)) {
  815.     XtGetConstraintResourceList(XtClass(parent), 
  816.         &constraint_resources, &num_constraint_resources);
  817.     } else {
  818.     num_constraint_resources = 0;
  819.     }
  820.  
  821.     while (argc >= 2) {
  822.     if (argv[0][0] != '-') {
  823.         sprintf(interp->result, "illegal setValues option \"%50s\"", argv[0]);
  824.         return TCL_ERROR;
  825.     }
  826.     resource = argv[0]+1;
  827.  
  828.         if (Tm_ConvertValueToString(w, resources, num_resources,
  829.         resource, &new_value)) {
  830.         /* store new_value in variable in argv[1] now */
  831. #        ifdef DEBUG
  832.         fprintf(stderr, "Got value: %s\n", (char *) new_value);
  833. #        endif
  834.         if (Tcl_SetVar(interp, argv[1], (char *) new_value,
  835.             TCL_LEAVE_ERR_MSG) == NULL)
  836.         fprintf(stderr, "%s\n", interp->result);
  837.     } else
  838.         if (num_constraint_resources > 0 &&
  839.         Tm_ConvertValueToString(w, constraint_resources, 
  840.                 num_constraint_resources, resource,
  841.                 &new_value)) {
  842.         /* store in a variable now */
  843.         if (Tcl_SetVar(interp, argv[1], (char *) new_value,
  844.             TCL_LEAVE_ERR_MSG) == NULL)
  845.         fprintf(stderr, "%s\n", interp->result);
  846.     } else 
  847. #ifndef MOTIF11
  848.         if (num_sec_resources > 0 &&
  849.         Tm_ConvertSubValueToString(w, sec_resources, 
  850.                 num_sec_resources, resource,
  851.                 &new_value)) {
  852.         /* store in a variable now */
  853.         if (Tcl_SetVar(interp, argv[1], (char *) new_value,
  854.             TCL_LEAVE_ERR_MSG) == NULL)
  855.         fprintf(stderr, "%s\n", interp->result);
  856.     } else
  857. #endif
  858.     {
  859.         sprintf(interp->result, "Conversion from %s to String failed\n",
  860.                     resource);
  861.         return TCL_ERROR;
  862.     }
  863.     argc -= 2;
  864.     argv += 2;
  865.     }
  866. #ifndef MOTIF11
  867.     if (num_sec_resources > 0)
  868.     Tm_FreeSecondaryResources(sec_resources, num_sec_resources);
  869. #endif
  870.     if (num_resources > 0) 
  871.     XtFree((char *) resources);
  872.     if (num_constraint_resources > 0) 
  873.     XtFree((char *) constraint_resources);
  874.     return TCL_OK;
  875. }
  876.  
  877. /*
  878.  *--------------------------------------------------------------
  879.  *
  880.  * Tm_ResourceInfo --
  881.  *
  882.  *    get the resource info out of a widget
  883.  *
  884.  * Results:
  885.  *    a tcl result
  886.  *
  887.  * Side effects:
  888.  *
  889.  *--------------------------------------------------------------
  890.  */
  891.  
  892. void
  893. Tm_GetResourceInfo(resourceInfo, w, resource)
  894.     Tcl_DString *resourceInfo;
  895.     Widget w;
  896.     XtResource *resource;
  897. {
  898.     char *resource_value;
  899.  
  900.     Tcl_DStringAppend(resourceInfo, "-", 1);
  901.     Tcl_DStringAppend(resourceInfo, resource->resource_name, -1);
  902.     Tcl_DStringAppendElement(resourceInfo, resource->resource_name);
  903.     Tcl_DStringAppendElement(resourceInfo, resource->resource_class);
  904.     Tcl_DStringAppendElement(resourceInfo, resource->resource_type);
  905.  
  906.     /* hack to let resource converter know what this is */
  907.     Tm_Resource = resource->resource_name;
  908.  
  909.     if (Tm_ConvertResourceToString(w, resource->resource_name,
  910.         resource->resource_size, resource->resource_type,
  911.         &resource_value)) {;
  912.         Tcl_DStringAppendElement(resourceInfo, resource_value);
  913.     } else {
  914.         Tcl_DStringAppendElement(resourceInfo, "");
  915.     }
  916. }
  917. /*
  918.  *--------------------------------------------------------------
  919.  *
  920.  * Tm_NoErrorMsg --
  921.  *
  922.  * Results:
  923.  *     none
  924.  *
  925.  * Side effects:
  926.  *    does nothing
  927.  *
  928.  *--------------------------------------------------------------
  929.  */
  930.  
  931. void
  932. Tm_NoErrorMsg(name, type, Class, defalt, params, num_params)
  933.     String name;
  934.     String type;
  935.     String Class;
  936.     String defalt;
  937.     String *params;
  938.     Cardinal *num_params;
  939. {
  940.     /* void */
  941. }
  942.  
  943.  
  944. /*
  945.  *--------------------------------------------------------------
  946.  *
  947.  * Tm_ResourceList --
  948.  *
  949.  *    get the resource list out of a widget
  950.  *
  951.  * Results:
  952.  *    a tcl result
  953.  *
  954.  * Side effects:
  955.  *
  956.  *--------------------------------------------------------------
  957.  */
  958.  
  959. int
  960. Tm_ResourceList(interp, w, class)
  961.     Tcl_Interp *interp;
  962.     Widget w;
  963.     WidgetClass class;
  964. {
  965.     XtResourceList resources, constraint_resources;
  966. #ifndef MOTIF11
  967.     XmSecondaryResourceData *sec_resources;
  968.     int num_sec_resources;
  969. #endif
  970.     Cardinal num_resources;
  971.     Cardinal num_constraint_resources;
  972.     int num_values = 0;
  973.     char *new_value;
  974.     char *resource;
  975.     Tm_ClientData *client_data;
  976.     Widget parent;
  977.     int m, n;
  978.     Tcl_DString resourceList, resourceInfo;
  979.     XtErrorHandler oldWarningHandler;
  980.  
  981.     parent = XtParent(w);    /* this is NULL for w == "." */
  982.     XtGetResourceList(class, &resources, &num_resources);
  983.  
  984. #ifndef MOTIF11
  985.     num_sec_resources = XmGetSecondaryResourceData(class, &sec_resources);
  986. #endif
  987.   
  988.     if (parent != NULL && XtIsConstraint(parent)) {
  989.     XtGetConstraintResourceList(XtClass(parent), 
  990.         &constraint_resources, &num_constraint_resources);
  991.     } else {
  992.     num_constraint_resources = 0;
  993.     }
  994.  
  995.     /* turn off error messages about converters that we don't support */
  996.     oldWarningHandler = XtAppSetWarningHandler(XtWidgetToApplicationContext(w), 
  997.                     Tm_NoErrorMsg);
  998.  
  999.     /* set up for garbage collect of resource values */
  1000.     Tm_InitFreeResourceList(128);
  1001.  
  1002.     Tcl_DStringInit(&resourceList);
  1003.  
  1004.     Tcl_DStringInit(&resourceInfo);
  1005.     for (n = 0; n < num_resources; n++) {
  1006.     Tm_GetResourceInfo(&resourceInfo, w, resources+n);
  1007.     /* hack to get string out of D-string */
  1008. /*
  1009.     Tcl_DStringResult(interp, &resourceInfo);
  1010.     Tcl_DStringAppendElement(&resourceList, interp->result);
  1011. */
  1012.  
  1013.     /* no, do it the proper way (accessing internals of DString :-(  ) */
  1014.     Tcl_DStringAppendElement(&resourceList, resourceInfo.string);
  1015.     Tcl_DStringFree(&resourceInfo);
  1016.     Tcl_DStringInit(&resourceInfo);
  1017.     }
  1018.  
  1019. #   ifndef MOTIF11
  1020.     Tcl_DStringInit(&resourceInfo);
  1021.     for (n = 0; n < num_sec_resources; n++) {
  1022.     for (m = 0; m < sec_resources[n]->num_resources; m++) {
  1023.         Tm_GetResourceInfo(&resourceInfo, w, &(sec_resources[n]->resources[m]));
  1024.         /* hack to get string out of D-string */
  1025.         Tcl_DStringResult(interp, &resourceInfo);
  1026.         Tcl_DStringAppendElement(&resourceList, interp->result);
  1027.     }
  1028.     }
  1029. #   endif
  1030.  
  1031.     Tcl_DStringInit(&resourceInfo);
  1032.     for (n = 0; n < num_constraint_resources; n++) {
  1033.     Tm_GetResourceInfo(&resourceInfo, w, constraint_resources+n);
  1034.     /* hack to get string out of D-string */
  1035.     Tcl_DStringResult(interp, &resourceInfo);
  1036.     Tcl_DStringAppendElement(&resourceList, interp->result);
  1037.     }
  1038.  
  1039.     /* turn error reporting back on */
  1040.     XtAppSetWarningHandler(XtWidgetToApplicationContext(w), oldWarningHandler);
  1041.  
  1042.     Tcl_DStringResult(interp, &resourceList);
  1043.  
  1044. #ifndef MOTIF11
  1045.     if (num_sec_resources > 0)
  1046.     Tm_FreeSecondaryResources(sec_resources, num_sec_resources);
  1047. #endif
  1048.     if (num_resources > 0) 
  1049.     XtFree((char *) resources);
  1050.     if (num_constraint_resources > 0) 
  1051.     XtFree((char *) constraint_resources);
  1052.     Tm_FreeResourceList();
  1053.  
  1054.     return TCL_OK;
  1055. }
  1056.  
  1057. /*
  1058.  *--------------------------------------------------------------
  1059.  *
  1060.  * Tm_GetAppResources -- get the resources specific to the
  1061.  *    application level
  1062.  *
  1063.  * Results:
  1064.  *     standard tcl result
  1065.  *
  1066.  * Side effects:
  1067.  *    sets tcl vbls with the application resources
  1068.  *
  1069.  *--------------------------------------------------------------
  1070.  */
  1071.  
  1072. int
  1073. Tm_GetAppResources(interp, w, resource_str)
  1074.     Tcl_Interp *interp;
  1075.     Widget w;
  1076.     String resource_str;
  1077. {
  1078.     char **resource_list;
  1079.     int num_resources;
  1080.     char **res_elmts;
  1081.     int num_elmts;
  1082.     XtResourceList resources;
  1083.     String *vbls;
  1084.     String *values;
  1085.     int n;
  1086.  
  1087.     Tcl_SplitList(interp, resource_str, &num_resources, &resource_list);
  1088.     resources = (XtResource *) XtMalloc(num_resources * sizeof(XtResource));
  1089.     vbls = (String *) XtMalloc(num_resources * sizeof(String));
  1090.     values = (String *) XtMalloc(num_resources * sizeof(String));
  1091.  
  1092.     for (n = 0; n < num_resources; n++) {
  1093.     Tcl_SplitList(interp, resource_list[n], &num_elmts, &res_elmts);
  1094.     if (num_elmts != 4) {
  1095.         sprintf(interp->result, "wrong getAppResources \"%50s\"",
  1096.             resource_list[n]);
  1097.        return TCL_ERROR;
  1098.     }
  1099.  
  1100.     resources[n].resource_name = res_elmts[0];
  1101.     resources[n].resource_class = res_elmts[1];
  1102.     resources[n].resource_type = XtRString;
  1103.     resources[n].resource_offset = n * sizeof(String);
  1104.     resources[n].default_type = XtRString;
  1105.     resources[n].default_addr = res_elmts[2];
  1106.  
  1107.     vbls[n] = res_elmts[3];
  1108.     }
  1109.  
  1110.     XtGetApplicationResources(w, values, resources, num_resources, NULL, 0);
  1111.  
  1112.     for (n = 0; n < num_resources; n++) {
  1113.     Tcl_SetVar(interp, vbls[n], values[n], 0);
  1114.     }
  1115.  
  1116.     return TCL_OK;
  1117. }
  1118.