src/xutil.c

   1 /*
   2  * Grace - GRaphing, Advanced Computation and Exploration of data
   3  *
   4  * Home page: http://plasma-gate.weizmann.ac.il/Grace/
   5  *
   6  * Copyright (c) 1991-1995 Paul J Turner, Portland, OR
   7  * Copyright (c) 1996-2004 Grace Development Team
   8  *
   9  * Maintained by Evgeny Stambulchik
  10  *
  11  *
  12  *                           All Rights Reserved
  13  *
  14  *    This program is free software; you can redistribute it and/or modify
  15  *    it under the terms of the GNU General Public License as published by
  16  *    the Free Software Foundation; either version 2 of the License, or
  17  *    (at your option) any later version.
  18  *
  19  *    This program is distributed in the hope that it will be useful,
  20  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *    GNU General Public License for more details.
  23  *
  24  *    You should have received a copy of the GNU General Public License
  25  *    along with this program; if not, write to the Free Software
  26  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27  */
  28
  29 #include <config.h>
  30
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <errno.h>
  34
  35 #include <X11/Xlib.h>
  36 #include <X11/cursorfont.h>
  37
  38 #include "defines.h"
  39 #include "globals.h"
  40
  41 #include "utils.h"
  42 #include "files.h"
  43 #include "core_utils.h"
  44 #include "plotone.h"
  45
  46 #include "motifinc.h"
  47 #include "protos.h"
  48
  49 extern XtAppContext app_con;
  50
  51 extern Input_buffer *ib_tbl;
  52 extern int ib_tblsize;
  53
  54 static GC gcxor;
  55
  56 static void resize_drawables(unsigned int w, unsigned int h);
  57
  58 long x11_allocate_color(GUI *gui, const RGB *rgb)
  59 {
  60     X11Stuff *xstuff = gui->xstuff;
  61     XColor xc;
  62
  63     xc.pixel = 0;
  64     xc.flags = DoRed | DoGreen | DoBlue;
  65
  66     xc.red   = rgb->red   << (16 - GRACE_BPP);
  67     xc.green = rgb->green << (16 - GRACE_BPP);
  68     xc.blue  = rgb->blue  << (16 - GRACE_BPP);
  69
  70     if (XAllocColor(xstuff->disp, xstuff->cmap, &xc)) {
  71         return xc.pixel;
  72     } else
  73     if (gui->install_cmap != CMAP_INSTALL_NEVER &&
  74         gui->private_cmap == FALSE) {
  75         xstuff->cmap = XCopyColormapAndFree(xstuff->disp, xstuff->cmap);
  76         gui->private_cmap = TRUE;
  77
  78         /* try to allocate the same color in the private colormap */
  79         return x11_allocate_color(gui, rgb);
  80     } else {
  81         return -1;
  82     }
  83 }
  84
  85 void set_wait_cursor(void)
  86 {
  87     if (grace->gui->xstuff->disp == NULL) {
  88         return;
  89     }
  90
  91     DefineDialogCursor(grace->gui->xstuff->wait_cursor);
  92 }
  93
  94 void unset_wait_cursor(void)
  95 {
  96     X11Stuff *xstuff = grace->gui->xstuff;
  97     if (xstuff->disp == NULL) {
  98         return;
  99     }
 100
 101     UndefineDialogCursor();
 102     if (xstuff->cur_cursor >= 0) {
 103         set_cursor(grace->gui, xstuff->cur_cursor);
 104     }
 105 }
 106
 107 void set_cursor(GUI *gui, int c)
 108 {
 109     X11Stuff *xstuff = gui->xstuff;
 110     if (xstuff->disp == NULL || xstuff->cur_cursor == c) {
 111         return;
 112     }
 113
 114     XUndefineCursor(xstuff->disp, xstuff->xwin);
 115     xstuff->cur_cursor = c;
 116     switch (c) {
 117     case 0:
 118         XDefineCursor(xstuff->disp, xstuff->xwin, xstuff->line_cursor);
 119         break;
 120     case 1:
 121         XDefineCursor(xstuff->disp, xstuff->xwin, xstuff->find_cursor);
 122         break;
 123     case 2:
 124         XDefineCursor(xstuff->disp, xstuff->xwin, xstuff->text_cursor);
 125         break;
 126     case 3:
 127         XDefineCursor(xstuff->disp, xstuff->xwin, xstuff->kill_cursor);
 128         break;
 129     case 4:
 130         XDefineCursor(xstuff->disp, xstuff->xwin, xstuff->move_cursor);
 131         break;
 132     case 5:
 133         XDefineCursor(xstuff->disp, xstuff->xwin, xstuff->drag_cursor);
 134         break;
 135     default:
 136         xstuff->cur_cursor = -1;
 137         break;
 138     }
 139     XFlush(xstuff->disp);
 140 }
 141
 142 void init_cursors(GUI *gui)
 143 {
 144     X11Stuff *xstuff = gui->xstuff;
 145
 146     xstuff->wait_cursor = XCreateFontCursor(xstuff->disp, XC_watch);
 147     xstuff->line_cursor = XCreateFontCursor(xstuff->disp, XC_crosshair);
 148     xstuff->find_cursor = XCreateFontCursor(xstuff->disp, XC_dotbox);
 149     xstuff->text_cursor = XCreateFontCursor(xstuff->disp, XC_xterm);
 150     xstuff->kill_cursor = XCreateFontCursor(xstuff->disp, XC_pirate);
 151     xstuff->move_cursor = XCreateFontCursor(xstuff->disp, XC_fleur);
 152     xstuff->drag_cursor = XCreateFontCursor(xstuff->disp, XC_hand2);
 153
 154     xstuff->cur_cursor = -1;
 155 }
 156
 157
 158 /*
 159  * put a string in the title bar
 160  */
 161 void update_app_title(const Quark *pr)
 162 {
 163     GUI *gui = gui_from_quark(pr);
 164     static char *ts_save = NULL;
 165     char *ts;
 166     static int dstate_save = 0;
 167     int dstate;
 168
 169     if (!pr || !gui->inwin) {
 170         return;
 171     }
 172
 173     dstate = quark_dirtystate_get(pr);
 174     ts = mybasename(project_get_docname(pr));
 175     if (ts_save == NULL || strcmp(ts_save, ts) != 0 || dstate != dstate_save) {
 176         char *buf1, *buf2;
 177         ts_save = copy_string(ts_save, ts);
 178         dstate_save = dstate;
 179         buf1 = copy_string(NULL, "Grace: ");
 180         buf1 = concat_strings(buf1, ts);
 181         buf2 = copy_string(NULL, ts);
 182         if (dstate) {
 183             buf2 = concat_strings(buf2, "*");
 184             buf1 = concat_strings(buf1, " (modified)");
 185         }
 186         XtVaSetValues(app_shell, XtNtitle, buf1, XtNiconName, buf2, NULL);
 187         xfree(buf1);
 188         xfree(buf2);
 189     }
 190 }
 191
 192 void page_zoom_inout(Grace *grace, int inout)
 193 {
 194     if (!gui_is_page_free(grace->gui)) {
 195         if (inout > 0) {
 196             grace->gui->zoom *= ZOOM_STEP;
 197         } else
 198         if (inout < 0) {
 199             grace->gui->zoom /= ZOOM_STEP;
 200         } else {
 201             grace->gui->zoom = 1.0;
 202         }
 203         xdrawgraph(grace->project, TRUE);
 204         set_left_footer(NULL);
 205     }
 206 }
 207
 208 /*
 209  *  Auxiliary routines for simultaneous drawing on display and pixmap
 210  */
 211 static void aux_XDrawLine(GUI *gui, int x1, int y1, int x2, int y2)
 212 {
 213     X11Stuff *xstuff = gui->xstuff;
 214     XDrawLine(xstuff->disp, xstuff->xwin, gcxor, x1, y1, x2, y2);
 215     if (xstuff->bufpixmap != (Pixmap) NULL) {
 216         XDrawLine(xstuff->disp, xstuff->bufpixmap, gcxor, x1, y1, x2, y2);
 217     }
 218 }
 219
 220 static void aux_XDrawRectangle(GUI *gui, int x1, int y1, int x2, int y2)
 221 {
 222     X11Stuff *xstuff = gui->xstuff;
 223     XDrawRectangle(xstuff->disp, xstuff->xwin, gcxor, x1, y1, x2, y2);
 224     if (xstuff->bufpixmap != (Pixmap) NULL) {
 225         XDrawRectangle(xstuff->disp, xstuff->bufpixmap, gcxor, x1, y1, x2, y2);
 226     }
 227 }
 228
 229 static void aux_XFillRectangle(GUI *gui, int x, int y, unsigned int width, unsigned int height)
 230 {
 231     X11Stuff *xstuff = gui->xstuff;
 232     XFillRectangle(xstuff->disp, xstuff->xwin, gcxor, x, y, width, height);
 233     if (xstuff->bufpixmap != (Pixmap) NULL) {
 234         XFillRectangle(xstuff->disp, xstuff->bufpixmap, gcxor, x, y, width, height);
 235     }
 236 }
 237
 238
 239 /*
 240  * draw the graph focus indicators
 241  */
 242 void draw_focus(Quark *gr)
 243 {
 244     short ix1, iy1, ix2, iy2;
 245     view v;
 246     VPoint vp;
 247     GUI *gui = gui_from_quark(gr);
 248
 249     if (gui->draw_focus_flag == TRUE) {
 250         graph_get_viewport(gr, &v);
 251         vp.x = v.xv1;
 252         vp.y = v.yv1;
 253         x11_VPoint2dev(&vp, &ix1, &iy1);
 254         vp.x = v.xv2;
 255         vp.y = v.yv2;
 256         x11_VPoint2dev(&vp, &ix2, &iy2);
 257         aux_XFillRectangle(gui, ix1 - 5, iy1 - 5, 10, 10);
 258         aux_XFillRectangle(gui, ix1 - 5, iy2 - 5, 10, 10);
 259         aux_XFillRectangle(gui, ix2 - 5, iy2 - 5, 10, 10);
 260         aux_XFillRectangle(gui, ix2 - 5, iy1 - 5, 10, 10);
 261
 262         gui->xstuff->f_x1 = ix1;
 263         gui->xstuff->f_x2 = ix2;
 264         gui->xstuff->f_y1 = iy1;
 265         gui->xstuff->f_y2 = iy2;
 266
 267         gui->xstuff->f_v  = v;
 268     }
 269 }
 270
 271 /*
 272  * rubber band line (optionally erasing previous one)
 273  */
 274 void select_line(GUI *gui, int x1, int y1, int x2, int y2, int erase)
 275 {
 276     static int x1_old, y1_old, x2_old, y2_old;
 277
 278     if (erase) {
 279         aux_XDrawLine(gui, x1_old, y1_old, x2_old, y2_old);
 280     }
 281     x1_old = x1;
 282     y1_old = y1;
 283     x2_old = x2;
 284     y2_old = y2;
 285     aux_XDrawLine(gui, x1, y1, x2, y2);
 286 }
 287
 288 static int region_need_erasing = FALSE;
 289 /*
 290  * draw an xor'ed box (optionally erasing previous one)
 291  */
 292 void select_region(GUI *gui, int x1, int y1, int x2, int y2, int erase)
 293 {
 294     static int x1_old, y1_old, dx_old, dy_old;
 295     int dx = x2 - x1;
 296     int dy = y2 - y1;
 297
 298     if (dx < 0) {
 299         iswap(&x1, &x2);
 300         dx = -dx;
 301     }
 302     if (dy < 0) {
 303         iswap(&y1, &y2);
 304         dy = -dy;
 305     }
 306     if (erase && region_need_erasing) {
 307         aux_XDrawRectangle(gui, x1_old, y1_old, dx_old, dy_old);
 308     }
 309     x1_old = x1;
 310     y1_old = y1;
 311     dx_old = dx;
 312     dy_old = dy;
 313     aux_XDrawRectangle(gui, x1, y1, dx, dy);
 314     region_need_erasing = TRUE;
 315 }
 316
 317 void select_vregion(GUI *gui, int x1, int x2, int erase)
 318 {
 319     X11Stuff *xstuff = gui->xstuff;
 320
 321     select_region(gui, x1, xstuff->f_y1, x2, xstuff->f_y2, erase);
 322 }
 323
 324 void select_hregion(GUI *gui, int y1, int y2, int erase)
 325 {
 326     X11Stuff *xstuff = gui->xstuff;
 327
 328     select_region(gui, xstuff->f_x1, y1, xstuff->f_x2, y2, erase);
 329 }
 330
 331 /*
 332  * slide an xor'ed bbox shifted by shift_*, (optionally erasing previous one)
 333  */
 334 void slide_region(GUI *gui, view bb, int shift_x, int shift_y, int erase)
 335 {
 336     short x1, x2, y1, y2;
 337     VPoint vp;
 338
 339     vp.x = bb.xv1;
 340     vp.y = bb.yv1;
 341     x11_VPoint2dev(&vp, &x1, &y1);
 342     x1 += shift_x;
 343     y1 += shift_y;
 344
 345     vp.x = bb.xv2;
 346     vp.y = bb.yv2;
 347     x11_VPoint2dev(&vp, &x2, &y2);
 348     x2 += shift_x;
 349     y2 += shift_y;
 350
 351     select_region(gui, x1, y1, x2, y2, erase);
 352 }
 353
 354 void resize_region(GUI *gui, view bb, int on_focus,
 355     int shift_x, int shift_y, int erase)
 356 {
 357     short x1, x2, y1, y2;
 358     VPoint vp;
 359
 360     vp.x = bb.xv1;
 361     vp.y = bb.yv1;
 362     x11_VPoint2dev(&vp, &x1, &y1);
 363     vp.x = bb.xv2;
 364     vp.y = bb.yv2;
 365     x11_VPoint2dev(&vp, &x2, &y2);
 366
 367     switch (on_focus) {
 368     case 1:
 369         x1 += shift_x;
 370         y1 += shift_y;
 371         break;
 372     case 2:
 373         x1 += shift_x;
 374         y2 += shift_y;
 375         break;
 376     case 3:
 377         x2 += shift_x;
 378         y2 += shift_y;
 379         break;
 380     case 4:
 381         x2 += shift_x;
 382         y1 += shift_y;
 383         break;
 384     default:
 385         return;
 386     }
 387
 388     select_region(gui, x1, y1, x2, y2, erase);
 389 }
 390
 391 static int crosshair_erase = FALSE;
 392 static int cursor_oldx, cursor_oldy;
 393
 394
 395 void reset_crosshair(GUI *gui, int clear)
 396 {
 397     X11Stuff *xstuff = gui->xstuff;
 398     crosshair_erase = FALSE;
 399     if (clear) {
 400         aux_XDrawLine(gui, xstuff->f_x1, cursor_oldy, xstuff->f_x2, cursor_oldy);
 401         aux_XDrawLine(gui, cursor_oldx, xstuff->f_y1, cursor_oldx, xstuff->f_y2);
 402     }
 403 }
 404
 405 /*
 406  * draw a crosshair cursor
 407  */
 408 void crosshair_motion(GUI *gui, int x, int y)
 409 {
 410     X11Stuff *xstuff = gui->xstuff;
 411
 412     /* Erase the previous crosshair */
 413     if (crosshair_erase == TRUE) {
 414         aux_XDrawLine(gui, xstuff->f_x1, cursor_oldy, xstuff->f_x2, cursor_oldy);
 415         aux_XDrawLine(gui, cursor_oldx, xstuff->f_y1, cursor_oldx, xstuff->f_y2);
 416     }
 417
 418     if (x < xstuff->f_x1 || x > xstuff->f_x2 ||
 419         y < xstuff->f_y2 || y > xstuff->f_y1) {
 420         crosshair_erase = FALSE;
 421         return;
 422     }
 423
 424     /* Draw the new crosshair */
 425     aux_XDrawLine(gui, xstuff->f_x1, y, xstuff->f_x2, y);
 426     aux_XDrawLine(gui, x, xstuff->f_y1, x, xstuff->f_y2);
 427     crosshair_erase = TRUE;
 428     cursor_oldx = x;
 429     cursor_oldy = y;
 430 }
 431
 432 void sync_canvas_size(Grace *grace)
 433 {
 434     X11Stuff *xstuff = grace->gui->xstuff;
 435     unsigned int w, h;
 436
 437     Device_entry *d = get_device_props(grace->rt->canvas, grace->rt->tdevice);
 438
 439     GetDimensions(xstuff->canvas, &w, &h);
 440
 441     set_page_dimensions(grace, w*72.0/d->pg.dpi, h*72.0/d->pg.dpi, TRUE);
 442 }
 443
 444
 445 /*
 446  * expose/resize proc
 447  */
 448 void expose_resize(Widget w, XtPointer client_data, XtPointer call_data)
 449 {
 450     Grace *grace = (Grace *) client_data;
 451     static int inc = FALSE;
 452     XmDrawingAreaCallbackStruct *cbs = (XmDrawingAreaCallbackStruct *) call_data;
 453
 454 #if defined(DEBUG)
 455     if (get_debuglevel(grace) == 7) {
 456         printf("Call to expose_resize(); reason == %d\n", cbs->reason);
 457     }
 458 #endif
 459
 460     /* HACK */
 461     if (!grace->gui->inwin) {
 462         return;
 463     }
 464
 465     if (!inc) {
 466         inc = TRUE;
 467
 468         update_all();
 469         xdrawgraph(grace->project, TRUE);
 470
 471         return;
 472     }
 473
 474     if (cbs->reason == XmCR_EXPOSE) {
 475         x11_redraw(cbs->window,
 476             cbs->event->xexpose.x,
 477             cbs->event->xexpose.y,
 478             cbs->event->xexpose.width,
 479             cbs->event->xexpose.height);
 480     } else {
 481         if (gui_is_page_free(grace->gui)) {
 482             sync_canvas_size(grace);
 483             update_all();
 484             xdrawgraph(grace->project, TRUE);
 485         }
 486     }
 487 }
 488
 489 /*
 490  * redraw all
 491  */
 492 void xdrawgraph(const Quark *q, int force)
 493 {
 494     Quark *project = get_parent_project(q);
 495     Grace *grace = grace_from_quark(q);
 496
 497     if (grace && grace->gui->inwin && (force || grace->gui->auto_redraw)) {
 498         X11Stuff *xstuff = grace->gui->xstuff;
 499         Quark *gr = graph_get_current(project);
 500         Device_entry *d = get_device_props(grace->rt->canvas, grace->rt->tdevice);
 501         Page_geometry *pg = &d->pg;
 502         float dpi = grace->gui->zoom*xstuff->dpi;
 503
 504         set_wait_cursor();
 505
 506         if (dpi != pg->dpi) {
 507             int wpp, hpp;
 508             project_get_page_dimensions(project, &wpp, &hpp);
 509
 510             pg->width  = (unsigned long) (wpp*dpi/72);
 511             pg->height = (unsigned long) (hpp*dpi/72);
 512             pg->dpi = dpi;
 513         }
 514
 515         resize_drawables(pg->width, pg->height);
 516
 517         select_device(grace->rt->canvas, grace->rt->tdevice);
 518         drawgraph(project);
 519
 520         if (quark_is_active(gr)) {
 521             draw_focus(gr);
 522         }
 523         reset_crosshair(grace->gui, FALSE);
 524         region_need_erasing = FALSE;
 525
 526         x11_redraw(xstuff->xwin, 0, 0, xstuff->win_w, xstuff->win_h);
 527
 528         XFlush(xstuff->disp);
 529
 530         unset_wait_cursor();
 531     }
 532 }
 533
 534
 535 void x11_redraw(Window window, int x, int y, int width, int height)
 536 {
 537     X11Stuff *xstuff = grace->gui->xstuff;
 538     if (grace->gui->inwin == TRUE && xstuff->bufpixmap != (Pixmap) NULL) {
 539         XCopyArea(xstuff->disp, xstuff->bufpixmap, window, xstuff->gc, x, y, width, height, x, y);
 540     }
 541 }
 542
 543 static void resize_drawables(unsigned int w, unsigned int h)
 544 {
 545     X11Stuff *xstuff = grace->gui->xstuff;
 546
 547     if (w == 0 || h == 0) {
 548         return;
 549     }
 550
 551     if (xstuff->bufpixmap == (Pixmap) NULL) {
 552         xstuff->bufpixmap = XCreatePixmap(xstuff->disp, xstuff->root, w, h, xstuff->depth);
 553     } else if (xstuff->win_w != w || xstuff->win_h != h) {
 554         XFreePixmap(xstuff->disp, xstuff->bufpixmap);
 555         xstuff->bufpixmap = XCreatePixmap(xstuff->disp, xstuff->root, w, h, xstuff->depth);
 556     }
 557
 558     if (xstuff->bufpixmap == (Pixmap) NULL) {
 559         errmsg("Can't allocate buffer pixmap");
 560         xstuff->win_w = 0;
 561         xstuff->win_h = 0;
 562     } else {
 563         xstuff->win_w = w;
 564         xstuff->win_h = h;
 565     }
 566
 567     xstuff->win_scale = MIN2(xstuff->win_w, xstuff->win_h);
 568
 569     if (!gui_is_page_free(grace->gui)) {
 570         SetDimensions(xstuff->canvas, xstuff->win_w, xstuff->win_h);
 571     }
 572 }
 573
 574 static void xmonitor_rti(XtPointer ib, int *ptrFd, XtInputId *ptrId)
 575 {
 576     set_wait_cursor();
 577
 578     monitor_input(grace, (Input_buffer *) ib, 1, 1);
 579
 580     unset_wait_cursor();
 581 }
 582
 583 void xregister_rti(Input_buffer *ib)
 584 {
 585     if (grace->gui->inwin && ib) {
 586         /* the screen has been initialized : we can register the buffer */
 587         ib->id = (unsigned long) XtAppAddInput(app_con,
 588                                                ib->fd,
 589                                                (XtPointer) XtInputReadMask,
 590                                                xmonitor_rti,
 591                                                (XtPointer) ib);
 592     }
 593 }
 594
 595 void xunregister_rti(const Input_buffer *ib)
 596 {
 597     if (grace->gui->inwin && ib) {
 598         /* the screen has been initialized : we can remove the buffer */
 599         XtRemoveInput((XtInputId) ib->id);
 600     }
 601 }
 602
 603 /*
 604  * for the goto point feature
 605  */
 606 void setpointer(VPoint vp)
 607 {
 608     X11Stuff *xstuff = grace->gui->xstuff;
 609     short x, y;
 610
 611     x11_VPoint2dev(&vp, &x, &y);
 612
 613     /* Make sure we remain inside the DA widget dimensions */
 614     x = MAX2(x, 0);
 615     x = MIN2(x, xstuff->win_w);
 616     y = MAX2(y, 0);
 617     y = MIN2(y, xstuff->win_h);
 618
 619     XWarpPointer(xstuff->disp, None, xstuff->xwin, 0, 0, 0, 0, x, y);
 620 }
 621
 622 char *display_name(GUI *gui)
 623 {
 624     return DisplayString(gui->xstuff->disp);
 625 }
 626
 627 #define BUFSIZE 1024
 628 static int HandleXError(Display *dpy, XErrorEvent *event)
 629 {
 630     char buffer[BUFSIZE], mesg[BUFSIZE], *output;
 631
 632     char *mtype = "XlibMessage";
 633
 634     XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", buffer, BUFSIZE);
 635     output = copy_string(NULL, buffer);
 636     output = concat_strings(output, ":");
 637
 638     XGetErrorText(dpy, event->error_code, buffer, BUFSIZE);
 639     output = concat_strings(output, buffer);
 640     output = concat_strings(output, "\n");
 641
 642     XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d", mesg,
 643                           BUFSIZE);
 644     sprintf(buffer, mesg, event->request_code);
 645     output = concat_strings(output, buffer);
 646
 647     if (event->request_code < 128) {
 648         char number[32];
 649         sprintf(number, "%d", event->request_code);
 650         XGetErrorDatabaseText(dpy, "XRequest", number, "", mesg, BUFSIZE);
 651         sprintf(buffer, " (%s)\n", mesg);
 652         output = concat_strings(output, buffer);
 653     }
 654
 655     switch (event->error_code) {
 656     case (BadWindow):
 657     case (BadPixmap):
 658     case (BadCursor):
 659     case (BadFont):
 660     case (BadDrawable):
 661     case (BadColor):
 662     case (BadGC):
 663     case (BadIDChoice):
 664     case (BadValue):
 665     case (BadAtom):
 666         if (event->error_code == BadValue) {
 667            XGetErrorDatabaseText(dpy, mtype, "Value", "Value 0x%x", mesg,
 668                                  BUFSIZE);
 669         } else if (event->error_code == BadAtom) {
 670            XGetErrorDatabaseText(dpy, mtype, "AtomID", "AtomID 0x%x", mesg,
 671                                  BUFSIZE);
 672         } else {
 673            XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
 674                                  mesg, BUFSIZE);
 675         }
 676         output = concat_strings(output, "  ");
 677         sprintf(buffer, mesg, event->resourceid);
 678         output = concat_strings(output, buffer);
 679         output = concat_strings(output, "\n");
 680         break;
 681     } /* switch() */
 682
 683     XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d", mesg,
 684                            BUFSIZE);
 685     sprintf(buffer, mesg, event->serial);
 686     output = concat_strings(output, "  ");
 687     output = concat_strings(output, buffer);
 688     output = concat_strings(output, ".");
 689
 690     emergency_exit(grace, TRUE, output);
 691     xfree(output);
 692
 693     /* return value is ignored anyway */
 694     return 0;
 695 }
 696
 697 /*
 698  * Interrupt handler for X IO errors
 699  */
 700 static int HandleXIOError(Display *d)
 701 {
 702     char msg[BUFSIZE];
 703     if (errno == EPIPE) {
 704         sprintf(msg, "X connection to %s broken (server error - EPIPE).",
 705                DisplayString(d));
 706     } else {
 707         sprintf(msg, "Fatal IO error on X server %s.", DisplayString(d));
 708     }
 709
 710     emergency_exit(grace, FALSE, msg);
 711
 712     /* Ideally, we don't reach this anyway ... */
 713     return 1;
 714 }
 715
 716 void installXErrorHandler(void)
 717 {
 718     XSetErrorHandler(HandleXError);
 719     XSetIOErrorHandler(HandleXIOError);
 720 }
 721
 722 int x11_init(Grace *grace)
 723 {
 724     X11Stuff *xstuff = grace->gui->xstuff;
 725     XGCValues gc_val;
 726     long mrsize;
 727     int max_path_limit;
 728
 729     xstuff->screennumber = DefaultScreen(xstuff->disp);
 730     xstuff->root = RootWindow(xstuff->disp, xstuff->screennumber);
 731
 732     xstuff->gc = DefaultGC(xstuff->disp, xstuff->screennumber);
 733
 734     xstuff->depth = DisplayPlanes(xstuff->disp, xstuff->screennumber);
 735
 736     /* init colormap */
 737     xstuff->cmap = DefaultColormap(xstuff->disp, xstuff->screennumber);
 738     /* redefine colormap, if needed */
 739     if (grace->gui->install_cmap == CMAP_INSTALL_ALWAYS) {
 740         xstuff->cmap = XCopyColormapAndFree(xstuff->disp, xstuff->cmap);
 741         grace->gui->private_cmap = TRUE;
 742     }
 743
 744     /* set GCs */
 745     if (grace->gui->invert) {
 746         gc_val.function = GXinvert;
 747     } else {
 748         gc_val.function = GXxor;
 749     }
 750     gcxor = XCreateGC(xstuff->disp, xstuff->root, GCFunction, &gc_val);
 751
 752     /* XExtendedMaxRequestSize() appeared in X11R6 */
 753 #if XlibSpecificationRelease > 5
 754     mrsize = XExtendedMaxRequestSize(xstuff->disp);
 755 #else
 756     mrsize = 0;
 757 #endif
 758     if (mrsize <= 0) {
 759         mrsize = XMaxRequestSize(xstuff->disp);
 760     }
 761     max_path_limit = (mrsize - 3)/2;
 762     if (max_path_limit < get_max_path_limit(grace->rt->canvas)) {
 763         char buf[128];
 764         sprintf(buf,
 765             "Setting max drawing path length to %d (limited by the X server)",
 766             max_path_limit);
 767         errmsg(buf);
 768         set_max_path_limit(grace->rt->canvas, max_path_limit);
 769     }
 770
 771     xstuff->dpi = rint(MM_PER_INCH*DisplayWidth(xstuff->disp, xstuff->screennumber)/
 772         DisplayWidthMM(xstuff->disp, xstuff->screennumber));
 773
 774     return RETURN_SUCCESS;
 775 }
 776
 777
 778 static int x11_convx(double x)
 779 {
 780     X11Stuff *xstuff = grace->gui->xstuff;
 781     return ((int) rint(xstuff->win_scale * x));
 782 }
 783
 784 static int x11_convy(double y)
 785 {
 786     X11Stuff *xstuff = grace->gui->xstuff;
 787     return ((int) rint(xstuff->win_h - xstuff->win_scale * y));
 788 }
 789
 790 void x11_VPoint2dev(const VPoint *vp, short *x, short *y)
 791 {
 792     *x = x11_convx(vp->x);
 793     *y = x11_convy(vp->y);
 794 }
 795
 796 /*
 797  * x11_dev2VPoint - given (x,y) in screen coordinates, return the
 798  * viewport coordinates
 799  */
 800 void x11_dev2VPoint(short x, short y, VPoint *vp)
 801 {
 802     X11Stuff *xstuff = grace->gui->xstuff;
 803     if (xstuff->win_scale == 0) {
 804         vp->x = (double) 0.0;
 805         vp->y = (double) 0.0;
 806     } else {
 807         vp->x = (double) x / xstuff->win_scale;
 808         vp->y = (double) (xstuff->win_h - y) / xstuff->win_scale;
 809     }
 810 }
 811
 812 Pixmap char_to_pixmap(Widget w, int font, char c, int csize)
 813 {
 814     X11Stuff *xstuff = grace->gui->xstuff;
 815     CPixmap *pm;
 816     Pixmap pixmap = 0;
 817     int height, width, hshift, vshift;
 818     float fsize = 0.8*(float)csize;
 819
 820     pm = canvas_raster_char(font, c, fsize, &vshift, &hshift);
 821
 822     if (pm != NULL && pm->bits != NULL) {
 823         long bg, fg;
 824         Pixmap ptmp;
 825
 826         vshift = csize - vshift - 4;
 827         height = pm->height;
 828         width = pm->width;
 829
 830         ptmp = XCreateBitmapFromData(xstuff->disp, xstuff->root,
 831                     pm->bits, width, height);
 832         pixmap = XCreatePixmap(xstuff->disp, xstuff->root,
 833             csize, csize, xstuff->depth);
 834
 835         XtVaGetValues(w, XmNbackground, &bg, XmNforeground, &fg, NULL);
 836         XSetForeground(xstuff->disp, xstuff->gc, bg);
 837         XFillRectangle(xstuff->disp, pixmap, xstuff->gc, 0, 0, csize, csize);
 838
 839         XSetBackground(xstuff->disp, xstuff->gc, bg);
 840         XSetForeground(xstuff->disp, xstuff->gc, fg);
 841         XCopyPlane(xstuff->disp, ptmp, pixmap, xstuff->gc, 0, 0,
 842             width, height, hshift, vshift, 1);
 843
 844         XFreePixmap(xstuff->disp, ptmp);
 845         canvas_cpixmap_free(pm);
 846     }
 847
 848     return pixmap;
 849 }