AnimatedGifControl.java

package com.yoursway.common.ui.animatedimage;

import java.io.InputStream;

import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

/**
 * @author Andrey Tarantsov
 * @see http://www.java2s.com/Code/Java/SWT-JFace-Eclipse/DisplayananimatedGIF.htm
 */
public class AnimatedGifControl extends Composite implements Listener {
    
    final static class AnimatedGifPainter {
        
        private final Display display;
        
        private Image canvasImage = null;
        private GC canvasGC = null;
        
        private Image currentFrameImage = null;
        
        private ImageLoader loader;
        
        private int frameOnOffscreenImage = -1;
        
        private Image backgroundImage;
        
        private Point backgroundImageOffset;
        
        private Color backgroundColor;
        
        public AnimatedGifPainter(Display display) {
            if (display == null)
                throw new NullPointerException("display is null");
            this.display = display;
        }
        
        public void setImageData(ImageLoader loader) {
            this.loader = loader;
            disposeCanvas();
            canvasImage = new Image(display, loader.logicalScreenWidth, loader.logicalScreenHeight);
            canvasGC = new GC(canvasImage);
        }
        
        public void setBackgroundColor(Color color) {
            if (color == null)
                throw new NullPointerException("color is null");
            backgroundColor = color;
            backgroundImage = null;
            backgroundImageOffset = null;
        }
        
        public void setBackgroundImage(Image image, Point offset) {
            if (image == null)
                throw new NullPointerException("image is null");
            if (offset == null)
                throw new NullPointerException("offset is null");
            backgroundColor = null;
            backgroundImage = image;
            backgroundImageOffset = offset;
        }
        
        public void setCurrentImage(int index) {
            disposeFrameImage();
            
            if (frameOnOffscreenImage >= 0) {
                ImageData data = loader.data[frameOnOffscreenImage];
                switch (data.disposalMethod) {
                case SWT.DM_FILL_BACKGROUND:
                    fillCanvasWithBackground();
                    break;
                case SWT.DM_FILL_PREVIOUS:
                    // TODO implement me
                    throw new UnsupportedOperationException(
                            "DM_FILL_PREVIOUS not supported in animated Gifs, but can be easily added (pls see code)");
                case SWT.DM_FILL_NONE:
                    break;
                }
            } else {
                fillCanvasWithBackground();
            }
            
            ImageData imageData = loader.data[index];
            currentFrameImage = new Image(display, imageData);
            canvasGC.drawImage(currentFrameImage, 0, 0, imageData.width, imageData.height, imageData.x,
                    imageData.y, imageData.width, imageData.height);
            frameOnOffscreenImage = index;
        }
        
        private void fillCanvasWithBackground() {
            if (backgroundImage != null)
                canvasGC.drawImage(backgroundImage, backgroundImageOffset.x, backgroundImageOffset.y,
                        loader.logicalScreenWidth, loader.logicalScreenHeight, 0, 0,
                        loader.logicalScreenWidth, loader.logicalScreenHeight);
            else {
                //              Color bgColor = null;
                //              if (useGifBackground && loader.backgroundPixel != -1) {
                //                  bgColor = new Color(getDisplay(), imageData.palette
                //                          .getRGB(loader.backgroundPixel));
                //              }
                //              if (bgColor != null)
                //                  bgColor.dispose();
                canvasGC.setBackground(backgroundColor);
                canvasGC.fillRectangle(0, 0, loader.logicalScreenWidth, loader.logicalScreenHeight);
            }
        }
        
        private void disposeCanvas() {
            if (canvasGC != null)
                canvasGC.dispose();
            if (canvasImage != null)
                canvasImage.dispose();
        }
        
        private void disposeFrameImage() {
            if (currentFrameImage != null && !currentFrameImage.isDisposed())
                currentFrameImage.dispose();
        }
        
        public int frameCount() {
            return loader.data.length;
        }
        
        public int frameWidth() {
            return loader.logicalScreenWidth;
        }
        
        public int frameHeight() {
            return loader.logicalScreenHeight;
        }
        
        public void paintOn(GC gc, int x, int y) {
            gc.drawImage(canvasImage, x, y);
        }
        
        public void dispose() {
            disposeCanvas();
            disposeFrameImage();
        }
        
    }
    
    private final class AnimationThread extends Thread {
        
        private AnimationThread(String name) {
            super(name);
        }
        
        public void run() {
            AnimatedGifPainter painter = new AnimatedGifPainter(getDisplay());
            try {
                SharedData data = null;
                boolean shouldRunAnimation = false;
                while (!shouldRunAnimation)
                    synchronized (sharedDataSync) {
                        data = sharedData;
                        shouldRunAnimation = data.backgroundImageValid && data.imageLoaded && data.isVisible
                                && data.clientArea != null;
                        if (!shouldRunAnimation)
                            try {
                                sharedDataSync.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                    }
                painter.setImageData(loader);
                painter.setBackgroundImage(data.backgroundImage, new Point(data.bounds.x, data.bounds.y));
                int imageDataIndex = 0;
                painter.setCurrentImage(imageDataIndex);
                int repeatCount = loader.repeatCount;
                while (loader.repeatCount == 0 || repeatCount > 0) {
                    if (isDisposed())
                        break;
                    
                    imageDataIndex = (imageDataIndex + 1) % painter.frameCount();
                    painter.setCurrentImage(imageDataIndex);
                    
                    /* Draw the off-screen image to the shell. */
                    int x = (data.clientArea.width - painter.frameWidth()) / 2;
                    int y = (data.clientArea.height - painter.frameHeight()) / 2;
                    painter.paintOn(gc, x, y);
                    
                    try {
                        sleepWithFudge(data.delayOverrideMs >= 0 ? data.delayOverrideMs
                                : loader.data[imageDataIndex].delayTime * 10);
                    } catch (InterruptedException e) {
                        return;
                    }
                    
                    if (imageDataIndex == painter.frameCount() - 1)
                        repeatCount--;
                }
            } catch (SWTException ex) {
                if (ex.code != SWT.ERROR_WIDGET_DISPOSED) {
                    System.out.println("There was an error animating the GIF");
                    ex.printStackTrace();
                }
            } finally {
                painter.dispose();
            }
        }
    }
    
    /**
     * Sleep for the specified delay time (adding commonly-used slow-down fudge
     * factors).
     */
    static void sleepWithFudge(int ms) throws InterruptedException {
        if (ms < 20)
            ms += 30;
        if (ms < 30)
            ms += 10;
        Thread.sleep(ms);
    }
    
    private static class SharedData implements Cloneable {
        
        public boolean useGifBackground = false;
        
        public boolean imageLoaded = false;
        
        public int delayOverrideMs = -1;
        
        public boolean backgroundImageValid = false;
        
        public Image backgroundImage;
        
        public GC backgroundGC;
        
        public Rectangle clientArea;
        
        public boolean isVisible;
        
        public Rectangle bounds;
        
        @Override
        protected SharedData clone() {
            try {
                return (SharedData) super.clone();
            } catch (CloneNotSupportedException e) {
                throw new AssertionError(e);
            }
        }
        
    }
    
    private volatile SharedData sharedData = new SharedData();
    
    private final Object sharedDataSync = new Object();
    
    private final GC gc;
    
    private Thread animateThread;
    
    private final ImageLoader loader;
    
    public AnimatedGifControl(Composite parent, int style) {
        super(parent, style);
        gc = new GC(this);
        loader = new ImageLoader();
        
        animateThread = new AnimationThread("Animation");
        animateThread.setDaemon(true);
        animateThread.start();
        
        addListener(SWT.Resize, this);
        addListener(SWT.Show, this);
        addListener(SWT.Hide, this);
        handleResize();
    }
    
    public void loadImage(InputStream stream) {
        SharedData newData = sharedData.clone();
        try {
            loader.load(stream);
            newData.imageLoaded = true;
        } catch (SWTException ex) {
            System.out.println("There was an error loading the GIF");
            ex.printStackTrace();
            newData.imageLoaded = false;
        }
        setSharedData(newData);
    }
    
    @Override
    public Point computeSize(int wHint, int hHint, boolean changed) {
        if (sharedData.imageLoaded)
            return new Point(loader.logicalScreenWidth, loader.logicalScreenHeight);
        else
            return super.computeSize(wHint, hHint, changed);
    }
    
    public void setDelayOverrideMs(int delayOverrideMs) {
        SharedData newData = sharedData.clone();
        newData.delayOverrideMs = delayOverrideMs;
        setSharedData(newData);
        updateVisibility();
    }
    
    public void handleEvent(Event event) {
        switch (event.type) {
        case SWT.Show:
            photocopyBackground();
            updateVisibility();
            break;
        case SWT.Hide:
            updateVisibility();
            break;
        case SWT.Resize:
            handleResize();
            break;
        }
    }
    
    private void handleResize() {
        SharedData newData = sharedData.clone();
        newData.clientArea = getClientArea();
        setSharedData(newData);
    }
    
    private void updateVisibility() {
        SharedData data = sharedData.clone();
        data.isVisible = isVisible();
        if (!data.isVisible)
            data.backgroundImageValid = false;
        setSharedData(data);
    }
    
    public void photocopyBackground() {
        Composite parent = getParent();
        Rectangle clientArea = parent.getClientArea();
        SharedData newData = sharedData.clone();
        newData.backgroundImage = new Image(getDisplay(), clientArea.width, clientArea.height);
        newData.backgroundGC = new GC(newData.backgroundImage);
        parent.print(newData.backgroundGC);
        newData.backgroundImageValid = true;
        newData.bounds = getBounds();
        setSharedData(newData);
    }
    
    private void setSharedData(SharedData sharedData) {
        synchronized (sharedDataSync) {
            this.sharedData = sharedData;
            sharedDataSync.notifyAll();
        }
    }
    
}