home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / x / xibm.zip / AIX / aixEvents.c < prev    next >
C/C++ Source or Header  |  1992-02-11  |  25KB  |  1,052 lines
  1. /*
  2.  * $Id: aixEvents.c,v 5.1 1992/02/12 00:21:36 jfc Exp $
  3.  *
  4.  * Copyright IBM Corporation 1987,1988,1989
  5.  *
  6.  * All Rights Reserved
  7.  *
  8.  * Permission to use, copy, modify, and distribute this software and its
  9.  * documentation for any purpose and without fee is hereby granted,
  10.  * provided that the above copyright notice appear in all copies and that 
  11.  * both that copyright notice and this permission notice appear in
  12.  * supporting documentation, and that the name of IBM not be
  13.  * used in advertising or publicity pertaining to distribution of the
  14.  * software without specific, written prior permission.
  15.  *
  16.  * IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  17.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  18.  * IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  19.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  21.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  22.  * SOFTWARE.
  23.  *
  24. */
  25.  
  26. #ifndef lint
  27. static char sccsid[] = "@(#)hftevents.c    3.PA 88/12/06";
  28. #endif
  29.  
  30. #include <sys/types.h>
  31. #include <sys/times.h>
  32. #include <sys/hft.h>
  33.  
  34. #define NEED_EVENTS
  35. #define NEED_REPLIES
  36. #include "X.h"
  37. #include "Xproto.h"
  38. #include "miscstruct.h"
  39. #include "scrnintstr.h"
  40. #include "cursorstr.h"
  41. #include "input.h"
  42. #include "inputstr.h"
  43.  
  44. #include "OScompiler.h"
  45. #include "OSio.h"
  46. #include "OScursor.h"
  47.  
  48. #include "ibmIO.h"
  49. #include "ibmMouse.h"
  50. #include "ibmKeybd.h"
  51. #include "ibmScreen.h"
  52. #include "ibmCmdArgs.h"
  53.  
  54. #include "aixModKeys.h"
  55. #include "hftQueue.h"
  56.  
  57. #include "ibmTrace.h"
  58.  
  59. #ifdef AIXEXTENSIONS
  60.  
  61. #include "AIX.h"
  62. #include "AIXproto.h"
  63. #include "AIXext.h"
  64. extern DevicePtr rtDial ;
  65. extern DevicePtr rtLpfk ;
  66.  
  67. #endif
  68.  
  69. extern  int      screenIsSaved;
  70. extern  int     kbdType ;
  71.  
  72. static  hftEvent delayedEvent;
  73. static  int      delayed_left;
  74. static  int      delayed_right;
  75. static  int      delayed_middle;
  76. static  unsigned char lastButtons = 0x00 ;
  77. static    short     lastModKeys;
  78. static  int      pendingX;
  79. static  int      pendingY;
  80.  
  81. static long clock = 0;
  82.  
  83. #define GET_OS_TIME() (GetTimeInMillis())
  84.  
  85. /***====================================================================***/
  86.  
  87.     /*
  88.      * 11/19/88 (ef) -- XXX!! Not really sure where these should live.
  89.      *    aixCursor, maybe?
  90.      *    Actually, once all of our systems give relative coordinates,
  91.      *    this can move to common.
  92.      */
  93.  
  94. int    AIXCurrentX = 0;
  95. int    AIXCurrentY = 0;
  96.  
  97. /***====================================================================***/
  98.  
  99. static void
  100. AIXFlushMouse()
  101. {
  102.     int            x,y;
  103.     ibmPerScreenInfo    *screenInfo;
  104.     int            oldScr;
  105.     int            setCursor;
  106.     xEvent        e;
  107.  
  108.     TRACE(("AIXFlushMouse\n"));
  109.  
  110.     if ((pendingX)||(pendingY))
  111.     {
  112.     ibmAccelerate(pendingX,pendingY);
  113.     x= AIXCurrentX+pendingX;
  114.     y= AIXCurrentY-pendingY;
  115.     screenInfo = ibmScreens[ oldScr = ibmCurrentScreen ];
  116.     setCursor = FALSE;
  117.  
  118.     if (ibmYWrapScreen)
  119.     {
  120.         while ( y<0 )
  121.         {
  122.         y+=    screenInfo->ibm_ScreenBounds.y2;
  123.         setCursor= TRUE;
  124.         }
  125.         while ( y>screenInfo->ibm_ScreenBounds.y2 )
  126.         {
  127.         y-=    screenInfo->ibm_ScreenBounds.y2;
  128.         setCursor= TRUE;
  129.         }
  130.     }
  131.  
  132.     while ( x<0 )
  133.     {
  134.         if ( screenInfo == ibmScreens[ 0 ] )
  135.         {
  136.         /* Already at first possible screen */
  137.         if ( ibmXWrapScreen )
  138.         {
  139.             screenInfo = 
  140.             ibmScreens[ ibmCurrentScreen = ibmNumScreens -1 ];
  141.             x+= screenInfo->ibm_ScreenBounds.x2;
  142.         }
  143.         else
  144.         {
  145.             x= 0;
  146.         }
  147.         }
  148.         else
  149.         {
  150.         screenInfo= ibmScreens[ --ibmCurrentScreen ];
  151.         x+= screenInfo->ibm_ScreenBounds.x2;
  152.         }
  153.         setCursor= TRUE;
  154.     }
  155.     while ( x>screenInfo->ibm_ScreenBounds.x2 )
  156.     {
  157.         if ( screenInfo == ibmScreens[ ibmNumScreens - 1 ] )
  158.         {
  159.         /* Already at last possible screen */
  160.         if ( ibmXWrapScreen )
  161.         {
  162.             x-= screenInfo->ibm_ScreenBounds.x2;
  163.             screenInfo= ibmScreens[ ibmCurrentScreen = 0 ];
  164.         }
  165.         else
  166.         {
  167.             x= screenInfo->ibm_ScreenBounds.x2;
  168.         }
  169.         }
  170.         else
  171.         {
  172.         x-=  screenInfo->ibm_ScreenBounds.x2; /* now x>0 */
  173.         screenInfo= ibmScreens[ ++ibmCurrentScreen ];
  174.         }
  175.         setCursor= TRUE;
  176.     }
  177.     if (y>screenInfo->ibm_ScreenBounds.y2)
  178.     {
  179.         y= screenInfo->ibm_ScreenBounds.y2;
  180.         setCursor= TRUE;
  181.     }
  182.     if (y<0)
  183.     {
  184.         y= 0;
  185.         setCursor= TRUE;
  186.     }
  187.     if (setCursor)
  188.     {
  189.         /* OS-DEPENDENT MACRO GOES HERE!!
  190.          * MACRO DEFINED IN FILE ibmos.h
  191.          * TELL OS THAT CURSOR HAS MOVED 
  192.          * TO A NEW POSITION
  193.          */
  194.         OS_TellCursorPosition(x,y);
  195.     }
  196.     if ( oldScr != ibmCurrentScreen )
  197.     {
  198.         (*ibmHideCursor( oldScr ) )( oldScr ) ;
  199.         NewCurrentScreen( screenInfo->ibm_Screen, x, y ) ;
  200.         if ( screenInfo->ibm_CurrentCursor != ibmCurrentCursor( oldScr ) )
  201.         {
  202.         (* screenInfo->ibm_Screen->RealizeCursor )
  203.             ( screenInfo->ibm_Screen, ibmCurrentCursor( oldScr ) ) ;
  204.         }
  205.         (* screenInfo->ibm_Screen->DisplayCursor )
  206.         ( screenInfo->ibm_Screen, ibmCurrentCursor( oldScr ) ) ;
  207.     }
  208.     (* screenInfo->ibm_CursorShow )( x, y ) ;
  209.  
  210.     e.u.u.type            = MotionNotify;
  211.     e.u.keyButtonPointer.rootX    = AIXCurrentX   = x;
  212.     e.u.keyButtonPointer.rootY    = AIXCurrentY   = y;
  213.     e.u.keyButtonPointer.time    = lastEventTime = GET_OS_TIME();
  214.     pendingX= pendingY= 0;
  215.     (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  216.     }
  217. }
  218.  
  219. /***====================================================================***/
  220.  
  221.     /*
  222.      * All of this keyboard stuff needs to
  223.      * be reorganized anyway (into osKeymap.h and a single keyboard.c)
  224.      */
  225.  
  226.  
  227. #define    LSHIFT    (HFUXLSH)
  228. #define    RSHIFT    (HFUXRSH)
  229. #define    RALT    (HFUXRALT)
  230. #define    LALT    (HFUXLALT)
  231. #ifdef DO_CTRL_KEY_CORRECTLY
  232. #define    CTRL    (HFUXCTRL<<8)
  233. #else
  234. #define CTRL    0
  235. #endif
  236.  
  237. #define    MODKEYMASK    (LSHIFT|RSHIFT|RALT|LALT|CTRL)
  238. #define    setModKeyState(ms,pe)    \
  239.         ((ms)=((((pe)->keStatus[0]<<8)|(pe)->keStatus[1])&MODKEYMASK))
  240.  
  241. #define    FAKEEVENT(ev,key,up)    {\
  242.     (ev)->u.u.detail= (key);\
  243.     (ev)->u.u.type= ((up)?KeyRelease:KeyPress);\
  244.     (*ibmKeybd->processInputProc)((ev),ibmKeybd,1);\
  245.     }
  246.  
  247. void
  248. AIXFakeModKeyEvent(changedModKeys)
  249.      unsigned short    changedModKeys;
  250. {
  251.     xEvent          e;
  252.  
  253.     TRACE(("AIXFakeModKeyEvent(0x%x)\n",changedModKeys));
  254.  
  255.     e.u.keyButtonPointer.rootX= AIXCurrentX;
  256.     e.u.keyButtonPointer.rootY= AIXCurrentY;
  257.     e.u.keyButtonPointer.time=  lastEventTime= GET_OS_TIME();
  258.     if (changedModKeys&LSHIFT)
  259.     FAKEEVENT(&e,Aix_Shift_L,(lastModKeys&LSHIFT));
  260.  
  261.     if (changedModKeys&RSHIFT)
  262.     FAKEEVENT(&e,Aix_Shift_R,(lastModKeys&RSHIFT));
  263.  
  264.     if (changedModKeys&LALT)
  265.     FAKEEVENT(&e,Aix_Alt_L,(lastModKeys&LALT));
  266.  
  267.     if (changedModKeys&RALT)
  268.     FAKEEVENT(&e,Aix_Alt_R,(lastModKeys&RALT));
  269.  
  270.  
  271. #ifdef DO_CTRL_KEY_CORRECTLY
  272.     if (changedModKeys&CTRL)
  273.     FAKEEVENT(&e,Aix_Control_L,(lastModKeys&CTRL));
  274. #endif
  275.     return;
  276. }
  277.  
  278. /***====================================================================***/
  279.  
  280. /* 12/22/88 (ef) -- tracking down right-ctrl weirdness */
  281. static int evdebug= 0;
  282.  
  283.     /*
  284.      * 11/17/88 (ef) -- XXX This function is too big -- the kanji
  285.      *    stuff and caps/num lock stuff should be seperated out.
  286.      */
  287.  
  288. static int
  289. AIXKbdEvent(pEv)
  290.      hftEvent    *pEv;
  291. {
  292.     hftKeyEv        *pKey= &pEv->hftEv.hftKey;
  293.     unsigned short    theseModKeys;
  294.     DeviceIntPtr    KeyboardPtr;
  295.     xEvent        e;
  296.     int                 key;
  297.     static int        kanjiCaps = 0 ;
  298.     static int        kanjiLeftAlt = 0 ;
  299.  
  300.     TRACE(("AIXKbdEvent (%d)\n",pKey->kePos));
  301.  
  302.     key = pKey->kePos + AIX_MIN_KEY ;
  303.  
  304.     if ((pendingX)||(pendingY))
  305.     AIXFlushMouse();
  306.  
  307.     setModKeyState(theseModKeys,pKey);
  308.     if (theseModKeys!=lastModKeys)
  309.     AIXFakeModKeyEvent(theseModKeys^lastModKeys);
  310.  
  311.     lastModKeys= theseModKeys;
  312.  
  313.     switch (key)
  314.     {
  315.       case Aix_Alt_L:     
  316.     /*
  317.      * 11/19/88 (ef) -- XXX!  Special case -- don't know where to get
  318.      *    keyboard IDs from, Kanji keyboard broken for now.
  319.      */
  320. #ifdef NOTDEF
  321.     {
  322.         if (kbdType == HF106KBD) /* special case */
  323.         break ;
  324.         else
  325.         return(1);
  326.     }
  327. #endif
  328.       case Aix_Shift_L:  case Aix_Shift_R:
  329.       case Aix_Alt_R:
  330. #ifdef DO_CTRL_KEY_CORRECTLY
  331.       case Aix_Control_L:
  332. #endif
  333.     return(1);
  334.       case Aix_Backspace:
  335.     if ((!ibmDontZap)&&(pKey->keStatus[0]&HFUXCTRL)&&
  336.         (pKey->keStatus[0]&HFUXALT))
  337.     {
  338.         GiveUp();    
  339.     }
  340.     break;
  341.       default:        
  342.     break;
  343.     }
  344.  
  345.     if ((!ibmKeyRepeat)&&pKey->keStatus[1]&HFUXRPT)
  346.     return(1);
  347.  
  348.     e.u.keyButtonPointer.rootX    = AIXCurrentX;
  349.     e.u.keyButtonPointer.rootY    = AIXCurrentY;
  350.     e.u.keyButtonPointer.time    = lastEventTime = GET_OS_TIME();
  351.     e.u.u.detail        = key ;
  352.     if (pKey->keStatus[1]&HFUXRPT)
  353.     {
  354.     e.u.u.type= KeyRelease;
  355.     (*ibmKeybd->processInputProc)(&e,ibmKeybd,1);
  356.     e.u.u.type= KeyPress;
  357.     }
  358.     else if (pKey->keStatus[0]&HFUXMAKE)    e.u.u.type= KeyPress;
  359.     else                    e.u.u.type= KeyRelease;
  360.  
  361.     /*
  362.      *    toggle lock shift keys:
  363.      *    ignore releases, toggle on & off on presses
  364.      */
  365.  
  366.     KeyboardPtr = (DeviceIntPtr)ibmKeybd;
  367.  
  368.     if( KeyboardPtr->key->modifierMap[key] & LockMask )
  369.     {
  370.     if( e.u.u.type == KeyRelease )
  371.         return (1);
  372.     if( KeyboardPtr->key->down[key >> 3] & (1 << (key & 7)) )
  373.     {
  374.         e.u.u.type = KeyRelease;
  375.         SetCapsLockLED(0);
  376.     } else
  377.         SetCapsLockLED(1);
  378.     }
  379.  
  380.     /*
  381.      *    toggle num lock key:
  382.      *    ignore releases, toggle on & off on presses
  383.      */
  384.  
  385.     if( KeyboardPtr->key->modifierMap[key] & NumLockMask )
  386.     {
  387.     if( e.u.u.type == KeyRelease )
  388.         return (1);
  389.     if( KeyboardPtr->key->down[key >> 3] & (1 << (key & 7)) )
  390.     {
  391.         e.u.u.type = KeyRelease;
  392.         SetNumLockLED(0);
  393.     } else
  394.         SetNumLockLED(1);
  395.     }
  396.  
  397.     (*ibmKeybd->processInputProc)(&e,ibmKeybd,1);
  398.  
  399.     return(1);
  400. }
  401.  
  402. /***====================================================================***/
  403.  
  404. #define NONE    0x00
  405. #define LEFT    Button1
  406. #define MIDDLE  Button2 
  407. #define RIGHT   Button3
  408.  
  409. #define UP      ButtonRelease
  410. #define DOWN    ButtonPress
  411.  
  412. static int AIX3ButtonPtrEvent();
  413. static int AIXPtrEvent();
  414.  
  415.  
  416. static void
  417. AIXlocatorTimeout()
  418. {
  419.     TRACE(("AIXlocatorTimeout()\n"));
  420.     AIXPtrEvent(&delayedEvent);
  421.     return;
  422. }
  423.  
  424.     /*
  425.      * 11/17/88 (ef) -- XXX!  This function should be revisited.  It
  426.      *    seems awfully large and complicated.  Two options leap to
  427.      *    to the fore:  a) just delay for a bit and check for new
  428.      *    events or go to a finite-state machine.
  429.      */
  430.  
  431. static int
  432. AIXPtrEvent(pIn)
  433.      hftEvent *pIn;
  434. {
  435.     extern int        AIXMouseChordDelay;
  436.     hftLocEv            *pEv    = &pIn->hftEv.hftLoc;
  437.     unsigned char    buttons = pEv->leButtons&(HFT_BUTTONS|HFT_MBUTTON);
  438.     xEvent              e;
  439.  
  440.  
  441.     TRACE(("AIXPtrEvent (%d,%d)\n",
  442.        HF_SHORT(pEv->leDeltaX),HF_SHORT(pEv->leDeltaY)));
  443.     pendingX+= HF_SHORT(pEv->leDeltaX);
  444.     pendingY+= HF_SHORT(pEv->leDeltaY);
  445.  
  446.     if (pendingX||pendingY)
  447.     AIXFlushMouse();
  448.  
  449.     e.u.keyButtonPointer.rootX    = AIXCurrentX;
  450.     e.u.keyButtonPointer.rootY    = AIXCurrentY;
  451.     e.u.keyButtonPointer.time    = GET_OS_TIME();
  452.  
  453.     if (buttons&HFT_MBUTTON)
  454.     {
  455.     /* We don't care about all the 2 button stuff anymore because
  456.        we know there is a three button mouse.  Therefore, LEFT&RIGHT
  457.        buttons down don't mean middle button( like they had to for a two
  458.        button mouse), they mean left and right button down consecutively.*/
  459.     if (delayed_right || (buttons&HFT_RBUTTON) )
  460.     {
  461.         hftAddTimeout(NULL,0);
  462.         e.u.u.detail = RIGHT;
  463.         e.u.u.type   = DOWN;
  464.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  465.     }
  466.     if (delayed_left || (buttons&HFT_LBUTTON) )
  467.     {
  468.         hftAddTimeout(NULL,0);
  469.         e.u.u.detail = LEFT;
  470.         e.u.u.type   = DOWN;
  471.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  472.     }
  473.     /* if we had previously generated a middle event from a LEFT&RIGHT
  474.        and we are waiting for it to go away */
  475.     if (delayed_middle)
  476.     {
  477.         hftAddTimeout(NULL,0);
  478.         e.u.u.detail = MIDDLE;
  479.         e.u.u.type   = UP;
  480.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  481.     }
  482.     e.u.u.detail = MIDDLE;
  483.     e.u.u.type   = DOWN;
  484.     (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  485.     lastButtons = buttons;
  486.     if (hftInstallHandler(HFT_LOCATOR,AIX3ButtonPtrEvent)==HFT_ERROR)
  487.         ErrorF("Couldn't install three button mouse handler\n");
  488.     return(1);
  489.     }
  490.  
  491.  
  492.     switch(lastButtons)
  493.     {
  494.       case NONE  :
  495.     switch(buttons)
  496.     {
  497.       case NONE  :
  498.         break;
  499.       case HFT_LBUTTON  :
  500.         delayed_left = TRUE;
  501.         break;
  502.       case HFT_RBUTTON  :
  503.         delayed_right = TRUE;
  504.         break;
  505.       case HFT_BUTTONS  :
  506.         e.u.u.detail = MIDDLE;
  507.         e.u.u.type   = DOWN;
  508.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  509.         break;
  510.     }
  511.     break;
  512.       case HFT_LBUTTON  :
  513.     switch(buttons)
  514.     {
  515.       case NONE  :
  516.         if (delayed_left)
  517.         {
  518.         hftAddTimeout(NULL,0);
  519.         e.u.u.detail = LEFT;
  520.         e.u.u.type   = DOWN;
  521.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  522.         delayed_left = FALSE;
  523.         }
  524.         if (delayed_middle)
  525.         {
  526.         e.u.u.detail = MIDDLE;
  527.         e.u.u.type   = UP;
  528.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  529.         delayed_middle = FALSE;
  530.         }
  531.         else
  532.         {
  533.         e.u.u.detail = LEFT;
  534.         e.u.u.type   = UP;
  535.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  536.         }
  537.         break;
  538.       case HFT_LBUTTON  :
  539.         if (delayed_left)
  540.         {
  541.         hftAddTimeout(NULL,0);
  542.         e.u.u.detail = LEFT;
  543.         e.u.u.type   = DOWN;
  544.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  545.         delayed_left = FALSE;
  546.         }
  547.         break;
  548.       case HFT_RBUTTON  :
  549.         if (delayed_left)
  550.         {
  551.         hftAddTimeout(NULL,0);
  552.         e.u.u.detail = LEFT;
  553.         e.u.u.type   = DOWN;
  554.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  555.         delayed_left = FALSE;
  556.         }
  557.         e.u.u.detail = LEFT;
  558.         e.u.u.type   = UP;
  559.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  560.         delayed_right = TRUE;
  561.         break;
  562.       case HFT_BUTTONS  :
  563.         if (delayed_left)
  564.         {
  565.         hftAddTimeout(NULL,0);
  566.         e.u.u.detail = MIDDLE;
  567.         e.u.u.type   = DOWN;
  568.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  569.         delayed_left = FALSE;
  570.         }
  571.         else if (!delayed_middle)
  572.         {
  573.         e.u.u.detail = LEFT;
  574.         e.u.u.type   = UP;
  575.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  576.         e.u.u.detail = MIDDLE;
  577.         e.u.u.type   = DOWN;
  578.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  579.         }
  580.         break;
  581.     }
  582.     break;
  583.       case HFT_RBUTTON  :
  584.     switch(buttons)
  585.     {
  586.       case NONE  :
  587.         if (delayed_right)
  588.         {
  589.         hftAddTimeout(NULL,0);
  590.         e.u.u.detail = RIGHT;
  591.         e.u.u.type   = DOWN;
  592.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  593.         delayed_right = FALSE;
  594.         }
  595.         if (delayed_middle)
  596.         {
  597.         e.u.u.detail = MIDDLE;
  598.         e.u.u.type   = UP;
  599.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  600.         delayed_middle = FALSE;
  601.         }
  602.         else
  603.         {
  604.         e.u.u.detail = RIGHT;
  605.         e.u.u.type   = UP;
  606.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  607.         }
  608.         break;
  609.       case HFT_LBUTTON  :
  610.         if (delayed_right)
  611.         {
  612.         hftAddTimeout(NULL,0);
  613.         e.u.u.detail = RIGHT;
  614.         e.u.u.type   = DOWN;
  615.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  616.         delayed_right = FALSE;
  617.         }
  618.         e.u.u.detail= RIGHT;
  619.         e.u.u.type=   UP;
  620.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  621.         delayed_left = TRUE;
  622.         break;
  623.       case HFT_RBUTTON  :
  624.         if (delayed_right)
  625.         {
  626.         hftAddTimeout(NULL,0);
  627.         e.u.u.detail= RIGHT;
  628.         e.u.u.type=   DOWN;
  629.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  630.         delayed_right = FALSE;
  631.         }
  632.         break;
  633.       case HFT_BUTTONS  :
  634.         if (delayed_right)
  635.         {
  636.         hftAddTimeout(NULL,0);
  637.         e.u.u.detail= MIDDLE;
  638.         e.u.u.type=   DOWN;
  639.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  640.         delayed_right = FALSE;
  641.         }
  642.         else if (!delayed_middle)
  643.         {
  644.         e.u.u.detail= RIGHT;
  645.         e.u.u.type=   UP;
  646.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  647.         e.u.u.detail= MIDDLE;
  648.         e.u.u.type=   DOWN;
  649.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  650.         }
  651.         break;
  652.     }
  653.     break;
  654.       case HFT_BUTTONS  :
  655.     switch(buttons)
  656.     {
  657.       case NONE  :
  658.         e.u.u.detail= MIDDLE;
  659.         e.u.u.type=   UP;
  660.         (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  661.         break;
  662.       case HFT_LBUTTON  :
  663.       case HFT_RBUTTON  :
  664.         delayed_middle = TRUE;
  665.         break;
  666.       case HFT_BUTTONS  :
  667.         break;
  668.     }
  669.     break;
  670.     }
  671.  
  672.     lastButtons = buttons;
  673.  
  674.     if (delayed_left || delayed_right) {
  675.     delayedEvent = *pIn;
  676.     HF_SETSHORT(delayedEvent.hftEv.hftLoc.leDeltaX,0);
  677.     HF_SETSHORT(delayedEvent.hftEv.hftLoc.leDeltaY,0);
  678.     hftAddTimeout(AIXlocatorTimeout,AIXMouseChordDelay);
  679.     }
  680.     return(1);
  681. }
  682.  
  683.  
  684.  
  685. /***====================================================================***/
  686.  
  687. static int
  688. AIX3ButtonPtrEvent(pIn)
  689. hftEvent        *pIn;
  690. {
  691.     extern  int     AIXMouseChordDelay;
  692.     hftLocEv        *pEv= &pIn->hftEv.hftLoc;
  693.     unsigned char   buttons= pEv->leButtons&(HFT_BUTTONS|HFT_MBUTTON);
  694.     unsigned char   changed;
  695.     xEvent          e;
  696.  
  697.     TRACE(("AIX3ButtonPtrEvent (%d,%d)\n",
  698.        HF_SHORT(pEv->leDeltaX),HF_SHORT(pEv->leDeltaY)));
  699.     pendingX+= HF_SHORT(pEv->leDeltaX);
  700.     pendingY+= HF_SHORT(pEv->leDeltaY);
  701.  
  702.     if (pendingX||pendingY)
  703.     AIXFlushMouse();
  704.     e.u.keyButtonPointer.rootX=     AIXCurrentX;
  705.     e.u.keyButtonPointer.rootY=     AIXCurrentY;
  706.     e.u.keyButtonPointer.time=      GET_OS_TIME();
  707.  
  708.     changed = buttons ^ lastButtons;
  709.     if (changed & HFT_LBUTTON)
  710.     {
  711.     if (buttons & HFT_LBUTTON)
  712.         e.u.u.type = DOWN;
  713.     else
  714.         e.u.u.type = UP;
  715.     e.u.u.detail= LEFT;
  716.     (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  717.     }
  718.     if (changed & HFT_RBUTTON)
  719.     {
  720.     if (buttons & HFT_RBUTTON)
  721.         e.u.u.type = DOWN;
  722.     else
  723.         e.u.u.type = UP;
  724.     e.u.u.detail= RIGHT;
  725.     (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  726.     }
  727.     if (changed & HFT_MBUTTON)
  728.     {
  729.     if (buttons & HFT_MBUTTON)
  730.         e.u.u.type = DOWN;
  731.     else
  732.         e.u.u.type = UP;
  733.     e.u.u.detail= MIDDLE;
  734.     (*ibmPtr->processInputProc)(&e,ibmPtr,1);
  735.     }
  736.     lastButtons = buttons;
  737.     return(1);
  738. }
  739.  
  740. /***====================================================================***/
  741.  
  742.     /*
  743.      * 11/17/88 (ef) -- XXX! Not sure why this has to be much different
  744.      *    than AIXFlushMouse.   have to examine.
  745.      */
  746.  
  747. #ifdef AIXEXTENSIONS
  748.  
  749. #ifdef AIXSTAT
  750. #include "AIXstat.h"
  751. extern int   aixsetcursorcount ;
  752. extern int   statenable ;
  753. extern int   statcodemask ;
  754. #endif
  755.  
  756. static int aixTabletSaveX = 1 ;
  757. static int aixTabletSaveY = 1;
  758. int aixTabletScaleX ;
  759. int aixTabletScaleY ;
  760.  
  761. static void
  762. AIXFlushTablet(deltax,deltay)
  763. int deltax,deltay;
  764. {
  765. int    x,y;
  766. ibmPerScreenInfo    *screenInfo;
  767.         int    setCursor;
  768.         xEvent    e;
  769.  
  770.     TRACE(("AIXFlushTablet()\n"));
  771.  
  772.     screenInfo = ibmScreens[ ibmCurrentScreen ];
  773.     x = AIXCurrentX ;
  774.     y = screenInfo->ibm_ScreenBounds.y2 - AIXCurrentY ;
  775.     setCursor = TRUE ;
  776.  
  777.     /*
  778.      * Analize horizontal movement for releative coordinates
  779.      */
  780.  
  781.     if ( deltax <= aixTabletSaveX )
  782.         x =  deltax * x / aixTabletSaveX ;
  783.     else
  784.      if ((screenInfo->ibm_ScreenBounds.x2 * aixTabletScaleX) != aixTabletSaveX)
  785.     x += (deltax - aixTabletSaveX) * (screenInfo->ibm_ScreenBounds.x2 - x) /
  786.      (screenInfo->ibm_ScreenBounds.x2 * aixTabletScaleX - aixTabletSaveX);
  787.  
  788.     if ( !deltax )    
  789.         aixTabletSaveX = 1 ;
  790.     else
  791.         aixTabletSaveX = deltax;
  792.  
  793.     /*
  794.      * Analize vertical movement for releative coordinates
  795.      */
  796.  
  797.     if ( deltay <= aixTabletSaveY )
  798.        y = deltay * y / aixTabletSaveY ;
  799.     else
  800.      if ((screenInfo->ibm_ScreenBounds.y2 * aixTabletScaleY) != aixTabletSaveY)
  801.        y += (deltay - aixTabletSaveY) * (screenInfo->ibm_ScreenBounds.y2 - y) /
  802.       (screenInfo->ibm_ScreenBounds.y2 * aixTabletScaleY - aixTabletSaveY);
  803.  
  804.     if ( !deltay)
  805.         aixTabletSaveY = 1 ;
  806.     else
  807.         aixTabletSaveY = deltay ;
  808.  
  809.          y = screenInfo->ibm_ScreenBounds.y2 - y ;
  810.  
  811.     if ( y > screenInfo->ibm_ScreenBounds.y2)
  812.          y = screenInfo->ibm_ScreenBounds.y2;
  813.  
  814.     if ( x > screenInfo->ibm_ScreenBounds.x2)
  815.          x = screenInfo->ibm_ScreenBounds.x2;
  816.  
  817.     if ( y <= 0) 
  818.         y = 0;
  819.  
  820.     if ( x <= 0) 
  821.         x = 0;
  822.  
  823.     if (setCursor) {
  824.         /* OS-DEPENDENT MACRO GOES HERE!!
  825.          * MACRO DEFINED IN FILE ibmos.h
  826.          * TELL OS THAT CURSOR HAS MOVED 
  827.          * TO A NEW POSITION
  828.          */
  829.         OS_TellCursorPosition(x,y);
  830.     }
  831.  
  832. #ifdef CROSSHAIR
  833.     CrossHairSetCursorPosition(x,y);
  834. #endif
  835.  
  836.      (* screenInfo->ibm_CursorShow )( x, y ) ;
  837.  
  838.      AIXCurrentX= x ;
  839.      AIXCurrentY= y ;
  840.      pendingX= pendingY= 0;
  841.      return ;
  842. }
  843.  
  844. /***====================================================================***/
  845.  
  846. static int
  847. AIXTabletEvent(pIn)
  848. hftEvent        *pIn;
  849. {
  850. hftLocEv        *pEv= &pIn->hftEv.hftLoc;
  851. unsigned char   tmpbuttons,buttons ;
  852. xEvent          e;
  853.  
  854.     TRACE(("AIXTabletEvent(0x%x)\n",pIn));
  855. #ifdef AIXSTAT
  856.     if (statenable && (statcodemask & aixsetcursorpositionCode))
  857.           aixsetcursorcount++ ;    
  858. #endif
  859.  
  860.     /* bug compatible */
  861.  
  862.     if (pEv->leButtons == 3 )
  863.         return ;
  864.  
  865.     buttons = pEv->leButtons >> 3 ;
  866.  
  867.     switch (buttons)
  868.         {
  869.     case  1 :
  870.         buttons = 0x80 ;
  871.         break ;
  872.     case  2 :
  873.         buttons = 0x40 ;
  874.         break ;
  875.     case  3 :
  876.         buttons = 0x20 ;
  877.         break ;
  878.     case  4 :
  879.         buttons = 0x10 ;
  880.         break ;
  881.     }
  882.  
  883.     if (lastButtons != (buttons & HFT_TABLET_BUTTONS)) {
  884.         if (lastButtons) {
  885.         e.u.u.type = ButtonRelease;
  886.         buttons = 0x00 ;
  887.         tmpbuttons = lastButtons;
  888.         } else {
  889.         e.u.u.type = ButtonPress;
  890.         tmpbuttons = buttons;
  891.         }
  892.  
  893.         lastButtons = buttons & HFT_TABLET_BUTTONS ;
  894.  
  895.         switch (tmpbuttons) {
  896.         case  HFT_BUTTON1 : e.u.u.detail = Button1;  break;
  897.         case  HFT_BUTTON2 : e.u.u.detail = Button2;  break;
  898.         case  HFT_BUTTON3 : e.u.u.detail = Button3;  break;
  899.         case  HFT_BUTTON4 : e.u.u.detail = Button4;  break;
  900.         }
  901.         }
  902.     else
  903.     {
  904.         e.u.u.detail= 0 ;
  905.         e.u.u.type=  MotionNotify;
  906.     }
  907.  
  908.     AIXFlushTablet(HF_SHORT(pEv->leDeltaX),HF_SHORT(pEv->leDeltaY));
  909.  
  910.     e.u.keyButtonPointer.rootX=     AIXCurrentX;
  911.     e.u.keyButtonPointer.rootY=     AIXCurrentY;
  912.     e.u.keyButtonPointer.time=      GET_OS_TIME();
  913.  
  914.         (*(ibmPtr->processInputProc))(&e,ibmPtr,1);
  915.  
  916.         return (1) ;
  917. }
  918.  
  919. #endif AIXEXTENSIONS
  920.  
  921.  
  922. /***====================================================================***/
  923.  
  924.     /*
  925.      * 11/27/88 (ef) -- XXX  -- Hack but not *too* gross, wouldn't be
  926.      *    bad if we could install it only when we knew it was
  927.      *    necessary -- in aixScreenSave or something.
  928.      *
  929.      * Called before any events are processed, IFF events are present on 
  930.      * the hft queue.  Turns off screen saver, if it is active and dumps
  931.      * malloc arena if requested.
  932.      */
  933. static void
  934. AIXPreEventHandler()
  935. {
  936. #ifdef IBM_SPECIAL_MALLOC
  937. extern int ibmShouldDumpArena;
  938. #endif /* IBM_SPECIAL_MALLOC */
  939.  
  940.     TRACE(("aixPreEventHandler()\n"));
  941. #ifdef IBM_SPECIAL_MALLOC
  942.     if (ibmShouldDumpArena) {
  943.     ibmDumpArena();
  944.     }
  945. #endif /* IBM_SPECIAL_MALLOC */
  946.     if (screenIsSaved == SCREEN_SAVER_ON) {
  947.     SaveScreens( SCREEN_SAVER_OFF, ScreenSaverReset );
  948.     }
  949.     return;
  950. }
  951.  
  952. /***====================================================================***/
  953.  
  954. void
  955. ProcessInputEvents()
  956. {
  957.  
  958.     TRACE(("ProcessInputEvents (pending=%d)\n",hftPending));
  959.     hftDispatchEvents();
  960.     if (pendingX||pendingY)
  961.     AIXFlushMouse();
  962.     return;
  963. }
  964.  
  965. /***====================================================================***/
  966.  
  967. #ifdef AIXEXTENSIONS
  968. static int
  969. AIXDialEvent (pIn)
  970. hftEvent    *pIn;
  971. {
  972.     xExtEvent    xe;
  973.     hftDialEv    *pEv = &pIn->hftEv.hftDial;
  974.  
  975.     TRACE(("AIXDialEvent(0x%x)\n",pIn));
  976.     xe.u.DialLpfk.rootX =  AIXCurrentX;
  977.     xe.u.DialLpfk.rootY =  AIXCurrentY;
  978.     lastEventTime = xe.u.DialLpfk.time = GET_OS_TIME();
  979.  
  980.     xe.u.u.type = DialRotate;
  981.     xe.u.u.detail = (char) pEv->deDialNo;
  982.     xe.u.DialLpfk.value = (char) pEv->deDelta;
  983.  
  984.     if (rtDial->on)
  985.     (*(rtDial->processInputProc))((xEvent *)&xe, rtDial,1);
  986.  
  987.  
  988.     return (1);
  989. }
  990.  
  991.  
  992. static int
  993. AIXLpfkEvent (pIn)
  994. hftEvent    *pIn;
  995. {
  996.     xExtEvent    xe;
  997.     hftLPFKEv    *pEv = &pIn->hftEv.hftLpfk;
  998.  
  999.     TRACE(("AIXLpfkEvent(0x%x)\n",pIn));
  1000.     xe.u.DialLpfk.rootX =  AIXCurrentX;
  1001.     xe.u.DialLpfk.rootY =  AIXCurrentY;
  1002.     lastEventTime = xe.u.DialLpfk.time = GET_OS_TIME();
  1003.  
  1004.     xe.u.u.type = LPFKeyPress ;
  1005.     xe.u.u.detail = pEv->lpfkeKeyNo ;
  1006.  
  1007.  
  1008.     if (rtLpfk->on)
  1009.     (*(rtLpfk->processInputProc))((xEvent *)&xe, rtLpfk,1);
  1010.  
  1011.  
  1012.     return (1);
  1013. }
  1014. #endif
  1015.  
  1016. /***====================================================================***/
  1017.  
  1018. extern void     ibmReactivateScreens(), ibmDeactivateScreens();
  1019.  
  1020. void
  1021. AIXInitEventHandlers()
  1022. {
  1023.     TRACE(("AIXInitEventHandlers()\n"));
  1024.     if (hftInstallHandler(HFT_BEFORE_EVENTS,AIXPreEventHandler)==HFT_ERROR) {
  1025.     ErrorF("Couldn't install pre-event handler\n");
  1026.     }
  1027.     if (hftInstallHandler(HFT_LOCATOR,AIXPtrEvent)==HFT_ERROR) {
  1028.     ErrorF("Couldn't install mouse handler\n");
  1029.     }
  1030.     if (hftInstallHandler(HFT_KEYBOARD,AIXKbdEvent)==HFT_ERROR) {
  1031.     ErrorF("Couldn't install keyboard handler\n");
  1032.     }
  1033.     hftInstallHandler(HFT_EVENT_ARRIVED,HFT_IGNORE);
  1034.     if (hftInstallHandler(HFT_GRANTED,ibmReactivateScreens)==HFT_ERROR) {
  1035.     ErrorF("Couldn't install grant routine\n");
  1036.     }
  1037.     if (hftInstallHandler(HFT_RETRACTED,ibmDeactivateScreens)==HFT_ERROR) {
  1038.         ErrorF("Couldn't install retract handler\n");
  1039.     }
  1040. #ifdef AIXEXTENSIONS
  1041.     if (hftInstallHandler(HFT_TABLET,AIXTabletEvent)==HFT_ERROR) {
  1042.     ErrorF("Couldn't install tablet handler\n");
  1043.     }
  1044.     if (hftInstallHandler(HFT_DIAL,AIXDialEvent)==HFT_ERROR) {
  1045.         ErrorF("Couldn't install dial handler\n");
  1046.     }
  1047.     if (hftInstallHandler(HFT_LPFK,AIXLpfkEvent)==HFT_ERROR) {
  1048.         ErrorF("Couldn't install lpfk handler\n");
  1049.     }
  1050. #endif
  1051. }
  1052.