RunningRainbow

// ***********************************************************
//  >>start
//	>name: 	RunningRainbow
//	>class: 	Applet
//	>Autor: 	(C) 1996 by Oleg V. Baranovsky.
//	>e-mail:	oleg@usemb.kiev.ua
//	>URL: 	http://www.usemb.kiev.ua/oleg/
//	>Description:
//		>>start
// 	Implements different methods for generation of running rainbow lines
//		>>end
//	>Classification:	Graphics/VisualEffects
//  >>end
// ***********************************************************

import java.awt.*;
import java.applet.Applet;
import java.lang.Math;
import java.lang.System;

public class RunningRainbow extends Applet implements Runnable {
    int delay;
    int shift;
    int offset;
    double ss, ar, ag, ab, sr, sg ,sb, ar1;
    String direction;
    String method;
    boolean isInvert;
    boolean isRunning;
    boolean isParams=false;
    Thread animatorThread;
    Image offImage;
    Graphics offGraphics;

    public void init() {
		isRunning=true;
		if (!isParams) getParams();
    }

    public void getParams() {
        String str;


	isParams=true;
	// How many milliseconds between frames?
        str = getParameter("delay");
        int fps = (str != null) ? Integer.parseInt(str) : 100;
        delay = (fps > 10) ?  fps : 100;

        // Shift between frames.
        str = getParameter("shift");
        fps = (str != null) ? Integer.parseInt(str) : 2;
        fps = (fps >= 0 && fps < 256) ? fps : 2;
        shift = size().width*fps/256;

        direction = getParameter("direction");
	if (direction == null) direction = new String("left");

        str = getParameter("invert");
        isInvert = str != null;

        method = getParameter("method");
        if (method == null) method = new String("none");
        if (method.compareTo("gaussian") == 0){
	//Now let's get parameters for color generator.
	  ar = getDoubleParam("ar", 0.);
          ag = getDoubleParam("ag", 0.5);
          ab = getDoubleParam("ab", 1.);
          ar1 = getDoubleParam("ar1", 0.);

          if (getParameter("ss") != null) {
            ss = getDoubleParam("ss", 0.5);
            sr = sg = sb = ss;
          } else {
            sr = getDoubleParam("sr", 0.5);
            sg = getDoubleParam("sg", 0.5);
            sb = getDoubleParam("sb", 0.5);
          }
          sr = sr*sr/2; sg = sg*sg/2; sb = sb*sb/2;
        }
    }


	public double getDoubleParam(String param, double defValue)
	{
	String str;
	double dbl;

        str = getParameter(param);
        if (str != null) dbl = parseDouble(str); else dbl = defValue;
        if (dbl < 0 || dbl > 1) dbl = defValue;
		return dbl;
	}

    public void start() {
        if (isRunning) {
			if (animatorThread == null) {
                animatorThread = new Thread(this);
				//getParams();
            }
			animatorThread.start();
        }
    }

    public void stop() {
        animatorThread = null;
    }

    public boolean mouseDown(Event e, int x, int y) {
        if(isRunning) {
			isRunning=false;
			stop();
		} else {

			isRunning=true;
			start();
		}
        return true;
    }

    public void run() {

        //Let's put somehow lower than normal priority.
		Thread.currentThread().setPriority(3);

      if (direction.compareTo("none") == 0) {
	    offset = shift;
	    repaint();
	    return;
	  }

        // Remember the starting time
      long startTime = System.currentTimeMillis();

      while (Thread.currentThread() == animatorThread) {
        // Display the next frame of animation.
        repaint();

        // Delay depending on how far we are behind.
        try {
          startTime += delay;
          Thread.sleep(Math.max(0, startTime-System.currentTimeMillis()));
        } catch (InterruptedException e) {
		    break;
		}

        if (direction.compareTo("right") == 0) {
           offset-=shift;
           if (offset < 0) offset = size().width;
        } else
           if (direction.compareTo("left") == 0) {
             offset+=shift;
             if (offset >= size().width) offset = 0;
           }
        }
    }

    // Paint the previous frame (if any).
    public void paint(Graphics g) {
        if (offImage != null) {
            g.drawImage(offImage, -offset, 0, this);
            g.drawImage(offImage, size().width-offset, 0, this);
        }
    }

    public void update(Graphics g) {
      if (offImage == null) createBuffer();
      g.drawImage(offImage, -offset, 0, this);
      g.drawImage(offImage, size().width-offset, 0, this);
    }

    public void createBuffer() {
	int x;

      if (offImage == null) offImage=createImage(size().width, size().height);
	  offGraphics=offImage.getGraphics();

	  if (method.compareTo("gaussian") == 0) {
          for (x = 0; x < size().width; x++) {
            offGraphics.setColor(cg(x));
            offGraphics.drawLine(x, 0, x, size().height);
	      }
	  } else {
          for (x = 0; x < size().width; x++) {
            offGraphics.setColor(c(x));
            offGraphics.drawLine(x, 0, x, size().height);
	      }
	  }
    }

    public Color c(int x){
      if (x >= size().width) x -= size().width;
      double y = (double)x * 6. / (double)(size().width);
      double r, g, b;

      if (y < 1) { r = 1; g = y; b = 0;}
      else
        if (y < 2) { r = 2.-y; g = 1; b = 0;}
        else
          if (y < 3) { r = 0; g = 1; b = y-2.0;}
          else
            if (y < 4) { r = 0; g = 4.0-y; b = 1;}
            else
              if (y < 5) { r = y-4.0; g = 0; b = 1;}
              else { r = 1; g = 0; b = 6.0-y;}
      return new Color((float)r, (float)g, (float)b);
    }

    public Color cg(int x){
      while (x >= size().width) {x -= size().width;};
      double y = (double)x / (double)(size().width);
      double r, g, b;

      if (ar1 != 0 && y > 0.5) r = y - ar1; else r = y - ar;
      g = y - ag; b = y - ab;
      if (sr != 0) r = Math.exp(-r*r/sr); else r = 0;
      if (sg != 0) g = Math.exp(-g*g/sg); else g = 0;
      if (sb != 0) b = Math.exp(-b*b/sb); else b = 0;
      if (isInvert)
	return new Color((float)(1-r), (float)(1-g), (float)(1-b));
      else
	return new Color((float)r, (float)g, (float)b);
    }

    public double parseDouble(String str) {
      Double d = new Double(str);
      return d.doubleValue();
    }

	public String getAppletInfo() {
      return "Running Rainbow applet. Copyright (c)1997, by Oleg V. Baranovsky.";
    }

	public String[][] getParameterInfo() {
       String[][] info = {
          // Parameter Name     Kind of Value   Description
           {"delay",            "Integer",      "delay of animation"},
           {"shift",            "Integer",      "shift of animation"},
           {"direction",        "String",       "direction of animation: left or right"},
           {"method",           "Integer",      "method of rainbow rendering: gaussian or trapezoid"},
           {"ar",               "Double",       "mean value of red component"},
           {"ag",               "Double",       "mean value of green component"},
           {"ab",               "Double",       "mean value of blue component"},
           {"sr",               "Double",       "dispersion of red component"},
           {"sg",               "Double",       "dispersion of green component"},
           {"sb",               "Double",       "dispersion of blue component"},
       };
       return info;
    }
}

Back to the RunningRainbow applet page.

How to Add Java Applets to Your Site

New on the Java Boutique:

New Review:

Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling API boasts simplicity, ease-of-integration, a well-rounded feature set, and it's free!

New Applet:

Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA sequences into three useful formats.

Elsewhere on internet.com:

WebDeveloper Java
Lots of Java information on webdeveloper.com

WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.

ScriptSearch Java
Hundreds of free Java code files to download.

jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.