home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume30 / gnuplot3 / patch02g / patch.2
Encoding:
Text File  |  1992-06-19  |  27.5 KB  |  825 lines
  1. diff -rc gnuplot/gnuplot_x11.c gnuplot3.2/gnuplot_x11.c
  2. *** gnuplot/gnuplot_x11.c    Mon Sep  9 13:13:19 1991
  3. --- gnuplot3.2/gnuplot_x11.c    Tue May  5 21:42:20 1992
  4. ***************
  5. *** 1,3 ****
  6. --- 1,7 ----
  7. + #ifndef lint
  8. + static char *RCSid = "$Id: gnuplot_x11.c,v 3.26 92/03/24 22:35:52 woo Exp Locker: woo $";
  9. + #endif
  10. + 
  11.   /*-----------------------------------------------------------------------------
  12.    *   gnuplot_x11 - X11 outboard terminal driver for gnuplot 3
  13.    *
  14. ***************
  15. *** 4,130 ****
  16.    *   Requires installation of companion inboard x11 driver in gnuplot/term.c
  17.    *
  18.    *   Acknowledgements: 
  19. !  *      Chris Peterson (MIT) - original Xlib gnuplot support (and Xaw examples)
  20. !  *      Dana Chee (Bellcore)  - mods to original support for gnuplot 2.0
  21. !  *      Arthur Smith (Cornell) - graphical-label-widget idea (xplot)
  22. !  *      Hendri Hondorp (University of Twente, The Netherlands) - Motif xgnuplot
  23.    *
  24.    *   This code is provided as is and with no warranties of any kind.
  25.    *       
  26. !  *   Ed Kubaitis - Computing Services Office -  University of Illinois, Urbana
  27.    *---------------------------------------------------------------------------*/
  28.    
  29.   #include <stdio.h>
  30.   #include <signal.h>
  31. - #include <X11/Intrinsic.h>
  32. - #include <X11/StringDefs.h>
  33. - #include <Label.h>          /* use -Idir for location on your system */
  34. - #ifdef MOTIF
  35. - #include <Xm.h>             /* use -Idir for location on your system */
  36. - #define LabelWC xmLabelWidgetClass
  37. - #define LabelBPM XmNbackgroundPixmap
  38. - #else
  39. - #define LabelWC labelWidgetClass
  40. - #define LabelBPM XtNbitmap
  41. - #endif
  42.   
  43. ! #define Color (D>1)
  44. ! #define Ncolors 11
  45.   unsigned long colors[Ncolors];
  46. - char color_keys[Ncolors][30] =   { "text", "border", "axis", 
  47. -    "line1", "line2", "line3", "line4", "line5", "line6", "line7", "line8" };
  48. - char color_values[Ncolors][30] = { "black", "black", "black", 
  49. -    "red",  "green", "blue",  "magenta", "cyan", "sienna", "orange", "coral" };
  50.   
  51.   char dashes[10][5] = { {0}, {1,6,0}, 
  52.      {0}, {4,2,0}, {1,3,0}, {4,4,0}, {1,5,0}, {4,4,4,1,0}, {4,2,0}, {1,3,0}
  53.      };
  54.   
  55. ! Widget w_top, w_label; Window win; Display *dpy;
  56. ! Pixmap pixmap;  GC gc = (GC)NULL;
  57. ! Dimension W = 640 , H = 450;  int D;
  58. ! Arg args[5];
  59. ! static void gnuplot(), resize();
  60.   
  61.   int cx=0, cy=0, vchar, nc = 0, ncalloc = 0;
  62.   double xscale, yscale;
  63. ! #define X(x) (Dimension) (x * xscale)
  64. ! #define Y(y) (Dimension) ((4095-y) * yscale)
  65.   enum JUSTIFY { LEFT, CENTRE, RIGHT } jmode;
  66.   #define Nbuf 1024
  67. ! char buf[Nbuf];
  68. ! String *commands = NULL;
  69.   
  70. ! typedef struct {       /* See "X Toolkit Intrinsics Programming Manual"      */
  71. !   XFontStruct *font;   /* Nye and O'Reilly, O'Reilly & Associates, pp. 80-85 */
  72. !   unsigned long fg;
  73. !   unsigned long bg;
  74. !   } RValues, *RVptr; 
  75. ! RValues rv;
  76.   
  77. - XtResource resources[] = {
  78. -    { XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *), 
  79. -      XtOffset(RVptr, font), XtRString, "fixed" },
  80. -    { XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel), 
  81. -      XtOffset(RVptr, fg), XtRString, XtDefaultForeground },
  82. -    { XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel), 
  83. -      XtOffset(RVptr, bg), XtRString, XtDefaultBackground },
  84. -    };
  85.   
  86.   /*-----------------------------------------------------------------------------
  87. !  *   main program - fire up application and callbacks
  88.    *---------------------------------------------------------------------------*/
  89.   
  90.   main(argc, argv) int argc; char *argv[]; {
  91.   
  92. !    signal(SIGINT, SIG_IGN);
  93. ! #ifdef SIGTSTP
  94. !    signal(SIGTSTP, SIG_IGN);
  95. ! #endif
  96.   
  97. !    /* initialize application */
  98. !    w_top = XtInitialize("gnuplot", "Gnuplot", NULL, 0, &argc, argv);
  99. !    XtSetArg(args[0], XtNwidth, W);
  100. !    XtSetArg(args[1], XtNheight, H);
  101. !    w_label = XtCreateManagedWidget ("", LabelWC, w_top, args, (Cardinal)2);
  102. !    XtRealizeWidget(w_top);
  103.   
  104. !    /* extract needed information */
  105. !    dpy = XtDisplay(w_top); win = XtWindow(w_label);
  106. !    D = DisplayPlanes(dpy,DefaultScreen(dpy));
  107. !    if (Color) {
  108. !       char option[20], *value; 
  109. !       XColor used, exact; int n;
  110.   
  111. !       for(n=0; n<Ncolors; n++) {
  112. !      strcpy(option, color_keys[n]);
  113. !      strcat(option, "Color");
  114. !      value = XGetDefault(dpy, "gnuplot", option);
  115. !      if (!value) { value = color_values[n]; }
  116. !      if (XAllocNamedColor(dpy, DefaultColormap(dpy,0), value, &used,&exact))
  117. !         colors[n] = used.pixel; 
  118. !      else {
  119. !         fprintf(stderr, "gnuplot: cannot allocate %s:%s\n", option, value);
  120. !         fprintf(stderr, "gnuplot: assuming %s:black\n", option);
  121. !         colors[n] = BlackPixel(dpy,0);
  122.           }
  123.        }
  124.         }
  125. !    XtSetArg(args[0], XtNwidth, &W);
  126. !    XtSetArg(args[1], XtNheight,&H);
  127. !    XtGetValues(w_label, args, (Cardinal)2);
  128. !    XtGetApplicationResources(w_top, &rv, resources, XtNumber(resources),NULL,0);
  129. !    vchar = (rv.font->ascent + rv.font->descent);
  130.   
  131. !    /* add callbacks on input-from-gnuplot-on-stdin & window-resized */
  132. !    XtAddInput(0, XtInputReadMask, gnuplot, NULL);
  133. !    XtAddEventHandler(w_label, StructureNotifyMask, FALSE, resize, NULL);
  134.   
  135. !    XtMainLoop();
  136.      }
  137.   
  138.   /*-----------------------------------------------------------------------------
  139. !  *   display - display accumulated commands from inboard driver
  140.    *---------------------------------------------------------------------------*/
  141.   
  142.   display() {
  143. --- 8,186 ----
  144.    *   Requires installation of companion inboard x11 driver in gnuplot/term.c
  145.    *
  146.    *   Acknowledgements: 
  147. !  *      Chris Peterson (MIT)
  148. !  *      Dana Chee (Bellcore) 
  149. !  *      Arthur Smith (Cornell)
  150. !  *      Hendri Hondorp (University of Twente, The Netherlands)
  151. !  *      Bill Kucharski (Solbourne)
  152. !  *      Charlie Kline (University of Illinois)
  153. !  *      O'Reilly & Associates: X Window System - Volumes 1 & 2
  154.    *
  155.    *   This code is provided as is and with no warranties of any kind.
  156.    *       
  157. !  *   Ed Kubaitis (ejk@uiuc.edu)
  158. !  *   Computing & Communications Services Office 
  159. !  *   University of Illinois, Urbana
  160.    *---------------------------------------------------------------------------*/
  161. + 
  162. + #include <X11/Xos.h>
  163. + #include <X11/Xlib.h>
  164. + #include <X11/Xutil.h>
  165. + #include <X11/Xatom.h>
  166. + #include <X11/Xresource.h>
  167.    
  168.   #include <stdio.h>
  169.   #include <signal.h>
  170.   
  171. ! #ifndef FD_SET
  172. ! #ifndef OLD_SELECT
  173. ! #include <sys/select.h>
  174. ! #else   /* OLD_SELECT */
  175. ! #define FD_SET(n, p)    ((p)->fds_bits[0] |= (1 << ((n) % 32)))
  176. ! #define FD_CLR(n, p)    ((p)->fds_bits[0] &= ~(1 << ((n) % 32)))
  177. ! #define FD_ISSET(n, p)  ((p)->fds_bits[0] & (1 << ((n) % 32)))
  178. ! #define FD_ZERO(p)      bzero((char *)(p), sizeof(*(p)))
  179. ! #endif  /* OLD_SELECT */
  180. ! #endif  /* FD_SET */
  181. ! 
  182. ! #include <errno.h>
  183. ! extern int errno;
  184. ! 
  185. ! #define FallbackFont "fixed"
  186. ! #define Ncolors 13
  187.   unsigned long colors[Ncolors];
  188.   
  189.   char dashes[10][5] = { {0}, {1,6,0}, 
  190.      {0}, {4,2,0}, {1,3,0}, {4,4,0}, {1,5,0}, {4,4,4,1,0}, {4,2,0}, {1,3,0}
  191.      };
  192.   
  193. ! Display *dpy; int scr; Window win, root;
  194. ! Visual *vis; GC gc = (GC)0; Pixmap pixmap; XFontStruct *font;
  195. ! unsigned int W = 640, H = 450; int D, gX = 100, gY = 100;
  196.   
  197. + Bool Mono = 0, Gray = 0, Rv = 0, Clear = 0;
  198. + char Name[64] = "gnuplot";
  199. + char Class[64] = "Gnuplot";
  200. + 
  201.   int cx=0, cy=0, vchar, nc = 0, ncalloc = 0;
  202.   double xscale, yscale;
  203. ! #define X(x) (int) (x * xscale)
  204. ! #define Y(y) (int) ((4095-y) * yscale)
  205.   enum JUSTIFY { LEFT, CENTRE, RIGHT } jmode;
  206. + 
  207.   #define Nbuf 1024
  208. ! char buf[Nbuf], **commands = (char **)0;
  209.   
  210. ! FILE *X11_ipc = stdin;
  211. ! char X11_ipcpath[32];
  212.   
  213.   
  214.   /*-----------------------------------------------------------------------------
  215. !  *   main program 
  216.    *---------------------------------------------------------------------------*/
  217.   
  218.   main(argc, argv) int argc; char *argv[]; {
  219.   
  220. !    preset(argc, argv);
  221. !    mainloop();
  222. !    exit(0);
  223.   
  224. !    }
  225.   
  226. ! /*-----------------------------------------------------------------------------
  227. !  *   mainloop - process X events and input from gnuplot
  228. !  *
  229. !  *   On systems with a fully implemented select(), select is used (without
  230. !  *   timeout) to sense both input from the X server network connection and
  231. !  *   pipe input from gnuplot. On platforms with an incomplete or faulty 
  232. !  *   select(), select (with timeout) is used for the server, and a temporary 
  233. !  *   file rather than a pipe is used for gnuplot input.
  234. !  *---------------------------------------------------------------------------*/
  235.   
  236. ! mainloop() {
  237. !    int nf, nfds, cn = ConnectionNumber(dpy), in = fileno(X11_ipc);
  238. !    struct timeval timeout, *timer = (struct timeval *)0;
  239. !    fd_set rset, tset;
  240. !    unsigned long all = 0xffffffff;
  241. !    XEvent xe;
  242. ! 
  243. !    FD_ZERO(&rset);
  244. !    FD_SET(cn, &rset);
  245. ! 
  246. ! #ifndef CRIPPLED_SELECT
  247. !    FD_SET(in, &rset);
  248. !    nfds = (cn > in) ? cn + 1 : in + 1;
  249. ! #else  /* CRIPPLED_SELECT */
  250. !    timeout.tv_sec = 1;
  251. !    timeout.tv_usec = 0;
  252. !    timer = &timeout;
  253. !    sprintf(X11_ipcpath, "/tmp/Gnuplot_%d", getppid());
  254. !    nfds = cn + 1;
  255. ! #endif /* CRIPPLED_SELECT */
  256. ! 
  257. !    while(1) {
  258. !       tset = rset;
  259. !       nf = select(nfds, &tset, (fd_set *)0, (fd_set *)0, timer);
  260. !       if (nf < 0) {
  261. !      if (errno == EINTR) continue;
  262. !      fprintf(stderr, "gnuplot: select failed. errno:%d\n", errno);
  263. !      exit(1);
  264. !      }
  265. !       nf > 0 && XNoOp(dpy);
  266. !       if (FD_ISSET(cn, &tset)) {
  267. !      while (XCheckMaskEvent(dpy, all, &xe)) {
  268. !         (xe.type == ConfigureNotify)  && resize(&xe); 
  269.           }
  270.        }
  271. + #ifndef CRIPPLED_SELECT
  272. +       FD_ISSET(in, &tset) && accept();
  273. + #else  /* CRIPPLED_SELECT */
  274. +       if ((X11_ipc = fopen(X11_ipcpath, "r"))) {
  275. +      unlink(X11_ipcpath);
  276. +      accept();
  277. +      fclose(X11_ipc);
  278. +      }
  279. + #endif /* CRIPPLED_SELECT */
  280.         }
  281. !    }
  282.   
  283. ! /*-----------------------------------------------------------------------------
  284. !  *   accept - accept & record new plot from gnuplot inboard X11 driver
  285. !  *---------------------------------------------------------------------------*/
  286.   
  287. ! accept() {
  288. ! 
  289. !    while (fgets(buf, Nbuf, X11_ipc)) {
  290. !      if (*buf == 'G') {                           /* enter graphics mode */
  291. !      if (commands) {
  292. !         int n; for (n=0; n<nc; n++) free(commands[n]);
  293. !         free(commands);
  294. !         }
  295. !      commands = (char **)0; nc = ncalloc = 0;
  296. !          }
  297. !       else if (*buf == 'E') { display(); break; } /* leave graphics mode */
  298. !       else if (*buf == 'R') { exit(0); }          /* leave X11/x11 mode  */
  299. !       else {                                      /* record command      */
  300. !      char *p;
  301. !      if (nc >= ncalloc) {
  302. !         ncalloc = ncalloc*2 + 1;
  303. !         commands = (commands)
  304. !            ? (char **)realloc(commands, ncalloc * sizeof(char *))
  305. !            : (char **)malloc(sizeof(char *));
  306. !         }
  307. !      p = (char *)malloc((unsigned)strlen(buf)+1);
  308. !      if (!commands || !p) {
  309. !         fprintf(stderr, "gnuplot: can't get memory. X11 aborted.\n");
  310. !         exit(1);
  311. !         }
  312. !      commands[nc++] = strcpy(p, buf);
  313. !      }
  314. !       }
  315. !    if (feof(X11_ipc) || ferror(X11_ipc)) exit(1);
  316.      }
  317.   
  318.   /*-----------------------------------------------------------------------------
  319. !  *   display - display last plot from gnuplot inboard X11 driver
  320.    *---------------------------------------------------------------------------*/
  321.   
  322.   display() {
  323. ***************
  324. *** 131,166 ****
  325.      int n, x, y, sw, sl, lt, width, type;
  326.      char *buf, *str;
  327.   
  328.      /* set scaling factor between internal driver & window geometry */
  329.      xscale = (double)W / 4096.;  yscale = (double)H / 4096.;  
  330.   
  331.      /* create new pixmap & GC */
  332.      if (gc) { XFreeGC(dpy, gc); XFreePixmap(dpy, pixmap); }
  333. !    pixmap = XCreatePixmap(dpy, RootWindow(dpy,DefaultScreen(dpy)), W, H, D);
  334. !    gc = XCreateGC(dpy, pixmap, 0, NULL);
  335. !    XSetFont(dpy, gc, rv.font->fid);
  336.   
  337. !    /* erase pixmap */
  338. ! #ifndef MOTIF
  339. !    if (Color) { /* Athena needs different erase for color and mono */
  340. ! #endif
  341. !       XSetForeground(dpy, gc, rv.bg);
  342. !       XFillRectangle(dpy, pixmap, gc, 0, 0, W, H);
  343. !       XSetForeground(dpy, gc, rv.fg);
  344. !       XSetBackground(dpy, gc, rv.bg);
  345. ! #ifndef MOTIF
  346. !       }
  347. !    else {  
  348. !       XSetFunction(dpy, gc, GXxor);
  349. !       XCopyArea(dpy, pixmap, pixmap, gc, 0, 0, W, H, 0, 0);
  350. !       XSetFunction(dpy, gc, GXcopyInverted);
  351. !       }
  352. ! #endif
  353.   
  354. !    /* connect new pixmap to label widget */
  355. !    XtSetArg(args[0], LabelBPM, pixmap);
  356. !    XtSetValues(w_label, args, (Cardinal)1);
  357.   
  358.      /* loop over accumulated commands from inboard driver */
  359.      for (n=0; n<nc; n++) {
  360.         buf = commands[n];
  361. --- 187,217 ----
  362.      int n, x, y, sw, sl, lt, width, type;
  363.      char *buf, *str;
  364.   
  365. +    if (!nc) return;
  366. + 
  367.      /* set scaling factor between internal driver & window geometry */
  368.      xscale = (double)W / 4096.;  yscale = (double)H / 4096.;  
  369.   
  370.      /* create new pixmap & GC */
  371.      if (gc) { XFreeGC(dpy, gc); XFreePixmap(dpy, pixmap); }
  372. !    pixmap = XCreatePixmap(dpy, root, W, H, D);
  373. !    gc = XCreateGC(dpy, pixmap, 0, (XGCValues *)0);
  374. !    XSetFont(dpy, gc, font->fid);
  375.   
  376. !    /* set pixmap background */
  377. !    XSetForeground(dpy, gc, colors[0]);
  378. !    XFillRectangle(dpy, pixmap, gc, 0, 0, W, H);
  379. !    XSetBackground(dpy, gc, colors[0]);
  380.   
  381. !    /* set new pixmap as window background */
  382. !    XSetWindowBackgroundPixmap(dpy, win, pixmap);
  383.   
  384. +    /* momentarily clear the window first if requested */
  385. +    if (Clear) {
  386. +       XClearWindow(dpy, win);
  387. +       XFlush(dpy);
  388. +       }
  389. + 
  390.      /* loop over accumulated commands from inboard driver */
  391.      for (n=0; n<nc; n++) {
  392.         buf = commands[n];
  393. ***************
  394. *** 180,198 ****
  395.         else if (*buf == 'T') { 
  396.        sscanf(buf, "T%4d%4d", &x, &y);  
  397.        str = buf + 9; sl = strlen(str) - 1;
  398. !      sw = XTextWidth(rv.font, str, sl);
  399.        switch(jmode) {
  400.           case LEFT:   sw = 0;     break;
  401.           case CENTRE: sw = -sw/2; break;
  402.           case RIGHT:  sw = -sw;   break;
  403.           }
  404. !      if (!Color) 
  405. !         XDrawString(dpy, pixmap, gc, X(x)+sw, Y(y)+vchar/3, str, sl);
  406. !      else { 
  407. !         XSetForeground(dpy, gc, colors[0]);
  408. !         XDrawString(dpy, pixmap, gc, X(x)+sw, Y(y)+vchar/3, str, sl);
  409. !         XSetForeground(dpy, gc, colors[lt+1]);
  410. !         }
  411.        }
  412.   
  413.         /*   X11_justify_text(mode) - set text justification mode  */
  414. --- 231,245 ----
  415.         else if (*buf == 'T') { 
  416.        sscanf(buf, "T%4d%4d", &x, &y);  
  417.        str = buf + 9; sl = strlen(str) - 1;
  418. !      sw = XTextWidth(font, str, sl);
  419.        switch(jmode) {
  420.           case LEFT:   sw = 0;     break;
  421.           case CENTRE: sw = -sw/2; break;
  422.           case RIGHT:  sw = -sw;   break;
  423.           }
  424. !      XSetForeground(dpy, gc, colors[2]);
  425. !      XDrawString(dpy, pixmap, gc, X(x)+sw, Y(y)+vchar/3, str, sl);
  426. !      XSetForeground(dpy, gc, colors[lt+3]);
  427.        }
  428.   
  429.         /*   X11_justify_text(mode) - set text justification mode  */
  430. ***************
  431. *** 204,210 ****
  432.        sscanf(buf, "L%4d", <);
  433.        lt = (lt%8)+2;
  434.        width = (lt == 0) ? 2 : 0;
  435. !      if (Color) {
  436.           if (lt != 1) 
  437.              type = LineSolid;
  438.           else {
  439. --- 251,257 ----
  440.        sscanf(buf, "L%4d", <);
  441.        lt = (lt%8)+2;
  442.        width = (lt == 0) ? 2 : 0;
  443. !      if (!Mono) {
  444.           if (lt != 1) 
  445.              type = LineSolid;
  446.           else {
  447. ***************
  448. *** 211,217 ****
  449.              type = LineOnOffDash;
  450.              XSetDashes(dpy, gc, 0, dashes[lt], strlen(dashes[lt]));
  451.              }
  452. !         XSetForeground(dpy, gc, colors[lt+1]);
  453.           }
  454.        else {
  455.           type  = (lt == 0 || lt == 2) ? LineSolid : LineOnOffDash;
  456. --- 258,264 ----
  457.              type = LineOnOffDash;
  458.              XSetDashes(dpy, gc, 0, dashes[lt], strlen(dashes[lt]));
  459.              }
  460. !         XSetForeground(dpy, gc, colors[lt+3]);
  461.           }
  462.        else {
  463.           type  = (lt == 0 || lt == 2) ? LineSolid : LineOnOffDash;
  464. ***************
  465. *** 222,263 ****
  466.        }
  467.         }
  468.   
  469. !    /* trigger expose events to display pixmap */
  470. !    XClearArea(dpy, win, 0, 0, 0, 0, True);
  471.      }
  472.   
  473.   /*-----------------------------------------------------------------------------
  474. !  *   gnuplot - Xt callback on input from gnuplot inboard X11 driver
  475. !  *   resize - Xt callback when window resized
  476.    *---------------------------------------------------------------------------*/
  477.   
  478. ! static void
  479. ! gnuplot(cd, s, id) char *cd; int *s; XtInputId *id; {
  480.   
  481. !    while (fgets(buf, Nbuf, stdin)) {
  482. !      if (*buf == 'G') {                           /* enter graphics mode */
  483. !      if (commands) {
  484. !         int n; for (n=0; n<nc; n++) XtFree(commands[n]);
  485. !         XtFree(commands);
  486.           }
  487. -      commands = NULL; nc = ncalloc = 0;
  488. -          }
  489. -       else if (*buf == 'E') { display(); break; } /* leave graphics mode */
  490. -       else if (*buf == 'R') { exit(0); }          /* leave X11/x11 mode  */
  491. -       else {
  492. -      if (nc >= ncalloc) {
  493. -         ncalloc = ncalloc*2 + 1;
  494. -         commands = (String *)XtRealloc(commands, ncalloc * sizeof(String));
  495. -         }
  496. -      commands[nc++] = XtNewString(buf);
  497.        }
  498.         }
  499. !    if (feof(stdin) || ferror(stdin)) exit(0);
  500.      }
  501.   
  502. ! static void
  503. ! resize(w, cd, e) Widget w; char *cd; XConfigureEvent *e; {
  504. !    if (e->type != ConfigureNotify) return;
  505. !    W = e->width; H = e->height;
  506. !    display(); 
  507.      }
  508. --- 269,584 ----
  509.        }
  510.         }
  511.   
  512. !    /* trigger exposure of background pixmap */
  513. !    XClearWindow(dpy,win);
  514. !    XFlush(dpy);
  515.      }
  516.   
  517.   /*-----------------------------------------------------------------------------
  518. !  *   resize - rescale last plot if window resized
  519.    *---------------------------------------------------------------------------*/
  520.   
  521. ! Bool init = True;
  522.   
  523. ! resize(xce) XConfigureEvent *xce; {
  524. !    if (!init || xce->width != W || xce->height != H) {
  525. !       W = xce->width; H = xce->height;
  526. !       display();
  527. !       init = True;
  528. !       }
  529. !    }
  530. ! 
  531. ! 
  532. ! /*-----------------------------------------------------------------------------
  533. !  *   preset - determine options, open display, create window
  534. !  *---------------------------------------------------------------------------*/
  535. ! 
  536. ! #define On(v) ( !strcmp(v,"on") || !strcmp(v,"true") || \
  537. !         !strcmp(v,"On") || !strcmp(v,"True") )
  538. ! 
  539. ! #define AppDefDir "/usr/lib/X11/app-defaults"
  540. ! #ifndef MAXHOSTNAMELEN
  541. ! #define MAXHOSTNAMELEN 64
  542. ! #endif
  543. ! 
  544. ! static XrmDatabase dbCmd, dbApp, dbDef, dbEnv, db = (XrmDatabase)0;
  545. ! 
  546. ! char *pr_GetR(), *getenv(), *type[20];
  547. ! XrmValue value;
  548. ! 
  549. ! #define Nopt 25
  550. ! static XrmOptionDescRec options[] = {
  551. !    {"-mono",             ".mono",             XrmoptionNoArg,   "on" },
  552. !    {"-gray",             ".gray",             XrmoptionNoArg,   "on" },
  553. !    {"-clear",            ".clear",            XrmoptionNoArg,   "on" },
  554. !    {"-display",          ".display",          XrmoptionSepArg,  NULL },
  555. !    {"-name",             ".name",             XrmoptionSepArg,  NULL },
  556. !    {"-geometry",         "*geometry",         XrmoptionSepArg,  NULL },
  557. !    {"-background",       "*background",       XrmoptionSepArg,  NULL },
  558. !    {"-bg",               "*background",       XrmoptionSepArg,  NULL },
  559. !    {"-foreground",       "*foreground",       XrmoptionSepArg,  NULL },
  560. !    {"-fg",               "*foreground",       XrmoptionSepArg,  NULL },
  561. !    {"-bordercolor",      "*bordercolor",      XrmoptionSepArg,  NULL },
  562. !    {"-bd",               "*bordercolor",      XrmoptionSepArg,  NULL },
  563. !    {"-borderwidth",      ".borderwidth",      XrmoptionSepArg,  NULL },
  564. !    {"-bw",               ".borderwidth",      XrmoptionSepArg,  NULL },
  565. !    {"-font",             "*font",             XrmoptionSepArg,  NULL },
  566. !    {"-fn",               "*font",             XrmoptionSepArg,  NULL },
  567. !    {"-reverse",          "*reverseVideo",     XrmoptionNoArg,   "on" },
  568. !    {"-rv",               "*reverseVideo",     XrmoptionNoArg,   "on" },
  569. !    {"+rv",               "*reverseVideo",     XrmoptionNoArg,   "off"},
  570. !    {"-iconic",           "*iconic",           XrmoptionNoArg,   "on" },
  571. !    {"-synchronous",      "*synchronous",      XrmoptionNoArg,   "on" },
  572. !    {"-xnllanguage",      "*xnllanguage",      XrmoptionSepArg,  NULL },
  573. !    {"-selectionTimeout", "*selectionTimeout", XrmoptionSepArg,  NULL },
  574. !    {"-title",            ".title",            XrmoptionSepArg,  NULL },
  575. !    {"-xrm",              NULL,                XrmoptionResArg,  NULL },
  576. !    };
  577. ! 
  578. ! preset(argc, argv) int argc; char *argv[]; {
  579. !    int Argc = argc; char **Argv = argv;
  580. ! 
  581. !    char *display = getenv("DISPLAY"),  *home = getenv("HOME");
  582. !    char *server_defaults, *env, buf[256];
  583. ! 
  584. !    /*---set to ignore ^C and ^Z----------------------------------------------*/
  585. ! 
  586. !    signal(SIGINT, SIG_IGN);
  587. ! #ifdef SIGTSTP
  588. !    signal(SIGTSTP, SIG_IGN);
  589. ! #endif
  590. ! 
  591. !    /*---prescan arguments for "-name"----------------------------------------*/
  592. ! 
  593. !    while(++Argv, --Argc > 0) {
  594. !       if (!strcmp(*Argv, "-name") && Argc > 1) {
  595. !      strncpy(Name, Argv[1], 64);
  596. !      strncpy(Class, Argv[1], 64);
  597. !      if (Class[0] >= 'a' && Class[0] <= 'z') Class[0] -= 0x20;
  598. !      }
  599. !       }
  600. !    Argc = argc; Argv = argv;
  601. ! 
  602. !    /*---parse command line---------------------------------------------------*/
  603. ! 
  604. !    XrmInitialize();
  605. !    XrmParseCommand(&dbCmd, options, Nopt, Name, &Argc, Argv);
  606. !    if (Argc > 1) {
  607. !       fprintf(stderr, "\ngnuplot: bad option: %s\n", Argv[1]);
  608. !       fprintf(stderr, "gnuplot: X11 aborted.\n");
  609. !       exit(1);
  610. !       }
  611. !    if (pr_GetR(dbCmd, ".display")) display = value.addr;
  612. ! 
  613. !    /*---open display---------------------------------------------------------*/
  614. ! 
  615. !    dpy = XOpenDisplay(display); 
  616. !    if (!dpy) {
  617. !       fprintf(stderr, "\ngnuplot: unable to open display '%s'\n", display);
  618. !       fprintf(stderr, "gnuplot: X11 aborted.\n");
  619. !       exit(1);
  620. !       }
  621. !    scr = DefaultScreen(dpy);
  622. !    vis = DefaultVisual(dpy,scr);
  623. !    D = DefaultDepth(dpy,scr);
  624. !    root = DefaultRootWindow(dpy);
  625. !    server_defaults = XResourceManagerString(dpy);
  626. ! 
  627. !    /*---get application defaults--(subset of Xt processing)------------------*/
  628. ! 
  629. !    sprintf(buf, "%s/%s", AppDefDir, "Gnuplot");
  630. !    dbApp = XrmGetFileDatabase(buf);
  631. !    XrmMergeDatabases(dbApp, &db);
  632. ! 
  633. !    /*---get server or ~/.Xdefaults-------------------------------------------*/
  634. ! 
  635. !    if (server_defaults)
  636. !       dbDef = XrmGetStringDatabase(server_defaults);
  637. !    else {
  638. !       sprintf(buf, "%s/.Xdefaults", home);
  639. !       dbDef = XrmGetFileDatabase(buf);
  640. !       }
  641. !    XrmMergeDatabases(dbDef, &db);
  642. ! 
  643. !    /*---get XENVIRONMENT or  ~/.Xdefaults-hostname---------------------------*/
  644. ! 
  645. !    if (env = getenv("XENVIRONMENT")) 
  646. !       dbEnv = XrmGetFileDatabase(env);
  647. !    else {
  648. !       char *p, host[MAXHOSTNAMELEN];
  649. !       if (gethostname(host, MAXHOSTNAMELEN) < 0) {
  650. !      fprintf(stderr, "gnuplot: gethostname failed. X11 aborted.\n");
  651. !      exit(1);
  652. !      }
  653. !       if (p = index(host, '.')) *p = '\0';
  654. !       sprintf(buf, "%s/.Xdefaults-%s", home, host);
  655. !       dbEnv = XrmGetFileDatabase(buf);
  656. !       }
  657. !    XrmMergeDatabases(dbEnv, &db);
  658. ! 
  659. !    /*---merge command line options-------------------------------------------*/
  660. ! 
  661. !    XrmMergeDatabases(dbCmd, &db);
  662. ! 
  663. !    /*---determine geometry, font and colors----------------------------------*/
  664. ! 
  665. !    pr_geometry();
  666. !    pr_font();
  667. !    pr_color();
  668. ! 
  669. !    /*---create window--------------------------------------------------------*/
  670. ! 
  671. !    pr_window();
  672. ! 
  673. !    } 
  674. ! 
  675. ! /*-----------------------------------------------------------------------------
  676. !  *   pr_GetR - get resource from database using "-name" option (if any)
  677. !  *---------------------------------------------------------------------------*/
  678. ! 
  679. ! char *
  680. ! pr_GetR(db, resource) XrmDatabase db; char *resource; {
  681. !    char name[128], class[128], *rc;
  682. ! 
  683. !    strcpy(name, Name); strcat(name, resource);
  684. !    strcpy(class, Class); strcat(class, resource);
  685. !    rc = XrmGetResource(db, name, class, type, &value)
  686. !       ? (char *)value.addr 
  687. !       : (char *)0;
  688. !    return(rc);
  689. !    }
  690. ! 
  691. ! /*-----------------------------------------------------------------------------
  692. !  *   pr_color - determine color values
  693. !  *---------------------------------------------------------------------------*/
  694. ! 
  695. ! char color_keys[Ncolors][30] =   { 
  696. !    "background", "bordercolor", "text", "border", "axis", 
  697. !    "line1", "line2", "line3",  "line4", 
  698. !    "line5", "line6", "line7",  "line8" 
  699. !    };
  700. ! char color_values[Ncolors][30] = { 
  701. !    "white", "black",  "black",  "black",  "black", 
  702. !    "red",   "green",  "blue",   "magenta", 
  703. !    "cyan",  "sienna", "orange", "coral" 
  704. !    };
  705. ! char gray_values[Ncolors][30] = { 
  706. !    "black",   "white",  "white",  "gray50", "gray50",
  707. !    "gray100", "gray60", "gray80", "gray40", 
  708. !    "gray90",  "gray50", "gray70", "gray30" 
  709. !    };
  710. ! 
  711. ! pr_color() {
  712. !    unsigned long black = BlackPixel(dpy, scr), white = WhitePixel(dpy,scr);
  713. !    char option[20], *v, *type = (Gray) ? "Gray" : "Color";
  714. !    XColor used, exact;
  715. !    Colormap cmap;
  716. !    int n;
  717. ! 
  718. !    pr_GetR(db, ".mono")         && On(value.addr) && Mono++;
  719. !    pr_GetR(db, ".gray")         && On(value.addr) && Gray++;
  720. !    pr_GetR(db, ".reverseVideo") && On(value.addr) && Rv++;
  721. ! 
  722. !    if (!Gray && (vis->class == GrayScale || vis->class == StaticGray)) Mono++;
  723. ! 
  724. !    if (!Mono) {
  725. !       cmap = DefaultColormap(dpy, scr);
  726. !       for (n=0; n<Ncolors; n++) {
  727. !      strcpy(option, ".");
  728. !      strcat(option, color_keys[n]);
  729. !      (n > 1) && strcat(option, type);
  730. !      v = pr_GetR(db, option) 
  731. !          ? value.addr
  732. !          : ((Gray) ? gray_values[n] : color_values[n]);
  733. !      if (XAllocNamedColor(dpy, cmap, v, &used, &exact))
  734. !         colors[n] = used.pixel;
  735. !      else {
  736. !         fprintf(stderr, "\ngnuplot: can't allocate %s:%s\n", option, v);
  737. !         fprintf(stderr, "gnuplot: reverting to monochrome\n");
  738. !         Mono++; break;
  739.           }
  740.        }
  741.         }
  742. !    if (Mono) {
  743. !       colors[0] = (Rv) ? black : white ;
  744. !       for (n=1; n<Ncolors; n++)  colors[n] = (Rv) ? white : black;
  745. !       }
  746.      }
  747.   
  748. ! /*-----------------------------------------------------------------------------
  749. !  *   pr_font - determine font          
  750. !  *---------------------------------------------------------------------------*/
  751. ! 
  752. ! pr_font() {
  753. !    char *fontname = pr_GetR(db, ".font");
  754. ! 
  755. !    if (!fontname) fontname = FallbackFont;
  756. !    font = XLoadQueryFont(dpy, fontname);
  757. !    if (!font) {
  758. !       fprintf(stderr, "\ngnuplot: can't load font '%s'\n", fontname);
  759. !       fprintf(stderr, "gnuplot: using font '%s' instead.\n", FallbackFont);
  760. !       font = XLoadQueryFont(dpy, FallbackFont);
  761. !       if (!font) {
  762. !      fprintf(stderr, "gnuplot: can't load font '%s'\n", FallbackFont);
  763. !      fprintf(stderr, "gnuplot: no useable font - X11 aborted.\n");
  764. !          exit(1);
  765. !      }
  766. !       }
  767. !    vchar = font->ascent + font->descent;
  768. !    }
  769. ! 
  770. ! /*-----------------------------------------------------------------------------
  771. !  *   pr_geometry - determine window geometry      
  772. !  *---------------------------------------------------------------------------*/
  773. ! 
  774. ! pr_geometry() {
  775. !    char *geometry = pr_GetR(db, ".geometry");
  776. !    int x, y, flags;
  777. !    unsigned int w, h; 
  778. ! 
  779. !    if (geometry) {
  780. !       flags = XParseGeometry(geometry, &x, &y, &w, &h);
  781. ! 
  782. !       if (flags & WidthValue)  W = w;
  783. !       if (flags & HeightValue) H = h;
  784. !       if (flags & XValue) {
  785. !      if (flags & XNegative) x += DisplayWidth(dpy,scr);
  786. !      gX = x;
  787. !      }
  788. !       if (flags & YValue) {
  789. !      if (flags & YNegative) y += DisplayHeight(dpy,scr);
  790. !      gY = y;
  791. !      }
  792. !       }
  793. !    }
  794. ! 
  795. ! /*-----------------------------------------------------------------------------
  796. !  *   pr_window - create window 
  797. !  *---------------------------------------------------------------------------*/
  798. ! 
  799. ! pr_window() {
  800. !    char *title =  pr_GetR(db, ".title");
  801. !    XSizeHints hints;
  802. ! 
  803. !    win = XCreateSimpleWindow(dpy, root, gX, gY, W, H, 2, colors[1], colors[0]);
  804. ! 
  805. !    pr_GetR(db, ".clear") && On(value.addr) && Clear++;
  806. ! 
  807. !    hints.flags = PPosition;
  808. !    hints.x = gX; hints.y = gY;
  809. !    XSetNormalHints(dpy, win, &hints);
  810. ! 
  811. !    if (pr_GetR(db, ".iconic") && On(value.addr)) {
  812. !       XWMHints wmh;
  813. ! 
  814. !       wmh.flags = StateHint ;
  815. !       wmh.initial_state = IconicState;
  816. !       XSetWMHints(dpy, win, &wmh);
  817. !       } 
  818. ! 
  819. !    XStoreName(dpy, win, ((title) ? title : Class));
  820. ! 
  821. !    XSelectInput(dpy, win, StructureNotifyMask);
  822. !    XMapWindow(dpy, win);
  823. !    
  824.      }
  825.