void
colresize(Column *c, Rectangle r)
{
int i;
Rectangle r1, r2;
Window *w;
clearmouse();
textresize(&c->tag, r, TRUE);
draw(screen, c->tag.scrollr, tagcols[TEXT], nil, ZP);
c->r = r;
r1 = r;
for(i=0; i<c->nw; i++){
w = c->w[i];
w->maxlines = 0;
if(i == c->nw-1)
r1.max.y = r.max.y;
else
r1.max.y = r1.min.y+(Dy(w->r)+Border)*Dy(r)/Dy(c->r);
r1.max.y = max(r1.max.y, r1.min.y + Border+font->height);
r2 = r1;
r2.max.y = r2.min.y+Border;
draw(screen, r2, display->black, nil, ZP);
r1.min.y = r2.max.y;
r1.min.y = winresize(w, r1, FALSE, i==c->nw-1);
}
}
void
colresize(Column *c, Rectangle r)
{
int i;
Rectangle r1, r2;
Window *w;
clearmouse();
r1 = r;
r1.max.y = r1.min.y + c->tag.font->height;
textresize(&c->tag, r1);
draw(screen, c->tag.scrollr, colbutton, nil, colbutton->r.min);
r1.min.y = r1.max.y;
r1.max.y += Border;
draw(screen, r1, display->black, nil, ZP);
r1.max.y = r.max.y;
for(i=0; i<c->nw; i++){
w = c->w[i];
w->maxlines = 0;
if(i == c->nw-1)
r1.max.y = r.max.y;
else
r1.max.y = r1.min.y+(Dy(w->r)+Border)*Dy(r)/Dy(c->r);
r2 = r1;
r2.max.y = r2.min.y+Border;
draw(screen, r2, display->black, nil, ZP);
r1.min.y = r2.max.y;
r1.min.y = winresize(w, r1, FALSE);
}
c->r = r;
}
static int
rmb(void)
{
static Menu menu = {nil, menugen};
int n;
Win *w;
File *f;
if(actw != nil && actw->tab->rmb != nil && actw->tab->rmb(actw, mc) >= 0)
return 0;
n = menuhit(3, mc, &menu, nil);
if(n < 0)
return 0;
switch(n){
case ZEROX:
w = winsel(mc, 3);
if(w != nil)
winzerox(w, mc);
return 0;
case CLOSE:
w = winsel(mc, 3);
if(w != nil)
winclose(w);
return 0;
case RESIZE:
winresize(winsel(mc, 3), mc);
return 0;
case WRITE:
w = winsel(mc, 3);
if(w != nil)
winwrite(w, nil);
return 0;
case QUIT:
return quit();
}
if(n < WIN)
sysfatal("rmb: no action for n=%d", n);
if(n == 0){
setfocus(cmdw);
return 0;
}
n -= WIN;
for(f = flist.next; f != &flist; f = f->next)
if(--n == 0){
if(f->wins.wnext == &f->wins){
newwinsel(f->type, mc, f);
return 0;
}
for(w = f->wins.wnext; w != &f->wins && w != actw; w = w->wnext)
;
if(w->wnext == &f->wins)
w = w->wnext;
setfocus(w->wnext);
return 0;
}
return 0;
}
void
colclose(Column *c, Window *w, int dofree)
{
Rectangle r;
int i, didmouse, up;
/* w is locked */
if(!c->safe)
colgrow(c, w, 1);
for(i=0; i<c->nw; i++)
if(c->w[i] == w)
goto Found;
error("can't find window");
Found:
r = w->r;
w->tag.col = nil;
w->body.col = nil;
w->col = nil;
didmouse = restoremouse(w);
if(dofree){
windelete(w);
winclose(w);
}
c->nw--;
memmove(c->w+i, c->w+i+1, (c->nw-i)*sizeof(Window*));
c->w = realloc(c->w, c->nw*sizeof(Window*));
if(c->nw == 0){
draw(screen, r, display->white, nil, ZP);
return;
}
up = 0;
if(i == c->nw){ /* extend last window down */
w = c->w[i-1];
r.min.y = w->r.min.y;
r.max.y = c->r.max.y;
}else{ /* extend next window up */
up = 1;
w = c->w[i];
r.max.y = w->r.max.y;
}
draw(screen, r, textcols[BACK], nil, ZP);
if(c->safe) {
if(!didmouse && up)
w->showdel = TRUE;
winresize(w, r, FALSE, TRUE);
if(!didmouse && up)
movetodel(w);
}
}
void
colsort(Column *c)
{
int i, y;
Rectangle r, r1, *rp;
Window **wp, *w;
if(c->nw == 0)
return;
clearmouse();
rp = emalloc(c->nw*sizeof(Rectangle));
wp = emalloc(c->nw*sizeof(Window*));
memmove(wp, c->w, c->nw*sizeof(Window*));
qsort(wp, c->nw, sizeof(Window*), colcmp);
for(i=0; i<c->nw; i++)
rp[i] = wp[i]->r;
r = c->r;
r.min.y = c->tag.r.max.y;
draw(screen, r, textcols[BACK], nil, ZP);
y = r.min.y;
for(i=0; i<c->nw; i++){
w = wp[i];
r.min.y = y;
if(i == c->nw-1)
r.max.y = c->r.max.y;
else
r.max.y = r.min.y+Dy(w->r)+Border;
r1 = r;
r1.max.y = r1.min.y+Border;
draw(screen, r1, display->black, nil, ZP);
r.min.y = r1.max.y;
y = winresize(w, r, FALSE);
}
free(rp);
free(c->w);
c->w = wp;
}
void
readfile(Column *c, char *s)
{
Window *w;
Rune rb[256];
int nr;
Runestr rs;
w = coladd(c, nil, nil, -1);
if(s[0] != '/')
runesnprint(rb, sizeof rb, "%s/%s", wdir, s);
else
runesnprint(rb, sizeof rb, "%s", s);
nr = runestrlen(rb);
rs = cleanrname(runestr(rb, nr));
winsetname(w, rs.r, rs.nr);
textload(&w->body, 0, s, 1);
w->body.file->mod = FALSE;
w->dirty = FALSE;
winsettag(w);
winresize(w, w->r, FALSE, TRUE);
textscrdraw(&w->body);
textsetselect(&w->tag, w->tag.file->b.nc, w->tag.file->b.nc);
}
static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint)
{
char buf[256];
fz_device *idev;
fz_device *tdev;
fz_colorspace *colorspace;
fz_matrix ctm;
fz_bbox bbox;
wincursor(app, WAIT);
if (loadpage)
{
if (app->page_list)
fz_free_display_list(app->page_list);
if (app->page_text)
fz_free_text_span(app->page_text);
if (app->page_links)
pdf_free_link(app->page_links);
if (app->xref)
pdfapp_loadpage_pdf(app);
if (app->xps)
pdfapp_loadpage_xps(app);
/* Zero search hit position */
app->hit = -1;
app->hitlen = 0;
/* Extract text */
app->page_text = fz_new_text_span();
tdev = fz_new_text_device(app->page_text);
fz_execute_display_list(app->page_list, tdev, fz_identity, fz_infinite_bbox);
fz_free_device(tdev);
}
if (drawpage)
{
sprintf(buf, "%s - %d/%d (%d dpi)", app->doctitle,
app->pageno, app->pagecount, app->resolution);
wintitle(app, buf);
ctm = pdfapp_viewctm(app);
bbox = fz_round_rect(fz_transform_rect(ctm, app->page_bbox));
/* Draw */
if (app->image)
fz_drop_pixmap(app->image);
if (app->grayscale)
colorspace = fz_device_gray;
else
#ifdef _WIN32
colorspace = fz_device_bgr;
#else
colorspace = fz_device_rgb;
#endif
app->image = fz_new_pixmap_with_rect(colorspace, bbox);
fz_clear_pixmap_with_color(app->image, 255);
idev = fz_new_draw_device(app->cache, app->image);
fz_execute_display_list(app->page_list, idev, ctm, bbox);
fz_free_device(idev);
}
if (repaint)
{
pdfapp_panview(app, app->panx, app->pany);
if (app->shrinkwrap)
{
int w = app->image->w;
int h = app->image->h;
if (app->winw == w)
app->panx = 0;
if (app->winh == h)
app->pany = 0;
if (w > app->scrw * 90 / 100)
w = app->scrw * 90 / 100;
if (h > app->scrh * 90 / 100)
h = app->scrh * 90 / 100;
if (w != app->winw || h != app->winh)
winresize(app, w, h);
}
winrepaint(app);
wincursor(app, ARROW);
}
fz_flush_warnings();
}
Window*
coladd(Column *c, Window *w, Window *clone, int y)
{
Rectangle r, r1;
Window *v;
int i, t;
v = nil;
r = c->r;
r.min.y = c->tag.r.max.y+Border;
if(y<r.min.y && c->nw>0){ /* steal half of last window by default */
v = c->w[c->nw-1];
y = v->body.r.min.y+Dy(v->body.r)/2;
}
/* look for window we'll land on */
for(i=0; i<c->nw; i++){
v = c->w[i];
if(y < v->r.max.y)
break;
}
if(c->nw > 0){
if(i < c->nw)
i++; /* new window will go after v */
/*
* if v's too small, grow it first.
*/
if(!c->safe || v->body.maxlines<=3){
colgrow(c, v, 1);
y = v->body.r.min.y+Dy(v->body.r)/2;
}
r = v->r;
if(i == c->nw)
t = c->r.max.y;
else
t = c->w[i]->r.min.y-Border;
r.max.y = t;
draw(screen, r, textcols[BACK], nil, ZP);
r1 = r;
y = min(y, t-(v->tag.font->height+v->body.font->height+Border+1));
r1.max.y = min(y, v->body.r.min.y+v->body.nlines*v->body.font->height);
r1.min.y = winresize(v, r1, FALSE);
r1.max.y = r1.min.y+Border;
draw(screen, r1, display->black, nil, ZP);
r.min.y = r1.max.y;
}
if(w == nil){
w = emalloc(sizeof(Window));
w->col = c;
draw(screen, r, textcols[BACK], nil, ZP);
wininit(w, clone, r);
}else{
w->col = c;
winresize(w, r, FALSE);
}
w->tag.col = c;
w->tag.row = c->row;
w->body.col = c;
w->body.row = c->row;
c->w = realloc(c->w, (c->nw+1)*sizeof(Window*));
memmove(c->w+i+1, c->w+i, (c->nw-i)*sizeof(Window*));
c->nw++;
c->w[i] = w;
savemouse(w);
/* near but not on the button */
moveto(mousectl, addpt(w->tag.scrollr.max, Pt(3, 3)));
barttext = &w->body;
c->safe = TRUE;
return w;
}
void
coldragwin(Column *c, Window *w, int but)
{
Rectangle r;
int i, b;
Point p, op;
Window *v;
Column *nc;
clearmouse();
setcursor(mousectl, &boxcursor);
b = mouse->buttons;
op = mouse->xy;
while(mouse->buttons == b)
readmouse(mousectl);
setcursor(mousectl, nil);
if(mouse->buttons){
while(mouse->buttons)
readmouse(mousectl);
return;
}
for(i=0; i<c->nw; i++)
if(c->w[i] == w)
goto Found;
error("can't find window");
Found:
p = mouse->xy;
if(abs(p.x-op.x)<5 && abs(p.y-op.y)<5){
colgrow(c, w, but);
winmousebut(w);
return;
}
/* is it a flick to the right? */
if(abs(p.y-op.y)<10 && p.x>op.x+30 && rowwhichcol(c->row, p)==c)
p.x = op.x+Dx(w->r); /* yes: toss to next column */
nc = rowwhichcol(c->row, p);
if(nc!=nil && nc!=c){
colclose(c, w, FALSE);
coladd(nc, w, nil, p.y);
winmousebut(w);
return;
}
if(i==0 && c->nw==1)
return; /* can't do it */
if((i>0 && p.y<c->w[i-1]->r.min.y) || (i<c->nw-1 && p.y>w->r.max.y)
|| (i==0 && p.y>w->r.max.y)){
/* shuffle */
colclose(c, w, FALSE);
coladd(c, w, nil, p.y);
winmousebut(w);
return;
}
if(i == 0)
return;
v = c->w[i-1];
if(p.y < v->tag.all.max.y)
p.y = v->tag.all.max.y;
if(p.y > w->r.max.y-Dy(w->tag.all)-Border)
p.y = w->r.max.y-Dy(w->tag.all)-Border;
r = v->r;
r.max.y = p.y;
if(r.max.y > v->body.r.min.y){
r.max.y -= (r.max.y-v->body.r.min.y)%v->body.font->height;
if(v->body.r.min.y == v->body.r.max.y)
r.max.y++;
}
if(!eqrect(v->r, r)){
draw(screen, r, textcols[BACK], nil, ZP);
winresize(v, r, c->safe);
}
r.min.y = v->r.max.y;
r.max.y = r.min.y+Border;
draw(screen, r, display->black, nil, ZP);
r.min.y = r.max.y;
if(i == c->nw-1)
r.max.y = c->r.max.y;
else
r.max.y = c->w[i+1]->r.min.y-Border;
if(!eqrect(w->r, r)){
draw(screen, r, textcols[BACK], nil, ZP);
winresize(w, r, c->safe);
}
c->safe = TRUE;
winmousebut(w);
}
void
colgrow(Column *c, Window *w, int but)
{
Rectangle r, cr;
int i, j, k, l, y1, y2, *nl, *ny, tot, nnl, onl, dnl, h;
Window *v;
for(i=0; i<c->nw; i++)
if(c->w[i] == w)
goto Found;
error("can't find window");
Found:
cr = c->r;
if(but < 0){ /* make sure window fills its own space properly */
r = w->r;
if(i==c->nw-1 || c->safe==FALSE)
r.max.y = cr.max.y;
else
r.max.y = c->w[i+1]->r.min.y;
winresize(w, r, FALSE);
return;
}
cr.min.y = c->w[0]->r.min.y;
if(but == 3){ /* full size */
if(i != 0){
v = c->w[0];
c->w[0] = w;
c->w[i] = v;
}
draw(screen, cr, textcols[BACK], nil, ZP);
winresize(w, cr, FALSE);
for(i=1; i<c->nw; i++)
c->w[i]->body.maxlines = 0;
c->safe = FALSE;
return;
}
/* store old #lines for each window */
onl = w->body.maxlines;
nl = emalloc(c->nw * sizeof(int));
ny = emalloc(c->nw * sizeof(int));
tot = 0;
for(j=0; j<c->nw; j++){
l = c->w[j]->body.maxlines;
nl[j] = l;
tot += l;
}
/* approximate new #lines for this window */
if(but == 2){ /* as big as can be */
memset(nl, 0, c->nw * sizeof(int));
goto Pack;
}
nnl = min(onl + max(min(5, w->maxlines), onl/2), tot);
if(nnl < w->maxlines)
nnl = (w->maxlines+nnl)/2;
if(nnl == 0)
nnl = 2;
dnl = nnl - onl;
/* compute new #lines for each window */
for(k=1; k<c->nw; k++){
/* prune from later window */
j = i+k;
if(j<c->nw && nl[j]){
l = min(dnl, max(1, nl[j]/2));
nl[j] -= l;
nl[i] += l;
dnl -= l;
}
/* prune from earlier window */
j = i-k;
if(j>=0 && nl[j]){
l = min(dnl, max(1, nl[j]/2));
nl[j] -= l;
nl[i] += l;
dnl -= l;
}
}
Pack:
/* pack everyone above */
y1 = cr.min.y;
for(j=0; j<i; j++){
v = c->w[j];
r = v->r;
r.min.y = y1;
r.max.y = y1+Dy(v->tag.all);
if(nl[j])
r.max.y += 1 + nl[j]*v->body.font->height;
if(!c->safe || !eqrect(v->r, r)){
draw(screen, r, textcols[BACK], nil, ZP);
winresize(v, r, c->safe);
}
r.min.y = v->r.max.y;
r.max.y += Border;
draw(screen, r, display->black, nil, ZP);
y1 = r.max.y;
}
/* scan to see new size of everyone below */
y2 = c->r.max.y;
for(j=c->nw-1; j>i; j--){
v = c->w[j];
r = v->r;
r.min.y = y2-Dy(v->tag.all);
if(nl[j])
r.min.y -= 1 + nl[j]*v->body.font->height;
r.min.y -= Border;
ny[j] = r.min.y;
y2 = r.min.y;
}
/* compute new size of window */
r = w->r;
r.min.y = y1;
r.max.y = r.min.y+Dy(w->tag.all);
h = w->body.font->height;
if(y2-r.max.y >= 1+h+Border){
r.max.y += 1;
r.max.y += h*((y2-r.max.y)/h);
}
/* draw window */
if(!c->safe || !eqrect(w->r, r)){
draw(screen, r, textcols[BACK], nil, ZP);
winresize(w, r, c->safe);
}
if(i < c->nw-1){
r.min.y = r.max.y;
r.max.y += Border;
draw(screen, r, display->black, nil, ZP);
for(j=i+1; j<c->nw; j++)
ny[j] -= (y2-r.max.y);
}
/* pack everyone below */
y1 = r.max.y;
for(j=i+1; j<c->nw; j++){
v = c->w[j];
r = v->r;
r.min.y = y1;
r.max.y = y1+Dy(v->tag.all);
if(nl[j])
r.max.y += 1 + nl[j]*v->body.font->height;
if(!c->safe || !eqrect(v->r, r)){
draw(screen, r, textcols[BACK], nil, ZP);
winresize(v, r, c->safe);
}
if(j < c->nw-1){ /* no border on last window */
r.min.y = v->r.max.y;
r.max.y += Border;
draw(screen, r, display->black, nil, ZP);
}
y1 = r.max.y;
}
r = w->r;
r.min.y = y1;
r.max.y = c->r.max.y;
draw(screen, r, textcols[BACK], nil, ZP);
free(nl);
free(ny);
c->safe = TRUE;
winmousebut(w);
}
Window*
coladd(Column *c, Window *w, Window *clone, int y)
{
Rectangle r, r1;
Window *v;
int i, j, minht, ymax, buggered;
v = nil;
r = c->r;
r.min.y = c->tag.fr.r.max.y+Border;
if(y<r.min.y && c->nw>0){ /* steal half of last window by default */
v = c->w[c->nw-1];
y = v->body.fr.r.min.y+Dy(v->body.fr.r)/2;
}
/* look for window we'll land on */
for(i=0; i<c->nw; i++){
v = c->w[i];
if(y < v->r.max.y)
break;
}
buggered = 0;
if(c->nw > 0){
if(i < c->nw)
i++; /* new window will go after v */
/*
* if landing window (v) is too small, grow it first.
*/
minht = v->tag.fr.font->height+Border+1;
j = 0;
while(!c->safe || v->body.fr.maxlines<=3 || Dy(v->body.all) <= minht){
if(++j > 10){
buggered = 1; /* too many windows in column */
break;
}
colgrow(c, v, 1);
}
/*
* figure out where to split v to make room for w
*/
/* new window stops where next window begins */
if(i < c->nw)
ymax = c->w[i]->r.min.y-Border;
else
ymax = c->r.max.y;
/* new window must start after v's tag ends */
y = max(y, v->tagtop.max.y+Border);
/* new window must start early enough to end before ymax */
y = min(y, ymax - minht);
/* if y is too small, too many windows in column */
if(y < v->tagtop.max.y+Border)
buggered = 1;
/*
* resize & redraw v
*/
r = v->r;
r.max.y = ymax;
draw(screen, r, textcols[BACK], nil, ZP);
r1 = r;
y = min(y, ymax-(v->tag.fr.font->height*v->taglines+v->body.fr.font->height+Border+1));
r1.max.y = min(y, v->body.fr.r.min.y+v->body.fr.nlines*v->body.fr.font->height);
r1.min.y = winresize(v, r1, FALSE, FALSE);
r1.max.y = r1.min.y+Border;
draw(screen, r1, display->black, nil, ZP);
/*
* leave r with w's coordinates
*/
r.min.y = r1.max.y;
}
if(w == nil){
w = emalloc(sizeof(Window));
w->col = c;
draw(screen, r, textcols[BACK], nil, ZP);
wininit(w, clone, r);
}else{
w->col = c;
winresize(w, r, FALSE, TRUE);
}
w->tag.col = c;
w->tag.row = c->row;
w->body.col = c;
w->body.row = c->row;
c->w = realloc(c->w, (c->nw+1)*sizeof(Window*));
memmove(c->w+i+1, c->w+i, (c->nw-i)*sizeof(Window*));
c->nw++;
c->w[i] = w;
c->safe = TRUE;
/* if there were too many windows, redraw the whole column */
if(buggered)
colresize(c, c->r);
savemouse(w);
/* near the button, but in the body */
moveto(mousectl, addpt(w->tag.scrollr.max, Pt(3, 3)));
barttext = &w->body;
return w;
}
void
texttype(Text *t, Rune r)
{
uint q0, q1;
int nnb, nb, n, i;
int nr;
Rune *rp;
Text *u;
if(t->what!=Body && t->what!=Tag && r=='\n')
return;
if(t->what == Tag)
t->w->tagsafe = FALSE;
nr = 1;
rp = &r;
switch(r){
case Kleft:
typecommit(t);
if(t->q0 > 0)
textshow(t, t->q0-1, t->q0-1, TRUE);
return;
case Kright:
typecommit(t);
if(t->q1 < t->file->b.nc)
textshow(t, t->q1+1, t->q1+1, TRUE);
return;
case Kdown:
if(t->what == Tag)
goto Tagdown;
n = t->fr.maxlines/3;
goto case_Down;
case Kscrollonedown:
if(t->what == Tag)
goto Tagdown;
n = mousescrollsize(t->fr.maxlines);
if(n <= 0)
n = 1;
goto case_Down;
case Kpgdown:
n = 2*t->fr.maxlines/3;
case_Down:
q0 = t->org+frcharofpt(&t->fr, Pt(t->fr.r.min.x, t->fr.r.min.y+n*t->fr.font->height));
textsetorigin(t, q0, TRUE);
return;
case Kup:
if(t->what == Tag)
goto Tagup;
n = t->fr.maxlines/3;
goto case_Up;
case Kscrolloneup:
if(t->what == Tag)
goto Tagup;
n = mousescrollsize(t->fr.maxlines);
goto case_Up;
case Kpgup:
n = 2*t->fr.maxlines/3;
case_Up:
q0 = textbacknl(t, t->org, n);
textsetorigin(t, q0, TRUE);
return;
case Khome:
typecommit(t);
if(t->org > t->iq1) {
q0 = textbacknl(t, t->iq1, 1);
textsetorigin(t, q0, TRUE);
} else
textshow(t, 0, 0, FALSE);
return;
case Kend:
typecommit(t);
if(t->iq1 > t->org+t->fr.nchars) {
if(t->iq1 > t->file->b.nc) {
// should not happen, but does. and it will crash textbacknl.
t->iq1 = t->file->b.nc;
}
q0 = textbacknl(t, t->iq1, 1);
textsetorigin(t, q0, TRUE);
} else
textshow(t, t->file->b.nc, t->file->b.nc, FALSE);
return;
case 0x01: /* ^A: beginning of line */
typecommit(t);
/* go to where ^U would erase, if not already at BOL */
nnb = 0;
if(t->q0>0 && textreadc(t, t->q0-1)!='\n')
nnb = textbswidth(t, 0x15);
textshow(t, t->q0-nnb, t->q0-nnb, TRUE);
return;
case 0x05: /* ^E: end of line */
typecommit(t);
q0 = t->q0;
while(q0<t->file->b.nc && textreadc(t, q0)!='\n')
q0++;
textshow(t, q0, q0, TRUE);
return;
case Kcmd+'c': /* %C: copy */
typecommit(t);
cut(t, t, nil, TRUE, FALSE, nil, 0);
return;
case Kcmd+'z': /* %Z: undo */
typecommit(t);
undo(t, nil, nil, TRUE, 0, nil, 0);
return;
Tagdown:
/* expand tag to show all text */
if(!t->w->tagexpand){
t->w->tagexpand = TRUE;
winresize(t->w, t->w->r, FALSE, TRUE);
}
return;
Tagup:
/* shrink tag to single line */
if(t->w->tagexpand){
t->w->tagexpand = FALSE;
t->w->taglines = 1;
winresize(t->w, t->w->r, FALSE, TRUE);
}
return;
}
if(t->what == Body){
seq++;
filemark(t->file);
}
/* cut/paste must be done after the seq++/filemark */
switch(r){
case Kcmd+'x': /* %X: cut */
typecommit(t);
if(t->what == Body){
seq++;
filemark(t->file);
}
cut(t, t, nil, TRUE, TRUE, nil, 0);
textshow(t, t->q0, t->q0, 1);
t->iq1 = t->q0;
return;
case Kcmd+'v': /* %V: paste */
typecommit(t);
if(t->what == Body){
seq++;
filemark(t->file);
}
paste(t, t, nil, TRUE, FALSE, nil, 0);
textshow(t, t->q0, t->q1, 1);
t->iq1 = t->q1;
return;
}
if(t->q1 > t->q0){
if(t->ncache != 0)
error("text.type");
cut(t, t, nil, TRUE, TRUE, nil, 0);
t->eq0 = ~0;
}
textshow(t, t->q0, t->q0, 1);
switch(r){
case 0x06: /* ^F: complete */
case Kins:
typecommit(t);
rp = textcomplete(t);
if(rp == nil)
return;
nr = runestrlen(rp);
break; /* fall through to normal insertion case */
case 0x1B:
if(t->eq0 != ~0) {
if(t->eq0 <= t->q0)
textsetselect(t, t->eq0, t->q0);
else
textsetselect(t, t->q0, t->eq0);
}
if(t->ncache > 0)
typecommit(t);
t->iq1 = t->q0;
return;
case 0x08: /* ^H: erase character */
case 0x15: /* ^U: erase line */
case 0x17: /* ^W: erase word */
if(t->q0 == 0) /* nothing to erase */
return;
nnb = textbswidth(t, r);
q1 = t->q0;
q0 = q1-nnb;
/* if selection is at beginning of window, avoid deleting invisible text */
if(q0 < t->org){
q0 = t->org;
nnb = q1-q0;
}
if(nnb <= 0)
return;
for(i=0; i<t->file->ntext; i++){
u = t->file->text[i];
u->nofill = TRUE;
nb = nnb;
n = u->ncache;
if(n > 0){
if(q1 != u->cq0+n)
error("text.type backspace");
if(n > nb)
n = nb;
u->ncache -= n;
textdelete(u, q1-n, q1, FALSE);
nb -= n;
}
if(u->eq0==q1 || u->eq0==~0)
u->eq0 = q0;
if(nb && u==t)
textdelete(u, q0, q0+nb, TRUE);
if(u != t)
textsetselect(u, u->q0, u->q1);
else
textsetselect(t, q0, q0);
u->nofill = FALSE;
}
for(i=0; i<t->file->ntext; i++)
textfill(t->file->text[i]);
t->iq1 = t->q0;
return;
case '\n':
if(t->w->autoindent){
/* find beginning of previous line using backspace code */
nnb = textbswidth(t, 0x15); /* ^U case */
rp = runemalloc(nnb + 1);
nr = 0;
rp[nr++] = r;
for(i=0; i<nnb; i++){
r = textreadc(t, t->q0-nnb+i);
if(r != ' ' && r != '\t')
break;
rp[nr++] = r;
}
}
break; /* fall through to normal code */
}
/* otherwise ordinary character; just insert, typically in caches of all texts */
for(i=0; i<t->file->ntext; i++){
u = t->file->text[i];
if(u->eq0 == ~0)
u->eq0 = t->q0;
if(u->ncache == 0)
u->cq0 = t->q0;
else if(t->q0 != u->cq0+u->ncache)
error("text.type cq1");
/*
* Change the tag before we add to ncache,
* so that if the window body is resized the
* commit will not find anything in ncache.
*/
if(u->what==Body && u->ncache == 0){
u->needundo = TRUE;
winsettag(t->w);
u->needundo = FALSE;
}
textinsert(u, t->q0, rp, nr, FALSE);
if(u != t)
textsetselect(u, u->q0, u->q1);
if(u->ncache+nr > u->ncachealloc){
u->ncachealloc += 10 + nr;
u->cache = runerealloc(u->cache, u->ncachealloc);
}
runemove(u->cache+u->ncache, rp, nr);
u->ncache += nr;
}
if(rp != &r)
free(rp);
textsetselect(t, t->q0+nr, t->q0+nr);
if(r=='\n' && t->w!=nil)
wincommit(t->w, t);
t->iq1 = t->q0;
}
void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage)
{
char buf[256];
fz_error *error;
fz_matrix ctm;
fz_rect bbox;
fz_obj *obj;
if (loadpage)
{
wincursor(app, WAIT);
if (app->page)
pdf_droppage(app->page);
app->page = nil;
obj = pdf_getpageobject(app->pages, app->pageno - 1);
error = pdf_loadpage(&app->page, app->xref, obj);
if (error)
pdfapp_error(app, error);
sprintf(buf, "%s - %d/%d", app->doctitle,
app->pageno, pdf_getpagecount(app->pages));
wintitle(app, buf);
}
if (drawpage)
{
wincursor(app, WAIT);
if (app->image)
fz_droppixmap(app->image);
app->image = nil;
ctm = pdfapp_viewctm(app);
bbox = fz_transformaabb(ctm, app->page->mediabox);
error = fz_rendertree(&app->image, app->rast, app->page->tree,
ctm, fz_roundrect(bbox), 1);
if (error)
pdfapp_error(app, error);
winconvert(app, app->image);
}
pdfapp_panview(app, app->panx, app->pany);
if (app->shrinkwrap)
{
int w = app->image->w;
int h = app->image->h;
if (app->winw == w)
app->panx = 0;
if (app->winh == h)
app->pany = 0;
if (w > app->scrw * 90 / 100)
w = app->scrw * 90 / 100;
if (h > app->scrh * 90 / 100)
h = app->scrh * 90 / 100;
if (w != app->winw || h != app->winh)
winresize(app, w, h);
}
winrepaint(app);
wincursor(app, ARROW);
}
static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage)
{
char buf[256];
fz_error error;
fz_device *idev, *tdev, *mdev;
fz_displaylist *list;
fz_matrix ctm;
fz_bbox bbox;
fz_obj *obj;
if (loadpage)
{
wincursor(app, WAIT);
if (app->page)
pdf_droppage(app->page);
app->page = nil;
//code change by kakai
kno_clearselect(app);
//code change by kakai
pdf_flushxref(app->xref, 0);
obj = pdf_getpageobject(app->xref, app->pageno);
error = pdf_loadpage(&app->page, app->xref, obj);
if (error)
pdfapp_error(app, error);
sprintf(buf, "%s - %d/%d", app->doctitle,
app->pageno, app->pagecount);
wintitle(app, buf);
}
if (drawpage)
{
wincursor(app, WAIT);
ctm = pdfapp_viewctm(app);
bbox = fz_roundrect(fz_transformrect(ctm, app->page->mediabox));
list = fz_newdisplaylist();
mdev = fz_newlistdevice(list);
error = pdf_runcontentstream(mdev, fz_identity(), app->xref, app->page->resources, app->page->contents);
if (error)
pdfapp_error(app, error);
fz_freedevice(mdev);
if (app->image)
fz_droppixmap(app->image);
app->image = fz_newpixmapwithrect(pdf_devicergb, bbox);
fz_clearpixmap(app->image, 0xFF);
idev = fz_newdrawdevice(app->cache, app->image);
fz_executedisplaylist(list, idev, ctm);
fz_freedevice(idev);
if (app->text)
fz_freetextspan(app->text);
app->text = fz_newtextspan();
tdev = fz_newtextdevice(app->text);
fz_executedisplaylist(list, tdev, ctm);
fz_freedevice(tdev);
fz_freedisplaylist(list);
//code change by kakai
kno_allocselection(app);
kno_applyselect(app);
//code change by kakai
winconvert(app, app->image);
}
pdfapp_panview(app, app->panx, app->pany);
if (app->shrinkwrap)
{
int w = app->image->w;
int h = app->image->h;
if (app->winw == w)
app->panx = 0;
if (app->winh == h)
app->pany = 0;
if (w > app->scrw * 90 / 100)
w = app->scrw * 90 / 100;
if (h > app->scrh * 90 / 100)
h = app->scrh * 90 / 100;
if (w != app->winw || h != app->winh)
winresize(app, w, h);
}
winrepaint(app);
wincursor(app, ARROW);
}
