--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/snippets/toolbar/Snippet288.d	Sat May 10 13:32:45 2008 -0700
@@ -0,0 +1,208 @@
+/*******************************************************************************
+ * Copyright (c) 2008 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+module snippets.toolbar.Snippet288;
+
+/*
+ * Create a ToolBar containing animated GIFs
+ *
+ * For a list of all SWT example snippets see
+ * http://www.eclipse.org/swt/snippets/
+ */
+import dwt.DWT;
+import dwt.DWTException;
+import dwt.graphics.GC;
+import dwt.graphics.Color;
+import dwt.graphics.Image;
+import dwt.graphics.ImageLoader;
+import dwt.graphics.ImageData;
+import dwt.widgets.Display;
+import dwt.widgets.Shell;
+import dwt.widgets.ToolBar;
+import dwt.widgets.ToolItem;
+import dwt.widgets.FileDialog;
+import dwt.dwthelper.Runnable;
+
+import tango.io.FilePath;
+import tango.io.FileConst;
+import tango.core.Thread;
+import tango.io.Stdout;
+import tango.util.Convert;
+import tango.core.Exception;
+
+static Display display;
+static Shell shell;
+static GC shellGC;
+static Color shellBackground;
+static ImageLoader[] loader;
+static ImageData[][] imageDataArray;
+static Thread[] animateThread;
+static Image[][] image;
+private static ToolItem[] item;
+static final bool useGIFBackground = false;
+
+void main () {
+    display = new Display();
+    Shell shell = new Shell (display);
+    shellBackground = shell.getBackground();
+    FileDialog dialog = new FileDialog(shell, DWT.OPEN | DWT.MULTI);
+    dialog.setText("Select Multiple Animated GIFs");
+    dialog.setFilterExtensions(["*.gif"]);
+    char[] filename = dialog.open();
+    char[][] filenames = dialog.getFileNames();
+    int numToolBarItems = filenames.length;
+    if (numToolBarItems > 0) {
+        try {
+            loadAllImages((new FilePath(filename)).parent, filenames);
+        } catch (DWTException e) {
+            Stdout.print("There was an error loading an image.").newline;
+            e.printStackTrace();
+        }
+        ToolBar toolBar = new ToolBar (shell, DWT.FLAT | DWT.BORDER | DWT.WRAP);
+        item = new ToolItem[numToolBarItems];
+        for (int i = 0; i < numToolBarItems; i++) {
+            item[i] = new ToolItem (toolBar, DWT.PUSH);
+            item[i].setImage(image[i][0]);
+        }
+        toolBar.pack ();
+        shell.open ();
+			
+        startAnimationThreads();
+			
+        while (!shell.isDisposed()) {
+            if (!display.readAndDispatch ()) display.sleep ();
+        }
+			
+        for (int i = 0; i < numToolBarItems; i++) {
+            for (int j = 0; j < image[i].length; j++) {
+                image[i][j].dispose();
+            }
+        }
+        display.dispose ();
+    }
+    thread_joinAll();
+}
+
+private static void loadAllImages(char[] directory, char[][] filenames) {
+    int numItems = filenames.length;
+    loader.length = numItems;
+    imageDataArray.length = numItems;
+    image.length = numItems;
+    for (int i = 0; i < numItems; i++) {
+        loader[i] = new ImageLoader();
+        int fullWidth = loader[i].logicalScreenWidth;
+        int fullHeight = loader[i].logicalScreenHeight;
+        imageDataArray[i] = loader[i].load(directory ~ FileConst.PathSeparatorChar ~ filenames[i]);
+        int numFramesOfAnimation = imageDataArray[i].length;
+        image[i] = new Image[numFramesOfAnimation];
+        for (int j = 0; j < numFramesOfAnimation; j++) {
+            if (j == 0) {
+                //for the first frame of animation, just draw the first frame
+                image[i][j] = new Image(display, imageDataArray[i][j]);
+                fullWidth = imageDataArray[i][j].width;
+                fullHeight = imageDataArray[i][j].height;
+            }
+            else {
+                //after the first frame of animation, draw the background or previous frame first, then the new image data 
+                image[i][j] = new Image(display, fullWidth, fullHeight);
+                GC gc = new GC(image[i][j]);
+                gc.setBackground(shellBackground);
+                gc.fillRectangle(0, 0, fullWidth, fullHeight);
+                ImageData imageData = imageDataArray[i][j];
+                switch (imageData.disposalMethod) {
+                case DWT.DM_FILL_BACKGROUND:
+                    /* Fill with the background color before drawing. */
+                    Color bgColor = null;
+                    if (useGIFBackground && loader[i].backgroundPixel != -1) {
+                        bgColor = new Color(display, imageData.palette.getRGB(loader[i].backgroundPixel));
+                    }
+                    gc.setBackground(bgColor !is null ? bgColor : shellBackground);
+                    gc.fillRectangle(imageData.x, imageData.y, imageData.width, imageData.height);
+                    if (bgColor !is null) bgColor.dispose();
+                    break;
+                default:
+                    /* Restore the previous image before drawing. */
+                    gc.drawImage(
+                        image[i][j-1],
+                        0,
+                        0,
+                        fullWidth,
+                        fullHeight,
+                        0,
+                        0,
+                        fullWidth,
+                        fullHeight);
+                    break;
+                }
+                Image newFrame = new Image(display, imageData);
+                gc.drawImage(newFrame,
+                             0,
+                             0,
+                             imageData.width,
+                             imageData.height,
+                             imageData.x,
+                             imageData.y,
+                             imageData.width,
+                             imageData.height);
+                newFrame.dispose();
+                gc.dispose();
+            }
+        }
+    }
+}
+
+private static void startAnimationThreads() {
+    animateThread = new Thread[image.length];
+    for (int ii = 0; ii < image.length; ii++) {
+        animateThread[ii] = new class(ii) Thread {
+            int imageDataIndex = 0;
+            int id = 0;
+            this(int _id) { 
+                id = _id;
+                name = "Animation "~to!(char[])(ii);
+                isDaemon = true;
+                super(&run);
+            }
+            void run() {
+                try {
+                    int repeatCount = loader[id].repeatCount;
+                    while (loader[id].repeatCount == 0 || repeatCount > 0) {
+                        imageDataIndex = (imageDataIndex + 1) % imageDataArray[id].length;
+                        if (!display.isDisposed()) {
+                            display.asyncExec(new class Runnable {
+									public void run() {
+										if (!item[id].isDisposed())
+											item[id].setImage(image[id][imageDataIndex]);
+									}
+								});
+                        }
+							
+                        /* Sleep for the specified delay time (adding commonly-used slow-down fudge factors). */
+                        try {
+                            int ms = imageDataArray[id][imageDataIndex].delayTime * 10;
+                            if (ms < 20) ms += 30;
+                            if (ms < 30) ms += 10;
+                            Thread.sleep(0.001*ms);
+                        } catch (ThreadException e) {
+                        }
+
+                        /* If we have just drawn the last image, decrement the repeat count and start again. */
+                        if (imageDataIndex == imageDataArray[id].length - 1) repeatCount--;
+                    }
+                } catch (DWTException ex) {
+                    Stdout.print("There was an error animating the GIF").newline;
+                    ex.printStackTrace();
+                }
+            }
+        };
+        animateThread[ii].start();
+    }
+}
+