checkpoint
[slipway.git] / 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) && (cell.xi() < L0 || cell.xi() > L4)
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 pressed() {
516         dragFrom = oldcell;
517     }
518     public void released() {
519         if (dragFrom == null || oldcell == null) return;
520         if (Math.abs(dragFrom._y - oldcell._y) > 1) return;
521         if (Math.abs(dragFrom._x - oldcell._x) > 1) return;
522         if (dragFrom._x == oldcell._x   && dragFrom._y == oldcell._y+1) oldcell.cell.yi(NORTH);
523         if (dragFrom._x == oldcell._x   && dragFrom._y == oldcell._y-1) oldcell.cell.yi(SOUTH);
524         if (dragFrom._x == oldcell._x+1 && dragFrom._y == oldcell._y)   oldcell.cell.yi(EAST);
525         if (dragFrom._x == oldcell._x-1 && dragFrom._y == oldcell._y)   oldcell.cell.yi(WEST);
526         if (dragFrom._x == oldcell._x+1 && dragFrom._y == oldcell._y+1) oldcell.cell.xi(NE);
527         if (dragFrom._x == oldcell._x+1 && dragFrom._y == oldcell._y-1) oldcell.cell.xi(SE);
528         if (dragFrom._x == oldcell._x-1 && dragFrom._y == oldcell._y+1) oldcell.cell.xi(NW);
529         if (dragFrom._x == oldcell._x-1 && dragFrom._y == oldcell._y-1) oldcell.cell.xi(SW);
530         repaint();
531     }
532     public void drawKeyboard(Image keyboardImage, Graphics2D g) {
533                 int width = 300;
534                 int height = (keyboardImage.getHeight(null) * width) / keyboardImage.getWidth(null);
535                 g.drawImage(keyboardImage,
536                             0, getHeight() - height,
537                             width, getHeight(),
538                             0, 0,
539                             keyboardImage.getWidth(null), keyboardImage.getHeight(null),
540                             null);
541     }
542
543     public void _paint(Graphics2D g) {
544
545         this.g = g;
546         this.gg = new G(g);
547         g.setStroke(new BasicStroke((float)0.5));
548
549         g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
550         g.setRenderingHint(RenderingHints.KEY_RENDERING,    RenderingHints.VALUE_RENDER_QUALITY);
551
552         AffineTransform t  = g.getTransform();
553         for(Cell c : cells) {
554             g.setTransform(t);
555             g.translate(     c._x * SIZE /*+ (10 * (c._x/4))*/,      c._y * SIZE /*+ (10 * (c._y/4))*/);
556             c.clear();
557         }
558         for(Cell c : cells) {
559             g.setTransform(t);
560             g.translate(     c._x * SIZE /*+ (10 * (c._x/4))*/,      c._y * SIZE /*+ (10 * (c._y/4))*/);
561             c.draw();
562         }
563         g.setTransform(t);
564
565         g.setTransform(new AffineTransform());
566
567         gg.color(selectedcell);
568         g.fillRect(getWidth() - 200, 0, 200, 600);
569         gg.color(Color.white);
570         g.drawRect(getWidth() - 200, 0, 200, 600);
571
572         Cell newcell = whichCell(mousex, mousey);
573         int line = 10;
574         g.setFont(new Font("monospaced", 0, 14));
575         if (newcell != null && newcell.cell != null) {
576             g.drawString("selected: " + newcell._x + "," + newcell._y, getWidth() - 200 + 10, (line += 15));
577             g.drawString("    xlut: " + XLUT_EQUATIONS[newcell.cell.xlut() & 0xff], getWidth() - 200 + 10, (line += 15));
578             g.drawString("    ylut: " + YLUT_EQUATIONS[newcell.cell.ylut() & 0xff], getWidth() - 200 + 10, (line += 15));
579             String xi = "??";
580             switch(newcell.cell.xi()) {
581                 case NW : xi = "NW"; break;
582                 case NE : xi = "NE"; break;
583                 case SW : xi = "SW"; break;
584                 case SE : xi = "SE"; break;
585                 case NONE  : xi = "."; break;
586                 default:  xi = "L"+(newcell.cell.xi()-L0); break;
587             }
588             g.drawString("x-in mux: " + xi, getWidth() - 200 + 10, (line += 15));
589
590             String yi = "??";
591             switch(newcell.cell.yi()) {
592                 case NORTH : yi = "NORTH"; break;
593                 case SOUTH : yi = "SOUTH"; break;
594                 case EAST  : yi = "EAST"; break;
595                 case WEST  : yi = "WEST"; break;
596                 case NONE  : yi = "."; break;
597                 default:     yi = "L"+(newcell.cell.yi()-L0); break;
598             }
599             g.drawString("y-in mux: " + yi, getWidth() - 200 + 10, (line += 15));
600
601             g.drawString("w-in mux: " + (newcell.cell.wi()==NONE ? "." : ("L"+(newcell.cell.wi()-L0))),
602                          getWidth() - 200 + 10, (line += 15));
603             g.drawString("z-in mux: " + (newcell.cell.zi()==NONE ? "." : ("L"+(newcell.cell.zi()-L0))),
604                          getWidth() - 200 + 10, (line += 15));
605             g.drawString("t-in mux: ", getWidth() - 200 + 10, (line += 15));
606
607             g.drawString(" set/rst: " + (newcell.cell.ff_reset_value() ? "reset=SET" : "."),
608                          getWidth() - 200 + 10, (line += 15));
609
610             String outs = "";
611             for(int i=0; i<5; i++) outs += (newcell.cell.out(L0+i) ? (i+" ") : ". ");
612             g.drawString("     out: " + outs,
613                          getWidth() - 200 + 10, (line += 15));
614             String hs = "";
615             for(int i=0; i<5; i++) hs += (newcell.cell.hx(L0+i) ? (i+" ") : ". ");
616             g.drawString("  h conn: " + hs,
617                          getWidth() - 200 + 10, (line += 15));
618             String vs = "";
619             for(int i=0; i<5; i++) vs += (newcell.cell.vx(L0+i) ? (i+" ") : ". ");
620             g.drawString("  v conn: " + vs,
621                          getWidth() - 200 + 10, (line += 15));
622             g.drawString("out enab: " + (newcell.cell.oe()==H4 ? "H4" : newcell.cell.oe()==V4 ? "V4" : "."),
623                          getWidth() - 200 + 10, (line += 15));
624             g.drawString("   c-mux: " + (newcell.cell.c()==ZMUX ? "zmux" : newcell.cell.c()==XLUT ? "x-lut" : "y-lut"),
625                          getWidth() - 200 + 10, (line += 15));
626             g.drawString(" fb src: " + (newcell.cell.f() ? "clocked" : "."),
627                          getWidth() - 200 + 10, (line += 15));
628             g.drawString("  bypass: " + (newcell.cell.b() ? "clocked" : "."),
629                          getWidth() - 200 + 10, (line += 15));
630             g.drawString("   x out: " + (newcell.cell.xo() ? (newcell.cell.b() ? "register" : "center") : "."),
631                          getWidth() - 200 + 10, (line += 15));
632             g.drawString("   y out: " + (newcell.cell.yo() ? (newcell.cell.b() ? "register" : "center") : "."),
633                          getWidth() - 200 + 10, (line += 15));
634
635         }
636         if (shiftkey) {
637             drawKeyboard(keyboard2, g);
638         } else switch(lastChar) {
639             case 'x':
640             case 'y':
641             case 'z':
642             case 'w':
643             case 'o':
644             case 'h':
645             case 'v':
646                 drawKeyboard(keyboard3, g);
647                 break;
648             default:
649                 drawKeyboard(keyboard1, g);
650                 break;
651         }
652
653         while (mousebutton) {
654
655             if (dragFrom == null || oldcell == null) break;
656             if (Math.abs(dragFrom._y - oldcell._y) > 1) break;
657             if (Math.abs(dragFrom._x - oldcell._x) > 1) break;
658             g.setTransform(t);
659             if (dragFrom._x == oldcell._x || dragFrom._y == oldcell._y)
660                 gg.color(BLUE);
661             else
662                 gg.color(RED);
663
664             gg.line( oldcell._x * SIZE + SIZE/2,
665                      oldcell._y * SIZE + SIZE/2,
666                      dragFrom._x * SIZE + SIZE/2,
667                      dragFrom._y * SIZE + SIZE/2, 5);
668             break;
669         }
670
671         this.g = null;
672         this.gg = null;
673     }
674     Cell dragFrom = null;
675
676     public void clear() {
677         Graphics2D g = (Graphics2D)getGraphics();
678         //gg.color(Color.black);
679         //gg.color(Color.lightGray);
680         g.clearRect(0, 0, getWidth(), getHeight());
681     }
682
683     public static final P translate(P p, int dx, int dy) {
684         return new P(p.getX()+dx, p.getY()+dy);
685     }
686
687     public Cell whichCell(int x, int y) {
688         P p = new P(x,y);
689         try {
690             p = p.inverseTransform(transform);
691         } catch (Exception e) {
692             e.printStackTrace();
693         }
694         int col = ((int)p.getX()+0) / SIZE;
695         int row = ((int)p.getY()+0) / SIZE;
696         for(Cell c : cells)
697             if (c._x == col && c._y == row)
698                 return c;
699         return null;
700     }
701
702     public static boolean xlut_relevant(At40k.Cell c) {
703         return c.xlut_relevant();
704     }
705
706     public void mouseClicked(MouseEvent e) {
707         System.out.println("click");
708         final Cell c = whichCell(e.getX(), e.getY());
709         if (c==null) return;
710         System.out.println("click at " + c._x + "," + c._y);
711         scan(c);
712     }
713
714     public void scan() {
715         for(int x=0; x<ca.length; x++)
716             for(int y=0; y<ca[x].length; y++)
717                 if (ca[x][y] != null)
718                     scan(ca[x][y]);
719     }
720     public void scan(final Gui.Cell c) {
721         final At40k.Cell cell = c.cell;
722         AtmelSerial.scan(at40k, cell, NONE, true);
723         boolean safe = !cell.fb_relevant();
724         if (cell.xo()) safe = false;
725         if (cell.yo()) safe = false;
726         for(int i=0; i<5; i++)
727             if (cell.out(i))
728                 safe = false;
729         if (safe) {
730             int oldc = cell.c();
731             if (cell.xlut_relevant()) {
732                 cell.c(XLUT);
733                 drone.readBus(new BCB(c, XLUT));
734             }
735             if (cell.ylut_relevant()) {
736                 cell.c(YLUT);
737                 drone.readBus(new BCB(c, YLUT));
738             }
739             cell.c(oldc);
740         } else {
741             switch(cell.c()) {
742                 case XLUT: if (cell.xlut_relevant()) drone.readBus(new BCB(c, XLUT)); break;
743                 case YLUT: if (cell.ylut_relevant()) drone.readBus(new BCB(c, YLUT)); break;
744             }
745             
746         }
747         AtmelSerial.scan(at40k, cell, NONE, false);
748     }
749
750     private class BCB implements AvrDrone.ByteCallback {
751         Gui.Cell c;
752         int who;
753         public BCB(Gui.Cell c, int who) { this.who = who; this.c = c; }
754         public void call(byte b) throws Exception {
755             System.out.println("callback: " + b);
756             boolean on = (b & 0x80) != 0;
757             c.xknown = false;
758             c.yknown = false;
759             switch(who) {
760                 case YLUT:
761                     c.yknown = true;
762                     c.yon = on;
763                     repaint();
764                     break;
765                 case XLUT:
766                     c.xknown = true;
767                     c.xon = on;
768                     repaint();
769                     break;
770             }
771         }
772     }
773
774     // FIXME: 2-input gates?
775     public abstract class Gate {
776         public boolean invert_x;
777         public boolean invert_y;
778         public boolean invert_z;
779         public boolean invert_out;
780         public abstract boolean result(boolean x, boolean y, boolean z);
781         public void draw(Graphics2D g, Color fill, Color stroke) {
782             GeneralPath p = new GeneralPath();
783             makePath(p);
784             g.setColor(fill);
785             g.fill(p);
786             g.setColor(stroke);
787             g.draw(p);
788
789             AffineTransform a = g.getTransform();
790             g.scale(1, -1);
791             g.setColor(Color.white);
792             if (label() != null) g.drawString(label(), 7, -14);
793             g.setTransform(a);
794         }
795         public String label() { return null; }
796         public boolean setLut(int lut) {
797             for(int inverts = 0; inverts < 16; inverts++) {
798                 invert_x   = (inverts & 0x1) != 0;
799                 invert_y   = (inverts & 0x2) != 0;
800                 invert_z   = (inverts & 0x4) != 0;
801                 invert_out = (inverts & 0x8) != 0;
802                 for(int bit=0; bit<8; bit++) {
803                     boolean x = (bit & 0x1) != 0;
804                     boolean y = (bit & 0x2) != 0;
805                     boolean z = (bit & 0x4) != 0;
806                     boolean expect = (lut & (1<<bit)) != 0;
807
808                     // FIXME symmetry issues here....
809                     boolean result = result(x ^ invert_x, y ^ invert_y, z ^ invert_z) ^ invert_out;
810                     if (result == expect) return true;
811                 }
812             }
813             return false;
814         }
815         public abstract void makePath(GeneralPath gp);
816     }
817
818     public class Or extends Gate {
819         public boolean result(boolean x, boolean y, boolean z) { return x || y || z; }
820         public String label() { return "+"; }
821         public void draw(Graphics2D g, Color fill, Color stroke) {
822             AffineTransform at = g.getTransform();
823             g.scale(1, -1);
824             g.translate(0, -40);
825             super.draw(g, fill, stroke);
826             g.setTransform(at);
827         }
828         public void makePath(GeneralPath gp) {
829             gp.moveTo(29.141f, 36.301f);
830             gp.lineTo(29.141f, 36.301f-7.161f);
831             gp.curveTo(27.71f, 11.24f, 23.413f, 9.45f, 14.82f, 0.5f);
832             gp.curveTo(6.229f, 9.45f, 1.932f, 11.24f, 0.5f, 29.141f);
833             gp.lineTo(0.5f, 29.141f+7.161f);
834             float x = 0.5f;
835             float y = 29.141f+7.161f;
836             gp.curveTo(5.729f+x, -1.789f+y,
837                        6.444f+x, -2.686f+y,
838                        14.32f+x, -3.58f+y);
839             gp.curveTo(22.697f, 33.616f, 23.413f, 34.512f, 29.141f, 36.301f);
840         }
841     }
842
843     public class And extends Gate {
844         public boolean result(boolean x, boolean y, boolean z) { return x && y && z; }
845         public String label() { return "&"; }
846         public void makePath(GeneralPath gp) {
847             gp.moveTo(0, 2);
848             gp.lineTo(0, 19);
849             gp.curveTo(0, 27, 3, 35, 13, 35);
850             gp.curveTo(20, 35, 23, 27, 23, 19);
851             gp.lineTo(23, 2);
852             gp.closePath();
853         }
854     }
855
856     public class Muller extends And {
857         public String label() { return "C"; }
858         public void draw(Graphics2D g, Color fill, Color stroke) {
859             super.draw(g, fill, stroke);
860             g.setColor(stroke);
861             g.drawLine(0, 0, 23, 0);
862         }
863     }
864
865     public class Xor extends Or {
866         public boolean result(boolean x, boolean y, boolean z) { return x ^ y ^ z; }
867         public String label() { return "^"; }
868         public void draw(Graphics2D g, Color fill, Color stroke) {
869             super.draw(g, fill, stroke);
870             g.setColor(stroke);
871             AffineTransform at = g.getTransform();
872             g.scale(1, -1);
873             g.translate(0, -40);
874
875             g.translate(0, 4);
876             GeneralPath gp = new GeneralPath();
877             float x = 0.5f;
878             float y = 29.141f+7.161f;
879             gp.moveTo(x,y);
880             gp.curveTo(5.729f+x, -1.789f+y,
881                        6.444f+x, -2.686f+y,
882                        14.32f+x, -3.58f+y);
883             gp.curveTo(22.697f, 33.616f, 23.413f, 34.512f, 29.141f, 36.301f);
884             g.draw(gp);
885
886             g.setTransform(at);
887         }
888     }
889
890     public abstract class Mux extends Gate {
891         public String label() { return "?"; }
892         public void makePath(GeneralPath gp) {
893             gp.moveTo(0, 15);
894             gp.lineTo(2, 23);
895             gp.lineTo(23, 23);
896             gp.lineTo(25, 15);
897             gp.lineTo(0, 15);
898         }
899     }
900
901     public class X_Mux extends Mux {
902         public boolean result(boolean x, boolean y, boolean z) { return x ? y : z; }
903     }
904     public class Y_Mux extends Mux {
905         public boolean result(boolean x, boolean y, boolean z) { return y ? x : z; }
906     }
907     public class Z_Mux extends Mux {
908         public boolean result(boolean x, boolean y, boolean z) { return z ? x : y; }
909     }
910
911
912     public abstract class Buf extends Gate {
913         public void makePath(GeneralPath gp) {
914             gp.moveTo(0, 15);
915             gp.lineTo(13, 35);
916             gp.lineTo(25, 15);
917             gp.lineTo(0, 15);
918         }
919     }
920
921     public class X extends Buf {
922         public boolean result(boolean x, boolean y, boolean z) { return x; }
923     }
924     public class Y extends Buf {
925         public boolean result(boolean x, boolean y, boolean z) { return y; }
926     }
927     public class Z extends Buf {
928         public boolean result(boolean x, boolean y, boolean z) { return z; }
929     }
930
931     private static Image keyboard1 = Toolkit.getDefaultToolkit().createImage("keyboard1.png");
932     private static Image keyboard2 = Toolkit.getDefaultToolkit().createImage("keyboard2.png");
933     private static Image keyboard3 = Toolkit.getDefaultToolkit().createImage("keyboard3.png");
934
935 }