void
tkcvssh(Tk *tk)
{
int top, bot, width;
TkCanvas *c = TKobj(TkCanvas, tk);
char val[Tkminitem], cmd[Tkmaxitem], *v, *e;
if(c->xscroll == nil)
return;
top = 0;
bot = TKI2F(1);
width = Dx(c->region);
if(width != 0) {
top = TKI2F(c->view.x)/width;
bot = TKI2F(c->view.x+tk->act.width)/width;
}
v = tkfprint(val, top);
*v++ = ' ';
tkfprint(v, bot);
snprint(cmd, sizeof(cmd), "%s %s", c->xscroll, val);
e = tkexec(tk->env->top, cmd, nil);
if ((e != nil) && (tk->name != nil))
print("tk: xscrollcommand \"%s\": %s\n", tk->name->name, e);
}
static char*
stepscale(Tk *tk, char *pos, int *end)
{
TkScale *tks = TKobj(TkScale, tk);
char *e, buf[Tkmaxitem], f[32];
int s;
s = sgn(tks->to - tks->from);
if(pos == trough1) {
tks->value -= s * tks->bigi;
} else {
/* trough2 */
tks->value += s * tks->bigi;
}
s = !tkscalecheckvalue(tk);
if (end != nil)
*end = s;
e = nil;
if(tks->command != nil) {
/* XXX perhaps should only send command if value has actually changed */
tkfprint(f, tks->value);
snprint(buf, sizeof(buf), "%s %s", tks->command, f);
e = tkexec(tk->env->top, buf, nil);
}
return e;
}
void
tkcvssv(Tk *tk)
{
TkCanvas *c;
int top, bot, height;
char val[Tkminitem], cmd[Tkmaxitem], *v, *e;
c = TKobj(TkCanvas, tk);
if(c->yscroll == nil)
return;
top = 0;
bot = TKI2F(1);
height = Dy(c->region);
if(height != 0) {
top = TKI2F(c->view.y)/height;
bot = TKI2F(c->view.y+tk->act.height)/height;
}
v = tkfprint(val, top);
*v++ = ' ';
tkfprint(v, bot);
snprint(cmd, sizeof(cmd), "%s %s", c->yscroll, val);
e = tkexec(tk->env->top, cmd, nil);
if ((e != nil) && (tk->name != nil))
print("tk: yscrollcommand \"%s\": %s\n", tk->name->name, e);
}
/* tkScrolBut1P %x %y */
static char*
tkScrolBut1P(Tk *tk, char *arg, char **val)
{
int pix;
TkTop *t;
char *e, *fmt, buf[Tkmaxitem];
TkScroll *tks = TKobj(TkScroll, tk);
USED(val);
t = tk->env->top;
if (tks->flag & Autorepeat)
return nil;
arg = tkword(t, arg, buf, buf+sizeof(buf), nil);
if(tks->orient == Tkvertical)
tkword(t, arg, buf, buf+sizeof(buf), nil);
if(buf[0] == '\0')
return TkBadvl;
pix = atoi(buf);
tks->dragpix = pix;
tks->dragtop = tks->top;
tks->dragbot = tks->bot;
pix += tk->borderwidth;
fmt = nil;
e = nil;
if(pix <= tks->a1) {
fmt = "%s scroll -1 unit";
tks->flag |= ButtonA1;
}
if(pix > tks->a1 && pix <= tks->t1)
fmt = "%s scroll -1 page";
if(pix > tks->t1 && pix < tks->t2)
tks->flag |= ButtonB1;
if(pix >= tks->t2 && pix < tks->a2)
fmt = "%s scroll 1 page";
if(pix >= tks->a2) {
fmt = "%s scroll 1 unit";
tks->flag |= ButtonA2;
}
if(tks->cmd != nil && fmt != nil) {
snprint(buf, sizeof(buf), fmt, tks->cmd);
e = tkexec(t, buf, nil);
tks->flag |= Autorepeat;
tkrepeat(tk, sbrepeat, fmt, TkRptpause, TkRptinterval);
}
tk->dirty = tkrect(tk, 1);
return e;
}
static char*
tkscaledrag(Tk *tk, char *arg, char **val)
{
int x, y, v;
char *e, buf[Tkmaxitem], f[32];
TkScale *tks = TKobj(TkScale, tk);
USED(val);
if((tks->flag & Dragging) == 0)
return nil;
if(tks->flag & Autorepeat)
return nil;
e = tkfracword(tk->env->top, &arg, &x, tk->env);
if(e != nil)
return e;
e = tkfracword(tk->env->top, &arg, &y, tk->env);
if(e != nil)
return e;
if(tks->orient == Tkvertical)
v = TKF2I(y) + tk->borderwidth;
else
v = TKF2I(x) + tk->borderwidth;
v -= tks->pix;
x = tks->pixmax-tks->pixmin;
if (x!=tks->sl)
v = tks->base + (vlong)v * (tks->to-tks->from)/(x-tks->sl);
else
v = tks->base;
if(tks->res > 0) {
int a = tks->res / 2;
if (v < 0)
a = -a;
v = ((v+a)/tks->res)*tks->res;
}
tks->value = v;
tkscalecheckvalue(tk);
if(tks->command != nil && tks->jump != BoolT) {
tkfprint(f, tks->value);
snprint(buf, sizeof(buf), "%s %s", tks->command, f);
e = tkexec(tk->env->top, buf, nil);
}
tk->dirty = tkrect(tk, 1);
return e;
}
/* tkScrolDrag %x %y */
static char*
tkScrollDrag(Tk *tk, char *arg, char **val)
{
TkTop *t;
int pix, delta;
char frac[32], buf[Tkmaxitem];
TkScroll *tks = TKobj(TkScroll, tk);
USED(val);
t = tk->env->top;
if (tks->flag & Autorepeat)
return nil;
if((tks->flag & ButtonB1) == 0)
return nil;
arg = tkword(t, arg, buf, buf+sizeof(buf), nil);
if(tks->orient == Tkvertical)
tkword(t, arg, buf, buf+sizeof(buf), nil);
if(buf[0] == '\0')
return TkBadvl;
pix = atoi(buf);
delta = TKI2F(pix-tks->dragpix);
if ( tks->a2 == tks->a1 )
return TkBadvl;
delta = delta/(tks->a2-tks->a1-4*Elembw);
if(tks->jump == BoolT) {
if(tks->dragtop+delta >= 0 &&
tks->dragbot+delta <= TKI2F(1)) {
tks->top = tks->dragtop+delta;
tks->bot = tks->dragbot+delta;
}
return nil;
}
if(tks->cmd != nil) {
delta += tks->dragtop;
if(delta < 0)
delta = 0;
if(delta > TKI2F(1))
delta = TKI2F(1);
tkfprint(frac, delta);
snprint(buf, sizeof(buf), "%s moveto %s", tks->cmd, frac);
return tkexec(t, buf, nil);
}
return nil;
}
static void
sbrepeat(Tk *tk, void *v, int cancelled)
{
char *e, buf[Tkmaxitem];
TkScroll *tks = TKobj(TkScroll, tk);
char *fmt = (char *)v;
if (cancelled) {
tks->flag &= ~Autorepeat;
return;
}
if(tks->cmd != nil && fmt != nil) {
snprint(buf, sizeof(buf), fmt, tks->cmd);
e = tkexec(tk->env->top, buf, nil);
if (e != nil) {
tks->flag &= ~Autorepeat;
tkcancelrepeat(tk);
} else
tkupdate(tk->env->top);
}
}
char*
tkentrysh(Tk *tk)
{
TkEntry *tke = TKobj(TkEntry, tk);
int dx, top, bot;
char *val, *cmd, *v, *e;
if(tke->xscroll == nil)
return nil;
bot = 0;
top = Tkfpscalar;
if(tke->text != 0 && tke->textlen != 0) {
dx = tk->act.width - 2*xinset(tk);
if (tke->xlen > dx) {
bot = TKI2F(tke->x0) / tke->xlen;
top = TKI2F(tke->x0 + dx) / tke->xlen;
}
}
val = mallocz(Tkminitem, 0);
if(val == nil)
return TkNomem;
v = tkfprint(val, bot);
*v++ = ' ';
tkfprint(v, top);
cmd = mallocz(Tkminitem, 0);
if(cmd == nil) {
free(val);
return TkNomem;
}
sprint(cmd, "%s %s", tke->xscroll, val);
e = tkexec(tk->env->top, cmd, nil);
free(cmd);
free(val);
return e;
}
/* tkScrolBut2P fraction */
static char*
tkScrolBut2P(Tk *tk, char *arg, char **val)
{
TkTop *t;
char *e, buf[Tkmaxitem], fracbuf[Tkmaxitem];
TkScroll *tks = TKobj(TkScroll, tk);
USED(val);
t = tk->env->top;
if(arg[0] == '\0')
return TkBadvl;
tkword(t, arg, fracbuf, fracbuf+sizeof(fracbuf), nil);
e = nil;
if(tks->cmd != nil) {
snprint(buf, sizeof(buf), "%s moveto %s", tks->cmd, fracbuf);
e = tkexec(t, buf, nil);
}
return e;
}
static char*
tkscalebut1r(Tk *tk, char *arg, char **val)
{
TkScale *tks = TKobj(TkScale, tk);
char *e, buf[Tkmaxitem], f[32];
USED(val);
USED(arg);
if(tks->flag & Autorepeat) {
tkcancelrepeat(tk);
tks->flag &= ~Autorepeat;
}
e = nil;
if (tks->flag & Dragging) {
if (tks->command != nil && tks->jump == BoolT && (tks->flag & Dragging)) {
tkfprint(f, tks->value);
snprint(buf, sizeof(buf), "%s %s", tks->command, f);
e = tkexec(tk->env->top, buf, nil);
}
tks->relief = TKraised;
tks->flag &= ~Dragging;
tk->dirty = tkrect(tk, 1);
}
return e;
}
void
tkcmdbind(Tk *tk, int event, char *s, void *data)
{
Point p;
TkMouse *m;
TkGeom *g;
int v, len;
char *e, *c, *ec, *cmd;
TkTop *t;
if(s == nil)
return;
cmd = malloc(2*Tkmaxitem);
if (cmd == nil) {
print("tk: bind command \"%s\": %s\n",
tk->name ? tk->name->name : "(noname)", TkNomem);
return;
}
m = (TkMouse*)data;
c = cmd;
ec = cmd+2*Tkmaxitem-1;
while(*s && c < ec) {
if(*s != '%') {
*c++ = *s++;
continue;
}
s++;
len = ec-c;
switch(*s++) {
def:
default:
*c++ = s[-1];
break;
case '%':
*c++ = '%';
break;
case 'b':
v = 0;
if (!(event & TkKey)) {
if(event & (TkButton1P|TkButton1R))
v = 1;
else if(event & (TkButton2P|TkButton2R))
v = 2;
else if(event & (TkButton3P|TkButton3R))
v = 3;
}
c += snprint(c, len, "%d", v);
break;
case 'h':
if((event & TkConfigure) == 0)
goto def;
g = (TkGeom*)data;
c += snprint(c, len, "%d", g->height);
break;
case 's':
if((event & TkKey))
c += snprint(c, len, "%d", TKKEY(event));
else if((event & (TkEmouse|TkEnter)))
c += snprint(c, len, "%d", m->b);
else if((event & TkFocusin))
c += snprint(c, len, "%d", (int)data);
else
goto def;
break;
case 'w':
if((event & TkConfigure) == 0)
goto def;
g = (TkGeom*)data;
c += snprint(c, len, "%d", g->width);
break;
case 'x': /* Relative mouse coords */
case 'y':
if((event & TkKey) || (event & (TkEmouse|TkEnter)) == 0)
goto def;
p = tkposn(tk);
if(s[-1] == 'x')
v = m->x - p.x;
else
v = m->y - p.y;
c += snprint(c, len, "%d", v - tk->borderwidth);
break;
case 'X': /* Absolute mouse coords */
case 'Y':
if((event & TkKey) || (event & TkEmouse) == 0)
goto def;
c += snprint(c, len, "%d", s[-1] == 'X' ? m->x : m->y);
break;
case 'A':
if((event & TkKey) == 0)
goto def;
v = TKKEY(event);
if(v == '{' || v == '}' || v == '\\')
c += snprint(c, len, "\\%C", v);
else if(v != '\0')
c += snprint(c, len, "%C", v);
break;
case 'K':
if((event & TkKey) == 0)
goto def;
c += snprint(c, len, "%.4X", TKKEY(event));
break;
case 'W':
if (tk->name != nil)
c += snprint(c, len, "%s", tk->name->name);
break;
}
}
*c = '\0';
e = nil;
t = tk->env->top;
t->execdepth = 0;
if(cmd[0] == '|')
tkexec(t, cmd+1, nil);
else if(cmd[0] != '\0')
e = tkexec(t, cmd, nil);
t->execdepth = -1;
if(e == nil) {
free(cmd);
return;
}
if(tk->name != nil){
char *s;
if(t->errx[0] != '\0')
s = tkerrstr(t, e);
else
s = e;
print("tk: bind command \"%s\": %s: %s\n", tk->name->name, cmd, s);
if(s != e)
free(s);
}
free(cmd);
}
