开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
params.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：12k
源码类别：

通讯编程

开发平台：

Visual C++

params.c：源码内容
  1. /* $Header: /usr/src/mash/repository/vint/xgraph/params.c,v 1.2 1999/12/08 19:32:41 heideman Exp $ */
  2. /*
  3.  * Xgraph Parameters
  4.  *
  5.  * This file contains routines for setting and retrieving
  6.  * various X style display parameters for xgraph.
  7.  *
  8.  * $Log: params.c,v $
  9.  * Revision 1.2  1999/12/08 19:32:41  heideman
  10.  * strcasecmp portability fix
  11.  *
  12.  * Revision 1.1.1.1  1999/12/03 23:15:52  heideman
  13.  * xgraph-12.0
  14.  *
  15.  */
  16. #ifndef lint
  17. static char rcsid[] = "$Id: params.c,v 1.2 1999/12/08 19:32:41 heideman Exp $";
  19. #endif
  21. #include <ctype.h>
  22. #include <stdio.h>
  23. #include "st.h"
  24. #include "params.h"
  25. #include "hard_devices.h"
  26. #include "xgraph.h" /* for string.h */
  28. /* For use by convenience macros */
  29. params  param_temp,
  30.        *param_temp_ptr;
  31. XColor  param_null_color =
  32. {0, 0, 0, 0, 0, 0};
  33. param_style param_null_style =
  34. {STYLE, 0, (char *) 0};
  36. static st_table *param_table = (st_table *) 0;
  38. typedef struct param_full_defn {
  39.     param_types type;
  40.     char   *text_form;
  41.     params *real_form;
  42. }       param_full;
  45. #define ISO_FONT "*-*-%s-medium-r-normal-*-*-%d-*-*-*-*-iso8859-*"
  46. static Display *param_disp;
  47. static Colormap param_cmap;
  48. static int param_scrn;
  50. static void free_resource();
  51. static params *resolve_entry();
  52. static int strihash();
  53. static int do_color();
  54. static int do_font();
  55. static int do_style();
  56. static int do_bool();
  58. #define DEF_INT "0"
  59. #define DEF_STR ""
  60. #define DEF_FONT "fixed"
  61. #define DEF_PIXEL "black"
  62. #define DEF_STYLE "1"
  63. #define DEF_BOOL "false"
  64. #define DEF_DBL "0.0"
  66. #define DEF_MAX_FONT 1024
  67. #define DEF_MAX_NAMES 10
  69. #define DUP(str)
  70. strcpy((char *) Malloc((unsigned) (strlen(str)+1)), (str))
  73. void
  74. param_init(disp, cmap)
  75. Display *disp; /* X Connection        */
  76. Colormap cmap; /* Colormap for colors */
  78. /*
  79.  * Initializes parameter package.  The display and colormap arguments
  80.  * are used to resolve font and pixel values.
  81.  */
  82. {
  83.     param_table = st_init_table(stricmp, strihash);
  84.     if (disp != NULL) {
  85. param_disp = disp;
  86. param_cmap = cmap;
  87. /* This could also be a parameter for greater generality */
  88. param_scrn = DefaultScreen(disp);
  89.     }
  90. }
  94. void
  95. param_set(name, type, val)
  96. char   *name; /* Name of parameter   */
  97. param_types type; /* Type                */
  98. char   *val; /* Text form for value */
  100. /*
  101.  * Sets the parameter with the given name to have the type
  102.  * `type' and the text value `value'.  This will be evaluated
  103.  * to its full form the first time it is referenced using
  104.  * param_get().  If it is already filled, the old value
  105.  * will be reclaimed.
  106.  */
  107. {
  108.     param_full *entry;
  110.     if (!param_table) {
  111. (void) fprintf(stderr, "Parameter table not initializedn");
  112. return;
  113.     }
  114.     if (st_lookup(param_table, name, (char **) &entry)) {
  115. if (entry->real_form)
  116.     free_resource(entry->real_form);
  117. entry->real_form = (params *) 0;
  118.     }
  119.     else {
  120. entry = (param_full *) Malloc(sizeof(param_full));
  121. entry->text_form = (char *) 0;
  122. entry->real_form = (params *) 0;
  123. (void) st_insert(param_table, DUP(name), (char *) entry);
  124.     }
  125.     entry->type = type;
  126.     if (entry->text_form)
  127. (void) Free((char *) (entry->text_form));
  128.     entry->text_form = DUP(val);
  129. }
  132. void
  133. param_reset(name, val)
  134. char   *name; /* Name of parameter   */
  135. char   *val; /* Text form for value */
  137. /*
  138.  * This routine sets the value of an existing parameter to a new
  139.  * value.  The type of the parameter remains the same.  Changes
  140.  * in type should be done by using param_set() directly.
  141.  */
  142. {
  143.     param_full *entry;
  145.     if (!param_table) {
  146. (void) fprintf(stderr, "Parameter table not initializedn");
  147. return;
  148.     }
  149.     if (st_lookup(param_table, name, (char **) &entry))
  150. param_set(name, entry->type, val);
  151.     else
  152. (void) fprintf(stderr, "Cannot reset unknown parameter `%s'n", name);
  153. }
  158. params *
  159. param_get(name, val)
  160. char   *name; /* Name of parameter */
  161. params *val; /* Result value      */
  163. /*
  164.  * Retrieves a value from the parameter table.  The value
  165.  * is placed in `val'.  If successful, the routine will
  166.  * return `val'.  Otherwise, it will return zero.
  167.  */
  168. {
  169.     param_full *entry;
  171.     if (!param_table) {
  172. (void) fprintf(stderr, "Parameter table not initializedn");
  173. return (params *) 0;
  174.     }
  175.     if (st_lookup(param_table, name, (char **) &entry)) {
  176. if (!entry->real_form)
  177.     entry->real_form = resolve_entry(name, entry->type,
  178.      entry->text_form);
  179. *val = *(entry->real_form);
  180. return val;
  181.     }
  182.     else {
  183. return (params *) 0;
  184.     }
  185. }
  188. static void
  189. free_resource(val)
  190. params *val; /* Value to free */
  192. /*
  193.  * Reclaims a resource based on its type.
  194.  */
  195. {
  196.     switch (val->type) {
  197.     case INT:
  198.     case STR:
  199.     case BOOL:
  200.     case DBL:
  201. /* No reclaimation necessary */
  202. break;
  203.     case PIXEL:
  204. if ((val->pixv.value.pixel != WhitePixel(param_disp, param_scrn)) &&
  205.     (val->pixv.value.pixel != BlackPixel(param_disp, param_scrn)))
  206.     XFreeColors(param_disp, param_cmap, &(val->pixv.value.pixel), 1, 0);
  207. break;
  208.     case FONT:
  209. XFreeFont(param_disp, val->fontv.value);
  210. break;
  211.     case STYLE:
  212. (void) Free(val->stylev.dash_list);
  213. break;
  214.     }
  215.     (void) Free((char *) val);
  216. }
  220. static params *
  221. resolve_entry(name, type, form)
  222. char   *name; /* Name of item for errors */
  223. param_types type; /* What type of thing */
  224. char   *form; /* Textual form       */
  226. /*
  227.  * Allocates and returns an appropriate parameter structure
  228.  * by translating `form' into its native type as given by `type'.
  229.  * If it can't translate the given form, it will fall back onto
  230.  * the default.
  231.  */
  232. {
  233.     static char paramstr[] =
  234.     "Parameter %s: can't translate `%s' into a %s (defaulting to `%s')n";
  235.     params *result = (params *) Malloc(sizeof(params));
  237.     result->type = type;
  238.     switch (type) {
  239.     case INT:
  240. if (sscanf(form, "%d", &result->intv.value) != 1) {
  241.     (void) fprintf(stderr, paramstr, name, form, "integer", DEF_INT);
  242.     result->intv.value = atoi(DEF_INT);
  243. }
  244. break;
  245.     case STR:
  246. result->strv.value = form;
  247. break;
  248.     case PIXEL:
  249. if (!do_color(form, &result->pixv.value)) {
  250.     (void) fprintf(stderr, paramstr, name, form, "color", DEF_PIXEL);
  251.     (void) do_color(DEF_PIXEL, &result->pixv.value);
  252. }
  253. break;
  254.     case FONT:
  255. if (!do_font(form, &result->fontv.value)) {
  256.     (void) fprintf(stderr, paramstr, name, form, "font", DEF_FONT);
  257.     (void) do_font(DEF_FONT, &result->fontv.value);
  258. }
  259. break;
  260.     case STYLE:
  261. if (!do_style(form, &result->stylev)) {
  262.     (void) fprintf(stderr, paramstr, name, form, "line style",
  263.    DEF_STYLE);
  264.     (void) do_style(DEF_STYLE, &result->stylev);
  265. }
  266. break;
  267.     case BOOL:
  268. if (!do_bool(form, &result->boolv.value)) {
  269.     (void) fprintf(stderr, paramstr, name, form, "boolean flag",
  270.    DEF_BOOL);
  271.     (void) do_bool(DEF_BOOL, &result->boolv.value);
  272. }
  273. break;
  274.     case DBL:
  275. if (sscanf(form, "%lf", &result->dblv.value) != 1) {
  276.     (void) fprintf(stderr, paramstr, name, form, "double", DEF_DBL);
  277.     result->dblv.value = atof(DEF_DBL);
  278. }
  279. break;
  280.     }
  281.     return result;
  282. }
  286. static int
  287. do_color(name, color)
  288. char   *name; /* Name for color */
  289. XColor *color; /* Returned color */
  291. /*
  292.  * Translates `name' into a color and attempts to get the pixel
  293.  * for the color using XAllocColor().
  294.  */
  295. {
  296.     int     result = 1;
  298.     if (PM_INT("Output Device") == D_XWINDOWS) {
  299. if (XParseColor(param_disp, param_cmap, name, color)) {
  300.     if (stricmp(name, "black") == 0) {
  301. color->pixel = BlackPixel(param_disp, param_scrn);
  302. XQueryColor(param_disp, param_cmap, color);
  303.     }
  304.     else if (stricmp(name, "white") == 0) {
  305. color->pixel = WhitePixel(param_disp, param_scrn);
  306. XQueryColor(param_disp, param_cmap, color);
  307.     }
  308.     else
  309. result = XAllocColor(param_disp, param_cmap, color);
  310. }
  311. else
  312.     result = 0;
  313.     }
  314.     return result;
  315. }
  319. static int
  320. do_font(name, font_info)
  321. char   *name; /* Name of desired font      */
  322. XFontStruct **font_info; /* Returned font information */
  324. /*
  325.  * This routine translates a font name into a font structure.  The
  326.  * font name can be in two forms.  The first form is <family>-<size>.
  327.  * The family is a family name (like helvetica) and the size is
  328.  * in points (like 12).  If the font is not in this form, it
  329.  * is assumed to be a regular X font name specification and
  330.  * is looked up using the standard means.
  331.  */
  332. {
  333.     char    name_copy[DEF_MAX_FONT],
  334.             query_spec[DEF_MAX_FONT];
  335.     char   *font_family,
  336.            *font_size,
  337.           **font_list;
  338.     int     font_size_value,
  339.             font_count,
  340.             i;
  342.     /* First attempt to interpret as font family/size */
  343.     if (PM_INT("Output Device") == D_XWINDOWS) {
  344. (void) strcpy(name_copy, name);
  345. if (font_size = index(name_copy, '-')) {
  346.     *font_size = '';
  347.     font_family = name_copy;
  348.     font_size++;
  349.     font_size_value = atoi(font_size);
  350.     if (font_size_value > 0) {
  351. /*
  352.  * Still a little iffy -- what about weight and roman vs. other
  353.  */
  354. (void) sprintf(query_spec, ISO_FONT,
  355.        font_family, font_size_value * 10);
  356. font_list = XListFonts(param_disp, query_spec,
  357.        DEF_MAX_NAMES, &font_count);
  359. /* Load first one that you can */
  360. for (i = 0; i < font_count; i++)
  361.     if (*font_info = XLoadQueryFont(param_disp, font_list[i]))
  362. break;
  363. if (*font_info)
  364.     return 1;
  365.     }
  366. }
  367. /* Assume normal font name */
  368. return (int) (*font_info = XLoadQueryFont(param_disp, name));
  369.     }
  370. }
  373. static int
  374. do_style(list, val)
  375. char   *list; /* List of ones and zeros */
  376. param_style *val; /* Line style returned    */
  378. /*
  379.  * Translates a string representation of a dash specification into
  380.  * a form suitable for use in XSetDashes().  Assumes `list'
  381.  * is a null terminated string of ones and zeros.
  382.  */
  383. {
  384.     char   *i,
  385.            *spot,
  386.             last_char;
  387.     int     count;
  389.     for (i = list; *i; i++)
  390. if ((*i != '0') && (*i != '1'))
  391.     break;
  393.     if (!*i) {
  394. val->len = 0;
  395. last_char = '';
  396. for (i = list; *i; i++) {
  397.     if (*i != last_char) {
  398. val->len += 1;
  399. last_char = *i;
  400.     }
  401. }
  402. val->dash_list = (char *) Malloc((unsigned)
  403.  (sizeof(char) * val->len + 1));
  404. last_char = *list;
  405. spot = val->dash_list;
  406. count = 0;
  407. for (i = list; *i; i++) {
  408.     if (*i != last_char) {
  409. *spot++ = (char) count;
  410. last_char = *i;
  411. count = 1;
  412.     }
  413.     else
  414. count++;
  415. }
  416. *spot = (char) count;
  417. return 1;
  418.     }
  419.     else {
  420. return 0;
  421.     }
  422. }
  425. static char *positive[] =
  426. {"on", "yes", "true", "1", "affirmative", (char *) 0};
  427. static char *negative[] =
  428. {"off", "no", "false", "0", "negative", (char *) 0};
  430. static int
  431. do_bool(name, val)
  432. char   *name; /* String representation */
  433. int    *val; /* Returned value        */
  435. /*
  436.  * Translates a string representation into a suitable binary value.
  437.  * Can parse all kinds of interesting boolean type words.
  438.  */
  439. {
  440.     char  **term;
  442.     for (term = positive; *term; term++) {
  443. if (stricmp(name, *term) == 0)
  444.     break;
  445.     }
  446.     if (*term) {
  447. *val = 1;
  448. return 1;
  449.     }
  450.     for (term = negative; *term; term++)
  451. if (stricmp(name, *term) == 0)
  452.     break;
  454.     if (*term) {
  455. *val = 0;
  456. return 1;
  457.     }
  458.     return 0;
  459. }
  463. /*ARGSUSED*/
  464. static enum st_retval
  465. dump_it(key, value, arg)
  466. char   *key,
  467.        *value,
  468.        *arg;
  469. {
  470.     param_full *val = (param_full *) value;
  472.     (void) fprintf(stdout, "%s (", key);
  473.     switch (val->type) {
  474.     case INT:
  475. (void) fprintf(stdout, "INT");
  476. break;
  477.     case STR:
  478. (void) fprintf(stdout, "STR");
  479. break;
  480.     case PIXEL:
  481. (void) fprintf(stdout, "PIXEL");
  482. break;
  483.     case FONT:
  484. (void) fprintf(stdout, "FONT");
  485. break;
  486.     case STYLE:
  487. (void) fprintf(stdout, "STYLE");
  488. break;
  489.     case BOOL:
  490. (void) fprintf(stdout, "BOOL");
  491. break;
  492.     case DBL:
  493. (void) fprintf(stdout, "DBL");
  494. break;
  495.     }
  496.     (void) fprintf(stdout, ") = %sn", val->text_form);
  497.     return ST_CONTINUE;
  498. }
  500. void
  501. param_dump()
  502. /*
  503.  * Dumps all of the parameter values to standard output.
  504.  */
  505. {
  506.     st_foreach(param_table, dump_it, (char *) 0);
  507. }
  511. #ifdef HAVE_STRCASECMP
  512. int
  513. stricmp(a, b)
  514. char *a, *b;
  515. {
  516. return strcasecmp(a, b);
  517. }
  518. #else
  519. int
  520. stricmp(a, b)
  521. register char *a,
  522.        *b;
  524. /*
  525.  * This routine compares two strings disregarding case.
  526.  */
  527. {
  528.     register int value;
  530.     if ((a == (char *) 0) || (b == (char *) 0)) {
  531. return a - b;
  532.     }
  534.     for ( /* nothing */ ;
  535.  ((*a | *b) &&
  536.   !(value = ((isupper(*a) ? *a - 'A' + 'a' : *a) -
  537.      (isupper(*b) ? *b - 'A' + 'a' : *b))));
  538.  a++, b++)
  539.  /* Empty Body */ ;
  541.     return value;
  542. }
  544. #endif
  546. static int
  547. strihash(string, modulus)
  548. register char *string;
  549. int     modulus;
  551. /* Case insensitive computation */
  552. {
  553.     register int val = 0;
  554.     register int c;
  556.     while ((c = *string++) != '') {
  557. if (isupper(c))
  558.     c = tolower(c);
  559. val = val * 997 + c;
  560.     }
  562.     return ((val < 0) ? -val : val) % modulus;
  563. }