char*
tkpropagate(TkTop *t, char *arg)
{
Tk *tk;
TkStab *s;
char *buf;
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
arg = tkword(t, arg, buf, buf+Tkmaxitem, nil);
tk = tklook(t, buf, 0);
if(tk == nil) {
tkerr(t, buf);
free(buf);
return TkBadwp;
}
tkword(t, arg, buf, buf+Tkmaxitem, nil);
for(s = tkbool; s->val; s++) {
if(strcmp(s->val, buf) == 0) {
if(s->con == BoolT) {
tk->flag &= ~Tknoprop;
tkpackqit(tk);
tkrunpack(t);
} else
tk->flag |= Tknoprop;
free(buf);
return nil;
}
}
free(buf);
return TkBadvl;
}
static char*
tkcvslower(Tk *tk, char *arg, char **val)
{
TkCtag *t;
TkCanvas *c;
TkName *f, *b;
char buf[Tkmaxitem];
TkCitem *it, **l, **below, *items, **itemtail, *prev, *iprev;
USED(val);
c = TKobj(TkCanvas, tk);
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
f = tkctaglook(tk, nil, buf);
if(f == nil || f->obj == nil)
return nil;
below = &c->head;
tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
if(buf[0] != '\0') {
b = tkctaglook(tk, nil, buf);
if(b == nil || f->obj == nil)
return TkBadtg;
for(it = c->head; it; it = it->next) {
for(t = b->obj; t; t = t->taglist)
if(t->item == it)
goto found;
below = &it->next;
}
found:;
}
l = &c->head;
prev = iprev = nil;
itemtail = &items;;
for (it = *l; it != nil; it = *l) {
for (t = f->obj; t; t = t->taglist) {
if(t->item == it) {
if (it == *below || below == &it->next)
below = l;
if (it == c->tail)
c->tail = prev;
*l = it->next;
*itemtail = it;
iprev = it;
itemtail = &it->next;
tkbbmax(&c->update, &it->p.bb);
goto next;
}
}
prev = it;
l = &it->next;
next:;
}
if (prev == nil)
c->tail = iprev;
*itemtail = *below;
*below = items;
tkcvssetdirty(tk);
return nil;
}
static char*
tkcvscanvx(Tk *tk, char *arg, char **val)
{
int x, s;
TkCanvas *c;
Point p;
char buf[Tkmaxitem];
c = TKobj(TkCanvas, tk);
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
if(buf[0] == '\0')
return TkBadvl;
p = tkposn(tk);
x = atoi(buf) + c->view.x - (p.x + tk->borderwidth);
if(*arg) {
tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
s = atoi(buf);
if (s) {
if (x>=0)
x = ((x+s/2)/s)*s;
else
x = ((x-s/2)/s)*s;
}
}
return tkvalue(val, "%d", x);
}
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;
}
/* 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;
}
/* 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*
tkslaves(TkTop *t, char *arg, char **val)
{
Tk *tk;
char *fmt, *e, *buf;
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
tkword(t, arg, buf, buf+Tkmaxitem, nil);
tk = tklook(t, buf, 0);
if(tk == nil){
tkerr(t, buf);
free(buf);
return TkBadwp;
}
free(buf);
fmt = "%s";
for(tk = tk->slave; tk; tk = tk->next) {
if (tk->name != nil) {
e = tkvalue(val, fmt, tk->name->name);
if(e != nil)
return e;
fmt = " %s";
}
}
return nil;
}
static char*
tkforget(TkTop *t, char *arg)
{
Tk *tk;
char *buf;
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
for(;;) {
arg = tkword(t, arg, buf, buf+Tkmaxitem, nil);
if(buf[0] == '\0')
break;
tk = tklook(t, buf, 0);
if(tk == nil) {
tkrunpack(t);
tkerr(t, buf);
free(buf);
return TkBadwp;
}
tkpackqit(tk->master);
tkdelpack(tk);
}
free(buf);
tkrunpack(t);
return nil;
}
static char*
tkentryicursor(Tk *tk, char *arg, char **val)
{
TkEntry *tke = TKobj(TkEntry, tk);
int index, locked;
char *r, *buf;
USED(val);
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
tkword(tk->env->top, arg, buf, buf+Tkmaxitem, nil);
r = tkentryparseindex(tk, buf, &index);
free(buf);
if(r != nil)
return r;
tke->icursor = index;
locked = lockdisplay(tk->env->top->display);
tke->xicursor = entrytextwidth(tk, tke->icursor);
if (locked)
unlockdisplay(tk->env->top->display);
blinkreset(tk);
tk->dirty = tkrect(tk, 1);
return nil;
}
char*
tksend(TkTop *t, char *arg, char **ret)
{
TkVar *v;
char *var;
USED(ret);
var = mallocz(Tkmaxitem, 0);
if(var == nil)
return TkNomem;
arg = tkword(t, arg, var, var+Tkmaxitem, nil);
v = tkmkvar(t, var, 0);
free(var);
if(v == nil)
return TkBadvr;
if(v->type != TkVchan)
return TkNotvt;
arg = tkskip(arg, " \t");
if(tktolimbo(v->value, arg) == 0)
return TkMovfw;
return nil;
}
static char*
tkcvsitemconf(Tk *tk, char *arg, char **val)
{
char *e;
TkName *f;
TkCtag *t;
TkCitem *i;
TkCanvas *c;
char buf[Tkmaxitem];
USED(val);
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
f = tkctaglook(tk, nil, buf);
if(f == nil || f->obj == nil)
return TkBadtg;
c = TKobj(TkCanvas, tk);
for(t = f->obj; t; t = t->taglist) {
for(i = c->head; i; i = i->next) {
if(i == t->item) {
tkbbmax(&c->update, &i->p.bb);
e = tkcimethod[i->type].conf(tk, i, arg);
tkbbmax(&c->update, &i->p.bb);
tkcvssetdirty(tk);
if(e != nil)
return e;
}
}
}
return nil;
}
static char*
tkcvscanvy(Tk *tk, char *arg, char **val)
{
int y, s;
TkCanvas *c;
Point p;
char buf[Tkmaxitem];
c = TKobj(TkCanvas, tk);
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
if(buf[0] == '\0')
return TkBadvl;
p = tkposn(tk);
y = atoi(buf) + c->view.y - (p.y + tk->borderwidth);
if(*arg) {
tkitem(buf, arg);
s = atoi(buf);
if (s) {
if (y>=0)
y = ((y+s/2)/s)*s;
else
y = ((y-s/2)/s)*s;
}
}
return tkvalue(val, "%d", y);
}
char*
tkcvstextinsert(Tk *tk, TkCitem *i, char *arg)
{
TkTop *top;
TkCtext *t;
int first, n;
char *e, *text, buf[Tkmaxitem];
t = TKobj(TkCtext, i);
top = tk->env->top;
arg = tkword(top, arg, buf, buf+sizeof(buf), nil);
e = tkcvsparseindex(i, buf, &first);
if(e != nil)
return e;
if(*arg == '\0')
return nil;
text = malloc(Tkcvstextins);
if(text == nil)
return TkNomem;
tkword(top, arg, text, text+Tkcvstextins, nil);
n = strlen(text);
t->text = realloc(t->text, t->tlen+n+1);
if(t->text == nil) {
free(text);
return TkNomem;
}
if(t->tlen == 0)
t->text[0] = '\0';
tkbbmax(&TKobj(TkCanvas, tk)->update, &i->p.bb);
memmove(t->text+first+n, t->text+first, t->tlen-first+1);
memmove(t->text+first, text, n);
t->tlen += n;
free(text);
tkcvstextsize(i);
tkbbmax(&TKobj(TkCanvas, tk)->update, &i->p.bb);
tkcvssetdirty(tk);
return nil;
}
static char*
tkcvsscale(Tk *tk, char *arg, char **val)
{
TkName *f;
TkCtag *t;
TkCanvas *c;
TkCpoints pts;
TkCitem *item;
int j;
char *e, buf[Tkmaxitem];
Point *p, *d, origin, scalef;
USED(val);
c = TKobj(TkCanvas, tk);
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
f = tkctaglook(tk, nil, buf);
if(f == nil || f->obj == nil)
return TkBadtg;
e = tkparsepts(tk->env->top, &pts, &arg, 0);
if(e != nil)
return e;
if(pts.npoint != 2) {
tkfreepoint(&pts);
return TkFewpt;
}
origin = pts.parampt[0];
scalef = pts.parampt[1];
tkfreepoint(&pts);
for(t = f->obj; t; t = t->taglist) {
item = t->item;
p = item->p.parampt;
d = item->p.drawpt;
for(j = 0; j < item->p.npoint; j++) {
p->x -= origin.x;
p->y -= origin.y;
p->x = TKF2I(p->x*scalef.x);
p->y = TKF2I(p->y*scalef.y);
p->x += origin.x;
p->y += origin.y;
d->x = TKF2I(p->x);
d->y = TKF2I(p->y);
d++;
p++;
}
tkbbmax(&c->update, &item->p.bb);
e = tkcimethod[item->type].coord(item, nil, 0, 0);
tkbbmax(&c->update, &item->p.bb);
if(e != nil)
return e;
tkcvssetdirty(tk);
}
return nil;
}
static char*
tkcvsselect(Tk *tk, char *arg, char **val)
{
int op;
TkCtag *t;
TkName *f;
TkCanvas *c;
char buf[Tkmaxitem];
c = TKobj(TkCanvas, tk);
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
if(strcmp(buf, "clear") == 0) {
tkcvstextclr(tk);
return nil;
}
if(strcmp(buf, "item") == 0) {
if(c->selection)
return tkvalue(val, "%d", c->selection->id);
return nil;
}
if(strcmp(buf, "to") == 0)
op = TkCselto;
else
if(strcmp(buf, "from") == 0)
op = TkCselfrom;
else
if(strcmp(buf, "adjust") == 0)
op = TkCseladjust;
else
return TkBadcm;
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
f = tkctaglook(tk, nil, buf);
if(f == nil)
return TkBadtg;
t = tkcfirsttag(c->head, f->obj);
if(t == nil)
return TkBadtg;
return tkcvstextselect(tk, t->item, arg, op);
}
char*
tkvariable(TkTop *t, char *arg, char **ret)
{
TkVar *v;
char *fmt, *e, *buf, *ebuf, *val;
int l;
l = strlen(arg) + 2;
buf = malloc(l);
if(buf == nil)
return TkNomem;
ebuf = buf+l;
arg = tkword(t, arg, buf, ebuf, nil);
arg = tkskip(arg, " \t");
if (*arg == '\0') {
if(strcmp(buf, "lasterror") == 0) {
free(buf);
if(t->err == nil)
return nil;
fmt = "%s: %s";
if(strlen(t->errcmd) == sizeof(t->errcmd)-1)
fmt = "%s...: %s";
e = tkvalue(ret, fmt, t->errcmd, t->err);
t->err = nil;
return e;
}
v = tkmkvar(t, buf, 0);
free(buf);
if(v == nil || v->value == nil)
return nil;
if(v->type != TkVstring)
return TkNotvt;
return tkvalue(ret, "%s", v->value);
}
val = buf+strlen(buf)+1;
tkword(t, arg, val, ebuf, nil);
e = tksetvar(t, buf, val);
free(buf);
return e;
}
static char*
tkentryget(Tk *tk, char *arg, char **val)
{
TkTop *top;
TkEntry *tke;
int first, last;
char *e, *buf;
tke = TKobj(TkEntry, tk);
if(tke->text == nil)
return nil;
arg = tkskip(arg, " \t");
if(*arg == '\0')
return tkvalue(val, "%.*S", tke->textlen, tke->text);
top = tk->env->top;
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
arg = tkword(top, arg, buf, buf+Tkmaxitem, nil);
e = tkentryparseindex(tk, buf, &first);
if(e != nil) {
free(buf);
return e;
}
last = first+1;
tkword(top, arg, buf, buf+Tkmaxitem, nil);
if(buf[0] != '\0') {
e = tkentryparseindex(tk, buf, &last);
if(e != nil) {
free(buf);
return e;
}
}
free(buf);
if(last <= first || tke->textlen == 0 || first == tke->textlen)
return tkvalue(val, "%S", L"");
return tkvalue(val, "%.*S", last-first, tke->text+first);
}
static char*
tkcvscreate(Tk *tk, char *arg, char **val)
{
TkCimeth *m;
char buf[Tkmaxitem];
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
for(m = tkcimethod; m->name; m++)
if(strcmp(buf, m->name) == 0)
return m->create(tk, arg, val);
return TkBadit;
}
char*
tkcvstextindex(Tk *tk, TkCitem *i, char *arg, char **val)
{
int first;
char *e, buf[Tkmaxitem];
tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
e = tkcvsparseindex(i, buf, &first);
if(e != nil)
return e;
return tkvalue(val, "%d", first);
}
char*
tkcvstextdchar(Tk *tk, TkCitem *i, char *arg)
{
TkTop *top;
TkCtext *t;
int first, last;
char *e, buf[Tkmaxitem];
t = TKobj(TkCtext, i);
top = tk->env->top;
arg = tkword(top, arg, buf, buf+sizeof(buf), nil);
e = tkcvsparseindex(i, buf, &first);
if(e != nil)
return e;
last = first+1;
if(*arg != '\0') {
tkword(top, arg, buf, buf+sizeof(buf), nil);
e = tkcvsparseindex(i, buf, &last);
if(e != nil)
return e;
}
if(last <= first || t->tlen == 0)
return nil;
tkbbmax(&TKobj(TkCanvas, tk)->update, &i->p.bb);
memmove(t->text+first, t->text+last, t->tlen-last+1);
t->tlen -= last-first;
tkcvstextsize(i);
tkbbmax(&TKobj(TkCanvas, tk)->update, &i->p.bb);
tkcvssetdirty(tk);
return nil;
}
static char*
tkscrollidentify(Tk *tk, char *arg, char **val)
{
int gotarg;
TkTop *t;
char *v, buf[Tkmaxitem];
Point p;
TkScroll *tks = TKobj(TkScroll, tk);
t = tk->env->top;
arg = tkword(t, arg, buf, buf+sizeof(buf), &gotarg);
if (!gotarg)
return TkBadvl;
p.x = atoi(buf);
tkword(t, arg, buf, buf+sizeof(buf), &gotarg);
if (!gotarg)
return TkBadvl;
p.y = atoi(buf);
if (!ptinrect(p, tkrect(tk, 0)))
return nil;
if (tks->orient == Tkvertical)
p.x = p.y;
p.x += tk->borderwidth;
v = "";
if(p.x <= tks->a1)
v = "arrow1";
if(p.x > tks->a1 && p.x <= tks->t1)
v = "trough1";
if(p.x > tks->t1 && p.x < tks->t2)
v = "slider";
if(p.x >= tks->t2 && p.x < tks->a2)
v = "trough2";
if(p.x >= tks->a2)
v = "arrow2";
return tkvalue(val, "%s", v);
}
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;
}
/*
* extension to tcl/tk:
* grab set tag
* grab release tag
* grab ifunset tag
*/
static char*
tkcvsgrab(Tk *tk, char *arg, char **val)
{
TkCtag *t;
TkName *f;
TkCanvas *c;
char buf[Tkmaxitem];
c = TKobj(TkCanvas, tk);
arg = tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
if (strcmp(buf, "status") == 0) {
if (c->grab != nil)
return tkvalue(val, "%d", c->grab->id);
}
else if (strcmp(buf, "release") == 0) {
c->grab = nil;
}
else if (strcmp(buf, "set") == 0 || strcmp(buf, "ifunset") == 0) {
if (buf[0] == 'i' && c->grab != nil)
return nil;
tkword(tk->env->top, arg, buf, buf + sizeof(buf), nil);
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;
c->grab = t->item;
}
else
return TkBadvl;
return nil;
}
static char *
tkcvsscreeny(Tk *tk, char *arg, char **val)
{
int y;
TkCanvas *c;
Point p;
char buf[Tkmaxitem];
c = TKobj(TkCanvas, tk);
tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
if(buf[0] == '\0')
return TkBadvl;
p = tkposn(tk);
y = atoi(buf) - c->view.y + (p.y + tk->borderwidth);
return tkvalue(val, "%d", y);
}
static char*
tkentryindex(Tk *tk, char *arg, char **val)
{
int index;
char *r, *buf;
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
tkword(tk->env->top, arg, buf, buf+Tkmaxitem, nil);
r = tkentryparseindex(tk, buf, &index);
free(buf);
if(r != nil)
return r;
return tkvalue(val, "%d", index);
}
/* Used for both backspace and DEL. If a selection exists, delete it.
* Otherwise delete the character to the left(right) of the insertion
* cursor, if any.
*/
static char*
tkentrybs(Tk *tk, char *arg, char **val)
{
TkEntry *tke = TKobj(TkEntry, tk);
char *buf, *e;
int ix;
USED(val);
USED(arg);
if(tke->textlen == 0)
return nil;
if(tke->sel0 < tke->sel1)
return tkentrydelete(tk, "sel.first sel.last", nil);
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
tkword(tk->env->top, arg, buf, buf+Tkmaxitem, nil);
ix = -1;
if(buf[0] != '\0') {
e = tkentryparseindex(tk, buf, &ix);
if(e != nil) {
free(buf);
return e;
}
}
if(ix > -1) { /* DEL */
if(tke->icursor >= tke->textlen) {
free(buf);
return nil;
}
}
else { /* backspace */
if(tke->icursor == 0) {
free(buf);
return nil;
}
tke->icursor--;
}
snprint(buf, Tkmaxitem, "%d", tke->icursor);
e = tkentrydelete(tk, buf, nil);
free(buf);
return e;
}
static char*
tkentryb2p(Tk *tk, char *arg, char **val)
{
TkEntry *tke;
char *buf;
USED(val);
tke = TKobj(TkEntry, tk);
buf = malloc(Tkmaxitem);
if (buf == nil)
return TkNomem;
tkword(tk->env->top, arg, buf, buf+Tkmaxitem, nil);
tke->oldx = atoi(buf);
return nil;
}
char*
tkcvstextselect(Tk *tk, TkCitem *i, char *arg, int op)
{
int indx;
TkCtext *t;
TkCanvas *c;
char *e, buf[Tkmaxitem];
tkword(tk->env->top, arg, buf, buf+sizeof(buf), nil);
e = tkcvsparseindex(i, buf, &indx);
if(e != nil)
return e;
c = TKobj(TkCanvas, tk);
t = TKobj(TkCtext, i);
switch(op) {
case TkCselfrom:
t->selfrom = indx;
return nil;
case TkCseladjust:
if(c->selection == i) {
if(abs(t->self-indx) < abs(t->sell-indx)) {
t->self = indx;
t->selfrom = t->sell;
}
else {
t->sell = indx;
t->selfrom = t->self;
}
}
/* No break */
case TkCselto:
if(c->selection != i)
tkcvstextclr(tk);
c->selection = i;
t->self = t->selfrom;
t->sell = indx;
break;
}
t->sbw = c->sborderwidth;
tkbbmax(&TKobj(TkCanvas, tk)->update, &i->p.bb);
tkcvssetdirty(tk);
return nil;
}
static char*
tkentrybboxcmd(Tk *tk, char *arg, char **val)
{
TkEntry *tke = TKobj(TkEntry, tk);
char *r, *buf;
int index;
Rectangle bbox;
buf = mallocz(Tkmaxitem, 0);
if(buf == nil)
return TkNomem;
tkword(tk->env->top, arg, buf, buf+Tkmaxitem, nil);
r = tkentryparseindex(tk, buf, &index);
free(buf);
if(r != nil)
return r;
bbox = rectaddpt(tkentrybbox(tk, index), Pt(xinset(tk) - tke->x0, yinset(tk)));
return tkvalue(val, "%d %d %d %d", bbox.min.x, bbox.min.y, bbox.max.x, bbox.max.y);
}
static char*
tkcvsfocus(Tk *tk, char *arg, char **val)
{
TkName *f;
TkCtag *t;
TkCanvas *c;
TkCitem *i, *focus;
char buf[Tkmaxitem];
c = TKobj(TkCanvas, tk);
if(*arg == '\0') {
if(c->focus == nil)
return nil;
return tkvalue(val, "%d", c->focus->id);
}
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 nil;
focus = c->focus;
if(focus != nil && focus->type == TkCVtext)
tkcvstextfocus(tk, focus, 0);
for(i = c->head; i; i = i->next) {
if(i->type == TkCVtext || i->type == TkCVwindow) {
for(t = f->obj; t; t = t->taglist)
if(t->item == i)
focus = i;
}
}
if(focus != nil && focus->type == TkCVtext)
tkcvstextfocus(tk, focus, 1);
c->focus = focus;
return nil;
}
