home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / server / ddx / omron / omronKbd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-29  |  20.4 KB  |  904 lines
  1. /*
  2.  * $XConsortium: omronKbd.c,v 1.1 91/06/29 13:49:01 xguest Exp $
  3.  *
  4.  * Copyright 1991 by OMRON Corporation
  5.  * 
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of OMRON not be used in advertising or
  11.  * publicity pertaining to distribution of the software without specific,
  12.  * written prior permission.  OMRON makes no representations about the
  13.  * suitability of this software for any purpose.  It is provided "as is"
  14.  * without express or implied warranty.
  15.  *
  16.  * OMRON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL OMRON
  18.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
  21.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  */
  23.  
  24. #include "omron.h"
  25.  
  26. #include "omronKbd.h"
  27.  
  28. #ifdef    uniosu
  29. # include <sys/semienc.t>
  30. #else /* not uniosu */
  31. # ifdef luna88k
  32. #  include <dev/semienc.t>
  33. # else
  34. #  ifdef luna2
  35. #   include <dev/semienc.t>
  36. #  else /* uniosb */
  37. #   include <om68kdev/keymap.t>
  38. #  endif
  39. # endif
  40. #endif
  41.  
  42. #if (!defined(uniosu)) && (!defined(luna88k)) && (!defined(luna2))
  43. #define NOTREP 0
  44. #define REPEAT 1
  45. #endif
  46.  
  47. extern CARD8 *omronKeyModMap[];
  48. extern KeySymsRec omronKeySyms[];
  49. extern unsigned char *omronAutoRepeats[];
  50.  
  51. static Bool omronKbdInit();
  52. static void omronBell();
  53. static void omronKbdCtrl();
  54. #ifndef USE_KANA_SWITCH
  55. static void omronKbdModCheck();
  56. #endif
  57.  
  58. int
  59. omronKbdProc(pKeyboard,what)
  60. DevicePtr     pKeyboard;
  61. int           what;
  62. {
  63.     static Bool initFlag = FALSE;
  64.     static omronKeyPrv prv[1];
  65.  
  66.     switch(what) {
  67.         case DEVICE_INIT:
  68.             pKeyboard->devicePrivate = (pointer)prv;
  69.             if (initFlag == FALSE) {
  70. #ifdef USE_KEYCOMPATI
  71.                 prv->offset = 0;
  72. #else
  73.                 prv->offset = 7;
  74. #endif
  75.                 if (!omronKbdInit(prv))
  76.                     return (!Success);
  77.                 initFlag = TRUE;
  78.             }
  79.             bcopy(prv->semiEncodeDef,prv->semiEncode,CODTBSZ);
  80. #ifndef USE_KANA_SWITCH
  81.             bcopy(prv->semiEncodeDef,prv->semiKanaEncode,CODTBSZ);
  82. #endif
  83.             bcopy (omronAutoRepeats[prv->type],
  84.                 defaultKeyboardControl.autoRepeats,AREPBUFSZ);
  85.             prv->keybdCtrl = defaultKeyboardControl;
  86. #ifndef USE_KANA_SWITCH
  87.             prv->key_state = 0;
  88. # ifdef luna2
  89.             if (prv->type != KB_ASCII ) {
  90. # endif
  91.                 prv->kana_offset =
  92.                     (omronKeySyms[prv->type].maxKeyCode +
  93.                      omronKeySyms[prv->type].minKeyCode + 1) /2 - 
  94.                      omronKeySyms[prv->type].minKeyCode ; 
  95. # ifdef luna2
  96.             }
  97. # endif
  98. #endif
  99.             InitKeyboardDeviceStruct(pKeyboard,
  100.                 &(omronKeySyms[prv->type]), (omronKeyModMap[prv->type]),
  101.                 omronBell, omronKbdCtrl);
  102. #ifndef UNUSE_DRV_TIME 
  103.             omronSetDriverTimeMode(NULL, pKeyboard);
  104. #endif
  105.             break;
  106.         case DEVICE_ON:
  107. #ifndef UNUSE_SIGIO_SIGNAL
  108.             prv->flags |= FASYNC;
  109.             if (fcntl(prv->fd, F_SETFL, prv->flags) < 0 ) {
  110.                 Error("Can't enable the keyboard SIGIO.");
  111.                 return (!Success);
  112.             }
  113. #endif
  114.             AddEnabledDevice(prv->fd);
  115.             pKeyboard->on = TRUE;
  116.             break;
  117.         case DEVICE_OFF:
  118.         case DEVICE_CLOSE:
  119. #ifndef UNUSE_SIGIO_SIGNAL
  120.             prv->flags &= ~FASYNC;
  121.             if (fcntl(prv->fd, F_SETFL, prv->flags) < 0 ) {
  122.                 Error("Can't disable the keyboard SIGIO.");
  123.             }
  124. #endif
  125.             if (ioctl(prv->fd, KBFLSH, NULL) < 0) {
  126.                 Error("Keyboard ioctl KBFLSH fault.");
  127.             }
  128.             RemoveEnabledDevice(prv->fd);
  129.             pKeyboard->on = FALSE;
  130.             break;
  131.     }
  132.     return (Success);
  133. } 
  134.  
  135.  
  136. static Bool
  137. omronKbdInit(prv)
  138. omronKeyPrvPtr prv;
  139. {
  140. #ifdef uniosu
  141.     struct termio new_term;
  142. #else
  143.     struct sgttyb new_term;
  144. #endif
  145.     struct kbssgeta segeta;
  146. #if   (! defined(uniosu)) && (! defined(luna88k)) && (! defined(luna2))
  147.     register int i;
  148. #endif
  149. #ifdef UNUSE_SIGIO_SIGNAL
  150.     int arg = 1; 
  151. #endif
  152.  
  153.  
  154.     if((prv->fd = open("/dev/kbd",O_RDWR,0)) < 0) {
  155.         Error("Can't open /dev/kbd");
  156.         return FALSE;
  157.     }
  158.  
  159. #ifdef luna2
  160.     if( ioctl(prv->fd,KIOCTYPE,&(prv->type)) == -1 ) {
  161.         Error("Can't get kbd type.");
  162.         return FALSE;
  163.     }    
  164. #else
  165.     prv->type = 0;
  166. #endif
  167.  
  168. #ifdef UNUSE_SIGIO_SIGNAL
  169.     ioctl (prv->fd, FIONBIO, &arg);
  170. #else
  171.     if ((prv->flags = fcntl(prv->fd, F_GETFL, NULL)) < 0) {
  172.         Error("Keyboard fcntl F_GETFL fault.");
  173.         return FALSE;
  174.     }
  175.     prv->flags |= FNDELAY;
  176.     if (fcntl(prv->fd, F_SETFL, prv->flags) < 0
  177.         || fcntl(prv->fd, F_SETOWN, getpid()) < 0) {
  178.         Error("Can't set up kbd to receive SIGIO.");
  179.         return FALSE;
  180.     }
  181. #endif
  182.  
  183.     if(ioctl(prv->fd,KBSETM,SEMIENCODED) < 0) {
  184.         Error("Keyboard ioctl SEMIENCODED fault.");
  185.         return FALSE;
  186.     }
  187.  
  188.     if (ioctl(prv->fd,KBRSTENABLE,RSTDISABLE) < 0) {
  189.         Error("Keyboard ioctl RSTDISABLE fault.");
  190.         return FALSE;
  191.     }
  192. #ifdef uniosu
  193.     if(ioctl(prv->fd,TCGETA,&(prv->old_term)) < 0) {
  194.         Error("Keyboard ioctl TCGETA fault.");
  195.         return FALSE;
  196.     }
  197. #else
  198.     if(ioctl(prv->fd,TIOCGETP,&(prv->old_term)) < 0) {
  199.         Error("Keyboard ioctl TCGETA fault.");
  200.         return FALSE;
  201.     }
  202. #endif
  203.  
  204.     new_term = prv->old_term;
  205.  
  206. #ifdef uniosu
  207.     new_term.c_lflag &= ~ICANON;
  208.     new_term.c_lflag &= ~ISIG;
  209.     new_term.c_cc[VEOF] = 1;
  210.     if (ioctl(prv->fd,TCSETA,&new_term) < 0) {    
  211.         Error("Keyboard ioctl TCSETA fault.");
  212.         return FALSE;
  213.     }
  214. #else
  215.     new_term.sg_flags = RAW;
  216.     if (ioctl(prv->fd,TIOCSETP,&new_term) < 0) {    
  217.         Error("Keyboard ioctl TIOCSETP fault.");
  218.         return FALSE;
  219.     }
  220. #endif
  221.     
  222.     segeta.kbsreptp = prv->semiEncodeDef;
  223.     if(ioctl(prv->fd, KBSGETTA, &segeta) < 0) {
  224.         Error("Kbd ioctl KBSGETTA fault.");
  225.         return FALSE;
  226.     }
  227.  
  228. #if   (! defined(uniosu)) && (! defined(luna88k)) && (! defined(luna2))
  229.     for(i = 0 ; i < CODTBSZ ; i++ ) {
  230.         prv->semiEncodeDef[i] = prv->semiEncodeDef[i] ? 0 : 1;
  231.     }
  232. #endif
  233.  
  234.     return TRUE;
  235. }
  236.         
  237. void
  238. omronKbdGiveUp()
  239. {
  240.     DevicePtr     pKeyboard;
  241.     omronKeyPrvPtr prv;
  242.  
  243.     pKeyboard = LookupKeyboardDevice();
  244.  
  245.     if(!pKeyboard) return;
  246.  
  247.     prv = (omronKeyPrvPtr)(pKeyboard->devicePrivate);
  248.     if(!prv) return;
  249.  
  250.     if (ioctl(prv->fd,KBSETM,ENCODED) < 0) {
  251.         Error("Kbd ioctl fault(set encode mode).");
  252.     }
  253.  
  254.     if (ioctl(prv->fd,KBRSTENABLE,RSTENABLE) < 0) {
  255.         Error("Kbd ioctl fault.");
  256.     }
  257.  
  258. #ifdef uniosu    
  259.     if (ioctl(prv->fd,TCSETA,&(prv->old_term)) < 0) {
  260.         Error("Kbd ioctl fault(reset term mode).");
  261.     }
  262. #else
  263.     if (ioctl(prv->fd,TIOCSETP,&(prv->old_term)) < 0) {
  264.         Error("Kbd ioctl fault(reset term mode).");
  265.     }
  266. #endif
  267.  
  268. #ifndef UNUSE_DRV_TIME
  269.     if(ioctl(prv->fd, KBTIME,0) < 0) {
  270.         if ( errno != EINVAL ) {
  271.             Error("Kbd ioctl KBTIME fault.");
  272.         }
  273.     }
  274. #endif
  275.  
  276.     close(prv->fd);
  277. }
  278.     
  279. static void
  280. omronBell(loudness, pKeyboard)
  281. int           loudness;
  282. DevicePtr     pKeyboard;
  283. {
  284.     register int     hz, msec;
  285.     char c;
  286.     omronKeyPrvPtr prv;
  287.  
  288.     prv = (omronKeyPrvPtr)(pKeyboard->devicePrivate);
  289.  
  290.     if (loudness == 0) {
  291.         return;
  292.     }
  293.     hz = prv->keybdCtrl.bell_pitch;
  294. #ifdef uniosu
  295.     if (hz <= 100){
  296.         c = 0x47;
  297.     } else  if (hz <= 150) {
  298.         c = 0x46;
  299.     } else  if (hz <= 300) {
  300.         c = 0x45;
  301.     } else  if (hz <= 600) {
  302.         c = 0x44;
  303.     } else  if (hz <= 1000) {
  304.         c = 0x43;
  305.     } else  if (hz <= 1500) {
  306.         c = 0x42;
  307.     } else  if (hz <= 3000) {
  308.         c = 0x41;
  309.     } else {
  310.         c = 0x40;
  311.     }
  312.  
  313.     msec = omronKeybdCtrl.bell_duration;
  314.     if (msec <= 40) {
  315.         i = 0;
  316.     } else if (msec <= 150) {
  317.         i = 1;
  318.     } else if (msec <= 400) {
  319.         i = 2;
  320.     } else {
  321.         i = 3;
  322.     }
  323.     c |= (i << 3);
  324. #else
  325.     if (hz <= 100){
  326.         c = K_HZ100;
  327.     } else  if (hz <= 150) {
  328.         c = K_HZ150;
  329.     } else  if (hz <= 300) {
  330.         c = K_HZ300;
  331.     } else  if (hz <= 600) {
  332.         c = K_HZ600;
  333.     } else  if (hz <= 1000) {
  334.         c = K_HZ1000;
  335.     } else  if (hz <= 1500) {
  336.         c = K_HZ1500;
  337.     } else  if (hz <= 3000) {
  338.         c = K_HZ3000;
  339.     } else {
  340.         c = K_HZ6000;
  341.     }
  342.  
  343.     msec = prv->keybdCtrl.bell_duration;
  344.     if (msec <= 40) {
  345.         c |= K_TIME40;
  346.     } else if (msec <= 150) {
  347.         c |= K_TIME150;
  348.     } else if (msec <= 400) {
  349.         c |= K_TIME400;
  350.     } else {
  351.         c |= K_TIME700;
  352.     }
  353. #endif
  354. #ifdef uniosu
  355.     if (  write(prv->fd,&c,1) < 0 ) {
  356.         Error ("OmronBell can't write keyboard.");
  357.     }
  358. #else
  359.     if (  ioctl(prv->fd, KBBELL, c) < 0 ) {
  360.         Error ("OmronBell ioctl KBBELL error.");
  361.     }
  362. #endif
  363. }
  364.  
  365. static void
  366. omronKbdCtrl(pKeyboard, ctrl)
  367. DevicePtr     pKeyboard;
  368. KeybdCtrl     *ctrl;
  369. {
  370.     struct kbrepeat rep;
  371.     struct kbssgeta seseta;
  372.     register KeyCode key;
  373.     register int mask,i;
  374.     int shift;
  375.     omronKeyPrvPtr prv;
  376.  
  377.     prv = (omronKeyPrvPtr)(pKeyboard->devicePrivate);
  378.  
  379.     if ( pKeyboard->on == FALSE ) {
  380.         if ( ctrl->click == 0 ) {
  381.             if(ioctl(prv->fd, KBCLICK, 0) < 0) {
  382.                 Error("Kbd ioctl KBCLICK error.");
  383.             }
  384.         } else {
  385.             if(ioctl(prv->fd, KBCLICK, 5) < 0) {
  386.                 Error("Kbd ioctl KBCLICK error.");
  387.             }
  388.         }
  389.  
  390.         if ( ctrl->autoRepeat == TRUE )
  391.             rep.repstart = REPCNT;
  392.         else
  393.             rep.repstart = 0;
  394.         
  395.         rep.repinterval = RPINTVL;
  396.     
  397.         if(ioctl(prv->fd, KBREPTIM, &rep) < 0) {
  398.             Error("Kbd ioctl KBREPTIM error.");
  399.         } 
  400.  
  401.         prv->minkey = omronKeySyms[prv->type].minKeyCode;
  402. #ifndef USE_KANA_SWITCH
  403. # ifdef luna2
  404.         if (prv->type == KB_ASCII )
  405.             prv->maxkey = omronKeySyms[prv->type].maxKeyCode; 
  406.         else
  407. # endif
  408.             prv->maxkey = omronKeySyms[prv->type].minKeyCode +
  409.                           prv->kana_offset - 1; 
  410. #else
  411.         prv->maxkey = omronKeySyms[prv->type].maxKeyCode; 
  412. #endif
  413.  
  414.         for( key = prv->minkey ; key <= prv->maxkey ; key++) {
  415.             if ( prv->semiEncodeDef[key - prv->offset] == REPEAT ) {
  416.                 i = (key >> 3) ; 
  417.                 mask = (1 << (key & 7));
  418.                 if ( ctrl->autoRepeats[i] & mask ) {
  419.                     prv->semiEncode[key - prv->offset] = REPEAT;    
  420.                 } else {
  421.                     prv->semiEncode[key - prv->offset] = NOTREP;    
  422.                 }
  423.             }
  424.         }
  425.  
  426. #ifndef USE_KANA_SWITCH
  427. # ifdef luna2
  428.         if ( prv->type != KB_ASCII ) {
  429. # endif
  430.             prv->kana_minkey = omronKeySyms[prv->type].minKeyCode +
  431.                                prv->kana_offset;
  432.             prv->kana_maxkey = omronKeySyms[prv->type].maxKeyCode; 
  433.     
  434.             for( key = prv->kana_minkey ; key <= prv->kana_maxkey ; key++) {
  435.                 if ( prv->semiEncodeDef[key - prv->kana_offset - prv->offset] == REPEAT ) {
  436.                     i = (key >> 3) ; 
  437.                     mask = (1 << (key & 7));
  438.                     if ( ctrl->autoRepeats[i] & mask ) {
  439.                         prv->semiKanaEncode[key - prv->kana_offset - prv->offset] = REPEAT;    
  440.                     } else {
  441.                         prv->semiKanaEncode[key - prv->kana_offset - prv->offset] = NOTREP;    
  442.                     }
  443.                 }
  444.             }
  445. # ifdef luna2
  446.         }
  447. # endif
  448. #endif
  449.         seseta.kbsreptp = prv->semiEncode;
  450.         if(ioctl(prv->fd, KBSSETTA, &seseta) < 0) {
  451.             Error("Kbd ioctl KBSSETTA error.");
  452.         } 
  453.     } else {
  454.         if ( ctrl->click != prv->keybdCtrl.click ) {
  455.             if( ctrl->click == 0 ) {
  456.                 if(ioctl(prv->fd, KBCLICK, 0) < 0) {
  457.                     Error("Kbd ioctl KBCLICK error.");
  458.                 }
  459.             } else {
  460.                 if(ioctl(prv->fd, KBCLICK, 5) < 0) {
  461.                     Error("Kbd ioctl KBCLICK error.");
  462.                 }
  463.             }
  464.         }
  465.         if ( ctrl->autoRepeat != prv->keybdCtrl.autoRepeat ) { 
  466.             if ( ctrl->autoRepeat == TRUE )     
  467.                 rep.repstart = REPCNT;
  468.             else
  469.                 rep.repstart = 0;
  470.             rep.repinterval = RPINTVL;
  471.             if(ioctl(prv->fd, KBREPTIM, &rep) < 0) {
  472.                 Error("Kbd ioctl KBREPTIM error.");
  473.             }
  474.         }
  475.         for ( i = 0 ; i < AREPBUFSZ ; i++) {
  476.             if (mask = ctrl->autoRepeats[i] ^ prv->keybdCtrl.autoRepeats[i] ) {
  477.                 shift = ffs(mask) -1;
  478.                 key = ( i << 3) | shift;
  479.                 if ( key >= prv->minkey && key <= prv->maxkey ) {
  480.                     key -= prv->offset;
  481.                     if ( prv->semiEncodeDef[key] == REPEAT ) {
  482.                         if ( ctrl->autoRepeats[i] & (1 << shift) )
  483.                         {
  484.                             prv->semiEncode[key] = REPEAT;
  485.                         }else{
  486.                             prv->semiEncode[key] = NOTREP;
  487.                         }
  488. #ifndef USE_KANA_SWITCH
  489.                         if ( !(prv->key_state & KS_KANA) ){
  490. #endif
  491.                             seseta.kbsreptp = prv->semiEncode;
  492.                             if(ioctl(prv->fd, KBSSETTA, &seseta) < 0) {
  493.                                 Error("Kbd ioctl fault(semi-encode table set).");
  494.                             }
  495. #ifndef USE_KANA_SWITCH
  496.                         }
  497. #endif
  498.                     }
  499. #ifdef USE_KANA_SWITCH
  500.                 }
  501. #else
  502. # ifdef luna2
  503.                 } else if(prv->type != KB_ASCII && key >= prv->kana_minkey &&
  504.                                                   key <= prv->kana_maxkey ) {
  505. # else
  506.                 } else if ( key >= prv->kana_minkey &&
  507.                             key <= prv->kana_maxkey ) {
  508. # endif
  509.                     key -= (prv->kana_offset + prv->offset);
  510.                     if ( prv->semiEncodeDef[key] == REPEAT ) {
  511.                         if ( ctrl->autoRepeats[i] & (1 << shift) )
  512.                             prv->semiKanaEncode[key] = REPEAT;
  513.                         else
  514.                             prv->semiKanaEncode[key] = NOTREP;
  515.                         if ( prv->key_state & KS_KANA ) {
  516.                             seseta.kbsreptp = prv->semiKanaEncode;
  517.                             if(ioctl(prv->fd, KBSSETTA, &seseta) < 0) {
  518.                                 Error("Kbd ioctl fault(semi-encode table set).");
  519.                             }
  520.                         }
  521.                     }
  522.                 }
  523. #endif
  524.                 break;
  525.             }
  526.         }
  527.     }
  528.     prv->keybdCtrl = *ctrl;
  529. }
  530.     
  531. Bool
  532. LegalModifier(key)
  533. BYTE key;
  534. {
  535.     return(TRUE);
  536. }
  537.  
  538. #define MAXEVENTS    1024
  539.  
  540. unsigned char *
  541. omronKbdGetEvents(pKeyboard, pNumEvents, pAgain)
  542. DevicePtr     pKeyboard;
  543. int           *pNumEvents;
  544. Bool          *pAgain;
  545. {    
  546.     int           nBytes;
  547.     static unsigned char codebuf[MAXEVENTS];
  548.     omronKeyPrvPtr prv;
  549.  
  550.     prv = (omronKeyPrvPtr)(pKeyboard->devicePrivate);
  551.  
  552.     nBytes = read(prv->fd,codebuf,sizeof(codebuf));
  553.  
  554.     if( nBytes < 0) {
  555.         if (errno == EWOULDBLOCK) {
  556.             *pNumEvents = 0;
  557.             *pAgain = FALSE;
  558.         } else {
  559.             Error ("Can't read keyboard");
  560.         }    
  561.     } else {
  562.         *pNumEvents = nBytes;
  563.         *pAgain = (nBytes == sizeof (codebuf));
  564.     }    
  565.     return(codebuf);
  566. }
  567.  
  568. #ifndef UNUSE_DRV_TIME
  569. key_event *
  570. omronKbdGetTEvents(pKeyboard, pNumEvents, pAgain)
  571. DevicePtr     pKeyboard;
  572. int           *pNumEvents;
  573. Bool          *pAgain;
  574. {    
  575.     int           nBytes;
  576.     static key_event codebuf[MAXEVENTS];
  577.     omronKeyPrvPtr prv;
  578.  
  579.     prv = (omronKeyPrvPtr)(pKeyboard->devicePrivate);
  580.  
  581.     nBytes = read(prv->fd,codebuf,sizeof(codebuf));
  582.  
  583.     if( nBytes < 0) {
  584.         if (errno == EWOULDBLOCK) {
  585.             *pNumEvents = 0;
  586.             *pAgain = FALSE;
  587.         } else {
  588.             Error ("Can't read keyboard");
  589.         }    
  590.     } else {
  591.         *pNumEvents = nBytes / sizeof (key_event);
  592.         *pAgain = (nBytes == sizeof (codebuf));
  593.     }    
  594.     return(codebuf);
  595. }
  596. #endif
  597.  
  598.  
  599. void
  600. omronKbdEnqueueEvent(pKeyboard, data)
  601. DevicePtr     pKeyboard;
  602. unsigned char   *data;
  603. {
  604.  
  605.     unsigned char key;
  606.     xEvent xE;
  607.     CARD8 keyModifiers;
  608.     KeySymsPtr pKeys;
  609.     int lock_key = 0;
  610. #ifndef USE_KANA_SWITCH
  611.     struct kbssgeta seseta;
  612.     unsigned long keysym; 
  613.     static unsigned long modstate = 0;
  614.     int    omron_key_state;
  615. #endif
  616.     omronKeyPrvPtr prv;
  617.  
  618.     prv = (omronKeyPrvPtr)(pKeyboard->devicePrivate);
  619. #ifndef USE_KANA_SWITCH
  620.     omron_key_state = prv->key_state;
  621. #endif
  622.  
  623.     lastEventTime = GetTimeInMillis();
  624.     xE.u.keyButtonPointer.time = lastEventTime;
  625.  
  626.     key = *data;
  627.  
  628. #ifndef USE_KANA_SWITCH
  629.     if (!(key & 0x80)) {
  630.         key &= 0x7f;
  631.         if (key == KANA_KEY) {
  632.             omron_key_state |= KS_KANA;
  633.             prv->key_state = omron_key_state;
  634.             seseta.kbsreptp = prv->semiKanaEncode;
  635.             if(ioctl(prv->fd, KBSSETTA, &seseta) < 0) {
  636.                 Error("Kbd ioctl fault(semi-encode table set).");
  637.             }
  638.             return;
  639.         }
  640.         xE.u.u.type = KeyPress;
  641.     } else {
  642.         key &= 0x7f;
  643.         if (key == KANA_KEY) {
  644.             omron_key_state &= ~KS_KANA;
  645.             prv->key_state = omron_key_state;
  646.             seseta.kbsreptp = prv->semiEncode;
  647.             if(ioctl(prv->fd, KBSSETTA, &seseta) < 0) {
  648.                 Error("Kbd ioctl fault(semi-encode table set).");
  649.             }
  650.             return;
  651.         }
  652.         xE.u.u.type = KeyRelease;
  653.     }
  654.     if (key == CAPSLOCK_KEY) {
  655.         lock_key = 1;
  656.     }
  657.     key += prv->offset;
  658.     keyModifiers = ((DeviceIntPtr)pKeyboard)->key->modifierMap[key];
  659.     if ((omron_key_state & KS_KANA) && (!modstate) && (keyModifiers == 0)) {
  660.         key += prv->kana_offset;
  661.     }
  662.     if (keyModifiers != 0) {
  663.         pKeys = &((DeviceIntPtr)pKeyboard)->key->curKeySyms;
  664.         if (!(lock_key ) && ((keyModifiers & LockMask) ||
  665.             ((keyModifiers & (Mod1Mask| Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask))
  666.             && (pKeys->map[(key - pKeys->minKeyCode) * pKeys->mapWidth] == XK_Mode_switch)))) {
  667.             if (xE.u.u.type == KeyRelease)
  668.                 return;
  669.             if (BitIsOn(((DeviceIntPtr)pKeyboard)->key->down,key))
  670.                 xE.u.u.type = KeyRelease;
  671.         } else if ((keyModifiers & ControlMask) ||
  672.             (keyModifiers & (Mod1Mask| Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask))) {
  673.             keysym = pKeys->map[(key - pKeys->minKeyCode) * pKeys->mapWidth];
  674.             omronKbdModCheck(keysym, xE.u.u.type, &modstate);
  675.         }
  676.     }
  677. #else
  678.     if (!(key & 0x80)) {
  679.         xE.u.u.type = KeyPress;
  680.     } else {
  681.         xE.u.u.type = KeyRelease;
  682.     }
  683.     key &= 0x7f;
  684.     if ((key == CAPSLOCK_KEY) || (key == KANA_KEY)) {
  685.         lock_key = 1;
  686.     }
  687.     key += prv->offset;
  688.     if (!lock_key) {
  689.         keyModifiers = ((DeviceIntPtr)pKeyboard)->key->modifierMap[key];
  690.         pKeys = &((DeviceIntPtr)pKeyboard)->key->curKeySyms;
  691.         if ((keyModifiers & LockMask) ||
  692.             ((keyModifiers & (Mod1Mask| Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask))
  693.             && (pKeys->map[(key - pKeys->minKeyCode) * pKeys->mapWidth] == XK_Mode_switch))) {
  694.             if (xE.u.u.type == KeyRelease)
  695.                 return;
  696.             if (BitIsOn(((DeviceIntPtr)pKeyboard)->key->down,key))
  697.                 xE.u.u.type = KeyRelease;
  698.         }
  699.     }
  700. #endif
  701.     xE.u.u.detail = key;
  702. #ifndef USE_KANA_SWITCH
  703.     prv->key_state = omron_key_state;
  704. #endif
  705.     mieqEnqueue(&xE);
  706. }
  707.  
  708. #ifndef UNUSE_DRV_TIME
  709. void
  710. omronKbdEnqueueTEvent(pKeyboard, data)
  711. DevicePtr     pKeyboard;
  712. key_event     *data;
  713. {
  714.  
  715.     unsigned char key;
  716.     xEvent xE;
  717.     CARD8 keyModifiers;
  718.     KeySymsPtr pKeys;
  719.     int lock_key = 0;
  720. #ifndef USE_KANA_SWITCH
  721.     struct kbssgeta seseta;
  722.     unsigned long keysym; 
  723.     static unsigned long modstate = 0;
  724.     int    omron_key_state;
  725. #endif
  726.     omronKeyPrvPtr prv;
  727.  
  728.     prv = (omronKeyPrvPtr)(pKeyboard->devicePrivate);
  729. #ifndef USE_KANA_SWITCH
  730.     omron_key_state = prv->key_state;
  731. #endif
  732.  
  733.     xE.u.keyButtonPointer.time = data->time;
  734.     key = data->code;
  735.  
  736. #ifndef USE_KANA_SWITCH
  737.     if (!(key & 0x80)) {
  738.         key &= 0x7f;
  739.         if (key == KANA_KEY) {
  740.             omron_key_state |= KS_KANA;
  741.             prv->key_state = omron_key_state;
  742.             seseta.kbsreptp = prv->semiKanaEncode;
  743.             if(ioctl(prv->fd, KBSSETTA, &seseta) < 0) {
  744.                 Error("Kbd ioctl fault(semi-encode table set).");
  745.             }
  746.             return;
  747.         }
  748.         xE.u.u.type = KeyPress;
  749.     } else {
  750.         key &= 0x7f;
  751.         if (key == KANA_KEY) {
  752.             omron_key_state &= ~KS_KANA;
  753.             prv->key_state = omron_key_state;
  754.             seseta.kbsreptp = prv->semiEncode;
  755.             if(ioctl(prv->fd, KBSSETTA, &seseta) < 0) {
  756.                 Error("Kbd ioctl fault(semi-encode table set).");
  757.             }
  758.             return;
  759.         }
  760.         xE.u.u.type = KeyRelease;
  761.     }
  762.     if (key == CAPSLOCK_KEY) {
  763.         lock_key = 1;
  764.     }
  765.     key += prv->offset;
  766.     keyModifiers = ((DeviceIntPtr)pKeyboard)->key->modifierMap[key];
  767.     if ((omron_key_state & KS_KANA) && (!modstate) && (keyModifiers == 0)) {
  768.         key += prv->kana_offset;
  769.     }
  770.     if (keyModifiers != 0) {
  771.         pKeys = &((DeviceIntPtr)pKeyboard)->key->curKeySyms;
  772.         if (!(lock_key ) && ((keyModifiers & LockMask) ||
  773.             ((keyModifiers & (Mod1Mask| Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask))
  774.             && (pKeys->map[(key - pKeys->minKeyCode) * pKeys->mapWidth] == XK_Mode_switch)))) {
  775.             if (xE.u.u.type == KeyRelease)
  776.                 return;
  777.             if (BitIsOn(((DeviceIntPtr)pKeyboard)->key->down,key))
  778.                 xE.u.u.type = KeyRelease;
  779.         } else if ((keyModifiers & ControlMask) ||
  780.             (keyModifiers & (Mod1Mask| Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask))) {
  781.             keysym = pKeys->map[(key - pKeys->minKeyCode) * pKeys->mapWidth];
  782.             omronKbdModCheck(keysym, xE.u.u.type, &modstate);
  783.         }
  784.     }
  785. #else
  786.     if (!(key & 0x80)) {
  787.         xE.u.u.type = KeyPress;
  788.     } else {
  789.         xE.u.u.type = KeyRelease;
  790.     }
  791.     key &= 0x7f;
  792.     if ((key == CAPSLOCK_KEY) || (key == KANA_KEY)) {
  793.         lock_key = 1;
  794.     }
  795.     key += prv->offset;
  796.     if (!lock_key) {
  797.         keyModifiers = ((DeviceIntPtr)pKeyboard)->key->modifierMap[key];
  798.         pKeys = &((DeviceIntPtr)pKeyboard)->key->curKeySyms;
  799.         if ((keyModifiers & LockMask) ||
  800.             ((keyModifiers & (Mod1Mask| Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask))
  801.             && (pKeys->map[(key - pKeys->minKeyCode) * pKeys->mapWidth] == XK_Mode_switch))) {
  802.             if (xE.u.u.type == KeyRelease)
  803.                 return;
  804.             if (BitIsOn(((DeviceIntPtr)pKeyboard)->key->down,key))
  805.                 xE.u.u.type = KeyRelease;
  806.         }
  807.     }
  808. #endif
  809.     xE.u.u.detail = key;
  810. #ifndef USE_KANA_SWITCH
  811.     prv->key_state = omron_key_state;
  812. #endif
  813.     mieqEnqueue(&xE);
  814. }
  815. #endif
  816.  
  817. #ifndef USE_KANA_SWITCH
  818. static void
  819. omronKbdModCheck(keysym, type, modstate)
  820. unsigned long keysym;
  821. BYTE type;
  822. unsigned long *modstate;
  823. {
  824.         unsigned long modst;
  825.  
  826.         modst = *modstate;
  827.         switch(keysym) {
  828.         case XK_Control_L:
  829.             if (type == KeyPress) {
  830.                 modst |= KS_CTRL_L;
  831.             } else {
  832.                 modst &= ~KS_CTRL_L;
  833.             }
  834.             break;
  835.         case XK_Control_R:
  836.             if (type == KeyPress) {
  837.                 modst |= KS_CTRL_R;
  838.             } else {
  839.                 modst &= ~KS_CTRL_R;
  840.             }
  841.             break;
  842.         case XK_Meta_L:
  843.             if (type == KeyPress) {
  844.                 modst |= KS_META_L;
  845.             } else {
  846.                 modst &= ~KS_META_L;
  847.             }
  848.             break;
  849.         case XK_Meta_R:
  850.             if (type == KeyPress) {
  851.                 modst |= KS_META_R;
  852.             } else {
  853.                 modst &= ~KS_META_R;
  854.             }
  855.             break;
  856.         case XK_Alt_L:
  857.             if (type == KeyPress) {
  858.                 modst |= KS_ALT_L;
  859.             } else {
  860.                 modst &= ~KS_ALT_L;
  861.             }
  862.             break;
  863.         case XK_Alt_R:
  864.             if (type == KeyPress) {
  865.                 modst |= KS_ALT_R;
  866.             } else {
  867.                 modst &= ~KS_ALT_R;
  868.             }
  869.             break;
  870.         case XK_Super_L:
  871.             if (type == KeyPress) {
  872.                 modst |= KS_SUPER_L;
  873.             } else {
  874.                 modst &= ~KS_SUPER_L;
  875.             }
  876.             break;
  877.         case XK_Super_R:
  878.             if (type == KeyPress) {
  879.                 modst |= KS_SUPER_R;
  880.             } else {
  881.                 modst &= ~KS_SUPER_R;
  882.             }
  883.             break;
  884.         case XK_Hyper_L:
  885.             if (type == KeyPress) {
  886.                 modst |= KS_HYPER_L;
  887.             } else {
  888.                 modst &= ~KS_HYPER_L;
  889.             }
  890.             break;
  891.         case XK_Hyper_R:
  892.             if (type == KeyPress) {
  893.                 modst |= KS_HYPER_R;
  894.             } else {
  895.                 modst &= ~KS_HYPER_R;
  896.             }
  897.             break;
  898.         default:
  899.             break;
  900.         }
  901.         *modstate = modst;
  902. }
  903. #endif
  904.