// FILE:    SomaDisplay.java
// PURPOSE: display soma cube solutions
// MODS:    mckeeman @ digital -- 96.09.25 -- original
// METHOD:  The solutions were precomputed.  See SomaSolutions.java.
//          The master data for the display is the exterior points of the
//          3x3x3 cube (64 total - 8 interior = 56);  Each facelet is a
//          polygon.  The color of the facelet is determined by the color
//          of the soma cube piece occupying its cubelet.  There are three
//          orientations for facelets (perpendicular to x, y, and z axes).
//          During the construction of the facelets, the coordinates of the
//          corners are recorded in an array in class Vertices.  The facelet
//          itself points to its corners.  All of the vertices can be rotated
//          together (orthogonal matrix multiply).  Each facelet thereby gets
//          new coordinates for display.  The x-y coordinates are used to
//          place the image.  The z coordinate contributes to a computation
//          which simulates highlighting from above (shadow).
//
//          A particular solution can be picked with the buttons.  Each
//          solution can be physically manipulated by mouse drag.  Near the
//          center of the figure the mouse tumbles the cube in the xz and yz
//          planes.  Near the periphery of the figure the mouse rotates the
//          figure about the z axis.   Double buffering and clipping are 
//          used to minimize flicker.  In addition very small rotations are
//          ignored so that the figure is not redrawn as often.
//
//          Almost all dimenions are hardwired into the display.  Screen
//          resize does not affect centering or scaling.

import java.awt.*;
import java.applet.*;

class Pt {                                        // a point in 3 space
    double[] v;                                   // the coordinates
    
    public
    Pt(double x, double y, double z) {            // ctor
        v = new double[3];
        v[0] = x;
        v[1] = y;
        v[2] = z;
    }
    
    public boolean
    equal(Pt w) {                                 // same x y z coordinates
        for (int i=0; i<3; i++) {
            if (v[i] != w.v[i]) return false;
        }
        return true;
    }
    
    public void
    set(double[] w) {                             // reset coordinates
        for (int i=0; i<w.length; i++) {
            v[i] = w[i];
        }
    }
    
    public void
    dump() {
        System.out.println("Vertex v="+v[0]+" "+v[1]+" "+v[2]);
    }
}

// The 3d coordinates are kept in an array
// The figure can be moved by changing the points
class Vertices {                                   // 3d vertices
    Pt[] vs;
    int count;
    
    public
    Vertices(int count) {                          // ctor
        vs = new Pt[count];                        // all the vertices
        this.count = 0;                            // none yet
    }
    
    public int
    add(Pt v) {                                    // add if necessary
         for (int i=0; i<count; i++) {
             if (v.equal(vs[i])) return i;         // where it is
         }
         vs[count] = v;                            // new value, add it
         return count++;                           // make room and report
    }
    
    public void
    dump() {
        for (int i=0; i<vs.length; i++) {
            vs[i].dump();
        }
    }
}

// facelets are defined in terms of the points
// each point is in several facelets.
// moving the points also moves the facelets.
class Facelet {
    public int[] t;                                // polygon for facelet
    public Color c;

    public
    Facelet(Color c, double x, double y, double z, int coord, Vertices vs) {
        this.c = c;
        t = new int[4];
        t[0] =     vs.add(new Pt(x/6.0,      y/6.0,      z/6.0));
        switch (coord) {
        case 0:
            t[1] = vs.add(new Pt(x/6.0,     (y+2)/6.0,   z/6.0));
            t[2] = vs.add(new Pt(x/6.0,     (y+2)/6.0,  (z+2)/6.0));
            t[3] = vs.add(new Pt(x/6.0,      y/6.0,     (z+2)/6.0));
            break;
        case 1:
            t[1] = vs.add(new Pt((x+2)/6.0,  y/6.0,      z/6.0));
            t[2] = vs.add(new Pt((x+2)/6.0,  y/6.0,     (z+2)/6.0));
            t[3] = vs.add(new Pt(x/6.0,      y/6.0,     (z+2)/6.0));
            break;        
        case 2:
            t[1] = vs.add(new Pt((x+2)/6.0,  y/6.0,      z/6.0));
            t[2] = vs.add(new Pt((x+2)/6.0, (y+2)/6.0,   z/6.0));
            t[3] = vs.add(new Pt(x/6.0,     (y+2)/6.0,   z/6.0));
            break; 
        }
        int dx = coord == 0 ? 0 : 2;
        int dy = coord == 1 ? 0 : 2;
        int dz = coord == 2 ? 0 : 2;
    }
    
    public void
    drawFacelet(Graphics g, boolean down, Vertices vs) {
        if (down) {
            g.setColor(c.darker());
        } else {
            g.setColor(c);
        }
        int[] x = new int[4];
        int[] y = new int[4];
        for (int i=0; i<4; i++) {
            x[i] = (int) (Cube.cx+Cube.scale*vs.vs[t[i]].v[0]);   // x
            y[i] = (int) (Cube.cy+Cube.scale*vs.vs[t[i]].v[1]);   // y
        }
        g.fillPolygon(x, y, 4);
    }
}

// a face is 3x3, therefore consists of 9 facelets
class Face {
    public Facelet[] f;                            // one side of cube
    private int count;                             // next avail space
    
    public
    Face(int count) {                              // ctor
        f = new Facelet[count];                    // 3x3 facelets
        this.count = 0;                            // none yet
    }
    
    public void
    add(Facelet fc) {                              // add a facelet
       f[count++] = fc;
    }

    public void
    drawFace(Graphics g, boolean down, Vertices vs) {
        for (int i=0; i<f.length; i++) {           // facelet at a time
             f[i].drawFacelet(g, down, vs);
        }
    }
}

// there are 6 faces
class Faces {
    public Face[] fs;                              // 6 of them
    
    public
    Faces(int count) {
        fs = new Face[count];                      // faces
    }
}

class Cube {
    public static int cx;                          // center
    public static int cy;
    public static int scale;                       // size
    private int solution;                          // which of 240
    
    public Vertices vs;                            // 54 vertices
    public Faces fs;                               // 6 faces

    int[] cublets;
    public static final Color V = Color.blue;      // v piece
    public static final Color L = Color.cyan;      // l piece
    public static final Color T = Color.green;     // t piece
    public static final Color Z = Color.yellow;    // z piece
    public static final Color R = Color.magenta;   // r piece
    public static final Color S = Color.red;       // s piece
    public static final Color Y = Color.gray;      // y piece
    public static final Color[] colors = {
        V,V,V, 
        L,L,L,L, 
        T,T,T,T, 
        Z,Z,Z,Z, 
        S,S,S,S, 
        R,R,R,R, 
        Y,Y,Y,Y};
        
    int[] cubelets;

    public
    Cube(int which, Dimension scr) {
        cx = scr.height/2;                          // set size from view
        cy = cx+20;                                 // set size from view
        scale = Math.min(scr.width, scr.height)/2;  // set size from view

        vs = new Vertices(64-8);                    // exterior of 3x3x3
        fs = new Faces(6);                          // exterior of 3x3x3

        cubelets = SomaSolutions.sol(which);        // initial solution
        int x, y, z;
        
        x = 3;  fs.fs[0] = new Face(9);                 // +x
        for (y=-3; y<=1; y+=2) for (z=-3; z<=1; z+=2) {
            int b = posit(x-2,y,z);
            int d = lookup(b+1);
            Color c = colors[d];
            fs.fs[0].add(new Facelet(c, x, y, z, 0, vs));
        }
        x = -3;  fs.fs[1] = new Face(9);                // +x
        for (y=-3; y<=1; y+=2) for (z=-3; z<=1; z+=2) {
            int b = posit(x,y,z);
            int d = lookup(b+1);
            Color c = colors[d];
            fs.fs[1].add(new Facelet(c, x, y, z, 0, vs));
        }
        x = 3;  fs.fs[2] = new Face(9);                 // +y
        for (y=-3; y<=1; y+=2) for (z=-3; z<=1; z+=2) {
            int b = posit(y,x-2,z);
            int d = lookup(b+1);
            Color c = colors[d];
            fs.fs[2].add(new Facelet(c, y, x, z, 1, vs));
        }
        x = -3;  fs.fs[3] = new Face(9);                // -y
        for (y=-3; y<=1; y+=2) for (z=-3; z<=1; z+=2) {
            int b = posit(y,x,z);
            int d = lookup(b+1);
            Color c = colors[d];
            fs.fs[3].add(new Facelet(c, y, x, z, 1, vs));
        }
        x = 3;  fs.fs[4] = new Face(9);                 // +z
        for (y=-3; y<=1; y+=2) for (z=-3; z<=1; z+=2) {
            int b = posit(z,y,x-2);
            int d = lookup(b+1);
            Color c = colors[d];
            fs.fs[4].add(new Facelet(c, z, y, x, 2, vs));
        }
        x = -3;  fs.fs[5] = new Face(9);                // -z
        for (y=-3; y<=1; y+=2) for (z=-3; z<=1; z+=2) {
            int b = posit(z,y,x);
            int d = lookup(b+1);
            Color c = colors[d];
            fs.fs[5].add(new Facelet(c, z, y, x, 2, vs));
        }
    }
        
    public int 
    posit(int x, int y, int z) {
         return (x+3)/2 + 3*(y+3)/2 + 9*(z+3)/2;
    }
    
    public int 
    lookup(int b) {
        for (int i=0; i<27; i++) {
            if (cubelets[i] == b) return i;
        }
        return 0;
    }
    
    public boolean
    isVisible(Face f) {
         Facelet t = f.f[4];                         // center facelet
         double s = 0;
         for (int i=0; i<4; i++) {
             s += vs.vs[t.t[i]].v[2];                // z coord
         }
         return s>0;                                 // positive means vis
    }
    
    public boolean
    isDown(Face f) {
         Facelet t = f.f[4];                         // center facelet
         double s = 0;
         for (int i=0; i<4; i++) {
             s += vs.vs[t.t[i]].v[1];                // y coord
         }
         return s>0;                                 // positive means down
    }
    
    public void
    drawCube(Graphics g) {
        for (int i=0; i<fs.fs.length; i++) {
            if (isVisible(fs.fs[i])) {
                fs.fs[i].drawFace(g, isDown(fs.fs[i]), vs);
            }
        }
    }
}

class Pieces {
    int cy;                                          // y coordinate
    int cx;                                          // x coordinate
    int delta;                                       // piece size
    
    Polygon[] p1;                                    // first to draw
    Polygon[] p2;                                    // second to draw
    Polygon[] p3;                                    // third to draw
    Color[]   c1; 
    Color[]   c2; 
    Color[]   c3;
     
    double edge;                                     // edge length
    static final double dx =  Math.cos(Math.PI/6);   // projected cubies
    static final double dy = -dx;
    static final double dz =  Math.sin(Math.PI/6);
    
    static final Color graygreen = new Color(0.0F, 0.9F, 0.0F);

    public 
    Pieces(Dimension scr) {
        Polygon up, left, right;
        Point p;
        
        edge = scr.height/30;
        delta = scr.height/6;

        p1 = new Polygon[20];  c1 = new Color[20];  int i1 = 0; 
        p2 = new Polygon[18];  c2 = new Color[18];  int i2 = 0;
        p3 = new Polygon[24];  c3 = new Color[24];  int i3 = 0;
        
        // compute basic forms

        up = new Polygon();                          // looks up
        p = pt(0,0,0); up.addPoint(p.x, p.y);
        p = pt(0,1,0); up.addPoint(p.x, p.y);
        p = pt(1,1,0); up.addPoint(p.x, p.y);
        p = pt(1,0,0); up.addPoint(p.x, p.y);
        p = pt(0,0,0); up.addPoint(p.x, p.y);
        
        left = new Polygon();                        // looks left
        p = pt(0,0,0); left.addPoint(p.x, p.y);
        p = pt(0,1,0); left.addPoint(p.x, p.y);
        p = pt(0,1,1); left.addPoint(p.x, p.y);
        p = pt(0,0,1); left.addPoint(p.x, p.y);
        p = pt(0,0,0); left.addPoint(p.x, p.y);
        
        right = new Polygon();                       // looks right
        p = pt(0,0,0); right.addPoint(p.x, p.y);
        p = pt(1,0,0); right.addPoint(p.x, p.y);
        p = pt(1,0,1); right.addPoint(p.x, p.y);
        p = pt(0,0,1); right.addPoint(p.x, p.y);
        p = pt(0,0,0); right.addPoint(p.x, p.y);
        
        // lay out V 
        cx = scr.height+scr.height/10;
        cy = scr.height/5;
	c1[i1] = Cube.V.darker(); p1[i1++] = move(up, 0, 0, 1);
	c1[i1] = Cube.V.darker(); p1[i1++] = move(up, 0, 0, 1);
	c1[i1] = Cube.V.darker(); p1[i1++] = move(up, 0, 1, 2);

	c2[i2] = Cube.V;          p2[i2++] = move(right, 0, 0, 0);
	c2[i2] = Cube.V;	  p2[i2++] = move(right, 0, 1, 1);

	c3[i3] = Cube.V;          p3[i3++] = move(left, 0, 0, 0);
	c3[i3] = Cube.V;          p3[i3++] = move(left, 0, 1, 0);
	c3[i3] = Cube.V;          p3[i3++] = move(left, 0, 1, 1);

        // lay out L
        cx += delta;
	c1[i1] = Cube.L.darker(); p1[i1++] = move(up, 0, 0, 1);
	c1[i1] = Cube.L.darker(); p1[i1++] = move(up, 0, 1, 3);

	c2[i2] = Cube.L;	  p2[i2++] = move(right, 0, 0, 0);
	c2[i2] = Cube.L;	  p2[i2++] = move(right, 0, 1, 1);
      	c2[i2] = Cube.L;	  p2[i2++] = move(right, 0, 1, 2);
 
	c3[i3] = Cube.L;          p3[i3++] = move(left, 0, 0, 0);
	c3[i3] = Cube.L;          p3[i3++] = move(left, 0, 1, 0);
      	c3[i3] = Cube.L;          p3[i3++] = move(left, 0, 1, 1);
      	c3[i3] = Cube.L;          p3[i3++] = move(left, 0, 1, 2);

        // lay out T
        cx -= delta;
        cy += delta;
	c1[i1] = Cube.T.darker(); p1[i1++] = move(up, 0, 0, 2);
	c1[i1] = Cube.T.darker(); p1[i1++] = move(up, 0, 1, 2);
	c1[i1] = Cube.T.darker(); p1[i1++] = move(up, 0, 2, 2);

	c2[i2] = graygreen;       p2[i2++] = move(right, 0, 1, 0);
	c2[i2] = graygreen;       p2[i2++] = move(right, 0, 0, 1);

	c3[i3] = Cube.T;          p3[i3++] = move(left, 0, 0, 1);
	c3[i3] = Cube.T;          p3[i3++] = move(left, 0, 1, 0);
      	c3[i3] = Cube.T;          p3[i3++] = move(left, 0, 1, 1);
      	c3[i3] = Cube.T;          p3[i3++] = move(left, 0, 2, 1);

        // lay out Z
        cx += delta;
	c1[i1] = Cube.Z.darker(); p1[i1++] = move(up, 0, 0, 1);
	c1[i1] = Cube.Z.darker(); p1[i1++] = move(up, 0, 1, 2);
	c1[i1] = Cube.Z.darker(); p1[i1++] = move(up, 0, 2, 2);

	c2[i2] = Cube.Z;          p2[i2++] = move(right, 0, 0, 0);
	c2[i2] = Cube.Z;          p2[i2++] = move(right, 0, 1, 1);

	c3[i3] = Cube.Z;          p3[i3++] = move(left, 0, 0, 0);
	c3[i3] = Cube.Z;          p3[i3++] = move(left, 0, 1, 0);
	c3[i3] = Cube.Z;          p3[i3++] = move(left, 0, 1, 1);
	c3[i3] = Cube.Z;          p3[i3++] = move(left, 0, 2, 1);

        // lay out R
        cx -= delta;
        cy += delta;
	c1[i1] = Cube.R.darker(); p1[i1++] = move(up, 1, 0, 2);
	c1[i1] = Cube.R.darker(); p1[i1++] = move(up, 0, 1, 1);
	c1[i1] = Cube.R.darker(); p1[i1++] = move(up, 1, 1, 1);

	c2[i2] = Cube.R;          p2[i2++] = move(right, 1, 0, 0);
	c2[i2] = Cube.R;          p2[i2++] = move(right, 1, 0, 1);
	c2[i2] = Cube.R;          p2[i2++] = move(right, 0, 1, 0);

	c3[i3] = Cube.R;          p3[i3++] = move(left, 1, 0, 0);
	c3[i3] = Cube.R;          p3[i3++] = move(left, 1, 0, 1);
	c3[i3] = Cube.R;          p3[i3++] = move(left, 0, 1, 0);

        // lay out S
        cx += delta;
	c1[i1] = Cube.S.darker(); p1[i1++] = move(up, 0, 1, 2);
	c1[i1] = Cube.S.darker(); p1[i1++] = move(up, 1, 0, 1);
	c1[i1] = Cube.S.darker(); p1[i1++] = move(up, 1, 1, 1);

	c2[i2] = Cube.S;          p2[i2++] = move(right, 1, 0, 0);
	c2[i2] = Cube.S;          p2[i2++] = move(right, 0, 1, 0);
	c2[i2] = Cube.S;          p2[i2++] = move(right, 0, 1, 1);

	c3[i3] = Cube.S;          p3[i3++] = move(left, 1, 0, 0);
	c3[i3] = Cube.S;          p3[i3++] = move(left, 0, 1, 0);
	c3[i3] = Cube.S;          p3[i3++] = move(left, 0, 1, 1);

        // lay out Y
        cx -= delta/2;
        cy += delta;
	c1[i1] = Cube.Y.darker(); p1[i1++] = move(up, 1, 0, 1);
	c1[i1] = Cube.Y.darker(); p1[i1++] = move(up, 0, 1, 1);
	c1[i1] = Cube.Y.darker(); p1[i1++] = move(up, 1, 1, 2);

	c2[i2] = Cube.Y;          p2[i2++] = move(right, 1, 0, 0);
	c2[i2] = Cube.Y;          p2[i2++] = move(right, 0, 1, 0);
	c2[i2] = Cube.Y;          p2[i2++] = move(right, 1, 1, 1);

	c3[i3] = Cube.Y.brighter(); p3[i3++] = move(left, 1, 0, 0);
	c3[i3] = Cube.Y.brighter(); p3[i3++] = move(left, 0, 1, 0);
	c3[i3] = Cube.Y.brighter(); p3[i3++] = move(left, 1, 1, 1);

    }
    
    private Point
    pt(int x, int y, int z) {
        int rx = (int)(edge*(x*dx+y*dy));
        int ry = (int)(edge*(x*dz+y*dz+z));
        return new Point(rx, ry);
    }
    
    private Polygon
    move(Polygon base, int x, int y, int z) {
        Polygon t = new Polygon();
        Point p = pt(x, y, z);
        for (int i=0; i<base.npoints; i++) {
            t.addPoint(base.xpoints[i]+p.x+cx, base.ypoints[i]+p.y+cy);
        }
        return t;
    }
    
    public void
    drawPieces(Graphics g) {
        Color edge = Color.white;
        for (int i=0; i<p1.length; i++) {
            if (p1[i] != null) {
                g.setColor(c1[i]);
                g.fillPolygon(p1[i]);
                g.setColor(edge);
                g.drawPolygon(p1[i]);
            }
        }
        for (int i=0; i<p2.length; i++) {
            if (p2[i] != null) {
                g.setColor(c2[i]);
                g.fillPolygon(p2[i]);
                g.setColor(edge);
                g.drawPolygon(p2[i]);
            }
        }
        for (int i=0; i<p3.length; i++) {
            if (p3[i] != null) {
                g.setColor(c3[i]);
                g.fillPolygon(p3[i]);
                g.setColor(edge);
                g.drawPolygon(p3[i]);
            }
        }
        g.setColor(Color.black);
        g.drawString("pieces", cx-delta/2+10, cy+delta+10);
    }
}

public final class 
SomaDisplay extends Applet {

    Pieces puzzle;
    
    int x1,y1,x2,y2;
    double SQRT3 = Math.sqrt(3);
    
    int solution = 240;
    int[] xs;
    int[] ys;
    
    boolean down;
    int downx, downy;
    int dragx, dragy;
    
    Button tenprev = new Button("-10");
    Button prev    = new Button("-1");
    Label number   = new Label("solution = "+solution);
    Button next    = new Button("+1");
    Button tennext = new Button("+10");
    
    Cube cube;
    private double rot[][];
    private double acc[];
    private double accrot[][];
    private double a[][];

    Image     osi;                                  // for double buffering
    Graphics  osg;
    Dimension screen;
    
    Frame appletFrame;
            
    public
    SomaDisplay() {
        rot = new double[3][3];                     // rotation matrix
        acc = new double[3];                        // vector accumulator
        accrot = new double[3][3];                  // rotation accumulator
        a = new double[3][3];                       // rotation temp
	add(tenprev);
	add(prev);
	add(number);
	add(next);
	add(tennext);
    }
    
    private void
    rotz(double sx, double cx, double sy, double cy) {
        rot[0][0]= cx;
        rot[0][1]= -sx*sy;
        rot[0][2]= -sx*cy;
        rot[1][0]= 0;
        rot[1][1]= cy;
        rot[1][2]= -sy;
        rot[2][0]= sx;
        rot[2][1]= cx*sy;
        rot[2][2]= cx*cy;
    }
    
    private void 
    anglez(double x, double y) {                    // tumble
        double dx = (double)(downx-x)/Cube.scale;   // x increment
        double dy = (double)(downy-y)/Cube.scale;   // y increment
        double sx = dx*1.5;                         // better leverage
        double sy = dy*1.5;
        sx = Math.max(-1, Math.min(1, dx));         // limiters
        sy = Math.max(-1, Math.min(1, dy));
        double cx = Math.sqrt(1-sx*sx);             // cosine
        double cy = Math.sqrt(1-sy*sy);             // cosine
        rotz(sx, cx, sy, cy);
    }
    
    private void 
    rotxy(double s, double c) {
        rot[0][0]= c;
        rot[0][1]= -s;
        rot[0][2]= 0;
        rot[1][0]= s;
        rot[1][1]= c;
        rot[1][2]= 0;
        rot[2][0]= 0;
        rot[2][1]= 0;
        rot[2][2]= 1;
    }
    
    private void
    anglexy(double x, double y) {                    // spin
        double dx  = (double)(downx-x)/Cube.scale;   // x increment
        double dy  = (double)(downy-y)/Cube.scale;   // y increment
        dx = Math.max(-0.1, Math.min(0.1, dx));      // limiters
        dy = Math.max(-0.1, Math.min(0.1, dy));
        
        double rxy = Math.sqrt(dx*dx+dy*dy);         // length of increment
        if (rxy == 0) return;

        double X   = (double)(Cube.cx-x)/Cube.scale; // x posit
        double Y   = (double)(Cube.cy-y)/Cube.scale; // y posit
        double rXY = Math.sqrt(X*X+Y*Y);             // radius to posit
        double cxy = (dx*X+dy*Y)/(rxy*rXY);          // cosine
        double sxy = Math.sqrt(1-cxy*cxy);           // projection
        
        double s   = rxy*sxy/rXY;                    // sine rotation
        double c   = Math.sqrt(1.0-s*s);             // cosine
        
        boolean ew = Math.abs(X) > Math.abs(Y);
        double dir = ew?sign(dy*X):sign(-dx*Y);      // 1 = cclockwise
        s = s*dir;
        rotxy(s, c);
    }
    
    private void
    cubeRotate(double rot[][]){
        for (int i=0; i<cube.vs.vs.length; i++) {
            for (int j=0; j<3; j++) {
                double ac = 0;
                for (int k=0; k<3; k++) {
                    ac += rot[j][k]*cube.vs.vs[i].v[k];
                }
                acc[j] = ac;
            }
            cube.vs.vs[i].set(acc);
        }
    }
    
    private void
    accRotate(double[][] rot) {
        for (int i=0; i<3; i++) {
            for (int j=0; j<3; j++) {
                double ac = 0;
                for (int k=0; k<3; k++) {
                    ac += rot[j][k]*accrot[k][i];
                }
                a[j][i] = ac;
            }
        }
        for (int i=0;i<3;i++) System.arraycopy(a[i], 0, accrot[i], 0, 3);
    }
    
    public void
    rotate() {                                       // rotate cube
        cubeRotate(rot);
        accRotate(rot);
    }
    
    public double
    sign(double x) {
        return x<0 ? -1 : 1;
    }
    
    public void 
    update(Graphics g) {
        paint(g);
    }
    
    public Frame
    getFrame() {
        Container c = this;
        while ((c = c.getParent()) != null) {
	    if (c instanceof Frame) {
	        return (Frame)c;
	    }
	}
	return null;
    }
    
    public void
    init() {                                        // applet init
	screen = size();                            // screen display area
        x1 = screen.width/20;
        y1 = screen.height/10;
        x2 = screen.width;
        y2 = screen.height;
        cube = new Cube(solution, screen);          // for display
        puzzle = new Pieces(screen);                // puzzle parts
        appletFrame = getFrame();
        accrot[0][0] = accrot[1][1] = accrot[2][2] = 1;
        rotxy(0, -1);                               // 180 about z
        rotate();
        double sa = Math.sin(2*Math.PI/3);
        rotz(-0.5, Math.sqrt(1-0.5*0.5), sa, -Math.sqrt(1-sa*sa));
        rotate();
        setBackground(Color.white);                 // background
        offScreenPaint();
    }
    
    private void
    offScreenPaint() {                              // before paint clears it
        screen = size();                            // display area
        if (osi == null) {                          // drawing buffer
            osi = createImage(screen.width, screen.height);
            osg = osi.getGraphics();
            osg.setFont(getFont());
            osg.setColor(Color.white);
            osg.fillRect(0,0,screen.width, screen.height);
            puzzle.drawPieces(osg);                 // unchanging
        }
        
        synchronized (osi) {
            osg.setColor(Color.white);
            osg.fillRect(0,0,screen.height,screen.height);

            cube.drawCube(osg);
            if (down) {
                int s = (int)(Cube.scale/2.0);
                int h = (int)(Math.sqrt(2.0/2)*s);
                int x = Cube.cx;
                int y = Cube.cy;
                osg.setColor(Color.black);
                osg.drawOval(x-h, y-h, 2*h, 2*h);
                h = (int)(h*SQRT3);
                osg.drawOval(x-h, y-h, 2*h, 2*h);
            }
        }
    }
    
    public void 
    paint(Graphics g) {                             // screen display
        synchronized (osi) {                        // protect from update
            g.drawImage(osi,0,0,this);              // minimal flicker
        }
    }

    public boolean
    mouseDown(Event e, int x, int y) {
        if (e.target instanceof Button) return true;
        downx = x;  downy = y; down = true;
        offScreenPaint();
        repaint(0,0, x2, y2);
        return true;
    }
    
    public boolean
    mouseDrag(Event e, int x, int y) {
        if (e.target instanceof Button) return true;

        int dx = Cube.cx-x;                         // from center to cursor
        int dy = Cube.cy-y;
        double r = Math.sqrt(dx*dx+dy*dy)/Cube.scale;

        if (r<0.5) {                                // near center: tumble
            appletFrame.setCursor(Frame.MOVE_CURSOR);
            showStatus("tumbling");
            anglez(x, y);                           // set up rot in z plane
        } else if (r<SQRT3/2) {                       // near edge: spin
            appletFrame.setCursor(Frame.HAND_CURSOR);
            showStatus("rotating");
            anglexy(x, y);                          // set up rot about z axis
        } else {
            appletFrame.setCursor(Frame.DEFAULT_CURSOR);
            showStatus("cursor out of range");
            return true;                            // ignore
        }

        rotate();
        downx = x;
        downy = y;
        offScreenPaint();
        repaint(0,0, x2,y2);
        return true;
    }
    
    public boolean
    mouseUp(Event e, int x, int y) {
        down = false;
        appletFrame.setCursor(Frame.DEFAULT_CURSOR);
        offScreenPaint();
        repaint(0,0, x2,y2);
        return true;
    }
    
    public boolean
    action(Event e, Object o) {                    // user mousemanship
        if (e.target instanceof Button) { 
            if (((String)o).equals("+1")) {
                solution++;
                if (solution>240) solution = 1;
            } else if (((String)o).equals("-1")) {
                solution--;
                if (solution<1) solution = 240;
            } else if (((String)o).equals("+10")) {
                solution += 10;
                if (solution>240) solution -= 240;;
            } else if (((String)o).equals("-10")) {
                solution -= 10;;
                if (solution<1) solution += 240;
            }
            number.setText("solution = "+solution);
            cube = new Cube(solution, screen);
            showStatus("new solution");
            cubeRotate(accrot);
            offScreenPaint();
            repaint(0,0, x2,y2);
            return true;                           // all done
        }
    	return false;                              // none of my business
    }
 
    public void
    start() {                                      // applet start
        showStatus("SomaDisplay started");
    }
    
    public void
    stop() {
        showStatus("SomaDisplay stopped");
    }
    
}                                                   // end SomaDisplay