Dépôt officiel du code source de l'ERP OpenConcerto

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.ui.effect;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.ColorModel;
import java.awt.image.DirectColorModel;
import java.awt.image.MemoryImageSource;
import java.awt.image.PixelGrabber;

import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JFrame;

public class Spots extends JComponent implements Runnable {

    // Allow to disable (more than 10% CPU on x2go VM (java itself + x2goagent))
    static public final String START_SLEEPING_PROP_NAME = Spots.class.getSimpleName() + ".startSleeping";
    static final boolean START_SLEEPING = Boolean.getBoolean(START_SLEEPING_PROP_NAME);

    static int width = 256;
    static int height = 48;

    private int x;
    private int y;
    private int K;

    private double P;
    private double Q;
    private double R;
    private double S;

    private double U;
    private double V;
    private double W;
    private double X;
    private Thread updateThread;

    private MediaTracker mediaTracker;
    private Image imagePalette;
    private Image imageSpot;
    private boolean initDone;
    private boolean ga;
    private int ha;

    private int ka;
    private float ma;

    private int offset;
    private int pa;

    private int pixles[];
    private int ua[];
    private int va[];

    private Image onScreenImage;
    private MemoryImageSource imageSource;
    private long sleeptime;
    private static final int DEFAULT_SLEEPTIME = 20;
    private static final int STOP_SLEEPTIME = 60 * 60 * 1000;

    public static void main(String[] args) {
        JFrame f = new JFrame();
        final Spots blob1 = new Spots();
        blob1.setPreferredSize(new Dimension(width, height));

        f.setContentPane(blob1);

        f.pack();

        f.setVisible(true);

    }

    public Spots() {
        this(START_SLEEPING, true);
    }

    public Spots(final boolean startSleeping, final boolean addMouseListener) {
        this.sleeptime = startSleeping ? STOP_SLEEPTIME : DEFAULT_SLEEPTIME;
        ga = true;

        pixles = new int[width * height];
        ua = new int[0x10100];
        va = new int[4146];
        setPreferredSize(new Dimension(width, height));
        setMinimumSize(new Dimension(width, height));
        setMaximumSize(new Dimension(width, height));
        if (addMouseListener) {
            this.addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    if (sleeptime == DEFAULT_SLEEPTIME) {
                        // Redessine un fois par heure
                        sleeptime = STOP_SLEEPTIME;
                    } else {
                        sleeptime = DEFAULT_SLEEPTIME;
                        updateThread.interrupt();
                    }
                }
            });
        }
    }

    public void init() {
        setBackground(Color.black);
        ColorModel colorModel = new DirectColorModel(32, 0xff0000, 0x00ff00, 0x0000FF, 0);

        imageSource = new MemoryImageSource(width, height, colorModel, pixles, 0, width);

        imageSource.setAnimated(true);
        imageSource.setFullBufferUpdates(true);
        onScreenImage = createImage(imageSource);
        mediaTracker = new MediaTracker(this);
        imagePalette = new ImageIcon(Spots.class.getResource("pal3.gif")).getImage();
        mediaTracker.addImage(imagePalette, 0);
        imageSpot = new ImageIcon(Spots.class.getResource("blob.gif")).getImage();
        mediaTracker.addImage(imageSpot, 1);

        initDone = false;
        for (int i = 0; i < width * height; i++)
            pixles[i] = 156565;

        for (int j = 0; j < 0x10000; j++)
            ua[j + 256] = -1;

        P = 0.0D;
        Q = 1.0D;
        R = 2D;
        S = 3D;

    }

    public void rotatePaletteAt(int i, int j) {

        offset = i + j * width;
        pa = 0;
        for (int k = 0; k < 64; k++) {
            for (int l = 0; l < 64; l++) {
                if (offset >= 0 && offset < pixles.length) {

                    pixles[offset] += va[pa];
                }
                pa++;
                offset++;
            }
            offset += width - 64;
        }

    }

    public void update(Graphics g) {
        paint(g);
    }

    public void paint(Graphics g) {
        start();
        if (initDone) {
            ha++;
            P += 0.04D * ma;
            Q += 0.054D * ma;
            R += 0.06D * ma;
            S += 0.034D * ma;
            for (int i = 0; i < width * height; i++)
                pixles[i] = 0;

            float centerX = (width - 64) / 2.0F;
            float centerY = (height - 64) / 2.0F;
            U = P;
            V = Q;
            W = R;
            X = S;
            for (int j = 0; j < 6; j++) {
                x = (int) (80 + 30 * Math.cos(U));
                y = (int) (centerY + 18 * Math.sin(U));

                rotatePaletteAt(x, y);
                x = (int) ((double) centerX + 50 + (centerX / 2) * Math.cos(-W));
                y = (int) (centerY + (centerY - 10F) * Math.sin(-W));

                rotatePaletteAt(x, y);
                x = (int) (width + 20 + 18 * Math.cos(W + 1));
                y = (int) (centerY + 18 * Math.sin(W));
                rotatePaletteAt(x, y);
                U += 0.10999999940395355D;
                V += 0.34000000357627869D;
                W += 2.440000057220459D;
                X += 9.4399995803833008D;
            }

            for (int k = 0; k < width * height; k++) {
                pixles[k] = ua[pixles[k]] & 0x00FFFFFF;
                pixles[k] = -pixles[k] + 0x00FFFFFF;
                int b = (pixles[k]) & (0x000000FF);
                float bf = ((255 - b));

                // System.out.println("b:"+b);
                int red = b + (int) ((bf) * (62f / 255));

                int green = b + (int) ((bf) * (5f / 255));
                int blue = b + (int) ((bf) * (141f / 255));

                /*
                 * if(b>200){ blue+=5; red+=5; green+=10; }
                 */
                if (red > 255)
                    red = 255;
                if (green > 255)
                    green = 255;
                if (blue > 255)
                    blue = 255;

                // Color c = new Color(red, green, blue);
                int value = ((255 & 0xFF) << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | ((blue & 0xFF) << 0);
                pixles[k] = value;// c.getRGB();//
                // <<b<<b;//0xFF+(b)*0xFF+0x00FFFF;//+0xFF;//+0xFF*b+0xFFFF*b;
                // System.out.println(pixles[k]+" /"+0x00FFFFFF);

            }
            if (imageSource != null)
                imageSource.newPixels();

            g.drawImage(onScreenImage, 0, 0, null);
            getToolkit().sync();
        }
    }

    private void b() {

        if (ga)
            while (!mediaTracker.checkAll(true))
                try {
                    Thread.sleep(20L);
                } catch (Exception exception) {
                }
        PixelGrabber pixelgrabberPalette = new PixelGrabber(imagePalette, 0, 0, 256, 1, ua, 0, 256);
        try {
            pixelgrabberPalette.grabPixels();
        } catch (InterruptedException interruptedexception) {
        }
        PixelGrabber pixelgrabberSpot = new PixelGrabber(imageSpot, 0, 0, 64, 64, va, 0, 64);
        try {
            pixelgrabberSpot.grabPixels();
        } catch (InterruptedException interruptedexception1) {
        }
        offset = 0;
        for (int i = 0; i < 64; i++) {
            for (int j = 0; j < 64; j++) {
                K = va[offset] & 0xff;
                va[offset] = K;
                offset++;
            }

        }

        initDone = true;
    }

    public void start() {
        if (updateThread == null) {
            init();
            b();
            updateThread = new Thread(this, this.getClass().getName());
            updateThread.setDaemon(true);
            updateThread.start();
        }
    }

    public void stop() {
        updateThread = null;
    }

    public void run() {

        long lastCurrentTimeMillis = System.currentTimeMillis() - 250;
        long currentTimeMillis;

        ha = 0;
        ma = 0.0002F;

        while (Thread.currentThread() == updateThread) {

            repaint();
            currentTimeMillis = System.currentTimeMillis();
            if (currentTimeMillis - lastCurrentTimeMillis > 500) {
                ka = ha;
                lastCurrentTimeMillis = currentTimeMillis;
                ha = 0;

                ma = ma * 0.35F + 0.65F * (50F / (ka * 2));

                if (ma < 2E-005F)
                    ma = 2E-005F;
                if (ma > 40F)
                    ma = 40F;
            }
            try {
                Thread.sleep(sleeptime);
            } catch (InterruptedException interruptedexception) {
            }
        }
    }

}