op public repos

Blob

Date:: Sat Oct 11 02:47:43 2003 UTC
Message:: Lots of X fixes.
Actions:: History | Blame | Raw File
1 /* input event and data structure translation */
2 
3 #include "x11-inc.h"
4 
5 #include <u.h>
6 #include <libc.h>
7 #include <draw.h>
8 #include <memdraw.h>
9 #include <mouse.h>
10 #include <cursor.h>
11 #include <keyboard.h>
12 #include "x11-memdraw.h"
13 
14 int
15 xtoplan9kbd(XEvent *e)
16 {
17 	int ind, k, md;
18 
19 	md = e->xkey.state;
20 	ind = 0;
21 	if(md & ShiftMask)
22 		ind = 1;
23 
24 	k = XKeycodeToKeysym(e->xany.display, (KeyCode)e->xkey.keycode, ind);
25 	if(k == XK_Multi_key || k == NoSymbol)
26 		return -1;
27 
28 	if(k&0xFF00){
29 		switch(k){
30 		case XK_BackSpace:
31 		case XK_Tab:
32 		case XK_Escape:
33 		case XK_Delete:
34 		case XK_KP_0:
35 		case XK_KP_1:
36 		case XK_KP_2:
37 		case XK_KP_3:
38 		case XK_KP_4:
39 		case XK_KP_5:
40 		case XK_KP_6:
41 		case XK_KP_7:
42 		case XK_KP_8:
43 		case XK_KP_9:
44 		case XK_KP_Divide:
45 		case XK_KP_Multiply:
46 		case XK_KP_Subtract:
47 		case XK_KP_Add:
48 		case XK_KP_Decimal:
49 			k &= 0x7F;
50 			break;
51 		case XK_Linefeed:
52 			k = '\r';
53 			break;
54 		case XK_KP_Space:
55 			k = ' ';
56 			break;
57 		case XK_Home:
58 		case XK_KP_Home:
59 			k = Khome;
60 			break;
61 		case XK_Left:
62 		case XK_KP_Left:
63 			k = Kleft;
64 			break;
65 		case XK_Up:
66 		case XK_KP_Up:
67 			k = Kup;
68 			break;
69 		case XK_Down:
70 		case XK_KP_Down:
71 			k = Kdown;
72 			break;
73 		case XK_Right:
74 		case XK_KP_Right:
75 			k = Kright;
76 			break;
77 		case XK_Page_Down:
78 		case XK_KP_Page_Down:
79 			k = Kpgdown;
80 			break;
81 		case XK_End:
82 		case XK_KP_End:
83 			k = Kend;
84 			break;
85 		case XK_Page_Up:	
86 		case XK_KP_Page_Up:
87 			k = Kpgup;
88 			break;
89 		case XK_Insert:
90 		case XK_KP_Insert:
91 			k = Kins;
92 			break;
93 		case XK_KP_Enter:
94 		case XK_Return:
95 			k = '\n';
96 			break;
97 		case XK_Alt_L:
98 		case XK_Alt_R:
99 			k = Kalt;
100 			break;
101 		default:		/* not ISO-1 or tty control */
102 			return -1;
103 		}
104 	}
105 
106 	/* Compensate for servers that call a minus a hyphen */
107 	if(k == XK_hyphen)
108 		k = XK_minus;
109 	/* Do control mapping ourselves if translator doesn't */
110 	if(e->xkey.state&ControlMask)
111 		k &= 0x9f;
112 	if(k == NoSymbol) {
113 		return -1;
114 	}
115 
116 	/* BUG: could/should do Alt translation here! */
117 	return k;
118 }
119 
120 int
121 xtoplan9mouse(XEvent *e, Mouse *m)
122 {
123 	int s;
124 	XButtonEvent *be;
125 	XMotionEvent *me;
126 
127 	switch(e->type){
128 	case ButtonPress:
129 		be = (XButtonEvent*)e;
130 		/* BUG? on mac need to inherit these from elsewhere? */
131 		m->xy.x = be->x;
132 		m->xy.y = be->y;
133 		s = be->state;
134 		m->msec = be->time;
135 		switch(be->button){
136 		case 1:
137 			s |= Button1Mask;
138 			break;
139 		case 2:
140 			s |= Button2Mask;
141 			break;
142 		case 3:
143 			s |= Button3Mask;
144 			break;
145 		}
146 		break;
147 	case ButtonRelease:
148 		be = (XButtonEvent*)e;
149 		m->xy.x = be->x;
150 		m->xy.y = be->y;
151 		s = be->state;
152 		m->msec = be->time;
153 		switch(be->button){
154 		case 1:
155 			s &= ~Button1Mask;
156 			break;
157 		case 2:
158 			s &= ~Button2Mask;
159 			break;
160 		case 3:
161 			s &= ~Button3Mask;
162 			break;
163 		}
164 		break;
165 
166 	case MotionNotify:
167 		me = (XMotionEvent*)e;
168 		s = me->state;
169 		m->xy.x = me->x;
170 		m->xy.y = me->y;
171 		m->msec = me->time;
172 		break;
173 
174 	default:
175 		return -1;
176 	}
177 
178 	m->buttons = 0;
179 	if(s & Button1Mask)
180 		m->buttons |= 1;
181 	if(s & Button2Mask)
182 		m->buttons |= 2;
183 	if(s & Button3Mask)
184 		m->buttons |= 4;
185 
186 	return 0;
187 }
188 
189 void
190 xmoveto(Point p)
191 {
192 	XWarpPointer(_x.display, None, _x.drawable, 0, 0, 0, 0, p.x, p.y);
193 	XFlush(_x.display);
194 }
195 
196 static int
197 revbyte(int b)
198 {
199 	int r;
200 
201 	r = 0;
202 	r |= (b&0x01) << 7;
203 	r |= (b&0x02) << 5;
204 	r |= (b&0x04) << 3;
205 	r |= (b&0x08) << 1;
206 	r |= (b&0x10) >> 1;
207 	r |= (b&0x20) >> 3;
208 	r |= (b&0x40) >> 5;
209 	r |= (b&0x80) >> 7;
210 	return r;
211 }
212 
213 static void
214 xcursorarrow(void)
215 {
216 	if(_x.cursor != 0){
217 		XFreeCursor(_x.display, _x.cursor);
218 		_x.cursor = 0;
219 	}
220 	XUndefineCursor(_x.display, _x.drawable);
221 	XFlush(_x.display);
222 }
223 
224 
225 void
226 xsetcursor(Cursor *c)
227 {
228 	XColor fg, bg;
229 	XCursor xc;
230 	Pixmap xsrc, xmask;
231 	int i;
232 	uchar src[2*16], mask[2*16];
233 
234 	if(c == nil){
235 		xcursorarrow();
236 		return;
237 	}
238 	for(i=0; i<2*16; i++){
239 		src[i] = revbyte(c->set[i]);
240 		mask[i] = revbyte(c->set[i] | c->clr[i]);
241 	}
242 
243 	fg = _x.map[0];
244 	bg = _x.map[255];
245 	xsrc = XCreateBitmapFromData(_x.display, _x.drawable, src, 16, 16);
246 	xmask = XCreateBitmapFromData(_x.display, _x.drawable, mask, 16, 16);
247 	xc = XCreatePixmapCursor(_x.display, xsrc, xmask, &fg, &bg, -c->offset.x, -c->offset.y);
248 	if(xc != 0) {
249 		XDefineCursor(_x.display, _x.drawable, xc);
250 		if(_x.cursor != 0)
251 			XFreeCursor(_x.display, _x.cursor);
252 		_x.cursor = xc;
253 	}
254 	XFreePixmap(_x.display, xsrc);
255 	XFreePixmap(_x.display, xmask);
256 	XFlush(_x.display);
257 }
258 
259 struct {
260 	char buf[SnarfSize];
261 	QLock lk;
262 } clip;
263 
264 char*
265 xgetsnarf(XDisplay *xd)
266 {
267 	uchar *data, *xdata;
268 	Atom type;
269 	ulong len, lastlen, dummy;
270 	int fmt, i;
271 	XWindow w;
272 
273 	qlock(&clip.lk);
274 	w = XGetSelectionOwner(xd, XA_PRIMARY);
275 	if(w == _x.drawable){
276 		data = (uchar*)strdup(clip.buf);
277 		goto out;
278 	}
279 	if(w == None){
280 		data = nil;
281 		goto out;
282 	}
283 	/*
284 	 * We should be waiting for SelectionNotify here, but it might never
285 	 * come, and we have no way to time out.  Instead, we will zero the 
286 	 * property, request our buddy to fill it in for us, and wait until
287 	 * he's done.
288 	 */
289 	XChangeProperty(xd, _x.drawable, XA_PRIMARY, XA_STRING, 8, PropModeReplace, (uchar*)"", 0);
290 	XConvertSelection(xd, XA_PRIMARY, XA_STRING, None, _x.drawable, CurrentTime);
291 	XFlush(xd);
292 	lastlen = 0;
293 	for(i=0; i<30; i++){
294 		usleep(100*1000);
295 		XGetWindowProperty(xd, _x.drawable, XA_STRING, 0, 0, 0, AnyPropertyType,
296 			&type, &fmt, &dummy, &len, &data);
297 		if(lastlen == len && len > 0)
298 			break;
299 		lastlen = len;
300 	}
301 	if(i == 30){
302 		data = nil;
303 		goto out;
304 	}
305 	/* get the property */
306 	data = nil;
307 	XGetWindowProperty(xd, _x.drawable, XA_STRING, 0, SnarfSize/4, 0, 
308 		AnyPropertyType, &type, &fmt, &len, &dummy, &xdata);
309 	if(type != XA_STRING || len == 0){
310 		if(xdata)
311 			XFree(xdata);
312 		data = nil;
313 	}else{
314 		if(xdata){
315 			data = strdup((char*)xdata);
316 			XFree(xdata);
317 		}else
318 			data = nil;
319 	}
320 out:
321 	qunlock(&clip.lk);
322 	return data;
323 }
324 
325 void
326 xputsnarf(XDisplay *xd, char *data)
327 {
328 	if(strlen(data) >= SnarfSize)
329 		return;
330 	qlock(&clip.lk);
331 	strcpy(clip.buf, data);
332 	/*
333 	 * BUG: This is wrong.  Instead, we should send an event to the
334 	 * mouse connection telling it to call XSetSelectionOwner.
335 	 */
336 	XSetSelectionOwner(_x.mousecon, XA_PRIMARY, _x.drawable, CurrentTime);
337 	XFlush(xd);
338 	qunlock(&clip.lk);
339 }
340 
341 int
342 xselect(XEvent *e, XDisplay *xd)
343 {
344 	XEvent r;
345 	XSelectionRequestEvent *xe;
346 
347 	memset(&r, 0, sizeof r);
348 	xe = (XSelectionRequestEvent*)e;
349 	if(1 || xe->target == XA_STRING){
350 		qlock(&clip.lk);
351 		XChangeProperty(xd, xe->requestor, xe->property, XA_STRING, 8,
352 			PropModeReplace, (uchar*)clip.buf, strlen(clip.buf)+1);
353 		qunlock(&clip.lk);
354 		r.xselection.property = xe->property;
355 	}else{
356 		fprint(2, "asked for a %d\n", xe->target);
357 		r.xselection.property = None;
358 	}
359 
360 	r.xselection.display = xe->display;
361 	/* r.xselection.property filled above */
362 	r.xselection.target = xe->target;
363 	r.xselection.type = SelectionNotify;
364 	r.xselection.requestor = xe->requestor;
365 	r.xselection.time = xe->time;
366 	r.xselection.send_event = True;
367 	r.xselection.selection = xe->selection;
368 	XSendEvent(xd, xe->requestor, False, 0, &r);
369 	XFlush(xd);
370 	return 0;
371 }
372 
373 void
374 putsnarf(char *data)
375 {
376 	xputsnarf(_x.snarfcon, data);
377 }
378 
379 char*
380 getsnarf(void)
381 {
382 	return xgetsnarf(_x.snarfcon);
383 }
384