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);
}
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);
}
static char*
tkcvsview(Tk *tk, char *arg, char **val, int nl, int *posn, int min, int max, int inc)
{
TkTop *t;
int top, bot, diff, amount;
char *e;
char buf[Tkmaxitem], *v;
diff = max-min;
if(*arg == '\0') {
if ( diff == 0 )
top = bot = 0;
else {
top = TKI2F(*posn-min)/diff;
bot = TKI2F(*posn+nl-min)/diff;
}
v = tkfprint(buf, top);
*v++ = ' ';
tkfprint(v, bot);
return tkvalue(val, "%s", buf);
}
t = tk->env->top;
arg = tkword(t, arg, buf, buf+sizeof(buf), nil);
if(strcmp(buf, "moveto") == 0) {
e = tkfrac(&arg, &top, nil);
if (e != nil)
return e;
*posn = min + TKF2I((top+1)*diff);
}
else
if(strcmp(buf, "scroll") == 0) {
arg = tkword(t, arg, buf, buf+sizeof(buf), nil);
amount = atoi(buf);
tkword(t, arg, buf, buf+sizeof(buf), nil);
if(buf[0] == 'p') /* Pages */
amount = amount * nl * 9 /10;
else if (inc > 0)
amount *= inc;
else
amount = amount * nl / 10;
*posn += amount;
}
else
return TkBadcm;
bot = max - nl;
if(*posn > bot)
*posn = bot;
if(*posn < min)
*posn = min;
tk->dirty = tkrect(tk, 0);
return nil;
}
void
tksizescale(Tk *tk)
{
Point p;
char buf[32];
TkScale *tks;
int fh, w, h, digits, digits2;
tks = TKobj(TkScale, tk);
digits = tks->digits;
if(digits <= 0) {
digits = tkfprint(buf, tks->from) - buf;
digits2 = tkfprint(buf, tks->to) - buf;
digits = maximum(digits, digits2);
if (tks->res > 0) {
digits2 = tkfprint(buf, tks->from + tks->res) - buf;
digits = maximum(digits, digits2);
digits2 = tkfprint(buf, tks->to - tks->res) - buf;
digits = maximum(digits, digits2);
}
}
digits *= tk->env->wzero;
if(tks->sv != BoolT)
digits = 0;
tks->digwidth = digits;
p = tkstringsize(tk, tks->label);
if(tks->orient == Tkvertical) {
h = tks->len + 2*ScaleBW + 2*ScalePad;
w = Scalewidth + 2*ScalePad + 2*ScaleBW;
if (p.x)
w += p.x + ScalePad;
if (tks->sv == BoolT)
w += digits + ScalePad;
} else {
w = maximum(p.x, tks->len + ScaleBW + 2*ScalePad);
h = Scalewidth + 2*ScalePad + 2*ScaleBW;
fh = tk->env->font->height;
if(tks->label != nil)
h += fh + ScalePad;
if(tks->sv == BoolT)
h += fh + ScalePad;
}
w += 2*tk->highlightwidth;
h += 2*tk->highlightwidth;
if(!(tk->flag & Tksetwidth))
tk->req.width = w;
if(!(tk->flag & Tksetheight))
tk->req.height = h;
}
static char*
tkscrollget(Tk *tk, char *arg, char **val)
{
char *v, buf[Tkmaxitem];
TkScroll *tks = TKobj(TkScroll, tk);
USED(arg);
v = tkfprint(buf, tks->top);
*v++ = ' ';
tkfprint(v, tks->bot);
return tkvalue(val, "%s", buf);
}
static char*
tkcvscoords(Tk *tk, char *arg, char **val)
{
int i;
Point *p;
TkCtag *t;
TkName *f;
TkCanvas *c;
TkCitem *item;
char *fmt, *e, *v, buf[Tkmaxitem];
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
if(buf[0] == '\0')
return TkBadvl;
f = tkctaglook(tk, nil, buf);
if(f == nil || f->obj == nil)
return TkBadtg;
c = TKobj(TkCanvas, tk);
t = tkcfirsttag(c->head, f->obj);
if(t == nil)
return TkBadtg;
item = t->item;
if(*arg == '\0') {
fmt = "%s";
p = item->p.parampt;
for(i = 0; i < item->p.npoint; i++) {
v = tkfprint(buf, p->x);
*v++ = ' ';
tkfprint(v, p->y);
e = tkvalue(val, fmt, buf);
if(e != nil)
return e;
fmt = " %s";
p++;
}
return nil;
}
tkbbmax(&c->update, &item->p.bb);
e = tkcimethod[item->type].coord(item, arg, 0, 0);
tkbbmax(&c->update, &item->p.bb);
tkcvssetdirty(tk);
return 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;
}
static char*
tkscrollfraction(Tk *tk, char *arg, char **val)
{
int len, frac, pos;
char buf[Tkmaxitem];
TkScroll *tks = TKobj(TkScroll, tk);
arg = tkitem(buf, arg);
if(tks->orient == Tkvertical)
tkitem(buf, arg);
if(*arg == '\0' || *buf == '\0')
return TkBadvl;
pos = atoi(buf);
if(pos < tks->a1)
pos = tks->a1;
if(pos > tks->a2)
pos = tks->a2;
len = tks->a2 - tks->a1 - 4*Elembw;
frac = TKI2F(1);
if(len != 0)
frac = TKI2F(pos-tks->a1)/len;
tkfprint(buf, frac);
return tkvalue(val, "%s", buf);
}
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;
}
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 char*
tkscrolldelta(Tk *tk, char *arg, char **val)
{
int l, delta;
char buf[Tkmaxitem];
TkScroll *tks = TKobj(TkScroll, tk);
arg = tkitem(buf, arg);
if(tks->orient == Tkvertical)
tkitem(buf, arg);
if(*arg == '\0' || *buf == '\0')
return TkBadvl;
l = tks->a2-tks->a1-4*Elembw;
delta = TKI2F(1);
if(l != 0)
delta = TKI2F(atoi(buf)) / l;
tkfprint(buf, delta);
return tkvalue(val, "%s", buf);
}
static char*
tkscaleget(Tk *tk, char *arg, char **val)
{
int x, y, value, v, l;
char buf[Tkminitem], *e;
TkScale *tks = TKobj(TkScale, tk);
value = tks->value;
if(arg[0] != '\0') {
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;
if(v < tks->pixmin)
value = tks->from;
else
if(v > tks->pixmax)
value = tks->to;
else {
l = tks->pixmax-tks->pixmin;
value = 0;
if (l!=0)
value = v * ((tks->to-tks->from)/l);
value += tks->from;
}
if(tks->res > 0)
value = (value/tks->res)*tks->res;
}
tkfprint(buf, value);
return tkvalue(val, "%s", buf);
}
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;
}
static char*
tkentryxview(Tk *tk, char *arg, char **val)
{
int locked;
TkEnv *env;
TkEntry *tke;
char *buf, *v;
int dx, top, bot, amount, ix, x;
char *e;
tke = TKobj(TkEntry, tk);
env = tk->env;
dx = tk->act.width - 2*xinset(tk);
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
if(*arg == '\0') {
if (tke->textlen == 0 || tke->xlen < dx) {
bot = TKI2F(0);
top = TKI2F(1);
} else {
bot = TKI2F(tke->x0) / tke->xlen;
top = TKI2F(tke->x0 + dx) / tke->xlen;
}
v = tkfprint(buf, bot);
*v++ = ' ';
tkfprint(v, top);
e = tkvalue(val, "%s", buf);
free(buf);
return e;
}
arg = tkitem(buf, arg);
if(strcmp(buf, "moveto") == 0) {
e = tkfracword(env->top, &arg, &top, nil);
if (e != nil) {
free(buf);
return e;
}
tke->x0 = TKF2I(top*tke->xlen);
}
else
if(strcmp(buf, "scroll") == 0) {
arg = tkitem(buf, arg);
amount = atoi(buf);
if(*arg == 'p') /* Pages */
amount *= (9*tke->xlen)/10;
else
if(*arg == 's') { /* Inferno-ism, "scr", must be used in the context of button2p */
x = amount;
amount = x < tke->oldx ? env->wzero : (x > tke->oldx ? -env->wzero : 0);
tke->oldx = x;
}
tke->x0 += amount;
}
else {
e = tkentryparseindex(tk, buf, &ix);
if(e != nil) {
free(buf);
return e;
}
locked = lockdisplay(env->top->display);
tke->x0 = entrytextwidth(tk, ix);
if (locked)
unlockdisplay(env->top->display);
}
free(buf);
if (tke->x0 > tke->xlen - dx)
tke->x0 = tke->xlen - dx;
if (tke->x0 < 0)
tke->x0 = 0;
recalcentry(tk);
e = tkentrysh(tk);
blinkreset(tk);
tk->dirty = tkrect(tk, 1);
return e;
}
static void
tkscalehoriz(Tk *tk, Image *i)
{
TkEnv *e;
char sv[32];
TkScale *tks;
Image *d, *l;
Rectangle r, r2, sr;
Point p, q;
int fh, sh, gh, sl, v, w, h, len;
int fgnd;
e = tk->env;
tks = TKobj(TkScale, tk);
fh = e->font->height;
fgnd = TkCforegnd;
if (tk->flag & Tkdisabled)
fgnd = TkCdisablefgnd;
r = Rect(0, 0, tk->act.width, tk->act.height);
r = rectaddpt(r, Pt(tk->borderwidth, tk->borderwidth));
r = insetrect(r, tk->highlightwidth);
r = insetrect(r, ScalePad);
if(tks->label != nil) {
string(i, r.min, tkgc(e, fgnd), ZP, e->font, tks->label);
r.min.y += fh + ScalePad;
}
if(tks->sv == BoolT)
r.min.y += fh + ScalePad;
sr = insetrect(r, ScaleBW);
w = Dx(sr);
h = Dy(sr);
sl = tks->sl + 2*ScaleBW;
l = tkgc(e, TkCbackgndlght);
d = tkgc(e, TkCbackgnddark);
tkbevel(i, r.min, w, h, ScaleBW, d, l);
tks->pixmin = sr.min.x;
tks->pixmax = sr.max.x;
sh = h - 2*ScaleBW;
tks->sw = sh/2;
w -= sl;
if (w <= 0)
w = 1;
p.x = sr.min.x;
p.y = sr.max.y;
if(tks->tick > 0){
int j, t, l;
t = tks->tick;
l = tks->to-tks->from;
if (l < 0)
l = -l;
if (l == 0)
l = 1;
r2.min.y = p.y;
r2.max.y = p.y + ScaleBW + ScalePad;
for(j = 0; j <= l; j += t){
r2.min.x = p.x+((vlong)j*w)/l+sl/2;
r2.max.x = r2.min.x+1;
draw(i, r2, tkgc(e, fgnd), nil, ZP);
}
}
v = tks->value-tks->from;
len = tks->to-tks->from;
if (len != 0)
p.x += ((vlong)v*w)/len;
p.y = sr.min.y;
q = p;
q.x += tks->sl/2 + 1;
if(ScaleBW > 1) {
gh = sh;
q.y++;
} else
gh = sh-1;
if(tk->flag & Tkactivated) {
r2.min = p;
r2.max.x = p.x+sl;
r2.max.y = sr.max.y;
draw(i, r2, tkgc(e, TkCactivebgnd), nil, ZP);
}
switch(tks->relief) {
case TKsunken:
tkbevel(i, p, tks->sl, sh, ScaleBW, d, l);
tkbevel(i, q, 0, gh, 1, l, d);
break;
case TKraised:
tkbevel(i, p, tks->sl, sh, ScaleBW, l, d);
tkbevel(i, q, 0, gh, 1, d, l);
break;
}
tks->pixpos = p.x;
tks->center = p.y + sh/2 + ScaleBW;
if(tks->sv != BoolT)
return;
tkfprint(sv, tks->value);
if(tks->digits > 0 && tks->digits < strlen(sv))
sv[tks->digits] = '\0';
w = stringwidth(e->font, sv);
p.x = q.x;
p.x -= w/2;
p.y = r.min.y - fh - ScalePad;
if(p.x < tks->pixmin)
p.x = tks->pixmin;
if(p.x+w > tks->pixmax)
p.x = tks->pixmax - w;
string(i, p, tkgc(e, fgnd), ZP, e->font, sv);
}
static void
tkscalevert(Tk *tk, Image *i)
{
TkEnv *e;
TkScale *tks;
char sv[32];
Image *d, *l;
Rectangle r, r2, sr;
Point p, q;
int fh, v, sw, gw, w, h, len, sl;
int fgnd;
e = tk->env;
tks = TKobj(TkScale, tk);
fh = e->font->height;
fgnd = TkCforegnd;
if (tk->flag & Tkdisabled)
fgnd = TkCdisablefgnd;
r = Rect(0, 0, tk->act.width, tk->act.height);
r = rectaddpt(r, Pt(tk->borderwidth, tk->borderwidth));
r = insetrect(r, tk->highlightwidth);
r = insetrect(r, ScalePad);
if (tks->sv)
r.min.x += tks->digwidth + ScalePad;
if(tks->label != nil) {
p = stringsize(e->font, tks->label);
r.max.x -= p.x;
string(i, Pt(r.max.x, r.min.y), tkgc(e, fgnd), ZP, e->font, tks->label);
r.max.x -= ScalePad;
}
sr = insetrect(r, ScaleBW);
h = Dy(sr);
w = Dx(sr);
sl = tks->sl + 2*ScaleBW;
l = tkgc(e, TkCbackgndlght);
d = tkgc(e, TkCbackgnddark);
tkbevel(i, r.min, w, h, ScaleBW, d, l);
tks->pixmin = sr.min.y;
tks->pixmax = sr.max.y;
sw = w - 2*ScaleBW;
tks->sw = sw/2;
h -= sl;
if (h <= 0)
h = 1;
p.x = sr.max.x;
p.y = sr.min.y;
if(tks->tick > 0){
int j, t, l;
t = tks->tick;
l = tks->to-tks->from;
if (l < 0)
l = -l;
if (l == 0)
l = 1;
r2.min = p;
r2.max.x = p.x + ScaleBW + ScalePad;
for(j = 0; j <= l; j += t){
r2.min.y = p.y+((vlong)j*h)/l+sl/2;
r2.max.y = r2.min.y+1;
draw(i, r2, tkgc(e, fgnd), nil, ZP);
}
}
v = tks->value-tks->from;
len = tks->to-tks->from;
if (len != 0)
p.y += ((vlong)v*h)/len;
p.x = sr.min.x;
q = p;
if(ScaleBW > 1) {
q.x++;
gw = sw;
} else
gw = sw-1;
q.y += tks->sl/2 + 1;
if(tk->flag & Tkactivated) {
r2.min = p;
r2.max.x = sr.max.x;
r2.max.y = p.y+sl;
draw(i, r2, tkgc(e, TkCactivebgnd), nil, ZP);
}
switch(tks->relief) {
case TKsunken:
tkbevel(i, p, sw, tks->sl, ScaleBW, d, l);
tkbevel(i, q, gw, 0, 1, l, d);
break;
case TKraised:
tkbevel(i, p, sw, tks->sl, ScaleBW, l, d);
tkbevel(i, q, gw, 0, 1, d, l);
break;
}
tks->pixpos = p.y;
tks->center = p.x + sw/2 + ScaleBW;
if(tks->sv != BoolT)
return;
tkfprint(sv, tks->value);
if(tks->digits > 0 && tks->digits < strlen(sv))
sv[tks->digits] = '\0';
p.x = r.min.x - ScalePad - stringwidth(e->font, sv);
p.y = q.y;
p.y -= fh/2;
if (p.y < tks->pixmin)
p.y = tks->pixmin;
if (p.y + fh > tks->pixmax)
p.y = tks->pixmax - fh;
string(i, p, tkgc(e, fgnd), ZP, e->font, sv);
}