home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / mouse / cmouse / cmouse.hpp < prev   
Encoding:
C/C++ Source or Header  |  1991-04-02  |  7.6 KB  |  293 lines
  1. /*
  2.  
  3.     cmouse.hpp
  4.     4-2-90
  5.     Microsoft mouse interrupt functions
  6.  
  7.     Copyright 1991
  8.     John W. Small
  9.     All rights reserved
  10.  
  11.     PSW / Power SoftWare
  12.     P.O. Box 10072
  13.     McLean, Virginia 22102 8072
  14.     (703) 759-3838
  15.  
  16.  
  17.     Works consulted:
  18.  
  19.     "Microsoft Mouse Programmer's Reference."
  20.         Bellevue, Washington: Microsoft Press, 1989.
  21.  
  22.     "Microsoft Mouse Programmer's Reference Guide."
  23.         Bellevue, Washington: Microsoft Press, 1986.
  24.  
  25.     Refer to above works for mouse function
  26.     documentation.
  27.  
  28. */
  29.  
  30. #ifndef CMOUSE_CPP
  31. #define CMOUSE_CPP
  32.  
  33. typedef  void interrupt (*MouseDriver)(...);
  34. typedef  void interrupt (*MouseHandler)(...);
  35.  
  36. #define MOUSE_INT 0x33
  37.  
  38. // mouse button designators
  39. #define MBleft   1
  40. #define MBright  2
  41.  
  42. // mouse events for callMask, altCallMask,
  43. // eventMask, eventFlags
  44. #define MEmoved          1
  45. #define MEleftPressed     2
  46. #define MEleftReleased    4
  47. #define MErightPressed    8
  48. #define MErightReleased  16
  49. #define MEshiftPressed   32
  50. #define MEctrlPressed    64
  51. #define MEaltPressed    128
  52.  
  53. // mouse types
  54. #define MTunknown  0
  55. #define MTbus      1
  56. #define MTserial   2
  57. #define MTinPort   3
  58. #define MTps2      4
  59. #define MThp       5
  60.  
  61. // mouse error message languages
  62. #define MLenglish      0
  63. #define MLfrench       1
  64. #define MLdutch        2
  65. #define MLgerman       3
  66. #define MLswedish      4
  67. #define MLfinnish      5
  68. #define MLspanish      6
  69. #define MLportuguese   7
  70. #define MLitalian      8
  71.  
  72.  
  73. // Do not instantiate the MicrosoftMouse class!
  74. // Reference MM.??? instead!
  75. // Write appropriate fields in MM and call member function
  76. // or call function and read appropriate fields.
  77. // Use physical screen coordinates for all values not
  78. // the mouse virtual coordinates.  Conversion to/from
  79. // mouse virtual coordinate is automatically handled
  80. // by the class member functions.
  81.  
  82. class MicrosoftMouse  {
  83.  
  84.     static unsigned Xcell[];
  85.     static unsigned Ycell[];
  86.     static unsigned LeftTopOfs[];
  87.  
  88.     // MF0, MF33 : Video mode at reset/softReset
  89.     // Call reset after all video mode changes!
  90.     unsigned vmode;
  91.  
  92.     // MF21, MF22, MF23 : Used by save and restore
  93.     void * origState, * state;
  94.     unsigned stateSize;
  95.  
  96.     // MF31, MF32 : Used by off/on
  97.     MouseDriver mouseIntrVector;
  98.  
  99.     // condOff virtual coordinates
  100.     unsigned covx1, covy1, covx2, covy2;
  101.  
  102. public:
  103.     // MF0 : Set by reset
  104.     unsigned present;
  105.     unsigned buttons;
  106.  
  107.     // MF3, MF5, MF6 : Button Status
  108.     unsigned leftPressed, rightPressed;
  109.  
  110.     // MF3, MF4 : Mouse Positon
  111.     unsigned x, y;
  112.     // X & Y are physical, not virtual coordinates!
  113.     // Text modes upper left corner : 1,1
  114.     // Graphics modes upper left corner : 0,0
  115.  
  116.     // MF5 : Button Press Information
  117.     unsigned lastLeftPressX, lastLeftPressY,
  118.         leftPresses;
  119.     unsigned lastRightPressX, lastRightPressY,
  120.         rightPresses;
  121.     // X & Y are physical, not virtual coordinates!
  122.  
  123.     // MF5, MF6 : Button Requested
  124.     unsigned buttonRequested;
  125.  
  126.     // MF6 : Button Release Information
  127.     unsigned lastLeftReleaseX, lastLeftReleaseY,
  128.         leftReleases;
  129.     unsigned lastRightReleaseX, lastRightReleaseY,
  130.         rightReleases;
  131.     // X & Y are physical, not virtual coordinates!
  132.  
  133.     // MF11 : Mouse motion counters
  134.     unsigned vertMickeys, horzMickeys;
  135.  
  136.     // MF12, MF20 : set/swapInterrupt(s) mask/addr
  137.     MouseHandler handler; // See MMautoEventHandler
  138.     unsigned callMask;
  139.     // Also used by autoEventUpdate.
  140.  
  141.     // Set by Mouse Event Handler.
  142.     unsigned eventMask, eventFlags, eventCount,
  143.         eventMoved;
  144.     long eventTime;
  145.     long clickTimeOut;
  146.     long leftClickTime;
  147.     unsigned leftClicks;
  148.     long rightClickTime;
  149.     unsigned rightClicks;
  150.  
  151.     // MF24, MF25 : set/getAltInterrupt mask/addr
  152.     MouseHandler altHandler; // See MMautoEventHandler
  153.     unsigned altCallMask;
  154.     // MF25 can read those set by MF20!
  155.  
  156.     // MF26, MF27 : set/getSensitivity
  157.     unsigned horzPercent, vertPercent, doublePercent;
  158.  
  159.     // MF29, MF30 : set/getCRTpage
  160.     unsigned crtPage;
  161.  
  162.     // MF34, MF35 : Used by get/setLanguage
  163.     unsigned language;
  164.  
  165.     // MF36 : Set by driver
  166.     unsigned driverVersion;
  167.     unsigned IRQ;
  168.     unsigned typeRequired;
  169.  
  170.  
  171.     MicrosoftMouse();
  172.     ~MicrosoftMouse();
  173.     void reset();                        /* MF0 */
  174.     void show()  { _AX = 1; geninterrupt(MOUSE_INT); }    /* MF1 */
  175.     void hide()  { _AX = 2; geninterrupt(MOUSE_INT); }      /* MF2 */
  176.     void updateStatusInfo();                /* MF3 */
  177.     void gotoxy();                        /* MF4 */
  178.     void updatePressInfo();                    /* MF5 */
  179.     void updateReleaseInfo();                /* MF6 */
  180.     void trap(unsigned x1, unsigned y1,                /* MF7, MF8 */
  181.         unsigned x2, unsigned y2);
  182.     void graphicsCursor(signed char horzHS,            /* MF9 */
  183.         signed char vertHS,
  184.         unsigned far *scrCurMask);
  185.     void softwareTextCursor(                /* MF10 */
  186.         unsigned scrMask, unsigned curMask)
  187.         { _BX = 0; _CX = scrMask; _DX = curMask;
  188.         _AX = 10; geninterrupt(MOUSE_INT); }
  189.     void updateMotionInfo()                    /* MF11 */
  190.         { _AX = 11; geninterrupt(MOUSE_INT);
  191.         horzMickeys = _CX; vertMickeys = _DX; }
  192.     void setInterrupt()  {                    /* MF12 */
  193.         _ES = FP_SEG(handler);
  194.         _DX = FP_OFF(handler);
  195.         _CX = callMask;
  196.         _AX = 12;
  197.         geninterrupt(MOUSE_INT);
  198.     }
  199.     void lightPenOn()                                       /* MF13 */
  200.         { _AX = 13; geninterrupt(MOUSE_INT); }
  201.     void lightPenOff()                    /* MF14 */
  202.         { _AX = 14; geninterrupt(MOUSE_INT); }
  203.     void speed(unsigned horz, unsigned vert)                /* MF15 */
  204.         { _CX = horz; _DX = vert; _AX = 15;
  205.         geninterrupt(MOUSE_INT); }
  206.     void condOffZone(unsigned x1, unsigned y1,
  207.         unsigned x2, unsigned y2)
  208.     {
  209.         covx1 = virtualX(x1);
  210.         covy1 = virtualY(y1);
  211.         covx2 = virtualX(x2);
  212.         covy2 = virtualY(y2);
  213.     }
  214.     void condOff()                                          /* MF16 */
  215.     {
  216.         _DI = covy2;
  217.         _SI = covx2;
  218.         _DX = covy1;
  219.         _CX = covx1;
  220.         _AX = 16;
  221.         geninterrupt(MOUSE_INT);
  222.     }
  223.     void doubleSpeedThreshold(unsigned mickeys)             /* MF19 */
  224.         { _DX = mickeys; _AX = 19;
  225.         geninterrupt(MOUSE_INT); }
  226.     void swapInterrupts();                    /* MF20 */
  227.     void autoEventUpdate();                    /* N/A  */
  228.     void save();                      /* MF21, MF22 */
  229.     void restore();                        /* MF23 */
  230.     void setAltInterrupt()                    /* MF24 */
  231.     {
  232.         _ES = FP_SEG(altHandler);
  233.         _DX = FP_OFF(altHandler);
  234.         _CX = altCallMask;
  235.         _AX = 24;
  236.         geninterrupt(MOUSE_INT);
  237.     }
  238.     void getAltInterrupt()                    /* MF25 */
  239.     {
  240.         _CX = altCallMask;
  241.         _AX = 25;
  242.         geninterrupt(MOUSE_INT);
  243.         altHandler = (MouseHandler) MK_FP(_BX,_DX);
  244.     }
  245.     void clearAltInterrupts();                /* N/A  */
  246.     void setSensitivity()                    /* MF26 */
  247.         { _DX = doublePercent; _CX = vertPercent;
  248.         _BX = horzPercent; _AX = 26;
  249.         geninterrupt(MOUSE_INT); }
  250.     void getSensitivity()                    /* MF27 */
  251.         { _AX = 27; geninterrupt(MOUSE_INT);
  252.         horzPercent = _BX; vertPercent = _CX;
  253.         doublePercent = _DX; }
  254.     void setInterruptRate(unsigned rate)                    /* MF28 */
  255.     {
  256.         if (typeRequired != MTinPort) return;
  257.         _BX = rate;
  258.         _AX = 28;
  259.         geninterrupt(MOUSE_INT);
  260.     }
  261.     void setCRTpage()                    /* MF29 */
  262.         { _BX = crtPage; _AX = 29;
  263.         geninterrupt(MOUSE_INT); }
  264.     void getCRTpage()                    /* MF30 */
  265.         { _AX = 30; geninterrupt(MOUSE_INT);
  266.         crtPage = _BX; }
  267.     void off();                        /* MF31 */
  268.     void on();                        /* MF32 */
  269.     void softReset();                    /* MF33 */
  270.     void setLanguage()                    /* MF34 */
  271.         { _BX = language; _AX = 34;
  272.         geninterrupt(MOUSE_INT); }
  273.     void getLanguage()                    /* MF35 */
  274.         { _AX = 35; geninterrupt(MOUSE_INT);
  275.         language = _BX; }
  276.     void driver();                        /* MF36 */
  277.  
  278.     unsigned virtualX(unsigned x)  {
  279.         return ((x - LeftTopOfs[vmode])
  280.         * Xcell[vmode]); }
  281.     unsigned virtualY(unsigned y)  {
  282.         return ((y - LeftTopOfs[vmode])
  283.         * Ycell[vmode]); }
  284.     unsigned physicalX(unsigned x)  {
  285.         return (x / Xcell[vmode]
  286.         + LeftTopOfs[vmode]); }
  287.     unsigned physicalY(unsigned y)  {
  288.         return (y / Ycell[vmode]
  289.         + LeftTopOfs[vmode]); }
  290.  
  291. };  // MicrosoftMouse
  292. #endif
  293.