home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / fermiVogle.tar.Z / fermiVogle.tar / devel / drivers / apollo.c next >
C/C++ Source or Header  |  1996-02-07  |  12KB  |  600 lines
  1. /*
  2.  *    Apollo driver for vogle.
  3.  */
  4.  
  5. #include "/sys/ins/base.ins.c"
  6. #include "/sys/ins/gpr.ins.c"
  7. #include "/sys/ins/pad.ins.c"
  8. #include "/sys/ins/kbd.ins.c"
  9. #include <stdio.h>
  10. #include "vogle.h"
  11.  
  12. #define FONTBASE "/sys/dm/fonts/"
  13.  
  14. #define MAXCOLORS        256
  15. #define MIN(x,y)        ((x) < (y) ? (x) : (y))
  16. #define COLOR_ENTRY(r, g, b)    (gpr_$pixel_value_t) ((r << 16) | (g << 8) | b)
  17.  
  18. static ios_$id_t        stream_id;
  19. static gpr_$pixel_value_t      color_value[MAXCOLORS];
  20. static gpr_$pixel_value_t      old_color_value[MAXCOLORS];
  21.  
  22. static gpr_$offset_t            init_bitmap_size;   
  23. static gpr_$bitmap_desc_t       current_bitmap, front_bitmap, back_bitmap;       
  24. static gpr_$attribute_desc_t       attribs;
  25. static gpr_$window_t           source;
  26. static gpr_$position_t           dest_pos;
  27.  
  28. static gpr_$display_mode_t      mode = gpr_$direct;
  29. static gpr_$plane_t             hi_plane_id = 0;    
  30. static boolean                  delete_display;    
  31. static status_$t                status;
  32. static gpr_$keyset_t            keys, mouse_keys;
  33.  
  34. static pad_$window_list_t     window_info;
  35. static short             n_windows;
  36. static gpr_$disp_char_t        disp;
  37. static short            disp_len;
  38.  
  39. static int             first_time, back_used;
  40. static int             current_color;
  41. static short             font_id;
  42.  
  43. static int noop(void);
  44. static int APOLLO_init(void);
  45. static void APOLLO_draw(int x, int y);
  46. static int APOLLO_getkey(void);
  47. static int APOLLO_checkkey(void);
  48. static int APOLLO_locator(int *wx, int *wy);
  49. static void APOLLO_clear(void);
  50. static void APOLLO_exit(void);
  51. static void APOLLO_color(int ind);
  52. static void APOLLO_mapcolor(int in, short r, short g, short b);
  53. static void APOLLO_fill(int n, int *x, int *y);
  54. static int APOLLO_font(char *fontfile);
  55. static void APOLLO_char(char c);
  56. static void APOLLO_string(char s[]);
  57. static int APOLLO_backb(void);
  58. static void APOLLO_swapb(void);
  59. static void APOLLO_frontb(void);
  60.  
  61. /*
  62.  * Do nothing
  63.  *
  64.  */
  65. static int
  66. noop(void)
  67. {
  68.     return(-1);
  69. }
  70.  
  71. /*
  72.  * APOLLO_init
  73.  *
  74.  *    initialises window to occupy current window
  75.  */
  76. static int
  77. APOLLO_init(void)
  78. {
  79.     pad_$window_desc_t     window;
  80.     int     size, prefx, prefy, prefxs, prefys, x, y, w, h;
  81.     short     i;
  82.  
  83.     pad_$set_scale(stream_$stdout,
  84.                1,
  85.                1,
  86.                status);
  87.  
  88.     pad_$inq_windows(stream_$stdout,
  89.              window_info,
  90.                   10,
  91.                n_windows,
  92.                  status);
  93.  
  94.     w = window_info[0].width;
  95.     h = window_info[0].height;
  96.     x = window_info[0].left;
  97.     y = window_info[0].top;
  98.  
  99.     getprefposandsize(&prefx, &prefy, &prefxs, &prefys);
  100.  
  101.     if (prefx > -1) {
  102.         x = prefx;
  103.         y = prefy;
  104.     }
  105.  
  106.     if (prefxs > -1) {
  107.         w = prefxs;
  108.         h = prefys;
  109.     }
  110.  
  111.     size = MIN(w, h);
  112.     vdevice.sizeX = vdevice.sizeY = size - 1;
  113.     vdevice.sizeSx = w - 1;
  114.     vdevice.sizeSy = h - 1;
  115.  
  116.         init_bitmap_size.x_size = w;
  117.         init_bitmap_size.y_size = h;
  118.  
  119.     source.window_base.x_coord = source.window_base.y_coord = 0;
  120.     source.window_size.x_size = init_bitmap_size.x_size;
  121.     source.window_size.y_size = init_bitmap_size.y_size;
  122.     dest_pos.x_coord = dest_pos.y_coord = 0;
  123.  
  124.     /*
  125.      * Inquire about the actual display ....
  126.      */
  127.  
  128.     gpr_$inq_disp_characteristics(mode,
  129.                       stream_$stdout,
  130.                       (short)60,
  131.                       disp,
  132.                       disp_len,
  133.                       status);
  134.  
  135.     vdevice.depth = disp.n_planes;
  136.     hi_plane_id = disp.n_planes - 1;
  137.  
  138.     if (prefx == -1 && prefxs == -1) {
  139.         stream_id = stream_$stdout;
  140.     } else {
  141.         window.top = y;
  142.         window.left = x;
  143.         window.width = w;
  144.         window.height = h;
  145.  
  146.         pad_$create_window("", 0,
  147.                 pad_$transcript, 
  148.                 1, 
  149.                 window,
  150.                 stream_id,
  151.                 status
  152.         );
  153.  
  154.         pad_$set_auto_close(stream_id, 1, true, status);
  155.     }
  156.  
  157.         gpr_$init(mode,
  158.                   stream_id,
  159.                   init_bitmap_size,
  160.                   hi_plane_id,
  161.                   front_bitmap,
  162.                   status);
  163.  
  164.     current_bitmap = front_bitmap;
  165.  
  166.     gpr_$set_auto_refresh(true, status);
  167.   
  168.     gpr_$set_cursor_active(false,status);
  169.  
  170.     /*  Set up all the character stuff  */
  171.  
  172.     first_time = 1;
  173.  
  174.     /*  create a key set for the event interupts  */
  175.  
  176.     lib_$init_set(keys, (short)256);
  177.     lib_$init_set(mouse_keys, (short)6);
  178.  
  179.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M1D);
  180.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M2D);
  181.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M3D);
  182.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M1U);
  183.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M2U);
  184.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M3U);
  185.  
  186.     for (i = 0; i < 128; i++) 
  187.         lib_$add_to_set(keys, (short)256, (short)i);
  188.  
  189.     gpr_$enable_input(gpr_$keystroke, keys, status);
  190.     gpr_$enable_input(gpr_$buttons, keys, status);
  191.     gpr_$enable_input(gpr_$locator, keys, status);
  192.  
  193.     /*  set default color (colour)   */
  194.  
  195.     if (disp.n_planes > 1) {
  196.         gpr_$inq_color_map(0L, (short)MAXCOLORS, old_color_value, status);
  197.         gpr_$inq_color_map(0L, (short)MAXCOLORS, color_value, status);
  198.  
  199.         color_value[0] = COLOR_ENTRY(0,0,0);         /* color--black   */
  200.         color_value[1] = COLOR_ENTRY(255,0,0);       /* color--red     */
  201.         color_value[2] = COLOR_ENTRY(0,255,0);       /* color--green   */
  202.         color_value[3] = COLOR_ENTRY(255,255,0);     /* color--yellow  */
  203.         color_value[4] = COLOR_ENTRY(0,0,255);       /* color--blue    */
  204.         color_value[5] = COLOR_ENTRY(255,0,255);     /* color--magenta */
  205.         color_value[6] = COLOR_ENTRY(0,255,255);     /* color--cyan    */
  206.         color_value[7] = COLOR_ENTRY(255,255,255);   /* color--white   */
  207.  
  208.         /* modify color table */
  209.         gpr_$acquire_display(status);
  210.         gpr_$set_color_map((long)0,
  211.                     (short)MAXCOLORS,
  212.                     color_value,
  213.                     status);
  214.         gpr_$release_display(status);
  215.     }
  216.  
  217.     back_used = 0;
  218.  
  219.     return(1);
  220. }
  221.  
  222.  
  223. /*
  224.  * APOLLO_draw
  225.  *
  226.  *    Draw a lines from the current graphics position to (x, y).
  227.  */
  228. static  void
  229. APOLLO_draw(int x, int y)
  230. {
  231.     gpr_$acquire_display(status);
  232.     gpr_$move((short)vdevice.cpVx, (short)(vdevice.sizeSy - vdevice.cpVy), status);
  233.     gpr_$line((short)x, (short)(vdevice.sizeSy - y), status);
  234.     gpr_$release_display(status);
  235.     vdevice.cpVx = x;
  236.     vdevice.cpVy = y;
  237. }
  238.  
  239. /*
  240.  * APOLLO_getkey
  241.  *
  242.  *    grab a character from the keyboard
  243.  */
  244. static int
  245. APOLLO_getkey(void)
  246. {
  247.     gpr_$event_t     et;
  248.     char         ed;
  249.     gpr_$position_t  pos;
  250.  
  251.  
  252.     et = gpr_$no_event;
  253.     while (et != gpr_$keystroke)
  254.         (void)gpr_$event_wait(et, ed, pos, status);
  255.  
  256.     /*
  257.      * What for this stupid gpr event system map the return key
  258.      * to a SYN character
  259.      */
  260.  
  261.     if ((ed & 0x7f) == 0x16)
  262.         ed = 13;
  263.  
  264.     return(ed);
  265. }
  266.  
  267. /*
  268.  * APOLLO_checkkey
  269.  *
  270.  *    checks if there is key waiting in the keyboard
  271.  */
  272. static int
  273. APOLLO_checkkey(void)
  274. {
  275.     gpr_$event_t     et;
  276.     char             ed;
  277.     gpr_$position_t  pos;
  278.  
  279.     et = gpr_$no_event;
  280.  
  281.     (void)gpr_$cond_event_wait(et, ed, pos, status);
  282.  
  283.     return((et == gpr_$keystroke ? 1 : 0));
  284. }
  285.  
  286. /*
  287.  * APOLLO_locator
  288.  *
  289.  *      return the window location of the cursor, plus which mouse button,
  290.  * if any, is been pressed.
  291.  *
  292.  *    LOCATOR - needs to return straight away.
  293.  */
  294. static int
  295. APOLLO_locator(int *wx, int *wy)
  296. {
  297.     gpr_$event_t     et;
  298.     char             ed;
  299.     gpr_$position_t  pos;
  300.     gpr_$position_t  origin;
  301.  
  302.     gpr_$bitmap_desc_t    curs_pat;
  303.     gpr_$raster_op_array_t    curs_raster_op;
  304.     boolean            active;
  305.     
  306.  
  307.  
  308.     (void)gpr_$cond_event_wait(et, ed, pos, status);
  309.  
  310.     gpr_$inq_cursor(curs_pat, curs_raster_op, active, pos, origin, status);
  311.  
  312.     *wx = (int)pos.x_coord;
  313.     *wy = (int)vdevice.sizeSy - (int)pos.y_coord;
  314.  
  315.     if (ed < 'a')            /* absorb button up */
  316.         return(0);
  317.  
  318.     return(1 << ((int)ed - 'a'));
  319. }
  320.  
  321. /*
  322.  * APOLLO_clear
  323.  *
  324.  *    clear the window to the current color.
  325.  */
  326. static void
  327. APOLLO_clear(void)
  328. {
  329.     gpr_$acquire_display(status);
  330.     gpr_$clear((long)current_color, status);
  331.     gpr_$release_display(status);
  332. }
  333.  
  334. /*
  335.  * APOLLO_exit
  336.  *
  337.  *    reset the window back to normal mode (sigh)
  338.  */
  339. static void
  340. APOLLO_exit(void)
  341. {
  342.     if (disp.n_planes > 1) {
  343.         gpr_$acquire_display(status);
  344.         gpr_$set_color_map((long)0,
  345.                     (short)MAXCOLORS,
  346.                     old_color_value,
  347.                     status);
  348.         gpr_$release_display(status);
  349.     }
  350.     gpr_$terminate(delete_display,status); /*Terminate gpr.*/
  351. }
  352.  
  353. /*
  354.  * APOLLO_color
  355.  *
  356.  *    change the drawing color.
  357.  */
  358. static void
  359. APOLLO_color(int ind)
  360. {
  361.     if (disp.n_planes <= 1) {
  362.         if (ind > 0)
  363.             current_color = 1;
  364.  
  365.         if (disp.invert)
  366.             current_color = !current_color;
  367.  
  368.     } else {
  369.         current_color = ind % MAXCOLORS;
  370.     }
  371.  
  372.     gpr_$set_draw_value((int)current_color, status); 
  373.     gpr_$set_text_value((int)current_color, status);
  374.     gpr_$set_fill_value((int)current_color, status);
  375.     /*
  376.      * GPR manual says that this sets text background to
  377.      * 'transparent'
  378.      */
  379.     gpr_$set_text_background_value((int)-1, status);
  380. }
  381.  
  382. /*
  383.  * APOLLO_mapcolor
  384.  *
  385.  *    set a colormap entry.
  386.  */
  387. static void
  388. APOLLO_mapcolor(int in, short r, short g, short b)
  389. {
  390.     if (in < 0 || in > MAXCOLORS)
  391.         verror("APOLLO_mapcolor: index out of range");
  392.     
  393.     color_value[in] = COLOR_ENTRY(r, g, b);
  394.  
  395.     /* modify color table */
  396.  
  397.     gpr_$acquire_display(status);
  398.     gpr_$set_color_map((long)0,
  399.                 (short)MAXCOLORS,
  400.                 color_value,
  401.                 status);
  402.     gpr_$release_display(status);
  403. }
  404.  
  405. /*
  406.  * APOLLO_fill
  407.  *
  408.  *    draw a filled polygon
  409.  */
  410. static void 
  411. APOLLO_fill(int n, int *x, int *y)
  412. {
  413.     short     nx[256], ny[256], startx, starty;
  414.     int    i;
  415.  
  416.     for (i = 1; i < n; i++) {
  417.         ny[i-1] = vdevice.sizeSy - y[i];
  418.         nx[i-1] = x[i];
  419.     }
  420.  
  421.     startx = x[0];
  422.     starty = vdevice.sizeSy - y[0];
  423.  
  424.     gpr_$acquire_display(status);
  425.     gpr_$start_pgon(startx, starty, status);
  426.  
  427.     gpr_$pgon_polyline(nx, ny, (short)(n - 1), status);
  428.     gpr_$close_fill_pgon(status);
  429.     gpr_$release_display(status);
  430. }
  431.  
  432. /*
  433.  * APOLLO_font
  434.  *
  435.  *    load in a hardware font
  436.  */
  437. static int
  438. APOLLO_font(char *fontfile)
  439. {
  440.     gpr_$offset_t start;
  441.     short xy_end;
  442.     char    buf[256];
  443.  
  444.     if (first_time) {
  445.         gpr_$unload_font_file(font_id, status);
  446.         first_time = 0;
  447.     }
  448.  
  449.     strcpy(buf, FONTBASE);
  450.     strcat(buf, fontfile);
  451.     gpr_$load_font_file(buf, (short)strlen(buf), font_id, status);
  452.  
  453.     if (status.all) 
  454.         return (0);
  455.  
  456.     gpr_$set_text_font(font_id, status);
  457.  
  458.     /* see above comment about &'s */
  459.  
  460.     gpr_$inq_text_offset("H", (short)1, start, xy_end, status);
  461.  
  462.     vdevice.hwidth = xy_end;
  463.     vdevice.hheight = start.y_size;
  464.  
  465.     return (1);
  466. }
  467.  
  468. /*
  469.  * APOLLO_char
  470.  *
  471.  *    output a character
  472.  */
  473. static void
  474. APOLLO_char(char c)
  475. {
  476.     char s[2];
  477.     s[1] = '\0';
  478.     s[0] = c;
  479.     gpr_$acquire_display(status);
  480.     gpr_$move((short)vdevice.cpVx, (short)(vdevice.sizeSy - vdevice.cpVy), status);
  481.     gpr_$text(s[0], (short)1, status);
  482.     gpr_$release_display(status);
  483. }
  484.  
  485. /*
  486.  * APOLLO_string
  487.  *
  488.  *    display a string
  489.  */
  490. static void
  491. APOLLO_string(char s[])
  492. {
  493.     short    len;
  494.  
  495.     len = (short)strlen(s);
  496.     gpr_$acquire_display(status);
  497.     gpr_$move((short)vdevice.cpVx, (short)(vdevice.sizeSy - vdevice.cpVy), status);
  498.     gpr_$text(s[0], len, status);
  499.     gpr_$release_display(status);
  500. }
  501.  
  502. /*
  503.  * APOLLO_backb
  504.  *
  505.  *    Allocates and sets the back display buffer.
  506.  */
  507. static int
  508. APOLLO_backb(void)
  509. {
  510.     if (!back_used) {
  511.         gpr_$allocate_attribute_block(attribs, status);
  512.         gpr_$allocate_bitmap(init_bitmap_size, (short)hi_plane_id, attribs, back_bitmap, status);
  513.         gpr_$enable_input(gpr_$keystroke, keys, status);
  514.         gpr_$enable_input(gpr_$buttons, keys, status);
  515.         gpr_$enable_input(gpr_$locator, keys, status);
  516.         back_used = 1;
  517.         if (status.all) {
  518.             fprintf(stderr, "APOLLO_backb: problem (status = %d)\n", status);
  519.             error_$print(status);
  520.             return(-1);
  521.         }
  522.     }
  523.  
  524.     gpr_$set_bitmap(back_bitmap, status);
  525.     gpr_$set_color_map((long)0,
  526.                 (short)MAXCOLORS,
  527.                 color_value,
  528.                 status);
  529.  
  530.     current_bitmap = back_bitmap;
  531.  
  532.     return(1);
  533. }
  534.  
  535. /*
  536.  * APOLLO_swapb
  537.  *
  538.  *    Swap the front and back buffers' role - actually just copy
  539.  *    the back buffer to the display buffer.
  540.  */
  541. static void
  542. APOLLO_swapb(void)
  543. {
  544.     gpr_$acquire_display(status);
  545.     gpr_$set_bitmap(front_bitmap, status);
  546.     gpr_$pixel_blt(back_bitmap, source, dest_pos, status);
  547.     gpr_$set_bitmap(back_bitmap, status);
  548.     gpr_$release_display(status);
  549. }
  550.  
  551. /*
  552.  * APOLLO_frontb
  553.  *
  554.  *    Make sure we are drawing in the front (display) buffer
  555.  */
  556. static void
  557. APOLLO_frontb(void)
  558. {
  559.     current_bitmap = front_bitmap;
  560.     gpr_$set_bitmap(front_bitmap, status);
  561. }
  562.  
  563.  
  564. static DevEntry apdev = {
  565.     "apollo",
  566.     "f16.b",
  567.     "f7x13.b",
  568.     APOLLO_backb,
  569.     APOLLO_char,
  570.     APOLLO_checkkey,
  571.     APOLLO_clear,
  572.     APOLLO_color,
  573.     APOLLO_draw,
  574.     APOLLO_exit,
  575.     APOLLO_fill,
  576.     APOLLO_font,
  577.     APOLLO_frontb,
  578.     APOLLO_getkey,
  579.     APOLLO_init,
  580.     APOLLO_locator,
  581.     APOLLO_mapcolor,
  582.     noop,
  583.     APOLLO_string,
  584.     APOLLO_swapb,
  585.     noop
  586. };
  587.  
  588. /*
  589.  * _APOLLO_devcpy
  590.  *
  591.  *      copy the apollo device into vdevice.dev.
  592.  */
  593. void
  594. _APOLLO_devcpy(void)
  595. {
  596.     vdevice.dev = apdev;
  597. }
  598.  
  599.  
  600.