sys/src/cmd/gview.c

   1 #include        <u.h>
   2 #include        <libc.h>
   3 #include        <ctype.h>
   4 #include        <draw.h>
   5 #include        <event.h>
   6 #include        <cursor.h>
   7 #include        <stdio.h>
   8
   9 #define Never   0xffffffff      /* Maximum ulong */
  10 #define LOG2  0.301029995664
  11 #define Button_bit(b)   (1 << ((b)-1))
  12
  13 enum {
  14         But1    = Button_bit(1),/* mouse buttons for events */
  15         But2    = Button_bit(2),
  16         But3    = Button_bit(3),
  17 };
  18 int cantmv = 1;                 /* disallow rotate and move? 0..1 */
  19 int plotdots;                   /* plot dots instead of lines */
  20 int top_border, bot_border, lft_border, rt_border;
  21 int lft_border0;                /* lft_border for y-axis labels >0 */
  22 int top_left, top_right;        /* edges of top line free space */
  23 int Mv_delay = 400;             /* msec for button click vs. button hold down */
  24 int Dotrad = 2;                 /* dot radius in pixels */
  25 int framewd=1;                  /* line thickness for frame (pixels) */
  26 int framesep=1;                 /* distance between frame and surrounding text */
  27 int outersep=1;                 /* distance: surrounding text to screen edge */
  28 Point sdigit;                   /* size of a digit in the font */
  29 Point smaxch;                   /* assume any character in font fits in this */
  30 double underscan = .05;         /* fraction of frame initially unused per side */
  31 double fuzz = 6;                /* selection tolerance in pixels */
  32 int tick_len = 15;              /* length of axis label tick mark in pixels */
  33 FILE* logfil = 0;               /* dump selected points here if nonzero */
  34
  35 #define labdigs  3              /* allow this many sig digits in axis labels */
  36 #define digs10pow 1000          /* pow(10,labdigs) */
  37 #define axis_color  clr_im(DLtblue)
  38
  39
  40
  41
  42 /********************************* Utilities  *********************************/
  43
  44 /* Prepend string s to null-terminated string in n-byte buffer buf[], truncating if
  45    necessary and using a space to separate s from the rest of buf[].
  46 */
  47 char* str_insert(char* buf, char* s, int n)
  48 {
  49         int blen, slen = strlen(s) + 1;
  50         if (slen >= n)
  51                 {strncpy(buf,s,n); buf[n-1]='\0'; return buf;}
  52         blen = strlen(buf);
  53         if (blen >= n-slen)
  54                 buf[blen=n-slen-1] = '\0';
  55         memmove(buf+slen, buf, slen+blen+1);
  56         memcpy(buf, s, slen-1);
  57         buf[slen-1] = ' ';
  58         return buf;
  59 }
  60
  61 /* Alter string smain (without lengthening it) so as to remove the first occurrence of
  62    ssub, assuming ssub is ASCII.  Return nonzero (true) if string smain had to be changed.
  63    In spite of the ASCII-centric appearance, I think this can handle UTF in smain.
  64 */
  65 int remove_substr(char* smain, char* ssub)
  66 {
  67         char *ss, *s = strstr(smain, ssub);
  68         int n = strlen(ssub);
  69         if (s==0)
  70                 return 0;
  71         if (islower(s[n]))
  72                 s[0] ^= 32;                     /* probably tolower(s[0]) or toupper(s[0]) */
  73         else {
  74                 for (ss=s+n; *ss!=0; s++, ss++)
  75                         *s = *ss;
  76                 *s = '\0';
  77         }
  78         return 1;
  79 }
  80
  81 void adjust_border(Font* f)
  82 {
  83         int sep = framesep + outersep;
  84         sdigit = stringsize(f, "8");
  85         smaxch = stringsize(f, "MMMg");
  86         smaxch.x = (smaxch.x + 3)/4;
  87         lft_border0 = (1+labdigs)*sdigit.x + framewd + sep;
  88         rt_border = (lft_border0 - sep)/2 + outersep;
  89         bot_border = sdigit.y + framewd + sep;
  90         top_border = smaxch.y + framewd + sep;
  91         lft_border = lft_border0;               /* this gets reset later */
  92 }
  93
  94
  95 int is_off_screen(Point p)
  96 {
  97         const Rectangle* r = &(screen->r);
  98         return p.x-r->min.x<lft_border || r->max.x-p.x<rt_border
  99                 || p.y-r->min.y<=top_border || r->max.y-p.y<=bot_border;
 100 }
 101
 102
 103 Cursor  bullseye =
 104 {
 105         {-7, -7},
 106         {
 107                 0x1F, 0xF8, 0x3F, 0xFC, 0x7F, 0xFE, 0xFB, 0xDF,
 108                 0xF3, 0xCF, 0xE3, 0xC7, 0xFF, 0xFF, 0xFF, 0xFF,
 109                 0xFF, 0xFF, 0xFF, 0xFF, 0xE3, 0xC7, 0xF3, 0xCF,
 110                 0x7B, 0xDF, 0x7F, 0xFE, 0x3F, 0xFC, 0x1F, 0xF8,
 111         },
 112         {
 113                 0x00, 0x00, 0x0F, 0xF0, 0x31, 0x8C, 0x21, 0x84,
 114                 0x41, 0x82, 0x41, 0x82, 0x41, 0x82, 0x7F, 0xFE,
 115                 0x7F, 0xFE, 0x41, 0x82, 0x41, 0x82, 0x41, 0x82,
 116                 0x21, 0x84, 0x31, 0x8C, 0x0F, 0xF0, 0x00, 0x00,
 117         }
 118 };
 119
 120 /* Wait for a mouse click and return 0 for failue if not button but (curs can be 0) */
 121 int get_1click(int but, Mouse* m, Cursor* curs)
 122 {
 123         if (curs)
 124                 esetcursor(curs);
 125         while (m->buttons==0)
 126                 *m = emouse();
 127         if (curs)
 128                 esetcursor(0);
 129         return (m->buttons==Button_bit(but));
 130 }
 131
 132
 133 /* Wait for a mouse click or keyboard event from the string of expected characters.  Return
 134    the character code or -1 for a button-but mouse event or 0 for wrong button.
 135 */
 136 int get_click_or_kbd(int but, Mouse* m, const char* expected)
 137 {
 138         Event ev;
 139         ulong expbits[4], ty;
 140         expbits[0] = expbits[1] = expbits[2] = expbits[3];
 141         for (; *expected!=0; expected++)
 142                 expbits[((*expected)>>5)&3] |= 1 << (*expected&31);
 143         do ty = eread(Emouse|Ekeyboard, &ev);
 144         while ((ty&Emouse) ? ev.mouse.buttons==0
 145                 : (ev.kbdc&~127) || !(expbits[(ev.kbdc>>5)&3] & (1<<(ev.kbdc&31))) );
 146         if (ty&Ekeyboard)
 147                 return ev.kbdc;
 148         *m = ev.mouse;
 149         return (ev.mouse.buttons==Button_bit(but)) ? -1 : 0;
 150 }
 151
 152
 153 /* Wait until but goes up or until a mouse event's msec passes tlimit.
 154    Return a boolean result that tells whether the button went up.
 155 */
 156 int lift_button(int but, Mouse* m, int tlimit)
 157 {
 158         do {    *m = emouse();
 159                 if (m->msec >= tlimit)
 160                         return 0;
 161         } while (m->buttons & Button_bit(but));
 162         return 1;
 163 }
 164
 165
 166 /* Set *m to the last pending mouse event, or the first one where but is up.
 167    If no mouse events are pending, wait for the next one.
 168 */
 169 void latest_mouse(int but, Mouse* m)
 170 {
 171         int bbit = Button_bit(but);
 172         do {    *m = emouse();
 173         } while ((m->buttons & bbit) && ecanmouse());
 174 }
 175
 176
 177
 178 /*********************************** Colors ***********************************/
 179
 180 enum {  DOrange=0xffaa00FF, Dgray=0xbbbbbbFF, DDkgreen=0x009900FF,
 181         DDkred=0xcc0000FF, DViolet=0x990099FF, DDkyellow=0xaaaa00FF,
 182         DLtblue=0xaaaaffFF, DPink=0xffaaaaFF,
 183         /* ndraw.h sets DBlack, DBlue, DRed, DYellow, DGreen,
 184                 DCyan, DMagenta, DWhite */
 185 };
 186
 187
 188 typedef struct thick_color {
 189         int thick;                      /* use 1+2*thick pixel wide lines */
 190         Image* clr;                     /* Color to use when drawing this */
 191 } thick_color;
 192
 193
 194 typedef struct color_ref {
 195         ulong c;                        /* RGBA pixel color */
 196         char* nam;                      /* ASCII name (matched to input, used in output)*/
 197         int nam1;                       /* single-letter version of color name */
 198         Image* im;                      /* replicated solid-color image */
 199 } color_ref;
 200
 201 color_ref clrtab[] = {
 202         DRed,           "Red",          'R', 0,
 203         DPink,          "Pink",         'P', 0,
 204         DDkred,         "Dkred",        'r', 0,
 205         DOrange,        "Orange",       'O', 0,
 206         DYellow,        "Yellow",       'Y', 0,
 207         DDkyellow,      "Dkyellow",     'y', 0,
 208         DGreen,         "Green",        'G', 0,
 209         DDkgreen,       "Dkgreen",      'g', 0,
 210         DCyan,          "Cyan",         'C', 0,
 211         DBlue,          "Blue",         'B', 0,
 212         DLtblue,        "Ltblue",       'b', 0,
 213         DMagenta,       "Magenta",      'M', 0,
 214         DViolet,        "Violet",       'V', 0,
 215         Dgray,          "Gray",         'A', 0,
 216         DBlack,         "Black",        'K', 0,
 217         DWhite,         "White",        'W', 0,
 218         DNofill,        0,              0,   0  /* DNofill means "end of data" */
 219 };
 220
 221 short nam1_idx[128];                    /* the clrtab[] index for each nam1, else -1 */
 222
 223
 224 void  init_clrtab(void)
 225 {
 226         int i;
 227         Rectangle r = Rect(0,0,1,1);
 228         memset(&nam1_idx[0], -1, sizeof(nam1_idx));
 229         for (i=0; clrtab[i].c!=DNofill; i++) {
 230                 clrtab[i].im = allocimage(display, r, CMAP8, 1, clrtab[i].c);
 231                 /* should check for 0 result? */
 232                 nam1_idx[clrtab[i].nam1] = i;
 233         }
 234 }
 235
 236
 237 int clrim_id(Image* clr)
 238 {
 239         int i;
 240         for (i=0; clrtab[i].im!=clr; i++)
 241                 if (clrtab[i].c==DNofill)
 242                         exits("bad image color");
 243         return i;
 244 }
 245
 246 int clr_id(int clr)
 247 {
 248         int i;
 249         for (i=0; clrtab[i].c!=clr; i++)
 250                 if (clrtab[i].c==DNofill)
 251                         exits("bad color");
 252         return i;
 253 }
 254
 255
 256 #define clr_im(clr)     clrtab[clr_id(clr)].im
 257 #define is_Multi  -2                    /* dummy clrtab[] less than -1 */
 258
 259
 260 thick_color* tc_default(thick_color *buf)
 261 {
 262         buf[0].thick = 1;
 263         buf[1].clr = clr_im(DBlack);
 264         buf[1].thick = 0;
 265         return buf;
 266 }
 267
 268
 269 /* Return an allocated array that describes the color letters (clrtab[].nam1 values,
 270    optionally prefixed by 'T') in the string that starts at c0 and ends just before
 271    fin.  The first entry is a dummy whose thick field tells how many data entries follow.
 272    If buf!=0, it should point to an array of length 2 that is to hold the output
 273    (truncated to a dummy and one data entry).  The error indication is 1 data entry
 274    of default color and thickness; e.g., "Multi(xxbadxx)" in a label prevents gview
 275    from recognizing anything that follows.
 276 */
 277 thick_color* parse_color_chars(const char* c0, const char* fin, thick_color *buf)
 278 {
 279         thick_color* tc;                /* Pending return value */
 280         int i, j, n=fin-c0;             /* n is an upper bound on how many data members */
 281         const char* c;
 282         for (c=c0; c<fin-1; c++)
 283                 if (*c=='T')
 284                         n--;
 285         if (buf==0)
 286                 tc = (thick_color*) malloc((n+1)*sizeof(thick_color));
 287         else {tc=buf; n=1;}
 288         i = 0;
 289         for (c=c0; c<fin && i<n; c++) {
 290                 tc[++i].thick = 0;
 291                 if (*c=='T')
 292                         if (++c==fin)
 293                                 return tc_default(tc);
 294                         else tc[i].thick=1;
 295                 j = (*c&~127) ? -1 : nam1_idx[*c];
 296                 if (j < 0)
 297                         return tc_default(tc);
 298                 tc[i].clr = clrtab[j].im;
 299         }
 300         tc[0].thick = i;
 301         return tc;
 302 }
 303
 304
 305 /* Decide what color and thickness to use for a polyline based on the label it has in the
 306    input file.  The winner is whichever color name comes first, or otherwise black; and
 307    thickness is determined by the presence of "Thick" in the string.  Place the result
 308    in *r1 and return 0 unless a Multi(...) spec is found, in which case the result is
 309    an allocated array of alternative color and thickness values.  A nonzero idxdest
 310    requests the clrtab[] index in *idxdest and no allocated array.
 311 */
 312 thick_color* nam2thclr(const char* nam, thick_color *r1, int *idxdest)
 313 {
 314         char *c, *cbest=0, *rp=0;
 315         int i, ibest=-1;
 316         thick_color* tc = 0;
 317         thick_color buf[2];
 318         if (*nam!=0) {
 319                 c = strstr(nam, "Multi(");
 320                 if (c!=0 && (rp=strchr(c+6,')'))!=0)
 321                         {ibest=is_Multi; cbest=c;}
 322                 for (i=0; clrtab[i].nam!=0; i++) {
 323                         c = strstr(nam,clrtab[i].nam);
 324                         if (c!=0 && (ibest==-1 || c<cbest))
 325                                 {ibest=i; cbest=c;}
 326                 }
 327         }
 328         if (ibest==is_Multi) {
 329                 tc = parse_color_chars(cbest+6, rp, (idxdest==0 ? 0 : &buf[0]));
 330                 ibest = clrim_id(tc[1].clr);
 331         }
 332         if (idxdest!=0)
 333                 *idxdest = (ibest<0) ? clr_id(DBlack) : ibest;
 334         r1->clr = (ibest<0) ? clr_im(DBlack) : clrtab[ibest].im;
 335         r1->thick = (tc!=0) ? tc[1].thick : (strstr(nam,"Thick")==0 ? 0 : 1);
 336         return tc;
 337 }
 338
 339
 340 /* Alter string nam so that nam2thick() and nam2clr() agree with *tc, using
 341    buf[] (a buffer of length bufn) to store the result if it differs from nam.
 342    We go to great pains to perform this alteration in a manner that will seem natural
 343    to the user, i.e., we try removing a suitably isolated color name before inserting
 344    a new one.
 345 */
 346 char* nam_with_thclr(char* nam, const thick_color *tc, char* buf, int bufn)
 347 {
 348         thick_color c0;
 349         int clr0i;
 350         nam2thclr(nam, &c0, &clr0i);
 351         char *clr0s;
 352         if (c0.thick==tc->thick && c0.clr==tc->clr)
 353                 return nam;
 354         clr0s = clrtab[clr0i].nam;
 355         if (strlen(nam)<bufn) strcpy(buf,nam);
 356         else {strncpy(buf,nam,bufn); buf[bufn-1]='\0';}
 357         if (c0.clr != tc->clr)
 358                 remove_substr(buf, clr0s);
 359         if (c0.thick > tc->thick)
 360                 while (remove_substr(buf, "Thick"))
 361                         /* do nothing */;
 362         nam2thclr(nam, &c0, &clr0i);
 363         if (c0.clr != tc->clr)
 364                 str_insert(buf, clrtab[clrim_id(tc->clr)].nam, bufn);
 365         if (c0.thick < tc->thick)
 366                 str_insert(buf, "Thick", bufn);
 367         return buf;
 368 }
 369
 370
 371
 372 /****************************** Data structures  ******************************/
 373
 374 Image* mv_bkgd;                         /* Background image (usually 0) */
 375
 376 typedef struct fpoint {
 377         double x, y;
 378 } fpoint;
 379
 380 typedef struct frectangle {
 381         fpoint min, max;
 382 } frectangle;
 383
 384 frectangle empty_frect = {1e30, 1e30, -1e30, -1e30};
 385
 386
 387 /* When *r2 is transformed by y=y-x*slant, might it intersect *r1 ?
 388 */
 389 int fintersects(const frectangle* r1, const frectangle* r2, double slant)
 390 {
 391         double x2min=r2->min.x, x2max=r2->max.x;
 392         if (r1->max.x <= x2min || x2max <= r1->min.x)
 393                 return 0;
 394         if (slant >=0)
 395                 {x2min*=slant; x2max*=slant;}
 396         else    {double t=x2min*slant; x2min=x2max*slant; x2max=t;}
 397         return r1->max.y > r2->min.y-x2max && r2->max.y-x2min > r1->min.y;
 398 }
 399
 400 int fcontains(const frectangle* r, fpoint p)
 401 {
 402         return r->min.x <=p.x && p.x<= r->max.x && r->min.y <=p.y && p.y<= r->max.y;
 403 }
 404
 405
 406 void grow_bb(frectangle* dest, const frectangle* r)
 407 {
 408         if (r->min.x < dest->min.x) dest->min.x=r->min.x;
 409         if (r->min.y < dest->min.y) dest->min.y=r->min.y;
 410         if (r->max.x > dest->max.x) dest->max.x=r->max.x;
 411         if (r->max.y > dest->max.y) dest->max.y=r->max.y;
 412 }
 413
 414
 415 void slant_frect(frectangle *r, double sl)
 416 {
 417         r->min.y += sl*r->min.x;
 418         r->max.y += sl*r->max.x;
 419 }
 420
 421
 422 fpoint fcenter(const frectangle* r)
 423 {
 424         fpoint c;
 425         c.x = .5*(r->max.x + r->min.x);
 426         c.y = .5*(r->max.y + r->min.y);
 427         return c;
 428 }
 429
 430
 431 typedef struct fpolygon {
 432         fpoint* p;                      /* a malloc'ed array */
 433         int n;                          /* p[] has n elements: p[0..n] */
 434         frectangle bb;                  /* bounding box */
 435         char* nam;                      /* name of this polygon (malloc'ed) */
 436         thick_color c;                  /* the current color and line thickness */
 437         thick_color* ct;                /* 0 or malloc'ed color schemes, ct[1..ct->thick] */
 438         struct fpolygon* link;
 439 } fpolygon;
 440
 441 typedef struct fpolygons {
 442         fpolygon* p;                    /* the head of a linked list */
 443         frectangle bb;                  /* overall bounding box */
 444         frectangle disp;                /* part being mapped onto screen->r */
 445         double slant_ht;                /* controls how disp is slanted */
 446 } fpolygons;
 447
 448
 449 fpolygons univ = {                      /* everything there is to display */
 450         0,
 451         1e30, 1e30, -1e30, -1e30,
 452         0, 0, 0, 0,
 453         2*1e30
 454 };
 455
 456
 457 void free_fp_etc(fpolygon* fp)
 458 {
 459         if (fp->ct != 0)
 460                 free(fp->ct);
 461         free(fp->p);
 462         free(fp);
 463 }
 464
 465
 466 void set_default_clrs(fpolygons* fps, fpolygon* fpstop)
 467 {
 468         fpolygon* fp;
 469         for (fp=fps->p; fp!=0 && fp!=fpstop; fp=fp->link)
 470                 fp->ct = nam2thclr(fp->nam, &fp->c, 0);
 471 }
 472
 473
 474 void fps_invert(fpolygons* fps)
 475 {
 476         fpolygon *p, *r=0;
 477         for (p=fps->p; p!=0;) {
 478                 fpolygon* q = p;
 479                 p = p->link;
 480                 q->link = r;
 481                 r = q;
 482         }
 483         fps->p = r;
 484 }
 485
 486
 487 void fp_remove(fpolygons* fps, fpolygon* fp)
 488 {
 489         fpolygon *q, **p = &fps->p;
 490         while (*p!=fp)
 491                 if (*p==0)
 492                         return;
 493                 else    p = &(*p)->link;
 494         *p = fp->link;
 495         fps->bb = empty_frect;
 496         for (q=fps->p; q!=0; q=q->link)
 497                 grow_bb(&fps->bb, &q->bb);
 498 }
 499
 500
 501 /* The transform maps abstract fpoint coordinates (the ones used in the input)
 502    to the current screen coordinates.  The do_untransform() macros reverses this.
 503    If univ.slant_ht is not the height of univ.disp, the actual region in the
 504    abstract coordinates is a parallelogram inscribed in univ.disp with two
 505    vertical edges and two slanted slanted edges: slant_ht>0 means that the
 506    vertical edges have height slant_ht and the parallelogram touches the lower
 507    left and upper right corners of univ.disp; slant_ht<0 refers to a parallelogram
 508    of height -slant_ht that touches the other two corners of univ.disp.
 509    NOTE: the ytransform macro assumes that tr->sl times the x coordinate has
 510    already been subtracted from yy.
 511 */
 512 typedef struct transform {
 513         double sl;
 514         fpoint o, sc;           /* (x,y):->(o.x+sc.x*x, o.y+sc.y*y+sl*x) */
 515 } transform;
 516
 517 #define do_transform(d,tr,s)    ((d)->x = (tr)->o.x + (tr)->sc.x*(s)->x,  \
 518                                 (d)->y = (tr)->o.y + (tr)->sc.y*(s)->y    \
 519                                         + (tr)->sl*(s)->x)
 520 #define do_untransform(d,tr,s)  ((d)->x = (.5+(s)->x-(tr)->o.x)/(tr)->sc.x,    \
 521                                 (d)->y = (.5+(s)->y-(tr)->sl*(d)->x-(tr)->o.y) \
 522                                         /(tr)->sc.y)
 523 #define xtransform(tr,xx)       ((tr)->o.x + (tr)->sc.x*(xx))
 524 #define ytransform(tr,yy)       ((tr)->o.y + (tr)->sc.y*(yy))
 525 #define dxuntransform(tr,xx)    ((xx)/(tr)->sc.x)
 526 #define dyuntransform(tr,yy)    ((yy)/(tr)->sc.y)
 527
 528
 529 transform cur_trans(void)
 530 {
 531         transform t;
 532         Rectangle d = screen->r;
 533         const frectangle* s = &univ.disp;
 534         double sh = univ.slant_ht;
 535         d.min.x += lft_border;
 536         d.min.y += top_border;
 537         d.max.x -= rt_border;
 538         d.max.y -= bot_border;
 539         t.sc.x = (d.max.x - d.min.x)/(s->max.x - s->min.x);
 540         t.sc.y = -(d.max.y - d.min.y)/fabs(sh);
 541         if (sh > 0) {
 542                 t.sl = -t.sc.y*(s->max.y-s->min.y-sh)/(s->max.x - s->min.x);
 543                 t.o.y = d.min.y - t.sc.y*s->max.y - t.sl*s->max.x;
 544         } else {
 545                 t.sl = t.sc.y*(s->max.y-s->min.y+sh)/(s->max.x - s->min.x);
 546                 t.o.y = d.min.y - t.sc.y*s->max.y - t.sl*s->min.x;
 547         }
 548         t.o.x = d.min.x - t.sc.x*s->min.x;
 549         return t;
 550 }
 551
 552
 553 double u_slant_amt(fpolygons *u)
 554 {
 555         double sh=u->slant_ht, dy=u->disp.max.y - u->disp.min.y;
 556         double dx = u->disp.max.x - u->disp.min.x;
 557         return (sh>0) ? (dy-sh)/dx : -(dy+sh)/dx;
 558 }
 559
 560
 561 /* Set *y0 and *y1 to the lower and upper bounds of the set of y-sl*x values that
 562    *u says to display, where sl is the amount of slant.
 563 */
 564 double set_unslanted_y(fpolygons *u, double *y0, double *y1)
 565 {
 566         double yy1, sl=u_slant_amt(u);
 567         if (u->slant_ht > 0) {
 568                 *y0 = u->disp.min.y - sl*u->disp.min.x;
 569                 yy1 = *y0 + u->slant_ht;
 570         } else {
 571                 yy1 = u->disp.max.y - sl*u->disp.min.x;
 572                 *y0 = yy1 + u->slant_ht;
 573         }
 574         if (y1 != 0)
 575                 *y1 = yy1;
 576         return sl;
 577 }
 578
 579
 580
 581
 582 /*************************** The region to display ****************************/
 583
 584 void nontrivial_interval(double *lo, double *hi)
 585 {
 586         if (*lo >= *hi) {
 587                 double mid = .5*(*lo + *hi);
 588                 double tweak = 1e-6 + 1e-6*fabs(mid);
 589                 *lo = mid - tweak;
 590                 *hi = mid + tweak;
 591         }
 592 }
 593
 594
 595 void init_disp(void)
 596 {
 597         double dw = (univ.bb.max.x - univ.bb.min.x)*underscan;
 598         double dh = (univ.bb.max.y - univ.bb.min.y)*underscan;
 599         univ.disp.min.x = univ.bb.min.x - dw;
 600         univ.disp.min.y = univ.bb.min.y - dh;
 601         univ.disp.max.x = univ.bb.max.x + dw;
 602         univ.disp.max.y = univ.bb.max.y + dh;
 603         nontrivial_interval(&univ.disp.min.x, &univ.disp.max.x);
 604         nontrivial_interval(&univ.disp.min.y, &univ.disp.max.y);
 605         univ.slant_ht = univ.disp.max.y - univ.disp.min.y;      /* means no slant */
 606 }
 607
 608
 609 void recenter_disp(Point c)
 610 {
 611         transform tr = cur_trans();
 612         fpoint cc, off;
 613         do_untransform(&cc, &tr, &c);
 614         off.x = cc.x - .5*(univ.disp.min.x + univ.disp.max.x);
 615         off.y = cc.y - .5*(univ.disp.min.y + univ.disp.max.y);
 616         univ.disp.min.x += off.x;
 617         univ.disp.min.y += off.y;
 618         univ.disp.max.x += off.x;
 619         univ.disp.max.y += off.y;
 620 }
 621
 622
 623 /* Find the upper-left and lower-right corners of the bounding box of the
 624    parallelogram formed by untransforming the rectangle rminx, rminy, ... (given
 625    in screen coordinates), and return the height of the parallelogram (negated
 626    if it slopes downward).
 627 */
 628 double untransform_corners(double rminx, double rminy, double rmaxx, double rmaxy,
 629                 fpoint *ul, fpoint *lr)
 630 {
 631         fpoint r_ur, r_ul, r_ll, r_lr;  /* corners of the given recangle */
 632         fpoint ur, ll;                  /* untransformed versions of r_ur, r_ll */
 633         transform tr = cur_trans();
 634         double ht;
 635         r_ur.x=rmaxx;  r_ur.y=rminy;
 636         r_ul.x=rminx;  r_ul.y=rminy;
 637         r_ll.x=rminx;  r_ll.y=rmaxy;
 638         r_lr.x=rmaxx;  r_lr.y=rmaxy;
 639         do_untransform(ul, &tr, &r_ul);
 640         do_untransform(lr, &tr, &r_lr);
 641         do_untransform(&ur, &tr, &r_ur);
 642         do_untransform(&ll, &tr, &r_ll);
 643         ht = ur.y - lr->y;
 644         if (ll.x < ul->x)
 645                 ul->x = ll.x;
 646         if (ur.y > ul->y)
 647                 ul->y = ur.y;
 648         else    ht = -ht;
 649         if (ur.x > lr->x)
 650                 lr->x = ur.x;
 651         if (ll.y < lr->y)
 652                 lr->y = ll.y;
 653         return ht;
 654 }
 655
 656
 657 void disp_dozoom(double rminx, double rminy, double rmaxx, double rmaxy)
 658 {
 659         fpoint ul, lr;
 660         double sh = untransform_corners(rminx, rminy, rmaxx, rmaxy, &ul, &lr);
 661         if (ul.x==lr.x || ul.y==lr.y)
 662                 return;
 663         univ.slant_ht = sh;
 664         univ.disp.min.x = ul.x;
 665         univ.disp.max.y = ul.y;
 666         univ.disp.max.x = lr.x;
 667         univ.disp.min.y = lr.y;
 668         nontrivial_interval(&univ.disp.min.x, &univ.disp.max.x);
 669         nontrivial_interval(&univ.disp.min.y, &univ.disp.max.y);
 670 }
 671
 672
 673 void disp_zoomin(Rectangle r)
 674 {
 675         disp_dozoom(r.min.x, r.min.y, r.max.x, r.max.y);
 676 }
 677
 678
 679 void disp_zoomout(Rectangle r)
 680 {
 681         double qminx, qminy, qmaxx, qmaxy;
 682         double scx, scy;
 683         Rectangle s = screen->r;
 684         if (r.min.x==r.max.x || r.min.y==r.max.y)
 685                 return;
 686         s.min.x += lft_border;
 687         s.min.y += top_border;
 688         s.max.x -= rt_border;
 689         s.max.y -= bot_border;
 690         scx = (s.max.x - s.min.x)/(r.max.x - r.min.x);
 691         scy = (s.max.y - s.min.y)/(r.max.y - r.min.y);
 692         qminx = s.min.x + scx*(s.min.x - r.min.x);
 693         qmaxx = s.max.x + scx*(s.max.x - r.max.x);
 694         qminy = s.min.y + scy*(s.min.y - r.min.y);
 695         qmaxy = s.max.y + scy*(s.max.y - r.max.y);
 696         disp_dozoom(qminx, qminy, qmaxx, qmaxy);
 697 }
 698
 699
 700 void expand2(double* a, double* b, double f)
 701 {
 702         double mid = .5*(*a + *b);
 703         *a = mid + f*(*a - mid);
 704         *b = mid + f*(*b - mid);
 705 }
 706
 707 void disp_squareup(void)
 708 {
 709         double dx = univ.disp.max.x - univ.disp.min.x;
 710         double dy = univ.disp.max.y - univ.disp.min.y;
 711         dx /= screen->r.max.x - lft_border - screen->r.min.x - rt_border;
 712         dy /= screen->r.max.y - bot_border - screen->r.min.y - top_border;
 713         if (dx > dy)
 714                 expand2(&univ.disp.min.y, &univ.disp.max.y, dx/dy);
 715         else    expand2(&univ.disp.min.x, &univ.disp.max.x, dy/dx);
 716         univ.slant_ht = univ.disp.max.y - univ.disp.min.y;
 717 }
 718
 719
 720 /* Slant so that p and q appear at the same height on the screen and the
 721    screen contains the smallest possible superset of what its previous contents.
 722 */
 723 void slant_disp(fpoint p, fpoint q)
 724 {
 725         double yll, ylr, yul, yur;      /* corner y coords of displayed parallelogram */
 726         double sh, dy;
 727         if (p.x == q.x)
 728                 return;
 729         sh = univ.slant_ht;
 730         if (sh > 0) {
 731                 yll=yul=univ.disp.min.y;  yul+=sh;
 732                 ylr=yur=univ.disp.max.y;  ylr-=sh;
 733         } else {
 734                 yll=yul=univ.disp.max.y;  yll+=sh;
 735                 ylr=yur=univ.disp.min.y;  yur-=sh;
 736         }
 737         dy = (univ.disp.max.x-univ.disp.min.x)*(q.y - p.y)/(q.x - p.x);
 738         dy -= ylr - yll;
 739         if (dy > 0)
 740                 {yll-=dy; yur+=dy;}
 741         else    {yul-=dy; ylr+=dy;}
 742         if (ylr > yll) {
 743                 univ.disp.min.y = yll;
 744                 univ.disp.max.y = yur;
 745                 univ.slant_ht = yur - ylr;
 746         } else {
 747                 univ.disp.max.y = yul;
 748                 univ.disp.min.y = ylr;
 749                 univ.slant_ht = ylr - yur;
 750         }
 751 }
 752
 753
 754
 755
 756 /******************************** Ascii input  ********************************/
 757
 758 void set_fbb(fpolygon* fp)
 759 {
 760         fpoint lo=fp->p[0], hi=fp->p[0];
 761         const fpoint *q, *qtop;
 762         for (qtop=(q=fp->p)+fp->n; ++q<=qtop;) {
 763                 if (q->x < lo.x) lo.x=q->x;
 764                 if (q->y < lo.y) lo.y=q->y;
 765                 if (q->x > hi.x) hi.x=q->x;
 766                 if (q->y > hi.y) hi.y=q->y;
 767         }
 768         fp->bb.min = lo;
 769         fp->bb.max = hi;
 770 }
 771
 772 char* mystrdup(char* s)
 773 {
 774         char *r, *t = strrchr(s,'"');
 775         if (t==0) {
 776                 t = s + strlen(s);
 777                 while (t>s && (t[-1]=='\n' || t[-1]=='\r'))
 778                         t--;
 779         }
 780         r = malloc(1+(t-s));
 781         memcpy(r, s, t-s);
 782         r[t-s] = 0;
 783         return r;
 784 }
 785
 786 int is_valid_label(char* lab)
 787 {
 788         char* t;
 789         if (lab[0]=='"')
 790                 return (t=strrchr(lab,'"'))!=0 && t!=lab && strspn(t+1," \t\r\n")==strlen(t+1);
 791         return strcspn(lab," \t")==strlen(lab);
 792 }
 793
 794 /* Read a polyline and update the number of lines read.  A zero result indicates bad
 795    syntax if *lineno increases; otherwise it indicates end of file.
 796 */
 797 fpolygon* rd_fpoly(FILE* fin, int *lineno)
 798 {
 799         char buf[4096], junk[2];
 800         fpoint q;
 801         fpolygon* fp;
 802         int allocn;
 803         if (!fgets(buf,4096,fin))
 804                 return 0;
 805         (*lineno)++;
 806         if (sscanf(buf,"%lg%lg%1s",&q.x,&q.y,junk) != 2)
 807                 return 0;
 808         fp = malloc(sizeof(fpolygon));
 809         allocn = 4;
 810         fp->p = malloc(allocn*sizeof(fpoint));
 811         fp->p[0] = q;
 812         fp->n = 0;
 813         fp->nam = "";
 814         fp->c.thick = 0;
 815         fp->c.clr = clr_im(DBlack);
 816         fp->ct = 0;
 817         while (fgets(buf,4096,fin)) {
 818                 (*lineno)++;
 819                 if (sscanf(buf,"%lg%lg%1s",&q.x,&q.y,junk) != 2) {
 820                         if (!is_valid_label(buf))
 821                                 {free_fp_etc(fp); return 0;}
 822                         fp->nam = (buf[0]=='"') ? buf+1 : buf;
 823                         break;
 824                 }
 825                 if (++(fp->n) == allocn)
 826                         fp->p = realloc(fp->p, (allocn<<=1)*sizeof(fpoint));
 827                 fp->p[fp->n] = q;
 828         }
 829         fp->nam = mystrdup(fp->nam);
 830         set_fbb(fp);
 831         fp->link = 0;
 832         return fp;
 833 }
 834
 835
 836 /* Read input into *fps and return 0 or a line number where there's a syntax error */
 837 int rd_fpolys(FILE* fin, fpolygons* fps)
 838 {
 839         fpolygon *fp, *fp0=fps->p;
 840         int lineno=0, ok_upto=0;
 841         while ((fp=rd_fpoly(fin,&lineno)) != 0) {
 842                 ok_upto = lineno;
 843                 fp->link = fps->p;
 844                 fps->p = fp;
 845                 grow_bb(&fps->bb, &fp->bb);
 846         }
 847         set_default_clrs(fps, fp0);
 848         return (ok_upto==lineno) ? 0 : lineno;
 849 }
 850
 851
 852 /* Read input from file fnam and return an error line no., -1 for "can't open"
 853    or 0 for success.
 854 */
 855 int doinput(char* fnam)
 856 {
 857         FILE* fin = strcmp(fnam,"-")==0 ? stdin : fopen(fnam, "r");
 858         int errline_or0;
 859         if (fin==0)
 860                 return -1;
 861         errline_or0 = rd_fpolys(fin, &univ);
 862         fclose(fin);
 863         return errline_or0;
 864 }
 865
 866
 867
 868 /******************************** Ascii output ********************************/
 869
 870 fpolygon* fp_reverse(fpolygon* fp)
 871 {
 872         fpolygon* r = 0;
 873         while (fp!=0) {
 874                 fpolygon* q = fp->link;
 875                 fp->link = r;
 876                 r = fp;
 877                 fp = q;
 878         }
 879         return r;
 880 }
 881
 882 void wr_fpoly(FILE* fout, const fpolygon* fp)
 883 {
 884         char buf[256];
 885         int i;
 886         for (i=0; i<=fp->n; i++)
 887                 fprintf(fout,"%.12g\t%.12g\n", fp->p[i].x, fp->p[i].y);
 888         fprintf(fout,"\"%s\"\n", nam_with_thclr(fp->nam, &fp->c, buf, 256));
 889 }
 890
 891 void wr_fpolys(FILE* fout, fpolygons* fps)
 892 {
 893         fpolygon* fp;
 894         fps->p = fp_reverse(fps->p);
 895         for (fp=fps->p; fp!=0; fp=fp->link)
 896                 wr_fpoly(fout, fp);
 897         fps->p = fp_reverse(fps->p);
 898 }
 899
 900
 901 int dooutput(char* fnam)
 902 {
 903         FILE* fout = fopen(fnam, "w");
 904         if (fout==0)
 905                 return 0;
 906         wr_fpolys(fout, &univ);
 907         fclose(fout);
 908         return 1;
 909 }
 910
 911
 912
 913
 914 /************************ Clipping to screen rectangle ************************/
 915
 916 /* Find the t values, 0<=t<=1 for which x0+t*(x1-x0) is between xlo and xhi,
 917    or return 0 to indicate no such t values exist.  If returning 1, set *t0 and
 918    *t1 to delimit the t interval.
 919 */
 920 int do_xory(double x0, double x1, double xlo, double xhi, double* t0, double* t1)
 921 {
 922         *t1 = 1.0;
 923         if (x0<xlo) {
 924                 if (x1<xlo) return 0;
 925                 *t0 = (xlo-x0)/(x1-x0);
 926                 if (x1>xhi) *t1 = (xhi-x0)/(x1-x0);
 927         } else if (x0>xhi) {
 928                 if (x1>xhi) return 0;
 929                 *t0 = (xhi-x0)/(x1-x0);
 930                 if (x1<xlo) *t1 = (xlo-x0)/(x1-x0);
 931         } else {
 932                 *t0 = 0.0;
 933                 if (x1>xhi) *t1 = (xhi-x0)/(x1-x0);
 934                 else if (x1<xlo) *t1 = (xlo-x0)/(x1-x0);
 935                 else *t1 = 1.0;
 936         }
 937         return 1;
 938 }
 939
 940
 941 /* After mapping y to y-slope*x, what initial fraction of the *p to *q edge is
 942    outside of *r?  Note that the edge could start outside *r, pass through *r,
 943    and wind up outside again.
 944 */
 945 double frac_outside(const fpoint* p, const fpoint* q, const frectangle* r,
 946                 double slope)
 947 {
 948         double t0, t1, tt0, tt1;
 949         double px=p->x, qx=q->x;
 950         if (!do_xory(px, qx, r->min.x, r->max.x, &t0, &t1))
 951                 return 1;
 952         if (!do_xory(p->y-slope*px, q->y-slope*qx, r->min.y, r->max.y, &tt0, &tt1))
 953                 return 1;
 954         if (tt0 > t0)
 955                 t0 = tt0;
 956         if (t1<=t0 || tt1<=t0)
 957                 return 1;
 958         return t0;
 959 }
 960
 961
 962 /* Think of p0..pn as piecewise-linear function F(t) for t=0..pn-p0, and find
 963    the maximum tt such that F(0..tt) is all inside of r, assuming p0 is inside.
 964    Coordinates are transformed by y=y-x*slope before testing against r.
 965 */
 966 double in_length(const fpoint* p0, const fpoint* pn, frectangle r, double slope)
 967 {
 968         const fpoint* p = p0;
 969         double px, py;
 970         do if (++p > pn)
 971                 return pn - p0;
 972         while (r.min.x<=(px=p->x) && px<=r.max.x
 973                         && r.min.y<=(py=p->y-slope*px) && py<=r.max.y);
 974         return (p - p0) - frac_outside(p, p-1, &r, slope);
 975 }
 976
 977
 978 /* Think of p0..pn as piecewise-linear function F(t) for t=0..pn-p0, and find
 979    the maximum tt such that F(0..tt) is all outside of *r.  Coordinates are
 980    transformed by y=y-x*slope before testing against r.
 981 */
 982 double out_length(const fpoint* p0, const fpoint* pn, frectangle r, double slope)
 983 {
 984         const fpoint* p = p0;
 985         double fr;
 986         do {    if (p->x < r.min.x)
 987                         do if (++p>pn) return pn-p0;
 988                         while (p->x <= r.min.x);
 989                 else if (p->x > r.max.x)
 990                         do if (++p>pn) return pn-p0;
 991                         while (p->x >= r.max.x);
 992                 else if (p->y-slope*p->x < r.min.y)
 993                         do if (++p>pn) return pn-p0;
 994                         while (p->y-slope*p->x <= r.min.y);
 995                 else if (p->y-slope*p->x > r.max.y)
 996                         do if (++p>pn) return pn-p0;
 997                         while (p->y-slope*p->x >= r.max.y);
 998                 else return p - p0;
 999         } while ((fr=frac_outside(p-1,p,&r,slope)) == 1);
1000         return (p - p0) + fr-1;
1001 }
1002
1003
1004
1005 /*********************** Drawing frame and axis labels  ***********************/
1006
1007 #define Nthous  7
1008 #define Len_thous  30                   /* bound on strlen(thous_nam[i]) */
1009 char* thous_nam[Nthous] = {
1010         "one", "thousand", "million", "billion",
1011         "trillion", "quadrillion", "quintillion",
1012 };
1013
1014
1015 typedef struct lab_interval {
1016         double sep;                     /* separation between tick marks */
1017         double unit;            /* power of 1000 divisor */
1018         int logunit;            /* log base 1000 of of this divisor */
1019         double off;                     /* offset to subtract before dividing */
1020 } lab_interval;
1021
1022
1023 char* abbrev_num(double x, const lab_interval* iv)
1024 {
1025         static char buf[16];
1026         double dx = x - iv->off;
1027         dx = iv->sep * floor(dx/iv->sep + .5);
1028         sprintf(buf,"%g", dx/iv->unit);
1029         return buf;
1030 }
1031
1032
1033 double lead_digits(double n, double r)  /* n truncated to power of 10 above r */
1034 {
1035         double rr = pow(10, ceil(log10(r)));
1036         double nn = (n<rr) ? 0.0 : rr*floor(n/rr);
1037         if (n+r-nn >= digs10pow) {
1038                 rr /= 10;
1039                 nn = (n<rr) ? 0.0 : rr*floor(n/rr);
1040         }
1041         return nn;
1042 }
1043
1044
1045 lab_interval next_larger(double s0, double xlo, double xhi)
1046 {
1047         double nlo, nhi;
1048         lab_interval r;
1049         r.logunit = (int) floor(log10(s0) + LOG2);
1050         r.unit = pow(10, r.logunit);
1051         nlo = xlo/r.unit;
1052         nhi = xhi/r.unit;
1053         if (nhi >= digs10pow)
1054                 r.off = r.unit*lead_digits(nlo, nhi-nlo);
1055         else if (nlo <= -digs10pow)
1056                 r.off = -r.unit*lead_digits(-nhi, nhi-nlo);
1057         else    r.off = 0;
1058         r.sep = (s0<=r.unit) ? r.unit : (s0<2*r.unit ? 2*r.unit : 5*r.unit);
1059         switch (r.logunit%3) {
1060         case 1: r.unit*=.1; r.logunit--;
1061                 break;
1062         case -1: case 2:
1063                 r.unit*=10; r.logunit++;
1064                 break;
1065         case -2: r.unit*=100; r.logunit+=2;
1066         }
1067         r.logunit /= 3;
1068         return r;
1069 }
1070
1071
1072 double min_hsep(const transform* tr)
1073 {
1074         double s = (2+labdigs)*sdigit.x;
1075         double ss = (univ.disp.min.x<0) ? s+sdigit.x : s;
1076         return dxuntransform(tr, ss);
1077 }
1078
1079
1080 lab_interval mark_x_axis(const transform* tr)
1081 {
1082         fpoint p = univ.disp.min;
1083         Point q, qtop, qbot, tmp;
1084         double x0=univ.disp.min.x, x1=univ.disp.max.x;
1085         double seps0, nseps, seps;
1086         lab_interval iv = next_larger(min_hsep(tr), x0, x1);
1087         set_unslanted_y(&univ, &p.y, 0);
1088         q.y = ytransform(tr, p.y) + .5;
1089         qtop.y = q.y - tick_len;
1090         qbot.y = q.y + framewd + framesep;
1091         seps0 = ceil(x0/iv.sep);
1092         for (seps=0, nseps=floor(x1/iv.sep)-seps0; seps<=nseps; seps+=1) {
1093                 char* num = abbrev_num((p.x=iv.sep*(seps0+seps)), &iv);
1094                 Font* f = display->defaultfont;
1095                 q.x = qtop.x = qbot.x = xtransform(tr, p.x);
1096                 line(screen, qtop, q, Enddisc, Enddisc, 0, axis_color, q);
1097                 tmp = stringsize(f, num);
1098                 qbot.x -= tmp.x/2;
1099                 string(screen, qbot, display->black, qbot, f, num);
1100         }
1101         return iv;
1102 }
1103
1104
1105 lab_interval mark_y_axis(const transform* tr)
1106 {
1107         Font* f = display->defaultfont;
1108         fpoint p = univ.disp.min;
1109         Point q, qrt, qlft;
1110         double y0, y1, seps0, nseps, seps;
1111         lab_interval iv;
1112         set_unslanted_y(&univ, &y0, &y1);
1113         iv = next_larger(dyuntransform(tr,-f->height), y0, y1);
1114         q.x = xtransform(tr, p.x) - .5;
1115         qrt.x = q.x + tick_len;
1116         qlft.x = q.x - (framewd + framesep);
1117         seps0 = ceil(y0/iv.sep);
1118         for (seps=0, nseps=floor(y1/iv.sep)-seps0; seps<=nseps; seps+=1) {
1119                 char* num = abbrev_num((p.y=iv.sep*(seps0+seps)), &iv);
1120                 Point qq = stringsize(f, num);
1121                 q.y = qrt.y = qlft.y = ytransform(tr, p.y);
1122                 line(screen, qrt, q, Enddisc, Enddisc, 0, axis_color, q);
1123                 qq.x = qlft.x - qq.x;
1124                 qq.y = qlft.y - qq.y/2;
1125                 string(screen, qq, display->black, qq, f, num);
1126         }
1127         return iv;
1128 }
1129
1130
1131 void lab_iv_info(const lab_interval *iv, double slant, char* buf, int *n)
1132 {
1133         if (iv->off > 0)
1134                 (*n) += sprintf(buf+*n,"-%.12g",iv->off);
1135         else if (iv->off < 0)
1136                 (*n) += sprintf(buf+*n,"+%.12g",-iv->off);
1137         if (slant>0)
1138                 (*n) += sprintf(buf+*n,"-%.6gx", slant);
1139         else if (slant<0)
1140                 (*n) += sprintf(buf+*n,"+%.6gx", -slant);
1141         if (abs(iv->logunit) >= Nthous)
1142                 (*n) += sprintf(buf+*n," in 1e%d units", 3*iv->logunit);
1143         else if (iv->logunit > 0)
1144                 (*n) += sprintf(buf+*n," in %ss", thous_nam[iv->logunit]);
1145         else if (iv->logunit < 0)
1146                 (*n) += sprintf(buf+*n," in %sths", thous_nam[-iv->logunit]);
1147 }
1148
1149
1150 void draw_xy_ranges(const lab_interval *xiv, const lab_interval *yiv)
1151 {
1152         Point p;
1153         char buf[2*(19+Len_thous+8)+50];
1154         int bufn = 0;
1155         buf[bufn++] = 'x';
1156         lab_iv_info(xiv, 0, buf, &bufn);
1157         bufn += sprintf(buf+bufn, "; y");
1158         lab_iv_info(yiv, u_slant_amt(&univ), buf, &bufn);
1159         buf[bufn] = '\0';
1160         p = stringsize(display->defaultfont, buf);
1161         top_left = screen->r.min.x + lft_border;
1162         p.x = top_right = screen->r.max.x - rt_border - p.x;
1163         p.y = screen->r.min.y + outersep;
1164         string(screen, p, display->black, p, display->defaultfont, buf);
1165 }
1166
1167
1168 transform draw_frame(void)
1169 {
1170         lab_interval x_iv, y_iv;
1171         transform tr;
1172         Rectangle r = screen->r;
1173         lft_border = (univ.disp.min.y<0) ? lft_border0+sdigit.x : lft_border0;
1174         tr = cur_trans();
1175         r.min.x += lft_border;
1176         r.min.y += top_border;
1177         r.max.x -= rt_border;
1178         r.max.y -= bot_border;
1179         border(screen, r, -framewd, axis_color, r.min);
1180         x_iv = mark_x_axis(&tr);
1181         y_iv = mark_y_axis(&tr);
1182         draw_xy_ranges(&x_iv, &y_iv);
1183         return tr;
1184 }
1185
1186
1187
1188 /*************************** Finding the selection  ***************************/
1189
1190 typedef struct pt_on_fpoly {
1191         fpoint p;                       /* the point */
1192         fpolygon* fp;                   /* the fpolygon it lies on */
1193         double t;                       /* how many knots from the beginning */
1194 } pt_on_fpoly;
1195
1196
1197 static double myx, myy;
1198 #define mydist(p,o,sl,xwt,ywt)  (myx=(p).x-(o).x, myy=(p).y-sl*(p).x-(o).y,     \
1199                                         xwt*myx*myx + ywt*myy*myy)
1200
1201 /* At what fraction of the way from p0[0] to p0[1] is mydist(p,ctr,slant,xwt,ywt)
1202    minimized?
1203 */
1204 double closest_time(const fpoint* p0, const fpoint* ctr, double slant,
1205                 double xwt, double ywt)
1206 {
1207         double p00y=p0[0].y-slant*p0[0].x, p01y=p0[1].y-slant*p0[1].x;
1208         double dx=p0[1].x-p0[0].x, dy=p01y-p00y;
1209         double x0=p0[0].x-ctr->x, y0=p00y-ctr->y;
1210         double bot = xwt*dx*dx + ywt*dy*dy;
1211         if (bot==0)
1212                 return 0;
1213         return -(xwt*x0*dx + ywt*y0*dy)/bot;
1214 }
1215
1216
1217 /* Scan the polygonal path of length len knots starting at p0, and find the
1218    point that the transformation y=y-x*slant makes closest to the center of *r,
1219    where *r itself defines the distance metric.  Knots get higher priority than
1220    points between knots.  If psel->t is negative, always update *psel; otherwise
1221    update *psel only if the scan can improve it.  Return a boolean that says
1222    whether *psel was updated.
1223      Note that *r is a very tiny rectangle (tiny when converted screen pixels)
1224    such that anything in *r is considered close enough to match the mouse click.
1225    The purpose of this routine is to be careful in case there is a lot of hidden
1226    detail in the tiny rectangle *r.
1227 */
1228 int improve_pt(fpoint* p0, double len, const frectangle* r, double slant,
1229                 pt_on_fpoly* psel)
1230 {
1231         fpoint ctr = fcenter(r);
1232         double x_wt=2/(r->max.x-r->min.x), y_wt=2/(r->max.y-r->min.y);
1233         double xwt=x_wt*x_wt, ywt=y_wt*y_wt;
1234         double d, dbest = (psel->t <0) ? 1e30 : mydist(psel->p,ctr,slant,xwt,ywt);
1235         double tt, dbest0 = dbest;
1236         fpoint pp;
1237         int ilen = (int) len;
1238         if (len==0 || ilen>0) {
1239                 int i;
1240                 for (i=(len==0 ? 0 : 1); i<=ilen; i++) {
1241                         d = mydist(p0[i], ctr, slant, xwt, ywt);
1242                         if (d < dbest)
1243                                 {psel->p=p0[i]; psel->t=i; dbest=d;}
1244                 }
1245                 return (dbest < dbest0);
1246         }
1247         tt = closest_time(p0, &ctr, slant, xwt, ywt);
1248         if (tt > len)
1249                 tt = len;
1250         pp.x = p0[0].x + tt*(p0[1].x - p0[0].x);
1251         pp.y = p0[0].y + tt*(p0[1].y - p0[0].y);
1252         if (mydist(pp, ctr, slant, xwt, ywt) < dbest) {
1253                 psel->p = pp;
1254                 psel->t = tt;
1255                 return 1;
1256         }
1257         return 0;
1258 }
1259
1260
1261 /* Test *fp against *r after transforming by y=y-x*slope, and set *psel accordingly.
1262 */
1263 void select_in_fpoly(fpolygon* fp, const frectangle* r, double slant,
1264                 pt_on_fpoly* psel)
1265 {
1266         fpoint *p0=fp->p, *pn=fp->p+fp->n;
1267         double l1, l2;
1268         if (p0==pn)
1269                 {improve_pt(p0, 0, r, slant, psel); psel->fp=fp; return;}
1270         while ((l1=out_length(p0,pn,*r,slant)) < pn-p0) {
1271                 fpoint p0sav;
1272                 int i1 = (int) l1;
1273                 p0+=i1; l1-=i1;
1274                 p0sav = *p0;
1275                 p0[0].x += l1*(p0[1].x - p0[0].x);
1276                 p0[0].y += l1*(p0[1].y - p0[0].y);
1277                 l2 = in_length(p0, pn, *r, slant);
1278                 if (improve_pt(p0, l2, r, slant, psel)) {
1279                         if (l1==0 && psel->t!=((int) psel->t)) {
1280                                 psel->t = 0;
1281                                 psel->p = *p0;
1282                         } else if (psel->t < 1)
1283                                 psel->t += l1*(1 - psel->t);
1284                         psel->t += p0 - fp->p;
1285                         psel->fp = fp;
1286                 }
1287                 *p0 = p0sav;
1288                 p0 += (l2>0) ? ((int) ceil(l2)) : 1;
1289         }
1290 }
1291
1292
1293 /* Test all the fpolygons against *r after transforming by y=y-x*slope, and return
1294    the resulting selection, if any.
1295 */
1296 pt_on_fpoly* select_in_univ(const frectangle* r, double slant)
1297 {
1298         static pt_on_fpoly answ;
1299         fpolygon* fp;
1300         answ.t = -1;
1301         for (fp=univ.p; fp!=0; fp=fp->link)
1302                 if (fintersects(r, &fp->bb, slant))
1303                         select_in_fpoly(fp, r, slant, &answ);
1304         if (answ.t < 0)
1305                 return 0;
1306         return &answ;
1307 }
1308
1309
1310
1311 /**************************** Using the selection  ****************************/
1312
1313 pt_on_fpoly cur_sel;                    /* current selection if cur_sel.t>=0 */
1314 pt_on_fpoly prev_sel;                   /* previous selection if prev_sel.t>=0 (for slant) */
1315 Image* sel_bkg = 0;                     /* what's behind the red dot */
1316
1317
1318 void clear_txt(void)
1319 {
1320         Rectangle r;
1321         r.min = screen->r.min;
1322         r.min.x += lft_border;
1323         r.min.y += outersep;
1324         r.max.x = top_left;
1325         r.max.y = r.min.y + smaxch.y;
1326         draw(screen, r, display->white, display->opaque, r.min);
1327         top_left = r.min.x;
1328 }
1329
1330
1331 Rectangle sel_dot_box(const transform* tr)
1332 {
1333         Point ctr;
1334         Rectangle r;
1335         if (tr==0)
1336                 ctr.x = ctr.y = Dotrad;
1337         else    do_transform(&ctr, tr, &cur_sel.p);
1338         r.min.x=ctr.x-Dotrad;  r.max.x=ctr.x+Dotrad+1;
1339         r.min.y=ctr.y-Dotrad;  r.max.y=ctr.y+Dotrad+1;
1340         return r;
1341 }
1342
1343
1344 void unselect(const transform* tr)
1345 {
1346         transform tra;
1347         if (sel_bkg==0)
1348                 sel_bkg = allocimage(display, sel_dot_box(0), CMAP8, 0, DWhite);
1349         clear_txt();
1350         if (cur_sel.t < 0)
1351                 return;
1352         prev_sel = cur_sel;
1353         if (tr==0)
1354                 {tra=cur_trans(); tr=&tra;}
1355         draw(screen, sel_dot_box(tr), sel_bkg, display->opaque, ZP);
1356         cur_sel.t = -1;
1357 }
1358
1359
1360 /* Text at top right is written first and this low-level routine clobbers it if
1361    the new top-left text would overwrite it.  However, users of this routine should
1362    try to keep the new text short enough to avoid this.
1363 */
1364 void show_mytext(char* msg)
1365 {
1366         Point tmp, pt = screen->r.min;
1367         int siz;
1368         tmp = stringsize(display->defaultfont, msg);
1369         siz = tmp.x;
1370         pt.x=top_left;  pt.y+=outersep;
1371         if (top_left+siz > top_right) {
1372                 Rectangle r;
1373                 r.min.y = pt.y;
1374                 r.min.x = top_right;
1375                 r.max.y = r.min.y + smaxch.y;
1376                 r.max.x = top_left+siz;
1377                 draw(screen, r, display->white, display->opaque, r.min);
1378                 top_right = top_left+siz;
1379         }
1380         string(screen, pt, display->black, ZP, display->defaultfont, msg);
1381         top_left += siz;
1382 }
1383
1384
1385 double rnd(double x, double tol)        /* round to enough digits for accuracy tol */
1386 {
1387         double t = pow(10, floor(log10(tol)));
1388         return t * floor(x/t + .5);
1389 }
1390
1391 double t_tol(double xtol, double ytol)
1392 {
1393         int t = (int) floor(cur_sel.t);
1394         fpoint* p = cur_sel.fp->p;
1395         double dx, dy;
1396         if (t==cur_sel.t)
1397                 return 1;
1398         dx = fabs(p[t+1].x - p[t].x);
1399         dy = fabs(p[t+1].y - p[t].y);
1400         xtol /= (xtol>dx) ? xtol : dx;
1401         ytol /= (ytol>dy) ? ytol : dy;
1402         return (xtol<ytol) ? xtol : ytol;
1403 }
1404
1405 void say_where(const transform* tr)
1406 {
1407         double xtol=dxuntransform(tr,1), ytol=dyuntransform(tr,-1);
1408         char buf[100];
1409         int n, nmax = (top_right - top_left)/smaxch.x;
1410         if (nmax >= 100)
1411                 nmax = 100-1;
1412         n = sprintf(buf,"(%.14g,%.14g) at t=%.14g",
1413                         rnd(cur_sel.p.x,xtol), rnd(cur_sel.p.y,ytol),
1414                         rnd(cur_sel.t, t_tol(xtol,ytol)));
1415         if (cur_sel.fp->nam[0] != 0)
1416                 sprintf(buf+n," %.*s", nmax-n-1, cur_sel.fp->nam);
1417         show_mytext(buf);
1418 }
1419
1420
1421 void reselect(const transform* tr)      /* uselect(); set cur_sel; call this */
1422 {
1423         Point pt2, pt3;
1424         fpoint p2;
1425         transform tra;
1426         if (cur_sel.t < 0)
1427                 return;
1428         if (tr==0)
1429                 {tra=cur_trans(); tr=&tra;}
1430         do_transform(&p2, tr, &cur_sel.p);
1431         if (fabs(p2.x)+fabs(p2.y)>1e8 || (pt2.x=p2.x, pt2.y=p2.y, is_off_screen(pt2)))
1432                 {cur_sel.t= -1; return;}
1433         pt3.x=pt2.x-Dotrad;  pt3.y=pt2.y-Dotrad;
1434         draw(sel_bkg, sel_dot_box(0), screen, display->opaque, pt3);
1435         fillellipse(screen, pt2, Dotrad, Dotrad, clr_im(DRed), pt2);
1436         say_where(tr);
1437 }
1438
1439
1440 void do_select(Point pt)
1441 {
1442         transform tr = cur_trans();
1443         fpoint pt1, pt2, ctr;
1444         frectangle r;
1445         double slant;
1446         pt_on_fpoly* psel;
1447         unselect(&tr);
1448         do_untransform(&ctr, &tr, &pt);
1449         pt1.x=pt.x-fuzz;  pt1.y=pt.y+fuzz;
1450         pt2.x=pt.x+fuzz;  pt2.y=pt.y-fuzz;
1451         do_untransform(&r.min, &tr, &pt1);
1452         do_untransform(&r.max, &tr, &pt2);
1453         slant = u_slant_amt(&univ);
1454         slant_frect(&r, -slant);
1455         psel = select_in_univ(&r, slant);
1456         if (psel==0)
1457                 return;
1458         if (logfil!=0) {
1459                 fprintf(logfil,"%.14g\t%.14g\n", psel->p.x, psel->p.y);
1460                 fflush(logfil);
1461         }
1462         cur_sel = *psel;
1463         reselect(&tr);
1464 }
1465
1466
1467 /***************************** Prompting for text *****************************/
1468
1469 void unshow_mytext(char* msg)
1470 {
1471         Rectangle r;
1472         Point siz = stringsize(display->defaultfont, msg);
1473         top_left -= siz.x;
1474         r.min.y = screen->r.min.y + outersep;
1475         r.min.x = top_left;
1476         r.max.y = r.min.y + siz.y;
1477         r.max.x = r.min.x + siz.x;
1478         draw(screen, r, display->white, display->opaque, r.min);
1479 }
1480
1481
1482 /* Show the given prompt and read a line of user input.  The text appears at the
1483    top left.  If it runs into the top right text, we stop echoing but let the user
1484    continue typing blind if he wants to.
1485 */
1486 char* prompt_text(char* prompt)
1487 {
1488         static char buf[200];
1489         int n0, n=0, nshown=0;
1490         Rune c;
1491         unselect(0);
1492         show_mytext(prompt);
1493         while (n<200-1-UTFmax && (c=ekbd())!='\n') {
1494                 if (c=='\b') {
1495                         buf[n] = 0;
1496                         if (n > 0)
1497                                 do n--;
1498                                 while (n>0 && (buf[n-1]&0xc0)==0x80);
1499                         if (n < nshown)
1500                                 {unshow_mytext(buf+n); nshown=n;}
1501                 } else {
1502                         n0 = n;
1503                         n += runetochar(buf+n, &c);
1504                         buf[n] = 0;
1505                         if (nshown==n0 && top_right-top_left >= smaxch.x)
1506                                 {show_mytext(buf+n0); nshown=n;}
1507                 }
1508         }
1509         buf[n] = 0;
1510         while (ecanmouse())
1511                 emouse();
1512         return buf;
1513 }
1514
1515
1516 /**************************** Redrawing the screen ****************************/
1517
1518 /* Let p0 and its successors define a piecewise-linear function of a paramter t,
1519    and draw the 0<=t<=n1 portion using transform *tr.
1520 */
1521 void draw_fpts(const fpoint* p0, double n1, const transform* tr, int thick,
1522                 Image* clr)
1523 {
1524         int n = (int) n1;
1525         const fpoint* p = p0 + n;
1526         fpoint pp;
1527         Point qq, q;
1528         if (n1 > n) {
1529                 pp.x = p[0].x + (n1-n)*(p[1].x - p[0].x);
1530                 pp.y = p[0].y + (n1-n)*(p[1].y - p[0].y);
1531         } else  pp = *p--;
1532         do_transform(&qq, tr, &pp);
1533         if (n1==0)
1534                 fillellipse(screen, qq, 1+thick, 1+thick, clr, qq);
1535         for (; p>=p0; p--) {
1536                 do_transform(&q, tr, p);
1537                 if(plotdots)
1538                         fillellipse(screen, q, Dotrad, Dotrad, clr, q);
1539                 else
1540                         line(screen, qq, q, Enddisc, Enddisc, thick, clr, qq);
1541                 qq = q;
1542         }
1543 }
1544
1545 void draw_1fpoly(const fpolygon* fp, const transform* tr, Image* clr,
1546                 const frectangle *udisp, double slant)
1547 {
1548         fpoint *p0=fp->p, *pn=fp->p+fp->n;
1549         double l1, l2;
1550         if (p0==pn && fcontains(udisp,*p0))
1551                 {draw_fpts(p0, 0, tr, fp->c.thick, clr); return;}
1552         while ((l1=out_length(p0,pn,*udisp,slant)) < pn-p0) {
1553                 fpoint p0sav;
1554                 int i1 = (int) l1;
1555                 p0+=i1; l1-=i1;
1556                 p0sav = *p0;
1557                 p0[0].x += l1*(p0[1].x - p0[0].x);
1558                 p0[0].y += l1*(p0[1].y - p0[0].y);
1559                 l2 = in_length(p0, pn, *udisp, slant);
1560                 draw_fpts(p0, l2, tr, fp->c.thick, clr);
1561                 *p0 = p0sav;
1562                 p0 += (l2>0) ? ((int) ceil(l2)) : 1;
1563         }
1564 }
1565
1566
1567 double get_clip_data(const fpolygons *u, frectangle *r)
1568 {
1569         double slant = set_unslanted_y(u, &r->min.y, &r->max.y);
1570         r->min.x = u->disp.min.x;
1571         r->max.x = u->disp.max.x;
1572         return slant;
1573 }
1574
1575
1576 void draw_fpoly(const fpolygon* fp, const transform* tr, Image* clr)
1577 {
1578         frectangle r;
1579         double slant = get_clip_data(&univ, &r);
1580         draw_1fpoly(fp, tr, clr, &r, slant);
1581 }
1582
1583
1584 void eresized(int new)
1585 {
1586         transform tr;
1587         fpolygon* fp;
1588         frectangle clipr;
1589         double slant;
1590         if(new && getwindow(display, Refmesg) < 0) {
1591                 fprintf(stderr,"can't reattach to window\n");
1592                 exits("reshap");
1593         }
1594         draw(screen, screen->r, display->white, display->opaque, screen->r.min);
1595         tr = draw_frame();
1596         slant = get_clip_data(&univ, &clipr);
1597         for (fp=univ.p; fp!=0; fp=fp->link)
1598                 if (fintersects(&clipr, &fp->bb, slant))
1599                         draw_1fpoly(fp, &tr, fp->c.clr, &clipr, slant);
1600         reselect(0);
1601         if (mv_bkgd!=0 && mv_bkgd->repl==0) {
1602                 freeimage(mv_bkgd);
1603                 mv_bkgd = display->white;
1604         }
1605         flushimage(display, 1);
1606 }
1607
1608
1609
1610
1611 /********************************* Recoloring *********************************/
1612
1613 int draw_palette(int n)         /* n is number of colors; returns patch dy */
1614 {
1615         int y0 = screen->r.min.y + top_border;
1616         int dy = (screen->r.max.y - bot_border - y0)/n;
1617         Rectangle r;
1618         int i;
1619         r.min.y = y0;
1620         r.min.x = screen->r.max.x - rt_border + framewd;
1621         r.max.y = y0 + dy;
1622         r.max.x = screen->r.max.x;
1623         for (i=0; i<n; i++) {
1624                 draw(screen, r, clrtab[i].im, display->opaque, r.min);
1625                 r.min.y = r.max.y;
1626                 r.max.y += dy;
1627         }
1628         return dy;
1629 }
1630
1631
1632 Image* palette_color(Point pt, int dy, int n)
1633 {                               /* mouse at pt, patch size dy, n colors */
1634         int yy;
1635         if (screen->r.max.x - pt.x > rt_border - framewd)
1636                 return 0;
1637         yy = pt.y - (screen->r.min.y + top_border);
1638         if (yy<0 || yy>=n*dy)
1639                 return 0;
1640         return clrtab[yy/dy].im;
1641 }
1642
1643
1644 void all_set_clr(fpolygons* fps, Image* clr)
1645 {
1646         fpolygon* p;
1647         for (p=fps->p; p!=0; p=p->link)
1648                 p->c.clr = clr;
1649 }
1650
1651
1652 void all_set_scheme(fpolygons* fps, int scheme)
1653 {
1654         fpolygon* p;
1655         for (p=fps->p; p!=0; p=p->link)
1656                 if (p->ct!=0 && scheme <= p->ct[0].thick)
1657                         p->c = p->ct[scheme];
1658 }
1659
1660
1661 void do_recolor(int but, Mouse* m, int alluniv)
1662 {
1663         int sel, clkk, nclr = clr_id(DWhite);
1664         int dy = draw_palette(nclr);
1665         Image* clr;
1666         clkk = get_click_or_kbd(but, m, "123456789abcdefghijklmnopqrstuvwxyz");
1667         if (clkk < 0) {
1668                 clr = palette_color(m->xy, dy, nclr);
1669                 if (clr != 0) {
1670                         if (alluniv)
1671                                 all_set_clr(&univ, clr);
1672                         else cur_sel.fp->c.clr = clr;
1673                 }
1674                 eresized(0);
1675                 lift_button(but, m, Never);
1676         } else if (clkk > 0) {
1677                 sel = ('0'<clkk&&clkk<='9') ? 0 : 10+(clkk-'a')*10;
1678                 while (!('0'<=clkk&&clkk<='9'))
1679                         clkk = ekbd();
1680                 sel += clkk-'0';
1681                 if (alluniv)
1682                         all_set_scheme(&univ, sel);
1683                 else if (sel <= cur_sel.fp->ct[0].thick)
1684                         cur_sel.fp->c = cur_sel.fp->ct[sel];
1685         }
1686         eresized(0);
1687 }
1688
1689
1690 /****************************** Move and rotate  ******************************/
1691
1692 void prepare_mv(const fpolygon* fp)
1693 {
1694         Rectangle r = screen->r;
1695         Image* scr0;
1696         int dt = 1 + fp->c.thick;
1697         r.min.x+=lft_border-dt;  r.min.y+=top_border-dt;
1698         r.max.x-=rt_border-dt;   r.max.y-=bot_border-dt;
1699         if (mv_bkgd!=0 && mv_bkgd->repl==0)
1700                 freeimage(mv_bkgd);
1701         mv_bkgd = allocimage(display, r, CMAP8, 0, DNofill);
1702         if (mv_bkgd==0)
1703                 mv_bkgd = display->white;
1704         else {  transform tr = cur_trans();
1705                 draw(mv_bkgd, r, screen, display->opaque, r.min);
1706                 draw(mv_bkgd, sel_dot_box(&tr), sel_bkg, display->opaque, ZP);
1707                 scr0 = screen;
1708                 screen = mv_bkgd;
1709                 draw_fpoly(fp, &tr, display->white);
1710                 screen = scr0;
1711         }
1712 }
1713
1714
1715 void move_fp(fpolygon* fp, double dx, double dy)
1716 {
1717         fpoint *p, *pn=fp->p+fp->n;
1718         for (p=fp->p; p<=pn; p++) {
1719                 (p->x) += dx;
1720                 (p->y) += dy;
1721         }
1722         (fp->bb.min.x)+=dx;  (fp->bb.min.y)+=dy;
1723         (fp->bb.max.x)+=dx;  (fp->bb.max.y)+=dy;
1724 }
1725
1726
1727 void rotate_fp(fpolygon* fp, fpoint o, double theta)
1728 {
1729         double s=sin(theta), c=cos(theta);
1730         fpoint *p, *pn=fp->p+fp->n;
1731         for (p=fp->p; p<=pn; p++) {
1732                 double x=p->x-o.x, y=p->y-o.y;
1733                 (p->x) = o.x + c*x - s*y;
1734                 (p->y) = o.y + s*x + c*y;
1735         }
1736         set_fbb(fp);
1737 }
1738
1739
1740 /* Move the selected fpolygon so the selected point tracks the mouse, and return
1741    the total amount of movement.  Button but has already been held down for at
1742    least Mv_delay milliseconds and the mouse might have moved some distance.
1743 */
1744 fpoint do_move(int but, Mouse* m)
1745 {
1746         transform tr = cur_trans();
1747         int bbit = Button_bit(but);
1748         fpolygon* fp = cur_sel.fp;
1749         fpoint loc, loc0=cur_sel.p;
1750         double tsav = cur_sel.t;
1751         unselect(&tr);
1752         do {    latest_mouse(but, m);
1753                 (fp->c.thick)++;                /* line() DISAGREES WITH ITSELF */
1754                 draw_fpoly(fp, &tr, mv_bkgd);
1755                 (fp->c.thick)--;
1756                 do_untransform(&loc, &tr, &m->xy);
1757                 move_fp(fp, loc.x-cur_sel.p.x, loc.y-cur_sel.p.y);
1758                 cur_sel.p = loc;
1759                 draw_fpoly(fp, &tr, fp->c.clr);
1760         } while (m->buttons & bbit);
1761         cur_sel.t = tsav;
1762         reselect(&tr);
1763         loc.x -= loc0.x;
1764         loc.y -= loc0.y;
1765         return loc;
1766 }
1767
1768
1769 double dir_angle(const Point* pt, const transform* tr)
1770 {
1771         fpoint p;
1772         double dy, dx;
1773         do_untransform(&p, tr, pt);
1774         dy=p.y-cur_sel.p.y;  dx=p.x-cur_sel.p.x;
1775         return (dx==0 && dy==0) ? 0.0 : atan2(dy, dx);
1776 }
1777
1778
1779 /* Rotate the selected fpolygon around the selection point so as to track the
1780    direction angle from the selected point to m->xy.  Stop when button but goes
1781    up and return the total amount of rotation in radians.
1782 */
1783 double do_rotate(int but, Mouse* m)
1784 {
1785         transform tr = cur_trans();
1786         int bbit = Button_bit(but);
1787         fpolygon* fp = cur_sel.fp;
1788         double theta0 = dir_angle(&m->xy, &tr);
1789         double th, theta = theta0;
1790         do {    latest_mouse(but, m);
1791                 (fp->c.thick)++;                /* line() DISAGREES WITH ITSELF */
1792                 draw_fpoly(fp, &tr, mv_bkgd);
1793                 (fp->c.thick)--;
1794                 th = dir_angle(&m->xy, &tr);
1795                 rotate_fp(fp, cur_sel.p, th-theta);
1796                 theta = th;
1797                 draw_fpoly(fp, &tr, fp->c.clr);
1798         } while (m->buttons & bbit);
1799         unselect(&tr);
1800         cur_sel = prev_sel;
1801         reselect(&tr);
1802         return theta - theta0;
1803 }
1804
1805
1806
1807 /********************************* Edit menu  *********************************/
1808
1809 typedef enum e_index {
1810                 Erecolor, Ethick, Edelete, Eundo, Erotate, Eoptions,
1811                 Emove
1812 } e_index;
1813
1814 char* e_items[Eoptions+1];
1815
1816 Menu e_menu = {e_items, 0, 0};
1817
1818
1819 typedef struct e_action {
1820         e_index typ;                    /* What type of action */
1821         fpolygon* fp;                   /* fpolygon the action applies to */
1822         Image* clr;                     /* color to use if typ==Erecolor */
1823         double amt;                     /* rotation angle or line thickness */
1824         fpoint pt;                      /* movement vector or rotation center */
1825         struct e_action* link;          /* next in a stack */
1826 } e_action;
1827
1828 e_action* unact = 0;                    /* heads a linked list of actions */
1829 e_action* do_undo(e_action*);           /* pop off an e_action and (un)do it */
1830 e_action* save_act(e_action*,e_index);  /* append new e_action for status quo */
1831
1832
1833 void save_mv(fpoint movement)
1834 {
1835         unact = save_act(unact, Emove);
1836         unact->pt = movement;
1837 }
1838
1839
1840 void init_e_menu(void)
1841 {
1842         char* u = "can't undo";
1843         e_items[Erecolor] = "recolor";
1844         e_items[Edelete] = "delete";
1845         e_items[Erotate] = "rotate";
1846         e_items[Eoptions-cantmv] = 0;
1847         e_items[Ethick] = (cur_sel.fp->c.thick >0) ? "thin" : "thick";
1848         if (unact!=0)
1849                 switch (unact->typ) {
1850                 case Erecolor: u="uncolor"; break;
1851                 case Ethick: u=(unact->fp->c.thick==0) ? "unthin" : "unthicken";
1852                         break;
1853                 case Edelete: u="undelete"; break;
1854                 case Emove: u="unmove"; break;
1855                 case Erotate: u="unrotate"; break;
1856                 }
1857         e_items[Eundo] = u;
1858 }
1859
1860
1861 void do_emenu(int but, Mouse* m)
1862 {
1863         int h;
1864         if (cur_sel.t < 0)
1865                 return;
1866         init_e_menu();
1867         h = emenuhit(but, m, &e_menu);
1868         switch(h) {
1869         case Ethick: unact = save_act(unact, h);
1870                 cur_sel.fp->c.thick ^= 1;
1871                 eresized(0);
1872                 break;
1873         case Edelete: unact = save_act(unact, h);
1874                 fp_remove(&univ, cur_sel.fp);
1875                 unselect(0);
1876                 eresized(0);
1877                 break;
1878         case Erecolor: unact = save_act(unact, h);
1879                 do_recolor(but, m, 0);
1880                 break;
1881         case Erotate: unact = save_act(unact, h);
1882                 prepare_mv(cur_sel.fp);
1883                 if (get_1click(but, m, 0)) {
1884                         unact->pt = cur_sel.p;
1885                         unact->amt = do_rotate(but, m);
1886                 }
1887                 break;
1888         case Eundo: unact = do_undo(unact);
1889                 break;
1890         }
1891 }
1892
1893
1894
1895 /******************************* Undoing edits  *******************************/
1896
1897 e_action* save_act(e_action* a0, e_index typ)
1898 {                                       /* append new e_action for status quo */
1899         e_action* a = malloc(sizeof(e_action));
1900         a->link = a0;
1901         a->pt.x = a->pt.y = 0.0;
1902         a->amt = cur_sel.fp->c.thick;
1903         a->clr = cur_sel.fp->c.clr;
1904         a->fp = cur_sel.fp;
1905         a->typ = typ;
1906         return a;
1907 }
1908
1909
1910 /* This would be trivial except it's nice to preserve the selection in order to make
1911    it easy to undo a series of moves.  (There's no do_unrotate() because it's harder
1912    and less important to preserve the selection in that case.)
1913 */
1914 void do_unmove(e_action* a)
1915 {
1916         double tsav = cur_sel.t;
1917         unselect(0);
1918         move_fp(a->fp, -a->pt.x, -a->pt.y);
1919         if (a->fp == cur_sel.fp) {
1920                 cur_sel.p.x -= a->pt.x;
1921                 cur_sel.p.y -= a->pt.y;
1922         }
1923         cur_sel.t = tsav;
1924         reselect(0);
1925 }
1926
1927
1928 e_action* do_undo(e_action* a0)         /* pop off an e_action and (un)do it */
1929 {
1930         e_action* a = a0;
1931         if (a==0)
1932                 return 0;
1933         switch(a->typ) {
1934         case Ethick: a->fp->c.thick = a->amt;
1935                 eresized(0);
1936                 break;
1937         case Erecolor: a->fp->c.clr = a->clr;
1938                 eresized(0);
1939                 break;
1940         case Edelete:
1941                 a->fp->link = univ.p;
1942                 univ.p = a->fp;
1943                 grow_bb(&univ.bb, &a->fp->bb);
1944                 eresized(0);
1945                 break;
1946         case Emove:
1947                 do_unmove(a);
1948                 eresized(0);
1949                 break;
1950         case Erotate:
1951                 unselect(0);
1952                 rotate_fp(a->fp, a->pt, -a->amt);
1953                 eresized(0);
1954                 break;
1955         }
1956         a0 = a->link;
1957         free(a);
1958         return a0;
1959 }
1960
1961
1962
1963 /********************************* Main menu  *********************************/
1964
1965 enum m_index {     Mzoom_in,  Mzoom_out,  Munzoom,  Mslant,    Munslant,
1966                 Msquare_up,  Mrecenter,  Mrecolor,  Mrestack,  Mread,
1967                 Mwrite,      Mexit};
1968 char* m_items[] = {"zoom in", "zoom out", "unzoom", "slant",   "unslant",
1969                 "square up", "recenter", "recolor", "restack", "read",
1970                 "write",     "exit", 0};
1971
1972 Menu m_menu = {m_items, 0, 0};
1973
1974
1975 void do_mmenu(int but, Mouse* m)
1976 {
1977         int e, h = emenuhit(but, m, &m_menu);
1978         switch (h) {
1979         case Mzoom_in:
1980                 disp_zoomin(egetrect(but,m));
1981                 eresized(0);
1982                 break;
1983         case Mzoom_out:
1984                 disp_zoomout(egetrect(but,m));
1985                 eresized(0);
1986                 break;
1987         case Msquare_up:
1988                 disp_squareup();
1989                 eresized(0);
1990                 break;
1991         case Munzoom:
1992                 init_disp();
1993                 eresized(0);
1994                 break;
1995         case Mrecenter:
1996                 if (get_1click(but, m, &bullseye)) {
1997                         recenter_disp(m->xy);
1998                         eresized(0);
1999                         lift_button(but, m, Never);
2000                 }
2001                 break;
2002         case Mslant:
2003                 if (cur_sel.t>=0 && prev_sel.t>=0) {
2004                         slant_disp(prev_sel.p, cur_sel.p);
2005                         eresized(0);
2006                 }
2007                 break;
2008         case Munslant:
2009                 univ.slant_ht = univ.disp.max.y - univ.disp.min.y;
2010                 eresized(0);
2011                 break;
2012         case Mrecolor:
2013                 do_recolor(but, m, 1);
2014                 break;
2015         case Mrestack:
2016                 fps_invert(&univ);
2017                 eresized(0);
2018                 break;
2019         case Mread:
2020                 e = doinput(prompt_text("File:"));
2021                 if (e==0)
2022                         eresized(0);
2023                 else if (e<0)
2024                         show_mytext(" - can't read");
2025                 else {
2026                         char ebuf[80];
2027                         snprintf(ebuf, 80, " - error line %d", e);
2028                         show_mytext(ebuf);
2029                 }
2030                 break;
2031         case Mwrite:
2032                 if (!dooutput(prompt_text("File:")))
2033                         show_mytext(" - can't write");
2034                 break;
2035         case Mexit:
2036                 exits("");
2037         }
2038 }
2039
2040
2041
2042 /****************************** Handling events  ******************************/
2043
2044 void doevent(void)
2045 {
2046         ulong etype;
2047         int mobile;
2048         ulong mvtime;
2049         Event   ev;
2050
2051         etype = eread(Emouse|Ekeyboard, &ev);
2052         if(etype & Emouse) {
2053                 if (ev.mouse.buttons & But1) {
2054                         do_select(ev.mouse.xy);
2055                         mvtime = Never;
2056                         mobile = !cantmv && cur_sel.t>=0;
2057                         if (mobile) {
2058                                 mvtime = ev.mouse.msec + Mv_delay;
2059                                 prepare_mv(cur_sel.fp);
2060                         }
2061                         if (!lift_button(1, &ev.mouse, mvtime) && mobile)
2062                                 save_mv(do_move(1, &ev.mouse));
2063                 } else if (ev.mouse.buttons & But2)
2064                         do_emenu(2, &ev.mouse);
2065                 else if (ev.mouse.buttons & But3)
2066                         do_mmenu(3, &ev.mouse);
2067         } else if (etype & Ekeyboard) {
2068                 if (ev.kbdc=='\n' && cur_sel.t>=0 && logfil!=0) {
2069                         fprintf(logfil,"%s\n", cur_sel.fp->nam);
2070                         fflush(logfil);
2071                 }
2072         }
2073 }
2074
2075
2076
2077 /******************************** Main program ********************************/
2078
2079 extern char* argv0;
2080
2081 void usage(void)
2082 {
2083         int i;
2084         fprintf(stderr,"Usage %s [options] [infile]\n", argv0);
2085         fprintf(stderr,
2086 "option ::= -l logfile | -m | -p\n"
2087 "\n"
2088 "Read a polygonal line graph in an ASCII format (one x y pair per line, delimited\n"
2089 "by spaces with a label after each polyline), and view it interactively.  Use\n"
2090 "standard input if no infile is specified.\n"
2091 "Option -l specifies a file in which to log the coordinates of each point selected.\n"
2092 "(Clicking a point with button one selects it and displays its coordinates and\n"
2093 "the label of its polylone.)  Option -m allows polylines to be moved and rotated.\n"
2094 "The -p option plots only the vertices of the polygons.\n"
2095 "The polyline labels can use the following color names:"
2096         );
2097         for (i=0; clrtab[i].c!=DNofill; i++)
2098                 fprintf(stderr,"%s%8s", (i%8==0 ? "\n" : "  "), clrtab[i].nam);
2099         fputc('\n', stderr);
2100         exits("usage");
2101 }
2102
2103 void main(int argc, char *argv[])
2104 {
2105         int e;
2106         char err[ERRMAX];
2107
2108         ARGBEGIN {
2109         case 'm':
2110                 cantmv=0;
2111                 break;
2112         case 'l':
2113                 logfil = fopen(ARGF(),"w");
2114                 break;
2115         case 'p':
2116                 plotdots++;
2117                 break;
2118         default:
2119                 usage();
2120         } ARGEND;
2121
2122         if(initdraw(0, 0, "gview") < 0)
2123                 exits("initdraw");
2124         einit(Emouse|Ekeyboard);
2125
2126         do {
2127                 e = doinput(*argv ? *argv : "-");
2128                 if (e < 0) {
2129                         rerrstr(err, sizeof err);
2130                         fprintf(stderr, "%s: cannot read %s: %s\n",
2131                                 argv0, *argv, err);
2132                         exits("no valid input file");
2133                 } else if (e > 0) {
2134                         fprintf(stderr, "%s: %s:%d: bad data syntax\n",
2135                                 argv0, (*argv ? *argv : "-"), e);
2136                         exits("bad syntax in input");
2137                 }
2138         } while (*argv && *++argv);
2139         init_disp();
2140         init_clrtab();
2141         set_default_clrs(&univ, 0);
2142         adjust_border(display->defaultfont);
2143         cur_sel.t = prev_sel.t = -1;
2144         eresized(0);
2145         for(;;)
2146                 doevent();
2147 }