xwin.c@ 74414

Last change on this file since 74414 was 55123, checked in by vboxsync, 9 years ago
rdesktop 1.8.3 modified for VBox
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 101.0 KB

Line
1	/* -- c-basic-offset: 8 --
2	rdesktop: A Remote Desktop Protocol client.
3	User interface services - X Window System
4	Copyright (C) Matthew Chapman <matthewc.unsw.edu.au> 1999-2008
5	Copyright 2007-2008 Pierre Ossman <ossman@cendio.se> for Cendio AB
6	Copyright 2002-2011 Peter Astrand <astrand@cendio.se> for Cendio AB
7	Copyright 2012-2013 Henrik Andersson <hean01@cendio.se> for Cendio AB
8
9	This program is free software: you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation, either version 3 of the License, or
12	(at your option) any later version.
13
14	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with this program. If not, see <http://www.gnu.org/licenses/>.
21	*/
22
23	/*
24	* Oracle GPL Disclaimer: For the avoidance of doubt, except that if any license choice
25	* other than GPL or LGPL is available it will apply instead, Oracle elects to use only
26	* the General Public License version 2 (GPLv2) at this time for any software where
27	* a choice of GPL license versions is made available with the language indicating
28	* that GPLv2 or any later version may be used, or where a choice of which version
29	* of the GPL is applied is otherwise unspecified.
30	*/
31
32	#include <X11/Xlib.h>
33	#include <X11/Xutil.h>
34	#include <X11/Xproto.h>
35	#include <unistd.h>
36	#include <sys/time.h>
37	#include <time.h>
38	#include <errno.h>
39	#include <strings.h>
40	#include "rdesktop.h"
41	#include "xproto.h"
42	#ifdef HAVE_XRANDR
43	#include <X11/extensions/Xrandr.h>
44	#endif
45
46	extern int g_sizeopt;
47	extern int g_width;
48	extern int g_height;
49	extern int g_xpos;
50	extern int g_ypos;
51	extern int g_pos;
52	extern RD_BOOL g_sendmotion;
53	extern RD_BOOL g_fullscreen;
54	extern RD_BOOL g_grab_keyboard;
55	extern RD_BOOL g_hide_decorations;
56	extern RD_BOOL g_pending_resize;
57	extern char g_title[];
58	extern char g_seamless_spawn_cmd[];
59	/* Color depth of the RDP session.
60	As of RDP 5.1, it may be 8, 15, 16 or 24. */
61	extern int g_server_depth;
62	extern int g_win_button_size;
63
64	Display *g_display;
65	Time g_last_gesturetime;
66	static int g_x_socket;
67	static Screen *g_screen;
68	Window g_wnd;
69
70	/* SeamlessRDP support */
71	typedef struct _seamless_group
72	{
73	Window wnd;
74	unsigned long id;
75	unsigned int refcnt;
76	} seamless_group;
77	typedef struct _seamless_window
78	{
79	Window wnd;
80	unsigned long id;
81	unsigned long behind;
82	seamless_group *group;
83	int xoffset, yoffset;
84	int width, height;
85	int state; /* normal/minimized/maximized. */
86	unsigned int desktop;
87	struct timeval *position_timer;
88
89	RD_BOOL outstanding_position;
90	unsigned int outpos_serial;
91	int outpos_xoffset, outpos_yoffset;
92	int outpos_width, outpos_height;
93
94	unsigned int icon_size;
95	unsigned int icon_offset;
96	char icon_buffer[32 * 32 * 4];
97
98	struct _seamless_window *next;
99	} seamless_window;
100	static seamless_window *g_seamless_windows = NULL;
101	static unsigned long g_seamless_focused = 0;
102	static RD_BOOL g_seamless_started = False; /* Server end is up and running */
103	static RD_BOOL g_seamless_active = False; /* We are currently in seamless mode */
104	static RD_BOOL g_seamless_hidden = False; /* Desktop is hidden on server */
105	static RD_BOOL g_seamless_broken_restack = False; /* WM does not properly restack */
106	extern RD_BOOL g_seamless_rdp;
107	extern RD_BOOL g_seamless_persistent_mode;
108
109	extern uint32 g_embed_wnd;
110	RD_BOOL g_enable_compose = False;
111	RD_BOOL g_Unobscured; /* used for screenblt */
112	static GC g_gc = NULL;
113	static GC g_create_bitmap_gc = NULL;
114	static GC g_create_glyph_gc = NULL;
115	static XRectangle g_clip_rectangle;
116	static Visual *g_visual;
117	/* Color depth of the X11 visual of our window (e.g. 24 for True Color R8G8B visual).
118	This may be 32 for R8G8B8 visuals, and then the rest of the bits are undefined
119	as far as we're concerned. */
120	static int g_depth;
121	/* Bits-per-Pixel of the pixmaps we'll be using to draw on our window.
122	This may be larger than g_depth, in which case some of the bits would
123	be kept solely for alignment (e.g. 32bpp pixmaps on a 24bpp visual). */
124	static int g_bpp;
125	static XIM g_IM;
126	static XIC g_IC;
127	static XModifierKeymap *g_mod_map;
128	/* Maps logical (xmodmap -pp) pointing device buttons (0-based) back
129	to physical (1-based) indices. */
130	static unsigned char g_pointer_log_to_phys_map[32];
131	static Cursor g_current_cursor;
132	static RD_HCURSOR g_null_cursor = NULL;
133	static Atom g_protocol_atom, g_kill_atom;
134	extern Atom g_net_wm_state_atom;
135	extern Atom g_net_wm_desktop_atom;
136	static RD_BOOL g_focused;
137	static RD_BOOL g_mouse_in_wnd;
138	/* Indicates that:
139	1) visual has 15, 16 or 24 depth and the same color channel masks
140	as its RDP equivalent (implies X server is LE),
141	2) host is LE
142	This will trigger an optimization whose real value is questionable.
143	*/
144	static RD_BOOL g_compatible_arch;
145	/* Indicates whether RDP's bitmaps and our XImages have the same
146	binary format. If so, we can avoid an expensive translation.
147	Note that this can be true when g_compatible_arch is false,
148	e.g.:
149
150	RDP(LE) <-> host(BE) <-> X-Server(LE)
151
152	('host' is the machine running rdesktop; the host simply memcpy's
153	so its endianess doesn't matter)
154	*/
155	static RD_BOOL g_no_translate_image = False;
156
157	/* endianness */
158	static RD_BOOL g_host_be;
159	static RD_BOOL g_xserver_be;
160	static int g_red_shift_r, g_blue_shift_r, g_green_shift_r;
161	static int g_red_shift_l, g_blue_shift_l, g_green_shift_l;
162
163	/* software backing store */
164	extern RD_BOOL g_ownbackstore;
165	static Pixmap g_backstore = 0;
166
167	/* Moving in single app mode */
168	static RD_BOOL g_moving_wnd;
169	static int g_move_x_offset = 0;
170	static int g_move_y_offset = 0;
171	static RD_BOOL g_using_full_workarea = False;
172
173	#ifdef WITH_RDPSND
174	extern RD_BOOL g_rdpsnd;
175	#endif
176
177	/* MWM decorations */
178	#define MWM_HINTS_DECORATIONS (1L << 1)
179	#define PROP_MOTIF_WM_HINTS_ELEMENTS 5
180	typedef struct
181	{
182	unsigned long flags;
183	unsigned long functions;
184	unsigned long decorations;
185	long inputMode;
186	unsigned long status;
187	}
188	PropMotifWmHints;
189
190	typedef struct
191	{
192	uint32 red;
193	uint32 green;
194	uint32 blue;
195	}
196	PixelColour;
197
198	#define ON_ALL_SEAMLESS_WINDOWS(func, args) \
199	do { \
200	seamless_window *sw; \
201	XRectangle rect; \
202	if (!g_seamless_windows) break; \
203	for (sw = g_seamless_windows; sw; sw = sw->next) { \
204	rect.x = g_clip_rectangle.x - sw->xoffset; \
205	rect.y = g_clip_rectangle.y - sw->yoffset; \
206	rect.width = g_clip_rectangle.width; \
207	rect.height = g_clip_rectangle.height; \
208	XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded); \
209	func args; \
210	} \
211	XSetClipRectangles(g_display, g_gc, 0, 0, &g_clip_rectangle, 1, YXBanded); \
212	} while (0)
213
214	static void
215	seamless_XFillPolygon(Drawable d, XPoint * points, int npoints, int xoffset, int yoffset)
216	{
217	points[0].x -= xoffset;
218	points[0].y -= yoffset;
219	XFillPolygon(g_display, d, g_gc, points, npoints, Complex, CoordModePrevious);
220	points[0].x += xoffset;
221	points[0].y += yoffset;
222	}
223
224	static void
225	seamless_XDrawLines(Drawable d, XPoint * points, int npoints, int xoffset, int yoffset)
226	{
227	points[0].x -= xoffset;
228	points[0].y -= yoffset;
229	XDrawLines(g_display, d, g_gc, points, npoints, CoordModePrevious);
230	points[0].x += xoffset;
231	points[0].y += yoffset;
232	}
233
234	#define FILL_RECTANGLE(x,y,cx,cy)\
235	{ \
236	XFillRectangle(g_display, g_wnd, g_gc, x, y, cx, cy); \
237	ON_ALL_SEAMLESS_WINDOWS(XFillRectangle, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy)); \
238	if (g_ownbackstore) \
239	XFillRectangle(g_display, g_backstore, g_gc, x, y, cx, cy); \
240	}
241
242	#define FILL_RECTANGLE_BACKSTORE(x,y,cx,cy)\
243	{ \
244	XFillRectangle(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, cx, cy); \
245	}
246
247	#define FILL_POLYGON(p,np)\
248	{ \
249	XFillPolygon(g_display, g_wnd, g_gc, p, np, Complex, CoordModePrevious); \
250	if (g_ownbackstore) \
251	XFillPolygon(g_display, g_backstore, g_gc, p, np, Complex, CoordModePrevious); \
252	ON_ALL_SEAMLESS_WINDOWS(seamless_XFillPolygon, (sw->wnd, p, np, sw->xoffset, sw->yoffset)); \
253	}
254
255	#define DRAW_ELLIPSE(x,y,cx,cy,m)\
256	{ \
257	switch (m) \
258	{ \
259	case 0: /* Outline */ \
260	XDrawArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
261	ON_ALL_SEAMLESS_WINDOWS(XDrawArc, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy, 0, 360*64)); \
262	if (g_ownbackstore) \
263	XDrawArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
264	break; \
265	case 1: /* Filled */ \
266	XFillArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
267	ON_ALL_SEAMLESS_WINDOWS(XFillArc, (g_display, sw->wnd, g_gc, x-sw->xoffset, y-sw->yoffset, cx, cy, 0, 360*64)); \
268	if (g_ownbackstore) \
269	XFillArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
270	break; \
271	} \
272	}
273
274	/* colour maps */
275	extern RD_BOOL g_owncolmap;
276	static Colormap g_xcolmap;
277	static uint32 *g_colmap = NULL;
278
279	#define TRANSLATE(col) ( g_server_depth != 8 ? translate_colour(col) : g_owncolmap ? col : g_colmap[col] )
280	#define SET_FOREGROUND(col) XSetForeground(g_display, g_gc, TRANSLATE(col));
281	#define SET_BACKGROUND(col) XSetBackground(g_display, g_gc, TRANSLATE(col));
282
283	static int rop2_map[] = {
284	GXclear, /* 0 */
285	GXnor, /* DPon */
286	GXandInverted, /* DPna */
287	GXcopyInverted, /* Pn */
288	GXandReverse, /* PDna */
289	GXinvert, /* Dn */
290	GXxor, /* DPx */
291	GXnand, /* DPan */
292	GXand, /* DPa */
293	GXequiv, /* DPxn */
294	GXnoop, /* D */
295	GXorInverted, /* DPno */
296	GXcopy, /* P */
297	GXorReverse, /* PDno */
298	GXor, /* DPo */
299	GXset /* 1 */
300	};
301
302	#define SET_FUNCTION(rop2) { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, rop2_map[rop2]); }
303	#define RESET_FUNCTION(rop2) { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, GXcopy); }
304
305	static seamless_window *
306	sw_get_window_by_id(unsigned long id)
307	{
308	seamless_window *sw;
309	for (sw = g_seamless_windows; sw; sw = sw->next)
310	{
311	if (sw->id == id)
312	return sw;
313	}
314	return NULL;
315	}
316
317
318	static seamless_window *
319	sw_get_window_by_wnd(Window wnd)
320	{
321	seamless_window *sw;
322	for (sw = g_seamless_windows; sw; sw = sw->next)
323	{
324	if (sw->wnd == wnd)
325	return sw;
326	}
327	return NULL;
328	}
329
330
331	static void
332	sw_remove_window(seamless_window * win)
333	{
334	seamless_window sw, *prevnext = &g_seamless_windows;
335	for (sw = g_seamless_windows; sw; sw = sw->next)
336	{
337	if (sw == win)
338	{
339	*prevnext = sw->next;
340	sw->group->refcnt--;
341	if (sw->group->refcnt == 0)
342	{
343	XDestroyWindow(g_display, sw->group->wnd);
344	xfree(sw->group);
345	}
346	xfree(sw->position_timer);
347	xfree(sw);
348	return;
349	}
350	prevnext = &sw->next;
351	}
352	return;
353	}
354
355
356	/* Move all windows except wnd to new desktop */
357	static void
358	sw_all_to_desktop(Window wnd, unsigned int desktop)
359	{
360	seamless_window *sw;
361	for (sw = g_seamless_windows; sw; sw = sw->next)
362	{
363	if (sw->wnd == wnd)
364	continue;
365	if (sw->desktop != desktop)
366	{
367	ewmh_move_to_desktop(sw->wnd, desktop);
368	sw->desktop = desktop;
369	}
370	}
371	}
372
373
374	/* Send our position */
375	static void
376	sw_update_position(seamless_window * sw)
377	{
378	XWindowAttributes wa;
379	int x, y;
380	Window child_return;
381	unsigned int serial;
382
383	XGetWindowAttributes(g_display, sw->wnd, &wa);
384	XTranslateCoordinates(g_display, sw->wnd, wa.root,
385	-wa.border_width, -wa.border_width, &x, &y, &child_return);
386
387	serial = seamless_send_position(sw->id, x, y, wa.width, wa.height, 0);
388
389	sw->outstanding_position = True;
390	sw->outpos_serial = serial;
391
392	sw->outpos_xoffset = x;
393	sw->outpos_yoffset = y;
394	sw->outpos_width = wa.width;
395	sw->outpos_height = wa.height;
396	}
397
398
399	/* Check if it's time to send our position */
400	static void
401	sw_check_timers()
402	{
403	seamless_window *sw;
404	struct timeval now;
405
406	gettimeofday(&now, NULL);
407	for (sw = g_seamless_windows; sw; sw = sw->next)
408	{
409	if (timerisset(sw->position_timer) && timercmp(sw->position_timer, &now, <))
410	{
411	timerclear(sw->position_timer);
412	sw_update_position(sw);
413	}
414	}
415	}
416
417
418	static void
419	sw_restack_window(seamless_window * sw, unsigned long behind)
420	{
421	seamless_window *sw_above;
422
423	/* Remove window from stack */
424	for (sw_above = g_seamless_windows; sw_above; sw_above = sw_above->next)
425	{
426	if (sw_above->behind == sw->id)
427	break;
428	}
429
430	if (sw_above)
431	sw_above->behind = sw->behind;
432
433	/* And then add it at the new position */
434	for (sw_above = g_seamless_windows; sw_above; sw_above = sw_above->next)
435	{
436	if (sw_above->behind == behind)
437	break;
438	}
439
440	if (sw_above)
441	sw_above->behind = sw->id;
442
443	sw->behind = behind;
444	}
445
446
447	static void
448	sw_handle_restack(seamless_window * sw)
449	{
450	Status status;
451	Window root, parent, *children;
452	unsigned int nchildren, i;
453	seamless_window *sw_below;
454
455	status = XQueryTree(g_display, RootWindowOfScreen(g_screen),
456	&root, &parent, &children, &nchildren);
457	if (!status \|\| !nchildren)
458	return;
459
460	sw_below = NULL;
461
462	i = 0;
463	while (children[i] != sw->wnd)
464	{
465	i++;
466	if (i >= nchildren)
467	goto end;
468	}
469
470	for (i++; i < nchildren; i++)
471	{
472	sw_below = sw_get_window_by_wnd(children[i]);
473	if (sw_below)
474	break;
475	}
476
477	if (!sw_below && !sw->behind)
478	goto end;
479	if (sw_below && (sw_below->id == sw->behind))
480	goto end;
481
482	if (sw_below)
483	{
484	seamless_send_zchange(sw->id, sw_below->id, 0);
485	sw_restack_window(sw, sw_below->id);
486	}
487	else
488	{
489	seamless_send_zchange(sw->id, 0, 0);
490	sw_restack_window(sw, 0);
491	}
492
493	end:
494	XFree(children);
495	}
496
497
498	static seamless_group *
499	sw_find_group(unsigned long id, RD_BOOL dont_create)
500	{
501	seamless_window *sw;
502	seamless_group *sg;
503	XSetWindowAttributes attribs;
504
505	for (sw = g_seamless_windows; sw; sw = sw->next)
506	{
507	if (sw->group->id == id)
508	return sw->group;
509	}
510
511	if (dont_create)
512	return NULL;
513
514	sg = xmalloc(sizeof(seamless_group));
515
516	sg->wnd =
517	XCreateWindow(g_display, RootWindowOfScreen(g_screen), -1, -1, 1, 1, 0,
518	CopyFromParent, CopyFromParent, CopyFromParent, 0, &attribs);
519
520	sg->id = id;
521	sg->refcnt = 0;
522
523	return sg;
524	}
525
526
527	static void
528	mwm_hide_decorations(Window wnd)
529	{
530	PropMotifWmHints motif_hints;
531	Atom hintsatom;
532
533	/* setup the property */
534	motif_hints.flags = MWM_HINTS_DECORATIONS;
535	motif_hints.decorations = 0;
536
537	/* get the atom for the property */
538	hintsatom = XInternAtom(g_display, "_MOTIF_WM_HINTS", False);
539	if (!hintsatom)
540	{
541	warning("Failed to get atom _MOTIF_WM_HINTS: probably your window manager does not support MWM hints\n");
542	return;
543	}
544
545	XChangeProperty(g_display, wnd, hintsatom, hintsatom, 32, PropModeReplace,
546	(unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
547
548	}
549
550	typedef struct _sw_configurenotify_context
551	{
552	Window window;
553	unsigned long serial;
554	} sw_configurenotify_context;
555
556	/* Predicate procedure for sw_wait_configurenotify */
557	static Bool
558	sw_configurenotify_p(Display * display, XEvent * xevent, XPointer arg)
559	{
560	sw_configurenotify_context context = (sw_configurenotify_context ) arg;
561	if (xevent->xany.type == ConfigureNotify
562	&& xevent->xconfigure.window == context->window
563	&& xevent->xany.serial >= context->serial)
564	return True;
565
566	return False;
567	}
568
569	/* Wait for a ConfigureNotify, with a equal or larger serial, on the
570	specified window. The event will be removed from the queue. We
571	could use XMaskEvent(StructureNotifyMask), but we would then risk
572	throwing away crucial events like DestroyNotify.
573
574	After a ConfigureWindow, according to ICCCM section 4.1.5, we
575	should recieve a ConfigureNotify, either a real or synthetic
576	one. This indicates that the configure has been "completed".
577	However, some WMs such as several versions of Metacity fails to
578	send synthetic events. See bug
579	http://bugzilla.gnome.org/show_bug.cgi?id=322840. We need to use a
580	timeout to avoid a hang. Tk uses the same approach. */
581	static void
582	sw_wait_configurenotify(Window wnd, unsigned long serial)
583	{
584	XEvent xevent;
585	sw_configurenotify_context context;
586	struct timeval now;
587	struct timeval future;
588	RD_BOOL got = False;
589
590	context.window = wnd;
591	context.serial = serial;
592
593	gettimeofday(&future, NULL);
594	future.tv_usec += 500000;
595
596	do
597	{
598	if (XCheckIfEvent(g_display, &xevent, sw_configurenotify_p, (XPointer) & context))
599	{
600	got = True;
601	break;
602	}
603	usleep(100000);
604	gettimeofday(&now, NULL);
605	}
606	while (timercmp(&now, &future, <));
607
608	if (!got)
609	{
610	warning("Broken Window Manager: Timeout while waiting for ConfigureNotify\n");
611	}
612	}
613
614	/* Get the toplevel window, in case of reparenting */
615	static Window
616	sw_get_toplevel(Window wnd)
617	{
618	Window root, parent;
619	Window *child_list;
620	unsigned int num_children;
621
622	while (1)
623	{
624	XQueryTree(g_display, wnd, &root, &parent, &child_list, &num_children);
625	if (root == parent)
626	{
627	break;
628	}
629	else if (!parent)
630	{
631	warning("Internal error: sw_get_toplevel called with root window\n");
632	}
633
634	wnd = parent;
635	}
636
637	return wnd;
638	}
639
640
641	/* Check if wnd is already behind a window wrt stacking order */
642	static RD_BOOL
643	sw_window_is_behind(Window wnd, Window behind)
644	{
645	Window dummy1, dummy2;
646	Window *child_list;
647	unsigned int num_children;
648	unsigned int i;
649	RD_BOOL found_behind = False;
650	RD_BOOL found_wnd = False;
651
652	wnd = sw_get_toplevel(wnd);
653	behind = sw_get_toplevel(behind);
654
655	XQueryTree(g_display, RootWindowOfScreen(g_screen), &dummy1, &dummy2, &child_list,
656	&num_children);
657
658	for (i = num_children; i > 0; i--)
659	{
660	if (child_list[i-1] == behind)
661	{
662	found_behind = True;
663	}
664	else if (child_list[i-1] == wnd)
665	{
666	found_wnd = True;
667	break;
668	}
669	}
670
671	if (child_list)
672	XFree(child_list);
673
674	if (!found_wnd)
675	{
676	warning("sw_window_is_behind: Unable to find window 0x%lx\n", wnd);
677
678	if (!found_behind)
679	{
680	warning("sw_window_is_behind: Unable to find behind window 0x%lx\n",
681	behind);
682	}
683	}
684
685	return found_behind;
686	}
687
688
689	/* Test if the window manager correctly handles window restacking. In
690	particular, we are testing if it's possible to place a window
691	between two other windows. Many WMs such as Metacity can only stack
692	windows on the top or bottom. The window creation should mostly
693	match ui_seamless_create_window. */
694	static void
695	seamless_restack_test()
696	{
697	/* The goal is to have the middle window between top and
698	bottom. The middle window is initially at the top,
699	though. */
700	Window wnds[3]; /* top, middle and bottom */
701	int i;
702	XEvent xevent;
703	XWindowChanges values;
704	unsigned long restack_serial;
705
706	for (i = 0; i < 3; i++)
707	{
708	char name[64];
709	wnds[i] =
710	XCreateSimpleWindow(g_display, RootWindowOfScreen(g_screen), 0, 0, 20, 20,
711	0, 0, 0);
712	snprintf(name, sizeof(name), "SeamlessRDP restack test - window %d", i);
713	XStoreName(g_display, wnds[i], name);
714	ewmh_set_wm_name(wnds[i], name);
715
716	/* Hide decorations. Often this means that no
717	reparenting will be done, which makes the restack
718	easier. Besides, we want to mimic our other
719	seamless windows as much as possible. We must still
720	handle the case with reparenting, though. */
721	mwm_hide_decorations(wnds[i]);
722
723	/* Prevent windows from appearing in task bar */
724	XSetTransientForHint(g_display, wnds[i], RootWindowOfScreen(g_screen));
725	ewmh_set_window_popup(wnds[i]);
726
727	/* We need to catch MapNotify/ConfigureNotify */
728	XSelectInput(g_display, wnds[i], StructureNotifyMask);
729	}
730
731	/* Map Windows. Currently, we assume that XMapRaised places
732	the window on the top of the stack. Should be fairly safe;
733	the window is configured before it's mapped. */
734	XMapRaised(g_display, wnds[2]); /* bottom */
735	do
736	{
737	XWindowEvent(g_display, wnds[2], StructureNotifyMask, &xevent);
738	}
739	while (xevent.type != MapNotify);
740	XMapRaised(g_display, wnds[0]); /* top */
741	do
742	{
743	XWindowEvent(g_display, wnds[0], StructureNotifyMask, &xevent);
744	}
745	while (xevent.type != MapNotify);
746	XMapRaised(g_display, wnds[1]); /* middle */
747	do
748	{
749	XWindowEvent(g_display, wnds[1], StructureNotifyMask, &xevent);
750	}
751	while (xevent.type != MapNotify);
752
753	/* The stacking order should now be 1 - 0 - 2 */
754	if (!sw_window_is_behind(wnds[0], wnds[1]) \|\| !sw_window_is_behind(wnds[2], wnds[1]))
755	{
756	/* Ok, technically a WM is allowed to stack windows arbitrarily, but... */
757	warning("Broken Window Manager: Unable to test window restacking\n");
758	g_seamless_broken_restack = True;
759	for (i = 0; i < 3; i++)
760	XDestroyWindow(g_display, wnds[i]);
761	return;
762	}
763
764	/* Restack, using XReconfigureWMWindow, which should correctly
765	handle reparented windows as well as nonreparenting WMs. */
766	values.stack_mode = Below;
767	values.sibling = wnds[0];
768	restack_serial = XNextRequest(g_display);
769	XReconfigureWMWindow(g_display, wnds[1], DefaultScreen(g_display), CWStackMode \| CWSibling,
770	&values);
771	sw_wait_configurenotify(wnds[1], restack_serial);
772
773	/* Now verify that middle is behind top but not behind
774	bottom */
775	if (!sw_window_is_behind(wnds[1], wnds[0]))
776	{
777	warning("Broken Window Manager: doesn't handle restack (restack request was ignored)\n");
778	g_seamless_broken_restack = True;
779	}
780	else if (sw_window_is_behind(wnds[1], wnds[2]))
781	{
782	warning("Broken Window Manager: doesn't handle restack (window was moved to bottom)\n");
783	g_seamless_broken_restack = True;
784	}
785
786	/* Destroy windows */
787	for (i = 0; i < 3; i++)
788	{
789	XDestroyWindow(g_display, wnds[i]);
790	do
791	{
792	XWindowEvent(g_display, wnds[i], StructureNotifyMask, &xevent);
793	}
794	while (xevent.type != DestroyNotify);
795	}
796	}
797
798	#define SPLITCOLOUR15(colour, rv) \
799	{ \
800	rv.red = ((colour >> 7) & 0xf8) \| ((colour >> 12) & 0x7); \
801	rv.green = ((colour >> 2) & 0xf8) \| ((colour >> 8) & 0x7); \
802	rv.blue = ((colour << 3) & 0xf8) \| ((colour >> 2) & 0x7); \
803	}
804
805	#define SPLITCOLOUR16(colour, rv) \
806	{ \
807	rv.red = ((colour >> 8) & 0xf8) \| ((colour >> 13) & 0x7); \
808	rv.green = ((colour >> 3) & 0xfc) \| ((colour >> 9) & 0x3); \
809	rv.blue = ((colour << 3) & 0xf8) \| ((colour >> 2) & 0x7); \
810	} \
811
812	#define SPLITCOLOUR24(colour, rv) \
813	{ \
814	rv.blue = (colour & 0xff0000) >> 16; \
815	rv.green = (colour & 0x00ff00) >> 8; \
816	rv.red = (colour & 0x0000ff); \
817	}
818
819	#define MAKECOLOUR(pc) \
820	((pc.red >> g_red_shift_r) << g_red_shift_l) \
821	\| ((pc.green >> g_green_shift_r) << g_green_shift_l) \
822	\| ((pc.blue >> g_blue_shift_r) << g_blue_shift_l) \
823
824	#define BSWAP16(x) { x = (((x & 0xff) << 8) \| (x >> 8)); }
825	#define BSWAP24(x) { x = (((x & 0xff) << 16) \| (x >> 16) \| (x & 0xff00)); }
826	#define BSWAP32(x) { x = (((x & 0xff00ff) << 8) \| ((x >> 8) & 0xff00ff)); \
827	x = (x << 16) \| (x >> 16); }
828
829	/* The following macros output the same octet sequences
830	on both BE and LE hosts: */
831
832	#define BOUT16(o, x) { (o++) = x >> 8; (o++) = x; }
833	#define BOUT24(o, x) { (o++) = x >> 16; (o++) = x >> 8; *(o++) = x; }
834	#define BOUT32(o, x) { (o++) = x >> 24; (o++) = x >> 16; (o++) = x >> 8; (o++) = x; }
835	#define LOUT16(o, x) { (o++) = x; (o++) = x >> 8; }
836	#define LOUT24(o, x) { (o++) = x; (o++) = x >> 8; *(o++) = x >> 16; }
837	#define LOUT32(o, x) { (o++) = x; (o++) = x >> 8; (o++) = x >> 16; (o++) = x >> 24; }
838
839	static uint32
840	translate_colour(uint32 colour)
841	{
842	PixelColour pc;
843	switch (g_server_depth)
844	{
845	case 15:
846	SPLITCOLOUR15(colour, pc);
847	break;
848	case 16:
849	SPLITCOLOUR16(colour, pc);
850	break;
851	case 24:
852	case 32:
853	SPLITCOLOUR24(colour, pc);
854	break;
855	default:
856	/* Avoid warning */
857	pc.red = 0;
858	pc.green = 0;
859	pc.blue = 0;
860	break;
861	}
862	return MAKECOLOUR(pc);
863	}
864
865	/* indent is confused by UNROLL8 */
866	/* INDENT-OFF */
867
868	/* repeat and unroll, similar to bitmap.c */
869	/* potentialy any of the following translate */
870	/* functions can use repeat but just doing */
871	/* the most common ones */
872
873	#define UNROLL8(stm) { stm stm stm stm stm stm stm stm }
874	/* 2 byte output repeat */
875	#define REPEAT2(stm) \
876	{ \
877	while (out <= end - 8 * 2) \
878	UNROLL8(stm) \
879	while (out < end) \
880	{ stm } \
881	}
882	/* 3 byte output repeat */
883	#define REPEAT3(stm) \
884	{ \
885	while (out <= end - 8 * 3) \
886	UNROLL8(stm) \
887	while (out < end) \
888	{ stm } \
889	}
890	/* 4 byte output repeat */
891	#define REPEAT4(stm) \
892	{ \
893	while (out <= end - 8 * 4) \
894	UNROLL8(stm) \
895	while (out < end) \
896	{ stm } \
897	}
898	/* INDENT-ON */
899
900	static void
901	translate8to8(const uint8 * data, uint8 * out, uint8 * end)
902	{
903	while (out < end)
904	(out++) = (uint8) g_colmap[(data++)];
905	}
906
907	static void
908	translate8to16(const uint8 * data, uint8 * out, uint8 * end)
909	{
910	uint16 value;
911
912	if (g_compatible_arch)
913	{
914	/* INDENT-OFF */
915	REPEAT2
916	(
917	((uint16 ) out) = g_colmap[*(data++)];
918	out += 2;
919	)
920	/* INDENT-ON */
921	}
922	else if (g_xserver_be)
923	{
924	while (out < end)
925	{
926	value = (uint16) g_colmap[*(data++)];
927	BOUT16(out, value);
928	}
929	}
930	else
931	{
932	while (out < end)
933	{
934	value = (uint16) g_colmap[*(data++)];
935	LOUT16(out, value);
936	}
937	}
938	}
939
940	/* little endian - conversion happens when colourmap is built */
941	static void
942	translate8to24(const uint8 * data, uint8 * out, uint8 * end)
943	{
944	uint32 value;
945
946	if (g_compatible_arch)
947	{
948	while (out < end)
949	{
950	value = g_colmap[*(data++)];
951	BOUT24(out, value);
952	}
953	}
954	else
955	{
956	while (out < end)
957	{
958	value = g_colmap[*(data++)];
959	LOUT24(out, value);
960	}
961	}
962	}
963
964	static void
965	translate8to32(const uint8 * data, uint8 * out, uint8 * end)
966	{
967	uint32 value;
968
969	if (g_compatible_arch)
970	{
971	/* INDENT-OFF */
972	REPEAT4
973	(
974	((uint32 ) out) = g_colmap[*(data++)];
975	out += 4;
976	)
977	/* INDENT-ON */
978	}
979	else if (g_xserver_be)
980	{
981	while (out < end)
982	{
983	value = g_colmap[*(data++)];
984	BOUT32(out, value);
985	}
986	}
987	else
988	{
989	while (out < end)
990	{
991	value = g_colmap[*(data++)];
992	LOUT32(out, value);
993	}
994	}
995	}
996
997	static void
998	translate15to16(const uint16 * data, uint8 * out, uint8 * end)
999	{
1000	uint16 pixel;
1001	uint16 value;
1002	PixelColour pc;
1003
1004	if (g_xserver_be)
1005	{
1006	while (out < end)
1007	{
1008	pixel = *(data++);
1009	if (g_host_be)
1010	{
1011	BSWAP16(pixel);
1012	}
1013	SPLITCOLOUR15(pixel, pc);
1014	value = MAKECOLOUR(pc);
1015	BOUT16(out, value);
1016	}
1017	}
1018	else
1019	{
1020	while (out < end)
1021	{
1022	pixel = *(data++);
1023	if (g_host_be)
1024	{
1025	BSWAP16(pixel);
1026	}
1027	SPLITCOLOUR15(pixel, pc);
1028	value = MAKECOLOUR(pc);
1029	LOUT16(out, value);
1030	}
1031	}
1032	}
1033
1034	static void
1035	translate15to24(const uint16 * data, uint8 * out, uint8 * end)
1036	{
1037	uint32 value;
1038	uint16 pixel;
1039	PixelColour pc;
1040
1041	if (g_compatible_arch)
1042	{
1043	/* INDENT-OFF */
1044	REPEAT3
1045	(
1046	pixel = *(data++);
1047	SPLITCOLOUR15(pixel, pc);
1048	*(out++) = pc.blue;
1049	*(out++) = pc.green;
1050	*(out++) = pc.red;
1051	)
1052	/* INDENT-ON */
1053	}
1054	else if (g_xserver_be)
1055	{
1056	while (out < end)
1057	{
1058	pixel = *(data++);
1059	if (g_host_be)
1060	{
1061	BSWAP16(pixel);
1062	}
1063	SPLITCOLOUR15(pixel, pc);
1064	value = MAKECOLOUR(pc);
1065	BOUT24(out, value);
1066	}
1067	}
1068	else
1069	{
1070	while (out < end)
1071	{
1072	pixel = *(data++);
1073	if (g_host_be)
1074	{
1075	BSWAP16(pixel);
1076	}
1077	SPLITCOLOUR15(pixel, pc);
1078	value = MAKECOLOUR(pc);
1079	LOUT24(out, value);
1080	}
1081	}
1082	}
1083
1084	static void
1085	translate15to32(const uint16 * data, uint8 * out, uint8 * end)
1086	{
1087	uint16 pixel;
1088	uint32 value;
1089	PixelColour pc;
1090
1091	if (g_compatible_arch)
1092	{
1093	/* INDENT-OFF */
1094	REPEAT4
1095	(
1096	pixel = *(data++);
1097	SPLITCOLOUR15(pixel, pc);
1098	*(out++) = pc.blue;
1099	*(out++) = pc.green;
1100	*(out++) = pc.red;
1101	*(out++) = 0;
1102	)
1103	/* INDENT-ON */
1104	}
1105	else if (g_xserver_be)
1106	{
1107	while (out < end)
1108	{
1109	pixel = *(data++);
1110	if (g_host_be)
1111	{
1112	BSWAP16(pixel);
1113	}
1114	SPLITCOLOUR15(pixel, pc);
1115	value = MAKECOLOUR(pc);
1116	BOUT32(out, value);
1117	}
1118	}
1119	else
1120	{
1121	while (out < end)
1122	{
1123	pixel = *(data++);
1124	if (g_host_be)
1125	{
1126	BSWAP16(pixel);
1127	}
1128	SPLITCOLOUR15(pixel, pc);
1129	value = MAKECOLOUR(pc);
1130	LOUT32(out, value);
1131	}
1132	}
1133	}
1134
1135	static void
1136	translate16to16(const uint16 * data, uint8 * out, uint8 * end)
1137	{
1138	uint16 pixel;
1139	uint16 value;
1140	PixelColour pc;
1141
1142	if (g_xserver_be)
1143	{
1144	if (g_host_be)
1145	{
1146	while (out < end)
1147	{
1148	pixel = *(data++);
1149	BSWAP16(pixel);
1150	SPLITCOLOUR16(pixel, pc);
1151	value = MAKECOLOUR(pc);
1152	BOUT16(out, value);
1153	}
1154	}
1155	else
1156	{
1157	while (out < end)
1158	{
1159	pixel = *(data++);
1160	SPLITCOLOUR16(pixel, pc);
1161	value = MAKECOLOUR(pc);
1162	BOUT16(out, value);
1163	}
1164	}
1165	}
1166	else
1167	{
1168	if (g_host_be)
1169	{
1170	while (out < end)
1171	{
1172	pixel = *(data++);
1173	BSWAP16(pixel);
1174	SPLITCOLOUR16(pixel, pc);
1175	value = MAKECOLOUR(pc);
1176	LOUT16(out, value);
1177	}
1178	}
1179	else
1180	{
1181	while (out < end)
1182	{
1183	pixel = *(data++);
1184	SPLITCOLOUR16(pixel, pc);
1185	value = MAKECOLOUR(pc);
1186	LOUT16(out, value);
1187	}
1188	}
1189	}
1190	}
1191
1192	static void
1193	translate16to24(const uint16 * data, uint8 * out, uint8 * end)
1194	{
1195	uint32 value;
1196	uint16 pixel;
1197	PixelColour pc;
1198
1199	if (g_compatible_arch)
1200	{
1201	/* INDENT-OFF */
1202	REPEAT3
1203	(
1204	pixel = *(data++);
1205	SPLITCOLOUR16(pixel, pc);
1206	*(out++) = pc.blue;
1207	*(out++) = pc.green;
1208	*(out++) = pc.red;
1209	)
1210	/* INDENT-ON */
1211	}
1212	else if (g_xserver_be)
1213	{
1214	if (g_host_be)
1215	{
1216	while (out < end)
1217	{
1218	pixel = *(data++);
1219	BSWAP16(pixel);
1220	SPLITCOLOUR16(pixel, pc);
1221	value = MAKECOLOUR(pc);
1222	BOUT24(out, value);
1223	}
1224	}
1225	else
1226	{
1227	while (out < end)
1228	{
1229	pixel = *(data++);
1230	SPLITCOLOUR16(pixel, pc);
1231	value = MAKECOLOUR(pc);
1232	BOUT24(out, value);
1233	}
1234	}
1235	}
1236	else
1237	{
1238	if (g_host_be)
1239	{
1240	while (out < end)
1241	{
1242	pixel = *(data++);
1243	BSWAP16(pixel);
1244	SPLITCOLOUR16(pixel, pc);
1245	value = MAKECOLOUR(pc);
1246	LOUT24(out, value);
1247	}
1248	}
1249	else
1250	{
1251	while (out < end)
1252	{
1253	pixel = *(data++);
1254	SPLITCOLOUR16(pixel, pc);
1255	value = MAKECOLOUR(pc);
1256	LOUT24(out, value);
1257	}
1258	}
1259	}
1260	}
1261
1262	static void
1263	translate16to32(const uint16 * data, uint8 * out, uint8 * end)
1264	{
1265	uint16 pixel;
1266	uint32 value;
1267	PixelColour pc;
1268
1269	if (g_compatible_arch)
1270	{
1271	/* INDENT-OFF */
1272	REPEAT4
1273	(
1274	pixel = *(data++);
1275	SPLITCOLOUR16(pixel, pc);
1276	*(out++) = pc.blue;
1277	*(out++) = pc.green;
1278	*(out++) = pc.red;
1279	*(out++) = 0;
1280	)
1281	/* INDENT-ON */
1282	}
1283	else if (g_xserver_be)
1284	{
1285	if (g_host_be)
1286	{
1287	while (out < end)
1288	{
1289	pixel = *(data++);
1290	BSWAP16(pixel);
1291	SPLITCOLOUR16(pixel, pc);
1292	value = MAKECOLOUR(pc);
1293	BOUT32(out, value);
1294	}
1295	}
1296	else
1297	{
1298	while (out < end)
1299	{
1300	pixel = *(data++);
1301	SPLITCOLOUR16(pixel, pc);
1302	value = MAKECOLOUR(pc);
1303	BOUT32(out, value);
1304	}
1305	}
1306	}
1307	else
1308	{
1309	if (g_host_be)
1310	{
1311	while (out < end)
1312	{
1313	pixel = *(data++);
1314	BSWAP16(pixel);
1315	SPLITCOLOUR16(pixel, pc);
1316	value = MAKECOLOUR(pc);
1317	LOUT32(out, value);
1318	}
1319	}
1320	else
1321	{
1322	while (out < end)
1323	{
1324	pixel = *(data++);
1325	SPLITCOLOUR16(pixel, pc);
1326	value = MAKECOLOUR(pc);
1327	LOUT32(out, value);
1328	}
1329	}
1330	}
1331	}
1332
1333	static void
1334	translate24to16(const uint8 * data, uint8 * out, uint8 * end)
1335	{
1336	uint32 pixel = 0;
1337	uint16 value;
1338	PixelColour pc;
1339
1340	while (out < end)
1341	{
1342	pixel = *(data++) << 16;
1343	pixel \|= *(data++) << 8;
1344	pixel \|= *(data++);
1345	SPLITCOLOUR24(pixel, pc);
1346	value = MAKECOLOUR(pc);
1347	if (g_xserver_be)
1348	{
1349	BOUT16(out, value);
1350	}
1351	else
1352	{
1353	LOUT16(out, value);
1354	}
1355	}
1356	}
1357
1358	static void
1359	translate24to24(const uint8 * data, uint8 * out, uint8 * end)
1360	{
1361	uint32 pixel;
1362	uint32 value;
1363	PixelColour pc;
1364
1365	if (g_xserver_be)
1366	{
1367	while (out < end)
1368	{
1369	pixel = *(data++) << 16;
1370	pixel \|= *(data++) << 8;
1371	pixel \|= *(data++);
1372	SPLITCOLOUR24(pixel, pc);
1373	value = MAKECOLOUR(pc);
1374	BOUT24(out, value);
1375	}
1376	}
1377	else
1378	{
1379	while (out < end)
1380	{
1381	pixel = *(data++) << 16;
1382	pixel \|= *(data++) << 8;
1383	pixel \|= *(data++);
1384	SPLITCOLOUR24(pixel, pc);
1385	value = MAKECOLOUR(pc);
1386	LOUT24(out, value);
1387	}
1388	}
1389	}
1390
1391	static void
1392	translate24to32(const uint8 * data, uint8 * out, uint8 * end)
1393	{
1394	uint32 pixel;
1395	uint32 value;
1396	PixelColour pc;
1397
1398	if (g_compatible_arch)
1399	{
1400	/* INDENT-OFF */
1401	#ifdef NEED_ALIGN
1402	REPEAT4
1403	(
1404	(out++) = (data++);
1405	(out++) = (data++);
1406	(out++) = (data++);
1407	*(out++) = 0;
1408	)
1409	#else
1410	REPEAT4
1411	(
1412	/* Only read 3 bytes. Reading 4 bytes means reading beyond buffer. */
1413	((uint32 ) out) = ((uint16 ) data) + (((uint8 ) data + 2) << 16);
1414	out += 4;
1415	data += 3;
1416	)
1417	#endif
1418	/* INDENT-ON */
1419	}
1420	else if (g_xserver_be)
1421	{
1422	while (out < end)
1423	{
1424	pixel = *(data++) << 16;
1425	pixel \|= *(data++) << 8;
1426	pixel \|= *(data++);
1427	SPLITCOLOUR24(pixel, pc);
1428	value = MAKECOLOUR(pc);
1429	BOUT32(out, value);
1430	}
1431	}
1432	else
1433	{
1434	while (out < end)
1435	{
1436	pixel = *(data++) << 16;
1437	pixel \|= *(data++) << 8;
1438	pixel \|= *(data++);
1439	SPLITCOLOUR24(pixel, pc);
1440	value = MAKECOLOUR(pc);
1441	LOUT32(out, value);
1442	}
1443	}
1444	}
1445
1446	static uint8 *
1447	translate_image(int width, int height, uint8 * data)
1448	{
1449	int size;
1450	uint8 *out;
1451	uint8 *end;
1452
1453	/*
1454	If RDP depth and X Visual depths match,
1455	and arch(endian) matches, no need to translate:
1456	just return data.
1457	Note: select_visual should've already ensured g_no_translate
1458	is only set for compatible depths, but the RDP depth might've
1459	changed during connection negotiations.
1460	*/
1461
1462	/* todo */
1463	if (g_server_depth == 32 && g_depth == 24)
1464	{
1465	return data;
1466	}
1467
1468	if (g_no_translate_image)
1469	{
1470	if ((g_depth == 15 && g_server_depth == 15) \|\|
1471	(g_depth == 16 && g_server_depth == 16) \|\|
1472	(g_depth == 24 && g_server_depth == 24))
1473	return data;
1474	}
1475
1476	size = width * height * (g_bpp / 8);
1477	out = (uint8 *) xmalloc(size);
1478	end = out + size;
1479
1480	switch (g_server_depth)
1481	{
1482	case 24:
1483	switch (g_bpp)
1484	{
1485	case 32:
1486	translate24to32(data, out, end);
1487	break;
1488	case 24:
1489	translate24to24(data, out, end);
1490	break;
1491	case 16:
1492	translate24to16(data, out, end);
1493	break;
1494	}
1495	break;
1496	case 16:
1497	switch (g_bpp)
1498	{
1499	case 32:
1500	translate16to32((uint16 *) data, out, end);
1501	break;
1502	case 24:
1503	translate16to24((uint16 *) data, out, end);
1504	break;
1505	case 16:
1506	translate16to16((uint16 *) data, out, end);
1507	break;
1508	}
1509	break;
1510	case 15:
1511	switch (g_bpp)
1512	{
1513	case 32:
1514	translate15to32((uint16 *) data, out, end);
1515	break;
1516	case 24:
1517	translate15to24((uint16 *) data, out, end);
1518	break;
1519	case 16:
1520	translate15to16((uint16 *) data, out, end);
1521	break;
1522	}
1523	break;
1524	case 8:
1525	switch (g_bpp)
1526	{
1527	case 8:
1528	translate8to8(data, out, end);
1529	break;
1530	case 16:
1531	translate8to16(data, out, end);
1532	break;
1533	case 24:
1534	translate8to24(data, out, end);
1535	break;
1536	case 32:
1537	translate8to32(data, out, end);
1538	break;
1539	}
1540	break;
1541	}
1542	return out;
1543	}
1544
1545	static void
1546	xwin_refresh_pointer_map(void)
1547	{
1548	unsigned char phys_to_log_map[sizeof(g_pointer_log_to_phys_map)];
1549	int i, pointer_buttons;
1550
1551	pointer_buttons = XGetPointerMapping(g_display, phys_to_log_map, sizeof(phys_to_log_map));
1552	if (pointer_buttons > sizeof(phys_to_log_map))
1553	pointer_buttons = sizeof(phys_to_log_map);
1554
1555	/* if multiple physical buttons map to the same logical button, then
1556	* use the lower numbered physical one */
1557	for (i = pointer_buttons - 1; i >= 0; i--)
1558	{
1559	/* a user could specify arbitrary values for the logical button
1560	* number, ignore any that are abnormally large */
1561	if (phys_to_log_map[i] > sizeof(g_pointer_log_to_phys_map))
1562	continue;
1563	g_pointer_log_to_phys_map[phys_to_log_map[i] - 1] = i + 1;
1564	}
1565	}
1566
1567	RD_BOOL
1568	get_key_state(unsigned int state, uint32 keysym)
1569	{
1570	int modifierpos, key, keysymMask = 0;
1571	int offset;
1572
1573	KeyCode keycode = XKeysymToKeycode(g_display, keysym);
1574
1575	if (keycode == NoSymbol)
1576	return False;
1577
1578	for (modifierpos = 0; modifierpos < 8; modifierpos++)
1579	{
1580	offset = g_mod_map->max_keypermod * modifierpos;
1581
1582	for (key = 0; key < g_mod_map->max_keypermod; key++)
1583	{
1584	if (g_mod_map->modifiermap[offset + key] == keycode)
1585	keysymMask \|= 1 << modifierpos;
1586	}
1587	}
1588
1589	return (state & keysymMask) ? True : False;
1590	}
1591
1592	static void
1593	calculate_shifts(uint32 mask, int shift_r, int shift_l)
1594	{
1595	*shift_l = ffs(mask) - 1;
1596	mask >>= *shift_l;
1597	*shift_r = 8 - ffs(mask & ~(mask >> 1));
1598	}
1599
1600	/* Given a mask of a colour channel (e.g. XVisualInfo.red_mask),
1601	calculates the bits-per-pixel of this channel (a.k.a. colour weight).
1602	*/
1603	static unsigned
1604	calculate_mask_weight(uint32 mask)
1605	{
1606	unsigned weight = 0;
1607	do
1608	{
1609	weight += (mask & 1);
1610	}
1611	while (mask >>= 1);
1612	return weight;
1613	}
1614
1615	static RD_BOOL
1616	select_visual(int screen_num)
1617	{
1618	XPixmapFormatValues *pfm;
1619	int pixmap_formats_count, visuals_count;
1620	XVisualInfo *vmatches = NULL;
1621	XVisualInfo template;
1622	int i;
1623	unsigned red_weight, blue_weight, green_weight;
1624
1625	red_weight = blue_weight = green_weight = 0;
1626
1627	if (g_server_depth == -1)
1628	{
1629	g_server_depth = DisplayPlanes(g_display, DefaultScreen(g_display));
1630	}
1631
1632	pfm = XListPixmapFormats(g_display, &pixmap_formats_count);
1633	if (pfm == NULL)
1634	{
1635	error("Unable to get list of pixmap formats from display.\n");
1636	XCloseDisplay(g_display);
1637	return False;
1638	}
1639
1640	/* Search for best TrueColor visual */
1641	template.class = TrueColor;
1642	template.screen = screen_num;
1643	vmatches =
1644	XGetVisualInfo(g_display, VisualClassMask \| VisualScreenMask, &template,
1645	&visuals_count);
1646	g_visual = NULL;
1647	g_no_translate_image = False;
1648	g_compatible_arch = False;
1649	if (vmatches != NULL)
1650	{
1651	for (i = 0; i < visuals_count; ++i)
1652	{
1653	XVisualInfo *visual_info = &vmatches[i];
1654	RD_BOOL can_translate_to_bpp = False;
1655	int j;
1656
1657	/* Try to find a no-translation visual that'll
1658	allow us to use RDP bitmaps directly as ZPixmaps. */
1659	if (!g_xserver_be && (((visual_info->depth == 15) &&
1660	/* R5G5B5 */
1661	(visual_info->red_mask == 0x7c00) &&
1662	(visual_info->green_mask == 0x3e0) &&
1663	(visual_info->blue_mask == 0x1f)) \|\|
1664	((visual_info->depth == 16) &&
1665	/* R5G6B5 */
1666	(visual_info->red_mask == 0xf800) &&
1667	(visual_info->green_mask == 0x7e0) &&
1668	(visual_info->blue_mask == 0x1f)) \|\|
1669	((visual_info->depth == 24) &&
1670	/* R8G8B8 */
1671	(visual_info->red_mask == 0xff0000) &&
1672	(visual_info->green_mask == 0xff00) &&
1673	(visual_info->blue_mask == 0xff))))
1674	{
1675	g_visual = visual_info->visual;
1676	g_depth = visual_info->depth;
1677	g_compatible_arch = !g_host_be;
1678	g_no_translate_image = (visual_info->depth == g_server_depth);
1679	if (g_no_translate_image)
1680	/* We found the best visual */
1681	break;
1682	}
1683	else
1684	{
1685	g_compatible_arch = False;
1686	}
1687
1688	if (visual_info->depth > 24)
1689	{
1690	/* Avoid 32-bit visuals and likes like the plague.
1691	They're either untested or proven to work bad
1692	(e.g. nvidia's Composite 32-bit visual).
1693	Most implementation offer a 24-bit visual anyway. */
1694	continue;
1695	}
1696
1697	/* Only care for visuals, for whose BPPs (not depths!)
1698	we have a translateXtoY function. */
1699	for (j = 0; j < pixmap_formats_count; ++j)
1700	{
1701	if (pfm[j].depth == visual_info->depth)
1702	{
1703	if ((pfm[j].bits_per_pixel == 16) \|\|
1704	(pfm[j].bits_per_pixel == 24) \|\|
1705	(pfm[j].bits_per_pixel == 32))
1706	{
1707	can_translate_to_bpp = True;
1708	}
1709	break;
1710	}
1711	}
1712
1713	/* Prefer formats which have the most colour depth.
1714	We're being truly aristocratic here, minding each
1715	weight on its own. */
1716	if (can_translate_to_bpp)
1717	{
1718	unsigned vis_red_weight =
1719	calculate_mask_weight(visual_info->red_mask);
1720	unsigned vis_green_weight =
1721	calculate_mask_weight(visual_info->green_mask);
1722	unsigned vis_blue_weight =
1723	calculate_mask_weight(visual_info->blue_mask);
1724	if ((vis_red_weight >= red_weight)
1725	&& (vis_green_weight >= green_weight)
1726	&& (vis_blue_weight >= blue_weight))
1727	{
1728	red_weight = vis_red_weight;
1729	green_weight = vis_green_weight;
1730	blue_weight = vis_blue_weight;
1731	g_visual = visual_info->visual;
1732	g_depth = visual_info->depth;
1733	}
1734	}
1735	}
1736	XFree(vmatches);
1737	}
1738
1739	if (g_visual != NULL)
1740	{
1741	g_owncolmap = False;
1742	calculate_shifts(g_visual->red_mask, &g_red_shift_r, &g_red_shift_l);
1743	calculate_shifts(g_visual->green_mask, &g_green_shift_r, &g_green_shift_l);
1744	calculate_shifts(g_visual->blue_mask, &g_blue_shift_r, &g_blue_shift_l);
1745	}
1746	else
1747	{
1748	template.class = PseudoColor;
1749	template.depth = 8;
1750	template.colormap_size = 256;
1751	vmatches =
1752	XGetVisualInfo(g_display,
1753	VisualClassMask \| VisualDepthMask \| VisualColormapSizeMask,
1754	&template, &visuals_count);
1755	if (vmatches == NULL)
1756	{
1757	error("No usable TrueColor or PseudoColor visuals on this display.\n");
1758	XCloseDisplay(g_display);
1759	XFree(pfm);
1760	return False;
1761	}
1762
1763	/* we use a colourmap, so the default visual should do */
1764	g_owncolmap = True;
1765	g_visual = vmatches[0].visual;
1766	g_depth = vmatches[0].depth;
1767	}
1768
1769	g_bpp = 0;
1770	for (i = 0; i < pixmap_formats_count; ++i)
1771	{
1772	XPixmapFormatValues *pf = &pfm[i];
1773	if (pf->depth == g_depth)
1774	{
1775	g_bpp = pf->bits_per_pixel;
1776
1777	if (g_no_translate_image)
1778	{
1779	switch (g_server_depth)
1780	{
1781	case 15:
1782	case 16:
1783	if (g_bpp != 16)
1784	g_no_translate_image = False;
1785	break;
1786	case 24:
1787	/* Yes, this will force image translation
1788	on most modern servers which use 32 bits
1789	for R8G8B8. */
1790	if (g_bpp != 24)
1791	g_no_translate_image = False;
1792	break;
1793	default:
1794	g_no_translate_image = False;
1795	break;
1796	}
1797	}
1798
1799	/* Pixmap formats list is a depth-to-bpp mapping --
1800	there's just a single entry for every depth,
1801	so we can safely break here */
1802	break;
1803	}
1804	}
1805	XFree(pfm);
1806	pfm = NULL;
1807	return True;
1808	}
1809
1810	static XErrorHandler g_old_error_handler;
1811	static RD_BOOL g_error_expected = False;
1812
1813	/* Check if the X11 window corresponding to a seamless window with
1814	specified id exists. */
1815	RD_BOOL
1816	sw_window_exists(unsigned long id)
1817	{
1818	seamless_window *sw;
1819	char *name;
1820	Status sts = 0;
1821
1822	sw = sw_get_window_by_id(id);
1823	if (!sw)
1824	return False;
1825
1826	g_error_expected = True;
1827	sts = XFetchName(g_display, sw->wnd, &name);
1828	g_error_expected = False;
1829	if (sts)
1830	{
1831	XFree(name);
1832	}
1833
1834	return sts;
1835	}
1836
1837	static int
1838	error_handler(Display * dpy, XErrorEvent * eev)
1839	{
1840	if (g_error_expected)
1841	return 0;
1842
1843	return g_old_error_handler(dpy, eev);
1844	}
1845
1846	/* Initialize the UI. This is done once per process. */
1847	RD_BOOL
1848	ui_init(void)
1849	{
1850	int screen_num;
1851
1852	g_display = XOpenDisplay(NULL);
1853	if (g_display == NULL)
1854	{
1855	error("Failed to open display: %s\n", XDisplayName(NULL));
1856	return False;
1857	}
1858
1859	{
1860	uint16 endianess_test = 1;
1861	g_host_be = !(RD_BOOL) ((uint8 ) (&endianess_test));
1862	}
1863
1864	g_old_error_handler = XSetErrorHandler(error_handler);
1865	g_xserver_be = (ImageByteOrder(g_display) == MSBFirst);
1866	screen_num = DefaultScreen(g_display);
1867	g_x_socket = ConnectionNumber(g_display);
1868	g_screen = ScreenOfDisplay(g_display, screen_num);
1869	g_depth = DefaultDepthOfScreen(g_screen);
1870
1871	if (!select_visual(screen_num))
1872	return False;
1873
1874	if (g_no_translate_image)
1875	{
1876	DEBUG(("Performance optimization possible: avoiding image translation (colour depth conversion).\n"));
1877	}
1878
1879	if (g_server_depth > g_bpp)
1880	{
1881	warning("Remote desktop colour depth %d higher than display colour depth %d.\n",
1882	g_server_depth, g_bpp);
1883	}
1884
1885	DEBUG(("RDP depth: %d, display depth: %d, display bpp: %d, X server BE: %d, host BE: %d\n",
1886	g_server_depth, g_depth, g_bpp, g_xserver_be, g_host_be));
1887
1888	if (!g_owncolmap)
1889	{
1890	g_xcolmap =
1891	XCreateColormap(g_display, RootWindowOfScreen(g_screen), g_visual,
1892	AllocNone);
1893	if (g_depth <= 8)
1894	warning("Display colour depth is %d bit: you may want to use -C for a private colourmap.\n", g_depth);
1895	}
1896
1897	if ((!g_ownbackstore) && (DoesBackingStore(g_screen) != Always))
1898	{
1899	warning("External BackingStore not available. Using internal.\n");
1900	g_ownbackstore = True;
1901	}
1902
1903	g_mod_map = XGetModifierMapping(g_display);
1904	xwin_refresh_pointer_map();
1905
1906	xkeymap_init();
1907
1908	if (g_enable_compose)
1909	g_IM = XOpenIM(g_display, NULL, NULL, NULL);
1910
1911	xclip_init();
1912	ewmh_init();
1913	if (g_seamless_rdp)
1914	{
1915	seamless_init();
1916	}
1917
1918	DEBUG_RDP5(("server bpp %d client bpp %d depth %d\n", g_server_depth, g_bpp, g_depth));
1919
1920	return True;
1921	}
1922
1923
1924	/*
1925	Initialize connection specific data, such as session size.
1926	*/
1927	void
1928	ui_init_connection(void)
1929	{
1930	/*
1931	* Determine desktop size
1932	*/
1933	if (g_fullscreen)
1934	{
1935	g_width = WidthOfScreen(g_screen);
1936	g_height = HeightOfScreen(g_screen);
1937	g_using_full_workarea = True;
1938	}
1939	else if (g_sizeopt < 0)
1940	{
1941	/* Percent of screen */
1942	if (-g_sizeopt >= 100)
1943	g_using_full_workarea = True;
1944	g_height = HeightOfScreen(g_screen) * (-g_sizeopt) / 100;
1945	g_width = WidthOfScreen(g_screen) * (-g_sizeopt) / 100;
1946	}
1947	else if (g_sizeopt == 1)
1948	{
1949	/* Fetch geometry from _NET_WORKAREA */
1950	uint32 x, y, cx, cy;
1951	if (get_current_workarea(&x, &y, &cx, &cy) == 0)
1952	{
1953	g_width = cx;
1954	g_height = cy;
1955	g_using_full_workarea = True;
1956	}
1957	else
1958	{
1959	warning("Failed to get workarea: probably your window manager does not support extended hints\n");
1960	g_width = WidthOfScreen(g_screen);
1961	g_height = HeightOfScreen(g_screen);
1962	}
1963	}
1964
1965	/* make sure width is a multiple of 4 */
1966	g_width = (g_width + 3) & ~3;
1967	}
1968
1969
1970	void
1971	ui_deinit(void)
1972	{
1973	xclip_deinit();
1974
1975	if (g_IM != NULL)
1976	XCloseIM(g_IM);
1977
1978	if (g_null_cursor != NULL)
1979	ui_destroy_cursor(g_null_cursor);
1980
1981	XFreeModifiermap(g_mod_map);
1982
1983	XFreeGC(g_display, g_gc);
1984	XCloseDisplay(g_display);
1985	g_display = NULL;
1986	}
1987
1988
1989	static void
1990	get_window_attribs(XSetWindowAttributes * attribs)
1991	{
1992	attribs->background_pixel = BlackPixelOfScreen(g_screen);
1993	attribs->border_pixel = WhitePixelOfScreen(g_screen);
1994	attribs->backing_store = g_ownbackstore ? NotUseful : Always;
1995	attribs->override_redirect = g_fullscreen;
1996	attribs->colormap = g_xcolmap;
1997	}
1998
1999	static void
2000	get_input_mask(long *input_mask)
2001	{
2002	*input_mask = KeyPressMask \| KeyReleaseMask \| ButtonPressMask \| ButtonReleaseMask \|
2003	VisibilityChangeMask \| FocusChangeMask \| StructureNotifyMask;
2004
2005	if (g_sendmotion)
2006	*input_mask \|= PointerMotionMask;
2007	if (g_ownbackstore)
2008	*input_mask \|= ExposureMask;
2009	if (g_fullscreen \|\| g_grab_keyboard)
2010	*input_mask \|= EnterWindowMask;
2011	if (g_grab_keyboard)
2012	*input_mask \|= LeaveWindowMask;
2013	}
2014
2015	RD_BOOL
2016	ui_create_window(void)
2017	{
2018	uint8 null_pointer_mask[1] = { 0x80 };
2019	uint8 null_pointer_data[24] = { 0x00 };
2020
2021	XSetWindowAttributes attribs;
2022	XClassHint *classhints;
2023	XSizeHints *sizehints;
2024	int wndwidth, wndheight;
2025	long input_mask, ic_input_mask;
2026	XEvent xevent;
2027
2028	wndwidth = g_fullscreen ? WidthOfScreen(g_screen) : g_width;
2029	wndheight = g_fullscreen ? HeightOfScreen(g_screen) : g_height;
2030
2031	/* Handle -x-y portion of geometry string */
2032	if (g_xpos < 0 \|\| (g_xpos == 0 && (g_pos & 2)))
2033	g_xpos = WidthOfScreen(g_screen) + g_xpos - g_width;
2034	if (g_ypos < 0 \|\| (g_ypos == 0 && (g_pos & 4)))
2035	g_ypos = HeightOfScreen(g_screen) + g_ypos - g_height;
2036
2037	get_window_attribs(&attribs);
2038
2039	g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), g_xpos, g_ypos, wndwidth,
2040	wndheight, 0, g_depth, InputOutput, g_visual,
2041	CWBackPixel \| CWBackingStore \| CWOverrideRedirect \| CWColormap \|
2042	CWBorderPixel, &attribs);
2043
2044	if (g_gc == NULL)
2045	{
2046	g_gc = XCreateGC(g_display, g_wnd, 0, NULL);
2047	ui_reset_clip();
2048	}
2049
2050	if (g_create_bitmap_gc == NULL)
2051	g_create_bitmap_gc = XCreateGC(g_display, g_wnd, 0, NULL);
2052
2053	if ((g_ownbackstore) && (g_backstore == 0))
2054	{
2055	g_backstore = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
2056
2057	/* clear to prevent rubbish being exposed at startup */
2058	XSetForeground(g_display, g_gc, BlackPixelOfScreen(g_screen));
2059	XFillRectangle(g_display, g_backstore, g_gc, 0, 0, g_width, g_height);
2060	}
2061
2062	XStoreName(g_display, g_wnd, g_title);
2063	ewmh_set_wm_name(g_wnd, g_title);
2064
2065	if (g_hide_decorations)
2066	mwm_hide_decorations(g_wnd);
2067
2068	classhints = XAllocClassHint();
2069	if (classhints != NULL)
2070	{
2071	classhints->res_name = classhints->res_class = "rdesktop";
2072	XSetClassHint(g_display, g_wnd, classhints);
2073	XFree(classhints);
2074	}
2075
2076	sizehints = XAllocSizeHints();
2077	if (sizehints)
2078	{
2079	sizehints->flags = PMinSize \| PMaxSize;
2080	if (g_pos)
2081	sizehints->flags \|= PPosition;
2082	sizehints->min_width = sizehints->max_width = g_width;
2083	sizehints->min_height = sizehints->max_height = g_height;
2084	XSetWMNormalHints(g_display, g_wnd, sizehints);
2085	XFree(sizehints);
2086	}
2087
2088	if (g_embed_wnd)
2089	{
2090	XReparentWindow(g_display, g_wnd, (Window) g_embed_wnd, 0, 0);
2091	}
2092
2093	get_input_mask(&input_mask);
2094
2095	if (g_IM != NULL)
2096	{
2097	g_IC = XCreateIC(g_IM, XNInputStyle, (XIMPreeditNothing \| XIMStatusNothing),
2098	XNClientWindow, g_wnd, XNFocusWindow, g_wnd, NULL);
2099
2100	if ((g_IC != NULL)
2101	&& (XGetICValues(g_IC, XNFilterEvents, &ic_input_mask, NULL) == NULL))
2102	input_mask \|= ic_input_mask;
2103	}
2104
2105	XSelectInput(g_display, g_wnd, input_mask);
2106	#ifdef HAVE_XRANDR
2107	XSelectInput(g_display, RootWindowOfScreen(g_screen), StructureNotifyMask);
2108	#endif
2109	XMapWindow(g_display, g_wnd);
2110
2111	/* wait for VisibilityNotify */
2112	do
2113	{
2114	XMaskEvent(g_display, VisibilityChangeMask, &xevent);
2115	}
2116	while (xevent.type != VisibilityNotify);
2117	g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured;
2118
2119	g_focused = False;
2120	g_mouse_in_wnd = False;
2121
2122	/* handle the WM_DELETE_WINDOW protocol */
2123	g_protocol_atom = XInternAtom(g_display, "WM_PROTOCOLS", True);
2124	g_kill_atom = XInternAtom(g_display, "WM_DELETE_WINDOW", True);
2125	XSetWMProtocols(g_display, g_wnd, &g_kill_atom, 1);
2126
2127	/* create invisible 1x1 cursor to be used as null cursor */
2128	if (g_null_cursor == NULL)
2129	g_null_cursor =
2130	ui_create_cursor(0, 0, 1, 1, null_pointer_mask, null_pointer_data, 24);
2131
2132	if (g_seamless_rdp)
2133	{
2134	seamless_reset_state();
2135	seamless_restack_test();
2136	}
2137
2138	return True;
2139	}
2140
2141	void
2142	ui_resize_window()
2143	{
2144	XSizeHints *sizehints;
2145	Pixmap bs;
2146
2147	sizehints = XAllocSizeHints();
2148	if (sizehints)
2149	{
2150	sizehints->flags = PMinSize \| PMaxSize;
2151	sizehints->min_width = sizehints->max_width = g_width;
2152	sizehints->min_height = sizehints->max_height = g_height;
2153	XSetWMNormalHints(g_display, g_wnd, sizehints);
2154	XFree(sizehints);
2155	}
2156
2157	if (!(g_fullscreen \|\| g_embed_wnd))
2158	{
2159	XResizeWindow(g_display, g_wnd, g_width, g_height);
2160	}
2161
2162	/* create new backstore pixmap */
2163	if (g_backstore != 0)
2164	{
2165	bs = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
2166	XSetForeground(g_display, g_gc, BlackPixelOfScreen(g_screen));
2167	XFillRectangle(g_display, bs, g_gc, 0, 0, g_width, g_height);
2168	XCopyArea(g_display, g_backstore, bs, g_gc, 0, 0, g_width, g_height, 0, 0);
2169	XFreePixmap(g_display, g_backstore);
2170	g_backstore = bs;
2171	}
2172	}
2173
2174	RD_BOOL
2175	ui_have_window()
2176	{
2177	return g_wnd ? True : False;
2178	}
2179
2180	void
2181	ui_destroy_window(void)
2182	{
2183	if (g_IC != NULL)
2184	XDestroyIC(g_IC);
2185
2186	XDestroyWindow(g_display, g_wnd);
2187	g_wnd = 0;
2188
2189	if (g_backstore)
2190	{
2191	XFreePixmap(g_display, g_backstore);
2192	g_backstore = 0;
2193	}
2194	}
2195
2196	void
2197	xwin_toggle_fullscreen(void)
2198	{
2199	Pixmap contents = 0;
2200
2201	if (g_seamless_active)
2202	/* Turn off SeamlessRDP mode */
2203	ui_seamless_toggle();
2204
2205	if (!g_ownbackstore)
2206	{
2207	/* need to save contents of window */
2208	contents = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
2209	XCopyArea(g_display, g_wnd, contents, g_gc, 0, 0, g_width, g_height, 0, 0);
2210	}
2211
2212	ui_destroy_window();
2213	g_fullscreen = !g_fullscreen;
2214	ui_create_window();
2215
2216	XDefineCursor(g_display, g_wnd, g_current_cursor);
2217
2218	if (!g_ownbackstore)
2219	{
2220	XCopyArea(g_display, contents, g_wnd, g_gc, 0, 0, g_width, g_height, 0, 0);
2221	XFreePixmap(g_display, contents);
2222	}
2223	}
2224
2225	static void
2226	handle_button_event(XEvent xevent, RD_BOOL down)
2227	{
2228	uint16 button, flags = 0;
2229	g_last_gesturetime = xevent.xbutton.time;
2230	/* Reverse the pointer button mapping, e.g. in the case of
2231	"left-handed mouse mode"; the RDP session expects to
2232	receive physical buttons (true in mstsc as well) and
2233	logical button behavior depends on the remote desktop's own
2234	mouse settings */
2235	xevent.xbutton.button = g_pointer_log_to_phys_map[xevent.xbutton.button - 1];
2236	button = xkeymap_translate_button(xevent.xbutton.button);
2237	if (button == 0)
2238	return;
2239
2240	if (down)
2241	flags = MOUSE_FLAG_DOWN;
2242
2243	/* Stop moving window when button is released, regardless of cursor position */
2244	if (g_moving_wnd && (xevent.type == ButtonRelease))
2245	g_moving_wnd = False;
2246
2247	/* If win_button_size is nonzero, enable single app mode */
2248	if (xevent.xbutton.y < g_win_button_size)
2249	{
2250	/* Check from right to left: */
2251	if (xevent.xbutton.x >= g_width - g_win_button_size)
2252	{
2253	/* The close button, continue */
2254	;
2255	}
2256	else if (xevent.xbutton.x >= g_width - g_win_button_size * 2)
2257	{
2258	/* The maximize/restore button. Do not send to
2259	server. It might be a good idea to change the
2260	cursor or give some other visible indication
2261	that rdesktop inhibited this click */
2262	if (xevent.type == ButtonPress)
2263	return;
2264	}
2265	else if (xevent.xbutton.x >= g_width - g_win_button_size * 3)
2266	{
2267	/* The minimize button. Iconify window. */
2268	if (xevent.type == ButtonRelease)
2269	{
2270	/* Release the mouse button outside the minimize button, to prevent the
2271	actual minimazation to happen */
2272	rdp_send_input(time(NULL), RDP_INPUT_MOUSE, button, 1, 1);
2273	XIconifyWindow(g_display, g_wnd, DefaultScreen(g_display));
2274	return;
2275	}
2276	}
2277	else if (xevent.xbutton.x <= g_win_button_size)
2278	{
2279	/* The system menu. Ignore. */
2280	if (xevent.type == ButtonPress)
2281	return;
2282	}
2283	else
2284	{
2285	/* The title bar. */
2286	if (xevent.type == ButtonPress)
2287	{
2288	if (!g_fullscreen && g_hide_decorations && !g_using_full_workarea)
2289	{
2290	g_moving_wnd = True;
2291	g_move_x_offset = xevent.xbutton.x;
2292	g_move_y_offset = xevent.xbutton.y;
2293	}
2294	return;
2295	}
2296	}
2297	}
2298
2299	/* Ignore mouse scroll button release event which will be handled as an additional
2300	* scrolldown event on the Windows side.
2301	*/
2302	if (!down && (button == MOUSE_FLAG_BUTTON4 \|\| button == MOUSE_FLAG_BUTTON5))
2303	{
2304	return;
2305	}
2306
2307	if (xevent.xmotion.window == g_wnd)
2308	{
2309	rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
2310	flags \| button, xevent.xbutton.x, xevent.xbutton.y);
2311	}
2312	else
2313	{
2314	/* SeamlessRDP */
2315	rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
2316	flags \| button, xevent.xbutton.x_root, xevent.xbutton.y_root);
2317	}
2318	}
2319
2320
2321	/* Process events in Xlib queue
2322	Returns 0 after user quit, 1 otherwise */
2323	static int
2324	xwin_process_events(void)
2325	{
2326	XEvent xevent;
2327	KeySym keysym;
2328	uint32 ev_time;
2329	char str[256];
2330	Status status;
2331	int events = 0;
2332	seamless_window *sw;
2333
2334	while ((XPending(g_display) > 0) && events++ < 20)
2335	{
2336	XNextEvent(g_display, &xevent);
2337
2338	if (!g_wnd)
2339	/* Ignore events between ui_destroy_window and ui_create_window */
2340	continue;
2341
2342	/* Also ignore root window events except ConfigureNotify */
2343	if (xevent.type != ConfigureNotify
2344	&& xevent.xany.window == DefaultRootWindow(g_display))
2345	continue;
2346
2347	if ((g_IC != NULL) && (XFilterEvent(&xevent, None) == True))
2348	{
2349	DEBUG_KBD(("Filtering event\n"));
2350	continue;
2351	}
2352
2353	switch (xevent.type)
2354	{
2355	case VisibilityNotify:
2356	if (xevent.xvisibility.window == g_wnd)
2357	g_Unobscured =
2358	xevent.xvisibility.state == VisibilityUnobscured;
2359
2360	break;
2361	case ClientMessage:
2362	/* the window manager told us to quit */
2363	if ((xevent.xclient.message_type == g_protocol_atom)
2364	&& ((Atom) xevent.xclient.data.l[0] == g_kill_atom))
2365	{
2366	/* When killing a seamless window, close the window on the
2367	serverside instead of terminating rdesktop */
2368	sw = sw_get_window_by_wnd(xevent.xclient.window);
2369	if (!sw)
2370	/* Otherwise, quit */
2371	return 0;
2372	/* send seamless destroy process message */
2373	seamless_send_destroy(sw->id);
2374	}
2375	break;
2376
2377	case KeyPress:
2378	g_last_gesturetime = xevent.xkey.time;
2379	if (g_IC != NULL)
2380	/* Multi_key compatible version */
2381	{
2382	XmbLookupString(g_IC,
2383	&xevent.xkey, str, sizeof(str), &keysym,
2384	&status);
2385	if (!((status == XLookupKeySym) \|\| (status == XLookupBoth)))
2386	{
2387	error("XmbLookupString failed with status 0x%x\n",
2388	status);
2389	break;
2390	}
2391	}
2392	else
2393	{
2394	/* Plain old XLookupString */
2395	DEBUG_KBD(("\nNo input context, using XLookupString\n"));
2396	XLookupString((XKeyEvent *) & xevent,
2397	str, sizeof(str), &keysym, NULL);
2398	}
2399
2400	DEBUG_KBD(("KeyPress for keysym (0x%lx, %s)\n", keysym,
2401	get_ksname(keysym)));
2402
2403	set_keypress_keysym(xevent.xkey.keycode, keysym);
2404	ev_time = time(NULL);
2405	if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
2406	break;
2407
2408	xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
2409	ev_time, True, 0);
2410	break;
2411
2412	case KeyRelease:
2413	g_last_gesturetime = xevent.xkey.time;
2414	XLookupString((XKeyEvent *) & xevent, str,
2415	sizeof(str), &keysym, NULL);
2416
2417	DEBUG_KBD(("\nKeyRelease for keysym (0x%lx, %s)\n", keysym,
2418	get_ksname(keysym)));
2419
2420	keysym = reset_keypress_keysym(xevent.xkey.keycode, keysym);
2421	ev_time = time(NULL);
2422	if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
2423	break;
2424
2425	xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
2426	ev_time, False, 0);
2427	break;
2428
2429	case ButtonPress:
2430	handle_button_event(xevent, True);
2431	break;
2432
2433	case ButtonRelease:
2434	handle_button_event(xevent, False);
2435	break;
2436
2437	case MotionNotify:
2438	if (g_moving_wnd)
2439	{
2440	XMoveWindow(g_display, g_wnd,
2441	xevent.xmotion.x_root - g_move_x_offset,
2442	xevent.xmotion.y_root - g_move_y_offset);
2443	break;
2444	}
2445
2446	if (g_fullscreen && !g_focused)
2447	XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
2448	CurrentTime);
2449
2450	if (xevent.xmotion.window == g_wnd)
2451	{
2452	rdp_send_input(time(NULL), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE,
2453	xevent.xmotion.x, xevent.xmotion.y);
2454	}
2455	else
2456	{
2457	/* SeamlessRDP */
2458	rdp_send_input(time(NULL), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE,
2459	xevent.xmotion.x_root,
2460	xevent.xmotion.y_root);
2461	}
2462	break;
2463
2464	case FocusIn:
2465	if (xevent.xfocus.mode == NotifyGrab)
2466	break;
2467	g_focused = True;
2468	reset_modifier_keys();
2469	if (g_grab_keyboard && g_mouse_in_wnd)
2470	XGrabKeyboard(g_display, g_wnd, True,
2471	GrabModeAsync, GrabModeAsync, CurrentTime);
2472
2473	sw = sw_get_window_by_wnd(xevent.xfocus.window);
2474	if (!sw)
2475	break;
2476
2477	/* Menu windows are real X11 windows,
2478	with focus. When such a window is
2479	destroyed, focus is reverted to the
2480	main application window, which
2481	would cause us to send FOCUS. This
2482	breaks window switching in, say,
2483	Seamonkey. We shouldn't need to
2484	send FOCUS: Windows should also
2485	revert focus to some other window
2486	when the menu window is
2487	destroyed. So, we only send FOCUS
2488	if the previous focus window still
2489	exists. */
2490	if (sw->id != g_seamless_focused)
2491	{
2492
2493	if (sw_window_exists(g_seamless_focused))
2494	seamless_send_focus(sw->id, 0);
2495	g_seamless_focused = sw->id;
2496	}
2497	break;
2498
2499	case FocusOut:
2500	if (xevent.xfocus.mode == NotifyUngrab)
2501	break;
2502	g_focused = False;
2503	if (xevent.xfocus.mode == NotifyWhileGrabbed)
2504	XUngrabKeyboard(g_display, CurrentTime);
2505	break;
2506
2507	case EnterNotify:
2508	/* we only register for this event when in fullscreen mode */
2509	/* or grab_keyboard */
2510	g_mouse_in_wnd = True;
2511	if (g_fullscreen)
2512	{
2513	XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
2514	CurrentTime);
2515	break;
2516	}
2517	if (g_focused)
2518	XGrabKeyboard(g_display, g_wnd, True,
2519	GrabModeAsync, GrabModeAsync, CurrentTime);
2520	break;
2521
2522	case LeaveNotify:
2523	/* we only register for this event when grab_keyboard */
2524	g_mouse_in_wnd = False;
2525	XUngrabKeyboard(g_display, CurrentTime);
2526	/* VirtualBox code begin */
2527	if (g_fullscreen)
2528	{
2529	/* If mouse pointer is outside the fullscreen client window,
2530	* release it to let the client on the other screen to continue
2531	* with the mouse processing.
2532	*/
2533	XUngrabPointer(g_display, CurrentTime);
2534	}
2535	/* VirtualBox code end */
2536	break;
2537
2538	case Expose:
2539	if (xevent.xexpose.window == g_wnd)
2540	{
2541	XCopyArea(g_display, g_backstore, xevent.xexpose.window,
2542	g_gc,
2543	xevent.xexpose.x, xevent.xexpose.y,
2544	xevent.xexpose.width, xevent.xexpose.height,
2545	xevent.xexpose.x, xevent.xexpose.y);
2546	}
2547	else
2548	{
2549	sw = sw_get_window_by_wnd(xevent.xexpose.window);
2550	if (!sw)
2551	break;
2552	XCopyArea(g_display, g_backstore,
2553	xevent.xexpose.window, g_gc,
2554	xevent.xexpose.x + sw->xoffset,
2555	xevent.xexpose.y + sw->yoffset,
2556	xevent.xexpose.width,
2557	xevent.xexpose.height, xevent.xexpose.x,
2558	xevent.xexpose.y);
2559	}
2560
2561	break;
2562
2563	case MappingNotify:
2564	/* Refresh keyboard mapping if it has changed. This is important for
2565	Xvnc, since it allocates keycodes dynamically */
2566	if (xevent.xmapping.request == MappingKeyboard
2567	\|\| xevent.xmapping.request == MappingModifier)
2568	XRefreshKeyboardMapping(&xevent.xmapping);
2569
2570	if (xevent.xmapping.request == MappingModifier)
2571	{
2572	XFreeModifiermap(g_mod_map);
2573	g_mod_map = XGetModifierMapping(g_display);
2574	}
2575
2576	if (xevent.xmapping.request == MappingPointer)
2577	{
2578	xwin_refresh_pointer_map();
2579	}
2580
2581	break;
2582
2583	/* clipboard stuff */
2584	case SelectionNotify:
2585	xclip_handle_SelectionNotify(&xevent.xselection);
2586	break;
2587	case SelectionRequest:
2588	xclip_handle_SelectionRequest(&xevent.xselectionrequest);
2589	break;
2590	case SelectionClear:
2591	xclip_handle_SelectionClear();
2592	break;
2593	case PropertyNotify:
2594	xclip_handle_PropertyNotify(&xevent.xproperty);
2595	if (xevent.xproperty.window == g_wnd)
2596	break;
2597	if (xevent.xproperty.window == DefaultRootWindow(g_display))
2598	break;
2599
2600	/* seamless */
2601	sw = sw_get_window_by_wnd(xevent.xproperty.window);
2602	if (!sw)
2603	break;
2604
2605	if ((xevent.xproperty.atom == g_net_wm_state_atom)
2606	&& (xevent.xproperty.state == PropertyNewValue))
2607	{
2608	sw->state = ewmh_get_window_state(sw->wnd);
2609	seamless_send_state(sw->id, sw->state, 0);
2610	}
2611
2612	if ((xevent.xproperty.atom == g_net_wm_desktop_atom)
2613	&& (xevent.xproperty.state == PropertyNewValue))
2614	{
2615	sw->desktop = ewmh_get_window_desktop(sw->wnd);
2616	sw_all_to_desktop(sw->wnd, sw->desktop);
2617	}
2618
2619	break;
2620	case MapNotify:
2621	if (!g_seamless_active)
2622	rdp_send_client_window_status(1);
2623	break;
2624	case UnmapNotify:
2625	if (!g_seamless_active)
2626	rdp_send_client_window_status(0);
2627	break;
2628	case ConfigureNotify:
2629	#ifdef HAVE_XRANDR
2630	if ((g_sizeopt \|\| g_fullscreen)
2631	&& xevent.xconfigure.window == DefaultRootWindow(g_display))
2632	{
2633	if (xevent.xconfigure.width != WidthOfScreen(g_screen)
2634	\|\| xevent.xconfigure.height != HeightOfScreen(g_screen))
2635	{
2636	XRRUpdateConfiguration(&xevent);
2637	XSync(g_display, False);
2638	g_pending_resize = True;
2639	}
2640
2641	}
2642	#endif
2643	if (!g_seamless_active)
2644	break;
2645
2646	sw = sw_get_window_by_wnd(xevent.xconfigure.window);
2647	if (!sw)
2648	break;
2649
2650	gettimeofday(sw->position_timer, NULL);
2651	if (sw->position_timer->tv_usec + SEAMLESSRDP_POSITION_TIMER >=
2652	1000000)
2653	{
2654	sw->position_timer->tv_usec +=
2655	SEAMLESSRDP_POSITION_TIMER - 1000000;
2656	sw->position_timer->tv_sec += 1;
2657	}
2658	else
2659	{
2660	sw->position_timer->tv_usec += SEAMLESSRDP_POSITION_TIMER;
2661	}
2662
2663	sw_handle_restack(sw);
2664	break;
2665	}
2666	}
2667	/* Keep going */
2668	return 1;
2669	}
2670
2671	/* Returns 0 after user quit, 1 otherwise */
2672	int
2673	ui_select(int rdp_socket)
2674	{
2675	int n;
2676	fd_set rfds, wfds;
2677	struct timeval tv;
2678	RD_BOOL s_timeout = False;
2679
2680	while (True)
2681	{
2682	n = (rdp_socket > g_x_socket) ? rdp_socket : g_x_socket;
2683	/* Process any events already waiting */
2684	if (!xwin_process_events())
2685	/* User quit */
2686	return 0;
2687
2688	if (g_seamless_active)
2689	sw_check_timers();
2690
2691	FD_ZERO(&rfds);
2692	FD_ZERO(&wfds);
2693	FD_SET(rdp_socket, &rfds);
2694	FD_SET(g_x_socket, &rfds);
2695
2696	/* default timeout */
2697	tv.tv_sec = 60;
2698	tv.tv_usec = 0;
2699
2700	#ifdef WITH_RDPSND
2701	rdpsnd_add_fds(&n, &rfds, &wfds, &tv);
2702	#endif
2703
2704	#ifdef WITH_RDPUSB
2705	rdpusb_add_fds (&n, &rfds, &wfds);
2706	#endif
2707
2708	/* add redirection handles */
2709	rdpdr_add_fds(&n, &rfds, &wfds, &tv, &s_timeout);
2710	seamless_select_timeout(&tv);
2711
2712	/* add ctrl slaves handles */
2713	ctrl_add_fds(&n, &rfds);
2714
2715	n++;
2716
2717	switch (select(n, &rfds, &wfds, NULL, &tv))
2718	{
2719	case -1:
2720	error("select: %s\n", strerror(errno));
2721
2722	case 0:
2723	#ifdef WITH_RDPSND
2724	rdpsnd_check_fds(&rfds, &wfds);
2725	#endif
2726
2727	/* Abort serial read calls */
2728	if (s_timeout)
2729	rdpdr_check_fds(&rfds, &wfds, (RD_BOOL) True);
2730	continue;
2731	}
2732
2733	#ifdef WITH_RDPUSB
2734	rdpusb_check_fds (&rfds, &wfds);
2735	#endif
2736
2737	#ifdef WITH_RDPSND
2738	rdpsnd_check_fds(&rfds, &wfds);
2739	#endif
2740
2741	rdpdr_check_fds(&rfds, &wfds, (RD_BOOL) False);
2742
2743	ctrl_check_fds(&rfds, &wfds);
2744
2745	if (FD_ISSET(rdp_socket, &rfds))
2746	return 1;
2747
2748	}
2749	}
2750
2751	void
2752	ui_move_pointer(int x, int y)
2753	{
2754	XWarpPointer(g_display, g_wnd, g_wnd, 0, 0, 0, 0, x, y);
2755	}
2756
2757	RD_HBITMAP
2758	ui_create_bitmap(int width, int height, uint8 * data)
2759	{
2760	XImage *image;
2761	Pixmap bitmap;
2762	uint8 *tdata;
2763	int bitmap_pad;
2764
2765	if (g_server_depth == 8)
2766	{
2767	bitmap_pad = 8;
2768	}
2769	else
2770	{
2771	bitmap_pad = g_bpp;
2772
2773	if (g_bpp == 24)
2774	bitmap_pad = 32;
2775	}
2776
2777	tdata = (g_owncolmap ? data : translate_image(width, height, data));
2778	bitmap = XCreatePixmap(g_display, g_wnd, width, height, g_depth);
2779	image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
2780	(char *) tdata, width, height, bitmap_pad, 0);
2781
2782	XPutImage(g_display, bitmap, g_create_bitmap_gc, image, 0, 0, 0, 0, width, height);
2783
2784	XFree(image);
2785	if (tdata != data)
2786	xfree(tdata);
2787	return (RD_HBITMAP) bitmap;
2788	}
2789
2790	void
2791	ui_paint_bitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data)
2792	{
2793	XImage *image;
2794	uint8 *tdata;
2795	int bitmap_pad;
2796
2797	if (g_server_depth == 8)
2798	{
2799	bitmap_pad = 8;
2800	}
2801	else
2802	{
2803	bitmap_pad = g_bpp;
2804
2805	if (g_bpp == 24)
2806	bitmap_pad = 32;
2807	}
2808
2809	tdata = (g_owncolmap ? data : translate_image(width, height, data));
2810	image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
2811	(char *) tdata, width, height, bitmap_pad, 0);
2812
2813	if (g_ownbackstore)
2814	{
2815	XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
2816	XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
2817	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
2818	(g_display, g_backstore, sw->wnd, g_gc, x, y, cx, cy,
2819	x - sw->xoffset, y - sw->yoffset));
2820	}
2821	else
2822	{
2823	XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
2824	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
2825	(g_display, g_wnd, sw->wnd, g_gc, x, y, cx, cy,
2826	x - sw->xoffset, y - sw->yoffset));
2827	}
2828
2829	XFree(image);
2830	if (tdata != data)
2831	xfree(tdata);
2832	}
2833
2834	void
2835	ui_destroy_bitmap(RD_HBITMAP bmp)
2836	{
2837	XFreePixmap(g_display, (Pixmap) bmp);
2838	}
2839
2840	RD_HGLYPH
2841	ui_create_glyph(int width, int height, uint8 * data)
2842	{
2843	XImage *image;
2844	Pixmap bitmap;
2845	int scanline;
2846
2847	scanline = (width + 7) / 8;
2848
2849	bitmap = XCreatePixmap(g_display, g_wnd, width, height, 1);
2850	if (g_create_glyph_gc == 0)
2851	g_create_glyph_gc = XCreateGC(g_display, bitmap, 0, NULL);
2852
2853	image = XCreateImage(g_display, g_visual, 1, ZPixmap, 0, (char *) data,
2854	width, height, 8, scanline);
2855	image->byte_order = MSBFirst;
2856	image->bitmap_bit_order = MSBFirst;
2857	XInitImage(image);
2858
2859	XPutImage(g_display, bitmap, g_create_glyph_gc, image, 0, 0, 0, 0, width, height);
2860
2861	XFree(image);
2862	return (RD_HGLYPH) bitmap;
2863	}
2864
2865	void
2866	ui_destroy_glyph(RD_HGLYPH glyph)
2867	{
2868	XFreePixmap(g_display, (Pixmap) glyph);
2869	}
2870
2871	/* convert next pixel to 32 bpp */
2872	static int
2873	get_next_xor_pixel(uint8 * xormask, int bpp, int *k)
2874	{
2875	int rv = 0;
2876	PixelColour pc;
2877	uint8 *s8;
2878	uint16 *s16;
2879
2880	switch (bpp)
2881	{
2882	case 1:
2883	s8 = xormask + (*k) / 8;
2884	rv = (s8) & (0x80 >> ((k) % 8));
2885	rv = rv ? 0xffffff : 0;
2886	(*k) += 1;
2887	break;
2888	case 8:
2889	s8 = xormask + *k;
2890	/* should use colour map */
2891	rv = s8[0];
2892	rv = rv ? 0xffffff : 0;
2893	(*k) += 1;
2894	break;
2895	case 15:
2896	s16 = (uint16 *) xormask;
2897	SPLITCOLOUR15(s16[*k], pc);
2898	rv = (pc.red << 16) \| (pc.green << 8) \| pc.blue;
2899	(*k) += 1;
2900	break;
2901	case 16:
2902	s16 = (uint16 *) xormask;
2903	SPLITCOLOUR16(s16[*k], pc);
2904	rv = (pc.red << 16) \| (pc.green << 8) \| pc.blue;
2905	(*k) += 1;
2906	break;
2907	case 24:
2908	s8 = xormask + *k;
2909	rv = (s8[0] << 16) \| (s8[1] << 8) \| s8[2];
2910	(*k) += 3;
2911	break;
2912	case 32:
2913	s8 = xormask + *k;
2914	rv = (s8[1] << 16) \| (s8[2] << 8) \| s8[3];
2915	(*k) += 4;
2916	break;
2917	default:
2918	error("unknown bpp in get_next_xor_pixel %d\n", bpp);
2919	break;
2920	}
2921	return rv;
2922	}
2923
2924	RD_HCURSOR
2925	ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
2926	uint8 * andmask, uint8 * xormask, int bpp)
2927	{
2928	RD_HGLYPH maskglyph, cursorglyph;
2929	XColor bg, fg;
2930	Cursor xcursor;
2931	uint8 cursor, pcursor;
2932	uint8 mask, pmask;
2933	uint8 nextbit;
2934	int scanline, offset, delta;
2935	int i, j, k;
2936
2937	k = 0;
2938	scanline = (width + 7) / 8;
2939	offset = scanline * height;
2940
2941	cursor = (uint8 *) xmalloc(offset);
2942	memset(cursor, 0, offset);
2943
2944	mask = (uint8 *) xmalloc(offset);
2945	memset(mask, 0, offset);
2946	if (bpp == 1)
2947	{
2948	offset = 0;
2949	delta = scanline;
2950	}
2951	else
2952	{
2953	offset = scanline * height - scanline;
2954	delta = -scanline;
2955	}
2956	/* approximate AND and XOR masks with a monochrome X pointer */
2957	for (i = 0; i < height; i++)
2958	{
2959	pcursor = &cursor[offset];
2960	pmask = &mask[offset];
2961
2962	for (j = 0; j < scanline; j++)
2963	{
2964	for (nextbit = 0x80; nextbit != 0; nextbit >>= 1)
2965	{
2966	if (get_next_xor_pixel(xormask, bpp, &k))
2967	{
2968	pcursor \|= (~(andmask) & nextbit);
2969	*pmask \|= nextbit;
2970	}
2971	else
2972	{
2973	pcursor \|= ((andmask) & nextbit);
2974	pmask \|= (~(andmask) & nextbit);
2975	}
2976	}
2977
2978	andmask++;
2979	pcursor++;
2980	pmask++;
2981	}
2982	offset += delta;
2983	}
2984
2985	fg.red = fg.blue = fg.green = 0xffff;
2986	bg.red = bg.blue = bg.green = 0x0000;
2987	fg.flags = bg.flags = DoRed \| DoBlue \| DoGreen;
2988
2989	cursorglyph = ui_create_glyph(width, height, cursor);
2990	maskglyph = ui_create_glyph(width, height, mask);
2991
2992	xcursor =
2993	XCreatePixmapCursor(g_display, (Pixmap) cursorglyph,
2994	(Pixmap) maskglyph, &fg, &bg, x, y);
2995
2996	ui_destroy_glyph(maskglyph);
2997	ui_destroy_glyph(cursorglyph);
2998	xfree(mask);
2999	xfree(cursor);
3000	return (RD_HCURSOR) xcursor;
3001	}
3002
3003	void
3004	ui_set_cursor(RD_HCURSOR cursor)
3005	{
3006	g_current_cursor = (Cursor) cursor;
3007	XDefineCursor(g_display, g_wnd, g_current_cursor);
3008	ON_ALL_SEAMLESS_WINDOWS(XDefineCursor, (g_display, sw->wnd, g_current_cursor));
3009	}
3010
3011	void
3012	ui_destroy_cursor(RD_HCURSOR cursor)
3013	{
3014	XFreeCursor(g_display, (Cursor) cursor);
3015	}
3016
3017	void
3018	ui_set_null_cursor(void)
3019	{
3020	ui_set_cursor(g_null_cursor);
3021	}
3022
3023	#define MAKE_XCOLOR(xc,c) \
3024	(xc)->red = ((c)->red << 8) \| (c)->red; \
3025	(xc)->green = ((c)->green << 8) \| (c)->green; \
3026	(xc)->blue = ((c)->blue << 8) \| (c)->blue; \
3027	(xc)->flags = DoRed \| DoGreen \| DoBlue;
3028
3029
3030	RD_HCOLOURMAP
3031	ui_create_colourmap(COLOURMAP * colours)
3032	{
3033	COLOURENTRY *entry;
3034	int i, ncolours = colours->ncolours;
3035	if (!g_owncolmap)
3036	{
3037	uint32 map = (uint32 ) xmalloc(sizeof(g_colmap) ncolours);
3038	XColor xentry;
3039	XColor xc_cache[256];
3040	uint32 colour;
3041	int colLookup = 256;
3042	for (i = 0; i < ncolours; i++)
3043	{
3044	entry = &colours->colours[i];
3045	MAKE_XCOLOR(&xentry, entry);
3046
3047	if (XAllocColor(g_display, g_xcolmap, &xentry) == 0)
3048	{
3049	/* Allocation failed, find closest match. */
3050	int j = 256;
3051	int nMinDist = 3 * 256 * 256;
3052	long nDist = nMinDist;
3053
3054	/* only get the colors once */
3055	while (colLookup--)
3056	{
3057	xc_cache[colLookup].pixel = colLookup;
3058	xc_cache[colLookup].red = xc_cache[colLookup].green =
3059	xc_cache[colLookup].blue = 0;
3060	xc_cache[colLookup].flags = 0;
3061	XQueryColor(g_display,
3062	DefaultColormap(g_display,
3063	DefaultScreen(g_display)),
3064	&xc_cache[colLookup]);
3065	}
3066	colLookup = 0;
3067
3068	/* approximate the pixel */
3069	while (j--)
3070	{
3071	if (xc_cache[j].flags)
3072	{
3073	nDist = ((long) (xc_cache[j].red >> 8) -
3074	(long) (xentry.red >> 8)) *
3075	((long) (xc_cache[j].red >> 8) -
3076	(long) (xentry.red >> 8)) +
3077	((long) (xc_cache[j].green >> 8) -
3078	(long) (xentry.green >> 8)) *
3079	((long) (xc_cache[j].green >> 8) -
3080	(long) (xentry.green >> 8)) +
3081	((long) (xc_cache[j].blue >> 8) -
3082	(long) (xentry.blue >> 8)) *
3083	((long) (xc_cache[j].blue >> 8) -
3084	(long) (xentry.blue >> 8));
3085	}
3086	if (nDist < nMinDist)
3087	{
3088	nMinDist = nDist;
3089	xentry.pixel = j;
3090	}
3091	}
3092	}
3093	colour = xentry.pixel;
3094
3095	/* update our cache */
3096	if (xentry.pixel < 256)
3097	{
3098	xc_cache[xentry.pixel].red = xentry.red;
3099	xc_cache[xentry.pixel].green = xentry.green;
3100	xc_cache[xentry.pixel].blue = xentry.blue;
3101
3102	}
3103
3104	map[i] = colour;
3105	}
3106	return map;
3107	}
3108	else
3109	{
3110	XColor xcolours, xentry;
3111	Colormap map;
3112
3113	xcolours = (XColor ) xmalloc(sizeof(XColor) ncolours);
3114	for (i = 0; i < ncolours; i++)
3115	{
3116	entry = &colours->colours[i];
3117	xentry = &xcolours[i];
3118	xentry->pixel = i;
3119	MAKE_XCOLOR(xentry, entry);
3120	}
3121
3122	map = XCreateColormap(g_display, g_wnd, g_visual, AllocAll);
3123	XStoreColors(g_display, map, xcolours, ncolours);
3124
3125	xfree(xcolours);
3126	return (RD_HCOLOURMAP) map;
3127	}
3128	}
3129
3130	void
3131	ui_destroy_colourmap(RD_HCOLOURMAP map)
3132	{
3133	if (!g_owncolmap)
3134	xfree(map);
3135	else
3136	XFreeColormap(g_display, (Colormap) map);
3137	}
3138
3139	void
3140	ui_set_colourmap(RD_HCOLOURMAP map)
3141	{
3142	if (!g_owncolmap)
3143	{
3144	if (g_colmap)
3145	xfree(g_colmap);
3146
3147	g_colmap = (uint32 *) map;
3148	}
3149	else
3150	{
3151	XSetWindowColormap(g_display, g_wnd, (Colormap) map);
3152	ON_ALL_SEAMLESS_WINDOWS(XSetWindowColormap, (g_display, sw->wnd, (Colormap) map));
3153	}
3154	}
3155
3156	void
3157	ui_set_clip(int x, int y, int cx, int cy)
3158	{
3159	g_clip_rectangle.x = x;
3160	g_clip_rectangle.y = y;
3161	g_clip_rectangle.width = cx;
3162	g_clip_rectangle.height = cy;
3163	XSetClipRectangles(g_display, g_gc, 0, 0, &g_clip_rectangle, 1, YXBanded);
3164	}
3165
3166	void
3167	ui_reset_clip(void)
3168	{
3169	g_clip_rectangle.x = 0;
3170	g_clip_rectangle.y = 0;
3171	g_clip_rectangle.width = g_width;
3172	g_clip_rectangle.height = g_height;
3173	XSetClipRectangles(g_display, g_gc, 0, 0, &g_clip_rectangle, 1, YXBanded);
3174	}
3175
3176	void
3177	ui_bell(void)
3178	{
3179	XBell(g_display, 0);
3180	}
3181
3182	void
3183	ui_destblt(uint8 opcode,
3184	/* dest */ int x, int y, int cx, int cy)
3185	{
3186	SET_FUNCTION(opcode);
3187	FILL_RECTANGLE(x, y, cx, cy);
3188	RESET_FUNCTION(opcode);
3189	}
3190
3191	static uint8 hatch_patterns[] = {
3192	0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, /* 0 - bsHorizontal */
3193	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, /* 1 - bsVertical */
3194	0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, /* 2 - bsFDiagonal */
3195	0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, /* 3 - bsBDiagonal */
3196	0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08, /* 4 - bsCross */
3197	0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 /* 5 - bsDiagCross */
3198	};
3199
3200	void
3201	ui_patblt(uint8 opcode,
3202	/* dest */ int x, int y, int cx, int cy,
3203	/* brush / BRUSH brush, int bgcolour, int fgcolour)
3204	{
3205	Pixmap fill;
3206	uint8 i, ipattern[8];
3207
3208	SET_FUNCTION(opcode);
3209
3210	switch (brush->style)
3211	{
3212	case 0: /* Solid */
3213	SET_FOREGROUND(fgcolour);
3214	FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
3215	break;
3216
3217	case 2: /* Hatch */
3218	fill = (Pixmap) ui_create_glyph(8, 8,
3219	hatch_patterns + brush->pattern[0] * 8);
3220	SET_FOREGROUND(fgcolour);
3221	SET_BACKGROUND(bgcolour);
3222	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3223	XSetStipple(g_display, g_gc, fill);
3224	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3225	FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
3226	XSetFillStyle(g_display, g_gc, FillSolid);
3227	XSetTSOrigin(g_display, g_gc, 0, 0);
3228	ui_destroy_glyph((RD_HGLYPH) fill);
3229	break;
3230
3231	case 3: /* Pattern */
3232	if (brush->bd == 0) /* rdp4 brush */
3233	{
3234	for (i = 0; i != 8; i++)
3235	ipattern[7 - i] = brush->pattern[i];
3236	fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
3237	SET_FOREGROUND(bgcolour);
3238	SET_BACKGROUND(fgcolour);
3239	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3240	XSetStipple(g_display, g_gc, fill);
3241	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3242	FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
3243	XSetFillStyle(g_display, g_gc, FillSolid);
3244	XSetTSOrigin(g_display, g_gc, 0, 0);
3245	ui_destroy_glyph((RD_HGLYPH) fill);
3246	}
3247	else if (brush->bd->colour_code > 1) /* > 1 bpp */
3248	{
3249	fill = (Pixmap) ui_create_bitmap(8, 8, brush->bd->data);
3250	XSetFillStyle(g_display, g_gc, FillTiled);
3251	XSetTile(g_display, g_gc, fill);
3252	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3253	FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
3254	XSetFillStyle(g_display, g_gc, FillSolid);
3255	XSetTSOrigin(g_display, g_gc, 0, 0);
3256	ui_destroy_bitmap((RD_HBITMAP) fill);
3257	}
3258	else
3259	{
3260	fill = (Pixmap) ui_create_glyph(8, 8, brush->bd->data);
3261	SET_FOREGROUND(bgcolour);
3262	SET_BACKGROUND(fgcolour);
3263	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3264	XSetStipple(g_display, g_gc, fill);
3265	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3266	FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
3267	XSetFillStyle(g_display, g_gc, FillSolid);
3268	XSetTSOrigin(g_display, g_gc, 0, 0);
3269	ui_destroy_glyph((RD_HGLYPH) fill);
3270	}
3271	break;
3272
3273	default:
3274	unimpl("brush %d\n", brush->style);
3275	}
3276
3277	RESET_FUNCTION(opcode);
3278
3279	if (g_ownbackstore)
3280	XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
3281	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3282	(g_display, g_ownbackstore ? g_backstore : g_wnd, sw->wnd, g_gc,
3283	x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
3284	}
3285
3286	void
3287	ui_screenblt(uint8 opcode,
3288	/* dest */ int x, int y, int cx, int cy,
3289	/* src */ int srcx, int srcy)
3290	{
3291	SET_FUNCTION(opcode);
3292	if (g_ownbackstore)
3293	{
3294	XCopyArea(g_display, g_Unobscured ? g_wnd : g_backstore,
3295	g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
3296	XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);
3297	}
3298	else
3299	{
3300	XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
3301	}
3302
3303	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3304	(g_display, g_ownbackstore ? g_backstore : g_wnd,
3305	sw->wnd, g_gc, x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
3306
3307	RESET_FUNCTION(opcode);
3308	}
3309
3310	void
3311	ui_memblt(uint8 opcode,
3312	/* dest */ int x, int y, int cx, int cy,
3313	/* src */ RD_HBITMAP src, int srcx, int srcy)
3314	{
3315	SET_FUNCTION(opcode);
3316	XCopyArea(g_display, (Pixmap) src, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
3317	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3318	(g_display, (Pixmap) src, sw->wnd, g_gc,
3319	srcx, srcy, cx, cy, x - sw->xoffset, y - sw->yoffset));
3320	if (g_ownbackstore)
3321	XCopyArea(g_display, (Pixmap) src, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);
3322	RESET_FUNCTION(opcode);
3323	}
3324
3325	void
3326	ui_triblt(uint8 opcode,
3327	/* dest */ int x, int y, int cx, int cy,
3328	/* src */ RD_HBITMAP src, int srcx, int srcy,
3329	/* brush / BRUSH brush, int bgcolour, int fgcolour)
3330	{
3331	/* This is potentially difficult to do in general. Until someone
3332	comes up with a more efficient way of doing it I am using cases. */
3333
3334	switch (opcode)
3335	{
3336	case 0x69: /* PDSxxn */
3337	ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
3338	ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
3339	break;
3340
3341	case 0xb8: /* PSDPxax */
3342	ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
3343	ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
3344	ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
3345	break;
3346
3347	case 0xc0: /* PSa */
3348	ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
3349	ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
3350	break;
3351
3352	default:
3353	unimpl("triblt 0x%x\n", opcode);
3354	ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
3355	}
3356	}
3357
3358	void
3359	ui_line(uint8 opcode,
3360	/* dest */ int startx, int starty, int endx, int endy,
3361	/* pen / PEN pen)
3362	{
3363	SET_FUNCTION(opcode);
3364	SET_FOREGROUND(pen->colour);
3365	XDrawLine(g_display, g_wnd, g_gc, startx, starty, endx, endy);
3366	ON_ALL_SEAMLESS_WINDOWS(XDrawLine, (g_display, sw->wnd, g_gc,
3367	startx - sw->xoffset, starty - sw->yoffset,
3368	endx - sw->xoffset, endy - sw->yoffset));
3369	if (g_ownbackstore)
3370	XDrawLine(g_display, g_backstore, g_gc, startx, starty, endx, endy);
3371	RESET_FUNCTION(opcode);
3372	}
3373
3374	void
3375	ui_rect(
3376	/* dest */ int x, int y, int cx, int cy,
3377	/* brush */ int colour)
3378	{
3379	SET_FOREGROUND(colour);
3380	FILL_RECTANGLE(x, y, cx, cy);
3381	}
3382
3383	void
3384	ui_polygon(uint8 opcode,
3385	/* mode */ uint8 fillmode,
3386	/* dest / RD_POINT point, int npoints,
3387	/* brush / BRUSH brush, int bgcolour, int fgcolour)
3388	{
3389	uint8 style, i, ipattern[8];
3390	Pixmap fill;
3391
3392	SET_FUNCTION(opcode);
3393
3394	switch (fillmode)
3395	{
3396	case ALTERNATE:
3397	XSetFillRule(g_display, g_gc, EvenOddRule);
3398	break;
3399	case WINDING:
3400	XSetFillRule(g_display, g_gc, WindingRule);
3401	break;
3402	default:
3403	unimpl("fill mode %d\n", fillmode);
3404	}
3405
3406	if (brush)
3407	style = brush->style;
3408	else
3409	style = 0;
3410
3411	switch (style)
3412	{
3413	case 0: /* Solid */
3414	SET_FOREGROUND(fgcolour);
3415	FILL_POLYGON((XPoint *) point, npoints);
3416	break;
3417
3418	case 2: /* Hatch */
3419	fill = (Pixmap) ui_create_glyph(8, 8,
3420	hatch_patterns + brush->pattern[0] * 8);
3421	SET_FOREGROUND(fgcolour);
3422	SET_BACKGROUND(bgcolour);
3423	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3424	XSetStipple(g_display, g_gc, fill);
3425	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3426	FILL_POLYGON((XPoint *) point, npoints);
3427	XSetFillStyle(g_display, g_gc, FillSolid);
3428	XSetTSOrigin(g_display, g_gc, 0, 0);
3429	ui_destroy_glyph((RD_HGLYPH) fill);
3430	break;
3431
3432	case 3: /* Pattern */
3433	if (brush->bd == 0) /* rdp4 brush */
3434	{
3435	for (i = 0; i != 8; i++)
3436	ipattern[7 - i] = brush->pattern[i];
3437	fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
3438	SET_FOREGROUND(bgcolour);
3439	SET_BACKGROUND(fgcolour);
3440	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3441	XSetStipple(g_display, g_gc, fill);
3442	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3443	FILL_POLYGON((XPoint *) point, npoints);
3444	XSetFillStyle(g_display, g_gc, FillSolid);
3445	XSetTSOrigin(g_display, g_gc, 0, 0);
3446	ui_destroy_glyph((RD_HGLYPH) fill);
3447	}
3448	else if (brush->bd->colour_code > 1) /* > 1 bpp */
3449	{
3450	fill = (Pixmap) ui_create_bitmap(8, 8, brush->bd->data);
3451	XSetFillStyle(g_display, g_gc, FillTiled);
3452	XSetTile(g_display, g_gc, fill);
3453	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3454	FILL_POLYGON((XPoint *) point, npoints);
3455	XSetFillStyle(g_display, g_gc, FillSolid);
3456	XSetTSOrigin(g_display, g_gc, 0, 0);
3457	ui_destroy_bitmap((RD_HBITMAP) fill);
3458	}
3459	else
3460	{
3461	fill = (Pixmap) ui_create_glyph(8, 8, brush->bd->data);
3462	SET_FOREGROUND(bgcolour);
3463	SET_BACKGROUND(fgcolour);
3464	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3465	XSetStipple(g_display, g_gc, fill);
3466	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3467	FILL_POLYGON((XPoint *) point, npoints);
3468	XSetFillStyle(g_display, g_gc, FillSolid);
3469	XSetTSOrigin(g_display, g_gc, 0, 0);
3470	ui_destroy_glyph((RD_HGLYPH) fill);
3471	}
3472	break;
3473
3474	default:
3475	unimpl("brush %d\n", brush->style);
3476	}
3477
3478	RESET_FUNCTION(opcode);
3479	}
3480
3481	void
3482	ui_polyline(uint8 opcode,
3483	/* dest / RD_POINT points, int npoints,
3484	/* pen / PEN pen)
3485	{
3486	/* TODO: set join style */
3487	SET_FUNCTION(opcode);
3488	SET_FOREGROUND(pen->colour);
3489	XDrawLines(g_display, g_wnd, g_gc, (XPoint *) points, npoints, CoordModePrevious);
3490	if (g_ownbackstore)
3491	XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints,
3492	CoordModePrevious);
3493
3494	ON_ALL_SEAMLESS_WINDOWS(seamless_XDrawLines,
3495	(sw->wnd, (XPoint *) points, npoints, sw->xoffset, sw->yoffset));
3496
3497	RESET_FUNCTION(opcode);
3498	}
3499
3500	void
3501	ui_ellipse(uint8 opcode,
3502	/* mode */ uint8 fillmode,
3503	/* dest */ int x, int y, int cx, int cy,
3504	/* brush / BRUSH brush, int bgcolour, int fgcolour)
3505	{
3506	uint8 style, i, ipattern[8];
3507	Pixmap fill;
3508
3509	SET_FUNCTION(opcode);
3510
3511	if (brush)
3512	style = brush->style;
3513	else
3514	style = 0;
3515
3516	switch (style)
3517	{
3518	case 0: /* Solid */
3519	SET_FOREGROUND(fgcolour);
3520	DRAW_ELLIPSE(x, y, cx, cy, fillmode);
3521	break;
3522
3523	case 2: /* Hatch */
3524	fill = (Pixmap) ui_create_glyph(8, 8,
3525	hatch_patterns + brush->pattern[0] * 8);
3526	SET_FOREGROUND(fgcolour);
3527	SET_BACKGROUND(bgcolour);
3528	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3529	XSetStipple(g_display, g_gc, fill);
3530	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3531	DRAW_ELLIPSE(x, y, cx, cy, fillmode);
3532	XSetFillStyle(g_display, g_gc, FillSolid);
3533	XSetTSOrigin(g_display, g_gc, 0, 0);
3534	ui_destroy_glyph((RD_HGLYPH) fill);
3535	break;
3536
3537	case 3: /* Pattern */
3538	if (brush->bd == 0) /* rdp4 brush */
3539	{
3540	for (i = 0; i != 8; i++)
3541	ipattern[7 - i] = brush->pattern[i];
3542	fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
3543	SET_FOREGROUND(bgcolour);
3544	SET_BACKGROUND(fgcolour);
3545	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3546	XSetStipple(g_display, g_gc, fill);
3547	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3548	DRAW_ELLIPSE(x, y, cx, cy, fillmode);
3549	XSetFillStyle(g_display, g_gc, FillSolid);
3550	XSetTSOrigin(g_display, g_gc, 0, 0);
3551	ui_destroy_glyph((RD_HGLYPH) fill);
3552	}
3553	else if (brush->bd->colour_code > 1) /* > 1 bpp */
3554	{
3555	fill = (Pixmap) ui_create_bitmap(8, 8, brush->bd->data);
3556	XSetFillStyle(g_display, g_gc, FillTiled);
3557	XSetTile(g_display, g_gc, fill);
3558	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3559	DRAW_ELLIPSE(x, y, cx, cy, fillmode);
3560	XSetFillStyle(g_display, g_gc, FillSolid);
3561	XSetTSOrigin(g_display, g_gc, 0, 0);
3562	ui_destroy_bitmap((RD_HBITMAP) fill);
3563	}
3564	else
3565	{
3566	fill = (Pixmap) ui_create_glyph(8, 8, brush->bd->data);
3567	SET_FOREGROUND(bgcolour);
3568	SET_BACKGROUND(fgcolour);
3569	XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
3570	XSetStipple(g_display, g_gc, fill);
3571	XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
3572	DRAW_ELLIPSE(x, y, cx, cy, fillmode);
3573	XSetFillStyle(g_display, g_gc, FillSolid);
3574	XSetTSOrigin(g_display, g_gc, 0, 0);
3575	ui_destroy_glyph((RD_HGLYPH) fill);
3576	}
3577	break;
3578
3579	default:
3580	unimpl("brush %d\n", brush->style);
3581	}
3582
3583	RESET_FUNCTION(opcode);
3584	}
3585
3586	/* warning, this function only draws on wnd or backstore, not both */
3587	void
3588	ui_draw_glyph(int mixmode,
3589	/* dest */ int x, int y, int cx, int cy,
3590	/* src */ RD_HGLYPH glyph, int srcx, int srcy,
3591	int bgcolour, int fgcolour)
3592	{
3593	SET_FOREGROUND(fgcolour);
3594	SET_BACKGROUND(bgcolour);
3595
3596	XSetFillStyle(g_display, g_gc,
3597	(mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
3598	XSetStipple(g_display, g_gc, (Pixmap) glyph);
3599	XSetTSOrigin(g_display, g_gc, x, y);
3600
3601	FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
3602
3603	XSetFillStyle(g_display, g_gc, FillSolid);
3604	}
3605
3606	#define DO_GLYPH(ttext,idx) \
3607	{\
3608	glyph = cache_get_font (font, ttext[idx]);\
3609	if (!(flags & TEXT2_IMPLICIT_X))\
3610	{\
3611	xyoffset = ttext[++idx];\
3612	if ((xyoffset & 0x80))\
3613	{\
3614	if (flags & TEXT2_VERTICAL)\
3615	y += ttext[idx+1] \| (ttext[idx+2] << 8);\
3616	else\
3617	x += ttext[idx+1] \| (ttext[idx+2] << 8);\
3618	idx += 2;\
3619	}\
3620	else\
3621	{\
3622	if (flags & TEXT2_VERTICAL)\
3623	y += xyoffset;\
3624	else\
3625	x += xyoffset;\
3626	}\
3627	}\
3628	if (glyph != NULL)\
3629	{\
3630	x1 = x + glyph->offset;\
3631	y1 = y + glyph->baseline;\
3632	XSetStipple(g_display, g_gc, (Pixmap) glyph->pixmap);\
3633	XSetTSOrigin(g_display, g_gc, x1, y1);\
3634	FILL_RECTANGLE_BACKSTORE(x1, y1, glyph->width, glyph->height);\
3635	if (flags & TEXT2_IMPLICIT_X)\
3636	x += glyph->width;\
3637	}\
3638	}
3639
3640	void
3641	ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode, int x, int y,
3642	int clipx, int clipy, int clipcx, int clipcy,
3643	int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush,
3644	int bgcolour, int fgcolour, uint8 * text, uint8 length)
3645	{
3646	/* TODO: use brush appropriately */
3647
3648	FONTGLYPH *glyph;
3649	int i, j, xyoffset, x1, y1;
3650	DATABLOB *entry;
3651
3652	SET_FOREGROUND(bgcolour);
3653
3654	/* Sometimes, the boxcx value is something really large, like
3655	32691. This makes XCopyArea fail with Xvnc. The code below
3656	is a quick fix. */
3657	if (boxx + boxcx > g_width)
3658	boxcx = g_width - boxx;
3659
3660	if (boxcx > 1)
3661	{
3662	FILL_RECTANGLE_BACKSTORE(boxx, boxy, boxcx, boxcy);
3663	}
3664	else if (mixmode == MIX_OPAQUE)
3665	{
3666	FILL_RECTANGLE_BACKSTORE(clipx, clipy, clipcx, clipcy);
3667	}
3668
3669	SET_FOREGROUND(fgcolour);
3670	SET_BACKGROUND(bgcolour);
3671	XSetFillStyle(g_display, g_gc, FillStippled);
3672
3673	/* Paint text, character by character */
3674	for (i = 0; i < length;)
3675	{
3676	switch (text[i])
3677	{
3678	case 0xff:
3679	/* At least two bytes needs to follow */
3680	if (i + 3 > length)
3681	{
3682	warning("Skipping short 0xff command:");
3683	for (j = 0; j < length; j++)
3684	fprintf(stderr, "%02x ", text[j]);
3685	fprintf(stderr, "\n");
3686	i = length = 0;
3687	break;
3688	}
3689	cache_put_text(text[i + 1], text, text[i + 2]);
3690	i += 3;
3691	length -= i;
3692	/* this will move pointer from start to first character after FF command */
3693	text = &(text[i]);
3694	i = 0;
3695	break;
3696
3697	case 0xfe:
3698	/* At least one byte needs to follow */
3699	if (i + 2 > length)
3700	{
3701	warning("Skipping short 0xfe command:");
3702	for (j = 0; j < length; j++)
3703	fprintf(stderr, "%02x ", text[j]);
3704	fprintf(stderr, "\n");
3705	i = length = 0;
3706	break;
3707	}
3708	entry = cache_get_text(text[i + 1]);
3709	if (entry->data != NULL)
3710	{
3711	if ((((uint8 *) (entry->data))[1] == 0)
3712	&& (!(flags & TEXT2_IMPLICIT_X)) && (i + 2 < length))
3713	{
3714	if (flags & TEXT2_VERTICAL)
3715	y += text[i + 2];
3716	else
3717	x += text[i + 2];
3718	}
3719	for (j = 0; j < entry->size; j++)
3720	DO_GLYPH(((uint8 *) (entry->data)), j);
3721	}
3722	if (i + 2 < length)
3723	i += 3;
3724	else
3725	i += 2;
3726	length -= i;
3727	/* this will move pointer from start to first character after FE command */
3728	text = &(text[i]);
3729	i = 0;
3730	break;
3731
3732	default:
3733	DO_GLYPH(text, i);
3734	i++;
3735	break;
3736	}
3737	}
3738
3739	XSetFillStyle(g_display, g_gc, FillSolid);
3740
3741	if (g_ownbackstore)
3742	{
3743	if (boxcx > 1)
3744	{
3745	XCopyArea(g_display, g_backstore, g_wnd, g_gc, boxx,
3746	boxy, boxcx, boxcy, boxx, boxy);
3747	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3748	(g_display, g_backstore, sw->wnd, g_gc,
3749	boxx, boxy,
3750	boxcx, boxcy,
3751	boxx - sw->xoffset, boxy - sw->yoffset));
3752	}
3753	else
3754	{
3755	XCopyArea(g_display, g_backstore, g_wnd, g_gc, clipx,
3756	clipy, clipcx, clipcy, clipx, clipy);
3757	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3758	(g_display, g_backstore, sw->wnd, g_gc,
3759	clipx, clipy,
3760	clipcx, clipcy, clipx - sw->xoffset,
3761	clipy - sw->yoffset));
3762	}
3763	}
3764	}
3765
3766	void
3767	ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
3768	{
3769	Pixmap pix;
3770	XImage *image;
3771
3772	if (g_ownbackstore)
3773	{
3774	image = XGetImage(g_display, g_backstore, x, y, cx, cy, AllPlanes, ZPixmap);
3775	exit_if_null(image);
3776	}
3777	else
3778	{
3779	pix = XCreatePixmap(g_display, g_wnd, cx, cy, g_depth);
3780	XCopyArea(g_display, g_wnd, pix, g_gc, x, y, cx, cy, 0, 0);
3781	image = XGetImage(g_display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
3782	exit_if_null(image);
3783	XFreePixmap(g_display, pix);
3784	}
3785
3786	offset *= g_bpp / 8;
3787	cache_put_desktop(offset, cx, cy, image->bytes_per_line, g_bpp / 8, (uint8 *) image->data);
3788
3789	XDestroyImage(image);
3790	}
3791
3792	void
3793	ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
3794	{
3795	XImage *image;
3796	uint8 *data;
3797
3798	offset *= g_bpp / 8;
3799	data = cache_get_desktop(offset, cx, cy, g_bpp / 8);
3800	if (data == NULL)
3801	return;
3802
3803	image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
3804	(char *) data, cx, cy, g_bpp, 0);
3805
3806	if (g_ownbackstore)
3807	{
3808	XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
3809	XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
3810	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3811	(g_display, g_backstore, sw->wnd, g_gc,
3812	x, y, cx, cy, x - sw->xoffset, y - sw->yoffset));
3813	}
3814	else
3815	{
3816	XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
3817	ON_ALL_SEAMLESS_WINDOWS(XCopyArea,
3818	(g_display, g_wnd, sw->wnd, g_gc, x, y, cx, cy,
3819	x - sw->xoffset, y - sw->yoffset));
3820	}
3821
3822	XFree(image);
3823	}
3824
3825	/* these do nothing here but are used in uiports */
3826	void
3827	ui_begin_update(void)
3828	{
3829	}
3830
3831	void
3832	ui_end_update(void)
3833	{
3834	XFlush(g_display);
3835	}
3836
3837
3838	void
3839	ui_seamless_begin(RD_BOOL hidden)
3840	{
3841	if (!g_seamless_rdp)
3842	return;
3843
3844	if (g_seamless_started)
3845	return;
3846
3847	g_seamless_started = True;
3848	g_seamless_hidden = hidden;
3849
3850	if (!hidden)
3851	ui_seamless_toggle();
3852
3853	if (g_seamless_spawn_cmd[0])
3854	{
3855	seamless_send_spawn(g_seamless_spawn_cmd);
3856	g_seamless_spawn_cmd[0] = 0;
3857	}
3858
3859	seamless_send_persistent(g_seamless_persistent_mode);
3860	}
3861
3862
3863	void
3864	ui_seamless_end()
3865	{
3866	/* Destroy all seamless windows */
3867	while (g_seamless_windows)
3868	{
3869	XDestroyWindow(g_display, g_seamless_windows->wnd);
3870	sw_remove_window(g_seamless_windows);
3871	}
3872
3873	g_seamless_started = False;
3874	g_seamless_active = False;
3875	g_seamless_hidden = False;
3876	}
3877
3878
3879	void
3880	ui_seamless_hide_desktop()
3881	{
3882	if (!g_seamless_rdp)
3883	return;
3884
3885	if (!g_seamless_started)
3886	return;
3887
3888	if (g_seamless_active)
3889	ui_seamless_toggle();
3890
3891	g_seamless_hidden = True;
3892	}
3893
3894
3895	void
3896	ui_seamless_unhide_desktop()
3897	{
3898	if (!g_seamless_rdp)
3899	return;
3900
3901	if (!g_seamless_started)
3902	return;
3903
3904	g_seamless_hidden = False;
3905
3906	ui_seamless_toggle();
3907	}
3908
3909
3910	void
3911	ui_seamless_toggle()
3912	{
3913	if (!g_seamless_rdp)
3914	return;
3915
3916	if (!g_seamless_started)
3917	return;
3918
3919	if (g_seamless_hidden)
3920	return;
3921
3922	if (g_seamless_active)
3923	{
3924	/* Deactivate */
3925	while (g_seamless_windows)
3926	{
3927	XDestroyWindow(g_display, g_seamless_windows->wnd);
3928	sw_remove_window(g_seamless_windows);
3929	}
3930	XMapWindow(g_display, g_wnd);
3931	}
3932	else
3933	{
3934	/* Activate */
3935	XUnmapWindow(g_display, g_wnd);
3936	seamless_send_sync();
3937	}
3938
3939	g_seamless_active = !g_seamless_active;
3940	}
3941
3942
3943	void
3944	ui_seamless_create_window(unsigned long id, unsigned long group, unsigned long parent,
3945	unsigned long flags)
3946	{
3947	Window wnd;
3948	XSetWindowAttributes attribs;
3949	XClassHint *classhints;
3950	XSizeHints *sizehints;
3951	XWMHints *wmhints;
3952	long input_mask;
3953	seamless_window sw, sw_parent;
3954
3955	if (!g_seamless_active)
3956	return;
3957
3958	/* Ignore CREATEs for existing windows */
3959	sw = sw_get_window_by_id(id);
3960	if (sw)
3961	return;
3962
3963	get_window_attribs(&attribs);
3964	wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), -1, -1, 1, 1, 0, g_depth,
3965	InputOutput, g_visual,
3966	CWBackPixel \| CWBackingStore \| CWColormap \| CWBorderPixel, &attribs);
3967
3968	XStoreName(g_display, wnd, "SeamlessRDP");
3969	ewmh_set_wm_name(wnd, "SeamlessRDP");
3970
3971	mwm_hide_decorations(wnd);
3972
3973	classhints = XAllocClassHint();
3974	if (classhints != NULL)
3975	{
3976	classhints->res_name = "rdesktop";
3977	classhints->res_class = "SeamlessRDP";
3978	XSetClassHint(g_display, wnd, classhints);
3979	XFree(classhints);
3980	}
3981
3982	/* WM_NORMAL_HINTS */
3983	sizehints = XAllocSizeHints();
3984	if (sizehints != NULL)
3985	{
3986	sizehints->flags = USPosition;
3987	XSetWMNormalHints(g_display, wnd, sizehints);
3988	XFree(sizehints);
3989	}
3990
3991	/* Parent-less transient windows */
3992	if (parent == 0xFFFFFFFF)
3993	{
3994	XSetTransientForHint(g_display, wnd, RootWindowOfScreen(g_screen));
3995	/* Some buggy wm:s (kwin) do not handle the above, so fake it
3996	using some other hints. */
3997	ewmh_set_window_popup(wnd);
3998	}
3999	/* Normal transient windows */
4000	else if (parent != 0x00000000)
4001	{
4002	sw_parent = sw_get_window_by_id(parent);
4003	if (sw_parent)
4004	XSetTransientForHint(g_display, wnd, sw_parent->wnd);
4005	else
4006	warning("ui_seamless_create_window: No parent window 0x%lx\n", parent);
4007	}
4008
4009	if (flags & SEAMLESSRDP_CREATE_MODAL)
4010	{
4011	/* We do this to support buggy wm:s (cough metacity cough)
4012	somewhat at least */
4013	if (parent == 0x00000000)
4014	XSetTransientForHint(g_display, wnd, RootWindowOfScreen(g_screen));
4015	ewmh_set_window_modal(wnd);
4016	}
4017
4018	if (flags & SEAMLESSRDP_CREATE_TOPMOST)
4019	{
4020	/* Make window always-on-top */
4021	ewmh_set_window_above(wnd);
4022	}
4023
4024	/* FIXME: Support for Input Context:s */
4025
4026	get_input_mask(&input_mask);
4027	input_mask \|= PropertyChangeMask;
4028
4029	XSelectInput(g_display, wnd, input_mask);
4030
4031	/* handle the WM_DELETE_WINDOW protocol. */
4032	XSetWMProtocols(g_display, wnd, &g_kill_atom, 1);
4033
4034	sw = xmalloc(sizeof(seamless_window));
4035
4036	memset(sw, 0, sizeof(seamless_window));
4037
4038	sw->wnd = wnd;
4039	sw->id = id;
4040	sw->group = sw_find_group(group, False);
4041	sw->group->refcnt++;
4042	sw->state = SEAMLESSRDP_NOTYETMAPPED;
4043	sw->desktop = 0;
4044	sw->position_timer = xmalloc(sizeof(struct timeval));
4045	timerclear(sw->position_timer);
4046
4047	sw->outstanding_position = False;
4048	sw->outpos_serial = 0;
4049	sw->outpos_xoffset = sw->outpos_yoffset = 0;
4050	sw->outpos_width = sw->outpos_height = 0;
4051
4052	sw->next = g_seamless_windows;
4053	g_seamless_windows = sw;
4054
4055	/* WM_HINTS */
4056	wmhints = XAllocWMHints();
4057	if (wmhints)
4058	{
4059	wmhints->flags = WindowGroupHint;
4060	wmhints->window_group = sw->group->wnd;
4061	XSetWMHints(g_display, sw->wnd, wmhints);
4062	XFree(wmhints);
4063	}
4064	}
4065
4066
4067	void
4068	ui_seamless_destroy_window(unsigned long id, unsigned long flags)
4069	{
4070	seamless_window *sw;
4071
4072	if (!g_seamless_active)
4073	return;
4074
4075	sw = sw_get_window_by_id(id);
4076	if (!sw)
4077	{
4078	warning("ui_seamless_destroy_window: No information for window 0x%lx\n", id);
4079	return;
4080	}
4081
4082	XDestroyWindow(g_display, sw->wnd);
4083	sw_remove_window(sw);
4084	}
4085
4086
4087	void
4088	ui_seamless_destroy_group(unsigned long id, unsigned long flags)
4089	{
4090	seamless_window sw, sw_next;
4091
4092	if (!g_seamless_active)
4093	return;
4094
4095	for (sw = g_seamless_windows; sw; sw = sw_next)
4096	{
4097	sw_next = sw->next;
4098
4099	if (sw->group->id == id)
4100	{
4101	XDestroyWindow(g_display, sw->wnd);
4102	sw_remove_window(sw);
4103	}
4104	}
4105	}
4106
4107
4108	void
4109	ui_seamless_seticon(unsigned long id, const char *format, int width, int height, int chunk,
4110	const char *data, int chunk_len)
4111	{
4112	seamless_window *sw;
4113
4114	if (!g_seamless_active)
4115	return;
4116
4117	sw = sw_get_window_by_id(id);
4118	if (!sw)
4119	{
4120	warning("ui_seamless_seticon: No information for window 0x%lx\n", id);
4121	return;
4122	}
4123
4124	if (chunk == 0)
4125	{
4126	if (sw->icon_size)
4127	warning("ui_seamless_seticon: New icon started before previous completed\n");
4128
4129	if (strcmp(format, "RGBA") != 0)
4130	{
4131	warning("ui_seamless_seticon: Uknown icon format \"%s\"\n", format);
4132	return;
4133	}
4134
4135	sw->icon_size = width * height * 4;
4136	if (sw->icon_size > 32 * 32 * 4)
4137	{
4138	warning("ui_seamless_seticon: Icon too large (%d bytes)\n", sw->icon_size);
4139	sw->icon_size = 0;
4140	return;
4141	}
4142
4143	sw->icon_offset = 0;
4144	}
4145	else
4146	{
4147	if (!sw->icon_size)
4148	return;
4149	}
4150
4151	if (chunk_len > (sw->icon_size - sw->icon_offset))
4152	{
4153	warning("ui_seamless_seticon: Too large chunk received (%d bytes > %d bytes)\n",
4154	chunk_len, sw->icon_size - sw->icon_offset);
4155	sw->icon_size = 0;
4156	return;
4157	}
4158
4159	memcpy(sw->icon_buffer + sw->icon_offset, data, chunk_len);
4160	sw->icon_offset += chunk_len;
4161
4162	if (sw->icon_offset == sw->icon_size)
4163	{
4164	ewmh_set_icon(sw->wnd, width, height, sw->icon_buffer);
4165	sw->icon_size = 0;
4166	}
4167	}
4168
4169
4170	void
4171	ui_seamless_delicon(unsigned long id, const char *format, int width, int height)
4172	{
4173	seamless_window *sw;
4174
4175	if (!g_seamless_active)
4176	return;
4177
4178	sw = sw_get_window_by_id(id);
4179	if (!sw)
4180	{
4181	warning("ui_seamless_seticon: No information for window 0x%lx\n", id);
4182	return;
4183	}
4184
4185	if (strcmp(format, "RGBA") != 0)
4186	{
4187	warning("ui_seamless_seticon: Uknown icon format \"%s\"\n", format);
4188	return;
4189	}
4190
4191	ewmh_del_icon(sw->wnd, width, height);
4192	}
4193
4194
4195	void
4196	ui_seamless_move_window(unsigned long id, int x, int y, int width, int height, unsigned long flags)
4197	{
4198	seamless_window *sw;
4199
4200	if (!g_seamless_active)
4201	return;
4202
4203	sw = sw_get_window_by_id(id);
4204	if (!sw)
4205	{
4206	warning("ui_seamless_move_window: No information for window 0x%lx\n", id);
4207	return;
4208	}
4209
4210	/* We ignore server updates until it has handled our request. */
4211	if (sw->outstanding_position)
4212	return;
4213
4214	if (!width \|\| !height)
4215	/* X11 windows must be at least 1x1 */
4216	return;
4217
4218	/* If we move the window in a maximized state, then KDE won't
4219	accept restoration */
4220	switch (sw->state)
4221	{
4222	case SEAMLESSRDP_MINIMIZED:
4223	case SEAMLESSRDP_MAXIMIZED:
4224	sw_update_position(sw);
4225	return;
4226	}
4227
4228	sw->xoffset = x;
4229	sw->yoffset = y;
4230	sw->width = width;
4231	sw->height = height;
4232
4233	/* FIXME: Perhaps use ewmh_net_moveresize_window instead */
4234	XMoveResizeWindow(g_display, sw->wnd, sw->xoffset, sw->yoffset, sw->width, sw->height);
4235	}
4236
4237
4238	void
4239	ui_seamless_restack_window(unsigned long id, unsigned long behind, unsigned long flags)
4240	{
4241	seamless_window *sw;
4242	XWindowChanges values;
4243	unsigned long restack_serial;
4244	unsigned int value_mask;
4245
4246	if (!g_seamless_active)
4247	return;
4248
4249	sw = sw_get_window_by_id(id);
4250	if (!sw)
4251	{
4252	warning("ui_seamless_restack_window: No information for window 0x%lx\n", id);
4253	return;
4254	}
4255
4256	if (behind)
4257	{
4258	seamless_window *sw_behind;
4259
4260	sw_behind = sw_get_window_by_id(behind);
4261	if (!sw_behind)
4262	{
4263	warning("ui_seamless_restack_window: No information for behind window 0x%lx\n", behind);
4264	return;
4265	}
4266
4267	values.stack_mode = Below;
4268	value_mask = CWStackMode \| CWSibling;
4269	values.sibling = sw_behind->wnd;
4270
4271	/* Avoid that topmost windows references non-topmost
4272	windows, and vice versa. */
4273	if (ewmh_is_window_above(sw->wnd))
4274	{
4275	if (!ewmh_is_window_above(sw_behind->wnd))
4276	{
4277	/* Disallow, move to bottom of the
4278	topmost stack. */
4279	values.stack_mode = Below;
4280	value_mask = CWStackMode; /* Not sibling */
4281	}
4282	}
4283	else
4284	{
4285	if (ewmh_is_window_above(sw_behind->wnd))
4286	{
4287	/* Move to top of non-topmost
4288	stack. */
4289	values.stack_mode = Above;
4290	value_mask = CWStackMode; /* Not sibling */
4291	}
4292	}
4293	}
4294	else
4295	{
4296	values.stack_mode = Above;
4297	value_mask = CWStackMode;
4298	}
4299
4300	restack_serial = XNextRequest(g_display);
4301	XReconfigureWMWindow(g_display, sw->wnd, DefaultScreen(g_display), value_mask, &values);
4302	sw_wait_configurenotify(sw->wnd, restack_serial);
4303
4304	sw_restack_window(sw, behind);
4305
4306	if (flags & SEAMLESSRDP_CREATE_TOPMOST)
4307	{
4308	/* Make window always-on-top */
4309	ewmh_set_window_above(sw->wnd);
4310	}
4311	}
4312
4313
4314	void
4315	ui_seamless_settitle(unsigned long id, const char *title, unsigned long flags)
4316	{
4317	seamless_window *sw;
4318
4319	if (!g_seamless_active)
4320	return;
4321
4322	sw = sw_get_window_by_id(id);
4323	if (!sw)
4324	{
4325	warning("ui_seamless_settitle: No information for window 0x%lx\n", id);
4326	return;
4327	}
4328
4329	/* FIXME: Might want to convert the name for non-EWMH WMs */
4330	XStoreName(g_display, sw->wnd, title);
4331	ewmh_set_wm_name(sw->wnd, title);
4332	}
4333
4334
4335	void
4336	ui_seamless_setstate(unsigned long id, unsigned int state, unsigned long flags)
4337	{
4338	seamless_window *sw;
4339
4340	if (!g_seamless_active)
4341	return;
4342
4343	sw = sw_get_window_by_id(id);
4344	if (!sw)
4345	{
4346	warning("ui_seamless_setstate: No information for window 0x%lx\n", id);
4347	return;
4348	}
4349
4350	switch (state)
4351	{
4352	case SEAMLESSRDP_NORMAL:
4353	case SEAMLESSRDP_MAXIMIZED:
4354	ewmh_change_state(sw->wnd, state);
4355	XMapWindow(g_display, sw->wnd);
4356	break;
4357	case SEAMLESSRDP_MINIMIZED:
4358	/* EWMH says: "if an Application asks to toggle _NET_WM_STATE_HIDDEN
4359	the Window Manager should probably just ignore the request, since
4360	_NET_WM_STATE_HIDDEN is a function of some other aspect of the window
4361	such as minimization, rather than an independent state." Besides,
4362	XIconifyWindow is easier. */
4363	if (sw->state == SEAMLESSRDP_NOTYETMAPPED)
4364	{
4365	XWMHints *hints;
4366	hints = XGetWMHints(g_display, sw->wnd);
4367	if (hints)
4368	{
4369	hints->flags \|= StateHint;
4370	hints->initial_state = IconicState;
4371	XSetWMHints(g_display, sw->wnd, hints);
4372	XFree(hints);
4373	}
4374	XMapWindow(g_display, sw->wnd);
4375	}
4376	else
4377	XIconifyWindow(g_display, sw->wnd, DefaultScreen(g_display));
4378	break;
4379	default:
4380	warning("SeamlessRDP: Invalid state %d\n", state);
4381	break;
4382	}
4383
4384	sw->state = state;
4385	}
4386
4387
4388	void
4389	ui_seamless_syncbegin(unsigned long flags)
4390	{
4391	if (!g_seamless_active)
4392	return;
4393
4394	/* Destroy all seamless windows */
4395	while (g_seamless_windows)
4396	{
4397	XDestroyWindow(g_display, g_seamless_windows->wnd);
4398	sw_remove_window(g_seamless_windows);
4399	}
4400	}
4401
4402
4403	void
4404	ui_seamless_ack(unsigned int serial)
4405	{
4406	seamless_window *sw;
4407	for (sw = g_seamless_windows; sw; sw = sw->next)
4408	{
4409	if (sw->outstanding_position && (sw->outpos_serial == serial))
4410	{
4411	sw->xoffset = sw->outpos_xoffset;
4412	sw->yoffset = sw->outpos_yoffset;
4413	sw->width = sw->outpos_width;
4414	sw->height = sw->outpos_height;
4415	sw->outstanding_position = False;
4416
4417	/* Do a complete redraw of the window as part of the
4418	completion of the move. This is to remove any
4419	artifacts caused by our lack of synchronization. */
4420	XCopyArea(g_display, g_backstore,
4421	sw->wnd, g_gc,
4422	sw->xoffset, sw->yoffset, sw->width, sw->height, 0, 0);
4423
4424	break;
4425	}
4426	}
4427	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/RDP/client-1.8.3/xwin.c@ 74414

Download in other formats: