ref: b2509ed78c437b8f49637c39279b8fb0a417e826
dir: /appl/wm/drawmux/drawmux.b/
implement Drawmux; include "sys.m"; include "draw.m"; include "drawmux.m"; include "drawoffs.m"; sys : Sys; draw : Draw; Display, Point, Rect, Chans : import draw; Ehungup : con "Hangup"; drawR: Draw->Rect; drawchans: Draw->Chans; drawop := Draw->SoverD; drawfd: ref Sys->FD; images: ref Imageset; screens: ref Screenset; viewers: list of ref Viewer; drawlock: chan of chan of int; readdata: array of byte; nhangups := 0; prevnhangups := 0; init() : (string, ref Draw->Display) { sys = load Sys Sys->PATH; draw = load Draw Draw->PATH; if (draw == nil) return (sys->sprint("cannot load %s: %r", Draw->PATH), nil); drawlock = chan of chan of int; images = Imageset.new(); screens = Screenset. new(); res := chan of (string, ref Draw->Display); spawn getdisp(res); r := <- res; return r; } newviewer(fd : ref Sys->FD) { reply := array of byte sys->sprint("%.11d %.11d ", drawR.max.x - drawR.min.x, drawR.max.y - drawR.min.y); if (sys->write(fd, reply, len reply) != len reply) { # sys->print("viewer hangup\n"); return; } buf := array [Sys->ATOMICIO] of byte; n := sys->read(fd, buf, len buf); if (n < 24) return; pubscr := int string buf[0:12]; chans := Chans.mk(string buf[12:24]); sys->pctl(Sys->FORKNS, nil); sys->mount(fd, nil, "/", Sys->MREPL, nil); cfd := sys->open("/new", Sys->OREAD); sys->read(cfd, buf, len buf); cnum := int string buf[0:12]; cdata := sys->sprint("/%d/data", cnum); datafd := sys->open(cdata, Sys->ORDWR); if (datafd == nil) { # sys->print("cannot open viewer data file: %r\n"); return; } Viewer.new(datafd, pubscr, chans); } getdisp(result : chan of (string, ref Draw->Display)) { sys->pctl(Sys->FORKNS, nil); sys->bind("#i", "/dev", Sys->MREPL); sys->bind("#s", "/dev/draw", Sys->MBEFORE); newio := sys->file2chan("/dev/draw", "new"); if (newio == nil) { result <- = ("cannot create /dev/new file2chan", nil); return; } spawn srvnew(newio); disp := Display.allocate(nil); if (disp == nil) { result <-= (sys->sprint("%r"), nil); return; } draw->disp.image.draw(disp.image.r, disp.rgb(0,0,0), nil, Point(0,0)); result <- = (nil, disp); } srvnew(newio : ref Sys->FileIO) { for (;;) alt { (offset, count, fid, rc) := <- newio.read => if (rc != nil) { c := chan of (string, ref Sys->FD); fd := sys->open("#i/draw/new", Sys->OREAD); # +1 because of a sprint() nasty in devdraw.c buf := array [(12 * 12)+1] of byte; nn := sys->read(fd, buf, len buf); cnum := int string buf[0:12]; drawchans = Chans.mk(string buf[24:36]); # repl is at [36:48] drawR.min.x = int string buf[48:60]; drawR.min.y = int string buf[60:72]; drawR.max.x = int string buf[72:84]; drawR.max.y = int string buf[84:96]; bwidth := bytesperline(drawR, drawchans); img := ref Image (0, 0, 0, 0, drawchans, 0, drawR, drawR, Draw->Black, nil, drawR.min, bwidth, 0, ""); images.add(0, img); cdir := sys->sprint("/dev/draw/%d", cnum); dpath := sys->sprint("#i/draw/%d/data", cnum); drawfd = sys->open(dpath, Sys->ORDWR); fd = nil; if (drawfd == nil) { rc <-= (nil, sys->sprint("%r")); return; } sys->bind("#s", cdir, Sys->MBEFORE); drawio := sys->file2chan(cdir, "data"); spawn drawclient(drawio); rc <- = (buf, nil); return; } (offset, data, fid, wc) := <- newio.write => if (wc != nil) writereply(wc, (0, "permission denied")); } } # for simplicity make the file 'exclusive use' drawclient(drawio : ref Sys->FileIO) { activefid := -1; closecount := 2; for (;closecount;) { alt { unlock := <- drawlock => <- unlock; (offset, count, fid, rc) := <- drawio.read => if (activefid == -1) activefid = fid; if (rc == nil) { closecount--; continue; } if (fid != activefid) { rc <-= (nil, "file busy"); continue; } if (readdata == nil) { rc <-= (nil, nil); continue; } if (count > len readdata) count = len readdata; rc <- = (readdata[0:count], nil); readdata = nil; (offset, data, fid, wc) := <- drawio.write => if (wc == nil) { closecount--; continue; } writereply(wc, process(data)); } if (nhangups != prevnhangups) { ok : list of ref Viewer; for (ok = nil; viewers != nil; viewers = tl viewers) { v := hd viewers; if (!v.hungup) ok = v :: ok; else { # sys->print("shutting down Viewer\n"); v.output <- = (nil, nil); } } viewers = ok; prevnhangups = nhangups; } } # sys->print("DRAWIO DONE!\n"); } writereply(wc : chan of (int, string), val : (int, string)) { alt { wc <-= val => ; * => ; } } Image: adt { id: int; refc: int; screenid: int; refresh: int; chans: Draw->Chans; repl: int; R: Draw->Rect; clipR: Draw->Rect; rrggbbaa: int; font: ref Font; lorigin: Draw->Point; bwidth: int; dirty: int; name: string; }; Screen: adt { id: int; imageid: int; fillid: int; windows: array of int; setz: fn (s: self ref Screen, z: array of int, top: int); addwin: fn (s: self ref Screen, wid: int); delwin: fn (s: self ref Screen, wid: int); }; Font: adt { ascent: int; chars: array of ref Fontchar; }; Fontchar: adt { srcid: int; R: Draw->Rect; P: Draw->Point; left: int; width: int; }; Idpair: adt { key: int; val: int; next: cyclic ref Idpair; }; Idmap: adt { buckets: array of ref Idpair; new: fn (): ref Idmap; add: fn (m: self ref Idmap, key, val: int); del: fn (m: self ref Idmap, key: int); lookup: fn (m: self ref Idmap, key: int): int; }; Imageset: adt { images: array of ref Image; ixmap: ref Idmap; freelist: list of int; new: fn (): ref Imageset; add: fn (s: self ref Imageset, id: int, img: ref Image); del: fn (s: self ref Imageset, id: int); lookup: fn (s: self ref Imageset, id: int): ref Image; findname: fn(s: self ref Imageset, name: string): ref Image; }; Screenset: adt { screens: array of ref Screen; ixmap: ref Idmap; freelist: list of int; new: fn (): ref Screenset; add: fn (s: self ref Screenset, scr: ref Screen); del: fn (s: self ref Screenset, id: int); lookup: fn (s: self ref Screenset, id: int): ref Screen; }; Drawreq: adt { data: array of byte; pick { # a => # allocate image # id: int; # screenid: int; # refresh: int; # ldepth: int; # repl: int; # R: Draw->Rect; # clipR: Draw->Rect; # value: int; b => # new allocate image id: int; screenid: int; refresh: int; chans: Draw->Chans; repl: int; R: Draw->Rect; clipR: Draw->Rect; rrggbbaa: int; A => # allocate screen id: int; imageid: int; fillid: int; c => # set clipr and repl dstid: int; repl: int; clipR: Draw->Rect; # x => # move cursor # C => # set cursor image and hotspot # _: int; d => # general draw op dstid: int; srcid: int; maskid: int; D => # debug mode _: int; e => # draw ellipse dstid: int; srcid: int; f => # free image id: int; img: ref Image; # helper for Viewers F => # free screen id: int; i => # convert image to font fontid: int; nchars: int; ascent: int; l => # load a char into font fontid: int; srcid: int; index: int; R: Draw->Rect; P: Draw->Point; left: int; width: int; L => # draw line dstid: int; srcid: int; n => # attach to named image dstid: int; name: string; N => # name image dstid: int; in: int; name: string; o => # set window origins id: int; rmin: Draw->Point; screenrmin: Draw->Point; O => # set next compositing op op: int; p => # draw polygon dstid: int; srcid: int; r => # read pixels id: int; R: Draw->Rect; s => # draw text dstid: int; srcid: int; fontid: int; x => # draw text with bg dstid: int; srcid: int; fontid: int; bgid: int; S => # import public screen t => # adjust window z order top: int; ids: array of int; v => # flush updates to display y => # write pixels id: int; R: Draw->Rect; } }; getreq(data : array of byte, ix : int) : (ref Drawreq, string) { mlen := 0; err := "short draw message"; req : ref Drawreq; case int data[ix] { 'b' => # alloc image mlen = 1+4+4+1+4+1+(4*4)+(4*4)+4; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.b; r.data = data; r.id = get4(data, OPb_id); r.screenid = get4(data, OPb_screenid); r.refresh = get1(data, OPb_refresh); r.chans = Draw->Chans(get4(data, OPb_chans)); r.repl = get1(data, OPb_repl); r.R = getR(data, OPb_R); r.clipR = getR(data, OPb_clipR); r.rrggbbaa = get4(data, OPb_rrggbbaa); req = r; } 'A' => # alloc screen mlen = 1+4+4+4+1; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.A; r.data = data; r.id = get4(data, OPA_id); r.imageid = get4(data, OPA_imageid); r.fillid = get4(data, OPA_fillid); req = r; } 'c' => # set clipR mlen = 1+4+1+(4*4); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.c; r.data = data; r.dstid = get4(data, OPc_dstid); r.repl = get1(data, OPc_repl); r.clipR = getR(data, OPc_clipR); req = r; } 'd' => # draw mlen = 1+4+4+4+(4*4)+(2*4)+(2*4); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.d; r.data = data; r.dstid = get4(data, OPd_dstid); r.srcid = get4(data, OPd_srcid); r.maskid = get4(data, OPd_maskid); req = r; } 'D' => # debug mode mlen = 1+1; if (mlen+ix <= len data) { req = ref Drawreq.v; req.data = data[ix:ix+mlen]; } 'e' or 'E' => # ellipse mlen = 1+4+4+(2*4)+4+4+4+(2*4)+4+4; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.e; r.data = data; r.dstid = get4(data, OPe_dstid); r.srcid = get4(data, OPe_srcid); req = r; } 'f' => # free image mlen = 1+4; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.f; r.data = data; r.id = get4(data, OPf_id); req = r; } 'F' => # free screen mlen = 1+4; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.f; r.data = data; r.id = get4(data, OPF_id); req = r; } 'i' => # alloc font mlen = 1+4+4+1; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.i; r.data = data; r.fontid = get4(data, OPi_fontid); r.nchars = get4(data, OPi_nchars); r.ascent = get1(data, OPi_ascent); req = r; } 'l' => # load font char mlen = 1+4+4+2+(4*4)+(2*4)+1+1; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.l; r.data = data; r.fontid = get4(data, OPl_fontid); r.srcid = get4(data, OPl_srcid); r.index = get2(data, OPl_index); r.R = getR(data, OPl_R); r.P = getP(data, OPl_P); r.left = get1(data, OPl_left); r.width = get1(data, OPl_width); req = r; } 'L' => # line mlen = 1+4+(2*4)+(2*4)+4+4+4+4+(2*4); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.L; r.data = data; r.dstid = get4(data, OPL_dstid); r.srcid = get4(data, OPL_srcid); req = r; } 'n' => # attach to named image mlen = 1+4+1; if (mlen+ix < len data) { mlen += get1(data, ix+OPn_j); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.n; r.data = data; r.dstid = get4(data, OPn_dstid); r.name = string data[OPn_name:]; req = r; } } 'N' => # name image mlen = 1+4+1+1; if (mlen+ix < len data) { mlen += get1(data, ix+OPN_j); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.N; r.data = data; r.dstid = get4(data, OPN_dstid); r.in = get1(data, OPN_in); r.name = string data[OPN_name:]; req = r; } } 'o' => # set origins mlen = 1+4+(2*4)+(2*4); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.o; r.data = data; r.id = get4(data, OPo_id); r.rmin = getP(data, OPo_rmin); r.screenrmin = getP(data, OPo_screenrmin); req = r; } 'O' => # set next compop mlen = 1+1; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.O; r.data = data; r.op = get1(data, OPO_op); req = r; } 'p' or 'P' => # polygon mlen = 1+4+2+4+4+4+4+(2*4); if (mlen + ix <= len data) { n := get2(data, ix+OPp_n); nb := coordslen(data, ix+OPp_P0, 2*(n+1)); if (nb == -1) err = "bad coords"; else { mlen += nb; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.p; r.data = data; r.dstid = get4(data, OPp_dstid); r.srcid = get4(data, OPp_srcid); req = r; } } } 'r' => # read pixels mlen = 1+4+(4*4); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.r; r.data = data; r.id = get4(data, OPr_id); r.R = getR(data, OPr_R); req = r; } 's' => # text mlen = 1+4+4+4+(2*4)+(4*4)+(2*4)+2; if (ix+mlen <= len data) { ni := get2(data, ix+OPs_ni); mlen += (2*ni); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.s; r.data = data; r.dstid = get4(data, OPs_dstid); r.srcid = get4(data, OPs_srcid); r.fontid = get4(data, OPs_fontid); req = r; } } 'x' => # text with bg img mlen = 1+4+4+4+(2*4)+(4*4)+(2*4)+2+4+(2*4); if (ix+mlen <= len data) { ni := get2(data, ix+OPx_ni); mlen += (2*ni); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.x; r.data = data; r.dstid = get4(data, OPx_dstid); r.srcid = get4(data, OPx_srcid); r.fontid = get4(data, OPx_fontid); r.bgid = get4(data, OPx_bgid); req = r; } } 'S' => # import public screen mlen = 1+4+4; if (mlen+ix <= len data) { data = data[ix:ix+mlen]; req = ref Drawreq.S; req.data = data; } 't' => # adjust window z order mlen = 1+1+2; if (ix+mlen<= len data) { nw := get2(data, ix+OPt_nw); mlen += (4*nw); if (mlen+ix <= len data) { data = data[ix:ix+mlen]; r := ref Drawreq.t; r.data = data; r.top = get1(data, OPt_top); r.ids = array [nw] of int; for (n := 0; n < nw; n++) r.ids[n] = get4(data, OPt_id + 4*n); req = r; } } 'v' => # flush req = ref Drawreq.v; req.data = data[ix:ix+1]; 'y' or 'Y' => # write pixels mlen = 1+4+(4*4); if (ix+mlen <= len data) { imgid := get4(data, ix+OPy_id); img := images.lookup(imgid); compd := data[ix] == byte 'Y'; r := getR(data, ix+OPy_R); n := imglen(img, data, ix+mlen, r, compd); if (n == -1) err ="bad image data"; mlen += n; if (mlen+ix <= len data) req = ref Drawreq.y (data[ix:ix+mlen], imgid, r); } * => err = "bad draw command"; } if (req == nil) return (nil, err); return (req, nil); } process(data : array of byte) : (int, string) { offset := 0; while (offset < len data) { (req, err) := getreq(data, offset); if (err != nil) return (0, err); offset += len req.data; n := sys->write(drawfd, req.data, len req.data); if (n <= 0) return (n, sys->sprint("[%c] %r", int req.data[0])); readn := 0; sendtoviews := 1; # actions that must be done before sending to Viewers pick r := req { b => # allocate image bwidth := bytesperline(r.R, r.chans); img := ref Image (r.id, 0, r.screenid, r.refresh, r.chans, r.repl, r.R, r.clipR, r.rrggbbaa, nil, r.R.min, bwidth, 0, ""); images.add(r.id, img); if (r.screenid != 0) { scr := screens.lookup(r.screenid); scr.addwin(r.id); } A => # allocate screen scr := ref Screen (r.id, r.imageid, r.fillid, nil); screens.add(scr); # we never allocate public screens on our Viewers put1(r.data, OPA_public, 0); dirty(r.imageid, 0); c => # set clipr and repl img := images.lookup(r.dstid); img.repl = r.repl; img.clipR = r.clipR; d => # general draw op dirty(r.dstid, 1); drawop = Draw->SoverD; e => # draw ellipse dirty(r.dstid, 1); drawop = Draw->SoverD; f => # free image # help out Viewers, real work is done later r.img = images.lookup(r.id); L => # draw line dirty(r.dstid, 1); drawop = Draw->SoverD; n => # attach to named image img := images.findname(r.name); images.add(r.dstid, img); N => # name image img := images.lookup(r.dstid); if (r.in) img.name = r.name; else img.name = nil; o => # set image origins img := images.lookup(r.id); deltax := img.lorigin.x - r.rmin.x; deltay := img.lorigin.y - r.rmin.y; w := img.R.max.x - img.R.min.x; h := img.R.max.y - img.R.min.y; img.R = Draw->Rect(r.screenrmin, (r.screenrmin.x + w, r.screenrmin.y + h)); img.clipR = Draw->Rect((img.clipR.min.x - deltax, img.clipR.min.y - deltay), (img.clipR.max.x - deltax, img.clipR.max.y - deltay)); img.lorigin = r.rmin; O => # set compositing op drawop = r.op; p => # draw polygon dirty(r.dstid, 1); drawop = Draw->SoverD; r => # read pixels img := images.lookup(r.id); bpl := bytesperline(r.R, img.chans); readn = bpl * (r.R.max.y - r.R.min.y); s => # draw text dirty(r.dstid, 1); drawop = Draw->SoverD; x => # draw text with bg dirty(r.dstid, 1); drawop = Draw->SoverD; t => # adjust window z order if (r.ids != nil) { img := images.lookup(r.ids[0]); scr := screens.lookup(img.screenid); scr.setz(r.ids, r.top); } y => # write pixels dirty(r.id, 1); } if (readn) { rdata := array [readn] of byte; if (sys->read(drawfd, rdata, readn) == readn) readdata = rdata; } for (vs := viewers; vs != nil; vs = tl vs) { v := hd vs; v.process(req); } # actions that must only be done after sending to Viewers pick r := req { f => # free image img := images.lookup(r.id); if (img.screenid != 0) { scr := screens.lookup(img.screenid); scr.delwin(img.id); } images.del(r.id); F => # free screen scr := screens.lookup(r.id); for (i := 0; i < len scr.windows; i++) { img := images.lookup(scr.windows[i]); img.screenid = 0; } screens.del(r.id); i => # convert image to font img := images.lookup(r.fontid); font := ref Font; font.ascent = r.ascent; font.chars = array[r.nchars] of ref Fontchar; img.font = font; l => # load a char into font img := images.lookup(r.fontid); font := img.font; fc := ref Fontchar(r.srcid, r.R, r.P, r.left, r.width); font.chars[r.index] = fc; } } return (offset, nil); } coordslen(data : array of byte, ix, n : int) : int { start := ix; dlen := len data; if (ix == dlen) return -1; while (ix < dlen && n) { n--; if ((int data[ix++]) & 16r80) ix += 2; } if (n) return -1; return ix - start; } imglen(i : ref Image, data : array of byte, ix : int, r : Draw->Rect, comp : int) : int { bpl := bytesperline(r, i.chans); if (!comp) return (r.max.y - r.min.y) * bpl; y := r.min.y; lineix := byteaddr(i, r.min); elineix := lineix+bpl; start := ix; eix := len data; for (;;) { if (lineix == elineix) { if (++y == r.max.y) break; lineix = byteaddr(i, Point(r.min.x, y)); elineix = lineix+bpl; } if (ix == eix) # buffer too small return -1; c := int data[ix++]; if (c >= 128) { for (cnt := c-128+1; cnt != 0; --cnt) { if (ix == eix) # buffer too small return -1; if (lineix == elineix) # phase error return -1; lineix++; ix++; } } else { if (ix == eix) # short buffer return -1; ix++; for (cnt := (c >> 2)+3; cnt != 0; --cnt) { if (lineix == elineix) # phase error return -1; lineix++; } } } return ix-start; } byteaddr(i: ref Image, p: Point): int { x := p.x - i.lorigin.x; y := p.y - i.lorigin.y; bits := i.chans.depth(); if (bits == 0) # invalid chans return 0; return (y*i.bwidth)+(x<<3)/bits; } bytesperline(r: Draw->Rect, chans: Draw->Chans): int { d := chans.depth(); l, t: int; if(r.min.x >= 0){ l = (r.max.x*d+8-1)/8; l -= (r.min.x*d)/8; }else{ # make positive before divide t = (-r.min.x*d+8-1)/8; l = t+(r.max.x*d+8-1)/8; } return l; } get1(data : array of byte, ix : int) : int { return int data[ix]; } put1(data : array of byte, ix, val : int) { data[ix] = byte val; } get2(data : array of byte, ix : int) : int { return int data[ix] | ((int data[ix+1]) << 8); } put2(data : array of byte, ix, val : int) { data[ix] = byte val; data[ix+1] = byte (val >> 8); } get4(data : array of byte, ix : int) : int { return int data[ix] | ((int data[ix+1]) << 8) | ((int data[ix+2]) << 16) | ((int data[ix+3]) << 24); } put4(data : array of byte, ix, val : int) { data[ix] = byte val; data[ix+1] = byte (val >> 8); data[ix+2] = byte (val >> 16); data[ix+3] = byte (val >> 24); } getP(data : array of byte, ix : int) : Draw->Point { x := int data[ix] | ((int data[ix+1]) << 8) | ((int data[ix+2]) << 16) | ((int data[ix+3]) << 24); ix += 4; y := int data[ix] | ((int data[ix+1]) << 8) | ((int data[ix+2]) << 16) | ((int data[ix+3]) << 24); return Draw->Point(x, y); } putP(data : array of byte, ix : int, P : Draw->Point) { val := P.x; data[ix] = byte val; data[ix+1] = byte (val >> 8); data[ix+2] = byte (val >> 16); data[ix+3] = byte (val >> 24); val = P.y; ix += 4; data[ix] = byte val; data[ix+1] = byte (val >> 8); data[ix+2] = byte (val >> 16); data[ix+3] = byte (val >> 24); } getR(data : array of byte, ix : int) : Draw->Rect { minx := int data[ix] | ((int data[ix+1]) << 8) | ((int data[ix+2]) << 16) | ((int data[ix+3]) << 24); ix += 4; miny := int data[ix] | ((int data[ix+1]) << 8) | ((int data[ix+2]) << 16) | ((int data[ix+3]) << 24); ix += 4; maxx := int data[ix] | ((int data[ix+1]) << 8) | ((int data[ix+2]) << 16) | ((int data[ix+3]) << 24); ix += 4; maxy := int data[ix] | ((int data[ix+1]) << 8) | ((int data[ix+2]) << 16) | ((int data[ix+3]) << 24); return Draw->Rect(Draw->Point(minx, miny), Draw->Point(maxx, maxy)); } putR(data : array of byte, ix : int , R : Draw->Rect) { val := R.min.x; data[ix] = byte val; data[ix+1] = byte (val >> 8); data[ix+2] = byte (val >> 16); data[ix+3] = byte (val >> 24); val = R.min.y; ix += 4; data[ix] = byte val; data[ix+1] = byte (val >> 8); data[ix+2] = byte (val >> 16); data[ix+3] = byte (val >> 24); val = R.max.x; ix += 4; data[ix] = byte val; data[ix+1] = byte (val >> 8); data[ix+2] = byte (val >> 16); data[ix+3] = byte (val >> 24); val = R.max.y; ix += 4; data[ix] = byte val; data[ix+1] = byte (val >> 8); data[ix+2] = byte (val >> 16); data[ix+3] = byte (val >> 24); } dirty(id, v : int) { img := images.lookup(id); img.dirty = v; } Screen.setz(s : self ref Screen, z : array of int, top : int) { old := s.windows; nw := array [len old] of int; # use a dummy idmap to ensure uniqueness; ids := Idmap.new(); ix := 0; if (top) { for (i := 0; i < len z; i++) { if (ids.lookup(z[i]) == -1) { ids.add(z[i], 0); nw[ix++] = z[i]; } } } for (i := 0; i < len old; i++) { if (ids.lookup(old[i]) == -1) { ids.add(old[i], 0); nw[ix++] = old[i]; } } if (!top) { for (i = 0; i < len z; i++) { if (ids.lookup(z[i]) == -1) { ids.add(z[i], 0); nw[ix++] = z[i]; } } } s.windows = nw; } Screen.addwin(s : self ref Screen, wid : int) { nw := array [len s.windows + 1] of int; nw[0] = wid; nw[1:] = s.windows; s.windows = nw; } Screen.delwin(s : self ref Screen, wid : int) { if (len s.windows == 1) { # assert s.windows[0] == wid s.windows = nil; return; } nw := array [len s.windows - 1] of int; ix := 0; for (i := 0; i < len s.windows; i++) { if (s.windows[i] == wid) continue; nw[ix++] = s.windows[i]; } s.windows = nw; } Idmap.new() : ref Idmap { m := ref Idmap; m.buckets = array[256] of ref Idpair; return m; } Idmap.add(m : self ref Idmap, key, val : int) { h := key & 16rff; m.buckets[h] = ref Idpair (key, val, m.buckets[h]); } Idmap.del(m : self ref Idmap, key : int) { h := key &16rff; prev := m.buckets[h]; if (prev == nil) return; if (prev.key == key) { m.buckets[h] = m.buckets[h].next; return; } for (idp := prev.next; idp != nil; idp = idp.next) { if (idp.key == key) break; prev = idp; } if (idp != nil) prev.next = idp.next; } Idmap.lookup(m :self ref Idmap, key : int) : int { h := key &16rff; for (idp := m.buckets[h]; idp != nil; idp = idp.next) { if (idp.key == key) return idp.val; } return -1; } Imageset.new() : ref Imageset { s := ref Imageset; s.images = array [32] of ref Image; s.ixmap = Idmap.new(); for (i := 0; i < len s.images; i++) s.freelist = i :: s.freelist; return s; } Imageset.add(s: self ref Imageset, id: int, img: ref Image) { if (s.freelist == nil) { n := 2 * len s.images; ni := array [n] of ref Image; ni[:] = s.images; for (i := len s.images; i < n; i++) s.freelist = i :: s.freelist; s.images = ni; } ix := hd s.freelist; s.freelist = tl s.freelist; s.images[ix] = img; s.ixmap.add(id, ix); img.refc++; } Imageset.del(s: self ref Imageset, id: int) { ix := s.ixmap.lookup(id); if (ix == -1) return; img := s.images[ix]; if (img != nil) img.refc--; s.images[ix] = nil; s.freelist = ix :: s.freelist; s.ixmap.del(id); } Imageset.lookup(s : self ref Imageset, id : int ) : ref Image { ix := s.ixmap.lookup(id); if (ix == -1) return nil; return s.images[ix]; } Imageset.findname(s: self ref Imageset, name: string): ref Image { for (ix := 0; ix < len s.images; ix++) { img := s.images[ix]; if (img != nil && img.name == name) return img; } return nil; } Screenset.new() : ref Screenset { s := ref Screenset; s.screens = array [32] of ref Screen; s.ixmap = Idmap.new(); for (i := 0; i < len s.screens; i++) s.freelist = i :: s.freelist; return s; } Screenset.add(s : self ref Screenset, scr : ref Screen) { if (s.freelist == nil) { n := 2 * len s.screens; ns := array [n] of ref Screen; ns[:] = s.screens; for (i := len s.screens; i < n; i++) s.freelist = i :: s.freelist; s.screens = ns; } ix := hd s.freelist; s.freelist = tl s.freelist; s.screens[ix] = scr; s.ixmap.add(scr.id, ix); } Screenset.del(s : self ref Screenset, id : int) { ix := s.ixmap.lookup(id); if (ix == -1) return; s.screens[ix] = nil; s.freelist = ix :: s.freelist; s.ixmap.del(id); } Screenset.lookup(s : self ref Screenset, id : int ) : ref Screen { ix := s.ixmap.lookup(id); if (ix == -1) return nil; return s.screens[ix]; } Viewer : adt { imgmap: ref Idmap; scrmap: ref Idmap; chanmap: ref Idmap; # maps to 1 for images that require chan conversion imageid: int; screenid: int; whiteid: int; hungup: int; dchans: Draw->Chans; # chans.desc of remote display img # temporary image for chan conversion tmpid: int; tmpR: Draw->Rect; output: chan of (array of byte, chan of string); new: fn(fd: ref Sys->FD, pubscr: int, chans: Draw->Chans): string; process: fn(v: self ref Viewer, req: ref Drawreq); getimg: fn(v: self ref Viewer, id: int): int; getscr: fn(v: self ref Viewer, id, win: int): (int, int); copyimg: fn(v: self ref Viewer, img: ref Image, id: int); chanconv: fn(v: self ref Viewer, img: ref Image, id: int, r: Rect, ymsg: array of byte); }; vwriter(fd : ref Sys->FD, datac : chan of array of byte, nc : chan of string) { for (;;) { data := <- datac; if (data == nil) return; n := sys->write(fd, data, len data); if (n != len data) { # sys->print("[%c]: %r\n", int data[0]); # sys->print("[%c] datalen %d got %d error: %r\n", int data[0], len data, n); nc <-= sys->sprint("%r"); } else { # sys->print("[%c]", int data[0]); nc <-= nil; } } } vbmsg : adt { data : array of byte; rc : chan of string; next : cyclic ref vbmsg; }; vbuffer(v : ref Viewer, fd : ref Sys->FD) { ioc := v.output; datac := chan of array of byte; errc := chan of string; spawn vwriter(fd, datac, errc); fd = nil; msghd : ref vbmsg; msgtl : ref vbmsg; Loop: for (;;) alt { (data, rc) := <- ioc => if (data == nil) break Loop; if (msgtl != nil) { if (msgtl != msghd && msgtl.rc == nil && (len msgtl.data + len data) <= Sys->ATOMICIO) { ndata := array [len msgtl.data + len data] of byte; ndata[:] = msgtl.data; ndata[len msgtl.data:] = data; msgtl.data = ndata; msgtl.rc = rc; } else { msgtl.next = ref vbmsg (data, rc, nil); msgtl = msgtl.next; } } else { msghd = ref vbmsg (data, rc, nil); msgtl = msghd; datac <-= data; } err := <- errc => if (msghd.rc != nil) msghd.rc <- = err; msghd = msghd.next; if (msghd != nil) datac <-= msghd.data; else msgtl = nil; if (err == Ehungup) { nhangups++; v.hungup = 1; } } # shutdown vwriter (may be blocked sending on errc) for (;;) alt { <- errc => ; datac <- = nil => return; } } Viewer.new(fd: ref Sys->FD, pubscr: int, chans: Draw->Chans): string { v := ref Viewer; v.output = chan of (array of byte, chan of string); spawn vbuffer(v, fd); v.imgmap = Idmap.new(); v.scrmap = Idmap.new(); v.chanmap = Idmap.new(); v.imageid = 0; v.screenid = pubscr; v.hungup = 0; v.dchans = chans; v.tmpid = 0; v.tmpR = Rect((0,0), (0,0)); #D := array[1+1] of byte; #D[0] = byte 'D'; #D[1] = byte 1; #v.output <-= (D, nil); reply := chan of string; # import remote public screen into our remote draw client S := array [1+4+4] of byte; S[0] = byte 'S'; put4(S, OPS_id, pubscr); put4(S, OPS_chans, chans.desc); v.output <-= (S, reply); err := <- reply; if (err != nil) { v.output <-= (nil, nil); return err; } # create remote window dispid := ++v.imageid; b := array [1+4+4+1+4+1+(4*4)+(4*4)+4] of byte; b[0] = byte 'b'; put4(b, OPb_id, dispid); put4(b, OPb_screenid, pubscr); put1(b, OPb_refresh, 0); put4(b, OPb_chans, chans.desc); put1(b, OPb_repl, 0); putR(b, OPb_R, drawR); putR(b, OPb_clipR, drawR); put4(b, OPb_rrggbbaa, Draw->White); v.output <-= (b, reply); err = <- reply; if (err != nil) { v.output <-= (nil, nil); return err; } # map local display image id to remote window image id v.imgmap.add(0, dispid); if (!drawchans.eq(chans)) # writepixels on this image must be chan converted v.chanmap.add(0, 1); # create 'white' repl image for use as mask v.whiteid = ++v.imageid; put4(b, OPb_id, v.whiteid); put4(b, OPb_screenid, 0); put1(b, OPb_refresh, 0); put4(b, OPb_chans, (Draw->RGBA32).desc); put1(b, OPb_repl, 1); putR(b, OPb_R, Rect((0,0), (1,1))); putR(b, OPb_clipR, Rect((-16r3FFFFFFF, -16r3FFFFFFF), (16r3FFFFFFF, 16r3FFFFFFF))); put4(b, OPb_rrggbbaa, Draw->White); v.output <-= (b, reply); err = <- reply; if (err != nil) { v.output <-= (nil, nil); return err; } img := images.lookup(0); key := chan of int; drawlock <- = key; v.copyimg(img, dispid); O := array [1+1] of byte; O[0] = byte 'O'; O[1] = byte drawop; v.output <-= (O, nil); flush := array [1] of byte; flush[0] = byte 'v'; v.output <- = (flush, nil); viewers = v :: viewers; key <-= 1; return nil; } Viewer.process(v : self ref Viewer, req : ref Drawreq) { data := req.data; pick r := req { b => # allocate image imgid := ++v.imageid; if (r.screenid != 0) { (scrid, mapchans) := v.getscr(r.screenid, 0); put4(data, OPb_screenid, scrid); if (mapchans) { put4(data, OPb_chans, v.dchans.desc); v.chanmap.add(r.id, 1); } } v.imgmap.add(r.id, imgid); put4(data, OPb_id, imgid); A => # allocate screen imgid := v.getimg(r.imageid); put4(data, OPA_fillid, v.getimg(r.fillid)); put4(data, OPA_imageid, imgid); reply := chan of string; for (i := 0; i < 25; i++) { put4(data, OPA_id, ++v.screenid); v.output <-= (data, reply); if (<-reply == nil) { v.scrmap.add(r.id, v.screenid); return; } } return; c => # set clipr and repl put4(data, OPc_dstid, v.getimg(r.dstid)); d => # general draw op dstid := v.imgmap.lookup(r.dstid); if (dstid == -1) { # don't do draw op as getimg() will do a writepixels v.getimg(r.dstid); return; } put4(data, OPd_maskid, v.getimg(r.maskid)); put4(data, OPd_srcid, v.getimg(r.srcid)); put4(data, OPd_dstid, dstid); e => # draw ellipse dstid := v.imgmap.lookup(r.dstid); if (dstid == -1) { # don't do draw op as getimg() will do a writepixels v.getimg(r.dstid); return; } put4(data, OPe_srcid, v.getimg(r.srcid)); put4(data, OPe_dstid, dstid); f => # free image id := v.imgmap.lookup(r.img.id); if (id == -1) # Viewer has never seen this image - ignore return; v.imgmap.del(r.id); # Viewers alias named images - only delete if last reference if (r.img.refc > 1) return; v.chanmap.del(r.img.id); put4(data, OPf_id, id); F => # free screen id := v.scrmap.lookup(r.id); scr := screens.lookup(r.id); # image and fill are free'd separately #v.imgmap.del(scr.imageid); #v.imgmap.del(scr.fillid); if (id == -1) return; put4(data, OPF_id, id); i => # convert image to font put4(data, OPi_fontid, v.getimg(r.fontid)); l => # load a char into font put4(data, OPl_srcid, v.getimg(r.srcid)); put4(data, OPl_fontid, v.getimg(r.fontid)); L => # draw line dstid := v.imgmap.lookup(r.dstid); if (dstid == -1) { # don't do draw op as getimg() will do a writepixels v.getimg(r.dstid); return; } put4(data, OPL_srcid, v.getimg(r.srcid)); put4(data, OPL_dstid, dstid); # n => # attach to named image # N => # name # Handled by id remapping to avoid clashes in namespace of remote viewers. # If it is a name we know then the id is remapped within the images Imageset # Otherwise, there is nothing we can do other than ignore all ops related to the id. o => # set image origins id := v.imgmap.lookup(r.id); if (id == -1) # Viewer has never seen this image - ignore return; put4(data, OPo_id, id); O => # set next compositing op ; p => # draw polygon dstid := v.imgmap.lookup(r.dstid); if (dstid == -1) { # don't do draw op as getimg() will do a writepixels v.getimg(r.dstid); return; } put4(data, OPp_srcid, v.getimg(r.srcid)); put4(data, OPp_dstid, dstid); s => # draw text dstid := v.imgmap.lookup(r.dstid); if (dstid == -1) { # don't do draw op as getimg() will do a writepixels v.getimg(r.dstid); return; } put4(data, OPs_fontid, v.getimg(r.fontid)); put4(data, OPs_srcid, v.getimg(r.srcid)); put4(data, OPs_dstid, dstid); x => # draw text with bg dstid := v.imgmap.lookup(r.dstid); if (dstid == -1) { # don't do draw op as getimg() will do a writepixels v.getimg(r.dstid); return; } put4(data, OPx_fontid, v.getimg(r.fontid)); put4(data, OPx_srcid, v.getimg(r.srcid)); put4(data, OPx_bgid, v.getimg(r.bgid)); put4(data, OPx_dstid, dstid); t => # adjust window z order for (i := 0; i < len r.ids; i++) put4(data, OPt_id + 4*i, v.getimg(r.ids[i])); v => # flush updates to display ; y => # write pixels id := v.imgmap.lookup(r.id); if (id == -1) { # don't do draw op as getimg() will do a writepixels v.getimg(r.id); return; } if (!drawchans.eq(v.dchans) && v.chanmap.lookup(r.id) != -1) { # chans clash img := images.lookup(r.id); # copy data as other Viewers may alter contents copy := (array [len data] of byte)[:] = data; v.chanconv(img, id, r.R, copy); return; } put4(data, OPy_id, id); * => return; } # send out a copy of the data as other Viewers may alter contents copy := array [len data] of byte; copy[:] = data; v.output <-= (copy, nil); } Viewer.getimg(v: self ref Viewer, localid: int) : int { remid := v.imgmap.lookup(localid); if (remid != -1) return remid; img := images.lookup(localid); if (img.id != localid) { # attached via name, see if we have the aliased image remid = v.imgmap.lookup(img.id); if (remid != -1) { # we have it, add mapping to save us this trouble next time v.imgmap.add(localid, remid); return remid; } } # is the image a window? scrid := 0; mapchans := 0; if (img.screenid != 0) (scrid, mapchans) = v.getscr(img.screenid, img.id); vid := ++v.imageid; # create the image # note: clipr for image creation has to be based on screen co-ords clipR := img.clipR.subpt(img.lorigin); clipR = clipR.addpt(img.R.min); b := array [1+4+4+1+4+1+(4*4)+(4*4)+4] of byte; b[0] = byte 'b'; put4(b, OPb_id, vid); put4(b, OPb_screenid, scrid); put1(b, OPb_refresh, 0); if (mapchans) put4(b, OPb_chans, v.dchans.desc); else put4(b, OPb_chans, img.chans.desc); put1(b, OPb_repl, img.repl); putR(b, OPb_R, img.R); putR(b, OPb_clipR, clipR); put4(b, OPb_rrggbbaa, img.rrggbbaa); v.output <-= (b, nil); v.imgmap.add(img.id, vid); if (mapchans) v.chanmap.add(img.id, 1); # set the origin if (img.lorigin.x != img.R.min.x || img.lorigin.y != img.R.min.y) { o := array [1+4+(2*4)+(2*4)] of byte; o[0] = byte 'o'; put4(o, OPo_id, vid); putP(o, OPo_rmin, img.lorigin); putP(o, OPo_screenrmin, img.R.min); v.output <-= (o, nil); } # is the image a font? if (img.font != nil) { f := img.font; i := array [1+4+4+1] of byte; i[0] = byte 'i'; put4(i, OPi_fontid, vid); put4(i, OPi_nchars, len f.chars); put1(i, OPi_ascent, f.ascent); v.output <-= (i, nil); for (index := 0; index < len f.chars; index++) { ch := f.chars[index]; if (ch == nil) continue; l := array [1+4+4+2+(4*4)+(2*4)+1+1] of byte; l[0] = byte 'l'; put4(l, OPl_fontid, vid); put4(l, OPl_srcid, v.getimg(ch.srcid)); put2(l, OPl_index, index); putR(l, OPl_R, ch.R); putP(l, OPl_P, ch.P); put1(l, OPl_left, ch.left); put1(l, OPl_width, ch.width); v.output <-= (l, nil); } } # if 'dirty' then writepixels if (img.dirty) v.copyimg(img, vid); return vid; } Viewer.copyimg(v : self ref Viewer, img : ref Image, id : int) { dx := img.R.max.x - img.R.min.x; dy := img.R.max.y - img.R.min.y; srcR := Rect (img.lorigin, (img.lorigin.x + dx, img.lorigin.y + dy)); bpl := bytesperline(srcR, img.chans); rlen : con 1+4+(4*4); ystep := (Sys->ATOMICIO - rlen)/ bpl; minx := srcR.min.x; maxx := srcR.max.x; maxy := srcR.max.y; chanconv := 0; if (!drawchans.eq(v.dchans) && v.chanmap.lookup(img.id) != -1) chanconv = 1; for (y := img.lorigin.y; y < maxy; y += ystep) { if (y + ystep > maxy) ystep = (maxy - y); R := Draw->Rect((minx, y), (maxx, y+ystep)); r := array [rlen] of byte; r[0] = byte 'r'; put4(r, OPr_id, img.id); putR(r, OPr_R, R); if (sys->write(drawfd, r, len r) != len r) break; nb := bpl * ystep; ymsg := array [1+4+(4*4)+nb] of byte; ymsg[0] = byte 'y'; # put4(ymsg, OPy_id, id); putR(ymsg, OPy_R, R); n := sys->read(drawfd, ymsg[OPy_data:], nb); if (n != nb) break; if (chanconv) v.chanconv(img, id, R, ymsg); else { put4(ymsg, OPy_id, id); v.output <-= (ymsg, nil); } } } Viewer.chanconv(v: self ref Viewer, img: ref Image, id: int, r: Rect, ymsg: array of byte) { # check origin matches and enough space in conversion image if (!(img.lorigin.eq(v.tmpR.min) && r.inrect(v.tmpR))) { # create new tmp image if (v.tmpid != 0) { f := array [1+4] of byte; f[0] = byte 'f'; put4(f, OPf_id, v.tmpid); v.output <-= (f, nil); } v.tmpR = Rect((0,0), (img.R.dx(), img.R.dy())).addpt(img.lorigin); v.tmpid = ++v.imageid; b := array [1+4+4+1+4+1+(4*4)+(4*4)+4] of byte; b[0] = byte 'b'; put4(b, OPb_id, v.tmpid); put4(b, OPb_screenid, 0); put1(b, OPb_refresh, 0); put4(b, OPb_chans, drawchans.desc); put1(b, OPb_repl, 0); putR(b, OPb_R, v.tmpR); putR(b, OPb_clipR, v.tmpR); put4(b, OPb_rrggbbaa, Draw->Nofill); v.output <-= (b, nil); } # writepixels to conversion image put4(ymsg, OPy_id, v.tmpid); v.output <-= (ymsg, nil); # ensure that drawop is Draw->S if (drawop != Draw->S) { O := array [1+1] of byte; O[0] = byte 'O'; put1(O, OPO_op, Draw->S); v.output <-= (O, nil); } # blit across to real target d := array [1+4+4+4+(4*4)+(2*4)+(2*4)] of byte; d[0] = byte 'd'; put4(d, OPd_dstid, id); put4(d, OPd_srcid, v.tmpid); put4(d, OPd_maskid, v.whiteid); putR(d, OPd_R, r); putP(d, OPd_P0, r.min); putP(d, OPd_P1, r.min); v.output <-= (d, nil); # restore drawop if necessary if (drawop != Draw->S) { O := array [1+1] of byte; O[0] = byte 'O'; put1(O, OPO_op, drawop); v.output <-= (O, nil); } } # returns (rid, map) # rid == remote screen id # map indicates that chan mapping is required for windows on this screen Viewer.getscr(v : self ref Viewer, localid, winid : int) : (int, int) { remid := v.scrmap.lookup(localid); if (remid != -1) { if (drawchans.eq(v.dchans)) return (remid, 0); scr := screens.lookup(localid); if (v.chanmap.lookup(scr.imageid) == -1) return (remid, 0); return (remid, 1); } scr := screens.lookup(localid); imgid := v.getimg(scr.imageid); fillid := v.getimg(scr.fillid); A := array [1+4+4+4+1] of byte; A[0] = byte 'A'; put4(A, OPA_imageid, imgid); put4(A, OPA_fillid, fillid); put1(A, OPA_public, 0); reply := chan of string; for (i := 0; i < 25; i++) { put4(A, OPA_id, ++v.screenid); v.output <-= (A, reply); if (<-reply != nil) continue; v.scrmap.add(localid, v.screenid); break; } # if i == 25 then we have a problem # ... if (i == 25) { # sys->print("failed to create remote screen\n"); return (0, 0); } # pre-construct the windows on this screen for (ix := len scr.windows -1; ix >=0; ix--) if (scr.windows[ix] != winid) v.getimg(scr.windows[ix]); if (drawchans.eq(v.dchans)) return (v.screenid, 0); if (v.chanmap.lookup(scr.imageid) == -1) return (v.screenid, 0); return (v.screenid, 1); }