libs/backends/GP_X11_Win.h

   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-2013 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 /*
  24  * X11 window.
  25  */
  26 struct x11_win {
  27         /* X11 Display */
  28         Display *dpy;
  29         /* X11 Screen */
  30         int scr;
  31         /* X11 Screen depth */
  32         int scr_depth;
  33         /* X11 Visual */
  34         Visual *vis;
  35         /* X11 Window */
  36         Window win;
  37
  38         /* Image info SHM or XImage */
  39         XImage *img;
  40
  41 #ifdef HAVE_X_SHM
  42         XShmSegmentInfo shminfo;
  43 #endif /* HAVE_X_SHM */
  44
  45         GP_Pixmap pixmap;
  46
  47         /* Window list pointers */
  48         struct x11_win *prev;
  49         struct x11_win *next;
  50
  51         /* Flags */
  52         int resized_flag:1;
  53         int shm_flag:1;
  54         int fullscreen_flag:1;
  55
  56         /* used to store width and height from ConfigureNotify event */
  57         unsigned int new_w;
  58         unsigned int new_h;
  59 };
  60
  61 static struct x11_win *win_list = NULL;
  62
  63 static void win_list_add(struct x11_win *win)
  64 {
  65         win->next = win_list;
  66         win->prev = NULL;
  67         win_list = win;
  68 }
  69
  70 static void win_list_rem(struct x11_win *win)
  71 {
  72         if (win->prev)
  73                 win->prev->next = win->next;
  74
  75         if (win->next)
  76                 win->next->prev = win->prev;
  77
  78         if (win == win_list)
  79                 win_list = win->next;
  80 }
  81
  82 static struct x11_win *win_list_lookup(Window win)
  83 {
  84         struct x11_win *i;
  85
  86         for (i = win_list; i != NULL; i = i->next) {
  87                 if (i->win == win)
  88                         return i;
  89         }
  90
  91         return NULL;
  92 }
  93
  94 static int win_list_empty(void)
  95 {
  96         return win_list == NULL;
  97 }
  98
  99 #ifndef _NET_WM_STATE_REMOVE
 100 # define _NET_WM_STATE_REMOVE 0
 101 #endif
 102
 103 #ifndef _NET_WM_STATE_ADD
 104 # define _NET_WM_STATE_ADD 1
 105 #endif
 106
 107 #ifndef _NET_WM_STATE_TOGGLE
 108 # define _NET_WM_STATE_TOGGLE 2
 109 #endif
 110
 111 /* Send NETWM message, most modern Window Managers should understand */
 112 static void x11_win_fullscreen(struct x11_win *win, int mode)
 113 {
 114         int fs;
 115         XEvent ev;
 116
 117         switch (mode) {
 118         case _NET_WM_STATE_REMOVE:
 119                 fs = 0;
 120         break;
 121         case _NET_WM_STATE_ADD:
 122                 fs = 1;
 123         break;
 124         case _NET_WM_STATE_TOGGLE:
 125                 fs = !win->fullscreen_flag;
 126         break;
 127         default:
 128                 GP_WARN("Invalid fullscreen mode = %u", mode);
 129                 return;
 130         }
 131
 132         if (fs == win->fullscreen_flag)
 133                 return;
 134
 135         if (!x11_conn.S__NET_WM_STATE || !x11_conn.S__NET_WM_STATE_FULLSCREEN) {
 136                 GP_WARN("NetWM Fullscreen not supported");
 137                 return;
 138         }
 139
 140         GP_DEBUG(2, "Requesting fullscreen mode = %u, fs = %i", mode, fs);
 141
 142         memset(&ev, 0, sizeof(ev));
 143
 144         ev.type = ClientMessage;
 145         ev.xclient.window = win->win;
 146         ev.xclient.message_type = x11_conn.A__NET_WM_STATE;
 147         ev.xclient.format = 32;
 148         ev.xclient.data.l[0] = mode;
 149         ev.xclient.data.l[1] = x11_conn.A__NET_WM_STATE_FULLSCREEN;
 150         ev.xclient.data.l[2] = 0;
 151         ev.xclient.data.l[3] = 1;
 152
 153         if (!XSendEvent(win->dpy, XDefaultRootWindow(win->dpy),
 154                         False, SubstructureNotifyMask|SubstructureRedirectMask, &ev)) {
 155                 GP_WARN("Failed to send _NET_WM_STATE_FULLSCREEN event");
 156                 return;
 157         }
 158
 159         win->fullscreen_flag = fs;
 160
 161         XFlush(win->dpy);
 162 }
 163
 164 /* Window request structure */
 165 struct x11_wreq {
 166         struct x11_win *win;
 167
 168         /* X11 display */
 169         const char *display;
 170
 171         /* geometry */
 172         int x;
 173         int y;
 174         unsigned int w;
 175         unsigned int h;
 176
 177         const char *caption;
 178
 179         unsigned int flags;
 180 };
 181
 182 static void x11_get_screen_size(struct x11_wreq *wreq)
 183 {
 184         wreq->w = DisplayWidth(wreq->win->dpy, wreq->win->scr);
 185         wreq->h = DisplayHeight(wreq->win->dpy, wreq->win->scr);
 186 }
 187
 188 static int x11_win_open(struct x11_wreq *wreq)
 189 {
 190         XSetWindowAttributes attrs;
 191         unsigned long attr_mask = 0;
 192         struct x11_win *win;
 193         Screen *scr_ptr;
 194
 195         /* Initialize connection/increase ref count */
 196         if (!x11_open(wreq->display))
 197                 return 1;
 198
 199         win = wreq->win;
 200
 201         win->fullscreen_flag = 0;
 202
 203         /* Copy display */
 204         win->dpy = x11_conn.dpy;
 205
 206         /* Get visual and screen depth */
 207         win->scr = DefaultScreen(win->dpy);
 208         win->vis = DefaultVisual(win->dpy, win->scr);
 209         scr_ptr = DefaultScreenOfDisplay(win->dpy);
 210         win->scr_depth = DefaultDepthOfScreen(scr_ptr);
 211
 212         GP_DEBUG(2, "Have Visual id %i, depth %u", (int)win->vis->visualid, win->scr_depth);
 213
 214         /* Set event mask */
 215         attrs.event_mask = ExposureMask | StructureNotifyMask | KeyPressMask |
 216                            KeyReleaseMask | PointerMotionMask;
 217         attr_mask |= CWEventMask;
 218
 219         /*
 220          * If root window was selected, resize w and h and set win->win to root
 221          * window.
 222          */
 223         if (wreq->flags & GP_X11_USE_ROOT_WIN) {
 224
 225                 win->win = DefaultRootWindow(win->dpy);
 226
 227                 x11_get_screen_size(wreq);
 228
 229                 GP_DEBUG(2, "Using root window, owerriding size to %ux%u",
 230                          wreq->w, wreq->h);
 231
 232                 win_list_add(win);
 233
 234                 XChangeWindowAttributes(win->dpy, win->win, attr_mask, &attrs);
 235
 236                 return 0;
 237         }
 238
 239         /*
 240          * For some reason reading mouse button clicks on root win are not
 241          * allowed...
 242          */
 243         attrs.event_mask |= ButtonPressMask | ButtonReleaseMask;
 244
 245         /*
 246          * Create undecoreated root window on background
 247          */
 248         if (wreq->flags & GP_X11_CREATE_ROOT_WIN) {
 249                 Atom xa;
 250
 251                 x11_get_screen_size(wreq);
 252
 253                 GP_DEBUG(2, "Creating a window above root, owerriding size to %ux%u",
 254                          wreq->w, wreq->h);
 255
 256                 win->win = XCreateWindow(win->dpy, DefaultRootWindow(win->dpy),
 257                                          0, 0, wreq->w, wreq->h, 0, CopyFromParent,
 258                                          InputOutput, CopyFromParent, attr_mask, &attrs);
 259
 260                 /* Set empty WM_PROTOCOLS */
 261                 GP_DEBUG(2, "Setting empty MW_PROTOCOLS");
 262                 XSetWMProtocols(win->dpy, win->win, NULL, 0);
 263
 264                 /* Set window type to desktop */
 265                 xa = XInternAtom(win->dpy, "_NET_WM_WINDOW_TYPE", False);
 266
 267                 if (xa != None) {
 268                         GP_DEBUG(2, "Setting Atom _NET_WM_WINDOW_TYPE to _NET_WM_WINDOW_TYPE_DESKTOP");
 269
 270                         Atom xa_prop = XInternAtom(win->dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", False);
 271
 272                         XChangeProperty(win->dpy, win->win, xa, XA_ATOM, 32,
 273                                         PropModeReplace, (unsigned char *) &xa_prop, 1);
 274                 }
 275
 276                 /* Turn off window decoration */
 277                 xa = XInternAtom(win->dpy, "_MOTIF_WM_HINTS", False);
 278
 279                 if (xa != None) {
 280                         GP_DEBUG(2, "Setting Atom _MOTIF_WM_HINTS to 2, 0, 0, 0, 0");
 281
 282                         long prop[5] = {2, 0, 0, 0, 0};
 283
 284                         XChangeProperty(win->dpy, win->win, xa, xa, 32,
 285                                         PropModeReplace, (unsigned char *) prop, 5);
 286                 }
 287
 288                 /* Set below other windows */
 289                 xa = XInternAtom(win->dpy, "_WIN_LAYER", False);
 290
 291                 if (xa != None) {
 292                         GP_DEBUG(2, "Setting Atom _WIN_LAYER to 6");
 293
 294                         long prop = 6;
 295
 296                         XChangeProperty(win->dpy, win->win, xa, XA_CARDINAL, 32,
 297                                         PropModeAppend, (unsigned char *) &prop, 1);
 298                 }
 299
 300                 xa = XInternAtom(win->dpy, "_NET_WM_STATE", False);
 301
 302                 if (xa != None) {
 303                         GP_DEBUG(2, "Setting Atom _NET_WM_STATE to _NET_WM_STATE_BELOW");
 304
 305                         Atom xa_prop = XInternAtom(win->dpy, "_NET_WM_STATE_BELOW", False);
 306
 307                         XChangeProperty(win->dpy, win->win, xa, XA_ATOM, 32,
 308                                         PropModeAppend, (unsigned char *) &xa_prop, 1);
 309                 }
 310
 311                 /* Set sticky */
 312                 xa = XInternAtom(win->dpy, "_NET_WM_DESKTOP", False);
 313
 314                 if (xa != None) {
 315                         GP_DEBUG(2, "Setting Atom _NET_WM_DESKTOP to 0xffffffff");
 316
 317                         CARD32 xa_prop = 0xffffffff;
 318
 319                         XChangeProperty(win->dpy, win->win, xa, XA_CARDINAL, 32,
 320                                         PropModeAppend, (unsigned char *) &xa_prop, 1);
 321                 }
 322
 323                 xa = XInternAtom(win->dpy, "_NET_WM_STATE", False);
 324
 325                 if (xa != None) {
 326                         GP_DEBUG(2, "Appending to Atom _NET_WM_STATE atom _NET_WM_STATE_STICKY");
 327
 328                         Atom xa_prop = XInternAtom(win->dpy, "_NET_WM_STATE_STICKY", False);
 329
 330                         XChangeProperty(win->dpy, win->win, xa, XA_ATOM, 32,
 331                                          PropModeAppend, (unsigned char *) &xa_prop, 1);
 332                 }
 333
 334                 /* Skip taskbar */
 335                 xa = XInternAtom(win->dpy, "_NET_WM_STATE", False);
 336
 337                 if (xa != None) {
 338                         GP_DEBUG(2, "Appending to Atom _NET_WM_STATE atom _NET_STATE_SKIP_TASKBAR");
 339
 340                         Atom xa_prop = XInternAtom(win->dpy, "_NET_WM_STATE_SKIP_TASKBAR", False);
 341
 342                         XChangeProperty(win->dpy, win->win, xa, XA_ATOM, 32,
 343                                          PropModeAppend, (unsigned char *) &xa_prop, 1);
 344                 }
 345
 346                 /* Skip pager */
 347                 xa = XInternAtom(win->dpy, "_NET_WM_STATE", False);
 348
 349                 if (xa != None) {
 350                         GP_DEBUG(2, "Appending to Atom _NET_WM_STATE atom _NET_STATE_SKIP_PAGER");
 351
 352                         Atom xa_prop = XInternAtom(win->dpy, "_NET_WM_STATE_SKIP_PAGER", False);
 353
 354                          XChangeProperty(win->dpy, win->win, xa, XA_ATOM, 32,
 355                                          PropModeAppend, (unsigned char *) &xa_prop, 1);
 356                 }
 357
 358                 /* Set 100% opacity */
 359                 xa = XInternAtom(win->dpy, "_NET_WM_WINDOW_OPACITY", False);
 360
 361                 if (xa != None) {
 362                         GP_DEBUG(2, "Setting Atom _NET_WM_WINDOW_OPACITY to 0xffffffff");
 363
 364                         long prop = 0xffffffff;
 365
 366                         XChangeProperty(win->dpy, win->win, xa, XA_CARDINAL, 32,
 367                                         PropModeAppend, (unsigned char *) &prop, 1);
 368                 }
 369
 370                 win_list_add(win);
 371
 372                 /* Show window */
 373                 XMapWindow(win->dpy, win->win);
 374                 return 0;
 375         }
 376
 377         GP_DEBUG(2, "Opening window '%s' %ix%i-%ux%u",
 378                  wreq->caption, wreq->x, wreq->y, wreq->w, wreq->h);
 379
 380         win->win = XCreateWindow(win->dpy, DefaultRootWindow(win->dpy),
 381                                  wreq->x, wreq->y, wreq->w, wreq->h, 0,
 382                                  CopyFromParent, InputOutput, CopyFromParent,
 383                                  attr_mask, &attrs);
 384
 385         /* Set window caption */
 386         XmbSetWMProperties(win->dpy, win->win, wreq->caption, wreq->caption,
 387                            NULL, 0, NULL, NULL, NULL);
 388
 389         /* Make the window close button send event */
 390         XSetWMProtocols(win->dpy, win->win, &x11_conn.A_WM_DELETE_WINDOW, 1);
 391
 392         win_list_add(win);
 393
 394         /* Show window */
 395         XMapWindow(win->dpy, win->win);
 396
 397         return 0;
 398 }
 399
 400 static void x11_win_close(struct x11_win *win)
 401 {
 402         GP_DEBUG(1, "Closing window");
 403
 404         XLockDisplay(win->dpy);
 405
 406         win_list_rem(win);
 407
 408 /*
 409         if (x11->shm_flag)
 410                 destroy_shm_ximage(self);
 411         else
 412                 destroy_ximage(self);
 413 */
 414         XUnmapWindow(win->dpy, win->win);
 415
 416         XDestroyWindow(win->dpy, win->win);
 417
 418         if (!win_list_empty())
 419                 XFlush(win->dpy);
 420
 421         XUnlockDisplay(win->dpy);
 422
 423         /* Close connection/Decrease ref count */
 424         x11_close();
 425 }