Return to lk201.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / lk201

Annotation of researchv9/X11/src/X.V11R1/server/ddx/lk201/lk201.c, revision 1.1

1.1     ! root        1: /************************************************************
        !             2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
        !             3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
        !             4: 
        !             5:                         All Rights Reserved
        !             6: 
        !             7: Permission to use, copy, modify, and distribute this software and its 
        !             8: documentation for any purpose and without fee is hereby granted, 
        !             9: provided that the above copyright notice appear in all copies and that
        !            10: both that copyright notice and this permission notice appear in 
        !            11: supporting documentation, and that the names of Digital or MIT not be
        !            12: used in advertising or publicity pertaining to distribution of the
        !            13: software without specific, written prior permission.  
        !            14: 
        !            15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
        !            16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
        !            17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
        !            18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
        !            19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
        !            20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
        !            21: SOFTWARE.
        !            22: 
        !            23: ********************************************************/
        !            24: /* $Header: lk201.c,v 1.25 87/09/13 00:51:54 toddb Exp $ */
        !            25: 
        !            26: #include "X.h"
        !            27: #define NEED_EVENTS
        !            28: #include "Xproto.h"
        !            29: #include "keynames.h"
        !            30: #include "keysym.h"
        !            31: 
        !            32: /* This file is device dependent, but is common to several devices */
        !            33: 
        !            34: #include <sys/types.h>
        !            35: #include "input.h"
        !            36: 
        !            37: #define KEYDOWN_ERROR  0x3d
        !            38: #define POWERUP_ERROR  0x3e
        !            39: #define BASEKEY                0x41
        !            40: #define MINSPECIAL     0xb3
        !            41: #define ALLUPS         0xb3
        !            42: #define METRONOME      0xb4
        !            43: #define OUTPUT_ERROR   0xb5
        !            44: #define INPUT_ERROR    0xb6
        !            45: #define MAXSPECIAL     0xba
        !            46: 
        !            47: static u_char lastkey;
        !            48: 
        !            49: #define NUMDIVS 14
        !            50: static u_char divbeg[NUMDIVS] = {0xbf, 0x91, 0xbc, 0xbd, 0xb0, 0xad, 0xa6,
        !            51:                                 0xa9, 0x88, 0x56, 0x63, 0x6f, 0x7b, 0x7e};
        !            52: static u_char divend[NUMDIVS] = {0xff, 0xa5, 0xbc, 0xbe, 0xb2, 0xaf, 0xa8,
        !            53:                                 0xac, 0x90, 0x62, 0x6e, 0x7a, 0x7d, 0x87};
        !            54: /* initially set for keyboard defaults */
        !            55: static unsigned int keymodes[8] = {0, 0, 0, 0, 0, 0x0001c000, 0, 0};
        !            56:        /* down/up keys */
        !            57: static unsigned int keys[8]; /* down/up keys that are currently down */
        !            58: 
        !            59: /* Handle keyboard input from LK201 */
        !            60: 
        !            61: void
        !            62: ProcessLK201Input (e, dev)
        !            63:        register xEvent *e;
        !            64:        DevicePtr dev;
        !            65: {
        !            66:     register unsigned int    key, bits;
        !            67:     register         int    idx;
        !            68: 
        !            69:     key = e->u.u.detail;
        !            70:     if (key > MAXSPECIAL || (key >= BASEKEY && key < MINSPECIAL))
        !            71:     {
        !            72:        lastkey = key;
        !            73:        idx = key >> 5;
        !            74:        key &= 0x1f;
        !            75:        key = 1 << key;
        !            76:        if (keymodes[idx] & key)        /* an up down type */
        !            77:        {
        !            78:            if ((keys[idx] ^= key) & key)
        !            79:                e->u.u.type = KeyPress;
        !            80:            else
        !            81:                e->u.u.type = KeyRelease;
        !            82:            (*dev->processInputProc)(e, dev);
        !            83:        }
        !            84:        else
        !            85:        {
        !            86:            e->u.u.type = KeyPress;
        !            87:            (*dev->processInputProc)(e, dev);
        !            88:            e->u.u.type = KeyRelease;
        !            89:            (*dev->processInputProc)(e, dev);
        !            90:        }
        !            91:     }
        !            92:     else
        !            93:     {
        !            94:        switch (key)
        !            95:        {
        !            96:            case METRONOME: 
        !            97:                e->u.u.type = KeyPress;
        !            98:                e->u.u.detail = lastkey;
        !            99:                (*dev->processInputProc)(e, dev);
        !           100:                e->u.u.type = KeyRelease;
        !           101:                (*dev->processInputProc)(e, dev);
        !           102:                break;
        !           103:            case ALLUPS: 
        !           104:                idx = 7;
        !           105:                e->u.u.type = KeyRelease;
        !           106:                do
        !           107:                {
        !           108:                    if (bits = keys[idx])
        !           109:                    {
        !           110:                        keys[idx] = 0;
        !           111:                        key = 0;
        !           112:                        do
        !           113:                        {
        !           114:                            if (bits & 1)
        !           115:                            {
        !           116:                                e->u.u.detail = (idx << 5) | key;
        !           117:                                (*dev->processInputProc)(e, dev);
        !           118:                            }
        !           119:                            key++;
        !           120:                        } while (bits >>= 1);
        !           121:                    }
        !           122:                } while (--idx >= 0);
        !           123:                break;
        !           124:            case POWERUP_ERROR: 
        !           125:            case KEYDOWN_ERROR: 
        !           126:            case OUTPUT_ERROR: 
        !           127:            case INPUT_ERROR: 
        !           128:            /*      Warning ("keyboard error");    XXX */
        !           129:                break;
        !           130:        }
        !           131:     }
        !           132: }
        !           133: 
        !           134: /* Put keyboard in autorepeat mode and return control command string.
        !           135:  * autorepeat/down: main keyboard, numeric keypad, delete, cursors
        !           136:  * up/down: all others
        !           137:  */
        !           138: 
        !           139: static void
        !           140: ResetLKModes (modes)
        !           141:        register int modes;
        !           142: {
        !           143:        register int i = 0;
        !           144:        register int key, last;
        !           145: 
        !           146:        bzero ((caddr_t) keymodes, sizeof (keymodes));
        !           147:        do {
        !           148:            if (modes & 1) {
        !           149:                for (key = divbeg[i], last = divend[i]; key <= last; key++)
        !           150:                    keymodes[key >> 5] |= 1 << (key & 0x1f);
        !           151:            }
        !           152:            modes >>= 1;
        !           153:        } while (++i < NUMDIVS);
        !           154: }
        !           155: 
        !           156: char *
        !           157: AutoRepeatLKMode ()
        !           158: {
        !           159:        ResetLKModes (0x3f38);
        !           160:        return ("\212\222\232\246\256\266\272\302\316\326\336\346\356\366");
        !           161: }
        !           162: 
        !           163: /* Put all of keyboard in down/up mode and return control command string */
        !           164: 
        !           165: char *
        !           166: UpDownLKMode ()
        !           167: {
        !           168:        ResetLKModes (0x3fff);
        !           169:        return ("\216\226\236\246\256\266\276\306\316\326\336\346\356\366");
        !           170: }
        !           171: 
        !           172: Bool
        !           173: LegalModifier(key)
        !           174:     BYTE key;
        !           175: {
        !           176:     if ((key == KEY_LOCK)
        !           177:      || (key == KEY_SHIFT)
        !           178:      || (key == KEY_COMPOSE)
        !           179:      || (key == KEY_CTRL))
        !           180:         return TRUE;
        !           181:     return FALSE;
        !           182: }
        !           183: 
        !           184: void
        !           185: GetLK201Mappings(pKeySyms, pModMap)
        !           186:     KeySymsPtr pKeySyms;
        !           187:     CARD8 *pModMap;
        !           188: {
        !           189: #define INDEX(in) ((in - MIN_LK201_KEY) * LK201_GLYPHS_PER_KEY)
        !           190:     int i;
        !           191:     KeySym *map;
        !           192: 
        !           193:     for (i = 0; i < MAP_LENGTH; i++)
        !           194:        pModMap[i] = NoSymbol;  /* make sure it is restored */
        !           195:     pModMap[ KEY_LOCK ] = LockMask;
        !           196:     pModMap[ KEY_SHIFT ] = ShiftMask;
        !           197:     pModMap[ KEY_CTRL ] = ControlMask;
        !           198:     pModMap[ KEY_COMPOSE ] = Mod1Mask;
        !           199: 
        !           200:     map = (KeySym *)Xalloc(sizeof(KeySym) * 
        !           201:                                    (MAP_LENGTH * LK201_GLYPHS_PER_KEY));
        !           202:     pKeySyms->minKeyCode = MIN_LK201_KEY;
        !           203:     pKeySyms->maxKeyCode = MAX_LK201_KEY;
        !           204:     pKeySyms->mapWidth = LK201_GLYPHS_PER_KEY;
        !           205:     pKeySyms->map = map;
        !           206: 
        !           207:     for (i = 0; i < (MAP_LENGTH * LK201_GLYPHS_PER_KEY); i++)
        !           208:        map[i] = NoSymbol;      /* make sure it is restored */
        !           209: 
        !           210:     map[INDEX(KEY_F1)] = XK_F1;
        !           211:     map[INDEX(KEY_F2)] = XK_F2;
        !           212:     map[INDEX(KEY_F3)] = XK_F3;
        !           213:     map[INDEX(KEY_F4)] = XK_F4;
        !           214:     map[INDEX(KEY_F5)] = XK_F5;
        !           215:     map[INDEX(KEY_F6)] = XK_F6;
        !           216:     map[INDEX(KEY_F7)] = XK_F7;
        !           217:     map[INDEX(KEY_F8)] = XK_F8;
        !           218:     map[INDEX(KEY_F9)] = XK_F9;
        !           219:     map[INDEX(KEY_F10)] = XK_F10;
        !           220:     map[INDEX(KEY_ESC)] = XK_Escape;
        !           221:     map[INDEX(KEY_F12)] = XK_BackSpace;
        !           222:     map[INDEX(KEY_LF)] = XK_Linefeed;
        !           223:     map[INDEX(KEY_F14)] = XK_F14;
        !           224: 
        !           225:     map[INDEX(KEY_HELP)] = XK_Help;
        !           226:     map[INDEX(KEY_MENU)] = XK_Menu;
        !           227: 
        !           228:     map[INDEX(KEY_F17)] = XK_F17;
        !           229:     map[INDEX(KEY_F18)] = XK_F18;
        !           230:     map[INDEX(KEY_F19)] = XK_F19;
        !           231:     map[INDEX(KEY_F20)] = XK_F20;
        !           232: 
        !           233:     map[INDEX(KEY_FIND)] = XK_Find;
        !           234:     map[INDEX(KEY_INSERT_HERE)] = XK_Insert;
        !           235:     map[INDEX(KEY_REMOVE)] = XK_Delete;
        !           236:     map[INDEX(KEY_SELECT)] = XK_Select;
        !           237:     map[INDEX(KEY_PREV_SCREEN)] = XK_Prior;
        !           238:     map[INDEX(KEY_NEXT_SCREEN)] = XK_Next;
        !           239: 
        !           240:     map[INDEX(KEY_KP_0)] = XK_KP_0;
        !           241:     map[INDEX(KEY_KP_PERIOD)] = XK_KP_Decimal;
        !           242:     map[INDEX(KEY_KP_ENTER)] = XK_KP_Enter;
        !           243:     map[INDEX(KEY_KP_1)] = XK_KP_1;
        !           244:     map[INDEX(KEY_KP_2)] = XK_KP_2;
        !           245:     map[INDEX(KEY_KP_3)] = XK_KP_3;
        !           246:     map[INDEX(KEY_KP_4)] = XK_KP_4;
        !           247:     map[INDEX(KEY_KP_5)] = XK_KP_5;
        !           248:     map[INDEX(KEY_KP_6)] = XK_KP_6;
        !           249:     map[INDEX(KEY_KP_COMMA)] = XK_KP_Separator;
        !           250:     map[INDEX(KEY_KP_7)] = XK_KP_7;
        !           251:     map[INDEX(KEY_KP_8)] = XK_KP_8;
        !           252:     map[INDEX(KEY_KP_9)] = XK_KP_9;
        !           253:     map[INDEX(KEY_KP_HYPHEN)] = XK_KP_Subtract;
        !           254:     map[INDEX(KEY_KP_PF1)] = XK_KP_F1;
        !           255:     map[INDEX(KEY_KP_PF2)] = XK_KP_F2;
        !           256:     map[INDEX(KEY_KP_PF3)] = XK_KP_F3;
        !           257:     map[INDEX(KEY_KP_PF4)] = XK_KP_F4;
        !           258: 
        !           259:     map[INDEX(KEY_LEFT)] = XK_Left;
        !           260:     map[INDEX(KEY_RIGHT)] = XK_Right;
        !           261:     map[INDEX(KEY_DOWN)] = XK_Down;
        !           262:     map[INDEX(KEY_UP)] = XK_Up;
        !           263: 
        !           264:     map[INDEX(KEY_SHIFT)] = XK_Shift_L;
        !           265:     map[INDEX(KEY_CTRL)] = XK_Control_L;
        !           266:     map[INDEX(KEY_LOCK)] = XK_Caps_Lock;
        !           267:     map[INDEX(KEY_COMPOSE)] = XK_Multi_key;
        !           268:     map[INDEX(KEY_DELETE)] = XK_Delete;
        !           269:     map[INDEX(KEY_RETURN)] = XK_Return;
        !           270:     map[INDEX(KEY_TAB)] = XK_Tab;
        !           271: 
        !           272:     map[INDEX(KEY_TILDE)] = XK_quoteleft;
        !           273:     map[INDEX(KEY_TILDE)+1] = XK_asciitilde;
        !           274: 
        !           275:     map[INDEX(KEY_TR_1)] = XK_1;                 
        !           276:     map[INDEX(KEY_TR_1)+1] = XK_exclam;
        !           277:     map[INDEX(KEY_Q)] = XK_Q;
        !           278:     map[INDEX(KEY_A)] = XK_A;
        !           279:     map[INDEX(KEY_Z)] = XK_Z;
        !           280: 
        !           281:     map[INDEX(KEY_TR_2)] = XK_2;
        !           282:     map[INDEX(KEY_TR_2)+1] = XK_at;
        !           283: 
        !           284:     map[INDEX(KEY_W)] = XK_W;
        !           285:     map[INDEX(KEY_S)] = XK_S;
        !           286:     map[INDEX(KEY_X)] = XK_X;
        !           287: 
        !           288:     map[INDEX(KEY_LANGLE_RANGLE)] = XK_less;
        !           289:     map[INDEX(KEY_LANGLE_RANGLE)+1] = XK_greater;
        !           290: 
        !           291:     map[INDEX(KEY_TR_3)] = XK_3;
        !           292:     map[INDEX(KEY_TR_3)+1] = XK_numbersign;
        !           293: 
        !           294:     map[INDEX(KEY_E)] = XK_E;
        !           295:     map[INDEX(KEY_D)] = XK_D;
        !           296:     map[INDEX(KEY_C)] = XK_C;
        !           297: 
        !           298:     map[INDEX(KEY_TR_4)] = XK_4;
        !           299:     map[INDEX(KEY_TR_4)+1] = XK_dollar;
        !           300: 
        !           301:     map[INDEX(KEY_R)] = XK_R;
        !           302:     map[INDEX(KEY_F)] = XK_F;
        !           303:     map[INDEX(KEY_V)] = XK_V;
        !           304:     map[INDEX(KEY_SPACE)] = XK_space;
        !           305: 
        !           306:     map[INDEX(KEY_TR_5)] = XK_5;
        !           307:     map[INDEX(KEY_TR_5)+1] = XK_percent;
        !           308: 
        !           309:     map[INDEX(KEY_T)] = XK_T;
        !           310:     map[INDEX(KEY_G)] = XK_G;
        !           311:     map[INDEX(KEY_B)] = XK_B;
        !           312: 
        !           313:     map[INDEX(KEY_TR_6)] = XK_6;
        !           314:     map[INDEX(KEY_TR_6)+1] = XK_asciicircum;
        !           315: 
        !           316:     map[INDEX(KEY_Y)] = XK_Y;
        !           317:     map[INDEX(KEY_H)] = XK_H;
        !           318:     map[INDEX(KEY_N)] = XK_N;
        !           319: 
        !           320:     map[INDEX(KEY_TR_7)] = XK_7;
        !           321:     map[INDEX(KEY_TR_7)+1] = XK_ampersand;
        !           322: 
        !           323:     map[INDEX(KEY_U)] = XK_U;
        !           324:     map[INDEX(KEY_J)] = XK_J;
        !           325:     map[INDEX(KEY_M)] = XK_M;
        !           326: 
        !           327:     map[INDEX(KEY_TR_8)] = XK_8;
        !           328:     map[INDEX(KEY_TR_8)+1] = XK_asterisk;
        !           329: 
        !           330:     map[INDEX(KEY_I)] = XK_I;
        !           331:     map[INDEX(KEY_K)] = XK_K;
        !           332: 
        !           333:     map[INDEX(KEY_COMMA)] = XK_comma;
        !           334:     map[INDEX(KEY_COMMA)+1] = XK_less;
        !           335: 
        !           336:     map[INDEX(KEY_TR_9)] = XK_9;
        !           337:     map[INDEX(KEY_TR_9)+1] = XK_parenleft;
        !           338: 
        !           339:     map[INDEX(KEY_O)] = XK_O;
        !           340:     map[INDEX(KEY_L)] = XK_L;
        !           341: 
        !           342:     map[INDEX(KEY_PERIOD)] = XK_period;
        !           343:     map[INDEX(KEY_PERIOD)+1] = XK_greater;
        !           344: 
        !           345:     map[INDEX(KEY_TR_0)] = XK_0;
        !           346:     map[INDEX(KEY_TR_0)+1] = XK_parenright;
        !           347: 
        !           348:     map[INDEX(KEY_P)] = XK_P;
        !           349: 
        !           350:     map[INDEX(KEY_SEMICOLON)] = XK_semicolon;
        !           351:     map[INDEX(KEY_SEMICOLON)+1] = XK_colon;
        !           352: 
        !           353:     map[INDEX(KEY_QMARK)] = XK_slash;   
        !           354:     map[INDEX(KEY_QMARK)+1] = XK_question;
        !           355: 
        !           356:     map[INDEX(KEY_PLUS)] = XK_equal;
        !           357:     map[INDEX(KEY_PLUS)+1] = XK_plus;
        !           358: 
        !           359:     map[INDEX(KEY_RBRACE)] = XK_bracketright;
        !           360:     map[INDEX(KEY_RBRACE)+1] = XK_braceright;
        !           361: 
        !           362:     map[INDEX(KEY_VBAR)] = XK_backslash;
        !           363:     map[INDEX(KEY_VBAR)+1] = XK_bar;
        !           364: 
        !           365:     map[INDEX(KEY_UBAR)] = XK_minus;
        !           366:     map[INDEX(KEY_UBAR)+1] = XK_underscore;
        !           367: 
        !           368:     map[INDEX(KEY_LBRACE)] = XK_bracketleft;
        !           369:     map[INDEX(KEY_LBRACE)+1] = XK_braceleft;
        !           370: 
        !           371:     map[INDEX(KEY_QUOTE)] = XK_quoteright;
        !           372:     map[INDEX(KEY_QUOTE)+1] = XK_quotedbl;
        !           373: #undef INDEX
        !           374: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.