Gitly


1 module sapp
2 
3 // X11 backend implementation for sokol_app.
4 // Ports the C _sapp_x11_* functions from sokol_app.h to V.
5 
6 const x11_max_keycodes = 256
7 
8 // Keysym-to-unicode lookup table (from GLFW's xkb_unicode.c)
9 struct X11Codepair {
10     keysym u16
11     ucs    u16
12 }
13 
14 const x11_keysymtab = [
15     X11Codepair{0x01a1, 0x0104},
16     X11Codepair{0x01a2, 0x02d8},
17     X11Codepair{0x01a3, 0x0141},
18     X11Codepair{0x01a5, 0x013d},
19     X11Codepair{0x01a6, 0x015a},
20     X11Codepair{0x01a9, 0x0160},
21     X11Codepair{0x01aa, 0x015e},
22     X11Codepair{0x01ab, 0x0164},
23     X11Codepair{0x01ac, 0x0179},
24     X11Codepair{0x01ae, 0x017d},
25     X11Codepair{0x01af, 0x017b},
26     X11Codepair{0x01b1, 0x0105},
27     X11Codepair{0x01b2, 0x02db},
28     X11Codepair{0x01b3, 0x0142},
29     X11Codepair{0x01b5, 0x013e},
30     X11Codepair{0x01b6, 0x015b},
31     X11Codepair{0x01b7, 0x02c7},
32     X11Codepair{0x01b9, 0x0161},
33     X11Codepair{0x01ba, 0x015f},
34     X11Codepair{0x01bb, 0x0165},
35     X11Codepair{0x01bc, 0x017a},
36     X11Codepair{0x01bd, 0x02dd},
37     X11Codepair{0x01be, 0x017e},
38     X11Codepair{0x01bf, 0x017c},
39     X11Codepair{0x01c0, 0x0154},
40     X11Codepair{0x01c3, 0x0102},
41     X11Codepair{0x01c5, 0x0139},
42     X11Codepair{0x01c6, 0x0106},
43     X11Codepair{0x01c8, 0x010c},
44     X11Codepair{0x01ca, 0x0118},
45     X11Codepair{0x01cc, 0x011a},
46     X11Codepair{0x01cf, 0x010e},
47     X11Codepair{0x01d0, 0x0110},
48     X11Codepair{0x01d1, 0x0143},
49     X11Codepair{0x01d2, 0x0147},
50     X11Codepair{0x01d5, 0x0150},
51     X11Codepair{0x01d8, 0x0158},
52     X11Codepair{0x01d9, 0x016e},
53     X11Codepair{0x01db, 0x0170},
54     X11Codepair{0x01de, 0x0162},
55     X11Codepair{0x01e0, 0x0155},
56     X11Codepair{0x01e3, 0x0103},
57     X11Codepair{0x01e5, 0x013a},
58     X11Codepair{0x01e6, 0x0107},
59     X11Codepair{0x01e8, 0x010d},
60     X11Codepair{0x01ea, 0x0119},
61     X11Codepair{0x01ec, 0x011b},
62     X11Codepair{0x01ef, 0x010f},
63     X11Codepair{0x01f0, 0x0111},
64     X11Codepair{0x01f1, 0x0144},
65     X11Codepair{0x01f2, 0x0148},
66     X11Codepair{0x01f5, 0x0151},
67     X11Codepair{0x01f8, 0x0159},
68     X11Codepair{0x01f9, 0x016f},
69     X11Codepair{0x01fb, 0x0171},
70     X11Codepair{0x01fe, 0x0163},
71     X11Codepair{0x01ff, 0x02d9},
72     X11Codepair{0x02a1, 0x0126},
73     X11Codepair{0x02a6, 0x0124},
74     X11Codepair{0x02a9, 0x0130},
75     X11Codepair{0x02ab, 0x011e},
76     X11Codepair{0x02ac, 0x0134},
77     X11Codepair{0x02b1, 0x0127},
78     X11Codepair{0x02b6, 0x0125},
79     X11Codepair{0x02b9, 0x0131},
80     X11Codepair{0x02bb, 0x011f},
81     X11Codepair{0x02bc, 0x0135},
82     X11Codepair{0x02c5, 0x010a},
83     X11Codepair{0x02c6, 0x0108},
84     X11Codepair{0x02d5, 0x0120},
85     X11Codepair{0x02d8, 0x011c},
86     X11Codepair{0x02dd, 0x016c},
87     X11Codepair{0x02de, 0x015c},
88     X11Codepair{0x02e5, 0x010b},
89     X11Codepair{0x02e6, 0x0109},
90     X11Codepair{0x02f5, 0x0121},
91     X11Codepair{0x02f8, 0x011d},
92     X11Codepair{0x02fd, 0x016d},
93     X11Codepair{0x02fe, 0x015d},
94     X11Codepair{0x03a2, 0x0138},
95     X11Codepair{0x03a3, 0x0156},
96     X11Codepair{0x03a5, 0x0128},
97     X11Codepair{0x03a6, 0x013b},
98     X11Codepair{0x03aa, 0x0112},
99     X11Codepair{0x03ab, 0x0122},
100     X11Codepair{0x03ac, 0x0166},
101     X11Codepair{0x03b3, 0x0157},
102     X11Codepair{0x03b5, 0x0129},
103     X11Codepair{0x03b6, 0x013c},
104     X11Codepair{0x03ba, 0x0113},
105     X11Codepair{0x03bb, 0x0123},
106     X11Codepair{0x03bc, 0x0167},
107     X11Codepair{0x03bd, 0x014a},
108     X11Codepair{0x03bf, 0x014b},
109     X11Codepair{0x03c0, 0x0100},
110     X11Codepair{0x03c7, 0x012e},
111     X11Codepair{0x03cc, 0x0116},
112     X11Codepair{0x03cf, 0x012a},
113     X11Codepair{0x03d1, 0x0145},
114     X11Codepair{0x03d2, 0x014c},
115     X11Codepair{0x03d3, 0x0136},
116     X11Codepair{0x03d9, 0x0172},
117     X11Codepair{0x03dd, 0x0168},
118     X11Codepair{0x03de, 0x016a},
119     X11Codepair{0x03e0, 0x0101},
120     X11Codepair{0x03e7, 0x012f},
121     X11Codepair{0x03ec, 0x0117},
122     X11Codepair{0x03ef, 0x012b},
123     X11Codepair{0x03f1, 0x0146},
124     X11Codepair{0x03f2, 0x014d},
125     X11Codepair{0x03f3, 0x0137},
126     X11Codepair{0x03f9, 0x0173},
127     X11Codepair{0x03fd, 0x0169},
128     X11Codepair{0x03fe, 0x016b},
129     X11Codepair{0x047e, 0x203e},
130     X11Codepair{0x04a1, 0x3002},
131     X11Codepair{0x04a2, 0x300c},
132     X11Codepair{0x04a3, 0x300d},
133     X11Codepair{0x04a4, 0x3001},
134     X11Codepair{0x04a5, 0x30fb},
135     X11Codepair{0x04a6, 0x30f2},
136     X11Codepair{0x04a7, 0x30a1},
137     X11Codepair{0x04a8, 0x30a3},
138     X11Codepair{0x04a9, 0x30a5},
139     X11Codepair{0x04aa, 0x30a7},
140     X11Codepair{0x04ab, 0x30a9},
141     X11Codepair{0x04ac, 0x30e3},
142     X11Codepair{0x04ad, 0x30e5},
143     X11Codepair{0x04ae, 0x30e7},
144     X11Codepair{0x04af, 0x30c3},
145     X11Codepair{0x04b0, 0x30fc},
146     X11Codepair{0x04b1, 0x30a2},
147     X11Codepair{0x04b2, 0x30a4},
148     X11Codepair{0x04b3, 0x30a6},
149     X11Codepair{0x04b4, 0x30a8},
150     X11Codepair{0x04b5, 0x30aa},
151     X11Codepair{0x04b6, 0x30ab},
152     X11Codepair{0x04b7, 0x30ad},
153     X11Codepair{0x04b8, 0x30af},
154     X11Codepair{0x04b9, 0x30b1},
155     X11Codepair{0x04ba, 0x30b3},
156     X11Codepair{0x04bb, 0x30b5},
157     X11Codepair{0x04bc, 0x30b7},
158     X11Codepair{0x04bd, 0x30b9},
159     X11Codepair{0x04be, 0x30bb},
160     X11Codepair{0x04bf, 0x30bd},
161     X11Codepair{0x04c0, 0x30bf},
162     X11Codepair{0x04c1, 0x30c1},
163     X11Codepair{0x04c2, 0x30c4},
164     X11Codepair{0x04c3, 0x30c6},
165     X11Codepair{0x04c4, 0x30c8},
166     X11Codepair{0x04c5, 0x30ca},
167     X11Codepair{0x04c6, 0x30cb},
168     X11Codepair{0x04c7, 0x30cc},
169     X11Codepair{0x04c8, 0x30cd},
170     X11Codepair{0x04c9, 0x30ce},
171     X11Codepair{0x04ca, 0x30cf},
172     X11Codepair{0x04cb, 0x30d2},
173     X11Codepair{0x04cc, 0x30d5},
174     X11Codepair{0x04cd, 0x30d8},
175     X11Codepair{0x04ce, 0x30db},
176     X11Codepair{0x04cf, 0x30de},
177     X11Codepair{0x04d0, 0x30df},
178     X11Codepair{0x04d1, 0x30e0},
179     X11Codepair{0x04d2, 0x30e1},
180     X11Codepair{0x04d3, 0x30e2},
181     X11Codepair{0x04d4, 0x30e4},
182     X11Codepair{0x04d5, 0x30e6},
183     X11Codepair{0x04d6, 0x30e8},
184     X11Codepair{0x04d7, 0x30e9},
185     X11Codepair{0x04d8, 0x30ea},
186     X11Codepair{0x04d9, 0x30eb},
187     X11Codepair{0x04da, 0x30ec},
188     X11Codepair{0x04db, 0x30ed},
189     X11Codepair{0x04dc, 0x30ef},
190     X11Codepair{0x04dd, 0x30f3},
191     X11Codepair{0x04de, 0x309b},
192     X11Codepair{0x04df, 0x309c},
193     X11Codepair{0x05ac, 0x060c},
194     X11Codepair{0x05bb, 0x061b},
195     X11Codepair{0x05bf, 0x061f},
196     X11Codepair{0x05c1, 0x0621},
197     X11Codepair{0x05c2, 0x0622},
198     X11Codepair{0x05c3, 0x0623},
199     X11Codepair{0x05c4, 0x0624},
200     X11Codepair{0x05c5, 0x0625},
201     X11Codepair{0x05c6, 0x0626},
202     X11Codepair{0x05c7, 0x0627},
203     X11Codepair{0x05c8, 0x0628},
204     X11Codepair{0x05c9, 0x0629},
205     X11Codepair{0x05ca, 0x062a},
206     X11Codepair{0x05cb, 0x062b},
207     X11Codepair{0x05cc, 0x062c},
208     X11Codepair{0x05cd, 0x062d},
209     X11Codepair{0x05ce, 0x062e},
210     X11Codepair{0x05cf, 0x062f},
211     X11Codepair{0x05d0, 0x0630},
212     X11Codepair{0x05d1, 0x0631},
213     X11Codepair{0x05d2, 0x0632},
214     X11Codepair{0x05d3, 0x0633},
215     X11Codepair{0x05d4, 0x0634},
216     X11Codepair{0x05d5, 0x0635},
217     X11Codepair{0x05d6, 0x0636},
218     X11Codepair{0x05d7, 0x0637},
219     X11Codepair{0x05d8, 0x0638},
220     X11Codepair{0x05d9, 0x0639},
221     X11Codepair{0x05da, 0x063a},
222     X11Codepair{0x05e0, 0x0640},
223     X11Codepair{0x05e1, 0x0641},
224     X11Codepair{0x05e2, 0x0642},
225     X11Codepair{0x05e3, 0x0643},
226     X11Codepair{0x05e4, 0x0644},
227     X11Codepair{0x05e5, 0x0645},
228     X11Codepair{0x05e6, 0x0646},
229     X11Codepair{0x05e7, 0x0647},
230     X11Codepair{0x05e8, 0x0648},
231     X11Codepair{0x05e9, 0x0649},
232     X11Codepair{0x05ea, 0x064a},
233     X11Codepair{0x05eb, 0x064b},
234     X11Codepair{0x05ec, 0x064c},
235     X11Codepair{0x05ed, 0x064d},
236     X11Codepair{0x05ee, 0x064e},
237     X11Codepair{0x05ef, 0x064f},
238     X11Codepair{0x05f0, 0x0650},
239     X11Codepair{0x05f1, 0x0651},
240     X11Codepair{0x05f2, 0x0652},
241     X11Codepair{0x06a1, 0x0452},
242     X11Codepair{0x06a2, 0x0453},
243     X11Codepair{0x06a3, 0x0451},
244     X11Codepair{0x06a4, 0x0454},
245     X11Codepair{0x06a5, 0x0455},
246     X11Codepair{0x06a6, 0x0456},
247     X11Codepair{0x06a7, 0x0457},
248     X11Codepair{0x06a8, 0x0458},
249     X11Codepair{0x06a9, 0x0459},
250     X11Codepair{0x06aa, 0x045a},
251     X11Codepair{0x06ab, 0x045b},
252     X11Codepair{0x06ac, 0x045c},
253     X11Codepair{0x06ae, 0x045e},
254     X11Codepair{0x06af, 0x045f},
255     X11Codepair{0x06b0, 0x2116},
256     X11Codepair{0x06b1, 0x0402},
257     X11Codepair{0x06b2, 0x0403},
258     X11Codepair{0x06b3, 0x0401},
259     X11Codepair{0x06b4, 0x0404},
260     X11Codepair{0x06b5, 0x0405},
261     X11Codepair{0x06b6, 0x0406},
262     X11Codepair{0x06b7, 0x0407},
263     X11Codepair{0x06b8, 0x0408},
264     X11Codepair{0x06b9, 0x0409},
265     X11Codepair{0x06ba, 0x040a},
266     X11Codepair{0x06bb, 0x040b},
267     X11Codepair{0x06bc, 0x040c},
268     X11Codepair{0x06be, 0x040e},
269     X11Codepair{0x06bf, 0x040f},
270     X11Codepair{0x06c0, 0x044e},
271     X11Codepair{0x06c1, 0x0430},
272     X11Codepair{0x06c2, 0x0431},
273     X11Codepair{0x06c3, 0x0446},
274     X11Codepair{0x06c4, 0x0434},
275     X11Codepair{0x06c5, 0x0435},
276     X11Codepair{0x06c6, 0x0444},
277     X11Codepair{0x06c7, 0x0433},
278     X11Codepair{0x06c8, 0x0445},
279     X11Codepair{0x06c9, 0x0438},
280     X11Codepair{0x06ca, 0x0439},
281     X11Codepair{0x06cb, 0x043a},
282     X11Codepair{0x06cc, 0x043b},
283     X11Codepair{0x06cd, 0x043c},
284     X11Codepair{0x06ce, 0x043d},
285     X11Codepair{0x06cf, 0x043e},
286     X11Codepair{0x06d0, 0x043f},
287     X11Codepair{0x06d1, 0x044f},
288     X11Codepair{0x06d2, 0x0440},
289     X11Codepair{0x06d3, 0x0441},
290     X11Codepair{0x06d4, 0x0442},
291     X11Codepair{0x06d5, 0x0443},
292     X11Codepair{0x06d6, 0x0436},
293     X11Codepair{0x06d7, 0x0432},
294     X11Codepair{0x06d8, 0x044c},
295     X11Codepair{0x06d9, 0x044b},
296     X11Codepair{0x06da, 0x0437},
297     X11Codepair{0x06db, 0x0448},
298     X11Codepair{0x06dc, 0x044d},
299     X11Codepair{0x06dd, 0x0449},
300     X11Codepair{0x06de, 0x0447},
301     X11Codepair{0x06df, 0x044a},
302     X11Codepair{0x06e0, 0x042e},
303     X11Codepair{0x06e1, 0x0410},
304     X11Codepair{0x06e2, 0x0411},
305     X11Codepair{0x06e3, 0x0426},
306     X11Codepair{0x06e4, 0x0414},
307     X11Codepair{0x06e5, 0x0415},
308     X11Codepair{0x06e6, 0x0424},
309     X11Codepair{0x06e7, 0x0413},
310     X11Codepair{0x06e8, 0x0425},
311     X11Codepair{0x06e9, 0x0418},
312     X11Codepair{0x06ea, 0x0419},
313     X11Codepair{0x06eb, 0x041a},
314     X11Codepair{0x06ec, 0x041b},
315     X11Codepair{0x06ed, 0x041c},
316     X11Codepair{0x06ee, 0x041d},
317     X11Codepair{0x06ef, 0x041e},
318     X11Codepair{0x06f0, 0x041f},
319     X11Codepair{0x06f1, 0x042f},
320     X11Codepair{0x06f2, 0x0420},
321     X11Codepair{0x06f3, 0x0421},
322     X11Codepair{0x06f4, 0x0422},
323     X11Codepair{0x06f5, 0x0423},
324     X11Codepair{0x06f6, 0x0416},
325     X11Codepair{0x06f7, 0x0412},
326     X11Codepair{0x06f8, 0x042c},
327     X11Codepair{0x06f9, 0x042b},
328     X11Codepair{0x06fa, 0x0417},
329     X11Codepair{0x06fb, 0x0428},
330     X11Codepair{0x06fc, 0x042d},
331     X11Codepair{0x06fd, 0x0429},
332     X11Codepair{0x06fe, 0x0427},
333     X11Codepair{0x06ff, 0x042a},
334     X11Codepair{0x07a1, 0x0386},
335     X11Codepair{0x07a2, 0x0388},
336     X11Codepair{0x07a3, 0x0389},
337     X11Codepair{0x07a4, 0x038a},
338     X11Codepair{0x07a5, 0x03aa},
339     X11Codepair{0x07a7, 0x038c},
340     X11Codepair{0x07a8, 0x038e},
341     X11Codepair{0x07a9, 0x03ab},
342     X11Codepair{0x07ab, 0x038f},
343     X11Codepair{0x07ae, 0x0385},
344     X11Codepair{0x07af, 0x2015},
345     X11Codepair{0x07b1, 0x03ac},
346     X11Codepair{0x07b2, 0x03ad},
347     X11Codepair{0x07b3, 0x03ae},
348     X11Codepair{0x07b4, 0x03af},
349     X11Codepair{0x07b5, 0x03ca},
350     X11Codepair{0x07b6, 0x0390},
351     X11Codepair{0x07b7, 0x03cc},
352     X11Codepair{0x07b8, 0x03cd},
353     X11Codepair{0x07b9, 0x03cb},
354     X11Codepair{0x07ba, 0x03b0},
355     X11Codepair{0x07bb, 0x03ce},
356     X11Codepair{0x07c1, 0x0391},
357     X11Codepair{0x07c2, 0x0392},
358     X11Codepair{0x07c3, 0x0393},
359     X11Codepair{0x07c4, 0x0394},
360     X11Codepair{0x07c5, 0x0395},
361     X11Codepair{0x07c6, 0x0396},
362     X11Codepair{0x07c7, 0x0397},
363     X11Codepair{0x07c8, 0x0398},
364     X11Codepair{0x07c9, 0x0399},
365     X11Codepair{0x07ca, 0x039a},
366     X11Codepair{0x07cb, 0x039b},
367     X11Codepair{0x07cc, 0x039c},
368     X11Codepair{0x07cd, 0x039d},
369     X11Codepair{0x07ce, 0x039e},
370     X11Codepair{0x07cf, 0x039f},
371     X11Codepair{0x07d0, 0x03a0},
372     X11Codepair{0x07d1, 0x03a1},
373     X11Codepair{0x07d2, 0x03a3},
374     X11Codepair{0x07d4, 0x03a4},
375     X11Codepair{0x07d5, 0x03a5},
376     X11Codepair{0x07d6, 0x03a6},
377     X11Codepair{0x07d7, 0x03a7},
378     X11Codepair{0x07d8, 0x03a8},
379     X11Codepair{0x07d9, 0x03a9},
380     X11Codepair{0x07e1, 0x03b1},
381     X11Codepair{0x07e2, 0x03b2},
382     X11Codepair{0x07e3, 0x03b3},
383     X11Codepair{0x07e4, 0x03b4},
384     X11Codepair{0x07e5, 0x03b5},
385     X11Codepair{0x07e6, 0x03b6},
386     X11Codepair{0x07e7, 0x03b7},
387     X11Codepair{0x07e8, 0x03b8},
388     X11Codepair{0x07e9, 0x03b9},
389     X11Codepair{0x07ea, 0x03ba},
390     X11Codepair{0x07eb, 0x03bb},
391     X11Codepair{0x07ec, 0x03bc},
392     X11Codepair{0x07ed, 0x03bd},
393     X11Codepair{0x07ee, 0x03be},
394     X11Codepair{0x07ef, 0x03bf},
395     X11Codepair{0x07f0, 0x03c0},
396     X11Codepair{0x07f1, 0x03c1},
397     X11Codepair{0x07f2, 0x03c3},
398     X11Codepair{0x07f3, 0x03c2},
399     X11Codepair{0x07f4, 0x03c4},
400     X11Codepair{0x07f5, 0x03c5},
401     X11Codepair{0x07f6, 0x03c6},
402     X11Codepair{0x07f7, 0x03c7},
403     X11Codepair{0x07f8, 0x03c8},
404     X11Codepair{0x07f9, 0x03c9},
405     X11Codepair{0x0cdf, 0x2017},
406     X11Codepair{0x0ce0, 0x05d0},
407     X11Codepair{0x0ce1, 0x05d1},
408     X11Codepair{0x0ce2, 0x05d2},
409     X11Codepair{0x0ce3, 0x05d3},
410     X11Codepair{0x0ce4, 0x05d4},
411     X11Codepair{0x0ce5, 0x05d5},
412     X11Codepair{0x0ce6, 0x05d6},
413     X11Codepair{0x0ce7, 0x05d7},
414     X11Codepair{0x0ce8, 0x05d8},
415     X11Codepair{0x0ce9, 0x05d9},
416     X11Codepair{0x0cea, 0x05da},
417     X11Codepair{0x0ceb, 0x05db},
418     X11Codepair{0x0cec, 0x05dc},
419     X11Codepair{0x0ced, 0x05dd},
420     X11Codepair{0x0cee, 0x05de},
421     X11Codepair{0x0cef, 0x05df},
422     X11Codepair{0x0cf0, 0x05e0},
423     X11Codepair{0x0cf1, 0x05e1},
424     X11Codepair{0x0cf2, 0x05e2},
425     X11Codepair{0x0cf3, 0x05e3},
426     X11Codepair{0x0cf4, 0x05e4},
427     X11Codepair{0x0cf5, 0x05e5},
428     X11Codepair{0x0cf6, 0x05e6},
429     X11Codepair{0x0cf7, 0x05e7},
430     X11Codepair{0x0cf8, 0x05e8},
431     X11Codepair{0x0cf9, 0x05e9},
432     X11Codepair{0x0cfa, 0x05ea},
433     X11Codepair{0x13a4, 0x20ac},
434     X11Codepair{0x13bc, 0x0152},
435     X11Codepair{0x13bd, 0x0153},
436     X11Codepair{0x13be, 0x0178},
437     X11Codepair{0x20ac, 0x20ac},
438     X11Codepair{0xfe50, 0x0060},
439     X11Codepair{0xfe51, 0x00b4},
440     X11Codepair{0xfe52, 0x005e},
441     X11Codepair{0xfe53, 0x007e},
442     X11Codepair{0xfe54, 0x00af},
443     X11Codepair{0xfe55, 0x02d8},
444     X11Codepair{0xfe56, 0x02d9},
445     X11Codepair{0xfe57, 0x00a8},
446     X11Codepair{0xfe58, 0x02da},
447     X11Codepair{0xfe59, 0x02dd},
448     X11Codepair{0xfe5a, 0x02c7},
449     X11Codepair{0xfe5b, 0x00b8},
450     X11Codepair{0xfe5c, 0x02db},
451     X11Codepair{0xfe5d, 0x037a},
452     X11Codepair{0xfe5e, 0x309b},
453     X11Codepair{0xfe5f, 0x309c},
454     X11Codepair{0xfe63, 0x002f},
455     X11Codepair{0xfe64, 0x02bc},
456     X11Codepair{0xfe65, 0x02bd},
457     X11Codepair{0xfe66, 0x02f5},
458     X11Codepair{0xfe67, 0x02f3},
459     X11Codepair{0xfe68, 0x02cd},
460     X11Codepair{0xfe69, 0xa788},
461     X11Codepair{0xfe6a, 0x02f7},
462     X11Codepair{0xfe6e, 0x002c},
463     X11Codepair{0xfe6f, 0x00a4},
464     X11Codepair{0xfe80, 0x0061},
465     X11Codepair{0xfe81, 0x0041},
466     X11Codepair{0xfe82, 0x0065},
467     X11Codepair{0xfe83, 0x0045},
468     X11Codepair{0xfe84, 0x0069},
469     X11Codepair{0xfe85, 0x0049},
470     X11Codepair{0xfe86, 0x006f},
471     X11Codepair{0xfe87, 0x004f},
472     X11Codepair{0xfe88, 0x0075},
473     X11Codepair{0xfe89, 0x0055},
474     X11Codepair{0xfe8a, 0x0259},
475     X11Codepair{0xfe8b, 0x018f},
476     X11Codepair{0xfe8c, 0x00b5},
477     X11Codepair{0xfe90, 0x005f},
478     X11Codepair{0xfe91, 0x02c8},
479     X11Codepair{0xfe92, 0x02cc},
480     X11Codepair{0xff80, 0x0020},
481     X11Codepair{0xff95, 0x0037},
482     X11Codepair{0xff96, 0x0034},
483     X11Codepair{0xff97, 0x0038},
484     X11Codepair{0xff98, 0x0036},
485     X11Codepair{0xff99, 0x0032},
486     X11Codepair{0xff9a, 0x0039},
487     X11Codepair{0xff9b, 0x0033},
488     X11Codepair{0xff9c, 0x0031},
489     X11Codepair{0xff9d, 0x0035},
490     X11Codepair{0xff9e, 0x0030},
491     X11Codepair{0xffaa, 0x002a},
492     X11Codepair{0xffab, 0x002b},
493     X11Codepair{0xffac, 0x002c},
494     X11Codepair{0xffad, 0x002d},
495     X11Codepair{0xffae, 0x002e},
496     X11Codepair{0xffaf, 0x002f},
497     X11Codepair{0xffb0, 0x0030},
498     X11Codepair{0xffb1, 0x0031},
499     X11Codepair{0xffb2, 0x0032},
500     X11Codepair{0xffb3, 0x0033},
501     X11Codepair{0xffb4, 0x0034},
502     X11Codepair{0xffb5, 0x0035},
503     X11Codepair{0xffb6, 0x0036},
504     X11Codepair{0xffb7, 0x0037},
505     X11Codepair{0xffb8, 0x0038},
506     X11Codepair{0xffb9, 0x0039},
507     X11Codepair{0xffbd, 0x003d},
508 ]!
509 
510 // === Error handling ===
511 
512 fn x11_grab_error_handler() {
513     g_sapp_state.x11.error_code = 0 // Success
514     C.XSetErrorHandler(voidptr(x11_error_handler))
515 }
516 
517 fn x11_release_error_handler() {
518     C.XSync(g_sapp_state.x11.display, x_false)
519     C.XSetErrorHandler(unsafe { nil })
520 }
521 
522 fn x11_error_handler(_display &C.Display, _event voidptr) int {
523     // XErrorEvent.error_code is at a known offset
524     // For simplicity, just set a non-zero error code
525     g_sapp_state.x11.error_code = 1
526     return 0
527 }
528 
529 // === Atom initialization ===
530 
531 fn x11_init_extensions() {
532     d := g_sapp_state.x11.display
533     g_sapp_state.x11.utf8_string = C.XInternAtom(d, c'UTF8_STRING', x_false)
534     g_sapp_state.x11.wm_protocols = C.XInternAtom(d, c'WM_PROTOCOLS', x_false)
535     g_sapp_state.x11.wm_delete_window = C.XInternAtom(d, c'WM_DELETE_WINDOW', x_false)
536     g_sapp_state.x11.wm_state = C.XInternAtom(d, c'WM_STATE', x_false)
537     g_sapp_state.x11.net_wm_name = C.XInternAtom(d, c'_NET_WM_NAME', x_false)
538     g_sapp_state.x11.net_wm_icon_name = C.XInternAtom(d, c'_NET_WM_ICON_NAME', x_false)
539     g_sapp_state.x11.net_wm_icon = C.XInternAtom(d, c'_NET_WM_ICON', x_false)
540     g_sapp_state.x11.net_wm_state = C.XInternAtom(d, c'_NET_WM_STATE', x_false)
541     g_sapp_state.x11.net_wm_state_fullscreen = C.XInternAtom(d, c'_NET_WM_STATE_FULLSCREEN',
542         x_false)
543     g_sapp_state.x11.clipboard_atom = C.XInternAtom(d, c'CLIPBOARD', x_false)
544     g_sapp_state.x11.targets = C.XInternAtom(d, c'TARGETS', x_false)
545     if g_sapp_state.drop.enabled {
546         g_sapp_state.x11.xdnd.xdnd_aware = C.XInternAtom(d, c'XdndAware', x_false)
547         g_sapp_state.x11.xdnd.xdnd_enter = C.XInternAtom(d, c'XdndEnter', x_false)
548         g_sapp_state.x11.xdnd.xdnd_position = C.XInternAtom(d, c'XdndPosition', x_false)
549         g_sapp_state.x11.xdnd.xdnd_status = C.XInternAtom(d, c'XdndStatus', x_false)
550         g_sapp_state.x11.xdnd.xdnd_action_copy = C.XInternAtom(d, c'XdndActionCopy', x_false)
551         g_sapp_state.x11.xdnd.xdnd_drop = C.XInternAtom(d, c'XdndDrop', x_false)
552         g_sapp_state.x11.xdnd.xdnd_finished = C.XInternAtom(d, c'XdndFinished', x_false)
553         g_sapp_state.x11.xdnd.xdnd_selection = C.XInternAtom(d, c'XdndSelection', x_false)
554         g_sapp_state.x11.xdnd.xdnd_type_list = C.XInternAtom(d, c'XdndTypeList', x_false)
555         g_sapp_state.x11.xdnd.text_uri_list = C.XInternAtom(d, c'text/uri-list', x_false)
556     }
557     // Check Xi extension for raw mouse input
558     if C.XQueryExtension(d, c'XInputExtension', &g_sapp_state.x11.xi.major_opcode,
559         &g_sapp_state.x11.xi.event_base, &g_sapp_state.x11.xi.error_base) != 0 {
560         g_sapp_state.x11.xi.major = 2
561         g_sapp_state.x11.xi.minor = 0
562         if C.XIQueryVersion(d, &g_sapp_state.x11.xi.major, &g_sapp_state.x11.xi.minor) == 0 {
563             g_sapp_state.x11.xi.available = true
564         }
565     }
566 }
567 
568 // === Key translation ===
569 
570 fn x11_translate_keysyms(keysyms &KeySym, width int) KeyCode {
571     if width > 1 {
572         unsafe {
573             match keysyms[1] {
574                 xk_kp_0 { return .kp_0 }
575                 xk_kp_1 { return .kp_1 }
576                 xk_kp_2 { return .kp_2 }
577                 xk_kp_3 { return .kp_3 }
578                 xk_kp_4 { return .kp_4 }
579                 xk_kp_5 { return .kp_5 }
580                 xk_kp_6 { return .kp_6 }
581                 xk_kp_7 { return .kp_7 }
582                 xk_kp_8 { return .kp_8 }
583                 xk_kp_9 { return .kp_9 }
584                 xk_kp_separator, xk_kp_decimal { return .kp_decimal }
585                 xk_kp_equal { return .kp_equal }
586                 xk_kp_enter { return .kp_enter }
587                 else {}
588             }
589         }
590     }
591     unsafe {
592         return match keysyms[0] {
593             xk_escape { KeyCode.escape }
594             xk_tab { KeyCode.tab }
595             xk_shift_l { KeyCode.left_shift }
596             xk_shift_r { KeyCode.right_shift }
597             xk_control_l { KeyCode.left_control }
598             xk_control_r { KeyCode.right_control }
599             xk_meta_l, xk_alt_l { KeyCode.left_alt }
600             xk_mode_switch, xk_iso_level3_shift, xk_meta_r, xk_alt_r { KeyCode.right_alt }
601             xk_super_l { KeyCode.left_super }
602             xk_super_r { KeyCode.right_super }
603             xk_menu { KeyCode.menu }
604             xk_num_lock { KeyCode.num_lock }
605             xk_caps_lock { KeyCode.caps_lock }
606             xk_print { KeyCode.print_screen }
607             xk_scroll_lock { KeyCode.scroll_lock }
608             xk_pause { KeyCode.pause }
609             xk_delete { KeyCode.delete }
610             xk_backspace { KeyCode.backspace }
611             xk_return { KeyCode.enter }
612             xk_home { KeyCode.home }
613             xk_end { KeyCode.end }
614             xk_page_up { KeyCode.page_up }
615             xk_page_down { KeyCode.page_down }
616             xk_insert { KeyCode.insert }
617             xk_left { KeyCode.left }
618             xk_right { KeyCode.right }
619             xk_down { KeyCode.down }
620             xk_up { KeyCode.up }
621             xk_f1 { KeyCode.f1 }
622             xk_f2 { KeyCode.f2 }
623             xk_f3 { KeyCode.f3 }
624             xk_f4 { KeyCode.f4 }
625             xk_f5 { KeyCode.f5 }
626             xk_f6 { KeyCode.f6 }
627             xk_f7 { KeyCode.f7 }
628             xk_f8 { KeyCode.f8 }
629             xk_f9 { KeyCode.f9 }
630             xk_f10 { KeyCode.f10 }
631             xk_f11 { KeyCode.f11 }
632             xk_f12 { KeyCode.f12 }
633             xk_f13 { KeyCode.f13 }
634             xk_f14 { KeyCode.f14 }
635             xk_f15 { KeyCode.f15 }
636             xk_f16 { KeyCode.f16 }
637             xk_f17 { KeyCode.f17 }
638             xk_f18 { KeyCode.f18 }
639             xk_f19 { KeyCode.f19 }
640             xk_f20 { KeyCode.f20 }
641             xk_f21 { KeyCode.f21 }
642             xk_f22 { KeyCode.f22 }
643             xk_f23 { KeyCode.f23 }
644             xk_f24 { KeyCode.f24 }
645             xk_f25 { KeyCode.f25 }
646             xk_kp_divide { KeyCode.kp_divide }
647             xk_kp_multiply { KeyCode.kp_multiply }
648             xk_kp_subtract { KeyCode.kp_subtract }
649             xk_kp_add { KeyCode.kp_add }
650             xk_kp_insert { KeyCode.kp_0 }
651             xk_kp_end { KeyCode.kp_1 }
652             xk_kp_down { KeyCode.kp_2 }
653             xk_kp_page_down { KeyCode.kp_3 }
654             xk_kp_left { KeyCode.kp_4 }
655             xk_kp_right { KeyCode.kp_6 }
656             xk_kp_home { KeyCode.kp_7 }
657             xk_kp_up { KeyCode.kp_8 }
658             xk_kp_page_up { KeyCode.kp_9 }
659             xk_kp_delete { KeyCode.kp_decimal }
660             xk_kp_equal { KeyCode.kp_equal }
661             xk_kp_enter { KeyCode.kp_enter }
662             xk_a { KeyCode.a }
663             xk_b { KeyCode.b }
664             xk_c { KeyCode.c }
665             xk_d { KeyCode.d }
666             xk_e { KeyCode.e }
667             xk_f { KeyCode.f }
668             xk_g { KeyCode.g }
669             xk_h { KeyCode.h }
670             xk_i { KeyCode.i }
671             xk_j { KeyCode.j }
672             xk_k { KeyCode.k }
673             xk_l { KeyCode.l }
674             xk_m { KeyCode.m }
675             xk_n { KeyCode.n }
676             xk_o { KeyCode.o }
677             xk_p { KeyCode.p }
678             xk_q { KeyCode.q }
679             xk_r { KeyCode.r }
680             xk_s { KeyCode.s }
681             xk_t { KeyCode.t }
682             xk_u { KeyCode.u }
683             xk_v { KeyCode.v }
684             xk_w { KeyCode.w }
685             xk_x { KeyCode.x }
686             xk_y { KeyCode.y }
687             xk_z { KeyCode.z }
688             xk_1 { KeyCode._1 }
689             xk_2 { KeyCode._2 }
690             xk_3 { KeyCode._3 }
691             xk_4 { KeyCode._4 }
692             xk_5 { KeyCode._5 }
693             xk_6 { KeyCode._6 }
694             xk_7 { KeyCode._7 }
695             xk_8 { KeyCode._8 }
696             xk_9 { KeyCode._9 }
697             xk_0 { KeyCode._0 }
698             xk_space { KeyCode.space }
699             xk_minus { KeyCode.minus }
700             xk_equal { KeyCode.equal }
701             xk_bracketleft { KeyCode.left_bracket }
702             xk_bracketright { KeyCode.right_bracket }
703             xk_backslash { KeyCode.backslash }
704             xk_semicolon { KeyCode.semicolon }
705             xk_apostrophe { KeyCode.apostrophe }
706             xk_grave { KeyCode.grave_accent }
707             xk_comma { KeyCode.comma }
708             xk_period { KeyCode.period }
709             xk_slash { KeyCode.slash }
710             xk_less { KeyCode.world_1 }
711             else { KeyCode.invalid }
712         }
713     }
714 }
715 
716 fn x11_lookup_keysym(event &C.XEvent) KeySym {
717     mut keysym := KeySym(0)
718     unsafe {
719         C.XLookupString(&event.xkey, nil, 0, &keysym, nil)
720     }
721     return keysym
722 }
723 
724 fn x11_translate_event_key(scancode int, keysym KeySym) KeyCode {
725     key := linux_translate_navigation_or_keypad_keysym(u32(keysym))
726     if key != .invalid {
727         return key
728     }
729     return x11_translate_key(scancode)
730 }
731 
732 // XKB key name to keycode mapping entry
733 struct X11KeymapEntry {
734 mut:
735     key  KeyCode
736     name [4]u8
737 }
738 
739 fn make_keymap_entry(key KeyCode, name string) X11KeymapEntry {
740     mut e := X11KeymapEntry{
741         key: key
742     }
743     for i := 0; i < 4 && i < name.len; i++ {
744         unsafe {
745             e.name[i] = name[i]
746         }
747     }
748     return e
749 }
750 
751 fn x11_init_keytable() {
752     for i in 0 .. max_keycodes {
753         g_sapp_state.keycodes[i] = .invalid
754     }
755     // Use XKB to determine physical key locations
756     desc := C.XkbGetMap(g_sapp_state.x11.display, 0, xkb_use_core_kbd)
757     if desc == unsafe { nil } {
758         return
759     }
760     C.XkbGetNames(g_sapp_state.x11.display, xkb_key_names_mask | xkb_key_aliases_mask, desc)
761 
762     scancode_min := int(desc.min_key_code)
763     scancode_max := int(desc.max_key_code)
764 
765     keymap := [
766         make_keymap_entry(.grave_accent, 'TLDE'),
767         make_keymap_entry(._1, 'AE01'),
768         make_keymap_entry(._2, 'AE02'),
769         make_keymap_entry(._3, 'AE03'),
770         make_keymap_entry(._4, 'AE04'),
771         make_keymap_entry(._5, 'AE05'),
772         make_keymap_entry(._6, 'AE06'),
773         make_keymap_entry(._7, 'AE07'),
774         make_keymap_entry(._8, 'AE08'),
775         make_keymap_entry(._9, 'AE09'),
776         make_keymap_entry(._0, 'AE10'),
777         make_keymap_entry(.minus, 'AE11'),
778         make_keymap_entry(.equal, 'AE12'),
779         make_keymap_entry(.q, 'AD01'),
780         make_keymap_entry(.w, 'AD02'),
781         make_keymap_entry(.e, 'AD03'),
782         make_keymap_entry(.r, 'AD04'),
783         make_keymap_entry(.t, 'AD05'),
784         make_keymap_entry(.y, 'AD06'),
785         make_keymap_entry(.u, 'AD07'),
786         make_keymap_entry(.i, 'AD08'),
787         make_keymap_entry(.o, 'AD09'),
788         make_keymap_entry(.p, 'AD10'),
789         make_keymap_entry(.left_bracket, 'AD11'),
790         make_keymap_entry(.right_bracket, 'AD12'),
791         make_keymap_entry(.a, 'AC01'),
792         make_keymap_entry(.s, 'AC02'),
793         make_keymap_entry(.d, 'AC03'),
794         make_keymap_entry(.f, 'AC04'),
795         make_keymap_entry(.g, 'AC05'),
796         make_keymap_entry(.h, 'AC06'),
797         make_keymap_entry(.j, 'AC07'),
798         make_keymap_entry(.k, 'AC08'),
799         make_keymap_entry(.l, 'AC09'),
800         make_keymap_entry(.semicolon, 'AC10'),
801         make_keymap_entry(.apostrophe, 'AC11'),
802         make_keymap_entry(.z, 'AB01'),
803         make_keymap_entry(.x, 'AB02'),
804         make_keymap_entry(.c, 'AB03'),
805         make_keymap_entry(.v, 'AB04'),
806         make_keymap_entry(.b, 'AB05'),
807         make_keymap_entry(.n, 'AB06'),
808         make_keymap_entry(.m, 'AB07'),
809         make_keymap_entry(.comma, 'AB08'),
810         make_keymap_entry(.period, 'AB09'),
811         make_keymap_entry(.slash, 'AB10'),
812         make_keymap_entry(.backslash, 'BKSL'),
813         make_keymap_entry(.world_1, 'LSGT'),
814         make_keymap_entry(.space, 'SPCE'),
815         make_keymap_entry(.escape, 'ESC\x00'),
816         make_keymap_entry(.enter, 'RTRN'),
817         make_keymap_entry(.tab, 'TAB\x00'),
818         make_keymap_entry(.backspace, 'BKSP'),
819         make_keymap_entry(.insert, 'INS\x00'),
820         make_keymap_entry(.delete, 'DELE'),
821         make_keymap_entry(.right, 'RGHT'),
822         make_keymap_entry(.left, 'LEFT'),
823         make_keymap_entry(.down, 'DOWN'),
824         make_keymap_entry(.up, 'UP\x00\x00'),
825         make_keymap_entry(.page_up, 'PGUP'),
826         make_keymap_entry(.page_down, 'PGDN'),
827         make_keymap_entry(.home, 'HOME'),
828         make_keymap_entry(.end, 'END\x00'),
829         make_keymap_entry(.caps_lock, 'CAPS'),
830         make_keymap_entry(.scroll_lock, 'SCLK'),
831         make_keymap_entry(.num_lock, 'NMLK'),
832         make_keymap_entry(.print_screen, 'PRSC'),
833         make_keymap_entry(.pause, 'PAUS'),
834         make_keymap_entry(.f1, 'FK01'),
835         make_keymap_entry(.f2, 'FK02'),
836         make_keymap_entry(.f3, 'FK03'),
837         make_keymap_entry(.f4, 'FK04'),
838         make_keymap_entry(.f5, 'FK05'),
839         make_keymap_entry(.f6, 'FK06'),
840         make_keymap_entry(.f7, 'FK07'),
841         make_keymap_entry(.f8, 'FK08'),
842         make_keymap_entry(.f9, 'FK09'),
843         make_keymap_entry(.f10, 'FK10'),
844         make_keymap_entry(.f11, 'FK11'),
845         make_keymap_entry(.f12, 'FK12'),
846         make_keymap_entry(.f13, 'FK13'),
847         make_keymap_entry(.f14, 'FK14'),
848         make_keymap_entry(.f15, 'FK15'),
849         make_keymap_entry(.f16, 'FK16'),
850         make_keymap_entry(.f17, 'FK17'),
851         make_keymap_entry(.f18, 'FK18'),
852         make_keymap_entry(.f19, 'FK19'),
853         make_keymap_entry(.f20, 'FK20'),
854         make_keymap_entry(.f21, 'FK21'),
855         make_keymap_entry(.f22, 'FK22'),
856         make_keymap_entry(.f23, 'FK23'),
857         make_keymap_entry(.f24, 'FK24'),
858         make_keymap_entry(.f25, 'FK25'),
859         make_keymap_entry(.kp_0, 'KP0\x00'),
860         make_keymap_entry(.kp_1, 'KP1\x00'),
861         make_keymap_entry(.kp_2, 'KP2\x00'),
862         make_keymap_entry(.kp_3, 'KP3\x00'),
863         make_keymap_entry(.kp_4, 'KP4\x00'),
864         make_keymap_entry(.kp_5, 'KP5\x00'),
865         make_keymap_entry(.kp_6, 'KP6\x00'),
866         make_keymap_entry(.kp_7, 'KP7\x00'),
867         make_keymap_entry(.kp_8, 'KP8\x00'),
868         make_keymap_entry(.kp_9, 'KP9\x00'),
869         make_keymap_entry(.kp_decimal, 'KPDL'),
870         make_keymap_entry(.kp_divide, 'KPDV'),
871         make_keymap_entry(.kp_multiply, 'KPMU'),
872         make_keymap_entry(.kp_subtract, 'KPSU'),
873         make_keymap_entry(.kp_add, 'KPAD'),
874         make_keymap_entry(.kp_enter, 'KPEN'),
875         make_keymap_entry(.kp_equal, 'KPEQ'),
876         make_keymap_entry(.left_shift, 'LFSH'),
877         make_keymap_entry(.left_control, 'LCTL'),
878         make_keymap_entry(.left_alt, 'LALT'),
879         make_keymap_entry(.left_super, 'LWIN'),
880         make_keymap_entry(.right_shift, 'RTSH'),
881         make_keymap_entry(.right_control, 'RCTL'),
882         make_keymap_entry(.right_alt, 'RALT'),
883         make_keymap_entry(.right_alt, 'LVL3'),
884         make_keymap_entry(.right_alt, 'MDSW'),
885         make_keymap_entry(.right_super, 'RWIN'),
886         make_keymap_entry(.menu, 'MENU'),
887     ]
888 
889     // Find X11 keycode to sokol-app key code mapping
890     for scancode in scancode_min .. scancode_max + 1 {
891         mut key := KeyCode.invalid
892         for km in keymap {
893             if unsafe {
894                 C.strncmp(&char(&desc.names.keys[scancode].name[0]), &char(&km.name[0]),
895                     usize(xkb_key_name_length))
896             } == 0 {
897                 key = km.key
898                 break
899             }
900         }
901         // Fall back to key aliases
902         if key == .invalid && desc.names.key_aliases != unsafe { nil } {
903             for i in 0 .. int(desc.names.num_key_aliases) {
904                 if unsafe {
905                     C.strncmp(&char(&desc.names.key_aliases[i].real[0]),
906                         &char(&desc.names.keys[scancode].name[0]), usize(xkb_key_name_length))
907                 } != 0 {
908                     continue
909                 }
910                 for km in keymap {
911                     if unsafe {
912                         C.strncmp(&char(&desc.names.key_aliases[i].alias[0]), &char(&km.name[0]),
913                             usize(xkb_key_name_length))
914                     } == 0 {
915                         key = km.key
916                         break
917                     }
918                 }
919                 if key != .invalid {
920                     break
921                 }
922             }
923         }
924         g_sapp_state.keycodes[scancode] = key
925     }
926     C.XkbFreeNames(desc, xkb_key_names_mask, x_true)
927     C.XkbFreeKeyboard(desc, 0, x_true)
928 
929     // Fall back using traditional keysym lookup
930     mut width := 0
931     keysyms := C.XGetKeyboardMapping(g_sapp_state.x11.display, u8(scancode_min), scancode_max -
932         scancode_min + 1, &width)
933     for scancode in scancode_min .. scancode_max + 1 {
934         if g_sapp_state.keycodes[scancode] == .invalid {
935             base := usize((scancode - scancode_min) * width)
936             g_sapp_state.keycodes[scancode] = x11_translate_keysyms(unsafe { keysyms + base },
937                 width)
938         }
939     }
940     C.XFree(keysyms)
941 }
942 
943 // === DPI ===
944 
945 fn x11_query_system_dpi() {
946     mut dpi_ok := false
947     rms := C.XResourceManagerString(g_sapp_state.x11.display)
948     if rms != unsafe { nil } {
949         db := C.XrmGetStringDatabase(rms)
950         if db != unsafe { nil } {
951             mut value := C.XrmValue{}
952             mut @type := &char(unsafe { nil })
953             if C.XrmGetResource(db, c'Xft.dpi', c'Xft.Dpi', &@type, &value) != 0 {
954                 if @type != unsafe { nil } && C.strcmp(@type, c'String') == 0 {
955                     g_sapp_state.x11.dpi = f32(C.atof(value.addr))
956                     dpi_ok = true
957                 }
958             }
959             C.XrmDestroyDatabase(db)
960         }
961     }
962     if !dpi_ok {
963         g_sapp_state.x11.dpi = 96.0
964     }
965 }
966 
967 // === Keysym to unicode ===
968 
969 fn x11_keysym_to_unicode(keysym KeySym) i32 {
970     // Latin-1 characters (1:1 mapping)
971     if (keysym >= 0x0020 && keysym <= 0x007e) || (keysym >= 0x00a0 && keysym <= 0x00ff) {
972         return i32(keysym)
973     }
974     // Directly encoded 24-bit UCS characters
975     if (keysym & 0xff000000) == 0x01000000 {
976         return i32(keysym & 0x00ffffff)
977     }
978     // Binary search in table
979     mut min := 0
980     mut max := x11_keysymtab.len - 1
981     for max >= min {
982         mid := (min + max) / 2
983         if u64(x11_keysymtab[mid].keysym) < keysym {
984             min = mid + 1
985         } else if u64(x11_keysymtab[mid].keysym) > keysym {
986             max = mid - 1
987         } else {
988             return i32(x11_keysymtab[mid].ucs)
989         }
990     }
991     return -1
992 }
993 
994 // === Window management ===
995 
996 fn x11_send_event(msg_type Atom, a i64, b i64, c_ i64, d i64, e i64) {
997     mut event := C.XEvent{}
998     unsafe {
999         event.@type = x_client_message
1000         event.xclient.window = g_sapp_state.x11.window
1001         event.xclient.format = 32
1002         event.xclient.message_type = msg_type
1003         event.xclient.data.l[0] = a
1004         event.xclient.data.l[1] = b
1005         event.xclient.data.l[2] = c_
1006         event.xclient.data.l[3] = d
1007         event.xclient.data.l[4] = e
1008     }
1009     C.XSendEvent(g_sapp_state.x11.display, g_sapp_state.x11.root, x_false,
1010         substructure_notify_mask | substructure_redirect_mask, &event)
1011 }
1012 
1013 fn x11_wait_for_event(event_type int, timeout_sec f64, out_event &C.XEvent) bool {
1014     // Simple polling loop
1015     for {
1016         if C.XCheckTypedWindowEvent(g_sapp_state.x11.display, g_sapp_state.x11.window, event_type,
1017             out_event) != 0 {
1018             return true
1019         }
1020         mut fd := C.pollfd{
1021             fd:     C.ConnectionNumber(g_sapp_state.x11.display)
1022             events: pollin
1023         }
1024         C.poll(&fd, 1, int(timeout_sec * 1000))
1025         // Simplified timeout - just try once
1026         return C.XCheckTypedWindowEvent(g_sapp_state.x11.display, g_sapp_state.x11.window,
1027             event_type, out_event) != 0
1028     }
1029     return false
1030 }
1031 
1032 fn x11_app_event(event_type EventType) {
1033     if g_sapp_state.init_called && !g_sapp_state.cleanup_called {
1034         init_sapp_event(event_type)
1035         call_sapp_event(&g_sapp_state.event)
1036     }
1037 }
1038 
1039 fn x11_roundf_gzero(v f32) int {
1040     if v >= 0.5 {
1041         return int(v + 0.5)
1042     } else {
1043         return int(v)
1044     }
1045 }
1046 
1047 fn x11_update_dimensions(x11_window_width int, x11_window_height int) {
1048     window_scale := g_sapp_state.x11.dpi / 96.0
1049     g_sapp_state.window_width = x11_roundf_gzero(f32(x11_window_width) / window_scale)
1050     g_sapp_state.window_height = x11_roundf_gzero(f32(x11_window_height) / window_scale)
1051     cur_fb_width := g_sapp_state.framebuffer_width
1052     cur_fb_height := g_sapp_state.framebuffer_height
1053     g_sapp_state.framebuffer_width =
1054         x11_roundf_gzero(f32(g_sapp_state.window_width) * g_sapp_state.dpi_scale)
1055     g_sapp_state.framebuffer_height =
1056         x11_roundf_gzero(f32(g_sapp_state.window_height) * g_sapp_state.dpi_scale)
1057     dim_changed := g_sapp_state.framebuffer_width != cur_fb_width
1058         || g_sapp_state.framebuffer_height != cur_fb_height
1059     if dim_changed && !g_sapp_state.first_frame {
1060         x11_app_event(.resized)
1061     }
1062 }
1063 
1064 fn x11_update_dimensions_from_window_size() {
1065     mut attribs := C.XWindowAttributes{}
1066     C.XGetWindowAttributes(g_sapp_state.x11.display, g_sapp_state.x11.window, &attribs)
1067     x11_update_dimensions(attribs.width, attribs.height)
1068 }
1069 
1070 fn x11_set_fullscreen(enable bool) {
1071     if g_sapp_state.x11.net_wm_state != x_none && g_sapp_state.x11.net_wm_state_fullscreen != x_none {
1072         if enable {
1073             x11_send_event(g_sapp_state.x11.net_wm_state, 1, // _NET_WM_STATE_ADD
1074              i64(g_sapp_state.x11.net_wm_state_fullscreen), 0, 1, 0)
1075         } else {
1076             x11_send_event(g_sapp_state.x11.net_wm_state, 0, // _NET_WM_STATE_REMOVE
1077              i64(g_sapp_state.x11.net_wm_state_fullscreen), 0, 1, 0)
1078         }
1079     }
1080     C.XFlush(g_sapp_state.x11.display)
1081 }
1082 
1083 // set_resizable toggles whether the current Linux window can be resized by the window manager.
1084 pub fn set_resizable(resizable bool) {
1085     $if sokol_wayland ? {
1086         wl_set_resizable(resizable)
1087     } $else {
1088         x11_set_resizable(resizable)
1089     }
1090 }
1091 
1092 fn x11_set_resizable(resizable bool) {
1093     if g_sapp_state.x11.display == unsafe { nil } || g_sapp_state.x11.window == 0 {
1094         return
1095     }
1096     mut hints := C.XAllocSizeHints()
1097     if hints == unsafe { nil } {
1098         return
1099     }
1100     hints.flags = pw_gravity
1101     hints.win_gravity = center_gravity
1102     if !resizable {
1103         mut attribs := C.XWindowAttributes{}
1104         C.XGetWindowAttributes(g_sapp_state.x11.display, g_sapp_state.x11.window, &attribs)
1105         hints.flags |= i64(1 << 4) | i64(1 << 5) // PMinSize | PMaxSize
1106         hints.min_width = attribs.width
1107         hints.min_height = attribs.height
1108         hints.max_width = attribs.width
1109         hints.max_height = attribs.height
1110     }
1111     C.XSetWMNormalHints(g_sapp_state.x11.display, g_sapp_state.x11.window, hints)
1112     C.XFree(hints)
1113     C.XFlush(g_sapp_state.x11.display)
1114 }
1115 
1116 fn x11_create_window(visual_ &C.Visual, depth int) {
1117     mut vis := unsafe { visual_ }
1118     mut dep := depth
1119     if vis == unsafe { nil } {
1120         vis = C.XDefaultVisual(g_sapp_state.x11.display, g_sapp_state.x11.screen)
1121         dep = C.XDefaultDepth(g_sapp_state.x11.display, g_sapp_state.x11.screen)
1122     }
1123     g_sapp_state.x11.colormap = C.XCreateColormap(g_sapp_state.x11.display, g_sapp_state.x11.root,
1124         vis, alloc_none)
1125     mut wa := C.XSetWindowAttributes{}
1126     wa.colormap = g_sapp_state.x11.colormap
1127     wa.border_pixel = 0
1128     wa.event_mask = u64(structure_notify_mask | key_press_mask | key_release_mask | pointer_motion_mask | button_press_mask | button_release_mask | exposure_mask | focus_change_mask | visibility_change_mask | enter_window_mask | leave_window_mask | property_change_mask)
1129 
1130     display_width := C.XDisplayWidth(g_sapp_state.x11.display, g_sapp_state.x11.screen)
1131     display_height := C.XDisplayHeight(g_sapp_state.x11.display, g_sapp_state.x11.screen)
1132     window_scale := g_sapp_state.x11.dpi / 96.0
1133     mut x11_window_width := x11_roundf_gzero(f32(g_sapp_state.window_width) * window_scale)
1134     mut x11_window_height := x11_roundf_gzero(f32(g_sapp_state.window_height) * window_scale)
1135     if g_sapp_state.window_width == 0 {
1136         x11_window_width = (display_width * 4) / 5
1137     }
1138     if g_sapp_state.window_height == 0 {
1139         x11_window_height = (display_height * 4) / 5
1140     }
1141     // wamask = CWBorderPixel | CWColormap | CWEventMask
1142     wamask := u64(0x800 | 0x2000 | 0x800)
1143     x11_grab_error_handler()
1144     g_sapp_state.x11.window = C.XCreateWindow(g_sapp_state.x11.display, g_sapp_state.x11.root, 0,
1145         0, u32(x11_window_width), u32(x11_window_height), 0, dep, input_output, vis, wamask, &wa)
1146     x11_release_error_handler()
1147     if g_sapp_state.x11.window == 0 {
1148         eprintln('sokol_app: X11: failed to create window')
1149         return
1150     }
1151     mut protocols := [1]Atom{}
1152     protocols[0] = g_sapp_state.x11.wm_delete_window
1153     C.XSetWMProtocols(g_sapp_state.x11.display, g_sapp_state.x11.window, &protocols[0], 1)
1154     mut hints := C.XAllocSizeHints()
1155     hints.flags = pw_gravity
1156     hints.win_gravity = center_gravity
1157     C.XSetWMNormalHints(g_sapp_state.x11.display, g_sapp_state.x11.window, hints)
1158     C.XFree(hints)
1159     // Announce support for drag'n'drop
1160     if g_sapp_state.drop.enabled {
1161         version := Atom(x11_xdnd_version)
1162         C.XChangeProperty(g_sapp_state.x11.display, g_sapp_state.x11.window,
1163             g_sapp_state.x11.xdnd.xdnd_aware, xa_atom, 32, prop_mode_replace,
1164             unsafe { &u8(&version) }, 1)
1165     }
1166     x11_update_window_title()
1167     x11_update_dimensions_from_window_size()
1168 }
1169 
1170 fn x11_destroy_window() {
1171     if g_sapp_state.x11.window != 0 {
1172         C.XUnmapWindow(g_sapp_state.x11.display, g_sapp_state.x11.window)
1173         C.XDestroyWindow(g_sapp_state.x11.display, g_sapp_state.x11.window)
1174         g_sapp_state.x11.window = 0
1175     }
1176     if g_sapp_state.x11.colormap != 0 {
1177         C.XFreeColormap(g_sapp_state.x11.display, g_sapp_state.x11.colormap)
1178         g_sapp_state.x11.colormap = 0
1179     }
1180     C.XFlush(g_sapp_state.x11.display)
1181 }
1182 
1183 fn x11_window_visible() bool {
1184     mut wa := C.XWindowAttributes{}
1185     C.XGetWindowAttributes(g_sapp_state.x11.display, g_sapp_state.x11.window, &wa)
1186     return wa.map_state == is_viewable
1187 }
1188 
1189 fn x11_show_window() {
1190     if !x11_window_visible() {
1191         C.XMapWindow(g_sapp_state.x11.display, g_sapp_state.x11.window)
1192         mut dummy := C.XEvent{}
1193         x11_wait_for_event(visibility_notify, 0.1, &dummy)
1194         C.XRaiseWindow(g_sapp_state.x11.display, g_sapp_state.x11.window)
1195         C.XFlush(g_sapp_state.x11.display)
1196     }
1197 }
1198 
1199 fn x11_update_window_title() {
1200     title := &char(&g_sapp_state.window_title[0])
1201     C.Xutf8SetWMProperties(g_sapp_state.x11.display, g_sapp_state.x11.window, title, title,
1202         unsafe { nil }, 0, unsafe { nil }, unsafe { nil }, unsafe { nil })
1203     C.XChangeProperty(g_sapp_state.x11.display, g_sapp_state.x11.window,
1204         g_sapp_state.x11.net_wm_name, g_sapp_state.x11.utf8_string, 8, prop_mode_replace,
1205         &g_sapp_state.window_title[0], int(C.strlen(title)))
1206     C.XChangeProperty(g_sapp_state.x11.display, g_sapp_state.x11.window,
1207         g_sapp_state.x11.net_wm_icon_name, g_sapp_state.x11.utf8_string, 8, prop_mode_replace,
1208         &g_sapp_state.window_title[0], int(C.strlen(title)))
1209     C.XFlush(g_sapp_state.x11.display)
1210 }
1211 
1212 // === Cursors ===
1213 
1214 fn x11_create_hidden_cursor() {
1215     mut img := C.XcursorImageCreate(16, 16)
1216     if img == unsafe { nil } {
1217         return
1218     }
1219     img.xhot = 0
1220     img.yhot = 0
1221     unsafe { C.memset(img.pixels, 0, usize(16 * 16 * 4)) }
1222     g_sapp_state.x11.hidden_cursor = C.XcursorImageLoadCursor(g_sapp_state.x11.display, img)
1223     C.XcursorImageDestroy(img)
1224 }
1225 
1226 fn x11_create_standard_cursor(cursor MouseCursor, name &char, theme &char, size int, fallback_native u32) {
1227     idx := int(cursor)
1228     if theme != unsafe { nil } {
1229         img := C.XcursorLibraryLoadImage(name, theme, size)
1230         if img != unsafe { nil } {
1231             g_sapp_state.x11.standard_cursors[idx] =
1232                 C.XcursorImageLoadCursor(g_sapp_state.x11.display, img)
1233             C.XcursorImageDestroy(img)
1234         }
1235     }
1236     if g_sapp_state.x11.standard_cursors[idx] == 0 && fallback_native != 0 {
1237         g_sapp_state.x11.standard_cursors[idx] = C.XCreateFontCursor(g_sapp_state.x11.display,
1238             fallback_native)
1239     }
1240 }
1241 
1242 fn x11_create_standard_cursors() {
1243     cursor_theme := C.XcursorGetTheme(g_sapp_state.x11.display)
1244     size := C.XcursorGetDefaultSize(g_sapp_state.x11.display)
1245     x11_create_standard_cursor(.arrow, c'default', cursor_theme, size, xc_left_ptr)
1246     x11_create_standard_cursor(.ibeam, c'text', cursor_theme, size, xc_xterm)
1247     x11_create_standard_cursor(.crosshair, c'crosshair', cursor_theme, size, xc_crosshair)
1248     x11_create_standard_cursor(.pointing_hand, c'pointer', cursor_theme, size, xc_hand2)
1249     x11_create_standard_cursor(.resize_ew, c'ew-resize', cursor_theme, size, xc_sb_h_double_arrow)
1250     x11_create_standard_cursor(.resize_ns, c'ns-resize', cursor_theme, size, xc_sb_v_double_arrow)
1251     x11_create_standard_cursor(.resize_nwse, c'nwse-resize', cursor_theme, size, 0)
1252     x11_create_standard_cursor(.resize_nesw, c'nesw-resize', cursor_theme, size, 0)
1253     x11_create_standard_cursor(.resize_all, c'all-scroll', cursor_theme, size, xc_fleur)
1254     x11_create_standard_cursor(.not_allowed, c'no-allowed', cursor_theme, size, 0)
1255     x11_create_hidden_cursor()
1256 }
1257 
1258 fn x11_destroy_standard_cursors() {
1259     if g_sapp_state.x11.hidden_cursor != 0 {
1260         C.XFreeCursor(g_sapp_state.x11.display, g_sapp_state.x11.hidden_cursor)
1261         g_sapp_state.x11.hidden_cursor = 0
1262     }
1263     for i in 0 .. mousecursor_num {
1264         if g_sapp_state.x11.standard_cursors[i] != 0 {
1265             C.XFreeCursor(g_sapp_state.x11.display, g_sapp_state.x11.standard_cursors[i])
1266             g_sapp_state.x11.standard_cursors[i] = 0
1267         }
1268     }
1269 }
1270 
1271 fn x11_toggle_fullscreen() {
1272     g_sapp_state.fullscreen = !g_sapp_state.fullscreen
1273     x11_set_fullscreen(g_sapp_state.fullscreen)
1274     x11_update_dimensions_from_window_size()
1275 }
1276 
1277 fn x11_update_cursor(cursor MouseCursor, shown bool) {
1278     idx := int(cursor)
1279     if shown {
1280         if g_sapp_state.custom_cursor_bound[idx] {
1281             xcursor := g_sapp_state.x11.custom_cursors[idx]
1282             if xcursor != 0 {
1283                 C.XDefineCursor(g_sapp_state.x11.display, g_sapp_state.x11.window, xcursor)
1284             }
1285         } else if g_sapp_state.x11.standard_cursors[idx] != 0 {
1286             C.XDefineCursor(g_sapp_state.x11.display, g_sapp_state.x11.window,
1287                 g_sapp_state.x11.standard_cursors[idx])
1288         } else {
1289             C.XUndefineCursor(g_sapp_state.x11.display, g_sapp_state.x11.window)
1290         }
1291     } else {
1292         C.XDefineCursor(g_sapp_state.x11.display, g_sapp_state.x11.window,
1293             g_sapp_state.x11.hidden_cursor)
1294     }
1295     C.XFlush(g_sapp_state.x11.display)
1296 }
1297 
1298 // === Mouse lock ===
1299 
1300 fn x11_lock_mouse(do_lock bool) {
1301     if do_lock == g_sapp_state.mouse.locked {
1302         return
1303     }
1304     g_sapp_state.mouse.dx = 0.0
1305     g_sapp_state.mouse.dy = 0.0
1306     g_sapp_state.mouse.locked = do_lock
1307     if g_sapp_state.mouse.locked {
1308         if g_sapp_state.x11.xi.available {
1309             mut em := C.XIEventMask{}
1310             mut mask := [4]u8{}
1311             em.deviceid = xi_all_master_devices
1312             em.mask_len = int(sizeof(mask))
1313             em.mask = unsafe { &mask[0] }
1314             xi_set_mask(unsafe { &mask[0] }, xi_raw_motion)
1315             C.XISelectEvents(g_sapp_state.x11.display, g_sapp_state.x11.root, &em, 1)
1316         }
1317         C.XGrabPointer(g_sapp_state.x11.display, g_sapp_state.x11.window, x_true,
1318             u32(button_press_mask | button_release_mask | pointer_motion_mask), grab_mode_async,
1319             grab_mode_async, g_sapp_state.x11.window, g_sapp_state.x11.hidden_cursor, current_time)
1320     } else {
1321         if g_sapp_state.x11.xi.available {
1322             mut em := C.XIEventMask{}
1323             mut mask := [1]u8{}
1324             em.deviceid = xi_all_master_devices
1325             em.mask_len = int(sizeof(mask))
1326             em.mask = unsafe { &mask[0] }
1327             C.XISelectEvents(g_sapp_state.x11.display, g_sapp_state.x11.root, &em, 1)
1328         }
1329         C.XWarpPointer(g_sapp_state.x11.display, Window(0), g_sapp_state.x11.window, 0, 0, 0, 0,
1330             int(g_sapp_state.mouse.x), int(g_sapp_state.mouse.y))
1331         C.XUngrabPointer(g_sapp_state.x11.display, current_time)
1332     }
1333     C.XFlush(g_sapp_state.x11.display)
1334 }
1335 
1336 // === Clipboard ===
1337 
1338 fn x11_set_clipboard_string(_str &char) {
1339     if !g_sapp_state.clipboard.enabled || g_sapp_state.clipboard.buffer == unsafe { nil } {
1340         return
1341     }
1342     C.XSetSelectionOwner(g_sapp_state.x11.display, g_sapp_state.x11.clipboard_atom,
1343         g_sapp_state.x11.window, current_time)
1344 }
1345 
1346 fn x11_get_clipboard_string() &char {
1347     if !g_sapp_state.clipboard.enabled || g_sapp_state.clipboard.buffer == unsafe { nil } {
1348         return unsafe { nil }
1349     }
1350     // If we own the selection, just return our buffer
1351     if C.XGetSelectionOwner(g_sapp_state.x11.display, g_sapp_state.x11.clipboard_atom) == g_sapp_state.x11.window {
1352         return g_sapp_state.clipboard.buffer
1353     }
1354     sapp_selection := C.XInternAtom(g_sapp_state.x11.display, c'SAPP_SELECTION', x_false)
1355     C.XConvertSelection(g_sapp_state.x11.display, g_sapp_state.x11.clipboard_atom,
1356         g_sapp_state.x11.utf8_string, sapp_selection, g_sapp_state.x11.window, current_time)
1357     mut event := C.XEvent{}
1358     if !x11_wait_for_event(x_selection_notify, 0.1, &event) {
1359         return unsafe { nil }
1360     }
1361     unsafe {
1362         if event.xselection.property == x_none {
1363             return nil
1364         }
1365         mut data := &u8(nil)
1366         mut actual_type := Atom(0)
1367         mut actual_format := 0
1368         mut item_count := u64(0)
1369         mut bytes_after := u64(0)
1370         C.XGetWindowProperty(g_sapp_state.x11.display, event.xselection.requestor,
1371             event.xselection.property, 0, 0x7fffffff, x_true, g_sapp_state.x11.utf8_string,
1372             &actual_type, &actual_format, &item_count, &bytes_after, &&u8(&data))
1373         if data == nil {
1374             return nil
1375         }
1376         if item_count >= usize(g_sapp_state.clipboard.buf_size) {
1377             C.XFree(data)
1378             return nil
1379         }
1380         C.memcpy(g_sapp_state.clipboard.buffer, data, usize(item_count))
1381         g_sapp_state.clipboard.buffer[item_count] = 0
1382         C.XFree(data)
1383         return g_sapp_state.clipboard.buffer
1384     }
1385 }
1386 
1387 // === Modifier helpers ===
1388 
1389 fn x11_key_modifier_bit(key KeyCode) u32 {
1390     return match key {
1391         .left_shift, .right_shift { u32(Modifier.shift) }
1392         .left_control, .right_control { u32(Modifier.ctrl) }
1393         .left_alt, .right_alt { u32(Modifier.alt) }
1394         .left_super, .right_super { u32(Modifier.super) }
1395         else { u32(0) }
1396     }
1397 }
1398 
1399 fn x11_button_modifier_bit(btn MouseButton) u32 {
1400     return match btn {
1401         .left { u32(Modifier.lmb) }
1402         .right { u32(Modifier.rmb) }
1403         .middle { u32(Modifier.mmb) }
1404         else { u32(0) }
1405     }
1406 }
1407 
1408 fn x11_mods(x11_mods_ u32) u32 {
1409     mut mods := u32(0)
1410     if x11_mods_ & shift_mask != 0 {
1411         mods |= u32(Modifier.shift)
1412     }
1413     if x11_mods_ & control_mask != 0 {
1414         mods |= u32(Modifier.ctrl)
1415     }
1416     if x11_mods_ & mod1_mask != 0 {
1417         mods |= u32(Modifier.alt)
1418     }
1419     if x11_mods_ & mod4_mask != 0 {
1420         mods |= u32(Modifier.super)
1421     }
1422     if x11_mods_ & button1_mask != 0 {
1423         mods |= u32(Modifier.lmb)
1424     }
1425     if x11_mods_ & button2_mask != 0 {
1426         mods |= u32(Modifier.mmb)
1427     }
1428     if x11_mods_ & button3_mask != 0 {
1429         mods |= u32(Modifier.rmb)
1430     }
1431     return mods
1432 }
1433 
1434 fn x11_translate_button(event &C.XEvent) MouseButton {
1435     return match unsafe { event.xbutton.button } {
1436         x_button1 { MouseButton.left }
1437         x_button2 { MouseButton.middle }
1438         x_button3 { MouseButton.right }
1439         else { MouseButton.invalid }
1440     }
1441 }
1442 
1443 // === Mouse/key event helpers ===
1444 
1445 fn x11_mouse_update(x int, y int, clear_dxdy bool) {
1446     if !g_sapp_state.mouse.locked {
1447         new_x := f32(x)
1448         new_y := f32(y)
1449         if clear_dxdy {
1450             g_sapp_state.mouse.dx = 0.0
1451             g_sapp_state.mouse.dy = 0.0
1452         } else if g_sapp_state.mouse.pos_valid {
1453             g_sapp_state.mouse.dx = new_x - g_sapp_state.mouse.x
1454             g_sapp_state.mouse.dy = new_y - g_sapp_state.mouse.y
1455         }
1456         g_sapp_state.mouse.x = new_x
1457         g_sapp_state.mouse.y = new_y
1458         g_sapp_state.mouse.pos_valid = true
1459     }
1460 }
1461 
1462 fn x11_mouse_event(event_type EventType, btn MouseButton, mods u32) {
1463     if g_sapp_state.init_called && !g_sapp_state.cleanup_called {
1464         init_sapp_event(event_type)
1465         g_sapp_state.event.mouse_button = btn
1466         g_sapp_state.event.modifiers = mods
1467         call_sapp_event(&g_sapp_state.event)
1468     }
1469 }
1470 
1471 fn x11_scroll_event(x f32, y f32, mods u32) {
1472     if g_sapp_state.init_called && !g_sapp_state.cleanup_called {
1473         init_sapp_event(.mouse_scroll)
1474         g_sapp_state.event.modifiers = mods
1475         g_sapp_state.event.scroll_x = x
1476         g_sapp_state.event.scroll_y = y
1477         call_sapp_event(&g_sapp_state.event)
1478     }
1479 }
1480 
1481 fn x11_key_event(event_type EventType, key KeyCode, repeat bool, mods u32) {
1482     if g_sapp_state.init_called && !g_sapp_state.cleanup_called {
1483         init_sapp_event(event_type)
1484         g_sapp_state.event.key_code = key
1485         g_sapp_state.event.key_repeat = repeat
1486         g_sapp_state.event.modifiers = mods
1487         call_sapp_event(&g_sapp_state.event)
1488         // Check if a CLIPBOARD_PASTED event must be sent too
1489         if g_sapp_state.clipboard.enabled && event_type == .key_down
1490             && g_sapp_state.event.modifiers == u32(Modifier.ctrl)
1491             && g_sapp_state.event.key_code == .v {
1492             init_sapp_event(.clipboard_pasted)
1493             call_sapp_event(&g_sapp_state.event)
1494         }
1495     }
1496 }
1497 
1498 fn x11_char_event(chr u32, repeat bool, mods u32) {
1499     if g_sapp_state.init_called && !g_sapp_state.cleanup_called {
1500         init_sapp_event(.char)
1501         g_sapp_state.event.char_code = chr
1502         g_sapp_state.event.key_repeat = repeat
1503         g_sapp_state.event.modifiers = mods
1504         call_sapp_event(&g_sapp_state.event)
1505     }
1506 }
1507 
1508 fn x11_translate_key(scancode int) KeyCode {
1509     if scancode >= 0 && scancode < x11_max_keycodes {
1510         return g_sapp_state.keycodes[scancode]
1511     }
1512     return .invalid
1513 }
1514 
1515 fn x11_keypress_repeat(keycode int) bool {
1516     mut repeat := false
1517     if keycode >= 0 && keycode < x11_max_keycodes {
1518         repeat = g_sapp_state.x11.key_repeat[keycode]
1519         g_sapp_state.x11.key_repeat[keycode] = true
1520     }
1521     return repeat
1522 }
1523 
1524 fn x11_keyrelease_repeat(keycode int) {
1525     if keycode >= 0 && keycode < x11_max_keycodes {
1526         g_sapp_state.x11.key_repeat[keycode] = false
1527     }
1528 }
1529 
1530 // === Window property helpers ===
1531 
1532 fn x11_get_window_property(window Window, property Atom, req_type Atom, value &&u8) u64 {
1533     mut actual_type := Atom(0)
1534     mut actual_format := 0
1535     mut item_count := u64(0)
1536     mut bytes_after := u64(0)
1537     C.XGetWindowProperty(g_sapp_state.x11.display, window, property, 0, 0x7fffffff, x_false,
1538         req_type, &actual_type, &actual_format, &item_count, &bytes_after, unsafe { &&&u8(value) })
1539     return item_count
1540 }
1541 
1542 fn x11_get_window_state() int {
1543     mut result := withdrawn_state
1544     mut state := &u8(unsafe { nil })
1545     if x11_get_window_property(g_sapp_state.x11.window, g_sapp_state.x11.wm_state,
1546         g_sapp_state.x11.wm_state, &&u8(&state)) >= 2 {
1547         unsafe {
1548             result = int(*(&u32(state)))
1549         }
1550     }
1551     if state != unsafe { nil } {
1552         C.XFree(state)
1553     }
1554     return result
1555 }
1556 
1557 // === Dropped files ===
1558 
1559 fn x11_parse_dropped_files_list(src &char) bool {
1560     if src == unsafe { nil } || g_sapp_state.drop.buffer == unsafe { nil } {
1561         return false
1562     }
1563     // Clear drop buffer
1564     unsafe { C.memset(g_sapp_state.drop.buffer, 0, usize(g_sapp_state.drop.buf_size)) }
1565     g_sapp_state.drop.num_files = 0
1566 
1567     mut err := false
1568     mut src_count := 0
1569     mut dst_ptr := g_sapp_state.drop.buffer
1570     dst_end_ptr := unsafe { g_sapp_state.drop.buffer + (g_sapp_state.drop.max_path_length - 1) }
1571     mut p := unsafe { src }
1572     for {
1573         src_chr := unsafe { *p }
1574         if src_chr == 0 {
1575             break
1576         }
1577         unsafe { p++ }
1578         src_count++
1579         mut dst_chr := u8(0)
1580         // Check leading 'file://'
1581         if src_count <= 7 {
1582             valid := (src_count == 1 && src_chr == `f`)
1583                 || (src_count == 2 && src_chr == `i`)
1584                 || (src_count == 3 && src_chr == `l`)
1585                 || (src_count == 4 && src_chr == `e`)
1586                 || (src_count == 5 && src_chr == `:`)
1587                 || (src_count == 6 && src_chr == `/`)
1588                 || (src_count == 7 && src_chr == `/`)
1589             if !valid {
1590                 err = true
1591                 break
1592             }
1593         } else if src_chr == `\r` {
1594             // skip
1595         } else if src_chr == `\n` {
1596             src_count = 0
1597             g_sapp_state.drop.num_files++
1598             if g_sapp_state.drop.num_files >= g_sapp_state.drop.max_files {
1599                 break
1600             }
1601             dst_ptr = unsafe {
1602                 g_sapp_state.drop.buffer +
1603                     g_sapp_state.drop.num_files * g_sapp_state.drop.max_path_length
1604             }
1605         } else if src_chr == `%` {
1606             unsafe {
1607                 if *p != 0 && *(p + 1) != 0 {
1608                     mut digits := [3]u8{}
1609                     digits[0] = u8(*p)
1610                     digits[1] = u8(*(p + 1))
1611                     digits[2] = 0
1612                     p = &char(usize(p) + 2)
1613                     dst_chr = u8(C.strtol(&char(&digits[0]), &char(0), 16))
1614                 }
1615             }
1616         } else {
1617             dst_chr = u8(src_chr)
1618         }
1619         if dst_chr != 0 {
1620             if usize(dst_ptr) < usize(dst_end_ptr) {
1621                 unsafe {
1622                     *dst_ptr = char(dst_chr)
1623                     dst_ptr++
1624                 }
1625             } else {
1626                 err = true
1627                 break
1628             }
1629         }
1630     }
1631     if err {
1632         unsafe { C.memset(g_sapp_state.drop.buffer, 0, usize(g_sapp_state.drop.buf_size)) }
1633         g_sapp_state.drop.num_files = 0
1634         return false
1635     }
1636     return true
1637 }
1638 
1639 // === Event handlers ===
1640 
1641 fn x11_on_genericevent(event &C.XEvent) {
1642     if g_sapp_state.mouse.locked && g_sapp_state.x11.xi.available {
1643         unsafe {
1644             if event.xcookie.extension == g_sapp_state.x11.xi.major_opcode {
1645                 if C.XGetEventData(g_sapp_state.x11.display, &event.xcookie) != 0 {
1646                     if event.xcookie.evtype == xi_raw_motion {
1647                         re := &C.XIRawEvent(event.xcookie.data)
1648                         if re.valuators.mask_len > 0 {
1649                             mut values := re.raw_values
1650                             if xi_mask_is_set(re.valuators.mask, 0) {
1651                                 g_sapp_state.mouse.dx = f32(*values)
1652                                 values = values + 1
1653                             }
1654                             if xi_mask_is_set(re.valuators.mask, 1) {
1655                                 g_sapp_state.mouse.dy = f32(*values)
1656                             }
1657                             x11_mouse_event(.mouse_move, .invalid, x11_mods(event.xmotion.state))
1658                         }
1659                     }
1660                     C.XFreeEventData(g_sapp_state.x11.display, &event.xcookie)
1661                 }
1662             }
1663         }
1664     }
1665 }
1666 
1667 fn x11_on_focusin(event &C.XEvent) {
1668     unsafe {
1669         if event.xfocus.mode != notify_grab && event.xfocus.mode != notify_ungrab {
1670             x11_app_event(.focused)
1671         }
1672     }
1673 }
1674 
1675 fn x11_on_focusout(event &C.XEvent) {
1676     if g_sapp_state.mouse.locked {
1677         x11_lock_mouse(false)
1678     }
1679     unsafe {
1680         if event.xfocus.mode != notify_grab && event.xfocus.mode != notify_ungrab {
1681             x11_app_event(.unfocused)
1682         }
1683     }
1684 }
1685 
1686 fn x11_on_keypress(event &C.XEvent) {
1687     unsafe {
1688         keycode := int(event.xkey.keycode)
1689         keysym := x11_lookup_keysym(event)
1690         key := x11_translate_event_key(keycode, keysym)
1691         repeat := x11_keypress_repeat(keycode)
1692         mut mods := x11_mods(event.xkey.state)
1693         // X11 doesn't set modifier bit on key down, so emulate that
1694         mods |= x11_key_modifier_bit(key)
1695         if key != .invalid {
1696             x11_key_event(.key_down, key, repeat, mods)
1697         }
1698         chr := x11_keysym_to_unicode(keysym)
1699         if chr > 0 {
1700             x11_char_event(u32(chr), repeat, mods)
1701         }
1702     }
1703 }
1704 
1705 fn x11_on_keyrelease(event &C.XEvent) {
1706     unsafe {
1707         keycode := int(event.xkey.keycode)
1708         keysym := x11_lookup_keysym(event)
1709         key := x11_translate_event_key(keycode, keysym)
1710         x11_keyrelease_repeat(keycode)
1711         if key != .invalid {
1712             mut mods := x11_mods(event.xkey.state)
1713             // X11 doesn't clear modifier bit on key up, so emulate that
1714             mods &= ~x11_key_modifier_bit(key)
1715             x11_key_event(.key_up, key, false, mods)
1716         }
1717     }
1718 }
1719 
1720 fn x11_on_buttonpress(event &C.XEvent) {
1721     unsafe {
1722         x11_mouse_update(event.xbutton.x, event.xbutton.y, false)
1723         btn := x11_translate_button(event)
1724         mut mods := x11_mods(event.xbutton.state)
1725         mods |= x11_button_modifier_bit(btn)
1726         if btn != .invalid {
1727             x11_mouse_event(.mouse_down, btn, mods)
1728             g_sapp_state.x11.mouse_buttons |= u8(1 << int(btn))
1729         } else {
1730             // Might be a scroll event
1731             match event.xbutton.button {
1732                 4 { x11_scroll_event(0.0, 1.0, mods) }
1733                 5 { x11_scroll_event(0.0, -1.0, mods) }
1734                 6 { x11_scroll_event(1.0, 0.0, mods) }
1735                 7 { x11_scroll_event(-1.0, 0.0, mods) }
1736                 else {}
1737             }
1738         }
1739     }
1740 }
1741 
1742 fn x11_on_buttonrelease(event &C.XEvent) {
1743     unsafe {
1744         x11_mouse_update(event.xbutton.x, event.xbutton.y, false)
1745         btn := x11_translate_button(event)
1746         if btn != .invalid {
1747             mut mods := x11_mods(event.xbutton.state)
1748             mods &= ~x11_button_modifier_bit(btn)
1749             x11_mouse_event(.mouse_up, btn, mods)
1750             g_sapp_state.x11.mouse_buttons &= ~u8(1 << int(btn))
1751         }
1752     }
1753 }
1754 
1755 fn x11_on_enternotify(event &C.XEvent) {
1756     if g_sapp_state.x11.mouse_buttons == 0 {
1757         unsafe {
1758             x11_mouse_update(event.xcrossing.x, event.xcrossing.y, true)
1759             x11_mouse_event(.mouse_enter, .invalid, x11_mods(event.xcrossing.state))
1760         }
1761     }
1762 }
1763 
1764 fn x11_on_leavenotify(event &C.XEvent) {
1765     if g_sapp_state.x11.mouse_buttons == 0 {
1766         unsafe {
1767             x11_mouse_update(event.xcrossing.x, event.xcrossing.y, true)
1768             x11_mouse_event(.mouse_leave, .invalid, x11_mods(event.xcrossing.state))
1769         }
1770     }
1771 }
1772 
1773 fn x11_on_motionnotify(event &C.XEvent) {
1774     if !g_sapp_state.mouse.locked {
1775         unsafe {
1776             x11_mouse_update(event.xmotion.x, event.xmotion.y, false)
1777             x11_mouse_event(.mouse_move, .invalid, x11_mods(event.xmotion.state))
1778         }
1779     }
1780 }
1781 
1782 fn x11_on_propertynotify(event &C.XEvent) {
1783     unsafe {
1784         if event.xproperty.state == property_new_value {
1785             if event.xproperty.atom == g_sapp_state.x11.wm_state {
1786                 state := x11_get_window_state()
1787                 if state != g_sapp_state.x11.window_state {
1788                     g_sapp_state.x11.window_state = state
1789                     if state == iconic_state {
1790                         x11_app_event(.iconified)
1791                     } else if state == normal_state {
1792                         x11_app_event(.restored)
1793                     }
1794                 }
1795             }
1796         }
1797     }
1798 }
1799 
1800 fn x11_on_selectionnotify(event &C.XEvent) {
1801     unsafe {
1802         if event.xselection.property == g_sapp_state.x11.xdnd.xdnd_selection {
1803             mut data := &u8(nil)
1804             result := x11_get_window_property(event.xselection.requestor,
1805                 event.xselection.property, event.xselection.target, &&u8(&data))
1806             if g_sapp_state.drop.enabled && result > 0 {
1807                 if x11_parse_dropped_files_list(&char(data)) {
1808                     g_sapp_state.mouse.dx = 0.0
1809                     g_sapp_state.mouse.dy = 0.0
1810                     if g_sapp_state.init_called && !g_sapp_state.cleanup_called {
1811                         init_sapp_event(.files_dropped)
1812                         call_sapp_event(&g_sapp_state.event)
1813                     }
1814                 }
1815             }
1816             if g_sapp_state.x11.xdnd.version >= 2 {
1817                 mut reply := C.XEvent{}
1818                 reply.@type = x_client_message
1819                 reply.xclient.window = g_sapp_state.x11.xdnd.source
1820                 reply.xclient.message_type = g_sapp_state.x11.xdnd.xdnd_finished
1821                 reply.xclient.format = 32
1822                 reply.xclient.data.l[0] = i64(g_sapp_state.x11.window)
1823                 reply.xclient.data.l[1] = i64(result)
1824                 reply.xclient.data.l[2] = i64(g_sapp_state.x11.xdnd.xdnd_action_copy)
1825                 C.XSendEvent(g_sapp_state.x11.display, g_sapp_state.x11.xdnd.source, x_false,
1826                     no_event_mask, &reply)
1827                 C.XFlush(g_sapp_state.x11.display)
1828             }
1829             if data != nil {
1830                 C.XFree(data)
1831             }
1832         }
1833     }
1834 }
1835 
1836 fn x11_on_selectionrequest(event &C.XEvent) {
1837     unsafe {
1838         req := &event.xselectionrequest
1839         if req.selection != g_sapp_state.x11.clipboard_atom {
1840             return
1841         }
1842         if !g_sapp_state.clipboard.enabled {
1843             return
1844         }
1845         mut reply := C.XEvent{}
1846         reply.@type = x_selection_notify
1847         reply.xselection.requestor = req.requestor
1848         reply.xselection.property = req.property
1849         reply.xselection.target = req.target
1850 
1851         if req.target == g_sapp_state.x11.utf8_string {
1852             C.XChangeProperty(g_sapp_state.x11.display, req.requestor, req.property,
1853                 g_sapp_state.x11.utf8_string, 8, prop_mode_replace,
1854                 &u8(g_sapp_state.clipboard.buffer), int(C.strlen(g_sapp_state.clipboard.buffer)))
1855         } else if req.target == g_sapp_state.x11.targets {
1856             C.XChangeProperty(g_sapp_state.x11.display, req.requestor, req.property, xa_atom, 32,
1857                 prop_mode_replace, &u8(&g_sapp_state.x11.utf8_string), 1)
1858         } else {
1859             reply.xselection.property = x_none
1860         }
1861         C.XSendEvent(g_sapp_state.x11.display, req.requestor, x_false, 0, &reply)
1862     }
1863 }
1864 
1865 fn x11_on_clientmessage(event &C.XEvent) {
1866     if C.XFilterEvent(event, Window(0)) != 0 {
1867         return
1868     }
1869     unsafe {
1870         if event.xclient.message_type == g_sapp_state.x11.wm_protocols {
1871             protocol := Atom(u64(event.xclient.data.l[0]))
1872             if protocol == g_sapp_state.x11.wm_delete_window {
1873                 g_sapp_state.quit_requested = true
1874             }
1875         } else if event.xclient.message_type == g_sapp_state.x11.xdnd.xdnd_enter {
1876             is_list := (event.xclient.data.l[1] & 1) != 0
1877             g_sapp_state.x11.xdnd.source = Window(u64(event.xclient.data.l[0]))
1878             g_sapp_state.x11.xdnd.version = event.xclient.data.l[1] >> 24
1879             g_sapp_state.x11.xdnd.format = x_none
1880             if g_sapp_state.x11.xdnd.version > x11_xdnd_version {
1881                 return
1882             }
1883             mut count := u64(0)
1884             mut formats := &Atom(nil)
1885             if is_list {
1886                 count = x11_get_window_property(g_sapp_state.x11.xdnd.source,
1887                     g_sapp_state.x11.xdnd.xdnd_type_list, xa_atom, &&u8(&formats))
1888             } else {
1889                 count = 3
1890                 formats = &Atom(voidptr(&event.xclient.data.l[2]))
1891             }
1892             for i in 0 .. count {
1893                 if formats[i] == g_sapp_state.x11.xdnd.text_uri_list {
1894                     g_sapp_state.x11.xdnd.format = g_sapp_state.x11.xdnd.text_uri_list
1895                     break
1896                 }
1897             }
1898             if is_list && formats != nil {
1899                 C.XFree(formats)
1900             }
1901         } else if event.xclient.message_type == g_sapp_state.x11.xdnd.xdnd_drop {
1902             if g_sapp_state.x11.xdnd.version > x11_xdnd_version {
1903                 return
1904             }
1905             if g_sapp_state.x11.xdnd.format != x_none {
1906                 mut time := current_time
1907                 if g_sapp_state.x11.xdnd.version >= 1 {
1908                     time = Time(u64(event.xclient.data.l[2]))
1909                 }
1910                 C.XConvertSelection(g_sapp_state.x11.display, g_sapp_state.x11.xdnd.xdnd_selection,
1911                     g_sapp_state.x11.xdnd.format, g_sapp_state.x11.xdnd.xdnd_selection,
1912                     g_sapp_state.x11.window, time)
1913             } else if g_sapp_state.x11.xdnd.version >= 2 {
1914                 mut reply := C.XEvent{}
1915                 reply.@type = x_client_message
1916                 reply.xclient.window = g_sapp_state.x11.xdnd.source
1917                 reply.xclient.message_type = g_sapp_state.x11.xdnd.xdnd_finished
1918                 reply.xclient.format = 32
1919                 reply.xclient.data.l[0] = i64(g_sapp_state.x11.window)
1920                 reply.xclient.data.l[1] = 0
1921                 reply.xclient.data.l[2] = i64(x_none)
1922                 C.XSendEvent(g_sapp_state.x11.display, g_sapp_state.x11.xdnd.source, x_false,
1923                     no_event_mask, &reply)
1924                 C.XFlush(g_sapp_state.x11.display)
1925             }
1926         } else if event.xclient.message_type == g_sapp_state.x11.xdnd.xdnd_position {
1927             if g_sapp_state.x11.xdnd.version > x11_xdnd_version {
1928                 return
1929             }
1930             mut reply := C.XEvent{}
1931             reply.@type = x_client_message
1932             reply.xclient.window = g_sapp_state.x11.xdnd.source
1933             reply.xclient.message_type = g_sapp_state.x11.xdnd.xdnd_status
1934             reply.xclient.format = 32
1935             reply.xclient.data.l[0] = i64(g_sapp_state.x11.window)
1936             if g_sapp_state.x11.xdnd.format != x_none {
1937                 reply.xclient.data.l[1] = 1
1938                 if g_sapp_state.x11.xdnd.version >= 2 {
1939                     reply.xclient.data.l[4] = i64(g_sapp_state.x11.xdnd.xdnd_action_copy)
1940                 }
1941             }
1942             C.XSendEvent(g_sapp_state.x11.display, g_sapp_state.x11.xdnd.source, x_false,
1943                 no_event_mask, &reply)
1944             C.XFlush(g_sapp_state.x11.display)
1945         }
1946     }
1947 }
1948 
1949 // === Main event dispatcher ===
1950 
1951 fn x11_process_event(event &C.XEvent) {
1952     unsafe {
1953         match event.@type {
1954             x_generic_event { x11_on_genericevent(event) }
1955             x_focus_in { x11_on_focusin(event) }
1956             x_focus_out { x11_on_focusout(event) }
1957             x_key_press { x11_on_keypress(event) }
1958             x_key_release { x11_on_keyrelease(event) }
1959             x_button_press { x11_on_buttonpress(event) }
1960             x_button_release { x11_on_buttonrelease(event) }
1961             x_enter_notify { x11_on_enternotify(event) }
1962             x_leave_notify { x11_on_leavenotify(event) }
1963             x_motion_notify { x11_on_motionnotify(event) }
1964             x_property_notify { x11_on_propertynotify(event) }
1965             x_selection_notify { x11_on_selectionnotify(event) }
1966             x_selection_request { x11_on_selectionrequest(event) }
1967             x_destroy_notify {}
1968             x_client_message { x11_on_clientmessage(event) }
1969             else {}
1970         }
1971     }
1972 }
1973 
1974 // === Frame and run functions ===
1975 
1976 fn x11_linux_frame() {
1977     x11_update_dimensions_from_window_size()
1978     sapp_do_frame()
1979     C.eglSwapBuffers(g_sapp_state.egl.display, g_sapp_state.egl.surface)
1980 }
1981 
1982 fn x11_run() {
1983     C.XInitThreads()
1984     C.XrmInitialize()
1985     g_sapp_state.x11.display = C.XOpenDisplay(unsafe { nil })
1986     if g_sapp_state.x11.display == unsafe { nil } {
1987         eprintln('sokol_app: X11: failed to open display')
1988         return
1989     }
1990     g_sapp_state.x11.screen = C.XDefaultScreen(g_sapp_state.x11.display)
1991     g_sapp_state.x11.root = C.XDefaultRootWindow(g_sapp_state.x11.display)
1992     g_sapp_state.x11.window_state = normal_state
1993     x11_query_system_dpi()
1994     g_sapp_state.dpi_scale = g_sapp_state.x11.dpi / 96.0
1995     x11_init_extensions()
1996     x11_create_standard_cursors()
1997     C.XkbSetDetectableAutoRepeat(g_sapp_state.x11.display, x_true, unsafe { nil })
1998     x11_init_keytable()
1999 
2000     // EGL init (creates window internally)
2001     sapp_egl_init_x11()
2002 
2003     g_sapp_state.valid = true
2004     x11_show_window()
2005     if g_sapp_state.fullscreen {
2006         x11_set_fullscreen(true)
2007     }
2008     C.XFlush(g_sapp_state.x11.display)
2009 
2010     for !g_sapp_state.quit_ordered {
2011         count := C.XPending(g_sapp_state.x11.display)
2012         for _ in 0 .. count {
2013             mut event := C.XEvent{}
2014             C.XNextEvent(g_sapp_state.x11.display, &event)
2015             x11_process_event(&event)
2016         }
2017         x11_linux_frame()
2018         C.XFlush(g_sapp_state.x11.display)
2019         // Handle quit-requested
2020         if g_sapp_state.quit_requested && !g_sapp_state.quit_ordered {
2021             x11_app_event(.quit_requested)
2022             if g_sapp_state.quit_requested {
2023                 g_sapp_state.quit_ordered = true
2024             }
2025         }
2026     }
2027     sapp_call_cleanup()
2028     sapp_egl_destroy()
2029     x11_destroy_window()
2030     x11_destroy_standard_cursors()
2031     C.XCloseDisplay(g_sapp_state.x11.display)
2032     sapp_discard_state()
2033 }
2034