home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume6 / wsxc2 / part03 / WsCvtStrToCallback.c < prev    next >
C/C++ Source or Header  |  1990-04-26  |  12KB  |  370 lines
  1. /*
  2. *******************************************************************************
  3. * Copyright 1990 by Auto-trol Technology Corporation, Denver, Colorado.
  4. *
  5. *                        All Rights Reserved
  6. *
  7. * Permission to use, copy, modify, and distribute this software and its
  8. * documentation for any purpose and without fee is hereby granted, provided
  9. * that the above copyright notice appears on all copies and that both the
  10. * copyright and this permission notice appear in supporting documentation
  11. * and that the name of Auto-trol not be used in advertising or publicity
  12. * pertaining to distribution of the software without specific, prior written
  13. * permission.
  14. * 
  15. * Auto-trol disclaims all warranties with regard to this software, including
  16. * all implied warranties of merchantability and fitness, in no event shall
  17. * Auto-trol be liable for any special, indirect or consequential damages or
  18. * any damages whatsoever resulting from loss of use, data or profits, whether 
  19. * in an action of contract, negligence or other tortious action, arising out 
  20. * of or in connection with the use or performance of this software.
  21. *
  22. * SCCS_data: @(#)WsCvtStrToCallback.c 1.2(4/18/90)
  23. *
  24. * Module_name:
  25. *
  26. *     WsCvtStrToCallback
  27. *
  28. * Subsystem_group:
  29. *
  30. *     Window System, Widget Set, Converters
  31. *
  32. * Related_keywords: 
  33. *
  34. *     Converter
  35. *
  36. * Module_description:
  37. *
  38. *     This module contains the String To Callback X resource converter.
  39. *
  40. *     The converter parses the resource string in the format:
  41. *
  42. *       ...path:   name[(args)][,name[(args)]]...
  43. *
  44. *     where:  name:   specifies the registered callback function name
  45. *             args:   specifies the string passed to a callback as
  46. *              "client data".
  47. *
  48. *     Multiple callbacks can be specified for a single callback list
  49. *     resource.  Any callbacks must be "registered" by the application
  50. *     prior converter invocation (.i.e.prior widget creation).
  51. *     If no "args" string is provided, the default "client data" 
  52. *     specified at callback registration are used.
  53. *
  54. * Module_interface_summary: 
  55. *
  56. *
  57. *     Resource converter is invoked indirectly by the toolkit. The
  58. *     converter is added to the toolkit by widgets calling
  59. *     WsAddStrToCallbackP() in the widget intialization code.
  60. *
  61. *     To register application callbacks, use:
  62. *
  63. *     WsRegisterCallback ( 
  64. *        WsAppContext    app,    - application context
  65. *        String        name,    - register name, case insensitive
  66. *        Callback        callback,    - callback function pointer
  67. *        ClientData      closure )    - default client data
  68. *
  69. * Module_history:
  70. *                                                  
  71. *   mm/dd/yy  initials  function  action
  72. *   --------  --------  --------  ---------------------------------------------
  73. *   04/03/90  MarBru    CvtStr..  Fixed argument termination with a NUL char
  74. *   02/26/90  MarBru    All       Created
  75. *
  76. * Design_notes:
  77. *
  78. *   For VMS, we could have used LIB$FIND_IMAGE_SYMBOL and use dynamic
  79. *   (runtime) binding. But since most UNIX systems lack such capability,
  80. *   we stick to the concept of "registration" routines.
  81. *
  82. *   One time, I considered applying conversion to callback argument, which
  83. *   would take the burden of conversion from the callback code (runtime)
  84. *   to the callback  conversion (one time initialization). The problem is
  85. *   that some conversions are widget context specific (color to pixel needs
  86. *   display connection), and at the time of callback conversion I do not
  87. *   have a widget. I could require the widget argument, but this would kill
  88. *   caching of the conversion result.
  89. *
  90. *   The sequential search of the callback cache is far from optimal. I should
  91. *   use binary search, or some of the R4 conversion support code.
  92. *   
  93. *******************************************************************************
  94. */
  95. /*
  96. *******************************************************************************
  97. * Include_files.
  98. *******************************************************************************
  99. */
  100.  
  101. /*  -- Operating system includes */
  102. #include <X11/Xos.h>
  103. #include <ctype.h>
  104.  
  105. /*  -- X Window System includes */
  106. #include <X11/IntrinsicP.h>
  107. #include <X11/StringDefs.h> 
  108.  
  109. /*  -- Auto-trol Window System includes */
  110.  
  111. /*
  112. *******************************************************************************
  113. * Private_constant_declarations.
  114. *******************************************************************************
  115. */
  116. #undef  NUL
  117. #define NUL '\0'
  118.  
  119. /*
  120. *******************************************************************************
  121. * Private_type_declarations.
  122. *******************************************************************************
  123. */
  124. #define MAX_XRMSTRING  1024        /* max length of the DB string        */
  125. #define MAX_CALLBACKS    64        /* max number of callbacks per list */
  126. #define ADD_CALLBACKS     16             /* increment of callback cache size */
  127.  
  128. /*
  129. *******************************************************************************
  130. * Private_macro_definitions.
  131. *******************************************************************************
  132. */
  133.  
  134. /*
  135. *******************************************************************************
  136. * Private_data_definitions.
  137. *******************************************************************************
  138.     The following cache/registry of known callbacks, initially empty, 
  139.     is loaded by the application using "registration" routines.
  140.     Assuming small numbers of callbacks, the sequential search
  141.     of such cache is (initially) considered acceptable.
  142. */
  143.  
  144. /*  -- Named callback procedures cache, intially empty */
  145.  
  146. typedef struct
  147. {
  148.     XrmQuark       quark;        /* quarkified callback name   */
  149.     XtCallbackProc callback;        /* callback procedure pointer */
  150.     caddr_t        closure;             /* default client data        */
  151. } CBCacheRec;
  152.  
  153.  
  154.  
  155. static int       callbacks_num = 0;
  156. static int       callbacks_max = 0;
  157. static CBCacheRec *callbacks_ptr = NULL;
  158.  
  159.  
  160. /*
  161. *******************************************************************************
  162. * Private_function_declarations.
  163. *******************************************************************************
  164. */
  165.  
  166. /*
  167.     -- Convert String To Callback
  168. *******************************************************************************
  169.     This conversion creates a callback list structure from the X resource
  170.     database string in format:
  171.  
  172.     name(arg),name(arg).....
  173.  
  174.     Note "name" is not case sensitive, while "arg" may be - it is passed to
  175.     a callback as client data as a null terminated string (first level
  176.     parenthesis stripped off).
  177. */
  178. void CvtStringToCallback (args, num_args, fromVal, toVal)
  179.  
  180. XrmValue *args;
  181. Cardinal *num_args;
  182. XrmValue *fromVal;
  183. XrmValue *toVal;
  184. {
  185.     typedef struct 
  186.     {
  187.     char *nsta,*nend;        /* callback name start, end */
  188.     char *asta,*aend;        /* argument string start, end */
  189.     } Segment;
  190.  
  191.     static XtCallbackRec *cb;
  192.     XtCallbackRec      callback_list[MAX_CALLBACKS];
  193.     int                   callback_num = 0;
  194.     String                string = (char *) fromVal->addr;
  195.     Segment               segs[MAX_CALLBACKS];    
  196.     Segment              *seg;
  197.     register char        *s;
  198.     register int          i,ipar;
  199.  
  200. /*  -- assume error or undefined input argument */
  201.     toVal->size = 0;
  202.     toVal->addr = (caddr_t) NULL;
  203.     if (string == NULL) return;
  204.  
  205. /*  -- parse input string finding segments   "name(arg)" comma separated */
  206.     ipar = 0;
  207.     seg  = segs;
  208.     seg->nsta = seg->nend = seg->asta = seg->aend = (char*)NULL;
  209.  
  210.     for ( s=string;  ;  s++ )
  211.     {
  212.     switch (*s)
  213.     {
  214.         case NUL:
  215.     case ',':  if ( ipar > 0 ) break;  /* commas in arguments ignored  */
  216.            if ( seg->nend == NULL ) seg->nend = s-1;  /* no argument */
  217.                seg++;           /* start the next segment */
  218.                seg->nsta = seg->nend = seg->asta = seg->aend = (char*)NULL;
  219.            break;           
  220.  
  221.     case '(':  if ( ipar++ == 0 ) { seg->nend = s-1; seg->asta = s+1; };
  222.                break;
  223.            
  224.     case ')':  if ( --ipar == 0 ) { seg->aend = s-1; };
  225.            break;
  226.  
  227.     default:   if ( *s > ' '  &&  seg->nsta == NULL )
  228.                     seg->nsta = s;   /* only start a new segment on non-blank char*/
  229.  
  230.     }
  231.     if (*s == NUL) break;
  232.     }
  233.     seg++;           /* start the terminating segment */
  234.     seg->nsta = (char*)NULL;
  235.  
  236.     if (ipar)
  237.     {
  238.     XtStringConversionWarning (string, "Callback, unbalanced parenthesis");
  239.     return;
  240.     }
  241.  
  242.  
  243. /*  -- process individual callback string segments "name(arg)" */
  244.     for( seg = segs;  seg->nsta;   seg++)
  245.     {
  246.         char                 cb_name[MAX_XRMSTRING];
  247.     XtCallbackProc       found = (XtCallbackProc)NULL;
  248.     XrmQuark             quark;
  249.     register char    *d;
  250.     register char    *end;
  251.  
  252.     /* our callback cache names are case insensitive, no white space */
  253.     for ( s=seg->nsta, d=cb_name; s<=seg->nend; )
  254.        if ( *s > ' ')
  255.              *d++ = (isupper(*s) ) ? tolower (*s++) : *s++;
  256.        else
  257.           s++;
  258.     *d   = NUL;
  259.  
  260.         /* try to locate callback in our cache of callbacks */
  261.         quark = XrmStringToQuark (cb_name);
  262.     for (i=0; i<callbacks_num; i++)
  263.         if ( callbacks_ptr[i].quark == quark )
  264.         {
  265.             register XtCallbackRec *rec = &callback_list[callback_num];
  266.         rec->callback = found = callbacks_ptr[i].callback;
  267.             rec->closure  = callbacks_ptr[i].closure;
  268.         break;
  269.         }
  270.  
  271.     /* we have found a registered callback, process arguments */
  272.     if (found)
  273.     {
  274.        register char *arg;
  275.        register int   alen;
  276.        register XtCallbackRec *rec = &callback_list[callback_num];
  277.        
  278.        if ( seg->asta )
  279.        {
  280.            alen = (int)seg->aend - (int)seg->asta +1;
  281.            arg  = XtMalloc(alen+1);
  282.            strncpy ( arg, seg->asta, alen );
  283.            arg[alen]    = NUL;
  284.            rec->closure = (caddr_t)arg;
  285.        }
  286.        callback_num++;
  287.         }
  288.     else
  289.     {
  290.            XtStringConversionWarning (cb_name, "Callback, unknown callback name");
  291.     }
  292.     } /* end for seg loop */
  293.  
  294. /*  -- terminate the callback list */
  295.     {
  296.     register XtCallbackRec *rec = &callback_list[callback_num];
  297.         rec->callback = NULL;
  298.     rec->closure  = NULL;
  299.     callback_num++;
  300.     }
  301.  
  302. /*  -- make a permanent copy of the new callback list, and return a pointer */
  303.     cb = (XtCallbackRec*)XtMalloc( callback_num * sizeof (XtCallbackRec) );
  304.     memcpy ( (char*)cb, (char*)callback_list,  
  305.               callback_num * sizeof (XtCallbackRec));
  306.     toVal->size = sizeof (XtCallbackRec*);
  307.     toVal->addr = (caddr_t)&cb;
  308.  
  309. }
  310.  
  311. /*
  312. *******************************************************************************
  313. * Public_function_declarations.
  314. *******************************************************************************
  315. */
  316.  
  317. /*
  318.     -- Add String To Callback Convertor
  319. *******************************************************************************
  320. */
  321.  
  322. void WsAddStringToCallbackP ()
  323. {
  324.     static Boolean added = FALSE;
  325.     if ( !added )
  326.     {
  327.        XtAddConverter    (XtRString, 
  328.                           XtRCallback,
  329.                           CvtStringToCallback,
  330.                           (XtConvertArgList)NULL,
  331.                           (Cardinal)0);
  332.        added = TRUE;
  333.     }
  334. }
  335.  
  336.  
  337. /*
  338.     -- Register callback
  339. *******************************************************************************
  340.     This procedure adds callback procedure/name to our list of registered
  341.     callbacks. So far very simplistic ... without checking for duplicate
  342.     entries, no cache hashing scheme, no ties to app_context.
  343. */
  344. void WsRegisterCallback ( app, name, callback, closure )
  345. XtAppContext    app;        /* not used (yet), must be present      */
  346. String          name;       /* callback name, case insensitive      */
  347. XtCallbackProc  callback;   /* callback function pointer            */
  348. caddr_t         closure;    /* default closure (client data)        */
  349. {
  350.     char           cb_name[MAX_XRMSTRING];
  351.     CBCacheRec    *rec;
  352.     register char *s;
  353.     register char *d;
  354.  
  355.     for ( d=cb_name, s=name; *s; s++)
  356.          *d++ = (isupper(*s)) ? tolower (*s) : *s;
  357.     *d = '\0';
  358.  
  359.     if (callbacks_num >= callbacks_max )
  360.     {
  361.     callbacks_max += ADD_CALLBACKS;
  362.     callbacks_ptr  = (CBCacheRec*) XtRealloc((char*)callbacks_ptr, 
  363.                       sizeof(CBCacheRec) * callbacks_max);
  364.     }
  365.     rec = &callbacks_ptr[callbacks_num++];
  366.     rec->quark    = XrmStringToQuark ( cb_name );
  367.     rec->callback = callback;
  368.     rec->closure  = closure;
  369. }
  370.