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 #define _GNU_SOURCE
  23 #include <getopt.h>
  24
  25 #include <errno.h>
  26 #include <locale.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <sys/select.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <sys/socket.h>
  33 #include <sys/un.h>
  34 #include <fcntl.h>
  35 #include <signal.h>
  36 #include <X11/cursorfont.h>
  37 #include <X11/keysym.h>
  38 #include <X11/Xatom.h>
  39 #include <X11/Xproto.h>
  40 #include <X11/Xutil.h>
  41 #include <X11/extensions/shape.h>
  42 #include <X11/extensions/Xrandr.h>
  43
  44 #include "config.h"
  45 #include "awesome.h"
  46 #include "event.h"
  47 #include "layout.h"
  48 #include "screen.h"
  49 #include "statusbar.h"
  50 #include "uicb.h"
  51 #include "window.h"
  52 #include "client.h"
  53 #include "focus.h"
  54 #include "ewmh.h"
  55 #include "common/awclient.h"
  56 #include "common/util.h"
  57 #include "common/awesome-version.h"
  58 #include "common/configopts.h"
  59
  60 static int (*xerrorxlib) (Display *, XErrorEvent *);
  61 static Bool running = True;
  62
  63 AwesomeConf globalconf;
  64
  65 /** Scan X to find windows to manage
  66  */
  67 static void
  68 scan()
  69 {
  70     unsigned int i, num;
  71     int screen, real_screen;
  72     Window *wins = NULL, d1, d2;
  73     XWindowAttributes wa;
  74
  75     for(screen = 0; screen < ScreenCount(globalconf.display); screen++)
  76     {
  77         if(XQueryTree(globalconf.display, RootWindow(globalconf.display, screen), &d1, &d2, &wins, &num))
  78         {
  79             real_screen = screen;
  80             for(i = 0; i < num; i++)
  81             {
  82                 /* XGetWindowAttributes return 1 on success */
  83                 if(!XGetWindowAttributes(globalconf.display, wins[i], &wa)
  84                    || wa.override_redirect
  85                    || XGetTransientForHint(globalconf.display, wins[i], &d1))
  86                     continue;
  87                 if(wa.map_state == IsViewable || window_getstate(wins[i]) == IconicState)
  88                 {
  89                     if(screen == 0)
  90                         real_screen = screen_get_bycoord(wa.x, wa.y);
  91                     client_manage(wins[i], &wa, real_screen);
  92                 }
  93             }
  94             /* now the transients */
  95             for(i = 0; i < num; i++)
  96             {
  97                 if(!XGetWindowAttributes(globalconf.display, wins[i], &wa))
  98                     continue;
  99                 if(XGetTransientForHint(globalconf.display, wins[i], &d1)
 100                    && (wa.map_state == IsViewable || window_getstate(wins[i]) == IconicState))
 101                 {
 102                     if(screen == 0)
 103                         real_screen = screen_get_bycoord(wa.x, wa.y);
 104                     client_manage(wins[i], &wa, real_screen);
 105                 }
 106             }
 107         }
 108         if(wins)
 109             XFree(wins);
 110     }
 111 }
 112
 113 /** Setup everything before running
 114  * \param screen Screen number
 115  * \todo clean things...
 116  */
 117 static void
 118 setup(int screen)
 119 {
 120     XSetWindowAttributes wa;
 121     Statusbar *statusbar;
 122     int phys_screen = get_phys_screen(screen);
 123
 124     /* init cursors */
 125     globalconf.cursor[CurNormal] = XCreateFontCursor(globalconf.display, XC_left_ptr);
 126     globalconf.cursor[CurResize] = XCreateFontCursor(globalconf.display, XC_sizing);
 127     globalconf.cursor[CurMove] = XCreateFontCursor(globalconf.display, XC_fleur);
 128
 129     /* select for events */
 130     wa.event_mask = SubstructureRedirectMask | SubstructureNotifyMask
 131         | EnterWindowMask | LeaveWindowMask | StructureNotifyMask;
 132     wa.cursor = globalconf.cursor[CurNormal];
 133
 134     XChangeWindowAttributes(globalconf.display,
 135                             RootWindow(globalconf.display, phys_screen),
 136                             CWEventMask | CWCursor, &wa);
 137
 138     XSelectInput(globalconf.display,
 139                  RootWindow(globalconf.display, phys_screen),
 140                  wa.event_mask);
 141
 142     grabkeys(phys_screen);
 143
 144     for(statusbar = globalconf.screens[screen].statusbar; statusbar; statusbar = statusbar->next)
 145         statusbar_init(statusbar);
 146 }
 147
 148 /** Startup Error handler to check if another window manager
 149  * is already running.
 150  * \param disp Display
 151  * \param ee Error event
 152  */
 153 static int __attribute__ ((noreturn))
 154 xerrorstart(Display * disp __attribute__ ((unused)),
 155             XErrorEvent * ee __attribute__ ((unused)))
 156 {
 157     eprint("another window manager is already running\n");
 158 }
 159
 160 /** Quit awesome
 161  * \param screen Screen ID
 162  * \param arg nothing
 163  * \ingroup ui_callback
 164  */
 165 void
 166 uicb_quit(int screen __attribute__ ((unused)), char *arg __attribute__ ((unused)))
 167 {
 168     running = False;
 169 }
 170
 171 static void
 172 exit_on_signal(int sig __attribute__ ((unused)))
 173 {
 174     running = False;
 175 }
 176
 177 /* There's no way to check accesses to destroyed windows, thus those cases are
 178  * ignored (especially on UnmapNotify's).  Other types of errors call Xlibs
 179  * default error handler, which may call exit.
 180  */
 181 static int
 182 xerror(Display *edpy, XErrorEvent *ee)
 183 {
 184     if(ee->error_code == BadWindow
 185        || (ee->error_code == BadMatch && ee->request_code == X_SetInputFocus))
 186         return 0;
 187     warn("fatal error: request code=%d, error code=%d\n", ee->request_code, ee->error_code);
 188     return xerrorxlib(edpy, ee);        /* may call exit */
 189 }
 190
 191 /** Print help and exit(2) with given exit_code.
 192  */
 193 static void __attribute__ ((noreturn))
 194 exit_help(int exit_code)
 195 {
 196     FILE *outfile = (exit_code == EXIT_SUCCESS) ? stdout : stderr;
 197     fprintf(outfile, "Usage: awesome [ -v | -h | -c configfile | -k ]\n");
 198     exit(exit_code);
 199 }
 200
 201 /** Hello, this is main
 202  * \param argc who knows
 203  * \param argv who knows
 204  * \return EXIT_SUCCESS I hope
 205  */
 206 typedef void event_handler (XEvent *);
 207 int
 208 main(int argc, char *argv[])
 209 {
 210     char buf[1024];
 211     const char *confpath = NULL;
 212     int r, xfd, e_dummy, csfd;
 213     fd_set rd;
 214     XEvent ev;
 215     Display * dpy;
 216     int shape_event, randr_event_base;
 217     int screen;
 218     int i, cmdlen;
 219     event_handler **handler;
 220     struct sockaddr_un *addr;
 221     int opt;
 222     Client *c;
 223     static struct option long_options[] =
 224     {
 225         {"help",    0, NULL, 'h'},
 226         {"version", 0, NULL, 'v'},
 227         {NULL,      0, NULL, 0}
 228     };
 229
 230     /* check args */
 231     while((opt = getopt_long(argc, argv, "vhkc:",
 232                              long_options, NULL)) != -1)
 233         switch(opt)
 234         {
 235           case 'v':
 236             eprint_version("awesome");
 237             break;
 238           case 'h':
 239             exit_help(EXIT_SUCCESS);
 240             break;
 241           case 'c':
 242             if(a_strlen(optarg))
 243                 confpath = optarg;
 244             else
 245                 eprint("-c option requires a file name\n");
 246             break;
 247           case 'k':
 248             return config_check(confpath);
 249             break;
 250         }
 251
 252     /* Text won't be printed correctly otherwise */
 253     setlocale(LC_CTYPE, "");
 254
 255     /* X stuff */
 256     if(!(dpy = XOpenDisplay(NULL)))
 257         eprint("cannot open display\n");
 258
 259     for(cmdlen = 0, i = 0; i < argc; i++)
 260         cmdlen += a_strlen(argv[i] + 1);
 261     globalconf.argv = p_new(char, cmdlen);
 262     a_strcpy(globalconf.argv, cmdlen, argv[0]);
 263     for(i = 1; i < argc; i++)
 264     {
 265         a_strcat(globalconf.argv, cmdlen, " ");
 266         a_strcat(globalconf.argv, cmdlen, argv[i]);
 267     }
 268
 269     xfd = ConnectionNumber(dpy);
 270
 271     XSetErrorHandler(xerrorstart);
 272     for(screen = 0; screen < ScreenCount(dpy); screen++)
 273         /* this causes an error if some other window manager is running */
 274         XSelectInput(dpy, RootWindow(dpy, screen), SubstructureRedirectMask);
 275
 276     /* need to XSync to validate errorhandler */
 277     XSync(dpy, False);
 278     XSetErrorHandler(NULL);
 279     xerrorxlib = XSetErrorHandler(xerror);
 280     XSync(dpy, False);
 281
 282     /* store display */
 283     globalconf.display = dpy;
 284
 285     /* init EWMH atoms */
 286     ewmh_init_atoms();
 287
 288     /* init screens struct */
 289     screen_build_screens();
 290     focus_add_client(NULL);
 291
 292     /* parse config */
 293     config_parse(confpath);
 294
 295     scan();
 296
 297     /* for each virtual screen */
 298     for(screen = 0; screen < globalconf.nscreen; screen++)
 299         setup(screen);
 300
 301     /* do this only for real screen */
 302     for(screen = 0; screen < ScreenCount(dpy); screen++)
 303     {
 304         loadawesomeprops(screen);
 305         ewmh_set_supported_hints(screen);
 306         /* call this to at least grab root window clicks */
 307         window_root_grabbuttons(screen);
 308     }
 309
 310     handler = p_new(event_handler *, LASTEvent);
 311     handler[ButtonPress] = handle_event_buttonpress;
 312     handler[ConfigureRequest] = handle_event_configurerequest;
 313     handler[ConfigureNotify] = handle_event_configurenotify;
 314     handler[DestroyNotify] = handle_event_destroynotify;
 315     handler[EnterNotify] = handle_event_enternotify;
 316     handler[LeaveNotify] = handle_event_leavenotify;
 317     handler[Expose] = handle_event_expose;
 318     handler[KeyPress] = handle_event_keypress;
 319     handler[MappingNotify] = handle_event_mappingnotify;
 320     handler[MapRequest] = handle_event_maprequest;
 321     handler[PropertyNotify] = handle_event_propertynotify;
 322     handler[UnmapNotify] = handle_event_unmapnotify;
 323     handler[ClientMessage] = handle_event_clientmessage;
 324
 325     /* check for shape extension */
 326     if((globalconf.have_shape = XShapeQueryExtension(dpy, &shape_event, &e_dummy)))
 327     {
 328         p_realloc(&handler, shape_event + 1);
 329         handler[shape_event] = handle_event_shape;
 330     }
 331
 332     /* check for randr extension */
 333     if((globalconf.have_randr = XRRQueryExtension(dpy, &randr_event_base, &e_dummy)))
 334     {
 335         p_realloc(&handler, randr_event_base + RRScreenChangeNotify + 1);
 336         handler[randr_event_base + RRScreenChangeNotify] = handle_event_randr_screen_change_notify;
 337     }
 338
 339     XSync(dpy, False);
 340
 341     /* get socket fd */
 342     csfd = get_client_socket();
 343     addr = get_client_addr(getenv("DISPLAY"));
 344
 345     if(bind(csfd, (const struct sockaddr *) addr, SUN_LEN(addr)))
 346     {
 347         if(errno == EADDRINUSE)
 348         {
 349             if(unlink(addr->sun_path))
 350                 perror("error unlinking existing file");
 351             if(bind(csfd, (const struct sockaddr *) addr, SUN_LEN(addr)))
 352                 perror("error binding UNIX domain socket");
 353         }
 354         else
 355             perror("error binding UNIX domain socket");
 356     }
 357
 358     /* register function for signals */
 359     signal(SIGINT, &exit_on_signal);
 360     signal(SIGTERM, &exit_on_signal);
 361     signal(SIGHUP, &exit_on_signal);
 362
 363     /* refresh everything before waiting events */
 364     statusbar_refresh();
 365     layout_refresh();
 366
 367     /* main event loop, also reads status text from socket */
 368     while(running)
 369     {
 370         FD_ZERO(&rd);
 371         if(csfd >= 0)
 372             FD_SET(csfd, &rd);
 373         FD_SET(xfd, &rd);
 374         if(select(MAX(xfd, csfd) + 1, &rd, NULL, NULL, NULL) == -1)
 375         {
 376             if(errno == EINTR)
 377                 continue;
 378             eprint("select failed\n");
 379         }
 380         if(csfd >= 0 && FD_ISSET(csfd, &rd))
 381             switch (r = recv(csfd, buf, sizeof(buf)-1, MSG_TRUNC))
 382             {
 383               case -1:
 384                 perror("awesome: error reading UNIX domain socket");
 385                 csfd = -1;
 386                 break;
 387               case 0:
 388                 break;
 389               default:
 390                 if(r >= ssizeof(buf))
 391                     break;
 392                 buf[r] = '\0';
 393                 parse_control(buf);
 394                 statusbar_refresh();
 395                 layout_refresh();
 396             }
 397         /* two level XPending:
 398          * we need to first check we have XEvent to handle
 399          * and if so, we handle them all in a round.
 400          * Then when we have refresh()'ed stuff so maybe new XEvent
 401          * are available and select() won't tell us, so let's check
 402          * with XPending() again.
 403          */
 404         while(XPending(dpy))
 405         {
 406             while(XPending(dpy))
 407             {
 408                 XNextEvent(dpy, &ev);
 409                 if(handler[ev.type])
 410                     handler[ev.type](&ev);
 411
 412                 /* drop events requested to */
 413                 if(globalconf.drop_events)
 414                 {
 415                     /* need to resync */
 416                     XSync(dpy, False);
 417                     while(XCheckMaskEvent(dpy, globalconf.drop_events, &ev));
 418                     globalconf.drop_events = NoEventMask;
 419                 }
 420
 421                 /* need to resync */
 422                 XSync(dpy, False);
 423             }
 424
 425             statusbar_refresh();
 426             layout_refresh();
 427
 428             /* need to resync */
 429             XSync(dpy, False);
 430         }
 431     }
 432
 433
 434     if(csfd > 0 && close(csfd))
 435         perror("error closing UNIX domain socket");
 436     if(unlink(addr->sun_path))
 437         perror("error unlinking UNIX domain socket");
 438     p_delete(&addr);
 439
 440     /* remap all clients since some WM won't handle them otherwise */
 441     for(c = globalconf.clients; c; c = c->next)
 442         client_unban(c);
 443
 444     XSync(globalconf.display, False);
 445
 446     XCloseDisplay(dpy);
 447
 448     return EXIT_SUCCESS;
 449 }
 450 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80