scrotwm.c

   1 /* $scrotwm$ */
   2 /*
   3  * Copyright (c) 2009 Marco Peereboom <marco@peereboom.us>
   4  * Copyright (c) 2009 Ryan McBride <mcbride@countersiege.com>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 /*
  19  * Much code and ideas taken from dwm under the following license:
  20  * MIT/X Consortium License
  21  *
  22  * 2006-2008 Anselm R Garbe <garbeam at gmail dot com>
  23  * 2006-2007 Sander van Dijk <a dot h dot vandijk at gmail dot com>
  24  * 2006-2007 Jukka Salmi <jukka at salmi dot ch>
  25  * 2007 Premysl Hruby <dfenze at gmail dot com>
  26  * 2007 Szabolcs Nagy <nszabolcs at gmail dot com>
  27  * 2007 Christof Musik <christof at sendfax dot de>
  28  * 2007-2008 Enno Gottox Boland <gottox at s01 dot de>
  29  * 2007-2008 Peter Hartlich <sgkkr at hartlich dot com>
  30  * 2008 Martin Hurton <martin dot hurton at gmail dot com>
  31  *
  32  * Permission is hereby granted, free of charge, to any person obtaining a
  33  * copy of this software and associated documentation files (the "Software"),
  34  * to deal in the Software without restriction, including without limitation
  35  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  36  * and/or sell copies of the Software, and to permit persons to whom the
  37  * Software is furnished to do so, subject to the following conditions:
  38  *
  39  * The above copyright notice and this permission notice shall be included in
  40  * all copies or substantial portions of the Software.
  41  *
  42  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  43  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  44  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  45  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  46  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  47  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  48  * DEALINGS IN THE SOFTWARE.
  49  */
  50
  51 static const char       *cvstag = "$scrotwm$";
  52
  53 #define SWM_VERSION     "0.9"
  54
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <err.h>
  58 #include <errno.h>
  59 #include <fcntl.h>
  60 #include <locale.h>
  61 #include <unistd.h>
  62 #include <time.h>
  63 #include <signal.h>
  64 #include <string.h>
  65 #include <util.h>
  66 #include <pwd.h>
  67 #include <ctype.h>
  68
  69 #include <sys/types.h>
  70 #include <sys/time.h>
  71 #include <sys/stat.h>
  72 #include <sys/wait.h>
  73 #include <sys/queue.h>
  74 #include <sys/param.h>
  75 #include <sys/select.h>
  76
  77 #include <X11/cursorfont.h>
  78 #include <X11/keysym.h>
  79 #include <X11/Xatom.h>
  80 #include <X11/Xlib.h>
  81 #include <X11/Xproto.h>
  82 #include <X11/Xutil.h>
  83 #include <X11/extensions/Xrandr.h>
  84
  85 #if RANDR_MAJOR < 1
  86 #  error XRandR versions less than 1.0 are not supported
  87 #endif
  88
  89 #if RANDR_MAJOR >= 1
  90 #if RANDR_MINOR >= 2
  91 #define SWM_XRR_HAS_CRTC
  92 #endif
  93 #endif
  94
  95 /* #define SWM_DEBUG */
  96 #ifdef SWM_DEBUG
  97 #define DPRINTF(x...)           do { if (swm_debug) fprintf(stderr, x); } while(0)
  98 #define DNPRINTF(n,x...)        do { if (swm_debug & n) fprintf(stderr, x); } while(0)
  99 #define SWM_D_MISC              0x0001
 100 #define SWM_D_EVENT             0x0002
 101 #define SWM_D_WS                0x0004
 102 #define SWM_D_FOCUS             0x0008
 103 #define SWM_D_MOVE              0x0010
 104 #define SWM_D_STACK             0x0020
 105 #define SWM_D_MOUSE             0x0040
 106 #define SWM_D_PROP              0x0080
 107 #define SWM_D_CLASS             0x0100
 108
 109 u_int32_t               swm_debug = 0
 110                             | SWM_D_MISC
 111                             | SWM_D_EVENT
 112                             | SWM_D_WS
 113                             | SWM_D_FOCUS
 114                             | SWM_D_MOVE
 115                             | SWM_D_STACK
 116                             | SWM_D_MOUSE
 117                             | SWM_D_PROP
 118                             | SWM_D_CLASS
 119                             ;
 120 #else
 121 #define DPRINTF(x...)
 122 #define DNPRINTF(n,x...)
 123 #endif
 124
 125 #define LENGTH(x)               (sizeof x / sizeof x[0])
 126 #define MODKEY                  Mod1Mask
 127 #define CLEANMASK(mask)         (mask & ~(numlockmask | LockMask))
 128 #define BUTTONMASK              (ButtonPressMask|ButtonReleaseMask)
 129 #define MOUSEMASK               (BUTTONMASK|PointerMotionMask)
 130 #define SWM_PROPLEN             (16)
 131 #define X(r)                    (r)->g.x
 132 #define Y(r)                    (r)->g.y
 133 #define WIDTH(r)                (r)->g.w
 134 #define HEIGHT(r)               (r)->g.h
 135 #define SWM_MAX_FONT_STEPS      (3)
 136
 137 #ifndef SWM_LIB
 138 #define SWM_LIB                 "/usr/X11R6/lib/swmhack.so"
 139 #endif
 140
 141 char                    **start_argv;
 142 Atom                    astate;
 143 Atom                    aprot;
 144 Atom                    adelete;
 145 int                     (*xerrorxlib)(Display *, XErrorEvent *);
 146 int                     other_wm;
 147 int                     running = 1;
 148 int                     ss_enabled = 0;
 149 int                     xrandr_support;
 150 int                     xrandr_eventbase;
 151 int                     ignore_enter = 0;
 152 unsigned int            numlockmask = 0;
 153 Display                 *display;
 154
 155 int                     cycle_empty = 0;
 156 int                     cycle_visible = 0;
 157 int                     term_width = 0;
 158 int                     font_adjusted = 0;
 159
 160 /* dialog windows */
 161 double                  dialog_ratio = .6;
 162 /* status bar */
 163 #define SWM_BAR_MAX     (128)
 164 char                    *bar_argv[] = { NULL, NULL };
 165 int                     bar_pipe[2];
 166 char                    bar_ext[SWM_BAR_MAX];
 167 char                    bar_vertext[SWM_BAR_MAX];
 168 int                     bar_version = 0;
 169 sig_atomic_t            bar_alarm = 0;
 170 int                     bar_delay = 30;
 171 int                     bar_enabled = 1;
 172 int                     bar_extra = 1;
 173 int                     bar_extra_running = 0;
 174 int                     bar_verbose = 1;
 175 int                     bar_height = 0;
 176 pid_t                   bar_pid;
 177 GC                      bar_gc;
 178 XGCValues               bar_gcv;
 179 int                     bar_fidx = 0;
 180 XFontStruct             *bar_fs;
 181 char                    *bar_fonts[] = {
 182                             "-*-terminus-*-*-*-*-*-*-*-*-*-*-*-*",
 183                             "-*-times-medium-r-*-*-*-*-*-*-*-*-*-*",
 184                             NULL
 185 };
 186
 187 /* terminal + args */
 188 char                    *spawn_term[] = { "xterm", NULL };
 189 char                    *spawn_screenshot[] = { "screenshot.sh", NULL, NULL };
 190 char                    *spawn_lock[] = { "xlock", NULL };
 191 char                    *spawn_initscr[] = { "initscreen.sh", NULL };
 192 char                    *spawn_menu[] = { "dmenu_run", "-fn", NULL, "-nb", NULL,
 193                             "-nf", NULL, "-sb", NULL, "-sf", NULL, NULL };
 194
 195 #define SWM_MENU_FN     (2)
 196 #define SWM_MENU_NB     (4)
 197 #define SWM_MENU_NF     (6)
 198 #define SWM_MENU_SB     (8)
 199 #define SWM_MENU_SF     (10)
 200
 201 /* layout manager data */
 202 struct swm_geometry {
 203         int                     x;
 204         int                     y;
 205         int                     w;
 206         int                     h;
 207 };
 208
 209 struct swm_screen;
 210 struct workspace;
 211
 212 /* virtual "screens" */
 213 struct swm_region {
 214         TAILQ_ENTRY(swm_region) entry;
 215         struct swm_geometry     g;
 216         struct workspace        *ws;    /* current workspace on this region */
 217         struct swm_screen       *s;     /* screen idx */
 218         Window                  bar_window;
 219 };
 220 TAILQ_HEAD(swm_region_list, swm_region);
 221
 222 struct ws_win {
 223         TAILQ_ENTRY(ws_win)     entry;
 224         Window                  id;
 225         struct swm_geometry     g;
 226         int                     got_focus;
 227         int                     floating;
 228         int                     transient;
 229         int                     manual;
 230         int                     font_size_boundary[SWM_MAX_FONT_STEPS];
 231         int                     font_steps;
 232         int                     last_inc;
 233         int                     can_delete;
 234         unsigned long           quirks;
 235         struct workspace        *ws;    /* always valid */
 236         struct swm_screen       *s;     /* always valid, never changes */
 237         XWindowAttributes       wa;
 238         XSizeHints              sh;
 239         XClassHint              ch;
 240 };
 241 TAILQ_HEAD(ws_win_list, ws_win);
 242
 243 /* layout handlers */
 244 void    stack(void);
 245 void    vertical_config(struct workspace *, int);
 246 void    vertical_stack(struct workspace *, struct swm_geometry *);
 247 void    horizontal_config(struct workspace *, int);
 248 void    horizontal_stack(struct workspace *, struct swm_geometry *);
 249 void    max_stack(struct workspace *, struct swm_geometry *);
 250
 251 void    grabbuttons(struct ws_win *, int);
 252
 253 struct layout {
 254         void            (*l_stack)(struct workspace *, struct swm_geometry *);
 255         void            (*l_config)(struct workspace *, int);
 256 } layouts[] =  {
 257         /* stack,               configure */
 258         { vertical_stack,       vertical_config},
 259         { horizontal_stack,     horizontal_config},
 260         { max_stack,            NULL},
 261         { NULL,                 NULL},
 262 };
 263
 264 #define SWM_H_SLICE             (32)
 265 #define SWM_V_SLICE             (32)
 266
 267 /* define work spaces */
 268 struct workspace {
 269         int                     idx;            /* workspace index */
 270         int                     restack;        /* restack on switch */
 271         struct layout           *cur_layout;    /* current layout handlers */
 272         struct ws_win           *focus;         /* may be NULL */
 273         struct ws_win           *focus_prev;    /* may be NULL */
 274         struct swm_region       *r;             /* may be NULL */
 275         struct ws_win_list      winlist;        /* list of windows in ws */
 276
 277         /* stacker state */
 278         struct {
 279                                 int horizontal_msize;
 280                                 int horizontal_mwin;
 281                                 int horizontal_stacks;
 282                                 int vertical_msize;
 283                                 int vertical_mwin;
 284                                 int vertical_stacks;
 285         } l_state;
 286 };
 287
 288 enum    { SWM_S_COLOR_BAR, SWM_S_COLOR_BAR_BORDER, SWM_S_COLOR_BAR_FONT,
 289           SWM_S_COLOR_FOCUS, SWM_S_COLOR_UNFOCUS, SWM_S_COLOR_MAX };
 290
 291 /* physical screen mapping */
 292 #define SWM_WS_MAX              (10)            /* XXX Too small? */
 293 struct swm_screen {
 294         int                     idx;            /* screen index */
 295         struct swm_region_list  rl;     /* list of regions on this screen */
 296         struct swm_region_list  orl;    /* list of old regions */
 297         Window                  root;
 298         struct workspace        ws[SWM_WS_MAX];
 299
 300         /* colors */
 301         struct {
 302                 unsigned long   color;
 303                 char            *name;
 304         } c[SWM_S_COLOR_MAX];
 305 };
 306 struct swm_screen       *screens;
 307 int                     num_screens;
 308
 309 struct ws_win           *cur_focus = NULL;
 310
 311 /* args to functions */
 312 union arg {
 313         int                     id;
 314 #define SWM_ARG_ID_FOCUSNEXT    (0)
 315 #define SWM_ARG_ID_FOCUSPREV    (1)
 316 #define SWM_ARG_ID_FOCUSMAIN    (2)
 317 #define SWM_ARG_ID_SWAPNEXT     (3)
 318 #define SWM_ARG_ID_SWAPPREV     (4)
 319 #define SWM_ARG_ID_SWAPMAIN     (5)
 320 #define SWM_ARG_ID_MASTERSHRINK (6)
 321 #define SWM_ARG_ID_MASTERGROW   (7)
 322 #define SWM_ARG_ID_MASTERADD    (8)
 323 #define SWM_ARG_ID_MASTERDEL    (9)
 324 #define SWM_ARG_ID_STACKRESET   (10)
 325 #define SWM_ARG_ID_STACKINIT    (11)
 326 #define SWM_ARG_ID_CYCLEWS_UP   (12)
 327 #define SWM_ARG_ID_CYCLEWS_DOWN (13)
 328 #define SWM_ARG_ID_CYCLESC_UP   (14)
 329 #define SWM_ARG_ID_CYCLESC_DOWN (15)
 330 #define SWM_ARG_ID_STACKINC     (16)
 331 #define SWM_ARG_ID_STACKDEC     (17)
 332 #define SWM_ARG_ID_SS_ALL       (0)
 333 #define SWM_ARG_ID_SS_WINDOW    (1)
 334 #define SWM_ARG_ID_DONTCENTER   (0)
 335 #define SWM_ARG_ID_CENTER       (1)
 336 #define SWM_ARG_ID_KILLWINDOW   (0)
 337 #define SWM_ARG_ID_DELETEWINDOW (1)
 338         char                    **argv;
 339 };
 340
 341 /* quirks */
 342 struct quirk {
 343         char                    *class;
 344         char                    *name;
 345         unsigned long           quirk;
 346 #define SWM_Q_FLOAT             (1<<0)  /* float this window */
 347 #define SWM_Q_TRANSSZ           (1<<1)  /* transiend window size too small */
 348 #define SWM_Q_ANYWHERE          (1<<2)  /* don't position this window */
 349 #define SWM_Q_XTERM_FONTADJ     (1<<3)  /* adjust xterm fonts when resizing */
 350 #define SWM_Q_FULLSCREEN        (1<<4)  /* remove border */
 351 } quirks[] = {
 352         { "MPlayer",            "xv",           SWM_Q_FLOAT | SWM_Q_FULLSCREEN },
 353         { "OpenOffice.org 2.4", "VCLSalFrame",  SWM_Q_FLOAT },
 354         { "OpenOffice.org 3.0", "VCLSalFrame",  SWM_Q_FLOAT },
 355         { "Firefox-bin",        "firefox-bin",  SWM_Q_TRANSSZ },
 356         { "Gimp",               "gimp",         SWM_Q_FLOAT | SWM_Q_ANYWHERE },
 357         { "XTerm",              "xterm",        SWM_Q_XTERM_FONTADJ },
 358         { "xine",               "Xine Window",  SWM_Q_FLOAT | SWM_Q_ANYWHERE },
 359         { "Xitk",               "Xitk Combo",   SWM_Q_FLOAT | SWM_Q_ANYWHERE },
 360         { "xine",               "xine Panel",   SWM_Q_FLOAT | SWM_Q_ANYWHERE },
 361         { "Xitk",               "Xine Window",  SWM_Q_FLOAT | SWM_Q_ANYWHERE },
 362         { "xine",               "xine Video Fullscreen Window", SWM_Q_FULLSCREEN | SWM_Q_FLOAT },
 363         { "pcb",                "pcb",          SWM_Q_FLOAT },
 364         { NULL,                 NULL,           0},
 365 };
 366
 367 /* events */
 368 void                    expose(XEvent *);
 369 void                    keypress(XEvent *);
 370 void                    buttonpress(XEvent *);
 371 void                    configurerequest(XEvent *);
 372 void                    configurenotify(XEvent *);
 373 void                    destroynotify(XEvent *);
 374 void                    enternotify(XEvent *);
 375 void                    focusin(XEvent *);
 376 void                    mappingnotify(XEvent *);
 377 void                    maprequest(XEvent *);
 378 void                    propertynotify(XEvent *);
 379 void                    unmapnotify(XEvent *);
 380 void                    visibilitynotify(XEvent *);
 381
 382 void                    (*handler[LASTEvent])(XEvent *) = {
 383                                 [Expose] = expose,
 384                                 [KeyPress] = keypress,
 385                                 [ButtonPress] = buttonpress,
 386                                 [ConfigureRequest] = configurerequest,
 387                                 [ConfigureNotify] = configurenotify,
 388                                 [DestroyNotify] = destroynotify,
 389                                 [EnterNotify] = enternotify,
 390                                 [FocusIn] = focusin,
 391                                 [MappingNotify] = mappingnotify,
 392                                 [MapRequest] = maprequest,
 393                                 [PropertyNotify] = propertynotify,
 394                                 [UnmapNotify] = unmapnotify,
 395                                 [VisibilityNotify] = visibilitynotify,
 396 };
 397
 398 unsigned long
 399 name_to_color(char *colorname)
 400 {
 401         Colormap                cmap;
 402         Status                  status;
 403         XColor                  screen_def, exact_def;
 404         unsigned long           result = 0;
 405         char                    cname[32] = "#";
 406
 407         cmap = DefaultColormap(display, screens[0].idx);
 408         status = XAllocNamedColor(display, cmap, colorname,
 409             &screen_def, &exact_def);
 410         if (!status) {
 411                 strlcat(cname, colorname + 2, sizeof cname - 1);
 412                 status = XAllocNamedColor(display, cmap, cname, &screen_def,
 413                     &exact_def);
 414         }
 415         if (status)
 416                 result = screen_def.pixel;
 417         else
 418                 fprintf(stderr, "color '%s' not found.\n", colorname);
 419
 420         return (result);
 421 }
 422
 423 void
 424 setscreencolor(char *val, int i, int c)
 425 {
 426         if (i > 0 && i <= ScreenCount(display)) {
 427                 screens[i - 1].c[c].color = name_to_color(val);
 428                 if ((screens[i - 1].c[c].name = strdup(val)) == NULL)
 429                         errx(1, "strdup");
 430         } else if (i == -1) {
 431                 for (i = 0; i < ScreenCount(display); i++)
 432                         screens[i].c[c].color = name_to_color(val);
 433                         if ((screens[i - 1].c[c].name = strdup(val)) == NULL)
 434                                 errx(1, "strdup");
 435         } else
 436                 errx(1, "invalid screen index: %d out of bounds (maximum %d)\n",
 437                     i, ScreenCount(display));
 438 }
 439
 440 void            new_region(struct swm_screen *, int, int, int, int);
 441
 442 void
 443 custom_region(char *val)
 444 {
 445         unsigned int                    sidx, x, y, w, h;
 446
 447         if (sscanf(val, "screen[%u]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5)
 448                 errx(1, "invalid custom region, "
 449                     "should be 'screen[<n>]:<n>x<n>+<n>+<n>\n");
 450         if (sidx < 1 || sidx > ScreenCount(display))
 451                 errx(1, "invalid screen index: %d out of bounds (maximum %d)\n",
 452                     sidx, ScreenCount(display));
 453         sidx--;
 454
 455         if (w < 1 || h < 1)
 456                 errx(1, "region %ux%u+%u+%u too small\n", w, h, x, y);
 457
 458         if (x  < 0 || x > DisplayWidth(display, sidx) ||
 459             y < 0 || y > DisplayHeight(display, sidx) ||
 460             w + x > DisplayWidth(display, sidx) ||
 461             h + y > DisplayHeight(display, sidx))
 462                 errx(1, "region %ux%u+%u+%u not within screen boundaries "
 463                     "(%ux%u)\n", w, h, x, y,
 464                     DisplayWidth(display, sidx), DisplayHeight(display, sidx));
 465
 466         new_region(&screens[sidx], x, y, w, h);
 467 }
 468
 469 int
 470 varmatch(char *var, char *name, int *index)
 471 {
 472         char                    *p, buf[5];
 473         int                     i;
 474
 475         i = strncmp(var, name, 255);
 476         if (index == NULL)
 477                 return (i);
 478
 479         *index = -1;
 480         if (i <= 0)
 481                 return (i);
 482         p = var + strlen(name);
 483         if (*p++ != '[')
 484                 return (i);
 485         bzero(buf, sizeof buf);
 486         i = 0;
 487         while (isdigit(*p) && i < sizeof buf)
 488                 buf[i++] = *p++;
 489         if (i == 0 || i >= sizeof buf || *p != ']')
 490                 return (1);
 491         *index = strtonum(buf, 0, 99, NULL);
 492         return (0);
 493 }
 494
 495 /* conf file stuff */
 496 #define SWM_CONF_WS     "\n= \t"
 497 #define SWM_CONF_FILE   "scrotwm.conf"
 498 int
 499 conf_load(char *filename)
 500 {
 501         FILE                    *config;
 502         char                    *line, *cp, *var, *val;
 503         size_t                  len, lineno = 0;
 504         int                     i, sc;
 505
 506         DNPRINTF(SWM_D_MISC, "conf_load: filename %s\n", filename);
 507
 508         if (filename == NULL)
 509                 return (1);
 510
 511         if ((config = fopen(filename, "r")) == NULL)
 512                 return (1);
 513
 514         for (sc = ScreenCount(display);;) {
 515                 if ((line = fparseln(config, &len, &lineno, NULL, 0)) == NULL)
 516                         if (feof(config))
 517                                 break;
 518                 cp = line;
 519                 cp += (long)strspn(cp, SWM_CONF_WS);
 520                 if (cp[0] == '\0') {
 521                         /* empty line */
 522                         free(line);
 523                         continue;
 524                 }
 525                 if ((var = strsep(&cp, SWM_CONF_WS)) == NULL || cp == NULL)
 526                         break;
 527                 cp += (long)strspn(cp, SWM_CONF_WS);
 528                 if ((val = strsep(&cp, SWM_CONF_WS)) == NULL)
 529                         break;
 530
 531                 DNPRINTF(SWM_D_MISC, "conf_load: %s=%s\n",var ,val);
 532                 switch (var[0]) {
 533                 case 'b':
 534                         if (!strncmp(var, "bar_enabled", strlen("bar_enabled")))
 535                                 bar_enabled = atoi(val);
 536                         else if (!varmatch(var, "bar_border", &i))
 537                                 setscreencolor(val, i, SWM_S_COLOR_BAR_BORDER);
 538                         else if (!varmatch(var, "bar_color", &i))
 539                                 setscreencolor(val, i, SWM_S_COLOR_BAR);
 540                         else if (!varmatch(var, "bar_font_color", &i))
 541                                 setscreencolor(val, i, SWM_S_COLOR_BAR_FONT);
 542                         else if (!strncmp(var, "bar_font", strlen("bar_font")))
 543                                 asprintf(&bar_fonts[0], "%s", val);
 544                         else if (!strncmp(var, "bar_action", strlen("bar_action")))
 545                                 asprintf(&bar_argv[0], "%s", val);
 546                         else if (!strncmp(var, "bar_delay", strlen("bar_delay")))
 547                                 bar_delay = atoi(val);
 548                         else
 549                                 goto bad;
 550                         break;
 551
 552                 case 'c':
 553                         if (!varmatch(var, "color_focus", &i))
 554                                 setscreencolor(val, i, SWM_S_COLOR_FOCUS);
 555                         else if (!varmatch(var, "color_unfocus", &i))
 556                                 setscreencolor(val, i, SWM_S_COLOR_UNFOCUS);
 557                         else if (!strncmp(var, "cycle_empty", strlen("cycle_empty")))
 558                                 cycle_visible = atoi(val);
 559                         else if (!strncmp(var, "cycle_visible", strlen("cycle_visible")))
 560                                 cycle_visible = atoi(val);
 561                         else
 562                                 goto bad;
 563                         break;
 564
 565                 case 'd':
 566                         if (!strncmp(var, "dialog_ratio",
 567                             strlen("dialog_ratio"))) {
 568                                 dialog_ratio = atof(val);
 569                                 if (dialog_ratio > 1.0 || dialog_ratio <= .3)
 570                                         dialog_ratio = .6;
 571                         } else
 572                                 goto bad;
 573                         break;
 574
 575                 case 'r':
 576                         if (!strncmp(var, "region", strlen("region")))
 577                                 custom_region(val);
 578                         else
 579                                 goto bad;
 580                         break;
 581
 582                 case 's':
 583                         if (!strncmp(var, "spawn_term", strlen("spawn_term")))
 584                                 asprintf(&spawn_term[0], "%s", val);
 585                         else if (!strncmp(var, "screenshot_enabled",
 586                             strlen("screenshot_enabled")))
 587                                 ss_enabled = atoi(val);
 588                         else if (!strncmp(var, "screenshot_app",
 589                             strlen("screenshot_app")))
 590                                 asprintf(&spawn_screenshot[0], "%s", val);
 591                         else
 592                                 goto bad;
 593                         break;
 594
 595                 case 't':
 596                         if (!strncmp(var, "term_width", strlen("term_width")))
 597                                 term_width = atoi(val);
 598                         else
 599                                 goto bad;
 600                         break;
 601
 602                 default:
 603                         goto bad;
 604                 }
 605                 free(line);
 606         }
 607
 608         fclose(config);
 609         return (0);
 610
 611 bad:
 612         errx(1, "invalid conf file entry: %s=%s", var, val);
 613 }
 614
 615 void
 616 socket_setnonblock(int fd)
 617 {
 618         int                     flags;
 619
 620         if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
 621                 err(1, "fcntl F_GETFL");
 622         flags |= O_NONBLOCK;
 623         if ((flags = fcntl(fd, F_SETFL, flags)) == -1)
 624                 err(1, "fcntl F_SETFL");
 625 }
 626
 627 void
 628 bar_print(struct swm_region *r, char *s)
 629 {
 630         XClearWindow(display, r->bar_window);
 631         XSetForeground(display, bar_gc, r->s->c[SWM_S_COLOR_BAR_FONT].color);
 632         XDrawString(display, r->bar_window, bar_gc, 4, bar_fs->ascent, s,
 633             strlen(s));
 634 }
 635
 636 void
 637 bar_extra_stop(void)
 638 {
 639         if (bar_pipe[0]) {
 640                 close(bar_pipe[0]);
 641                 bzero(bar_pipe, sizeof bar_pipe);
 642         }
 643         if (bar_pid) {
 644                 kill(bar_pid, SIGTERM);
 645                 bar_pid = 0;
 646         }
 647         strlcpy(bar_ext, "", sizeof bar_ext);
 648         bar_extra = 0;
 649 }
 650
 651 void
 652 bar_update(void)
 653 {
 654         time_t                  tmt;
 655         struct tm               tm;
 656         struct swm_region       *r;
 657         int                     i, x;
 658         size_t                  len;
 659         char                    s[SWM_BAR_MAX];
 660         char                    loc[SWM_BAR_MAX];
 661         char                    *b;
 662
 663         if (bar_enabled == 0)
 664                 return;
 665         if (bar_extra && bar_extra_running) {
 666                 /* ignore short reads; it'll correct itself */
 667                 while ((b = fgetln(stdin, &len)) != NULL)
 668                         if (b && b[len - 1] == '\n') {
 669                                 b[len - 1] = '\0';
 670                                 strlcpy(bar_ext, b, sizeof bar_ext);
 671                         }
 672                 if (b == NULL && errno != EAGAIN) {
 673                         fprintf(stderr, "bar_extra failed: errno: %d %s\n",
 674                             errno, strerror(errno));
 675                         bar_extra_stop();
 676                 }
 677         } else
 678                 strlcpy(bar_ext, "", sizeof bar_ext);
 679
 680         time(&tmt);
 681         localtime_r(&tmt, &tm);
 682         strftime(s, sizeof s, "%a %b %d %R %Z %Y", &tm);
 683         for (i = 0; i < ScreenCount(display); i++) {
 684                 x = 1;
 685                 TAILQ_FOREACH(r, &screens[i].rl, entry) {
 686                         snprintf(loc, sizeof loc, "%s     %d:%d    %s    %s",
 687                             s, x++, r->ws->idx + 1, bar_ext, bar_vertext);
 688                         bar_print(r, loc);
 689                 }
 690         }
 691         XSync(display, False);
 692         alarm(bar_delay);
 693 }
 694
 695 void
 696 bar_signal(int sig)
 697 {
 698         bar_alarm = 1;
 699 }
 700
 701 void
 702 bar_toggle(struct swm_region *r, union arg *args)
 703 {
 704         struct swm_region       *tmpr;
 705         int                     i, j, sc = ScreenCount(display);
 706
 707         DNPRINTF(SWM_D_MISC, "bar_toggle\n");
 708
 709         if (bar_enabled) {
 710                 for (i = 0; i < sc; i++)
 711                         TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
 712                                 XUnmapWindow(display, tmpr->bar_window);
 713         } else {
 714                 for (i = 0; i < sc; i++)
 715                         TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
 716                                 XMapRaised(display, tmpr->bar_window);
 717         }
 718         bar_enabled = !bar_enabled;
 719         for (i = 0; i < sc; i++)
 720                 for (j = 0; j < SWM_WS_MAX; j++)
 721                         screens[i].ws[j].restack = 1;
 722
 723         stack();
 724         /* must be after stack */
 725         bar_update();
 726 }
 727
 728 void
 729 bar_refresh(void)
 730 {
 731         XSetWindowAttributes    wa;
 732         struct swm_region       *r;
 733         int                     i;
 734
 735         /* do this here because the conf file is in memory */
 736         if (bar_extra && bar_extra_running == 0 && bar_argv[0]) {
 737                 /* launch external status app */
 738                 bar_extra_running = 1;
 739                 if (pipe(bar_pipe) == -1)
 740                         err(1, "pipe error");
 741                 socket_setnonblock(bar_pipe[0]);
 742                 socket_setnonblock(bar_pipe[1]); /* XXX hmmm, really? */
 743                 if (dup2(bar_pipe[0], 0) == -1)
 744                         errx(1, "dup2");
 745                 if (dup2(bar_pipe[1], 1) == -1)
 746                         errx(1, "dup2");
 747                 if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
 748                         err(1, "could not disable SIGPIPE");
 749                 switch (bar_pid = fork()) {
 750                 case -1:
 751                         err(1, "cannot fork");
 752                         break;
 753                 case 0: /* child */
 754                         close(bar_pipe[0]);
 755                         execvp(bar_argv[0], bar_argv);
 756                         err(1, "%s external app failed", bar_argv[0]);
 757                         break;
 758                 default: /* parent */
 759                         close(bar_pipe[1]);
 760                         break;
 761                 }
 762         }
 763
 764         bzero(&wa, sizeof wa);
 765         for (i = 0; i < ScreenCount(display); i++)
 766                 TAILQ_FOREACH(r, &screens[i].rl, entry) {
 767                         wa.border_pixel =
 768                             screens[i].c[SWM_S_COLOR_BAR_BORDER].color;
 769                         wa.background_pixel =
 770                             screens[i].c[SWM_S_COLOR_BAR].color;
 771                         XChangeWindowAttributes(display, r->bar_window,
 772                             CWBackPixel | CWBorderPixel, &wa);
 773                 }
 774         bar_update();
 775 }
 776
 777 void
 778 bar_setup(struct swm_region *r)
 779 {
 780         int                     i;
 781
 782         for (i = 0; bar_fonts[i] != NULL; i++) {
 783                 bar_fs = XLoadQueryFont(display, bar_fonts[i]);
 784                 if (bar_fs) {
 785                         bar_fidx = i;
 786                         break;
 787                 }
 788         }
 789         if (bar_fonts[i] == NULL)
 790                         errx(1, "couldn't load font");
 791         bar_height = bar_fs->ascent + bar_fs->descent + 3;
 792
 793         r->bar_window = XCreateSimpleWindow(display,
 794             r->s->root, X(r), Y(r), WIDTH(r) - 2, bar_height - 2,
 795             1, r->s->c[SWM_S_COLOR_BAR_BORDER].color,
 796             r->s->c[SWM_S_COLOR_BAR].color);
 797         bar_gc = XCreateGC(display, r->bar_window, 0, &bar_gcv);
 798         XSetFont(display, bar_gc, bar_fs->fid);
 799         XSelectInput(display, r->bar_window, VisibilityChangeMask);
 800         if (bar_enabled)
 801                 XMapRaised(display, r->bar_window);
 802         DNPRINTF(SWM_D_MISC, "bar_setup: bar_window %lu\n", r->bar_window);
 803
 804         if (signal(SIGALRM, bar_signal) == SIG_ERR)
 805                 err(1, "could not install bar_signal");
 806         bar_refresh();
 807 }
 808
 809 void
 810 version(struct swm_region *r, union arg *args)
 811 {
 812         bar_version = !bar_version;
 813         if (bar_version)
 814                 strlcpy(bar_vertext, cvstag, sizeof bar_vertext);
 815         else
 816                 strlcpy(bar_vertext, "", sizeof bar_vertext);
 817         bar_update();
 818 }
 819
 820 void
 821 client_msg(struct ws_win *win, Atom a)
 822 {
 823         XClientMessageEvent     cm;
 824
 825         bzero(&cm, sizeof cm);
 826         cm.type = ClientMessage;
 827         cm.window = win->id;
 828         cm.message_type = aprot;
 829         cm.format = 32;
 830         cm.data.l[0] = a;
 831         cm.data.l[1] = CurrentTime;
 832         XSendEvent(display, win->id, False, 0L, (XEvent *)&cm);
 833 }
 834
 835 void
 836 config_win(struct ws_win *win)
 837 {
 838         XConfigureEvent         ce;
 839
 840         DNPRINTF(SWM_D_MISC, "config_win: win %lu x %d y %d w %d h %d\n",
 841             win->id, win->g.x, win->g.y, win->g.w, win->g.h);
 842         ce.type = ConfigureNotify;
 843         ce.display = display;
 844         ce.event = win->id;
 845         ce.window = win->id;
 846         ce.x = win->g.x;
 847         ce.y = win->g.y;
 848         ce.width = win->g.w;
 849         ce.height = win->g.h;
 850         ce.border_width = 1; /* XXX store this! */
 851         ce.above = None;
 852         ce.override_redirect = False;
 853         XSendEvent(display, win->id, False, StructureNotifyMask, (XEvent *)&ce);
 854 }
 855
 856 int
 857 count_win(struct workspace *ws, int count_transient)
 858 {
 859         struct ws_win           *win;
 860         int                     count = 0;
 861
 862         TAILQ_FOREACH(win, &ws->winlist, entry) {
 863                 if (count_transient == 0 && win->floating)
 864                         continue;
 865                 if (count_transient == 0 && win->transient)
 866                         continue;
 867                 count++;
 868         }
 869         DNPRINTF(SWM_D_MISC, "count_win: %d\n", count);
 870
 871         return (count);
 872 }
 873
 874 void
 875 quit(struct swm_region *r, union arg *args)
 876 {
 877         DNPRINTF(SWM_D_MISC, "quit\n");
 878         running = 0;
 879 }
 880
 881 void
 882 unmap_all(void)
 883 {
 884         struct ws_win           *win;
 885         int                     i, j;
 886
 887         for (i = 0; i < ScreenCount(display); i++)
 888                 for (j = 0; j < SWM_WS_MAX; j++)
 889                         TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
 890                                 XUnmapWindow(display, win->id);
 891 }
 892
 893 void
 894 fake_keypress(struct ws_win *win, int keysym, int modifiers)
 895 {
 896         XKeyEvent event;
 897
 898         event.display = display;        /* Ignored, but what the hell */
 899         event.window = win->id;
 900         event.root = win->s->root;
 901         event.subwindow = None;
 902         event.time = CurrentTime;
 903         event.x = win->g.x;
 904         event.y = win->g.y;
 905         event.x_root = 1;
 906         event.y_root = 1;
 907         event.same_screen = True;
 908         event.keycode = XKeysymToKeycode(display, keysym);
 909         event.state = modifiers;
 910
 911         event.type = KeyPress;
 912         XSendEvent(event.display, event.window, True,
 913             KeyPressMask, (XEvent *)&event);
 914
 915         event.type = KeyRelease;
 916         XSendEvent(event.display, event.window, True,
 917             KeyPressMask, (XEvent *)&event);
 918
 919 }
 920
 921 void
 922 restart(struct swm_region *r, union arg *args)
 923 {
 924         DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]);
 925
 926         /* disable alarm because the following code may not be interrupted */
 927         alarm(0);
 928         if (signal(SIGALRM, SIG_IGN) == SIG_ERR)
 929                 errx(1, "can't disable alarm");
 930
 931         bar_extra_stop();
 932         bar_extra = 1;
 933         unmap_all();
 934         XCloseDisplay(display);
 935         execvp(start_argv[0], start_argv);
 936         fprintf(stderr, "execvp failed\n");
 937         perror(" failed");
 938         quit(NULL, NULL);
 939 }
 940
 941 struct swm_region *
 942 root_to_region(Window root)
 943 {
 944         struct swm_region       *r = NULL;
 945         Window                  rr, cr;
 946         int                     i, x, y, wx, wy;
 947         unsigned int            mask;
 948
 949         for (i = 0; i < ScreenCount(display); i++)
 950                 if (screens[i].root == root)
 951                         break;
 952
 953         if (XQueryPointer(display, screens[i].root,
 954             &rr, &cr, &x, &y, &wx, &wy, &mask) != False) {
 955                 /* choose a region based on pointer location */
 956                 TAILQ_FOREACH(r, &screens[i].rl, entry)
 957                         if (x >= X(r) && x <= X(r) + WIDTH(r) &&
 958                             y >= Y(r) && y <= Y(r) + HEIGHT(r))
 959                                 break;
 960         }
 961
 962         if (r == NULL)
 963                 r = TAILQ_FIRST(&screens[i].rl);
 964
 965         return (r);
 966 }
 967
 968 struct ws_win *
 969 find_window(Window id)
 970 {
 971         struct ws_win           *win;
 972         int                     i, j;
 973
 974         for (i = 0; i < ScreenCount(display); i++)
 975                 for (j = 0; j < SWM_WS_MAX; j++)
 976                         TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
 977                                 if (id == win->id)
 978                                         return (win);
 979         return (NULL);
 980 }
 981
 982 void
 983 spawn(struct swm_region *r, union arg *args)
 984 {
 985         char                    *ret;
 986         int                     si;
 987
 988         DNPRINTF(SWM_D_MISC, "spawn: %s\n", args->argv[0]);
 989         /*
 990          * The double-fork construct avoids zombie processes and keeps the code
 991          * clean from stupid signal handlers.
 992          */
 993         if (fork() == 0) {
 994                 if (fork() == 0) {
 995                         if (display)
 996                                 close(ConnectionNumber(display));
 997                         setenv("LD_PRELOAD", SWM_LIB, 1);
 998                         if (asprintf(&ret, "%d", r->ws->idx)) {
 999                                 setenv("_SWM_WS", ret, 1);
1000                                 free(ret);
1001                         }
1002                         if (asprintf(&ret, "%d", getpid())) {
1003                                 setenv("_SWM_PID", ret, 1);
1004                                 free(ret);
1005                         }
1006                         setsid();
1007                         /* kill stdin, mplayer, ssh-add etc. need that */
1008                         si = open("/dev/null", O_RDONLY, 0);
1009                         if (si == -1)
1010                                 err(1, "open /dev/null");
1011                         if (dup2(si, 0) == -1)
1012                                 err(1, "dup2 /dev/null");
1013                         execvp(args->argv[0], args->argv);
1014                         fprintf(stderr, "execvp failed\n");
1015                         perror(" failed");
1016                 }
1017                 exit(0);
1018         }
1019         wait(0);
1020 }
1021
1022 void
1023 spawnterm(struct swm_region *r, union arg *args)
1024 {
1025         DNPRINTF(SWM_D_MISC, "spawnterm\n");
1026
1027         if (term_width)
1028                 setenv("_SWM_XTERM_FONTADJ", "", 1);
1029         spawn(r, args);
1030 }
1031
1032 void
1033 spawnmenu(struct swm_region *r, union arg *args)
1034 {
1035         DNPRINTF(SWM_D_MISC, "spawnmenu\n");
1036
1037         spawn_menu[SWM_MENU_FN] = bar_fonts[bar_fidx];
1038         spawn_menu[SWM_MENU_NB] = r->s->c[SWM_S_COLOR_BAR].name;
1039         spawn_menu[SWM_MENU_NF] = r->s->c[SWM_S_COLOR_BAR_FONT].name;
1040         spawn_menu[SWM_MENU_SB] = r->s->c[SWM_S_COLOR_BAR_BORDER].name;
1041         spawn_menu[SWM_MENU_SF] = r->s->c[SWM_S_COLOR_BAR].name;
1042
1043         spawn(r, args);
1044 }
1045
1046 void
1047 unfocus_all(void)
1048 {
1049         struct ws_win           *win;
1050         int                     i, j;
1051
1052         DNPRINTF(SWM_D_FOCUS, "unfocus_all:\n");
1053
1054         for (i = 0; i < ScreenCount(display); i++)
1055                 for (j = 0; j < SWM_WS_MAX; j++)
1056                         TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) {
1057                                 if (win->ws->r == NULL)
1058                                         continue;
1059                                 grabbuttons(win, 0);
1060                                 XSetWindowBorder(display, win->id,
1061                                     win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
1062                                 win->got_focus = 0;
1063                                 win->ws->focus = NULL;
1064                                 cur_focus = NULL;
1065                         }
1066 }
1067
1068 void
1069 focus_win(struct ws_win *win)
1070 {
1071         DNPRINTF(SWM_D_FOCUS, "focus_win: id: %lu\n", win ? win->id : 0);
1072
1073         if (win == NULL)
1074                 return;
1075
1076         if (win->ws->focus != win && win->ws->focus != NULL)
1077                 win->ws->focus_prev = win->ws->focus;
1078
1079         unfocus_all();
1080         win->ws->focus = win;
1081         if (win->ws->r != NULL) {
1082                 cur_focus = win;
1083                 if (!win->got_focus) {
1084                         XSetWindowBorder(display, win->id,
1085                             win->ws->r->s->c[SWM_S_COLOR_FOCUS].color);
1086                         grabbuttons(win, 1);
1087                 }
1088                 win->got_focus = 1;
1089                 XSetInputFocus(display, win->id,
1090                     RevertToPointerRoot, CurrentTime);
1091         }
1092 }
1093
1094 void
1095 switchws(struct swm_region *r, union arg *args)
1096 {
1097         int                     wsid = args->id;
1098         struct swm_region       *this_r, *other_r;
1099         struct ws_win           *win;
1100         struct workspace        *new_ws, *old_ws;
1101
1102         this_r = r;
1103         old_ws = this_r->ws;
1104         new_ws = &this_r->s->ws[wsid];
1105
1106         DNPRINTF(SWM_D_WS, "switchws screen[%d]:%dx%d+%d+%d: "
1107             "%d -> %d\n", r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r),
1108             old_ws->idx, wsid);
1109
1110         if (new_ws == old_ws)
1111                 return;
1112
1113         other_r = new_ws->r;
1114         if (!other_r) {
1115                 /* if the other workspace is hidden, switch windows */
1116                 /* map new window first to prevent ugly blinking */
1117                 old_ws->r = NULL;
1118                 old_ws->restack = 1;
1119
1120                 TAILQ_FOREACH(win, &new_ws->winlist, entry)
1121                         XMapRaised(display, win->id);
1122
1123                 TAILQ_FOREACH(win, &old_ws->winlist, entry)
1124                         XUnmapWindow(display, win->id);
1125         } else {
1126                 other_r->ws = old_ws;
1127                 old_ws->r = other_r;
1128         }
1129         this_r->ws = new_ws;
1130         new_ws->r = this_r;
1131
1132         ignore_enter = 1;
1133         /* set focus */
1134         if (new_ws->focus)
1135                 focus_win(new_ws->focus);
1136         stack();
1137         bar_update();
1138 }
1139
1140 void
1141 cyclews(struct swm_region *r, union arg *args)
1142 {
1143         union                   arg a;
1144         struct swm_screen       *s = r->s;
1145
1146         DNPRINTF(SWM_D_WS, "cyclews id %d "
1147             "in screen[%d]:%dx%d+%d+%d ws %d\n", args->id,
1148             r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx);
1149
1150         a.id = r->ws->idx;
1151         do {
1152                 switch (args->id) {
1153                 case SWM_ARG_ID_CYCLEWS_UP:
1154                         if (a.id < SWM_WS_MAX - 1)
1155                                 a.id++;
1156                         else
1157                                 a.id = 0;
1158                         break;
1159                 case SWM_ARG_ID_CYCLEWS_DOWN:
1160                         if (a.id > 0)
1161                                 a.id--;
1162                         else
1163                                 a.id = SWM_WS_MAX - 1;
1164                         break;
1165                 default:
1166                         return;
1167                 };
1168
1169                 if (cycle_empty == 0 && TAILQ_EMPTY(&s->ws[a.id].winlist))
1170                         continue;
1171                 if (cycle_visible == 0 && s->ws[a.id].r != NULL)
1172                         continue;
1173
1174                 switchws(r, &a);
1175         } while (a.id != r->ws->idx);
1176 }
1177
1178 void
1179 cyclescr(struct swm_region *r, union arg *args)
1180 {
1181         struct swm_region       *rr;
1182         int                     i;
1183
1184         i = r->s->idx;
1185         switch (args->id) {
1186         case SWM_ARG_ID_CYCLESC_UP:
1187                 rr = TAILQ_NEXT(r, entry);
1188                 if (rr == NULL)
1189                         rr = TAILQ_FIRST(&screens[i].rl);
1190                 break;
1191         case SWM_ARG_ID_CYCLESC_DOWN:
1192                 rr = TAILQ_PREV(r, swm_region_list, entry);
1193                 if (rr == NULL)
1194                         rr = TAILQ_LAST(&screens[i].rl, swm_region_list);
1195                 break;
1196         default:
1197                 return;
1198         };
1199         unfocus_all();
1200         XSetInputFocus(display, PointerRoot, RevertToPointerRoot, CurrentTime);
1201         XWarpPointer(display, None, rr->s[i].root, 0, 0, 0, 0, rr->g.x,
1202             rr->g.y + bar_enabled ? bar_height : 0);
1203 }
1204
1205 void
1206 swapwin(struct swm_region *r, union arg *args)
1207 {
1208         struct ws_win           *target, *source;
1209         struct ws_win_list      *wl;
1210
1211
1212         DNPRINTF(SWM_D_WS, "swapwin id %d "
1213             "in screen %d region %dx%d+%d+%d ws %d\n", args->id,
1214             r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx);
1215         if (cur_focus == NULL)
1216                 return;
1217
1218         source = cur_focus;
1219         wl = &source->ws->winlist;
1220
1221         switch (args->id) {
1222         case SWM_ARG_ID_SWAPPREV:
1223                 target = TAILQ_PREV(source, ws_win_list, entry);
1224                 TAILQ_REMOVE(wl, cur_focus, entry);
1225                 if (target == NULL)
1226                         TAILQ_INSERT_TAIL(wl, source, entry);
1227                 else
1228                         TAILQ_INSERT_BEFORE(target, source, entry);
1229                 break;
1230         case SWM_ARG_ID_SWAPNEXT:
1231                 target = TAILQ_NEXT(source, entry);
1232                 TAILQ_REMOVE(wl, source, entry);
1233                 if (target == NULL)
1234                         TAILQ_INSERT_HEAD(wl, source, entry);
1235                 else
1236                         TAILQ_INSERT_AFTER(wl, target, source, entry);
1237                 break;
1238         case SWM_ARG_ID_SWAPMAIN:
1239                 target = TAILQ_FIRST(wl);
1240                 if (target == source) {
1241                         if (source->ws->focus_prev != NULL &&
1242                             source->ws->focus_prev != target)
1243
1244                                 source = source->ws->focus_prev;
1245                         else
1246                                 return;
1247                 }
1248                 source->ws->focus_prev = target;
1249                 TAILQ_REMOVE(wl, target, entry);
1250                 TAILQ_INSERT_BEFORE(source, target, entry);
1251                 TAILQ_REMOVE(wl, source, entry);
1252                 TAILQ_INSERT_HEAD(wl, source, entry);
1253                 break;
1254         default:
1255                 DNPRINTF(SWM_D_MOVE, "invalid id: %d\n", args->id);
1256                 return;
1257         }
1258
1259         ignore_enter = 1;
1260         stack();
1261 }
1262
1263 void
1264 focus(struct swm_region *r, union arg *args)
1265 {
1266         struct ws_win           *winfocus, *winlostfocus;
1267         struct ws_win_list      *wl;
1268
1269         DNPRINTF(SWM_D_FOCUS, "focus: id %d\n", args->id);
1270         if (cur_focus == NULL)
1271                 return;
1272
1273         wl = &cur_focus->ws->winlist;
1274
1275         winlostfocus = cur_focus;
1276
1277         switch (args->id) {
1278         case SWM_ARG_ID_FOCUSPREV:
1279                 winfocus = TAILQ_PREV(cur_focus, ws_win_list, entry);
1280                 if (winfocus == NULL)
1281                         winfocus = TAILQ_LAST(wl, ws_win_list);
1282                 break;
1283
1284         case SWM_ARG_ID_FOCUSNEXT:
1285                 winfocus = TAILQ_NEXT(cur_focus, entry);
1286                 if (winfocus == NULL)
1287                         winfocus = TAILQ_FIRST(wl);
1288                 break;
1289
1290         case SWM_ARG_ID_FOCUSMAIN:
1291                 winfocus = TAILQ_FIRST(wl);
1292                 break;
1293
1294         default:
1295                 return;
1296         }
1297
1298         if (winfocus == winlostfocus || winfocus == NULL)
1299                 return;
1300
1301         XMapRaised(display, winfocus->id);
1302         focus_win(winfocus);
1303         XSync(display, False);
1304 }
1305
1306 void
1307 cycle_layout(struct swm_region *r, union arg *args)
1308 {
1309         struct workspace        *ws = r->ws;
1310
1311         DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx);
1312
1313         ws->cur_layout++;
1314         if (ws->cur_layout->l_stack == NULL)
1315                 ws->cur_layout = &layouts[0];
1316         ignore_enter = 1;
1317         stack();
1318 }
1319
1320 void
1321 stack_config(struct swm_region *r, union arg *args)
1322 {
1323         struct workspace        *ws = r->ws;
1324
1325         DNPRINTF(SWM_D_STACK, "stack_config for workspace %d (id %d\n",
1326             args->id, ws->idx);
1327
1328         if (ws->cur_layout->l_config != NULL)
1329                 ws->cur_layout->l_config(ws, args->id);
1330
1331         if (args->id != SWM_ARG_ID_STACKINIT);
1332                 stack();
1333 }
1334
1335 void
1336 stack(void) {
1337         struct swm_geometry     g;
1338         struct swm_region       *r;
1339         int                     i, j;
1340
1341         DNPRINTF(SWM_D_STACK, "stack\n");
1342
1343         for (i = 0; i < ScreenCount(display); i++) {
1344                 j = 0;
1345                 TAILQ_FOREACH(r, &screens[i].rl, entry) {
1346                         DNPRINTF(SWM_D_STACK, "stacking workspace %d "
1347                             "(screen %d, region %d)\n", r->ws->idx, i, j++);
1348
1349                         /* start with screen geometry, adjust for bar */
1350                         g = r->g;
1351                         g.w -= 2;
1352                         g.h -= 2;
1353                         if (bar_enabled) {
1354                                 g.y += bar_height;
1355                                 g.h -= bar_height;
1356                         }
1357
1358                         r->ws->restack = 0;
1359                         r->ws->cur_layout->l_stack(r->ws, &g);
1360                 }
1361         }
1362         if (font_adjusted)
1363                 font_adjusted--;
1364         XSync(display, False);
1365 }
1366
1367 void
1368 stack_floater(struct ws_win *win, struct swm_region *r)
1369 {
1370         unsigned int            mask;
1371         XWindowChanges          wc;
1372
1373         bzero(&wc, sizeof wc);
1374         mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight;
1375         if ((win->quirks & SWM_Q_FULLSCREEN) && (win->g.w == WIDTH(r)) &&
1376             (win->g.h == HEIGHT(r)))
1377                 wc.border_width = 0;
1378         else
1379                 wc.border_width = 1;
1380         if (win->transient && (win->quirks & SWM_Q_TRANSSZ)) {
1381                 win->g.w = (double)WIDTH(r) * dialog_ratio;
1382                 win->g.h = (double)HEIGHT(r) * dialog_ratio;
1383         }
1384         wc.width = win->g.w;
1385         wc.height = win->g.h;
1386         if (win->manual) {
1387                 wc.x = win->g.x;
1388                 wc.y = win->g.y;
1389         } else {
1390                 wc.x = (WIDTH(r) - win->g.w) / 2;
1391                 wc.y = (HEIGHT(r) - win->g.h) / 2;
1392         }
1393
1394         DNPRINTF(SWM_D_STACK, "stack_floater: win %lu x %d y %d w %d h %d\n",
1395             win->id, wc.x, wc.y, wc.width, wc.height);
1396
1397         XConfigureWindow(display, win->id, mask, &wc);
1398 }
1399
1400 /*
1401  * Send keystrokes to terminal to decrease/increase the font size as the
1402  * window size changes.
1403  */
1404 void
1405 adjust_font(struct ws_win *win)
1406 {
1407         if (!(win->quirks & SWM_Q_XTERM_FONTADJ) ||
1408             win->floating || win->transient)
1409                 return;
1410
1411         if (win->sh.width_inc && win->last_inc != win->sh.width_inc &&
1412             win->g.w / win->sh.width_inc < term_width &&
1413             win->font_steps < SWM_MAX_FONT_STEPS) {
1414                 win->font_size_boundary[win->font_steps] =
1415                     (win->sh.width_inc * term_width) + win->sh.base_width;
1416                 win->font_steps++;
1417                 font_adjusted++;
1418                 win->last_inc = win->sh.width_inc;
1419                 fake_keypress(win, XK_KP_Subtract, ShiftMask);
1420         } else if (win->font_steps && win->last_inc != win->sh.width_inc &&
1421             win->g.w > win->font_size_boundary[win->font_steps - 1]) {
1422                 win->font_steps--;
1423                 font_adjusted++;
1424                 win->last_inc = win->sh.width_inc;
1425                 fake_keypress(win, XK_KP_Add, ShiftMask);
1426         }
1427 }
1428
1429 #define SWAPXY(g)       do {                            \
1430         int tmp;                                        \
1431         tmp = (g)->y; (g)->y = (g)->x; (g)->x = tmp;    \
1432         tmp = (g)->h; (g)->h = (g)->w; (g)->w = tmp;    \
1433 } while (0)
1434 void
1435 stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
1436 {
1437         XWindowChanges          wc;
1438         struct swm_geometry     win_g, r_g = *g;
1439         struct ws_win           *win, *winfocus;
1440         int                     i, j, s, stacks;
1441         int                     w_inc = 1, h_inc, w_base = 1, h_base;
1442         int                     hrh, extra = 0, h_slice, last_h = 0;
1443         int                     split, colno, winno, mwin, msize, mscale;
1444         int                     remain, missing, v_slice;;
1445         unsigned int            mask;
1446
1447         DNPRINTF(SWM_D_STACK, "stack_master: workspace: %d\n rot=%s flip=%s",
1448             ws->idx, rot ? "yes" : "no", flip ? "yes" : "no");
1449
1450         if ((winno = count_win(ws, 0)) == 0)
1451                 return;
1452
1453         if (ws->focus == NULL)
1454                 ws->focus = TAILQ_FIRST(&ws->winlist);
1455         winfocus = cur_focus ? cur_focus : ws->focus;
1456
1457         TAILQ_FOREACH(win, &ws->winlist, entry)
1458                 if (win->transient == 0 && win->floating == 0)
1459                         break;
1460
1461         if (win == NULL)
1462                 goto notiles;
1463
1464         if (rot) {
1465                 w_inc = win->sh.width_inc;
1466                 w_base = win->sh.base_width;
1467                 mwin = ws->l_state.horizontal_mwin;
1468                 mscale = ws->l_state.horizontal_msize;
1469                 stacks = ws->l_state.horizontal_stacks;
1470                 SWAPXY(&r_g);
1471         } else {
1472                 w_inc = win->sh.height_inc;
1473                 w_base = win->sh.base_height;
1474                 mwin = ws->l_state.vertical_mwin;
1475                 mscale = ws->l_state.vertical_msize;
1476                 stacks = ws->l_state.vertical_stacks;
1477         }
1478         win_g = r_g;
1479
1480         if (stacks > winno - mwin)
1481                 stacks = winno - mwin;
1482         if (stacks < 1)
1483                 stacks = 1;
1484
1485         h_slice = r_g.h / SWM_H_SLICE;
1486         if (mwin && winno > mwin) {
1487                 v_slice = r_g.w / SWM_V_SLICE;
1488
1489                 split = mwin;
1490                 colno = split;
1491                 win_g.w = v_slice * mscale;
1492
1493                 if (w_inc > 1 && w_inc < v_slice) {
1494                         /* adjust for window's requested size increment */
1495                         remain = (win_g.w - w_base) % w_inc;
1496                         missing = w_inc - remain;
1497                         win_g.w -= remain;
1498                         extra += remain;
1499                 }
1500
1501                 msize = win_g.w;
1502                 if (flip)
1503                         win_g.x += r_g.w - msize;
1504         } else {
1505                 msize = -2;
1506                 colno = split = winno / stacks;
1507                 win_g.w = ((r_g.w - (stacks * 2) + 2) / stacks);
1508         }
1509         hrh = r_g.h / colno;
1510         extra = r_g.h - (colno * hrh);
1511         win_g.h = hrh - 2;
1512
1513         /*  stack all the tiled windows */
1514         i = j = 0, s = stacks;
1515         TAILQ_FOREACH(win, &ws->winlist, entry) {
1516                 if (win->transient != 0 || win->floating != 0)
1517                         continue;
1518
1519                 if (split && i == split) {
1520                         colno = (winno - mwin) / stacks;
1521                         if (s <= (winno - mwin) % stacks)
1522                                 colno++;
1523                         split = split + colno;
1524                         hrh = (r_g.h / colno);
1525                         extra = r_g.h - (colno * hrh);
1526                         if (flip)
1527                                 win_g.x = r_g.x;
1528                         else
1529                                 win_g.x += win_g.w + 2;
1530                         win_g.w = (r_g.w - msize - (stacks * 2)) / stacks;
1531                         if (s == 1)
1532                                 win_g.w += (r_g.w - msize - (stacks * 2)) %
1533                                     stacks;
1534                         s--;
1535                         j = 0;
1536                 }
1537                 win_g.h = hrh - 2;
1538                 if (rot) {
1539                         h_inc = win->sh.width_inc;
1540                         h_base = win->sh.base_width;
1541                 } else {
1542                         h_inc = win->sh.height_inc;
1543                         h_base = win->sh.base_height;
1544                 }
1545                 if (j == colno - 1) {
1546                         win_g.h = hrh + extra;
1547                 } else if (h_inc > 1 && h_inc < h_slice) {
1548                         /* adjust for window's requested size increment */
1549                         remain = (win_g.h - h_base) % h_inc;
1550                         missing = h_inc - remain;
1551
1552                         if (missing <= extra || j == 0) {
1553                                 extra -= missing;
1554                                 win_g.h += missing;
1555                         } else {
1556                                 win_g.h -= remain;
1557                                 extra += remain;
1558                         }
1559                 }
1560
1561                 if (j == 0)
1562                         win_g.y = r_g.y;
1563                 else
1564                         win_g.y += last_h + 2;
1565
1566                 bzero(&wc, sizeof wc);
1567                 wc.border_width = 1;
1568                 if (rot) {
1569                         win->g.x = wc.x = win_g.y;
1570                         win->g.y = wc.y = win_g.x;
1571                         win->g.w = wc.width = win_g.h;
1572                         win->g.h = wc.height = win_g.w;
1573                 } else {
1574                         win->g.x = wc.x = win_g.x;
1575                         win->g.y = wc.y = win_g.y;
1576                         win->g.w = wc.width = win_g.w;
1577                         win->g.h = wc.height = win_g.h;
1578                 }
1579                 adjust_font(win);
1580                 mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
1581                 XConfigureWindow(display, win->id, mask, &wc);
1582                 XMapRaised(display, win->id);
1583
1584                 last_h = win_g.h;
1585                 i++;
1586                 j++;
1587         }
1588
1589  notiles:
1590         /* now, stack all the floaters and transients */
1591         TAILQ_FOREACH(win, &ws->winlist, entry) {
1592                 if (win->transient == 0 && win->floating == 0)
1593                         continue;
1594
1595                 stack_floater(win, ws->r);
1596                 XMapRaised(display, win->id);
1597         }
1598
1599         if (winfocus)
1600                 focus_win(winfocus); /* has to be done outside of the loop */
1601 }
1602
1603 void
1604 vertical_config(struct workspace *ws, int id)
1605 {
1606         DNPRINTF(SWM_D_STACK, "vertical_resize: workspace: %d\n", ws->idx);
1607
1608         switch (id) {
1609         case SWM_ARG_ID_STACKRESET:
1610         case SWM_ARG_ID_STACKINIT:
1611                 ws->l_state.vertical_msize = SWM_V_SLICE / 2;
1612                 ws->l_state.vertical_mwin = 1;
1613                 ws->l_state.vertical_stacks = 1;
1614                 break;
1615         case SWM_ARG_ID_MASTERSHRINK:
1616                 if (ws->l_state.vertical_msize > 1)
1617                         ws->l_state.vertical_msize--;
1618                 break;
1619         case SWM_ARG_ID_MASTERGROW:
1620                 if (ws->l_state.vertical_msize < SWM_V_SLICE - 1)
1621                         ws->l_state.vertical_msize++;
1622                 break;
1623         case SWM_ARG_ID_MASTERADD:
1624                 ws->l_state.vertical_mwin++;
1625                 break;
1626         case SWM_ARG_ID_MASTERDEL:
1627                 if (ws->l_state.vertical_mwin > 0)
1628                         ws->l_state.vertical_mwin--;
1629                 break;
1630         case SWM_ARG_ID_STACKINC:
1631                 ws->l_state.vertical_stacks++;
1632                 break;
1633         case SWM_ARG_ID_STACKDEC:
1634                 if (ws->l_state.vertical_stacks > 1)
1635                         ws->l_state.vertical_stacks--;
1636                 break;
1637         default:
1638                 return;
1639         }
1640 }
1641
1642 void
1643 vertical_stack(struct workspace *ws, struct swm_geometry *g)
1644 {
1645         DNPRINTF(SWM_D_STACK, "vertical_stack: workspace: %d\n", ws->idx);
1646
1647         stack_master(ws, g, 0, 0);
1648 }
1649
1650 void
1651 horizontal_config(struct workspace *ws, int id)
1652 {
1653         DNPRINTF(SWM_D_STACK, "horizontal_config: workspace: %d\n", ws->idx);
1654
1655         switch (id) {
1656         case SWM_ARG_ID_STACKRESET:
1657         case SWM_ARG_ID_STACKINIT:
1658                 ws->l_state.horizontal_mwin = 1;
1659                 ws->l_state.horizontal_msize = SWM_H_SLICE / 2;
1660                 ws->l_state.horizontal_stacks = 1;
1661                 break;
1662         case SWM_ARG_ID_MASTERSHRINK:
1663                 if (ws->l_state.horizontal_msize > 1)
1664                         ws->l_state.horizontal_msize--;
1665                 break;
1666         case SWM_ARG_ID_MASTERGROW:
1667                 if (ws->l_state.horizontal_msize < SWM_H_SLICE - 1)
1668                         ws->l_state.horizontal_msize++;
1669                 break;
1670         case SWM_ARG_ID_MASTERADD:
1671                 ws->l_state.horizontal_mwin++;
1672                 break;
1673         case SWM_ARG_ID_MASTERDEL:
1674                 if (ws->l_state.horizontal_mwin > 0)
1675                         ws->l_state.horizontal_mwin--;
1676                 break;
1677         case SWM_ARG_ID_STACKINC:
1678                 ws->l_state.horizontal_stacks++;
1679                 break;
1680         case SWM_ARG_ID_STACKDEC:
1681                 if (ws->l_state.horizontal_stacks > 1)
1682                         ws->l_state.horizontal_stacks--;
1683                 break;
1684         default:
1685                 return;
1686         }
1687 }
1688
1689 void
1690 horizontal_stack(struct workspace *ws, struct swm_geometry *g)
1691 {
1692         DNPRINTF(SWM_D_STACK, "vertical_stack: workspace: %d\n", ws->idx);
1693
1694         stack_master(ws, g, 1, 0);
1695 }
1696
1697 /* fullscreen view */
1698 void
1699 max_stack(struct workspace *ws, struct swm_geometry *g) {
1700         XWindowChanges          wc;
1701         struct swm_geometry     gg = *g;
1702         struct ws_win           *win, *winfocus;
1703         unsigned int            mask;
1704
1705         DNPRINTF(SWM_D_STACK, "max_stack: workspace: %d\n", ws->idx);
1706
1707         if (count_win(ws, 0) == 0)
1708                 return;
1709
1710         if (ws->focus == NULL)
1711                 ws->focus = TAILQ_FIRST(&ws->winlist);
1712         winfocus = cur_focus ? cur_focus : ws->focus;
1713
1714         TAILQ_FOREACH(win, &ws->winlist, entry) {
1715                 if (win->transient != 0 || win->floating != 0) {
1716                         if (win == ws->focus) {
1717                                 /* XXX maximize? */
1718                                 stack_floater(win, ws->r);
1719                                 XMapRaised(display, win->id);
1720                         } else
1721                                 XUnmapWindow(display, win->id);
1722                 } else {
1723                         bzero(&wc, sizeof wc);
1724                         wc.border_width = 1;
1725                         win->g.x = wc.x = gg.x;
1726                         win->g.y = wc.y = gg.y;
1727                         win->g.w = wc.width = gg.w;
1728                         win->g.h = wc.height = gg.h;
1729                         mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
1730                         XConfigureWindow(display, win->id, mask, &wc);
1731
1732                         if (win == ws->focus) {
1733                                 XMapRaised(display, win->id);
1734                         } else
1735                                 XUnmapWindow(display, win->id);
1736                 }
1737         }
1738
1739         if (winfocus)
1740                 focus_win(winfocus); /* has to be done outside of the loop */
1741 }
1742
1743 void
1744 send_to_ws(struct swm_region *r, union arg *args)
1745 {
1746         int                     wsid = args->id;
1747         struct ws_win           *win = cur_focus;
1748         struct workspace        *ws, *nws;
1749         Atom                    ws_idx_atom = 0;
1750         unsigned char           ws_idx_str[SWM_PROPLEN];
1751
1752         if (win == NULL)
1753                 return;
1754
1755         DNPRINTF(SWM_D_MOVE, "send_to_ws: win: %lu\n", win->id);
1756
1757         ws = win->ws;
1758         nws = &win->s->ws[wsid];
1759
1760         XUnmapWindow(display, win->id);
1761
1762         /* find a window to focus */
1763         ws->focus = TAILQ_PREV(win, ws_win_list, entry);
1764         if (ws->focus == NULL)
1765                 ws->focus = TAILQ_FIRST(&ws->winlist);
1766         if (ws->focus == win)
1767                 ws->focus = NULL;
1768
1769         TAILQ_REMOVE(&ws->winlist, win, entry);
1770
1771         TAILQ_INSERT_TAIL(&nws->winlist, win, entry);
1772         win->ws = nws;
1773
1774         /* Try to update the window's workspace property */
1775         ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
1776         if (ws_idx_atom &&
1777             snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < SWM_PROPLEN) {
1778                 DNPRINTF(SWM_D_PROP, "setting property _SWM_WS to %s\n",
1779                     ws_idx_str);
1780                 XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8,
1781                     PropModeReplace, ws_idx_str, SWM_PROPLEN);
1782         }
1783
1784         if (count_win(nws, 1) == 1)
1785                 nws->focus = win;
1786         ws->restack = 1;
1787         nws->restack = 1;
1788
1789         stack();
1790 }
1791
1792 void
1793 wkill(struct swm_region *r, union arg *args)
1794 {
1795         DNPRINTF(SWM_D_MISC, "wkill %d\n", args->id);
1796
1797         if(r->ws->focus == NULL)
1798                 return;
1799
1800         if (args->id == SWM_ARG_ID_KILLWINDOW)
1801                 XKillClient(display, r->ws->focus->id);
1802         else
1803                 if (r->ws->focus->can_delete)
1804                         client_msg(r->ws->focus, adelete);
1805 }
1806
1807 void
1808 screenshot(struct swm_region *r, union arg *args)
1809 {
1810         union arg                       a;
1811
1812         DNPRINTF(SWM_D_MISC, "screenshot\n");
1813
1814         if (ss_enabled == 0)
1815                 return;
1816
1817         switch (args->id) {
1818         case SWM_ARG_ID_SS_ALL:
1819                 spawn_screenshot[1] = "full";
1820                 break;
1821         case SWM_ARG_ID_SS_WINDOW:
1822                 spawn_screenshot[1] = "window";
1823                 break;
1824         default:
1825                 return;
1826         }
1827         a.argv = spawn_screenshot;
1828         spawn(r, &a);
1829 }
1830
1831 void
1832 floating_toggle(struct swm_region *r, union arg *args)
1833 {
1834         struct ws_win   *win = cur_focus;
1835
1836         if (win == NULL)
1837                 return;
1838
1839         win->floating = !win->floating;
1840         win->manual = 0;
1841         stack();
1842         focus_win(win);
1843 }
1844
1845 /* key definitions */
1846 struct key {
1847         unsigned int            mod;
1848         KeySym                  keysym;
1849         void                    (*func)(struct swm_region *r, union arg *);
1850         union arg               args;
1851 } keys[] = {
1852         /* modifier             key     function                argument */
1853         { MODKEY,               XK_space,       cycle_layout,   {0} },
1854         { MODKEY | ShiftMask,   XK_space,       stack_config,   {.id = SWM_ARG_ID_STACKRESET} },
1855         { MODKEY,               XK_h,           stack_config,   {.id = SWM_ARG_ID_MASTERSHRINK} },
1856         { MODKEY,               XK_l,           stack_config,   {.id = SWM_ARG_ID_MASTERGROW} },
1857         { MODKEY,               XK_comma,       stack_config,   {.id = SWM_ARG_ID_MASTERADD} },
1858         { MODKEY,               XK_period,      stack_config,   {.id = SWM_ARG_ID_MASTERDEL} },
1859         { MODKEY | ShiftMask,   XK_comma,       stack_config,   {.id = SWM_ARG_ID_STACKINC} },
1860         { MODKEY | ShiftMask,   XK_period,      stack_config,   {.id = SWM_ARG_ID_STACKDEC} },
1861         { MODKEY,               XK_Return,      swapwin,        {.id = SWM_ARG_ID_SWAPMAIN} },
1862         { MODKEY,               XK_j,           focus,          {.id = SWM_ARG_ID_FOCUSNEXT} },
1863         { MODKEY,               XK_k,           focus,          {.id = SWM_ARG_ID_FOCUSPREV} },
1864         { MODKEY | ShiftMask,   XK_j,           swapwin,        {.id = SWM_ARG_ID_SWAPNEXT} },
1865         { MODKEY | ShiftMask,   XK_k,           swapwin,        {.id = SWM_ARG_ID_SWAPPREV} },
1866         { MODKEY | ShiftMask,   XK_Return,      spawnterm,      {.argv = spawn_term} },
1867         { MODKEY,               XK_p,           spawnmenu,      {.argv = spawn_menu} },
1868         { MODKEY | ShiftMask,   XK_q,           quit,           {0} },
1869         { MODKEY,               XK_q,           restart,        {0} },
1870         { MODKEY,               XK_m,           focus,          {.id = SWM_ARG_ID_FOCUSMAIN} },
1871         { MODKEY,               XK_1,           switchws,       {.id = 0} },
1872         { MODKEY,               XK_2,           switchws,       {.id = 1} },
1873         { MODKEY,               XK_3,           switchws,       {.id = 2} },
1874         { MODKEY,               XK_4,           switchws,       {.id = 3} },
1875         { MODKEY,               XK_5,           switchws,       {.id = 4} },
1876         { MODKEY,               XK_6,           switchws,       {.id = 5} },
1877         { MODKEY,               XK_7,           switchws,       {.id = 6} },
1878         { MODKEY,               XK_8,           switchws,       {.id = 7} },
1879         { MODKEY,               XK_9,           switchws,       {.id = 8} },
1880         { MODKEY,               XK_0,           switchws,       {.id = 9} },
1881         { MODKEY,               XK_Right,       cyclews,        {.id = SWM_ARG_ID_CYCLEWS_UP} },
1882         { MODKEY,               XK_Left,        cyclews,        {.id = SWM_ARG_ID_CYCLEWS_DOWN} },
1883         { MODKEY | ShiftMask,   XK_Right,       cyclescr,       {.id = SWM_ARG_ID_CYCLESC_UP} },
1884         { MODKEY | ShiftMask,   XK_Left,        cyclescr,       {.id = SWM_ARG_ID_CYCLESC_DOWN} },
1885         { MODKEY | ShiftMask,   XK_1,           send_to_ws,     {.id = 0} },
1886         { MODKEY | ShiftMask,   XK_2,           send_to_ws,     {.id = 1} },
1887         { MODKEY | ShiftMask,   XK_3,           send_to_ws,     {.id = 2} },
1888         { MODKEY | ShiftMask,   XK_4,           send_to_ws,     {.id = 3} },
1889         { MODKEY | ShiftMask,   XK_5,           send_to_ws,     {.id = 4} },
1890         { MODKEY | ShiftMask,   XK_6,           send_to_ws,     {.id = 5} },
1891         { MODKEY | ShiftMask,   XK_7,           send_to_ws,     {.id = 6} },
1892         { MODKEY | ShiftMask,   XK_8,           send_to_ws,     {.id = 7} },
1893         { MODKEY | ShiftMask,   XK_9,           send_to_ws,     {.id = 8} },
1894         { MODKEY | ShiftMask,   XK_0,           send_to_ws,     {.id = 9} },
1895         { MODKEY,               XK_b,           bar_toggle,     {0} },
1896         { MODKEY,               XK_Tab,         focus,          {.id = SWM_ARG_ID_FOCUSNEXT} },
1897         { MODKEY | ShiftMask,   XK_Tab,         focus,          {.id = SWM_ARG_ID_FOCUSPREV} },
1898         { MODKEY | ShiftMask,   XK_x,           wkill,          {.id = SWM_ARG_ID_KILLWINDOW} },
1899         { MODKEY,               XK_x,           wkill,          {.id = SWM_ARG_ID_DELETEWINDOW} },
1900         { MODKEY,               XK_s,           screenshot,     {.id = SWM_ARG_ID_SS_ALL} },
1901         { MODKEY | ShiftMask,   XK_s,           screenshot,     {.id = SWM_ARG_ID_SS_WINDOW} },
1902         { MODKEY,               XK_t,           floating_toggle,{0} },
1903         { MODKEY | ShiftMask,   XK_v,           version,        {0} },
1904         { MODKEY | ShiftMask,   XK_Delete,      spawn,          {.argv = spawn_lock} },
1905         { MODKEY | ShiftMask,   XK_i,           spawn,          {.argv = spawn_initscr} },
1906 };
1907
1908 void
1909 resize_window(struct ws_win *win, int center)
1910 {
1911         unsigned int            mask;
1912         XWindowChanges          wc;
1913         struct swm_region       *r;
1914
1915         r = root_to_region(win->wa.root);
1916         bzero(&wc, sizeof wc);
1917         mask = CWBorderWidth | CWWidth | CWHeight;
1918         wc.border_width = 1;
1919         wc.width = win->g.w;
1920         wc.height = win->g.h;
1921         if (center == SWM_ARG_ID_CENTER) {
1922                 wc.x = (WIDTH(r) - win->g.w) / 2;
1923                 wc.y = (HEIGHT(r) - win->g.h) / 2;
1924                 mask |= CWX | CWY;
1925         }
1926
1927         DNPRINTF(SWM_D_STACK, "resize_window: win %lu x %d y %d w %d h %d\n",
1928             win->id, wc.x, wc.y, wc.width, wc.height);
1929
1930         XConfigureWindow(display, win->id, mask, &wc);
1931         config_win(win);
1932 }
1933
1934 void
1935 resize(struct ws_win *win, union arg *args)
1936 {
1937         XEvent                  ev;
1938         Time                    time = 0;
1939
1940         DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %d\n",
1941             win->id, win->floating, win->transient);
1942
1943         if (!(win->transient != 0 || win->floating != 0))
1944                 return;
1945
1946         if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
1947             GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
1948                 return;
1949         XWarpPointer(display, None, win->id, 0, 0, 0, 0, win->g.w, win->g.h);
1950         do {
1951                 XMaskEvent(display, MOUSEMASK | ExposureMask |
1952                     SubstructureRedirectMask, &ev);
1953                 switch(ev.type) {
1954                 case ConfigureRequest:
1955                 case Expose:
1956                 case MapRequest:
1957                         handler[ev.type](&ev);
1958                         break;
1959                 case MotionNotify:
1960                         if (ev.xmotion.x <= 1)
1961                                 ev.xmotion.x = 1;
1962                         if (ev.xmotion.y <= 1)
1963                                 ev.xmotion.y = 1;
1964                         win->g.w = ev.xmotion.x;
1965                         win->g.h = ev.xmotion.y;
1966
1967                         /* not free, don't sync more than 60 times / second */
1968                         if ((ev.xmotion.time - time) > (1000 / 60) ) {
1969                                 time = ev.xmotion.time;
1970                                 XSync(display, False);
1971                                 resize_window(win, args->id);
1972                         }
1973                         break;
1974                 }
1975         } while (ev.type != ButtonRelease);
1976         if (time) {
1977                 XSync(display, False);
1978                 resize_window(win, args->id);
1979         }
1980         XWarpPointer(display, None, win->id, 0, 0, 0, 0, win->g.w - 1,
1981             win->g.h - 1);
1982         XUngrabPointer(display, CurrentTime);
1983
1984         /* drain events */
1985         while (XCheckMaskEvent(display, EnterWindowMask, &ev));
1986 }
1987
1988 void
1989 move_window(struct ws_win *win)
1990 {
1991         unsigned int            mask;
1992         XWindowChanges          wc;
1993         struct swm_region       *r;
1994
1995         r = root_to_region(win->wa.root);
1996         bzero(&wc, sizeof wc);
1997         mask = CWX | CWY;
1998         wc.x = win->g.x;
1999         wc.y = win->g.y;
2000
2001         DNPRINTF(SWM_D_STACK, "move_window: win %lu x %d y %d w %d h %d\n",
2002             win->id, wc.x, wc.y, wc.width, wc.height);
2003
2004         XConfigureWindow(display, win->id, mask, &wc);
2005         config_win(win);
2006 }
2007
2008 void
2009 move(struct ws_win *win, union arg *args)
2010 {
2011         XEvent                  ev;
2012         Time                    time = 0;
2013         int                     restack = 0;
2014
2015         DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %d\n",
2016             win->id, win->floating, win->transient);
2017
2018         if (win->floating == 0) {
2019                 win->floating = 1;
2020                 win->manual = 1;
2021                 restack = 1;
2022         }
2023
2024         if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
2025             GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
2026                 return;
2027         XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0);
2028         do {
2029                 XMaskEvent(display, MOUSEMASK | ExposureMask |
2030                     SubstructureRedirectMask, &ev);
2031                 switch(ev.type) {
2032                 case ConfigureRequest:
2033                 case Expose:
2034                 case MapRequest:
2035                         handler[ev.type](&ev);
2036                         break;
2037                 case MotionNotify:
2038                         win->g.x = ev.xmotion.x_root;
2039                         win->g.y = ev.xmotion.y_root;
2040
2041                         /* not free, don't sync more than 60 times / second */
2042                         if ((ev.xmotion.time - time) > (1000 / 60) ) {
2043                                 time = ev.xmotion.time;
2044                                 XSync(display, False);
2045                                 move_window(win);
2046                         }
2047                         break;
2048                 }
2049         } while (ev.type != ButtonRelease);
2050         if (time) {
2051                 XSync(display, False);
2052                 move_window(win);
2053         }
2054         XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0);
2055         XUngrabPointer(display, CurrentTime);
2056         if (restack)
2057                 stack();
2058
2059         /* drain events */
2060         while (XCheckMaskEvent(display, EnterWindowMask, &ev));
2061 }
2062
2063 /* mouse */
2064 enum { client_click, root_click };
2065 struct button {
2066         unsigned int            action;
2067         unsigned int            mask;
2068         unsigned int            button;
2069         void                    (*func)(struct ws_win *, union arg *);
2070         union arg               args;
2071 } buttons[] = {
2072           /* action             key             mouse button    func            args */
2073         { client_click,         MODKEY,         Button3,        resize,         {.id = SWM_ARG_ID_DONTCENTER} },
2074         { client_click,         MODKEY | ShiftMask, Button3,    resize,         {.id = SWM_ARG_ID_CENTER} },
2075         { client_click,         MODKEY,         Button1,        move,           {0} },
2076 };
2077
2078 void
2079 updatenumlockmask(void)
2080 {
2081         unsigned int            i, j;
2082         XModifierKeymap         *modmap;
2083
2084         DNPRINTF(SWM_D_MISC, "updatenumlockmask\n");
2085         numlockmask = 0;
2086         modmap = XGetModifierMapping(display);
2087         for (i = 0; i < 8; i++)
2088                 for (j = 0; j < modmap->max_keypermod; j++)
2089                         if (modmap->modifiermap[i * modmap->max_keypermod + j]
2090                           == XKeysymToKeycode(display, XK_Num_Lock))
2091                                 numlockmask = (1 << i);
2092
2093         XFreeModifiermap(modmap);
2094 }
2095
2096 void
2097 grabkeys(void)
2098 {
2099         unsigned int            i, j, k;
2100         KeyCode                 code;
2101         unsigned int            modifiers[] =
2102             { 0, LockMask, numlockmask, numlockmask | LockMask };
2103
2104         DNPRINTF(SWM_D_MISC, "grabkeys\n");
2105         updatenumlockmask();
2106
2107         for (k = 0; k < ScreenCount(display); k++) {
2108                 if (TAILQ_EMPTY(&screens[k].rl))
2109                         continue;
2110                 XUngrabKey(display, AnyKey, AnyModifier, screens[k].root);
2111                 for (i = 0; i < LENGTH(keys); i++) {
2112                         if ((code = XKeysymToKeycode(display, keys[i].keysym)))
2113                                 for (j = 0; j < LENGTH(modifiers); j++)
2114                                         XGrabKey(display, code,
2115                                             keys[i].mod | modifiers[j],
2116                                             screens[k].root, True,
2117                                             GrabModeAsync, GrabModeAsync);
2118                 }
2119         }
2120 }
2121
2122 void
2123 grabbuttons(struct ws_win *win, int focused)
2124 {
2125         unsigned int            i, j;
2126         unsigned int            modifiers[] =
2127             { 0, LockMask, numlockmask, numlockmask|LockMask };
2128
2129         updatenumlockmask();
2130         XUngrabButton(display, AnyButton, AnyModifier, win->id);
2131         if(focused) {
2132                 for (i = 0; i < LENGTH(buttons); i++)
2133                         if (buttons[i].action == client_click)
2134                                 for (j = 0; j < LENGTH(modifiers); j++)
2135                                         XGrabButton(display, buttons[i].button,
2136                                             buttons[i].mask | modifiers[j],
2137                                             win->id, False, BUTTONMASK,
2138                                             GrabModeAsync, GrabModeSync, None,
2139                                             None);
2140         } else
2141                 XGrabButton(display, AnyButton, AnyModifier, win->id, False,
2142                     BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
2143 }
2144
2145 void
2146 expose(XEvent *e)
2147 {
2148         DNPRINTF(SWM_D_EVENT, "expose: window: %lu\n", e->xexpose.window);
2149 }
2150
2151 void
2152 keypress(XEvent *e)
2153 {
2154         unsigned int            i;
2155         KeySym                  keysym;
2156         XKeyEvent               *ev = &e->xkey;
2157
2158         DNPRINTF(SWM_D_EVENT, "keypress: window: %lu\n", ev->window);
2159
2160         keysym = XKeycodeToKeysym(display, (KeyCode)ev->keycode, 0);
2161         for (i = 0; i < LENGTH(keys); i++)
2162                 if (keysym == keys[i].keysym
2163                    && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
2164                    && keys[i].func)
2165                         keys[i].func(root_to_region(ev->root),
2166                             &(keys[i].args));
2167 }
2168
2169 void
2170 buttonpress(XEvent *e)
2171 {
2172         XButtonPressedEvent     *ev = &e->xbutton;
2173
2174         struct ws_win           *win;
2175         int                     i, action;
2176
2177         DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window);
2178
2179         action = root_click;
2180         if ((win = find_window(ev->window)) == NULL)
2181                 return;
2182         else {
2183                 focus_win(win);
2184                 action = client_click;
2185         }
2186
2187         for (i = 0; i < LENGTH(buttons); i++)
2188                 if (action == buttons[i].action && buttons[i].func &&
2189                     buttons[i].button == ev->button &&
2190                     CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))
2191                         buttons[i].func(win, &buttons[i].args);
2192 }
2193
2194 void
2195 set_win_state(struct ws_win *win, long state)
2196 {
2197         long                    data[] = {state, None};
2198
2199         DNPRINTF(SWM_D_EVENT, "set_win_state: window: %lu\n", win->id);
2200
2201         XChangeProperty(display, win->id, astate, astate, 32, PropModeReplace,
2202             (unsigned char *)data, 2);
2203 }
2204
2205 struct ws_win *
2206 manage_window(Window id)
2207 {
2208         Window                  trans;
2209         struct workspace        *ws;
2210         struct ws_win           *win;
2211         int                     format, i, ws_idx, n;
2212         unsigned long           nitems, bytes;
2213         Atom                    ws_idx_atom = 0, type;
2214         Atom                    *prot = NULL, *pp;
2215         unsigned char           ws_idx_str[SWM_PROPLEN], *prop = NULL;
2216         struct swm_region       *r;
2217         long                    mask;
2218         const char              *errstr;
2219         XWindowChanges          wc;
2220
2221         if ((win = find_window(id)) != NULL)
2222                         return (win);   /* already being managed */
2223
2224         if ((win = calloc(1, sizeof(struct ws_win))) == NULL)
2225                 errx(1, "calloc: failed to allocate memory for new window");
2226
2227         /* Get all the window data in one shot */
2228         ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
2229         if (ws_idx_atom)
2230                 XGetWindowProperty(display, id, ws_idx_atom, 0, SWM_PROPLEN,
2231                     False, XA_STRING, &type, &format, &nitems, &bytes, &prop);
2232         XGetWindowAttributes(display, id, &win->wa);
2233         XGetTransientForHint(display, id, &trans);
2234         XGetWMNormalHints(display, id, &win->sh, &mask); /* XXX function? */
2235         if (trans) {
2236                 win->transient = trans;
2237                 DNPRINTF(SWM_D_MISC, "manage_window: win %u transient %u\n",
2238                     (unsigned)win->id, win->transient);
2239         }
2240         /* get supported protocols */
2241         if (XGetWMProtocols(display, id, &prot, &n)) {
2242                 for (i = 0, pp = prot; i < n; i++, pp++)
2243                         if (*pp == adelete)
2244                                 win->can_delete = 1;
2245                 if (prot)
2246                         XFree(prot);
2247         }
2248
2249         /*
2250          * Figure out where to put the window. If it was previously assigned to
2251          * a workspace (either by spawn() or manually moving), and isn't
2252          * transient, * put it in the same workspace
2253          */
2254         r = root_to_region(win->wa.root);
2255         if (prop && win->transient == 0) {
2256                 DNPRINTF(SWM_D_PROP, "got property _SWM_WS=%s\n", prop);
2257                 ws_idx = strtonum(prop, 0, 9, &errstr);
2258                 if (errstr) {
2259                         DNPRINTF(SWM_D_EVENT, "window idx is %s: %s",
2260                             errstr, prop);
2261                 }
2262                 ws = &r->s->ws[ws_idx];
2263         } else
2264                 ws = r->ws;
2265
2266         /* set up the window layout */
2267         win->id = id;
2268         win->ws = ws;
2269         win->s = r->s;  /* this never changes */
2270         TAILQ_INSERT_TAIL(&ws->winlist, win, entry);
2271
2272         win->g.w = win->wa.width;
2273         win->g.h = win->wa.height;
2274         win->g.x = win->wa.x;
2275         win->g.y = win->wa.y;
2276
2277         /* Set window properties so we can remember this after reincarnation */
2278         if (ws_idx_atom && prop == NULL &&
2279             snprintf(ws_idx_str, SWM_PROPLEN, "%d", ws->idx) < SWM_PROPLEN) {
2280                 DNPRINTF(SWM_D_PROP, "setting property _SWM_WS to %s\n",
2281                     ws_idx_str);
2282                 XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8,
2283                     PropModeReplace, ws_idx_str, SWM_PROPLEN);
2284         }
2285         XFree(prop);
2286
2287         if (XGetClassHint(display, win->id, &win->ch)) {
2288                 DNPRINTF(SWM_D_CLASS, "class: %s name: %s\n",
2289                     win->ch.res_class, win->ch.res_name);
2290                 for (i = 0; quirks[i].class != NULL && quirks[i].name != NULL &&
2291                     quirks[i].quirk != 0; i++){
2292                         if (!strcmp(win->ch.res_class, quirks[i].class) &&
2293                             !strcmp(win->ch.res_name, quirks[i].name)) {
2294                                 DNPRINTF(SWM_D_CLASS, "found: %s name: %s\n",
2295                                     win->ch.res_class, win->ch.res_name);
2296                                 if (quirks[i].quirk & SWM_Q_FLOAT)
2297                                         win->floating = 1;
2298                                 win->quirks = quirks[i].quirk;
2299                         }
2300                 }
2301         }
2302
2303         /* alter window position if quirky */
2304         if (win->quirks & SWM_Q_ANYWHERE) {
2305                 win->manual = 1; /* don't center the quirky windows */
2306                 bzero(&wc, sizeof wc);
2307                 mask = 0;
2308                 if (win->g.y < bar_height) {
2309                         win->g.y = wc.y = bar_height;
2310                         mask |= CWY;
2311                 }
2312                 if (win->g.w + win->g.x > WIDTH(r)) {
2313                         win->g.x = wc.x = WIDTH(win->ws->r) - win->g.w - 2;
2314                         mask |= CWX;
2315                 }
2316                 wc.border_width = 1;
2317                 mask |= CWBorderWidth;
2318                 XConfigureWindow(display, win->id, mask, &wc);
2319         }
2320
2321         /* Reset font sizes (the bruteforce way; no default keybinding). */
2322         if (win->quirks & SWM_Q_XTERM_FONTADJ) {
2323                 for (i = 0; i < SWM_MAX_FONT_STEPS; i++)
2324                         fake_keypress(win, XK_KP_Subtract, ShiftMask);
2325                 for (i = 0; i < SWM_MAX_FONT_STEPS; i++)
2326                         fake_keypress(win, XK_KP_Add, ShiftMask);
2327         }
2328
2329         XSelectInput(display, id, EnterWindowMask | FocusChangeMask |
2330             PropertyChangeMask | StructureNotifyMask);
2331
2332         set_win_state(win, NormalState);
2333
2334         /* floaters need to be mapped if they are in the current workspace */
2335         if (win->floating && (ws->idx == r->ws->idx))
2336                 XMapRaised(display, win->id);
2337
2338         /* make new win focused */
2339         focus_win(win);
2340
2341         return (win);
2342 }
2343
2344 void
2345 unmanage_window(struct ws_win *win)
2346 {
2347         struct workspace        *ws;
2348
2349         if (win == NULL)
2350                 return;
2351
2352         DNPRINTF(SWM_D_MISC, "unmanage_window:  %lu\n", win->id);
2353
2354         /* don't unmanage if we are switching workspaces */
2355         ws = win->ws;
2356         if (ws->restack)
2357                 return;
2358
2359         /* find a window to focus */
2360         if (ws->focus == win)
2361                 ws->focus = TAILQ_PREV(win, ws_win_list, entry);
2362         if (ws->focus == NULL)
2363                 ws->focus = TAILQ_FIRST(&ws->winlist);
2364         if (ws->focus == NULL || ws->focus == win) {
2365                 ws->focus = NULL;
2366                 unfocus_all();
2367         } else
2368                 focus_win(ws->focus);
2369         if (ws->focus_prev == win)
2370                 ws->focus_prev = NULL;
2371
2372         TAILQ_REMOVE(&win->ws->winlist, win, entry);
2373         set_win_state(win, WithdrawnState);
2374         if (win->ch.res_class)
2375                 XFree(win->ch.res_class);
2376         if (win->ch.res_name)
2377                 XFree(win->ch.res_name);
2378         free(win);
2379 }
2380
2381 void
2382 configurerequest(XEvent *e)
2383 {
2384         XConfigureRequestEvent  *ev = &e->xconfigurerequest;
2385         struct ws_win           *win;
2386         int                     new = 0;
2387         XWindowChanges          wc;
2388
2389         if ((win = find_window(ev->window)) == NULL)
2390                 new = 1;
2391
2392         if (new) {
2393                 DNPRINTF(SWM_D_EVENT, "configurerequest: new window: %lu\n",
2394                     ev->window);
2395                 bzero(&wc, sizeof wc);
2396                 wc.x = ev->x;
2397                 wc.y = ev->y;
2398                 wc.width = ev->width;
2399                 wc.height = ev->height;
2400                 wc.border_width = ev->border_width;
2401                 wc.sibling = ev->above;
2402                 wc.stack_mode = ev->detail;
2403                 XConfigureWindow(display, ev->window, ev->value_mask, &wc);
2404         } else {
2405                 DNPRINTF(SWM_D_EVENT, "configurerequest: change window: %lu\n",
2406                     ev->window);
2407                 if (win->floating) {
2408                         if (ev->value_mask & CWX)
2409                                 win->g.x = ev->x;
2410                         if (ev->value_mask & CWY)
2411                                 win->g.y = ev->y;
2412                         if (ev->value_mask & CWWidth)
2413                                 win->g.w = ev->width;
2414                         if (ev->value_mask & CWHeight)
2415                                 win->g.h = ev->height;
2416                         if (win->ws->r != NULL) {
2417                                 /* this seems to be full screen */
2418                                 if (win->g.w >= WIDTH(win->ws->r)) {
2419                                         win->g.x = 0;
2420                                         win->g.w = WIDTH(win->ws->r);
2421                                         ev->value_mask |= CWX | CWWidth;
2422                                 }
2423                                 if (win->g.h >= HEIGHT(win->ws->r)) {
2424                                         /* kill border */
2425                                         win->g.y = 0;
2426                                         win->g.h = HEIGHT(win->ws->r);
2427                                         ev->value_mask |= CWY | CWHeight;
2428                                 }
2429                         }
2430                         if ((ev->value_mask & (CWX | CWY)) &&
2431                             !(ev->value_mask & (CWWidth | CWHeight)))
2432                                 config_win(win);
2433                         XMoveResizeWindow(display, win->id,
2434                             win->g.x, win->g.y, win->g.w, win->g.h);
2435                 } else
2436                         config_win(win);
2437         }
2438 }
2439
2440 void
2441 configurenotify(XEvent *e)
2442 {
2443         struct ws_win           *win;
2444         long                    mask;
2445
2446         DNPRINTF(SWM_D_EVENT, "configurenotify: window: %lu\n",
2447             e->xconfigure.window);
2448
2449         win = find_window(e->xconfigure.window);
2450         XMapWindow(display, win->id);
2451         XGetWMNormalHints(display, win->id, &win->sh, &mask);
2452         adjust_font(win);
2453         XMapWindow(display, win->id);
2454         if (font_adjusted)
2455                 stack();
2456 }
2457
2458 void
2459 destroynotify(XEvent *e)
2460 {
2461         struct ws_win           *win;
2462         XDestroyWindowEvent     *ev = &e->xdestroywindow;
2463
2464         DNPRINTF(SWM_D_EVENT, "destroynotify: window %lu\n", ev->window);
2465
2466         if ((win = find_window(ev->window)) != NULL) {
2467                 unmanage_window(win);
2468                 stack();
2469         }
2470 }
2471
2472 void
2473 enternotify(XEvent *e)
2474 {
2475         XCrossingEvent          *ev = &e->xcrossing;
2476         struct ws_win           *win;
2477
2478         DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window);
2479
2480         if (ignore_enter) {
2481                 /* eat event(r) to prevent autofocus */
2482                 ignore_enter--;
2483                 return;
2484         }
2485
2486         if ((win = find_window(ev->window)) != NULL)
2487                 focus_win(win);
2488 }
2489
2490 void
2491 focusin(XEvent *e)
2492 {
2493         DNPRINTF(SWM_D_EVENT, "focusin: window: %lu\n", e->xfocus.window);
2494 }
2495
2496 void
2497 mappingnotify(XEvent *e)
2498 {
2499         XMappingEvent           *ev = &e->xmapping;
2500
2501         DNPRINTF(SWM_D_EVENT, "mappingnotify: window: %lu\n", ev->window);
2502
2503         XRefreshKeyboardMapping(ev);
2504         if (ev->request == MappingKeyboard)
2505                 grabkeys();
2506 }
2507
2508 void
2509 maprequest(XEvent *e)
2510 {
2511         XMapRequestEvent        *ev = &e->xmaprequest;
2512         XWindowAttributes       wa;
2513
2514         DNPRINTF(SWM_D_EVENT, "maprequest: window: %lu\n",
2515             e->xmaprequest.window);
2516
2517         if (!XGetWindowAttributes(display, ev->window, &wa))
2518                 return;
2519         if (wa.override_redirect)
2520                 return;
2521         manage_window(e->xmaprequest.window);
2522
2523         stack();
2524 }
2525
2526 void
2527 propertynotify(XEvent *e)
2528 {
2529         struct ws_win           *win;
2530         XPropertyEvent          *ev = &e->xproperty;
2531
2532         DNPRINTF(SWM_D_EVENT, "propertynotify: window: %lu\n",
2533             ev->window);
2534
2535         if (ev->state == PropertyDelete)
2536                 return; /* ignore */
2537         win = find_window(ev->window);
2538         if (win == NULL)
2539                 return;
2540
2541         switch (ev->atom) {
2542         case XA_WM_NORMAL_HINTS:
2543 #if 0
2544                 long            mask;
2545                 XGetWMNormalHints(display, win->id, &win->sh, &mask);
2546                 fprintf(stderr, "normal hints: flag 0x%x\n", win->sh.flags);
2547                 if (win->sh.flags & PMinSize) {
2548                         win->g.w = win->sh.min_width;
2549                         win->g.h = win->sh.min_height;
2550                         fprintf(stderr, "min %d %d\n", win->g.w, win->g.h);
2551                 }
2552                 XMoveResizeWindow(display, win->id,
2553                     win->g.x, win->g.y, win->g.w, win->g.h);
2554 #endif
2555                 break;
2556         default:
2557                 break;
2558         }
2559 }
2560
2561 void
2562 unmapnotify(XEvent *e)
2563 {
2564         XDestroyWindowEvent     *ev = &e->xdestroywindow;
2565         struct ws_win           *win;
2566
2567         DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window);
2568
2569         if ((win = find_window(ev->window)) != NULL)
2570                 if (win->transient)
2571                         unmanage_window(win);
2572 }
2573
2574 void
2575 visibilitynotify(XEvent *e)
2576 {
2577         int                     i;
2578         struct swm_region       *r;
2579
2580         DNPRINTF(SWM_D_EVENT, "visibilitynotify: window: %lu\n",
2581             e->xvisibility.window);
2582         if (e->xvisibility.state == VisibilityUnobscured)
2583                 for (i = 0; i < ScreenCount(display); i++)
2584                         TAILQ_FOREACH(r, &screens[i].rl, entry)
2585                                 if (e->xvisibility.window == r->bar_window)
2586                                         bar_update();
2587 }
2588
2589 int
2590 xerror_start(Display *d, XErrorEvent *ee)
2591 {
2592         other_wm = 1;
2593         return (-1);
2594 }
2595
2596 int
2597 xerror(Display *d, XErrorEvent *ee)
2598 {
2599         /* fprintf(stderr, "error: %p %p\n", display, ee); */
2600         return (-1);
2601 }
2602
2603 int
2604 active_wm(void)
2605 {
2606         other_wm = 0;
2607         xerrorxlib = XSetErrorHandler(xerror_start);
2608
2609         /* this causes an error if some other window manager is running */
2610         XSelectInput(display, DefaultRootWindow(display),
2611             SubstructureRedirectMask);
2612         XSync(display, False);
2613         if (other_wm)
2614                 return (1);
2615
2616         XSetErrorHandler(xerror);
2617         XSync(display, False);
2618         return (0);
2619 }
2620
2621 long
2622 getstate(Window w)
2623 {
2624         int                     format, status;
2625         long                    result = -1;
2626         unsigned char           *p = NULL;
2627         unsigned long           n, extra;
2628         Atom                    real;
2629
2630         status = XGetWindowProperty(display, w, astate, 0L, 2L, False, astate,
2631             &real, &format, &n, &extra, (unsigned char **)&p);
2632         if (status != Success)
2633                 return (-1);
2634         if (n != 0)
2635                 result = *((long *)p);
2636         XFree(p);
2637         return (result);
2638 }
2639
2640 void
2641 new_region(struct swm_screen *s, int x, int y, int w, int h)
2642 {
2643         struct swm_region       *r, *n;
2644         struct workspace        *ws = NULL;
2645         int                     i;
2646
2647         DNPRINTF(SWM_D_MISC, "new region: screen[%d]:%dx%d+%d+%d\n",
2648              s->idx, w, h, x, y);
2649
2650         /* remove any conflicting regions */
2651         n = TAILQ_FIRST(&s->rl);
2652         while (n) {
2653                 r = n;
2654                 n = TAILQ_NEXT(r, entry);
2655                 if (X(r) < (x + w) &&
2656                     (X(r) + WIDTH(r)) > x &&
2657                     Y(r) < (y + h) &&
2658                     (Y(r) + HEIGHT(r)) > y) {
2659                         XDestroyWindow(display, r->bar_window);
2660                         TAILQ_REMOVE(&s->rl, r, entry);
2661                         TAILQ_INSERT_TAIL(&s->orl, r, entry);
2662                 }
2663         }
2664
2665         /* search old regions for one to reuse */
2666
2667         /* size + location match */
2668         TAILQ_FOREACH(r, &s->orl, entry)
2669                 if (X(r) == x && Y(r) == y &&
2670                     HEIGHT(r) == h && WIDTH(r) == w)
2671                         break;
2672
2673         /* size match */
2674         TAILQ_FOREACH(r, &s->orl, entry)
2675                 if (HEIGHT(r) == h && WIDTH(r) == w)
2676                         break;
2677
2678         if (r != NULL) {
2679                 TAILQ_REMOVE(&s->orl, r, entry);
2680                 /* try to use old region's workspace */
2681                 if (r->ws->r == NULL)
2682                         ws = r->ws;
2683         } else
2684                 if ((r = calloc(1, sizeof(struct swm_region))) == NULL)
2685                         errx(1, "calloc: failed to allocate memory for screen");
2686
2687         /* if we don't have a workspace already, find one */
2688         if (ws == NULL) {
2689                 for (i = 0; i < SWM_WS_MAX; i++)
2690                         if (s->ws[i].r == NULL) {
2691                                 ws = &s->ws[i];
2692                                 break;
2693                         }
2694         }
2695
2696         if (ws == NULL)
2697                 errx(1, "no free workspaces\n");
2698
2699         X(r) = x;
2700         Y(r) = y;
2701         WIDTH(r) = w;
2702         HEIGHT(r) = h;
2703         r->s = s;
2704         r->ws = ws;
2705         ws->r = r;
2706         TAILQ_INSERT_TAIL(&s->rl, r, entry);
2707 }
2708
2709 void
2710 scan_xrandr(int i)
2711 {
2712 #ifdef SWM_XRR_HAS_CRTC
2713         XRRCrtcInfo             *ci;
2714         XRRScreenResources      *sr;
2715         int                     c;
2716         int                     ncrtc = 0;
2717 #endif /* SWM_XRR_HAS_CRTC */
2718         struct swm_region       *r;
2719
2720
2721         if (i >= ScreenCount(display))
2722                 errx(1, "invalid screen");
2723
2724         /* remove any old regions */
2725         while ((r = TAILQ_FIRST(&screens[i].rl)) != NULL) {
2726                 r->ws->r = NULL;
2727                 XDestroyWindow(display, r->bar_window);
2728                 TAILQ_REMOVE(&screens[i].rl, r, entry);
2729                 TAILQ_INSERT_TAIL(&screens[i].orl, r, entry);
2730         }
2731
2732         /* map virtual screens onto physical screens */
2733 #ifdef SWM_XRR_HAS_CRTC
2734         if (xrandr_support) {
2735                 sr = XRRGetScreenResources(display, screens[i].root);
2736                 if (sr == NULL)
2737                         new_region(&screens[i], 0, 0,
2738                             DisplayWidth(display, i),
2739                             DisplayHeight(display, i));
2740                 else
2741                         ncrtc = sr->ncrtc;
2742
2743                 for (c = 0, ci = NULL; c < ncrtc; c++) {
2744                         ci = XRRGetCrtcInfo(display, sr, sr->crtcs[c]);
2745                         if (ci->noutput == 0)
2746                                 continue;
2747
2748                         if (ci != NULL && ci->mode == None)
2749                                 new_region(&screens[i], 0, 0,
2750                                     DisplayWidth(display, i),
2751                                     DisplayHeight(display, i));
2752                         else
2753                                 new_region(&screens[i],
2754                                     ci->x, ci->y, ci->width, ci->height);
2755                 }
2756                 if (ci)
2757                         XRRFreeCrtcInfo(ci);
2758                 XRRFreeScreenResources(sr);
2759         } else
2760 #endif /* SWM_XRR_HAS_CRTC */
2761         {
2762                 new_region(&screens[i], 0, 0, DisplayWidth(display, i),
2763                     DisplayHeight(display, i));
2764         }
2765 }
2766
2767 void
2768 screenchange(XEvent *e) {
2769         XRRScreenChangeNotifyEvent      *xe = (XRRScreenChangeNotifyEvent *)e;
2770         struct swm_region               *r;
2771         struct ws_win                   *win;
2772         int                             i;
2773
2774         DNPRINTF(SWM_D_EVENT, "screenchange: %lu\n", xe->root);
2775
2776         if (!XRRUpdateConfiguration(e))
2777                 return;
2778
2779         /* silly event doesn't include the screen index */
2780         for (i = 0; i < ScreenCount(display); i++)
2781                 if (screens[i].root == xe->root)
2782                         break;
2783         if (i >= ScreenCount(display))
2784                 errx(1, "screenchange: screen not found\n");
2785
2786         /* brute force for now, just re-enumerate the regions */
2787         scan_xrandr(i);
2788
2789         /* hide any windows that went away */
2790         TAILQ_FOREACH(r, &screens[i].rl, entry)
2791                 TAILQ_FOREACH(win, &r->ws->winlist, entry)
2792                         XUnmapWindow(display, win->id);
2793         stack();
2794 }
2795
2796 void
2797 setup_screens(void)
2798 {
2799         Window                  d1, d2, *wins = NULL;
2800         XWindowAttributes       wa;
2801         unsigned int            no;
2802         int                     i, j, k;
2803         int                     errorbase, major, minor;
2804         struct workspace        *ws;
2805         int                     ws_idx_atom;
2806
2807
2808         if ((screens = calloc(ScreenCount(display),
2809              sizeof(struct swm_screen))) == NULL)
2810                 errx(1, "calloc: screens");
2811
2812         ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
2813
2814         /* initial Xrandr setup */
2815         xrandr_support = XRRQueryExtension(display,
2816             &xrandr_eventbase, &errorbase);
2817         if (xrandr_support)
2818                 if (XRRQueryVersion(display, &major, &minor) && major < 1)
2819                         xrandr_support = 0;
2820
2821         /* map physical screens */
2822         for (i = 0; i < ScreenCount(display); i++) {
2823                 DNPRINTF(SWM_D_WS, "setup_screens: init screen %d\n", i);
2824                 screens[i].idx = i;
2825                 TAILQ_INIT(&screens[i].rl);
2826                 TAILQ_INIT(&screens[i].orl);
2827                 screens[i].root = RootWindow(display, i);
2828
2829                 /* set default colors */
2830                 setscreencolor("red", i + 1, SWM_S_COLOR_FOCUS);
2831                 setscreencolor("rgb:88/88/88", i + 1, SWM_S_COLOR_UNFOCUS);
2832                 setscreencolor("rgb:00/80/80", i + 1, SWM_S_COLOR_BAR_BORDER);
2833                 setscreencolor("black", i + 1, SWM_S_COLOR_BAR);
2834                 setscreencolor("rgb:a0/a0/a0", i + 1, SWM_S_COLOR_BAR_FONT);
2835
2836                 /* init all workspaces */
2837                 /* XXX these should be dynamically allocated too */
2838                 for (j = 0; j < SWM_WS_MAX; j++) {
2839                         ws = &screens[i].ws[j];
2840                         ws->idx = j;
2841                         ws->restack = 1;
2842                         ws->focus = NULL;
2843                         ws->r = NULL;
2844                         TAILQ_INIT(&ws->winlist);
2845
2846                         for (k = 0; layouts[k].l_stack != NULL; k++)
2847                                 if (layouts[k].l_config != NULL)
2848                                         layouts[k].l_config(ws,
2849                                             SWM_ARG_ID_STACKINIT);
2850                         ws->cur_layout = &layouts[0];
2851                 }
2852                 /* grab existing windows (before we build the bars)*/
2853                 if (!XQueryTree(display, screens[i].root, &d1, &d2, &wins, &no))
2854                         continue;
2855
2856                 scan_xrandr(i);
2857
2858                 if (xrandr_support)
2859                         XRRSelectInput(display, screens[i].root,
2860                             RRScreenChangeNotifyMask);
2861
2862                 /* attach windows to a region */
2863                 /* normal windows */
2864                 for (j = 0; j < no; j++) {
2865                         XGetWindowAttributes(display, wins[j], &wa);
2866                         if (!XGetWindowAttributes(display, wins[j], &wa) ||
2867                             wa.override_redirect ||
2868                             XGetTransientForHint(display, wins[j], &d1))
2869                                 continue;
2870
2871                         if (wa.map_state == IsViewable ||
2872                             getstate(wins[j]) == NormalState)
2873                                 manage_window(wins[j]);
2874                 }
2875                 /* transient windows */
2876                 for (j = 0; j < no; j++) {
2877                         if (!XGetWindowAttributes(display, wins[j], &wa))
2878                                 continue;
2879
2880                         if (XGetTransientForHint(display, wins[j], &d1) &&
2881                             (wa.map_state == IsViewable || getstate(wins[j]) ==
2882                             NormalState))
2883                                 manage_window(wins[j]);
2884                 }
2885                 if (wins) {
2886                         XFree(wins);
2887                         wins = NULL;
2888                 }
2889         }
2890 }
2891
2892 int
2893 main(int argc, char *argv[])
2894 {
2895         struct passwd           *pwd;
2896         struct swm_region       *r;
2897         char                    conf[PATH_MAX], *cfile = NULL;
2898         struct stat             sb;
2899         XEvent                  e;
2900         int                     xfd, i;
2901         fd_set                  rd;
2902
2903         start_argv = argv;
2904         fprintf(stderr, "Welcome to scrotwm V%s cvs tag: %s\n",
2905             SWM_VERSION, cvstag);
2906         if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
2907                 warnx("no locale support");
2908
2909         if (!(display = XOpenDisplay(0)))
2910                 errx(1, "can not open display");
2911
2912         if (active_wm())
2913                 errx(1, "other wm running");
2914
2915         astate = XInternAtom(display, "WM_STATE", False);
2916         aprot = XInternAtom(display, "WM_PROTOCOLS", False);
2917         adelete = XInternAtom(display, "WM_DELETE_WINDOW", False);
2918
2919         /* look for local and global conf file */
2920         pwd = getpwuid(getuid());
2921         if (pwd == NULL)
2922                 errx(1, "invalid user %d", getuid());
2923
2924         setup_screens();
2925
2926         snprintf(conf, sizeof conf, "%s/.%s", pwd->pw_dir, SWM_CONF_FILE);
2927         if (stat(conf, &sb) != -1) {
2928                 if (S_ISREG(sb.st_mode))
2929                         cfile = conf;
2930         } else {
2931                 /* try global conf file */
2932                 snprintf(conf, sizeof conf, "/etc/%s", SWM_CONF_FILE);
2933                 if (!stat(conf, &sb))
2934                         if (S_ISREG(sb.st_mode))
2935                                 cfile = conf;
2936         }
2937         if (cfile)
2938                 conf_load(cfile);
2939
2940         /* setup all bars */
2941         for (i = 0; i < ScreenCount(display); i++)
2942                 TAILQ_FOREACH(r, &screens[i].rl, entry)
2943                         bar_setup(r);
2944
2945         /* ws[0].focus = TAILQ_FIRST(&ws[0].winlist); */
2946
2947         grabkeys();
2948         stack();
2949
2950         xfd = ConnectionNumber(display);
2951         while (running) {
2952                 FD_ZERO(&rd);
2953                 FD_SET(xfd, &rd);
2954                 if (select(xfd + 1, &rd, NULL, NULL, NULL) == -1)
2955                         if (errno != EINTR)
2956                                 errx(1, "select failed");
2957                 if (bar_alarm) {
2958                         bar_alarm = 0;
2959                         bar_update();
2960                 }
2961                 while (XPending(display)) {
2962                         XNextEvent(display, &e);
2963                         if (e.type < LASTEvent) {
2964                                 if (handler[e.type])
2965                                         handler[e.type](&e);
2966                                 else
2967                                         DNPRINTF(SWM_D_EVENT,
2968                                             "win: %lu unknown event: %d\n",
2969                                             e.xany.window, e.type);
2970                         } else {
2971                                 switch (e.type - xrandr_eventbase) {
2972                                 case RRScreenChangeNotify:
2973                                         screenchange(&e);
2974                                         break;
2975                                 default:
2976                                         DNPRINTF(SWM_D_EVENT,
2977                                             "win: %lu unknown xrandr event: "
2978                                             "%d\n", e.xany.window, e.type);
2979                                         break;
2980                                 }
2981                         }
2982                 }
2983         }
2984
2985         XCloseDisplay(display);
2986
2987         return (0);
2988 }