Annotation of OpenXM_contrib/gnuplot/gplt_x11.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: gplt_x11.c,v 1.71 1998/04/14 00:15:22 drd Exp $";
! 3: #endif
! 4:
! 5: /* GNUPLOT - gplt_x11.c */
! 6:
! 7: /*[
! 8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
! 9: *
! 10: * Permission to use, copy, and distribute this software and its
! 11: * documentation for any purpose with or without fee is hereby granted,
! 12: * provided that the above copyright notice appear in all copies and
! 13: * that both that copyright notice and this permission notice appear
! 14: * in supporting documentation.
! 15: *
! 16: * Permission to modify the software is granted, but not the right to
! 17: * distribute the complete modified source code. Modifications are to
! 18: * be distributed as patches to the released version. Permission to
! 19: * distribute binaries produced by compiling modified sources is granted,
! 20: * provided you
! 21: * 1. distribute the corresponding source modifications from the
! 22: * released version in the form of a patch file along with the binaries,
! 23: * 2. add special version identification to distinguish your version
! 24: * in addition to the base release version number,
! 25: * 3. provide your name and address as the primary contact for the
! 26: * support of your modified version, and
! 27: * 4. retain our contact information in regard to use of the base
! 28: * software.
! 29: * Permission to distribute the released version of the source code along
! 30: * with corresponding source modifications in the form of a patch file is
! 31: * granted with same provisions 2 through 4 for binary distributions.
! 32: *
! 33: * This software is provided "as is" without express or implied warranty
! 34: * to the extent permitted by applicable law.
! 35: ]*/
! 36:
! 37:
! 38: /* lph changes:
! 39: * (a) make EXPORT_SELECTION the default and specify NOEXPORT to undefine
! 40: * (b) append X11 terminal number to resource name
! 41: * (c) change cursor for active terminal
! 42: */
! 43:
! 44: /*-----------------------------------------------------------------------------
! 45: * gnuplot_x11 - X11 outboard terminal driver for gnuplot 3.3
! 46: *
! 47: * Requires installation of companion inboard x11 driver in gnuplot/term.c
! 48: *
! 49: * Acknowledgements:
! 50: * Chris Peterson (MIT)
! 51: * Dana Chee (Bellcore)
! 52: * Arthur Smith (Cornell)
! 53: * Hendri Hondorp (University of Twente, The Netherlands)
! 54: * Bill Kucharski (Solbourne)
! 55: * Charlie Kline (University of Illinois)
! 56: * Yehavi Bourvine (Hebrew University of Jerusalem, Israel)
! 57: * Russell Lang (Monash University, Australia)
! 58: * O'Reilly & Associates: X Window System - Volumes 1 & 2
! 59: *
! 60: * This code is provided as is and with no warranties of any kind.
! 61: *
! 62: * drd: change to allow multiple windows to be maintained independently
! 63: *
! 64: * There is a mailing list for gnuplot users. Note, however, that the
! 65: * newsgroup
! 66: * comp.graphics.apps.gnuplot
! 67: * is identical to the mailing list (they
! 68: * both carry the same set of messages). We prefer that you read the
! 69: * messages through that newsgroup, to subscribing to the mailing list.
! 70: * (If you can read that newsgroup, and are already on the mailing list,
! 71: * please send a message to majordomo@dartmouth.edu, asking to be
! 72: * removed from the mailing list.)
! 73: *
! 74: * The address for mailing to list members is
! 75: * info-gnuplot@dartmouth.edu
! 76: * and for mailing administrative requests is
! 77: * majordomo@dartmouth.edu
! 78: * The mailing list for bug reports is
! 79: * bug-gnuplot@dartmouth.edu
! 80: * The list of those interested in beta-test versions is
! 81: * info-gnuplot-beta@dartmouth.edu
! 82: *---------------------------------------------------------------------------*/
! 83:
! 84: /* drd : export the graph via ICCCM primary selection. well... not quite
! 85: * ICCCM since we dont support full list of targets, but this
! 86: * is a start. define EXPORT_SELECTION if you want this feature
! 87: */
! 88:
! 89: /*lph: add a "feature" to undefine EXPORT_SELECTION
! 90: The following makes EXPORT_SELECTION the default and
! 91: defining NOEXPORT over-rides the default
! 92: */
! 93:
! 94: #ifdef HAVE_CONFIG_H
! 95: # include "config.h"
! 96: #endif
! 97:
! 98: #ifdef EXPORT_SELECTION
! 99: # undef EXPORT_SELECTION
! 100: #endif /* EXPORT SELECTION */
! 101: #ifndef NOEXPORT
! 102: # define EXPORT_SELECTION XA_PRIMARY
! 103: #endif /* NOEXPORT */
! 104:
! 105:
! 106: #if !(defined(VMS) || defined(CRIPPLED_SELECT))
! 107: # define DEFAULT_X11
! 108: #endif
! 109:
! 110: #if defined(VMS) && defined(CRIPPLED_SELECT)
! 111: Error. Incompatible options.
! 112: #endif
! 113:
! 114:
! 115: #include <X11/Xos.h>
! 116: #include <X11/Xlib.h>
! 117: #include <X11/Xresource.h>
! 118: #include <X11/Xutil.h>
! 119: #include <X11/Xatom.h>
! 120: #include <X11/keysym.h>
! 121:
! 122: #include <signal.h>
! 123:
! 124: #ifdef HAVE_SYS_BSDTYPES_H
! 125: # include <sys/bsdtypes.h>
! 126: #endif /* HAVE_SYS_BSDTYPES_H */
! 127:
! 128: #ifdef __EMX__
! 129: /* for gethostname ... */
! 130: # include <netdb.h>
! 131: #endif
! 132:
! 133: #if defined(HAVE_SYS_SELECT_H) && !defined(VMS)
! 134: # include <sys/select.h>
! 135: #endif /* HAVE_SYS_SELECT_H && !VMS */
! 136:
! 137: #ifndef FD_SET
! 138: # define FD_SET(n, p) ((p)->fds_bits[0] |= (1 << ((n) % 32)))
! 139: # define FD_CLR(n, p) ((p)->fds_bits[0] &= ~(1 << ((n) % 32)))
! 140: # define FD_ISSET(n, p) ((p)->fds_bits[0] & (1 << ((n) % 32)))
! 141: # define FD_ZERO(p) memset((char *)(p),'\0',sizeof(*(p)))
! 142: #endif /* not FD_SET */
! 143:
! 144: #include "plot.h"
! 145:
! 146: #if defined(HAVE_SYS_SYSTEMINFO_H) && defined(HAVE_SYSINFO)
! 147: # include <sys/systeminfo.h>
! 148: # define SYSINFO_METHOD "sysinfo"
! 149: # define GP_SYSTEMINFO(host) sysinfo (SI_HOSTNAME, (host), MAXHOSTNAMELEN)
! 150: #else
! 151: # define SYSINFO_METHOD "gethostname"
! 152: # define GP_SYSTEMINFO(host) gethostname ((host), MAXHOSTNAMELEN)
! 153: #endif /* HAVE_SYS_SYSTEMINFO_H && HAVE_SYSINFO */
! 154:
! 155: #ifdef VMS
! 156: # ifdef __DECC
! 157: # include <starlet.h>
! 158: # endif /* __DECC */
! 159: # define EXIT(status) sys$delprc(0,0) /* VMS does not drop itself */
! 160: #else
! 161: # define EXIT(status) exit(status)
! 162: #endif
! 163:
! 164: #ifdef OSK
! 165: # define EINTR E_ILLFNC
! 166: #endif
! 167:
! 168: /* information about one window/plot */
! 169:
! 170: typedef struct plot_struct {
! 171: Window window;
! 172: Pixmap pixmap;
! 173: unsigned int posn_flags;
! 174: int x, y;
! 175: unsigned int width, height; /* window size */
! 176: unsigned int px, py; /* pointsize */
! 177: int ncommands, max_commands;
! 178: char **commands;
! 179: } plot_struct;
! 180:
! 181: void store_command __PROTO((char *line, plot_struct * plot));
! 182: void prepare_plot __PROTO((plot_struct * plot, int term_number));
! 183: void delete_plot __PROTO((plot_struct * plot));
! 184:
! 185: int record __PROTO((void));
! 186: void process_event __PROTO((XEvent * event)); /* from Xserver */
! 187:
! 188: void mainloop __PROTO((void));
! 189:
! 190: void display __PROTO((plot_struct * plot));
! 191:
! 192: void reset_cursor __PROTO((void));
! 193:
! 194: void preset __PROTO((int argc, char *argv[]));
! 195: char *pr_GetR __PROTO((XrmDatabase db, char *resource));
! 196: void pr_color __PROTO((void));
! 197: void pr_dashes __PROTO((void));
! 198: void pr_font __PROTO((void));
! 199: void pr_geometry __PROTO((void));
! 200: void pr_pointsize __PROTO((void));
! 201: void pr_width __PROTO((void));
! 202: Window pr_window __PROTO((unsigned int flags, int x, int y, unsigned int width, unsigned height));
! 203: void pr_raise __PROTO((void));
! 204: void pr_persist __PROTO((void));
! 205:
! 206: #ifdef EXPORT_SELECTION
! 207: void export_graph __PROTO((plot_struct * plot));
! 208: void handle_selection_event __PROTO((XEvent * event));
! 209: #endif
! 210:
! 211: #define FallbackFont "fixed"
! 212:
! 213: #define Ncolors 13
! 214: unsigned long colors[Ncolors];
! 215:
! 216: #define Nwidths 10
! 217: unsigned int widths[Nwidths] = { 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
! 218:
! 219: #define Ndashes 10
! 220: char dashes[Ndashes][5];
! 221:
! 222: #define MAX_WINDOWS 16
! 223:
! 224: #define XC_crosshair 34
! 225:
! 226:
! 227: struct plot_struct plot_array[MAX_WINDOWS];
! 228:
! 229:
! 230: Display *dpy;
! 231: int scr;
! 232: Window root;
! 233: Visual *vis;
! 234: GC gc = (GC) 0;
! 235: XFontStruct *font;
! 236: int do_raise = 1, persist = 0;
! 237: KeyCode q_keycode;
! 238: Cursor cursor;
! 239:
! 240: int windows_open = 0;
! 241:
! 242: int gX = 100, gY = 100;
! 243: unsigned int gW = 640, gH = 450;
! 244: unsigned int gFlags = PSize;
! 245:
! 246: unsigned int BorderWidth = 2;
! 247: unsigned int D; /* depth */
! 248:
! 249: Bool Mono = 0, Gray = 0, Rv = 0, Clear = 0;
! 250: char Name[64] = "gnuplot";
! 251: char Class[64] = "Gnuplot";
! 252:
! 253: int cx = 0, cy = 0, vchar;
! 254: double xscale, yscale, pointsize;
! 255: #define X(x) (int) ((x) * xscale)
! 256: #define Y(y) (int) ((4095-(y)) * yscale)
! 257:
! 258: #define Nbuf 1024
! 259: char buf[Nbuf], **commands = (char **) 0;
! 260:
! 261: FILE *X11_ipc;
! 262: char X11_ipcpath[32];
! 263:
! 264: /* when using an ICCCM-compliant window manager, we can ask it
! 265: * to send us an event when user chooses 'close window'. We do this
! 266: * by setting WM_DELETE_WINDOW atom in property WM_PROTOCOLS
! 267: */
! 268:
! 269: Atom WM_PROTOCOLS, WM_DELETE_WINDOW;
! 270:
! 271: XPoint Diamond[5], Triangle[4];
! 272: XSegment Plus[2], Cross[2], Star[4];
! 273:
! 274: /*-----------------------------------------------------------------------------
! 275: * main program
! 276: *---------------------------------------------------------------------------*/
! 277:
! 278: int main(argc, argv)
! 279: int argc;
! 280: char *argv[];
! 281: {
! 282:
! 283:
! 284: #ifdef OSK
! 285: /* malloc large blocks, otherwise problems with fragmented mem */
! 286: _mallocmin(102400);
! 287: #endif
! 288: #ifdef __EMX__
! 289: /* close open file handles */
! 290: fcloseall();
! 291: #endif
! 292:
! 293: FPRINTF((stderr, "gnuplot_X11 starting up\n"));
! 294:
! 295: preset(argc, argv);
! 296:
! 297: /* set up the alternative cursor */
! 298: cursor = XCreateFontCursor(dpy, XC_crosshair);
! 299:
! 300: mainloop();
! 301:
! 302: if (persist) {
! 303: FPRINTF((stderr, "waiting for %d windows\n, windows_open"));
! 304: /* read x events until all windows have been quit */
! 305: while (windows_open > 0) {
! 306: XEvent event;
! 307: XNextEvent(dpy, &event);
! 308: process_event(&event);
! 309: }
! 310: }
! 311: XCloseDisplay(dpy);
! 312:
! 313: FPRINTF((stderr, "exiting\n"));
! 314:
! 315: EXIT(0);
! 316: }
! 317:
! 318: /*-----------------------------------------------------------------------------
! 319: * mainloop processing - process X events and input from gnuplot
! 320: *
! 321: * Three different versions of main loop processing are provided to support
! 322: * three different platforms.
! 323: *
! 324: * DEFAULT_X11: use select() for both X events and input on stdin
! 325: * from gnuplot inboard driver
! 326: *
! 327: * CRIPPLED_SELECT: use select() to service X events and check during
! 328: * select timeout for temporary plot file created
! 329: * by inboard driver
! 330: *
! 331: * VMS: use XNextEvent to service X events and AST to
! 332: * service input from gnuplot inboard driver on stdin
! 333: *---------------------------------------------------------------------------*/
! 334:
! 335:
! 336: #ifdef DEFAULT_X11
! 337: /*-----------------------------------------------------------------------------
! 338: * DEFAULT_X11 mainloop
! 339: *---------------------------------------------------------------------------*/
! 340:
! 341: void mainloop()
! 342: {
! 343: int nf, nfds, cn = ConnectionNumber(dpy), in;
! 344: struct timeval *timer = (struct timeval *) 0;
! 345: #ifdef ISC22
! 346: struct timeval timeout;
! 347: #endif
! 348: fd_set rset, tset;
! 349:
! 350: X11_ipc = stdin;
! 351: in = fileno(X11_ipc);
! 352:
! 353: FD_ZERO(&rset);
! 354: FD_SET(cn, &rset);
! 355:
! 356: FD_SET(in, &rset);
! 357: nfds = (cn > in) ? cn + 1 : in + 1;
! 358:
! 359: #ifdef ISC22
! 360: /* Added by Robert Eckardt, RobertE@beta.TP2.Ruhr-Uni-Bochum.de */
! 361: timeout.tv_sec = 0; /* select() in ISC2.2 needs timeout */
! 362: timeout.tv_usec = 300000; /* otherwise input from gnuplot is */
! 363: timer = &timeout; /* suspended til next X event. */
! 364: #endif /* ISC22 (0.3s are short enough not to be noticed */
! 365:
! 366: while (1) {
! 367:
! 368: /* XNextEvent does an XFlush() before waiting. But here.
! 369: * we must ensure that the queue is flushed, since we
! 370: * dont call XNextEvent until an event arrives. (I have
! 371: * twice wasted quite some time over this issue, so now
! 372: * I am making sure of it !
! 373: */
! 374:
! 375: XFlush(dpy);
! 376:
! 377: tset = rset;
! 378: nf = select((gp_nfds_t)nfds, gp_fd_set_p &tset, gp_fd_set_p 0,
! 379: gp_fd_set_p 0, gp_timeval_p timer);
! 380: if (nf < 0) {
! 381: if (errno == EINTR)
! 382: continue;
! 383: fprintf(stderr, "gnuplot: select failed. errno:%d\n", errno);
! 384: EXIT(1);
! 385: }
! 386: if (nf > 0)
! 387: XNoOp(dpy);
! 388:
! 389: if (FD_ISSET(cn, &tset)) {
! 390: /* used to use CheckMaskEvent() but that cannot receive
! 391: * maskable events such as ClientMessage. So now we do
! 392: * one event, then return to the select.
! 393: * And that almost works, except that under some Xservers
! 394: * running without a window manager (e.g. Hummingbird Exceed under Win95)
! 395: * a bogus ConfigureNotify is sent followed by a valid ConfigureNotify
! 396: * when the window is maximized. The two events are queued, apparently
! 397: * in a single I/O because select() above doesn't see the second, valid
! 398: * event. This little loop fixes the problem by flushing the
! 399: * event queue completely.
! 400: */
! 401: XEvent xe;
! 402: do {
! 403: XNextEvent(dpy, &xe);
! 404: process_event(&xe);
! 405: } while (XPending(dpy));
! 406: }
! 407: if (FD_ISSET(in, &tset)) {
! 408: if (!record()) /* end of input */
! 409: return;
! 410: }
! 411: }
! 412: }
! 413:
! 414: #endif
! 415:
! 416:
! 417: #ifdef CRIPPLED_SELECT
! 418: /*-----------------------------------------------------------------------------
! 419: * CRIPPLED_SELECT mainloop
! 420: *---------------------------------------------------------------------------*/
! 421:
! 422: void mainloop()
! 423: {
! 424: int nf, nfds, cn = ConnectionNumber(dpy);
! 425: struct timeval timeout, *timer;
! 426: fd_set rset, tset;
! 427: unsigned long all = (unsigned long) (-1L);
! 428: XEvent xe;
! 429:
! 430: FD_ZERO(&rset);
! 431: FD_SET(cn, &rset);
! 432:
! 433: timeout.tv_sec = 1;
! 434: timeout.tv_usec = 0;
! 435: timer = &timeout;
! 436: sprintf(X11_ipcpath, "/tmp/Gnuplot_%d", getppid());
! 437: nfds = cn + 1;
! 438:
! 439: while (1) {
! 440: XFlush(dpy); /* see above */
! 441: tset = rset;
! 442: nf = select((gp_nfds_t)nfds, gp_fd_set_p &tset, gp_fd_set_p 0,
! 443: gp_fd_set_p 0, gp_timeval_p timer);
! 444: if (nf < 0) {
! 445: if (errno == EINTR)
! 446: continue;
! 447: fprintf(stderr, "gnuplot: select failed. errno:%d\n", errno);
! 448: EXIT(1);
! 449: }
! 450: nf > 0 && XNoOp(dpy);
! 451: if (FD_ISSET(cn, &tset)) {
! 452: while (XCheckMaskEvent(dpy, all, &xe)) {
! 453: process_event(&xe);
! 454: }
! 455: }
! 456: if ((X11_ipc = fopen(X11_ipcpath, "r"))) {
! 457: unlink(X11_ipcpath);
! 458: record();
! 459: fclose(X11_ipc);
! 460: }
! 461: }
! 462: }
! 463: #endif /* CRIPPLED_SELECT */
! 464:
! 465:
! 466: #ifdef VMS
! 467: /*-----------------------------------------------------------------------------
! 468: * VMS mainloop - Yehavi Bourvine - YEHAVI@VMS.HUJI.AC.IL
! 469: *---------------------------------------------------------------------------*/
! 470:
! 471: /* In VMS there is no decent Select(). hence, we have to loop inside
! 472: * XGetNextEvent for getting the next X window event. In order to get input
! 473: * from the master we assign a channel to SYS$INPUT and use AST's in order to
! 474: * receive data. In order to exit the mainloop, we need to somehow make XNextEvent
! 475: * return from within the ast. We do this with a XSendEvent() to ourselves !
! 476: * This needs a window to send the message to, so we create an unmapped window
! 477: * for this purpose. Event type XClientMessage is perfect for this, but it
! 478: * appears that such messages come from elsewhere (motif window manager, perhaps ?)
! 479: * So we need to check fairly carefully that it is the ast event that has been received.
! 480: */
! 481:
! 482: #include <iodef.h>
! 483: char STDIIN[] = "SYS$INPUT:";
! 484: short STDIINchannel, STDIINiosb[4];
! 485: struct { short size, type; char *address; } STDIINdesc;
! 486: char STDIINbuffer[64];
! 487: int status;
! 488:
! 489: ast()
! 490: {
! 491: int status = sys$qio(0, STDIINchannel, IO$_READVBLK, STDIINiosb, record,
! 492: 0, STDIINbuffer, sizeof(STDIINbuffer) - 1, 0, 0, 0, 0);
! 493: if ((status & 0x1) == 0)
! 494: EXIT(status);
! 495: }
! 496:
! 497: Window message_window;
! 498:
! 499: void mainloop()
! 500: {
! 501: /* dummy unmapped window for receiving internally-generated terminate
! 502: * messages
! 503: */
! 504: message_window = XCreateSimpleWindow(dpy, root, 0, 0, 1, 1, 1, 0, 0);
! 505:
! 506: STDIINdesc.size = strlen(STDIIN);
! 507: STDIINdesc.type = 0;
! 508: STDIINdesc.address = STDIIN;
! 509: status = sys$assign(&STDIINdesc, &STDIINchannel, 0, 0, 0);
! 510: if ((status & 0x1) == 0)
! 511: EXIT(status);
! 512: ast();
! 513:
! 514: for (;;) {
! 515: XEvent xe;
! 516: XNextEvent(dpy, &xe);
! 517: if (xe.type == ClientMessage && xe.xclient.window == message_window) {
! 518: if (xe.xclient.message_type == None &&
! 519: xe.xclient.format == 8 &&
! 520: strcmp(xe.xclient.data.b, "die gnuplot die") == 0) {
! 521: FPRINTF((stderr, "quit message from ast\n"));
! 522: return;
! 523: } else {
! 524: FPRINTF((stderr, "Bogus XClientMessage event from window manager ?\n"));
! 525: }
! 526: }
! 527: process_event(&xe);
! 528: }
! 529: }
! 530:
! 531: #endif /* VMS */
! 532:
! 533: /* delete a window / plot */
! 534:
! 535: void delete_plot(plot)
! 536: plot_struct *plot;
! 537: {
! 538: int i;
! 539:
! 540: FPRINTF((stderr, "Delete plot %d\n", plot - plot_array));
! 541:
! 542: for (i = 0; i < plot->ncommands; ++i)
! 543: free(plot->commands[i]);
! 544: plot->ncommands = 0;
! 545:
! 546: if (plot->window) {
! 547: FPRINTF((stderr, "Destroy window 0x%x\n", plot->window));
! 548: XDestroyWindow(dpy, plot->window);
! 549: plot->window = None;
! 550: --windows_open;
! 551: }
! 552: if (plot->pixmap) {
! 553: XFreePixmap(dpy, plot->pixmap);
! 554: plot->pixmap = None;
! 555: }
! 556: /* but preserve geometry */
! 557: }
! 558:
! 559:
! 560: /* prepare the plot structure */
! 561:
! 562: void prepare_plot(plot, term_number)
! 563: plot_struct *plot;
! 564: int term_number;
! 565: {
! 566: int i;
! 567: char *term_name;
! 568:
! 569: for (i = 0; i < plot->ncommands; ++i)
! 570: free(plot->commands[i]);
! 571: plot->ncommands = 0;
! 572:
! 573: if (!plot->posn_flags) {
! 574: /* first time this window has been used - use default or -geometry
! 575: * settings
! 576: */
! 577: plot->posn_flags = gFlags;
! 578: plot->x = gX;
! 579: plot->y = gY;
! 580: plot->width = gW;
! 581: plot->height = gH;
! 582: }
! 583:
! 584: if (!plot->window) {
! 585: plot->window = pr_window(plot->posn_flags, plot->x, plot->y, plot->width, plot->height);
! 586: ++windows_open;
! 587:
! 588: /* append the X11 terminal number (if greater than zero) */
! 589:
! 590: if (term_number) {
! 591: char new_name[60];
! 592: XFetchName(dpy, plot->window, &term_name);
! 593: FPRINTF((stderr, "Window title is %s\n", term_name));
! 594:
! 595: sprintf(new_name, "%.55s%3d", term_name, term_number);
! 596: FPRINTF((stderr, "term_number is %d\n", term_number));
! 597:
! 598: XStoreName(dpy, plot->window, new_name);
! 599:
! 600: sprintf(new_name, "gplt%3d", term_number);
! 601: XSetIconName(dpy, plot->window, new_name);
! 602: }
! 603: }
! 604: /* We don't know that it is the same window as before, so we reset the
! 605: * cursors for all windows and then define the cursor for the active
! 606: * window
! 607: */
! 608: reset_cursor();
! 609: XDefineCursor(dpy, plot->window, cursor);
! 610:
! 611: }
! 612:
! 613: /* store a command in a plot structure */
! 614:
! 615: void store_command(buffer, plot)
! 616: char *buffer;
! 617: plot_struct *plot;
! 618: {
! 619: char *p;
! 620:
! 621: FPRINTF((stderr, "Store in %d : %s", plot - plot_array, buffer));
! 622:
! 623: if (plot->ncommands >= plot->max_commands) {
! 624: plot->max_commands = plot->max_commands * 2 + 1;
! 625: plot->commands = (plot->commands)
! 626: ? (char **) realloc(plot->commands, plot->max_commands * sizeof(char *))
! 627: : (char **) malloc(sizeof(char *));
! 628: }
! 629: p = (char *) malloc((unsigned) strlen(buffer) + 1);
! 630: if (!plot->commands || !p) {
! 631: fputs("gnuplot: can't get memory. X11 aborted.\n", stderr);
! 632: EXIT(1);
! 633: }
! 634: plot->commands[plot->ncommands++] = strcpy(p, buffer);
! 635: }
! 636:
! 637: #ifndef VMS
! 638: /*-----------------------------------------------------------------------------
! 639: * record - record new plot from gnuplot inboard X11 driver (Unix)
! 640: *---------------------------------------------------------------------------*/
! 641:
! 642: int record()
! 643: {
! 644: static plot_struct *plot = plot_array;
! 645:
! 646: while (fgets(buf, Nbuf, X11_ipc)) {
! 647: switch (*buf) {
! 648: case 'G': /* enter graphics mode */
! 649: {
! 650: int plot_number = atoi(buf + 1); /* 0 if none specified */
! 651:
! 652: if (plot_number < 0 || plot_number >= MAX_WINDOWS)
! 653: plot_number = 0;
! 654:
! 655: FPRINTF((stderr, "plot for window number %d\n", plot_number));
! 656: plot = plot_array + plot_number;
! 657: prepare_plot(plot, plot_number);
! 658: continue;
! 659: }
! 660: case 'E': /* leave graphics mode / suspend */
! 661: display(plot);
! 662: return 1;
! 663: case 'R': /* leave x11 mode */
! 664: reset_cursor();
! 665: return 0;
! 666: default:
! 667: store_command(buf, plot);
! 668: continue;
! 669: }
! 670: }
! 671:
! 672: /* get here if fgets fails */
! 673:
! 674: #ifdef OSK
! 675: if (feof(X11_ipc)) /* On OS-9 sometimes while resizing the window, */
! 676: _cleareof(X11_ipc); /* and plotting data, the eof or error flag of */
! 677: if (ferror(X11_ipc)) /* X11_ipc stream gets set, while there is */
! 678: clearerr(X11_ipc); /* nothing wrong! Probably a bug in my select()? */
! 679: #else
! 680: if (feof(X11_ipc) || ferror(X11_ipc))
! 681: return 0;
! 682: #endif /* not OSK */
! 683:
! 684: return 1;
! 685: }
! 686:
! 687: #else /* VMS */
! 688: /*-----------------------------------------------------------------------------
! 689: * record - record new plot from gnuplot inboard X11 driver (VMS)
! 690: *---------------------------------------------------------------------------*/
! 691:
! 692: record()
! 693: {
! 694: static plot_struct *plot = plot_array;
! 695:
! 696: int status;
! 697:
! 698: if ((STDIINiosb[0] & 0x1) == 0)
! 699: EXIT(STDIINiosb[0]);
! 700: STDIINbuffer[STDIINiosb[1]] = '\0';
! 701: strcpy(buf, STDIINbuffer);
! 702:
! 703: switch (*buf) {
! 704: case 'G': /* enter graphics mode */
! 705: {
! 706: int plot_number = atoi(buf + 1); /* 0 if none specified */
! 707: if (plot_number < 0 || plot_number >= MAX_WINDOWS)
! 708: plot_number = 0;
! 709: FPRINTF((stderr, "plot for window number %d\n", plot_number));
! 710: plot = plot_array + plot_number;
! 711: prepare_plot(plot, plot_number);
! 712: break;
! 713: }
! 714: case 'E': /* leave graphics mode */
! 715: display(plot);
! 716: break;
! 717: case 'R': /* exit x11 mode */
! 718: FPRINTF((stderr, "received R - sending ClientMessage\n"));
! 719: reset_cursor();
! 720: sys$cancel(STDIINchannel);
! 721: /* this is ridiculous - cook up an event to ourselves,
! 722: * in order to get the mainloop() out of the XNextEvent() call
! 723: * it seems that window manager can also send clientmessages,
! 724: * so put a checksum into the message
! 725: */
! 726: {
! 727: XClientMessageEvent event;
! 728: event.type = ClientMessage;
! 729: event.send_event = True;
! 730: event.display = dpy;
! 731: event.window = message_window;
! 732: event.message_type = None;
! 733: event.format = 8;
! 734: strcpy(event.data.b, "die gnuplot die");
! 735: XSendEvent(dpy, message_window, False, 0, (XEvent *) & event);
! 736: XFlush(dpy);
! 737: }
! 738: return; /* no ast */
! 739: default:
! 740: store_command(buf, plot);
! 741: break;
! 742: }
! 743: ast();
! 744: }
! 745: #endif /* VMS */
! 746:
! 747:
! 748: /*-----------------------------------------------------------------------------
! 749: * display - display a stored plot
! 750: *---------------------------------------------------------------------------*/
! 751:
! 752: void display(plot)
! 753: plot_struct *plot;
! 754: {
! 755: int n, x, y, sw, sl, lt = 0, width, type, point, px, py;
! 756: int user_width = 1; /* as specified by plot...linewidth */
! 757: char *buffer, *str;
! 758: enum JUSTIFY jmode;
! 759:
! 760: FPRINTF((stderr, "Display %d ; %d commands\n", plot - plot_array, plot->ncommands));
! 761:
! 762: if (plot->ncommands == 0)
! 763: return;
! 764:
! 765: /* set scaling factor between internal driver & window geometry */
! 766: xscale = plot->width / 4096.0;
! 767: yscale = plot->height / 4096.0;
! 768:
! 769: /* initial point sizes, until overridden with P7xxxxyyyy */
! 770: px = (int) (xscale * pointsize);
! 771: py = (int) (yscale * pointsize);
! 772:
! 773: /* create new pixmap & GC */
! 774: if (gc)
! 775: XFreeGC(dpy, gc);
! 776:
! 777: if (!plot->pixmap) {
! 778: FPRINTF((stderr, "Create pixmap %d : %dx%dx%d\n", plot - plot_array, plot->width, plot->height, D));
! 779: plot->pixmap = XCreatePixmap(dpy, root, plot->width, plot->height, D);
! 780: }
! 781:
! 782: gc = XCreateGC(dpy, plot->pixmap, 0, (XGCValues *) 0);
! 783:
! 784: XSetFont(dpy, gc, font->fid);
! 785:
! 786: /* set pixmap background */
! 787: XSetForeground(dpy, gc, colors[0]);
! 788: XFillRectangle(dpy, plot->pixmap, gc, 0, 0, plot->width, plot->height);
! 789: XSetBackground(dpy, gc, colors[0]);
! 790:
! 791: if (!plot->window) {
! 792: plot->window = pr_window(plot->posn_flags, plot->x, plot->y, plot->width, plot->height);
! 793: ++windows_open;
! 794: }
! 795: /* top the window but don't put keyboard or mouse focus into it. */
! 796: if (do_raise)
! 797: XMapRaised(dpy, plot->window);
! 798:
! 799: /* momentarily clear the window first if requested */
! 800: if (Clear) {
! 801: XClearWindow(dpy, plot->window);
! 802: XFlush(dpy);
! 803: }
! 804: /* loop over accumulated commands from inboard driver */
! 805: for (n = 0; n < plot->ncommands; n++) {
! 806: buffer = plot->commands[n];
! 807:
! 808: /* X11_vector(x,y) - draw vector */
! 809: if (*buffer == 'V') {
! 810: sscanf(buffer, "V%4d%4d", &x, &y);
! 811: XDrawLine(dpy, plot->pixmap, gc, X(cx), Y(cy), X(x), Y(y));
! 812: cx = x;
! 813: cy = y;
! 814: }
! 815: /* X11_move(x,y) - move */
! 816: else if (*buffer == 'M')
! 817: sscanf(buffer, "M%4d%4d", &cx, &cy);
! 818:
! 819: /* X11_put_text(x,y,str) - draw text */
! 820: else if (*buffer == 'T') {
! 821: sscanf(buffer, "T%4d%4d", &x, &y);
! 822: str = buffer + 9;
! 823: sl = strlen(str) - 1;
! 824: sw = XTextWidth(font, str, sl);
! 825:
! 826: switch (jmode) {
! 827: case LEFT:
! 828: sw = 0;
! 829: break;
! 830: case CENTRE:
! 831: sw = -sw / 2;
! 832: break;
! 833: case RIGHT:
! 834: sw = -sw;
! 835: break;
! 836: }
! 837:
! 838: XSetForeground(dpy, gc, colors[2]);
! 839: XDrawString(dpy, plot->pixmap, gc, X(x) + sw, Y(y) + vchar / 3, str, sl);
! 840: XSetForeground(dpy, gc, colors[lt + 3]);
! 841: } else if (*buffer == 'F') { /* fill box */
! 842: int style, xtmp, ytmp, w, h;
! 843:
! 844: if (sscanf(buffer + 1, "%4d%4d%4d%4d%4d", &style, &xtmp, &ytmp, &w, &h) == 5) {
! 845: /* gnuplot has origin at bottom left, but X uses top left
! 846: * There may be an off-by-one (or more) error here.
! 847: * style ignored here for the moment
! 848: */
! 849: ytmp += h; /* top left corner of rectangle to be filled */
! 850: w *= xscale;
! 851: h *= yscale;
! 852: XSetForeground(dpy, gc, colors[0]);
! 853: XFillRectangle(dpy, plot->pixmap, gc, X(xtmp), Y(ytmp), w, h);
! 854: XSetForeground(dpy, gc, colors[lt + 3]);
! 855: }
! 856: }
! 857: /* X11_justify_text(mode) - set text justification mode */
! 858: else if (*buffer == 'J')
! 859: sscanf(buffer, "J%4d", (int *) &jmode);
! 860:
! 861: /* X11_linewidth(width) - set line width */
! 862: else if (*buffer == 'W')
! 863: sscanf(buffer + 1, "%4d", &user_width);
! 864:
! 865: /* X11_linetype(type) - set line type */
! 866: else if (*buffer == 'L') {
! 867: sscanf(buffer, "L%4d", <);
! 868: lt = (lt % 8) + 2;
! 869: /* default width is 0 {which X treats as 1} */
! 870: width = widths[lt] ? user_width * widths[lt] : user_width;
! 871: if (dashes[lt][0]) {
! 872: type = LineOnOffDash;
! 873: XSetDashes(dpy, gc, 0, dashes[lt], strlen(dashes[lt]));
! 874: } else {
! 875: type = LineSolid;
! 876: }
! 877: XSetForeground(dpy, gc, colors[lt + 3]);
! 878: XSetLineAttributes(dpy, gc, width, type, CapButt, JoinBevel);
! 879: }
! 880: /* X11_point(number) - draw a point */
! 881: else if (*buffer == 'P') {
! 882: /* linux sscanf does not like %1d%4d%4d" with Oxxxxyyyy */
! 883: /* sscanf(buffer, "P%1d%4d%4d", &point, &x, &y); */
! 884: point = buffer[1] - '0';
! 885: sscanf(buffer + 2, "%4d%4d", &x, &y);
! 886: if (point == 7) {
! 887: /* set point size */
! 888: px = (int) (x * xscale * pointsize);
! 889: py = (int) (y * yscale * pointsize);
! 890: } else {
! 891: if (type != LineSolid || width != 0) { /* select solid line */
! 892: XSetLineAttributes(dpy, gc, 0, LineSolid, CapButt, JoinBevel);
! 893: }
! 894: switch (point) {
! 895: case 0: /* dot */
! 896: XDrawPoint(dpy, plot->pixmap, gc, X(x), Y(y));
! 897: break;
! 898: case 1: /* do diamond */
! 899: Diamond[0].x = (short) X(x) - px;
! 900: Diamond[0].y = (short) Y(y);
! 901: Diamond[1].x = (short) px;
! 902: Diamond[1].y = (short) -py;
! 903: Diamond[2].x = (short) px;
! 904: Diamond[2].y = (short) py;
! 905: Diamond[3].x = (short) -px;
! 906: Diamond[3].y = (short) py;
! 907: Diamond[4].x = (short) -px;
! 908: Diamond[4].y = (short) -py;
! 909:
! 910: /*
! 911: * Should really do a check with XMaxRequestSize()
! 912: */
! 913: XDrawLines(dpy, plot->pixmap, gc, Diamond, 5, CoordModePrevious);
! 914: XDrawPoint(dpy, plot->pixmap, gc, X(x), Y(y));
! 915: break;
! 916: case 2: /* do plus */
! 917: Plus[0].x1 = (short) X(x) - px;
! 918: Plus[0].y1 = (short) Y(y);
! 919: Plus[0].x2 = (short) X(x) + px;
! 920: Plus[0].y2 = (short) Y(y);
! 921: Plus[1].x1 = (short) X(x);
! 922: Plus[1].y1 = (short) Y(y) - py;
! 923: Plus[1].x2 = (short) X(x);
! 924: Plus[1].y2 = (short) Y(y) + py;
! 925:
! 926: XDrawSegments(dpy, plot->pixmap, gc, Plus, 2);
! 927: break;
! 928: case 3: /* do box */
! 929: XDrawRectangle(dpy, plot->pixmap, gc, X(x) - px, Y(y) - py, (px + px), (py + py));
! 930: XDrawPoint(dpy, plot->pixmap, gc, X(x), Y(y));
! 931: break;
! 932: case 4: /* do X */
! 933: Cross[0].x1 = (short) X(x) - px;
! 934: Cross[0].y1 = (short) Y(y) - py;
! 935: Cross[0].x2 = (short) X(x) + px;
! 936: Cross[0].y2 = (short) Y(y) + py;
! 937: Cross[1].x1 = (short) X(x) - px;
! 938: Cross[1].y1 = (short) Y(y) + py;
! 939: Cross[1].x2 = (short) X(x) + px;
! 940: Cross[1].y2 = (short) Y(y) - py;
! 941:
! 942: XDrawSegments(dpy, plot->pixmap, gc, Cross, 2);
! 943: break;
! 944: case 5: /* do triangle */
! 945: {
! 946: short temp_x, temp_y;
! 947:
! 948: temp_x = (short) (1.33 * (double) px + 0.5);
! 949: temp_y = (short) (1.33 * (double) py + 0.5);
! 950:
! 951: Triangle[0].x = (short) X(x);
! 952: Triangle[0].y = (short) Y(y) - temp_y;
! 953: Triangle[1].x = (short) temp_x;
! 954: Triangle[1].y = (short) 2 *py;
! 955: Triangle[2].x = (short) -(2 * temp_x);
! 956: Triangle[2].y = (short) 0;
! 957: Triangle[3].x = (short) temp_x;
! 958: Triangle[3].y = (short) -(2 * py);
! 959:
! 960: XDrawLines(dpy, plot->pixmap, gc, Triangle, 4, CoordModePrevious);
! 961: XDrawPoint(dpy, plot->pixmap, gc, X(x), Y(y));
! 962: }
! 963: break;
! 964: case 6: /* do star */
! 965: Star[0].x1 = (short) X(x) - px;
! 966: Star[0].y1 = (short) Y(y);
! 967: Star[0].x2 = (short) X(x) + px;
! 968: Star[0].y2 = (short) Y(y);
! 969: Star[1].x1 = (short) X(x);
! 970: Star[1].y1 = (short) Y(y) - py;
! 971: Star[1].x2 = (short) X(x);
! 972: Star[1].y2 = (short) Y(y) + py;
! 973: Star[2].x1 = (short) X(x) - px;
! 974: Star[2].y1 = (short) Y(y) - py;
! 975: Star[2].x2 = (short) X(x) + px;
! 976: Star[2].y2 = (short) Y(y) + py;
! 977: Star[3].x1 = (short) X(x) - px;
! 978: Star[3].y1 = (short) Y(y) + py;
! 979: Star[3].x2 = (short) X(x) + px;
! 980: Star[3].y2 = (short) Y(y) - py;
! 981:
! 982: XDrawSegments(dpy, plot->pixmap, gc, Star, 4);
! 983: break;
! 984: }
! 985: if (type != LineSolid || width != 0) { /* select solid line */
! 986: XSetLineAttributes(dpy, gc, width, type, CapButt, JoinBevel);
! 987: }
! 988: }
! 989: }
! 990: }
! 991:
! 992: /* set new pixmap as window background */
! 993: XSetWindowBackgroundPixmap(dpy, plot->window, plot->pixmap);
! 994:
! 995: /* trigger exposure of background pixmap */
! 996: XClearWindow(dpy, plot->window);
! 997:
! 998: #ifdef EXPORT_SELECTION
! 999: export_graph(plot);
! 1000: #endif
! 1001:
! 1002: XFlush(dpy);
! 1003: }
! 1004:
! 1005: /*---------------------------------------------------------------------------
! 1006: * reset all cursors (since we dont have a record of the previous terminal #)
! 1007: *---------------------------------------------------------------------------*/
! 1008:
! 1009: void reset_cursor()
! 1010: {
! 1011: int plot_number;
! 1012: plot_struct *plot = plot_array;
! 1013:
! 1014: for (plot_number = 0, plot = plot_array;
! 1015: plot_number < MAX_WINDOWS;
! 1016: ++plot_number, ++plot) {
! 1017: if (plot->window) {
! 1018: FPRINTF((stderr, "Window for plot %d exists\n", plot_number));
! 1019: XUndefineCursor(dpy, plot->window);;
! 1020: }
! 1021: }
! 1022:
! 1023: FPRINTF((stderr, "Cursors reset\n"));
! 1024: return;
! 1025: }
! 1026:
! 1027: /*-----------------------------------------------------------------------------
! 1028: * resize - rescale last plot if window resized
! 1029: *---------------------------------------------------------------------------*/
! 1030:
! 1031: plot_struct *find_plot(window)
! 1032: Window window;
! 1033: {
! 1034: int plot_number;
! 1035: plot_struct *plot = plot_array;
! 1036:
! 1037: for (plot_number = 0, plot = plot_array;
! 1038: plot_number < MAX_WINDOWS;
! 1039: ++plot_number, ++plot) {
! 1040: if (plot->window == window) {
! 1041: FPRINTF((stderr, "Event for plot %d\n", plot_number));
! 1042: return plot;
! 1043: }
! 1044: }
! 1045:
! 1046: FPRINTF((stderr, "Bogus window 0x%x in event !\n", window));
! 1047: return NULL;
! 1048: }
! 1049:
! 1050: void process_event(event)
! 1051: XEvent *event;
! 1052: {
! 1053: FPRINTF((stderr, "Event 0x%x\n", event->type));
! 1054:
! 1055: switch (event->type) {
! 1056: case ConfigureNotify:
! 1057: {
! 1058: plot_struct *plot = find_plot(event->xconfigure.window);
! 1059: if (plot) {
! 1060: int w = event->xconfigure.width, h = event->xconfigure.height;
! 1061:
! 1062: /* store settings in case window is closed then recreated */
! 1063: plot->x = event->xconfigure.x;
! 1064: plot->y = event->xconfigure.y;
! 1065: plot->posn_flags = (plot->posn_flags & ~PPosition) | USPosition;
! 1066:
! 1067: if (w > 1 && h > 1 && (w != plot->width || h != plot->height)) {
! 1068: plot->width = w;
! 1069: plot->height = h;
! 1070: plot->posn_flags = (plot->posn_flags & ~PSize) | USSize;
! 1071: if (plot->pixmap) {
! 1072: /* it is the wrong size now */
! 1073: FPRINTF((stderr, "Free pixmap %d\n", 0));
! 1074: XFreePixmap(dpy, plot->pixmap);
! 1075: plot->pixmap = None;
! 1076: }
! 1077: display(plot);
! 1078: }
! 1079: }
! 1080: break;
! 1081: }
! 1082: case KeyPress:
! 1083: if (event->xkey.keycode == q_keycode) {
! 1084: plot_struct *plot = find_plot(event->xkey.window);
! 1085: if (plot)
! 1086: delete_plot(plot);
! 1087: }
! 1088: break;
! 1089: case ClientMessage:
! 1090: if (event->xclient.message_type == WM_PROTOCOLS &&
! 1091: event->xclient.format == 32 &&
! 1092: event->xclient.data.l[0] == WM_DELETE_WINDOW) {
! 1093: plot_struct *plot = find_plot(event->xclient.window);
! 1094: if (plot)
! 1095: delete_plot(plot);
! 1096: }
! 1097: break;
! 1098: #ifdef EXPORT_SELECTION
! 1099: case SelectionNotify:
! 1100: case SelectionRequest:
! 1101: handle_selection_event(event);
! 1102: break;
! 1103: #endif
! 1104: }
! 1105: }
! 1106:
! 1107: /*-----------------------------------------------------------------------------
! 1108: * preset - determine options, open display, create window
! 1109: *---------------------------------------------------------------------------*/
! 1110:
! 1111: #define On(v) ( !strcmp(v,"on") || !strcmp(v,"true") || \
! 1112: !strcmp(v,"On") || !strcmp(v,"True") || \
! 1113: !strcmp(v,"ON") || !strcmp(v,"TRUE") )
! 1114:
! 1115: #define AppDefDir "/usr/lib/X11/app-defaults"
! 1116: #ifndef MAXHOSTNAMELEN
! 1117: #define MAXHOSTNAMELEN 64
! 1118: #endif
! 1119:
! 1120: static XrmDatabase dbCmd, dbApp, dbDef, dbEnv, db = (XrmDatabase) 0;
! 1121:
! 1122: char *pr_GetR(), *getenv(), *type[20];
! 1123: XrmValue value;
! 1124:
! 1125: static XrmOptionDescRec options[] = {
! 1126: {"-mono", ".mono", XrmoptionNoArg, (caddr_t) "on"},
! 1127: {"-gray", ".gray", XrmoptionNoArg, (caddr_t) "on"},
! 1128: {"-clear", ".clear", XrmoptionNoArg, (caddr_t) "on"},
! 1129: {"-tvtwm", ".tvtwm", XrmoptionNoArg, (caddr_t) "on"},
! 1130: {"-pointsize", ".pointsize", XrmoptionSepArg, (caddr_t) NULL},
! 1131: {"-display", ".display", XrmoptionSepArg, (caddr_t) NULL},
! 1132: {"-name", ".name", XrmoptionSepArg, (caddr_t) NULL},
! 1133: {"-geometry", "*geometry", XrmoptionSepArg, (caddr_t) NULL},
! 1134: {"-background", "*background", XrmoptionSepArg, (caddr_t) NULL},
! 1135: {"-bg", "*background", XrmoptionSepArg, (caddr_t) NULL},
! 1136: {"-foreground", "*foreground", XrmoptionSepArg, (caddr_t) NULL},
! 1137: {"-fg", "*foreground", XrmoptionSepArg, (caddr_t) NULL},
! 1138: {"-bordercolor", "*bordercolor", XrmoptionSepArg, (caddr_t) NULL},
! 1139: {"-bd", "*bordercolor", XrmoptionSepArg, (caddr_t) NULL},
! 1140: {"-borderwidth", ".borderwidth", XrmoptionSepArg, (caddr_t) NULL},
! 1141: {"-bw", ".borderwidth", XrmoptionSepArg, (caddr_t) NULL},
! 1142: {"-font", "*font", XrmoptionSepArg, (caddr_t) NULL},
! 1143: {"-fn", "*font", XrmoptionSepArg, (caddr_t) NULL},
! 1144: {"-reverse", "*reverseVideo", XrmoptionNoArg, (caddr_t) "on"},
! 1145: {"-rv", "*reverseVideo", XrmoptionNoArg, (caddr_t) "on"},
! 1146: {"+rv", "*reverseVideo", XrmoptionNoArg, (caddr_t) "off"},
! 1147: {"-iconic", "*iconic", XrmoptionNoArg, (caddr_t) "on"},
! 1148: {"-synchronous", "*synchronous", XrmoptionNoArg, (caddr_t) "on"},
! 1149: {"-xnllanguage", "*xnllanguage", XrmoptionSepArg, (caddr_t) NULL},
! 1150: {"-selectionTimeout", "*selectionTimeout", XrmoptionSepArg, (caddr_t) NULL},
! 1151: {"-title", ".title", XrmoptionSepArg, (caddr_t) NULL},
! 1152: {"-xrm", NULL, XrmoptionResArg, (caddr_t) NULL},
! 1153: {"-raise", "*raise", XrmoptionNoArg, (caddr_t) "on"},
! 1154: {"-noraise", "*raise", XrmoptionNoArg, (caddr_t) "off"},
! 1155: {"-persist", "*persist", XrmoptionNoArg, (caddr_t) "on"}
! 1156: };
! 1157:
! 1158: #define Nopt (sizeof(options) / sizeof(options[0]))
! 1159:
! 1160: void preset(argc, argv)
! 1161: int argc;
! 1162: char *argv[];
! 1163: {
! 1164: int Argc = argc;
! 1165: char **Argv = argv;
! 1166:
! 1167: #ifdef VMS
! 1168: char *ldisplay = (char *) 0;
! 1169: #else
! 1170: char *ldisplay = getenv("DISPLAY");
! 1171: #endif
! 1172: char *home = getenv("HOME");
! 1173: char *server_defaults, *env, buffer[256];
! 1174:
! 1175: /* avoid bus error when env vars are not set */
! 1176: if (ldisplay == NULL)
! 1177: ldisplay = "";
! 1178: if (home == NULL)
! 1179: home = "";
! 1180:
! 1181: /*---set to ignore ^C and ^Z----------------------------------------------*/
! 1182:
! 1183: signal(SIGINT, SIG_IGN);
! 1184: #ifdef SIGTSTP
! 1185: signal(SIGTSTP, SIG_IGN);
! 1186: #endif
! 1187:
! 1188: /*---prescan arguments for "-name"----------------------------------------*/
! 1189:
! 1190: while (++Argv, --Argc > 0) {
! 1191: if (!strcmp(*Argv, "-name") && Argc > 1) {
! 1192: safe_strncpy(Name, Argv[1], sizeof(Name));
! 1193: safe_strncpy(Class, Argv[1], sizeof(Class));
! 1194: if (Class[0] >= 'a' && Class[0] <= 'z')
! 1195: Class[0] -= 0x20;
! 1196: }
! 1197: }
! 1198: Argc = argc;
! 1199: Argv = argv;
! 1200:
! 1201: /*---parse command line---------------------------------------------------*/
! 1202:
! 1203: XrmInitialize();
! 1204: XrmParseCommand(&dbCmd, options, Nopt, Name, &Argc, Argv);
! 1205: if (Argc > 1) {
! 1206: fprintf(stderr, "\n\
! 1207: gnuplot: bad option: %s\n\
! 1208: gnuplot: X11 aborted.\n", Argv[1]);
! 1209: EXIT(1);
! 1210: }
! 1211: if (pr_GetR(dbCmd, ".display"))
! 1212: ldisplay = (char *) value.addr;
! 1213:
! 1214: /*---open display---------------------------------------------------------*/
! 1215:
! 1216: dpy = XOpenDisplay(ldisplay);
! 1217: if (!dpy) {
! 1218: fprintf(stderr, "\n\
! 1219: gnuplot: unable to open display '%s'\n\
! 1220: gnuplot: X11 aborted.\n", ldisplay);
! 1221: EXIT(1);
! 1222: }
! 1223: scr = DefaultScreen(dpy);
! 1224: vis = DefaultVisual(dpy, scr);
! 1225: D = DefaultDepth(dpy, scr);
! 1226: root = DefaultRootWindow(dpy);
! 1227: server_defaults = XResourceManagerString(dpy);
! 1228:
! 1229: /*---get symcode for key q ---*/
! 1230:
! 1231: q_keycode = XKeysymToKeycode(dpy, XK_q);
! 1232:
! 1233: /**** atoms we will need later ****/
! 1234:
! 1235: WM_PROTOCOLS = XInternAtom(dpy, "WM_PROTOCOLS", False);
! 1236: WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
! 1237:
! 1238:
! 1239: /*---get application defaults--(subset of Xt processing)------------------*/
! 1240:
! 1241: #ifdef VMS
! 1242: strcpy(buffer, "DECW$USER_DEFAULTS:GNUPLOT_X11.INI");
! 1243: #else
! 1244: # ifdef OS2
! 1245: /* for Xfree86 ... */
! 1246: {
! 1247: char *appdefdir = "XFree86/lib/X11/app-defaults";
! 1248: char *xroot = getenv("X11ROOT");
! 1249: sprintf(buffer, "%s/%s/%s", xroot, appdefdir, "Gnuplot");
! 1250: }
! 1251: # else
! 1252: sprintf(buffer, "%s/%s", AppDefDir, "Gnuplot");
! 1253: # endif /* !OS2 */
! 1254: #endif /* !VMS */
! 1255:
! 1256: dbApp = XrmGetFileDatabase(buffer);
! 1257: XrmMergeDatabases(dbApp, &db);
! 1258:
! 1259: /*---get server or ~/.Xdefaults-------------------------------------------*/
! 1260:
! 1261: if (server_defaults)
! 1262: dbDef = XrmGetStringDatabase(server_defaults);
! 1263: else {
! 1264: #ifdef VMS
! 1265: strcpy(buffer, "DECW$USER_DEFAULTS:DECW$XDEFAULTS.DAT");
! 1266: #else
! 1267: sprintf(buffer, "%s/.Xdefaults", home);
! 1268: #endif
! 1269: dbDef = XrmGetFileDatabase(buffer);
! 1270: }
! 1271: XrmMergeDatabases(dbDef, &db);
! 1272:
! 1273: /*---get XENVIRONMENT or ~/.Xdefaults-hostname---------------------------*/
! 1274:
! 1275: #ifndef VMS
! 1276: if ((env = getenv("XENVIRONMENT")) != NULL)
! 1277: dbEnv = XrmGetFileDatabase(env);
! 1278: else {
! 1279: char *p = NULL, host[MAXHOSTNAMELEN];
! 1280:
! 1281: if (GP_SYSTEMINFO(host) < 0) {
! 1282: fprintf(stderr, "gnuplot: %s failed. X11 aborted.\n", SYSINFO_METHOD);
! 1283: EXIT(1);
! 1284: }
! 1285: if ((p = strchr(host, '.')) != NULL)
! 1286: *p = '\0';
! 1287: sprintf(buffer, "%s/.Xdefaults-%s", home, host);
! 1288: dbEnv = XrmGetFileDatabase(buffer);
! 1289: }
! 1290: XrmMergeDatabases(dbEnv, &db);
! 1291: #endif /* not VMS */
! 1292:
! 1293: /*---merge command line options-------------------------------------------*/
! 1294:
! 1295: XrmMergeDatabases(dbCmd, &db);
! 1296:
! 1297: /*---set geometry, font, colors, line widths, dash styles, point size-----*/
! 1298:
! 1299: pr_geometry();
! 1300: pr_font();
! 1301: pr_color();
! 1302: pr_width();
! 1303: pr_dashes();
! 1304: pr_pointsize();
! 1305: pr_raise();
! 1306: pr_persist();
! 1307: }
! 1308:
! 1309: /*-----------------------------------------------------------------------------
! 1310: * pr_GetR - get resource from database using "-name" option (if any)
! 1311: *---------------------------------------------------------------------------*/
! 1312:
! 1313: char *
! 1314: pr_GetR(xrdb, resource)
! 1315: XrmDatabase xrdb;
! 1316: char *resource;
! 1317: {
! 1318: char name[128], class[128], *rc;
! 1319:
! 1320: strcpy(name, Name);
! 1321: strcat(name, resource);
! 1322: strcpy(class, Class);
! 1323: strcat(class, resource);
! 1324: rc = XrmGetResource(xrdb, name, class, type, &value)
! 1325: ? (char *) value.addr
! 1326: : (char *) 0;
! 1327: return (rc);
! 1328: }
! 1329:
! 1330: /*-----------------------------------------------------------------------------
! 1331: * pr_color - determine color values
! 1332: *---------------------------------------------------------------------------*/
! 1333:
! 1334: char color_keys[Ncolors][30] = {
! 1335: "background", "bordercolor", "text", "border", "axis",
! 1336: "line1", "line2", "line3", "line4",
! 1337: "line5", "line6", "line7", "line8"
! 1338: };
! 1339: char color_values[Ncolors][30] = {
! 1340: "white", "black", "black", "black", "black",
! 1341: "red", "green", "blue", "magenta",
! 1342: "cyan", "sienna", "orange", "coral"
! 1343: };
! 1344: char gray_values[Ncolors][30] = {
! 1345: "black", "white", "white", "gray50", "gray50",
! 1346: "gray100", "gray60", "gray80", "gray40",
! 1347: "gray90", "gray50", "gray70", "gray30"
! 1348: };
! 1349:
! 1350: void pr_color()
! 1351: {
! 1352: unsigned long black = BlackPixel(dpy, scr), white = WhitePixel(dpy, scr);
! 1353: char option[20], color[30], *v, *ctype;
! 1354: XColor xcolor;
! 1355: Colormap cmap;
! 1356: double intensity = -1;
! 1357: int n;
! 1358:
! 1359: pr_GetR(db, ".mono") && On(value.addr) && Mono++;
! 1360: pr_GetR(db, ".gray") && On(value.addr) && Gray++;
! 1361: pr_GetR(db, ".reverseVideo") && On(value.addr) && Rv++;
! 1362:
! 1363: if (!Gray && (vis->class == GrayScale || vis->class == StaticGray))
! 1364: Mono++;
! 1365:
! 1366: if (!Mono) {
! 1367: cmap = DefaultColormap(dpy, scr);
! 1368: ctype = (Gray) ? "Gray" : "Color";
! 1369:
! 1370: for (n = 0; n < Ncolors; n++) {
! 1371: strcpy(option, ".");
! 1372: strcat(option, color_keys[n]);
! 1373: (n > 1) && strcat(option, ctype);
! 1374: v = pr_GetR(db, option)
! 1375: ? (char *) value.addr
! 1376: : ((Gray) ? gray_values[n] : color_values[n]);
! 1377:
! 1378: if (sscanf(v, "%30[^,],%lf", color, &intensity) == 2) {
! 1379: if (intensity < 0 || intensity > 1) {
! 1380: fprintf(stderr, "\ngnuplot: invalid color intensity in '%s'\n",
! 1381: color);
! 1382: intensity = 1;
! 1383: }
! 1384: } else {
! 1385: strcpy(color, v);
! 1386: intensity = 1;
! 1387: }
! 1388:
! 1389: if (!XParseColor(dpy, cmap, color, &xcolor)) {
! 1390: fprintf(stderr, "\ngnuplot: unable to parse '%s'. Using black.\n",
! 1391: color);
! 1392: colors[n] = black;
! 1393: } else {
! 1394: xcolor.red *= intensity;
! 1395: xcolor.green *= intensity;
! 1396: xcolor.blue *= intensity;
! 1397: if (XAllocColor(dpy, cmap, &xcolor)) {
! 1398: colors[n] = xcolor.pixel;
! 1399: } else {
! 1400: fprintf(stderr, "\ngnuplot: can't allocate '%s'. Using black.\n",
! 1401: v);
! 1402: colors[n] = black;
! 1403: }
! 1404: }
! 1405: }
! 1406: } else {
! 1407: colors[0] = (Rv) ? black : white;
! 1408: for (n = 1; n < Ncolors; n++)
! 1409: colors[n] = (Rv) ? white : black;
! 1410: }
! 1411: }
! 1412:
! 1413: /*-----------------------------------------------------------------------------
! 1414: * pr_dashes - determine line dash styles
! 1415: *---------------------------------------------------------------------------*/
! 1416:
! 1417: char dash_keys[Ndashes][10] = {
! 1418: "border", "axis",
! 1419: "line1", "line2", "line3", "line4", "line5", "line6", "line7", "line8"
! 1420: };
! 1421:
! 1422: char dash_mono[Ndashes][10] = {
! 1423: "0", "16",
! 1424: "0", "42", "13", "44", "15", "4441", "42", "13"
! 1425: };
! 1426:
! 1427: char dash_color[Ndashes][10] = {
! 1428: "0", "16",
! 1429: "0", "0", "0", "0", "0", "0", "0", "0"
! 1430: };
! 1431:
! 1432: void pr_dashes()
! 1433: {
! 1434: int n, j, l, ok;
! 1435: char option[20], *v;
! 1436:
! 1437: for (n = 0; n < Ndashes; n++) {
! 1438: strcpy(option, ".");
! 1439: strcat(option, dash_keys[n]);
! 1440: strcat(option, "Dashes");
! 1441: v = pr_GetR(db, option)
! 1442: ? (char *) value.addr
! 1443: : ((Mono) ? dash_mono[n] : dash_color[n]);
! 1444: l = strlen(v);
! 1445: if (l == 1 && *v == '0') {
! 1446: dashes[n][0] = (unsigned char) 0;
! 1447: continue;
! 1448: }
! 1449: for (ok = 0, j = 0; j < l; j++) {
! 1450: v[j] >= '1' && v[j] <= '9' && ok++;
! 1451: }
! 1452: if (ok != l || (ok != 2 && ok != 4)) {
! 1453: fprintf(stderr, "gnuplot: illegal dashes value %s:%s\n", option, v);
! 1454: dashes[n][0] = (unsigned char) 0;
! 1455: continue;
! 1456: }
! 1457: for (j = 0; j < l; j++) {
! 1458: dashes[n][j] = (unsigned char) (v[j] - '0');
! 1459: }
! 1460: dashes[n][l] = (unsigned char) 0;
! 1461: }
! 1462: }
! 1463:
! 1464: /*-----------------------------------------------------------------------------
! 1465: * pr_font - determine font
! 1466: *---------------------------------------------------------------------------*/
! 1467:
! 1468: void pr_font()
! 1469: {
! 1470: char *fontname = pr_GetR(db, ".font");
! 1471:
! 1472: if (!fontname)
! 1473: fontname = FallbackFont;
! 1474: font = XLoadQueryFont(dpy, fontname);
! 1475: if (!font) {
! 1476: fprintf(stderr, "\ngnuplot: can't load font '%s'\n", fontname);
! 1477: fprintf(stderr, "gnuplot: using font '%s' instead.\n", FallbackFont);
! 1478: font = XLoadQueryFont(dpy, FallbackFont);
! 1479: if (!font) {
! 1480: fprintf(stderr, "\
! 1481: gnuplot: can't load font '%s'\n\
! 1482: gnuplot: no useable font - X11 aborted.\n", FallbackFont);
! 1483: EXIT(1);
! 1484: }
! 1485: }
! 1486: vchar = font->ascent + font->descent;
! 1487: }
! 1488:
! 1489: /*-----------------------------------------------------------------------------
! 1490: * pr_geometry - determine window geometry
! 1491: *---------------------------------------------------------------------------*/
! 1492:
! 1493: void pr_geometry()
! 1494: {
! 1495: char *geometry = pr_GetR(db, ".geometry");
! 1496: int x, y, flags;
! 1497: unsigned int w, h;
! 1498:
! 1499: if (geometry) {
! 1500: flags = XParseGeometry(geometry, &x, &y, &w, &h);
! 1501: if (flags & WidthValue)
! 1502: gW = w;
! 1503: if (flags & HeightValue)
! 1504: gH = h;
! 1505: if (flags & (WidthValue | HeightValue))
! 1506: gFlags = (gFlags & ~PSize) | USSize;
! 1507:
! 1508: if (flags & XValue)
! 1509: gX = (flags & XNegative) ? x + DisplayWidth(dpy, scr) - gW - BorderWidth * 2 : x;
! 1510:
! 1511: if (flags & YValue)
! 1512: gY = (flags & YNegative) ? y + DisplayHeight(dpy, scr) - gH - BorderWidth * 2 : y;
! 1513:
! 1514: if (flags & (XValue | YValue))
! 1515: gFlags = (gFlags & ~PPosition) | USPosition;
! 1516: }
! 1517: }
! 1518:
! 1519: /*-----------------------------------------------------------------------------
! 1520: * pr_pointsize - determine size of points for 'points' plotting style
! 1521: *---------------------------------------------------------------------------*/
! 1522:
! 1523: void pr_pointsize()
! 1524: {
! 1525: if (pr_GetR(db, ".pointsize")) {
! 1526: if (sscanf((char *) value.addr, "%lf", &pointsize) == 1) {
! 1527: if (pointsize <= 0 || pointsize > 10) {
! 1528: fprintf(stderr, "\ngnuplot: invalid pointsize '%s'\n", value.addr);
! 1529: pointsize = 1;
! 1530: }
! 1531: } else {
! 1532: fprintf(stderr, "\ngnuplot: invalid pointsize '%s'\n", value.addr);
! 1533: pointsize = 1;
! 1534: }
! 1535: } else {
! 1536: pointsize = 1;
! 1537: }
! 1538: }
! 1539:
! 1540: /*-----------------------------------------------------------------------------
! 1541: * pr_width - determine line width values
! 1542: *---------------------------------------------------------------------------*/
! 1543:
! 1544: char width_keys[Nwidths][30] = {
! 1545: "border", "axis",
! 1546: "line1", "line2", "line3", "line4", "line5", "line6", "line7", "line8"
! 1547: };
! 1548:
! 1549: void pr_width()
! 1550: {
! 1551: int n;
! 1552: char option[20], *v;
! 1553:
! 1554: for (n = 0; n < Nwidths; n++) {
! 1555: strcpy(option, ".");
! 1556: strcat(option, width_keys[n]);
! 1557: strcat(option, "Width");
! 1558: if ((v = pr_GetR(db, option)) != NULL) {
! 1559: if (*v < '0' || *v > '4' || strlen(v) > 1)
! 1560: fprintf(stderr, "gnuplot: illegal width value %s:%s\n", option, v);
! 1561: else
! 1562: widths[n] = (unsigned int) atoi(v);
! 1563: }
! 1564: }
! 1565: }
! 1566:
! 1567: /*-----------------------------------------------------------------------------
! 1568: * pr_window - create window
! 1569: *---------------------------------------------------------------------------*/
! 1570:
! 1571: Window pr_window(flags, x, y, width, height)
! 1572: unsigned int flags;
! 1573: int x, y;
! 1574: unsigned int width, height;
! 1575: {
! 1576: char *title = pr_GetR(db, ".title");
! 1577: static XSizeHints hints;
! 1578: int Tvtwm = 0;
! 1579:
! 1580: Window win = XCreateSimpleWindow(dpy, root, x, y, width, height, BorderWidth,
! 1581: colors[1], colors[0]);
! 1582:
! 1583: /* ask ICCCM-compliant window manager to tell us when close window
! 1584: * has been chosen, rather than just killing us
! 1585: */
! 1586:
! 1587: XChangeProperty(dpy, win, WM_PROTOCOLS, XA_ATOM, 32, PropModeReplace,
! 1588: (unsigned char *) &WM_DELETE_WINDOW, 1);
! 1589:
! 1590: pr_GetR(db, ".clear") && On(value.addr) && Clear++;
! 1591: pr_GetR(db, ".tvtwm") && On(value.addr) && Tvtwm++;
! 1592:
! 1593: if (!Tvtwm) {
! 1594: hints.flags = flags;
! 1595: } else {
! 1596: hints.flags = (flags & ~USPosition) | PPosition; /* ? */
! 1597: }
! 1598: hints.x = gX;
! 1599: hints.y = gY;
! 1600: hints.width = width;
! 1601: hints.height = height;
! 1602:
! 1603: XSetNormalHints(dpy, win, &hints);
! 1604:
! 1605: if (pr_GetR(db, ".iconic") && On(value.addr)) {
! 1606: XWMHints wmh;
! 1607:
! 1608: wmh.flags = StateHint;
! 1609: wmh.initial_state = IconicState;
! 1610: XSetWMHints(dpy, win, &wmh);
! 1611: }
! 1612: XStoreName(dpy, win, ((title) ? title : Class));
! 1613:
! 1614: XSelectInput(dpy, win, KeyPressMask | StructureNotifyMask);
! 1615: XMapWindow(dpy, win);
! 1616:
! 1617: return win;
! 1618: }
! 1619:
! 1620:
! 1621: /***** pr_raise ***/
! 1622: void pr_raise()
! 1623: {
! 1624: if (pr_GetR(db, ".raise"))
! 1625: do_raise = (On(value.addr));
! 1626: }
! 1627:
! 1628:
! 1629: void pr_persist()
! 1630: {
! 1631: if (pr_GetR(db, ".persist"))
! 1632: persist = (On(value.addr));
! 1633: }
! 1634:
! 1635: /************ code to handle selection export *********************/
! 1636:
! 1637: #ifdef EXPORT_SELECTION
! 1638:
! 1639: /* bit of a bodge, but ... */
! 1640: static struct plot_struct *exported_plot;
! 1641:
! 1642: void export_graph(plot)
! 1643: struct plot_struct *plot;
! 1644: {
! 1645: FPRINTF((stderr, "export_graph(0x%x)\n", plot));
! 1646:
! 1647: XSetSelectionOwner(dpy, EXPORT_SELECTION, plot->window, CurrentTime);
! 1648: /* to check we have selection, we would have to do a
! 1649: * GetSelectionOwner(), but if it failed, it failed - no big deal
! 1650: */
! 1651: exported_plot = plot;
! 1652: }
! 1653:
! 1654: void handle_selection_event(event)
! 1655: XEvent *event;
! 1656: {
! 1657: switch (event->type) {
! 1658: case SelectionRequest:
! 1659: {
! 1660: XEvent reply;
! 1661:
! 1662: static Atom XA_TARGETS = (Atom) 0;
! 1663: if (XA_TARGETS == 0)
! 1664: XA_TARGETS = XInternAtom(dpy, "TARGETS", False);
! 1665:
! 1666: reply.type = SelectionNotify;
! 1667: reply.xselection.send_event = True;
! 1668: reply.xselection.display = event->xselectionrequest.display;
! 1669: reply.xselection.requestor = event->xselectionrequest.requestor;
! 1670: reply.xselection.selection = event->xselectionrequest.selection;
! 1671: reply.xselection.target = event->xselectionrequest.target;
! 1672: reply.xselection.property = event->xselectionrequest.property;
! 1673: reply.xselection.time = event->xselectionrequest.time;
! 1674:
! 1675: FPRINTF((stderr, "selection request\n"));
! 1676:
! 1677: if (reply.xselection.target == XA_TARGETS) {
! 1678: static Atom targets[] = {XA_PIXMAP, XA_COLORMAP};
! 1679:
! 1680: FPRINTF((stderr, "Targets request from %d\n", reply.xselection.requestor));
! 1681:
! 1682: XChangeProperty(dpy, reply.xselection.requestor,
! 1683: reply.xselection.property, reply.xselection.target, 32, PropModeReplace,
! 1684: (unsigned char *) targets, 2);
! 1685: } else if (reply.xselection.target == XA_COLORMAP) {
! 1686: Colormap cmap = DefaultColormap(dpy, 0);
! 1687:
! 1688: FPRINTF((stderr, "colormap request from %d\n", reply.xselection.requestor));
! 1689:
! 1690: XChangeProperty(dpy, reply.xselection.requestor,
! 1691: reply.xselection.property, reply.xselection.target, 32, PropModeReplace,
! 1692: (unsigned char *) &cmap, 1);
! 1693: } else if (reply.xselection.target == XA_PIXMAP) {
! 1694:
! 1695: FPRINTF((stderr, "pixmap request from %d\n", reply.xselection.requestor));
! 1696:
! 1697: XChangeProperty(dpy, reply.xselection.requestor,
! 1698: reply.xselection.property, reply.xselection.target, 32, PropModeReplace,
! 1699: (unsigned char *) &(exported_plot->pixmap), 1);
! 1700: } else {
! 1701: reply.xselection.property = None;
! 1702: }
! 1703:
! 1704: XSendEvent(dpy, reply.xselection.requestor, False, 0L, &reply);
! 1705: /* we never block on XNextEvent(), so must flush manually
! 1706: * (took me *ages* to find this out !)
! 1707: */
! 1708:
! 1709: XFlush(dpy);
! 1710: }
! 1711: break;
! 1712: }
! 1713: }
! 1714:
! 1715: #endif /* EXPORT_SELECTION */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gplt_x11.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot