![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lk201.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / lk201|
Return to lk201.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / lk201 |
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.