ref: 600bbfe4aaa9ad0f73d8d73eef1b7670e5f7d3a3
dir: /appl/charon/paginate.b/
implement Paginate;
include "common.m";
include "print.m";
include "paginate.m";
sys: Sys;
print: Print;
L: Layout;
D: Draw;
Frame, Lay, Line, Control: import Layout;
Docinfo: import Build;
Image, Display, Rect, Point: import D;
Item: import Build;
MaskedImage: import CharonUtils;
disp: ref Display;
p0: Point;
nulimg: ref Image;
DPI: con 110;
init(layout: Layout, draw: Draw, display: ref Draw->Display): string
{
sys = load Sys Sys->PATH;
L = layout;
D = draw;
disp = display;
if (L == nil || D == nil || disp == nil)
return "bad args";
print = load Print Print->PATH;
if (print == nil)
return sys->sprint("cannot load module %s: %r", Print->PATH);
print->init();
#nullfd := sys->open("/dev/null", Sys->OWRITE);
#print->set_printfd(nullfd);
p0 = Point(0, 0);
nulimg = disp.newimage(((0, 0), (1, 1)), 3, 0, 0);
return nil;
}
paginate(frame: ref Layout->Frame, orient: int, pnums, cancel: chan of int, result: chan of (string, ref Pageset))
{
pidc := chan of int;
spawn watchdog(pidc, cancel, nil, sys->pctl(0, nil));
watchpid := <- pidc;
if (frame.kids != nil) {
result <-= ("cannot print frameset", nil);
kill(watchpid);
return;
}
defp := print->get_defprinter();
if (defp == nil) {
result <-= ("no default printer", nil);
kill(watchpid);
return;
}
# assuming printer's X & Y resolution are the same
if (orient == PORTRAIT)
defp.popt.orientation = Print->PORTRAIT;
else
defp.popt.orientation = Print->LANDSCAPE;
(dpi, pagew, pageh) := print->get_size(defp);
pagew = (DPI * pagew)/dpi;
pageh = (DPI * pageh)/dpi;
pfr := copyframe(frame);
pr := Rect(p0, (pagew, pageh));
pfr.r = pr;
pfr.cr = pr;
pfr.viewr = pr;
l := pfr.layout;
L->relayout(pfr, l, pagew, l.just);
maxy := l.height + l.margin; # don't include bottom margin
prctxt := ref Layout->Printcontext;
pfr.prctxt = prctxt;
pfr.cim = nulimg;
pnum := 1;
startys : list of int;
for (y := 0; y < maxy;) {
startys = y :: startys;
pnums <-= pnum++;
endy := y + pageh;
prctxt.endy = pageh;
pfr.viewr.min.y = y;
pfr.viewr.max.y = endy;
L->drawall(pfr);
y += prctxt.endy;
}
# startys are in reverse order
ys : list of int;
for (; startys != nil; startys = tl startys)
ys = hd startys :: ys;
pageset := ref Pageset(defp, pfr, ys);
result <-= (nil, pageset);
kill(watchpid);
}
printpageset(pset: ref Pageset, pnums, cancel: chan of int)
{
pidc := chan of int;
stopdog := chan of int;
spawn watchdog(pidc, cancel, stopdog, sys->pctl(0, nil));
watchpid := <- pidc;
frame := pset.frame;
pageh := frame.cr.dy();
white := disp.rgb2cmap(255, 255, 255);
prctxt := frame.prctxt;
l := frame.layout;
maxy := l.height + l.margin; # don't include bottom margin
maxy = max(maxy, pageh);
pnum := 1;
for (pages := pset.pages; pages != nil; pages = tl pages) {
y := hd pages;
if (y + pageh > maxy)
pageh = maxy - y;
frame.cr.max.y = pageh;
frame.cim = disp.newimage(frame.cr, 3, 0, white);
if (frame.cim == nil) {
pnums <-= -1;
kill(watchpid);
return;
}
pnums <-= pnum++;
endy := y + pageh;
prctxt.endy = pageh;
frame.viewr.min.y = y;
frame.viewr.max.y = endy;
L->drawall(frame);
stopdog <-= 1;
#start := sys->millisec();
if (print->print_image(pset.printer, disp, frame.cim, 100, cancel) == -1) {
# cancelled
kill(watchpid);
return;
}
stopdog <-= 1;
#sys->print("PAGE %d: %dms\n", pnum -1, sys->millisec()-start);
}
pnums <-= -1;
kill(watchpid);
}
watchdog(pidc, cancel, pause: chan of int, pid: int)
{
pidc <-= sys->pctl(0, nil);
if (pause == nil)
pause = chan of int;
for (;;) alt {
<- cancel =>
kill(pid);
return;
<- pause =>
<- pause;
}
}
kill(pid: int)
{
sys->fprint(sys->open("/prog/" + string pid +"/ctl", Sys->OWRITE), "kill");
}
killgrp(pid: int)
{
sys->fprint(sys->open("/prog/" + string pid +"/ctl", Sys->OWRITE), "killgrp");
}
max(a, b: int): int
{
if (a > b)
return a;
return b;
}
copyframe(f: ref Frame): ref Frame
{
zr := Draw->Rect(p0, p0);
newf := ref Frame(
-1, # id
nil, # doc
nil, # src
" PRINT FRAME ", # name
f.marginw, # marginw
f.marginh, # marginh
0, # framebd
Build->FRnoscroll, # flags
nil, # layout - filled in below, needs this frame ref
nil, # sublays - filled in by geometry code
0, # sublayid
nil, # controls - filled in below, needs this frame ref
0, # controlid - filled in below
nil, # cim
zr, # r
zr, # cr
zr, # totalr
zr, # viewr
nil, # vscr
nil, # hscr
nil, # parent
nil, # kids
0, # animpid
nil # prctxt
);
newf.doc = copydoc(f, newf, f.doc);
controls := array [len f.controls] of ref Control;
for (i := 0; i < len controls; i++)
controls[i] = copycontrol(f, newf, f.controls[i]);
newf.layout = copylay(f, newf, f.layout);
newf.controls = controls;
newf.controlid = len controls;
return newf;
}
copysublay(oldf, f: ref Frame, oldid:int): int
{
if (oldid < 0)
return -1;
if (f.sublayid >= len f.sublays)
f.sublays = (array [len f.sublays + 30] of ref Lay)[:] = f.sublays;
id := f.sublayid++;
lay := copylay(oldf, f, oldf.sublays[oldid]);
f.sublays[id] = lay;
return id;
}
copydoc(oldf, f : ref Frame, doc: ref Build->Docinfo): ref Docinfo
{
background := copybackground(oldf, f, doc.background);
newdoc := ref Build->Docinfo(
nil, #src
nil, #base
nil, #referrer
nil, #doctitle
background,
nil, #backgrounditem
doc.text, doc.link, doc.vlink, doc.alink,
nil, #target
nil, #refresh
nil, #chset
nil, #lastModified
0, #scripttype
0, #hasscripts
nil, #events
0, #evmask
nil, #kidinfo
0, #frameid
nil, #anchors
nil, #dests
nil, #forms
nil, #tables
nil, #maps
nil #images
);
return newdoc;
}
copylay(oldf, f: ref Frame, l: ref Lay): ref Lay
{
start := copyline(oldf, f, nil, l.start);
end := start;
for (line := l.start.next; line != nil; line = line.next)
end = copyline(oldf, f, end, line);
newl := ref Lay(
start,
end,
l.targetwidth, # targetwidth
l.width, # width
l.height, # height
l.margin, # margin
nil, # floats - filled in by geometry code
copybackground(oldf, f, l.background),
l.just,
Layout->Lchanged
);
start.flags = end.flags = byte 0;
return newl;
}
copycontrol(oldf, f: ref Frame, ctl: ref Control): ref Control
{
if (ctl == nil)
return nil;
pick c := ctl {
Cbutton =>
return ref Control.Cbutton(f, nil, c.r, c.flags, nil, c.pic, c.picmask, c.dpic, c.dpicmask, c.label, c.dorelief);
Centry =>
scr := copycontrol(oldf, f, c.scr);
return ref Control.Centry(f, nil, c.r, c.flags, nil, scr, c.s, c.sel, c.left, c.linewrap, 0);
Ccheckbox=>
return ref Control.Ccheckbox(f, nil, c.r, c.flags, nil, c.isradio);
Cselect =>
scr := copycontrol(oldf, f, c.scr);
options := (array [len c.options] of Build->Option)[:] = c.options;
return ref Control.Cselect(f, nil, c.r, c.flags, nil, nil, scr, c.nvis, c.first, options);
Clistbox =>
hscr := copycontrol(oldf, f, c.hscr);
vscr := copycontrol(oldf, f, c.vscr);
options := (array [len c.options] of Build->Option)[:] = c.options;
return ref Control.Clistbox(f, nil, c.r, c.flags, nil, hscr, vscr, c.nvis, c.first, c.start, c.maxcol, options, nil);
Cscrollbar =>
# do not copy ctl as this is set by those associated controls
return ref Control.Cscrollbar(f, nil, c.r, c.flags, nil, c.top, c.bot, c.mindelta, c.deltaval, nil, c.holdstate);
Canimimage =>
bg := copybackground(oldf, f, c.bg);
return ref Control.Canimimage(f, nil, c.r, c.flags, nil, c.cim, 0, 0, big 0, bg);
Clabel =>
return ref Control.Clabel(f, nil, c.r, c.flags, nil, c.s);
* =>
return nil;
}
}
copyline(oldf, f: ref Frame, prev, l: ref Line): ref Line
{
if (l == nil)
return nil;
cp := ref *l;
items := copyitems(oldf, f, l.items);
newl := ref Line (items, nil, prev, l.pos, l.width, l.height, l.ascent, Layout->Lchanged);
if (prev != nil)
prev.next = newl;
return newl;
}
copyitems(oldf, f: ref Frame, items: ref Item): ref Item
{
if (items == nil)
return nil;
item := copyitem(oldf, f, items);
end := item;
for (items = items.next; items != nil; items = items.next) {
end.next = copyitem(oldf, f, items);
end = end.next;
}
return item;
}
copyitem(oldf, f : ref Frame, item: ref Item): ref Item
{
if (item == nil)
return nil;
pick it := item {
Itext =>
return ref Item.Itext(
nil, it.width, it.height, it.ascent, 0, it.state, nil,
it.s, it.fnt, it.fg, it.voff, it.ul);
Irule =>
return ref Item.Irule(
nil, it.width, it.height, it.ascent, 0, it.state, nil,
it.align, it.noshade, it.size, it.wspec);
Iimage =>
# need to copy the image to prevent
# ongoing image fetches from messing up our layout
ci := copycimage(it.ci);
return ref Item.Iimage(
nil, it.width, it.height, it.ascent, 0, it.state, nil,
it.imageid, ci, it.imwidth, it.imheight, it.altrep,
nil, it.name, -1, it.align, it.hspace, it.vspace, it.border);
Iformfield =>
return ref Item.Iformfield(
nil, it.width, it.height, it.ascent, 0, it.state, nil,
copyformfield(oldf, f, it.formfield)
);
Itable =>
return ref Item.Itable(
nil, it.width, it.height, it.ascent, 0, it.state, nil,
copytable(oldf, f, it.table));
Ifloat =>
items := copyitem(oldf, f, it.item);
return ref Item.Ifloat(
nil, it.width, it.height, it.ascent, 0, it.state, nil,
items, it.x, it.y, it.side, byte 0);
Ispacer =>
return ref Item.Ispacer(
nil, it.width, it.height, it.ascent, 0, it.state, nil,
it.spkind, it.fnt);
* =>
return nil;
}
}
copycimage(ci: ref CharonUtils->CImage): ref CharonUtils->CImage
{
if (ci == nil)
return nil;
mims : array of ref MaskedImage;
if (len ci.mims > 0)
# if len> 1 then animated, but we only want first frame
mims = array [1] of {0 => ci.mims[0]};
return ref CharonUtils->CImage(nil, nil, nil, 0, ci.width, ci.height, nil, mims, 0);
}
copyformfield(oldf, f: ref Frame, ff: ref Build->Formfield): ref Build->Formfield
{
image := copyitem(oldf, f, ff.image);
# should be safe to reference Option list
newff := ref Build->Formfield(
ff.ftype, 0, nil, ff.name, ff.value, ff.size, ff.maxlength, ff.rows,
ff.cols, ff.flags, ff.options, image, ff.ctlid, nil, 0
);
return newff;
}
copytable(oldf, f: ref Frame, tbl: ref Build->Table): ref Build->Table
{
nrow := tbl.nrow;
ncol := tbl.ncol;
caption_lay := copysublay(oldf, f, tbl.caption_lay);
cols := (array [ncol] of Build->Tablecol)[:] = tbl.cols;
rows := array [nrow] of ref Build->Tablerow;
for (i := 0; i < nrow; i++) {
r := tbl.rows[i];
rows[i] = ref Build->Tablerow(nil, r.height, r.ascent, r.align, r.background, r.pos, r.flags);
}
cells : list of ref Build->Tablecell;
grid := array [nrow] of {* => array [ncol] of ref Build->Tablecell};
for (rix := 0; rix < nrow; rix++) {
rowcells: list of ref Build->Tablecell = nil;
for (colix := 0; colix < ncol; colix++) {
cell := copytablecell(oldf, f, tbl.grid[rix][colix]);
if (cell == nil)
continue;
grid[rix][colix] = cell;
cells = cell :: cells;
rowcells = cell :: rowcells;
}
# reverse the row cells;
rcells : list of ref Build->Tablecell = nil;
for (; rowcells != nil; rowcells = tl rowcells)
rcells = hd rowcells :: rcells;
rows[rix].cells = rcells;
}
# reverse the cells
sllec: list of ref Build->Tablecell;
for (; cells != nil; cells = tl cells)
sllec = hd cells :: sllec;
cells = sllec;
return ref Build->Table(
tbl.tableid, # tableid
nrow, # nrow
ncol, # ncol
len cells, # ncell
tbl.align, # align
tbl.width, # width
tbl.border, # border
tbl.cellspacing, # cellspacing
tbl.cellpadding, # cellpadding
tbl.background, # background
nil, # caption
tbl.caption_place, # caption_place
caption_lay, # caption_lay
nil, # currows
cols, # cols
rows, # rows
cells, # cells
tbl.totw, # totw
tbl.toth, # toth
tbl.caph, # caph
tbl.availw, # availw
grid, # grid
nil, # tabletok
Layout->Lchanged # flags
);
}
copytablecell(oldf, f: ref Frame, cell: ref Build->Tablecell): ref Build->Tablecell
{
if (cell == nil)
return nil;
layid := copysublay(oldf, f, cell.layid);
background := copybackground(oldf, f, cell.background);
newcell := ref Build->Tablecell(
cell.cellid,
nil, # content
layid,
cell.rowspan, cell.colspan, cell.align,
cell.flags, cell.wspec, cell.hspec,
background, cell.minw, cell.maxw,
cell.ascent, cell.row, cell.col, cell.pos);
return newcell;
}
copybackground(oldf, f: ref Frame, bg: Build->Background): Build->Background
{
img := copyitem(oldf, f, bg.image);
if (img != nil) {
pick i := img {
Iimage =>
bg.image = i;
}
}
return bg;
}