java swt 之 图片控件

swt好像加载动态gif也得需要自己让图片跑起来，找了很长时间找到一份源码，改了改，让它更原本一点。

 

使用的话，注意gif帧速的变量，可以自己多调试调试，gif在不同的平台上速度是不一样的，就像那个跑疯了的手机测试gif一样。

 

 

package atomQQswt.ui.core;

import java.io.InputStream;

import org.eclipse.swt.SWT;
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.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

public class ImageCanvas extends Canvas {
    
    private ImageLoader loader;

    protected Point origin = new Point(0, 0);
    protected Image image;
    protected ImageData[] imageDatas;
    protected Image[] images;
    protected int current;

    private int repeatCount;
    private Runnable animationTimer;
 
    private Color bg;
    private Display display;

    public ImageCanvas(Composite parent) {
        super(parent, SWT.DOUBLE_BUFFERED | SWT.INHERIT_FORCE |SWT.INHERIT_DEFAULT);

      
        bg = getBackground();
        display = getDisplay();
        addListeners();
    }
    
    /**
     * 传入路径获取图片.
     *
     * @param path the new image
     */
    public void setImage(String path){
         loader = new ImageLoader();
         imageDatas = loader.load(path);
         if(imageDatas.length == 0)
             return;
         else if(imageDatas.length == 1){
             checkWidget();

             stopAnimationTimer();
             this.image = new Image(display, imageDatas[0]);
             this.imageDatas = null;
             this.images = null;
             redraw();
         }else {
             checkWidget();

             this.image = null;
             this.repeatCount = loader.repeatCount;
             convertImageDatasToImages();
             startAnimationTimer();
             redraw();
             
         }
    }
    
    /**
     * 传入InputStream获取图片.
     *
     * @param isin the new image
     */
    public void setImage(InputStream isin){
         loader = new ImageLoader();
         imageDatas = loader.load(isin);
         if(imageDatas.length == 0)
             return;
         else if(imageDatas.length == 1){
             checkWidget();

             stopAnimationTimer();
             this.image = new Image(display, imageDatas[0]);
             this.imageDatas = null;
             this.images = null;
             redraw();
         }else {
             checkWidget();

             this.image = null;
             this.repeatCount = loader.repeatCount;
             convertImageDatasToImages();
             startAnimationTimer();
             redraw();
             
         }
        
    }

    

    @Override
    public Point computeSize(int wHint, int hHint, boolean changed) {
        checkWidget();

        Image image = getCurrentImage();
        if (image != null) {
            Rectangle rect = image.getBounds();
            Rectangle trim = computeTrim(0, 0, rect.width, rect.height);
            return new Point(trim.width, trim.height);
        }

        return new Point(wHint, hHint);
    }

    @Override
    public void dispose() {
        if (image != null)
            image.dispose();

        if (images != null)
            for (int i = 0; i < images.length; i++)
                images[i].dispose();

        super.dispose();
    }

    protected void paint(Event e) {
        Image image = getCurrentImage();
        if (image == null)
            return;

        GC gc = e.gc;
        gc.drawImage(image, origin.x, origin.y);

        gc.setBackground(bg);
        Rectangle rect = image.getBounds();
        Rectangle client = getClientArea();
        int marginWidth = client.width - rect.width;
        if (marginWidth > 0) {
            gc.fillRectangle(rect.width, 0, marginWidth, client.height);
        }
        int marginHeight = client.height - rect.height;
        if (marginHeight > 0) {
            gc.fillRectangle(0, rect.height, client.width, marginHeight);
        }
        
        
       
    }

    void addListeners() {
        addListener(SWT.Paint, new Listener() {
            public void handleEvent(Event e) {
                paint(e);
            }
        });
    }

  

    void convertImageDatasToImages() {
        images = new Image[imageDatas.length];

        // Step 1: Determine the size of the resulting images.
        int width = imageDatas[0].width;
        int height = imageDatas[0].height;

        // Step 2: Construct each image.
        int transition = SWT.DM_FILL_BACKGROUND;
        for (int i = 0; i < imageDatas.length; i++) {
            ImageData id = imageDatas[i];
            images[i] = new Image(display, width, height);
            GC gc = new GC(images[i]);

            // Do the transition from the previous image.
            switch (transition) {
            case SWT.DM_FILL_NONE:
            case SWT.DM_UNSPECIFIED:
                // Start from last image.
                gc.drawImage(images[i - 1], 0, 0);
                break;
            case SWT.DM_FILL_PREVIOUS:
                // Start from second last image.
                gc.drawImage(images[i - 2], 0, 0);
                break;
            default:
                // DM_FILL_BACKGROUND or anything else,
                // just fill with default background.
                gc.setBackground(bg);
                gc.fillRectangle(0, 0, width, height);
                break;
            }

            // Draw the current image and clean up.
            Image img = new Image(display, id);
            gc.drawImage(img, 0, 0, id.width, id.height, id.x, id.y, id.width,
                    id.height);
            img.dispose();
            gc.dispose();

            // Compute the next transition.
            // Special case: Can't do DM_FILL_PREVIOUS on the
            // second image since there is no "second last"
            // image to use.
            transition = id.disposalMethod;
            if (i == 0 && transition == SWT.DM_FILL_PREVIOUS)
                transition = SWT.DM_FILL_NONE;
        }
    }

    Image getCurrentImage() {
        if (image != null)
            return image;

        if (images == null)
            return null;

        return images[current];
    }

    void startAnimationTimer() {
        if (images == null || images.length < 2)
            return;

        int delay = imageDatas[current].delayTime*20;
        if (delay <5) delay = 100;
       
        final int ms=delay;
        display.timerExec(ms, animationTimer = new Runnable() {
            public void run() {
                if (isDisposed())
                    return;

                current = (current + 1) % images.length;
                redraw();

                if (current + 1 == images.length && repeatCount != 0
                        && --repeatCount <= 0)
                    return;
                display.timerExec(ms, this);
            }
        });
    }

    void stopAnimationTimer() {
        if (animationTimer != null)
            display.timerExec(-1, animationTimer);
    }
}