home *** CD-ROM | disk | FTP | other *** search
/ Micro R&D 1 / MicroRD-CD-ROM-Vol1-1994.iso / hardware / drivr / optmouse.lzh / OptMouse12 / OptMouse.c < prev    next >
C/C++ Source or Header  |  1991-04-04  |  10KB  |  447 lines
  1. /*
  2.  * OptMouse.c
  3.  *
  4.  * Serial Port Optical Mouse Driver
  5.  *
  6.  * (c) Copyright 1989,1991 J. Edward Hanway
  7.  * This code may be freely redistributed for non-commercial purposes. There
  8.  * is NO WARRANTY on this program. The author assumes no responsibility for
  9.  * any damages resulting from use of this program. You know the drill.
  10.  *
  11.  * Language: SAS/C 5.10a
  12.  *
  13.  * $Id: OptMouse.c,v 1.2 91/04/04 17:41:53 jeh Exp $
  14.  *
  15.  * $Log:    OptMouse.c,v $
  16.  * Revision 1.2  91/04/04  17:41:53  jeh
  17.  * Reworked to send two position update messages for each 5-byte packet
  18.  * received from the mouse.  Should now update the position about 48 times
  19.  * per second.
  20.  * 
  21.  * Added a simple accellerator function.
  22.  * 
  23.  * Note: I (jeh) haven't tested this version except to make sure that it
  24.  * doesn't crash the machine.  (Long ago I modified my mouse according
  25.  * to the instructions in Hardware.doc.)  Thanks to fellow BIXer rjenks
  26.  * for testing this version.
  27.  * 
  28.  * Revision 1.1  91/03/25  22:47:18  jeh
  29.  * Initial revision
  30.  * 
  31.  * pre-RCS Revision History:
  32.  *
  33.  * Version 1.0    27 May 1989
  34.  *    Supports Mouse Systems M2/M3 serial optical mouse
  35.  * Version 1.1  3 June 1989
  36.  *    Added support for other device/unit combinations besides serial.device
  37.  *    (e.g. siosbx.device) *** NOTE: This feature has not been tested. ***
  38.  */
  39.  
  40. #define VERSION "1.2"
  41.  
  42. #include <exec/types.h>
  43. #include <devices/serial.h>
  44. #include <devices/input.h>
  45. #include <devices/inputevent.h>
  46. #include <devices/keyboard.h>
  47. #include <libraries/dos.h>
  48. #include <proto/exec.h>
  49. #include <proto/dos.h>
  50. #include <string.h>
  51. #include <stdlib.h>
  52.  
  53. #define SAY(x) \
  54. {if(_Backstdout) {Write(_Backstdout, (x), strlen(x)); Close(_Backstdout);}}
  55.  
  56. void MemCleanup() {}
  57.  
  58. /* This stuff is for linking with cback.o (for "load and stay resident" code) */
  59.  
  60. LONG        _stack = 4000;        /* stack size */
  61. char        *_procname = "OptMouse";/* process name */
  62. LONG        _priority = 20;        /* priority */
  63. LONG        _BackGroundIO = 1;    /* requires I/O */
  64. extern    BPTR    _Backstdout;
  65.  
  66. static char    *ser_portname = "OptMouse";
  67.     
  68. /* default device/unit */
  69. static char    *device = SERIALNAME;
  70. static int    unit = 0;
  71.  
  72. /* default middle button behavior */
  73. static BOOL    mid_is_shift = 0;
  74.  
  75. /* default accelleration threshold/multiplier */
  76. static int    threshold = 32767;
  77. static int    multiplier = 2;
  78.  
  79. static struct dev {
  80.     struct MsgPort        *port;
  81.     struct IORequest    *iob;
  82.     BOOL            open;
  83. }    ser = {NULL, NULL, FALSE},
  84.     in = {NULL, NULL, FALSE},
  85.     time = {NULL, NULL, FALSE},
  86.     key = {NULL, NULL, FALSE};
  87.     
  88. /* shorthand */
  89. #define SER_IOB        ((struct IOExtSer *)(ser.iob))
  90. #define IN_IOB        ((struct IOStdReq *)(in.iob))
  91. #define TIME_IOB    ((struct timerequest *)(time.iob))
  92. #define KEY_IOB        ((struct IOStdReq *)(key.iob))
  93.  
  94. static signed char    b;        /* byte read from mouse */
  95.  
  96. static struct button {
  97.     BOOL left, middle, right;
  98. }    button, last_button = { FALSE, FALSE, FALSE };
  99.  
  100. static struct InputEvent event = {
  101.     NULL,                /* NextEvent */
  102.     IECLASS_RAWMOUSE,        /* Class */
  103.     NULL,                /* SubClass */
  104.     NULL,                /* Code, filled in later */
  105.     NULL,                /* Qualifier, filled in later */
  106.     { NULL, NULL },            /* Position, filled in later */
  107.     { 0L, 0L }            /* TimeStamp */    
  108. };
  109.  
  110. /* Matrix for reading key states. All we care about are the 
  111.  * shift/ctrl/alt/amiga keys, which are conveniently qrouped in
  112.  * keymatrix[12] in the same order as required for the qualifier
  113.  *
  114.  * The following number, which is the ONLY read length that works for
  115.  * KBD_READMATRIX, was documented NOWHERE! I had to find it by trial and error.
  116.  */
  117. #define KEY_MATRIX_READ_LENGTH    13
  118.  
  119. static UBYTE keymatrix[16];
  120.  
  121. void
  122. close_dev(struct dev *dev)
  123. {
  124.     if(dev->open) {
  125.         AbortIO(dev->iob);
  126.         CloseDevice(dev->iob);
  127.         dev->open = FALSE;
  128.     }
  129.     if(dev->iob) {
  130.         DeleteExtIO(dev->iob);
  131.         dev->iob = NULL;
  132.     }
  133.     if(dev->port) {
  134.         DeletePort(dev->port);
  135.         dev->port = NULL;
  136.     }
  137. }
  138.  
  139. void
  140. die(void)
  141. {
  142.     close_dev(&time);
  143.     close_dev(&in);
  144.     close_dev(&ser);
  145.     close_dev(&key);
  146.     _exit(0);
  147. }
  148.  
  149. void
  150. open_dev(struct dev *dev, char *portname, char *devname, int unit, int size)
  151. { 
  152.     if(!(dev->port = CreatePort(portname, 0)) ||
  153.        !(dev->iob = CreateExtIO(dev->port, size)) ||
  154.        !(dev->open = !OpenDevice(devname, unit, dev->iob, 0L))) {
  155.         SAY("Device error\n");
  156.         die();
  157.     }
  158. }
  159.  
  160. /* my_DoIO does everything that DoIO does (I hope) except it allows for a break
  161.  * signal.
  162.  */
  163. void
  164. my_DoIO(struct IORequest *iob)
  165. {
  166.     register LONGBITS signals, sigbit;
  167.  
  168. /* Lattice/SAS doesn't seem to provide a register-parameter entry to BeginIO,
  169.  * so here's a hack that avoids an annoying 3 line assembly language program.
  170.  * Just don't try to call BeginIO on anything but iob->io_Device.
  171.  */
  172. #pragma libcall iob->io_Device BeginIO 1e 901
  173.  
  174.     iob->io_Flags |= IOF_QUICK;
  175.     BeginIO(iob);
  176.     if(!(iob->io_Flags & IOF_QUICK)) {
  177.         sigbit = 1L << iob->io_Message.mn_ReplyPort->mp_SigBit;
  178.         signals = Wait(sigbit | SIGBREAKF_CTRL_C);
  179.         
  180.         if(signals & sigbit)
  181.             GetMsg(iob->io_Message.mn_ReplyPort);
  182.  
  183.         if(signals & SIGBREAKF_CTRL_C)
  184.             die();
  185.     }
  186. }
  187.  
  188. #undef isspace
  189.  
  190. int
  191. isspace(register char c)
  192. {
  193.     return ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'));
  194. }
  195.  
  196. char *
  197. skiparg(register char *s)
  198. {
  199.     while(*s && !isspace(*s))
  200.         s++;
  201.     return s;
  202. }
  203.  
  204. char *
  205. skipwhite(register char *s)
  206. {
  207.     while(*s && isspace(*s))
  208.         s++;
  209.     return s;
  210. }
  211.  
  212. void
  213. update_buttons(void)
  214. {
  215.     /* Send 0-3 events for button state changes as necessary */
  216.     
  217.     /* Valid time stamp is required for double-clicking
  218.      * to work properly.
  219.      */
  220.     my_DoIO(time.iob);
  221.     event.ie_TimeStamp = TIME_IOB->tr_time;
  222.  
  223.     /* Shift key status is needed for shift-click support */
  224.     my_DoIO(key.iob);
  225.  
  226.     event.ie_X = event.ie_Y = 0;
  227.  
  228.     /* straightforward parts of qualifier: left & right buttons +
  229.      * ctrl/alt/shift keys
  230.      */
  231.     event.ie_Qualifier = IEQUALIFIER_RELATIVEMOUSE |
  232.                  (button.right ? IEQUALIFIER_RBUTTON : 0) |
  233.                  (button.left ? IEQUALIFIER_LEFTBUTTON : 0) |
  234.                  keymatrix[12];
  235.  
  236.     /* middle mouse button support */
  237.     if(button.middle) {
  238.         if(mid_is_shift) {
  239.             /* make middle button look like shifted left button */
  240.             event.ie_Qualifier |= IEQUALIFIER_LEFTBUTTON | IEQUALIFIER_LSHIFT;
  241.         } else {
  242.             /* middle button event is ignored by Intuition prior to V36 */
  243.             event.ie_Qualifier |= IEQUALIFIER_MIDBUTTON;
  244.         }
  245.     }
  246.  
  247.     if(button.left ^ last_button.left) {
  248.         event.ie_Code = button.left ? IECODE_LBUTTON : IECODE_LBUTTON | IECODE_UP_PREFIX;
  249.         my_DoIO(in.iob);
  250.     }
  251.  
  252.     if(button.middle ^ last_button.middle) {
  253.         if(mid_is_shift) {
  254.             event.ie_Code = button.middle ? IECODE_LBUTTON : IECODE_LBUTTON | IECODE_UP_PREFIX;
  255.         } else {
  256.             event.ie_Code = button.middle ? IECODE_MBUTTON : IECODE_MBUTTON | IECODE_UP_PREFIX;
  257.         }
  258.         my_DoIO(in.iob);
  259.     }
  260.  
  261.     if(button.right ^ last_button.right) {
  262.         event.ie_Code = button.right ? IECODE_RBUTTON : IECODE_RBUTTON | IECODE_UP_PREFIX;
  263.         my_DoIO(in.iob);
  264.     }
  265.  
  266.     last_button = button;
  267. }
  268.  
  269. void
  270. update_position(WORD dx, WORD dy)
  271. {
  272.     /* Send one event if the mouse position has changed
  273.      *
  274.      * event.ie_Qualifier is initialized in update_buttons()
  275.      */
  276.  
  277.     if(dx || dy) {
  278.             
  279.         /* Valid time stamp is required for double-clicking
  280.          * to work properly.
  281.          */
  282.         my_DoIO(time.iob);
  283.         event.ie_TimeStamp = TIME_IOB->tr_time;
  284.         
  285.         /* apply accelleration for movements bigger than the threshold */
  286.         
  287.         if((dx > threshold) || (dx < -threshold)) {
  288.             dx *= multiplier;
  289.         } 
  290.         if((dy > threshold) || (dy < -threshold)) {
  291.             dy *= multiplier;
  292.         } 
  293.  
  294.         event.ie_X = dx;
  295.         event.ie_Y = -dy;
  296.         event.ie_Code = IECODE_NOBUTTON;
  297.  
  298.         my_DoIO(in.iob);
  299.     }
  300. }
  301.  
  302. void
  303. _tinymain(char *s)
  304. {
  305.     UWORD        state = 0;
  306.     WORD        dx, dy;
  307.     BOOL        kill = 0;
  308.  
  309.     /* I'm playing it fast and loose with parsing here */
  310.     s = skiparg(s);
  311.     s = skipwhite(s);
  312.     while(*s == '-') {
  313.         switch(*(s+1)) {
  314.         case 'a': case 'A':    /* accelleration */
  315.             s += 2;
  316.             s += stcd_i(s, &threshold);
  317.             if(*s) {
  318.                 s++; /* skip ',' */
  319.                 s += stcd_i(s, &multiplier);
  320.             }
  321.             break;
  322.             
  323.         case 'k': case 'K':    /* kill */
  324.             kill++;
  325.             break;
  326.         
  327.         case 'm': case 'M':    /* mid button is shifted left button */
  328.             mid_is_shift++;
  329.             break;
  330.         }
  331.         s = skiparg(s);
  332.         s = skipwhite(s);
  333.     }
  334.  
  335.     /* device name */
  336.     if(*s) {
  337.         device = s;
  338.         s = skiparg(s);
  339.         if(*s)
  340.             *s++ = '\0';
  341.         s = skipwhite(s);
  342.     }
  343.  
  344.     /* unit */
  345.     if(*s) {
  346.         (void) stcd_i(s, &unit);
  347.     }
  348.  
  349.     if(FindPort(ser_portname)) {
  350.         if(kill) {
  351.             Signal(FindTask(_procname),SIGBREAKF_CTRL_C);
  352.             SAY("Killed\n");
  353.         } else {
  354.             SAY("Already installed\n");
  355.         }
  356.         die();
  357.     }
  358.  
  359.     open_dev(&ser, ser_portname, device, unit, sizeof(struct IOExtSer));
  360.     open_dev(&in, NULL, "input.device", 0L, sizeof(struct IOStdReq));
  361.     open_dev(&time, NULL, TIMERNAME, UNIT_MICROHZ, sizeof(struct timerequest));
  362.     open_dev(&key, NULL, "keyboard.device", 0L, sizeof(struct IOStdReq));
  363.  
  364.     SAY("OptMouse " VERSION " \xA9 Copyright 1989,1991 J. Edward Hanway\n");
  365.  
  366.     /* Set serial port parameters:
  367.      * 1200 baud, 8 bits, no parity, 1 stop bit, no flow control
  368.      */
  369.     SER_IOB->IOSer.io_Command = SDCMD_SETPARAMS;
  370.     SER_IOB->io_Baud = 1200;
  371.     SER_IOB->io_ReadLen = 8;
  372.     SER_IOB->io_StopBits = 1;
  373.     SER_IOB->io_SerFlags = SERF_XDISABLED | SERF_RAD_BOOGIE;
  374.     my_DoIO(ser.iob);
  375.  
  376.     /* Since each IORequest will be used for only one type of command,
  377.      * lots of invariant fields can be filled in here
  378.      */
  379.     KEY_IOB->io_Command = KBD_READMATRIX;
  380.     KEY_IOB->io_Data = (APTR) keymatrix;
  381.     KEY_IOB->io_Length = KEY_MATRIX_READ_LENGTH;
  382.  
  383.     TIME_IOB->tr_node.io_Command = TR_GETSYSTIME;
  384.  
  385.     IN_IOB->io_Command = IND_WRITEEVENT;
  386.     IN_IOB->io_Flags = 0;
  387.     IN_IOB->io_Length = sizeof(struct InputEvent);
  388.     IN_IOB->io_Data = (APTR) &event;
  389.  
  390.     SER_IOB->IOSer.io_Command = CMD_READ;
  391.     SER_IOB->IOSer.io_Length = 1;
  392.     SER_IOB->IOSer.io_Data = (APTR) &b;
  393.  
  394.     for(;;) {
  395.         my_DoIO(ser.iob);
  396.         
  397.         /* The Mouse Systems mouse sends back a five byte code
  398.          * as follows:
  399.          *
  400.          * byte 0: (sync byte) %10000XXX (XXX = button states)
  401.          * byte 1: X delta
  402.          * byte 2: Y delta
  403.          * byte 3: X delta
  404.          * byte 4: Y delta
  405.          *
  406.          * Note that bytes 3 & 4 specify the mouse movement since
  407.          * bytes 1 & 2 were sent.  Thus a single 5 byte message
  408.          * updates the mouse position twice, although it
  409.          * only updates switch states once.
  410.          */
  411.  
  412.         switch(state) {
  413.         case 0:
  414.             if((b & 0xf8) == 0x80) {
  415.                 button.right  = !(b & (1 << 0));
  416.                 button.middle = !(b & (1 << 1));
  417.                 button.left   = !(b & (1 << 2));
  418.                 update_buttons();
  419.                 state++;
  420.             }
  421.             break;
  422.         
  423.         case 1:
  424.             dx = b;
  425.             state++;
  426.             break;
  427.         
  428.         case 2:
  429.             dy = b;
  430.             update_position(dx, dy);
  431.             state++;
  432.             break;
  433.         
  434.         case 3:
  435.             dx = b;
  436.             state++;
  437.             break;
  438.         
  439.         case 4:
  440.             dy = b;
  441.             update_position(dx, dy);
  442.             state = 0;
  443.             break;
  444.         }
  445.     }
  446. }
  447.