code: 9ferno

ref: b548687a8ed1d0a159c9d3f3f921d93bbb56908e
dir: /libtk/utils.c/

#include "lib9.h"
#include "draw.h"
#include "tk.h"

struct TkCol
{
	ulong	rgba1;
	ulong	rgba3;	/* if mixed, otherwise DNotacolor */
	Image*	i;
	TkCol*	forw;
};

extern void	rptwakeup(void*, void*);
extern void*	rptproc(char*, int, void*, int (*)(void*), int (*)(void*,int), void (*)(void*));

typedef struct Cmd Cmd;
struct Cmd
{
	char*	name;
	char*	(*fn)(TkTop*, char*, char**);
};
static struct Cmd cmdmain[] =
{
	"bind",		tkbind,
	"button",	tkbutton,
	"canvas",	tkcanvas,
	"checkbutton",	tkcheckbutton,
	"choicebutton", tkchoicebutton,
	"cursor",	tkcursorcmd,
	"destroy",	tkdestroy,
	"entry",	tkentry,
	"focus",	tkfocus,
	"frame",	tkframe,
	"grab",		tkgrab,
	"grid",	tkgrid,
	"image",	tkimage,
	"label",	tklabel,
	"listbox",	tklistbox,
	"lower",	tklower,
	"menu",		tkmenu,
	"menubutton",	tkmenubutton,
	"pack",		tkpack,
	"panel",		tkpanel,
	"puts",		tkputs,
	"radiobutton",	tkradiobutton,
	"raise",	tkraise,
	"scale",	tkscale,
	"scrollbar",	tkscrollbar,
	"see",	tkseecmd,
	"send",		tksend,
	"text",		tktext,
	"update",	tkupdatecmd,
	"variable",	tkvariable,
	"winfo",	tkwinfo,
};

char*	tkfont;

/*
 * auto-repeating support
 * should perhaps be one rptproc per TkCtxt
 * This is not done for the moment as there isn't
 * a mechanism for terminating the rptproc
 */
static void *autorpt;
static int rptid;
static Tk *rptw;
static void *rptnote;
static void (*rptcb)(Tk*, void*, int);
static long rptto;
static int rptint;

/* blinking carets - should be per TkCtxt */
static void *blinkrpt;
static Tk *blinkw;
static void (*blinkcb)(Tk*, int);
static int blinkignore;
static int blinkon;


ulong
tkrgba(int r, int g, int b, int a)
{
	ulong p;

	if(r < 0)
		r = 0;
	else if(r > 255)
		r = 255;
	if(g < 0)
		g = 0;
	else if(g > 255)
		g = 255;
	if(b < 0)
		b = 0;
	else if(b > 255)
		b = 255;
	p = (r<<24)|(g<<16)|(b<<8)|0xFF;
	if(a == 255)
		return p;
	return setalpha(p, a);
}

/* to be replaced */
static int
revalpha(int c, int a)
{
	if (a == 0)
		return 0;
	return (c & 0xff) * 255 / a;
}

void
tkrgbavals(ulong rgba, int *R, int *G, int *B, int *A)
{
	int a;

	a = rgba & 0xff;
	*A = a;
	if (a != 0xff) {
		*R = revalpha(rgba>>24, a);
		*G = revalpha((rgba>>16) & 0xFF, a);
		*B = revalpha((rgba >> 8) & 0xFF, a);
	} else {
		*R = (rgba>>24);
		*G = ((rgba>>16) & 0xFF);
		*B = ((rgba >> 8) & 0xFF);
	}
}

static int
tkcachecol(TkCtxt *c, Image *i, ulong one, ulong three)
{
	TkCol *cc;

	cc = malloc(sizeof(*cc));
	if(cc == nil)
		return 0;
	cc->rgba1 = one;
	cc->rgba3 = three;
	cc->i = i;
	cc->forw = c->chead;
	c->chead = cc;
	c->ncol++;
	/* we'll do LRU management at some point */
	if(c->ncol > TkColcachesize){
		static int warn;
		if(warn == 0){
			warn = 1;
			print("tk: %d colours cached\n", TkColcachesize);
		}
	}
	return 1;
}

static Image*
tkfindcol(TkCtxt *c, ulong one, ulong three)
{
	TkCol *cc, **l;

	for(l = &c->chead; (cc = *l) != nil; l = &cc->forw)
		if(cc->rgba1 == one && cc->rgba3 == three){
			/* move it up in the list */
			*l = cc->forw;
			cc->forw = c->chead;
			c->chead = cc;
			/* we assume it will be used right away and not stored */
			return cc->i;
		}
	return nil;
}

void
tkfreecolcache(TkCtxt *c)
{
	TkCol *cc;

	if(c == nil)
		return;
	while((cc = c->chead) != nil){
		c->chead = cc->forw;
		freeimage(cc->i);
		free(cc);
	}
	c->ctail = nil;
	c->ncol = 0;
}

Image*
tkcolormix(TkCtxt *c, ulong one, ulong three)
{
	Image *i;
	Display *d;

	i = tkfindcol(c, one, three);
	if(i != nil)
		return i;
	d = c->display;
	i = allocimagemix(d, one, three);
	if(i == nil)
		return d->black;
	if(!tkcachecol(c, i, one, three)){
		freeimage(i);
		return d->black;
	}
	return i;
}

Image*
tkcolor(TkCtxt *c, ulong pix)
{
	Image *i;
	Display *d;
	Rectangle r;

	d = c->display;
	if(pix == DWhite)
		return d->white;
	if(pix == DBlack)
		return d->black;
	i = tkfindcol(c, pix, DNotacolor);
	if(i != nil)
		return i;
	r.min = ZP;
	r.max.x = 1;
	r.max.y = 1;
	if ((pix & 0xff) == 0xff)
		i = allocimage(d, r, RGB24, 1, pix);
	else
		i = allocimage(d, r, RGBA32, 1, pix);
	if(i == nil)
		return d->black;
	if(!tkcachecol(c, i, pix, DNotacolor)) {
		freeimage(i);
		return d->black;
	}
	return i;
}

Image*
tkgradient(TkCtxt *c, Rectangle r, int dir, ulong pix0, ulong pix1)
{
	Display *d;
	Image *i;
	uchar *b, *p, *e;
	int c0[3], c1[3], delta[3], a, j, x, y, n, locked;
	Rectangle s;

	d = c->display;
	y = Dy(r);
	x = Dx(r);
	if(x <= 0 || y <= 0) {
		r = Rect(0, 0, 1, 1);
		x = y = 1;
	}
	/* TO DO: diagonal */
	s = r;
	if(dir == Tkhorizontal){
		n = x;
		r.max.y = r.min.y+1;
	}else{
		n = y;
		r.max.x = r.min.x+1;
	}
	b = mallocz(3*n, 0);
	if(b == nil)
		return nil;
	locked = lockdisplay(d);
	i = allocimage(d, r, RGB24, 1, DNofill);
	if(i == nil)
		goto Ret;
	tkrgbavals(pix0, &c0[2], &c0[1], &c0[0], &a);
	tkrgbavals(pix1, &c1[2], &c1[1], &c1[0], &a);
	for(j = 0; j < 3; j++){
		c0[j] <<= 12;
		c1[j] <<= 12;
		delta[j] = ((c1[j]-c0[j])+(1<<11))/n;
	}
	e = b+3*n;
	for(p = b; p < e; p += 3) {
		p[0] = c0[0]>>12;
		p[1] = c0[1]>>12;
		p[2] = c0[2]>>12;
		c0[0] += delta[0];
		c0[1] += delta[1];
		c0[2] += delta[2];
	}
	loadimage(i, r, b, 3*n);
	replclipr(i, 1, s);
Ret:
	if(locked)
		unlockdisplay(d);
	free(b);
	return i;
}

/*
 * XXX should be in libdraw?
 */
int
tkchanhastype(ulong c, int t)
{
	for(; c; c>>=8)
		if(TYPE(c) == t)
			return 1;
	return 0;
}

void
tksettransparent(Tk *tk, int transparent)
{
	if (transparent)
		tk->flag |= Tktransparent;
	else
		tk->flag &= ~Tktransparent;
}

int
tkhasalpha(TkEnv *e, int col)
{
	return (e->colors[col] & 0xff) != 0xff;
}

Image*
tkgc(TkEnv *e, int col)
{
	return tkcolor(e->top->ctxt, e->colors[col]);
}


/*
 * Todo: improve the fixed-point code
 * the 255 scale factor is used because RGB ranges 0-255
 */
static void
rgb2hsv(int r, int g, int b, int *h, int *s, int *v)
{
	int min, max, delta;

	max = r;
	if(g > max)
		max = g;
	if(b > max)
		max = b;
	min = r;
	if(g < min)
		min = g;
	if(b < min)
		min = b;
	*v = max;
	if (max != 0)
		*s = ((max - min)*255) / max;
	else
		*s = 0;

	if (*s == 0) {
		*h = 0;	/* undefined */
	} else {
		delta = max - min;
		if (r == max) 
			*h = (g - b)*255 / delta;
		else if (g == max)
			*h = (2*255) + ((b - r)*255) / delta;
		else if (b == max)
			*h = (4*255) + ((r - g)*255)/ delta;
		*h *= 60;
		if (*h < 0)
			*h += 360*255;
		*h /= 255;
	}
}

static void
hsv2rgb(int h, int s, int v, int *r, int *g, int *b)
{
	int	i;
	int	f,p,q,t;

	if (s == 0 && h == 0) {
		*r = *g = *b = v;	/* achromatic case */
	} else {
		if (h >= 360)
			h = 0;
		i = h / 60;
		h *= 255;
		h /= 60;

		f = h % 255;
		p = v * (255 - s);
		q = v * (255 - ((s * f)/255));
		t = v * (255- ((s * (255 - f))/255));
		p /= 255;
		q /= 255;
		t /= 255;
		switch (i) {
		case 0: *r = v; *g = t; *b = p; break;
		case 1: *r = q; *g = v; *b = p; break;
		case 2: *r = p; *g = v; *b = t; break;
		case 3: *r = p; *g = q; *b = v; break;
		case 4: *r = t; *g = p; *b = v; break;
		case 5: *r = v; *g = p; *b = q; break;
		}
	}
}

enum {
	MINDELTA	= 0x10,
	DELTA	= 0x30,
};

ulong
tkrgbashade(ulong rgba, int shade)
{
	int R, G, B, A, h, s, v, vl, vd;

	if (shade == TkSameshade)
		return rgba;

	tkrgbavals(rgba, &R, &G, &B, &A);
	h = s = v = 0;
	rgb2hsv(R, G, B, &h, &s, &v);

	if (v < MINDELTA) {
		vd = v+DELTA;
		vl = vd+DELTA;
	} else if (v > 255-MINDELTA) {
		vl = v-DELTA;
		vd = vl-DELTA;
	} else {
		vl = v+DELTA;
		vd = v-DELTA;
	}

	v = (shade == TkLightshade)?vl:vd;
	if (v < 0)
		v = 0;
	if (v > 255)
		v = 255;
	hsv2rgb(h, s, v, &R, &G, &B);

	return tkrgba(R, G, B, A);
}

Image*
tkgshade(TkEnv *e, int col, int shade)
{
	ulong rgba;

	if (col == TkCbackgnd || col == TkCselectbgnd || col == TkCactivebgnd)
		return tkgc(e, col+shade);
	rgba = tkrgbashade(e->colors[col], shade);
	return tkcolor(e->top->ctxt, rgba);
}

TkEnv*
tknewenv(TkTop *t)
{
	TkEnv *e;

	e = malloc(sizeof(TkEnv));
	if(e == nil)
		return nil;

	e->ref = 1;
	e->top = t;
	return e;
}

TkEnv*
tkdefaultenv(TkTop *t)
{
	int locked;
	TkEnv *env;
	Display *d;

	if(t->env != nil) {
		t->env->ref++;
		return t->env;
	}
	t->env = malloc(sizeof(TkEnv));
	if(t->env == nil)
		return nil;

	env = t->env;
	env->ref = 1;
	env->top = t;

	if(tkfont == nil)
		tkfont = "/fonts/pelm/unicode.8.font";

	d = t->display;
	env->font = font_open(d, tkfont);
	if(env->font == nil) {
		static int warn;
		if(warn == 0) {
			warn = 1;
			print("tk: font not found: %s\n", tkfont);
		}
		env->font = font_open(d, "*default*");
		if(env->font == nil) {
			free(t->env);
			t->env = nil;
			return nil;
		}
	}

	locked = lockdisplay(d);
	env->wzero = stringwidth(env->font, "0");
	if ( env->wzero <= 0 )
		env->wzero = env->font->height / 2;
	if(locked)
		unlockdisplay(d);

	tksetenvcolours(env);
	return env;
}

void
tkputenv(TkEnv *env)
{
	Display *d;
	int locked;

	if(env == nil)
		return;

	env->ref--;
	if(env->ref != 0)
		return;

	d = env->top->display;
	locked = lockdisplay(d);

	if(env->font != nil)
		font_close(env->font);

	if(locked)
		unlockdisplay(d);

	free(env);
}

TkEnv*
tkdupenv(TkEnv **env)
{
	Display *d;
	TkEnv *e, *ne;

	e = *env;
	if(e->ref == 1)
		return e;

	ne = malloc(sizeof(TkEnv));
	if(ne == nil)
		return nil;

	ne->ref = 1;
	ne->top = e->top;

	d = e->top->display;
	memmove(ne->colors, e->colors, sizeof(e->colors));
	ne->set = e->set;
	ne->font = font_open(d, e->font->name);
	ne->wzero = e->wzero;

	e->ref--;
	*env = ne;
	return ne;
}

Tk*
tknewobj(TkTop *t, int type, int n)
{
	Tk *tk;

	tk = malloc(n);
	if(tk == 0)
		return 0;

	tk->type = type;		/* Defaults */
	tk->flag = Tktop;
	tk->relief = TKflat;
	tk->env = tkdefaultenv(t);
	if(tk->env == nil) {
		free(tk);
		return nil;
	}

	return tk;
}

void
tkfreebind(TkAction *a)
{
	TkAction *next;

	while(a != nil) {
		next = a->link;
		if((a->type & 0xff) == TkDynamic)
			free(a->arg);
		free(a);
		a = next;
	}
}

void
tkfreename(TkName *f)
{
	TkName *n;

	while(f != nil) {
		n = f->link;
		free(f);
		f = n;
	}
}

void
tkfreeobj(Tk *tk)
{
	TkCtxt *c;

	c = tk->env->top->ctxt;
	if(c != nil) {
		if(c->tkkeygrab == tk)
			c->tkkeygrab = nil;
		if(c->mgrab == tk)
			tksetmgrab(tk->env->top, nil);
		if(c->mfocus == tk)
			c->mfocus = nil;
		if(c->entered == tk)
			c->entered = nil;
	}

	if (tk == rptw) {
		/* cancel the autorepeat without notifying the widget */
		rptid++;
		rptw = nil;
	}
	if (tk == blinkw)
		blinkw = nil;
	tkextnfreeobj(tk);
	tkmethod[tk->type]->free(tk);
	tkputenv(tk->env);
	tkfreebind(tk->binds);
	if(tk->name != nil)
		free(tk->name);
	free(tk);
}

char*
tkaddchild(TkTop *t, Tk *tk, TkName **names)
{
	TkName *n;
	Tk *f, **l;
	int found, len;
	char *s, *ep;

	n = *names;
	if(n == nil || n->name[0] != '.'){
		if(n != nil)
			tkerr(t, n->name);
		return TkBadwp;
	}

	if (n->name[1] == '\0')
		return TkDupli;

	/*
	 * check that the name is well-formed.
	 * ep will point to end of parent component of the name.
	 */
	ep = nil;
	for (s = n->name + 1; *s; s++) {
		if (*s == '.'){
			tkerr(t, n->name);
			return TkBadwp;
		}
		for (; *s && *s != '.'; s++)
			;
		if (*s == '\0')
			break;
		ep = s;
	}
	if (ep == s - 1){
		tkerr(t, n->name);
		return TkBadwp;
	}
	if (ep == nil)
		ep = n->name + 1;
	len = ep - n->name;

	found = 0;
	l = &t->root;
	for(f = *l; f; f = f->siblings) {
		if (f->name != nil) {
			if (strcmp(n->name, f->name->name) == 0)
				return TkDupli;
			if (!found &&
					strncmp(n->name, f->name->name, len) == 0 &&
					f->name->name[len] == '\0')
				found = 1;
		}
		l = &f->siblings;
	}
	if (0) {		/* don't enable this until a reasonably major release... if ever */
		/*
		 * parent widget must already exist
		 */
		if (!found){
			tkerr(t, n->name);
			return TkBadwp;
		}
	}
	*l = tk;
	tk->name = n;
	*names = n->link;

	return nil;
}

Tk*
tklook(TkTop *t, char *wp, int parent)
{
	Tk *f;
	char *p, *q;

	if(wp == nil)
		return nil;

	if(parent) {
		p = strdup(wp);
		if(p == nil)
			return nil;
		q = strrchr(p, '.');
		if(q == nil)
			abort();
		if(q == p) {
			free(p);
			return t->root;
		}
		*q = '\0';	
	} else
		p = wp;

	for(f = t->root; f; f = f->siblings)
		if ((f->name != nil) && (strcmp(f->name->name, p) == 0))
			break;

	if(f != nil && (f->flag & Tkdestroy))
		f = nil;

	if (parent)
		free(p);
	return f;
}

void
tktextsdraw(Image *img, Rectangle r, TkEnv *e, int sbw)
{
	Image *l, *d;
	Rectangle s;

	draw(img, r, tkgc(e, TkCselectbgnd), nil, ZP);
	s.min = r.min;
	s.min.x -= sbw;
	s.min.y -= sbw;
	s.max.x = r.max.x;
	s.max.y = r.min.y;
	l = tkgc(e, TkCselectbgndlght);
	draw(img, s, l, nil, ZP);
	s.max.x = s.min.x + sbw;
	s.max.y = r.max.y + sbw;
	draw(img, s, l, nil, ZP);
	s.max = r.max;
	s.max.x += sbw;
	s.max.y += sbw;
	s.min.x = r.min.x;
	s.min.y = r.max.y;
	d = tkgc(e, TkCselectbgnddark);
	draw(img, s, d, nil, ZP);
	s.min.x = r.max.x;
	s.min.y = r.min.y - sbw;
	draw(img, s, d, nil, ZP);
}

void
tkbox(Image *i, Rectangle r, int bd, Image *fill)
{
	if (bd > 0) {
		draw(i, Rect(r.min.x, r.min.y, r.max.x, r.min.y+bd), fill, nil, ZP);
		draw(i, Rect(r.min.x, r.min.y+bd, r.min.x+bd, r.max.y-bd), fill, nil, ZP);
		draw(i, Rect(r.min.x, r.max.y-bd, r.max.x, r.max.y), fill, nil, ZP);
		draw(i, Rect(r.max.x-bd, r.min.y+bd, r.max.x, r.max.y), fill, nil, ZP);
	}
}

void
tkbevel(Image *i, Point o, int w, int h, int bw, Image *top, Image *bottom)
{
	Rectangle r;
	int x, border;

	border = 2 * bw;

	r.min = o;
	r.max.x = r.min.x + w + border;
	r.max.y = r.min.y + bw;
	draw(i, r, top, nil, ZP);

	r.max.x = r.min.x + bw;
	r.max.y = r.min.y + h + border;
	draw(i, r, top, nil, ZP);

	r.max.x = o.x + w + border;
	r.max.y = o.y + h + border;
	r.min.x = o.x + bw;
	r.min.y = r.max.y - bw;
	for(x = 0; x < bw; x++) {
		draw(i, r, bottom, nil, ZP);
		r.min.x--;
		r.min.y++;
	}
	r.min.x = o.x + bw + w;
	r.min.y = o.y + bw;
	for(x = bw; x >= 0; x--) {
		draw(i, r, bottom, nil, ZP);
		r.min.x++;
		r.min.y--;
	}
}

/*
 * draw a relief border.
 * color is an index into tk->env->colors and assumes
 * light and dark versions following immediately after
 * that index
 */
void
tkdrawrelief(Image *i, Tk *tk, Point o, int color, int rlf)
{
	TkEnv *e;
	Image *l, *d, *t;
	int h, w, bd, bd1, bd2;

	if(tk->borderwidth == 0)
		return;

	h = tk->act.height;
	w = tk->act.width;

	e = tk->env;
	if (color == TkCbackgnd || color == TkCselectbgnd || color == TkCactivebgnd) {
		l = tkgc(e, color+TkLightshade);
		d = tkgc(e, color+TkDarkshade);
	} else {
		l = tkgshade(e, color, TkLightshade);
		d = tkgshade(e, color, TkDarkshade);
	}
	bd = tk->borderwidth;
	if(rlf < 0)
		rlf = TKraised;
	switch(rlf) {
	case TKflat:
		break;
	case TKsunken:
		tkbevel(i, o, w, h, bd, d, l);
		break;	
	case TKraised:
		tkbevel(i, o, w, h, bd, l, d);
		break;	
	case TKgroove:
		t = d;
		d = l;
		l = t;
		/* fall through */
	case TKridge:
		bd1 = bd/2;
		bd2 = bd - bd1;
		if(bd1 > 0)
			tkbevel(i, o, w + 2*bd2, h + 2*bd2, bd1, l, d);
		o.x += bd1;
		o.y += bd1;
		tkbevel(i, o, w, h, bd2, d, l);
		break;
	}
}

Point
tkstringsize(Tk *tk, char *text)
{
	char *q;
	int locked;
	Display *d;
	Point p, t;

	if(text == nil) {
		p.x = 0;
		p.y = tk->env->font->height;
		return p;
	}

	d = tk->env->top->display;
	locked = lockdisplay(d);

	p = ZP;
	while(*text) {
		q = strchr(text, '\n');
		if(q != nil)
			*q = '\0';
		t = stringsize(tk->env->font, text);
		p.y += t.y;
		if(p.x < t.x)
			p.x = t.x;
		if(q == nil)
			break;
		text = q+1;
		*q = '\n';
	}
	if(locked)
		unlockdisplay(d);

	return p;	
}

static void
tkulall(Image *i, Point o, Image *col, Font *f, char *text)
{
	Rectangle r;

	r.max = stringsize(f, text);
	r.max = addpt(r.max, o);
	r.min.x = o.x;
	r.min.y = r.max.y - 1;
	draw(i, r, col, nil, ZP);	
}

static void
tkul(Image *i, Point o, Image *col, int ul, Font *f, char *text)
{
	char c, *v;
	Rectangle r;

	v = text+ul+1;
	c = *v;
	*v = '\0';
	r.max = stringsize(f, text);
	r.max = addpt(r.max, o);
	r.min = stringsize(f, v-1);
	*v = c;
	r.min.x = r.max.x - r.min.x;
	r.min.y = r.max.y - 1;
	r.max.y++;
	draw(i, r, col, nil, ZP);	
}

void
tkdrawstring(Tk *tk, Image *i, Point o, char *text, int ul, Image *col, int j)
{
	int n, l, maxl, sox;
	char *q, *txt;
	Point p;
	TkEnv *e;

	e = tk->env;
	sox = maxl = 0;
	if(j != Tkleft){
		maxl = 0;
		txt = text;
		while(*txt){
			q = strchr(txt, '\n');
			if(q != nil)
				*q = '\0';
			l = stringwidth(e->font, txt);
			if(l > maxl)
				maxl = l;
			if(q == nil)
				break;
			txt = q+1;
			*q = '\n';
		}
		sox = o.x;
	}
	while(*text) {
		q = strchr(text, '\n');
		if(q != nil)
			*q = '\0';
		if(j != Tkleft){
			o.x = sox;
			l = stringwidth(e->font, text);
			if(j == Tkcenter)
				o.x += (maxl-l)/2;
			else
				o.x += maxl-l;
		}
		p = string(i, o, col, o, e->font, text);
		if(ul >= 0) {
			n = strlen(text);
			if(ul < n) {
				tkul(i, o, col, ul, e->font, text);
				ul = -1;
			} else if(ul == n) {
				tkulall(i, o, col, e->font, text);
				ul = -1;
			} else
				ul -= n;
		}
		o.y += e->font->height;
		if(q == nil)
			break;
		text = q+1;
		*q = '\n';
	}
}

/* for debugging */
char*
tkname(Tk *tk)
{
	if(tk == nil)
		return "(nil)";
	if(tk->name == nil)
		return "(noname)";
	return tk->name->name;
}

Tk*
tkdeliver(Tk *tk, int event, void *data)
{
	Tk *dest;

	if(tk != nil && ((ulong)tk->type >= TKwidgets || (uintptr)tk->name < 4096 && tk->name != nil)){
		print("invalid Tk: type %d name %p\n", tk->type, tk->name);
		abort();
	}
//print("tkdeliver %v to %s\n", event, tkname(tk));
	if(tk == nil || ((tk->flag&Tkdestroy) && event != TkDestroy))
		return tk;
	if(event&(TkFocusin|TkFocusout) && (tk->flag&Tktakefocus))
		tk->dirty = tkrect(tk, 1);

	if (tkmethod[tk->type]->deliver != nil) {
		dest = tkmethod[tk->type]->deliver(tk, event, data);
		if (dest == nil)
			return tk;
		tkdirty(tk);
		return dest;
	}

	if((tk->flag & Tkdisabled) == 0)
		tksubdeliver(tk, tk->binds, event, data, 0);
	tkdirty(tk);
	return tk;
}

static int
nullop(char *fmt, ...)
{
	USED(fmt);
	return 0;
}

int
tksubdeliver(Tk *tk, TkAction *binds, int event, void *data, int extn)
{

	TkAction *a;
	int delivered, genkey, delivered2, iskey;
//int (*debug)(char *fmt, ...);

	if (!extn)
		return tkextndeliver(tk, binds, event, data);

//debug = (tk->name && !strcmp(tk->name->name, ".cd")) ? print : nullop;
//debug("subdeliver %v\n", event);

	if (event & TkTakefocus) {
		if (tk->flag & Tktakefocus)
			tksetkeyfocus(tk->env->top, tk, 0);
		return TkDdelivered;
	}

	delivered = TkDnone;
	genkey = 0;
	for(a = binds; a != nil; a = a->link) {
		if(event == a->event) {
//debug("  exact match on %v\n", a->event);
			tkcmdbind(tk, event, a->arg, data);
			delivered = TkDdelivered;
		} else if (a->event == TkKey && (a->type>>8)==TkAadd)
			genkey = 1;
	}
	if(delivered != TkDnone && !((event & TkKey) && genkey))
		return delivered;

	delivered2 = delivered;
	for(a = binds; a != nil; a = a->link) {
		/*
		 * only bind to non-specific key events; if a specific
		 * key event has already been delivered, only deliver event if
		 * the non-specific binding was added. (TkAadd)
		 */
		if (a->event & TkExtns)
			continue;
		iskey = (a->event & TkKey);
		if (iskey ^ (event & TkKey))
			continue;
		if(iskey && (TKKEY(a->event) != 0
					|| ((a->type>>8) != TkAadd && delivered != TkDnone)))
			continue;
		if(!iskey && (a->event & TkMotion) && (a->event&TkEpress) != 0)
			continue;
		if(!(event & TkDouble) && (a->event & TkDouble))
			continue;
		if((event & ~TkDouble) & a->event) {
//debug("  partial match on %v\n", a->event);
			tkcmdbind(tk, event, a->arg, data);
			delivered2 = TkDdelivered;
		}
	}
	return delivered2;
}

void
tkcancel(TkAction **l, int event)
{
	TkAction *a;

	for(a = *l; a; a = *l) {
		if(a->event == event) {
			*l = a->link;
			a->link = nil;
			tkfreebind(a);
			continue;
		}
		l = &a->link;
	}
}

static void
tkcancela(TkAction **l, int event, int type, char *arg)
{
	TkAction *a;

	for(a = *l; a; a = *l) {
		if(a->event == event && strcmp(a->arg, arg) == 0 && (a->type&0xff) == type){
			*l = a->link;
			a->link = nil;
			tkfreebind(a);
			continue;
		}
		l = &a->link;
	}
}

char*
tkaction(TkAction **l, int event, int type, char *arg, int how)
{
	TkAction *a;

	if(arg == nil)
		return nil;
	if(how == TkArepl)
		tkcancel(l, event);
	else if(how == TkAadd){
		for(a = *l; a; a = a->link)
			if(a->event == event && strcmp(a->arg, arg) == 0 && (a->type&0xff) == type){
				a->type = type + (how << 8);
				return nil;
			}
	}
	else if(how == TkAsub){
		tkcancela(l, event, type, arg);
		if(type == TkDynamic)	/* should always be the case */
			free(arg);
		return nil;
	}

	a = malloc(sizeof(TkAction));
	if(a == nil) {
		if(type == TkDynamic)
			free(arg);
		return TkNomem;
	}

	a->event = event;
	a->arg = arg;
	a->type = type + (how << 8);

	a->link = *l;
	*l = a;

	return nil;
}

char*
tkitem(char *buf, char *a)
{
	char *e;

	while(*a && (*a == ' ' || *a == '\t'))
		a++;

	e = buf + Tkmaxitem - 1;
	while(*a && *a != ' ' && *a != '\t' && buf < e)
		*buf++ = *a++;

	*buf = '\0';
	while(*a && (*a == ' ' || *a == '\t'))
		a++;
	return a;
}

/*
 * if tk is a subwindow or a descendent, return the subwindow;
 * return nil otherwise
 */
Tk*
tkfindsub(Tk *tk)
{
	for(; tk != nil; tk = tk->master){
		if(tk->parent != nil)
			return tk;	/* tk->parent is canvas or text */
	}
	return nil;
}

/*
 * Return absolute screen position of tk (just outside its top-left border).
 * When a widget is embedded in a text or canvas widget, we need to
 * use the text or canvas's relpos() function instead of act{x,y}, and we
 * need to folow up the parent pointer rather than the master one.
 */
Point
tkposn(Tk *tk)
{
	Tk *f, *last;
	Point g;

	last = tk;
	if(tk->parent != nil) {
		g = tkmethod[tk->parent->type]->relpos(tk);
		f = tk->parent;
	} else {
		g.x = tk->act.x;
		g.y = tk->act.y;
		f = tk->master;
	}
	while(f != nil) {
		g.x += f->borderwidth;
		g.y += f->borderwidth;
		last = f;
		if(f->parent != nil) {
			g = addpt(g, tkmethod[f->parent->type]->relpos(f));
			f = f->parent;
		} else {
			g.x += f->act.x;
			g.y += f->act.y;
			f = f->master;
		}
	}
	if (last->flag & Tkwindow)
		g = addpt(g, TKobj(TkWin, last)->req);
	return g;
}

/*
 * convert screen coords to local widget coords
 */
Point
tkscrn2local(Tk *tk, Point p)
{
	p = subpt(p, tkposn(tk));
	p.x -= tk->borderwidth;
	p.y -= tk->borderwidth;
	return p;
}

int
tkvisiblerect(Tk *tk, Rectangle *rr)
{
	Rectangle r;
	Point g;
	Tk *f, *last;
	g = Pt(tk->borderwidth, tk->borderwidth);
	last = tk;
	if(tk->parent != nil) {
		g = addpt(g, tkmethod[tk->parent->type]->relpos(tk));
		f = tk->parent;
	} else {
		g.x += tk->act.x;
		g.y += tk->act.y;
		f = tk->master;
	}
	if (f == nil) {
		*rr = tkrect(tk, 1);
		return 1;
	}
	r = rectaddpt(tkrect(tk, 1), g);
	while (f) {
		if (!rectclip(&r, tkrect(f, 0)))
			return 0;
		g.x = f->borderwidth;
		g.y = f->borderwidth;
		last = f;
		if (f->parent != nil) {
			g = addpt(g, tkmethod[f->parent->type]->relpos(f));
			f = f->parent;
		} else {
			g.x += f->act.x;
			g.y += f->act.y;
			f = f->master;
		}
		r = rectaddpt(r, g);
	}
	if (last->flag & Tkwindow)
		r = rectaddpt(r, TKobj(TkWin, last)->act);
	/*
	 * now we have the visible rectangle in screen coords;
	 * subtract actx+borderwidth and we've got it back in
	 * widget-local coords again
	 */
	r = rectsubpt(r, tkposn(tk));
	*rr = rectsubpt(r, Pt(tk->borderwidth, tk->borderwidth));
	return 1;
}

Point
tkanchorpoint(Rectangle r, Point size, int anchor)
{
	int dx, dy;
	Point p;

	p = r.min;
	dx = Dx(r) - size.x;
	dy = Dy(r) - size.y;
	if((anchor & (Tknorth|Tksouth)) == 0)
		p.y += dy/2;
	else if(anchor & Tksouth)
		p.y += dy;

	if((anchor & (Tkeast|Tkwest)) == 0)
		p.x += dx/2;
	else if(anchor & Tkeast)
		p.x += dx;
	return p;
}
	
static char*
tkunits(char c, int *d, TkEnv *e)
{
	switch(c) {
	default:
		if(c >= '0' || c <= '9' || c == '.')
			break;
		return TkBadvl;
	case '\0':
		break;
	case 'c':		/* Centimeters */
		*d *= (Tkdpi*100)/254;
		break;
	case 'm':		/* Millimeters */
		*d *= (Tkdpi*10)/254;
		break;
	case 'i':		/* Inches */
		*d *= Tkdpi;
		break;
	case 'p':		/* Points */
		*d = (*d*Tkdpi)/72;
		break;
	case 'w':		/* Character width */
		if(e == nil)
			return TkBadvl;
		*d = *d * e->wzero;
		break;
	case 'h':		/* Character height */
		if(e == nil)
			return TkBadvl;
		*d = *d * e->font->height;
		break;
	}
	return nil;
}

int
TKF2I(int f)
{
	if (f >= 0)
		return (f + Tkfpscalar/2) / Tkfpscalar;
	return (f - Tkfpscalar/2) / Tkfpscalar;
}

/*
 * Parse a floating point number into a decimal fixed point representation
 */
char*
tkfrac(char **arg, s32 *f, TkEnv *env)
{
	int c, minus, i, fscale, seendigit;
	char *p, *e;

	seendigit = 0;

	p = *arg;
	p = tkskip(p, " \t");

	minus = 0;
	if(*p == '-') {
		minus = 1;
		p++;
	}
	i = 0;
	while(*p) {
		c = *p;
		if(c == '.')
			break;
		if(c < '0' || c > '9')
			break;
		i = i*10 + (c - '0');
		seendigit = 1;
		p++;
	}
	i *= Tkfpscalar;
	if(*p == '.')
		p++;
	fscale = Tkfpscalar;
	while(*p && *p >= '0' && *p <= '9') {
		fscale /= 10;
		i += fscale * (*p++ - '0');
		seendigit = 1;
	}

	if(minus)
		i = -i;

	if(!seendigit)
		return TkBadvl;
	e = tkunits(*p, &i, env);
	if (e != nil)
		return e;
	while (*p && *p != ' ' && *p != '\t')
		p++;
	*arg = p;
	*f = i;
	return nil;
}

char*
tkfracword(TkTop *t, char **arg, s32 *f, TkEnv *env)
{
	char *p;
	char buf[Tkminitem];

	*arg = tkword(t, *arg, buf, buf+sizeof(buf), nil);
	p = buf;
	return tkfrac(&p, f, env);
}

char*
tkfprint(char *v, int frac)
{
	int fscale;

	if(frac < 0) {
		*v++ = '-';
		frac = -frac;
	}
	v += sprint(v, "%d", frac/Tkfpscalar);
	frac = frac%Tkfpscalar;
	if(frac != 0)
		*v++ = '.';
	fscale = Tkfpscalar/10;
	while(frac) {
		*v++ = '0' + frac/fscale;
		frac %= fscale;
		fscale /= 10;
	}
	*v = '\0';
	return v;	
}

char*
tkvalue(char **val, char *fmt, ...)
{
	va_list arg;
	Fmt fmtx;

	if(val == nil)
		return nil;

	fmtstrinit(&fmtx);
	if(*val != nil)
		if(fmtprint(&fmtx, "%s", *val) < 0)
			return TkNomem;
	va_start(arg, fmt);
	fmtvprint(&fmtx, fmt, arg);
	va_end(arg);
	free(*val);
	*val = fmtstrflush(&fmtx);
	if(*val == nil)
		return TkNomem;
	return nil;
}

static char*
tkwidgetcmd(TkTop *t, Tk *tk, char *arg, char **val)
{
	TkMethod *cm;
	TkCmdtab *ct;
	int bot, top, new, r;
	char *e, *buf;

	buf = mallocz(Tkmaxitem, 0);
	if(buf == nil)
		return TkNomem;

	arg = tkword(t, arg, buf, buf+Tkmaxitem, nil);
	if(val != nil)
		*val = nil;

	cm = tkmethod[tk->type];

	e = TkBadcm;
	bot = 0;
	top = cm->ncmd - 1;

	while(bot <= top) {
		new = (bot + top)/2;
		ct = &cm->cmd[new];
		r = strcmp(ct->name, buf);
		if(r == 0) {
			e = ct->fn(tk, arg, val);
			break;
		}
		if(r < 0)
			bot = new + 1;
		else
			top = new - 1;
	}
	free(buf);
	tkdirty(tk);
	return e;
}

Rectangle
tkrect(Tk *tk, int withborder)
{
	Rectangle r;
	int bd;

	bd = withborder? tk->borderwidth: 0;
	r.min.x = -bd;
	r.min.y = -bd;
	r.max.x = tk->act.width + bd;
	r.max.y = tk->act.height + bd;
	return r;
}

void
tkdirty(Tk *tk)
{
	Tk *sub;
	Point rel;
	Rectangle dirty;
	int isdirty, transparent;

	/*
	 * mark as dirty all views underneath a dirty transparent widget
	 *	down to the first opaque widget.
	 * inform parents about any dirtiness.

	 * XXX as Tksubsub never gets reset, testing against Tksubsub doesn't *exactly* test
	 * whether we're in a canvas/text widget, but merely
	 * whether it has ever been. Tksubsub should probably be reset on unpack.
	 */
	isdirty = Dx(tk->dirty) > 0;
	transparent = tk->flag & Tktransparent;
	sub = tk;
	while (isdirty && ((tk->flag&Tksubsub) || transparent)) {
		if (tk->master != nil) {
			if (transparent) {
				rel.x = tk->act.x + tk->borderwidth;
				rel.y = tk->act.y + tk->borderwidth;
				dirty = rectaddpt(sub->dirty, rel);
				sub = tk->master;
				combinerect(&sub->dirty, dirty);
				transparent = sub->flag & Tktransparent;
			}
			tk = tk->master;
		} else if (tk->parent != nil) {
			tkmethod[tk->parent->type]->dirtychild(sub);
			tk = sub = tk->parent;
			isdirty = Dx(sub->dirty) > 0;
			transparent = sub->flag & Tktransparent;
		} else
			break;
	}
}

static int
qcmdcmp(const void *a, const void *b)
{
	return strcmp(((TkCmdtab*)a)->name, ((TkCmdtab*)b)->name);
}

void
tksorttable(void)
{
	int i;
	TkMethod *c;
	TkCmdtab *cmd;

	for(i = 0; i < TKwidgets; i++) {
		c = tkmethod[i];
		if(c->cmd == nil)
			continue;

		for(cmd = c->cmd; cmd->name != nil; cmd++)
			;
		c->ncmd = cmd - c->cmd;

		qsort(c->cmd, c->ncmd, sizeof(TkCmdtab), qcmdcmp);
	}
}

static char*
tksinglecmd(TkTop *t, char *arg, char **val)
{
	Tk *tk;
	int bot, top, new;
	char *e, *buf;

	if(t->debug)
		print("tk: '%s'\n", arg);

	buf = mallocz(Tkmaxitem, 0);
	if(buf == nil)
		return TkNomem;

	arg = tkword(t, arg, buf, buf+Tkmaxitem, nil);
	switch(buf[0]) {
	case '\0':
		free(buf);
		return nil;
	case '.':
		tk = tklook(t, buf, 0);
		if(tk == nil){
			tkerr(t, buf);
			free(buf);
			return TkBadwp;
		}
		e = tkwidgetcmd(t, tk, arg, val);
		free(buf);
		return e;
	}

	bot = 0;
	top = nelem(cmdmain) - 1;
	e = TkBadcm;
	while(bot <= top) {
		int rc;
		new = (bot + top)/2;
		rc = strcmp(cmdmain[new].name, buf); 
		if(!rc) {
			e = cmdmain[new].fn(t, arg, val);
			break;
		}

		if(rc < 0) 
			bot = new + 1;
		else
			top = new - 1;
	}
	free(buf);
	return e;
}

static char*
tkmatch(int inc, int dec, char *p)
{
	int depth, esc, c;

	esc = 0;
	depth = 1;
	while(*p) {
		c = *p;
		if(esc == 0) {
			if(c == inc)
				depth++;
			if(c == dec)
				depth--;
			if(depth == 0)
				return p;
		}
		if(c == '\\' && esc == 0)
			esc = 1;
		else
			esc = 0;
		p++;
	}
	return nil;
}

char*
tkexec(TkTop *t, char *arg, char **val)
{
	int cmdsz, n;
	char *p, *cmd, *e, *c;

	if(t->execdepth >= 0 && ++t->execdepth > 128)
		return TkDepth;

	cmd = nil;
	cmdsz = 0;

	p = arg;
	for(;;) {
		switch(*p++) {
		case '[':
			p = tkmatch('[', ']', p);
			if(p == nil){
				free(cmd);
				return TkSyntx;
			}
			break;
		case '{':
			p = tkmatch('{', '}', p);
			if(p == nil){
				free(cmd);
				return TkSyntx;
			}
			break;
		case ';':
			n = p - arg - 1;
			if(cmdsz < n)
				cmdsz = n;
			c = realloc(cmd, cmdsz+1);
			if(c == nil){
				free(cmd);
				return TkNomem;
			}
			cmd = c;
			memmove(cmd, arg, n);
			cmd[n] = '\0';
			e = tksinglecmd(t, cmd, nil);
			if(e != nil) {
				t->err = e;
				strncpy(t->errcmd, cmd, sizeof(t->errcmd));
				t->errcmd[sizeof(t->errcmd)-1] = '\0';
				free(cmd);
				return e;
			}
			arg = p;
			break;
		case '\0':
		case '\'':
			free(cmd);
			e = tksinglecmd(t, arg, val);
			if(e != nil) {
				t->err = e;
				strncpy(t->errcmd, arg, sizeof(t->errcmd));
				t->errcmd[sizeof(t->errcmd)-1] = '\0';
			}
			return e;
		}
	}
}

static struct {
	char *name;
	int mask;
} events[] = {
	"Button1P",	TkButton1P,
	"Button1R",	TkButton1R,
	"Button2P",	TkButton2P,
	"Button2R",	TkButton2R,
	"Button3P",	TkButton3P,
	"Button3R",	TkButton3R,
	"Button4P",	TkButton4P,
	"Button4R",	TkButton4R,
	"Button5P",	TkButton5P,
	"Button5R",	TkButton5R,
	"Button6P",	TkButton6P,
	"Button6R",	TkButton6R,
	"Extn1",		TkExtn1,
	"Extn2",		TkExtn2,
	"Takefocus",	TkTakefocus,
	"Destroy",		TkDestroy,
	"Enter",		TkEnter,
	"Leave",		TkLeave,
	"Motion",		TkMotion,
	"Map",		TkMap,
	"Unmap",		TkUnmap,
	"Key",		TkKey,
	"Focusin",		TkFocusin,
	"Focusout",	TkFocusout,
	"Configure",	TkConfigure,
	"Double",		TkDouble,
	0
};

int
tkeventfmt(Fmt *f)
{
	int k, i, d;
	int e;

	e = va_arg(f->args, int);

	if ((f->flags & FmtSharp) && e == TkMotion)
		return 0;
	fmtprint(f, "<");
	k = -1;
	if (e & TkKey) {
		k = e & 0xffff;
		e &= ~0xffff;
	}
	d = 0;
	for (i = 0; events[i].name; i++) {
		if (e & events[i].mask) {
			if (d++)
				fmtprint(f, "|");
			fmtprint(f, "%s", events[i].name);
		}
	}
	if (k != -1) {
		fmtprint(f, "[%c]", k);
	} else if (e == 0)
		fmtprint(f, "Noevent");
	fmtprint(f, ">");
	return 0;
}

void
tkerr(TkTop *t, char *e)
{
	if(t != nil && e != nil){
		strncpy(t->errx, e, sizeof(t->errx));
		t->errx[sizeof(t->errx)-1] = '\0';
	}
}

char*
tkerrstr(TkTop *t, char *e)
{
	char *s = malloc(strlen(e)+1+strlen(t->errx)+1);

	if(s == nil)
		return nil;
	strcpy(s, e);
	if(*e == '!'){
		strcat(s, " ");
		strcat(s, t->errx);
	}
	t->errx[0] = '\0';
	return s;
}

char*
tksetmgrab(TkTop *t, Tk *tk)
{
	Tk *omgrab;
	TkCtxt *c;
	c = t->ctxt;
	if (tk == nil) {
		omgrab = c->mgrab;
		c->mgrab = nil;
		/*
		 * don't enterleave if grab reset would cause no leave event
		 */
		if (!(omgrab != nil && (omgrab->flag & Tknograb) &&
				c->entered != nil && (c->entered->flag & Tknograb)))
			tkenterleave(t);
	} else {
		if (c->focused && c->mfocus != nil && c->mfocus->env->top != tk->env->top)
			return "!grab already taken on another toplevel";
		c->mgrab = tk;
		if (tk->flag & Tknograb) {
			if (c->focused) {
				c->focused = 0;
				c->mfocus = nil;
			}
		} else if (c->focused || c->mstate.b != 0) {
			c->focused = 1;
			c->mfocus = tk;
		}
//print("setmgrab(%s) focus now %s\n", tkname(tk), tkname(c->mfocus));
		tkenterleave(t);
	}
	return nil;
}

int
tkinsidepoly(Point *poly, int np, int winding, Point p)
{
	Point pi, pj;
	int i, j, hit;

	hit = 0;
	j = np - 1;
	for(i = 0; i < np; j = i++) {
		pi = poly[i];
		pj = poly[j];
		if((pi.y <= p.y && p.y < pj.y || pj.y <= p.y && p.y < pi.y) &&
				p.x < (pj.x - pi.x) * (p.y - pi.y) / (pj.y - pi.y) + pi.x) {
			if(winding == 1 || pi.y > p.y)
				hit++;
			else
				hit--;
		}
	}
	return (hit & winding) != 0;
}

int
tklinehit(Point *a, int np, int w, Point p)
{
	Point *b;
	int z, nx, ny, nrm;

	while(np-- > 1) {
		b = a+1;
		nx = a->y - b->y;
		ny = b->x - a->x;
		nrm = (nx < 0? -nx : nx) + (ny < 0? -ny : ny);
		if(nrm)
			z = (p.x-b->x)*nx/nrm + (p.y-b->y)*ny/nrm;
		else
			z = (p.x-b->x) + (p.y-b->y);
		if(z < 0)
			z = -z;
		if(z < w)
			return 1;
		a++;
	}
	return 0;
}

int
tkiswordchar(int c)
{
	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c >= 0xA0;
}

int
tkhaskeyfocus(Tk *tk)
{
	if (tk == nil || tk->env->top->focused == 0)
		return 0;
	return tk == tk->env->top->ctxt->tkkeygrab;
}

static int
rptactive(void *v)
{
	intptr id = (intptr)v;
	if (id == rptid)
		return 1;
	return 0;
}

static int
ckrpt(void *v, int interval)
{
	intptr id = (intptr)v;
	if (id != rptid)
		return -1;
	if (interval < rptto)
		return 0;
	return 1;
}

static void
dorpt(void *v)
{
	intptr id = (intptr)v;

	if (id == rptid) {
		rptto = rptint;
		(*rptcb)(rptw, rptnote, 0);
		if (rptint <= 0) {
			rptid++;
			rptw = nil;
		}
	}
}

void
tkcancelrepeat(Tk *tk)
{
	if (tk == rptw) {
		rptid++;
		rptw = nil;
	}
}

void
tkrepeat(Tk *tk, void (*callback)(Tk*, void*, int), void *note, int pause, int interval)
{
	rptid++;
	if (tk != rptw && rptw != nil)
		/* existing callback being replaced- report to owner */
		(*rptcb)(rptw, rptnote, 1);
	rptw = tk;
	if (tk == nil || callback == nil)
		return;
	rptnote = note;
	rptcb = callback;
	rptto = pause;
	rptint = interval;
	if (!autorpt)
		autorpt = rptproc("autorepeat", TkRptclick, (void*)rptid, rptactive, ckrpt, dorpt);
	else
		rptwakeup((void*)rptid, autorpt);
}

static int
blinkactive(void *v)
{
	USED(v);
	return blinkw != nil;
}

static int
ckblink(void *v, int interval)
{
	USED(v);
	USED(interval);

	if (blinkw == nil)
		return -1;
	if (blinkignore) {
		blinkignore = 0;
		return 0;
	}
	return 1;
}

static void
doblink(void *v)
{
	USED(v);

	if (blinkw == nil)
		return;
	blinkcb(blinkw, blinkon++ & 1);
	tkupdate(blinkw->env->top);
}

void
tkblinkreset(Tk *tk)
{
	if (blinkw == tk) {
		blinkignore = 1;
		blinkon = 0;
	}
}

void
tkblink(Tk *tk, void (*callback)(Tk*, int))
{
	if (tk == nil || callback == nil) {
		blinkw = nil;
		return;
	}
	blinkw = tk;
	blinkcb = callback;
	if (!blinkrpt)
		blinkrpt = rptproc("blinker", TkBlinkinterval, nil, blinkactive, ckblink, doblink);
	else
		rptwakeup(nil, blinkrpt);
}

/*
 * debugging
 */
void
tkdump(Tk *tk)
{
	Tk *sl;

	if(tk == nil)
		return;
	if((uint)tk->type < TKwidgets)
		print("%s", tkmethod[tk->type]->name);
	else
		print("TYPE#%#ux", tk->type);
	if(tk->name == nil || (uintptr)tk->name < 512)
		print(" NAME %p", tk->name);
	else
		print(" %s", tkname(tk));
	print(" # tk %#p flag %#ux grid %#p", tk, tk->flag, tk->grid);
	if(tk->parent != nil)
		print(" parent [%#p %q]", tk->parent, tkname(tk->parent));
	if(tk->master != nil)
		print(" master [%#p %q]", tk->master, tkname(tk->master));
	if(tk->slave != nil){
		print(" slaves");
		for(sl = tk->slave; sl != nil; sl = sl->next)
			print(" [%#p %q]", sl, tkname(sl));
	}
	print("\n");
	if(tk->type != TKcanvas)
		return;
	tkcvsdump(tk);
}

void
tktopdump(Tk *tk)
{
	TkTop *top;
	Tk *sub;

	if(tk == nil || tk->env == nil){
		print("# %#p no top\n", tk);
		return;
	}
	top = tk->env->top;
	print("# env %#p top %#p\n", tk->env, top);
	if(top != nil){
		for(sub = top->root; sub != nil; sub = sub->siblings)
			tkdump(sub);
	}
}