void
redraw(Image *screen)
{
Rectangle r;
if(im == nil)
return;
ulrange.max = screen->r.max;
ulrange.min = subpt(screen->r.min, Pt(Dx(im->r), Dy(im->r)));
ul = pclip(ul, ulrange);
drawop(screen, screen->r, im, nil, subpt(im->r.min, subpt(ul, screen->r.min)), S);
if(im->repl)
return;
/* fill in any outer edges */
/* black border */
r = rectaddpt(im->r, subpt(ul, im->r.min));
border(screen, r, -2, display->black, ZP);
r.min = subpt(r.min, Pt(2,2));
r.max = addpt(r.max, Pt(2,2));
/* gray for the rest */
if(gray == nil) {
gray = xallocimage(display, Rect(0,0,1,1), RGB24, 1, 0x888888FF);
if(gray == nil) {
fprint(2, "g out of memory: %r\n");
wexits("mem");
}
}
border(screen, r, -4000, gray, ZP);
// flushimage(display, 0);
}
/*
* Translate the image in the window by delta.
*/
static void
translate(Point delta)
{
Point u;
Rectangle r, or;
if(im == nil)
return;
u = pclip(addpt(ul, delta), ulrange);
delta = subpt(u, ul);
if(delta.x == 0 && delta.y == 0)
return;
/*
* The upper left corner of the image is currently at ul.
* We want to move it to u.
*/
or = rectaddpt(Rpt(ZP, Pt(Dx(im->r), Dy(im->r))), ul);
r = rectaddpt(or, delta);
drawop(screen, r, screen, nil, ul, S);
ul = u;
/* fill in gray where image used to be but isn't. */
drawdiff(screen, insetrect(or, -2), insetrect(r, -2), gray, nil, ZP, S);
/* fill in black border */
drawdiff(screen, insetrect(r, -2), r, display->black, nil, ZP, S);
/* fill in image where it used to be off the screen. */
if(rectclip(&or, screen->r))
drawdiff(screen, r, rectaddpt(or, delta), im, nil, im->r.min, S);
else
drawop(screen, r, im, nil, im->r.min, S);
flushimage(display, 1);
}
Image*
tkitmp(TkEnv *e, Point p, int fillcol)
{
Image *i, **ip;
TkTop *t;
TkCtxt *ti;
Display *d;
Rectangle r;
ulong pix;
int alpha;
t = e->top;
ti = t->ctxt;
d = t->display;
pix = e->colors[fillcol];
alpha = (pix & 0xff) != 0xff;
ip = alpha ? &ti->ia : &ti->i;
if(*ip != nil) {
i = *ip;
if(p.x <= i->r.max.x && p.y <= i->r.max.y) {
r.min = ZP;
r.max = p;
if (alpha)
drawop(i, r, nil, nil, ZP, Clear);
draw(i, r, tkgc(e, fillcol), nil, ZP);
return i;
}
r = i->r;
freeimage(i);
if(p.x < r.max.x)
p.x = r.max.x;
if(p.y < r.max.y)
p.y = r.max.y;
}
r.min = ZP;
r.max = p;
*ip = allocimage(d, r, alpha?RGBA32:d->image->chan, 0, pix);
return *ip;
}
static Image*
_cachedpage(Document *doc, int angle, int page, char *ra)
{
int i;
Cached *c, old;
Image *im, *tmp;
if((page < 0 || page >= doc->npage) && !doc->fwdonly)
return nil;
Again:
for(i=0; i<nelem(cache); i++){
c = &cache[i];
if(c->doc == doc && c->angle == angle && c->page == page){
if(chatty) fprint(2, "cache%s hit %d\n", ra, page);
goto Found;
}
if(c->doc == nil)
break;
}
if(i >= nelem(cache))
i = nelem(cache)-1;
c = &cache[i];
if(c->im)
freeimage(c->im);
c->im = nil;
c->doc = nil;
c->page = -1;
if(chatty) fprint(2, "cache%s load %d\n", ra, page);
im = doc->drawpage(doc, page);
if(im == nil){
if(doc->fwdonly) /* end of file */
wexits(0);
im = questionmark();
if(im == nil){
Flush:
if(i > 0){
cacheflush();
goto Again;
}
fprint(2, "out of memory: %r\n");
wexits("memory");
}
return im;
}
if(im->r.min.x != 0 || im->r.min.y != 0){
/* translate to 0,0 */
tmp = xallocimage(display, Rect(0, 0, Dx(im->r), Dy(im->r)), im->chan, 0, DNofill);
if(tmp == nil){
freeimage(im);
goto Flush;
}
drawop(tmp, tmp->r, im, nil, im->r.min, S);
freeimage(im);
im = tmp;
}
switch(angle){
case 90:
im = rot90(im);
break;
case 180:
rot180(im);
break;
case 270:
im = rot270(im);
break;
}
if(im == nil)
goto Flush;
c->doc = doc;
c->page = page;
c->angle = angle;
c->im = im;
Found:
if(chatty) fprint(2, "cache%s mtf %d @%d:", ra, c->page, i);
old = *c;
memmove(cache+1, cache, (c-cache)*sizeof cache[0]);
cache[0] = old;
if(chatty){
for(i=0; i<nelem(cache); i++)
fprint(2, " %d", cache[i].page);
fprint(2, "\n");
}
if(chatty) fprint(2, "cache%s return %d %p\n", ra, old.page, old.im);
return old.im;
}
char*
tkdrawcanv(Tk *tk, Point orig)
{
Image *dst;
TkCitem *i;
Display *d;
TkCanvas *c;
Rectangle r, bufr, oclipr;
int vis, alpha, buffer;
Point rel, p;
TkCimeth *imeth;
c = TKobj(TkCanvas, tk);
d = tk->env->top->display;
dst = tkimageof(tk);
/*
* translation from local to screen coords
*/
rel.x = orig.x + tk->act.x + tk->borderwidth;
rel.y = orig.y + tk->act.y + tk->borderwidth;
buffer = c->buffer;
if (buffer == TkCbufauto)
buffer = TkCbufvisible;
/* buffer = (dst == TKobj(TkWin, tk->env->top->root)->image) ? TkCbufvisible : TkCbufnone; */
if (buffer == TkCbufnone) {
if(c->image != nil && c->ialloc)
freeimage(c->image);
c->image = dst;
c->ialloc = 0;
r = tkrect(tk, 0);
bufr = r;
rectclip(&bufr, tk->dirty);
oclipr = dst->clipr;
replclipr(dst, 0, rectaddpt(bufr, rel));
draw(dst, rectaddpt(bufr, rel), tkgc(tk->env, TkCbackgnd), nil, ZP);
p = subpt(rel, c->view);
p.x = TKI2F(p.x);
p.y = TKI2F(p.y);
bufr = rectaddpt(bufr, c->view);
for(i = c->head; i; i = i->next) {
if(rectXrect(i->p.bb, bufr)) {
imeth = &tkcimethod[i->type];
imeth->coord(i, nil, p.x, p.y);
imeth->draw(dst, i, tk->env);
imeth->coord(i, nil, -p.x, -p.y);
}
}
replclipr(dst, 0, oclipr);
} else {
if (c->buffer == TkCbufall)
bufr = c->region;
else {
bufr.min = c->view;
bufr.max.x = c->view.x + tk->act.width;
bufr.max.y = c->view.y + tk->act.height;
}
alpha = (tk->env->colors[TkCbackgnd] & 0xff) != 0xff;
if(c->image == nil || eqrect(bufr, c->image->r) == 0) {
if(c->image != nil && c->ialloc)
freeimage(c->image);
c->image = allocimage(d, bufr, alpha?RGBA32:d->image->chan, 0, tk->env->colors[TkCbackgnd]);
c->ialloc = 1;
c->update = bufr;
tkcvssetdirty(tk); /* unnecessary? */
}
if(c->image == nil)
return nil;
r = c->update;
if (rectclip(&r, c->image->r)) {
if (alpha)
drawop(c->image, c->update, nil, nil, ZP, Clear);
draw(c->image, c->update, tkgc(tk->env, TkCbackgnd), nil, c->view);
replclipr(c->image, 0, r);
for(i = c->head; i; i = i->next) {
if(rectXrect(i->p.bb, r))
tkcimethod[i->type].draw(c->image, i, tk->env);
}
replclipr(c->image, 0, c->image->r);
}
/*
* if the visible area of the canvas image doesn't
* fit completely within the dirty rectangle,
* then we'll need to draw the background behind it
*/
r = tkrect(tk, 0);
bufr = rectsubpt(bufr, c->view);
vis = rectclip(&bufr, tkrect(tk, 0));
if (!vis || !rectinrect(tk->dirty, bufr))
draw(dst, rectaddpt(tk->dirty, rel), tkgc(tk->env, TkCbackgnd), nil, c->view);
if (vis && rectclip(&bufr, tk->dirty))
draw(dst, rectaddpt(bufr, rel), c->image, nil, addpt(bufr.min, c->view));
}
/*
* if the border is dirty too, then draw that
*/
if (!rectinrect(tk->dirty, bufr)) {
r.min = addpt(r.min, rel);
r.min.x -= tk->borderwidth;
r.min.y -= tk->borderwidth;
tkdrawrelief(dst, tk, r.min, TkCbackgnd, tk->relief);
}
c->update = bbnil;
return nil;
}
