awesome.c

   1 /*
   2  * awesome.c - awesome main 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 <getopt.h>
  23
  24 #include <locale.h>
  25 #include <stdio.h>
  26 #include <unistd.h>
  27 #include <signal.h>
  28
  29 #include <xcb/bigreq.h>
  30 #include <xcb/randr.h>
  31 #include <xcb/xcb_event.h>
  32 #include <xcb/xinerama.h>
  33 #include <xcb/xtest.h>
  34
  35 #include "awesome.h"
  36 #include "spawn.h"
  37 #include "objects/client.h"
  38 #include "xwindow.h"
  39 #include "ewmh.h"
  40 #include "dbus.h"
  41 #include "systray.h"
  42 #include "event.h"
  43 #include "property.h"
  44 #include "screen.h"
  45 #include "luaa.h"
  46 #include "common/version.h"
  47 #include "common/atoms.h"
  48 #include "common/xcursor.h"
  49 #include "common/xutil.h"
  50 #include "common/backtrace.h"
  51
  52 awesome_t globalconf;
  53
  54 /** argv used to run awesome */
  55 static char *awesome_argv;
  56
  57 /** Call before exiting.
  58  */
  59 void
  60 awesome_atexit(bool restart)
  61 {
  62     lua_pushboolean(globalconf.L, restart);
  63     signal_object_emit(globalconf.L, &global_signals, "exit", 1);
  64
  65     a_dbus_cleanup();
  66
  67     systray_cleanup();
  68
  69     /* Close Lua */
  70     lua_close(globalconf.L);
  71
  72     xcb_flush(globalconf.connection);
  73
  74     /* Disconnect *after* closing lua */
  75     xcb_disconnect(globalconf.connection);
  76
  77     ev_default_destroy();
  78 }
  79
  80 /** Scan X to find windows to manage.
  81  */
  82 static void
  83 scan(xcb_query_tree_cookie_t tree_c)
  84 {
  85     int i, tree_c_len;
  86     xcb_query_tree_reply_t *tree_r;
  87     xcb_window_t *wins = NULL;
  88     xcb_get_window_attributes_reply_t *attr_r;
  89     xcb_get_geometry_reply_t *geom_r;
  90     long state;
  91
  92     tree_r = xcb_query_tree_reply(globalconf.connection,
  93                                   tree_c,
  94                                   NULL);
  95
  96     if(!tree_r)
  97         return;
  98
  99     /* Get the tree of the children windows of the current root window */
 100     if(!(wins = xcb_query_tree_children(tree_r)))
 101         fatal("cannot get tree children");
 102
 103     tree_c_len = xcb_query_tree_children_length(tree_r);
 104     xcb_get_window_attributes_cookie_t attr_wins[tree_c_len];
 105     xcb_get_property_cookie_t state_wins[tree_c_len];
 106
 107     for(i = 0; i < tree_c_len; i++)
 108     {
 109         attr_wins[i] = xcb_get_window_attributes_unchecked(globalconf.connection,
 110                                                            wins[i]);
 111
 112         state_wins[i] = xwindow_get_state_unchecked(wins[i]);
 113     }
 114
 115     xcb_get_geometry_cookie_t *geom_wins[tree_c_len];
 116
 117     for(i = 0; i < tree_c_len; i++)
 118     {
 119         attr_r = xcb_get_window_attributes_reply(globalconf.connection,
 120                                                  attr_wins[i],
 121                                                  NULL);
 122
 123         state = xwindow_get_state_reply(state_wins[i]);
 124
 125         if(!attr_r || attr_r->override_redirect
 126            || attr_r->map_state == XCB_MAP_STATE_UNMAPPED
 127            || state == XCB_ICCCM_WM_STATE_WITHDRAWN)
 128         {
 129             geom_wins[i] = NULL;
 130             p_delete(&attr_r);
 131             continue;
 132         }
 133
 134         p_delete(&attr_r);
 135
 136         /* Get the geometry of the current window */
 137         geom_wins[i] = p_alloca(xcb_get_geometry_cookie_t, 1);
 138         *(geom_wins[i]) = xcb_get_geometry_unchecked(globalconf.connection, wins[i]);
 139     }
 140
 141     for(i = 0; i < tree_c_len; i++)
 142     {
 143         if(!geom_wins[i] || !(geom_r = xcb_get_geometry_reply(globalconf.connection,
 144                                                               *(geom_wins[i]), NULL)))
 145             continue;
 146
 147         client_manage(wins[i], geom_r, true);
 148
 149         p_delete(&geom_r);
 150     }
 151
 152     p_delete(&tree_r);
 153 }
 154
 155 static xcb_visualtype_t *
 156 a_default_visual(xcb_screen_t *s)
 157 {
 158     xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(s);
 159
 160     if(depth_iter.data)
 161         for(; depth_iter.rem; xcb_depth_next (&depth_iter))
 162             for(xcb_visualtype_iterator_t visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
 163                 visual_iter.rem; xcb_visualtype_next (&visual_iter))
 164                 if(s->root_visual == visual_iter.data->visual_id)
 165                     return visual_iter.data;
 166
 167     return NULL;
 168 }
 169
 170 static xcb_visualtype_t *
 171 a_argb_visual(xcb_screen_t *s)
 172 {
 173     xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(s);
 174
 175     if(depth_iter.data)
 176         for(; depth_iter.rem; xcb_depth_next (&depth_iter))
 177             if(depth_iter.data->depth == 32)
 178                 for(xcb_visualtype_iterator_t visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
 179                     visual_iter.rem; xcb_visualtype_next (&visual_iter))
 180                     return visual_iter.data;
 181
 182     return NULL;
 183 }
 184
 185 static uint8_t
 186 a_visual_depth(xcb_screen_t *s, xcb_visualid_t vis)
 187 {
 188     xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(s);
 189
 190     if(depth_iter.data)
 191         for(; depth_iter.rem; xcb_depth_next (&depth_iter))
 192             for(xcb_visualtype_iterator_t visual_iter = xcb_depth_visuals_iterator(depth_iter.data);
 193                 visual_iter.rem; xcb_visualtype_next (&visual_iter))
 194                 if(vis == visual_iter.data->visual_id)
 195                     return depth_iter.data->depth;
 196
 197     fatal("Could not find a visual's depth");
 198 }
 199
 200 static void
 201 a_refresh_cb(EV_P_ ev_prepare *w, int revents)
 202 {
 203     awesome_refresh();
 204 }
 205
 206 static void
 207 a_xcb_check_cb(EV_P_ ev_check *w, int revents)
 208 {
 209     xcb_generic_event_t *mouse = NULL, *event;
 210
 211     while((event = xcb_poll_for_event(globalconf.connection)))
 212     {
 213         /* We will treat mouse events later.
 214          * We cannot afford to treat all mouse motion events,
 215          * because that would be too much CPU intensive, so we just
 216          * take the last we get after a bunch of events. */
 217         if(XCB_EVENT_RESPONSE_TYPE(event) == XCB_MOTION_NOTIFY)
 218         {
 219             p_delete(&mouse);
 220             mouse = event;
 221         }
 222         else
 223         {
 224             uint8_t type = XCB_EVENT_RESPONSE_TYPE(event);
 225             if((type == XCB_ENTER_NOTIFY || type == XCB_LEAVE_NOTIFY) && mouse)
 226             {
 227                 /* Make sure enter/motion/leave events are handled in the
 228                  * correct order */
 229                 event_handle(mouse);
 230                 p_delete(&mouse);
 231                 mouse = NULL;
 232             }
 233             event_handle(event);
 234             p_delete(&event);
 235         }
 236     }
 237
 238     if(mouse)
 239     {
 240         event_handle(mouse);
 241         p_delete(&mouse);
 242     }
 243 }
 244
 245 static void
 246 a_xcb_io_cb(EV_P_ ev_io *w, int revents)
 247 {
 248     /* a_xcb_check_cb() already handled all events */
 249
 250     if(xcb_connection_has_error(globalconf.connection))
 251         fatal("X server connection broke");
 252 }
 253
 254 static void
 255 signal_fatal(int signum)
 256 {
 257     buffer_t buf;
 258     backtrace_get(&buf);
 259     fatal("dumping backtrace\n%s", buf.s);
 260 }
 261
 262 /** Function to exit on some signals.
 263  * \param w the signal received, unused
 264  * \param revents currently unused
 265  */
 266 static void
 267 exit_on_signal(EV_P_ ev_signal *w, int revents)
 268 {
 269     ev_unloop(EV_A_ 1);
 270 }
 271
 272 void
 273 awesome_restart(void)
 274 {
 275     awesome_atexit(true);
 276     a_exec(awesome_argv);
 277 }
 278
 279 /** Function to restart awesome on some signals.
 280  * \param w the signal received, unused
 281  * \param revents Currently unused
 282  */
 283 static void
 284 restart_on_signal(EV_P_ ev_signal *w, int revents)
 285 {
 286     awesome_restart();
 287 }
 288
 289 /** Print help and exit(2) with given exit_code.
 290  * \param exit_code The exit code.
 291  */
 292 static void __attribute__ ((noreturn))
 293 exit_help(int exit_code)
 294 {
 295     FILE *outfile = (exit_code == EXIT_SUCCESS) ? stdout : stderr;
 296     fprintf(outfile,
 297 "Usage: awesome [OPTION]\n\
 298   -h, --help             show help\n\
 299   -v, --version          show version\n\
 300   -c, --config FILE      configuration file to use\n\
 301   -k, --check            check configuration file syntax\n");
 302     exit(exit_code);
 303 }
 304
 305 /** Hello, this is main.
 306  * \param argc Who knows.
 307  * \param argv Who knows.
 308  * \return EXIT_SUCCESS I hope.
 309  */
 310 int
 311 main(int argc, char **argv)
 312 {
 313     char *confpath = NULL;
 314     int xfd, i, opt;
 315     ssize_t cmdlen = 1;
 316     xdgHandle xdg;
 317     bool no_argb = false;
 318     xcb_generic_event_t *event;
 319     xcb_query_tree_cookie_t tree_c;
 320     static struct option long_options[] =
 321     {
 322         { "help",    0, NULL, 'h' },
 323         { "version", 0, NULL, 'v' },
 324         { "config",  1, NULL, 'c' },
 325         { "check",   0, NULL, 'k' },
 326         { "no-argb", 0, NULL, 'a' },
 327         { NULL,      0, NULL, 0 }
 328     };
 329
 330     /* event loop watchers */
 331     ev_io xio    = { .fd = -1 };
 332     ev_check xcheck;
 333     ev_prepare a_refresh;
 334     ev_signal sigint;
 335     ev_signal sigterm;
 336     ev_signal sighup;
 337
 338     /* clear the globalconf structure */
 339     p_clear(&globalconf, 1);
 340     globalconf.keygrabber = LUA_REFNIL;
 341     globalconf.mousegrabber = LUA_REFNIL;
 342     buffer_init(&globalconf.startup_errors);
 343
 344     /* save argv */
 345     for(i = 0; i < argc; i++)
 346         cmdlen += a_strlen(argv[i]) + 1;
 347
 348     awesome_argv = p_new(char, cmdlen);
 349     a_strcpy(awesome_argv, cmdlen, argv[0]);
 350
 351     for(i = 1; i < argc; i++)
 352     {
 353         a_strcat(awesome_argv, cmdlen, " ");
 354         a_strcat(awesome_argv, cmdlen, argv[i]);
 355     }
 356
 357     /* Text won't be printed correctly otherwise */
 358     setlocale(LC_CTYPE, "");
 359
 360     /* Get XDG basedir data */
 361     xdgInitHandle(&xdg);
 362
 363     /* init lua */
 364     luaA_init(&xdg);
 365
 366     /* check args */
 367     while((opt = getopt_long(argc, argv, "vhkc:a",
 368                              long_options, NULL)) != -1)
 369         switch(opt)
 370         {
 371           case 'v':
 372             eprint_version();
 373             break;
 374           case 'h':
 375             exit_help(EXIT_SUCCESS);
 376             break;
 377           case 'k':
 378             if(!luaA_parserc(&xdg, confpath, false))
 379             {
 380                 fprintf(stderr, "✘ Configuration file syntax error.\n");
 381                 return EXIT_FAILURE;
 382             }
 383             else
 384             {
 385                 fprintf(stderr, "✔ Configuration file syntax OK.\n");
 386                 return EXIT_SUCCESS;
 387             }
 388           case 'c':
 389             if(a_strlen(optarg))
 390                 confpath = a_strdup(optarg);
 391             else
 392                 fatal("-c option requires a file name");
 393             break;
 394           case 'a':
 395             no_argb = true;
 396             break;
 397         }
 398
 399     globalconf.loop = ev_default_loop(EVFLAG_NOSIGFD);
 400
 401     /* register function for signals */
 402     ev_signal_init(&sigint, exit_on_signal, SIGINT);
 403     ev_signal_init(&sigterm, exit_on_signal, SIGTERM);
 404     ev_signal_init(&sighup, restart_on_signal, SIGHUP);
 405     ev_signal_start(globalconf.loop, &sigint);
 406     ev_signal_start(globalconf.loop, &sigterm);
 407     ev_signal_start(globalconf.loop, &sighup);
 408     ev_unref(globalconf.loop);
 409     ev_unref(globalconf.loop);
 410     ev_unref(globalconf.loop);
 411
 412     struct sigaction sa = { .sa_handler = signal_fatal, .sa_flags = 0 };
 413     sigemptyset(&sa.sa_mask);
 414     sigaction(SIGSEGV, &sa, 0);
 415
 416     /* X stuff */
 417     globalconf.connection = xcb_connect(NULL, &globalconf.default_screen);
 418     if(xcb_connection_has_error(globalconf.connection))
 419         fatal("cannot open display");
 420
 421     globalconf.screen = xcb_aux_get_screen(globalconf.connection, globalconf.default_screen);
 422     globalconf.default_visual = a_default_visual(globalconf.screen);
 423     /* FIXME The following two assignments were swapped on purpose */
 424     if(!no_argb)
 425         globalconf.visual = globalconf.default_visual;
 426     if(!globalconf.visual)
 427         globalconf.visual = a_argb_visual(globalconf.screen);
 428     globalconf.default_depth = a_visual_depth(globalconf.screen, globalconf.visual->visual_id);
 429     globalconf.default_cmap = globalconf.screen->default_colormap;
 430     if(globalconf.default_depth != globalconf.screen->root_depth)
 431     {
 432         // We need our own color map if we aren't using the default depth
 433         globalconf.default_cmap = xcb_generate_id(globalconf.connection);
 434         xcb_create_colormap(globalconf.connection, XCB_COLORMAP_ALLOC_NONE,
 435                 globalconf.default_cmap, globalconf.screen->root,
 436                 globalconf.visual->visual_id);
 437     }
 438
 439     /* Prefetch all the extensions we might need */
 440     xcb_prefetch_extension_data(globalconf.connection, &xcb_big_requests_id);
 441     xcb_prefetch_extension_data(globalconf.connection, &xcb_test_id);
 442     xcb_prefetch_extension_data(globalconf.connection, &xcb_randr_id);
 443     xcb_prefetch_extension_data(globalconf.connection, &xcb_xinerama_id);
 444
 445     /* initialize dbus */
 446     a_dbus_init();
 447
 448     /* Get the file descriptor corresponding to the X connection */
 449     xfd = xcb_get_file_descriptor(globalconf.connection);
 450     ev_io_init(&xio, &a_xcb_io_cb, xfd, EV_READ);
 451     ev_io_start(globalconf.loop, &xio);
 452     ev_check_init(&xcheck, &a_xcb_check_cb);
 453     ev_check_start(globalconf.loop, &xcheck);
 454     ev_unref(globalconf.loop);
 455     ev_prepare_init(&a_refresh, &a_refresh_cb);
 456     ev_prepare_start(globalconf.loop, &a_refresh);
 457     ev_unref(globalconf.loop);
 458
 459     /* Grab server */
 460     xcb_grab_server(globalconf.connection);
 461
 462     /* Make sure there are no pending events. Since we didn't really do anything
 463      * at all yet, we will just discard all events which we received so far.
 464      * The above GrabServer should make sure no new events are generated. */
 465     xcb_aux_sync(globalconf.connection);
 466     while ((event = xcb_poll_for_event(globalconf.connection)) != NULL)
 467     {
 468         /* Make sure errors are printed */
 469         uint8_t response_type = XCB_EVENT_RESPONSE_TYPE(event);
 470         if(response_type == 0)
 471             event_handle(event);
 472         p_delete(&event);
 473     }
 474
 475     {
 476         const uint32_t select_input_val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
 477
 478         /* This causes an error if some other window manager is running */
 479         xcb_change_window_attributes(globalconf.connection,
 480                                      globalconf.screen->root,
 481                                      XCB_CW_EVENT_MASK, &select_input_val);
 482     }
 483
 484     /* Need to xcb_flush to validate error handler */
 485     xcb_aux_sync(globalconf.connection);
 486
 487     /* Process all errors in the queue if any. There can be no events yet, so if
 488      * this function returns something, it must be an error. */
 489     if (xcb_poll_for_event(globalconf.connection) != NULL)
 490         fatal("another window manager is already running");
 491
 492     /* Prefetch the maximum request length */
 493     xcb_prefetch_maximum_request_length(globalconf.connection);
 494
 495     /* check for xtest extension */
 496     const xcb_query_extension_reply_t *xtest_query;
 497     xtest_query = xcb_get_extension_data(globalconf.connection, &xcb_test_id);
 498     globalconf.have_xtest = xtest_query->present;
 499
 500     /* Allocate the key symbols */
 501     globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection);
 502     xcb_get_modifier_mapping_cookie_t xmapping_cookie =
 503         xcb_get_modifier_mapping_unchecked(globalconf.connection);
 504
 505     /* init atom cache */
 506     atoms_init(globalconf.connection);
 507
 508     /* init screens information */
 509     screen_scan();
 510
 511     xutil_lock_mask_get(globalconf.connection, xmapping_cookie,
 512                         globalconf.keysyms, &globalconf.numlockmask,
 513                         &globalconf.shiftlockmask, &globalconf.capslockmask,
 514                         &globalconf.modeswitchmask);
 515
 516     /* do this only for real screen */
 517     ewmh_init();
 518     systray_init();
 519
 520     /* init spawn (sn) */
 521     spawn_init();
 522
 523     /* The default GC is just a newly created associated with a window with
 524      * depth globalconf.default_depth */
 525     xcb_window_t tmp_win = xcb_generate_id(globalconf.connection);
 526     globalconf.gc = xcb_generate_id(globalconf.connection);
 527     xcb_create_window(globalconf.connection, globalconf.default_depth,
 528                       tmp_win, globalconf.screen->root,
 529                       -1, -1, 1, 1, 0,
 530                       XCB_COPY_FROM_PARENT, globalconf.visual->visual_id,
 531                       XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP,
 532                       (const uint32_t [])
 533                       {
 534                           globalconf.screen->black_pixel,
 535                           globalconf.screen->black_pixel,
 536                           globalconf.default_cmap
 537                       });
 538     xcb_create_gc(globalconf.connection, globalconf.gc, tmp_win, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND,
 539                   (const uint32_t[]) { globalconf.screen->black_pixel, globalconf.screen->white_pixel });
 540     xcb_destroy_window(globalconf.connection, tmp_win);
 541
 542     /* Get the window tree associated to this screen */
 543     tree_c = xcb_query_tree_unchecked(globalconf.connection,
 544                                       globalconf.screen->root);
 545
 546     xcb_change_window_attributes(globalconf.connection,
 547                                  globalconf.screen->root,
 548                                  XCB_CW_EVENT_MASK,
 549                                  ROOT_WINDOW_EVENT_MASK);
 550
 551     /* we will receive events, stop grabbing server */
 552     xcb_ungrab_server(globalconf.connection);
 553
 554     /* Parse and run configuration file */
 555     if (!luaA_parserc(&xdg, confpath, true))
 556         fatal("couldn't find any rc file");
 557
 558     p_delete(&confpath);
 559
 560     xdgWipeHandle(&xdg);
 561
 562     /* scan existing windows */
 563     scan(tree_c);
 564
 565     xcb_flush(globalconf.connection);
 566
 567     /* main event loop */
 568     ev_loop(globalconf.loop, 0);
 569
 570     /* cleanup event loop */
 571     ev_ref(globalconf.loop);
 572     ev_check_stop(globalconf.loop, &xcheck);
 573     ev_ref(globalconf.loop);
 574     ev_prepare_stop(globalconf.loop, &a_refresh);
 575     ev_ref(globalconf.loop);
 576     ev_io_stop(globalconf.loop, &xio);
 577
 578     awesome_atexit(false);
 579
 580     return EXIT_SUCCESS;
 581 }
 582
 583 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80