#include <locale.h>
#include <pwd.h>
#include <stdarg.h>
-#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ISCONTROLC0(c) (BETWEEN(c, 0, 0x1f) || (c) == '\177')
#define ISCONTROLC1(c) (BETWEEN(c, 0x80, 0x9f))
#define ISCONTROL(c) (ISCONTROLC0(c) || ISCONTROLC1(c))
-#define ISDELIM(u) (BETWEEN(u, 0, 127) && strchr(worddelimiters, u) != NULL)
+#define ISDELIM(u) (utf8strchr(worddelimiters, u) != NULL)
#define LIMIT(x, a, b) (x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x)
#define ATTRCMP(a, b) ((a).mode != (b).mode || (a).fg != (b).fg || (a).bg != (b).bg)
#define IS_SET(flag) ((term.mode & (flag)) != 0)
typedef struct {
Rune u; /* character code */
ushort mode; /* attribute flags */
- ushort fg; /* foreground */
- ushort bg; /* background */
+ uint32_t fg; /* foreground */
+ uint32_t bg; /* background */
} Glyph;
typedef Glyph *Line;
int col; /* nb col */
Line *line; /* screen */
Line *alt; /* alternate screen */
- bool *dirty; /* dirtyness of lines */
+ int *dirty; /* dirtyness of lines */
XftGlyphFontSpec *specbuf; /* font spec buffer used for rendering */
TCursor c; /* cursor */
int top; /* top scroll limit */
char trantbl[4]; /* charset table translation */
int charset; /* current charset */
int icharset; /* selected charset for sequence */
- bool numlock; /* lock numbers in keyboard */
- bool *tabs;
+ int numlock; /* lock numbers in keyboard */
+ int *tabs;
} Term;
/* Purely graphic info */
Visual *vis;
XSetWindowAttributes attrs;
int scr;
- bool isfixed; /* is fixed geometry? */
+ int isfixed; /* is fixed geometry? */
int l, t; /* left and top offset */
int gm; /* geometry mask */
int tw, th; /* tty width and height */
char *primary, *clipboard;
Atom xtarget;
- bool alt;
+ int alt;
struct timespec tclick1;
struct timespec tclick2;
} Selection;
static void tswapscreen(void);
static void tsetdirt(int, int);
static void tsetdirtattr(int);
-static void tsetmode(bool, bool, int *, int);
+static void tsetmode(int, int, int *, int);
static void tfulldirt(void);
static void techo(Rune);
static void tcontrolcode(uchar );
static void tdectest(char );
static int32_t tdefcolor(int *, int *, int);
static void tdeftran(char);
-static inline bool match(uint, uint);
+static inline int match(uint, uint);
static void ttynew(void);
static void ttyread(void);
static void ttyresize(void);
static void selinit(void);
static void selnormalize(void);
-static inline bool selected(int, int);
+static inline int selected(int, int);
static char *getsel(void);
static void selcopy(Time);
static void selscroll(int, int);
static Rune utf8decodebyte(char, size_t *);
static size_t utf8encode(Rune, char *);
static char utf8encodebyte(Rune, size_t);
+static char *utf8strchr(char *s, Rune u);
static size_t utf8validate(Rune *, size_t);
static ssize_t xwrite(int, const char *, size_t);
static int cmdfd;
static pid_t pid;
static Selection sel;
-static int iofd = STDOUT_FILENO;
+static int iofd = 1;
static char **opt_cmd = NULL;
static char *opt_io = NULL;
static char *opt_title = NULL;
static int frclen = 0;
ssize_t
-xwrite(int fd, const char *s, size_t len) {
+xwrite(int fd, const char *s, size_t len)
+{
size_t aux = len;
while(len > 0) {
}
void *
-xmalloc(size_t len) {
+xmalloc(size_t len)
+{
void *p = malloc(len);
if(!p)
}
void *
-xrealloc(void *p, size_t len) {
+xrealloc(void *p, size_t len)
+{
if((p = realloc(p, len)) == NULL)
die("Out of memory\n");
}
char *
-xstrdup(char *s) {
+xstrdup(char *s)
+{
if((s = strdup(s)) == NULL)
die("Out of memory\n");
}
size_t
-utf8decode(char *c, Rune *u, size_t clen) {
+utf8decode(char *c, Rune *u, size_t clen)
+{
size_t i, j, len, type;
Rune udecoded;
}
Rune
-utf8decodebyte(char c, size_t *i) {
+utf8decodebyte(char c, size_t *i)
+{
for(*i = 0; *i < LEN(utfmask); ++(*i))
if(((uchar)c & utfmask[*i]) == utfbyte[*i])
return (uchar)c & ~utfmask[*i];
}
size_t
-utf8encode(Rune u, char *c) {
+utf8encode(Rune u, char *c)
+{
size_t len, i;
len = utf8validate(&u, 0);
}
char
-utf8encodebyte(Rune u, size_t i) {
+utf8encodebyte(Rune u, size_t i)
+{
return utfbyte[i] | (u & ~utfmask[i]);
}
+char *
+utf8strchr(char *s, Rune u)
+{
+ Rune r;
+ size_t i, j, len;
+
+ len = strlen(s);
+ for(i = 0, j = 0; i < len; i += j) {
+ if(!(j = utf8decode(&s[i], &r, len - i)))
+ break;
+ if(r == u)
+ return &(s[i]);
+ }
+ return NULL;
+}
+
size_t
-utf8validate(Rune *u, size_t i) {
+utf8validate(Rune *u, size_t i)
+{
if(!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
*u = UTF_INVALID;
for(i = 1; *u > utfmax[i]; ++i)
}
void
-selinit(void) {
+selinit(void)
+{
memset(&sel.tclick1, 0, sizeof(sel.tclick1));
memset(&sel.tclick2, 0, sizeof(sel.tclick2));
sel.mode = SEL_IDLE;
}
int
-x2col(int x) {
+x2col(int x)
+{
x -= borderpx;
x /= xw.cw;
}
int
-y2row(int y) {
+y2row(int y)
+{
y -= borderpx;
y /= xw.ch;
}
int
-tlinelen(int y) {
+tlinelen(int y)
+{
int i = term.col;
if(term.line[y][i - 1].mode & ATTR_WRAP)
}
void
-selnormalize(void) {
+selnormalize(void)
+{
int i;
if(sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
sel.ne.x = term.col - 1;
}
-bool
-selected(int x, int y) {
+int
+selected(int x, int y)
+{
if(sel.mode == SEL_EMPTY)
- return false;
+ return 0;
if(sel.type == SEL_RECTANGULAR)
return BETWEEN(y, sel.nb.y, sel.ne.y)
}
void
-selsnap(int *x, int *y, int direction) {
+selsnap(int *x, int *y, int direction)
+{
int newx, newy, xt, yt;
- bool delim, prevdelim;
+ int delim, prevdelim;
Glyph *gp, *prevgp;
switch(sel.snap) {
}
void
-getbuttoninfo(XEvent *e) {
+getbuttoninfo(XEvent *e)
+{
int type;
uint state = e->xbutton.state & ~(Button1Mask | forceselmod);
}
void
-mousereport(XEvent *e) {
+mousereport(XEvent *e)
+{
int x = x2col(e->xbutton.x), y = y2row(e->xbutton.y),
button = e->xbutton.button, state = e->xbutton.state,
len;
}
void
-bpress(XEvent *e) {
+bpress(XEvent *e)
+{
struct timespec now;
Mousekey *mk;
}
char *
-getsel(void) {
+getsel(void)
+{
char *str, *ptr;
int y, bufsize, lastx, linelen;
Glyph *gp, *last;
}
void
-selcopy(Time t) {
+selcopy(Time t)
+{
xsetsel(getsel(), t);
}
void
-selnotify(XEvent *e) {
+selnotify(XEvent *e)
+{
ulong nitems, ofs, rem;
int format;
uchar *data, *last, *repl;
}
void
-selpaste(const Arg *dummy) {
+selpaste(const Arg *dummy)
+{
XConvertSelection(xw.dpy, XA_PRIMARY, sel.xtarget, XA_PRIMARY,
xw.win, CurrentTime);
}
void
-clipcopy(const Arg *dummy) {
+clipcopy(const Arg *dummy)
+{
Atom clipboard;
if(sel.clipboard != NULL)
}
void
-clippaste(const Arg *dummy) {
+clippaste(const Arg *dummy)
+{
Atom clipboard;
clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
}
void
-selclear(XEvent *e) {
+selclear(XEvent *e)
+{
if(sel.ob.x == -1)
return;
sel.mode = SEL_IDLE;
}
void
-selrequest(XEvent *e) {
+selrequest(XEvent *e)
+{
XSelectionRequestEvent *xsre;
XSelectionEvent xev;
Atom xa_targets, string, clipboard;
}
/* all done, send a notification to the listener */
- if(!XSendEvent(xsre->display, xsre->requestor, True, 0, (XEvent *) &xev))
+ if(!XSendEvent(xsre->display, xsre->requestor, 1, 0, (XEvent *) &xev))
fprintf(stderr, "Error sending SelectionNotify event\n");
}
void
-xsetsel(char *str, Time t) {
+xsetsel(char *str, Time t)
+{
free(sel.primary);
sel.primary = str;
}
void
-brelease(XEvent *e) {
+brelease(XEvent *e)
+{
if(IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) {
mousereport(e);
return;
}
void
-bmotion(XEvent *e) {
+bmotion(XEvent *e)
+{
int oldey, oldex, oldsby, oldsey;
if(IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) {
}
void
-die(const char *errstr, ...) {
+die(const char *errstr, ...)
+{
va_list ap;
va_start(ap, errstr);
vfprintf(stderr, errstr, ap);
va_end(ap);
- exit(EXIT_FAILURE);
+ exit(1);
}
void
-execsh(void) {
+execsh(void)
+{
char **args, *sh, *prog;
const struct passwd *pw;
char buf[sizeof(long) * 8 + 1];
signal(SIGALRM, SIG_DFL);
execvp(prog, args);
- _exit(EXIT_FAILURE);
+ _exit(1);
}
void
-sigchld(int a) {
- int stat, ret;
+sigchld(int a)
+{
+ int stat;
pid_t p;
if((p = waitpid(pid, &stat, WNOHANG)) < 0)
if(pid != p)
return;
- ret = WIFEXITED(stat) ? WEXITSTATUS(stat) : EXIT_FAILURE;
- if (ret != EXIT_SUCCESS)
+ if (!WIFEXITED(stat) || WEXITSTATUS(stat))
die("child finished with error '%d'\n", stat);
- exit(EXIT_SUCCESS);
+ exit(0);
}
}
void
-ttynew(void) {
+ttynew(void)
+{
int m, s;
struct winsize w = {term.row, term.col, 0, 0};
if(opt_io) {
term.mode |= MODE_PRINT;
iofd = (!strcmp(opt_io, "-")) ?
- STDOUT_FILENO :
- open(opt_io, O_WRONLY | O_CREAT, 0666);
+ 1 : open(opt_io, O_WRONLY | O_CREAT, 0666);
if(iofd < 0) {
fprintf(stderr, "Error opening %s:%s\n",
opt_io, strerror(errno));
if (opt_line) {
if((cmdfd = open(opt_line, O_RDWR)) < 0)
die("open line failed: %s\n", strerror(errno));
- close(STDIN_FILENO);
+ close(0);
dup(cmdfd);
stty();
return;
case 0:
close(iofd);
setsid(); /* create a new process group */
- dup2(s, STDIN_FILENO);
- dup2(s, STDOUT_FILENO);
- dup2(s, STDERR_FILENO);
+ dup2(s, 0);
+ dup2(s, 1);
+ dup2(s, 2);
if(ioctl(s, TIOCSCTTY, NULL) < 0)
die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
close(s);
}
void
-ttyread(void) {
+ttyread(void)
+{
static char buf[BUFSIZ];
static int buflen = 0;
char *ptr;
}
void
-ttywrite(const char *s, size_t n) {
+ttywrite(const char *s, size_t n)
+{
if(xwrite(cmdfd, s, n) == -1)
die("write error on tty: %s\n", strerror(errno));
}
void
-ttysend(char *s, size_t n) {
+ttysend(char *s, size_t n)
+{
int len;
Rune u;
}
void
-ttyresize(void) {
+ttyresize(void)
+{
struct winsize w;
w.ws_row = term.row;
}
int
-tattrset(int attr) {
+tattrset(int attr)
+{
int i, j;
for(i = 0; i < term.row-1; i++) {
}
void
-tsetdirt(int top, int bot) {
+tsetdirt(int top, int bot)
+{
int i;
LIMIT(top, 0, term.row-1);
}
void
-tsetdirtattr(int attr) {
+tsetdirtattr(int attr)
+{
int i, j;
for(i = 0; i < term.row-1; i++) {
}
void
-tfulldirt(void) {
+tfulldirt(void)
+{
tsetdirt(0, term.row-1);
}
void
-tcursor(int mode) {
+tcursor(int mode)
+{
static TCursor c[2];
- bool alt = IS_SET(MODE_ALTSCREEN);
+ int alt = IS_SET(MODE_ALTSCREEN);
if(mode == CURSOR_SAVE) {
c[alt] = term.c;
}
void
-treset(void) {
+treset(void)
+{
uint i;
term.c = (TCursor){{
}
void
-tnew(int col, int row) {
+tnew(int col, int row)
+{
term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
tresize(col, row);
term.numlock = 1;
}
void
-tswapscreen(void) {
+tswapscreen(void)
+{
Line *tmp = term.line;
term.line = term.alt;
}
void
-tscrolldown(int orig, int n) {
+tscrolldown(int orig, int n)
+{
int i;
Line temp;
}
void
-tscrollup(int orig, int n) {
+tscrollup(int orig, int n)
+{
int i;
Line temp;
}
void
-selscroll(int orig, int n) {
+selscroll(int orig, int n)
+{
if(sel.ob.x == -1)
return;
}
void
-tnewline(int first_col) {
+tnewline(int first_col)
+{
int y = term.c.y;
if(y == term.bot) {
}
void
-csiparse(void) {
+csiparse(void)
+{
char *p = csiescseq.buf, *np;
long int v;
/* for absolute user moves, when decom is set */
void
-tmoveato(int x, int y) {
+tmoveato(int x, int y)
+{
tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
}
void
-tmoveto(int x, int y) {
+tmoveto(int x, int y)
+{
int miny, maxy;
if(term.c.state & CURSOR_ORIGIN) {
}
void
-tsetchar(Rune u, Glyph *attr, int x, int y) {
+tsetchar(Rune u, Glyph *attr, int x, int y)
+{
static char *vt100_0[62] = { /* 0x41 - 0x7e */
"↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
}
void
-tclearregion(int x1, int y1, int x2, int y2) {
+tclearregion(int x1, int y1, int x2, int y2)
+{
int x, y, temp;
Glyph *gp;
}
void
-tdeletechar(int n) {
+tdeletechar(int n)
+{
int dst, src, size;
Glyph *line;
}
void
-tinsertblank(int n) {
+tinsertblank(int n)
+{
int dst, src, size;
Glyph *line;
}
void
-tinsertblankline(int n) {
+tinsertblankline(int n)
+{
if(BETWEEN(term.c.y, term.top, term.bot))
tscrolldown(term.c.y, n);
}
void
-tdeleteline(int n) {
+tdeleteline(int n)
+{
if(BETWEEN(term.c.y, term.top, term.bot))
tscrollup(term.c.y, n);
}
int32_t
-tdefcolor(int *attr, int *npar, int l) {
+tdefcolor(int *attr, int *npar, int l)
+{
int32_t idx = -1;
uint r, g, b;
}
void
-tsetattr(int *attr, int l) {
+tsetattr(int *attr, int l)
+{
int i;
int32_t idx;
}
void
-tsetscroll(int t, int b) {
+tsetscroll(int t, int b)
+{
int temp;
LIMIT(t, 0, term.row-1);
}
void
-tsetmode(bool priv, bool set, int *args, int narg) {
+tsetmode(int priv, int set, int *args, int narg)
+{
int *lim, mode;
- bool alt;
+ int alt;
for(lim = args + narg; args < lim; ++args) {
if(priv) {
}
void
-csihandle(void) {
+csihandle(void)
+{
char buf[40];
int len;
}
void
-csidump(void) {
+csidump(void)
+{
int i;
uint c;
}
void
-csireset(void) {
+csireset(void)
+{
memset(&csiescseq, 0, sizeof(csiescseq));
}
void
-strhandle(void) {
+strhandle(void)
+{
char *p = NULL;
int j, narg, par;
}
void
-strparse(void) {
+strparse(void)
+{
int c;
char *p = strescseq.buf;
}
void
-strdump(void) {
+strdump(void)
+{
int i;
uint c;
}
void
-strreset(void) {
+strreset(void)
+{
memset(&strescseq, 0, sizeof(strescseq));
}
void
-tprinter(char *s, size_t len) {
+tprinter(char *s, size_t len)
+{
if(iofd != -1 && xwrite(iofd, s, len) < 0) {
fprintf(stderr, "Error writing in %s:%s\n",
opt_io, strerror(errno));
}
void
-toggleprinter(const Arg *arg) {
+toggleprinter(const Arg *arg)
+{
term.mode ^= MODE_PRINT;
}
void
-printscreen(const Arg *arg) {
+printscreen(const Arg *arg)
+{
tdump();
}
void
-printsel(const Arg *arg) {
+printsel(const Arg *arg)
+{
tdumpsel();
}
void
-tdumpsel(void) {
+tdumpsel(void)
+{
char *ptr;
if((ptr = getsel())) {
}
void
-tdumpline(int n) {
+tdumpline(int n)
+{
char buf[UTF_SIZ];
Glyph *bp, *end;
}
void
-tdump(void) {
+tdump(void)
+{
int i;
for(i = 0; i < term.row; ++i)
}
void
-tputtab(int n) {
+tputtab(int n)
+{
uint x = term.c.x;
if(n > 0) {
}
void
-techo(Rune u) {
+techo(Rune u)
+{
if(ISCONTROL(u)) { /* control code */
if(u & 0x80) {
u &= 0x7f;
}
void
-tdeftran(char ascii) {
+tdeftran(char ascii)
+{
static char cs[] = "0B";
static int vcs[] = {CS_GRAPHIC0, CS_USA};
char *p;
}
void
-tdectest(char c) {
+tdectest(char c)
+{
int x, y;
if(c == '8') { /* DEC screen alignment test. */
}
void
-tstrsequence(uchar c) {
+tstrsequence(uchar c)
+{
switch (c) {
case 0x90: /* DCS -- Device Control String */
c = 'P';
}
void
-tcontrolcode(uchar ascii) {
+tcontrolcode(uchar ascii)
+{
switch(ascii) {
case '\t': /* HT */
tputtab(1);
* more characters for this sequence, otherwise 0
*/
int
-eschandle(uchar ascii) {
+eschandle(uchar ascii)
+{
switch(ascii) {
case '[':
term.esc |= ESC_CSI;
}
void
-tputc(Rune u) {
+tputc(Rune u)
+{
char c[UTF_SIZ];
- bool control;
+ int control;
int width, len;
Glyph *gp;
}
void
-tresize(int col, int row) {
+tresize(int col, int row)
+{
int i;
int minrow = MIN(row, term.row);
int mincol = MIN(col, term.col);
- bool *bp;
+ int *bp;
TCursor c;
if(col < 1 || row < 1) {
}
void
-xresize(int col, int row) {
+xresize(int col, int row)
+{
xw.tw = MAX(1, col * xw.cw);
xw.th = MAX(1, row * xw.ch);
}
ushort
-sixd_to_16bit(int x) {
+sixd_to_16bit(int x)
+{
return x == 0 ? 0 : 0x3737 + 0x2828 * x;
}
-bool
-xloadcolor(int i, const char *name, Color *ncolor) {
+int
+xloadcolor(int i, const char *name, Color *ncolor)
+{
XRenderColor color = { .alpha = 0xffff };
if(!name) {
}
void
-xloadcols(void) {
+xloadcols(void)
+{
int i;
- static bool loaded;
+ static int loaded;
Color *cp;
if(loaded) {
else
die("Could not allocate color %d\n", i);
}
- loaded = true;
+ loaded = 1;
}
int
-xsetcolorname(int x, const char *name) {
+xsetcolorname(int x, const char *name)
+{
Color ncolor;
if(!BETWEEN(x, 0, LEN(dc.col)))
}
void
-xtermclear(int col1, int row1, int col2, int row2) {
+xtermclear(int col1, int row1, int col2, int row2)
+{
XftDrawRect(xw.draw,
&dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg],
borderpx + col1 * xw.cw,
* Absolute coordinates.
*/
void
-xclear(int x1, int y1, int x2, int y2) {
+xclear(int x1, int y1, int x2, int y2)
+{
XftDrawRect(xw.draw,
&dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg],
x1, y1, x2-x1, y2-y1);
}
void
-xhints(void) {
+xhints(void)
+{
XClassHint class = {opt_class ? opt_class : termname, termname};
XWMHints wm = {.flags = InputHint, .input = 1};
XSizeHints *sizeh = NULL;
sizeh->width_inc = xw.cw;
sizeh->base_height = 2 * borderpx;
sizeh->base_width = 2 * borderpx;
- if(xw.isfixed == True) {
+ if(xw.isfixed) {
sizeh->flags |= PMaxSize | PMinSize;
sizeh->min_width = sizeh->max_width = xw.w;
sizeh->min_height = sizeh->max_height = xw.h;
}
int
-xgeommasktogravity(int mask) {
+xgeommasktogravity(int mask)
+{
switch(mask & (XNegative|YNegative)) {
case 0:
return NorthWestGravity;
}
int
-xloadfont(Font *f, FcPattern *pattern) {
+xloadfont(Font *f, FcPattern *pattern)
+{
FcPattern *match;
FcResult result;
}
void
-xloadfonts(char *fontstr, double fontsize) {
+xloadfonts(char *fontstr, double fontsize)
+{
FcPattern *pattern;
- FcResult r_sz, r_psz;
double fontval;
float ceilf(float);
FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)fontsize);
usedfontsize = fontsize;
} else {
- r_psz = FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval);
- r_sz = FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval);
- if(r_psz == FcResultMatch) {
+ if(FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) ==
+ FcResultMatch) {
usedfontsize = fontval;
- } else if(r_sz == FcResultMatch) {
+ } else if(FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) ==
+ FcResultMatch) {
usedfontsize = -1;
} else {
/*
}
void
-xunloadfont(Font *f) {
+xunloadfont(Font *f)
+{
XftFontClose(xw.dpy, f->match);
FcPatternDestroy(f->pattern);
if(f->set)
}
void
-xunloadfonts(void) {
+xunloadfonts(void)
+{
/* Free the loaded fonts in the font cache. */
while(frclen > 0)
XftFontClose(xw.dpy, frc[--frclen].font);
}
void
-xzoom(const Arg *arg) {
+xzoom(const Arg *arg)
+{
Arg larg;
- larg.i = usedfontsize + arg->i;
+ larg.f = usedfontsize + arg->f;
xzoomabs(&larg);
}
void
-xzoomabs(const Arg *arg) {
+xzoomabs(const Arg *arg)
+{
xunloadfonts();
- xloadfonts(usedfont, arg->i);
+ xloadfonts(usedfont, arg->f);
cresize(0, 0);
redraw();
xhints();
}
void
-xzoomreset(const Arg *arg) {
+xzoomreset(const Arg *arg)
+{
Arg larg;
if(defaultfontsize > 0) {
- larg.i = defaultfontsize;
+ larg.f = defaultfontsize;
xzoomabs(&larg);
}
}
void
-xinit(void) {
+xinit(void)
+{
XGCValues gcvalues;
Cursor cursor;
Window parent;
if(f >= frclen) {
if(!font->set)
font->set = FcFontSort(0, font->pattern,
- FcTrue, 0, &fcres);
+ 1, 0, &fcres);
fcsets[0] = font->set;
/*
FcCharSetAddChar(fccharset, rune);
FcPatternAddCharSet(fcpattern, FC_CHARSET,
fccharset);
- FcPatternAddBool(fcpattern, FC_SCALABLE,
- FcTrue);
+ FcPatternAddBool(fcpattern, FC_SCALABLE, 1);
FcConfigSubstitute(0, fcpattern,
FcMatchPattern);
}
void
-xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y) {
+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 * xw.cw, winy = borderpx + y * xw.ch,
width = charlen * xw.cw;
}
void
-xdrawglyph(Glyph g, int x, int y) {
+xdrawglyph(Glyph g, int x, int y)
+{
int numspecs;
XftGlyphFontSpec spec;
numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y);
}
void
-xdrawcursor(void) {
+xdrawcursor(void)
+{
static int oldx = 0, oldy = 0;
int curx;
Glyph g = {' ', ATTR_NULL, defaultbg, defaultcs};
void
-xsettitle(char *p) {
+xsettitle(char *p)
+{
XTextProperty prop;
Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
}
void
-xresettitle(void) {
+xresettitle(void)
+{
xsettitle(opt_title ? opt_title : "st");
}
void
-redraw(void) {
+redraw(void)
+{
tfulldirt();
draw();
}
void
-draw(void) {
+draw(void)
+{
drawregion(0, 0, term.col, term.row);
XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, xw.w,
xw.h, 0, 0);
}
void
-drawregion(int x1, int y1, int x2, int y2) {
+drawregion(int x1, int y1, int x2, int y2)
+{
int i, x, y, ox, numspecs;
Glyph base, new;
XftGlyphFontSpec* specs;
- bool ena_sel = sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN);
+ int ena_sel = sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN);
if(!(xw.state & WIN_VISIBLE))
return;
}
void
-expose(XEvent *ev) {
+expose(XEvent *ev)
+{
redraw();
}
void
-visibility(XEvent *ev) {
+visibility(XEvent *ev)
+{
XVisibilityEvent *e = &ev->xvisibility;
MODBIT(xw.state, e->state != VisibilityFullyObscured, WIN_VISIBLE);
}
void
-unmap(XEvent *ev) {
+unmap(XEvent *ev)
+{
xw.state &= ~WIN_VISIBLE;
}
void
-xsetpointermotion(int set) {
+xsetpointermotion(int set)
+{
MODBIT(xw.attrs.event_mask, set, PointerMotionMask);
XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs);
}
void
-xseturgency(int add) {
+xseturgency(int add)
+{
XWMHints *h = XGetWMHints(xw.dpy, xw.win);
MODBIT(h->flags, add, XUrgencyHint);
}
void
-focus(XEvent *ev) {
+focus(XEvent *ev)
+{
XFocusChangeEvent *e = &ev->xfocus;
if(e->mode == NotifyGrab)
}
}
-bool
-match(uint mask, uint state) {
+int
+match(uint mask, uint state)
+{
return mask == XK_ANY_MOD || mask == (state & ~ignoremod);
}
void
-numlock(const Arg *dummy) {
+numlock(const Arg *dummy)
+{
term.numlock ^= 1;
}
char*
-kmap(KeySym k, uint state) {
+kmap(KeySym k, uint state)
+{
Key *kp;
int i;
}
void
-kpress(XEvent *ev) {
+kpress(XEvent *ev)
+{
XKeyEvent *e = &ev->xkey;
KeySym ksym;
char buf[32], *customkey;
void
-cmessage(XEvent *e) {
+cmessage(XEvent *e)
+{
/*
* See xembed specs
* http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html
} else if(e->xclient.data.l[0] == xw.wmdeletewin) {
/* Send SIGHUP to shell */
kill(pid, SIGHUP);
- exit(EXIT_SUCCESS);
+ exit(0);
}
}
void
-cresize(int width, int height) {
+cresize(int width, int height)
+{
int col, row;
if(width != 0)
}
void
-resize(XEvent *e) {
+resize(XEvent *e)
+{
if(e->xconfigure.width == xw.w && e->xconfigure.height == xw.h)
return;
}
void
-run(void) {
+run(void)
+{
XEvent ev;
int w = xw.w, h = xw.h;
fd_set rfd;
/* Waiting for window mapping */
do {
XNextEvent(xw.dpy, &ev);
+ /*
+ * XFilterEvent is required to be called after you using XOpenIM,
+ * this is not unnecessary.It does not only filter the key event,
+ * but some clientmessage for input method as well.
+ */
+ if(XFilterEvent(&ev, None))
+ continue;
if(ev.type == ConfigureNotify) {
w = ev.xconfigure.width;
h = ev.xconfigure.height;
}
void
-usage(void) {
+usage(void)
+{
die("%s " VERSION " (c) 2010-2015 st engineers\n"
"usage: st [-a] [-v] [-c class] [-f font] [-g geometry] [-o file]\n"
" [-i] [-t title] [-w windowid] [-e command ...] [command ...]\n"
}
int
-main(int argc, char *argv[]) {
+main(int argc, char *argv[])
+{
uint cols = 80, rows = 24;
xw.l = xw.t = 0;
ARGBEGIN {
case 'a':
- allowaltscreen = false;
+ allowaltscreen = 0;
break;
case 'c':
opt_class = EARGF(usage());
break;
case 'e':
- if(argc > 1)
+ if(argc > 0)
--argc, ++argv;
goto run;
case 'f':
&xw.l, &xw.t, &cols, &rows);
break;
case 'i':
- xw.isfixed = True;
+ xw.isfixed = 1;
break;
case 'o':
opt_io = EARGF(usage());
return 0;
}
-
