home *** CD-ROM | disk | FTP | other *** search
/ Boldly Go Collection / version40.iso / TS / 17A / DRWIN101.ZIP / MOUSUTIL.C < prev    next >
C/C++ Source or Header  |  1991-07-23  |  14KB  |  359 lines
  1. #include <stdio.h>
  2. #include <dos.h>
  3.  
  4. #include "mousutil.h"
  5.  
  6. static union REGS ir,or;
  7. static MOUSTRAP mousfunc=NULL;
  8. static char mousinitd=0;
  9.  
  10.  
  11. /****************************************************************************/
  12. /*  mousinit                                                                */
  13. /****************************************************************************/
  14. /*-----------------------------Description----------------------------------*/
  15. /*  This function initializes the mouse.                                    */
  16. /*-----------------------------Arguments------------------------------------*/
  17. /*-----------------------------Return value---------------------------------*/
  18. /*  Returns 1 if a mouse is available, 0 otherwise.                         */
  19. /*-----------------------------Global constants-----------------------------*/
  20. /*-------------------Mod-------Global variables-----------------------------*/
  21. /*-----------------------------Functions called-----------------------------*/
  22. /*-----------------------------Constraints/Gotchas--------------------------*/
  23. /*--Date--------Programmer----------Comments--------------------------------*/
  24. /*  1990.10.09  D. Rogers           initial code                            */
  25. /****************************************************************************/
  26. int  mousinit(void)
  27. {
  28.   LWORD iv;                            /*interrupt vector for mouse*/
  29.  
  30.   disable();
  31.   iv=*(LWORD far *)((LWORD)(MOUSINT<<2));  /*get interrupt vector*/
  32.   enable();
  33.   mousinitd=0;
  34.   if (iv==0) return 0;
  35.   ir.x.ax=0x0000;
  36.   int86(MOUSINT,&ir,&or);
  37.   if (or.x.ax==0) return 0;
  38.   mousinitd=1;
  39.   return 1;
  40. }   /*mousinit*/
  41.  
  42.  
  43. /****************************************************************************/
  44. /*  mousset, mousshow, moushide                                             */
  45. /****************************************************************************/
  46. /*-----------------------------Description----------------------------------*/
  47. /*  These functions turn on/off the display of the mouse.                   */
  48. /*  mousset() will call mousshow if its argument is non-zero; otherwise,    */
  49. /*  it calls moushide.                                                      */
  50. /*-----------------------------Arguments------------------------------------*/
  51. /*-----------------------------Return value---------------------------------*/
  52. /*-----------------------------Global constants-----------------------------*/
  53. /*-------------------Mod-------Global variables-----------------------------*/
  54. /*-----------------------------Functions called-----------------------------*/
  55. /*-----------------------------Constraints/Gotchas--------------------------*/
  56. /*--Date--------Programmer----------Comments--------------------------------*/
  57. /*  1990.10.09  D. Rogers           initial code                            */
  58. /****************************************************************************/
  59. void mousshow(void)
  60. {
  61.   if (!mousinitd) if (!mousinit()) return;
  62.   ir.x.ax=0x0001;
  63.   int86(MOUSINT,&ir,&or);
  64. }   /*mousshow*/
  65.  
  66.  
  67. void moushide(void)
  68. {
  69.   if (!mousinitd) if (!mousinit()) return;
  70.   ir.x.ax=0x0002;
  71.   int86(MOUSINT,&ir,&or);
  72. }   /*moushide*/
  73.  
  74.  
  75. void mousset(int show)
  76. {
  77.   if (show) mousshow(); else moushide();
  78. }   /*mousset*/
  79.  
  80.  
  81. /****************************************************************************/
  82. /*  mousgetrow, mousgetcol, mousgetbut, mousgetall                          */
  83. /****************************************************************************/
  84. /*-----------------------------Description----------------------------------*/
  85. /*  These functions return status information to the caller.                */
  86. /*-----------------------------Arguments------------------------------------*/
  87. /*-----------------------------Return value---------------------------------*/
  88. /*-----------------------------Global constants-----------------------------*/
  89. /*-------------------Mod-------Global variables-----------------------------*/
  90. /*-----------------------------Functions called-----------------------------*/
  91. /*-----------------------------Constraints/Gotchas--------------------------*/
  92. /*--Date--------Programmer----------Comments--------------------------------*/
  93. /*  1990.10.09  D. Rogers           initial code                            */
  94. /****************************************************************************/
  95. int  mousgetall(MOUS *m)
  96. {
  97.   if (!mousinitd) if (!mousinit()) return 0;
  98.   ir.x.ax=0x0003;
  99.   int86(MOUSINT,&ir,&or);
  100.   m->butstat=or.x.bx;                  /*button status*/
  101.   m->row=or.x.dx;                      /*row, Y-coordinate*/
  102.   m->col=or.x.cx;                      /*col, X-coordinate*/
  103.   m->butcnt=(or.x.bx!=0);              /*set button count for easy-check*/
  104.   return 1;
  105. }   /*mousgetall*/
  106.  
  107.  
  108. int  mousgetbut(void)
  109. {
  110.   if (!mousinitd) if (!mousinit()) return 0;
  111.   ir.x.ax=0x0003;
  112.   int86(MOUSINT,&ir,&or);
  113.   return or.x.bx;                      /*button status*/
  114. }   /*mousgetbut*/
  115.  
  116.  
  117. int  mousgetrow(void)
  118. {
  119.   if (!mousinitd) if (!mousinit()) return 0;
  120.   ir.x.ax=0x0003;
  121.   int86(MOUSINT,&ir,&or);
  122.   return or.x.dx;                      /*row, Y-coordinate*/
  123. }   /*mousgetrow*/
  124.  
  125.  
  126. int  mousgetcol(void)
  127. {
  128.   if (!mousinitd) if (!mousinit()) return 0;
  129.   ir.x.ax=0x0003;
  130.   int86(MOUSINT,&ir,&or);
  131.   return or.x.cx;                      /*column, X-coordinate*/
  132. }   /*mousgetcol*/
  133.  
  134.  
  135. /****************************************************************************/
  136. /*  moussetrow, moussetcol, moussetall                                      */
  137. /****************************************************************************/
  138. /*-----------------------------Description----------------------------------*/
  139. /*-----------------------------Arguments------------------------------------*/
  140. /*-----------------------------Return value---------------------------------*/
  141. /*-----------------------------Global constants-----------------------------*/
  142. /*-------------------Mod-------Global variables-----------------------------*/
  143. /*-----------------------------Functions called-----------------------------*/
  144. /*-----------------------------Constraints/Gotchas--------------------------*/
  145. /*--Date--------Programmer----------Comments--------------------------------*/
  146. /*  1990.10.09  D. Rogers           initial code                            */
  147. /****************************************************************************/
  148. int  moussetall(MOUS *m)
  149. {
  150.   if (!mousinitd) if (!mousinit()) return 0;
  151.   ir.x.ax=0x0004;
  152.   ir.x.cx=m->col;
  153.   ir.x.dx=m->row;
  154.   int86(MOUSINT,&ir,&or);
  155.   return 1;
  156. }   /*moussetall*/
  157.  
  158.  
  159. int  moussetcpos(int row,int col)
  160. {
  161.   if (!mousinitd) if (!mousinit()) return 0;
  162.   ir.x.ax=0x0004;
  163.   ir.x.cx=col;
  164.   ir.x.dx=row;
  165.   int86(MOUSINT,&ir,&or);
  166.   return 1;
  167. }   /*moussetcpos*/
  168.  
  169.  
  170. int  moussetrow(int row)
  171. {
  172.   if (!mousinitd) if (!mousinit()) return 0;
  173.   ir.x.ax=0x0003;
  174.   int86(MOUSINT,&ir,&or);
  175.   ir.x.ax=0x0004;
  176.   ir.x.cx=or.x.cx;                     /*keep current column*/
  177.   ir.x.dx=row;                         /*set the new row*/
  178.   int86(MOUSINT,&ir,&or);
  179.   return 1;
  180. }   /*moussetrow*/
  181.  
  182.  
  183. int  moussetcol(int col)
  184. {
  185.   if (!mousinitd) if (!mousinit()) return 0;
  186.   ir.x.ax=0x0003;
  187.   int86(MOUSINT,&ir,&or);
  188.   ir.x.ax=0x0004;
  189.   ir.x.dx=or.x.dx;                     /*keep current row*/
  190.   ir.x.cx=col;                         /*set the new column*/
  191.   int86(MOUSINT,&ir,&or);
  192.   return 1;
  193. }   /*moussetcol*/
  194.  
  195.  
  196. /****************************************************************************/
  197. /*  mousgetprs, mousgetrel                                                  */
  198. /****************************************************************************/
  199. /*-----------------------------Description----------------------------------*/
  200. /*  These functions return information about the most recent button press   */
  201. /*  and release.  Use the constants MOUS_LBUT, MOUS_RBUT and MOUS_CBUT to   */
  202. /*  specify which button you will request information for.                  */
  203. /*-----------------------------Arguments------------------------------------*/
  204. /*-----------------------------Return value---------------------------------*/
  205. /*-----------------------------Global constants-----------------------------*/
  206. /*-------------------Mod-------Global variables-----------------------------*/
  207. /*-----------------------------Functions called-----------------------------*/
  208. /*-----------------------------Constraints/Gotchas--------------------------*/
  209. /*--Date--------Programmer----------Comments--------------------------------*/
  210. /*  1990.10.09  D. Rogers           initial code                            */
  211. /****************************************************************************/
  212. int  mousgetprs(WORD but,MOUS *m)
  213. {
  214.   if (but>MOUS_CBUT) return 0;
  215.   if (!mousinitd) if (!mousinit()) return 0;
  216.   ir.x.ax=0x0005;
  217.   ir.x.bx=but;
  218.   int86(MOUSINT,&ir,&or);
  219.   m->butstat=or.x.ax;
  220.   m->butcnt=or.x.bx;                   /*button-presses since last call*/
  221.   m->row=or.x.dx;                      /*row of last press*/
  222.   m->col=or.x.cx;                      /*column of last press*/
  223.   return 1;
  224. }   /*mousgetprs*/
  225.  
  226.  
  227. int  mousgetrel(WORD but,MOUS *m)
  228. {
  229.   if (!mousinitd) if (!mousinit()) return 0;
  230.   if (but>MOUS_CBUT) return 0;
  231.   ir.x.ax=0x0006;
  232.   ir.x.bx=but;
  233.   int86(MOUSINT,&ir,&or);
  234.   m->butstat=or.x.ax;
  235.   m->butcnt=or.x.bx;                   /*button-releases since last call*/
  236.   m->row=or.x.dx;                      /*row of last release*/
  237.   m->col=or.x.cx;                      /*column of last release*/
  238.   return 1;
  239. }   /*mousgetrel*/
  240.  
  241.  
  242. /****************************************************************************/
  243. /*  mouscurstype                                                            */
  244. /****************************************************************************/
  245. /*-----------------------------Description----------------------------------*/
  246. /*  This function sets the screen and cursor masks for the mouse.  The      */
  247. /*  screen mask is ANDed, and the cursor mask is XORed, with the attribute  */
  248. /*  and character at the current mouse cursor's position.                   */
  249. /*-----------------------------Arguments------------------------------------*/
  250. /*-----------------------------Return value---------------------------------*/
  251. /*-----------------------------Global constants-----------------------------*/
  252. /*-------------------Mod-------Global variables-----------------------------*/
  253. /*-----------------------------Functions called-----------------------------*/
  254. /*-----------------------------Constraints/Gotchas--------------------------*/
  255. /*--Date--------Programmer----------Comments--------------------------------*/
  256. /*  1990.10.09  D. Rogers           initial code                            */
  257. /****************************************************************************/
  258. int  mouscurstype(WORD and,WORD xor)
  259. {
  260.   if (!mousinitd) if (!mousinit()) return 0;
  261.   ir.x.ax=0x000A;
  262.   ir.x.bx=0;                           /*use attribute cursor, not hardware*/
  263.   ir.x.cx=and;
  264.   ir.x.dx=xor;
  265.   int86(MOUSINT,&ir,&or);
  266.   return 1;
  267. }   /*mouscurstype*/
  268.  
  269.  
  270. int  moushwcurs(WORD start,WORD stop)
  271. {
  272.   if (!mousinitd) if (!mousinit()) return 0;
  273.   ir.x.ax=0x000A;
  274.   ir.x.bx=0xFFFF;                      /*hardware*/
  275.   ir.x.cx=start;                       /*start scan line*/
  276.   ir.x.dx=stop;                        /*stop scan line*/
  277.   int86(MOUSINT,&ir,&or);
  278.   return 1;
  279. }   /*moushwcurs*/
  280.  
  281.  
  282. /****************************************************************************/
  283. /*  moustrap                                                                */
  284. /****************************************************************************/
  285. /*-----------------------------Description----------------------------------*/
  286. /*  This function allows you to set up a function to trap mouse conditions  */
  287. /*  within regions on the screen.                                           */
  288. /*-----------------------------Arguments------------------------------------*/
  289. /*-----------------------------Return value---------------------------------*/
  290. /*-----------------------------Global constants-----------------------------*/
  291. /*-------------------Mod-------Global variables-----------------------------*/
  292. /*-----------------------------Functions called-----------------------------*/
  293. /*-----------------------------Constraints/Gotchas--------------------------*/
  294. /*--Date--------Programmer----------Comments--------------------------------*/
  295. /*  1990.01.01  A. Turing           initial code                            */
  296. /****************************************************************************/
  297. void mousintfunc(void)
  298. {
  299.   auto int event;
  300.   auto int button;
  301.   auto int x;
  302.   auto int y;
  303.   auto int xcounts;
  304.   auto int ycounts;
  305.   asm  PUSH DS
  306.   asm  PUSH AX
  307.   asm  PUSH BX
  308.   asm  PUSH CX
  309.   asm  PUSH DX
  310.   asm  PUSH SI
  311.   asm  PUSH DI
  312.   asm  MOV event,AX
  313.   asm  MOV button,BX
  314.   asm  MOV x,CX
  315.   asm  MOV y,DX
  316.   asm  MOV xcounts,SI
  317.   asm  MOV ycounts,DI
  318. #if defined(__HUGE__)|defined(__LARGE__)|defined(__COMPACT__)
  319.   asm  MOV AX,SEG mousfunc
  320.   asm  MOV DS,AX
  321. #endif
  322.  
  323.   if (mousfunc) mousfunc(event,button,x,y,xcounts,ycounts);
  324.  
  325.   asm  POP DI
  326.   asm  POP SI
  327.   asm  POP DX
  328.   asm  POP CX
  329.   asm  POP BX
  330.   asm  POP AX
  331.   asm  POP DS
  332. }   /*mousintfunc*/
  333.  
  334.  
  335. int moustrapinit(int event)
  336. {
  337.   asm {
  338.     MOV AX,SEG mousintfunc
  339.     MOV ES,AX
  340.     MOV DX,OFFSET mousintfunc
  341.     MOV CX,event
  342.     MOV AX,0Ch
  343.     MOV BX,0
  344.     INT 033h
  345.   };
  346.   return 1;
  347. }   /*moustrapinit*/
  348.  
  349.  
  350. int moustrap(int event,MOUSTRAP func)
  351. {
  352.   mousfunc=func;
  353.   moustrapinit(event);
  354.   return 1;
  355. }   /*moustrap*/
  356.  
  357.  
  358.  
  359.