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 #define SWM_VERSION     "0.5"
  52
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <err.h>
  56 #include <locale.h>
  57 #include <unistd.h>
  58 #include <time.h>
  59 #include <signal.h>
  60 #include <string.h>
  61 #include <util.h>
  62 #include <pwd.h>
  63
  64 #include <sys/types.h>
  65 #include <sys/stat.h>
  66 #include <sys/wait.h>
  67 #include <sys/queue.h>
  68 #include <sys/param.h>
  69
  70 #include <X11/cursorfont.h>
  71 #include <X11/keysym.h>
  72 #include <X11/Xatom.h>
  73 #include <X11/Xlib.h>
  74 #include <X11/Xproto.h>
  75 #include <X11/Xutil.h>
  76
  77 /* #define SWM_DEBUG */
  78 #ifdef SWM_DEBUG
  79 #define DPRINTF(x...)           do { if (swm_debug) fprintf(stderr, x); } while(0)
  80 #define DNPRINTF(n,x...)        do { if (swm_debug & n) fprintf(stderr, x); } while(0)
  81 #define SWM_D_MISC              0x0001
  82 #define SWM_D_EVENT             0x0002
  83 #define SWM_D_WS                0x0004
  84 #define SWM_D_FOCUS             0x0008
  85 #define SWM_D_MOVE              0x0010
  86
  87 u_int32_t               swm_debug = 0
  88                             | SWM_D_MISC
  89                             | SWM_D_EVENT
  90                             | SWM_D_WS
  91                             | SWM_D_FOCUS
  92                             | SWM_D_MOVE
  93                             ;
  94 #else
  95 #define DPRINTF(x...)
  96 #define DNPRINTF(n,x...)
  97 #endif
  98
  99 #define LENGTH(x)               (sizeof x / sizeof x[0])
 100 #define MODKEY                  Mod1Mask
 101 #define CLEANMASK(mask)         (mask & ~(numlockmask | LockMask))
 102
 103 #define WIDTH           ws[current_ws].g.w
 104 #define HEIGHT          ws[current_ws].g.h
 105
 106 char                    **start_argv;
 107 Atom                    astate;
 108 int                     (*xerrorxlib)(Display *, XErrorEvent *);
 109 int                     other_wm;
 110 int                     screen;
 111 int                     running = 1;
 112 int                     ignore_enter = 0;
 113 unsigned int            numlockmask = 0;
 114 unsigned long           color_focus = 0xff0000; /* XXX should this be per ws? */
 115 unsigned long           color_unfocus = 0x888888;
 116 Display                 *display;
 117 Window                  root;
 118
 119 /* dialog windows */
 120 double                  dialog_ratio = .6;
 121 /* status bar */
 122 int                     bar_enabled = 1;
 123 int                     bar_height = 0;
 124 unsigned long           bar_border = 0x008080;
 125 unsigned long           bar_color = 0x000000;
 126 unsigned long           bar_font_color = 0xa0a0a0;
 127 Window                  bar_window;
 128 GC                      bar_gc;
 129 XGCValues               bar_gcv;
 130 XFontStruct             *bar_fs;
 131 char                    bar_text[128];
 132 char                    *bar_fonts[] = {
 133                             "-*-terminus-*-*-*-*-*-*-*-*-*-*-*-*",
 134                             "-*-times-medium-r-*-*-*-*-*-*-*-*-*-*",
 135                             NULL
 136 };
 137
 138 /* terminal + args */
 139 char                            *spawn_term[] = { "xterm", NULL };
 140 char                            *spawn_menu[] = { "dmenu_run", NULL };
 141
 142 /* layout manager data */
 143 struct swm_geometry {
 144         int                     x;
 145         int                     y;
 146         int                     w;
 147         int                     h;
 148 };
 149
 150
 151 struct ws_win {
 152         TAILQ_ENTRY(ws_win)     entry;
 153         Window                  id;
 154         struct swm_geometry     g;
 155         int                     floating;
 156         int                     transient;
 157         XWindowAttributes       wa;
 158 };
 159 TAILQ_HEAD(ws_win_list, ws_win);
 160
 161 /* layout handlers */
 162 void    stack(void);
 163 void    vertical_init(int);
 164 void    vertical_resize(int);
 165 void    vertical_stack(struct swm_geometry *);
 166 void    horizontal_init(int);
 167 void    horizontal_resize(int);
 168 void    horizontal_stack(struct swm_geometry *);
 169 void    max_init(int);
 170 void    max_focus(struct ws_win *);
 171 void    max_stack(struct swm_geometry *);
 172
 173 struct layout {
 174         void                    (*l_init)(int); /* init/reset */
 175         void                    (*l_stack)(struct swm_geometry *);
 176         void                    (*l_resize)(int);
 177         void                    (*l_focus)(struct ws_win *);
 178 } layouts[] =  {
 179         /* init                 stack,                  resize */
 180         { vertical_init,        vertical_stack,         vertical_resize,        NULL},
 181         { horizontal_init,      horizontal_stack,       horizontal_resize,      NULL},
 182         { NULL,                 max_stack,              NULL,                   max_focus},
 183         { NULL,                 NULL,                   NULL,                   NULL},
 184 };
 185
 186
 187 /* define work spaces */
 188 #define SWM_WS_MAX              (10)
 189 struct workspace {
 190         int                     visible;        /* workspace visible */
 191         int                     restack;        /* restack on switch */
 192         struct swm_geometry     g;
 193         struct layout           *cur_layout;    /* current layout handlers */
 194         struct ws_win           *focus;         /* which win has focus */
 195         struct ws_win_list      winlist;        /* list of windows in ws */
 196 } ws[SWM_WS_MAX];
 197 int                     current_ws = 0;
 198
 199 /* args to functions */
 200 union arg {
 201         int                     id;
 202 #define SWM_ARG_ID_FOCUSNEXT    (0)
 203 #define SWM_ARG_ID_FOCUSPREV    (1)
 204 #define SWM_ARG_ID_FOCUSMAIN    (2)
 205 #define SWM_ARG_ID_SWAPNEXT     (3)
 206 #define SWM_ARG_ID_SWAPPREV     (4)
 207 #define SWM_ARG_ID_SWAPMAIN     (5)
 208 #define SWM_ARG_ID_MASTERSHRINK (6)
 209 #define SWM_ARG_ID_MASTERGROW   (7)
 210         char                    **argv;
 211 };
 212
 213 unsigned long
 214 name_to_color(char *colorname)
 215 {
 216         Colormap                cmap;
 217         Status                  r;
 218         XColor                  screen_def, exact_def;
 219         unsigned long           result = 0;
 220         char                    cname[32] = "#";
 221
 222         cmap = DefaultColormap(display, screen);
 223         r = XAllocNamedColor(display, cmap, colorname, &screen_def, &exact_def);
 224         if (!r) {
 225                 strlcat(cname, colorname + 2, sizeof cname - 1);
 226                 r = XAllocNamedColor(display, cmap, cname, &screen_def,
 227                     &exact_def);
 228         }
 229         if (r)
 230                 result = screen_def.pixel;
 231         else
 232                 fprintf(stderr, "color '%s' not found.\n", colorname);
 233
 234         return (result);
 235 }
 236
 237 /* conf file stuff */
 238 #define SWM_CONF_WS     "\n= \t"
 239 #define SWM_CONF_FILE   "scrotwm.conf"
 240 int
 241 conf_load(char *filename)
 242 {
 243         FILE                    *config;
 244         char                    *line, *cp, *var, *val;
 245         size_t                   len, lineno = 0;
 246
 247         DNPRINTF(SWM_D_MISC, "conf_load: filename %s\n", filename);
 248
 249         if (filename == NULL)
 250                 return (1);
 251
 252         if ((config = fopen(filename, "r")) == NULL)
 253                 return (1);
 254
 255         for (;;) {
 256                 if ((line = fparseln(config, &len, &lineno, NULL, 0)) == NULL)
 257                         if (feof(config))
 258                                 break;
 259                 cp = line;
 260                 cp += (long)strspn(cp, SWM_CONF_WS);
 261                 if (cp[0] == '\0') {
 262                         /* empty line */
 263                         free(line);
 264                         continue;
 265                 }
 266                 if ((var = strsep(&cp, SWM_CONF_WS)) == NULL || cp == NULL)
 267                         break;
 268                 cp += (long)strspn(cp, SWM_CONF_WS);
 269                 if ((val = strsep(&cp, SWM_CONF_WS)) == NULL)
 270                         break;
 271
 272                 DNPRINTF(SWM_D_MISC, "conf_load: %s=%s\n",var ,val);
 273                 switch (var[0]) {
 274                 case 'b':
 275                         if (!strncmp(var, "bar_enabled", strlen("bar_enabled")))
 276                                 bar_enabled = atoi(val);
 277                         else if (!strncmp(var, "bar_border",
 278                             strlen("bar_border")))
 279                                 bar_border = name_to_color(val);
 280                         else if (!strncmp(var, "bar_color",
 281                             strlen("bar_color")))
 282                                 bar_color = name_to_color(val);
 283                         else if (!strncmp(var, "bar_font_color",
 284                             strlen("bar_font_color")))
 285                                 bar_font_color = name_to_color(val);
 286                         else if (!strncmp(var, "bar_font", strlen("bar_font")))
 287                                 asprintf(&bar_fonts[0], "%s", val);
 288                         else
 289                                 goto bad;
 290                         break;
 291
 292                 case 'c':
 293                         if (!strncmp(var, "color_focus", strlen("color_focus")))
 294                                 color_focus = name_to_color(val);
 295                         else if (!strncmp(var, "color_unfocus",
 296                             strlen("color_unfocus")))
 297                                 color_unfocus = name_to_color(val);
 298                         else
 299                                 goto bad;
 300                         break;
 301
 302                 case 'd':
 303                         if (!strncmp(var, "dialog_ratio",
 304                             strlen("dialog_ratio"))) {
 305                                 dialog_ratio = atof(val);
 306                                 if (dialog_ratio > 1.0 || dialog_ratio <= .3)
 307                                         dialog_ratio = .6;
 308                         } else
 309                                 goto bad;
 310                         break;
 311
 312                 case 's':
 313                         if (!strncmp(var, "spawn_term", strlen("spawn_term")))
 314                                 asprintf(&spawn_term[0], "%s", val); /* XXX args? */
 315                         break;
 316                 default:
 317                         goto bad;
 318                 }
 319                 free(line);
 320         }
 321
 322         fclose(config);
 323         return (0);
 324 bad:
 325         errx(1, "invalid conf file entry: %s=%s", var, val);
 326 }
 327
 328 void
 329 bar_print(void)
 330 {
 331         time_t                  tmt;
 332         struct tm               tm;
 333
 334         if (bar_enabled == 0)
 335                 return;
 336
 337         /* clear old text */
 338         XSetForeground(display, bar_gc, bar_color);
 339         XDrawString(display, bar_window, bar_gc, 4, bar_fs->ascent, bar_text,
 340             strlen(bar_text));
 341
 342         /* draw new text */
 343         time(&tmt);
 344         localtime_r(&tmt, &tm);
 345         strftime(bar_text, sizeof bar_text, "%a %b %d %R %Z %Y", &tm);
 346         XSetForeground(display, bar_gc, bar_font_color);
 347         XDrawString(display, bar_window, bar_gc, 4, bar_fs->ascent, bar_text,
 348             strlen(bar_text));
 349         XSync(display, False);
 350
 351         alarm(60);
 352 }
 353
 354 void
 355 bar_signal(int sig)
 356 {
 357         /* XXX yeah yeah byte me */
 358         bar_print();
 359 }
 360
 361 void
 362 bar_toggle(union arg *args)
 363 {
 364         int i;
 365
 366         DNPRINTF(SWM_D_MISC, "bar_toggle\n");
 367
 368         if (bar_enabled) {
 369                 bar_enabled = 0;
 370                 XUnmapWindow(display, bar_window);
 371         } else {
 372                 bar_enabled = 1;
 373                 XMapRaised(display, bar_window);
 374         }
 375         XSync(display, False);
 376         for (i = 0; i < SWM_WS_MAX; i++)
 377                 ws[i].restack = 1;
 378
 379         stack();
 380         bar_print(); /* must be after stack */
 381 }
 382
 383 void
 384 bar_setup(void)
 385 {
 386         int                     i;
 387
 388         for (i = 0; bar_fonts[i] != NULL; i++) {
 389                 bar_fs = XLoadQueryFont(display, bar_fonts[i]);
 390                 if (bar_fs)
 391                         break;
 392         }
 393         if (bar_fonts[i] == NULL)
 394                         errx(1, "couldn't load font");
 395         bar_height = bar_fs->ascent + bar_fs->descent + 3;
 396
 397         bar_window = XCreateSimpleWindow(display, root, 0, 0,
 398             WIDTH, bar_height - 2, 1, bar_border, bar_color);
 399         bar_gc = XCreateGC(display, bar_window, 0, &bar_gcv);
 400         XSetFont(display, bar_gc, bar_fs->fid);
 401         XSelectInput(display, bar_window, VisibilityChangeMask);
 402         if (bar_enabled) {
 403                 XMapRaised(display, bar_window);
 404         }
 405         DNPRINTF(SWM_D_MISC, "bar_setup: bar_window %d\n", (int)bar_window);
 406
 407         if (signal(SIGALRM, bar_signal) == SIG_ERR)
 408                 err(1, "could not install bar_signal");
 409         bar_print();
 410 }
 411
 412 void
 413 config_win(struct ws_win *win)
 414 {
 415         XConfigureEvent         ce;
 416
 417         DNPRINTF(SWM_D_MISC, "config_win: win %lu x %d y %d w %d h %d\n",
 418             win->id, win->g.x, win->g.y, win->g.w, win->g.h);
 419         ce.type = ConfigureNotify;
 420         ce.display = display;
 421         ce.event = win->id;
 422         ce.window = win->id;
 423         ce.x = win->g.x;
 424         ce.y = win->g.y;
 425         ce.width = win->g.w;
 426         ce.height = win->g.h;
 427         ce.border_width = 1; /* XXX store this! */
 428         ce.above = None;
 429         ce.override_redirect = False;
 430         XSendEvent(display, win->id, False, StructureNotifyMask, (XEvent *)&ce);
 431 }
 432
 433 int
 434 count_win(int wsid, int count_transient)
 435 {
 436         struct ws_win           *win;
 437         int                     count = 0;
 438
 439         TAILQ_FOREACH (win, &ws[wsid].winlist, entry) {
 440                 if (count_transient == 0 && win->floating)
 441                         continue;
 442                 if (count_transient == 0 && win->transient)
 443                         continue;
 444                 count++;
 445         }
 446         DNPRINTF(SWM_D_MISC, "count_win: %d\n", count);
 447
 448         return (count);
 449 }
 450 void
 451 quit(union arg *args)
 452 {
 453         DNPRINTF(SWM_D_MISC, "quit\n");
 454         running = 0;
 455 }
 456
 457 void
 458 restart(union arg *args)
 459 {
 460         DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]);
 461
 462         XCloseDisplay(display);
 463         execvp(start_argv[0], start_argv);
 464         fprintf(stderr, "execvp failed\n");
 465         perror(" failed");
 466         quit(NULL);
 467 }
 468
 469 void
 470 spawn(union arg *args)
 471 {
 472         DNPRINTF(SWM_D_MISC, "spawn: %s\n", args->argv[0]);
 473         /*
 474          * The double-fork construct avoids zombie processes and keeps the code
 475          * clean from stupid signal handlers.
 476          */
 477         if (fork() == 0) {
 478                 if (fork() == 0) {
 479                         if (display)
 480                                 close(ConnectionNumber(display));
 481                         setsid();
 482                         execvp(args->argv[0], args->argv);
 483                         fprintf(stderr, "execvp failed\n");
 484                         perror(" failed");
 485                 }
 486                 exit(0);
 487         }
 488         wait(0);
 489 }
 490
 491 void
 492 focus_win(struct ws_win *win)
 493 {
 494         DNPRINTF(SWM_D_FOCUS, "focus_win: id: %lu\n", win->id);
 495         XSetWindowBorder(display, win->id, color_focus);
 496         XSetInputFocus(display, win->id, RevertToPointerRoot, CurrentTime);
 497         ws[current_ws].focus = win;
 498 }
 499
 500 void
 501 unfocus_win(struct ws_win *win)
 502 {
 503         DNPRINTF(SWM_D_FOCUS, "unfocus_win: id: %lu\n", win->id);
 504         XSetWindowBorder(display, win->id, color_unfocus);
 505         if (ws[current_ws].focus == win)
 506                 ws[current_ws].focus = NULL;
 507 }
 508
 509 void
 510 switchws(union arg *args)
 511 {
 512         int                     wsid = args->id;
 513         struct ws_win           *win;
 514
 515         DNPRINTF(SWM_D_WS, "switchws: %d\n", wsid + 1);
 516
 517         if (wsid == current_ws)
 518                 return;
 519
 520         /* map new window first to prevent ugly blinking */
 521         TAILQ_FOREACH (win, &ws[wsid].winlist, entry)
 522                 XMapRaised(display, win->id);
 523         ws[wsid].visible = 1;
 524
 525         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry)
 526                 XUnmapWindow(display, win->id);
 527         ws[current_ws].visible = 0;
 528
 529         current_ws = wsid;
 530
 531         ignore_enter = 1;
 532         if (ws[wsid].restack) {
 533                 stack();
 534                 bar_print();
 535         } else {
 536                 if (ws[wsid].focus != NULL)
 537                         focus_win(ws[wsid].focus);
 538                 XSync(display, False);
 539         }
 540 }
 541
 542 void
 543 swapwin(union arg *args)
 544 {
 545         struct ws_win           *target;
 546
 547         DNPRINTF(SWM_D_MOVE, "swapwin: id %d\n", args->id);
 548         if (ws[current_ws].focus == NULL)
 549                 return;
 550
 551         switch (args->id) {
 552         case SWM_ARG_ID_SWAPPREV:
 553                 target = TAILQ_PREV(ws[current_ws].focus, ws_win_list, entry);
 554                 TAILQ_REMOVE(&ws[current_ws].winlist,
 555                     ws[current_ws].focus, entry);
 556                 if (target == NULL)
 557                         TAILQ_INSERT_TAIL(&ws[current_ws].winlist,
 558                             ws[current_ws].focus, entry);
 559                 else
 560                         TAILQ_INSERT_BEFORE(target, ws[current_ws].focus,
 561                             entry);
 562                 break;
 563         case SWM_ARG_ID_SWAPNEXT:
 564                 target = TAILQ_NEXT(ws[current_ws].focus, entry);
 565                 TAILQ_REMOVE(&ws[current_ws].winlist,
 566                     ws[current_ws].focus, entry);
 567                 if (target == NULL)
 568                         TAILQ_INSERT_HEAD(&ws[current_ws].winlist,
 569                             ws[current_ws].focus, entry);
 570                 else
 571                         TAILQ_INSERT_AFTER(&ws[current_ws].winlist, target,
 572                             ws[current_ws].focus, entry);
 573                 break;
 574         case SWM_ARG_ID_SWAPMAIN:
 575                 target = TAILQ_FIRST(&ws[current_ws].winlist);
 576                 if (target == ws[current_ws].focus)
 577                         return;
 578                 TAILQ_REMOVE(&ws[current_ws].winlist, target, entry);
 579                 TAILQ_INSERT_BEFORE(ws[current_ws].focus, target, entry);
 580                 TAILQ_REMOVE(&ws[current_ws].winlist,
 581                     ws[current_ws].focus, entry);
 582                 TAILQ_INSERT_HEAD(&ws[current_ws].winlist,
 583                     ws[current_ws].focus, entry);
 584                 break;
 585         default:
 586                 DNPRINTF(SWM_D_MOVE, "invalid id: %d\n", args->id);
 587                 return;
 588         }
 589
 590         ignore_enter = 2;
 591         stack();
 592 }
 593
 594 void
 595 focus(union arg *args)
 596 {
 597         struct ws_win           *winfocus, *winlostfocus;
 598
 599         DNPRINTF(SWM_D_FOCUS, "focus: id %d\n", args->id);
 600         if (ws[current_ws].focus == NULL)
 601                 return;
 602
 603         winlostfocus = ws[current_ws].focus;
 604
 605         switch (args->id) {
 606         case SWM_ARG_ID_FOCUSPREV:
 607                 winfocus = TAILQ_PREV(ws[current_ws].focus, ws_win_list, entry);
 608                 if (winfocus == NULL)
 609                         winfocus =
 610                             TAILQ_LAST(&ws[current_ws].winlist, ws_win_list);
 611                 break;
 612
 613         case SWM_ARG_ID_FOCUSNEXT:
 614                 winfocus = TAILQ_NEXT(ws[current_ws].focus, entry);
 615                 if (winfocus == NULL)
 616                         winfocus = TAILQ_FIRST(&ws[current_ws].winlist);
 617                 break;
 618
 619         case SWM_ARG_ID_FOCUSMAIN:
 620                 winfocus = TAILQ_FIRST(&ws[current_ws].winlist);
 621                 break;
 622
 623         default:
 624                 return;
 625         }
 626
 627         if (winfocus == winlostfocus)
 628                 return;
 629
 630         unfocus_win(winlostfocus);
 631         focus_win(winfocus);
 632         /* XXX if we hook in focus_win(), we get a nasty cycle */
 633         if (ws[current_ws].cur_layout->l_focus != NULL)
 634                 ws[current_ws].cur_layout->l_focus(winfocus);
 635         XSync(display, False);
 636 }
 637
 638 void
 639 cycle_layout(union arg *args)
 640 {
 641         DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", current_ws);
 642
 643         ws[current_ws].cur_layout++;
 644         if (ws[current_ws].cur_layout->l_stack == NULL)
 645                 ws[current_ws].cur_layout = &layouts[0];
 646         ignore_enter = 1;
 647
 648         stack();
 649 }
 650
 651 void
 652 resize_master(union arg *args)
 653 {
 654         DNPRINTF(SWM_D_EVENT, "resize_master: id %d\n", args->id);
 655
 656         if (ws[current_ws].cur_layout->l_resize != NULL)
 657                 ws[current_ws].cur_layout->l_resize(args->id);
 658 }
 659
 660 void
 661 stack_reset(union arg *args)
 662 {
 663         DNPRINTF(SWM_D_EVENT, "stack_reset: ws %d\n", current_ws);
 664
 665         if (ws[current_ws].cur_layout->l_init != NULL) {
 666                 ws[current_ws].cur_layout->l_init(current_ws);
 667                 stack();
 668         }
 669 }
 670
 671 void
 672 stack(void) {
 673         struct swm_geometry g;
 674         DNPRINTF(SWM_D_EVENT, "stack: workspace: %d\n", current_ws);
 675
 676         /* start with workspace geometry, adjust for bar */
 677         g = ws[current_ws].g;
 678         if (bar_enabled) {
 679                 g.y += bar_height;
 680                 g.h -= bar_height;
 681         }
 682
 683         ws[current_ws].restack = 0;
 684         ws[current_ws].cur_layout->l_stack(&g);
 685         XSync(display, False);
 686 }
 687
 688 void
 689 stack_floater(struct ws_win *win)
 690 {
 691         unsigned int            mask;
 692         XWindowChanges          wc;
 693
 694         bzero(&wc, sizeof wc);
 695         mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight;
 696         wc.border_width = 1;
 697         if (win->transient) {
 698                 win->g.w = (double)WIDTH * dialog_ratio;
 699                 win->g.h = (double)HEIGHT * dialog_ratio;
 700         }
 701         wc.width = win->g.w;
 702         wc.height = win->g.h;
 703         wc.x = (WIDTH - win->g.w) / 2;
 704         wc.y = (HEIGHT - win->g.h) / 2;
 705
 706         DNPRINTF(SWM_D_EVENT, "stack_floater: win %d x %d y %d w %d h %d\n",
 707             win, wc.x, wc.y, wc.width, wc.height);
 708
 709         XConfigureWindow(display, win->id, mask, &wc);
 710 }
 711
 712
 713 int vertical_msize[SWM_WS_MAX];
 714
 715 void
 716 vertical_init(int ws_idx)
 717 {
 718         DNPRINTF(SWM_D_MISC, "vertical_init: workspace: %d\n", current_ws);
 719
 720         vertical_msize[ws_idx] = ws[ws_idx].g.w / 2;
 721 }
 722
 723 void
 724 vertical_resize(int id)
 725 {
 726         DNPRINTF(SWM_D_MISC, "vertical_resize: workspace: %d\n", current_ws);
 727
 728         switch (id) {
 729         case SWM_ARG_ID_MASTERSHRINK:
 730                 vertical_msize[current_ws] -= WIDTH / 32;
 731                 if ( vertical_msize[current_ws] < WIDTH / 16)
 732                         vertical_msize[current_ws] = WIDTH / 16;
 733                 break;
 734         case SWM_ARG_ID_MASTERGROW:
 735                 vertical_msize[current_ws] += WIDTH / 32;
 736                 if ( vertical_msize[current_ws] >
 737                    (WIDTH - (WIDTH / 16)))
 738                         vertical_msize[current_ws] =
 739                             WIDTH - WIDTH / 16;
 740                 break;
 741         default:
 742                 return;
 743         }
 744         stack();
 745 }
 746
 747 void
 748 vertical_stack(struct swm_geometry *g) {
 749         XWindowChanges          wc;
 750         struct swm_geometry     gg = *g;
 751         struct ws_win           wf, *win, *winfocus = &wf;
 752         int                     i, hrh, winno;
 753         unsigned int            mask;
 754
 755         DNPRINTF(SWM_D_EVENT, "vertical_stack: workspace: %d\n", current_ws);
 756
 757         winno = count_win(current_ws, 0);
 758         if (winno == 0)
 759                 return;
 760         winfocus->id = root;
 761
 762         if (winno > 1)
 763                 gg.w = vertical_msize[current_ws];
 764
 765         if (winno > 2)
 766                 hrh = g->h / (winno - 1);
 767         else
 768                 hrh = 0;
 769
 770         i = 0;
 771         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
 772                 if (i == 1) {
 773                         gg.x += vertical_msize[current_ws] + 2;
 774                         gg.w = g->w - (vertical_msize[current_ws] + 2);
 775                 }
 776                 if (i != 0 && hrh != 0) {
 777                         /* correct the last window for lost pixels */
 778                         if (win == TAILQ_LAST(&ws[current_ws].winlist,
 779                             ws_win_list)) {
 780                                 gg.h = hrh + (g->h - (i * hrh));
 781                                 gg.y += hrh;
 782                         } else {
 783                                 gg.h = hrh - 2;
 784                                 /* leave first right hand window at y = 0 */
 785                                 if (i > 1)
 786                                         gg.y += gg.h + 2;
 787                         }
 788                 }
 789
 790                 if (win->transient != 0 || win->floating != 0)
 791                         stack_floater(win);
 792                 else {
 793                         bzero(&wc, sizeof wc);
 794                         wc.border_width = 1;
 795                         win->g.x = wc.x = gg.x;
 796                         win->g.y = wc.y = gg.y;
 797                         win->g.w = wc.width = gg.w;
 798                         win->g.h = wc.height = gg.h;
 799                         mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
 800                         XConfigureWindow(display, win->id, mask, &wc);
 801                 }
 802
 803                 if (win == ws[current_ws].focus)
 804                         winfocus = win;
 805                 else
 806                         unfocus_win(win);
 807                 XMapRaised(display, win->id);
 808                 i++;
 809         }
 810
 811         focus_win(winfocus); /* this has to be done outside of the loop */
 812 }
 813
 814 int horizontal_msize[SWM_WS_MAX];
 815
 816 void
 817 horizontal_init(int ws_idx)
 818 {
 819         DNPRINTF(SWM_D_MISC, "horizontal_init: workspace: %d\n", current_ws);
 820
 821         horizontal_msize[ws_idx] = ws[ws_idx].g.h / 2;
 822 }
 823
 824 void
 825 horizontal_resize(int id)
 826 {
 827         DNPRINTF(SWM_D_MISC, "horizontal_resize: workspace: %d\n", current_ws);
 828
 829         switch (id) {
 830         case SWM_ARG_ID_MASTERSHRINK:
 831                 horizontal_msize[current_ws] -= HEIGHT / 32;
 832                 if ( horizontal_msize[current_ws] < HEIGHT / 16)
 833                         horizontal_msize[current_ws] = HEIGHT / 16;
 834                 break;
 835         case SWM_ARG_ID_MASTERGROW:
 836                 horizontal_msize[current_ws] += HEIGHT / 32;
 837                 if ( horizontal_msize[current_ws] >
 838                    (HEIGHT - (HEIGHT / 16)))
 839                         horizontal_msize[current_ws] =
 840                             HEIGHT - HEIGHT / 16;
 841                 break;
 842         default:
 843                 return;
 844         }
 845         stack();
 846 }
 847
 848 void
 849 horizontal_stack(struct swm_geometry *g) {
 850         XWindowChanges          wc;
 851         struct swm_geometry     gg = *g;
 852         struct ws_win           wf, *win, *winfocus = &wf;
 853         int                     i, hrw, winno;
 854         unsigned int            mask;
 855
 856         DNPRINTF(SWM_D_EVENT, "horizontal_stack: workspace: %d\n", current_ws);
 857
 858         winno = count_win(current_ws, 0);
 859         if (winno == 0)
 860                 return;
 861         winfocus->id = root;
 862
 863         if (winno > 1)
 864                 gg.h = horizontal_msize[current_ws];
 865
 866         if (winno > 2)
 867                 hrw = g->w / (winno - 1);
 868         else
 869                 hrw = 0;
 870
 871         i = 0;
 872         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
 873                 if (i == 1) {
 874                         gg.y += horizontal_msize[current_ws] + 2;
 875                         gg.h = g->h - (horizontal_msize[current_ws] + 2);
 876                 }
 877                 if (i != 0 && hrw != 0) {
 878                         /* correct the last window for lost pixels */
 879                         if (win == TAILQ_LAST(&ws[current_ws].winlist,
 880                             ws_win_list)) {
 881                                 gg.w = hrw + (g->w - (i * hrw));
 882                                 gg.x += hrw;
 883                         } else {
 884                                 gg.w = hrw - 2;
 885                                 /* leave first bottom window at x = 0 */
 886                                 if (i > 1)
 887                                         gg.x += gg.w + 2;
 888                         }
 889                 }
 890
 891                 if (win->transient != 0 || win->floating != 0)
 892                         stack_floater(win);
 893                 else {
 894                         bzero(&wc, sizeof wc);
 895                         wc.border_width = 1;
 896                         win->g.x = wc.x = gg.x;
 897                         win->g.y = wc.y = gg.y;
 898                         win->g.w = wc.width = gg.w;
 899                         win->g.h = wc.height = gg.h;
 900                         mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
 901                         XConfigureWindow(display, win->id, mask, &wc);
 902                 }
 903
 904                 if (win == ws[current_ws].focus)
 905                         winfocus = win;
 906                 else
 907                         unfocus_win(win);
 908                 XMapRaised(display, win->id);
 909                 i++;
 910         }
 911
 912         focus_win(winfocus); /* this has to be done outside of the loop */
 913 }
 914
 915 void
 916 max_focus(struct ws_win *fwin)
 917 {
 918         struct ws_win *win;
 919
 920         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
 921                 if (win->transient == 0 && win->floating == 0 && win == fwin)
 922                         XMapRaised(display, win->id);
 923                 else
 924                         XUnmapWindow(display, win->id);
 925         }
 926 }
 927
 928 /* fullscreen view */
 929 void
 930 max_stack(struct swm_geometry *g) {
 931         XWindowChanges          wc;
 932         struct swm_geometry     gg = *g;
 933         struct ws_win           *win, *winfocus;
 934         unsigned int            mask;
 935
 936         DNPRINTF(SWM_D_EVENT, "max_stack: workspace: %d\n", current_ws);
 937
 938         if (count_win(current_ws, 0) == 0)
 939                 return;
 940
 941         winfocus = ws[current_ws].focus;
 942         if (!winfocus)
 943                 winfocus = TAILQ_FIRST(&ws[current_ws].winlist);
 944
 945         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
 946                 if (win->transient != 0 || win->floating != 0) {
 947                         if (win == winfocus) {
 948                                 stack_floater(win); /* XXX maximize? */
 949                                 XMapRaised(display, win->id);
 950                         } else
 951                                 XUnmapWindow(display, win->id);
 952                 } else {
 953                         bzero(&wc, sizeof wc);
 954                         wc.border_width = 1;
 955                         win->g.x = wc.x = gg.x;
 956                         win->g.y = wc.y = gg.y;
 957                         win->g.w = wc.width = gg.w;
 958                         win->g.h = wc.height = gg.h;
 959                         mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
 960                         XConfigureWindow(display, win->id, mask, &wc);
 961
 962                         if (winfocus == win)
 963                                 XMapRaised(display, win->id);
 964                         else
 965                                 XUnmapWindow(display, win->id);
 966                 }
 967         }
 968
 969         focus_win(winfocus); /* this has to be done outside of the loop */
 970 }
 971
 972 void
 973 send_to_ws(union arg *args)
 974 {
 975         int                     wsid = args->id;
 976         struct ws_win           *win = ws[current_ws].focus;
 977
 978         DNPRINTF(SWM_D_MOVE, "send_to_ws: win: %lu\n", win->id);
 979
 980         XUnmapWindow(display, win->id);
 981
 982         /* find a window to focus */
 983         ws[current_ws].focus = TAILQ_PREV(win, ws_win_list, entry);
 984         if (ws[current_ws].focus == NULL)
 985                 ws[current_ws].focus = TAILQ_FIRST(&ws[current_ws].winlist);
 986         if (ws[current_ws].focus == win)
 987                 ws[current_ws].focus = NULL;
 988
 989         TAILQ_REMOVE(&ws[current_ws].winlist, win, entry);
 990
 991         TAILQ_INSERT_TAIL(&ws[wsid].winlist, win, entry);
 992         if (count_win(wsid, 1) == 1)
 993                 ws[wsid].focus = win;
 994         ws[wsid].restack = 1;
 995
 996         stack();
 997 }
 998
 999 /* key definitions */
1000 struct key {
1001         unsigned int            mod;
1002         KeySym                  keysym;
1003         void                    (*func)(union arg *);
1004         union arg               args;
1005 } keys[] = {
1006         /* modifier             key     function                argument */
1007         { MODKEY,               XK_space,       cycle_layout,   {0} },
1008         { MODKEY | ShiftMask,   XK_space,       stack_reset,    {0} },
1009         { MODKEY,               XK_h,           resize_master,  {.id = SWM_ARG_ID_MASTERSHRINK} },
1010         { MODKEY,               XK_l,           resize_master,  {.id = SWM_ARG_ID_MASTERGROW} },
1011         { MODKEY,               XK_Return,      swapwin,        {.id = SWM_ARG_ID_SWAPMAIN} },
1012         { MODKEY,               XK_j,           focus,          {.id = SWM_ARG_ID_FOCUSNEXT} },
1013         { MODKEY,               XK_k,           focus,          {.id = SWM_ARG_ID_FOCUSPREV} },
1014         { MODKEY | ShiftMask,   XK_j,           swapwin,        {.id = SWM_ARG_ID_SWAPNEXT} },
1015         { MODKEY | ShiftMask,   XK_k,           swapwin,        {.id = SWM_ARG_ID_SWAPPREV} },
1016         { MODKEY | ShiftMask,   XK_Return,      spawn,          {.argv = spawn_term} },
1017         { MODKEY,               XK_p,           spawn,          {.argv = spawn_menu} },
1018         { MODKEY | ShiftMask,   XK_q,           quit,           {0} },
1019         { MODKEY,               XK_q,           restart,        {0} },
1020         { MODKEY,               XK_m,           focus,          {.id = SWM_ARG_ID_FOCUSMAIN} },
1021         { MODKEY,               XK_1,           switchws,       {.id = 0} },
1022         { MODKEY,               XK_2,           switchws,       {.id = 1} },
1023         { MODKEY,               XK_3,           switchws,       {.id = 2} },
1024         { MODKEY,               XK_4,           switchws,       {.id = 3} },
1025         { MODKEY,               XK_5,           switchws,       {.id = 4} },
1026         { MODKEY,               XK_6,           switchws,       {.id = 5} },
1027         { MODKEY,               XK_7,           switchws,       {.id = 6} },
1028         { MODKEY,               XK_8,           switchws,       {.id = 7} },
1029         { MODKEY,               XK_9,           switchws,       {.id = 8} },
1030         { MODKEY,               XK_0,           switchws,       {.id = 9} },
1031         { MODKEY | ShiftMask,   XK_1,           send_to_ws,     {.id = 0} },
1032         { MODKEY | ShiftMask,   XK_2,           send_to_ws,     {.id = 1} },
1033         { MODKEY | ShiftMask,   XK_3,           send_to_ws,     {.id = 2} },
1034         { MODKEY | ShiftMask,   XK_4,           send_to_ws,     {.id = 3} },
1035         { MODKEY | ShiftMask,   XK_5,           send_to_ws,     {.id = 4} },
1036         { MODKEY | ShiftMask,   XK_6,           send_to_ws,     {.id = 5} },
1037         { MODKEY | ShiftMask,   XK_7,           send_to_ws,     {.id = 6} },
1038         { MODKEY | ShiftMask,   XK_8,           send_to_ws,     {.id = 7} },
1039         { MODKEY | ShiftMask,   XK_9,           send_to_ws,     {.id = 8} },
1040         { MODKEY | ShiftMask,   XK_0,           send_to_ws,     {.id = 9} },
1041         { MODKEY,               XK_b,           bar_toggle,     {0} },
1042         { MODKEY,               XK_Tab,         focus,          {.id = SWM_ARG_ID_FOCUSNEXT} },
1043         { MODKEY | ShiftMask,   XK_Tab,         focus,          {.id = SWM_ARG_ID_FOCUSPREV} },
1044 };
1045
1046 void
1047 updatenumlockmask(void)
1048 {
1049         unsigned int            i, j;
1050         XModifierKeymap         *modmap;
1051
1052         DNPRINTF(SWM_D_MISC, "updatenumlockmask\n");
1053         numlockmask = 0;
1054         modmap = XGetModifierMapping(display);
1055         for (i = 0; i < 8; i++)
1056                 for (j = 0; j < modmap->max_keypermod; j++)
1057                         if (modmap->modifiermap[i * modmap->max_keypermod + j]
1058                           == XKeysymToKeycode(display, XK_Num_Lock))
1059                                 numlockmask = (1 << i);
1060
1061         XFreeModifiermap(modmap);
1062 }
1063
1064 void
1065 grabkeys(void)
1066 {
1067         unsigned int            i, j;
1068         KeyCode                 code;
1069         unsigned int            modifiers[] =
1070             { 0, LockMask, numlockmask, numlockmask | LockMask };
1071
1072         DNPRINTF(SWM_D_MISC, "grabkeys\n");
1073         updatenumlockmask();
1074
1075         XUngrabKey(display, AnyKey, AnyModifier, root);
1076         for (i = 0; i < LENGTH(keys); i++) {
1077                 if ((code = XKeysymToKeycode(display, keys[i].keysym)))
1078                         for (j = 0; j < LENGTH(modifiers); j++)
1079                                 XGrabKey(display, code,
1080                                     keys[i].mod | modifiers[j], root,
1081                                     True, GrabModeAsync, GrabModeAsync);
1082         }
1083 }
1084 void
1085 expose(XEvent *e)
1086 {
1087         DNPRINTF(SWM_D_EVENT, "expose: window: %lu\n", e->xexpose.window);
1088 }
1089
1090 void
1091 keypress(XEvent *e)
1092 {
1093         unsigned int            i;
1094         KeySym                  keysym;
1095         XKeyEvent               *ev = &e->xkey;
1096
1097         DNPRINTF(SWM_D_EVENT, "keypress: window: %lu\n", ev->window);
1098
1099         keysym = XKeycodeToKeysym(display, (KeyCode)ev->keycode, 0);
1100         for (i = 0; i < LENGTH(keys); i++)
1101                 if (keysym == keys[i].keysym
1102                    && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
1103                    && keys[i].func)
1104                         keys[i].func(&(keys[i].args));
1105 }
1106
1107 void
1108 buttonpress(XEvent *e)
1109 {
1110         XButtonPressedEvent     *ev = &e->xbutton;
1111 #ifdef SWM_CLICKTOFOCUS
1112         struct ws_win           *win;
1113 #endif
1114
1115
1116         DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window);
1117
1118         if (ev->window == root)
1119                 return;
1120         if (ev->window == ws[current_ws].focus->id)
1121                 return;
1122 #ifdef SWM_CLICKTOFOCUS
1123         TAILQ_FOREACH(win, &ws[current_ws].winlist, entry)
1124                 if (win->id == ev->window) {
1125                         /* focus in the clicked window */
1126                         XSetWindowBorder(display, ev->window, 0xff0000);
1127                         XSetWindowBorder(display,
1128                             ws[current_ws].focus->id, 0x888888);
1129                         XSetInputFocus(display, ev->window, RevertToPointerRoot,
1130                             CurrentTime);
1131                         ws[current_ws].focus = win;
1132                         XSync(display, False);
1133                         break;
1134         }
1135 #endif
1136 }
1137
1138 void
1139 set_win_state(struct ws_win *win, long state)
1140 {
1141         long                    data[] = {state, None};
1142
1143         DNPRINTF(SWM_D_EVENT, "set_win_state: window: %lu\n", win->id);
1144
1145         XChangeProperty(display, win->id, astate, astate, 32, PropModeReplace,
1146             (unsigned char *)data, 2);
1147 }
1148
1149 struct ws_win *
1150 manage_window(Window id)
1151 {
1152         Window                  trans;
1153         struct ws_win           *win;
1154         XClassHint              ch;
1155
1156         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
1157                 if (win->id == id)
1158                         return (win);   /* already being managed */
1159         }
1160
1161         if ((win = calloc(1, sizeof(struct ws_win))) == NULL)
1162                 errx(1, "calloc: failed to allocate memory for new window");
1163
1164         win->id = id;
1165         TAILQ_INSERT_TAIL(&ws[current_ws].winlist, win, entry);
1166         ws[current_ws].focus = win; /* make new win focused */
1167
1168         XGetTransientForHint(display, win->id, &trans);
1169         if (trans) {
1170                 win->transient = trans;
1171                 DNPRINTF(SWM_D_MISC, "manage_window: win %u transient %u\n",
1172                     (unsigned)win->id, win->transient);
1173         }
1174         XGetWindowAttributes(display, win->id, &win->wa);
1175         win->g.w = win->wa.width;
1176         win->g.h = win->wa.height;
1177         win->g.x = win->wa.x;
1178         win->g.y = win->wa.y;
1179
1180         /* XXX make this a table */
1181         bzero(&ch, sizeof ch);
1182         if (XGetClassHint(display, win->id, &ch)) {
1183                 /*fprintf(stderr, "class: %s name: %s\n", ch.res_class, ch.res_name); */
1184                 if (!strcmp(ch.res_class, "MPlayer") && !strcmp(ch.res_name, "xv")) {
1185                         win->floating = 1;
1186                 }
1187                 if (ch.res_class)
1188                         XFree(ch.res_class);
1189                 if (ch.res_name)
1190                         XFree(ch.res_name);
1191         }
1192
1193         XSelectInput(display, id, EnterWindowMask | FocusChangeMask |
1194             PropertyChangeMask | StructureNotifyMask);
1195
1196         set_win_state(win, NormalState);
1197
1198         return (win);
1199 }
1200
1201 void
1202 configurerequest(XEvent *e)
1203 {
1204         XConfigureRequestEvent  *ev = &e->xconfigurerequest;
1205         struct ws_win           *win;
1206         int                     new = 1;
1207         XWindowChanges          wc;
1208
1209         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
1210                 if (win->id == ev->window) {
1211                         new = 0;
1212                         break;
1213                 }
1214         }
1215
1216         if (new) {
1217                 DNPRINTF(SWM_D_EVENT, "configurerequest: new window: %lu\n",
1218                     ev->window);
1219                 bzero(&wc, sizeof wc);
1220                 wc.x = ev->x;
1221                 wc.y = ev->y;
1222                 wc.width = ev->width;
1223                 wc.height = ev->height;
1224                 wc.border_width = ev->border_width;
1225                 wc.sibling = ev->above;
1226                 wc.stack_mode = ev->detail;
1227                 XConfigureWindow(display, ev->window, ev->value_mask, &wc);
1228         } else {
1229                 DNPRINTF(SWM_D_EVENT, "configurerequest: change window: %lu\n",
1230                     ev->window);
1231                 if(win->floating) {
1232                         if(ev->value_mask & CWX)
1233                                 win->g.x = ev->x;
1234                         if(ev->value_mask & CWY)
1235                                 win->g.y = ev->y;
1236                         if(ev->value_mask & CWWidth)
1237                                 win->g.w = ev->width;
1238                         if(ev->value_mask & CWHeight)
1239                                 win->g.h = ev->height;
1240                         /* this seems to be full screen */
1241                         if (win->g.w > WIDTH) {
1242                                 /* kill border */
1243                                 win->g.x -= 1;
1244                                 win->g.w += 1;
1245                         }
1246                         if (win->g.h > HEIGHT) {
1247                                 /* kill border */
1248                                 win->g.y -= 1;
1249                                 win->g.h += 1;
1250                         }
1251                         if((ev->value_mask & (CWX|CWY)) && !(ev->value_mask & (CWWidth|CWHeight)))
1252                                 config_win(win);
1253                         XMoveResizeWindow(display, win->id, win->g.x, win->g.y, win->g.w, win->g.h);
1254                 } else
1255                         config_win(win);
1256         }
1257 }
1258
1259 void
1260 configurenotify(XEvent *e)
1261 {
1262         DNPRINTF(SWM_D_EVENT, "configurenotify: window: %lu\n",
1263             e->xconfigure.window);
1264 }
1265
1266 void
1267 destroynotify(XEvent *e)
1268 {
1269         struct ws_win           *win;
1270         XDestroyWindowEvent     *ev = &e->xdestroywindow;
1271
1272         DNPRINTF(SWM_D_EVENT, "destroynotify: window %lu\n", ev->window);
1273
1274         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
1275                 if (ev->window == win->id) {
1276                         /* find a window to focus */
1277                         ws[current_ws].focus = TAILQ_PREV(win,
1278                             ws_win_list, entry);
1279                         if (ws[current_ws].focus == NULL)
1280                                 ws[current_ws].focus =
1281                                     TAILQ_FIRST(&ws[current_ws].winlist);
1282                         if (win == ws[current_ws].focus)
1283                                 ws[current_ws].focus = NULL;
1284
1285                         TAILQ_REMOVE(&ws[current_ws].winlist, win, entry);
1286                         set_win_state(win, WithdrawnState);
1287                         free(win);
1288                         break;
1289                 }
1290         }
1291
1292         stack();
1293 }
1294
1295 void
1296 enternotify(XEvent *e)
1297 {
1298         XCrossingEvent          *ev = &e->xcrossing;
1299         struct ws_win           *win;
1300
1301         DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window);
1302
1303         if ((ev->mode != NotifyNormal || ev->detail == NotifyInferior) &&
1304             ev->window != root)
1305                 return;
1306         if (ignore_enter) {
1307                 /* eat event(s) to prevent autofocus */
1308                 ignore_enter--;
1309                 return;
1310         }
1311         TAILQ_FOREACH (win, &ws[current_ws].winlist, entry) {
1312                 if (win->id == ev->window)
1313                         focus_win(win);
1314                 else
1315                         unfocus_win(win);
1316         }
1317 }
1318
1319 void
1320 focusin(XEvent *e)
1321 {
1322         XFocusChangeEvent       *ev = &e->xfocus;
1323
1324         DNPRINTF(SWM_D_EVENT, "focusin: window: %lu\n", ev->window);
1325
1326         if (ev->window == root)
1327                 return;
1328         /*
1329          * kill grab for now so that we can cut and paste , this screws up
1330          * click to focus
1331          */
1332         /*
1333         DNPRINTF(SWM_D_EVENT, "focusin: window: %lu grabbing\n", ev->window);
1334         XGrabButton(display, Button1, AnyModifier, ev->window, False,
1335             ButtonPress, GrabModeAsync, GrabModeSync, None, None);
1336         */
1337 }
1338
1339 void
1340 mappingnotify(XEvent *e)
1341 {
1342         XMappingEvent           *ev = &e->xmapping;
1343
1344         DNPRINTF(SWM_D_EVENT, "mappingnotify: window: %lu\n", ev->window);
1345
1346         XRefreshKeyboardMapping(ev);
1347         if (ev->request == MappingKeyboard)
1348                 grabkeys();
1349 }
1350
1351 void
1352 maprequest(XEvent *e)
1353 {
1354         XMapRequestEvent        *ev = &e->xmaprequest;
1355         XWindowAttributes       wa;
1356
1357         DNPRINTF(SWM_D_EVENT, "maprequest: window: %lu\n",
1358             e->xmaprequest.window);
1359
1360         if (!XGetWindowAttributes(display, ev->window, &wa))
1361                 return;
1362         if (wa.override_redirect)
1363                 return;
1364         manage_window(e->xmaprequest.window);
1365         stack();
1366 }
1367
1368 void
1369 propertynotify(XEvent *e)
1370 {
1371         DNPRINTF(SWM_D_EVENT, "propertynotify: window: %lu\n",
1372             e->xproperty.window);
1373 }
1374
1375 void
1376 unmapnotify(XEvent *e)
1377 {
1378         DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window);
1379 }
1380
1381 void
1382 visibilitynotify(XEvent *e)
1383 {
1384         DNPRINTF(SWM_D_EVENT, "visibilitynotify: window: %lu\n", e->xvisibility.window);
1385
1386         if (e->xvisibility.window == bar_window &&
1387             e->xvisibility.state == VisibilityUnobscured)
1388                 bar_print();
1389 }
1390
1391 void                    (*handler[LASTEvent])(XEvent *) = {
1392                                 [Expose] = expose,
1393                                 [KeyPress] = keypress,
1394                                 [ButtonPress] = buttonpress,
1395                                 [ConfigureRequest] = configurerequest,
1396                                 [ConfigureNotify] = configurenotify,
1397                                 [DestroyNotify] = destroynotify,
1398                                 [EnterNotify] = enternotify,
1399                                 [FocusIn] = focusin,
1400                                 [MappingNotify] = mappingnotify,
1401                                 [MapRequest] = maprequest,
1402                                 [PropertyNotify] = propertynotify,
1403                                 [UnmapNotify] = unmapnotify,
1404                                 [VisibilityNotify] = visibilitynotify,
1405 };
1406
1407 int
1408 xerror_start(Display *d, XErrorEvent *ee)
1409 {
1410         other_wm = 1;
1411         return (-1);
1412 }
1413
1414 int
1415 xerror(Display *d, XErrorEvent *ee)
1416 {
1417         /* fprintf(stderr, "error: %p %p\n", display, ee); */
1418         return (-1);
1419 }
1420
1421 int
1422 active_wm(void)
1423 {
1424         other_wm = 0;
1425         xerrorxlib = XSetErrorHandler(xerror_start);
1426
1427         /* this causes an error if some other window manager is running */
1428         XSelectInput(display, DefaultRootWindow(display),
1429             SubstructureRedirectMask);
1430         XSync(display, False);
1431         if (other_wm)
1432                 return (1);
1433
1434         XSetErrorHandler(xerror);
1435         XSync(display, False);
1436         return (0);
1437 }
1438
1439 long
1440 getstate(Window w)
1441 {
1442         int                     format, status;
1443         long                    result = -1;
1444         unsigned char           *p = NULL;
1445         unsigned long           n, extra;
1446         Atom                    real;
1447
1448         astate = XInternAtom(display, "WM_STATE", False);
1449         status = XGetWindowProperty(display, w, astate, 0L, 2L, False, astate,
1450             &real, &format, &n, &extra, (unsigned char **)&p);
1451         if (status != Success)
1452                 return (-1);
1453         if (n != 0)
1454                 result = *p;
1455         XFree(p);
1456         return (result);
1457 }
1458
1459 int
1460 main(int argc, char *argv[])
1461 {
1462         struct passwd           *pwd;
1463         char                    conf[PATH_MAX], *cfile = NULL;
1464         struct stat             sb;
1465         XEvent                  e;
1466         unsigned int            i, j, num;
1467         Window                  d1, d2, *wins = NULL;
1468         XWindowAttributes       wa;
1469
1470         start_argv = argv;
1471         fprintf(stderr, "Welcome to scrotwm V%s\n", SWM_VERSION);
1472         if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
1473                 warnx("no locale support");
1474
1475         if (!(display = XOpenDisplay(0)))
1476                 errx(1, "can not open display");
1477
1478         if (active_wm())
1479                 errx(1, "other wm running");
1480
1481         screen = DefaultScreen(display);
1482         root = RootWindow(display, screen);
1483         astate = XInternAtom(display, "WM_STATE", False);
1484
1485         /* set default colors */
1486         color_focus = name_to_color("red");
1487         color_unfocus = name_to_color("rgb:88/88/88");
1488         bar_border = name_to_color("rgb:00/80/80");
1489         bar_color = name_to_color("black");
1490         bar_font_color = name_to_color("rgb:a0/a0/a0");
1491
1492         /* look for local and global conf file */
1493         pwd = getpwuid(getuid());
1494         if (pwd == NULL)
1495                 errx(1, "invalid user %d", getuid());
1496
1497         snprintf(conf, sizeof conf, "%s/.%s", pwd->pw_dir, SWM_CONF_FILE);
1498         if (stat(conf, &sb) != -1) {
1499                 if (S_ISREG(sb.st_mode))
1500                         cfile = conf;
1501         } else {
1502                 /* try global conf file */
1503                 snprintf(conf, sizeof conf, "/etc/%s", SWM_CONF_FILE);
1504                 if (!stat(conf, &sb))
1505                         if (S_ISREG(sb.st_mode))
1506                                 cfile = conf;
1507         }
1508         if (cfile)
1509                 conf_load(cfile);
1510
1511         /* init all workspaces */
1512         for (i = 0; i < SWM_WS_MAX; i++) {
1513                 ws[i].visible = 0;
1514                 ws[i].restack = 1;
1515                 ws[i].focus = NULL;
1516                 ws[i].g.x = 0;
1517                 ws[i].g.y = 0;
1518                 ws[i].g.w = DisplayWidth(display, screen) - 2;
1519                 ws[i].g.h = DisplayHeight(display, screen) - 2;
1520                 TAILQ_INIT(&ws[i].winlist);
1521
1522                 for (j = 0; layouts[j].l_stack != NULL; j++) {
1523                         if (layouts[j].l_init != NULL)
1524                                 layouts[j].l_init(i);
1525                 }
1526                 ws[i].cur_layout = &layouts[0];
1527         }
1528         /* make work space 1 active */
1529         ws[0].visible = 1;
1530
1531         /* grab existing windows */
1532         if (XQueryTree(display, root, &d1, &d2, &wins, &num)) {
1533                 /* normal windows */
1534                 for (i = 0; i < num; i++) {
1535                         XGetWindowAttributes(display, wins[i], &wa);
1536                         if (!XGetWindowAttributes(display, wins[i], &wa) ||
1537                             wa.override_redirect || XGetTransientForHint(display, wins[i], &d1))
1538                                 continue;
1539                         if (wa.map_state == IsViewable || getstate(wins[i]) == NormalState)
1540                                 manage_window(wins[i]);
1541                 }
1542                 /* transient windows */
1543                 for (i = 0; i < num; i++) {
1544                         if (!XGetWindowAttributes(display, wins[i], &wa))
1545                                 continue;
1546                         if (XGetTransientForHint(display, wins[i], &d1) &&
1547                             (wa.map_state == IsViewable || getstate(wins[i]) ==
1548                             NormalState))
1549                                 manage_window(wins[i]);
1550                 }
1551                 if (wins)
1552                         XFree(wins);
1553         }
1554         ws[0].focus = TAILQ_FIRST(&ws[0].winlist);
1555
1556         /* setup status bar */
1557         bar_setup();
1558
1559         XSelectInput(display, root, SubstructureRedirectMask |
1560             SubstructureNotifyMask | ButtonPressMask | KeyPressMask |
1561             EnterWindowMask | LeaveWindowMask | StructureNotifyMask |
1562             FocusChangeMask | PropertyChangeMask | ExposureMask);
1563
1564         grabkeys();
1565         stack();
1566
1567         while (running) {
1568                 XNextEvent(display, &e);
1569                 if (handler[e.type])
1570                         handler[e.type](&e);
1571         }
1572
1573         XCloseDisplay(display);
1574
1575         return (0);
1576 }