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

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