Fixes

4 files changed, 578 insertions, 14 deletions

diff --git a/examples/org.eclipse.swt.opengl.examples/plugin.properties b/examples/org.eclipse.swt.opengl.examples/plugin.properties
index 418b729e44..53ce66cc6a 100755
--- a/examples/org.eclipse.swt.opengl.examples/plugin.properties
+++ b/examples/org.eclipse.swt.opengl.examples/plugin.properties
@@ -11,11 +11,6 @@
 providerName = Eclipse.org
 plugin.OpenGLExampleSet.name = SWT OpenGL Examples Plugin
 
-launchcategory.OpenGLExamples.name = OpenGL
-launchcategory.OpenGLExamples.description = \
-	A collection of examples that demonstrate using OpenGL \
-	with the Standard Widget Toolkit.
-
 launchitem.OpenGLExample.name = OpenGL Example
 launchitem.OpenGLExample.description = \
 	The OpenGL example shows how to use many OpenGL features in \
diff --git a/examples/org.eclipse.swt.opengl.examples/plugin.xml b/examples/org.eclipse.swt.opengl.examples/plugin.xml
index 362b933dda..92fce2ec9c 100755
--- a/examples/org.eclipse.swt.opengl.examples/plugin.xml
+++ b/examples/org.eclipse.swt.opengl.examples/plugin.xml
@@ -10,7 +10,7 @@
 <!-- Required plugins -->
 <requires>
    <import plugin="org.eclipse.swt"/>
-   <import plugin="org.eclipse.swt.opengl"/>
+   <import plugin="org.eclipse.opengl"/>
 </requires>
 
 <!-- Runtime -->
@@ -24,15 +24,10 @@
 <!-- Extension points -->
 <extension
       point="org.eclipse.swt.examples.launcher.launchItems">
-   <category
-         name="%launchcategory.OpenGLExamples.name"
-         description="%launchcategory.OpenGLExamples.description"
-         id="org.eclipse.swt.examples.launchOpenGLCategory">
-   </category>
    <item
          name="%launchitem.OpenGLExample.name"
          description="%launchitem.OpenGLExample.description"
-         category="org.eclipse.swt.examples.launchOpenGLCategory"
+         category="org.eclipse.swt.examples.launchStandaloneCategory"
          id="org.eclipse.swt.opengl.examples.OpenGLExample.standalonelauncher">
       <program
             pluginId="org.eclipse.swt.opengl.examples"
diff --git a/examples/org.eclipse.swt.opengl.examples/src/org/eclipse/swt/opengl/examples/ImageDataUtil.java b/examples/org.eclipse.swt.opengl.examples/src/org/eclipse/swt/opengl/examples/ImageDataUtil.java
new file mode 100755
index 0000000000..9166ae9608
--- /dev/null
+++ b/examples/org.eclipse.swt.opengl.examples/src/org/eclipse/swt/opengl/examples/ImageDataUtil.java
@@ -0,0 +1,559 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 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
+ *******************************************************************************/
+package org.eclipse.swt.opengl.examples;
+
+import org.eclipse.swt.graphics.ImageData;
+import org.eclipse.swt.graphics.PaletteData;
+
+public class ImageDataUtil {
+	/**
+	 * Alpha mode, values 0 - 255 specify global alpha level
+	 */
+	static final int
+		ALPHA_OPAQUE = 255,           // Fully opaque (ignores any alpha data)
+		ALPHA_TRANSPARENT = 0,        // Fully transparent (ignores any alpha data)
+		ALPHA_CHANNEL_SEPARATE = -1,  // Use alpha channel from separate alphaData
+		ALPHA_CHANNEL_SOURCE = -2,    // Use alpha channel embedded in sourceData
+		ALPHA_MASK_UNPACKED = -3,     // Use transparency mask formed by bytes in alphaData (non-zero is opaque)
+		ALPHA_MASK_PACKED = -4,       // Use transparency mask formed by packed bits in alphaData
+		ALPHA_MASK_INDEX = -5,        // Consider source palette indices transparent if in alphaData array
+		ALPHA_MASK_RGB = -6;          // Consider source RGBs transparent if in RGB888 format alphaData array
+		
+	/**
+	 * Data types (internal)
+	 */
+	private static final int
+		// direct / true color formats with arbitrary masks & shifts
+		TYPE_GENERIC_8 = 0,
+		TYPE_GENERIC_16_MSB = 1,
+		TYPE_GENERIC_16_LSB = 2,
+		TYPE_GENERIC_24 = 3,
+		TYPE_GENERIC_32_MSB = 4,
+		TYPE_GENERIC_32_LSB = 5;
+		
+	/**
+	 * Byte and bit order constants.
+	 */
+	static final int LSB_FIRST = 0;
+	static final int MSB_FIRST = 1;
+	
+	/**
+	 * Blit operation bits to be OR'ed together to specify the desired operation.
+	 */
+	static final int
+		BLIT_SRC = 1,     // copy source directly, else applies logic operations
+		BLIT_ALPHA = 2,   // enable alpha blending
+		BLIT_DITHER = 4;  // enable dithering in low color modes
+		
+	/**
+	 * Arbitrary channel width data to 8-bit conversion table.
+	 */
+	static final byte[][] ANY_TO_EIGHT = new byte[9][];
+	static {
+		for (int b = 0; b < 9; ++b) {
+			byte[] data = ANY_TO_EIGHT[b] = new byte[1 << b];
+			if (b == 0) continue;
+			int inc = 0;
+			for (int bit = 0x10000; (bit >>= b) != 0;) inc |= bit;
+			for (int v = 0, p = 0; v < 0x10000; v+= inc) data[p++] = (byte)(v >> 8);
+		}
+	}
+
+	/**
+	 * Blits a direct palette image into a direct palette image.
+	 * <p>
+	 * Note: When the source and destination depth, order and masks
+	 * are pairwise equal and the blitter operation is BLIT_SRC,
+	 * the masks are ignored.  Hence when not changing the image
+	 * data format, 0 may be specified for the masks.
+	 * </p>
+	 * 
+	 * @param op the blitter operation: a combination of BLIT_xxx flags
+	 *        (see BLIT_xxx constants)
+	 * @param srcData the source byte array containing image data
+	 * @param srcDepth the source depth: one of 8, 16, 24, 32
+	 * @param srcStride the source number of bytes per line
+	 * @param srcOrder the source byte ordering: one of MSB_FIRST or LSB_FIRST;
+	 *        ignored if srcDepth is not 16 or 32
+	 * @param srcX the top-left x-coord of the source blit region
+	 * @param srcY the top-left y-coord of the source blit region
+	 * @param srcWidth the width of the source blit region
+	 * @param srcHeight the height of the source blit region
+	 * @param srcRedMask the source red channel mask
+	 * @param srcGreenMask the source green channel mask
+	 * @param srcBlueMask the source blue channel mask
+	 * @param alphaMode the alpha blending or mask mode, may be
+	 *        an integer 0-255 for global alpha; ignored if BLIT_ALPHA
+	 *        not specified in the blitter operations
+	 *        (see ALPHA_MODE_xxx constants)
+	 * @param alphaData the alpha blending or mask data, varies depending
+	 *        on the value of alphaMode and sometimes ignored
+	 * @param alphaStride the alpha data number of bytes per line
+	 * @param alphaX the top-left x-coord of the alpha blit region
+	 * @param alphaY the top-left y-coord of the alpha blit region
+	 * @param destData the destination byte array containing image data
+	 * @param destDepth the destination depth: one of 8, 16, 24, 32
+	 * @param destStride the destination number of bytes per line
+	 * @param destOrder the destination byte ordering: one of MSB_FIRST or LSB_FIRST;
+	 *        ignored if destDepth is not 16 or 32
+	 * @param destX the top-left x-coord of the destination blit region
+	 * @param destY the top-left y-coord of the destination blit region
+	 * @param destWidth the width of the destination blit region
+	 * @param destHeight the height of the destination blit region
+	 * @param destRedMask the destination red channel mask
+	 * @param destGreenMask the destination green channel mask
+	 * @param destBlueMask the destination blue channel mask
+	 * @param flipX if true the resulting image is flipped along the vertical axis
+	 * @param flipY if true the resulting image is flipped along the horizontal axis
+	 */
+	static void blit(int op,
+		byte[] srcData, int srcDepth, int srcStride, int srcOrder,
+		int srcX, int srcY, int srcWidth, int srcHeight,
+		int srcRedMask, int srcGreenMask, int srcBlueMask,
+		int alphaMode, byte[] alphaData, int alphaStride, int alphaX, int alphaY,
+		byte[] destData, int destDepth, int destStride, int destOrder,
+		int destX, int destY, int destWidth, int destHeight,
+		int destRedMask, int destGreenMask, int destBlueMask,
+		boolean flipX, boolean flipY) {
+		if ((destWidth <= 0) || (destHeight <= 0) || (alphaMode == ALPHA_TRANSPARENT)) return;
+
+		// these should be supplied as params later
+		final int srcAlphaMask = 0, destAlphaMask = 0;
+
+		/*** Prepare scaling data ***/
+		final int dwm1 = destWidth - 1;
+		final int sfxi = (dwm1 != 0) ? (int)((((long)srcWidth << 16) - 1) / dwm1) : 0;
+		final int dhm1 = destHeight - 1;
+		final int sfyi = (dhm1 != 0) ? (int)((((long)srcHeight << 16) - 1) / dhm1) : 0;
+
+		/*** Prepare source-related data ***/
+		final int sbpp, stype;
+		switch (srcDepth) {
+			case 8:
+				sbpp = 1;
+				stype = TYPE_GENERIC_8;
+				break;
+			case 16:
+				sbpp = 2;
+				stype = (srcOrder == MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+				break;
+			case 24:
+				sbpp = 3;
+				stype = TYPE_GENERIC_24;
+				break;
+			case 32:
+				sbpp = 4;
+				stype = (srcOrder == MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+				break;
+			default:
+				//throw new IllegalArgumentException("Invalid source type");
+				return;
+		}			
+		int spr = srcY * srcStride + srcX * sbpp;
+
+		/*** Prepare destination-related data ***/
+		final int dbpp, dtype;
+		switch (destDepth) {
+			case 8:
+				dbpp = 1;
+				dtype = TYPE_GENERIC_8;
+				break;
+			case 16:
+				dbpp = 2;
+				dtype = (destOrder == MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+				break;
+			case 24:
+				dbpp = 3;
+				dtype = TYPE_GENERIC_24;
+				break;
+			case 32:
+				dbpp = 4;
+				dtype = (destOrder == MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+				break;
+			default:
+				//throw new IllegalArgumentException("Invalid destination type");
+				return;
+		}			
+		int dpr = ((flipY) ? destY + dhm1 : destY) * destStride + ((flipX) ? destX + dwm1 : destX) * dbpp;
+		final int dprxi = (flipX) ? -dbpp : dbpp;
+		final int dpryi = (flipY) ? -destStride : destStride;
+
+		/*** Prepare special processing data ***/
+		int apr;
+		if ((op & BLIT_ALPHA) != 0) {
+			switch (alphaMode) {
+				case ALPHA_MASK_UNPACKED:
+				case ALPHA_CHANNEL_SEPARATE:
+					if (alphaData == null) alphaMode = 0x10000;
+					apr = alphaY * alphaStride + alphaX;
+					break;
+				case ALPHA_MASK_PACKED:
+					if (alphaData == null) alphaMode = 0x10000;
+					alphaStride <<= 3;
+					apr = alphaY * alphaStride + alphaX;
+					break;
+				case ALPHA_MASK_INDEX:
+					//throw new IllegalArgumentException("Invalid alpha type");
+					return;
+				case ALPHA_MASK_RGB:
+					if (alphaData == null) alphaMode = 0x10000;
+					apr = 0;
+					break;
+				default:
+					alphaMode = (alphaMode << 16) / 255; // prescale
+				case ALPHA_CHANNEL_SOURCE:
+					apr = 0;
+					break;
+			}
+		} else {
+			alphaMode = 0x10000;
+			apr = 0;
+		}
+
+		/*** Blit ***/
+		int dp = dpr;
+		int sp = spr;
+		if ((alphaMode == 0x10000) && (stype == dtype) &&
+			(srcRedMask == destRedMask) && (srcGreenMask == destGreenMask) &&
+			(srcBlueMask == destBlueMask) && (srcAlphaMask == destAlphaMask)) {
+			/*** Fast blit (straight copy) ***/
+			switch (sbpp) {
+				case 1:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							sp += (sfx >>> 16);
+						}
+					}
+					break;					
+				case 2:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							destData[dp + 1] = srcData[sp + 1];
+							sp += (sfx >>> 16) * 2;
+						}
+					}
+					break;
+				case 3:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							destData[dp + 1] = srcData[sp + 1];
+							destData[dp + 2] = srcData[sp + 2];
+							sp += (sfx >>> 16) * 3;
+						}
+					}
+					break;
+				case 4:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							destData[dp + 1] = srcData[sp + 1];
+							destData[dp + 2] = srcData[sp + 2];
+							destData[dp + 3] = srcData[sp + 3];
+							sp += (sfx >>> 16) * 4;
+						}
+					}
+					break;
+			}
+			return;
+		}
+		/*** Comprehensive blit (apply transformations) ***/
+		final int srcRedShift = getChannelShift(srcRedMask);
+		final byte[] srcReds = ANY_TO_EIGHT[getChannelWidth(srcRedMask, srcRedShift)];
+		final int srcGreenShift = getChannelShift(srcGreenMask);
+		final byte[] srcGreens = ANY_TO_EIGHT[getChannelWidth(srcGreenMask, srcGreenShift)];
+		final int srcBlueShift = getChannelShift(srcBlueMask);
+		final byte[] srcBlues = ANY_TO_EIGHT[getChannelWidth(srcBlueMask, srcBlueShift)];
+		final int srcAlphaShift = getChannelShift(srcAlphaMask);
+		final byte[] srcAlphas = ANY_TO_EIGHT[getChannelWidth(srcAlphaMask, srcAlphaShift)];
+
+		final int destRedShift = getChannelShift(destRedMask);
+		final int destRedWidth = getChannelWidth(destRedMask, destRedShift);
+		final byte[] destReds = ANY_TO_EIGHT[destRedWidth];
+		final int destRedPreShift = 8 - destRedWidth;
+		final int destGreenShift = getChannelShift(destGreenMask);
+		final int destGreenWidth = getChannelWidth(destGreenMask, destGreenShift);
+		final byte[] destGreens = ANY_TO_EIGHT[destGreenWidth];
+		final int destGreenPreShift = 8 - destGreenWidth;
+		final int destBlueShift = getChannelShift(destBlueMask);
+		final int destBlueWidth = getChannelWidth(destBlueMask, destBlueShift);
+		final byte[] destBlues = ANY_TO_EIGHT[destBlueWidth];
+		final int destBluePreShift = 8 - destBlueWidth;
+		final int destAlphaShift = getChannelShift(destAlphaMask);
+		final int destAlphaWidth = getChannelWidth(destAlphaMask, destAlphaShift);
+		final byte[] destAlphas = ANY_TO_EIGHT[destAlphaWidth];
+		final int destAlphaPreShift = 8 - destAlphaWidth;
+
+		int ap = apr, alpha = alphaMode;
+		int r = 0, g = 0, b = 0, a = 0;
+		int rq = 0, gq = 0, bq = 0, aq = 0;
+		for (int dy = destHeight, sfy = sfyi; dy > 0; --dy,
+				sp = spr += (sfy >>> 16) * srcStride,
+				ap = apr += (sfy >>> 16) * alphaStride,
+				sfy = (sfy & 0xffff) + sfyi,
+				dp = dpr += dpryi) {
+			for (int dx = destWidth, sfx = sfxi; dx > 0; --dx,
+					dp += dprxi,
+					sfx = (sfx & 0xffff) + sfxi) {
+				/*** READ NEXT PIXEL ***/
+				switch (stype) {
+					case TYPE_GENERIC_8: {
+						final int data = srcData[sp] & 0xff;
+						sp += (sfx >>> 16);
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_16_MSB: {
+						final int data = ((srcData[sp] & 0xff) << 8) | (srcData[sp + 1] & 0xff);
+						sp += (sfx >>> 16) * 2;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_16_LSB: {
+						final int data = ((srcData[sp + 1] & 0xff) << 8) | (srcData[sp] & 0xff);
+						sp += (sfx >>> 16) * 2;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_24: {
+						final int data = (( ((srcData[sp] & 0xff) << 8) |
+							(srcData[sp + 1] & 0xff)) << 8) |
+							(srcData[sp + 2] & 0xff);
+						sp += (sfx >>> 16) * 3;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_32_MSB: {
+						final int data = (( (( ((srcData[sp] & 0xff) << 8) |
+							(srcData[sp + 1] & 0xff)) << 8) |
+							(srcData[sp + 2] & 0xff)) << 8) |
+							(srcData[sp + 3] & 0xff);
+						sp += (sfx >>> 16) * 4;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_32_LSB: {
+						final int data = (( (( ((srcData[sp + 3] & 0xff) << 8) |
+							(srcData[sp + 2] & 0xff)) << 8) |
+							(srcData[sp + 1] & 0xff)) << 8) |
+							(srcData[sp] & 0xff);
+						sp += (sfx >>> 16) * 4;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+				}
+
+				/*** DO SPECIAL PROCESSING IF REQUIRED ***/
+				switch (alphaMode) {
+					case ALPHA_CHANNEL_SEPARATE:
+						alpha = ((alphaData[ap] & 0xff) << 16) / 255;
+						ap += (sfx >> 16);
+						break;
+					case ALPHA_CHANNEL_SOURCE:
+						alpha = (a << 16) / 255;
+						break;
+					case ALPHA_MASK_UNPACKED:
+						alpha = (alphaData[ap] != 0) ? 0x10000 : 0;
+						ap += (sfx >> 16);
+						break;						
+					case ALPHA_MASK_PACKED:
+						alpha = (alphaData[ap >> 3] << ((ap & 7) + 9)) & 0x10000;
+						ap += (sfx >> 16);
+						break;
+					case ALPHA_MASK_RGB:
+						alpha = 0x10000;
+						for (int i = 0; i < alphaData.length; i += 3) {
+							if ((r == alphaData[i]) && (g == alphaData[i + 1]) && (b == alphaData[i + 2])) {
+								alpha = 0x0000;
+								break;
+							}
+						}
+						break;
+				}
+				if (alpha != 0x10000) {
+					if (alpha == 0x0000) continue;
+					switch (dtype) {
+						case TYPE_GENERIC_8: {
+							final int data = destData[dp] & 0xff;
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_16_MSB: {
+							final int data = ((destData[dp] & 0xff) << 8) | (destData[dp + 1] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_16_LSB: {
+							final int data = ((destData[dp + 1] & 0xff) << 8) | (destData[dp] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_24: {
+							final int data = (( ((destData[dp] & 0xff) << 8) |
+								(destData[dp + 1] & 0xff)) << 8) |
+								(destData[dp + 2] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_32_MSB: {
+							final int data = (( (( ((destData[dp] & 0xff) << 8) |
+								(destData[dp + 1] & 0xff)) << 8) |
+								(destData[dp + 2] & 0xff)) << 8) |
+								(destData[dp + 3] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_32_LSB: {
+							final int data = (( (( ((destData[dp + 3] & 0xff) << 8) |
+								(destData[dp + 2] & 0xff)) << 8) |
+								(destData[dp + 1] & 0xff)) << 8) |
+								(destData[dp] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+					}
+					// Perform alpha blending
+					a = aq + ((a - aq) * alpha >> 16);
+					r = rq + ((r - rq) * alpha >> 16);
+					g = gq + ((g - gq) * alpha >> 16);
+					b = bq + ((b - bq) * alpha >> 16);
+				}
+
+				/*** WRITE NEXT PIXEL ***/
+				final int data = 
+					(r >>> destRedPreShift << destRedShift) |
+					(g >>> destGreenPreShift << destGreenShift) |
+					(b >>> destBluePreShift << destBlueShift) |
+					(a >>> destAlphaPreShift << destAlphaShift);
+				switch (dtype) {
+					case TYPE_GENERIC_8: {
+						destData[dp] = (byte) data;
+					} break;
+					case TYPE_GENERIC_16_MSB: {
+						destData[dp] = (byte) (data >>> 8);
+						destData[dp + 1] = (byte) (data & 0xff);
+					} break;
+					case TYPE_GENERIC_16_LSB: {
+						destData[dp] = (byte) (data & 0xff);
+						destData[dp + 1] = (byte) (data >>> 8);
+					} break;
+					case TYPE_GENERIC_24: {
+						destData[dp] = (byte) (data >>> 16);
+						destData[dp + 1] = (byte) (data >>> 8);
+						destData[dp + 2] = (byte) (data & 0xff);
+					} break;
+					case TYPE_GENERIC_32_MSB: {
+						destData[dp] = (byte) (data >>> 24);
+						destData[dp + 1] = (byte) (data >>> 16);
+						destData[dp + 2] = (byte) (data >>> 8);
+						destData[dp + 3] = (byte) (data & 0xff);
+					} break;
+					case TYPE_GENERIC_32_LSB: {
+						destData[dp] = (byte) (data & 0xff);
+						destData[dp + 1] = (byte) (data >>> 8);
+						destData[dp + 2] = (byte) (data >>> 16);
+						destData[dp + 3] = (byte) (data >>> 24);
+					} break;
+				}
+			}
+		}			
+	}
+
+	/**
+	 * Computes the required channel shift from a mask.
+	 */
+	static int getChannelShift(int mask) {
+		if (mask == 0) return 0;
+		int i;
+		for (i = 0; ((mask & 1) == 0) && (i < 32); ++i) {
+			mask >>>= 1;
+		}
+		return i;
+	}
+	
+	/**
+	 * Computes the required channel width (depth) from a mask.
+	 */
+	static int getChannelWidth(int mask, int shift) {
+		if (mask == 0) return 0;
+		int i;
+		mask >>>= shift;
+		for (i = shift; ((mask & 1) != 0) && (i < 32); ++i) {
+			mask >>>= 1;
+		}
+		return i - shift;
+	}
+
+	public static ImageData convertImageData (ImageData source) {
+		PaletteData palette = new PaletteData (0xff0000, 0xff00, 0xff);
+		ImageData newSource = new ImageData (source.width, source.height, 24, palette);
+
+		ImageDataUtil.blit (
+			1,
+			source.data,
+			source.depth,
+			source.bytesPerLine,
+			(source.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			source.width,
+			source.height,
+			source.palette.redMask,
+			source.palette.greenMask,
+			source.palette.blueMask,
+			255,
+			null,
+			0,
+			0,
+			0,
+			newSource.data,
+			newSource.depth,
+			newSource.bytesPerLine,
+			(newSource.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			newSource.width,
+			newSource.height,
+			newSource.palette.redMask,
+			newSource.palette.greenMask,
+			newSource.palette.blueMask,
+			false,
+			true);
+
+		return newSource;
+	}
+}
diff --git a/examples/org.eclipse.swt.opengl.examples/src/org/eclipse/swt/opengl/examples/OpenGLExample.java b/examples/org.eclipse.swt.opengl.examples/src/org/eclipse/swt/opengl/examples/OpenGLExample.java
index 09c8e0a1f2..eb2609dc34 100644
--- a/examples/org.eclipse.swt.opengl.examples/src/org/eclipse/swt/opengl/examples/OpenGLExample.java
+++ b/examples/org.eclipse.swt.opengl.examples/src/org/eclipse/swt/opengl/examples/OpenGLExample.java
@@ -12,6 +12,7 @@ package org.eclipse.swt.opengl.examples;
 
 
 import org.eclipse.swt.*;
+import org.eclipse.swt.graphics.*;
 import org.eclipse.swt.layout.*;
 import org.eclipse.swt.widgets.*;
 
@@ -24,13 +25,15 @@ public class OpenGLExample {
 	private OpenGLTab[] tabs;
 	private int sleep;
 	
+	public OpenGLExample() {}
+
 	/**
 	 * Creates an instance of an OpenGLExample embedded inside
 	 * the supplied parent Composite.
 	 * 
 	 * @param parent the container of the example
 	 */
-	OpenGLExample(Composite parent) {		
+	public OpenGLExample(Composite parent) {
 		tabFolder = new TabFolder(parent, SWT.NONE);
 		tabs =
 			new OpenGLTab[] {
@@ -118,7 +121,10 @@ public class OpenGLExample {
 	 * Invokes as a standalone program.
 	 */
 	public static void main(String[] args) {
-		Display display = new Display();
+		DeviceData data = new DeviceData();
+		data.debug = true;
+		System.out.println("huh");
+		Display display = new Display(data);
 		Shell shell = new Shell(display);
 		shell.setLayout(new FillLayout());
 		OpenGLExample instance = new OpenGLExample(shell);
@@ -129,4 +135,13 @@ public class OpenGLExample {
 		}
 		instance.dispose();
 	}
+
+	public Shell open (Display display) {
+		Shell shell = new Shell (display);
+		shell.setLayout(new FillLayout());
+		new OpenGLExample(shell);
+		shell.setText(getResourceString("window.title"));
+		shell.open();
+		return shell;
+	}
 }