git.sesse.net Git - vlc/blob - modules/video_output/xcb/window.c

   1 /**
   2  * @file window.c
   3  * @brief X C Bindings window provider module for VLC media player
   4  */
   5 /*****************************************************************************
   6  * Copyright © 2009 Rémi Denis-Courmont
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  ****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 #include <stdarg.h>
  28 #include <assert.h>
  29 #include <poll.h>
  30 #include <unistd.h> /* gethostname() and sysconf() */
  31 #include <limits.h> /* _POSIX_HOST_NAME_MAX */
  32
  33 #include <xcb/xcb.h>
  34 typedef xcb_atom_t Atom;
  35 #include <X11/Xatom.h> /* XA_WM_NAME */
  36
  37 #include <vlc_common.h>
  38 #include <vlc_plugin.h>
  39 #include <vlc_vout_window.h>
  40
  41 #include "xcb_vlc.h"
  42
  43 #define XID_TEXT N_("ID of the video output X window")
  44 #define XID_LONGTEXT N_( \
  45     "VLC can embed its video output in an existing X11 window. " \
  46     "This is the X identifier of that window (0 means none).")
  47
  48 static int  Open (vlc_object_t *);
  49 static void Close (vlc_object_t *);
  50 static int  EmOpen (vlc_object_t *);
  51 static void EmClose (vlc_object_t *);
  52
  53 /*
  54  * Module descriptor
  55  */
  56 vlc_module_begin ()
  57     set_shortname (N_("X window"))
  58     set_description (N_("X11 video window (XCB)"))
  59     set_category (CAT_VIDEO)
  60     set_subcategory (SUBCAT_VIDEO_VOUT)
  61     set_capability ("vout window xid", 10)
  62     set_callbacks (Open, Close)
  63
  64     /* Obsolete since 1.1.0: */
  65     add_obsolete_bool ("x11-altfullscreen")
  66     add_obsolete_bool ("xvideo-altfullscreen")
  67     add_obsolete_bool ("xvmc-altfullscreen")
  68     add_obsolete_bool ("glx-altfullscreen")
  69
  70     add_submodule ()
  71     set_shortname (N_("Drawable"))
  72     set_description (N_("Embedded window video"))
  73     set_category (CAT_VIDEO)
  74     set_subcategory (SUBCAT_VIDEO_VOUT)
  75     set_capability ("vout window xid", 70)
  76     set_callbacks (EmOpen, EmClose)
  77
  78     add_integer ("drawable-xid", 0, NULL, XID_TEXT, XID_LONGTEXT, true)
  79         change_unsaveable ()
  80
  81 vlc_module_end ()
  82
  83 static int Control (vout_window_t *, int, va_list ap);
  84 static void *Thread (void *);
  85
  86 #define MATCHBOX_HACK 1 /* Matchbox focus hack */
  87
  88 struct vout_window_sys_t
  89 {
  90     xcb_connection_t *conn;
  91     key_handler_t *keys;
  92     vlc_thread_t thread;
  93
  94     xcb_window_t root;
  95     xcb_atom_t wm_state;
  96     xcb_atom_t wm_state_above;
  97     xcb_atom_t wm_state_below;
  98     xcb_atom_t wm_state_fullscreen;
  99 #ifdef MATCHBOX_HACK
 100     xcb_atom_t mb_current_app_window;
 101 #endif
 102 };
 103
 104 /** Set an X window property from a nul-terminated string */
 105 static inline
 106 void set_string (xcb_connection_t *conn, xcb_window_t window,
 107                  xcb_atom_t type, xcb_atom_t atom, const char *str)
 108 {
 109     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, atom, type,
 110                          /* format */ 8, strlen (str), str);
 111 }
 112
 113 /** Set an X window string property */
 114 static inline
 115 void set_ascii_prop (xcb_connection_t *conn, xcb_window_t window,
 116                      xcb_atom_t atom, const char *value)
 117 {
 118     set_string (conn, window, XA_STRING, atom, value);
 119 }
 120
 121 static inline
 122 void set_wm_hints (xcb_connection_t *conn, xcb_window_t window)
 123 {
 124     static const uint32_t wm_hints[8] = {
 125         3, /* flags: Input, Initial state */
 126         1, /* input: True */
 127         1, /* initial state: Normal */
 128         0, 0, 0, 0, 0, /* Icon */
 129     };
 130     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, XA_WM_HINTS,
 131                          XA_WM_HINTS, 32, 8, wm_hints);
 132 }
 133
 134 /** Set the Window ICCCM client machine property */
 135 static inline
 136 void set_hostname_prop (xcb_connection_t *conn, xcb_window_t window)
 137 {
 138     char* hostname;
 139     long host_name_max = sysconf (_SC_HOST_NAME_MAX);
 140     if (host_name_max <= 0) host_name_max = _POSIX_HOST_NAME_MAX;
 141     hostname = malloc (host_name_max);
 142     if(!hostname) return;
 143
 144     if (gethostname (hostname, host_name_max) == 0)
 145     {
 146         hostname[host_name_max - 1] = '\0';
 147         set_ascii_prop (conn, window, XA_WM_CLIENT_MACHINE, hostname);
 148     }
 149     free(hostname);
 150 }
 151
 152 /** Request the X11 server to internalize a string into an atom */
 153 static inline
 154 xcb_intern_atom_cookie_t intern_string (xcb_connection_t *c, const char *s)
 155 {
 156     return xcb_intern_atom (c, 0, strlen (s), s);
 157 }
 158
 159 /** Extract the X11 atom from an intern request cookie */
 160 static
 161 xcb_atom_t get_atom (xcb_connection_t *conn, xcb_intern_atom_cookie_t ck)
 162 {
 163     xcb_intern_atom_reply_t *reply;
 164     xcb_atom_t atom;
 165
 166     reply = xcb_intern_atom_reply (conn, ck, NULL);
 167     if (reply == NULL)
 168         return 0;
 169
 170     atom = reply->atom;
 171     free (reply);
 172     return atom;
 173 }
 174
 175 #define NET_WM_STATE_REMOVE 0
 176 #define NET_WM_STATE_ADD    1
 177 #define NET_WM_STATE_TOGGLE 2
 178
 179 static void CacheAtoms (vout_window_sys_t *p_sys)
 180 {
 181     xcb_connection_t *conn = p_sys->conn;
 182     xcb_intern_atom_cookie_t wm_state_ck, wm_state_above_ck,
 183                              wm_state_below_ck, wm_state_fs_ck;
 184
 185     wm_state_ck = intern_string (conn, "_NET_WM_STATE");
 186     wm_state_above_ck = intern_string (conn, "_NET_WM_STATE_ABOVE");
 187     wm_state_below_ck = intern_string (conn, "_NET_WM_STATE_BELOW");
 188     wm_state_fs_ck = intern_string (conn, "_NET_WM_STATE_FULLSCREEN");
 189 #ifdef MATCHBOX_HACK
 190     xcb_intern_atom_cookie_t mb_current_app_window;
 191     mb_current_app_window = xcb_intern_atom (conn, true,
 192                                              strlen ("_MB_CURRENT_APP_WINDOW"),
 193                                              "_MB_CURRENT_APP_WINDOW");
 194 #endif
 195
 196     p_sys->wm_state = get_atom (conn, wm_state_ck);
 197     p_sys->wm_state_above = get_atom (conn, wm_state_above_ck);
 198     p_sys->wm_state_below = get_atom (conn, wm_state_below_ck);
 199     p_sys->wm_state_fullscreen = get_atom (conn, wm_state_fs_ck);
 200 #ifdef MATCHBOX_HACK
 201     p_sys->mb_current_app_window = get_atom (conn, mb_current_app_window);
 202 #endif
 203 }
 204
 205 /**
 206  * Create an X11 window.
 207  */
 208 static int Open (vlc_object_t *obj)
 209 {
 210     vout_window_t *wnd = (vout_window_t *)obj;
 211     xcb_generic_error_t *err;
 212     xcb_void_cookie_t ck;
 213
 214     vout_window_sys_t *p_sys = malloc (sizeof (*p_sys));
 215     if (p_sys == NULL)
 216         return VLC_ENOMEM;
 217
 218     /* Connect to X */
 219     char *display = var_CreateGetNonEmptyString (wnd, "x11-display");
 220     int snum;
 221
 222     xcb_connection_t *conn = xcb_connect (display, &snum);
 223     if (xcb_connection_has_error (conn) /*== NULL*/)
 224         goto error;
 225
 226     /* Find configured screen */
 227     const xcb_setup_t *setup = xcb_get_setup (conn);
 228     const xcb_screen_t *scr = NULL;
 229     for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup);
 230          i.rem > 0; xcb_screen_next (&i))
 231     {
 232         if (snum == 0)
 233         {
 234             scr = i.data;
 235             break;
 236         }
 237         snum--;
 238     }
 239     if (scr == NULL)
 240     {
 241         msg_Err (wnd, "bad X11 screen number");
 242         goto error;
 243     }
 244
 245     /* Create window */
 246     const uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
 247     uint32_t values[2] = {
 248         /* XCB_CW_BACK_PIXEL */
 249         scr->black_pixel,
 250         /* XCB_CW_EVENT_MASK */
 251         XCB_EVENT_MASK_KEY_PRESS,
 252     };
 253
 254     xcb_window_t window = xcb_generate_id (conn);
 255     ck = xcb_create_window_checked (conn, scr->root_depth, window, scr->root,
 256                                     0, 0, wnd->cfg->width, wnd->cfg->height, 0,
 257                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
 258                                     scr->root_visual, mask, values);
 259     err = xcb_request_check (conn, ck);
 260     if (err)
 261     {
 262         msg_Err (wnd, "creating window: X11 error %d", err->error_code);
 263         free (err);
 264         goto error;
 265     }
 266
 267     wnd->handle.xid = window;
 268     wnd->x11_display = display;
 269     wnd->control = Control;
 270     wnd->sys = p_sys;
 271
 272     p_sys->conn = conn;
 273     if (var_CreateGetBool (obj, "keyboard-events"))
 274         p_sys->keys = CreateKeyHandler (obj, conn);
 275     else
 276         p_sys->keys = NULL;
 277     p_sys->root = scr->root;
 278
 279     /* ICCCM
 280      * No cut&paste nor drag&drop, only Window Manager communication. */
 281     /* Plain ASCII localization of VLC for ICCCM window name */
 282     set_ascii_prop (conn, window, XA_WM_NAME,
 283                   vlc_pgettext ("ASCII", "VLC media player"));
 284     set_ascii_prop (conn, window, XA_WM_ICON_NAME,
 285                     vlc_pgettext ("ASCII", "VLC"));
 286     set_wm_hints (conn, window);
 287     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, XA_WM_CLASS,
 288                          XA_STRING, 8, 8, "vlc\0Vlc");
 289     set_hostname_prop (conn, window);
 290
 291     /* EWMH */
 292     xcb_intern_atom_cookie_t utf8_string_ck
 293         = intern_string (conn, "UTF8_STRING");;
 294     xcb_intern_atom_cookie_t net_wm_name_ck
 295         = intern_string (conn, "_NET_WM_NAME");
 296     xcb_intern_atom_cookie_t net_wm_icon_name_ck
 297         = intern_string (conn, "_NET_WM_ICON_NAME");
 298     xcb_intern_atom_cookie_t wm_window_role_ck
 299         = intern_string (conn, "WM_WINDOW_ROLE");
 300
 301     xcb_atom_t utf8 = get_atom (conn, utf8_string_ck);
 302
 303     xcb_atom_t net_wm_name = get_atom (conn, net_wm_name_ck);
 304     char *title = var_CreateGetNonEmptyString (wnd, "video-title");
 305     if (title)
 306     {
 307         set_string (conn, window, utf8, net_wm_name, title);
 308         free (title);
 309     }
 310     else
 311         set_string (conn, window, utf8, net_wm_name, _("VLC media player"));
 312
 313     xcb_atom_t net_wm_icon_name = get_atom (conn, net_wm_icon_name_ck);
 314     set_string (conn, window, utf8, net_wm_icon_name, _("VLC"));
 315
 316     xcb_atom_t wm_window_role = get_atom (conn, wm_window_role_ck);
 317     set_ascii_prop (conn, window, wm_window_role, "vlc-video");
 318
 319     /* Cache any EWMH atom we may need later */
 320     CacheAtoms (p_sys);
 321 #ifdef MATCHBOX_HACK
 322     if (p_sys->mb_current_app_window)
 323     {
 324         uint32_t value = XCB_EVENT_MASK_PROPERTY_CHANGE;
 325         xcb_change_window_attributes (conn, scr->root,
 326                                       XCB_CW_EVENT_MASK, &value);
 327     }
 328 #endif
 329
 330     /* Make the window visible */
 331     xcb_map_window (conn, window);
 332
 333     if (var_CreateGetBool (obj, "video-wallpaper"))
 334     {
 335         vout_window_SetState (wnd, VOUT_WINDOW_STATE_BELOW);
 336         vout_window_SetFullScreen (wnd, true);
 337     }
 338
 339     /* Create the event thread. It will dequeue all events, so any checked
 340      * request from this thread must be completed at this point. */
 341     if ((p_sys->keys != NULL)
 342      && vlc_clone (&p_sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
 343         DestroyKeyHandler (p_sys->keys);
 344
 345 #ifdef MATCHBOX_HACK
 346     if (p_sys->mb_current_app_window)
 347         xcb_set_input_focus (p_sys->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
 348                              wnd->handle.xid, XCB_CURRENT_TIME);
 349 #endif
 350     xcb_flush (conn); /* Make sure map_window is sent (should be useless) */
 351     return VLC_SUCCESS;
 352
 353 error:
 354     xcb_disconnect (conn);
 355     free (display);
 356     free (p_sys);
 357     return VLC_EGENERIC;
 358 }
 359
 360
 361 /**
 362  * Destroys the X11 window.
 363  */
 364 static void Close (vlc_object_t *obj)
 365 {
 366     vout_window_t *wnd = (vout_window_t *)obj;
 367     vout_window_sys_t *p_sys = wnd->sys;
 368     xcb_connection_t *conn = p_sys->conn;
 369
 370     if (p_sys->keys)
 371     {
 372         vlc_cancel (p_sys->thread);
 373         vlc_join (p_sys->thread, NULL);
 374         DestroyKeyHandler (p_sys->keys);
 375     }
 376     xcb_disconnect (conn);
 377     free (wnd->x11_display);
 378     free (p_sys);
 379 }
 380
 381
 382 /** Background thread for X11 events handling */
 383 static void *Thread (void *data)
 384 {
 385     vout_window_t *wnd = data;
 386     vout_window_sys_t *p_sys = wnd->sys;
 387     xcb_connection_t *conn = p_sys->conn;
 388
 389     int fd = xcb_get_file_descriptor (conn);
 390     if (fd == -1)
 391         return NULL;
 392
 393     for (;;)
 394     {
 395         xcb_generic_event_t *ev;
 396         struct pollfd ufd = { .fd = fd, .events = POLLIN, };
 397
 398         poll (&ufd, 1, -1);
 399
 400         int canc = vlc_savecancel ();
 401         while ((ev = xcb_poll_for_event (conn)) != NULL)
 402         {
 403             if (ProcessKeyEvent (p_sys->keys, ev) == 0)
 404                 continue;
 405 #ifdef MATCHBOX_HACK
 406             if (p_sys->mb_current_app_window
 407              && (ev->response_type & 0x7f) == XCB_PROPERTY_NOTIFY)
 408             {
 409                 const xcb_property_notify_event_t *pne =
 410                     (xcb_property_notify_event_t *)ev;
 411                 if (pne->atom == p_sys->mb_current_app_window
 412                  && pne->state == XCB_PROPERTY_NEW_VALUE)
 413                 {
 414                     xcb_get_property_reply_t *r =
 415                         xcb_get_property_reply (conn,
 416                             xcb_get_property (conn, 0, pne->window, pne->atom,
 417                                               XA_WINDOW, 0, 4), NULL);
 418                     if (r != NULL
 419                      && !memcmp (xcb_get_property_value (r), &wnd->handle.xid,
 420                                  4))
 421                     {
 422                         msg_Dbg (wnd, "asking Matchbox for input focus");
 423                         xcb_set_input_focus (conn,
 424                                              XCB_INPUT_FOCUS_POINTER_ROOT,
 425                                              wnd->handle.xid, pne->time);
 426                         xcb_flush (conn);
 427                     }
 428                     free (r);
 429                 }
 430             }
 431             else
 432 #endif
 433                 msg_Dbg (wnd, "unhandled event: %"PRIu8, ev->response_type);
 434             free (ev);
 435         }
 436         vlc_restorecancel (canc);
 437
 438         if (xcb_connection_has_error (conn))
 439         {
 440             msg_Err (wnd, "X server failure");
 441             break;
 442         }
 443     }
 444     return NULL;
 445 }
 446
 447 /** Changes the EWMH state of the window */
 448 static void set_wm_state (vout_window_t *wnd, bool on, xcb_atom_t state)
 449 {
 450     vout_window_sys_t *sys = wnd->sys;
 451     /* From EWMH "_WM_STATE" */
 452     xcb_client_message_event_t ev = {
 453          .response_type = XCB_CLIENT_MESSAGE,
 454          .format = 32,
 455          .window = wnd->handle.xid,
 456          .type = sys->wm_state,
 457     };
 458
 459     ev.data.data32[0] = on ? NET_WM_STATE_ADD : NET_WM_STATE_REMOVE;
 460     ev.data.data32[1] = state;
 461     ev.data.data32[2] = 0;
 462     ev.data.data32[3] = 1;
 463
 464     /* From ICCCM "Changing Window State" */
 465     xcb_send_event (sys->conn, 0, sys->root,
 466                     XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
 467                     XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
 468                     (const char *)&ev);
 469 }
 470
 471
 472 static int Control (vout_window_t *wnd, int cmd, va_list ap)
 473 {
 474     vout_window_sys_t *p_sys = wnd->sys;
 475     xcb_connection_t *conn = p_sys->conn;
 476
 477     switch (cmd)
 478     {
 479         case VOUT_WINDOW_SET_SIZE:
 480         {
 481             unsigned width = va_arg (ap, unsigned);
 482             unsigned height = va_arg (ap, unsigned);
 483             const uint32_t values[] = { width, height, };
 484
 485             xcb_configure_window (conn, wnd->handle.xid,
 486                                   XCB_CONFIG_WINDOW_WIDTH |
 487                                   XCB_CONFIG_WINDOW_HEIGHT, values);
 488             break;
 489         }
 490
 491         case VOUT_WINDOW_SET_STATE:
 492         {
 493             unsigned state = va_arg (ap, unsigned);
 494             bool above = (state & VOUT_WINDOW_STATE_ABOVE) != 0;
 495             bool below = (state & VOUT_WINDOW_STATE_BELOW) != 0;
 496
 497             set_wm_state (wnd, above, p_sys->wm_state_above);
 498             set_wm_state (wnd, below, p_sys->wm_state_below);
 499             break;
 500         }
 501
 502         case VOUT_WINDOW_SET_FULLSCREEN:
 503         {
 504             bool fs = va_arg (ap, int);
 505             if (!fs && var_GetBool (wnd, "video-wallpaper"))
 506                 return VLC_EGENERIC;
 507             set_wm_state (wnd, fs, p_sys->wm_state_fullscreen);
 508             break;
 509         }
 510
 511         default:
 512             msg_Err (wnd, "request %d not implemented", cmd);
 513             return VLC_EGENERIC;
 514     }
 515     xcb_flush (p_sys->conn);
 516     return VLC_SUCCESS;
 517 }
 518
 519 /*** Embedded drawable support ***/
 520
 521 static vlc_mutex_t serializer = VLC_STATIC_MUTEX;
 522
 523 /** Acquire a drawable */
 524 static int AcquireDrawable (vlc_object_t *obj, xcb_window_t window)
 525 {
 526     xcb_window_t *used;
 527     size_t n = 0;
 528
 529     if (var_Create (obj->p_libvlc, "xid-in-use", VLC_VAR_ADDRESS))
 530         return VLC_ENOMEM;
 531
 532     /* Keep a list of busy drawables, so we don't overlap videos if there are
 533      * more than one video track in the stream. */
 534     vlc_mutex_lock (&serializer);
 535     used = var_GetAddress (obj->p_libvlc, "xid-in-use");
 536     if (used != NULL)
 537     {
 538         while (used[n])
 539         {
 540             if (used[n] == window)
 541                 goto skip;
 542             n++;
 543         }
 544     }
 545
 546     used = realloc (used, sizeof (*used) * (n + 2));
 547     if (used != NULL)
 548     {
 549         used[n] = window;
 550         used[n + 1] = 0;
 551         var_SetAddress (obj->p_libvlc, "xid-in-use", used);
 552     }
 553     else
 554     {
 555 skip:
 556         msg_Warn (obj, "X11 drawable 0x%08"PRIx8" is busy", window);
 557         window = 0;
 558     }
 559     vlc_mutex_unlock (&serializer);
 560
 561     return (window == 0) ? VLC_EGENERIC : VLC_SUCCESS;
 562 }
 563
 564 /** Remove this drawable from the list of busy ones */
 565 static void ReleaseDrawable (vlc_object_t *obj, xcb_window_t window)
 566 {
 567     xcb_window_t *used;
 568     size_t n = 0;
 569
 570     vlc_mutex_lock (&serializer);
 571     used = var_GetAddress (obj->p_libvlc, "xid-in-use");
 572     assert (used);
 573     while (used[n] != window)
 574     {
 575         assert (used[n]);
 576         n++;
 577     }
 578     do
 579         used[n] = used[n + 1];
 580     while (used[++n]);
 581
 582     if (n == 0)
 583          var_SetAddress (obj->p_libvlc, "xid-in-use", NULL);
 584     vlc_mutex_unlock (&serializer);
 585
 586     if (n == 0)
 587         free (used);
 588     /* Variables are reference-counted... */
 589     var_Destroy (obj->p_libvlc, "xid-in-use");
 590 }
 591
 592 /**
 593  * Wrap an existing X11 window to embed the video.
 594  */
 595 static int EmOpen (vlc_object_t *obj)
 596 {
 597     vout_window_t *wnd = (vout_window_t *)obj;
 598
 599     xcb_window_t window = var_CreateGetInteger (obj, "drawable-xid");
 600     if (window == 0)
 601         return VLC_EGENERIC;
 602     var_Destroy (obj, "drawable-xid");
 603
 604     if (AcquireDrawable (obj, window))
 605         return VLC_EGENERIC;
 606
 607     vout_window_sys_t *p_sys = malloc (sizeof (*p_sys));
 608     xcb_connection_t *conn = xcb_connect (NULL, NULL);
 609     if (p_sys == NULL || xcb_connection_has_error (conn))
 610         goto error;
 611
 612     wnd->handle.xid = window;
 613     wnd->control = Control;
 614     wnd->sys = p_sys;
 615
 616     p_sys->conn = conn;
 617
 618     xcb_get_geometry_reply_t *geo =
 619         xcb_get_geometry_reply (conn, xcb_get_geometry (conn, window), NULL);
 620     if (geo == NULL)
 621     {
 622         msg_Err (obj, "bad X11 window 0x%08"PRIx8, window);
 623         goto error;
 624     }
 625     p_sys->root = geo->root;
 626     free (geo);
 627
 628     if (var_CreateGetBool (obj, "keyboard-events"))
 629     {
 630         p_sys->keys = CreateKeyHandler (obj, conn);
 631         if (p_sys->keys != NULL)
 632         {
 633             const uint32_t mask = XCB_CW_EVENT_MASK;
 634             const uint32_t values[1] = {
 635                 XCB_EVENT_MASK_KEY_PRESS,
 636             };
 637             xcb_change_window_attributes (conn, window, mask, values);
 638         }
 639     }
 640
 641     CacheAtoms (p_sys);
 642     if ((p_sys->keys != NULL)
 643      && vlc_clone (&p_sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
 644         DestroyKeyHandler (p_sys->keys);
 645
 646     xcb_flush (conn);
 647
 648     return VLC_SUCCESS;
 649
 650 error:
 651     xcb_disconnect (conn);
 652     free (p_sys);
 653     ReleaseDrawable (obj, window);
 654     return VLC_EGENERIC;
 655 }
 656
 657 static void EmClose (vlc_object_t *obj)
 658 {
 659     vout_window_t *wnd = (vout_window_t *)obj;
 660     xcb_window_t window = wnd->handle.xid;
 661
 662     Close (obj);
 663     ReleaseDrawable (obj, window);
 664 }