home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume13 / ishido / part01 / gl.c next >
C/C++ Source or Header  |  1992-04-10  |  10KB  |  450 lines
  1. /*
  2.  * gl.c - Simple graphics library, based on X11. 
  3.  *
  4.  * Author:  John Sullivan, Amdahl Corporation (jjs40@cd.amdahl.com)
  5.  *
  6.  */
  7.  
  8. /*****************************************************************************/
  9.  
  10. #include "gl.h"
  11.  
  12. #include <X11/Xlib.h>
  13. #include <X11/Xutil.h>
  14. #include <X11/Xos.h>
  15.  
  16. #include <stdlib.h>
  17. #include <stdio.h>
  18.  
  19. /*****************************************************************************/
  20.  
  21. Display        *gl_display;
  22. int             gl_screen;
  23. Window          gl_window;
  24. GC              gl_gc;
  25. GL_REDRAW_FUNC  gl_redraw_fn;
  26. GL_EVENT_FUNC   gl_event_fn;
  27. int             gl_main;
  28. int             gl_screen_width;
  29. int             gl_screen_height;
  30. int             gl_fg;
  31. int             gl_bg;
  32.  
  33. /*****************************************************************************/
  34.  
  35. void
  36. gl_bomb(s)
  37.     char           *s;
  38. {
  39.     printf("gl_bomb(): %s\n");
  40.     exit(1);
  41. };
  42.  
  43. /*****************************************************************************/
  44.  
  45. GL_PIXEL
  46. gl_alloc_color(name)
  47.     char           *name;
  48. {
  49.     XColor          c1, c2;
  50.     int             res;
  51.  
  52.     res = XAllocNamedColor(gl_display,
  53.                    DefaultColormap(gl_display, gl_screen),
  54.                    name, &c1, &c2);
  55.     if (!res) {
  56.         gl_bomb("Unable to allocate color.");
  57.     };
  58.     return (c1.pixel);
  59. };
  60.  
  61. /*****************************************************************************/
  62.  
  63. void
  64. gl_redraw_func(func)
  65.     GL_REDRAW_FUNC  func;
  66. {
  67.     gl_redraw_fn = func;
  68. };
  69.  
  70. /*****************************************************************************/
  71.  
  72. void
  73. gl_event_func(func)
  74.     GL_EVENT_FUNC   func;
  75. {
  76.     gl_event_fn = func;
  77. };
  78.  
  79. /*****************************************************************************/
  80.  
  81. char            gl_event_str_buf[GL_BUFSIZE];
  82.  
  83. char           *
  84. gl_event_str(gl_ev)
  85.     GL_EVENT       *gl_ev;
  86. {
  87.     switch (gl_ev->type) {
  88.     case GL_EVENT_KEY:
  89.         sprintf(gl_event_str_buf,
  90.             "gl_event: key '%c' at (%d,%d)",
  91.             gl_ev->key, gl_ev->x, gl_ev->y);
  92.         break;
  93.     case GL_EVENT_BUTTON:
  94.         sprintf(gl_event_str_buf,
  95.             "gl_event: button %d at (%d,%d)",
  96.             gl_ev->button, gl_ev->x, gl_ev->y);
  97.     };
  98.     return (gl_event_str_buf);
  99. };
  100.  
  101. /*****************************************************************************/
  102.  
  103. void
  104. gl_main_loop()
  105. {
  106.     XEvent          xev;
  107.     XButtonEvent   *xbev;
  108.     XKeyEvent      *xkev;
  109.     GL_EVENT        gl_ev;
  110.     char            buf[GL_BUFSIZE];
  111.  
  112.     gl_main = 1;
  113.     while (gl_main) {
  114.         XNextEvent(gl_display, &xev);
  115.         switch (xev.type) {
  116.         case Expose:
  117.             if (gl_redraw_fn != NULL) {
  118.                 (*gl_redraw_fn) ();
  119.             };
  120.             break;
  121.         case KeyPress:
  122.             gl_ev.type = GL_EVENT_KEY;
  123.             xkev = (XKeyEvent *) & xev;
  124.             XLookupString(xkev, buf, GL_BUFSIZE, NULL, NULL);
  125.             gl_ev.key = buf[0];
  126.             gl_ev.x = xkev->x;
  127.             gl_ev.y = xkev->y;
  128.             if (gl_event_fn != NULL) {
  129.                 (*gl_event_fn) (&gl_ev);
  130.             };
  131.             break;
  132.         case ButtonPress:
  133.             gl_ev.type = GL_EVENT_BUTTON;
  134.             xbev = (XButtonEvent *) & xev;
  135.             gl_ev.button = xbev->button;
  136.             gl_ev.x = xbev->x;
  137.             gl_ev.y = xbev->y;
  138.             if (gl_event_fn != NULL) {
  139.                 (*gl_event_fn) (&gl_ev);
  140.             };
  141.             break;
  142.         };
  143.     };
  144. };
  145.  
  146. /*****************************************************************************/
  147.  
  148. void
  149. gl_exit_main()
  150. {
  151.     gl_main = 0;
  152. };
  153.  
  154. /*****************************************************************************/
  155.  
  156. void
  157. gl_set_fg(c)
  158.     GL_PIXEL        c;
  159. {
  160.     XGCValues       gcv;
  161.  
  162.     gl_fg = c;
  163.     gcv.foreground = gl_fg;
  164.     XChangeGC(gl_display, gl_gc, GCForeground, &gcv);
  165. };
  166.  
  167. /*****************************************************************************/
  168.  
  169. void
  170. gl_set_bg(c)
  171.     GL_PIXEL        c;
  172. {
  173.     XGCValues       gcv;
  174.  
  175.     gl_bg = c;
  176.     gcv.background = gl_bg;
  177.     XChangeGC(gl_display, gl_gc, GCBackground, &gcv);
  178. };
  179.  
  180. /*****************************************************************************/
  181.  
  182. void
  183. gl_set_fg_bg(c1, c2)
  184.     GL_PIXEL        c1, c2;
  185. {
  186.     gl_set_fg(c1);
  187.     gl_set_bg(c2);
  188. };
  189.  
  190. /*****************************************************************************/
  191.  
  192. void
  193. gl_draw_point(x, y)
  194.     int             x, y;
  195. {
  196.     XDrawPoint(gl_display, gl_window, gl_gc, x, y);
  197. };
  198.  
  199. /*****************************************************************************/
  200.  
  201. void
  202. gl_draw_line(x1, y1, x2, y2)
  203.     int             x1, y1;
  204.     int             x2, y2;
  205. {
  206.     XDrawLine(gl_display, gl_window, gl_gc, x1, y1, x2, y2);
  207. };
  208.  
  209. /*****************************************************************************/
  210.  
  211. void
  212. gl_draw_rect(x1, y1, w, h)
  213.     int             x1, y1;
  214.     int             w, h;
  215. {
  216.     XDrawRectangle(gl_display, gl_window, gl_gc, x1, y1, w - 1, h - 1);
  217. };
  218.  
  219. /*****************************************************************************/
  220.  
  221. void
  222. gl_fill_rect(x1, y1, w, h)
  223.     int             x1, y1;
  224.     int             w, h;
  225. {
  226.     XFillRectangle(gl_display, gl_window, gl_gc, x1, y1, w, h);
  227. };
  228.  
  229. /*****************************************************************************/
  230.  
  231. void
  232. gl_draw_text(x, y, s)
  233.     int             x, y;
  234.     char           *s;
  235. {
  236.     int             len;
  237.  
  238.     len = strlen(s);
  239.     y = y + GL_FONT_DESCENT;
  240.     XDrawImageString(gl_display, gl_window, gl_gc, x, y, s, len);
  241. };
  242.  
  243. /*****************************************************************************/
  244.  
  245. void
  246. gl_ring_bell()
  247. {
  248.     XBell(gl_display, 75);
  249. };
  250.  
  251. /*****************************************************************************/
  252.  
  253. GL_BITMAP
  254. gl_load_bitmap(data, w, h)
  255.     char           *data;
  256.     int             w, h;
  257. {
  258.     return (XCreateBitmapFromData(gl_display, gl_window, data, w, h));
  259. };
  260.  
  261. /*****************************************************************************/
  262.  
  263. void
  264. gl_draw_bitmap(bitmap, x, y, w, h)
  265.     GL_BITMAP       bitmap;
  266.     int             x, y;
  267.     int             w, h;
  268. {
  269.     XCopyPlane(gl_display, bitmap, gl_window, gl_gc, 0, 0, w, h, x, y,
  270. 1);
  271. };
  272.  
  273. /*****************************************************************************/
  274.  
  275. void
  276. gl_init(argc, argv, w, h)
  277.     int             argc;
  278.     char          **argv;
  279.     int             w, h;
  280. {
  281.     XSizeHints      hints;
  282.     XGCValues       gcv;
  283.     unsigned long   gcvm;
  284.  
  285.     gl_display = XOpenDisplay(NULL);
  286.     if (!gl_display) {
  287.         gl_bomb("Unable to connect to display.");
  288.     };
  289.  
  290.     gl_redraw_fn = NULL;
  291.     gl_event_fn = NULL;
  292.  
  293.     gl_screen_width = w;
  294.     gl_screen_height = h;
  295.     hints.width = gl_screen_width;
  296.     hints.height = gl_screen_height;
  297.     hints.flags = PSize;
  298.  
  299.     gl_fg = gl_alloc_color(GL_FOREGROUND);
  300.     gl_bg = gl_alloc_color(GL_BACKGROUND);
  301.     gcv.foreground = gl_fg;
  302.     gcv.background = gl_bg;
  303.     gcv.font = XLoadFont(gl_display, GL_FONT);
  304.     gcvm = GCForeground | GCBackground | GCFont;
  305.  
  306.     gl_screen = DefaultScreen(gl_display);
  307.     gl_window = XCreateSimpleWindow(gl_display,
  308.                RootWindow(gl_display, gl_screen), 0, 0, hints.width,
  309.                hints.height, 2, gcv.foreground, gcv.background);
  310.  
  311.     XSetStandardProperties(gl_display, gl_window, "GL", "GL",
  312.                    None, argv, argc, &hints);
  313.     XSelectInput(gl_display, gl_window,
  314.              ExposureMask | KeyPressMask | ButtonPressMask);
  315.  
  316.     gl_gc = XCreateGC(gl_display, gl_window, gcvm, &gcv);
  317. };
  318.  
  319. /*****************************************************************************/
  320.  
  321. void
  322. gl_start()
  323. {
  324.     XMapWindow(gl_display, gl_window);
  325.     XSync(gl_display);
  326. };
  327.  
  328. /*****************************************************************************/
  329.  
  330. void
  331. gl_exit()
  332. {
  333.     XCloseDisplay(gl_display);
  334.     exit(0);
  335. };
  336.  
  337. /*****************************************************************************/
  338.  
  339. void
  340. gu_draw_border(x, y, w, h, z)
  341.     int             x, y;
  342.     int             w, h;
  343.     int             z;
  344. {
  345.     int             i;
  346.  
  347.     for (i = 1; i <= z; i++) {
  348.         gl_draw_rect(x - i, y - i, w + i * 2, h + i * 2);
  349.     };
  350. };
  351.  
  352. /*****************************************************************************/
  353.  
  354. void
  355. gu_draw_centered_text(x, y, s)
  356.     int             x, y;
  357.     char           *s;
  358. {
  359.     int             sx, sy;
  360.  
  361.     sx = x - (strlen(s) * GL_FONT_WIDTH) / 2;
  362.     sy = y - GL_FONT_HEIGHT / 2;
  363.     gl_draw_text(sx, sy, s);
  364. };
  365.  
  366. /*****************************************************************************/
  367.  
  368. GL_BOOL
  369. gu_event_in_rect(event, x, y, w, h)
  370.     GL_EVENT       *event;
  371.     int             x, y;
  372.     int             w, h;
  373. {
  374.     x = event->x - x;
  375.     y = event->y - y;
  376.     return ((x >= 0) && (x < w) && (y >= 0) && (y < h));
  377. };
  378.  
  379. /*****************************************************************************/
  380.  
  381. void
  382. gb_draw_button(btn)
  383.     GB_BUTTON      *btn;
  384. {
  385.     gl_set_fg(btn->border);
  386.     gu_draw_border(btn->x, btn->y, btn->w, btn->h, 2);
  387.     gl_set_fg(btn->background);
  388.     gl_fill_rect(btn->x, btn->y, btn->w, btn->h);
  389.     gl_set_fg_bg(btn->text, btn->background);
  390.     gu_draw_centered_text(btn->x + btn->w / 2, btn->y + btn->h / 2,
  391. btn->label);
  392. };
  393.  
  394. /*****************************************************************************/
  395.  
  396. void
  397. gb_draw_buttons(n, btn)
  398.     int             n;
  399.     GB_BUTTON      *btn;
  400. {
  401.     int             i;
  402.  
  403.     for (i = 0; i < n; i++) {
  404.         gb_draw_button(&(btn[i]));
  405.     };
  406. };
  407.  
  408. /*****************************************************************************/
  409.  
  410. GL_BOOL
  411. gb_event_in_button(event, btn)
  412.     GL_EVENT       *event;
  413.     GB_BUTTON      *btn;
  414. {
  415.     return (gu_event_in_rect(event, btn->x, btn->y, btn->w, btn->h));
  416. };
  417.  
  418. /*****************************************************************************/
  419.  
  420. void
  421. gb_button_press(event, btn)
  422.     GL_EVENT       *event;
  423.     GB_BUTTON      *btn;
  424. {
  425.     if (btn->event_fn != NULL) {
  426.         (*(btn->event_fn)) (event);
  427.     };
  428. };
  429.  
  430. /*****************************************************************************/
  431.  
  432. GL_BOOL
  433. gb_button_event(event, n, btn)
  434.     GL_EVENT       *event;
  435.     int             n;
  436.     GB_BUTTON      *btn;
  437. {
  438.     int             i;
  439.  
  440.     for (i = 0; i < n; i++) {
  441.         if (gb_event_in_button(event, &(btn[i]))) {
  442.             gb_button_press(event, &(btn[i]));
  443.             return (GL_TRUE);
  444.         };
  445.     };
  446.     return (GL_FALSE);
  447. };
  448.  
  449. /*****************************************************************************/
  450.