tabbed.c

   1 /*
   2  * See LICENSE file for copyright and license details.
   3  */
   4
   5 #include <sys/wait.h>
   6 #include <locale.h>
   7 #include <signal.h>
   8 #include <stdarg.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <X11/Xatom.h>
  14 #include <X11/Xlib.h>
  15 #include <X11/Xproto.h>
  16 #include <X11/Xutil.h>
  17 #include <X11/XKBlib.h>
  18 #include <X11/Xft/Xft.h>
  19
  20 #include "arg.h"
  21
  22 /* XEMBED messages */
  23 #define XEMBED_EMBEDDED_NOTIFY          0
  24 #define XEMBED_WINDOW_ACTIVATE          1
  25 #define XEMBED_WINDOW_DEACTIVATE        2
  26 #define XEMBED_REQUEST_FOCUS            3
  27 #define XEMBED_FOCUS_IN                 4
  28 #define XEMBED_FOCUS_OUT                5
  29 #define XEMBED_FOCUS_NEXT               6
  30 #define XEMBED_FOCUS_PREV               7
  31 /* 8-9 were used for XEMBED_GRAB_KEY/XEMBED_UNGRAB_KEY */
  32 #define XEMBED_MODALITY_ON              10
  33 #define XEMBED_MODALITY_OFF             11
  34 #define XEMBED_REGISTER_ACCELERATOR     12
  35 #define XEMBED_UNREGISTER_ACCELERATOR   13
  36 #define XEMBED_ACTIVATE_ACCELERATOR     14
  37
  38 /* Details for  XEMBED_FOCUS_IN: */
  39 #define XEMBED_FOCUS_CURRENT            0
  40 #define XEMBED_FOCUS_FIRST              1
  41 #define XEMBED_FOCUS_LAST               2
  42
  43 /* Macros */
  44 #define MAX(a, b)               ((a) > (b) ? (a) : (b))
  45 #define MIN(a, b)               ((a) < (b) ? (a) : (b))
  46 #define LENGTH(x)               (sizeof((x)) / sizeof(*(x)))
  47 #define CLEANMASK(mask)         (mask & ~(numlockmask | LockMask))
  48 #define TEXTW(x)                (textnw(x, strlen(x)) + dc.font.height)
  49
  50 enum { ColFG, ColBG, ColLast };       /* color */
  51 enum { WMProtocols, WMDelete, WMName, WMState, WMFullscreen,
  52        XEmbed, WMSelectTab, WMLast }; /* default atoms */
  53
  54 typedef union {
  55         int i;
  56         const void *v;
  57 } Arg;
  58
  59 typedef struct {
  60         unsigned int mod;
  61         KeySym keysym;
  62         void (*func)(const Arg *);
  63         const Arg arg;
  64 } Key;
  65
  66 typedef struct {
  67         int x, y, w, h;
  68         XftColor norm[ColLast];
  69         XftColor sel[ColLast];
  70         XftColor urg[ColLast];
  71         Drawable drawable;
  72         GC gc;
  73         struct {
  74                 int ascent;
  75                 int descent;
  76                 int height;
  77                 XftFont *xfont;
  78         } font;
  79 } DC; /* draw context */
  80
  81 typedef struct {
  82         char name[256];
  83         Window win;
  84         int tabx;
  85         Bool urgent;
  86         Bool closed;
  87 } Client;
  88
  89 /* function declarations */
  90 static void buttonpress(const XEvent *e);
  91 static void cleanup(void);
  92 static void clientmessage(const XEvent *e);
  93 static void configurenotify(const XEvent *e);
  94 static void configurerequest(const XEvent *e);
  95 static void createnotify(const XEvent *e);
  96 static void destroynotify(const XEvent *e);
  97 static void die(const char *errstr, ...);
  98 static void drawbar(void);
  99 static void drawtext(const char *text, XftColor col[ColLast]);
 100 static void *ecalloc(size_t n, size_t size);
 101 static void *erealloc(void *o, size_t size);
 102 static void expose(const XEvent *e);
 103 static void focus(int c);
 104 static void focusin(const XEvent *e);
 105 static void focusonce(const Arg *arg);
 106 static void focusurgent(const Arg *arg);
 107 static void fullscreen(const Arg *arg);
 108 static char *getatom(int a);
 109 static int getclient(Window w);
 110 static XftColor getcolor(const char *colstr);
 111 static int getfirsttab(void);
 112 static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
 113 static void initfont(const char *fontstr);
 114 static Bool isprotodel(int c);
 115 static void keypress(const XEvent *e);
 116 static void killclient(const Arg *arg);
 117 static void manage(Window win);
 118 static void maprequest(const XEvent *e);
 119 static void move(const Arg *arg);
 120 static void movetab(const Arg *arg);
 121 static void propertynotify(const XEvent *e);
 122 static void resize(int c, int w, int h);
 123 static void rotate(const Arg *arg);
 124 static void run(void);
 125 static void sendxembed(int c, long msg, long detail, long d1, long d2);
 126 static void setcmd(int argc, char *argv[], int);
 127 static void setup(void);
 128 static void sigchld(int unused);
 129 static void spawn(const Arg *arg);
 130 static int textnw(const char *text, unsigned int len);
 131 static void toggle(const Arg *arg);
 132 static void unmanage(int c);
 133 static void unmapnotify(const XEvent *e);
 134 static void updatenumlockmask(void);
 135 static void updatetitle(int c);
 136 static int xerror(Display *dpy, XErrorEvent *ee);
 137 static void xsettitle(Window w, const char *str);
 138
 139 /* variables */
 140 static int screen;
 141 static void (*handler[LASTEvent]) (const XEvent *) = {
 142         [ButtonPress] = buttonpress,
 143         [ClientMessage] = clientmessage,
 144         [ConfigureNotify] = configurenotify,
 145         [ConfigureRequest] = configurerequest,
 146         [CreateNotify] = createnotify,
 147         [UnmapNotify] = unmapnotify,
 148         [DestroyNotify] = destroynotify,
 149         [Expose] = expose,
 150         [FocusIn] = focusin,
 151         [KeyPress] = keypress,
 152         [MapRequest] = maprequest,
 153         [PropertyNotify] = propertynotify,
 154 };
 155 static int bh, wx, wy, ww, wh;
 156 static unsigned int numlockmask;
 157 static Bool running = True, nextfocus, doinitspawn = True,
 158             fillagain = False, closelastclient = False,
 159             killclientsfirst = False;
 160 static Display *dpy;
 161 static DC dc;
 162 static Atom wmatom[WMLast];
 163 static Window root, win;
 164 static Client **clients;
 165 static int nclients, sel = -1, lastsel = -1;
 166 static int (*xerrorxlib)(Display *, XErrorEvent *);
 167 static int cmd_append_pos;
 168 static char winid[64];
 169 static char **cmd;
 170 static char *wmname = "tabbed";
 171 static const char *geometry;
 172
 173 char *argv0;
 174
 175 /* configuration, allows nested code to access above variables */
 176 #include "config.h"
 177
 178 void
 179 buttonpress(const XEvent *e)
 180 {
 181         const XButtonPressedEvent *ev = &e->xbutton;
 182         int i, fc;
 183         Arg arg;
 184
 185         if (ev->y < 0 || ev->y > bh)
 186                 return;
 187
 188         if (((fc = getfirsttab()) > 0 && ev->x < TEXTW(before)) || ev->x < 0)
 189                 return;
 190
 191         for (i = fc; i < nclients; i++) {
 192                 if (clients[i]->tabx > ev->x) {
 193                         switch (ev->button) {
 194                         case Button1:
 195                                 focus(i);
 196                                 break;
 197                         case Button2:
 198                                 focus(i);
 199                                 killclient(NULL);
 200                                 break;
 201                         case Button4: /* FALLTHROUGH */
 202                         case Button5:
 203                                 arg.i = ev->button == Button4 ? -1 : 1;
 204                                 rotate(&arg);
 205                                 break;
 206                         }
 207                         break;
 208                 }
 209         }
 210 }
 211
 212 void
 213 cleanup(void)
 214 {
 215         int i;
 216
 217         for (i = 0; i < nclients; i++) {
 218                 focus(i);
 219                 killclient(NULL);
 220                 XReparentWindow(dpy, clients[i]->win, root, 0, 0);
 221                 unmanage(i);
 222         }
 223         free(clients);
 224         clients = NULL;
 225
 226         XFreePixmap(dpy, dc.drawable);
 227         XFreeGC(dpy, dc.gc);
 228         XDestroyWindow(dpy, win);
 229         XSync(dpy, False);
 230         free(cmd);
 231 }
 232
 233 void
 234 clientmessage(const XEvent *e)
 235 {
 236         const XClientMessageEvent *ev = &e->xclient;
 237
 238         if (ev->message_type == wmatom[WMProtocols] &&
 239             ev->data.l[0] == wmatom[WMDelete]) {
 240                 if (nclients > 1 && killclientsfirst) {
 241                         killclient(0);
 242                         return;
 243                 }
 244                 running = False;
 245         }
 246 }
 247
 248 void
 249 configurenotify(const XEvent *e)
 250 {
 251         const XConfigureEvent *ev = &e->xconfigure;
 252
 253         if (ev->window == win && (ev->width != ww || ev->height != wh)) {
 254                 ww = ev->width;
 255                 wh = ev->height;
 256                 XFreePixmap(dpy, dc.drawable);
 257                 dc.drawable = XCreatePixmap(dpy, root, ww, wh,
 258                               DefaultDepth(dpy, screen));
 259                 if (sel > -1)
 260                         resize(sel, ww, wh - bh);
 261                 XSync(dpy, False);
 262         }
 263 }
 264
 265 void
 266 configurerequest(const XEvent *e)
 267 {
 268         const XConfigureRequestEvent *ev = &e->xconfigurerequest;
 269         XWindowChanges wc;
 270         int c;
 271
 272         if ((c = getclient(ev->window)) > -1) {
 273                 wc.x = 0;
 274                 wc.y = bh;
 275                 wc.width = ww;
 276                 wc.height = wh - bh;
 277                 wc.border_width = 0;
 278                 wc.sibling = ev->above;
 279                 wc.stack_mode = ev->detail;
 280                 XConfigureWindow(dpy, clients[c]->win, ev->value_mask, &wc);
 281         }
 282 }
 283
 284 void
 285 createnotify(const XEvent *e)
 286 {
 287         const XCreateWindowEvent *ev = &e->xcreatewindow;
 288
 289         if (ev->window != win && getclient(ev->window) < 0)
 290                 manage(ev->window);
 291 }
 292
 293 void
 294 destroynotify(const XEvent *e)
 295 {
 296         const XDestroyWindowEvent *ev = &e->xdestroywindow;
 297         int c;
 298
 299         if ((c = getclient(ev->window)) > -1)
 300                 unmanage(c);
 301 }
 302
 303 void
 304 die(const char *errstr, ...)
 305 {
 306         va_list ap;
 307
 308         va_start(ap, errstr);
 309         vfprintf(stderr, errstr, ap);
 310         va_end(ap);
 311         exit(EXIT_FAILURE);
 312 }
 313
 314 void
 315 drawbar(void)
 316 {
 317         XftColor *col;
 318         int c, cc, fc, width;
 319         char *name = NULL;
 320
 321         if (nclients == 0) {
 322                 dc.x = 0;
 323                 dc.w = ww;
 324                 XFetchName(dpy, win, &name);
 325                 drawtext(name ? name : "", dc.norm);
 326                 XCopyArea(dpy, dc.drawable, win, dc.gc, 0, 0, ww, bh, 0, 0);
 327                 XSync(dpy, False);
 328
 329                 return;
 330         }
 331
 332         width = ww;
 333         cc = ww / tabwidth;
 334         if (nclients > cc)
 335                 cc = (ww - TEXTW(before) - TEXTW(after)) / tabwidth;
 336
 337         if ((fc = getfirsttab()) + cc < nclients) {
 338                 dc.w = TEXTW(after);
 339                 dc.x = width - dc.w;
 340                 drawtext(after, dc.sel);
 341                 width -= dc.w;
 342         }
 343         dc.x = 0;
 344
 345         if (fc > 0) {
 346                 dc.w = TEXTW(before);
 347                 drawtext(before, dc.sel);
 348                 dc.x += dc.w;
 349                 width -= dc.w;
 350         }
 351
 352         cc = MIN(cc, nclients);
 353         for (c = fc; c < fc + cc; c++) {
 354                 dc.w = width / cc;
 355                 if (c == sel) {
 356                         col = dc.sel;
 357                         dc.w += width % cc;
 358                 } else {
 359                         col = clients[c]->urgent ? dc.urg : dc.norm;
 360                 }
 361                 drawtext(clients[c]->name, col);
 362                 dc.x += dc.w;
 363                 clients[c]->tabx = dc.x;
 364         }
 365         XCopyArea(dpy, dc.drawable, win, dc.gc, 0, 0, ww, bh, 0, 0);
 366         XSync(dpy, False);
 367 }
 368
 369 void
 370 drawtext(const char *text, XftColor col[ColLast])
 371 {
 372         int i, j, x, y, h, len, olen;
 373         char buf[256];
 374         XftDraw *d;
 375         XRectangle r = { dc.x, dc.y, dc.w, dc.h };
 376
 377         XSetForeground(dpy, dc.gc, col[ColBG].pixel);
 378         XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
 379         if (!text)
 380                 return;
 381
 382         olen = strlen(text);
 383         h = dc.font.ascent + dc.font.descent;
 384         y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent;
 385         x = dc.x + (h / 2);
 386
 387         /* shorten text if necessary */
 388         for (len = MIN(olen, sizeof(buf));
 389                 len && textnw(text, len) > dc.w - h; len--);
 390
 391         if (!len)
 392                 return;
 393
 394         memcpy(buf, text, len);
 395         if (len < olen) {
 396                 for (i = len, j = strlen(titletrim); j && i;
 397                      buf[--i] = titletrim[--j])
 398                         ;
 399         }
 400
 401         d = XftDrawCreate(dpy, dc.drawable, DefaultVisual(dpy, screen), DefaultColormap(dpy, screen));
 402         XftDrawStringUtf8(d, &col[ColFG], dc.font.xfont, x, y, (XftChar8 *) buf, len);
 403         XftDrawDestroy(d);
 404 }
 405
 406 void *
 407 ecalloc(size_t n, size_t size)
 408 {
 409         void *p;
 410
 411         if (!(p = calloc(n, size)))
 412                 die("%s: cannot calloc\n", argv0);
 413         return p;
 414 }
 415
 416 void *
 417 erealloc(void *o, size_t size)
 418 {
 419         void *p;
 420
 421         if (!(p = realloc(o, size)))
 422                 die("%s: cannot realloc\n", argv0);
 423         return p;
 424 }
 425
 426 void
 427 expose(const XEvent *e)
 428 {
 429         const XExposeEvent *ev = &e->xexpose;
 430
 431         if (ev->count == 0 && win == ev->window)
 432                 drawbar();
 433 }
 434
 435 void
 436 focus(int c)
 437 {
 438         char buf[BUFSIZ] = "tabbed-"VERSION" ::";
 439         size_t i, n;
 440         XWMHints* wmh;
 441
 442         /* If c, sel and clients are -1, raise tabbed-win itself */
 443         if (nclients == 0) {
 444                 cmd[cmd_append_pos] = NULL;
 445                 for(i = 0, n = strlen(buf); cmd[i] && n < sizeof(buf); i++)
 446                         n += snprintf(&buf[n], sizeof(buf) - n, " %s", cmd[i]);
 447
 448                 xsettitle(win, buf);
 449                 XRaiseWindow(dpy, win);
 450
 451                 return;
 452         }
 453
 454         if (c < 0 || c >= nclients)
 455                 return;
 456
 457         resize(c, ww, wh - bh);
 458         XRaiseWindow(dpy, clients[c]->win);
 459         XSetInputFocus(dpy, clients[c]->win, RevertToParent, CurrentTime);
 460         sendxembed(c, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT, 0, 0);
 461         sendxembed(c, XEMBED_WINDOW_ACTIVATE, 0, 0, 0);
 462         xsettitle(win, clients[c]->name);
 463
 464         if (sel != c) {
 465                 lastsel = sel;
 466                 sel = c;
 467         }
 468
 469         if (clients[c]->urgent && (wmh = XGetWMHints(dpy, clients[c]->win))) {
 470                 wmh->flags &= ~XUrgencyHint;
 471                 XSetWMHints(dpy, clients[c]->win, wmh);
 472                 clients[c]->urgent = False;
 473                 XFree(wmh);
 474         }
 475
 476         drawbar();
 477         XSync(dpy, False);
 478 }
 479
 480 void
 481 focusin(const XEvent *e)
 482 {
 483         const XFocusChangeEvent *ev = &e->xfocus;
 484         int dummy;
 485         Window focused;
 486
 487         if (ev->mode != NotifyUngrab) {
 488                 XGetInputFocus(dpy, &focused, &dummy);
 489                 if (focused == win)
 490                         focus(sel);
 491         }
 492 }
 493
 494 void
 495 focusonce(const Arg *arg)
 496 {
 497         nextfocus = True;
 498 }
 499
 500 void
 501 focusurgent(const Arg *arg)
 502 {
 503         int c;
 504
 505         if (sel < 0)
 506                 return;
 507
 508         for (c = (sel + 1) % nclients; c != sel; c = (c + 1) % nclients) {
 509                 if (clients[c]->urgent) {
 510                         focus(c);
 511                         return;
 512                 }
 513         }
 514 }
 515
 516 void
 517 fullscreen(const Arg *arg)
 518 {
 519         XEvent e;
 520
 521         e.type = ClientMessage;
 522         e.xclient.window = win;
 523         e.xclient.message_type = wmatom[WMState];
 524         e.xclient.format = 32;
 525         e.xclient.data.l[0] = 2;
 526         e.xclient.data.l[1] = wmatom[WMFullscreen];
 527         e.xclient.data.l[2] = 0;
 528         XSendEvent(dpy, root, False, SubstructureNotifyMask, &e);
 529 }
 530
 531 char *
 532 getatom(int a)
 533 {
 534         static char buf[BUFSIZ];
 535         Atom adummy;
 536         int idummy;
 537         unsigned long ldummy;
 538         unsigned char *p = NULL;
 539
 540         XGetWindowProperty(dpy, win, wmatom[a], 0L, BUFSIZ, False, XA_STRING,
 541                            &adummy, &idummy, &ldummy, &ldummy, &p);
 542         if (p)
 543                 strncpy(buf, (char *)p, LENGTH(buf)-1);
 544         else
 545                 buf[0] = '\0';
 546         XFree(p);
 547
 548         return buf;
 549 }
 550
 551 int
 552 getclient(Window w)
 553 {
 554         int i;
 555
 556         for (i = 0; i < nclients; i++) {
 557                 if (clients[i]->win == w)
 558                         return i;
 559         }
 560
 561         return -1;
 562 }
 563
 564 XftColor
 565 getcolor(const char *colstr)
 566 {
 567         XftColor color;
 568
 569         if (!XftColorAllocName(dpy, DefaultVisual(dpy, screen), DefaultColormap(dpy, screen), colstr, &color))
 570                 die("%s: cannot allocate color '%s'\n", argv0, colstr);
 571
 572         return color;
 573 }
 574
 575 int
 576 getfirsttab(void)
 577 {
 578         int cc, ret;
 579
 580         if (sel < 0)
 581                 return 0;
 582
 583         cc = ww / tabwidth;
 584         if (nclients > cc)
 585                 cc = (ww - TEXTW(before) - TEXTW(after)) / tabwidth;
 586
 587         ret = sel - cc / 2 + (cc + 1) % 2;
 588         return ret < 0 ? 0 :
 589                ret + cc > nclients ? MAX(0, nclients - cc) :
 590                ret;
 591 }
 592
 593 Bool
 594 gettextprop(Window w, Atom atom, char *text, unsigned int size)
 595 {
 596         char **list = NULL;
 597         int n;
 598         XTextProperty name;
 599
 600         if (!text || size == 0)
 601                 return False;
 602
 603         text[0] = '\0';
 604         XGetTextProperty(dpy, w, &name, atom);
 605         if (!name.nitems)
 606                 return False;
 607
 608         if (name.encoding == XA_STRING) {
 609                 strncpy(text, (char *)name.value, size - 1);
 610         } else if (XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Success
 611                    && n > 0 && *list) {
 612                 strncpy(text, *list, size - 1);
 613                 XFreeStringList(list);
 614         }
 615         text[size - 1] = '\0';
 616         XFree(name.value);
 617
 618         return True;
 619 }
 620
 621 void
 622 initfont(const char *fontstr)
 623 {
 624         if (!(dc.font.xfont = XftFontOpenName(dpy, screen, fontstr))
 625             && !(dc.font.xfont = XftFontOpenName(dpy, screen, "fixed")))
 626                 die("error, cannot load font: '%s'\n", fontstr);
 627
 628         dc.font.ascent = dc.font.xfont->ascent;
 629         dc.font.descent = dc.font.xfont->descent;
 630         dc.font.height = dc.font.ascent + dc.font.descent;
 631 }
 632
 633 Bool
 634 isprotodel(int c)
 635 {
 636         int i, n;
 637         Atom *protocols;
 638         Bool ret = False;
 639
 640         if (XGetWMProtocols(dpy, clients[c]->win, &protocols, &n)) {
 641                 for (i = 0; !ret && i < n; i++) {
 642                         if (protocols[i] == wmatom[WMDelete])
 643                                 ret = True;
 644                 }
 645                 XFree(protocols);
 646         }
 647
 648         return ret;
 649 }
 650
 651 void
 652 keypress(const XEvent *e)
 653 {
 654         const XKeyEvent *ev = &e->xkey;
 655         unsigned int i;
 656         KeySym keysym;
 657
 658         keysym = XkbKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0, 0);
 659         for (i = 0; i < LENGTH(keys); i++) {
 660                 if (keysym == keys[i].keysym &&
 661                     CLEANMASK(keys[i].mod) == CLEANMASK(ev->state) &&
 662                     keys[i].func)
 663                         keys[i].func(&(keys[i].arg));
 664         }
 665 }
 666
 667 void
 668 killclient(const Arg *arg)
 669 {
 670         XEvent ev;
 671
 672         if (sel < 0)
 673                 return;
 674
 675         if (isprotodel(sel) && !clients[sel]->closed) {
 676                 ev.type = ClientMessage;
 677                 ev.xclient.window = clients[sel]->win;
 678                 ev.xclient.message_type = wmatom[WMProtocols];
 679                 ev.xclient.format = 32;
 680                 ev.xclient.data.l[0] = wmatom[WMDelete];
 681                 ev.xclient.data.l[1] = CurrentTime;
 682                 XSendEvent(dpy, clients[sel]->win, False, NoEventMask, &ev);
 683                 clients[sel]->closed = True;
 684         } else {
 685                 XKillClient(dpy, clients[sel]->win);
 686         }
 687 }
 688
 689 void
 690 manage(Window w)
 691 {
 692         updatenumlockmask();
 693         {
 694                 int i, j, nextpos;
 695                 unsigned int modifiers[] = { 0, LockMask, numlockmask,
 696                                              numlockmask | LockMask };
 697                 KeyCode code;
 698                 Client *c;
 699                 XEvent e;
 700
 701                 XWithdrawWindow(dpy, w, 0);
 702                 XReparentWindow(dpy, w, win, 0, bh);
 703                 XSelectInput(dpy, w, PropertyChangeMask |
 704                              StructureNotifyMask | EnterWindowMask);
 705                 XSync(dpy, False);
 706
 707                 for (i = 0; i < LENGTH(keys); i++) {
 708                         if ((code = XKeysymToKeycode(dpy, keys[i].keysym))) {
 709                                 for (j = 0; j < LENGTH(modifiers); j++) {
 710                                         XGrabKey(dpy, code, keys[i].mod |
 711                                                  modifiers[j], w, True,
 712                                                  GrabModeAsync, GrabModeAsync);
 713                                 }
 714                         }
 715                 }
 716
 717                 c = ecalloc(1, sizeof *c);
 718                 c->win = w;
 719
 720                 nclients++;
 721                 clients = erealloc(clients, sizeof(Client *) * nclients);
 722
 723                 if(npisrelative) {
 724                         nextpos = sel + newposition;
 725                 } else {
 726                         if (newposition < 0)
 727                                 nextpos = nclients - newposition;
 728                         else
 729                                 nextpos = newposition;
 730                 }
 731                 if (nextpos >= nclients)
 732                         nextpos = nclients - 1;
 733                 if (nextpos < 0)
 734                         nextpos = 0;
 735
 736                 if (nclients > 1 && nextpos < nclients - 1)
 737                         memmove(&clients[nextpos + 1], &clients[nextpos],
 738                                 sizeof(Client *) * (nclients - nextpos - 1));
 739
 740                 clients[nextpos] = c;
 741                 updatetitle(nextpos);
 742
 743                 XLowerWindow(dpy, w);
 744                 XMapWindow(dpy, w);
 745
 746                 e.xclient.window = w;
 747                 e.xclient.type = ClientMessage;
 748                 e.xclient.message_type = wmatom[XEmbed];
 749                 e.xclient.format = 32;
 750                 e.xclient.data.l[0] = CurrentTime;
 751                 e.xclient.data.l[1] = XEMBED_EMBEDDED_NOTIFY;
 752                 e.xclient.data.l[2] = 0;
 753                 e.xclient.data.l[3] = win;
 754                 e.xclient.data.l[4] = 0;
 755                 XSendEvent(dpy, root, False, NoEventMask, &e);
 756
 757                 XSync(dpy, False);
 758
 759                 /* Adjust sel before focus does set it to lastsel. */
 760                 if (sel >= nextpos)
 761                         sel++;
 762                 focus(nextfocus ? nextpos :
 763                       sel < 0 ? 0 :
 764                       sel);
 765                 nextfocus = foreground;
 766         }
 767 }
 768
 769 void
 770 maprequest(const XEvent *e)
 771 {
 772         const XMapRequestEvent *ev = &e->xmaprequest;
 773
 774         if (getclient(ev->window) < 0)
 775                 manage(ev->window);
 776 }
 777
 778 void
 779 move(const Arg *arg)
 780 {
 781         if (arg->i >= 0 && arg->i < nclients)
 782                 focus(arg->i);
 783 }
 784
 785 void
 786 movetab(const Arg *arg)
 787 {
 788         int c;
 789         Client *new;
 790
 791         if (sel < 0)
 792                 return;
 793
 794         c = (sel + arg->i) % nclients;
 795         if (c < 0)
 796                 c += nclients;
 797
 798         if (c == sel)
 799                 return;
 800
 801         new = clients[sel];
 802         if (sel < c)
 803                 memmove(&clients[sel], &clients[sel+1],
 804                         sizeof(Client *) * (c - sel));
 805         else
 806                 memmove(&clients[c+1], &clients[c],
 807                         sizeof(Client *) * (sel - c));
 808         clients[c] = new;
 809         sel = c;
 810
 811         drawbar();
 812 }
 813
 814 void
 815 propertynotify(const XEvent *e)
 816 {
 817         const XPropertyEvent *ev = &e->xproperty;
 818         XWMHints *wmh;
 819         int c;
 820         char* selection = NULL;
 821         Arg arg;
 822
 823         if (ev->state == PropertyNewValue && ev->atom == wmatom[WMSelectTab]) {
 824                 selection = getatom(WMSelectTab);
 825                 if (!strncmp(selection, "0x", 2)) {
 826                         arg.i = getclient(strtoul(selection, NULL, 0));
 827                         move(&arg);
 828                 } else {
 829                         cmd[cmd_append_pos] = selection;
 830                         arg.v = cmd;
 831                         spawn(&arg);
 832                 }
 833         } else if (ev->state == PropertyNewValue && ev->atom == XA_WM_HINTS &&
 834                    (c = getclient(ev->window)) > -1 &&
 835                    (wmh = XGetWMHints(dpy, clients[c]->win))) {
 836                 if (wmh->flags & XUrgencyHint) {
 837                         XFree(wmh);
 838                         wmh = XGetWMHints(dpy, win);
 839                         if (c != sel) {
 840                                 if (urgentswitch && wmh &&
 841                                     !(wmh->flags & XUrgencyHint)) {
 842                                         /* only switch, if tabbed was focused
 843                                          * since last urgency hint if WMHints
 844                                          * could not be received,
 845                                          * default to no switch */
 846                                         focus(c);
 847                                 } else {
 848                                         /* if no switch should be performed,
 849                                          * mark tab as urgent */
 850                                         clients[c]->urgent = True;
 851                                         drawbar();
 852                                 }
 853                         }
 854                         if (wmh && !(wmh->flags & XUrgencyHint)) {
 855                                 /* update tabbed urgency hint
 856                                  * if not set already */
 857                                 wmh->flags |= XUrgencyHint;
 858                                 XSetWMHints(dpy, win, wmh);
 859                         }
 860                 }
 861                 XFree(wmh);
 862         } else if (ev->state != PropertyDelete && ev->atom == XA_WM_NAME &&
 863                    (c = getclient(ev->window)) > -1) {
 864                 updatetitle(c);
 865         }
 866 }
 867
 868 void
 869 resize(int c, int w, int h)
 870 {
 871         XConfigureEvent ce;
 872         XWindowChanges wc;
 873
 874         ce.x = 0;
 875         ce.y = bh;
 876         ce.width = wc.width = w;
 877         ce.height = wc.height = h;
 878         ce.type = ConfigureNotify;
 879         ce.display = dpy;
 880         ce.event = clients[c]->win;
 881         ce.window = clients[c]->win;
 882         ce.above = None;
 883         ce.override_redirect = False;
 884         ce.border_width = 0;
 885
 886         XConfigureWindow(dpy, clients[c]->win, CWWidth | CWHeight, &wc);
 887         XSendEvent(dpy, clients[c]->win, False, StructureNotifyMask,
 888                    (XEvent *)&ce);
 889 }
 890
 891 void
 892 rotate(const Arg *arg)
 893 {
 894         int nsel = -1;
 895
 896         if (sel < 0)
 897                 return;
 898
 899         if (arg->i == 0) {
 900                 if (lastsel > -1)
 901                         focus(lastsel);
 902         } else if (sel > -1) {
 903                 /* Rotating in an arg->i step around the clients. */
 904                 nsel = sel + arg->i;
 905                 while (nsel >= nclients)
 906                         nsel -= nclients;
 907                 while (nsel < 0)
 908                         nsel += nclients;
 909                 focus(nsel);
 910         }
 911 }
 912
 913 void
 914 run(void)
 915 {
 916         XEvent ev;
 917
 918         /* main event loop */
 919         XSync(dpy, False);
 920         drawbar();
 921         if (doinitspawn == True)
 922                 spawn(NULL);
 923
 924         while (running) {
 925                 XNextEvent(dpy, &ev);
 926                 if (handler[ev.type])
 927                         (handler[ev.type])(&ev); /* call handler */
 928         }
 929 }
 930
 931 void
 932 sendxembed(int c, long msg, long detail, long d1, long d2)
 933 {
 934         XEvent e = { 0 };
 935
 936         e.xclient.window = clients[c]->win;
 937         e.xclient.type = ClientMessage;
 938         e.xclient.message_type = wmatom[XEmbed];
 939         e.xclient.format = 32;
 940         e.xclient.data.l[0] = CurrentTime;
 941         e.xclient.data.l[1] = msg;
 942         e.xclient.data.l[2] = detail;
 943         e.xclient.data.l[3] = d1;
 944         e.xclient.data.l[4] = d2;
 945         XSendEvent(dpy, clients[c]->win, False, NoEventMask, &e);
 946 }
 947
 948 void
 949 setcmd(int argc, char *argv[], int replace)
 950 {
 951         int i;
 952
 953         cmd = ecalloc(argc + 3, sizeof(*cmd));
 954         if (argc == 0)
 955                 return;
 956         for (i = 0; i < argc; i++)
 957                 cmd[i] = argv[i];
 958         cmd[replace > 0 ? replace : argc] = winid;
 959         cmd_append_pos = argc + !replace;
 960         cmd[cmd_append_pos] = cmd[cmd_append_pos + 1] = NULL;
 961 }
 962
 963 void
 964 setup(void)
 965 {
 966         int bitm, tx, ty, tw, th, dh, dw, isfixed;
 967         XWMHints *wmh;
 968         XClassHint class_hint;
 969         XSizeHints *size_hint;
 970
 971         /* clean up any zombies immediately */
 972         sigchld(0);
 973
 974         /* init screen */
 975         screen = DefaultScreen(dpy);
 976         root = RootWindow(dpy, screen);
 977         initfont(font);
 978         bh = dc.h = dc.font.height + 2;
 979
 980         /* init atoms */
 981         wmatom[WMDelete] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
 982         wmatom[WMFullscreen] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN",
 983                                            False);
 984         wmatom[WMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
 985         wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
 986         wmatom[WMSelectTab] = XInternAtom(dpy, "_TABBED_SELECT_TAB", False);
 987         wmatom[WMState] = XInternAtom(dpy, "_NET_WM_STATE", False);
 988         wmatom[XEmbed] = XInternAtom(dpy, "_XEMBED", False);
 989
 990         /* init appearance */
 991         wx = 0;
 992         wy = 0;
 993         ww = 800;
 994         wh = 600;
 995         isfixed = 0;
 996
 997         if (geometry) {
 998                 tx = ty = tw = th = 0;
 999                 bitm = XParseGeometry(geometry, &tx, &ty, (unsigned *)&tw,
1000                                       (unsigned *)&th);
1001                 if (bitm & XValue)
1002                         wx = tx;
1003                 if (bitm & YValue)
1004                         wy = ty;
1005                 if (bitm & WidthValue)
1006                         ww = tw;
1007                 if (bitm & HeightValue)
1008                         wh = th;
1009                 if (bitm & XNegative && wx == 0)
1010                         wx = -1;
1011                 if (bitm & YNegative && wy == 0)
1012                         wy = -1;
1013                 if (bitm & (HeightValue | WidthValue))
1014                         isfixed = 1;
1015
1016                 dw = DisplayWidth(dpy, screen);
1017                 dh = DisplayHeight(dpy, screen);
1018                 if (wx < 0)
1019                         wx = dw + wx - ww - 1;
1020                 if (wy < 0)
1021                         wy = dh + wy - wh - 1;
1022         }
1023
1024         dc.norm[ColBG] = getcolor(normbgcolor);
1025         dc.norm[ColFG] = getcolor(normfgcolor);
1026         dc.sel[ColBG] = getcolor(selbgcolor);
1027         dc.sel[ColFG] = getcolor(selfgcolor);
1028         dc.urg[ColBG] = getcolor(urgbgcolor);
1029         dc.urg[ColFG] = getcolor(urgfgcolor);
1030         dc.drawable = XCreatePixmap(dpy, root, ww, wh,
1031                                     DefaultDepth(dpy, screen));
1032         dc.gc = XCreateGC(dpy, root, 0, 0);
1033
1034         win = XCreateSimpleWindow(dpy, root, wx, wy, ww, wh, 0,
1035                                   dc.norm[ColFG].pixel, dc.norm[ColBG].pixel);
1036         XMapRaised(dpy, win);
1037         XSelectInput(dpy, win, SubstructureNotifyMask | FocusChangeMask |
1038                      ButtonPressMask | ExposureMask | KeyPressMask |
1039                      PropertyChangeMask | StructureNotifyMask |
1040                      SubstructureRedirectMask);
1041         xerrorxlib = XSetErrorHandler(xerror);
1042
1043         class_hint.res_name = wmname;
1044         class_hint.res_class = "tabbed";
1045         XSetClassHint(dpy, win, &class_hint);
1046
1047         size_hint = XAllocSizeHints();
1048         if (!isfixed) {
1049                 size_hint->flags = PSize;
1050                 size_hint->height = wh;
1051                 size_hint->width = ww;
1052         } else {
1053                 size_hint->flags = PMaxSize | PMinSize;
1054                 size_hint->min_width = size_hint->max_width = ww;
1055                 size_hint->min_height = size_hint->max_height = wh;
1056         }
1057         wmh = XAllocWMHints();
1058         XSetWMProperties(dpy, win, NULL, NULL, NULL, 0, size_hint, wmh, NULL);
1059         XFree(size_hint);
1060         XFree(wmh);
1061
1062         XSetWMProtocols(dpy, win, &wmatom[WMDelete], 1);
1063
1064         snprintf(winid, sizeof(winid), "%lu", win);
1065         setenv("XEMBED", winid, 1);
1066
1067         nextfocus = foreground;
1068         focus(-1);
1069 }
1070
1071 void
1072 sigchld(int unused)
1073 {
1074         if (signal(SIGCHLD, sigchld) == SIG_ERR)
1075                 die("%s: cannot install SIGCHLD handler", argv0);
1076
1077         while (0 < waitpid(-1, NULL, WNOHANG));
1078 }
1079
1080 void
1081 spawn(const Arg *arg)
1082 {
1083         if (fork() == 0) {
1084                 if(dpy)
1085                         close(ConnectionNumber(dpy));
1086
1087                 setsid();
1088                 if (arg && arg->v) {
1089                         execvp(((char **)arg->v)[0], (char **)arg->v);
1090                         fprintf(stderr, "%s: execvp %s", argv0,
1091                                 ((char **)arg->v)[0]);
1092                 } else {
1093                         cmd[cmd_append_pos] = NULL;
1094                         execvp(cmd[0], cmd);
1095                         fprintf(stderr, "%s: execvp %s", argv0, cmd[0]);
1096                 }
1097                 perror(" failed");
1098                 exit(0);
1099         }
1100 }
1101
1102 int
1103 textnw(const char *text, unsigned int len)
1104 {
1105         XGlyphInfo ext;
1106         XftTextExtentsUtf8(dpy, dc.font.xfont, (XftChar8 *) text, len, &ext);
1107         return ext.xOff;
1108 }
1109
1110 void
1111 toggle(const Arg *arg)
1112 {
1113     *(Bool*) arg->v = !*(Bool*) arg->v;
1114 }
1115
1116 void
1117 unmanage(int c)
1118 {
1119         if (c < 0 || c >= nclients) {
1120                 drawbar();
1121                 XSync(dpy, False);
1122                 return;
1123         }
1124
1125         if (!nclients)
1126                 return;
1127
1128         if (c == 0) {
1129                 /* First client. */
1130                 nclients--;
1131                 free(clients[0]);
1132                 memmove(&clients[0], &clients[1], sizeof(Client *) * nclients);
1133         } else if (c == nclients - 1) {
1134                 /* Last client. */
1135                 nclients--;
1136                 free(clients[c]);
1137                 clients = erealloc(clients, sizeof(Client *) * nclients);
1138         } else {
1139                 /* Somewhere inbetween. */
1140                 free(clients[c]);
1141                 memmove(&clients[c], &clients[c+1],
1142                         sizeof(Client *) * (nclients - (c + 1)));
1143                 nclients--;
1144         }
1145
1146         if (nclients <= 0) {
1147                 lastsel = sel = -1;
1148
1149                 if (closelastclient)
1150                         running = False;
1151                 else if (fillagain && running)
1152                         spawn(NULL);
1153         } else {
1154                 if (lastsel >= nclients)
1155                         lastsel = nclients - 1;
1156                 else if (lastsel > c)
1157                         lastsel--;
1158
1159                 if (c == sel && lastsel >= 0) {
1160                         focus(lastsel);
1161                 } else {
1162                         if (sel > c)
1163                                 sel--;
1164                         if (sel >= nclients)
1165                                 sel = nclients - 1;
1166
1167                         focus(sel);
1168                 }
1169         }
1170
1171         drawbar();
1172         XSync(dpy, False);
1173 }
1174
1175 void
1176 unmapnotify(const XEvent *e)
1177 {
1178         const XUnmapEvent *ev = &e->xunmap;
1179         int c;
1180
1181         if ((c = getclient(ev->window)) > -1)
1182                 unmanage(c);
1183 }
1184
1185 void
1186 updatenumlockmask(void)
1187 {
1188         unsigned int i, j;
1189         XModifierKeymap *modmap;
1190
1191         numlockmask = 0;
1192         modmap = XGetModifierMapping(dpy);
1193         for (i = 0; i < 8; i++) {
1194                 for (j = 0; j < modmap->max_keypermod; j++) {
1195                         if (modmap->modifiermap[i * modmap->max_keypermod + j]
1196                             == XKeysymToKeycode(dpy, XK_Num_Lock))
1197                                 numlockmask = (1 << i);
1198                 }
1199         }
1200         XFreeModifiermap(modmap);
1201 }
1202
1203 void
1204 updatetitle(int c)
1205 {
1206         if (!gettextprop(clients[c]->win, wmatom[WMName], clients[c]->name,
1207             sizeof(clients[c]->name)))
1208                 gettextprop(clients[c]->win, XA_WM_NAME, clients[c]->name,
1209                             sizeof(clients[c]->name));
1210         if (sel == c)
1211                 xsettitle(win, clients[c]->name);
1212         drawbar();
1213 }
1214
1215 /* There's no way to check accesses to destroyed windows, thus those cases are
1216  * ignored (especially on UnmapNotify's).  Other types of errors call Xlibs
1217  * default error handler, which may call exit.  */
1218 int
1219 xerror(Display *dpy, XErrorEvent *ee)
1220 {
1221         if (ee->error_code == BadWindow
1222             || (ee->request_code == X_SetInputFocus &&
1223                 ee->error_code == BadMatch)
1224             || (ee->request_code == X_PolyText8 &&
1225                 ee->error_code == BadDrawable)
1226             || (ee->request_code == X_PolyFillRectangle &&
1227                 ee->error_code == BadDrawable)
1228             || (ee->request_code == X_PolySegment &&
1229                 ee->error_code == BadDrawable)
1230             || (ee->request_code == X_ConfigureWindow &&
1231                 ee->error_code == BadMatch)
1232             || (ee->request_code == X_GrabButton &&
1233                 ee->error_code == BadAccess)
1234             || (ee->request_code == X_GrabKey &&
1235                 ee->error_code == BadAccess)
1236             || (ee->request_code == X_CopyArea &&
1237                 ee->error_code == BadDrawable))
1238                 return 0;
1239
1240         fprintf(stderr, "%s: fatal error: request code=%d, error code=%d\n",
1241                 argv0, ee->request_code, ee->error_code);
1242         return xerrorxlib(dpy, ee); /* may call exit */
1243 }
1244
1245 void
1246 xsettitle(Window w, const char *str)
1247 {
1248         XTextProperty xtp;
1249
1250         if (XmbTextListToTextProperty(dpy, (char **)&str, 1,
1251             XCompoundTextStyle, &xtp) == Success) {
1252                 XSetTextProperty(dpy, w, &xtp, wmatom[WMName]);
1253                 XSetTextProperty(dpy, w, &xtp, XA_WM_NAME);
1254                 XFree(xtp.value);
1255         }
1256 }
1257
1258 void
1259 usage(void)
1260 {
1261         die("usage: %s [-dfksv] [-g geometry] [-n name] [-p [s+/-]pos]\n"
1262             "       [-r narg] [-o color] [-O color] [-t color] [-T color]\n"
1263             "       [-u color] [-U color] command...\n", argv0);
1264 }
1265
1266 int
1267 main(int argc, char *argv[])
1268 {
1269         Bool detach = False;
1270         int replace = 0;
1271         char *pstr;
1272
1273         ARGBEGIN {
1274         case 'c':
1275                 closelastclient = True;
1276                 fillagain = False;
1277                 break;
1278         case 'd':
1279                 detach = True;
1280                 break;
1281         case 'f':
1282                 fillagain = True;
1283                 break;
1284         case 'g':
1285                 geometry = EARGF(usage());
1286                 break;
1287         case 'k':
1288                 killclientsfirst = True;
1289                 break;
1290         case 'n':
1291                 wmname = EARGF(usage());
1292                 break;
1293         case 'O':
1294                 normfgcolor = EARGF(usage());
1295                 break;
1296         case 'o':
1297                 normbgcolor = EARGF(usage());
1298                 break;
1299         case 'p':
1300                 pstr = EARGF(usage());
1301                 if (pstr[0] == 's') {
1302                         npisrelative = True;
1303                         newposition = atoi(&pstr[1]);
1304                 } else {
1305                         newposition = atoi(pstr);
1306                 }
1307                 break;
1308         case 'r':
1309                 replace = atoi(EARGF(usage()));
1310                 break;
1311         case 's':
1312                 doinitspawn = False;
1313                 break;
1314         case 'T':
1315                 selfgcolor = EARGF(usage());
1316                 break;
1317         case 't':
1318                 selbgcolor = EARGF(usage());
1319                 break;
1320         case 'U':
1321                 urgfgcolor = EARGF(usage());
1322                 break;
1323         case 'u':
1324                 urgbgcolor = EARGF(usage());
1325                 break;
1326         case 'v':
1327                 die("tabbed-"VERSION", © 2009-2016 tabbed engineers, "
1328                     "see LICENSE for details.\n");
1329                 break;
1330         default:
1331                 usage();
1332                 break;
1333         } ARGEND;
1334
1335         if (argc < 1) {
1336                 doinitspawn = False;
1337                 fillagain = False;
1338         }
1339
1340         setcmd(argc, argv, replace);
1341
1342         if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
1343                 fprintf(stderr, "%s: no locale support\n", argv0);
1344         if (!(dpy = XOpenDisplay(NULL)))
1345                 die("%s: cannot open display\n", argv0);
1346
1347         setup();
1348         printf("0x%lx\n", win);
1349         fflush(NULL);
1350
1351         if (detach) {
1352                 if (fork() == 0) {
1353                         fclose(stdout);
1354                 } else {
1355                         if (dpy)
1356                                 close(ConnectionNumber(dpy));
1357                         return EXIT_SUCCESS;
1358                 }
1359         }
1360
1361         run();
1362         cleanup();
1363         XCloseDisplay(dpy);
1364
1365         return EXIT_SUCCESS;
1366 }