property.c

   1 /*
   2  * property.c - property handlers
   3  *
   4  * Copyright © 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 <xcb/xcb_atom.h>
  23
  24 #include "property.h"
  25 #include "client.h"
  26 #include "widget.h"
  27 #include "ewmh.h"
  28 #include "common/atoms.h"
  29
  30 extern awesome_t globalconf;
  31
  32
  33 void
  34 property_update_wm_transient_for(client_t *c, xcb_get_property_reply_t *reply)
  35 {
  36     xcb_window_t trans;
  37
  38     if(reply)
  39     {
  40         if(!xcb_get_wm_transient_for_from_reply(&trans, reply))
  41             return;
  42     }
  43     else
  44     {
  45         if(!xcb_get_wm_transient_for_reply(globalconf.connection,
  46                                             xcb_get_wm_transient_for_unchecked(globalconf.connection,
  47                                                                                c->win),
  48                                             &trans, NULL))
  49             return;
  50     }
  51
  52     c->type = WINDOW_TYPE_DIALOG;
  53     c->transient_for = client_getbywin(trans);
  54 }
  55
  56 static int
  57 property_handle_wm_transient_for(void *data,
  58                                  xcb_connection_t *connection,
  59                                  uint8_t state,
  60                                  xcb_window_t window,
  61                                  xcb_atom_t name,
  62                                  xcb_get_property_reply_t *reply)
  63 {
  64     client_t *c = client_getbywin(window);
  65
  66     if(c && !client_isfloating(c))
  67         property_update_wm_transient_for(c, reply);
  68
  69     return 0;
  70 }
  71
  72 /** Update the size hints of a client.
  73  * \param c The client.
  74  */
  75 void
  76 property_update_wm_normal_hints(client_t *c, xcb_get_property_reply_t *reply)
  77 {
  78     if(reply)
  79     {
  80         if(!xcb_get_wm_size_hints_from_reply(&c->size_hints, reply))
  81             return;
  82     }
  83     else
  84     {
  85         if(!xcb_get_wm_normal_hints_reply(globalconf.connection,
  86                                           xcb_get_wm_normal_hints_unchecked(globalconf.connection,
  87                                                                             c->win),
  88                                           &c->size_hints, NULL))
  89             return;
  90     }
  91
  92     if((c->size_hints.flags & XCB_SIZE_HINT_P_SIZE))
  93     {
  94         c->basew = c->size_hints.base_width;
  95         c->baseh = c->size_hints.base_height;
  96     }
  97     else if((c->size_hints.flags & XCB_SIZE_HINT_P_MIN_SIZE))
  98     {
  99         c->basew = c->size_hints.min_width;
 100         c->baseh = c->size_hints.min_height;
 101     }
 102     else
 103         c->basew = c->baseh = 0;
 104
 105     if((c->size_hints.flags & XCB_SIZE_HINT_P_RESIZE_INC))
 106     {
 107         c->incw = c->size_hints.width_inc;
 108         c->inch = c->size_hints.height_inc;
 109     }
 110     else
 111         c->incw = c->inch = 0;
 112
 113     if((c->size_hints.flags & XCB_SIZE_HINT_P_MAX_SIZE))
 114     {
 115         c->maxw = c->size_hints.max_width;
 116         c->maxh = c->size_hints.max_height;
 117     }
 118     else
 119         c->maxw = c->maxh = 0;
 120
 121     if((c->size_hints.flags & XCB_SIZE_HINT_P_MIN_SIZE))
 122     {
 123         c->minw = c->size_hints.min_width;
 124         c->minh = c->size_hints.min_height;
 125     }
 126     else if((c->size_hints.flags & XCB_SIZE_HINT_BASE_SIZE))
 127     {
 128         c->minw = c->size_hints.base_width;
 129         c->minh = c->size_hints.base_height;
 130     }
 131     else
 132         c->minw = c->minh = 0;
 133
 134     if((c->size_hints.flags & XCB_SIZE_HINT_P_ASPECT))
 135     {
 136         c->minax = c->size_hints.min_aspect_num;
 137         c->minay = c->size_hints.min_aspect_den;
 138         c->maxax = c->size_hints.max_aspect_num;
 139         c->maxay = c->size_hints.max_aspect_den;
 140     }
 141     else
 142         c->minax = c->maxax = c->minay = c->maxay = 0;
 143
 144     c->hassizehints = !(!c->basew && !c->baseh && !c->incw && !c->inch
 145                         && !c->maxw && !c->maxh && !c->minw && !c->minh
 146                         && !c->minax && !c->maxax && !c->minax && !c->minay);
 147 }
 148
 149 static int
 150 property_handle_wm_normal_hints(void *data,
 151                                 xcb_connection_t *connection,
 152                                 uint8_t state,
 153                                 xcb_window_t window,
 154                                 xcb_atom_t name,
 155                                 xcb_get_property_reply_t *reply)
 156 {
 157     client_t *c = client_getbywin(window);
 158
 159     if(c)
 160         property_update_wm_normal_hints(c, reply);
 161
 162     return 0;
 163 }
 164
 165 /** Update the WM hints of a client.
 166  * \param c The client.
 167  */
 168 void
 169 property_update_wm_hints(client_t *c, xcb_get_property_reply_t *reply)
 170 {
 171     xcb_wm_hints_t wmh;
 172
 173     if(reply)
 174     {
 175         if(!xcb_get_wm_hints_from_reply(&wmh, reply))
 176             return;
 177     }
 178     else
 179     {
 180         if(!xcb_get_wm_hints_reply(globalconf.connection,
 181                                   xcb_get_wm_hints_unchecked(globalconf.connection, c->win),
 182                                   &wmh, NULL))
 183             return;
 184     }
 185
 186     bool isurgent = xcb_wm_hints_get_urgency(&wmh);
 187     if(isurgent != c->isurgent)
 188     {
 189         c->isurgent = isurgent;
 190
 191         /* execute hook */
 192         luaA_client_userdata_new(globalconf.L, c);
 193         luaA_dofunction(globalconf.L, globalconf.hooks.urgent, 1, 0);
 194
 195         widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 196     }
 197     if((wmh.flags & XCB_WM_HINT_STATE) &&
 198        wmh.initial_state == XCB_WM_STATE_WITHDRAWN)
 199         client_setborder(c, 0);
 200
 201     c->nofocus = !wmh.input;
 202 }
 203
 204 static int
 205 property_handle_wm_hints(void *data,
 206                          xcb_connection_t *connection,
 207                          uint8_t state,
 208                          xcb_window_t window,
 209                          xcb_atom_t name,
 210                          xcb_get_property_reply_t *reply)
 211 {
 212     client_t *c = client_getbywin(window);
 213
 214     if(c)
 215         property_update_wm_hints(c, reply);
 216
 217     return 0;
 218 }
 219
 220 /** Update client name attribute with its new title.
 221  * \param c The client.
 222  * \param Return true if it has been updated.
 223  */
 224 void
 225 property_update_wm_name(client_t *c)
 226 {
 227     char *name, *utf8;
 228     ssize_t len;
 229
 230     if(!xutil_text_prop_get(globalconf.connection, c->win, _NET_WM_NAME, &name, &len))
 231         if(!xutil_text_prop_get(globalconf.connection, c->win, WM_NAME, &name, &len))
 232             return;
 233
 234     p_delete(&c->name);
 235
 236     if((utf8 = draw_iso2utf8(name, len)))
 237         c->name = utf8;
 238     else
 239         c->name = name;
 240
 241     /* call hook */
 242     luaA_client_userdata_new(globalconf.L, c);
 243     luaA_dofunction(globalconf.L, globalconf.hooks.titleupdate, 1, 0);
 244
 245     widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 246 }
 247
 248 static int
 249 property_handle_wm_name(void *data,
 250                         xcb_connection_t *connection,
 251                         uint8_t state,
 252                         xcb_window_t window,
 253                         xcb_atom_t name,
 254                         xcb_get_property_reply_t *reply)
 255 {
 256     client_t *c = client_getbywin(window);
 257
 258     if(c)
 259         property_update_wm_name(c);
 260
 261     return 0;
 262 }
 263
 264 static int
 265 property_handle_net_wm_strut_partial(void *data,
 266                                      xcb_connection_t *connection,
 267                                      uint8_t state,
 268                                      xcb_window_t window,
 269                                      xcb_atom_t name,
 270                                      xcb_get_property_reply_t *reply)
 271 {
 272     client_t *c = client_getbywin(window);
 273
 274     if(c)
 275         ewmh_client_strut_update(c, reply);
 276
 277     return 0;
 278 }
 279
 280 static int
 281 property_handle_net_wm_icon(void *data,
 282                             xcb_connection_t *connection,
 283                             uint8_t state,
 284                             xcb_window_t window,
 285                             xcb_atom_t name,
 286                             xcb_get_property_reply_t *reply)
 287 {
 288     client_t *c = client_getbywin(window);
 289
 290     if(c)
 291     {
 292         image_t *icon;
 293         image_unref(&c->icon);
 294         widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 295         icon = ewmh_window_icon_from_reply(reply);
 296         c->icon = icon ? image_ref(&icon) : NULL;
 297     }
 298
 299     return 0;
 300 }
 301
 302 /** The property notify event handler.
 303  * \param data currently unused.
 304  * \param connection The connection to the X server.
 305  * \param ev The event.
 306  */
 307 static int
 308 property_handle_xembed_info(void *data __attribute__ ((unused)),
 309                             xcb_connection_t *connection,
 310                             uint8_t state,
 311                             xcb_window_t window,
 312                             xcb_atom_t name,
 313                             xcb_get_property_reply_t *reply)
 314 {
 315     xembed_window_t *emwin = xembed_getbywin(globalconf.embedded, window);
 316
 317     if(emwin)
 318         xembed_property_update(connection, emwin, reply);
 319
 320     return 0;
 321 }
 322
 323 void a_xcb_set_property_handlers(void)
 324 {
 325     /* init */
 326     xcb_property_handlers_init(&globalconf.prophs, &globalconf.evenths);
 327
 328     /* Xembed stuff */
 329     xcb_property_set_handler(&globalconf.prophs, _XEMBED_INFO, UINT_MAX,
 330                              property_handle_xembed_info, NULL);
 331
 332     /* ICCCM stuff */
 333     xcb_property_set_handler(&globalconf.prophs, WM_TRANSIENT_FOR, UINT_MAX,
 334                              property_handle_wm_transient_for, NULL);
 335     xcb_property_set_handler(&globalconf.prophs, WM_NORMAL_HINTS, UINT_MAX,
 336                              property_handle_wm_normal_hints, NULL);
 337     xcb_property_set_handler(&globalconf.prophs, WM_HINTS, UINT_MAX,
 338                              property_handle_wm_hints, NULL);
 339     xcb_property_set_handler(&globalconf.prophs, WM_NAME, UINT_MAX,
 340                              property_handle_wm_name, NULL);
 341
 342     /* EWMH stuff */
 343     xcb_property_set_handler(&globalconf.prophs, _NET_WM_NAME, UINT_MAX,
 344                              property_handle_wm_name, NULL);
 345     xcb_property_set_handler(&globalconf.prophs, _NET_WM_STRUT_PARTIAL, UINT_MAX,
 346                              property_handle_net_wm_strut_partial, NULL);
 347     xcb_property_set_handler(&globalconf.prophs, _NET_WM_ICON, UINT_MAX,
 348                              property_handle_net_wm_icon, NULL);
 349 }
 350
 351 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80