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         hooks_property(c, "urgent");
 193
 194         widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 195     }
 196     if(wmh.flags & XCB_WM_HINT_STATE &&
 197        wmh.initial_state == XCB_WM_STATE_WITHDRAWN)
 198         client_setborder(c, 0);
 199
 200     if(wmh.flags & XCB_WM_HINT_INPUT)
 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     hooks_property(c, "name");
 243
 244     widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 245 }
 246
 247 static int
 248 property_handle_wm_name(void *data,
 249                         xcb_connection_t *connection,
 250                         uint8_t state,
 251                         xcb_window_t window,
 252                         xcb_atom_t name,
 253                         xcb_get_property_reply_t *reply)
 254 {
 255     client_t *c = client_getbywin(window);
 256
 257     if(c)
 258         property_update_wm_name(c);
 259
 260     return 0;
 261 }
 262
 263 static int
 264 property_handle_net_wm_strut_partial(void *data,
 265                                      xcb_connection_t *connection,
 266                                      uint8_t state,
 267                                      xcb_window_t window,
 268                                      xcb_atom_t name,
 269                                      xcb_get_property_reply_t *reply)
 270 {
 271     client_t *c = client_getbywin(window);
 272
 273     if(c)
 274         ewmh_client_strut_update(c, reply);
 275
 276     return 0;
 277 }
 278
 279 static int
 280 property_handle_net_wm_icon(void *data,
 281                             xcb_connection_t *connection,
 282                             uint8_t state,
 283                             xcb_window_t window,
 284                             xcb_atom_t name,
 285                             xcb_get_property_reply_t *reply)
 286 {
 287     client_t *c = client_getbywin(window);
 288
 289     if(c)
 290     {
 291         image_t *icon;
 292         image_unref(&c->icon);
 293         widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 294         icon = ewmh_window_icon_from_reply(reply);
 295         c->icon = icon ? image_ref(&icon) : NULL;
 296
 297         /* execute hook */
 298         hooks_property(c, "icon");
 299     }
 300
 301     return 0;
 302 }
 303
 304 /** The property notify event handler.
 305  * \param data currently unused.
 306  * \param connection The connection to the X server.
 307  * \param ev The event.
 308  */
 309 static int
 310 property_handle_xembed_info(void *data __attribute__ ((unused)),
 311                             xcb_connection_t *connection,
 312                             uint8_t state,
 313                             xcb_window_t window,
 314                             xcb_atom_t name,
 315                             xcb_get_property_reply_t *reply)
 316 {
 317     xembed_window_t *emwin = xembed_getbywin(globalconf.embedded, window);
 318
 319     if(emwin)
 320         xembed_property_update(connection, emwin, reply);
 321
 322     return 0;
 323 }
 324
 325 static int
 326 property_handle_xrootpmap_id(void *data __attribute__ ((unused)),
 327                              xcb_connection_t *connection,
 328                              uint8_t state,
 329                              xcb_window_t window,
 330                              xcb_atom_t name,
 331                              xcb_get_property_reply_t *reply)
 332 {
 333     if(globalconf.xinerama_is_active)
 334         for(int screen = 0; screen < globalconf.nscreen; screen++)
 335         {
 336             wibox_array_t *w = &globalconf.screens[screen].wiboxes;
 337             for(int i = 0; i < w->len; i++)
 338                 w->tab[i]->need_update = true;
 339         }
 340     else
 341     {
 342         int screen = xutil_root2screen(connection, window);
 343         wibox_array_t *w = &globalconf.screens[screen].wiboxes;
 344         for(int i = 0; i < w->len; i++)
 345             w->tab[i]->need_update = true;
 346     }
 347
 348     return 0;
 349 }
 350
 351 void a_xcb_set_property_handlers(void)
 352 {
 353     /* init */
 354     xcb_property_handlers_init(&globalconf.prophs, &globalconf.evenths);
 355
 356     /* Xembed stuff */
 357     xcb_property_set_handler(&globalconf.prophs, _XEMBED_INFO, UINT_MAX,
 358                              property_handle_xembed_info, NULL);
 359
 360     /* ICCCM stuff */
 361     xcb_property_set_handler(&globalconf.prophs, WM_TRANSIENT_FOR, UINT_MAX,
 362                              property_handle_wm_transient_for, NULL);
 363     xcb_property_set_handler(&globalconf.prophs, WM_NORMAL_HINTS, UINT_MAX,
 364                              property_handle_wm_normal_hints, NULL);
 365     xcb_property_set_handler(&globalconf.prophs, WM_HINTS, UINT_MAX,
 366                              property_handle_wm_hints, NULL);
 367     xcb_property_set_handler(&globalconf.prophs, WM_NAME, UINT_MAX,
 368                              property_handle_wm_name, NULL);
 369
 370     /* EWMH stuff */
 371     xcb_property_set_handler(&globalconf.prophs, _NET_WM_NAME, UINT_MAX,
 372                              property_handle_wm_name, NULL);
 373     xcb_property_set_handler(&globalconf.prophs, _NET_WM_STRUT_PARTIAL, UINT_MAX,
 374                              property_handle_net_wm_strut_partial, NULL);
 375     xcb_property_set_handler(&globalconf.prophs, _NET_WM_ICON, UINT_MAX,
 376                              property_handle_net_wm_icon, NULL);
 377
 378     /* background change */
 379     xcb_property_set_handler(&globalconf.prophs, _XROOTPMAP_ID, 1,
 380                              property_handle_xrootpmap_id, NULL);
 381 }
 382
 383 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80