ewmh.c

   1 /*
   2  * ewmh.c - EWMH support functions
   3  *
   4  * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24
  25 #include <xcb/xcb.h>
  26 #include <xcb/xcb_atom.h>
  27
  28 #include "ewmh.h"
  29 #include "tag.h"
  30 #include "screen.h"
  31 #include "client.h"
  32 #include "widget.h"
  33 #include "cnode.h"
  34 #include "titlebar.h"
  35 #include "common/atoms.h"
  36
  37 extern awesome_t globalconf;
  38
  39 #define _NET_WM_STATE_REMOVE 0
  40 #define _NET_WM_STATE_ADD 1
  41 #define _NET_WM_STATE_TOGGLE 2
  42
  43 void
  44 ewmh_init(int phys_screen)
  45 {
  46     xcb_window_t father;
  47     xcb_screen_t *xscreen = xutil_screen_get(globalconf.connection, phys_screen);
  48     xcb_atom_t atom[] =
  49     {
  50         _NET_SUPPORTED,
  51         _NET_SUPPORTING_WM_CHECK,
  52         _NET_CLIENT_LIST,
  53         _NET_CLIENT_LIST_STACKING,
  54         _NET_NUMBER_OF_DESKTOPS,
  55         _NET_CURRENT_DESKTOP,
  56         _NET_DESKTOP_NAMES,
  57         _NET_ACTIVE_WINDOW,
  58         _NET_WORKAREA,
  59         _NET_CLOSE_WINDOW,
  60         _NET_WM_NAME,
  61         _NET_WM_ICON_NAME,
  62         _NET_WM_VISIBLE_ICON_NAME,
  63         _NET_WM_DESKTOP,
  64         _NET_WM_WINDOW_TYPE,
  65         _NET_WM_WINDOW_TYPE_NORMAL,
  66         _NET_WM_WINDOW_TYPE_DESKTOP,
  67         _NET_WM_WINDOW_TYPE_DOCK,
  68         _NET_WM_WINDOW_TYPE_SPLASH,
  69         _NET_WM_WINDOW_TYPE_DIALOG,
  70         _NET_WM_ICON,
  71         _NET_WM_PID,
  72         _NET_WM_STATE,
  73         _NET_WM_STATE_STICKY,
  74         _NET_WM_STATE_SKIP_TASKBAR,
  75         _NET_WM_STATE_FULLSCREEN,
  76         _NET_WM_STATE_ABOVE,
  77         _NET_WM_STATE_BELOW,
  78         _NET_WM_STATE_MODAL,
  79         _NET_WM_STATE_HIDDEN,
  80         _NET_WM_STATE_DEMANDS_ATTENTION
  81     };
  82     int i;
  83
  84     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
  85                         xscreen->root, _NET_SUPPORTED, ATOM, 32,
  86                         countof(atom), atom);
  87
  88     /* create our own window */
  89     father = xcb_generate_id(globalconf.connection);
  90     xcb_create_window(globalconf.connection, xscreen->root_depth,
  91                       father, xscreen->root, -1, -1, 1, 1, 0,
  92                       XCB_COPY_FROM_PARENT, xscreen->root_visual, 0, NULL);
  93
  94     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
  95                         xscreen->root, _NET_SUPPORTING_WM_CHECK, WINDOW, 32,
  96                         1, &father);
  97
  98     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
  99                         father, _NET_SUPPORTING_WM_CHECK, WINDOW, 32,
 100                         1, &father);
 101
 102     /* set the window manager name */
 103     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 104                         father, _NET_WM_NAME, UTF8_STRING, 8, 7, "awesome");
 105
 106     /* set the window manager PID */
 107     i = getpid();
 108     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 109                         father, _NET_WM_PID, CARDINAL, 32, 1, &i);
 110 }
 111
 112 void
 113 ewmh_update_net_client_list(int phys_screen)
 114 {
 115     xcb_window_t *wins;
 116     client_t *c;
 117     int n = 0;
 118
 119     for(c = globalconf.clients; c; c = c->next)
 120         n++;
 121
 122     wins = p_new(xcb_window_t, n);
 123
 124     for(n = 0, c = globalconf.clients; c; c = c->next, n++)
 125         if(c->phys_screen == phys_screen)
 126             wins[n] = c->win;
 127
 128     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 129                         xutil_screen_get(globalconf.connection, phys_screen)->root,
 130                         _NET_CLIENT_LIST, WINDOW, 32, n, wins);
 131
 132     p_delete(&wins);
 133 }
 134
 135 /** Set the client list in stacking order, bottom to top.
 136  * \param phys_screen The physical screen id.
 137  */
 138 void
 139 ewmh_update_net_client_list_stacking(int phys_screen)
 140 {
 141     xcb_window_t *wins;
 142     client_node_t *c;
 143     int n = 0;
 144
 145     for(c = globalconf.stack; c; c = c->next)
 146         n++;
 147
 148     wins = p_new(xcb_window_t, n);
 149
 150     for(n = 0, c = *client_node_list_last(&globalconf.stack); c; c = c->prev, n++)
 151         if(c->client->phys_screen == phys_screen)
 152             wins[n] = c->client->win;
 153
 154     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 155                         xutil_screen_get(globalconf.connection, phys_screen)->root,
 156                         _NET_CLIENT_LIST_STACKING, WINDOW, 32, n, wins);
 157
 158     p_delete(&wins);
 159 }
 160
 161 void
 162 ewmh_update_net_numbers_of_desktop(int phys_screen)
 163 {
 164     uint32_t count = globalconf.screens[phys_screen].tags.len;
 165
 166     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 167                         xutil_screen_get(globalconf.connection, phys_screen)->root,
 168                         _NET_NUMBER_OF_DESKTOPS, CARDINAL, 32, 1, &count);
 169 }
 170
 171 void
 172 ewmh_update_net_current_desktop(int phys_screen)
 173 {
 174     tag_array_t *tags = &globalconf.screens[phys_screen].tags;
 175     uint32_t count = 0;
 176     tag_t **curtags = tags_get_current(phys_screen);
 177
 178     while(count < (uint32_t) tags->len && tags->tab[count] != curtags[0])
 179         count++;
 180
 181     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 182                         xutil_screen_get(globalconf.connection, phys_screen)->root,
 183                         _NET_CURRENT_DESKTOP, CARDINAL, 32, 1, &count);
 184
 185     p_delete(&curtags);
 186 }
 187
 188 void
 189 ewmh_update_net_desktop_names(int phys_screen)
 190 {
 191     tag_array_t *tags = &globalconf.screens[phys_screen].tags;
 192     buffer_t buf;
 193
 194     buffer_inita(&buf, BUFSIZ);
 195
 196     for(int i = 0; i < tags->len; i++)
 197     {
 198         buffer_adds(&buf, tags->tab[i]->name);
 199         buffer_addc(&buf, '\0');
 200     }
 201
 202     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 203                         xutil_screen_get(globalconf.connection, phys_screen)->root,
 204                         _NET_DESKTOP_NAMES, UTF8_STRING, 8, buf.len, buf.s);
 205     buffer_wipe(&buf);
 206 }
 207
 208 /** Update the work area space for each physical screen and each desktop.
 209  * \param phys_screen The physical screen id.
 210  */
 211 void
 212 ewmh_update_workarea(int phys_screen)
 213 {
 214     tag_array_t *tags = &globalconf.screens[phys_screen].tags;
 215     uint32_t *area = p_alloca(uint32_t, tags->len * 4);
 216     area_t geom = screen_area_get(&globalconf.screens[phys_screen].geometry,
 217                                   globalconf.screens[phys_screen].statusbar,
 218                                   &globalconf.screens[phys_screen].padding);
 219
 220
 221     for(int i = 0; i < tags->len; i++)
 222     {
 223         area[4 * i + 0] = geom.x;
 224         area[4 * i + 1] = geom.y;
 225         area[4 * i + 2] = geom.width;
 226         area[4 * i + 3] = geom.height;
 227     }
 228
 229     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 230                         xutil_screen_get(globalconf.connection, phys_screen)->root,
 231                         _NET_WORKAREA, CARDINAL, 32, tags->len * 4, area);
 232 }
 233
 234 void
 235 ewmh_update_net_active_window(int phys_screen)
 236 {
 237     xcb_window_t win;
 238
 239     if(globalconf.screen_focus->client_focus
 240        && globalconf.screen_focus->client_focus->phys_screen == phys_screen)
 241         win = globalconf.screen_focus->client_focus->win;
 242     else
 243         win = XCB_NONE;
 244
 245     xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE,
 246                         xutil_screen_get(globalconf.connection, phys_screen)->root,
 247                         _NET_ACTIVE_WINDOW, WINDOW, 32, 1, &win);
 248 }
 249
 250 static void
 251 ewmh_process_state_atom(client_t *c, xcb_atom_t state, int set)
 252 {
 253     if(state == _NET_WM_STATE_STICKY)
 254     {
 255         tag_array_t *tags = &globalconf.screens[c->screen].tags;
 256         for(int i = 0; i < tags->len; i++)
 257             tag_client(c, tags->tab[i]);
 258     }
 259     else if(state == _NET_WM_STATE_SKIP_TASKBAR)
 260     {
 261         if(set == _NET_WM_STATE_REMOVE)
 262         {
 263             c->skiptb = false;
 264             c->skip = false;
 265         }
 266         else if(set == _NET_WM_STATE_ADD)
 267         {
 268             c->skiptb = true;
 269             c->skip = true;
 270         }
 271     }
 272     else if(state == _NET_WM_STATE_FULLSCREEN)
 273     {
 274         area_t geometry = c->geometry;
 275         if(set == _NET_WM_STATE_REMOVE)
 276         {
 277             /* restore geometry */
 278             geometry = c->m_geometry;
 279             /* restore borders and titlebar */
 280             if(c->titlebar && c->titlebar->sw && (c->titlebar->position = c->titlebar->oldposition))
 281                 xcb_map_window(globalconf.connection, c->titlebar->sw->window);
 282             c->noborder = false;
 283             c->ismax = false;
 284             client_setlayer(c, c->oldlayer);
 285             client_setborder(c, c->oldborder);
 286             client_setfloating(c, c->wasfloating);
 287         }
 288         else if(set == _NET_WM_STATE_ADD)
 289         {
 290             geometry = screen_area_get(&globalconf.screens[c->screen].geometry,
 291                                        NULL,
 292                                        &globalconf.screens[c->screen].padding);
 293             /* save geometry */
 294             c->m_geometry = c->geometry;
 295             c->wasfloating = c->isfloating;
 296             /* disable titlebar and borders */
 297             if(c->titlebar && c->titlebar->sw && (c->titlebar->oldposition = c->titlebar->position))
 298             {
 299                 xcb_unmap_window(globalconf.connection, c->titlebar->sw->window);
 300                 c->titlebar->position = Off;
 301             }
 302             c->ismax = true;
 303             c->oldborder = c->border;
 304             client_setborder(c, 0);
 305             c->noborder = true;
 306             c->oldlayer = c->layer;
 307             client_setlayer(c, LAYER_FULLSCREEN);
 308             client_setfloating(c, true);
 309         }
 310         widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 311         client_resize(c, geometry, false);
 312     }
 313     else if(state == _NET_WM_STATE_ABOVE)
 314     {
 315         if(set == _NET_WM_STATE_REMOVE)
 316             client_setlayer(c, c->oldlayer);
 317         else if(set == _NET_WM_STATE_ADD)
 318         {
 319             c->oldlayer = c->layer;
 320             client_setlayer(c, LAYER_ABOVE);
 321         }
 322     }
 323     else if(state == _NET_WM_STATE_BELOW)
 324     {
 325         if(set == _NET_WM_STATE_REMOVE)
 326             client_setlayer(c, c->oldlayer);
 327         else if(set == _NET_WM_STATE_ADD)
 328         {
 329             c->oldlayer = c->layer;
 330             client_setlayer(c, LAYER_BELOW);
 331         }
 332     }
 333     else if(state == _NET_WM_STATE_MODAL)
 334     {
 335         if(set == _NET_WM_STATE_REMOVE)
 336             client_setlayer(c, c->oldlayer);
 337         else if(set == _NET_WM_STATE_ADD)
 338         {
 339             c->oldlayer = c->layer;
 340             client_setlayer(c, LAYER_MODAL);
 341         }
 342     }
 343     else if(state == _NET_WM_STATE_HIDDEN)
 344     {
 345         if(set == _NET_WM_STATE_REMOVE)
 346             c->ishidden = false;
 347         else if(set == _NET_WM_STATE_ADD)
 348             c->ishidden = true;
 349         globalconf.screens[c->screen].need_arrange = true;
 350     }
 351     else if(state == _NET_WM_STATE_DEMANDS_ATTENTION)
 352     {
 353         if(set == _NET_WM_STATE_REMOVE)
 354             c->isurgent = false;
 355         else if(set == _NET_WM_STATE_ADD)
 356         {
 357             c->isurgent = true;
 358             /* execute hook */
 359             luaA_client_userdata_new(globalconf.L, c);
 360             luaA_dofunction(globalconf.L, globalconf.hooks.urgent, 1, 0);
 361             widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 362         }
 363     }
 364 }
 365
 366 static void
 367 ewmh_process_window_type_atom(client_t *c, xcb_atom_t state)
 368 {
 369     if(state == _NET_WM_WINDOW_TYPE_NORMAL)
 370     {
 371         /* do nothing. this is REALLY IMPORTANT */
 372     }
 373     else if(state == _NET_WM_WINDOW_TYPE_DOCK
 374             || state == _NET_WM_WINDOW_TYPE_SPLASH)
 375     {
 376         c->skip = true;
 377         c->isfixed = true;
 378         if(c->titlebar && c->titlebar->position && c->titlebar->sw)
 379         {
 380             xcb_unmap_window(globalconf.connection, c->titlebar->sw->window);
 381             c->titlebar->position = Off;
 382         }
 383         client_setborder(c, 0);
 384         c->noborder = true;
 385         client_setlayer(c, LAYER_ABOVE);
 386         client_setfloating(c, true);
 387     }
 388     else if(state == _NET_WM_WINDOW_TYPE_DIALOG)
 389     {
 390         client_setlayer(c, LAYER_MODAL);
 391         client_setfloating(c, true);
 392     }
 393     else if(state == _NET_WM_WINDOW_TYPE_DESKTOP)
 394     {
 395         tag_array_t *tags = &globalconf.screens[c->screen].tags;
 396         c->noborder = true;
 397         c->isfixed = true;
 398         c->skip = true;
 399         client_setlayer(c, LAYER_DESKTOP);
 400         for(int i = 0; i < tags->len; i++)
 401             tag_client(c, tags->tab[i]);
 402     }
 403 }
 404
 405 int
 406 ewmh_process_client_message(xcb_client_message_event_t *ev)
 407 {
 408     client_t *c;
 409     int screen;
 410
 411     if(ev->type == _NET_CURRENT_DESKTOP)
 412         for(screen = 0;
 413             screen < xcb_setup_roots_length(xcb_get_setup(globalconf.connection));
 414             screen++)
 415         {
 416             if(ev->window == xutil_screen_get(globalconf.connection, screen)->root)
 417                 tag_view_only_byindex(screen, ev->data.data32[0]);
 418         }
 419     else if(ev->type == _NET_CLOSE_WINDOW)
 420     {
 421         if((c = client_getbywin(ev->window)))
 422            client_kill(c);
 423     }
 424     else if(ev->type == _NET_WM_DESKTOP)
 425     {
 426         if((c = client_getbywin(ev->window)))
 427         {
 428             tag_array_t *tags = &globalconf.screens[c->screen].tags;
 429
 430             if(ev->data.data32[0] == 0xffffffff)
 431                 for(int i = 0; i < tags->len; i++)
 432                     tag_client(c, tags->tab[i]);
 433             else
 434                 for(int i = 0; i < tags->len; i++)
 435                     if((int)ev->data.data32[0] == i)
 436                         tag_client(c, tags->tab[i]);
 437                     else
 438                         untag_client(c, tags->tab[i]);
 439         }
 440     }
 441     else if(ev->type == _NET_WM_STATE)
 442     {
 443         if((c = client_getbywin(ev->window)))
 444         {
 445             ewmh_process_state_atom(c, (xcb_atom_t) ev->data.data32[1], ev->data.data32[0]);
 446             if(ev->data.data32[2])
 447                 ewmh_process_state_atom(c, (xcb_atom_t) ev->data.data32[2],
 448                                         ev->data.data32[0]);
 449         }
 450     }
 451
 452     return 0;
 453 }
 454
 455 void
 456 ewmh_check_client_hints(client_t *c)
 457 {
 458     xcb_atom_t *state;
 459     void *data = NULL;
 460     int desktop;
 461     xcb_get_property_cookie_t c0, c1, c2;
 462     xcb_get_property_reply_t *reply;
 463
 464     /* Send the GetProperty requests which will be processed later */
 465     c0 = xcb_get_property_unchecked(globalconf.connection, false, c->win,
 466                                     _NET_WM_DESKTOP, XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
 467
 468     c1 = xcb_get_property_unchecked(globalconf.connection, false, c->win,
 469                                     _NET_WM_STATE, ATOM, 0, UINT32_MAX);
 470
 471     c2 = xcb_get_property_unchecked(globalconf.connection, false, c->win,
 472                                     _NET_WM_WINDOW_TYPE, ATOM, 0, UINT32_MAX);
 473
 474     reply = xcb_get_property_reply(globalconf.connection, c0, NULL);
 475     if(reply && reply->value_len && (data = xcb_get_property_value(reply)))
 476     {
 477         tag_array_t *tags = &globalconf.screens[c->screen].tags;
 478
 479         desktop = *(uint32_t *) data;
 480         if(desktop == -1)
 481             for(int i = 0; i < tags->len; i++)
 482                 tag_client(c, tags->tab[i]);
 483         else
 484             for(int i = 0; i < tags->len; i++)
 485                 if(desktop == i)
 486                     tag_client(c, tags->tab[i]);
 487                 else
 488                     untag_client(c, tags->tab[i]);
 489     }
 490
 491     p_delete(&reply);
 492
 493     reply = xcb_get_property_reply(globalconf.connection, c1, NULL);
 494     if(reply && (data = xcb_get_property_value(reply)))
 495     {
 496         state = (xcb_atom_t *) data;
 497         for(int i = 0; i < xcb_get_property_value_length(reply); i++)
 498             ewmh_process_state_atom(c, state[i], _NET_WM_STATE_ADD);
 499     }
 500
 501     p_delete(&reply);
 502
 503     reply = xcb_get_property_reply(globalconf.connection, c2, NULL);
 504     if(reply && (data = xcb_get_property_value(reply)))
 505     {
 506         state = (xcb_atom_t *) data;
 507         for(int i = 0; i < xcb_get_property_value_length(reply); i++)
 508             ewmh_process_window_type_atom(c, state[i]);
 509     }
 510
 511     p_delete(&reply);
 512 }
 513
 514 /** Send request to get NET_WM_ICON (EWMH)
 515  * \param w The window.
 516  * \return The cookie associated with the request.
 517  */
 518 xcb_get_property_cookie_t
 519 ewmh_window_icon_get_unchecked(xcb_window_t w)
 520 {
 521   return xcb_get_property_unchecked(globalconf.connection, false, w,
 522                                     _NET_WM_ICON, CARDINAL, 0, UINT32_MAX);
 523 }
 524
 525 /** Get NET_WM_ICON.
 526  * \param cookie The cookie.
 527  * \return A netwm_icon_t structure which must be deleted after usage.
 528  */
 529 netwm_icon_t *
 530 ewmh_window_icon_get_reply(xcb_get_property_cookie_t cookie)
 531 {
 532     double alpha;
 533     netwm_icon_t *icon;
 534     int size, i;
 535     uint32_t *data;
 536     unsigned char *imgdata;
 537     xcb_get_property_reply_t *r;
 538
 539     r = xcb_get_property_reply(globalconf.connection, cookie, NULL);
 540     if(!r || r->type != CARDINAL || r->format != 32 || r->length < 2 ||
 541        !(data = (uint32_t *) xcb_get_property_value(r)))
 542     {
 543         p_delete(&r);
 544         return NULL;
 545     }
 546
 547     icon = p_new(netwm_icon_t, 1);
 548
 549     icon->width = data[0];
 550     icon->height = data[1];
 551     size = icon->width * icon->height;
 552
 553     if(!size)
 554     {
 555         p_delete(&icon);
 556         p_delete(&r);
 557         return NULL;
 558     }
 559
 560     icon->image = p_new(unsigned char, size * 4);
 561     for(imgdata = icon->image, i = 2; i < size + 2; i++, imgdata += 4)
 562     {
 563         imgdata[3] = (data[i] >> 24) & 0xff;           /* A */
 564         alpha = imgdata[3] / 255.0;
 565         imgdata[2] = ((data[i] >> 16) & 0xff) * alpha; /* R */
 566         imgdata[1] = ((data[i] >>  8) & 0xff) * alpha; /* G */
 567         imgdata[0] = (data[i]         & 0xff) * alpha; /* B */
 568     }
 569
 570     p_delete(&r);
 571
 572     return icon;
 573 }
 574
 575 /**
 576  * Restart awesome.
 577  */
 578 void
 579 ewmh_restart(void)
 580 {
 581     client_t *c;
 582
 583     for(c = globalconf.clients; c; c = c->next)
 584         client_unban(c);
 585
 586     xcb_aux_sync(globalconf.connection);
 587     xcb_disconnect(globalconf.connection);
 588
 589     a_exec(globalconf.argv);
 590 }
 591
 592 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80