/*
  So what we do is when user draws with components, the screen sees
  off cpts; so does imgOff; imgOn gets the same thing, but with some
  of the LEDs lit (i.e. images come from the lit palette?; imgOnZ
  gets the appropriate LEDs lit and the appropriate polcaps zorched,
  and imgOffZ gets no lit LEDs but appropriate polcaps zorched.
  
  Then when user turns on voltage:
  
  if n<s>fwd</s>led > 0, we sub in fadings from imgOff to imgOn --
  speed fn of caps (else imgOff=imgOn)
  
  then, if n<s>rev</s>pol>0, we sub in fadings from imgOn to imgOnZ --
  slowly (steps 0 to 3). (else imgOn=imgOnZ)
  
  When user turns off voltage:
  imgOff becomes= imgOffZ. if n<s>fwd</s>led>0, we sub in fadings
  from imgOnZ to imgOff (Their zorchinesses should be the same, so if
  nfwdled=0, never mind.)
  Enable further drawing (and clearing), adding cpts normally to
  imgOff, lit to imgOn, z/l to imgOnZ, z/off to imgOffZ.
  
  KLUDGES: skip checking whether there's really anything to redraw --
  nled,npol instead of nfwdled>0 or nrevpol>0.  if an LED is
  reversed or a POL is forward, its partner in other is itself.  Then
  how do you know whether any smoking's gonna happen?  Oh, well.  So
  that'll be a boring delay.
*/


import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;


public class Hosed extends Applet
{
  
  public colorChip[] palette;

  int nled=0, nres=0, ncap=0, npol=0, nNewPol=0;

  public static final int NONE=0;
  public static final int LED=1;
  public static final int RES=2;
  public static final int CAP=3;
  public static final int POL=4;

  Panel chipcol; // colors
  hCanvas vcol,gcol; //+5V and GND
  hCanvas cvs;
  cCanvas[] chips;
  
  Image switchOpen, switchClosed, ground;
  MediaTracker powerMt;

  Image imgOff, imgOn, imgOnZ, imgOffZ, interpImg;
  //offscreen buffers; LEDs unlit, lit. pols zorched, unz
  int[] offArr, onArr, onZArr, interpArr;

  MemoryImageSource mis;

  int[] whiteArr;
  MemoryImageSource whiteMis;
  Image whiteImg;

  int last_x, last_y;
  int currentColor = 0;
  
  boolean power=false;
  boolean running=false;

  int scatter = 0;
  int rate = 0;

  Applet thisApplet=this;
  
  
  
  class hCanvas extends Canvas
  {
    Image img=null;

    hCanvas()
      {
	super();
      }

    public void update(Graphics g)
      { paint(g); }
    
    public void paint()
      { paint(this.getGraphics()); }

    public void paint(Graphics g)
      {
	if (img!= null)
	  g.drawImage(img,0,0,this);
	else
	  {
	    g.setColor(Color.lightGray);
	    g.fillRect(0,0,
		       getSize().width,
		       getSize().height);
	  }
      }
  }

  class cCanvas extends Canvas
  {
    Image img1, img2;
    boolean me;

    cCanvas()
      {
	super();
	me=false;
      }

    cCanvas(Image img1, Image img2, boolean me)
      {
	super();
	this.img1 = img1;
	this.img2 = img2;
	this.me = me;
      }

    public void update(Graphics g)
      { paint(g); }
    
    public void paint()
      { paint(this.getGraphics()); }

    public void paint(Graphics g)
      {
	if ((img1!= null)&&(img2!=null))
	  {
	    g.setColor(me?Color.white:Color.lightGray);
	    g.fillRect(0,0, getSize().width,getSize().height);

	    g.drawImage(img1,
			getSize().width/3-img1.getWidth(this)/2,
			getSize().height/3-img1.getHeight(this)/2,
			this);
	    g.drawImage(img2,
			(2*getSize().width)/3-img2.getWidth(this)/2,
			(2*getSize().height)/3-img2.getHeight(this)/2,
			this);
	  }
      }
  }

  class colorChip
  {
    int type1,type2, numType1, numType2;
    Image[] imgs, other;
    int[] w;
    int[] h;
    String name;
    MediaTracker mt;

    // so imgs in imgs/colornumber.gif with a lit/zorched counterpart
    // (all pols and .5 leds -- ack -- so LEDs should all have a lit
    // ctpt but for the revd ones and res/cap/none it'll look the
    // same, ick, whatever) are going to have it in
    // other/colornumber.gif

    colorChip(int numImgs, int type, String colorName,
	      String prefix, String suffix) 
      {
	type1 = type;
	type2 = type;
	numType1 = numImgs;
	numType2 = 0;
	imgs = new Image[numImgs];
	other = new Image[numImgs];
	w = new int[numImgs];
	h = new int[numImgs];
	name = colorName;
	mt = new MediaTracker(thisApplet); 
	
	for (int i=0; i<numImgs; i++)
	  {
	    imgs[i] = thisApplet.getImage
	      (thisApplet.getDocumentBase(), "imgs/"+prefix+i+suffix);
	    mt.addImage(imgs[i], i);
	  }

	for (int i=0; i<numImgs; i++)
	  {
	    other[i] = thisApplet.getImage
	      (thisApplet.getDocumentBase(), "other/"+prefix+i+suffix);
	    mt.addImage(other[i], numImgs+i);
	  }
      }
    
    colorChip(int t1, int t2, String colorName,
	      colorChip colorChip1, colorChip colorChip2)
      {
	type1 = t1;
	type2 = t2;
	numType1 = colorChip1.imgs.length;
	numType2 = colorChip2.imgs.length;

	imgs = new Image[colorChip1.imgs.length+colorChip2.imgs.length];
	other = new Image[colorChip1.imgs.length+colorChip2.imgs.length];
	w = new int[colorChip1.imgs.length+colorChip2.imgs.length];
	h = new int[colorChip1.imgs.length+colorChip2.imgs.length];
	name = colorName;

	//reconsider?
	//	mt = new MediaTracker(thisApplet); 
	
	for (int i=0; i<numType1; i++)
	  {
	    imgs[i] = colorChip1.imgs[i];
	    other[i] = colorChip1.other[i];
	  }
	
	for (int i=0; i<numType2; i++)
	  {
	    imgs[i+numType1] = colorChip2.imgs[i];
	    other[i+numType1] = colorChip2.other[i];
	  }
      }
  }
  
  
  public void init()
    {
      thisApplet = this;

      offArr = new int[400*400];
      onArr = new int[400*400];
      onZArr = new int[400*400];

      interpArr = new int[400*400];
      whiteArr = new int[400*400];

      for (int i=0; i<400*400; i++)
	{
	  interpArr[i]=0xFFFFFFFF;
	  whiteArr[i]=0xFFFFFFFF;
	}

      mis = new MemoryImageSource
	(400,400, interpArr, 0,400);
      mis.setAnimated(true);
      interpImg = createImage(mis);

      whiteMis = new MemoryImageSource
	(400,400, whiteArr, 0,400);
      whiteImg = createImage(whiteMis);

      setUpChips();
      powerImgs();
      gui();
      listeners();
    }
  
  void setUpChips()
    {
      palette = new colorChip[12];
      // we're just writing down how many images there are of each
      // color.  I suppose later we'll do the same with which way
      // they're facing.

      palette[0] = new colorChip(5, LED, "red", "r", ".gif");
      palette[2] = new colorChip(3, CAP, "orange", "o", ".gif");
      palette[4] = new colorChip(5, RES, "yellow", "y", ".gif");
      palette[6] = new colorChip(6, LED, "green", "g", ".gif");
      palette[8] = new colorChip(5, POL, "blue", "b", ".gif");
      palette[10] = new colorChip(3, NONE, "violet", "v", ".gif");
      palette[1] = new colorChip
	(LED, CAP, "red-orange", palette[0], palette[2]); 
      palette[3] = new colorChip
	(CAP, RES, "orange-yellow", palette[2], palette[4]); 
      palette[5] = new colorChip
	(RES, LED, "yellow-green", palette[4], palette[6]); 
      palette[7] = new colorChip
	(LED, POL, "green-blue", palette[6], palette[8]);
      palette[9] = new colorChip
	(POL, NONE, "blue-violet", palette[8], palette[10]);
      palette[11] = new colorChip
	(NONE, LED, "violet-red", palette[10], palette[0]);

    }
  
  void powerImgs()
    {
      powerMt = new MediaTracker(thisApplet); 

      switchClosed = thisApplet.getImage
	(thisApplet.getDocumentBase(), "power/switchClosed.gif");
      powerMt.addImage(switchClosed,0);

      switchOpen = thisApplet.getImage
	(thisApplet.getDocumentBase(), "power/switchOpen.gif");
      powerMt.addImage(switchOpen,1);

      ground = thisApplet.getImage
	(thisApplet.getDocumentBase(), "power/ground.gif");
      powerMt.addImage(ground,2);

    }

  void gui()
    {
      thisApplet.setBackground(Color.black);
      thisApplet.setLayout(null);
      
      vcol = new hCanvas();
      vcol.setBounds(0,0, 48,80);
      thisApplet.add(vcol);

      cvs = new hCanvas();
      cvs.setBounds(48,0, 400,400);
      thisApplet.add(cvs);
      
      gcol = new hCanvas();
      gcol.setBounds(48+400,400-60, 48,60);
      thisApplet.add(gcol);

      chipcol = new Panel();
      chipcol.setLayout(new GridLayout(0,1,0,4));
      chipcol.setBounds(48+400+48,4, 40,400);
      thisApplet.add(chipcol);
      

      chips = new cCanvas[12];
      for (int i=0; i<12; i++)
	{
	  chips[i] = new cCanvas(palette[i].imgs[0],
				 i%2==0?
				 palette[i].imgs[palette[i].imgs.length>1?1:0]:
				 palette[i].imgs[palette[i-1].imgs.length],
				 i==0?true:false);
	  // Was that obscure enough?  It means if it's even (roygbv),
	  // draw the same image twice -- or the first and second if
	  // there's more than one -- and if it's odd (ro oy yg gb bv
	  // vr), draw the first one of each color.  Yikes!

	  chips[i].setSize(40,400/12);
	  chipcol.add(chips[i]);
	}

      validate();
    }
  
  void listeners()
    {
      chips[0].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 0;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[1].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 1;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[2].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 2;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[3].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 3;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[4].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 4;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[5].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 5;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[6].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 6;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[7].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 7;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[8].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 8;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[9].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 9;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[10].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 10;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      chips[11].addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       chips[currentColor].me = false;
	       chips[currentColor].paint();
	       currentColor = 11;
	       chips[currentColor].me = true;
	       chips[currentColor].paint();
	     }
	 }
	 );
      
      
      cvs.addMouseListener
	(new MouseAdapter()
	 {
           public void mouseEntered(MouseEvent e)
	     {
	       cvs.requestFocus();
	     }

	   public void mousePressed(MouseEvent e)
	     {
	       last_x = e.getX();
	       last_y = e.getY();
	     }
	 }
	 );

      cvs.addMouseMotionListener
	(new MouseMotionAdapter()
	 {
	   public void mouseDragged(MouseEvent e)
	     {
	       int i, j, xx, yy;

	       if (power) return;
	       int x = e.getX(), y = e.getY();

	       for (j=0; j<rate+1; j++)
		 {
		   i = (int)Math.round
		     ( ( (double)palette[currentColor].imgs.length - 1.0)
		       * Math.random() );
		   xx = (int)
		     (x + scatter * (Math.random()*2.0 -1.0) - palette[currentColor].w[i]/2);
		   yy = (int)
		     (y + scatter * (Math.random()*2.0 -1.0) - palette[currentColor].h[i]/2);
		   
		   switch (i<palette[currentColor].numType1?
			 palette[currentColor].type1:
			 palette[currentColor].type2)		       
		     {
		     case LED: // not used anywhere
		       nled++;
		       break;
		     case POL:
		       npol++;
		       nNewPol++;
		       break;
		     case CAP:
		       ncap++;
		       break;
		     case RES: // not used anywhere
		       nres++;
		       break;
		     }
		   
		   imgOff.getGraphics().drawImage
		     (palette[currentColor].imgs[i], xx, yy, cvs);

		   imgOn.getGraphics().drawImage
		     (
		      (((i<palette[currentColor].numType1?
			 palette[currentColor].type1:
			 palette[currentColor].type2)		       
			==LED)?
		       palette[currentColor].other[i] :
		       palette[currentColor].imgs[i]),
		      xx, yy, cvs);

		   imgOnZ.getGraphics().drawImage
		     (
		      ((
			((i<palette[currentColor].numType1?
			  palette[currentColor].type1:
			  palette[currentColor].type2)		       
			 ==LED)
			||((i<palette[currentColor].numType1?
			    palette[currentColor].type1:
			    palette[currentColor].type2)		       
			   ==POL)
			)?
		       palette[currentColor].other[i] :
		       palette[currentColor].imgs[i]),
		      xx, yy, cvs);

		   imgOffZ.getGraphics().drawImage
		     (
		      (((i<palette[currentColor].numType1?
			 palette[currentColor].type1:
			 palette[currentColor].type2)		       
			==POL)?
		       palette[currentColor].other[i] :
		       palette[currentColor].imgs[i]),
		      xx, yy, cvs);

		   cvs.img = imgOff;
		   cvs.paint();
		 }
	       
	       last_x = x; last_y = y;
	     }
	 }
	 );
      
      cvs.addKeyListener
        (new KeyAdapter()
         {
           public void keyPressed(KeyEvent e)
             {
	       if ((e.getKeyCode()==10)
                   || (e.getKeyChar()=='\n') 
                   || (e.getKeyChar()==' '))
                 {
		   if (power) return;

		   imgOff.getGraphics().drawImage(whiteImg, 0,0, thisApplet);
		   imgOn.getGraphics().drawImage(whiteImg, 0,0, thisApplet);
		   imgOnZ.getGraphics().drawImage(whiteImg, 0,0, thisApplet);
		   imgOffZ.getGraphics().drawImage(whiteImg, 0,0, thisApplet);

		   cvs.img=imgOff;
		   cvs.paint();
	       
		   nled=0; ncap=0; npol=0; nNewPol=0; nres=0;
		 }
	       else if ((e.getKeyCode() == KeyEvent.VK_DOWN)
			||(e.getKeyCode() == KeyEvent.VK_LEFT))
		 {
		   if (scatter>=10)
		     scatter -=10;
		   if (rate>=1)
		     rate -=1;
		   
		 }
               else if ((e.getKeyCode() == KeyEvent.VK_UP)
			|| (e.getKeyCode() == KeyEvent.VK_RIGHT))
		 {
		   scatter += 10;
		   rate += 1;
		 }
             }
	 }
	 );
      

      vcol.addMouseListener
	(new MouseAdapter()
	 {
	   public void mousePressed(MouseEvent e)
	     {
	       int roff, goff, boff, ron, gon, bon, ronz, gonz, bonz,
		 rinterp, ginterp, binterp;

	       if (running) return;

	       running = true;
	       power = !power;

	       if(power)
		 {
		   vcol.img = switchClosed;
		   vcol.paint();

		   //light right LEDs
		   if ((ncap+npol==0)||(nled==0)) //quick decay
		     {
		       cvs.img = imgOn;
		       cvs.paint();
		     }
		   else
		     {	

		       PixelGrabber pgOff = new PixelGrabber
			 (imgOff, 0,0, 400,400, offArr, 0,400);
		       try{ pgOff.grabPixels(); }
		       catch (InterruptedException ie) { ; }
		       
		       PixelGrabber pgOn = new PixelGrabber
			 (imgOn, 0,0, 400,400, onArr, 0,400);
		       try{ pgOn.grabPixels(); }
		       catch (InterruptedException ie) { ; }
		       
		       for(int l=0; l<=(ncap+npol); l++) 
			 {
			   for (int i=0; i<400*400; i++)
			     {
			       // GOING FROM OFF TO ON

			       ron= (onArr[i]&0xFF0000)>>16;
			       gon= (onArr[i]&0x00FF00)>>8;
			       bon= (onArr[i]&0x0000FF);
			       
			       roff= (offArr[i]&0xFF0000)>>16;
			       goff= (offArr[i]&0x00FF00)>>8;
			       boff= (offArr[i]&0x0000FF);
			       
			       rinterp= (l*ron + (ncap+npol-l)*roff)/(ncap+npol);
			       ginterp= (l*gon + (ncap+npol-l)*goff)/(ncap+npol);
			       binterp= (l*bon + (ncap+npol-l)*boff)/(ncap+npol);
			       
			       interpArr[i]= 0xFF000000
				 | rinterp <<16 | ginterp <<8 | binterp;
			       
			     }

			   mis.newPixels(0,0,400,400);
			   cvs.img=interpImg;
			   cvs.paint();
			 }
		     }  
		   
		   // zorch reversed pols
		   
		   if (nNewPol==0)
		     {
		       running=false;
		       return;
		     }

		   nNewPol=0;

		   PixelGrabber pgOnZ = new PixelGrabber
		     (imgOnZ, 0,0, 400,400, onZArr, 0,400);      
		   try{ pgOnZ.grabPixels(); }
		   catch (InterruptedException ie) { ; }

		   for(int l=0; l<=3; l++) 
		     {
		       for (int i=0; i<400*400; i++)
			 {
			   // GOING FROM ON TO ONZ

			   ron= (onArr[i]&0xFF0000)>>16;
			   gon= (onArr[i]&0x00FF00)>>8;
			   bon= (onArr[i]&0x0000FF);
			   
			   ronz= (onZArr[i]&0xFF0000)>>16;
			   gonz= (onZArr[i]&0x00FF00)>>8;
			   bonz= (onZArr[i]&0x0000FF);
			   
			   rinterp= (l*ronz + (3-l)*ron)/(3);
			   ginterp= (l*gonz + (3-l)*gon)/(3);
			   binterp= (l*bonz + (3-l)*bon)/(3);
			   
			   interpArr[i]= 0xFF000000
			     | rinterp <<16 | ginterp <<8 | binterp;
			 }

			   mis.newPixels(0,0,400,400);
			   cvs.img=interpImg;
			   cvs.paint();
		     }
		   //		   imgOff = imgOffZ;
		   //		   imgOn = imgOnZ;
		   // or is that

		   imgOff.getGraphics().drawImage(imgOffZ, 0,0,thisApplet);
		   imgOn.getGraphics().drawImage(imgOnZ, 0,0,thisApplet);
		 }
	       else //!power
		 {
		   vcol.img = switchOpen;
		   vcol.paint();
		   
		   // unlight LEDs.  don't unzorch pols.
		   // any way we could remove them from the cap count?
		 
		   if ((ncap+npol==0)||(nled==0)) //quick decay
		     {
		       cvs.img = imgOff;
		       cvs.paint();
		     }
		   else
		     {
		       //(imgOff has already been set to imgOffZ)
		       
		       //pgOnZ should be same as before, though.
		       PixelGrabber pgOnZ = new PixelGrabber
			 (imgOnZ, 0,0, 400,400, onZArr, 0,400);
		       try{ pgOnZ.grabPixels(); }
		       catch (InterruptedException ie) { ; }
		       
		       PixelGrabber pgOff = new PixelGrabber
			 (imgOff, 0,0, 400,400, offArr, 0,400);
		       try{ pgOff.grabPixels(); }
		       catch (InterruptedException ie) { ; }
		     
		       for(int l=0; l<=(ncap+npol); l++) 
			 {
			   for (int i=0; i<400*400; i++)
			     {
			       // GOING FROM ONZ TO OFF
			       
			       roff= (offArr[i]&0xFF0000)>>16;
			       goff= (offArr[i]&0x00FF00)>>8;
			       boff= (offArr[i]&0x0000FF);
			       
			       ronz= (onZArr[i]&0xFF0000)>>16;
			       gonz= (onZArr[i]&0x00FF00)>>8;
			       bonz= (onZArr[i]&0x0000FF);
			       
			       rinterp= (l*roff + (ncap+npol-l)*ronz)/(ncap+npol);
			       ginterp= (l*goff + (ncap+npol-l)*gonz)/(ncap+npol);
			       binterp= (l*boff + (ncap+npol-l)*bonz)/(ncap+npol);
			       
			       interpArr[i]= 0xFF000000
				 | rinterp <<16 | ginterp <<8 | binterp;
			     }
			   mis.newPixels(0,0,400,400);
			   cvs.img=interpImg;
			   cvs.paint();
			 }
		     }
		 }
	       running=false;
	     }
	 }
	 );
      
    }

  public void show()
    {
      
      int i,j;

      // wait until all images have loaded

      for (i = 0; i < palette.length; i+=2) // evens only
	for (j = 0; j < 2*palette[i].imgs.length; j++)
	  {
	    this.showStatus
	      ("Loading "
	       + palette[i].name + " chip "
	       + Integer.toString(1+j) + " of "
	       + Integer.toString(2*palette[i].imgs.length,10));
	    try { palette[i].mt.waitForID(j); }
	    catch (InterruptedException e) { ; }
	    // how did it go?
	    if (palette[i].mt.isErrorID(j))
	      {
		this.showStatus("Barfed on chip " + palette[i].name
				+ " image " + j + "; quitting.");
		return;
	      }
	  }

      for (i=0;i<3;i++)
	{
	  this.showStatus
	    ("Loading power hookup image "
	     + Integer.toString(1+i) + " of 3");
	  try { powerMt.waitForID(i); }
	  catch (InterruptedException e) { ; }
	  // how did it go?
	  if (powerMt.isErrorID(i))
	    {
	      this.showStatus("Barfed on power image " + i + "; quitting.");
	      return;
	    }
	  }
      this.showStatus("Images loaded.");

      for (i = 0; i < palette.length; i++)
	for (j = 0; j < palette[i].imgs.length; j++)
	  {
	    palette[i].w[j] = palette[i].imgs[j].getWidth(thisApplet);
	    palette[i].h[j] = palette[i].imgs[j].getHeight(thisApplet);
	  }


      imgOff = this.createImage(400,400);
      imgOn = this.createImage(400,400);
      imgOnZ = this.createImage(400,400);
      imgOffZ = this.createImage(400,400);

      imgOff.getGraphics().drawImage(whiteImg, 0,0, thisApplet);
      imgOn.getGraphics().drawImage(whiteImg, 0,0, thisApplet);
      imgOnZ.getGraphics().drawImage(whiteImg, 0,0, thisApplet);
      imgOffZ.getGraphics().drawImage(whiteImg, 0,0, thisApplet);

      cvs.img = imgOff;
      cvs.paint();

      for(i=0; i<12; i++)
	chips[i].paint();

      vcol.img = switchOpen;
      gcol.img = ground;

      super.show();
    }


  public void destroy()
    {
      for (int i=0; i<palette.length; i+=2)
	for (int j=0; j<palette[i].imgs.length; j++)
	  palette[i].imgs[j].flush();
      // even i because odd-i ones are just references to them(?)
    }


}