1 /* input event and data structure translation */
2 
3 #include <u.h>
4 #include "x11-inc.h"
5 #include <libc.h>
6 #include <draw.h>
7 #include <memdraw.h>
8 #include <mouse.h>
9 #include <cursor.h>
10 #include <keyboard.h>
11 #include "x11-memdraw.h"
12 #include "x11-keysym2ucs.h"
13 
14 #undef time
15 
16 
17 static KeySym
18 __xtoplan9kbd(XEvent *e)
19 {
20 	KeySym k;
21 
22 	if(e->xany.type != KeyPress)
23 		return -1;
24 	needstack(64*1024);	/* X has some *huge* buffers in openobject */
25 		/* and they're even bigger on SuSE */
26 	XLookupString((XKeyEvent*)e,NULL,0,&k,NULL);
27 	if(k == XK_Multi_key || k == NoSymbol)
28 		return -1;
29 
30 	if(k&0xFF00){
31 		switch(k){
32 		case XK_BackSpace:
33 		case XK_Tab:
34 		case XK_Escape:
35 		case XK_Delete:
36 		case XK_KP_0:
37 		case XK_KP_1:
38 		case XK_KP_2:
39 		case XK_KP_3:
40 		case XK_KP_4:
41 		case XK_KP_5:
42 		case XK_KP_6:
43 		case XK_KP_7:
44 		case XK_KP_8:
45 		case XK_KP_9:
46 		case XK_KP_Divide:
47 		case XK_KP_Multiply:
48 		case XK_KP_Subtract:
49 		case XK_KP_Add:
50 		case XK_KP_Decimal:
51 			k &= 0x7F;
52 			break;
53 		case XK_Linefeed:
54 			k = '\r';
55 			break;
56 		case XK_KP_Space:
57 			k = ' ';
58 			break;
59 		case XK_Home:
60 		case XK_KP_Home:
61 			k = Khome;
62 			break;
63 		case XK_Left:
64 		case XK_KP_Left:
65 			k = Kleft;
66 			break;
67 		case XK_Up:
68 		case XK_KP_Up:
69 			k = Kup;
70 			break;
71 		case XK_Down:
72 		case XK_KP_Down:
73 			k = Kdown;
74 			break;
75 		case XK_Right:
76 		case XK_KP_Right:
77 			k = Kright;
78 			break;
79 		case XK_Page_Down:
80 		case XK_KP_Page_Down:
81 			k = Kpgdown;
82 			break;
83 		case XK_End:
84 		case XK_KP_End:
85 			k = Kend;
86 			break;
87 		case XK_Page_Up:	
88 		case XK_KP_Page_Up:
89 			k = Kpgup;
90 			break;
91 		case XK_Insert:
92 		case XK_KP_Insert:
93 			k = Kins;
94 			break;
95 		case XK_KP_Enter:
96 		case XK_Return:
97 			k = '\n';
98 			break;
99 		case XK_Alt_L:
100 		case XK_Meta_L:	/* Shift Alt on PCs */
101 		case XK_Alt_R:
102 		case XK_Meta_R:	/* Shift Alt on PCs */
103 			k = Kalt;
104 			break;
105 		default:		/* not ISO-1 or tty control */
106 			if(k>0xff) {
107 				k = _p9keysym2ucs(k);
108 				if(k==-1) return -1;
109 			}
110 		}
111 	}
112 
113 	/* Compensate for servers that call a minus a hyphen */
114 	if(k == XK_hyphen)
115 		k = XK_minus;
116 	/* Do control mapping ourselves if translator doesn't */
117 	if(e->xkey.state&ControlMask)
118 		k &= 0x9f;
119 	if(k == NoSymbol) {
120 		return -1;
121 	}
122 
123 	return k+0;
124 }
125 
126 static Rune*
127 xtoplan9latin1(XEvent *e)
128 {
129 	static Rune k[10];
130 	static int alting, nk;
131 	int n;
132 	int r;
133 
134 	r = __xtoplan9kbd(e);
135 	if(r < 0)
136 		return nil;
137 	if(alting){
138 		/*
139 		 * Kludge for Mac's X11 3-button emulation.
140 		 * It treats Command+Button as button 3, but also
141 		 * ends up sending XK_Meta_L twice.
142 		 */
143 		if(r == Kalt){
144 			alting = 0;
145 			return nil;
146 		}
147 		k[nk++] = r;
148 		n = _latin1(k, nk);
149 		if(n > 0){
150 			alting = 0;
151 			k[0] = n;
152 			k[1] = 0;
153 			return k;
154 		}
155 		if(n == -1){
156 			alting = 0;
157 			k[nk] = 0;
158 			return k;
159 		}
160 		/* n < -1, need more input */
161 		return nil;
162 	}else if(r == Kalt){
163 		alting = 1;
164 		nk = 0;
165 		return nil;
166 	}else{
167 		k[0] = r;
168 		k[1] = 0;
169 		return k;
170 	}
171 }
172 
173 int
174 _xtoplan9kbd(XEvent *e)
175 {
176 	static Rune *r;
177 
178 	if(e == (XEvent*)-1){
179 		assert(r);
180 		r--;
181 		return 0;
182 	}
183 	if(e)
184 		r = xtoplan9latin1(e);
185 	if(r && *r)
186 		return *r++;
187 	return -1;
188 }
189 
190 int
191 _xtoplan9mouse(XDisplay *xd, XEvent *e, Mouse *m)
192 {
193 	int s;
194 	XButtonEvent *be;
195 	XMotionEvent *me;
196 
197 	if(_x.putsnarf != _x.assertsnarf){
198 		_x.assertsnarf = _x.putsnarf;
199 		XSetSelectionOwner(_x.mousecon, XA_PRIMARY, _x.drawable, CurrentTime);
200 		if(_x.clipboard != None)
201 			XSetSelectionOwner(_x.mousecon, _x.clipboard, _x.drawable, CurrentTime);
202 		XFlush(xd);
203 	}
204 
205 	switch(e->type){
206 	case ButtonPress:
207 		be = (XButtonEvent*)e;
208 		/* 
209 		 * Fake message, just sent to make us announce snarf.
210 		 * Apparently state and button are 16 and 8 bits on
211 		 * the wire, since they are truncated by the time they
212 		 * get to us.
213 		 */
214 		if(be->send_event
215 		&& (~be->state&0xFFFF)==0
216 		&& (~be->button&0xFF)==0)
217 			return -1;
218 		/* BUG? on mac need to inherit these from elsewhere? */
219 		m->xy.x = be->x;
220 		m->xy.y = be->y;
221 		s = be->state;
222 		m->msec = be->time;
223 		switch(be->button){
224 		case 1:
225 			s |= Button1Mask;
226 			break;
227 		case 2:
228 			s |= Button2Mask;
229 			break;
230 		case 3:
231 			s |= Button3Mask;
232 			break;
233 		case 4:
234 			s |= Button4Mask;
235 			break;
236 		case 5:
237 			s |= Button5Mask;
238 			break;
239 		}
240 		break;
241 	case ButtonRelease:
242 		be = (XButtonEvent*)e;
243 		m->xy.x = be->x;
244 		m->xy.y = be->y;
245 		s = be->state;
246 		m->msec = be->time;
247 		switch(be->button){
248 		case 1:
249 			s &= ~Button1Mask;
250 			break;
251 		case 2:
252 			s &= ~Button2Mask;
253 			break;
254 		case 3:
255 			s &= ~Button3Mask;
256 			break;
257 		case 4:
258 			s &= ~Button4Mask;
259 			break;
260 		case 5:
261 			s &= ~Button5Mask;
262 			break;
263 		}
264 		break;
265 
266 	case MotionNotify:
267 		me = (XMotionEvent*)e;
268 		s = me->state;
269 		m->xy.x = me->x;
270 		m->xy.y = me->y;
271 		m->msec = me->time;
272 		break;
273 
274 	default:
275 		return -1;
276 	}
277 
278 	m->buttons = 0;
279 	if(s & Button1Mask)
280 		m->buttons |= 1;
281 	if(s & Button2Mask)
282 		m->buttons |= 2;
283 	if(s & Button3Mask)
284 		m->buttons |= 4;
285 	if(s & Button4Mask)
286 		m->buttons |= 8;
287 	if(s & Button5Mask)
288 		m->buttons |= 16;
289 	return 0;
290 }
291 
292 void
293 _xmoveto(Point p)
294 {
295 	XWarpPointer(_x.display, None, _x.drawable, 0, 0, 0, 0, p.x, p.y);
296 	XFlush(_x.display);
297 }
298 
299 static int
300 revbyte(int b)
301 {
302 	int r;
303 
304 	r = 0;
305 	r |= (b&0x01) << 7;
306 	r |= (b&0x02) << 5;
307 	r |= (b&0x04) << 3;
308 	r |= (b&0x08) << 1;
309 	r |= (b&0x10) >> 1;
310 	r |= (b&0x20) >> 3;
311 	r |= (b&0x40) >> 5;
312 	r |= (b&0x80) >> 7;
313 	return r;
314 }
315 
316 static void
317 xcursorarrow(void)
318 {
319 	if(_x.cursor != 0){
320 		XFreeCursor(_x.display, _x.cursor);
321 		_x.cursor = 0;
322 	}
323 	XUndefineCursor(_x.display, _x.drawable);
324 	XFlush(_x.display);
325 }
326 
327 
328 void
329 _xsetcursor(Cursor *c)
330 {
331 	XColor fg, bg;
332 	XCursor xc;
333 	Pixmap xsrc, xmask;
334 	int i;
335 	uchar src[2*16], mask[2*16];
336 
337 	if(c == nil){
338 		xcursorarrow();
339 		return;
340 	}
341 	for(i=0; i<2*16; i++){
342 		src[i] = revbyte(c->set[i]);
343 		mask[i] = revbyte(c->set[i] | c->clr[i]);
344 	}
345 
346 	fg = _x.map[0];
347 	bg = _x.map[255];
348 	xsrc = XCreateBitmapFromData(_x.display, _x.drawable, (char*)src, 16, 16);
349 	xmask = XCreateBitmapFromData(_x.display, _x.drawable, (char*)mask, 16, 16);
350 	xc = XCreatePixmapCursor(_x.display, xsrc, xmask, &fg, &bg, -c->offset.x, -c->offset.y);
351 	if(xc != 0) {
352 		XDefineCursor(_x.display, _x.drawable, xc);
353 		if(_x.cursor != 0)
354 			XFreeCursor(_x.display, _x.cursor);
355 		_x.cursor = xc;
356 	}
357 	XFreePixmap(_x.display, xsrc);
358 	XFreePixmap(_x.display, xmask);
359 	XFlush(_x.display);
360 }
361 
362 struct {
363 	char buf[SnarfSize];
364 	QLock lk;
365 } clip;
366 
367 char*
368 _xgetsnarf(XDisplay *xd)
369 {
370 	uchar *data, *xdata;
371 	Atom clipboard, type, prop;
372 	ulong len, lastlen, dummy;
373 	int fmt, i;
374 	XWindow w;
375 
376 	qlock(&clip.lk);
377 	/*
378 	 * Have we snarfed recently and the X server hasn't caught up?
379 	 */
380 	if(_x.putsnarf != _x.assertsnarf)
381 		goto mine;
382 
383 	/*
384 	 * Is there a primary selection (highlighted text in an xterm)?
385 	 */
386 	clipboard = XA_PRIMARY;
387 	w = XGetSelectionOwner(xd, XA_PRIMARY);
388 	if(w == _x.drawable){
389 	mine:
390 		data = (uchar*)strdup(clip.buf);
391 		goto out;
392 	}
393 
394 	/*
395 	 * If not, is there a clipboard selection?
396 	 */
397 	if(w == None && _x.clipboard != None){
398 		clipboard = _x.clipboard;
399 		w = XGetSelectionOwner(xd, _x.clipboard);
400 		if(w == _x.drawable)
401 			goto mine;
402 	}
403 
404 	/*
405 	 * If not, give up.
406 	 */
407 	if(w == None){
408 		data = nil;
409 		goto out;
410 	}
411 		
412 	/*
413 	 * We should be waiting for SelectionNotify here, but it might never
414 	 * come, and we have no way to time out.  Instead, we will clear
415 	 * local property #1, request our buddy to fill it in for us, and poll
416 	 * until he's done or we get tired of waiting.
417 	 *
418 	 * We should try to go for _x.utf8string instead of XA_STRING,
419 	 * but that would add to the polling.
420 	 */
421 	prop = 1;
422 	XChangeProperty(xd, _x.drawable, prop, XA_STRING, 8, PropModeReplace, (uchar*)"", 0);
423 	XConvertSelection(xd, clipboard, XA_STRING, prop, _x.drawable, CurrentTime);
424 	XFlush(xd);
425 	lastlen = 0;
426 	for(i=0; i<10 || (lastlen!=0 && i<30); i++){
427 		usleep(100*1000);
428 		XGetWindowProperty(xd, _x.drawable, prop, 0, 0, 0, AnyPropertyType,
429 			&type, &fmt, &dummy, &len, &data);
430 		if(lastlen == len && len > 0)
431 			break;
432 		lastlen = len;
433 	}
434 	if(i == 10){
435 		data = nil;
436 		goto out;
437 	}
438 	/* get the property */
439 	data = nil;
440 	XGetWindowProperty(xd, _x.drawable, prop, 0, SnarfSize/sizeof(ulong), 0, 
441 		AnyPropertyType, &type, &fmt, &len, &dummy, &xdata);
442 	if((type != XA_STRING && type != _x.utf8string) || len == 0){
443 		if(xdata)
444 			XFree(xdata);
445 		data = nil;
446 	}else{
447 		if(xdata){
448 			data = (uchar*)strdup((char*)xdata);
449 			XFree(xdata);
450 		}else
451 			data = nil;
452 	}
453 out:
454 	qunlock(&clip.lk);
455 	return (char*)data;
456 }
457 
458 void
459 _xputsnarf(XDisplay *xd, char *data)
460 {
461 	XButtonEvent e;
462 
463 	if(strlen(data) >= SnarfSize)
464 		return;
465 	qlock(&clip.lk);
466 	strcpy(clip.buf, data);
467 
468 	/* leave note for mouse proc to assert selection ownership */
469 	_x.putsnarf++;
470 
471 	/* send mouse a fake event so snarf is announced */
472 	memset(&e, 0, sizeof e);
473 	e.type = ButtonPress;
474 	e.window = _x.drawable;
475 	e.state = ~0;
476 	e.button = ~0;
477 	XSendEvent(xd, _x.drawable, True, ButtonPressMask, (XEvent*)&e);
478 	XFlush(xd);
479 
480 	qunlock(&clip.lk);
481 }
482 
483 int
484 _xselect(XEvent *e, XDisplay *xd)
485 {
486 	char *name;
487 	XEvent r;
488 	XSelectionRequestEvent *xe;
489 	Atom a[4];
490 
491 	memset(&r, 0, sizeof r);
492 	xe = (XSelectionRequestEvent*)e;
493 if(0) fprint(2, "xselect target=%d requestor=%d property=%d selection=%d\n",
494 	xe->target, xe->requestor, xe->property, xe->selection);
495 	r.xselection.property = xe->property;
496 	if(xe->target == _x.targets){
497 		a[0] = XA_STRING;
498 		a[1] = _x.utf8string;
499 		a[2] = _x.text;
500 		a[3] = _x.compoundtext;
501 
502 		XChangeProperty(xd, xe->requestor, xe->property, xe->target,
503 			8, PropModeReplace, (uchar*)a, sizeof a);
504 	}else if(xe->target == XA_STRING || xe->target == _x.utf8string || xe->target == _x.text || xe->target == _x.compoundtext){
505 		/* if the target is STRING we're supposed to reply with Latin1 XXX */
506 		qlock(&clip.lk);
507 		XChangeProperty(xd, xe->requestor, xe->property, xe->target,
508 			8, PropModeReplace, (uchar*)clip.buf, strlen(clip.buf));
509 		qunlock(&clip.lk);
510 	}else{
511 		name = XGetAtomName(xd, xe->target);
512 		if(strcmp(name, "TIMESTAMP") != 0)
513 			fprint(2, "%s: cannot handle selection request for '%s' (%d)\n", argv0, name, (int)xe->target);
514 		r.xselection.property = None;
515 	}
516 
517 	r.xselection.display = xe->display;
518 	/* r.xselection.property filled above */
519 	r.xselection.target = xe->target;
520 	r.xselection.type = SelectionNotify;
521 	r.xselection.requestor = xe->requestor;
522 	r.xselection.time = xe->time;
523 	r.xselection.send_event = True;
524 	r.xselection.selection = xe->selection;
525 	XSendEvent(xd, xe->requestor, False, 0, &r);
526 	XFlush(xd);
527 	return 0;
528 }
529 
530 void
531 putsnarf(char *data)
532 {
533 	_xputsnarf(_x.snarfcon, data);
534 }
535 
536 char*
537 getsnarf(void)
538 {
539 	return _xgetsnarf(_x.snarfcon);
540 }
541