usim

Check-in [ee2075a420]
Login
☰Home Timeline Branches Tags ForumTickets Wiki

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Half working SDL2 keyboard input.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | ams/sdl1
Files: files | file ages | folders
SHA3-256: ee2075a42050137c84987c66b3918c1ed95edb41db5a27d2e4d9dfb476ca6e86
User & Date: ams 2024-06-11 11:19:12
Context
2024-06-12
07:32
Initial hack for handling all-up keys on Cadet. check-in: a2d5e20fe1 user: ams tags: ams/sdl1
2024-06-11
11:19
Half working SDL2 keyboard input. check-in: ee2075a420 user: ams tags: ams/sdl1
2024-06-05
08:26
Garbage attempt at handling keyboard. check-in: 994fa0d7b2 user: ams tags: ams/sdl1
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Changes to knight.c.

︙︙
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include "knight.defs"
#undef X
} knight_keysyms;

static unsigned short knight_kbd_map[256];
static unsigned short knight_modifier_map[5];

static void
knight_process_bucky(int k, int *extra)
{
	switch (k) {
	case KBD_SHIFT:
	case KBD_TOP:
	case KBD_CONTROL:
	case KBD_META:








|








25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include "knight.defs"
#undef X
} knight_keysyms;

static unsigned short knight_kbd_map[256];
static unsigned short knight_modifier_map[5];

void
knight_process_bucky(int k, int *extra)
{
	switch (k) {
	case KBD_SHIFT:
	case KBD_TOP:
	case KBD_CONTROL:
	case KBD_META:
︙︙

Changes to sdl2.c. 

1
2
3
4
5
6
7
8
9
10
11
12
13


















































































































































14
15
16
17
18
19
20

/* sdl2.c --- SDL2 routines used by the TV and KBD interfaces
 */

#include <signal.h>

#include <SDL.h>

#include "tv.h"
#include "kbd.h"
#include "mouse.h"
#include "utrace.h"
#include "idle.h"



















































































































































SDL_Window *window;
SDL_Renderer *renderer;
SDL_Texture *texture;

/*
 * Translation map for the host keyboard to a corresponding Lisp
 * Machine character or modifier.













|
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>








1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

/* sdl2.c --- SDL2 routines used by the TV and KBD interfaces
 */

#include <signal.h>

#include <SDL.h>

#include "tv.h"
#include "kbd.h"
#include "mouse.h"
#include "utrace.h"
#include "idle.h"

#define ShiftMapIndex		0
#define LockMapIndex		1
#define ControlMapIndex		2
#define Mod1MapIndex		3
#define Mod2MapIndex		4
#define Mod3MapIndex		5
#define Mod4MapIndex		6
#define Mod5MapIndex		7


#define XK_0                             0x0030  /* U+0030 DIGIT ZERO */
#define XK_1                             0x0031  /* U+0031 DIGIT ONE */
#define XK_2                             0x0032  /* U+0032 DIGIT TWO */
#define XK_3                             0x0033  /* U+0033 DIGIT THREE */
#define XK_4                             0x0034  /* U+0034 DIGIT FOUR */
#define XK_5                             0x0035  /* U+0035 DIGIT FIVE */
#define XK_6                             0x0036  /* U+0036 DIGIT SIX */
#define XK_7                             0x0037  /* U+0037 DIGIT SEVEN */
#define XK_8                             0x0038  /* U+0038 DIGIT EIGHT */
#define XK_9                             0x0039  /* U+0039 DIGIT NINE */
#define XK_A                             0x0041  /* U+0041 LATIN CAPITAL LETTER A */
#define XK_B                             0x0042  /* U+0042 LATIN CAPITAL LETTER B */
#define XK_BackSpace                     0xff08  /* U+0008 BACKSPACE */
#define XK_C                             0x0043  /* U+0043 LATIN CAPITAL LETTER C */
#define XK_D                             0x0044  /* U+0044 LATIN CAPITAL LETTER D */
#define XK_Down                          0xff54  /* Move down, down arrow */
#define XK_E                             0x0045  /* U+0045 LATIN CAPITAL LETTER E */
#define XK_End                           0xff57  /* EOL */
#define XK_Escape                        0xff1b  /* U+001B ESCAPE */
#define XK_F                             0x0046  /* U+0046 LATIN CAPITAL LETTER F */
#define XK_F1                            0xffbe
#define XK_F2                            0xffbf
#define XK_F3                            0xffc0
#define XK_F4                            0xffc1
#define XK_F5                            0xffc2
#define XK_F6                            0xffc3
#define XK_F7                            0xffc4
#define XK_G                             0x0047  /* U+0047 LATIN CAPITAL LETTER G */
#define XK_H                             0x0048  /* U+0048 LATIN CAPITAL LETTER H */
#define XK_Home                          0xff50
#define XK_I                             0x0049  /* U+0049 LATIN CAPITAL LETTER I */
#define XK_J                             0x004a  /* U+004A LATIN CAPITAL LETTER J */
#define XK_K                             0x004b  /* U+004B LATIN CAPITAL LETTER K */
#define XK_L                             0x004c  /* U+004C LATIN CAPITAL LETTER L */
#define XK_Left                          0xff51  /* Move left, left arrow */
#define XK_M                             0x004d  /* U+004D LATIN CAPITAL LETTER M */
#define XK_N                             0x004e  /* U+004E LATIN CAPITAL LETTER N */
#define XK_O                             0x004f  /* U+004F LATIN CAPITAL LETTER O */
#define XK_P                             0x0050  /* U+0050 LATIN CAPITAL LETTER P */
#define XK_Page_Down                     0xff56  /* deprecated alias for Next */
#define XK_Page_Up                       0xff55  /* deprecated alias for Prior */
#define XK_Q                             0x0051  /* U+0051 LATIN CAPITAL LETTER Q */
#define XK_R                             0x0052  /* U+0052 LATIN CAPITAL LETTER R */
#define XK_Return                        0xff0d  /* U+000D CARRIAGE RETURN */
#define XK_Right                         0xff53  /* Move right, right arrow */
#define XK_S                             0x0053  /* U+0053 LATIN CAPITAL LETTER S */
#define XK_T                             0x0054  /* U+0054 LATIN CAPITAL LETTER T */
#define XK_Tab                           0xff09  /* U+0009 CHARACTER TABULATION */
#define XK_U                             0x0055  /* U+0055 LATIN CAPITAL LETTER U */
#define XK_Up                            0xff52  /* Move up, up arrow */
#define XK_V                             0x0056  /* U+0056 LATIN CAPITAL LETTER V */
#define XK_W                             0x0057  /* U+0057 LATIN CAPITAL LETTER W */
#define XK_X                             0x0058  /* U+0058 LATIN CAPITAL LETTER X */
#define XK_Y                             0x0059  /* U+0059 LATIN CAPITAL LETTER Y */
#define XK_Z                             0x005a  /* U+005A LATIN CAPITAL LETTER Z */
#define XK_a                             0x0061  /* U+0061 LATIN SMALL LETTER A */
#define XK_apostrophe                    0x0027  /* U+0027 APOSTROPHE */
#define XK_b                             0x0062  /* U+0062 LATIN SMALL LETTER B */
#define XK_backslash                     0x005c  /* U+005C REVERSE SOLIDUS */
#define XK_bracketleft                   0x005b  /* U+005B LEFT SQUARE BRACKET */
#define XK_bracketright                  0x005d  /* U+005D RIGHT SQUARE BRACKET */
#define XK_c                             0x0063  /* U+0063 LATIN SMALL LETTER C */
#define XK_comma                         0x002c  /* U+002C COMMA */
#define XK_d                             0x0064  /* U+0064 LATIN SMALL LETTER D */
#define XK_e                             0x0065  /* U+0065 LATIN SMALL LETTER E */
#define XK_equal                         0x003d  /* U+003D EQUALS SIGN */
#define XK_f                             0x0066  /* U+0066 LATIN SMALL LETTER F */
#define XK_g                             0x0067  /* U+0067 LATIN SMALL LETTER G */
#define XK_grave                         0x0060  /* U+0060 GRAVE ACCENT */
#define XK_h                             0x0068  /* U+0068 LATIN SMALL LETTER H */
#define XK_i                             0x0069  /* U+0069 LATIN SMALL LETTER I */
#define XK_j                             0x006a  /* U+006A LATIN SMALL LETTER J */
#define XK_k                             0x006b  /* U+006B LATIN SMALL LETTER K */
#define XK_l                             0x006c  /* U+006C LATIN SMALL LETTER L */
#define XK_m                             0x006d  /* U+006D LATIN SMALL LETTER M */
#define XK_minus                         0x002d  /* U+002D HYPHEN-MINUS */
#define XK_n                             0x006e  /* U+006E LATIN SMALL LETTER N */
#define XK_o                             0x006f  /* U+006F LATIN SMALL LETTER O */
#define XK_p                             0x0070  /* U+0070 LATIN SMALL LETTER P */
#define XK_period                        0x002e  /* U+002E FULL STOP */
#define XK_q                             0x0071  /* U+0071 LATIN SMALL LETTER Q */
#define XK_r                             0x0072  /* U+0072 LATIN SMALL LETTER R */
#define XK_s                             0x0073  /* U+0073 LATIN SMALL LETTER S */
#define XK_semicolon                     0x003b  /* U+003B SEMICOLON */
#define XK_slash                         0x002f  /* U+002F SOLIDUS */
#define XK_space                 0x0020  // U+0020 SPACE
#define XK_t                             0x0074  /* U+0074 LATIN SMALL LETTER T */
#define XK_u                             0x0075  /* U+0075 LATIN SMALL LETTER U */
#define XK_v                             0x0076  /* U+0076 LATIN SMALL LETTER V */
#define XK_w                             0x0077  /* U+0077 LATIN SMALL LETTER W */
#define XK_x                             0x0078  /* U+0078 LATIN SMALL LETTER X */
#define XK_y                             0x0079  /* U+0079 LATIN SMALL LETTER Y */
#define XK_z                             0x007a  /* U+007A LATIN SMALL LETTER Z */
#define XK_0                             0x0030  /* U+0030 DIGIT ZERO */
#define XK_1                             0x0031  /* U+0031 DIGIT ONE */
#define XK_2                             0x0032  /* U+0032 DIGIT TWO */
#define XK_3                             0x0033  /* U+0033 DIGIT THREE */
#define XK_4                             0x0034  /* U+0034 DIGIT FOUR */
#define XK_5                             0x0035  /* U+0035 DIGIT FIVE */
#define XK_6                             0x0036  /* U+0036 DIGIT SIX */
#define XK_7                             0x0037  /* U+0037 DIGIT SEVEN */
#define XK_8                             0x0038  /* U+0038 DIGIT EIGHT */
#define XK_9                             0x0039  /* U+0039 DIGIT NINE */
#define XK_minus                         0x002d  /* U+002D HYPHEN-MINUS */
#define XK_underscore                    0x005f  /* U+005F LOW LINE */
#define XK_equal                         0x003d  /* U+003D EQUALS SIGN */
#define XK_plus                          0x002b  /* U+002B PLUS SIGN */
#define XK_exclam                        0x0021  /* U+0021 EXCLAMATION MARK */
#define XK_numbersign                    0x0023  /* U+0023 NUMBER SIGN */
#define XK_dollar                        0x0024  /* U+0024 DOLLAR SIGN */
#define XK_percent                       0x0025  /* U+0025 PERCENT SIGN */
#define XK_asciicircum                   0x005e  /* U+005E CIRCUMFLEX ACCENT */
#define XK_ampersand                     0x0026  /* U+0026 AMPERSAND */
#define XK_asterisk                      0x002a  /* U+002A ASTERISK */
#define XK_parenleft                     0x0028  /* U+0028 LEFT PARENTHESIS */
#define XK_parenright                    0x0029  /* U+0029 RIGHT PARENTHESIS */
#define XK_at                            0x0040  /* U+0040 COMMERCIAL AT */
#define XK_asciitilde                    0x007e  /* U+007E TILDE */
#define XK_Tab                           0xff09  /* U+0009 CHARACTER TABULATION */
#define XK_braceleft                     0x007b  /* U+007B LEFT CURLY BRACKET */
#define XK_braceright                    0x007d  /* U+007D RIGHT CURLY BRACKET */
#define XK_bracketleft                   0x005b  /* U+005B LEFT SQUARE BRACKET */
#define XK_bracketright                  0x005d  /* U+005D RIGHT SQUARE BRACKET */
#define XK_bar                           0x007c  /* U+007C VERTICAL LINE */
#define XK_BackSpace                     0xff08  /* U+0008 BACKSPACE */
#define XK_semicolon                     0x003b  /* U+003B SEMICOLON */
#define XK_apostrophe                    0x0027  /* U+0027 APOSTROPHE */
#define XK_Return                        0xff0d  /* U+000D CARRIAGE RETURN */
#define XK_colon                         0x003a  /* U+003A COLON */
#define XK_apostrophe                    0x0027  /* U+0027 APOSTROPHE */
#define XK_quotedbl                      0x0022  /* U+0022 QUOTATION MARK */
#define XK_less                          0x003c  /* U+003C LESS-THAN SIGN */
#define XK_greater                       0x003e  /* U+003E GREATER-THAN SIGN */
#define XK_question                      0x003f  /* U+003F QUESTION MARK */


SDL_Window *window;
SDL_Renderer *renderer;
SDL_Texture *texture;

/*
 * Translation map for the host keyboard to a corresponding Lisp
 * Machine character or modifier.
︙︙
65
66
67
68
69
70
71

























































































72
73
74
75
76
77
78

79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116


117
118
119
120
121
122
123
124

	}
	u_minh = 0x7fffffff;
	u_maxh = 0;
	u_minv = 0x7fffffff;
	u_maxv = 0;
}


























































































static void
process_key(SDL_KeyboardEvent e, int keydown)
{
//	KeySym keysym;
//	SDLKey keycode;
	
	int bi;

	unsigned char buf[5];
	
	idle_keyboard_activity();
	
//	keycode = SDL_KeysymToKeycode(e->keysym.sym);
//if (event->key.code == key) ...
	
//	XLookupString(&e->xkey, (char *)buf, sizeof(buf), &keysym, &status);
//	keycode = x11_keysym_to_keycode(keysym);
//	if (keycode == NoSymbol || keysym > NELEM(x11_kbd_map)) {
//		NOTICE(TRACE_USIM, "kbd (cadet): unable to translate to sdl2 keycode (keysym = 0%o)\n", keysym);
//		return;
//	}
	
	if (kbd_type == 0) {
		if (!keydown)
			return;
		bi = 0;
//		if (e->xkey.state & ShiftMask)
//			knight_process_bucky(x11_modifier_map[ShiftMapIndex], &bi);
//		if (e->xkey.state & LockMask)
//			knight_process_bucky(x11_modifier_map[LockMapIndex], &bi);
//		if (e->xkey.state & ControlMask)
//			knight_process_bucky(x11_modifier_map[ControlMapIndex], &bi);
//		if (e->xkey.state & Mod1Mask)
//			knight_process_bucky(x11_modifier_map[Mod1MapIndex], &bi);
//		if (e->xkey.state & Mod2Mask)
//			knight_process_bucky(x11_modifier_map[Mod2MapIndex], &bi);
//		if (e->xkey.state & Mod3Mask)
//			knight_process_bucky(x11_modifier_map[Mod3MapIndex], &bi);
//		if (e->xkey.state & Mod4Mask)
//			knight_process_bucky(x11_modifier_map[Mod4MapIndex], &bi);
//		if (e->xkey.state & Mod5Mask)
//			knight_process_bucky(x11_modifier_map[Mod5MapIndex], &bi);
		knight_process_key(e.keysym.sym, bi, keydown, sdl2_kbd_map, sdl2_modifier_map);
	} else {
//		bi = sdl2_bucky(e.keysym.sym);
		bi = -1;


		cadet_process_key(e.keysym.sym, bi, keydown, sdl2_kbd_map, sdl2_modifier_map);
	}
}

void
sdl2_event(void)
{
	SDL_Event ev;








>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>







>








|
|









|

|

|

|

|

|

|

|


|
|
>
>
|








211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362

	}
	u_minh = 0x7fffffff;
	u_maxh = 0;
	u_minv = 0x7fffffff;
	u_maxv = 0;
}

int
sdl2_bucky(SDL_Keymod mod)
{
	if (mod & KMOD_CTRL) return ControlMapIndex;
//	if (mod & KMOD_SHIFT) return ShiftMapIndex;
	if (mod & KMOD_ALT) return Mod1MapIndex;
	if (mod & KMOD_NUM) return Mod2MapIndex;
	if (mod & KMOD_MODE) return Mod3MapIndex;
	if (mod & KMOD_GUI) return Mod4MapIndex;
	if (mod & KMOD_SCROLL) return Mod5MapIndex;
	return -1;
}

int
sdl2_keysym_to_xk(SDL_KeyboardEvent e)
{
	switch (e.keysym.scancode) {
	case SDL_SCANCODE_ESCAPE: return XK_Escape;
	case SDL_SCANCODE_F1: return XK_F1;
	case SDL_SCANCODE_F2: return XK_F2;
	case SDL_SCANCODE_F3: return XK_F3;
	case SDL_SCANCODE_F4: return XK_F4;
	case SDL_SCANCODE_F5: return XK_F5;
	case SDL_SCANCODE_F6: return XK_F6;
	case SDL_SCANCODE_F7: return XK_F7;
	case SDL_SCANCODE_PAGEUP: return XK_Page_Up;
	case SDL_SCANCODE_PAGEDOWN: return XK_Page_Down;
	case SDL_SCANCODE_HOME: return XK_Home;
	case SDL_SCANCODE_END: return XK_End;
	case SDL_SCANCODE_LEFT: return XK_Left;
	case SDL_SCANCODE_RIGHT: return XK_Right;
	case SDL_SCANCODE_UP: return XK_Up;
	case SDL_SCANCODE_DOWN: return XK_Down;
	case SDL_SCANCODE_GRAVE: return e.keysym.mod & KMOD_SHIFT ? XK_asciitilde : XK_grave;
	case SDL_SCANCODE_1: return e.keysym.mod & KMOD_SHIFT ? XK_exclam : XK_1;
	case SDL_SCANCODE_2: return e.keysym.mod & KMOD_SHIFT ? XK_at : XK_2;
	case SDL_SCANCODE_3: return e.keysym.mod & KMOD_SHIFT ? XK_numbersign : XK_3;
	case SDL_SCANCODE_4: return e.keysym.mod & KMOD_SHIFT ? XK_dollar : XK_4;
	case SDL_SCANCODE_5: return e.keysym.mod & KMOD_SHIFT ? XK_percent : XK_5;
	case SDL_SCANCODE_6: return e.keysym.mod & KMOD_SHIFT ? XK_asciicircum : XK_6;
	case SDL_SCANCODE_7: return e.keysym.mod & KMOD_SHIFT ? XK_ampersand : XK_7;
	case SDL_SCANCODE_8: return e.keysym.mod & KMOD_SHIFT ? XK_asterisk : XK_8;
	case SDL_SCANCODE_9: return e.keysym.mod & KMOD_SHIFT ? XK_parenleft : XK_9;
	case SDL_SCANCODE_0: return e.keysym.mod & KMOD_SHIFT ? XK_parenright : XK_0;
	case SDL_SCANCODE_MINUS: return e.keysym.mod & KMOD_SHIFT ? XK_underscore : XK_minus;
	case SDL_SCANCODE_EQUALS: return e.keysym.mod & KMOD_SHIFT ? XK_plus : XK_equal;
	case SDL_SCANCODE_TAB: return XK_Tab;
	case SDL_SCANCODE_Q: return e.keysym.mod & KMOD_SHIFT ? XK_Q : XK_q;
	case SDL_SCANCODE_W: return e.keysym.mod & KMOD_SHIFT ? XK_W : XK_w;
	case SDL_SCANCODE_E: return e.keysym.mod & KMOD_SHIFT ? XK_E : XK_e;
	case SDL_SCANCODE_R: return e.keysym.mod & KMOD_SHIFT ? XK_R : XK_r;
	case SDL_SCANCODE_T: return e.keysym.mod & KMOD_SHIFT ? XK_T : XK_t;
	case SDL_SCANCODE_Y: return e.keysym.mod & KMOD_SHIFT ? XK_Y : XK_y;
	case SDL_SCANCODE_U: return e.keysym.mod & KMOD_SHIFT ? XK_U : XK_u;
	case SDL_SCANCODE_I: return e.keysym.mod & KMOD_SHIFT ? XK_I : XK_i;
	case SDL_SCANCODE_O: return e.keysym.mod & KMOD_SHIFT ? XK_O : XK_o;
	case SDL_SCANCODE_P: return e.keysym.mod & KMOD_SHIFT ? XK_P : XK_p;
	case SDL_SCANCODE_LEFTBRACKET: return e.keysym.mod & KMOD_SHIFT ? XK_braceleft : XK_bracketleft;
	case SDL_SCANCODE_RIGHTBRACKET: return e.keysym.mod & KMOD_SHIFT ? XK_braceright : XK_bracketright;
	case SDL_SCANCODE_BACKSLASH: return e.keysym.mod & KMOD_SHIFT ? XK_bar : XK_backslash;
	case SDL_SCANCODE_BACKSPACE: return XK_BackSpace;
	case SDL_SCANCODE_A: return e.keysym.mod & KMOD_SHIFT ? XK_A : XK_a;
	case SDL_SCANCODE_S: return e.keysym.mod & KMOD_SHIFT ? XK_S : XK_s;
	case SDL_SCANCODE_D: return e.keysym.mod & KMOD_SHIFT ? XK_D : XK_d;
	case SDL_SCANCODE_F: return e.keysym.mod & KMOD_SHIFT ? XK_F : XK_f;
	case SDL_SCANCODE_G: return e.keysym.mod & KMOD_SHIFT ? XK_G : XK_g;
	case SDL_SCANCODE_H: return e.keysym.mod & KMOD_SHIFT ? XK_H : XK_h;
	case SDL_SCANCODE_J: return e.keysym.mod & KMOD_SHIFT ? XK_J : XK_j;
	case SDL_SCANCODE_K: return e.keysym.mod & KMOD_SHIFT ? XK_K : XK_k;
	case SDL_SCANCODE_L: return e.keysym.mod & KMOD_SHIFT ? XK_L : XK_l;
	case SDL_SCANCODE_SEMICOLON: return e.keysym.mod & KMOD_SHIFT ? XK_colon : XK_semicolon;
	case SDL_SCANCODE_APOSTROPHE: return e.keysym.mod & KMOD_SHIFT ? XK_quotedbl : XK_apostrophe;
	case SDL_SCANCODE_RETURN: return XK_Return;
	case SDL_SCANCODE_Z: return e.keysym.mod & KMOD_SHIFT ? XK_Z : XK_z;
	case SDL_SCANCODE_X: return e.keysym.mod & KMOD_SHIFT ? XK_X : XK_x;
	case SDL_SCANCODE_C: return e.keysym.mod & KMOD_SHIFT ? XK_C : XK_c;
	case SDL_SCANCODE_V: return e.keysym.mod & KMOD_SHIFT ? XK_V : XK_v;
	case SDL_SCANCODE_B: return e.keysym.mod & KMOD_SHIFT ? XK_B : XK_b;
	case SDL_SCANCODE_N: return e.keysym.mod & KMOD_SHIFT ? XK_N : XK_n;
	case SDL_SCANCODE_M: return e.keysym.mod & KMOD_SHIFT ? XK_M : XK_m;
	case SDL_SCANCODE_COMMA: return e.keysym.mod & KMOD_SHIFT ? XK_less : XK_comma;
	case SDL_SCANCODE_PERIOD: return e.keysym.mod & KMOD_SHIFT ? XK_greater : XK_period;
	case SDL_SCANCODE_SLASH: return e.keysym.mod & KMOD_SHIFT ? XK_question : XK_slash;
	case SDL_SCANCODE_SPACE: return XK_space;

	default: return 0xffffff;
	}
}

static void
process_key(SDL_KeyboardEvent e, int keydown)
{
//	KeySym keysym;
//	SDLKey keycode;
	
	int bi;
	int keysym;
	unsigned char buf[5];
	
	idle_keyboard_activity();
	
//	keycode = SDL_KeysymToKeycode(e->keysym.sym);
//if (event->key.code == key) ...
	
//	XLookupString(&e->xkey, (char *)buf, sizeof(buf), &keysym, &status);
//	keycode = sdl2_keysym_to_keycode(keysym);
//	if (keycode == NoSymbol || keysym > NELEM(sdl2_kbd_map)) {
//		NOTICE(TRACE_USIM, "kbd (cadet): unable to translate to sdl2 keycode (keysym = 0%o)\n", keysym);
//		return;
//	}
	
	if (kbd_type == 0) {
		if (!keydown)
			return;
		bi = 0;
//		if (e->xkey.state & ShiftMask)
//			knight_process_bucky(sdl2_modifier_map[ShiftMapIndex], &bi);
//		if (e->xkey.state & LockMask)
//			knight_process_bucky(sdl2_modifier_map[LockMapIndex], &bi);
//		if (e->xkey.state & ControlMask)
//			knight_process_bucky(sdl2_modifier_map[ControlMapIndex], &bi);
//		if (e->xkey.state & Mod1Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod1MapIndex], &bi);
//		if (e->xkey.state & Mod2Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod2MapIndex], &bi);
//		if (e->xkey.state & Mod3Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod3MapIndex], &bi);
//		if (e->xkey.state & Mod4Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod4MapIndex], &bi);
//		if (e->xkey.state & Mod5Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod5MapIndex], &bi);
		knight_process_key(e.keysym.sym, bi, keydown, sdl2_kbd_map, sdl2_modifier_map);
	} else {
		bi = sdl2_bucky(e.keysym.mod);
		keysym = sdl2_keysym_to_xk(e);
		printf("bi = %d, keysym=%c -- 0%o\n", bi,keysym,keysym);
		if (keysym == 0xffffff) return;
		cadet_process_key(keysym, bi, keydown, sdl2_kbd_map, sdl2_modifier_map);
	}
}

void
sdl2_event(void)
{
	SDL_Event ev;
︙︙
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178































































































































































179
180
181
182
183
184
185

		case SDL_WINDOWEVENT:
			SDL_UpdateTexture(texture, NULL, tv_bitmap, tv_width * sizeof (Uint32));
			// flush
			SDL_RenderClear(renderer);
			SDL_RenderCopy(renderer, texture, NULL, NULL);
			SDL_RenderPresent(renderer);
			break;
		case SDL_TEXTINPUT: 
			printf("text: %s shift %d\n", ev.text.text, shift);
			break;
		case SDL_KEYDOWN:
			if (ev.key.keysym.sym == SDLK_RCTRL || ev.key.keysym.sym == SDLK_LCTRL)
				ctrl = 1;
			if (ev.key.keysym.sym == SDLK_RSHIFT || ev.key.keysym.sym == SDLK_LSHIFT)
				shift = 1;
			break;
		case SDL_KEYUP:
			if (ev.key.keysym.sym == SDLK_RCTRL || ev.key.keysym.sym == SDLK_LCTRL)
				ctrl = 0;
			if (ev.key.keysym.sym == SDLK_RSHIFT || ev.key.keysym.sym == SDLK_LSHIFT)
				shift = 1;
			break;
//		case SDL_KEYDOWN:
//			process_key(ev.key, 1);
//			break;
//		case SDL_KEYUP:
//			process_key(ev.key, 0);
//			break;
		case SDL_MOUSEMOTION:
		case SDL_MOUSEBUTTONDOWN:
		case SDL_MOUSEBUTTONUP:
			mouse_event(ev.button.x, ev.button.y, ev.button.button);
			break;
		case SDL_QUIT:
			exit(0);
			break;
		}
	}
}

void
sdl2_default_kbd_map(void)
{
	for (int i = 0; i < (int) NELEM(sdl2_kbd_map); i++)
		sdl2_kbd_map[i] = LMCH_NoSymbol;
	for (int i = 0; i < (int) NELEM(sdl2_modifier_map); i++)
		sdl2_modifier_map[i] = KBD_NoSymbol;































































































































































}

void
sdl2_init(void)
{
	NOTICE(TRACE_USIM, "tv: using SDL backend for monitor and keyboard\n"); 









<
<
<

<
<
<
<
<
<
<
<
<
<
<
<
|
|
|
|
|



















>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>








370
371
372
373
374
375
376



377












378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567

		case SDL_WINDOWEVENT:
			SDL_UpdateTexture(texture, NULL, tv_bitmap, tv_width * sizeof (Uint32));
			// flush
			SDL_RenderClear(renderer);
			SDL_RenderCopy(renderer, texture, NULL, NULL);
			SDL_RenderPresent(renderer);
			break;



		case SDL_KEYDOWN:












			process_key(ev.key, 1);
			break;
		case SDL_KEYUP:
			process_key(ev.key, 0);
			break;
		case SDL_MOUSEMOTION:
		case SDL_MOUSEBUTTONDOWN:
		case SDL_MOUSEBUTTONUP:
			mouse_event(ev.button.x, ev.button.y, ev.button.button);
			break;
		case SDL_QUIT:
			exit(0);
			break;
		}
	}
}

void
sdl2_default_kbd_map(void)
{
	for (int i = 0; i < (int) NELEM(sdl2_kbd_map); i++)
		sdl2_kbd_map[i] = LMCH_NoSymbol;
	for (int i = 0; i < (int) NELEM(sdl2_modifier_map); i++)
		sdl2_modifier_map[i] = KBD_NoSymbol;

	/* *INDENT-OFF* */
	/*
	 * Initialize keyboard modifiers
	 */

	sdl2_modifier_map[ShiftMapIndex] = KBD_SHIFT;
	sdl2_modifier_map[LockMapIndex] = KBD_SHIFT_LOCK;
	sdl2_modifier_map[ControlMapIndex] = KBD_CONTROL;
	sdl2_modifier_map[Mod1MapIndex] = KBD_META;
	sdl2_modifier_map[Mod2MapIndex] = KBD_NoSymbol;
	sdl2_modifier_map[Mod3MapIndex] = KBD_NoSymbol;
	sdl2_modifier_map[Mod4MapIndex] = KBD_TOP;
	sdl2_modifier_map[Mod5MapIndex] = KBD_NoSymbol;

	/*
	 * Initialize keyboard mapping.
	 *
	 * We cann't reuse lmch.defs here because the Lisp Machine
	 * charachter set has names and charachters that do not have a
	 * corresponding mapping in X11.
	 */

	/* Function keys */

	/*
	 * LispM "Escape" is actually Terminal, but in Zmacs this is more
	 * useful.
	 */
	sdl2_kbd_map[XK_Escape] = LMCH_altmode;

	sdl2_kbd_map[XK_F1] = LMCH_system;
	sdl2_kbd_map[XK_F2] = LMCH_network;
	sdl2_kbd_map[XK_F3] = LMCH_status;
	sdl2_kbd_map[XK_F4] = LMCH_terminal;
	sdl2_kbd_map[XK_F5] = LMCH_help;
	sdl2_kbd_map[XK_F6] = LMCH_clear;
	sdl2_kbd_map[XK_F7] = LMCH_break;

	sdl2_kbd_map[XK_Page_Up] = LMCH_abort;
	sdl2_kbd_map[XK_Page_Down] = LMCH_resume;
	sdl2_kbd_map[XK_Home] = LMCH_break;	/* This is really handy next to the others */
	sdl2_kbd_map[XK_End] = LMCH_end;

	/* This is natural */
	sdl2_kbd_map[XK_Left] = LMCH_hand_left;
	sdl2_kbd_map[XK_Right] = LMCH_hand_right;
	sdl2_kbd_map[XK_Up] = LMCH_hand_up;
	sdl2_kbd_map[XK_Down] = LMCH_hand_down;

	/* Unshifted */
	sdl2_kbd_map[XK_grave] = LMCH_grave;
	sdl2_kbd_map[XK_1] = LMCH_1;
	sdl2_kbd_map[XK_2] = LMCH_2;
	sdl2_kbd_map[XK_3] = LMCH_3;
	sdl2_kbd_map[XK_4] = LMCH_4;
	sdl2_kbd_map[XK_5] = LMCH_5;
	sdl2_kbd_map[XK_6] = LMCH_6;
	sdl2_kbd_map[XK_7] = LMCH_7;
	sdl2_kbd_map[XK_8] = LMCH_8;
	sdl2_kbd_map[XK_9] = LMCH_9;
	sdl2_kbd_map[XK_0] = LMCH_0;
	sdl2_kbd_map[XK_minus] = LMCH_minus;
	sdl2_kbd_map[XK_equal] = LMCH_equal;

	sdl2_kbd_map[XK_Tab] = LMCH_tab;
	sdl2_kbd_map[XK_q] = LMCH_q;
	sdl2_kbd_map[XK_w] = LMCH_w;
	sdl2_kbd_map[XK_e] = LMCH_e;
	sdl2_kbd_map[XK_r] = LMCH_r;
	sdl2_kbd_map[XK_t] = LMCH_t;
	sdl2_kbd_map[XK_y] = LMCH_y;
	sdl2_kbd_map[XK_u] = LMCH_u;
	sdl2_kbd_map[XK_i] = LMCH_i;
	sdl2_kbd_map[XK_o] = LMCH_o;
	sdl2_kbd_map[XK_p] = LMCH_p;
	sdl2_kbd_map[XK_bracketleft] = LMCH_bracketleft;
	sdl2_kbd_map[XK_bracketright] = LMCH_bracketright;
	sdl2_kbd_map[XK_backslash] = LMCH_backslash;
	sdl2_kbd_map[XK_BackSpace] = LMCH_rubout;

	sdl2_kbd_map[XK_a] = LMCH_a;
	sdl2_kbd_map[XK_s] = LMCH_s;
	sdl2_kbd_map[XK_d] = LMCH_d;
	sdl2_kbd_map[XK_f] = LMCH_f;
	sdl2_kbd_map[XK_g] = LMCH_g;
	sdl2_kbd_map[XK_h] = LMCH_h;
	sdl2_kbd_map[XK_j] = LMCH_j;
	sdl2_kbd_map[XK_k] = LMCH_k;
	sdl2_kbd_map[XK_l] = LMCH_l;
	sdl2_kbd_map[XK_semicolon] = LMCH_semicolon;
	sdl2_kbd_map[XK_apostrophe] = LMCH_apostrophe;
	sdl2_kbd_map[XK_Return] = LMCH_cr;

	sdl2_kbd_map[XK_z] = LMCH_z;
	sdl2_kbd_map[XK_x] = LMCH_x;
	sdl2_kbd_map[XK_c] = LMCH_c;
	sdl2_kbd_map[XK_v] = LMCH_v;
	sdl2_kbd_map[XK_b] = LMCH_b;
	sdl2_kbd_map[XK_n] = LMCH_n;
	sdl2_kbd_map[XK_m] = LMCH_m;
	sdl2_kbd_map[XK_comma] = LMCH_comma;
	sdl2_kbd_map[XK_period] = LMCH_period;
	sdl2_kbd_map[XK_slash] = LMCH_slash;

	/* Shifted */
	sdl2_kbd_map[XK_asciitilde] = LMCH_asciitilde;
	sdl2_kbd_map[XK_exclam] = LMCH_exclam;
	sdl2_kbd_map[XK_at] = LMCH_at;
	sdl2_kbd_map[XK_numbersign] = LMCH_numbersign;
	sdl2_kbd_map[XK_dollar] = LMCH_dollar;
	sdl2_kbd_map[XK_percent] = LMCH_percent;
	sdl2_kbd_map[XK_asciicircum] = LMCH_asciicircum;
	sdl2_kbd_map[XK_ampersand] = LMCH_ampersand;
	sdl2_kbd_map[XK_asterisk] = LMCH_asterisk;
	sdl2_kbd_map[XK_parenleft] = LMCH_parenleft;
	sdl2_kbd_map[XK_parenright] = LMCH_parenright;
	sdl2_kbd_map[XK_underscore] = LMCH_underscore;
	sdl2_kbd_map[XK_plus] = LMCH_plus;

	sdl2_kbd_map[XK_Q] = LMCH_Q;
	sdl2_kbd_map[XK_W] = LMCH_W;
	sdl2_kbd_map[XK_E] = LMCH_E;
	sdl2_kbd_map[XK_R] = LMCH_R;
	sdl2_kbd_map[XK_T] = LMCH_T;
	sdl2_kbd_map[XK_Y] = LMCH_Y;
	sdl2_kbd_map[XK_U] = LMCH_U;
	sdl2_kbd_map[XK_I] = LMCH_I;
	sdl2_kbd_map[XK_O] = LMCH_O;
	sdl2_kbd_map[XK_P] = LMCH_P;
	sdl2_kbd_map[XK_braceleft] = LMCH_braceleft;
	sdl2_kbd_map[XK_braceright] = LMCH_braceright;
	sdl2_kbd_map[XK_bar] = LMCH_bar;

	sdl2_kbd_map[XK_A] = LMCH_A;
	sdl2_kbd_map[XK_S] = LMCH_S;
	sdl2_kbd_map[XK_D] = LMCH_D;
	sdl2_kbd_map[XK_F] = LMCH_F;
	sdl2_kbd_map[XK_G] = LMCH_G;
	sdl2_kbd_map[XK_H] = LMCH_H;
	sdl2_kbd_map[XK_J] = LMCH_J;
	sdl2_kbd_map[XK_K] = LMCH_K;
	sdl2_kbd_map[XK_L] = LMCH_L;
	sdl2_kbd_map[XK_colon] = LMCH_colon;
	sdl2_kbd_map[XK_quotedbl] = LMCH_quotedbl;

	sdl2_kbd_map[XK_Z] = LMCH_Z;
	sdl2_kbd_map[XK_X] = LMCH_X;
	sdl2_kbd_map[XK_C] = LMCH_C;
	sdl2_kbd_map[XK_V] = LMCH_V;
	sdl2_kbd_map[XK_B] = LMCH_B;
	sdl2_kbd_map[XK_N] = LMCH_N;
	sdl2_kbd_map[XK_M] = LMCH_M;
	sdl2_kbd_map[XK_less] = LMCH_less;
	sdl2_kbd_map[XK_greater] = LMCH_greater;
	sdl2_kbd_map[XK_question] = LMCH_question;

	sdl2_kbd_map[XK_space] = LMCH_space;
	/* *INDENT-ON* */
}

void
sdl2_init(void)
{
	NOTICE(TRACE_USIM, "tv: using SDL backend for monitor and keyboard\n");
︙︙
194
195
196
197
198
199
200
201
202
203
204

//	SDL_RenderClear(renderer);
//	SDL_RenderPresent(renderer);

	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  // make the scaled rendering look smoother.
	SDL_RenderSetLogicalSize(renderer, tv_width, tv_height);

	texture = SDL_CreateTexture(renderer,
				    SDL_PIXELFORMAT_ARGB8888,
				    SDL_TEXTUREACCESS_STREAMING,
				    tv_width, tv_height);
}








|
|
|


576
577
578
579
580
581
582
583
584
585
586

//	SDL_RenderClear(renderer);
//	SDL_RenderPresent(renderer);

	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  // make the scaled rendering look smoother.
	SDL_RenderSetLogicalSize(renderer, tv_width, tv_height);

	texture = SDL_CreateTexture(renderer,
	    SDL_PIXELFORMAT_ARGB8888,
	    SDL_TEXTUREACCESS_STREAMING,
	    tv_width, tv_height);
}

Changes to x11.c.

︙︙
132
133
134
135
136
137
138

139
140
141
142
143
144
145

		if (e->xkey.state & Mod4Mask)
			knight_process_bucky(x11_modifier_map[Mod4MapIndex], &bi);
		if (e->xkey.state & Mod5Mask)
			knight_process_bucky(x11_modifier_map[Mod5MapIndex], &bi);
		knight_process_key(keysym, bi, keydown, x11_kbd_map, x11_modifier_map);
	} else {
		bi = x11_bucky(keycode);

		cadet_process_key(keysym, bi, keydown, x11_kbd_map, x11_modifier_map);
	}
}

static int u_minh = 0x7fffffff;
static int u_maxh;
static int u_minv = 0x7fffffff;








>








132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

		if (e->xkey.state & Mod4Mask)
			knight_process_bucky(x11_modifier_map[Mod4MapIndex], &bi);
		if (e->xkey.state & Mod5Mask)
			knight_process_bucky(x11_modifier_map[Mod5MapIndex], &bi);
		knight_process_key(keysym, bi, keydown, x11_kbd_map, x11_modifier_map);
	} else {
		bi = x11_bucky(keycode);
		printf("bi = %d, keysym=%c -- 0%o\n", bi,keysym,keysym);
		cadet_process_key(keysym, bi, keydown, x11_kbd_map, x11_modifier_map);
	}
}

static int u_minh = 0x7fffffff;
static int u_maxh;
static int u_minv = 0x7fffffff;
︙︙

This page was generated in about 0.024s by Fossil 2.22 [66ee0beb9b] 2023-05-31 15:26:08