?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
filters: Fix the laplace filter (it's not separable, gah)
[gfxprim.git] / libs / backends / GP_X11.c
blobd95e2dec45ca3ce11f414df6efb438e3ed27328e
1 /*****************************************************************************
2 * This file is part of gfxprim library. *
3 * *
4 * Gfxprim is free software; you can redistribute it and/or *
5 * modify it under the terms of the GNU Lesser General Public *
6 * License as published by the Free Software Foundation; either *
7 * version 2.1 of the License, or (at your option) any later version. *
8 * *
9 * Gfxprim is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
12 * Lesser General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU Lesser General Public *
15 * License along with gfxprim; if not, write to the Free Software *
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, *
17 * Boston, MA 02110-1301 USA *
18 * *
19 * Copyright (C) 2009-2012 Cyril Hrubis <metan@ucw.cz> *
20 * *
21 *****************************************************************************/
22
23 #include "../../config.h"
24
25 #include "core/GP_Debug.h"
26 #include "core/GP_Common.h"
27
28 #ifdef HAVE_LIBX11
29
30 #include <X11/Xlib.h>
31 #include <X11/Xutil.h>
32 #include <X11/Xatom.h>
33 #include <X11/Xmd.h>
34
35 #include "input/GP_InputDriverX11.h"
36 #include "GP_X11.h"
37
38 struct x11_priv {
39 Display *dpy;
40 int scr;
41 Screen *scr_ptr;
42 int scr_depth;
43 Window win;
44 Visual *vis;
45
46 XImage *img;
47
48 int resized_flag;
49 };
50
51 static void destroy_ximage(GP_Backend *self);
52
53 static int resize_ximage(GP_Backend *self, int w, int h);
54
55 static void x11_exit(GP_Backend *self)
56 {
57 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
58
59 XLockDisplay(x11->dpy);
60
61 destroy_ximage(self);
62
63 XDestroyWindow(x11->dpy, x11->win);
64 /* I wonder if this is right sequence... */
65 XUnlockDisplay(x11->dpy);
66 XCloseDisplay(x11->dpy);
67
68 free(self);
69 }
70
71 static void x11_update_rect(GP_Backend *self, GP_Coord x0, GP_Coord y0,
72 GP_Coord x1, GP_Coord y1)
73 {
74 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
75
76 GP_DEBUG(4, "Updating rect %ix%i-%ix%i", x0, y0, x1, y1);
77
78 XLockDisplay(x11->dpy);
79
80 XPutImage(x11->dpy, x11->win, DefaultGC(x11->dpy, x11->scr),
81 x11->img, x0, y0, x0, y0, x1-x0+1, y1-y0+1);
82 XFlush(x11->dpy);
83
84 x11->resized_flag = 0;
85
86 XUnlockDisplay(x11->dpy);
87 }
88
89 static void x11_flip(GP_Backend *self)
90 {
91 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
92 unsigned int w = self->context->w;
93 unsigned int h = self->context->h;
94
95 GP_DEBUG(4, "Flipping context");
96
97 XLockDisplay(x11->dpy);
98
99 XPutImage(x11->dpy, x11->win, DefaultGC(x11->dpy, x11->scr),
100 x11->img, 0, 0, 0, 0, w, h);
101 XFlush(x11->dpy);
102
103 x11->resized_flag = 0;
104
105 XUnlockDisplay(x11->dpy);
106 }
107
108 static void x11_ev(GP_Backend *self, XEvent *ev)
109 {
110 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
111
112 switch (ev->type) {
113 case Expose:
114 GP_DEBUG(4, "Expose %ix%i-%ix%i %i",
115 ev->xexpose.x, ev->xexpose.y,
116 ev->xexpose.width, ev->xexpose.height,
117 ev->xexpose.count);
118
119 if (x11->resized_flag)
120 break;
121
122 x11_update_rect(self, ev->xexpose.x, ev->xexpose.y,
123 ev->xexpose.x + ev->xexpose.width - 1,
124 ev->xexpose.y + ev->xexpose.height - 1);
125 break;
126 case ConfigureNotify:
127 if (ev->xconfigure.width == (int)self->context->w &&
128 ev->xconfigure.height == (int)self->context->h)
129 break;
130 default:
131 GP_InputDriverX11EventPut(ev);
132 break;
133 }
134 }
135
136 static void x11_poll(GP_Backend *self)
137 {
138 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
139 XEvent ev;
140
141 XLockDisplay(x11->dpy);
142
143 while (XPending(x11->dpy)) {
144 XNextEvent(x11->dpy, &ev);
145 x11_ev(self, &ev);
146 }
147
148 XUnlockDisplay(x11->dpy);
149 }
150
151 static void x11_wait(GP_Backend *self)
152 {
153 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
154 XEvent ev;
155
156 XLockDisplay(x11->dpy);
157
158 XNextEvent(x11->dpy, &ev);
159 x11_ev(self, &ev);
160
161 XUnlockDisplay(x11->dpy);
162 }
163
164 static int x11_set_attributes(struct GP_Backend *self,
165 uint32_t w, uint32_t h,
166 const char *caption)
167 {
168 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
169
170 XLockDisplay(x11->dpy);
171
172 if (caption != NULL) {
173 GP_DEBUG(3, "Setting window caption to '%s'", caption);
174 XmbSetWMProperties(x11->dpy, x11->win, caption, caption,
175 NULL, 0, NULL, NULL, NULL);
176 }
177
178 if (w != 0 && h != 0) {
179 GP_DEBUG(3, "Setting window size to %ux%u", w, h);
180
181 if (resize_ximage(self, w, h))
182 return 1;
183
184 /* Resize X11 window */
185 // XResizeWindow(x11->dpy, x11->win, w, h);
186 XFlush(x11->dpy);
187
188 x11->resized_flag = 1;
189 }
190
191 XUnlockDisplay(x11->dpy);
192
193 return 0;
194 }
195
196 static int create_ximage(GP_Backend *self, GP_Size w, GP_Size h)
197 {
198 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
199 int depth;
200 enum GP_PixelType pixel_type;
201
202 /*
203 * Eh, the XImage supports either 8, 16 or 32 bit pixels
204 *
205 * Do best effor on selecting appropriate pixel type
206 */
207 for (depth = 8; depth <= 32; depth<<=1) {
208 pixel_type = GP_PixelRGBMatch(x11->vis->red_mask,
209 x11->vis->green_mask,
210 x11->vis->blue_mask,
211 0x0, depth);
212
213 if (pixel_type != GP_PIXEL_UNKNOWN)
214 break;
215 }
216
217 if (pixel_type == GP_PIXEL_UNKNOWN) {
218 GP_DEBUG(1, "Unknown pixel type");
219 return 1;
220 }
221
222 self->context = GP_ContextAlloc(w, h, pixel_type);
223
224 if (self->context == NULL)
225 return 1;
226
227 x11->img = XCreateImage(x11->dpy, x11->vis, x11->scr_depth, ZPixmap, 0,
228 NULL, w, h, depth, 0);
229
230 if (x11->img == NULL) {
231 GP_DEBUG(1, "Failed to create XImage");
232 GP_ContextFree(self->context);
233 return 1;
234 }
235
236 x11->img->data = (char*)self->context->pixels;
237 return 0;
238 }
239
240 static void destroy_ximage(GP_Backend *self)
241 {
242 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
243
244 GP_ContextFree(self->context);
245 x11->img->data = NULL;
246 XDestroyImage(x11->img);
247 }
248
249 static int resize_ximage(GP_Backend *self, int w, int h)
250 {
251 struct x11_priv *x11 = GP_BACKEND_PRIV(self);
252 XImage *img;
253
254 /* Create new X image */
255 img = XCreateImage(x11->dpy, x11->vis, x11->scr_depth, ZPixmap, 0, NULL,
256 w, h, x11->img->bitmap_pad, 0);
257
258 if (img == NULL) {
259 GP_DEBUG(2, "XCreateImage failed");
260 return 1;
261 }
262
263 /* Resize context */
264 if (GP_ContextResize(self->context, w, h)) {
265 XDestroyImage(img);
266 return 1;
267 }
268
269 /* Free old image */
270 x11->img->data = NULL;
271 XDestroyImage(x11->img);
272
273 /* Swap the pointers */
274 img->data = (char*)self->context->pixels;
275 x11->img = img;
276
277 return 0;
278 }
279
280 void create_window(struct x11_priv *x11, int x, int y,
281 unsigned int *w, unsigned int *h,
282 const char *caption, enum GP_BackendX11Flags flags)
283 {
284 XSetWindowAttributes attrs;
285 unsigned long attr_mask = 0;
286
287 /* Set event mask */
288 attrs.event_mask = ExposureMask | StructureNotifyMask | KeyPressMask |
289 KeyReleaseMask | PointerMotionMask;
290 attr_mask |= CWEventMask;
291
292 /*
293 * If root window was selected, resize w and h and set x11->win to root
294 * window.
295 */
296 if (flags & GP_X11_USE_ROOT_WIN) {
297 x11->win = DefaultRootWindow(x11->dpy);
298 *w = DisplayWidth(x11->dpy, x11->scr);
299 *h = DisplayHeight(x11->dpy, x11->scr);
300
301 GP_DEBUG(2, "Using root window, owerriding size to %ux%u",
302 *w, *h);
303
304 XChangeWindowAttributes(x11->dpy, x11->win, attr_mask, &attrs);
305
306 return;
307 }
308
309 /*
310 * For some reason reading mouse button clicks on root win are not
311 * allowed...
312 */
313 attrs.event_mask |= ButtonPressMask | ButtonReleaseMask;
314
315 /*
316 * Create undecoreated root window on background
317 */
318 if (flags & GP_X11_CREATE_ROOT_WIN) {
319 Atom xa;
320
321 *w = DisplayWidth(x11->dpy, x11->scr);
322 *h = DisplayHeight(x11->dpy, x11->scr);
323
324 GP_DEBUG(2, "Creating a window above root, owerriding size to %ux%u",
325 *w, *h);
326
327 x11->win = XCreateWindow(x11->dpy, DefaultRootWindow(x11->dpy),
328 0, 0, *w, *h, 0, CopyFromParent,
329 InputOutput, CopyFromParent, attr_mask, &attrs);
330
331 /* Set empty WM_PROTOCOLS */
332 GP_DEBUG(2, "Setting empty MW_PROTOCOLS");
333 XSetWMProtocols(x11->dpy, x11->win, NULL, 0);
334
335 /* Set window type to desktop */
336 xa = XInternAtom(x11->dpy, "_NET_WM_WINDOW_TYPE", False);
337
338 if (xa != None) {
339 GP_DEBUG(2, "Setting Atom _NET_WM_WINDOW_TYPE to _NET_WM_WINDOW_TYPE_DESKTOP");
340
341 Atom xa_prop = XInternAtom(x11->dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", False);
342
343 XChangeProperty(x11->dpy, x11->win, xa, XA_ATOM, 32,
344 PropModeReplace, (unsigned char *) &xa_prop, 1);
345 }
346
347 /* Turn off window decoration */
348 xa = XInternAtom(x11->dpy, "_MOTIF_WM_HINTS", False);
349
350 if (xa != None) {
351 GP_DEBUG(2, "Setting Atom _MOTIF_WM_HINTS to 2, 0, 0, 0, 0");
352
353 long prop[5] = {2, 0, 0, 0, 0};
354
355 XChangeProperty(x11->dpy, x11->win, xa, xa, 32,
356 PropModeReplace, (unsigned char *) prop, 5);
357 }
358
359 /* Set below other windows */
360 xa = XInternAtom(x11->dpy, "_WIN_LAYER", False);
361
362 if (xa != None) {
363 GP_DEBUG(2, "Setting Atom _WIN_LAYER to 6");
364
365 long prop = 6;
366
367 XChangeProperty(x11->dpy, x11->win, xa, XA_CARDINAL, 32,
368 PropModeAppend, (unsigned char *) &prop, 1);
369 }
370
371 xa = XInternAtom(x11->dpy, "_NET_WM_STATE", False);
372
373 if (xa != None) {
374 GP_DEBUG(2, "Setting Atom _NET_WM_STATE to _NET_WM_STATE_BELOW");
375
376 Atom xa_prop = XInternAtom(x11->dpy, "_NET_WM_STATE_BELOW", False);
377
378 XChangeProperty(x11->dpy, x11->win, xa, XA_ATOM, 32,
379 PropModeAppend, (unsigned char *) &xa_prop, 1);
380 }
381
382 /* Set sticky */
383 xa = XInternAtom(x11->dpy, "_NET_WM_DESKTOP", False);
384
385 if (xa != None) {
386 GP_DEBUG(2, "Setting Atom _NET_WM_DESKTOP to 0xffffffff");
387
388 CARD32 xa_prop = 0xffffffff;
389
390 XChangeProperty(x11->dpy, x11->win, xa, XA_CARDINAL, 32,
391 PropModeAppend, (unsigned char *) &xa_prop, 1);
392 }
393
394 xa = XInternAtom(x11->dpy, "_NET_WM_STATE", False);
395
396 if (xa != None) {
397 GP_DEBUG(2, "Appending to Atom _NET_WM_STATE atom _NET_WM_STATE_STICKY");
398
399 Atom xa_prop = XInternAtom(x11->dpy, "_NET_WM_STATE_STICKY", False);
400
401 XChangeProperty(x11->dpy, x11->win, xa, XA_ATOM, 32,
402 PropModeAppend, (unsigned char *) &xa_prop, 1);
403 }
404
405 /* Skip taskbar */
406 xa = XInternAtom(x11->dpy, "_NET_WM_STATE", False);
407
408 if (xa != None) {
409 GP_DEBUG(2, "Appending to Atom _NET_WM_STATE atom _NET_STATE_SKIP_TASKBAR");
410
411 Atom xa_prop = XInternAtom(x11->dpy, "_NET_WM_STATE_SKIP_TASKBAR", False);
412
413 XChangeProperty(x11->dpy, x11->win, xa, XA_ATOM, 32,
414 PropModeAppend, (unsigned char *) &xa_prop, 1);
415 }
416
417 /* Skip pager */
418 xa = XInternAtom(x11->dpy, "_NET_WM_STATE", False);
419
420 if (xa != None) {
421 GP_DEBUG(2, "Appending to Atom _NET_WM_STATE atom _NET_STATE_SKIP_PAGER");
422
423 Atom xa_prop = XInternAtom(x11->dpy, "_NET_WM_STATE_SKIP_PAGER", False);
424
425 XChangeProperty(x11->dpy, x11->win, xa, XA_ATOM, 32,
426 PropModeAppend, (unsigned char *) &xa_prop, 1);
427 }
428
429 /* Set 100% opacity */
430 xa = XInternAtom(x11->dpy, "_NET_WM_WINDOW_OPACITY", False);
431
432 if (xa != None) {
433 GP_DEBUG(2, "Setting Atom _NET_WM_WINDOW_OPACITY to 0xffffffff");
434
435 long prop = 0xffffffff;
436
437 XChangeProperty(x11->dpy, x11->win, xa, XA_CARDINAL, 32,
438 PropModeAppend, (unsigned char *) &prop, 1);
439 }
440
441 /* Show window */
442 XMapWindow(x11->dpy, x11->win);
443 return;
444 }
445
446 GP_DEBUG(2, "Opening window '%s' %ix%i-%ux%u",
447 caption, x, y, *w, *h);
448
449 x11->win = XCreateWindow(x11->dpy, DefaultRootWindow(x11->dpy),
450 x, y, *w, *h, 0, CopyFromParent,
451 InputOutput, CopyFromParent, attr_mask, &attrs);
452
453 /* Set window caption */
454 XmbSetWMProperties(x11->dpy, x11->win, caption, caption,
455 NULL, 0, NULL, NULL, NULL);
456
457 /* Show window */
458 XMapWindow(x11->dpy, x11->win);
459 }
460
461 GP_Backend *GP_BackendX11Init(const char *display, int x, int y,
462 unsigned int w, unsigned int h,
463 const char *caption,
464 enum GP_BackendX11Flags flags)
465 {
466 GP_Backend *backend;
467 struct x11_priv *x11;
468
469 GP_DEBUG(1, "Initalizing X11 display '%s'", display);
470
471 if (!XInitThreads()) {
472 GP_DEBUG(2, "XInitThreads failed");
473 return NULL;
474 }
475
476 backend = malloc(sizeof(GP_Backend) +
477 sizeof(struct x11_priv));
478
479 if (backend == NULL)
480 return NULL;
481
482 x11 = GP_BACKEND_PRIV(backend);
483
484 x11->dpy = XOpenDisplay(display);
485
486 if (x11->dpy == NULL)
487 goto err0;
488
489 x11->scr = DefaultScreen(x11->dpy);
490 x11->vis = DefaultVisual(x11->dpy, x11->scr);
491 x11->scr_ptr = DefaultScreenOfDisplay(x11->dpy);
492 x11->scr_depth = DefaultDepthOfScreen(x11->scr_ptr);
493
494 GP_DEBUG(2, "Have Visual id %i, depth %u", (int)x11->vis->visualid, x11->scr_depth);
495
496 create_window(x11, x, y, &w, &h, caption, flags);
497
498 if (x11->win == None) {
499 //TODO: Error message?
500 GP_DEBUG(1, "Failed to create window");
501 goto err1;
502 }
503
504 if (create_ximage(backend, w, h))
505 goto err1;
506
507
508 XFlush(x11->dpy);
509
510 x11->resized_flag = 0;
511
512 backend->name = "X11";
513 backend->Flip = x11_flip;
514 backend->UpdateRect = x11_update_rect;
515 backend->Exit = x11_exit;
516 backend->Poll = x11_poll;
517 backend->Wait = x11_wait;
518 backend->SetAttributes = x11_set_attributes;
519 backend->fd = XConnectionNumber(x11->dpy);
520
521 return backend;
522 err1:
523 XCloseDisplay(x11->dpy);
524 err0:
525 free(backend);
526 return NULL;
527 }
528
529 #else
530
531 #include "GP_Backend.h"
532
533 GP_Backend *GP_BackendX11Init(const char *GP_UNUSED(display),
534 int GP_UNUSED(x), int GP_UNUSED(y),
535 unsigned int GP_UNUSED(w),
536 unsigned int GP_UNUSED(h),
537 const char *GP_UNUSED(caption))
538 {
539 GP_DEBUG(0, "FATAL: X11 support not compiled in");
540 return NULL;
541 }
542
543 #endif /* HAVE_LIBX11 */
A simple 2D graphics library with emphasis on correctness and well-defined operation.