src/edu/berkeley/obits/gui/Gui.java

   1 package edu.berkeley.obits.gui;
   2
   3 import static edu.berkeley.obits.device.atmel.AtmelDevice.Constants.*;
   4 import static edu.berkeley.obits.device.atmel.AtmelDevice.Util.*;
   5 import edu.berkeley.obits.*;
   6 import edu.berkeley.obits.device.atmel.*;
   7 import java.awt.*;
   8 import java.awt.geom.*;
   9 import java.awt.event.*;
  10 import java.awt.color.*;
  11 import org.ibex.util.*;
  12 import java.io.*;
  13 import java.util.*;
  14 import javax.swing.*;
  15 import static edu.berkeley.obits.gui.GuiConstants.*;
  16
  17 public class Gui extends ZoomingPanel implements KeyListener, MouseMotionListener {
  18
  19     Graphics2D g;
  20     G gg;
  21
  22     At40k at40k;
  23     AvrDrone drone;
  24
  25     private Cell[][] ca = new Cell[128][];
  26
  27     //public static final Color nonselectedcell = new Color(0x44, 0x44, 0x44);
  28     public static final Color nonselectedcell = new Color(0xee, 0xee, 0xee);
  29     public static final Color selectedcell    = new Color(0x00, 0x00, 0x00);
  30
  31     public void writeMode4() {
  32         try {
  33             final JFileChooser fc = new JFileChooser();
  34             int returnVal = fc.showSaveDialog(this);
  35             Writer pw = new OutputStreamWriter(new FileOutputStream(fc.getSelectedFile()));
  36             drone.writeMode4(pw);
  37             pw.flush();
  38             pw.close();
  39             System.err.println("done writing");
  40         } catch (Exception e) {
  41             e.printStackTrace();
  42         }
  43     }
  44
  45     public void readMode4() {
  46         try {
  47             final JFileChooser fc = new JFileChooser();
  48             int returnVal = fc.showOpenDialog(this);
  49             drone.readMode4(new FileInputStream(fc.getSelectedFile()));
  50             System.err.println("done reading");
  51             repaint();
  52         } catch (Exception e) {
  53             e.printStackTrace();
  54         }
  55     }
  56
  57     public Gui(At40k at40k, AvrDrone drone) {
  58         this.at40k = at40k;
  59         this.drone = drone;
  60         for(int i=0; i<ca.length; i++)
  61             ca[i] = new Cell[128];
  62         for(int x=7; x<17; x++)
  63             for(int y=7; y<17; y++)
  64                 new Cell(x-7,y-7, at40k.cell(x, y));
  65         /*
  66         At40k.Cell c = at40k.cell(0,0);
  67         for(int i=0; i<256; i++) {
  68             c.ylut(i);
  69             System.out.println(c.printYLut());
  70         }
  71         */
  72     }
  73
  74     public class Cell {
  75         At40k.Cell cell;
  76         boolean in = false;
  77         public boolean xon = false;
  78         public boolean yon = false;
  79         public boolean xknown = false;
  80         public boolean yknown = false;
  81         int _x, _y;
  82         public Cell(int x, int y, At40k.Cell cell) {
  83             _x = x;
  84             _y = y;
  85             ca[_x][_y] = this;
  86             this.cell = cell;
  87             cells.add(this);
  88         }
  89         public void clear() {
  90             gg.color(in ? selectedcell : nonselectedcell);
  91             g.fillRect(0, 0, SIZE, SIZE);
  92         }
  93         public void draw() {
  94
  95             drawWires();
  96             drawLocal();
  97
  98             AffineTransform t = g.getTransform();
  99
 100             drawBuffer();
 101             g.transform(rotateInnerTransform());
 102             drawMux();
 103             drawRegister();
 104             drawInternalRouting();
 105             g.setTransform(t);
 106
 107             drawGates();
 108             drawBorder();
 109         }
 110         public void drawBuffer() {
 111             /*
 112             if (!cell.out_relevant()) return;
 113
 114             GeneralPath p = new GeneralPath();
 115             p.moveTo(24, 61);
 116             p.lineTo(22, 68);
 117             p.lineTo(29, 66);
 118             p.lineTo(24, 61);
 119             gg.color(cell.oe() == NONE ? Color.white : Color.green);
 120             g.fill(p);
 121             gg.color(Color.green);
 122             g.draw(p);
 123
 124             gg.color(Color.magenta);
 125             if (cell.oe() == V4) {
 126                 gg.line(24, 62, 16, 63);
 127             } else if (cell.oe() == H4) {
 128                 gg.line(24, 67, 24, 76);
 129             }
 130             */
 131         }
 132         public void drawWires() {
 133             gg.color(MAGENTA);
 134             for(int i=0; i<5; i++)
 135                 if (cell.hwire(i).isDriven()) {
 136                     gg.color(cell.out(i) ? ORANGE : MAGENTA);
 137                     gg.line(0, SIZE-(2*(1+RINGS)+2*i), SIZE, SIZE-(2*(1+RINGS)+2*i));
 138                 }
 139             for(int i=0; i<5; i++)
 140                 if (cell.vwire(i).isDriven()) {
 141                     gg.color(cell.out(i) ? ORANGE : MAGENTA);
 142                     gg.line(2*(1+RINGS)+2*i, 0, 2*(1+RINGS)+2*i, SIZE);
 143                 }
 144             if (cell.zi_to_xlut_relevant()) wire(cell.zi(), true);
 145             if (cell.zi_to_ylut_relevant()) wire(cell.zi(), false);
 146             if (cell.zi_to_xlut_relevant()) wire(cell.wi(), true);
 147             if (cell.zi_to_ylut_relevant()) wire(cell.wi(), false);
 148         }
 149
 150         public void wire(int plane, boolean xlut) {
 151             if (!(plane >= L0 && plane <= L4 && cell.vx(plane))) return;
 152             if (xlut ? xlut_relevant(cell) : cell.ylut_relevant())
 153                 route(new P(17 - 2*(plane-L0), 8),
 154                       rotateInner(xlut ? new P(38, 18) : new P(64, 18)),
 155                       3);
 156         }
 157
 158         public P corner(int corner, int size, int ring) {
 159             switch(corner) {
 160                 case NW: return new P(0    +2*ring,  size -2*ring);
 161                 case SW: return new P(0    +2*ring,  0    +2*ring);
 162                 case NE: return new P(size -2*ring,  size -2*ring);
 163                 case SE: return new P(size -2*ring,  0    +2*ring);
 164                 default: return null;
 165             }
 166         }
 167
 168         public void drawInternalRouting() {
 169             gg.color(ORANGE);
 170             if (cell.fb_relevant()) {
 171                 if (cell.f()) {
 172                     gg.line(51, 74, 37, 74);
 173                     gg.line(37, 74, 51, 12);
 174                 } else if (cell.c() == XLUT) {
 175                     gg.color(LIGHTRED);
 176                     gg.line(33, 52, 51, 52);
 177                     gg.line(51, 52, 51, 12);
 178                 } else if (cell.c() == YLUT) {
 179                     gg.color(LIGHTBLUE);
 180                     gg.line(67, 52, 51, 52);
 181                     gg.line(51, 52, 51, 12);
 182                 } else {
 183                     gg.line(51, 56, 41, 56);
 184                     gg.line(41, 56, 51, 12);
 185                 }
 186                 if (xlut_relevant(cell)) {
 187                     gg.line(52, 12, XLUT_OUTPUT_POINT.getX(), 12);
 188                     gg.line(XLUT_OUTPUT_POINT.getX(), 12, XLUT_OUTPUT_POINT.getX(), 32);
 189                 }
 190                 if (cell.ylut_relevant()) {
 191                     gg.line(52, 12, YLUT_OUTPUT_POINT.getX(), 12);
 192                     gg.line(YLUT_OUTPUT_POINT.getX(), 12, YLUT_OUTPUT_POINT.getX(), 32);
 193                 }
 194             }
 195         }
 196
 197         public void drawLocal() {
 198             if (!cell.ylut_relevant() && !xlut_relevant(cell)) return;
 199
 200             P in = rotateOuter(new P(HOFF, 0));
 201             P join = rotateInner(new P(HOFF, CORE_OFFSET));
 202             int rot = rot();
 203             switch(rot) {
 204                 case 0: case 2:
 205                     join = new P(in.getX(), join.getY());
 206                     break;
 207                 case 1: case 3:
 208                     join = new P(join.getX(), in.getY());
 209                     break;
 210             }
 211
 212             // x-input to cell
 213             gg.color(RED);
 214             P xi  = corner(cell.xi(), SIZE, 4);
 215             if ((cell.xlut_relevant() && cell.xi_to_xlut_relevant()) ||
 216                 (cell.ylut_relevant() && cell.xi_to_ylut_relevant())
 217                 && (cell.xi() != NONE)
 218                 ) {
 219                 P xi2 = corner(cell.xi(), SIZE + 2*BEVEL, -1).translate(-BEVEL, -BEVEL);
 220                 switch(cell.xi()) {
 221                     case NW: case NE:
 222                         xi = translate(xi, 0, -3);
 223                         xi2 = translate(xi2, 0, -3);
 224                         break;
 225                     case SW: case SE:
 226                         xi = translate(xi, 0, 3);
 227                         xi2 = translate(xi2, 0, 3);
 228                         break;
 229                 }
 230                 gg.line(xi2, xi);
 231             }
 232
 233             if (xlut_relevant(cell)) {
 234
 235                 if (cell.xi_to_xlut_relevant() && xi != null)
 236                     route(xi, rotateInner(new P(SIZE - CORE_OFFSET - CORE_SIZE/2 - CORE_SIZE / 3, 20)), 4);
 237
 238                 // xlut y-input
 239                 gg.color(BLUE);
 240                 if (cell.yi_to_xlut_relevant())
 241                     route(in, rotateInner(new P(SIZE - CORE_OFFSET - CORE_SIZE/2 - CORE_SIZE / 6, 20)), 5);
 242
 243                 // xlut output
 244                 int xring = 4;
 245                 gg.color(cell.xo() ? ORANGE : LIGHTRED);
 246                 P xout = rotateInner(new P(SIZE-CORE_OFFSET-CORE_SIZE+17 - 2, CORE_OFFSET + CORE_SIZE - 3));
 247                 if (cell.xo()) {
 248                     xout = rotateInner(new P(51, 74));
 249                     gg.line(rotateInner(new P(51, 62)), xout);
 250                 } else if (cell.xo_relevant()) {
 251                     gg.line(rotateInner(XLUT_OUTPUT_POINT), xout);
 252                 }
 253                 if (cell.xo_relevant(NE)) {
 254                     gg.line(corner(NE, SIZE, xring).translate(0, 3), corner(NE, SIZE, 0).translate(0, 3));
 255                     route(xout, corner(NE, SIZE, xring).translate(0, 3), xring);
 256                 }
 257                 if (cell.xo_relevant(NW)) {
 258                     gg.line(corner(NW, SIZE, xring).translate(0, 3),  corner(NW, SIZE, 0).translate(0, 3));
 259                     route(xout, corner(NW, SIZE, xring).translate(0, 3),  xring);
 260                 }
 261                 if (cell.xo_relevant(SE)) {
 262                     gg.line(corner(SE, SIZE, xring).translate(0, -3), corner(SE, SIZE, 0).translate(0, -3));
 263                     route(xout, corner(SE, SIZE, xring).translate(0, -3), xring);
 264                 }
 265                 if (cell.xo_relevant(SW)) {
 266                     gg.line(corner(SW, SIZE, xring).translate(0, -3),  corner(SW, SIZE, 0).translate(0, -3));
 267                     route(xout, corner(SW, SIZE, xring).translate(0, -3),  xring);
 268                 }
 269             }
 270
 271             if (cell.ylut_relevant()) {
 272
 273                 // ylut y-input
 274                 gg.color(BLUE);
 275                 if (cell.yi_to_ylut_relevant())
 276                     route(in, rotateInner(new P(SIZE - CORE_OFFSET - CORE_SIZE/2 + CORE_SIZE / 6, 20)), 5);
 277
 278                 // ylut x-input
 279                 gg.color(RED);
 280                 if (xi != null && cell.xi_to_ylut_relevant())
 281                     route(xi, rotateInner(new P(SIZE - CORE_OFFSET - CORE_SIZE/2 + CORE_SIZE / 3, 20)), 4);
 282
 283                 // lines directly from the ylut output to the four neighbors
 284                 gg.color(cell.yo() ? ORANGE : LIGHTBLUE);
 285                 P yout = rotateInner(new P(SIZE-CORE_OFFSET-CORE_SIZE+51 - 2, CORE_OFFSET + CORE_SIZE - 3));
 286                 if (cell.yo()) {
 287                     yout = rotateInner(new P(51, 74));
 288                     gg.line(rotateInner(new P(51, 62)), yout);
 289                 } else if (cell.yo_relevant()) {
 290                     gg.line(rotateInner(YLUT_OUTPUT_POINT), yout);
 291                 }
 292                 if (cell.yo_relevant(NORTH)) route(yout, new P(SIZE-40, SIZE+ 0), 2);
 293                 if (cell.yo_relevant(EAST))  route(yout, new P(SIZE+ 0,      40), 2);
 294                 if (cell.yo_relevant(SOUTH)) route(yout, new P(     40,       0), 2);
 295                 if (cell.yo_relevant(WEST))  route(yout, new P(      0, SIZE-40), 2);
 296             }
 297
 298         }
 299
 300         private AffineTransform rotateOuterTransform() {
 301             int rot = rot();
 302             AffineTransform a = new AffineTransform();
 303             a.rotate((Math.PI/2) * rot);
 304             switch(rot) {
 305                 case 0: break;
 306                 case 1: a.translate(0,  -SIZE); break;
 307                 case 2: a.translate(-SIZE, -SIZE); break;
 308                 case 3: a.translate(-SIZE, 0); break;
 309             }
 310             return a;
 311         }
 312
 313         private P rotateOuter(P p) { return p.transform(rotateOuterTransform()); }
 314         private P rotateInner(P p) { return p.transform(rotateInnerTransform()); }
 315         private P unRotateInner(P p) { return p.inverseTransform(rotateInnerTransform()); }
 316
 317         private AffineTransform rotateInnerTransform() {
 318             int rot = rot();
 319             AffineTransform a = new AffineTransform();
 320             a.translate(SIZE-CORE_SIZE-CORE_OFFSET, CORE_OFFSET);
 321             a.rotate((Math.PI/2) * rot);
 322             switch(rot) {
 323                 case 0: break;
 324                 case 1: a.translate(0,  -CORE_SIZE); break;
 325                 case 2: a.translate(-CORE_SIZE, -CORE_SIZE); break;
 326                 case 3: a.translate(-CORE_SIZE, 0); break;
 327             }
 328             a.translate(-1 * (SIZE-CORE_SIZE-CORE_OFFSET), -CORE_OFFSET);
 329             return a;
 330         }
 331
 332
 333         private P project(P p1, int ring) {
 334             double north = Math.abs( (SIZE-(ring*2)) - p1.getY() );
 335             double south = Math.abs( (     (ring*2)) - p1.getY() );
 336             double east  = Math.abs( (SIZE-(ring*2)) - p1.getX() );
 337             double west  = Math.abs( (     (ring*2)) - p1.getX() );
 338             if (north < south && north < east && north < west) return new P(p1.x,        SIZE-ring*2);
 339             else if (south < east && south < west)             return new P(p1.x,        ring*2);
 340             else if (east < west)                              return new P(SIZE-ring*2, p1.y);
 341             else                                               return new P(ring*2,      p1.y);
 342
 343         }
 344
 345         private void route(P p1, P p2, int ring) {
 346             int ringpos = ring * 2;
 347             P projected = project(p1, ring);
 348             gg.line(p1, projected);
 349             p1 = projected;
 350
 351             projected = project(p2, ring);
 352             gg.line(p2, projected);
 353             p2 = projected;
 354
 355             if (p1.x==p2.x || p1.y==p2.y) {
 356                 gg.line(p1, p2);
 357                 return;
 358             }
 359
 360             if ((p1.x==SIZE-ring*2 || p1.x==ring*2) && !(p1.y==SIZE-ring*2 || p1.y==ring*2)) {
 361                 P p3 = new P(p1.x, p2.y > SIZE/2 ? SIZE-ring*2 : ring*2);
 362                 gg.line(p1, p3);
 363                 route(p3, p2, ring);
 364             } else if ((p1.y==SIZE-ring*2 || p1.y==ring*2) && !(p1.x==SIZE-ring*2 || p1.x==ring*2)) {
 365                 P p3 = new P(p2.x > SIZE/2 ? SIZE-ring*2 : ring*2, p1.y);
 366                 gg.line(p1, p3);
 367                 route(p3, p2, ring);
 368             } else
 369                 route(p2, p1, ring);
 370         }
 371
 372         private int rot() {
 373             int rot = 0;
 374             switch(cell.yi()) {
 375                 case SOUTH: rot = 0; break;
 376                 case NORTH: rot = 2; break;
 377                 case EAST: rot = 1; break;
 378                 case WEST: rot = 3; break;
 379                 default: {
 380                     // FIXME: choose based on xin
 381                     if (cell.north() != null && cell.north().yi()==SOUTH) { rot = 0; break; }
 382                     if (cell.south() != null && cell.south().yi()==NORTH) { rot = 2; break; }
 383                     if (cell.east()  != null && cell.east().yi()==WEST) { rot = 3; break; }
 384                     if (cell.west()  != null && cell.west().yi()==EAST) { rot = 1; break; }
 385                 }
 386             }
 387             return rot;
 388         }
 389
 390         public void drawGates() {
 391             AffineTransform t = g.getTransform();
 392             try {
 393                 g.translate(SIZE-CORE_SIZE-CORE_OFFSET, CORE_OFFSET);
 394
 395                 int rot = rot();
 396                 g.rotate((Math.PI/2) * rot);
 397                 switch(rot) {
 398                     case 0: break;
 399                     case 1: g.translate(0,  -CORE_SIZE); break;
 400                     case 2: g.translate(-CORE_SIZE, -CORE_SIZE); break;
 401                     case 3: g.translate(-CORE_SIZE, 0); break;
 402                 }
 403
 404                 //gg.color(Color.gray);
 405                 //g.drawRect(0, 0, CORE_SIZE, CORE_SIZE);
 406                 //g.scale(1, -1);
 407
 408                 Gate gate = new Muller();
 409
 410                 g.translate(2,   5f);
 411                 if (xlut_relevant(cell))
 412                     gate.draw(g,
 413                               !xknown ? Color.gray : xon ? Color.red : Color.white,
 414                               (xon && xknown) ? Color.white : Color.red);
 415                 g.translate(34f, 0f);
 416                 if (cell.ylut_relevant())
 417                     gate.draw(g,
 418                               !yknown ? Color.gray : yon ? Color.blue : Color.white,
 419                               (yon && yknown) ? Color.white : Color.blue);
 420             } finally {
 421                 g.setTransform(t);
 422             }
 423         }
 424         public void drawMux() {
 425             if (!cell.c_relevant()) return;
 426             gg.color(Color.black);
 427             if (xlut_relevant(cell) && (cell.c() == ZMUX || cell.c() == XLUT)) {
 428                 gg.color(LIGHTRED);
 429                 gg.line(XLUT_OUTPUT_POINT, new P(XLUT_OUTPUT_POINT.getX(), 52));
 430                 gg.line(new P(XLUT_OUTPUT_POINT.getX(), 52), new P(51, 52));
 431             }
 432             if (cell.ylut_relevant() && (cell.c() == ZMUX || cell.c() == YLUT)) {
 433                 gg.color(LIGHTBLUE);
 434                 gg.line(YLUT_OUTPUT_POINT, new P(YLUT_OUTPUT_POINT.getX(), 52));
 435                 gg.line(new P(YLUT_OUTPUT_POINT.getX(), 52), new P(51, 52));
 436             }
 437             if (cell.c() == ZMUX)
 438                 gg.color(ORANGE);
 439
 440             gg.line(51, 52, 51, 51+23);
 441
 442             if (cell.register_relevant() && cell.f() && !cell.b()) {
 443                 gg.line(51, 56, 60, 56);
 444                 gg.line(60, 56, 60, 51+25);
 445             } else {
 446                 gg.line(51, 51+23, 51, 51+25);
 447             }
 448
 449             if (cell.c() == ZMUX) {
 450
 451                 gg.color(GREEN);
 452                 int plane = cell.zi()+1;
 453                 route(unRotateInner(new P(8 + 2*(plane-L0),  76 + 2*(plane-L0))),
 454                       new P(51, 20),
 455                       3);
 456                 gg.line(new P(51, 20), new P(51, 50));
 457
 458                 GeneralPath p = new GeneralPath();
 459                 p.moveTo(45, 50);
 460                 p.lineTo(47, 54);
 461                 p.lineTo(56, 54);
 462                 p.lineTo(58, 50);
 463                 p.lineTo(45, 50);
 464                 gg.color(WHITE);
 465                 gg.g.fill(p);
 466
 467                 gg.color(ORANGE);
 468                 gg.g.draw(p);
 469
 470             }
 471         }
 472         public int ccolor() {
 473             switch(cell.c()) {
 474                 case XLUT: return LIGHTRED;
 475                 case YLUT: return LIGHTBLUE;
 476                 case ZMUX: return ORANGE;
 477             }
 478             return BLACK;
 479         }
 480         public void drawRegister() {
 481             if (!cell.register_relevant()) return;
 482
 483             int dark = ccolor();
 484             gg.color(Color.white);
 485             g.fillRect(47, 58, 9, 14);
 486             gg.color(dark);
 487             g.drawRect(47, 58, 9, 14);
 488
 489             GeneralPath p = new GeneralPath();
 490             p.moveTo(56, 70);
 491             p.lineTo(53, 68);
 492             p.lineTo(56, 66);
 493             p.lineTo(56, 70);
 494             gg.color(cell.ff_reset_value() ? WHITE : dark);
 495             g.fill(p);
 496             gg.color(dark);
 497             g.draw(p);
 498         }
 499         public void drawBorder() {
 500             gg.color(Color.gray);
 501             gg.line(BEVEL, 0, SIZE-BEVEL, 0);
 502             gg.line(SIZE, BEVEL, SIZE, SIZE-BEVEL);
 503             gg.line(SIZE-BEVEL, SIZE, BEVEL, SIZE);
 504             gg.line(0, SIZE-BEVEL, 0, BEVEL);
 505             /*
 506             gg.color(0xdddddd);
 507             gg.line(0, BEVEL, BEVEL,    0);
 508             gg.line(SIZE-BEVEL, 0, SIZE, BEVEL);
 509             gg.line(SIZE, SIZE-BEVEL, SIZE-BEVEL, SIZE);
 510             gg.line(BEVEL, SIZE, 0, SIZE-BEVEL);
 511             */
 512         }
 513     }
 514
 515     public void _paint(Graphics2D g) {
 516
 517         this.g = g;
 518         this.gg = new G(g);
 519         g.setStroke(new BasicStroke((float)0.5));
 520
 521         g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 522         g.setRenderingHint(RenderingHints.KEY_RENDERING,    RenderingHints.VALUE_RENDER_QUALITY);
 523
 524         AffineTransform t  = g.getTransform();
 525         for(Cell c : cells) {
 526             g.setTransform(t);
 527             g.translate(     c._x * SIZE /*+ (10 * (c._x/4))*/,      c._y * SIZE /*+ (10 * (c._y/4))*/);
 528             c.clear();
 529         }
 530         for(Cell c : cells) {
 531             g.setTransform(t);
 532             g.translate(     c._x * SIZE /*+ (10 * (c._x/4))*/,      c._y * SIZE /*+ (10 * (c._y/4))*/);
 533             c.draw();
 534         }
 535         g.setTransform(t);
 536
 537         g.setTransform(new AffineTransform());
 538
 539         gg.color(selectedcell);
 540         g.fillRect(getWidth() - 200, 0, 200, 600);
 541         gg.color(Color.white);
 542         g.drawRect(getWidth() - 200, 0, 200, 600);
 543
 544         Cell newcell = whichCell(mousex, mousey);
 545         int line = 10;
 546         g.setFont(new Font("monospaced", 0, 14));
 547         if (newcell != null && newcell.cell != null) {
 548             g.drawString("selected: " + newcell._x + ","+newcell._y,
 549                          getWidth() - 200 + 10, (line += 15));
 550             g.drawString("    xlut: " + XLUT_EQUATIONS[newcell.cell.xlut() & 0xff],
 551                          getWidth() - 200 + 10, (line += 15));
 552             g.drawString("    ylut: " + YLUT_EQUATIONS[newcell.cell.ylut() & 0xff],
 553                          getWidth() - 200 + 10, (line += 15));
 554             String xi = "??";
 555             switch(newcell.cell.xi()) {
 556                 case NW : xi = "NW"; break;
 557                 case NE : xi = "NE"; break;
 558                 case SW : xi = "SW"; break;
 559                 case SE : xi = "SE"; break;
 560                 case NONE  : xi = "."; break;
 561                 default:  xi = "L"+(newcell.cell.xi()-L0); break;
 562             }
 563             g.drawString("      xi: " + xi, getWidth() - 200 + 10, (line += 15));
 564
 565             String yi = "??";
 566             switch(newcell.cell.yi()) {
 567                 case NORTH : yi = "NORTH"; break;
 568                 case SOUTH : yi = "SOUTH"; break;
 569                 case EAST  : yi = "EAST"; break;
 570                 case WEST  : yi = "WEST"; break;
 571                 case NONE  : yi = "."; break;
 572                 default:     yi = "L"+(newcell.cell.yi()-L0); break;
 573             }
 574             g.drawString("      yi: " + yi, getWidth() - 200 + 10, (line += 15));
 575
 576             g.drawString("      wi: " + (newcell.cell.wi()==NONE ? "." : ("L"+(newcell.cell.wi()-L0))),
 577                          getWidth() - 200 + 10, (line += 15));
 578             g.drawString("      zi: " + (newcell.cell.zi()==NONE ? "." : ("L"+(newcell.cell.zi()-L0))),
 579                          getWidth() - 200 + 10, (line += 15));
 580
 581             g.drawString("      FF: " + (newcell.cell.ff_reset_value() ? "reset=SET" : "."),
 582                          getWidth() - 200 + 10, (line += 15));
 583
 584             String outs = "";
 585             for(int i=0; i<5; i++) outs += (newcell.cell.out(L0+i) ? (i+" ") : ". ");
 586             g.drawString("     out: " + outs,
 587                          getWidth() - 200 + 10, (line += 15));
 588             String hs = "";
 589             for(int i=0; i<5; i++) hs += (newcell.cell.hx(L0+i) ? (i+" ") : ". ");
 590             g.drawString("       H: " + hs,
 591                          getWidth() - 200 + 10, (line += 15));
 592             String vs = "";
 593             for(int i=0; i<5; i++) vs += (newcell.cell.vx(L0+i) ? (i+" ") : ". ");
 594             g.drawString("       V: " + vs,
 595                          getWidth() - 200 + 10, (line += 15));
 596             g.drawString("      OE: " + (newcell.cell.oe()==H4 ? "H4" : newcell.cell.oe()==V4 ? "V4" : "."),
 597                          getWidth() - 200 + 10, (line += 15));
 598             g.drawString("  center: " + (newcell.cell.c()==ZMUX ? "zmux" : newcell.cell.c()==XLUT ? "x-lut" : "y-lut"),
 599                          getWidth() - 200 + 10, (line += 15));
 600             g.drawString("  fb/out: " + (newcell.cell.f() ? "clocked" : "."),
 601                          getWidth() - 200 + 10, (line += 15));
 602             g.drawString("  bypass: " + (newcell.cell.b() ? "clocked" : "."),
 603                          getWidth() - 200 + 10, (line += 15));
 604             g.drawString("   x out: " + (newcell.cell.xo() ? (newcell.cell.b() ? "register" : "center") : "."),
 605                          getWidth() - 200 + 10, (line += 15));
 606             g.drawString("   y out: " + (newcell.cell.yo() ? (newcell.cell.b() ? "register" : "center") : "."),
 607                          getWidth() - 200 + 10, (line += 15));
 608
 609         }
 610         this.g = null;
 611         this.gg = null;
 612     }
 613
 614
 615     public void clear() {
 616         Graphics2D g = (Graphics2D)getGraphics();
 617         //gg.color(Color.black);
 618         //gg.color(Color.lightGray);
 619         g.clearRect(0, 0, getWidth(), getHeight());
 620     }
 621
 622     public static final P translate(P p, int dx, int dy) {
 623         return new P(p.getX()+dx, p.getY()+dy);
 624     }
 625
 626     public Cell whichCell(int x, int y) {
 627         P p = new P(x,y);
 628         try {
 629             p = p.inverseTransform(transform);
 630         } catch (Exception e) {
 631             e.printStackTrace();
 632         }
 633         int col = ((int)p.getX()+0) / SIZE;
 634         int row = ((int)p.getY()+0) / SIZE;
 635         for(Cell c : cells)
 636             if (c._x == col && c._y == row)
 637                 return c;
 638         return null;
 639     }
 640
 641     public static boolean xlut_relevant(At40k.Cell c) {
 642         return c.xlut_relevant();
 643     }
 644
 645     public void mouseClicked(MouseEvent e) {
 646         System.out.println("click");
 647         final Cell c = whichCell(e.getX(), e.getY());
 648         if (c==null) return;
 649         System.out.println("click at " + c._x + "," + c._y);
 650         scan(c);
 651     }
 652
 653     public void scan() {
 654         for(int x=0; x<ca.length; x++)
 655             for(int y=0; y<ca[x].length; y++)
 656                 if (ca[x][y] != null)
 657                     scan(ca[x][y]);
 658     }
 659     public void scan(final Gui.Cell c) {
 660         final At40k.Cell cell = c.cell;
 661         AtmelSerial.scan(at40k, cell, NONE, true);
 662         boolean safe = !cell.fb_relevant();
 663         if (cell.xo()) safe = false;
 664         if (cell.yo()) safe = false;
 665         for(int i=0; i<5; i++)
 666             if (cell.out(i))
 667                 safe = false;
 668         if (safe) {
 669             int oldc = cell.c();
 670             if (cell.xlut_relevant()) {
 671                 cell.c(XLUT);
 672                 drone.readBus(new BCB(c, XLUT));
 673             }
 674             if (cell.ylut_relevant()) {
 675                 cell.c(YLUT);
 676                 drone.readBus(new BCB(c, YLUT));
 677             }
 678             cell.c(oldc);
 679         } else {
 680             switch(cell.c()) {
 681                 case XLUT: if (cell.xlut_relevant()) drone.readBus(new BCB(c, XLUT)); break;
 682                 case YLUT: if (cell.ylut_relevant()) drone.readBus(new BCB(c, YLUT)); break;
 683             }
 684
 685         }
 686         AtmelSerial.scan(at40k, cell, NONE, false);
 687     }
 688
 689     private class BCB implements AvrDrone.ByteCallback {
 690         Gui.Cell c;
 691         int who;
 692         public BCB(Gui.Cell c, int who) { this.who = who; this.c = c; }
 693         public void call(byte b) throws Exception {
 694             System.out.println("callback: " + b);
 695             boolean on = (b & 0x80) != 0;
 696             c.xknown = false;
 697             c.yknown = false;
 698             switch(who) {
 699                 case YLUT:
 700                     c.yknown = true;
 701                     c.yon = on;
 702                     repaint();
 703                     break;
 704                 case XLUT:
 705                     c.xknown = true;
 706                     c.xon = on;
 707                     repaint();
 708                     break;
 709             }
 710         }
 711     }
 712
 713     // FIXME: 2-input gates?
 714     public abstract class Gate {
 715         public boolean invert_x;
 716         public boolean invert_y;
 717         public boolean invert_z;
 718         public boolean invert_out;
 719         public abstract boolean result(boolean x, boolean y, boolean z);
 720         public void draw(Graphics2D g, Color fill, Color stroke) {
 721             GeneralPath p = new GeneralPath();
 722             makePath(p);
 723             g.setColor(fill);
 724             g.fill(p);
 725             g.setColor(stroke);
 726             g.draw(p);
 727
 728             AffineTransform a = g.getTransform();
 729             g.scale(1, -1);
 730             g.setColor(Color.white);
 731             if (label() != null) g.drawString(label(), 7, -14);
 732             g.setTransform(a);
 733         }
 734         public String label() { return null; }
 735         public boolean setLut(int lut) {
 736             for(int inverts = 0; inverts < 16; inverts++) {
 737                 invert_x   = (inverts & 0x1) != 0;
 738                 invert_y   = (inverts & 0x2) != 0;
 739                 invert_z   = (inverts & 0x4) != 0;
 740                 invert_out = (inverts & 0x8) != 0;
 741                 for(int bit=0; bit<8; bit++) {
 742                     boolean x = (bit & 0x1) != 0;
 743                     boolean y = (bit & 0x2) != 0;
 744                     boolean z = (bit & 0x4) != 0;
 745                     boolean expect = (lut & (1<<bit)) != 0;
 746
 747                     // FIXME symmetry issues here....
 748                     boolean result = result(x ^ invert_x, y ^ invert_y, z ^ invert_z) ^ invert_out;
 749                     if (result == expect) return true;
 750                 }
 751             }
 752             return false;
 753         }
 754         public abstract void makePath(GeneralPath gp);
 755     }
 756
 757     public class Or extends Gate {
 758         public boolean result(boolean x, boolean y, boolean z) { return x || y || z; }
 759         public String label() { return "+"; }
 760         public void draw(Graphics2D g, Color fill, Color stroke) {
 761             AffineTransform at = g.getTransform();
 762             g.scale(1, -1);
 763             g.translate(0, -40);
 764             super.draw(g, fill, stroke);
 765             g.setTransform(at);
 766         }
 767         public void makePath(GeneralPath gp) {
 768             gp.moveTo(29.141f, 36.301f);
 769             gp.lineTo(29.141f, 36.301f-7.161f);
 770             gp.curveTo(27.71f, 11.24f, 23.413f, 9.45f, 14.82f, 0.5f);
 771             gp.curveTo(6.229f, 9.45f, 1.932f, 11.24f, 0.5f, 29.141f);
 772             gp.lineTo(0.5f, 29.141f+7.161f);
 773             float x = 0.5f;
 774             float y = 29.141f+7.161f;
 775             gp.curveTo(5.729f+x, -1.789f+y,
 776                        6.444f+x, -2.686f+y,
 777                        14.32f+x, -3.58f+y);
 778             gp.curveTo(22.697f, 33.616f, 23.413f, 34.512f, 29.141f, 36.301f);
 779         }
 780     }
 781
 782     public class And extends Gate {
 783         public boolean result(boolean x, boolean y, boolean z) { return x && y && z; }
 784         public String label() { return "&"; }
 785         public void makePath(GeneralPath gp) {
 786             gp.moveTo(0, 2);
 787             gp.lineTo(0, 19);
 788             gp.curveTo(0, 27, 3, 35, 13, 35);
 789             gp.curveTo(20, 35, 23, 27, 23, 19);
 790             gp.lineTo(23, 2);
 791             gp.closePath();
 792         }
 793     }
 794
 795     public class Muller extends And {
 796         public String label() { return "C"; }
 797         public void draw(Graphics2D g, Color fill, Color stroke) {
 798             super.draw(g, fill, stroke);
 799             g.setColor(stroke);
 800             g.drawLine(0, 0, 23, 0);
 801         }
 802     }
 803
 804     public class Xor extends Or {
 805         public boolean result(boolean x, boolean y, boolean z) { return x ^ y ^ z; }
 806         public String label() { return "^"; }
 807         public void draw(Graphics2D g, Color fill, Color stroke) {
 808             super.draw(g, fill, stroke);
 809             g.setColor(stroke);
 810             AffineTransform at = g.getTransform();
 811             g.scale(1, -1);
 812             g.translate(0, -40);
 813
 814             g.translate(0, 4);
 815             GeneralPath gp = new GeneralPath();
 816             float x = 0.5f;
 817             float y = 29.141f+7.161f;
 818             gp.moveTo(x,y);
 819             gp.curveTo(5.729f+x, -1.789f+y,
 820                        6.444f+x, -2.686f+y,
 821                        14.32f+x, -3.58f+y);
 822             gp.curveTo(22.697f, 33.616f, 23.413f, 34.512f, 29.141f, 36.301f);
 823             g.draw(gp);
 824
 825             g.setTransform(at);
 826         }
 827     }
 828
 829     public abstract class Mux extends Gate {
 830         public String label() { return "?"; }
 831         public void makePath(GeneralPath gp) {
 832             gp.moveTo(0, 15);
 833             gp.lineTo(2, 23);
 834             gp.lineTo(23, 23);
 835             gp.lineTo(25, 15);
 836             gp.lineTo(0, 15);
 837         }
 838     }
 839
 840     public class X_Mux extends Mux {
 841         public boolean result(boolean x, boolean y, boolean z) { return x ? y : z; }
 842     }
 843     public class Y_Mux extends Mux {
 844         public boolean result(boolean x, boolean y, boolean z) { return y ? x : z; }
 845     }
 846     public class Z_Mux extends Mux {
 847         public boolean result(boolean x, boolean y, boolean z) { return z ? x : y; }
 848     }
 849
 850
 851     public abstract class Buf extends Gate {
 852         public void makePath(GeneralPath gp) {
 853             gp.moveTo(0, 15);
 854             gp.lineTo(13, 35);
 855             gp.lineTo(25, 15);
 856             gp.lineTo(0, 15);
 857         }
 858     }
 859
 860     public class X extends Buf {
 861         public boolean result(boolean x, boolean y, boolean z) { return x; }
 862     }
 863     public class Y extends Buf {
 864         public boolean result(boolean x, boolean y, boolean z) { return y; }
 865     }
 866     public class Z extends Buf {
 867         public boolean result(boolean x, boolean y, boolean z) { return z; }
 868     }
 869
 870 }