void resize(void) { Rectangle old, r; int dxo, dyo, dxn, dyn; Win *w; old = screen->r; dxo = Dx(old); dyo = Dy(old); if(getwindow(display, Refnone) < 0) sysfatal("resize failed: %r"); dxn = Dx(screen->r); dyn = Dy(screen->r); freescreen(scr); scr = allocscreen(screen, display->white, 0); if(scr == nil) sysfatal("allocscreen: %r"); for(w = wlist.next; w != &wlist; w = w->next){ r = rectsubpt(w->entire, old.min); r.min.x = muldiv(r.min.x, dxn, dxo); r.max.x = muldiv(r.max.x, dxn, dxo); r.min.y = muldiv(r.min.y, dyn, dyo); r.max.y = muldiv(r.max.y, dyn, dyo); w->entire = rectaddpt(r, screen->r.min); w->inner = insetrect(w->entire, BORDSIZ); freeimage(w->im); w->im = allocwindow(scr, w->entire, Refbackup, 0); if(w->im == nil) sysfatal("allocwindow: %r"); draw(w->im, w->inner, w->tab->cols[BACK], nil, ZP); border(w->im, w->entire, BORDSIZ, w->tab->cols[w == actw ? BORD : DISB], ZP); w->tab->draw(w); } }

void grabmouse(void*) { int fd, x, y; char ibuf[256], obuf[256]; if(debug) return; fd = open("/dev/mouse", ORDWR); if(fd < 0) error("can't open /dev/mouse: %r"); snprint(obuf, sizeof obuf, "m %d %d", screen->r.min.x + Dx(screen->r)/2, screen->r.min.y + Dy(screen->r)/2); while(read(fd, ibuf, sizeof ibuf) > 0){ ibuf[12] = 0; ibuf[24] = 0; x = atoi(ibuf+1); y = atoi(ibuf+13); if(x != screen->r.min.x + Dx(screen->r)/2 || y != screen->r.min.y + Dy(screen->r)/2){ fprint(fd, "%s", obuf); doblank = 1; } } }

Point pix2board(int x, int y) { float d, rx, ry, yh; int ny, nx; /* XXX: float→int causes small rounding errors */ d = (float)(Dx(screen->r) > Dy(screen->r)) ? Dy(screen->r) -20: Dx(screen->r)-20; rx = d/(float)SzX; rx = rx/2.0; ry =d/(float)SzY; ry = ry/2.0; yh = ry/3.73205082; /* reverse board2pix() */ ny = (int)(((float)y - ry)/(2*ry - ((y>2*ry)?yh:0.0)) + 0.5); /* ny = (y - ry)/(2ry-yh) */ nx = (int)(((float)x - rx - (ny%2?rx:0.0))/(rx*2.0) + 0.5); /* nx = (x - rx - rx)/2rx */ if (nx >= SzX) nx = SzX-1; if (ny >=SzY) ny = SzY-1; return Pt(nx, ny); }

void rowresize(Row *row, Rectangle r) { int i, dx, odx; Rectangle r1, r2; Column *c; dx = Dx(r); odx = Dx(row->r); row->r = r; r1 = r; r1.max.y = r1.min.y + font->height; textresize(&row->tag, screen, r1); r1.min.y = r1.max.y; r1.max.y += Border; draw(screen, r1, display->black, nil, ZP); r.min.y = r1.max.y; r1 = r; r1.max.x = r1.min.x; for(i=0; i<row->ncol; i++){ c = row->col[i]; r1.min.x = r1.max.x; if(i == row->ncol-1) r1.max.x = r.max.x; else r1.max.x = r1.min.x+Dx(c->r)*dx/odx; if(i > 0){ r2 = r1; r2.max.x = r2.min.x+Border; draw(screen, r2, display->black, nil, ZP); r1.min.x = r2.max.x; } colresize(c, r1); } }

void tkcvsrectdraw(Image *img, TkCitem *i, TkEnv *pe) { int lw, rw; TkEnv *e; TkCrect *r; Rectangle d, rr; Point tr, bl; Image *pen; USED(pe); d.min = i->p.drawpt[0]; d.max = i->p.drawpt[1]; e = i->env; r = TKobj(TkCrect, i); pen = nil; if((e->set & (1<<TkCfill))) pen = tkgc(e, TkCfill); if(pen != nil) draw(img, d, pen, r->stipple, d.min); tr.x = d.max.x; tr.y = d.min.y; bl.x = d.min.x; bl.y = d.max.y; rw = (TKF2I(r->width) + 1)/2; if(rw <= 0) return; lw = (TKF2I(r->width))/2; pen = tkgc(e, TkCforegnd); if(pen != nil) { /* horizontal lines first */ rr.min.x = d.min.x - lw; rr.max.x = d.max.x + rw; rr.min.y = d.min.y - lw; rr.max.y = d.min.y + rw; draw(img, rr, pen, nil, rr.min); rr.min.y += Dy(d); rr.max.y += Dy(d); draw(img, rr, pen, nil, rr.min); /* now the vertical */ /* horizontal lines first */ rr.min.x = d.min.x - lw; rr.max.x = d.min.x + rw; rr.min.y = d.min.y + rw; rr.max.y = d.max.y - lw; draw(img, rr, pen, nil, rr.min); rr.min.x += Dx(d); rr.max.x += Dx(d); draw(img, rr, pen, nil, rr.min); } }

/* * A draw operation that touches only the area contained in bot but not in top. * mp and sp get aligned with bot.min. */ static void gendrawdiff(Image *dst, Rectangle bot, Rectangle top, Image *src, Point sp, Image *mask, Point mp, int op) { Rectangle r; Point origin; Point delta; USED(op); if(Dx(bot)*Dy(bot) == 0) return; /* no points in bot - top */ if(rectinrect(bot, top)) return; /* bot - top ≡ bot */ if(Dx(top)*Dy(top)==0 || rectXrect(bot, top)==0){ gendrawop(dst, bot, src, sp, mask, mp, op); return; } origin = bot.min; /* split bot into rectangles that don't intersect top */ /* left side */ if(bot.min.x < top.min.x){ r = Rect(bot.min.x, bot.min.y, top.min.x, bot.max.y); delta = subpt(r.min, origin); gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op); bot.min.x = top.min.x; } /* right side */ if(bot.max.x > top.max.x){ r = Rect(top.max.x, bot.min.y, bot.max.x, bot.max.y); delta = subpt(r.min, origin); gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op); bot.max.x = top.max.x; } /* top */ if(bot.min.y < top.min.y){ r = Rect(bot.min.x, bot.min.y, bot.max.x, top.min.y); delta = subpt(r.min, origin); gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op); bot.min.y = top.min.y; } /* bottom */ if(bot.max.y > top.max.y){ r = Rect(bot.min.x, top.max.y, bot.max.x, bot.max.y); delta = subpt(r.min, origin); gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op); bot.max.y = top.max.y; } }

void redraw(Image *screen) { Rectangle r = Rect(0,0,Dx(screen->r), Dy(screen->r)); catoffs.x=(Dx(r)-CATWID)/2; catoffs.y=(Dy(r)-CATHGT)/2; if(!ptinrect(catoffs, r)) fprint(2, "catclock: window too small, resize!\n"); xredraw=1; }

static int mga4xxscroll(VGAscr *scr, Rectangle dr, Rectangle sr) { uchar * mga; int pitch; int width, height; ulong start, end, sgn; Point sp, dp; if(scr->mmio == 0) return 0; mga = (uchar*)scr->mmio; assert(Dx(sr) == Dx(dr) && Dy(sr) == Dy(dr)); sp = sr.min; dp = dr.min; if(eqpt(sp, dp)) return 1; pitch = Dx(scr->gscreen->r); width = Dx(sr); height = Dy(sr); sgn = 0; if(dp.y > sp.y && dp.y < sp.y + height){ sp.y += height - 1; dp.y += height - 1; sgn |= SGN_UP; } width--; start = end = sp.x + (sp.y * pitch); if(dp.x > sp.x && dp.x < sp.x + width){ start += width; sgn |= SGN_LEFT; } else end += width; mga_fifo(mga, 8); mgawrite32(mga, DWGCTL, 0); mgawrite32(mga, SGN, sgn); mgawrite32(mga, AR5, sgn & SGN_UP ? -pitch : pitch); mgawrite32(mga, AR0, end); mgawrite32(mga, AR3, start); mgawrite32(mga, FXBNDRY, ((dp.x + width) << 16) | dp.x); mgawrite32(mga, YDSTLEN, (dp.y << 16) | height); mgawrite32(mga, DWGCTL + GO, DWG_BITBLT | DWG_SHIFTZERO | DWG_BFCOL | DWG_REPLACE); while(mgaread32(mga, STATUS) & 0x00010000) ; return 1; }

void drawnowin(int i) { Rectangle r; r = Rect(0,0,(Dx(screen->r)-2*MARGIN+PAD)/cols-PAD, font->height); r = rectaddpt(rectaddpt(r, Pt(MARGIN+(PAD+Dx(r))*(i/rows), MARGIN+(PAD+Dy(r))*(i%rows))), screen->r.min); draw(screen, insetrect(r, -1), lightblue, nil, ZP); }

void resize(void) { int fd, size = (Dx(screen->r) > Dy(screen->r)) ? Dy(screen->r) + 20 : Dx(screen->r)+20; fd = open("/dev/wctl", OWRITE); if(fd >= 0){ fprint(fd, "resize -dx %d -dy %d", size, size); close(fd); } }

void drawbar(void) { int i, j; int p; char buf[400], bar[200]; static char lastbar[200]; if(n > d || n < 0 || d <= 0) return; i = (Dx(rbar)*n)/d; p = (n*100LL)/d; if(textmode){ if(Dx(rbar) > 150){ rbar.min.x = 0; rbar.max.x = 150; return; } bar[0] = '|'; for(j=0; j<i; j++) bar[j+1] = '#'; for(; j<Dx(rbar); j++) bar[j+1] = '-'; bar[j++] = '|'; bar[j++] = ' '; sprint(bar+j, "%3d%% ", p); for(i=0; bar[i]==lastbar[i] && bar[i]; i++) ; memset(buf, '\b', strlen(lastbar)-i); strcpy(buf+strlen(lastbar)-i, bar+i); if(buf[0]) write(1, buf, strlen(buf)); strcpy(lastbar, bar); return; } if(lastp == p && last == i) return; if(lastp != p){ sprint(buf, "%d%%", p); stringbg(screen, addpt(screen->r.min, Pt(Dx(rbar)-30, 4)), text, ZP, display->defaultfont, buf, light, ZP); lastp = p; } if(last != i){ draw(screen, Rect(rbar.min.x+last, rbar.min.y, rbar.min.x+i, rbar.max.y), dark, nil, ZP); last = i; } flushimage(display, 1); }

Column* rowadd(Row *row, Column *c, int x) { Rectangle r, r1; Column *d; int i; d = nil; r = row->r; r.min.y = row->tag.r.max.y+Border; if(x<r.min.x && row->ncol>0){ /*steal 40% of last column by default */ d = row->col[row->ncol-1]; x = d->r.min.x + 3*Dx(d->r)/5; } /* look for column we'll land on */ for(i=0; i<row->ncol; i++){ d = row->col[i]; if(x < d->r.max.x) break; } if(row->ncol > 0){ if(i < row->ncol) i++; /* new column will go after d */ r = d->r; if(Dx(r) < 100) return nil; draw(screen, r, display->white, nil, ZP); r1 = r; r1.max.x = min(x, r.max.x-50); if(Dx(r1) < 50) r1.max.x = r1.min.x+50; colresize(d, r1); r1.min.x = r1.max.x; r1.max.x = r1.min.x+Border; draw(screen, r1, display->black, nil, ZP); r.min.x = r1.max.x; } if(c == nil){ c = emalloc(sizeof(Column)); colinit(c, r); incref(&reffont); }else colresize(c, r); c->row = row; c->tag.row = row; row->col = realloc(row->col, (row->ncol+1)*sizeof(Column*)); memmove(row->col+i+1, row->col+i, (row->ncol-i)*sizeof(Column*)); row->col[i] = c; row->ncol++; clearmouse(); return c; }

static void boxboxresize(Group *g, Rectangle r) { int rows, cols, ht, wid, i, hpad, wpad; Rectangle rr; if(debug) fprint(2, "boxboxresize %q %R (%d×%d) min/max %R separation %d\n", g->name, r, Dx(r), Dy(r), g->size, g->separation); ht = 0; for(i=0; i<g->nkids; i++){ if (g->kids[i]->size.min.y > ht) ht = g->kids[i]->size.min.y; } if (ht == 0) ctlerror("boxboxresize: height"); rows = Dy(r) / (ht+g->separation); hpad = (Dy(r) % (ht+g->separation)) / g->nkids; cols = (g->nkids+rows-1)/rows; wid = Dx(r) / cols - g->separation; for(i=0; i<g->nkids; i++){ if (g->kids[i]->size.max.x < wid) wid = g->kids[i]->size.max.x; } for(i=0; i<g->nkids; i++){ if (g->kids[i]->size.min.x > wid) wid = g->kids[i]->size.min.x; } if (wid > Dx(r) / cols) ctlerror("can't fit controls in boxbox"); wpad = (Dx(r) % (wid+g->separation)) / g->nkids; rr = rectaddpt(Rect(0,0,wid, ht), addpt(r.min, Pt(g->separation/2, g->separation/2))); if(debug) fprint(2, "boxboxresize rows %d, cols %d, wid %d, ht %d, wpad %d, hpad %d\n", rows, cols, wid, ht, wpad, hpad); for(i=0; i<g->nkids; i++){ if(debug) fprint(2, " %d %q: %R (%d×%d)\n", i, g->kids[i]->name, rr, Dx(rr), Dy(rr)); _ctlprint(g->kids[i], "rect %R", rectaddpt(rr, Pt((wpad+wid+g->separation)*(i/rows), (hpad+ht+g->separation)*(i%rows)))); } g->nseparators = rows + cols - 2; g->separators = realloc(g->separators, g->nseparators*sizeof(Rectangle)); rr = r; rr.max.y = rr.min.y + g->separation+hpad; for (i = 1; i < rows; i++){ g->separators[i-1] = rectaddpt(rr, Pt(0, (hpad+ht+g->separation)*i-g->separation-hpad)); if(debug) fprint(2, "row separation %d [%d]: %R\n", i, i-1, rectaddpt(rr, Pt(0, (hpad+ht+g->separation)*i-g->separation))); } rr = r; rr.max.x = rr.min.x + g->separation+wpad; for (i = 1; i < cols; i++){ g->separators[i+rows-2] = rectaddpt(rr, Pt((wpad+wid+g->separation)*i-g->separation-wpad, 0)); if(debug) fprint(2, "col separation %d [%d]: %R\n", i, i+rows-2, rectaddpt(rr, Pt((wpad+wid+g->separation)*i-g->separation, 0))); } }

void geometry(void) { int i, rows; Rectangle r; rows = (Dy(screen->r)-2*MARGIN+PAD)/(font->height+PAD); r = Rect(0,0,(Dx(screen->r)-2*MARGIN), font->height); for(i=0; i<nmap; i++) map[i].r = rectaddpt(rectaddpt(r, Pt(MARGIN+(PAD+Dx(r))*(i/rows), MARGIN+(PAD+Dy(r))*(i%rows))), screen->r.min); }

int sub_image (imageptr iptr, regionptr rptr, imageptr *optr) { int nx,ny,nz, nx1,ny1,nz1, ix,iy,iz, ix0,iy0,iz0; size_t np, np1; nx = Nx(iptr); ny = Ny(iptr); nz = Nz(iptr); np = nx*ny*nz; /* grab the bounding box */ ix0 = BLC(rptr)[0]; iy0 = BLC(rptr)[1]; iz0 = BLC(rptr)[2]; nx1 = TRC(rptr)[0] - ix0; ny1 = TRC(rptr)[1] - iy0; nz1 = TRC(rptr)[2] - iz0; np1 = nx1*ny1*nz1; *optr = (imageptr ) allocate(sizeof(image)); dprintf (DLEV,"copy_image:Allocated image @ %d size=%d * %d * %d",*optr,nx1,ny1,nz1); Frame(*optr) = (real *) allocate(np1*sizeof(real)); dprintf (DLEV,"Frame allocated @ %d ",Frame(*optr)); Nx(*optr) = nx1; Ny(*optr) = ny1; Nz(*optr) = nz1; Xmin(*optr) = Xmin(iptr) + ix0*Dx(iptr); Ymin(*optr) = Ymin(iptr) + iy0*Dy(iptr); Zmin(*optr) = Zmin(iptr) + iz0*Dz(iptr); Dx(*optr) = Dx(iptr); Dy(*optr) = Dy(iptr); Dz(*optr) = Dz(iptr); Namex(*optr) = mystrcpy(Namex(iptr)); Namey(*optr) = mystrcpy(Namey(iptr)); Namez(*optr) = mystrcpy(Namez(iptr)); Xref(*optr) = Xref(iptr) + ix0; Yref(*optr) = Yref(iptr) + iy0; Zref(*optr) = Zref(iptr) + iz0; for (iz=0; iz<nz1; iz++) for (iy=0; iy<ny1; iy++) for (ix=0; ix<nx1; ix++) CubeValue(*optr,ix,iy,iz) = CubeValue(iptr,ix-ix0,iy-iy0,iz-iy0); Storage(*optr) = matdef[idef]; Axis(*optr) = Axis(iptr); set_iarray(*optr); return 1; /* succes return code */ }

void textredraw(Text *t, Rectangle r, Font *f, Image *b, int odx) { int maxt; Rectangle rr; frinit(t, r, f, b, t->Frame.cols); rr = t->r; rr.min.x -= Scrollwid+Scrollgap; /* back fill to scroll bar */ draw(t->b, rr, t->cols[BACK], nil, ZP); /* use no wider than 3-space tabs in a directory */ maxt = maxtab; if(t->what == Body){ if(t->w->isdir) maxt = min(TABDIR, maxtab); else maxt = t->tabstop; } t->maxtab = maxt*stringwidth(f, "0"); if(t->what==Body && t->w->isdir && odx!=Dx(t->all)){ if(t->maxlines > 0){ textreset(t); textcolumnate(t, t->w->dlp, t->w->ndl); textshow(t, 0, 0, 1); } }else{ textfill(t); textsetselect(t, t->q0, t->q1); } }

nemo_main() { int n = 0; setparams(); /* set globals */ instr = stropen (infile, "r"); plinit ("***", 0.0, 20.0, 0.0, 20.0); /* init yapp */ while (read_image(instr,&iptr)) { /* loop while more images found */ dprintf(1,"Time= %g MinMax= %g %g\n",Time(iptr),MapMin(iptr),MapMax(iptr)); nx=Nx(iptr); ny=Ny(iptr); nz=Nz(iptr); if (nz > 1) error("Cannot handle 3D images [%d,%d,%d]",nx,ny,nz); xmin=Xmin(iptr); ymin=Ymin(iptr); dx=Dx(iptr); dy=Dy(iptr); xsize = nx * dx; ysize = ny * dy; if (n>0) { sleep(1); plframe(); } plot_map(); /* plot the map */ n++; } plstop(); /* end of yapp */ strclose(instr); }

void tkcvssh(Tk *tk) { int top, bot, width; TkCanvas *c = TKobj(TkCanvas, tk); char val[Tkminitem], cmd[Tkmaxitem], *v, *e; if(c->xscroll == nil) return; top = 0; bot = TKI2F(1); width = Dx(c->region); if(width != 0) { top = TKI2F(c->view.x)/width; bot = TKI2F(c->view.x+tk->act.width)/width; } v = tkfprint(val, top); *v++ = ' '; tkfprint(v, bot); snprint(cmd, sizeof(cmd), "%s %s", c->xscroll, val); e = tkexec(tk->env->top, cmd, nil); if ((e != nil) && (tk->name != nil)) print("tk: xscrollcommand \"%s\": %s\n", tk->name->name, e); }

// constructive heuristics for orthogonal representation OR void LongestPathCompaction::constructiveHeuristics( PlanRep &PG, OrthoRep &OR, const RoutingChannel<int> &rc, GridLayoutMapped &drawing) { OGDF_ASSERT(OR.isOrientated()); // x-coordinates of vertical segments CompactionConstraintGraph<int> Dx(OR, PG, odEast, rc.separation()); Dx.insertVertexSizeArcs(PG, drawing.width(), rc); NodeArray<int> xDx(Dx.getGraph(), 0); computeCoords(Dx, xDx); // y-coordinates of horizontal segments CompactionConstraintGraph<int> Dy(OR, PG, odNorth, rc.separation()); Dy.insertVertexSizeArcs(PG, drawing.height(), rc); NodeArray<int> yDy(Dy.getGraph(), 0); computeCoords(Dy, yDy); // final coordinates of vertices for(node v : PG.nodes) { drawing.x(v) = xDx[Dx.pathNodeOf(v)]; drawing.y(v) = yDy[Dy.pathNodeOf(v)]; } }

/* * GCs are all for same screen, and depth is either 1 or screen depth. * Return a GC for the depth of b, with values as specified by gcv. * * Also, set (or unset) the clip rectangle if necessary. * (This implementation should be improved if setting a clip rectangle is not rare). */ GC _getgc(Bitmap *b, uint64_t gcvm, XGCValues *pgcv) { static GC gc0, gcn; static bool clipset = false; GC g; XRectangle xr; g = (b->ldepth==0)? gc0 : gcn; if(!g){ g = XCreateGC(_dpy, (Drawable)b->id, gcvm, pgcv); if(b->ldepth==0) gc0 = g; else gcn = g; } else XChangeGC(_dpy, g, gcvm, pgcv); if(b->flag&CLIP){ xr.x = b->clipr.min.x; xr.y = b->clipr.min.y; xr.width = Dx(b->clipr); xr.height = Dy(b->clipr); if(b->flag&SHIFT){ xr.x -= b->r.min.x; xr.y -= b->r.min.y; } XSetClipRectangles(_dpy, g, 0, 0, &xr, 1, YXBanded); clipset = true; }else if(clipset){ pgcv->clip_mask = None; XChangeGC(_dpy, g, GCClipMask, pgcv); clipset = false; } return g; }

void showpage(int page, Menu *m) { if(doc->fwdonly) m->lasthit = 0; /* this page */ else m->lasthit = reverse ? doc->npage-1-page : page; esetcursor(&reading); delayfreeimage(nil); im = cachedpage(doc, angle, page); if(im == nil) wexits(0); if(resizing) resize(Dx(im->r), Dy(im->r)); esetcursor(nil); if(showbottom){ ul.y = screen->r.max.y - Dy(im->r); showbottom = 0; } redraw(screen); flushimage(display, 1); }

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); }

void ini_matrix(imageptr *iptr, int nx, int ny) { int ix,iy; printf ("iptr @ %d (sizeof = %d)\n",*iptr,sizeof(image)); if (*iptr==0) { *iptr = (imageptr ) allocate((sizeof(image))); printf ("allocated image 'iptr' @ %d\n",*iptr); Frame(*iptr) = (real *) allocate (nx*ny*sizeof(real)); printf ("Allocated frame @ %d\n",Frame(*iptr)); } else { printf ("Image already allocated @ %d\n",*iptr); printf ("with Frame @ %d\n",Frame(*iptr)); } Nx(*iptr) = nx; Ny(*iptr) = ny; Nz(*iptr) = 1; Xmin(*iptr) = 1.0; Ymin(*iptr) = 2.0; Zmin(*iptr) = 3.0; Dx(*iptr) = 0.1; Dy(*iptr) = 0.1; Dz(*iptr) = 0.1; Namex(*iptr) = NULL; /* no axis names */ Namey(*iptr) = NULL; Namez(*iptr) = NULL; Unit(*iptr) = NULL; /* no units */ Mask(*iptr) = NULL; set_iarray(*iptr); for (ix=0; ix<nx; ix++) for (iy=0; iy<ny; iy++) MapValue(*iptr,ix,iy) = (ix*ny+iy)*0.1; }

int textresize(Text *t, Rectangle r, int keepextra) { int odx; if(Dy(r) <= 0) r.max.y = r.min.y; else if(!keepextra) r.max.y -= Dy(r)%t->fr.font->height; odx = Dx(t->all); t->all = r; t->scrollr = r; t->scrollr.max.x = r.min.x+Scrollwid; t->lastsr = nullrect; r.min.x += Scrollwid+Scrollgap; frclear(&t->fr, 0); textredraw(t, r, t->fr.font, t->fr.b, odx); if(keepextra && t->fr.r.max.y < t->all.max.y && !t->fr.noredraw){ /* draw background in bottom fringe of window */ r.min.x -= Scrollgap; r.min.y = t->fr.r.max.y; r.max.y = t->all.max.y; draw(screen, r, t->fr.cols[BACK], nil, ZP); } return t->all.max.y; }

int movemouse(void) { mouse.xy = Pt(rboard.min.x + Dx(rboard)/2, rboard.min.y +Dy(rboard)/2); moveto(mousectl, mouse.xy); return mouse.xy.x; }

static int Rfmt(Fmt *f) { Rectangle r; r = va_arg(f->args, Rectangle); return fmtprint(f, "%P+%dx%d", r.min, Dx(r), Dy(r)); }

void nemo_main () { setparams(); /* set par's in globals */ instr = stropen (infile, "r"); read_image (instr,&iptr); /* set some global paramters */ nx = Nx(iptr); ny = Ny(iptr); nz = Nz(iptr); xmin = Xmin(iptr); ymin = Ymin(iptr); zmin = Zmin(iptr); dx = Dx(iptr); dy = Dy(iptr); dz = Dz(iptr); if(hasvalue("gauss")) make_gauss_beam(getparam("dir")); outstr = stropen (outfile,"w"); if (hasvalue("wiener")) wiener(); else smooth_it(); write_image (outstr,iptr); strclose(instr); strclose(outstr); }

/* make socket name from scriptname, switching / for _ */ static char * MakeSockName(char * scriptname ) { char * sockname; char * save; /* strict C compilers can't/won't do char foo[variant]; */ char *fullpath = my_malloc(path_max); int i = 0; if (realpath(scriptname, fullpath) == NULL) { perror("pperl: resolving full pathname to script failed"); exit(1); } Dx(Debug("realpath returned: %s\n", fullpath)); /* Ugh. I am a terrible C programmer! */ sockname = my_malloc(strlen(P_tmpdir) + strlen(fullpath) + 3); save = sockname; sprintf(sockname, "%s/", P_tmpdir); sockname += strlen(P_tmpdir) + 1; while (fullpath[i] != '\0') { if (fullpath[i] == '/') { *sockname = '_'; } else if (fullpath[i] == '.') { *sockname = '_'; } else { *sockname = fullpath[i]; } sockname++; i++; } *sockname = '\0'; free(fullpath); return save; }

static void renderchilds(Page *p) { Rectangle r; Kidinfo *k; Page *c; int i, j, x, y, *w, *h; draw(p->b, p->all, display->white, nil, ZP); r = p->all; y = r.min.y; c = p->child; k = p->kidinfo; frdims(k->rows, k->nrows, Dy(r), &h); frdims(k->cols, k->ncols, Dx(r), &w); for(i=0; i<k->nrows; i++){ x = r.min.x; for(j=0; j<k->ncols; j++){ if(c->aborting) return; c->b = p->b; c->all = Rect(x,y,x+w[j],y+h[i]); c->w = p->w; pagerender(c); c = c->next; x += w[j]; } y += h[i]; } free(w); free(h); }

void reshapewin(Window *w, Rectangle r) { assert(w->type == WWindow); assert(Dx(r) > 0 && Dy(r) > 0); /* Rather than an X error. */ configwin(w, r, w->border); }