home *** CD-ROM | disk | FTP | other *** search
/ Monster Disc 2: The Best of 1992 / MONSTER2.ISO / prog / djgpp / cbgrx102.a01 / CONTRIB / LIBGRX / SRC / MOUSE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-12  |  15.4 KB  |  641 lines
  1. /**
  2.  ** MOUSE.C
  3.  **
  4.  **  Copyright (C) 1992, Csaba Biegl
  5.  **    820 Stirrup Dr, Nashville, TN, 37221
  6.  **    csaba@vuse.vanderbilt.edu
  7.  **
  8.  **  This file is distributed under the terms listed in the document
  9.  **  "copying.cb", available from the author at the address above.
  10.  **  A copy of "copying.cb" should accompany this file; if not, a copy
  11.  **  should be available from where this file was obtained.  This file
  12.  **  may not be distributed without a verbatim copy of "copying.cb".
  13.  **  You should also have received a copy of the GNU General Public
  14.  **  License along with this program (it is in the file "copying");
  15.  **  if not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  16.  **  Cambridge, MA 02139, USA.
  17.  **
  18.  **  This program is distributed in the hope that it will be useful,
  19.  **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  **  GNU General Public License for more details.
  22.  **/
  23.  
  24. #include "grx.h"
  25. #include "mousex.h"
  26. #include "libgrx.h"
  27. #include "interrup.h"
  28. #include "clipping.h"
  29.  
  30. #include "../events/eventque.h"
  31. #include <string.h>
  32. #include <stdarg.h>
  33.  
  34. #ifdef __TURBOC__
  35. # include <time.h>
  36. # include <conio.h>
  37. #endif
  38.  
  39. #ifdef __GNUC__
  40.   extern  long        rawclock();
  41. # define  clock()   rawclock()
  42. #endif
  43.  
  44. /*
  45.  * mouse status flags
  46.  */
  47. #define UNKNOWN        0
  48. #define MISSING        1
  49. #define PRESENT        2
  50. #define INITTED        3
  51. #define QUEUED        4
  52.  
  53. #define DRAW_STACK  1024
  54. #define QUEUE_SIZE  100
  55.  
  56. #define CHECK_CONTEXT(cxt)  ((cxt)->gc_baseaddr == SCREEN->gc_baseaddr)
  57.  
  58. extern GrCursor *_GrMouseCursor;    /* current mouse cursor */
  59.  
  60. static EventQueue *queue,qbuf;
  61. static int mouse_status = UNKNOWN;
  62. static int own_cursor    = FALSE;
  63. static int use_queue    = FALSE;
  64. static int kb_enable    = TRUE;
  65. static int ms_enable    = TRUE;
  66. static int ms_curmode    = M_CUR_NORMAL;
  67. static int ms_xanchor,ms_yanchor;
  68. static int ms_dx2,ms_dy2;
  69. static int ms_curcolor;
  70. static int ms_buttons;
  71. static int ms_xpos;
  72. static int ms_ypos;
  73.  
  74. #define ms_dx1  ms_xanchor
  75. #define ms_dy1  ms_yanchor
  76.  
  77. static void (*getevent)(int flags,MouseEvent *event);
  78.  
  79. static char ptr12x16bits[] = {
  80.     0,1,0,0,0,0,0,0,0,0,0,0,
  81.     1,2,1,0,0,0,0,0,0,0,0,0,
  82.     1,2,2,1,0,0,0,0,0,0,0,0,
  83.     1,2,2,2,1,0,0,0,0,0,0,0,
  84.     1,2,2,2,2,1,0,0,0,0,0,0,
  85.     1,2,2,2,2,2,1,0,0,0,0,0,
  86.     1,2,2,2,2,2,2,1,0,0,0,0,
  87.     1,2,2,2,2,2,2,2,1,0,0,0,
  88.     1,2,2,2,2,2,2,2,2,1,0,0,
  89.     1,2,2,2,2,2,2,2,2,2,1,0,
  90.     1,2,2,2,2,2,2,2,2,2,2,1,
  91.     1,2,2,2,2,1,1,1,1,1,1,0,
  92.     1,2,2,2,1,0,0,0,0,0,0,0,
  93.     1,2,2,1,0,0,0,0,0,0,0,0,
  94.     1,2,1,0,0,0,0,0,0,0,0,0,
  95.     0,1,0,0,0,0,0,0,0,0,0,0,
  96. };
  97.  
  98. static int check_mouse(void)
  99. {
  100.     if(mouse_status < INITTED) {
  101.         if(mouse_status != MISSING) MouseInit();
  102.         if(mouse_status <  INITTED) return(FALSE);
  103.     }
  104.     return(TRUE);
  105. }
  106.  
  107. static void draw_special(void)
  108. {
  109.     int x = _GrMouseCursor->cr_xcord;
  110.     int y = _GrMouseCursor->cr_ycord;
  111.     int msflag = _GrMouseCheck;
  112.     GrContext csave;
  113.  
  114.     csave = *CURC;
  115.     *CURC = *SCREEN;
  116.     _GrMouseCheck = FALSE;
  117.     switch(ms_curmode) {
  118.       case M_CUR_RUBBER:
  119.         GrBox(x,y,ms_xanchor,ms_yanchor,ms_curcolor);
  120.         break;
  121.       case M_CUR_LINE:
  122.         GrLine(x,y,ms_xanchor,ms_yanchor,ms_curcolor);
  123.         break;
  124.       case M_CUR_BOX:
  125.         GrBox(x+ms_dx1,y+ms_dy1,x+ms_dx2,y+ms_dy2,ms_curcolor);
  126.         break;
  127.     }
  128.     *CURC = csave;
  129.     _GrMouseCheck = msflag;
  130. }
  131.  
  132. static void draw_mouse(void)
  133. {
  134.     if(_GrMouseCursor->cr_displayed) return;
  135.     GrMoveCursor(_GrMouseCursor,queue->evq_xpos,queue->evq_ypos);
  136.     GrDisplayCursor(_GrMouseCursor);
  137.     if(ms_curmode != M_CUR_NORMAL) draw_special();
  138. }
  139.  
  140. static void erase_mouse(void)
  141. {
  142.     if(!_GrMouseCursor->cr_displayed) return;
  143.     if(ms_curmode != M_CUR_NORMAL) draw_special();
  144.     GrEraseCursor(_GrMouseCursor);
  145. }
  146.  
  147. static void move_mouse(void)
  148. {
  149. #ifdef CRASH_AT_0_0
  150.     if((queue->evq_xpos == 0) && (queue->evq_ypos == 0)) {
  151.         char tmp[20];
  152.         char *ptr = (char *)NULL;
  153.         int  crashval = ++(*ptr);
  154.         sprintf(tmp,"%d",crashval);
  155.     }
  156. #endif
  157.     if(!_GrMouseCursor->cr_displayed) {
  158.         GrMoveCursor(_GrMouseCursor,queue->evq_xpos,queue->evq_ypos);
  159.         return;
  160.     }
  161.     if(ms_curmode != M_CUR_NORMAL) draw_special();
  162.     GrMoveCursor(_GrMouseCursor,queue->evq_xpos,queue->evq_ypos);
  163.     if(ms_curmode != M_CUR_NORMAL) draw_special();
  164. }
  165.  
  166. static void get_polled_event(int flags,MouseEvent *e)
  167. {
  168.     REGISTERS regs;
  169.     int moved;
  170.     int diff;
  171.  
  172.     for( ; ; ) {
  173.         if((flags & M_KEYPRESS) && kbhit()) {
  174.         e->flags  = M_KEYPRESS;
  175.         e->key      = getkey();
  176.         e->kbstat = getkbstat();
  177.         e->time      = clock();
  178.         return;
  179.         }
  180.         moved = 0;
  181.         regs.r_ax = 11;
  182.         int33(®s);
  183.         if((diff = (short)regs.r_cx) != 0) {
  184.         ms_xpos += diff;
  185.         if((diff = ms_xpos / queue->evq_xspeed) != 0) {
  186.             ms_xpos %= queue->evq_xspeed;
  187.             if(IABS(diff) >= queue->evq_thresh)
  188.             diff *= queue->evq_accel;
  189.             diff += queue->evq_xpos;
  190.             if(diff <= queue->evq_xmin) diff = queue->evq_xmin;
  191.             if(diff >= queue->evq_xmax) diff = queue->evq_xmax;
  192.             if(diff != queue->evq_xpos) {
  193.             queue->evq_xpos  = diff;
  194.             queue->evq_moved = 1;
  195.             moved = M_MOTION;
  196.             }
  197.         }
  198.         }
  199.         if((diff = (short)regs.r_dx) != 0) {
  200.         ms_ypos += diff;
  201.         if((diff = ms_ypos / queue->evq_yspeed) != 0) {
  202.             ms_ypos %= queue->evq_yspeed;
  203.             if(IABS(diff) >= queue->evq_thresh)
  204.             diff *= queue->evq_accel;
  205.             diff += queue->evq_ypos;
  206.             if(diff <= queue->evq_ymin) diff = queue->evq_ymin;
  207.             if(diff >= queue->evq_ymax) diff = queue->evq_ymax;
  208.             if(diff != queue->evq_ypos) {
  209.             queue->evq_ypos  = diff;
  210.             queue->evq_moved = 1;
  211.             moved = M_MOTION;
  212.             }
  213.         }
  214.         }
  215.         if(moved && queue->evq_drawmouse) move_mouse();
  216.         regs.r_ax = 3;
  217.         int33(®s);
  218.         if(flags & M_BUTTON_DOWN) {
  219.         diff = (regs.r_bx & ~ms_buttons);
  220.         if(diff & M_LEFT)   moved |= M_LEFT_DOWN;
  221.         if(diff & M_MIDDLE) moved |= M_MIDDLE_DOWN;
  222.         if(diff & M_RIGHT)  moved |= M_RIGHT_DOWN;
  223.         }
  224.         if(flags & M_BUTTON_UP) {
  225.         diff = (~regs.r_bx & ms_buttons);
  226.         if(diff & M_LEFT)   moved |= M_LEFT_UP;
  227.         if(diff & M_MIDDLE) moved |= M_MIDDLE_UP;
  228.         if(diff & M_RIGHT)  moved |= M_RIGHT_UP;
  229.         }
  230.         ms_buttons = regs.r_bx & (M_LEFT | M_MIDDLE | M_RIGHT);
  231.         if(flags & (moved | M_POLL)) {
  232.         e->flags   = moved & flags;
  233.         e->x       = queue->evq_xpos;
  234.         e->y       = queue->evq_ypos;
  235.         e->buttons = ms_buttons;
  236.         e->kbstat  = getkbstat();
  237.         e->time       = clock();
  238.         return;
  239.         }
  240.     }
  241. }
  242.  
  243. static void get_queued_event(int flags,MouseEvent *e)
  244. {
  245.     EventRecord evr;
  246.     int moved = 0;
  247.  
  248.     for( ; ; ) {
  249.         if(queue->evq_moved) {
  250.         moved = M_MOTION;
  251.         queue->evq_moved = 0;
  252.         }
  253.         if(EventQueueNextEvent(queue,&evr)) {
  254.         switch(evr.evt_type) {
  255.           case EVENT_KEYBD:
  256.             if(flags & M_KEYPRESS) {
  257.             e->flags   = M_KEYPRESS;
  258.             e->key       = evr.evt_keycode;
  259.             e->kbstat  = evr.evt_kbstat;
  260.             e->time       = evr.evt_time;
  261.             return;
  262.             }
  263.             break;
  264.           case EVENT_MOUSE:
  265.             ms_buttons = evr.evt_button;
  266.             if(flags & evr.evt_mask) {
  267.             e->flags   = flags & (evr.evt_mask | moved);
  268.             e->x       = evr.evt_xpos;
  269.             e->y       = evr.evt_ypos;
  270.             e->buttons = evr.evt_button;
  271.             e->kbstat  = evr.evt_kbstat;
  272.             e->time       = evr.evt_time;
  273.             return;
  274.             }
  275.             break;
  276.         }
  277.         continue;
  278.         }
  279.         if(flags & (moved | M_POLL)) {
  280.         e->flags   = flags & moved;
  281.         e->x       = queue->evq_xpos;
  282.         e->y       = queue->evq_ypos;
  283.         e->buttons = ms_buttons;
  284.         e->kbstat  = getkbstat();
  285.         e->time       = clock();
  286.         return;
  287.         }
  288.     }
  289. }
  290.  
  291. void MouseEventMode(int use_interrupts)
  292. {
  293.     use_queue = use_interrupts;
  294. }
  295.  
  296. int MouseDetect(void)
  297. {
  298.     REGISTERS regs;
  299.  
  300.     if(mouse_status == UNKNOWN) {
  301.         regs.r_ax = 0;
  302.         int33(®s);
  303.         mouse_status = (regs.r_ax == 0) ? MISSING : PRESENT;
  304.     }
  305.     return((mouse_status == MISSING) ? FALSE : TRUE);
  306. }
  307.  
  308. void MouseUnInit(void)
  309. {
  310.     REGISTERS regs;
  311.  
  312.     if(mouse_status >= INITTED) {
  313.         if(mouse_status == QUEUED) {
  314.         EventQueueDeInit();
  315.         queue = NULL;
  316.         }
  317.         else {
  318.         regs.r_ax = 0;
  319.         int33(®s);
  320.         }
  321.         if(_GrMouseDrawn) erase_mouse();
  322.         mouse_status = PRESENT;
  323.     }
  324. }
  325.  
  326. void MouseInit(void)
  327. {
  328.     REGISTERS regs;
  329.  
  330.     if(mouse_status != PRESENT) {
  331.         MouseDetect();
  332.         MouseUnInit();
  333.         if(mouse_status != PRESENT) return;
  334.     }
  335.     if(use_queue) {
  336.         queue = EventQueueInit(QUEUE_SIZE,DRAW_STACK,move_mouse);
  337.         if(queue != NULL) {
  338.         mouse_status = QUEUED;
  339.         getevent = get_queued_event;
  340.         queue->evq_drawmouse = FALSE;
  341.         }
  342.     }
  343.     if(mouse_status < INITTED) {
  344.         queue = &qbuf;
  345.         regs.r_ax = 0;
  346.         int33(®s);
  347.         regs.r_ax = 3;
  348.         int33(®s);
  349.         ms_buttons = regs.r_bx & (M_LEFT | M_MIDDLE | M_RIGHT);
  350.         regs.r_ax = 11;
  351.         int33(®s);
  352.         ms_xpos = 0;
  353.         ms_ypos = 0;
  354.         getevent = get_polled_event;
  355.         mouse_status = INITTED;
  356.     }
  357.     if(_GrMouseCursor == NULL) MouseSetColors(GrWhite(),GrBlack());
  358.     _GrMouseBlock    = MouseBlock;
  359.     _GrMouseUnBlock = MouseUnBlock;
  360.     _GrMouseUnInit  = MouseUnInit;
  361.     _GrMouseDrawn    = FALSE;
  362.     _GrMouseCheck    = FALSE;
  363.     MouseEventEnable(kb_enable,ms_enable);
  364.     MouseSetLimits(0,0,(_GrScreenX - 1),(_GrScreenY - 1));
  365.     MouseWarp((_GrScreenX >> 1),(_GrScreenY >> 1));
  366.     MouseSetSpeed(1);
  367.     MouseSetAccel(1000,1);
  368. }
  369.  
  370. void MouseSetSpeed(int speed)
  371. {
  372.     if(!check_mouse()) return;
  373.     queue->evq_xspeed = speed;
  374.     queue->evq_yspeed = speed;
  375. }
  376.  
  377. void MouseSetAccel(int thresh,int accel)
  378. {
  379.     if(!check_mouse()) return;
  380.     queue->evq_thresh = thresh;
  381.     queue->evq_accel  = accel;
  382. }
  383.  
  384. void MouseSetLimits(int x1,int y1,int x2,int y2)
  385. {
  386.     if(!check_mouse()) return;
  387.     CLIPBOXTOCONTEXT(SCREEN,x1,y1,x2,y2);
  388.     queue->evq_xmin = x1;
  389.     queue->evq_ymin = y1;
  390.     queue->evq_xmax = x2;
  391.     queue->evq_ymax = y2;
  392.     MouseWarp(queue->evq_xpos,queue->evq_ypos);
  393. }
  394.  
  395. void MouseGetLimits(int *x1,int *y1,int *x2,int *y2)
  396. {
  397.     if(!check_mouse()) return;
  398.     *x1 = queue->evq_xmin;
  399.     *y1 = queue->evq_ymin;
  400.     *x2 = queue->evq_xmax;
  401.     *y2 = queue->evq_ymax;
  402. }
  403.  
  404. void MouseWarp(int x,int y)
  405. {
  406.     char msdraw;
  407.  
  408.     if(!check_mouse()) return;
  409.     msdraw = queue->evq_drawmouse;
  410.     queue->evq_drawmouse = FALSE;
  411.     if(x < queue->evq_xmin) x = queue->evq_xmin;
  412.     if(y < queue->evq_ymin) y = queue->evq_ymin;
  413.     if(x > queue->evq_xmax) x = queue->evq_xmax;
  414.     if(y > queue->evq_ymax) y = queue->evq_ymax;
  415.     queue->evq_xpos = x;
  416.     queue->evq_ypos = y;
  417.     if(_GrMouseDrawn) move_mouse();
  418.     queue->evq_drawmouse = msdraw;
  419. }
  420.  
  421. void MouseSetCursor(GrCursor *cursor)
  422. {
  423.     GrCursor *old = _GrMouseCursor;
  424.     char msdraw = 0;
  425.  
  426.     if(cursor != NULL) {
  427.         if(mouse_status >= INITTED) {
  428.         msdraw = queue->evq_drawmouse;
  429.         queue->evq_drawmouse = FALSE;
  430.         if(_GrMouseDrawn) erase_mouse();
  431.         }
  432.         _GrMouseCursor = cursor;
  433.         if(own_cursor) GrDestroyCursor(old);
  434.         own_cursor = FALSE;
  435.         if(mouse_status >= INITTED) {
  436.         if(_GrMouseDrawn) draw_mouse();
  437.         queue->evq_drawmouse = msdraw;
  438.         }
  439.     }
  440. }
  441.  
  442. void MouseSetColors(int fg,int bg)
  443. {
  444.     GrCursor *new;
  445.     int cols[3];
  446.  
  447.     cols[0] = 2;
  448.     cols[1] = bg;
  449.     cols[2] = fg;
  450.     new = GrBuildCursor(ptr12x16bits,12,16,1,1,cols);
  451.     if(new != NULL) {
  452.         MouseSetCursor(new);
  453.         own_cursor = TRUE;
  454.     }
  455. }
  456.  
  457. void MouseSetCursorMode(int mode,...)
  458. {
  459.     va_list ap;
  460.     char msdraw = 0;
  461.  
  462.     if(mouse_status >= INITTED) {
  463.         msdraw = queue->evq_drawmouse;
  464.         queue->evq_drawmouse = FALSE;
  465.         if(_GrMouseDrawn && (ms_curmode != M_CUR_NORMAL)) draw_special();
  466.     }
  467.     va_start(ap,mode);
  468.     switch(mode) {
  469.       case M_CUR_RUBBER:
  470.         ms_curmode  = M_CUR_RUBBER;
  471.         ms_xanchor  = va_arg(ap,int);
  472.         ms_yanchor  = va_arg(ap,int);
  473.         ms_curcolor = (va_arg(ap,int) & C_COLOR) | GrXOR;
  474.         break;
  475.       case M_CUR_LINE:
  476.         ms_curmode  = M_CUR_LINE;
  477.         ms_xanchor  = va_arg(ap,int);
  478.         ms_yanchor  = va_arg(ap,int);
  479.         ms_curcolor = (va_arg(ap,int) & C_COLOR) | GrXOR;
  480.         break;
  481.       case M_CUR_BOX:
  482.         ms_curmode  = M_CUR_BOX;
  483.         ms_dx1    = va_arg(ap,int);
  484.         ms_dy1    = va_arg(ap,int);
  485.         ms_dx2    = va_arg(ap,int);
  486.         ms_dy2    = va_arg(ap,int);
  487.         ms_curcolor = (va_arg(ap,int) & C_COLOR) | GrXOR;
  488.         break;
  489.       default:
  490.         ms_curmode  = M_CUR_NORMAL;
  491.         break;
  492.     }
  493.     va_end(ap);
  494.     if(mouse_status >= INITTED) {
  495.         if(_GrMouseDrawn && (ms_curmode != M_CUR_NORMAL)) draw_special();
  496.         queue->evq_drawmouse = msdraw;
  497.     }
  498. }
  499.  
  500. GrCursor *MouseGetCursor(void)
  501. {
  502.     return(_GrMouseCursor);
  503. }
  504.  
  505. int MouseCursorIsDisplayed(void)
  506. {
  507.     return(_GrMouseDrawn);
  508. }
  509.  
  510. void MouseDisplayCursor(void)
  511. {
  512.     if((mouse_status < INITTED) || _GrMouseDrawn) return;
  513.     draw_mouse();
  514.     _GrMouseDrawn = TRUE;
  515.     _GrMouseCheck = CHECK_CONTEXT(CURC) ? TRUE : FALSE;
  516.     queue->evq_drawmouse = TRUE;
  517. }
  518.  
  519. void MouseEraseCursor(void)
  520. {
  521.     if((mouse_status < INITTED) || !_GrMouseDrawn) return;
  522.     queue->evq_drawmouse = FALSE;
  523.     _GrMouseDrawn = FALSE;
  524.     _GrMouseCheck = FALSE;
  525.     erase_mouse();
  526. }
  527.  
  528. int MouseBlock(GrContext *c,int x1,int y1,int x2,int y2)
  529. {
  530.     int mx1,my1,mx2,my2;
  531.  
  532.     if(c == NULL) c = CURC;
  533.     if((mouse_status < INITTED) || !_GrMouseDrawn || !CHECK_CONTEXT(c))
  534.         return(FALSE);
  535.     queue->evq_drawmouse = FALSE;
  536.     queue->evq_moved = FALSE;
  537.     x1 += c->gc_xoffset; y1 += c->gc_yoffset;
  538.     x2 += c->gc_xoffset; y2 += c->gc_yoffset;
  539.     mx1 = _GrMouseCursor->cr_xwpos;
  540.     my1 = _GrMouseCursor->cr_ywpos;
  541.     mx2 = mx1 + _GrMouseCursor->cr_xwork - 1;
  542.     my2 = my1 + _GrMouseCursor->cr_ywork - 1;
  543.     if(ms_curmode != M_CUR_NORMAL) {
  544.         int cx2,cy2;
  545.         int cx1 = _GrMouseCursor->cr_xcord;
  546.         int cy1 = _GrMouseCursor->cr_ycord;
  547.         switch(ms_curmode) {
  548.           case M_CUR_RUBBER:
  549.         cx2 = ms_xanchor;
  550.         cy2 = ms_yanchor;
  551.         break;
  552.           case M_CUR_LINE:
  553.         cx2 = ms_xanchor;
  554.         cy2 = ms_yanchor;
  555.         break;
  556.           case M_CUR_BOX:
  557.         cx2 = cx1 + ms_dx2;
  558.         cy2 = cy1 + ms_dy2;
  559.         cx1 += ms_dx1;
  560.         cy2 += ms_dy1;
  561.         break;
  562.           default:
  563.         return(FALSE);
  564.         }
  565.         SORT2(cx1,cx2);
  566.         SORT2(cy1,cy2);
  567.         if(cx1 < mx1) mx1 = cx1;
  568.         if(cy1 < my1) my1 = cy1;
  569.         if(cx2 > mx2) mx2 = cx2;
  570.         if(cy2 > my2) my2 = cy2;
  571.     }
  572.     if(mx1 > x1) x1 = mx1;
  573.     if(my1 > y1) y1 = my1;
  574.     if(mx2 < x2) x2 = mx2;
  575.     if(my2 < y2) y2 = my2;
  576.     if((x1 <= x2) && (y1 <= y2)) {
  577.         _GrMouseDrawn = FALSE;
  578.         erase_mouse();
  579.     }
  580.     _GrMouseCheck = FALSE;
  581.     return(TRUE);
  582. }
  583.  
  584. void MouseUnBlock(void)
  585. {
  586.     if(mouse_status < INITTED) return;
  587.     if(queue->evq_moved) move_mouse();
  588.     if(!_GrMouseDrawn) draw_mouse();
  589.     _GrMouseDrawn = TRUE;
  590.     _GrMouseCheck = CHECK_CONTEXT(CURC) ? TRUE : FALSE;
  591.     queue->evq_drawmouse = TRUE;
  592. }
  593.  
  594. void MouseEventEnable(int enable_kb,int enable_ms)
  595. {
  596.     if(mouse_status >= INITTED) {
  597.         queue->evq_enable =
  598.         (enable_kb ? EVENT_ENABLE(EVENT_KEYBD) : 0) |
  599.         (enable_ms ? EVENT_ENABLE(EVENT_MOUSE) : 0);
  600.     }
  601.     kb_enable = enable_kb;
  602.     ms_enable = enable_ms;
  603. }
  604.  
  605. void MouseGetEvent(int flags,MouseEvent *e)
  606. {
  607.     int erase = FALSE;
  608.  
  609.     if(!kb_enable) flags &= ~M_KEYPRESS;
  610.     if(!ms_enable) flags &= ~(M_MOTION | M_BUTTON_DOWN | M_BUTTON_UP);
  611.     if(!(flags & M_EVENT)) { e->flags = 0; return; }
  612.     if(!check_mouse()) {
  613.         e->flags = 0;
  614.         if((flags & M_KEYPRESS) && (!(flags & M_POLL) || kbhit())) {
  615.         e->flags  = M_KEYPRESS;
  616.         e->key      = getkey();
  617.         e->kbstat = getkbstat();
  618.         e->time      = clock();
  619.         }
  620.         return;
  621.     }
  622.     if(!_GrMouseDrawn && !(flags & M_NOPAINT)) {
  623.         draw_mouse();
  624.         queue->evq_drawmouse = TRUE;
  625.         erase = TRUE;
  626.     }
  627.     (*getevent)(flags,e);
  628.     if(erase) {
  629.         queue->evq_drawmouse = FALSE;
  630.         erase_mouse();
  631.     }
  632. }
  633.  
  634. int MousePendingEvent(void)
  635. {
  636.     if((mouse_status >= INITTED) && (queue->evq_cursize > 0))
  637.         return(TRUE);
  638.     return(FALSE);
  639. }
  640.  
  641.