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         /* execute hook */
 191         hooks_property(c, "urgent");
 192     }
 193     if(wmh.flags & XCB_WM_HINT_STATE &&
 194        wmh.initial_state == XCB_WM_STATE_WITHDRAWN)
 195         client_setborder(c, 0);
 196
 197     if(wmh.flags & XCB_WM_HINT_INPUT)
 198         c->nofocus = !wmh.input;
 199 }
 200
 201 static int
 202 property_handle_wm_hints(void *data,
 203                          xcb_connection_t *connection,
 204                          uint8_t state,
 205                          xcb_window_t window,
 206                          xcb_atom_t name,
 207                          xcb_get_property_reply_t *reply)
 208 {
 209     client_t *c = client_getbywin(window);
 210
 211     if(c)
 212         property_update_wm_hints(c, reply);
 213
 214     return 0;
 215 }
 216
 217 /** Update client name attribute with its new title.
 218  * \param c The client.
 219  * \param Return true if it has been updated.
 220  */
 221 void
 222 property_update_wm_name(client_t *c)
 223 {
 224     char *name, *utf8;
 225     ssize_t len;
 226
 227     if(!xutil_text_prop_get(globalconf.connection, c->win, _NET_WM_NAME, &name, &len))
 228         if(!xutil_text_prop_get(globalconf.connection, c->win, WM_NAME, &name, &len))
 229             return;
 230
 231     p_delete(&c->name);
 232
 233     if((utf8 = draw_iso2utf8(name, len)))
 234         c->name = utf8;
 235     else
 236         c->name = name;
 237
 238     /* call hook */
 239     hooks_property(c, "name");
 240 }
 241
 242 /** Update client icon name attribute with its new title.
 243  * \param c The client.
 244  * \param Return true if it has been updated.
 245  */
 246 void
 247 property_update_wm_icon_name(client_t *c)
 248 {
 249     char *name, *utf8;
 250     ssize_t len;
 251
 252     if(!xutil_text_prop_get(globalconf.connection, c->win, _NET_WM_ICON_NAME, &name, &len))
 253         if(!xutil_text_prop_get(globalconf.connection, c->win, WM_ICON_NAME, &name, &len))
 254             return;
 255
 256     p_delete(&c->icon_name);
 257
 258     if((utf8 = draw_iso2utf8(name, len)))
 259         c->icon_name = utf8;
 260     else
 261         c->icon_name = name;
 262
 263     /* call hook */
 264     hooks_property(c, "icon_name");
 265 }
 266
 267 static int
 268 property_handle_wm_name(void *data,
 269                         xcb_connection_t *connection,
 270                         uint8_t state,
 271                         xcb_window_t window,
 272                         xcb_atom_t name,
 273                         xcb_get_property_reply_t *reply)
 274 {
 275     client_t *c = client_getbywin(window);
 276
 277     if(c)
 278         property_update_wm_name(c);
 279
 280     return 0;
 281 }
 282
 283 static int
 284 property_handle_wm_icon_name(void *data,
 285                              xcb_connection_t *connection,
 286                              uint8_t state,
 287                              xcb_window_t window,
 288                              xcb_atom_t name,
 289                              xcb_get_property_reply_t *reply)
 290 {
 291     client_t *c = client_getbywin(window);
 292
 293     if(c)
 294         property_update_wm_icon_name(c);
 295
 296     return 0;
 297 }
 298
 299 static int
 300 property_handle_net_wm_strut_partial(void *data,
 301                                      xcb_connection_t *connection,
 302                                      uint8_t state,
 303                                      xcb_window_t window,
 304                                      xcb_atom_t name,
 305                                      xcb_get_property_reply_t *reply)
 306 {
 307     client_t *c = client_getbywin(window);
 308
 309     if(c)
 310         ewmh_client_strut_update(c, reply);
 311
 312     return 0;
 313 }
 314
 315 static int
 316 property_handle_net_wm_icon(void *data,
 317                             xcb_connection_t *connection,
 318                             uint8_t state,
 319                             xcb_window_t window,
 320                             xcb_atom_t name,
 321                             xcb_get_property_reply_t *reply)
 322 {
 323     client_t *c = client_getbywin(window);
 324
 325     if(c)
 326     {
 327         image_t *icon;
 328         image_unref(&c->icon);
 329         icon = ewmh_window_icon_from_reply(reply);
 330         c->icon = icon ? image_ref(&icon) : NULL;
 331
 332         /* execute hook */
 333         hooks_property(c, "icon");
 334     }
 335
 336     return 0;
 337 }
 338
 339 /** The property notify event handler.
 340  * \param data currently unused.
 341  * \param connection The connection to the X server.
 342  * \param ev The event.
 343  */
 344 static int
 345 property_handle_xembed_info(void *data __attribute__ ((unused)),
 346                             xcb_connection_t *connection,
 347                             uint8_t state,
 348                             xcb_window_t window,
 349                             xcb_atom_t name,
 350                             xcb_get_property_reply_t *reply)
 351 {
 352     xembed_window_t *emwin = xembed_getbywin(globalconf.embedded, window);
 353
 354     if(emwin)
 355         xembed_property_update(connection, emwin, reply);
 356
 357     return 0;
 358 }
 359
 360 static int
 361 property_handle_xrootpmap_id(void *data __attribute__ ((unused)),
 362                              xcb_connection_t *connection,
 363                              uint8_t state,
 364                              xcb_window_t window,
 365                              xcb_atom_t name,
 366                              xcb_get_property_reply_t *reply)
 367 {
 368     if(globalconf.xinerama_is_active)
 369         for(int screen = 0; screen < globalconf.nscreen; screen++)
 370         {
 371             wibox_array_t *w = &globalconf.screens[screen].wiboxes;
 372             for(int i = 0; i < w->len; i++)
 373                 w->tab[i]->need_update = true;
 374         }
 375     else
 376     {
 377         int screen = xutil_root2screen(connection, window);
 378         wibox_array_t *w = &globalconf.screens[screen].wiboxes;
 379         for(int i = 0; i < w->len; i++)
 380             w->tab[i]->need_update = true;
 381     }
 382
 383     return 0;
 384 }
 385
 386 void a_xcb_set_property_handlers(void)
 387 {
 388     /* init */
 389     xcb_property_handlers_init(&globalconf.prophs, &globalconf.evenths);
 390
 391     /* Xembed stuff */
 392     xcb_property_set_handler(&globalconf.prophs, _XEMBED_INFO, UINT_MAX,
 393                              property_handle_xembed_info, NULL);
 394
 395     /* ICCCM stuff */
 396     xcb_property_set_handler(&globalconf.prophs, WM_TRANSIENT_FOR, UINT_MAX,
 397                              property_handle_wm_transient_for, NULL);
 398     xcb_property_set_handler(&globalconf.prophs, WM_NORMAL_HINTS, UINT_MAX,
 399                              property_handle_wm_normal_hints, NULL);
 400     xcb_property_set_handler(&globalconf.prophs, WM_HINTS, UINT_MAX,
 401                              property_handle_wm_hints, NULL);
 402     xcb_property_set_handler(&globalconf.prophs, WM_NAME, UINT_MAX,
 403                              property_handle_wm_name, NULL);
 404     xcb_property_set_handler(&globalconf.prophs, WM_ICON_NAME, UINT_MAX,
 405                              property_handle_wm_icon_name, NULL);
 406
 407     /* EWMH stuff */
 408     xcb_property_set_handler(&globalconf.prophs, _NET_WM_NAME, UINT_MAX,
 409                              property_handle_wm_name, NULL);
 410     xcb_property_set_handler(&globalconf.prophs, _NET_WM_ICON_NAME, UINT_MAX,
 411                              property_handle_wm_icon_name, NULL);
 412     xcb_property_set_handler(&globalconf.prophs, _NET_WM_STRUT_PARTIAL, UINT_MAX,
 413                              property_handle_net_wm_strut_partial, NULL);
 414     xcb_property_set_handler(&globalconf.prophs, _NET_WM_ICON, UINT_MAX,
 415                              property_handle_net_wm_icon, NULL);
 416
 417     /* background change */
 418     xcb_property_set_handler(&globalconf.prophs, _XROOTPMAP_ID, 1,
 419                              property_handle_xrootpmap_id, NULL);
 420 }
 421
 422 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80