sys/src/cmd/mug.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <draw.h>
   4 #include <event.h>
   5 #include <cursor.h>
   6
   7 #define initstate muginitstate
   8
   9 typedef struct State State;
  10 struct State {
  11         double black;
  12         double white;
  13         double stretch;
  14         double gamma;
  15         int depth;
  16         int gtab[1001];
  17         Rectangle selr;
  18 };
  19
  20 typedef struct Face Face;
  21 struct Face {
  22         Rectangle r;
  23         State state;
  24         Image *small;
  25 };
  26
  27 double GAMMA = 1.0;             /* theory tells me this should be 2.2, but 1.0 sure looks better */
  28 enum {
  29         Left=0,
  30         Right,
  31         Top,
  32         Bottom,
  33
  34         RTopLeft=0,
  35         RTop,
  36         RTopRight,
  37         RLeft,
  38         RMiddle,
  39         RRight,
  40         RBotLeft,
  41         RBot,
  42         RBotRight,
  43 };
  44
  45 void*
  46 emalloc(ulong sz)
  47 {
  48         void *v;
  49
  50         v = malloc(sz);
  51         if(v == nil)
  52                 sysfatal("malloc %lud fails", sz);
  53         memset(v, 0, sz);
  54         return v;
  55 }
  56
  57 Face *face[8];
  58 int nface;
  59 uchar grey2cmap[256];
  60 Image *bkgd;
  61 Image *orig;
  62 Image *ramp, *small, *osmall, *tmp8, *red, *green, *blue;
  63 State state, ostate;
  64 uchar val2cmap[256];
  65 uchar clamp[3*256];
  66 Rectangle rbig, rramp, rface[nelem(face)], rsmall;
  67 double *rdata;
  68 int sdy, sdx;
  69
  70 void
  71 geometry(Rectangle r)
  72 {
  73         int i;
  74         Rectangle fr[9];
  75
  76         rramp.min = addpt(r.min, Pt(4,4));
  77         rramp.max = addpt(rramp.min, Pt(256,256));
  78
  79         rbig.min = Pt(rramp.max.x+6, rramp.min.y);
  80         rbig.max = addpt(rbig.min, Pt(Dx(orig->r), Dy(orig->r)));
  81
  82         for(i=0; i<9; i++)
  83                 fr[i] = rectaddpt(Rect(0,0,48,48), Pt(rramp.min.x+48+56*(i%3), rramp.max.y+6+56*(i/3)));
  84
  85         rsmall = fr[4];
  86         for(i=0; i<4; i++)
  87                 rface[i] = fr[i];
  88         for(i=4; i<8; i++)
  89                 rface[i] = fr[i+1];
  90 }
  91
  92 double
  93 y2gamma(int y)
  94 {
  95         double g;
  96
  97         g = (double)y / 128.0;
  98         return 0.5+g*g;         /* gamma from 0.5 to 4.5, with 1.0 near the middle */
  99 }
 100
 101 int
 102 gamma2y(double g)
 103 {
 104         g -= 0.5;
 105         return (int)(128.0*sqrt(g)+0.5);
 106 }
 107
 108 void
 109 drawface(int i)
 110 {
 111         if(i==-1){
 112                 border(screen, rsmall, -3, blue, ZP);
 113                 draw(screen, rsmall, small, nil, ZP);
 114                 return;
 115         }
 116         border(screen, rface[i], -1, display->black, ZP);
 117         if(face[i])
 118                 draw(screen, rface[i], face[i]->small, nil, ZP);
 119         else
 120                 draw(screen, rface[i], display->white, nil, ZP);
 121 }
 122
 123 void
 124 drawrampbar(Image *color, State *s)
 125 {
 126         Rectangle liner, r;
 127         static Rectangle br;
 128
 129         if(Dx(br))
 130                 draw(screen, br, ramp, nil, subpt(br.min, rramp.min));
 131
 132         r = rramp;
 133         r.max.x = r.min.x + (int)(s->white*255.0);
 134         r.min.x += (int)(s->black*255.0);
 135         r.min.y += gamma2y(s->gamma);
 136         r.max.y = r.min.y+1;
 137         rectclip(&r, rramp);
 138         draw(screen, r, color, nil, ZP);
 139         br = r;
 140
 141         r.min.y -= 2;
 142         r.max.y += 2;
 143
 144         liner = r;
 145         r.min.x += Dx(liner)/3;
 146         r.max.x -= Dx(liner)/3;
 147         rectclip(&r, rramp);
 148         draw(screen, r, color, nil, ZP);
 149         combinerect(&br, r);
 150
 151         r = liner;
 152         r.max.x = r.min.x+3;
 153         rectclip(&r, rramp);
 154         draw(screen, r, color, nil, ZP);
 155         combinerect(&br, r);
 156
 157         r = liner;
 158         r.min.x = r.max.x-3;
 159         rectclip(&r, rramp);
 160         draw(screen, r, color, nil, ZP);
 161         combinerect(&br, r);
 162 }
 163
 164 void
 165 drawscreen(int clear)
 166 {
 167         int i;
 168
 169         if(clear){
 170                 geometry(screen->r);
 171                 draw(screen, screen->r, bkgd, nil, ZP);
 172         }
 173
 174         border(screen, rbig, -1, display->black, ZP);
 175         draw(screen, rbig, orig, nil, orig->r.min);
 176
 177         border(screen, rramp, -1, display->black, ZP);
 178         draw(screen, rramp, ramp, nil, ramp->r.min);
 179         drawrampbar(red, &state);
 180
 181         border(screen, rectaddpt(state.selr, subpt(rbig.min, orig->r.min)), -2, red, ZP);
 182         if(clear){
 183                 drawface(-1);
 184                 for(i=0; i<nelem(face); i++)
 185                         drawface(i);
 186         }
 187 }
 188
 189 void
 190 moveframe(Rectangle old, Rectangle new)
 191 {
 192         border(screen, rectaddpt(old, subpt(rbig.min, orig->r.min)), -2, orig, old.min);
 193         border(screen, rectaddpt(new, subpt(rbig.min, orig->r.min)), -2, red, ZP);
 194 }
 195
 196
 197 /*
 198  * Initialize gamma ramp; should dither for
 199  * benefit of non-true-color displays.
 200  */
 201 void
 202 initramp(void)
 203 {
 204         int k, x, y;
 205         uchar dat[256*256];
 206         double g;
 207
 208         k = 0;
 209         for(y=0; y<256; y++) {
 210                 g = y2gamma(y);
 211                 for(x=0; x<256; x++)
 212                         dat[k++] = 255.0 * pow(x/255.0, g);
 213         }
 214         assert(k == sizeof dat);
 215
 216         ramp = allocimage(display, Rect(0,0,256,256), GREY8, 0, DNofill);
 217         if(ramp == nil)
 218                 sysfatal("allocimage: %r");
 219
 220         if(loadimage(ramp, ramp->r, dat, sizeof dat) != sizeof dat)
 221                 sysfatal("loadimage: %r");
 222 }
 223
 224 void
 225 initclamp(void)
 226 {
 227         int i;
 228
 229         for(i=0; i<256; i++) {
 230                 clamp[i] = 0;
 231                 clamp[256+i] = i;
 232                 clamp[512+i] = 255;
 233         }
 234 }
 235
 236 void
 237 changestretch(double stretch)
 238 {
 239         state.stretch = stretch;
 240 }
 241
 242 /*
 243  * There is greyscale data for the rectangle datar in data;
 244  * extract square r and write it into the 48x48 pixel image small.
 245  */
 246 void
 247 process(double *data, Rectangle datar, Rectangle r, Image *small)
 248 {
 249         double black, center, delta, *k, shrink, sum, *tmp[48], *tt, w, white, x;
 250         int datadx, dp, dx, dy, error, i, ii, j, jj;
 251         int ksize, ksizeby2, sdata[48*48], sd, sh, sm, sv, u, uu, uuu, v, vv;
 252         uchar bdata[48*48];
 253
 254         datadx = Dx(datar);
 255         dx = Dx(r);
 256         dy = Dy(r);
 257         shrink = dx/48.0;
 258
 259         ksize = 1+2*(int)(shrink/2.0);
 260         if(ksize <= 2)
 261                 return;
 262
 263         k = emalloc(ksize*sizeof(k[0]));
 264
 265         /* center of box */
 266         for(i=1; i<ksize-1; i++)
 267                 k[i] = 1.0;
 268
 269         /* edges */
 270         x = shrink - floor(shrink);
 271         k[0] = x;
 272         k[ksize-1] = x;
 273
 274         sum = 0.0;
 275         for(i=0; i<ksize; i++)
 276                 sum += k[i];
 277
 278         for(i=0; i<ksize; i++)
 279                 k[i] /= sum;
 280
 281         ksizeby2 = ksize/2;
 282
 283         for(i=0; i<48; i++)
 284                 tmp[i] = emalloc(datadx*sizeof(tmp[i][0]));
 285
 286         /* squeeze vertically */
 287         for(i=0; i<48; i++) {
 288                 ii = r.min.y+i*dy/48;
 289                 tt = tmp[i];
 290                 uu = ii - ksizeby2;
 291                 for(j=r.min.x-ksize; j<r.max.x+ksize; j++) {
 292                         if(j<datar.min.x || j>=datar.max.x)
 293                                 continue;
 294                         w = 0.0;
 295
 296                         uuu = uu*datadx+j;
 297                         if(uu>=datar.min.y && uu+ksize<datar.max.y)
 298                                 for(u=0; u<ksize; u++){
 299                                         w += k[u]*data[uuu];
 300                                         uuu += datadx;
 301                                 }
 302                         else
 303                                 for(u=0; u<ksize; u++){
 304                                         if(uu+u>=datar.min.y && uu+u<datar.max.y)
 305                                                 w += k[u]*data[uuu];
 306                                         uuu+=datadx;
 307                                 }
 308                         tt[j-datar.min.x] = w;
 309                 }
 310         }
 311
 312         /* stretch value scale */
 313         center = (state.black+state.white)/2;
 314         delta = state.stretch*(state.white-state.black)/2;
 315         black = center - delta;
 316         white = center + delta;
 317
 318         /* squeeze horizontally */
 319         for(i=0; i<48; i++) {
 320                 tt = tmp[i];
 321                 for(j=0; j<48; j++) {
 322                         jj = r.min.x+j*dx/48;
 323                         w = 0.0;
 324                         for(v=0; v<ksize; v++) {
 325                                 vv = jj - ksizeby2 + v;
 326                                 if(vv<datar.min.x || vv>=datar.max.x) {
 327                                         w += k[v];              /* assume white surround */
 328                                         continue;
 329                                 }
 330                                 w += k[v]*tt[vv-datar.min.x];
 331                         }
 332                         if(w < black || black==white)
 333                                 w = 0.0;
 334                         else if(w > white)
 335                                 w = 1.0;
 336                         else
 337                                 w = (w-black)/(white-black);
 338                         sdata[i*48+j] = state.gtab[(int)(1000.0*w)];
 339                 }
 340         }
 341
 342         /* dither to lower depth before copying into GREY8 version */
 343         if(small->chan != GREY8) {
 344                 u = 0;
 345                 dp = small->depth;
 346                 for(i=0; i<48; i++) {
 347                         sm = 0xFF ^ (0xFF>>dp);
 348                         sh = 0;
 349                         v = 0;
 350                         for(j=0; j<48; j++) {
 351                                 ii = 48*i+j;
 352                                 sd = clamp[sdata[ii]+256];
 353                                 sv = sd&sm;
 354                                 v |= sv>>sh;
 355                                 sh += dp;
 356                                 if(sh == 8) {
 357                                         bdata[u++] = v;
 358                                         v = 0;
 359                                         sh = 0;
 360                                 }
 361
 362                                 /* propagate error, with decay (sum errors < 1) */
 363                                 error = sd - sv;
 364                                 if(ii+49 < 48*48) {     /* one test is enough, really */
 365                                         sdata[ii+1] = sdata[ii+1]+((3*error)>>4);
 366                                         sdata[ii+48] = sdata[ii+48]+((3*error)>>4);
 367                                         sdata[ii+49] = sdata[ii+49]+((3*error)>>3);
 368                                 }
 369
 370                                 /* produce correct color map value by copying bits */
 371                                 switch(dp){
 372                                 case 1:
 373                                         sv |= sv>>1;
 374                                 case 2:
 375                                         sv |= sv>>2;
 376                                 case 4:
 377                                         sv |= sv>>4;
 378                                 }
 379                                 sdata[ii] = sv;
 380                         }
 381                 }
 382                 for(i=0; i<nelem(bdata); i++)
 383                         bdata[i] = sdata[i];
 384                 if(loadimage(tmp8, tmp8->r, bdata, sizeof bdata) != sizeof bdata)
 385                         sysfatal("loadimage: %r");
 386                 draw(small, small->r, tmp8, nil, tmp8->r.min);
 387         } else {
 388                 for(i=0; i<nelem(bdata); i++)
 389                         bdata[i] = sdata[i];
 390                 if(loadimage(small, small->r, bdata, sizeof bdata) != sizeof bdata)
 391                         sysfatal("loadimage: %r");
 392         }
 393
 394         free(k);
 395         for(i=0; i<48; i++)
 396                 free(tmp[i]);
 397 }
 398
 399 void
 400 initval2cmap(void)
 401 {
 402         int i;
 403
 404         for(i=0; i<256; i++)
 405                 val2cmap[i] = rgb2cmap(i, i, i);
 406 }
 407
 408 void
 409 setgtab(State *s)
 410 {
 411         int i;
 412
 413         for(i=0; i<=1000; i++)
 414                 s->gtab[i] = val2cmap[(int)(255.0*pow((i/1000.0), 1.0/s->gamma))];
 415 }
 416
 417 int
 418 section(int x)
 419 {
 420         int ib, iw;
 421
 422         ib = state.black * 255.0;
 423         iw = state.white * 255.0;
 424
 425         if(x<ib-5 || iw+5<x)
 426                 return -1;
 427
 428         iw -= ib;
 429         x -= ib;
 430         if(x < iw/3)
 431                 return 0;
 432         if(x < 2*iw/3)
 433                 return 1;
 434         return 2;
 435 }
 436
 437 Image*
 438 copyimage(Image *i)
 439 {
 440         Image *n;
 441
 442         if(i == nil)
 443                 return nil;
 444
 445         n = allocimage(display, i->r, i->chan, 0, DNofill);
 446         if(n == nil)
 447                 sysfatal("allocimage: %r");
 448
 449         draw(n, n->r, i, nil, i->r.min);
 450         return n;
 451 }
 452
 453 Image*
 454 grey8image(Image *i)
 455 {
 456         Image *n;
 457
 458         if(i->chan == GREY8)
 459                 return i;
 460
 461         n = allocimage(display, i->r, GREY8, 0, DNofill);
 462         if(n == nil)
 463                 sysfatal("allocimage: %r");
 464
 465         draw(n, n->r, i, nil, i->r.min);
 466         freeimage(i);
 467         return n;
 468 }
 469
 470
 471 void
 472 mark(void)
 473 {
 474         if(osmall != small){
 475                 freeimage(osmall);
 476                 osmall = small;
 477         }
 478         ostate = state;
 479 }
 480
 481 void
 482 undo(void)
 483 {
 484         if(small != osmall){
 485                 freeimage(small);
 486                 small = osmall;
 487         }
 488         state = ostate;
 489         process(rdata, orig->r, state.selr, small);
 490         drawface(-1);
 491         drawscreen(0);
 492 }
 493
 494 void
 495 saveface(Face *f, int slot)
 496 {
 497         if(slot == -1){
 498                 mark();
 499                 state = f->state;
 500                 small = copyimage(f->small);
 501                 drawface(-1);
 502                 drawscreen(0);
 503                 return;
 504         }
 505
 506         if(face[slot]==nil)
 507                 face[slot] = emalloc(sizeof(*face[slot]));
 508         else{
 509                 freeimage(face[slot]->small);
 510                 face[slot]->small = nil;
 511         }
 512
 513         if(f == nil){
 514                 face[slot]->small = copyimage(small);
 515                 face[slot]->state = state;
 516         }else{
 517                 face[slot]->small = copyimage(f->small);
 518                 face[slot]->state = f->state;
 519         }
 520         drawface(slot);
 521 }
 522
 523 int
 524 writeface(char *outfile, Image *image)
 525 {
 526         int i, fd, rv, y;
 527         uchar data[48*48/2];
 528
 529         if(outfile == nil)
 530                 fd = 1;
 531         else{
 532                 if((fd = create(outfile, OWRITE, 0666)) < 0)
 533                         return -1;
 534         }
 535
 536         switch(image->chan) {
 537         default:
 538                 rv = -1;
 539                 break;
 540
 541         case GREY1:
 542                 if(unloadimage(image, image->r, data, 48*48/8) != 48*48/8)
 543                         sysfatal("unloadimage: %r");
 544                 for(y=0; y<48; y++) {
 545                         for(i=0; i<3; i++)
 546                                 fprint(fd, "0x%.2x%.2x,", data[y*6+i*2+0], data[y*6+i*2+1]);
 547                         fprint(fd, "\n");
 548                 }
 549                 rv = 0;
 550                 break;
 551
 552         case GREY2:
 553                 if(unloadimage(image, image->r, data, 48*48/4) != 48*48/4)
 554                         sysfatal("unloadimage: %r");
 555                 for(y=0; y<48; y++) {
 556                         for(i=0; i<3; i++)
 557                                 fprint(fd, "0x%.2x%.2x,%.2x%.2x,",
 558                                         data[y*12+i*4+0], data[y*12+i*4+1],
 559                                         data[y*12+i*4+2], data[y*12+i*4+3]);
 560                         fprint(fd, "\n");
 561                 }
 562                 rv = 0;
 563                 break;
 564
 565         case GREY4:
 566         case GREY8:
 567                 rv = writeimage(fd, image, 0);  /* dolock? */
 568                 break;
 569         }
 570
 571         if(outfile)
 572                 close(fd);
 573         return rv;
 574 }
 575
 576 void
 577 room(Rectangle out, Rectangle in, int *a)
 578 {
 579         a[Left] = out.min.x - in.min.x;
 580         a[Right] = out.max.x - in.max.x;
 581         a[Top] = out.min.y - in.min.y;
 582         a[Bottom] = out.max.y - in.max.y;
 583 }
 584
 585 int
 586 min(int a, int b)
 587 {
 588         if(a < b)
 589                 return a;
 590         return b;
 591 }
 592
 593 int
 594 max(int a, int b)
 595 {
 596         if(a > b)
 597                 return a;
 598         return b;
 599 }
 600
 601 int
 602 move(Rectangle r, Rectangle picr, Point d, int k, Rectangle *rp)
 603 {
 604         int a[4], i;
 605         Rectangle oldr;
 606         static int toggle;
 607
 608         oldr = r;
 609         room(picr, r, a);
 610         switch(k){
 611         case RTopLeft:
 612                 i = (d.x+d.y)/2;
 613                 if(i>=Dx(r) || i>=Dy(r))
 614                         break;
 615                 i = max(i, a[Left]);
 616                 i = max(i, a[Top]);
 617                 r.min.x += i;
 618                 r.min.y += i;
 619                 break;
 620         case RTop:
 621                 i = d.y;
 622                 if(i < 0){
 623                         /*
 624                          * should really check i/2, but this is safe and feedback
 625                          * makes the control feel right
 626                          */
 627                         i = -min(-i, a[Right]);
 628                         i = max(i, a[Left]);
 629                 }
 630                 i = max(i, a[Top]);
 631                 if(i >= Dy(r))
 632                         break;
 633                 r.min.y += i;
 634                 /* divide the half bit equally */
 635                 toggle = 1-toggle;
 636                 if(toggle){
 637                         r.min.x += i/2;
 638                         r.max.x = r.min.x+Dy(r);
 639                 }else{
 640                         r.max.x -= i/2;
 641                         r.min.x = r.max.x-Dy(r);
 642                 }
 643                 break;
 644         case RTopRight:
 645                 i = (-d.x+d.y)/2;
 646                 if(i>=Dx(r) || i>=Dy(r))
 647                         break;
 648                 i = -min(-i, a[Right]);
 649                 i = max(i, a[Top]);
 650                 r.max.x -= i;
 651                 r.min.y += i;
 652                 break;
 653         case RLeft:
 654                 i = d.x;
 655                 if(i < 0){
 656                         i = -min(-i, a[Bottom]);
 657                         i = max(i, a[Top]);
 658                 }
 659                 i = max(i, a[Left]);
 660                 if(i >= Dx(r))
 661                         break;
 662                 r.min.x += i;
 663                 /* divide the half bit equally */
 664                 toggle = 1-toggle;
 665                 if(toggle){
 666                         r.min.y += i/2;
 667                         r.max.y = r.min.y+Dx(r);
 668                 }else{
 669                         r.max.y -= i/2;
 670                         r.min.y = r.max.y-Dx(r);
 671                 }
 672                 break;
 673         case RMiddle:
 674                 if(d.x >= 0)
 675                         d.x = min(d.x, a[Right]);
 676                 else
 677                         d.x = max(d.x, a[Left]);
 678                 if(d.y >= 0)
 679                         d.y = min(d.y, a[Bottom]);
 680                 else
 681                         d.y = max(d.y, a[Top]);
 682                 r = rectaddpt(r, d);
 683                 break;
 684         case RRight:
 685                 i = d.x;
 686                 if(i > 0){
 687                         i = min(i, a[Bottom]);
 688                         i = -max(-i, a[Top]);
 689                 }
 690                 i = min(i, a[Right]);
 691                 if(-i >= Dx(r))
 692                         break;
 693                 r.max.x += i;
 694                 /* divide the half bit equally */
 695                 toggle = 1-toggle;
 696                 if(toggle){
 697                         r.min.y -= i/2;
 698                         r.max.y = r.min.y+Dx(r);
 699                 }else{
 700                         r.max.y += i/2;
 701                         r.min.y = r.max.y-Dx(r);
 702                 }
 703                 break;
 704         case RBotLeft:
 705                 i = (d.x+-d.y)/2;
 706                 if(i>=Dx(r) || i>=Dy(r))
 707                         break;
 708                 i = max(i, a[Left]);
 709                 i = -min(-i, a[Bottom]);
 710                 r.min.x += i;
 711                 r.max.y -= i;
 712                 break;
 713         case RBot:
 714                 i = d.y;
 715                 if(i > 0){
 716                         i = min(i, a[Right]);
 717                         i = -max(-i, a[Left]);
 718                 }
 719                 i = min(i, a[Bottom]);
 720                 if(i >= Dy(r))
 721                         break;
 722                 r.max.y += i;
 723                 /* divide the half bit equally */
 724                 toggle = 1-toggle;
 725                 if(toggle){
 726                         r.min.x -= i/2;
 727                         r.max.x = r.min.x+Dy(r);
 728                 }else{
 729                         r.max.x += i/2;
 730                         r.min.x = r.max.x-Dy(r);
 731                 }
 732                 break;
 733         case RBotRight:
 734                 i = (-d.x+-d.y)/2;
 735                 if(i>=Dx(r) || i>=Dy(r))
 736                         break;
 737                 i = -min(-i, a[Right]);
 738                 i = -min(-i, a[Bottom]);
 739                 r.max.x -= i;
 740                 r.max.y -= i;
 741                 break;
 742         }
 743         if(Dx(r)<3 || Dy(r)<3){
 744                 *rp = oldr;
 745                 return 0;
 746         }
 747         *rp = r;
 748         return !eqrect(r, oldr);
 749 }
 750
 751 void
 752 rlist(Rectangle r, Rectangle *ra)
 753 {
 754         Rectangle tr;
 755
 756         tr = r;
 757         tr.max.y = r.min.y+Dy(r)/4;
 758         ra[0] = tr;
 759         ra[0].max.x = tr.min.x+Dx(tr)/4;
 760         ra[1] = tr;
 761         ra[1].min.x = ra[0].max.x;
 762         ra[1].max.x = tr.max.x-Dx(tr)/4;
 763         ra[2] = tr;
 764         ra[2].min.x = ra[1].max.x;
 765
 766         tr.min.y = tr.max.y;
 767         tr.max.y = r.max.y-Dy(r)/4;
 768         ra[3] = tr;
 769         ra[3].max.x = tr.min.x+Dx(tr)/4;
 770         ra[4] = tr;
 771         ra[4].min.x = ra[3].max.x;
 772         ra[4].max.x = tr.max.x-Dx(tr)/4;
 773         ra[5] = tr;
 774         ra[5].min.x = ra[4].max.x;
 775
 776         tr.min.y = tr.max.y;
 777         tr.max.y = r.max.y;
 778         ra[6] = tr;
 779         ra[6].max.x = tr.min.x+Dx(tr)/4;
 780         ra[7] = tr;
 781         ra[7].min.x = ra[6].max.x;
 782         ra[7].max.x = tr.max.x-Dx(tr)/4;
 783         ra[8] = tr;
 784         ra[8].min.x = ra[7].max.x;
 785 }
 786
 787 int
 788 abs(int a)
 789 {
 790         if(a < 0)
 791                 return -a;
 792         return a;
 793 }
 794
 795 void
 796 usage(void)
 797 {
 798         fprint(2, "usage: mug [file.bit]\n");
 799         exits("usage");
 800 }
 801
 802 void
 803 eresized(int new)
 804 {
 805         if(new && getwindow(display, Refmesg) < 0)
 806                 fprint(2,"can't reattach to window");
 807         drawscreen(1);
 808
 809 }
 810
 811 /*
 812 interface notes
 813
 814 cursor changes while in rbig to indicate region.
 815 only button 1 works for resizing region
 816 only button 1 works for moving thingy in ramp
 817
 818 button-3 menu: Reset, Depth, Undo, Save, Write
 819 */
 820
 821 Cursor tl = {
 822         {-4, -4},
 823         {0xfe, 0x00, 0x82, 0x00, 0x8c, 0x00, 0x87, 0xff,
 824          0xa0, 0x01, 0xb0, 0x01, 0xd0, 0x01, 0x11, 0xff,
 825          0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
 826          0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x1f, 0x00, },
 827         {0x00, 0x00, 0x7c, 0x00, 0x70, 0x00, 0x78, 0x00,
 828          0x5f, 0xfe, 0x4f, 0xfe, 0x0f, 0xfe, 0x0e, 0x00,
 829          0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
 830          0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x00, 0x00, }
 831 };
 832
 833 Cursor t = {
 834         {-7, -8},
 835         {0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x06, 0xc0,
 836          0x1c, 0x70, 0x10, 0x10, 0x0c, 0x60, 0xfc, 0x7f,
 837          0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xff, 0xff,
 838          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
 839         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
 840          0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80, 0x03, 0x80,
 841          0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00,
 842          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
 843 };
 844
 845 Cursor tr = {
 846         {-11, -4},
 847         {0x00, 0x7f, 0x00, 0x41, 0x00, 0x31, 0xff, 0xe1,
 848          0x80, 0x05, 0x80, 0x0d, 0x80, 0x0b, 0xff, 0x88,
 849          0x00, 0x88, 0x0, 0x88, 0x00, 0x88, 0x00, 0x88,
 850          0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0xf8, },
 851         {0x00, 0x00, 0x00, 0x3e, 0x00, 0x0e, 0x00, 0x1e,
 852          0x7f, 0xfa, 0x7f, 0xf2, 0x7f, 0xf0, 0x00, 0x70,
 853          0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
 854          0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, }
 855 };
 856
 857 Cursor r = {
 858         {-8, -7},
 859         {0x07, 0xc0, 0x04, 0x40, 0x04, 0x40, 0x04, 0x58,
 860          0x04, 0x68, 0x04, 0x6c, 0x04, 0x06, 0x04, 0x02,
 861          0x04, 0x06, 0x04, 0x6c, 0x04, 0x68, 0x04, 0x58,
 862          0x04, 0x40, 0x04, 0x40, 0x04, 0x40, 0x07, 0xc0, },
 863         {0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80,
 864          0x03, 0x90, 0x03, 0x90, 0x03, 0xf8, 0x03, 0xfc,
 865          0x03, 0xf8, 0x03, 0x90, 0x03, 0x90, 0x03, 0x80,
 866          0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
 867 };
 868
 869 Cursor br = {
 870         {-11, -11},
 871         {0x00, 0xf8, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
 872          0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
 873          0xff, 0x88, 0x80, 0x0b, 0x80, 0x0d, 0x80, 0x05,
 874          0xff, 0xe1, 0x00, 0x31, 0x00, 0x41, 0x00, 0x7f, },
 875         {0x00, 0x00, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
 876          0x0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
 877          0x00, 0x70, 0x7f, 0xf0, 0x7f, 0xf2, 0x7f, 0xfa,
 878          0x00, 0x1e, 0x00, 0x0e, 0x00, 0x3e, 0x00, 0x00, }
 879 };
 880
 881 Cursor b = {
 882         {-7, -7},
 883         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 884          0xff, 0xff, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
 885          0xfc, 0x7f, 0x0c, 0x60, 0x10, 0x10, 0x1c, 0x70,
 886          0x06, 0xc0, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, },
 887         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 888          0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe,
 889          0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80,
 890          0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
 891 };
 892
 893 Cursor bl = {
 894         {-4, -11},
 895         {0x1f, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
 896          0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
 897          0x11, 0xff, 0xd0, 0x01, 0xb0, 0x01, 0xa0, 0x01,
 898          0x87, 0xff, 0x8c, 0x00, 0x82, 0x00, 0xfe, 0x00, },
 899         {0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
 900          0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
 901          0x0e, 0x00, 0x0f, 0xfe, 0x4f, 0xfe, 0x5f, 0xfe,
 902          0x78, 0x00, 0x70, 0x00, 0x7c, 0x00, 0x00, 0x0, }
 903 };
 904
 905 Cursor l = {
 906         {-7, -7},
 907         {0x03, 0xe0, 0x02, 0x20, 0x02, 0x20, 0x1a, 0x20,
 908          0x16, 0x20, 0x36, 0x20, 0x60, 0x20, 0x40, 0x20,
 909          0x60, 0x20, 0x36, 0x20, 0x16, 0x20, 0x1a, 0x20,
 910          0x02, 0x20, 0x02, 0x20, 0x02, 0x20, 0x03, 0xe0, },
 911         {0x00, 0x00, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
 912          0x09, 0xc0, 0x09, 0xc0, 0x1f, 0xc0, 0x3f, 0xc0,
 913          0x1f, 0xc0, 0x09, 0xc0, 0x09, 0xc0, 0x01, 0xc0,
 914          0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x00, 0x00, }
 915 };
 916
 917 Cursor boxcursor = {
 918         {-7, -7},
 919         {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 920          0xFF, 0xFF, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F,
 921          0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xFF, 0xFF,
 922          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, },
 923         {0x00, 0x00, 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE,
 924          0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
 925          0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
 926          0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x00, 0x00, }
 927 };
 928
 929 Cursor clearcursor;
 930
 931 Cursor *corners[10] = {
 932         &tl,    &t,     &tr,
 933         &l,     &boxcursor,     &r,
 934         &bl,    &b,     &br,
 935         nil,    /* default arrow */
 936 };
 937
 938 char *item[] = {
 939         "Reset",
 940         "Depth",
 941         "Undo",
 942         "Write",
 943         "Exit",
 944         nil
 945 };
 946
 947 Menu menu = {
 948         item,
 949         nil,
 950         2
 951 };
 952
 953 /*BUG make less flashy */
 954 void
 955 moveface(Image *back, Point lastp, Image *face, Point p, Point d)
 956 {
 957         draw(screen, rectaddpt(back->r, subpt(lastp, d)), back, nil, back->r.min);
 958         draw(back, back->r, screen, nil, addpt(back->r.min, subpt(p, d)));
 959         border(screen, rectaddpt(face->r, subpt(p, d)),
 960                  -1, display->black, ZP);
 961         draw(screen, rectaddpt(face->r, subpt(p, d)),
 962                 face, nil, face->r.min);
 963 }
 964
 965 int
 966 dragface(Mouse *m, Image *im, Point d, int x)
 967 {
 968         int i;
 969         Point lastp;
 970         static Image *back;
 971
 972         if(back == nil){
 973                 back = allocimage(display, Rect(-1,-1,49,49), display->image->chan, 0, DNofill);
 974                 if(back == nil)
 975                         sysfatal("dragface backing store: %r");
 976         }
 977
 978         lastp = m->xy;
 979         draw(back, back->r, screen, nil, addpt(back->r.min, subpt(lastp, d)));
 980         esetcursor(&clearcursor);
 981         do{
 982                 moveface(back, lastp, im, m->xy, d);
 983                 lastp = m->xy;
 984         }while(*m=emouse(), m->buttons==1);
 985
 986         draw(screen, rectaddpt(back->r, subpt(lastp, d)), back, nil, back->r.min);
 987         esetcursor(nil);
 988         if(m->buttons==0){
 989                 for(i=0; i<nelem(face); i++)
 990                         if(ptinrect(m->xy, rface[i]))
 991                                 return i;
 992                 if(ptinrect(m->xy, rsmall))
 993                         return -1;
 994                 return x;
 995         }
 996         while(*m=emouse(), m->buttons)
 997                 ;
 998         return x;
 999 }
1000
1001 void
1002 initstate(void)
1003 {
1004         state.black = 0.0;
1005         state.white = 1.0;
1006         state.stretch = 1.0;
1007         state.depth = 4;
1008         state.gamma = 1.0;
1009         setgtab(&state);
1010         state.selr = insetrect(orig->r, 5);
1011         sdx = Dx(state.selr);
1012         sdy = Dy(state.selr);
1013         if(sdx > sdy)
1014                 state.selr.max.x = state.selr.min.x+sdy;
1015         else
1016                 state.selr.max.y = state.selr.min.y+sdx;
1017 }
1018
1019 void
1020 main(int argc, char **argv)
1021 {
1022         int ccursor, i, fd, k, n, y;
1023         uchar *data;
1024         double gammatab[256];
1025         Event e;
1026         Mouse m;
1027         Point lastp, p;
1028         Rectangle nselr, rbig9[9];
1029
1030         ARGBEGIN{
1031         default:
1032                 usage();
1033         }ARGEND
1034
1035         if(argc > 1)
1036                 usage();
1037         if(argc == 1){
1038                 if((fd = open(argv[0], OREAD)) < 0)
1039                         sysfatal("open %s: %r", argv[0]);
1040         }else
1041                 fd = 0;
1042
1043         if (initdraw(0, 0, "mug") < 0)
1044                 sysfatal("initdraw failed: %r");
1045
1046         if((orig = readimage(display, fd, 0)) == nil)
1047                 sysfatal("readimage: %r");
1048
1049         orig = grey8image(orig);
1050
1051         initramp();
1052         initclamp();
1053         initval2cmap();
1054         bkgd = allocimagemix(display, DPaleyellow, DWhite);
1055         small = allocimage(display, Rect(0,0,48,48), GREY4, 0, DWhite);
1056         tmp8 = allocimage(display, Rect(0,0,48,48), GREY8, 0, DWhite);
1057         red = allocimage(display, Rect(0,0,1,1), display->image->chan, 1, DRed);
1058         green = allocimage(display, Rect(0,0,1,1), display->image->chan, 1, DGreen);
1059         blue = allocimage(display, Rect(0,0,1,1), display->image->chan, 1, DBlue);
1060         if(bkgd==nil || small==nil || tmp8==nil || red==nil || green==nil || blue==nil)
1061                 sysfatal("allocimage: %r");
1062
1063         n = Dx(orig->r)*Dy(orig->r);
1064         data = emalloc(n*sizeof data[0]);
1065         rdata = emalloc(n*sizeof rdata[0]);
1066
1067         if(unloadimage(orig, orig->r, data, n) != n)
1068                 sysfatal("unloadimage: %r");
1069
1070         for(i=0; i<256; i++)
1071                 gammatab[i] = pow((255-i)/(double)255.0, GAMMA);
1072
1073         for(i=0; i<n; i++)
1074                 rdata[i] = gammatab[255-data[i]];
1075
1076         initstate();
1077         process(rdata, orig->r, state.selr, small);
1078         drawscreen(1);
1079         flushimage(display, 1);
1080         einit(Emouse|Ekeyboard);
1081         ccursor = 9;
1082         for(;;){
1083                 if((n=eread(Emouse|Ekeyboard, &e))==Ekeyboard)
1084                         continue;
1085                 if(n != Emouse)
1086                         break;
1087
1088                 m = e.mouse;
1089                 if(m.buttons&4){
1090                         ccursor = 9;
1091                         esetcursor(corners[ccursor]);
1092                         switch(emenuhit(3, &m, &menu)){
1093                         case -1:
1094                                 continue;
1095                         case 0: /* Reset */
1096                                 mark();
1097                                 initstate();
1098                                 small = allocimage(display, Rect(0,0,48,48), CHAN1(CGrey, state.depth), 0, DWhite);
1099                                 if(small == nil)
1100                                         sysfatal("allocimage: %r");
1101                                 process(rdata, orig->r, state.selr, small);
1102                                 drawface(-1);
1103                                 drawscreen(0);
1104                                 break;
1105                         case 1: /* Depth */
1106                                 mark();
1107                                 /* osmall = small, so no freeimage */
1108                                 state.depth /= 2;
1109                                 if(state.depth == 0)
1110                                         state.depth = 8;
1111                                 small = allocimage(display, Rect(0,0,48,48), CHAN1(CGrey, state.depth), 0, DWhite);
1112                                 if(small == nil)
1113                                         sysfatal("allocimage: %r");
1114                                 process(rdata, orig->r, state.selr, small);
1115                                 drawface(-1);
1116                                 break;
1117                         case 2: /* Undo */
1118                                 undo();
1119                                 break;
1120                         case 3: /* Write */
1121                                 writeface(nil, small);
1122                                 break;
1123                         case 4: /* Exit */
1124                                 exits(nil);
1125                                 break;
1126                         }
1127                 }
1128
1129                 if(ptinrect(m.xy, rbig)){
1130                         rlist(rectaddpt(state.selr, subpt(rbig.min, orig->r.min)), rbig9);
1131                         for(i=0; i<9; i++)
1132                                 if(ptinrect(m.xy, rbig9[i]))
1133                                         break;
1134                         if(i != ccursor){
1135                                 ccursor = i;
1136                                 esetcursor(corners[ccursor]);
1137                         }
1138                         if(i==9)
1139                                 continue;
1140
1141                         if(m.buttons & 1){
1142                                 mark();
1143                                 lastp = m.xy;
1144                                 while(m=emouse(), m.buttons&1){
1145                                         if(move(state.selr, orig->r, subpt(m.xy, lastp), i, &nselr)){
1146                                                 moveframe(state.selr, nselr);
1147                                                 state.selr = nselr;
1148                                                 lastp = m.xy;
1149                                                 process(rdata, orig->r, state.selr, small);
1150                                                 drawface(-1);
1151                                         }
1152                                 }
1153                         }
1154                         continue;
1155                 }
1156
1157                 if(ccursor != 9){       /* default cursor */
1158                         ccursor = 9;
1159                         esetcursor(corners[ccursor]);
1160                 }
1161
1162                 if(ptinrect(m.xy, rramp)){
1163                         if(m.buttons != 1)
1164                                 continue;
1165                         mark();
1166                         y = gamma2y(state.gamma);
1167                         if(abs(y-(m.xy.y-rramp.min.y)) > 5)
1168                                 continue;
1169                         k = section(m.xy.x-rramp.min.x);
1170                         drawrampbar(green, &state);
1171                         lastp = m.xy;
1172                         while(m=emouse(), m.buttons&1){
1173                                 if(!ptinrect(m.xy, rramp))
1174                                         continue;
1175                                 switch(k){
1176                                 case -1:
1177                                         continue;
1178                                 case 0:
1179                                         if((m.xy.x-rramp.min.x)/255.0 < state.white){
1180                                                 state.black = (m.xy.x-rramp.min.x)/255.0;
1181                                                 break;
1182                                         }
1183                                         continue;
1184                                 case 1:
1185                                         state.gamma = y2gamma(m.xy.y-rramp.min.y);
1186                                         setgtab(&state);
1187                                         break;
1188                                 case 2:
1189                                         if((m.xy.x-rramp.min.x)/255.0 > state.black){
1190                                                 state.white = (m.xy.x-rramp.min.x)/255.0;
1191                                                 break;
1192                                         }
1193                                         continue;
1194                                 case 10:
1195                                         state.black += (m.xy.x-lastp.x)/255.0;
1196                                         state.white += (m.xy.x-lastp.x)/255.0;
1197                                         state.gamma = y2gamma(p.y);
1198                                         break;
1199                                 }
1200                                 process(rdata, orig->r, state.selr, small);
1201                                 drawface(-1);
1202                                 drawrampbar(green, &state);
1203                         }
1204                         if(m.buttons == 0){
1205                                 process(rdata, orig->r, state.selr, small);
1206                                 drawface(-1);
1207                                 drawrampbar(red, &state);
1208                         }else
1209                                 undo();
1210                         continue;
1211                 }
1212
1213                 if(ptinrect(m.xy, rsmall)){
1214                         if(m.buttons != 1)
1215                                 continue;
1216                         n=dragface(&m, small, subpt(m.xy, rsmall.min), -1);
1217                         if(n == -1)
1218                                 continue;
1219                         saveface(nil, n);
1220                 }
1221
1222                 for(i=0; i<nelem(face); i++)
1223                         if(ptinrect(m.xy, rface[i]))
1224                                 break;
1225                 if(i<nelem(face) && face[i] != nil){
1226                         if(m.buttons != 1)
1227                                 continue;
1228                         n=dragface(&m, face[i]->small, subpt(m.xy, rface[i].min), i);
1229                         if(n == i)
1230                                 continue;
1231                         saveface(face[i], n);
1232                         continue;
1233                 }
1234
1235                 do
1236                         m = emouse();
1237                 while(m.buttons==1);
1238         }
1239         exits(nil);
1240 }