patch: anysize

[st.git] / x.c

diff --git a/x.c b/x.c
index 6474a01..752348f 100644 (file)
--- a/x.c
+++ b/x.c
@@ -1,63 +1,125 @@
 /* See LICENSE for license details. */
 #include <errno.h>
 /* See LICENSE for license details. */
 #include <errno.h>

+#include <math.h>
+#include <limits.h>

 #include <locale.h>
 #include <signal.h>
 #include <locale.h>
 #include <signal.h>

-#include <stdint.h>

 #include <sys/select.h>
 #include <time.h>
 #include <unistd.h>
 #include <libgen.h>
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <sys/select.h>
 #include <time.h>
 #include <unistd.h>
 #include <libgen.h>
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>

-#include <X11/Xutil.h>

 #include <X11/cursorfont.h>
 #include <X11/keysym.h>
 #include <X11/Xft/Xft.h>
 #include <X11/XKBlib.h>
 
 #include <X11/cursorfont.h>
 #include <X11/keysym.h>
 #include <X11/Xft/Xft.h>
 #include <X11/XKBlib.h>
 

+char *argv0;

 #include "arg.h"
 #include "arg.h"

+#include "st.h"
+#include "win.h"

 
 

-#define Glyph Glyph_
-#define Font Font_
+/* types used in config.h */
+typedef struct {
+       uint mod;
+       KeySym keysym;
+       void (*func)(const Arg *);
+       const Arg arg;
+} Shortcut;

 
 

-#include "win.h"
-#include "st.h"
+typedef struct {
+       uint mod;
+       uint button;
+       void (*func)(const Arg *);
+       const Arg arg;
+       uint  release;
+} MouseShortcut;
+
+typedef struct {
+       KeySym k;
+       uint mask;
+       char *s;
+       /* three-valued logic variables: 0 indifferent, 1 on, -1 off */
+       signed char appkey;    /* application keypad */
+       signed char appcursor; /* application cursor */
+} Key;
+
+/* X modifiers */
+#define XK_ANY_MOD    UINT_MAX
+#define XK_NO_MOD     0
+#define XK_SWITCH_MOD (1<<13|1<<14)
+
+/* function definitions used in config.h */
+static void clipcopy(const Arg *);
+static void clippaste(const Arg *);
+static void numlock(const Arg *);
+static void selpaste(const Arg *);
+static void zoom(const Arg *);
+static void zoomabs(const Arg *);
+static void zoomreset(const Arg *);
+static void ttysend(const Arg *);
+
+/* config.h for applying patches and the configuration. */
+#include "config.h"

 
 /* XEMBED messages */
 #define XEMBED_FOCUS_IN  4
 #define XEMBED_FOCUS_OUT 5
 
 /* macros */
 
 /* XEMBED messages */
 #define XEMBED_FOCUS_IN  4
 #define XEMBED_FOCUS_OUT 5
 
 /* macros */

+#define IS_SET(flag)           ((win.mode & (flag)) != 0)

 #define TRUERED(x)             (((x) & 0xff0000) >> 8)
 #define TRUEGREEN(x)           (((x) & 0xff00))
 #define TRUEBLUE(x)            (((x) & 0xff) << 8)
 
 typedef XftDraw *Draw;
 typedef XftColor Color;
 #define TRUERED(x)             (((x) & 0xff0000) >> 8)
 #define TRUEGREEN(x)           (((x) & 0xff00))
 #define TRUEBLUE(x)            (((x) & 0xff) << 8)
 
 typedef XftDraw *Draw;
 typedef XftColor Color;

+typedef XftGlyphFontSpec GlyphFontSpec;

 
 /* Purely graphic info */
 
 /* Purely graphic info */

+typedef struct {
+       int tw, th; /* tty width and height */
+       int w, h; /* window width and height */
+       int hborderpx, vborderpx;
+       int ch; /* char height */
+       int cw; /* char width  */
+       int mode; /* window state/mode flags */
+       int cursor; /* cursor style */
+} TermWindow;
+

 typedef struct {
        Display *dpy;
        Colormap cmap;
        Window win;
        Drawable buf;
 typedef struct {
        Display *dpy;
        Colormap cmap;
        Window win;
        Drawable buf;

-       Atom xembed, wmdeletewin, netwmname, netwmpid;
-       XIM xim;
-       XIC xic;
+       GlyphFontSpec *specbuf; /* font spec buffer used for rendering */
+       Atom xembed, wmdeletewin, netwmname, netwmiconname, netwmpid;
+       struct {
+               XIM xim;
+               XIC xic;
+               XPoint spot;
+               XVaNestedList spotlist;
+       } ime;

        Draw draw;
        Visual *vis;
        XSetWindowAttributes attrs;
        int scr;
        int isfixed; /* is fixed geometry? */
        Draw draw;
        Visual *vis;
        XSetWindowAttributes attrs;
        int scr;
        int isfixed; /* is fixed geometry? */

+       int depth; /* bit depth */

        int l, t; /* left and top offset */
        int gm; /* geometry mask */
 } XWindow;
 
 typedef struct {
        Atom xtarget;
        int l, t; /* left and top offset */
        int gm; /* geometry mask */
 } XWindow;
 
 typedef struct {
        Atom xtarget;

+       char *primary, *clipboard;
+       struct timespec tclick1;
+       struct timespec tclick2;

 } XSelection;
 
 /* Font structure */
 } XSelection;
 
 /* Font structure */

+#define Font Font_

 typedef struct {
        int height;
        int width;
 typedef struct {
        int height;
        int width;


@@ -85,11 +147,24 @@ static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int)
 static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int);
 static void xdrawglyph(Glyph, int, int);
 static void xclear(int, int, int, int);
 static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int);
 static void xdrawglyph(Glyph, int, int);
 static void xclear(int, int, int, int);

-static void xdrawcursor(void);

 static int xgeommasktogravity(int);
 static int xgeommasktogravity(int);

+static int ximopen(Display *);
+static void ximinstantiate(Display *, XPointer, XPointer);
+static void ximdestroy(XIM, XPointer, XPointer);
+static int xicdestroy(XIC, XPointer, XPointer);
+static void xinit(int, int);
+static void cresize(int, int);
+static void xresize(int, int);
+static void xhints(void);
+static int xloadcolor(int, const char *, Color *);

 static int xloadfont(Font *, FcPattern *);
 static int xloadfont(Font *, FcPattern *);

-static void xsetsel(char *, Time);
+static void xloadfonts(const char *, double);

 static void xunloadfont(Font *);
 static void xunloadfont(Font *);

+static void xunloadfonts(void);
+static void xsetenv(void);
+static void xseturgency(int);
+static int evcol(XEvent *);
+static int evrow(XEvent *);

 
 static void expose(XEvent *);
 static void visibility(XEvent *);
 
 static void expose(XEvent *);
 static void visibility(XEvent *);


@@ -98,6 +173,8 @@ static void kpress(XEvent *);
 static void cmessage(XEvent *);
 static void resize(XEvent *);
 static void focus(XEvent *);
 static void cmessage(XEvent *);
 static void resize(XEvent *);
 static void focus(XEvent *);

+static uint buttonmask(uint);
+static int mouseaction(XEvent *, uint);

 static void brelease(XEvent *);
 static void bpress(XEvent *);
 static void bmotion(XEvent *);
 static void brelease(XEvent *);
 static void bpress(XEvent *);
 static void bmotion(XEvent *);


@@ -105,10 +182,14 @@ static void propnotify(XEvent *);
 static void selnotify(XEvent *);
 static void selclear_(XEvent *);
 static void selrequest(XEvent *);
 static void selnotify(XEvent *);
 static void selclear_(XEvent *);
 static void selrequest(XEvent *);

-
-static void selcopy(Time);
-static void getbuttoninfo(XEvent *);
+static void setsel(char *, Time);
+static void mousesel(XEvent *, int);

 static void mousereport(XEvent *);
 static void mousereport(XEvent *);

+static char *kmap(KeySym, uint);
+static int match(uint, uint);
+
+static void run(void);
+static void usage(void);

 
 static void (*handler[LASTEvent])(XEvent *) = {
        [KeyPress] = kpress,
 
 static void (*handler[LASTEvent])(XEvent *) = {
        [KeyPress] = kpress,


@@ -140,6 +221,7 @@ static void (*handler[LASTEvent])(XEvent *) = {
 static DC dc;
 static XWindow xw;
 static XSelection xsel;
 static DC dc;
 static XWindow xw;
 static XSelection xsel;

+static TermWindow win;

 
 /* Font Ring Cache */
 enum {
 
 /* Font Ring Cache */
 enum {


@@ -156,150 +238,274 @@ typedef struct {
 } Fontcache;
 
 /* Fontcache is an array now. A new font will be appended to the array. */
 } Fontcache;
 
 /* Fontcache is an array now. A new font will be appended to the array. */

-static Fontcache frc[16];
+static Fontcache *frc = NULL;

 static int frclen = 0;
 static int frclen = 0;

+static int frccap = 0;
+static char *usedfont = NULL;
+static double usedfontsize = 0;
+static double defaultfontsize = 0;
+
+static char *opt_alpha = NULL;
+static char *opt_class = NULL;
+static char **opt_cmd  = NULL;
+static char *opt_embed = NULL;
+static char *opt_font  = NULL;
+static char *opt_io    = NULL;
+static char *opt_line  = NULL;
+static char *opt_name  = NULL;
+static char *opt_title = NULL;
+
+static uint buttons; /* bit field of pressed buttons */
+
+void
+clipcopy(const Arg *dummy)
+{
+       Atom clipboard;
+
+       free(xsel.clipboard);
+       xsel.clipboard = NULL;
+
+       if (xsel.primary != NULL) {
+               xsel.clipboard = xstrdup(xsel.primary);
+               clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
+               XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime);
+       }
+}

 
 void
 
 void

-getbuttoninfo(XEvent *e)
+clippaste(const Arg *dummy)

 {
 {

-       int type;
-       uint state = e->xbutton.state & ~(Button1Mask | forceselmod);
+       Atom clipboard;
+
+       clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
+       XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard,
+                       xw.win, CurrentTime);
+}

 
 

-       sel.alt = IS_SET(MODE_ALTSCREEN);
+void
+selpaste(const Arg *dummy)
+{
+       XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY,
+                       xw.win, CurrentTime);
+}

 
 

-       sel.oe.x = x2col(e->xbutton.x);
-       sel.oe.y = y2row(e->xbutton.y);
-       selnormalize();
+void
+numlock(const Arg *dummy)
+{
+       win.mode ^= MODE_NUMLOCK;
+}

 
 

-       sel.type = SEL_REGULAR;
-       for (type = 1; type < selmaskslen; ++type) {
+void
+zoom(const Arg *arg)
+{
+       Arg larg;
+
+       larg.f = usedfontsize + arg->f;
+       zoomabs(&larg);
+}
+
+void
+zoomabs(const Arg *arg)
+{
+       xunloadfonts();
+       xloadfonts(usedfont, arg->f);
+       cresize(0, 0);
+       redraw();
+       xhints();
+}
+
+void
+zoomreset(const Arg *arg)
+{
+       Arg larg;
+
+       if (defaultfontsize > 0) {
+               larg.f = defaultfontsize;
+               zoomabs(&larg);
+       }
+}
+
+void
+ttysend(const Arg *arg)
+{
+       ttywrite(arg->s, strlen(arg->s), 1);
+}
+
+int
+evcol(XEvent *e)
+{
+       int x = e->xbutton.x - win.hborderpx;
+       LIMIT(x, 0, win.tw - 1);
+       return x / win.cw;
+}
+
+int
+evrow(XEvent *e)
+{
+       int y = e->xbutton.y - win.vborderpx;
+       LIMIT(y, 0, win.th - 1);
+       return y / win.ch;
+}
+
+void
+mousesel(XEvent *e, int done)
+{
+       int type, seltype = SEL_REGULAR;
+       uint state = e->xbutton.state & ~(Button1Mask | forcemousemod);
+
+       for (type = 1; type < LEN(selmasks); ++type) {

                if (match(selmasks[type], state)) {
                if (match(selmasks[type], state)) {

-                       sel.type = type;
+                       seltype = type;

                        break;
                }
        }
                        break;
                }
        }

+       selextend(evcol(e), evrow(e), seltype, done);
+       if (done)
+               setsel(getsel(), e->xbutton.time);

 }
 
 void
 mousereport(XEvent *e)
 {
 }
 
 void
 mousereport(XEvent *e)
 {

-       int x = x2col(e->xbutton.x), y = y2row(e->xbutton.y),
-           button = e->xbutton.button, state = e->xbutton.state,
-           len;
+       int len, btn, code;
+       int x = evcol(e), y = evrow(e);
+       int state = e->xbutton.state;

        char buf[40];
        static int ox, oy;
 
        char buf[40];
        static int ox, oy;
 

-       /* from urxvt */
-       if (e->xbutton.type == MotionNotify) {
+       if (e->type == MotionNotify) {

                if (x == ox && y == oy)
                        return;
                if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY))
                        return;
                if (x == ox && y == oy)
                        return;
                if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY))
                        return;

-               /* MOUSE_MOTION: no reporting if no button is pressed */
-               if (IS_SET(MODE_MOUSEMOTION) && oldbutton == 3)
+               /* MODE_MOUSEMOTION: no reporting if no button is pressed */
+               if (IS_SET(MODE_MOUSEMOTION) && buttons == 0)

                        return;
                        return;

-
-               button = oldbutton + 32;
-               ox = x;
-               oy = y;
+               /* Set btn to lowest-numbered pressed button, or 12 if no
+                * buttons are pressed. */
+               for (btn = 1; btn <= 11 && !(buttons & (1<<(btn-1))); btn++)
+                       ;
+               code = 32;

        } else {
        } else {

-               if (!IS_SET(MODE_MOUSESGR) && e->xbutton.type == ButtonRelease) {
-                       button = 3;
-               } else {
-                       button -= Button1;
-                       if (button >= 3)
-                               button += 64 - 3;
-               }
-               if (e->xbutton.type == ButtonPress) {
-                       oldbutton = button;
-                       ox = x;
-                       oy = y;
-               } else if (e->xbutton.type == ButtonRelease) {
-                       oldbutton = 3;
+               btn = e->xbutton.button;
+               /* Only buttons 1 through 11 can be encoded */
+               if (btn < 1 || btn > 11)
+                       return;
+               if (e->type == ButtonRelease) {

                        /* MODE_MOUSEX10: no button release reporting */
                        if (IS_SET(MODE_MOUSEX10))
                                return;
                        /* MODE_MOUSEX10: no button release reporting */
                        if (IS_SET(MODE_MOUSEX10))
                                return;

-                       if (button == 64 || button == 65)
+                       /* Don't send release events for the scroll wheel */
+                       if (btn == 4 || btn == 5)

                                return;
                }
                                return;
                }

+               code = 0;

        }
 
        }
 

+       ox = x;
+       oy = y;
+
+       /* Encode btn into code. If no button is pressed for a motion event in
+        * MODE_MOUSEMANY, then encode it as a release. */
+       if ((!IS_SET(MODE_MOUSESGR) && e->type == ButtonRelease) || btn == 12)
+               code += 3;
+       else if (btn >= 8)
+               code += 128 + btn - 8;
+       else if (btn >= 4)
+               code += 64 + btn - 4;
+       else
+               code += btn - 1;
+

        if (!IS_SET(MODE_MOUSEX10)) {
        if (!IS_SET(MODE_MOUSEX10)) {

-               button += ((state & ShiftMask  ) ? 4  : 0)
-                       + ((state & Mod4Mask   ) ? 8  : 0)
-                       + ((state & ControlMask) ? 16 : 0);
+               code += ((state & ShiftMask  ) ?  4 : 0)
+                     + ((state & Mod1Mask   ) ?  8 : 0) /* meta key: alt */
+                     + ((state & ControlMask) ? 16 : 0);

        }
 
        if (IS_SET(MODE_MOUSESGR)) {
                len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c",
        }
 
        if (IS_SET(MODE_MOUSESGR)) {
                len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c",

-                               button, x+1, y+1,
-                               e->xbutton.type == ButtonRelease ? 'm' : 'M');
+                               code, x+1, y+1,
+                               e->type == ButtonRelease ? 'm' : 'M');

        } else if (x < 223 && y < 223) {
                len = snprintf(buf, sizeof(buf), "\033[M%c%c%c",
        } else if (x < 223 && y < 223) {
                len = snprintf(buf, sizeof(buf), "\033[M%c%c%c",

-                               32+button, 32+x+1, 32+y+1);
+                               32+code, 32+x+1, 32+y+1);

        } else {
                return;
        }
 
        } else {
                return;
        }
 

-       ttywrite(buf, len);
+       ttywrite(buf, len, 0);
+}
+
+uint
+buttonmask(uint button)
+{
+       return button == Button1 ? Button1Mask
+            : button == Button2 ? Button2Mask
+            : button == Button3 ? Button3Mask
+            : button == Button4 ? Button4Mask
+            : button == Button5 ? Button5Mask
+            : 0;
+}
+
+int
+mouseaction(XEvent *e, uint release)
+{
+       MouseShortcut *ms;
+
+       /* ignore Button<N>mask for Button<N> - it's set on release */
+       uint state = e->xbutton.state & ~buttonmask(e->xbutton.button);
+
+       for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
+               if (ms->release == release &&
+                   ms->button == e->xbutton.button &&
+                   (match(ms->mod, state) ||  /* exact or forced */
+                    match(ms->mod, state & ~forcemousemod))) {
+                       ms->func(&(ms->arg));
+                       return 1;
+               }
+       }
+
+       return 0;

 }
 
 void
 bpress(XEvent *e)
 {
 }
 
 void
 bpress(XEvent *e)
 {

+       int btn = e->xbutton.button;

        struct timespec now;
        struct timespec now;

-       MouseShortcut *ms;
+       int snap;

 
 

-       if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) {
+       if (1 <= btn && btn <= 11)
+               buttons |= 1 << (btn-1);
+
+       if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {

                mousereport(e);
                return;
        }
 
                mousereport(e);
                return;
        }
 

-       for (ms = mshortcuts; ms < mshortcuts + mshortcutslen; ms++) {
-               if (e->xbutton.button == ms->b
-                               && match(ms->mask, e->xbutton.state)) {
-                       ttysend(ms->s, strlen(ms->s));
-                       return;
-               }
-       }
-
-       if (e->xbutton.button == Button1) {
-               clock_gettime(CLOCK_MONOTONIC, &now);
-
-               /* Clear previous selection, logically and visually. */
-               selclear_(NULL);
-               sel.mode = SEL_EMPTY;
-               sel.type = SEL_REGULAR;
-               sel.oe.x = sel.ob.x = x2col(e->xbutton.x);
-               sel.oe.y = sel.ob.y = y2row(e->xbutton.y);
+       if (mouseaction(e, 0))
+               return;

 
 

+       if (btn == Button1) {

                /*
                 * If the user clicks below predefined timeouts specific
                 * snapping behaviour is exposed.
                 */
                /*
                 * If the user clicks below predefined timeouts specific
                 * snapping behaviour is exposed.
                 */

-               if (TIMEDIFF(now, sel.tclick2) <= tripleclicktimeout) {
-                       sel.snap = SNAP_LINE;
-               } else if (TIMEDIFF(now, sel.tclick1) <= doubleclicktimeout) {
-                       sel.snap = SNAP_WORD;
+               clock_gettime(CLOCK_MONOTONIC, &now);
+               if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) {
+                       snap = SNAP_LINE;
+               } else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) {
+                       snap = SNAP_WORD;

                } else {
                } else {

-                       sel.snap = 0;
+                       snap = 0;

                }
                }

-               selnormalize();
+               xsel.tclick2 = xsel.tclick1;
+               xsel.tclick1 = now;

 
 

-               if (sel.snap != 0)
-                       sel.mode = SEL_READY;
-               tsetdirt(sel.nb.y, sel.ne.y);
-               sel.tclick2 = sel.tclick1;
-               sel.tclick1 = now;
+               selstart(evcol(e), evrow(e), snap);

        }
 }
 
        }
 }
 

-void
-selcopy(Time t)
-{
-       xsetsel(getsel(), t);
-}
-

 void
 propnotify(XEvent *e)
 {
 void
 propnotify(XEvent *e)
 {


@@ -320,18 +526,16 @@ selnotify(XEvent *e)
        ulong nitems, ofs, rem;
        int format;
        uchar *data, *last, *repl;
        ulong nitems, ofs, rem;
        int format;
        uchar *data, *last, *repl;

-       Atom type, incratom, property;
+       Atom type, incratom, property = None;

 
        incratom = XInternAtom(xw.dpy, "INCR", 0);
 
        ofs = 0;
 
        incratom = XInternAtom(xw.dpy, "INCR", 0);
 
        ofs = 0;

-       if (e->type == SelectionNotify) {
+       if (e->type == SelectionNotify)

                property = e->xselection.property;
                property = e->xselection.property;

-       } else if(e->type == PropertyNotify) {
+       else if (e->type == PropertyNotify)

                property = e->xproperty.atom;
                property = e->xproperty.atom;

-       } else {
-               return;
-       }
+

        if (property == None)
                return;
 
        if (property == None)
                return;
 


@@ -387,10 +591,10 @@ selnotify(XEvent *e)
                }
 
                if (IS_SET(MODE_BRCKTPASTE) && ofs == 0)
                }
 
                if (IS_SET(MODE_BRCKTPASTE) && ofs == 0)

-                       ttywrite("\033[200~", 6);
-               ttysend((char *)data, nitems * format / 8);
+                       ttywrite("\033[200~", 6, 0);
+               ttywrite((char *)data, nitems * format / 8, 1);

                if (IS_SET(MODE_BRCKTPASTE) && rem == 0)
                if (IS_SET(MODE_BRCKTPASTE) && rem == 0)

-                       ttywrite("\033[201~", 6);
+                       ttywrite("\033[201~", 6, 0);

                XFree(data);
                /* number of 32-bit chunks returned */
                ofs += nitems * format / 32;
                XFree(data);
                /* number of 32-bit chunks returned */
                ofs += nitems * format / 32;


@@ -403,36 +607,10 @@ selnotify(XEvent *e)
        XDeleteProperty(xw.dpy, xw.win, (int)property);
 }
 
        XDeleteProperty(xw.dpy, xw.win, (int)property);
 }
 

-void
-xselpaste(void)
-{
-       XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY,
-                       xw.win, CurrentTime);
-}
-

 void
 xclipcopy(void)
 {
 void
 xclipcopy(void)
 {

-       Atom clipboard;
-
-       if (sel.clipboard != NULL)
-               free(sel.clipboard);
-
-       if (sel.primary != NULL) {
-               sel.clipboard = xstrdup(sel.primary);
-               clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
-               XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime);
-       }
-}
-
-void
-xclippaste(void)
-{
-       Atom clipboard;
-
-       clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
-       XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard,
-                       xw.win, CurrentTime);
+       clipcopy(NULL);

 }
 
 void
 }
 
 void


@@ -476,9 +654,9 @@ selrequest(XEvent *e)
                 */
                clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
                if (xsre->selection == XA_PRIMARY) {
                 */
                clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
                if (xsre->selection == XA_PRIMARY) {

-                       seltext = sel.primary;
+                       seltext = xsel.primary;

                } else if (xsre->selection == clipboard) {
                } else if (xsre->selection == clipboard) {

-                       seltext = sel.clipboard;
+                       seltext = xsel.clipboard;

                } else {
                        fprintf(stderr,
                                "Unhandled clipboard selection 0x%lx\n",
                } else {
                        fprintf(stderr,
                                "Unhandled clipboard selection 0x%lx\n",


@@ -500,72 +678,92 @@ selrequest(XEvent *e)
 }
 
 void
 }
 
 void

-xsetsel(char *str, Time t)
+setsel(char *str, Time t)

 {
 {

-       free(sel.primary);
-       sel.primary = str;
+       if (!str)
+               return;
+
+       free(xsel.primary);
+       xsel.primary = str;

 
        XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t);
        if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win)
 
        XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t);
        if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win)

-               selclear_(NULL);
+               selclear();
+}
+
+void
+xsetsel(char *str)
+{
+       setsel(str, CurrentTime);

 }
 
 void
 brelease(XEvent *e)
 {
 }
 
 void
 brelease(XEvent *e)
 {

-       if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) {
+       int btn = e->xbutton.button;
+
+       if (1 <= btn && btn <= 11)
+               buttons &= ~(1 << (btn-1));
+
+       if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {

                mousereport(e);
                return;
        }
 
                mousereport(e);
                return;
        }
 

-       if (e->xbutton.button == Button2) {
-               xselpaste();
-       } else if (e->xbutton.button == Button1) {
-               if (sel.mode == SEL_READY) {
-                       getbuttoninfo(e);
-                       selcopy(e->xbutton.time);
-               } else
-                       selclear_(NULL);
-               sel.mode = SEL_IDLE;
-               tsetdirt(sel.nb.y, sel.ne.y);
-       }
+       if (mouseaction(e, 1))
+               return;
+       if (btn == Button1)
+               mousesel(e, 1);

 }
 
 void
 bmotion(XEvent *e)
 {
 }
 
 void
 bmotion(XEvent *e)
 {

-       int oldey, oldex, oldsby, oldsey;
-
-       if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) {
+       if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {

                mousereport(e);
                return;
        }
 
                mousereport(e);
                return;
        }
 

-       if (!sel.mode)
-               return;
+       mousesel(e, 0);
+}
+
+void
+cresize(int width, int height)
+{
+       int col, row;
+
+       if (width != 0)
+               win.w = width;
+       if (height != 0)
+               win.h = height;
+
+       col = (win.w - 2 * borderpx) / win.cw;
+       row = (win.h - 2 * borderpx) / win.ch;
+       col = MAX(1, col);
+       row = MAX(1, row);

 
 

-       sel.mode = SEL_READY;
-       oldey = sel.oe.y;
-       oldex = sel.oe.x;
-       oldsby = sel.nb.y;
-       oldsey = sel.ne.y;
-       getbuttoninfo(e);
+       win.hborderpx = (win.w - col * win.cw) / 2;
+       win.vborderpx = (win.h - row * win.ch) / 2;

 
 

-       if (oldey != sel.oe.y || oldex != sel.oe.x)
-               tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));
+       tresize(col, row);
+       xresize(col, row);
+       ttyresize(win.tw, win.th);

 }
 
 void
 xresize(int col, int row)
 {
 }
 
 void
 xresize(int col, int row)
 {

-       win.tw = MAX(1, col * win.cw);
-       win.th = MAX(1, row * win.ch);
+       win.tw = col * win.cw;
+       win.th = row * win.ch;

 
        XFreePixmap(xw.dpy, xw.buf);
        xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
 
        XFreePixmap(xw.dpy, xw.buf);
        xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,

-                       DefaultDepth(xw.dpy, xw.scr));
+                       xw.depth);

        XftDrawChange(xw.draw, xw.buf);
        xclear(0, 0, win.w, win.h);
        XftDrawChange(xw.draw, xw.buf);
        xclear(0, 0, win.w, win.h);

+
+       /* resize to new width */
+       xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));

 }
 
 ushort
 }
 
 ushort


@@ -605,24 +803,44 @@ xloadcols(void)
        static int loaded;
        Color *cp;
 
        static int loaded;
        Color *cp;
 

-       dc.collen = MAX(colornamelen, 256);
-       dc.col = xmalloc(dc.collen * sizeof(Color));
-

        if (loaded) {
                for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)
                        XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);
        if (loaded) {
                for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)
                        XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);

+       } else {
+               dc.collen = MAX(LEN(colorname), 256);
+               dc.col = xmalloc(dc.collen * sizeof(Color));

        }
 
        for (i = 0; i < dc.collen; i++)
                if (!xloadcolor(i, NULL, &dc.col[i])) {
                        if (colorname[i])
        }
 
        for (i = 0; i < dc.collen; i++)
                if (!xloadcolor(i, NULL, &dc.col[i])) {
                        if (colorname[i])

-                               die("Could not allocate color '%s'\n", colorname[i]);
+                               die("could not allocate color '%s'\n", colorname[i]);

                        else
                        else

-                               die("Could not allocate color %d\n", i);
+                               die("could not allocate color %d\n", i);

                }
                }

+
+       /* set alpha value of bg color */
+       if (opt_alpha)
+               alpha = strtof(opt_alpha, NULL);
+       dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha);
+       dc.col[defaultbg].pixel &= 0x00FFFFFF;
+       dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24;

        loaded = 1;
 }
 
        loaded = 1;
 }
 

+int
+xgetcolor(int x, unsigned char *r, unsigned char *g, unsigned char *b)
+{
+       if (!BETWEEN(x, 0, dc.collen))
+               return 1;
+
+       *r = dc.col[x].color.red >> 8;
+       *g = dc.col[x].color.green >> 8;
+       *b = dc.col[x].color.blue >> 8;
+
+       return 0;
+}
+

 int
 xsetcolorname(int x, const char *name)
 {
 int
 xsetcolorname(int x, const char *name)
 {


@@ -631,7 +849,6 @@ xsetcolorname(int x, const char *name)
        if (!BETWEEN(x, 0, dc.collen))
                return 1;
 
        if (!BETWEEN(x, 0, dc.collen))
                return 1;
 

-

        if (!xloadcolor(x, name, &ncolor))
                return 1;
 
        if (!xloadcolor(x, name, &ncolor))
                return 1;
 


@@ -658,19 +875,21 @@ xhints(void)
        XClassHint class = {opt_name ? opt_name : termname,
                            opt_class ? opt_class : termname};
        XWMHints wm = {.flags = InputHint, .input = 1};
        XClassHint class = {opt_name ? opt_name : termname,
                            opt_class ? opt_class : termname};
        XWMHints wm = {.flags = InputHint, .input = 1};

-       XSizeHints *sizeh = NULL;
+       XSizeHints *sizeh;

 
        sizeh = XAllocSizeHints();
 
 
        sizeh = XAllocSizeHints();
 

-       sizeh->flags = PSize | PResizeInc | PBaseSize;
+       sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize;

        sizeh->height = win.h;
        sizeh->width = win.w;
        sizeh->height = win.h;
        sizeh->width = win.w;

-       sizeh->height_inc = win.ch;
-       sizeh->width_inc = win.cw;
+       sizeh->height_inc = 1;
+       sizeh->width_inc = 1;

        sizeh->base_height = 2 * borderpx;
        sizeh->base_width = 2 * borderpx;
        sizeh->base_height = 2 * borderpx;
        sizeh->base_width = 2 * borderpx;

+       sizeh->min_height = win.ch + 2 * borderpx;
+       sizeh->min_width = win.cw + 2 * borderpx;

        if (xw.isfixed) {
        if (xw.isfixed) {

-               sizeh->flags |= PMaxSize | PMinSize;
+               sizeh->flags |= PMaxSize;

                sizeh->min_width = sizeh->max_width = win.w;
                sizeh->min_height = sizeh->max_height = win.h;
        }
                sizeh->min_width = sizeh->max_width = win.w;
                sizeh->min_height = sizeh->max_height = win.h;
        }


@@ -743,7 +962,7 @@ xloadfont(Font *f, FcPattern *pattern)
                if ((XftPatternGetInteger(f->match->pattern, "slant", 0,
                    &haveattr) != XftResultMatch) || haveattr < wantattr) {
                        f->badslant = 1;
                if ((XftPatternGetInteger(f->match->pattern, "slant", 0,
                    &haveattr) != XftResultMatch) || haveattr < wantattr) {
                        f->badslant = 1;

-                       fputs("st: font slant does not match\n", stderr);
+                       fputs("font slant does not match\n", stderr);

                }
        }
 
                }
        }
 


@@ -752,7 +971,7 @@ xloadfont(Font *f, FcPattern *pattern)
                if ((XftPatternGetInteger(f->match->pattern, "weight", 0,
                    &haveattr) != XftResultMatch) || haveattr != wantattr) {
                        f->badweight = 1;
                if ((XftPatternGetInteger(f->match->pattern, "weight", 0,
                    &haveattr) != XftResultMatch) || haveattr != wantattr) {
                        f->badweight = 1;

-                       fputs("st: font weight does not match\n", stderr);
+                       fputs("font weight does not match\n", stderr);

                }
        }
 
                }
        }
 


@@ -775,20 +994,18 @@ xloadfont(Font *f, FcPattern *pattern)
 }
 
 void
 }
 
 void

-xloadfonts(char *fontstr, double fontsize)
+xloadfonts(const char *fontstr, double fontsize)

 {
        FcPattern *pattern;
        double fontval;
 {
        FcPattern *pattern;
        double fontval;

-       float ceilf(float);

 
 

-       if (fontstr[0] == '-') {
+       if (fontstr[0] == '-')

                pattern = XftXlfdParse(fontstr, False, False);
                pattern = XftXlfdParse(fontstr, False, False);

-       } else {
-               pattern = FcNameParse((FcChar8 *)fontstr);
-       }
+       else
+               pattern = FcNameParse((const FcChar8 *)fontstr);

 
        if (!pattern)
 
        if (!pattern)

-               die("st: can't open font %s\n", fontstr);
+               die("can't open font %s\n", fontstr);

 
        if (fontsize > 1) {
                FcPatternDel(pattern, FC_PIXEL_SIZE);
 
        if (fontsize > 1) {
                FcPatternDel(pattern, FC_PIXEL_SIZE);


@@ -814,7 +1031,7 @@ xloadfonts(char *fontstr, double fontsize)
        }
 
        if (xloadfont(&dc.font, pattern))
        }
 
        if (xloadfont(&dc.font, pattern))

-               die("st: can't open font %s\n", fontstr);
+               die("can't open font %s\n", fontstr);

 
        if (usedfontsize < 0) {
                FcPatternGetDouble(dc.font.match->pattern,
 
        if (usedfontsize < 0) {
                FcPatternGetDouble(dc.font.match->pattern,


@@ -831,17 +1048,17 @@ xloadfonts(char *fontstr, double fontsize)
        FcPatternDel(pattern, FC_SLANT);
        FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
        if (xloadfont(&dc.ifont, pattern))
        FcPatternDel(pattern, FC_SLANT);
        FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
        if (xloadfont(&dc.ifont, pattern))

-               die("st: can't open font %s\n", fontstr);
+               die("can't open font %s\n", fontstr);

 
        FcPatternDel(pattern, FC_WEIGHT);
        FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
        if (xloadfont(&dc.ibfont, pattern))
 
        FcPatternDel(pattern, FC_WEIGHT);
        FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
        if (xloadfont(&dc.ibfont, pattern))

-               die("st: can't open font %s\n", fontstr);
+               die("can't open font %s\n", fontstr);

 
        FcPatternDel(pattern, FC_SLANT);
        FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
        if (xloadfont(&dc.bfont, pattern))
 
        FcPatternDel(pattern, FC_SLANT);
        FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
        if (xloadfont(&dc.bfont, pattern))

-               die("st: can't open font %s\n", fontstr);
+               die("can't open font %s\n", fontstr);

 
        FcPatternDestroy(pattern);
 }
 
        FcPatternDestroy(pattern);
 }


@@ -868,34 +1085,100 @@ xunloadfonts(void)
        xunloadfont(&dc.ibfont);
 }
 
        xunloadfont(&dc.ibfont);
 }
 

+int
+ximopen(Display *dpy)
+{
+       XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy };
+       XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy };
+
+       xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL);
+       if (xw.ime.xim == NULL)
+               return 0;
+
+       if (XSetIMValues(xw.ime.xim, XNDestroyCallback, &imdestroy, NULL))
+               fprintf(stderr, "XSetIMValues: "
+                               "Could not set XNDestroyCallback.\n");
+
+       xw.ime.spotlist = XVaCreateNestedList(0, XNSpotLocation, &xw.ime.spot,
+                                             NULL);
+
+       if (xw.ime.xic == NULL) {
+               xw.ime.xic = XCreateIC(xw.ime.xim, XNInputStyle,
+                                      XIMPreeditNothing | XIMStatusNothing,
+                                      XNClientWindow, xw.win,
+                                      XNDestroyCallback, &icdestroy,
+                                      NULL);
+       }
+       if (xw.ime.xic == NULL)
+               fprintf(stderr, "XCreateIC: Could not create input context.\n");
+
+       return 1;
+}
+
+void
+ximinstantiate(Display *dpy, XPointer client, XPointer call)
+{
+       if (ximopen(dpy))
+               XUnregisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
+                                                ximinstantiate, NULL);
+}
+
+void
+ximdestroy(XIM xim, XPointer client, XPointer call)
+{
+       xw.ime.xim = NULL;
+       XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
+                                      ximinstantiate, NULL);
+       XFree(xw.ime.spotlist);
+}
+
+int
+xicdestroy(XIC xim, XPointer client, XPointer call)
+{
+       xw.ime.xic = NULL;
+       return 1;
+}
+

 void
 void

-xinit(void)
+xinit(int cols, int rows)

 {
        XGCValues gcvalues;
        Cursor cursor;
        Window parent;
        pid_t thispid = getpid();
        XColor xmousefg, xmousebg;
 {
        XGCValues gcvalues;
        Cursor cursor;
        Window parent;
        pid_t thispid = getpid();
        XColor xmousefg, xmousebg;

+       XWindowAttributes attr;
+       XVisualInfo vis;

 
        if (!(xw.dpy = XOpenDisplay(NULL)))
 
        if (!(xw.dpy = XOpenDisplay(NULL)))

-               die("Can't open display\n");
+               die("can't open display\n");

        xw.scr = XDefaultScreen(xw.dpy);
        xw.scr = XDefaultScreen(xw.dpy);

-       xw.vis = XDefaultVisual(xw.dpy, xw.scr);
+
+       if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) {
+               parent = XRootWindow(xw.dpy, xw.scr);
+               xw.depth = 32;
+       } else {
+               XGetWindowAttributes(xw.dpy, parent, &attr);
+               xw.depth = attr.depth;
+       }
+
+       XMatchVisualInfo(xw.dpy, xw.scr, xw.depth, TrueColor, &vis);
+       xw.vis = vis.visual;

 
        /* font */
        if (!FcInit())
 
        /* font */
        if (!FcInit())

-               die("Could not init fontconfig.\n");
+               die("could not init fontconfig.\n");

 
        usedfont = (opt_font == NULL)? font : opt_font;
        xloadfonts(usedfont, 0);
 
        /* colors */
 
        usedfont = (opt_font == NULL)? font : opt_font;
        xloadfonts(usedfont, 0);
 
        /* colors */

-       xw.cmap = XDefaultColormap(xw.dpy, xw.scr);
+       xw.cmap = XCreateColormap(xw.dpy, parent, xw.vis, None);

        xloadcols();
 
        /* adjust fixed window geometry */
        xloadcols();
 
        /* adjust fixed window geometry */

-       win.w = 2 * borderpx + term.col * win.cw;
-       win.h = 2 * borderpx + term.row * win.ch;
+       win.w = 2 * win.hborderpx + 2 * borderpx + cols * win.cw;
+       win.h = 2 * win.vborderpx + 2 * borderpx + rows * win.ch;

        if (xw.gm & XNegative)
                xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2;
        if (xw.gm & YNegative)
        if (xw.gm & XNegative)
                xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2;
        if (xw.gm & YNegative)


@@ -905,47 +1188,34 @@ xinit(void)
        xw.attrs.background_pixel = dc.col[defaultbg].pixel;
        xw.attrs.border_pixel = dc.col[defaultbg].pixel;
        xw.attrs.bit_gravity = NorthWestGravity;
        xw.attrs.background_pixel = dc.col[defaultbg].pixel;
        xw.attrs.border_pixel = dc.col[defaultbg].pixel;
        xw.attrs.bit_gravity = NorthWestGravity;

-       xw.attrs.event_mask = FocusChangeMask | KeyPressMask
+       xw.attrs.event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask

                | ExposureMask | VisibilityChangeMask | StructureNotifyMask
                | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask;
        xw.attrs.colormap = xw.cmap;
 
                | ExposureMask | VisibilityChangeMask | StructureNotifyMask
                | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask;
        xw.attrs.colormap = xw.cmap;
 

-       if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0))))
-               parent = XRootWindow(xw.dpy, xw.scr);

        xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t,
        xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t,

-                       win.w, win.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput,
+                       win.w, win.h, 0, xw.depth, InputOutput,

                        xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity
                        | CWEventMask | CWColormap, &xw.attrs);
 
        memset(&gcvalues, 0, sizeof(gcvalues));
        gcvalues.graphics_exposures = False;
                        xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity
                        | CWEventMask | CWColormap, &xw.attrs);
 
        memset(&gcvalues, 0, sizeof(gcvalues));
        gcvalues.graphics_exposures = False;

-       dc.gc = XCreateGC(xw.dpy, parent, GCGraphicsExposures,
-                       &gcvalues);
-       xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
-                       DefaultDepth(xw.dpy, xw.scr));
+       xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, xw.depth);
+       dc.gc = XCreateGC(xw.dpy, xw.buf, GCGraphicsExposures, &gcvalues);

        XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel);
        XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h);
 
        XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel);
        XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h);
 

+       /* font spec buffer */
+       xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec));
+

        /* Xft rendering context */
        xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap);
 
        /* input methods */
        /* Xft rendering context */
        xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap);
 
        /* input methods */

-       if ((xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL) {
-               XSetLocaleModifiers("@im=local");
-               if ((xw.xim =  XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL) {
-                       XSetLocaleModifiers("@im=");
-                       if ((xw.xim = XOpenIM(xw.dpy,
-                                       NULL, NULL, NULL)) == NULL) {
-                               die("XOpenIM failed. Could not open input"
-                                       " device.\n");
-                       }
-               }
+       if (!ximopen(xw.dpy)) {
+               XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
+                                              ximinstantiate, NULL);

        }
        }

-       xw.xic = XCreateIC(xw.xim, XNInputStyle, XIMPreeditNothing
-                                          | XIMStatusNothing, XNClientWindow, xw.win,
-                                          XNFocusWindow, xw.win, NULL);
-       if (xw.xic == NULL)
-               die("XCreateIC failed. Could not obtain input method.\n");

 
        /* white cursor, black outline */
        cursor = XCreateFontCursor(xw.dpy, mouseshape);
 
        /* white cursor, black outline */
        cursor = XCreateFontCursor(xw.dpy, mouseshape);


@@ -968,17 +1238,23 @@ xinit(void)
        xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False);
        xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False);
        xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False);
        xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False);
        xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False);
        xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False);

+       xw.netwmiconname = XInternAtom(xw.dpy, "_NET_WM_ICON_NAME", False);

        XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1);
 
        xw.netwmpid = XInternAtom(xw.dpy, "_NET_WM_PID", False);
        XChangeProperty(xw.dpy, xw.win, xw.netwmpid, XA_CARDINAL, 32,
                        PropModeReplace, (uchar *)&thispid, 1);
 
        XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1);
 
        xw.netwmpid = XInternAtom(xw.dpy, "_NET_WM_PID", False);
        XChangeProperty(xw.dpy, xw.win, xw.netwmpid, XA_CARDINAL, 32,
                        PropModeReplace, (uchar *)&thispid, 1);
 

+       win.mode = MODE_NUMLOCK;

        resettitle();
        resettitle();

-       XMapWindow(xw.dpy, xw.win);

        xhints();
        xhints();

+       XMapWindow(xw.dpy, xw.win);

        XSync(xw.dpy, False);
 
        XSync(xw.dpy, False);
 

+       clock_gettime(CLOCK_MONOTONIC, &xsel.tclick1);
+       clock_gettime(CLOCK_MONOTONIC, &xsel.tclick2);
+       xsel.primary = NULL;
+       xsel.clipboard = NULL;

        xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0);
        if (xsel.xtarget == None)
                xsel.xtarget = XA_STRING;
        xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0);
        if (xsel.xtarget == None)
                xsel.xtarget = XA_STRING;


@@ -987,7 +1263,7 @@ xinit(void)
 int
 xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y)
 {
 int
 xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y)
 {

-       float winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, xp, yp;
+       float winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, xp, yp;

        ushort mode, prevmode = USHRT_MAX;
        Font *font = &dc.font;
        int frcflags = FRC_NORMAL;
        ushort mode, prevmode = USHRT_MAX;
        Font *font = &dc.font;
        int frcflags = FRC_NORMAL;


@@ -1082,17 +1358,17 @@ xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x
                        fontpattern = FcFontSetMatch(0, fcsets, 1,
                                        fcpattern, &fcres);
 
                        fontpattern = FcFontSetMatch(0, fcsets, 1,
                                        fcpattern, &fcres);
 

-                       /*
-                        * Overwrite or create the new cache entry.
-                        */
-                       if (frclen >= LEN(frc)) {
-                               frclen = LEN(frc) - 1;
-                               XftFontClose(xw.dpy, frc[frclen].font);
-                               frc[frclen].unicodep = 0;
+                       /* Allocate memory for the new cache entry. */
+                       if (frclen >= frccap) {
+                               frccap += 16;
+                               frc = xrealloc(frc, frccap * sizeof(Fontcache));

                        }
 
                        frc[frclen].font = XftFontOpenPattern(xw.dpy,
                                        fontpattern);
                        }
 
                        frc[frclen].font = XftFontOpenPattern(xw.dpy,
                                        fontpattern);

+                       if (!frc[frclen].font)
+                               die("XftFontOpenPattern failed seeking fallback font: %s\n",
+                                       strerror(errno));

                        frc[frclen].flags = frcflags;
                        frc[frclen].unicodep = rune;
 
                        frc[frclen].flags = frcflags;
                        frc[frclen].unicodep = rune;
 


@@ -1120,7 +1396,7 @@ void
 xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y)
 {
        int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1);
 xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y)
 {
        int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1);

-       int winx = borderpx + x * win.cw, winy = borderpx + y * win.ch,
+       int winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch,

            width = charlen * win.cw;
        Color *fg, *bg, *temp, revfg, revbg, truefg, truebg;
        XRenderColor colfg, colbg;
            width = charlen * win.cw;
        Color *fg, *bg, *temp, revfg, revbg, truefg, truebg;
        XRenderColor colfg, colbg;


@@ -1187,21 +1463,22 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i
                }
        }
 
                }
        }
 

-       if (base.mode & ATTR_REVERSE) {
-               temp = fg;
-               fg = bg;
-               bg = temp;
-       }
-

        if ((base.mode & ATTR_BOLD_FAINT) == ATTR_FAINT) {
                colfg.red = fg->color.red / 2;
                colfg.green = fg->color.green / 2;
                colfg.blue = fg->color.blue / 2;
        if ((base.mode & ATTR_BOLD_FAINT) == ATTR_FAINT) {
                colfg.red = fg->color.red / 2;
                colfg.green = fg->color.green / 2;
                colfg.blue = fg->color.blue / 2;

+               colfg.alpha = fg->color.alpha;

                XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &revfg);
                fg = &revfg;
        }
 
                XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &revfg);
                fg = &revfg;
        }
 

-       if (base.mode & ATTR_BLINK && term.mode & MODE_BLINK)
+       if (base.mode & ATTR_REVERSE) {
+               temp = fg;
+               fg = bg;
+               bg = temp;
+       }
+
+       if (base.mode & ATTR_BLINK && win.mode & MODE_BLINK)

                fg = bg;
 
        if (base.mode & ATTR_INVISIBLE)
                fg = bg;
 
        if (base.mode & ATTR_INVISIBLE)


@@ -1209,16 +1486,17 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i
 
        /* Intelligent cleaning up of the borders. */
        if (x == 0) {
 
        /* Intelligent cleaning up of the borders. */
        if (x == 0) {

-               xclear(0, (y == 0)? 0 : winy, borderpx,
-                       winy + win.ch + ((y >= term.row-1)? win.h : 0));
+               xclear(0, (y == 0)? 0 : winy, win.vborderpx,
+                       winy + win.ch +
+                       ((winy + win.ch >= win.vborderpx + win.th)? win.h : 0));

        }
        }

-       if (x + charlen >= term.col) {
+       if (winx + width >= win.hborderpx + win.tw) {

                xclear(winx + width, (y == 0)? 0 : winy, win.w,
                xclear(winx + width, (y == 0)? 0 : winy, win.w,

-                       ((y >= term.row-1)? win.h : (winy + win.ch)));
+                       ((winy + win.ch >= win.vborderpx + win.th)? win.h : (winy + win.ch)));

        }
        if (y == 0)
        }
        if (y == 0)

-               xclear(winx, 0, winx + width, borderpx);
-       if (y == term.row-1)
+               xclear(winx, 0, winx + width, win.vborderpx);
+       if (winy + win.ch >= win.vborderpx + win.th)

                xclear(winx, winy + win.ch, winx + width, win.h);
 
        /* Clean up the region we want to draw to. */
                xclear(winx, winy + win.ch, winx + width, win.h);
 
        /* Clean up the region we want to draw to. */


@@ -1236,12 +1514,12 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i
 
        /* Render underline and strikethrough. */
        if (base.mode & ATTR_UNDERLINE) {
 
        /* Render underline and strikethrough. */
        if (base.mode & ATTR_UNDERLINE) {

-               XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent + 1,
+               XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent * chscale + 1,

                                width, 1);
        }
 
        if (base.mode & ATTR_STRUCK) {
                                width, 1);
        }
 
        if (base.mode & ATTR_STRUCK) {

-               XftDrawRect(xw.draw, fg, winx, winy + 2 * dc.font.ascent / 3,
+               XftDrawRect(xw.draw, fg, winx, winy + 2 * dc.font.ascent * chscale / 3,

                                width, 1);
        }
 
                                width, 1);
        }
 


@@ -1260,40 +1538,27 @@ xdrawglyph(Glyph g, int x, int y)
 }
 
 void
 }
 
 void

-xdrawcursor(void)
+xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og)

 {
 {

-       static int oldx = 0, oldy = 0;
-       int curx;
-       Glyph g = {' ', ATTR_NULL, defaultbg, defaultcs}, og;
-       int ena_sel = sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN);

        Color drawcol;
 
        Color drawcol;
 

-       LIMIT(oldx, 0, term.col-1);
-       LIMIT(oldy, 0, term.row-1);
-
-       curx = term.c.x;
-
-       /* adjust position if in dummy */
-       if (term.line[oldy][oldx].mode & ATTR_WDUMMY)
-               oldx--;
-       if (term.line[term.c.y][curx].mode & ATTR_WDUMMY)
-               curx--;
-

        /* remove the old cursor */
        /* remove the old cursor */

-       og = term.line[oldy][oldx];
-       if (ena_sel && selected(oldx, oldy))
+       if (selected(ox, oy))

                og.mode ^= ATTR_REVERSE;
                og.mode ^= ATTR_REVERSE;

-       xdrawglyph(og, oldx, oldy);
+       xdrawglyph(og, ox, oy);

 
 

-       g.u = term.line[term.c.y][term.c.x].u;
+       if (IS_SET(MODE_HIDE))
+               return;

 
        /*
         * Select the right color for the right mode.
         */
 
        /*
         * Select the right color for the right mode.
         */

+       g.mode &= ATTR_BOLD|ATTR_ITALIC|ATTR_UNDERLINE|ATTR_STRUCK|ATTR_WIDE;
+

        if (IS_SET(MODE_REVERSE)) {
                g.mode |= ATTR_REVERSE;
                g.bg = defaultfg;
        if (IS_SET(MODE_REVERSE)) {
                g.mode |= ATTR_REVERSE;
                g.bg = defaultfg;

-               if (ena_sel && selected(term.c.x, term.c.y)) {
+               if (selected(cx, cy)) {

                        drawcol = dc.col[defaultcs];
                        g.fg = defaultrcs;
                } else {
                        drawcol = dc.col[defaultcs];
                        g.fg = defaultrcs;
                } else {


@@ -1301,64 +1566,61 @@ xdrawcursor(void)
                        g.fg = defaultcs;
                }
        } else {
                        g.fg = defaultcs;
                }
        } else {

-               if (ena_sel && selected(term.c.x, term.c.y)) {
-                       drawcol = dc.col[defaultrcs];
+               if (selected(cx, cy)) {

                        g.fg = defaultfg;
                        g.bg = defaultrcs;
                } else {
                        g.fg = defaultfg;
                        g.bg = defaultrcs;
                } else {

-                       drawcol = dc.col[defaultcs];
+                       g.fg = defaultbg;
+                       g.bg = defaultcs;

                }
                }

+               drawcol = dc.col[g.bg];

        }
 
        }
 

-       if (IS_SET(MODE_HIDE))
-               return;
-

        /* draw the new one */
        /* draw the new one */

-       if (win.state & WIN_FOCUSED) {
+       if (IS_SET(MODE_FOCUSED)) {

                switch (win.cursor) {
                switch (win.cursor) {

-               case 7: /* st extension: snowman */
-                       utf8decode("☃", &g.u, UTF_SIZ);
+               case 7: /* st extension */
+                       g.u = 0x2603; /* snowman (U+2603) */
+                       /* FALLTHROUGH */

                case 0: /* Blinking Block */
                case 1: /* Blinking Block (Default) */
                case 2: /* Steady Block */
                case 0: /* Blinking Block */
                case 1: /* Blinking Block (Default) */
                case 2: /* Steady Block */

-                       g.mode |= term.line[term.c.y][curx].mode & ATTR_WIDE;
-                       xdrawglyph(g, term.c.x, term.c.y);
+                       xdrawglyph(g, cx, cy);

                        break;
                case 3: /* Blinking Underline */
                case 4: /* Steady Underline */
                        XftDrawRect(xw.draw, &drawcol,
                        break;
                case 3: /* Blinking Underline */
                case 4: /* Steady Underline */
                        XftDrawRect(xw.draw, &drawcol,

-                                       borderpx + curx * win.cw,
-                                       borderpx + (term.c.y + 1) * win.ch - \
+                                       win.hborderpx + cx * win.cw,
+                                       win.vborderpx + (cy + 1) * win.ch - \

                                                cursorthickness,
                                        win.cw, cursorthickness);
                        break;
                case 5: /* Blinking bar */
                case 6: /* Steady bar */
                        XftDrawRect(xw.draw, &drawcol,
                                                cursorthickness,
                                        win.cw, cursorthickness);
                        break;
                case 5: /* Blinking bar */
                case 6: /* Steady bar */
                        XftDrawRect(xw.draw, &drawcol,

-                                       borderpx + curx * win.cw,
-                                       borderpx + term.c.y * win.ch,
+                                       win.hborderpx + cx * win.cw,
+                                       win.vborderpx + cy * win.ch,

                                        cursorthickness, win.ch);
                        break;
                }
        } else {
                XftDrawRect(xw.draw, &drawcol,
                                        cursorthickness, win.ch);
                        break;
                }
        } else {
                XftDrawRect(xw.draw, &drawcol,

-                               borderpx + curx * win.cw,
-                               borderpx + term.c.y * win.ch,
+                               win.hborderpx + cx * win.cw,
+                               win.vborderpx + cy * win.ch,

                                win.cw - 1, 1);
                XftDrawRect(xw.draw, &drawcol,
                                win.cw - 1, 1);
                XftDrawRect(xw.draw, &drawcol,

-                               borderpx + curx * win.cw,
-                               borderpx + term.c.y * win.ch,
+                               win.hborderpx + cx * win.cw,
+                               win.vborderpx + cy * win.ch,

                                1, win.ch - 1);
                XftDrawRect(xw.draw, &drawcol,
                                1, win.ch - 1);
                XftDrawRect(xw.draw, &drawcol,

-                               borderpx + (curx + 1) * win.cw - 1,
-                               borderpx + term.c.y * win.ch,
+                               win.hborderpx + (cx + 1) * win.cw - 1,
+                               win.vborderpx + cy * win.ch,

                                1, win.ch - 1);
                XftDrawRect(xw.draw, &drawcol,
                                1, win.ch - 1);
                XftDrawRect(xw.draw, &drawcol,

-                               borderpx + curx * win.cw,
-                               borderpx + (term.c.y + 1) * win.ch - 1,
+                               win.hborderpx + cx * win.cw,
+                               win.vborderpx + (cy + 1) * win.ch - 1,

                                win.cw, 1);
        }
                                win.cw, 1);
        }

-       oldx = curx, oldy = term.c.y;

 }
 
 void
 }
 
 void


@@ -1370,22 +1632,74 @@ xsetenv(void)
        setenv("WINDOWID", buf, 1);
 }
 
        setenv("WINDOWID", buf, 1);
 }
 

+void
+xseticontitle(char *p)
+{
+       XTextProperty prop;
+       DEFAULT(p, opt_title);
+
+       if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
+                                       &prop) != Success)
+               return;
+       XSetWMIconName(xw.dpy, xw.win, &prop);
+       XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmiconname);
+       XFree(prop.value);
+}
+

 void
 xsettitle(char *p)
 {
        XTextProperty prop;
 void
 xsettitle(char *p)
 {
        XTextProperty prop;

+       DEFAULT(p, opt_title);

 
 

-       Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
-                       &prop);
+       if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
+                                       &prop) != Success)
+               return;

        XSetWMName(xw.dpy, xw.win, &prop);
        XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
        XFree(prop.value);
 }
 
        XSetWMName(xw.dpy, xw.win, &prop);
        XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
        XFree(prop.value);
 }
 

+int
+xstartdraw(void)
+{
+       return IS_SET(MODE_VISIBLE);
+}
+

 void
 void

-draw(void)
+xdrawline(Line line, int x1, int y1, int x2)
+{
+       int i, x, ox, numspecs;
+       Glyph base, new;
+       XftGlyphFontSpec *specs = xw.specbuf;
+
+       numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1);
+       i = ox = 0;
+       for (x = x1; x < x2 && i < numspecs; x++) {
+               new = line[x];
+               if (new.mode == ATTR_WDUMMY)
+                       continue;
+               if (selected(x, y1))
+                       new.mode ^= ATTR_REVERSE;
+               if (i > 0 && ATTRCMP(base, new)) {
+                       xdrawglyphfontspecs(specs, base, i, ox, y1);
+                       specs += i;
+                       numspecs -= i;
+                       i = 0;
+               }
+               if (i == 0) {
+                       ox = x;
+                       base = new;
+               }
+               i++;
+       }
+       if (i > 0)
+               xdrawglyphfontspecs(specs, base, i, ox, y1);
+}
+
+void
+xfinishdraw(void)

 {
 {

-       drawregion(0, 0, term.col, term.row);

        XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w,
                        win.h, 0, 0);
        XSetForeground(xw.dpy, dc.gc,
        XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w,
                        win.h, 0, 0);
        XSetForeground(xw.dpy, dc.gc,


@@ -1394,48 +1708,15 @@ draw(void)
 }
 
 void
 }
 
 void

-drawregion(int x1, int y1, int x2, int y2)
+xximspot(int x, int y)

 {
 {

-       int i, x, y, ox, numspecs;
-       Glyph base, new;
-       XftGlyphFontSpec *specs;
-       int ena_sel = sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN);
-
-       if (!(win.state & WIN_VISIBLE))
+       if (xw.ime.xic == NULL)

                return;
 
                return;
 

-       for (y = y1; y < y2; y++) {
-               if (!term.dirty[y])
-                       continue;
-
-               term.dirty[y] = 0;
-
-               specs = term.specbuf;
-               numspecs = xmakeglyphfontspecs(specs, &term.line[y][x1], x2 - x1, x1, y);
+       xw.ime.spot.x = borderpx + x * win.cw;
+       xw.ime.spot.y = borderpx + (y + 1) * win.ch;

 
 

-               i = ox = 0;
-               for (x = x1; x < x2 && i < numspecs; x++) {
-                       new = term.line[y][x];
-                       if (new.mode == ATTR_WDUMMY)
-                               continue;
-                       if (ena_sel && selected(x, y))
-                               new.mode ^= ATTR_REVERSE;
-                       if (i > 0 && ATTRCMP(base, new)) {
-                               xdrawglyphfontspecs(specs, base, i, ox, y);
-                               specs += i;
-                               numspecs -= i;
-                               i = 0;
-                       }
-                       if (i == 0) {
-                               ox = x;
-                               base = new;
-                       }
-                       i++;
-               }
-               if (i > 0)
-                       xdrawglyphfontspecs(specs, base, i, ox, y);
-       }
-       xdrawcursor();
+       XSetICValues(xw.ime.xic, XNPreeditAttributes, xw.ime.spotlist, NULL);

 }
 
 void
 }
 
 void


@@ -1449,13 +1730,13 @@ visibility(XEvent *ev)
 {
        XVisibilityEvent *e = &ev->xvisibility;
 
 {
        XVisibilityEvent *e = &ev->xvisibility;
 

-       MODBIT(win.state, e->state != VisibilityFullyObscured, WIN_VISIBLE);
+       MODBIT(win.mode, e->state != VisibilityFullyObscured, MODE_VISIBLE);

 }
 
 void
 unmap(XEvent *ev)
 {
 }
 
 void
 unmap(XEvent *ev)
 {

-       win.state &= ~WIN_VISIBLE;
+       win.mode &= ~MODE_VISIBLE;

 }
 
 void
 }
 
 void


@@ -1465,6 +1746,24 @@ xsetpointermotion(int set)
        XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs);
 }
 
        XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs);
 }
 

+void
+xsetmode(int set, unsigned int flags)
+{
+       int mode = win.mode;
+       MODBIT(win.mode, set, flags);
+       if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE))
+               redraw();
+}
+
+int
+xsetcursor(int cursor)
+{
+       if (!BETWEEN(cursor, 0, 7)) /* 7: st extension */
+               return 1;
+       win.cursor = cursor;
+       return 0;
+}
+

 void
 xseturgency(int add)
 {
 void
 xseturgency(int add)
 {


@@ -1476,15 +1775,12 @@ xseturgency(int add)
 }
 
 void
 }
 
 void

-xbell(int vol)
-{
-       XkbBell(xw.dpy, xw.win, vol, (Atom)NULL);
-}
-
-unsigned long
-xwinid(void)
+xbell(void)

 {
 {

-       return xw.win;
+       if (!(IS_SET(MODE_FOCUSED)))
+               xseturgency(1);
+       if (bellvolume)
+               XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL);

 }
 
 void
 }
 
 void


@@ -1496,17 +1792,62 @@ focus(XEvent *ev)
                return;
 
        if (ev->type == FocusIn) {
                return;
 
        if (ev->type == FocusIn) {

-               XSetICFocus(xw.xic);
-               win.state |= WIN_FOCUSED;
+               if (xw.ime.xic)
+                       XSetICFocus(xw.ime.xic);
+               win.mode |= MODE_FOCUSED;

                xseturgency(0);
                if (IS_SET(MODE_FOCUS))
                xseturgency(0);
                if (IS_SET(MODE_FOCUS))

-                       ttywrite("\033[I", 3);
+                       ttywrite("\033[I", 3, 0);

        } else {
        } else {

-               XUnsetICFocus(xw.xic);
-               win.state &= ~WIN_FOCUSED;
+               if (xw.ime.xic)
+                       XUnsetICFocus(xw.ime.xic);
+               win.mode &= ~MODE_FOCUSED;

                if (IS_SET(MODE_FOCUS))
                if (IS_SET(MODE_FOCUS))

-                       ttywrite("\033[O", 3);
+                       ttywrite("\033[O", 3, 0);
+       }
+}
+
+int
+match(uint mask, uint state)
+{
+       return mask == XK_ANY_MOD || mask == (state & ~ignoremod);
+}
+
+char*
+kmap(KeySym k, uint state)
+{
+       Key *kp;
+       int i;
+
+       /* Check for mapped keys out of X11 function keys. */
+       for (i = 0; i < LEN(mappedkeys); i++) {
+               if (mappedkeys[i] == k)
+                       break;
+       }
+       if (i == LEN(mappedkeys)) {
+               if ((k & 0xFFFF) < 0xFD00)
+                       return NULL;
+       }
+
+       for (kp = key; kp < key + LEN(key); kp++) {
+               if (kp->k != k)
+                       continue;
+
+               if (!match(kp->mask, state))
+                       continue;
+
+               if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0)
+                       continue;
+               if (IS_SET(MODE_NUMLOCK) && kp->appkey == 2)
+                       continue;
+
+               if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0)
+                       continue;
+
+               return kp->s;

        }
        }

+
+       return NULL;

 }
 
 void
 }
 
 void


@@ -1514,7 +1855,7 @@ kpress(XEvent *ev)
 {
        XKeyEvent *e = &ev->xkey;
        KeySym ksym;
 {
        XKeyEvent *e = &ev->xkey;
        KeySym ksym;

-       char buf[32], *customkey;
+       char buf[64], *customkey;

        int len;
        Rune c;
        Status status;
        int len;
        Rune c;
        Status status;


@@ -1523,9 +1864,12 @@ kpress(XEvent *ev)
        if (IS_SET(MODE_KBDLOCK))
                return;
 
        if (IS_SET(MODE_KBDLOCK))
                return;
 

-       len = XmbLookupString(xw.xic, e, buf, sizeof buf, &ksym, &status);
+       if (xw.ime.xic)
+               len = XmbLookupString(xw.ime.xic, e, buf, sizeof buf, &ksym, &status);
+       else
+               len = XLookupString(e, buf, sizeof buf, &ksym, NULL);

        /* 1. shortcuts */
        /* 1. shortcuts */

-       for (bp = shortcuts; bp < shortcuts + shortcutslen; bp++) {
+       for (bp = shortcuts; bp < shortcuts + LEN(shortcuts); bp++) {

                if (ksym == bp->keysym && match(bp->mod, e->state)) {
                        bp->func(&(bp->arg));
                        return;
                if (ksym == bp->keysym && match(bp->mod, e->state)) {
                        bp->func(&(bp->arg));
                        return;


@@ -1534,7 +1878,7 @@ kpress(XEvent *ev)
 
        /* 2. custom keys from config.h */
        if ((customkey = kmap(ksym, e->state))) {
 
        /* 2. custom keys from config.h */
        if ((customkey = kmap(ksym, e->state))) {

-               ttysend(customkey, strlen(customkey));
+               ttywrite(customkey, strlen(customkey), 1);

                return;
        }
 
                return;
        }
 


@@ -1553,10 +1897,9 @@ kpress(XEvent *ev)
                        len = 2;
                }
        }
                        len = 2;
                }
        }

-       ttysend(buf, len);
+       ttywrite(buf, len, 1);

 }
 
 }
 

-

 void
 cmessage(XEvent *e)
 {
 void
 cmessage(XEvent *e)
 {


@@ -1566,14 +1909,13 @@ cmessage(XEvent *e)
         */
        if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) {
                if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) {
         */
        if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) {
                if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) {

-                       win.state |= WIN_FOCUSED;
+                       win.mode |= MODE_FOCUSED;

                        xseturgency(0);
                } else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) {
                        xseturgency(0);
                } else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) {

-                       win.state &= ~WIN_FOCUSED;
+                       win.mode &= ~MODE_FOCUSED;

                }
        } else if (e->xclient.data.l[0] == xw.wmdeletewin) {
                }
        } else if (e->xclient.data.l[0] == xw.wmdeletewin) {

-               /* Send SIGHUP to shell */
-               kill(pid, SIGHUP);
+               ttyhangup();

                exit(0);
        }
 }
                exit(0);
        }
 }


@@ -1585,7 +1927,6 @@ resize(XEvent *e)
                return;
 
        cresize(e->xconfigure.width, e->xconfigure.height);
                return;
 
        cresize(e->xconfigure.width, e->xconfigure.height);

-       ttyresize();

 }
 
 void
 }
 
 void


@@ -1594,9 +1935,9 @@ run(void)
        XEvent ev;
        int w = win.w, h = win.h;
        fd_set rfd;
        XEvent ev;
        int w = win.w, h = win.h;
        fd_set rfd;

-       int xfd = XConnectionNumber(xw.dpy), xev, blinkset = 0, dodraw = 0;
-       struct timespec drawtimeout, *tv = NULL, now, last, lastblink;
-       long deltatime;
+       int xfd = XConnectionNumber(xw.dpy), ttyfd, xev, drawing;
+       struct timespec seltv, *tv, now, lastblink, trigger;
+       double timeout;

 
        /* Waiting for window mapping */
        do {
 
        /* Waiting for window mapping */
        do {


@@ -1614,100 +1955,110 @@ run(void)
                }
        } while (ev.type != MapNotify);
 
                }
        } while (ev.type != MapNotify);
 

+       ttyfd = ttynew(opt_line, shell, opt_io, opt_cmd);

        cresize(w, h);
        cresize(w, h);

-       ttynew();
-       ttyresize();
-
-       clock_gettime(CLOCK_MONOTONIC, &last);
-       lastblink = last;

 
 

-       for (xev = actionfps;;) {
+       for (timeout = -1, drawing = 0, lastblink = (struct timespec){0};;) {

                FD_ZERO(&rfd);
                FD_ZERO(&rfd);

-               FD_SET(cmdfd, &rfd);
+               FD_SET(ttyfd, &rfd);

                FD_SET(xfd, &rfd);
 
                FD_SET(xfd, &rfd);
 

-               if (pselect(MAX(xfd, cmdfd)+1, &rfd, NULL, NULL, tv, NULL) < 0) {
+               if (XPending(xw.dpy))
+                       timeout = 0;  /* existing events might not set xfd */
+
+               seltv.tv_sec = timeout / 1E3;
+               seltv.tv_nsec = 1E6 * (timeout - 1E3 * seltv.tv_sec);
+               tv = timeout >= 0 ? &seltv : NULL;
+
+               if (pselect(MAX(xfd, ttyfd)+1, &rfd, NULL, NULL, tv, NULL) < 0) {

                        if (errno == EINTR)
                                continue;
                        die("select failed: %s\n", strerror(errno));
                }
                        if (errno == EINTR)
                                continue;
                        die("select failed: %s\n", strerror(errno));
                }

-               if (FD_ISSET(cmdfd, &rfd)) {
-                       ttyread();
-                       if (blinktimeout) {
-                               blinkset = tattrset(ATTR_BLINK);
-                               if (!blinkset)
-                                       MODBIT(term.mode, 0, MODE_BLINK);
-                       }
-               }
+               clock_gettime(CLOCK_MONOTONIC, &now);

 
 

-               if (FD_ISSET(xfd, &rfd))
-                       xev = actionfps;
+               if (FD_ISSET(ttyfd, &rfd))
+                       ttyread();

 
 

-               clock_gettime(CLOCK_MONOTONIC, &now);
-               drawtimeout.tv_sec = 0;
-               drawtimeout.tv_nsec =  (1000 * 1E6)/ xfps;
-               tv = &drawtimeout;
-
-               dodraw = 0;
-               if (blinktimeout && TIMEDIFF(now, lastblink) > blinktimeout) {
-                       tsetdirtattr(ATTR_BLINK);
-                       term.mode ^= MODE_BLINK;
-                       lastblink = now;
-                       dodraw = 1;
-               }
-               deltatime = TIMEDIFF(now, last);
-               if (deltatime > 1000 / (xev ? xfps : actionfps)) {
-                       dodraw = 1;
-                       last = now;
+               xev = 0;
+               while (XPending(xw.dpy)) {
+                       xev = 1;
+                       XNextEvent(xw.dpy, &ev);
+                       if (XFilterEvent(&ev, None))
+                               continue;
+                       if (handler[ev.type])
+                               (handler[ev.type])(&ev);

                }
 
                }
 

-               if (dodraw) {
-                       while (XPending(xw.dpy)) {
-                               XNextEvent(xw.dpy, &ev);
-                               if (XFilterEvent(&ev, None))
-                                       continue;
-                               if (handler[ev.type])
-                                       (handler[ev.type])(&ev);
+               /*
+                * To reduce flicker and tearing, when new content or event
+                * triggers drawing, we first wait a bit to ensure we got
+                * everything, and if nothing new arrives - we draw.
+                * We start with trying to wait minlatency ms. If more content
+                * arrives sooner, we retry with shorter and shorter periods,
+                * and eventually draw even without idle after maxlatency ms.
+                * Typically this results in low latency while interacting,
+                * maximum latency intervals during `cat huge.txt`, and perfect
+                * sync with periodic updates from animations/key-repeats/etc.
+                */
+               if (FD_ISSET(ttyfd, &rfd) || xev) {
+                       if (!drawing) {
+                               trigger = now;
+                               drawing = 1;

                        }
                        }

+                       timeout = (maxlatency - TIMEDIFF(now, trigger)) \
+                                 / maxlatency * minlatency;
+                       if (timeout > 0)
+                               continue;  /* we have time, try to find idle */
+               }

 
 

-                       draw();
-                       XFlush(xw.dpy);
-
-                       if (xev && !FD_ISSET(xfd, &rfd))
-                               xev--;
-                       if (!FD_ISSET(cmdfd, &rfd) && !FD_ISSET(xfd, &rfd)) {
-                               if (blinkset) {
-                                       if (TIMEDIFF(now, lastblink) \
-                                                       > blinktimeout) {
-                                               drawtimeout.tv_nsec = 1000;
-                                       } else {
-                                               drawtimeout.tv_nsec = (1E6 * \
-                                                       (blinktimeout - \
-                                                       TIMEDIFF(now,
-                                                               lastblink)));
-                                       }
-                                       drawtimeout.tv_sec = \
-                                           drawtimeout.tv_nsec / 1E9;
-                                       drawtimeout.tv_nsec %= (long)1E9;
-                               } else {
-                                       tv = NULL;
-                               }
+               /* idle detected or maxlatency exhausted -> draw */
+               timeout = -1;
+               if (blinktimeout && tattrset(ATTR_BLINK)) {
+                       timeout = blinktimeout - TIMEDIFF(now, lastblink);
+                       if (timeout <= 0) {
+                               if (-timeout > blinktimeout) /* start visible */
+                                       win.mode |= MODE_BLINK;
+                               win.mode ^= MODE_BLINK;
+                               tsetdirtattr(ATTR_BLINK);
+                               lastblink = now;
+                               timeout = blinktimeout;

                        }
                }
                        }
                }

+
+               draw();
+               XFlush(xw.dpy);
+               drawing = 0;

        }
 }
 
        }
 }
 

+void
+usage(void)
+{
+       die("usage: %s [-aiv] [-c class] [-f font] [-g geometry]"
+           " [-n name] [-o file]\n"
+           "          [-T title] [-t title] [-w windowid]"
+           " [[-e] command [args ...]]\n"
+           "       %s [-aiv] [-c class] [-f font] [-g geometry]"
+           " [-n name] [-o file]\n"
+           "          [-T title] [-t title] [-w windowid] -l line"
+           " [stty_args ...]\n", argv0, argv0);
+}
+

 int
 main(int argc, char *argv[])
 {
        xw.l = xw.t = 0;
        xw.isfixed = False;
 int
 main(int argc, char *argv[])
 {
        xw.l = xw.t = 0;
        xw.isfixed = False;

-       win.cursor = cursorshape;
+       xsetcursor(cursorshape);

 
        ARGBEGIN {
        case 'a':
                allowaltscreen = 0;
                break;
 
        ARGBEGIN {
        case 'a':
                allowaltscreen = 0;
                break;

+       case 'A':
+               opt_alpha = EARGF(usage());
+               break;

        case 'c':
                opt_class = EARGF(usage());
                break;
        case 'c':
                opt_class = EARGF(usage());
                break;


@@ -1742,23 +2093,26 @@ main(int argc, char *argv[])
                opt_embed = EARGF(usage());
                break;
        case 'v':
                opt_embed = EARGF(usage());
                break;
        case 'v':

-               die("%s " VERSION " (c) 2010-2016 st engineers\n", argv0);
+               die("%s " VERSION "\n", argv0);

                break;
        default:
                usage();
        } ARGEND;
 
 run:
                break;
        default:
                usage();
        } ARGEND;
 
 run:

-       if (argc > 0) {
-               /* eat all remaining arguments */
+       if (argc > 0) /* eat all remaining arguments */

                opt_cmd = argv;
                opt_cmd = argv;

-               if (!opt_title && !opt_line)
-                       opt_title = basename(xstrdup(argv[0]));
-       }
+
+       if (!opt_title)
+               opt_title = (opt_line || !opt_cmd) ? "st" : opt_cmd[0];
+

        setlocale(LC_CTYPE, "");
        XSetLocaleModifiers("");
        setlocale(LC_CTYPE, "");
        XSetLocaleModifiers("");

-       tnew(MAX(cols, 1), MAX(rows, 1));
-       xinit();
+       cols = MAX(cols, 1);
+       rows = MAX(rows, 1);
+       tnew(cols, rows);
+       xinit(cols, rows);
+       xsetenv();

        selinit();
        run();
 
        selinit();
        run();