projects/dwt-win: dwt/graphics/Image.d comparison

comparison dwt/graphics/Image.d @ 213:36f5cb12e1a2

Update to SWT 3.4M7

author	Frank Benoit <benoit@tionex.de>
date	Sat, 17 May 2008 17:34:28 +0200
parents	ab60f3309436
children	e2affbeb686d

comparison

equal deleted inserted replaced

-:ab60f3309436
+:36f5cb12e1a2
 * @see ImageLoader
 */
 public final class Image : Resource, Drawable {
+alias Resource.init_ init_;
 /**
 * specifies whether the receiver is a bitmap or an icon
 * (one of <code>DWT.BITMAP</code>, <code>DWT.ICON</code>)
 * <p>
 * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT
 static const int DEFAULT_SCANLINE_PAD = 4;
 /**
 * Prevents uninitialized instances from being created outside the package.
 */
-this () {
+this (Device device) {
+super(device);
 }
 /**
 * Constructs an empty instance of this class with the
 * specified width and height. The result may be drawn upon
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
 public this(Device device, int width, int height) {
-if (device is null) device = Device.getDevice();
+super(device);
-if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+init_(width, height);
-init_(device, width, height);
+init_();
-if (device.tracking) device.new_Object(this);
 }
 /**
 * Constructs a new instance of this class based on the
 * provided image, with an appearance that varies depending
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
 public this(Device device, Image srcImage, int flag) {
-if (device is null) device = Device.getDevice();
+super(device);
-if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+device = this.device;
-this.device = device;
 if (srcImage is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 if (srcImage.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
 Rectangle rect = srcImage.getBounds();
+this.type = srcImage.type;
 switch (flag) {
 case DWT.IMAGE_COPY: {
-this.type = srcImage.type;
 switch (type) {
 case DWT.BITMAP:
 /* Get the HDC for the device */
 auto hDC = device.internal_new_GC(null);
 System.arraycopy(srcImage.alphaData, 0, alphaData, 0, alphaData.length);
 }
 break;
 case DWT.ICON:
 static if (OS.IsWinCE) {
-init_(device, srcImage.data);
+init_(srcImage.data);
 } else {
 handle = OS.CopyImage(srcImage.handle, OS.IMAGE_ICON, rect.width, rect.height, 0);
 if (handle is null) DWT.error(DWT.ERROR_NO_HANDLES);
 }
 break;
 default:
 DWT.error(DWT.ERROR_INVALID_IMAGE);
 }
-if (device.tracking) device.new_Object(this);
+break;
-return;
 }
 case DWT.IMAGE_DISABLE: {
 ImageData data = srcImage.getImageData();
 PaletteData palette = data.palette;
 RGB[] rgbs = new RGB[3];
 }
 }
 offset++;
 }
 }
-init_ (device, newData);
+init_ (newData);
-if (device.tracking) device.new_Object(this);
+break;
-return;
 }
 case DWT.IMAGE_GRAY: {
 ImageData data = srcImage.getImageData();
 PaletteData palette = data.palette;
 ImageData newData = data;
 }
 offset++;
 }
 }
 }
-init_ (device, newData);
+init_ (newData);
-if (device.tracking) device.new_Object(this);
+break;
-return;
 }
 default:
 DWT.error(DWT.ERROR_INVALID_ARGUMENT);
 }
+init_();
 }
 /**
 * Constructs an empty instance of this class with the
 * width and height of the specified rectangle. The result
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
 public this(Device device, Rectangle bounds) {
-if (device is null) device = Device.getDevice();
+super(device);
-if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 if (bounds is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
-init_(device, bounds.width, bounds.height);
+init_(bounds.width, bounds.height);
-if (device.tracking) device.new_Object(this);
+init_();
 }
 /**
 * Constructs an instance of this class from the given
 * <code>ImageData</code>.
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
 public this(Device device, ImageData data) {
-if (device is null) device = Device.getDevice();
+super(device);
-if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+init_(data);
-init_(device, data);
+init_();
-if (device.tracking) device.new_Object(this);
 }
 /**
 * Constructs an instance of this class, whose type is
 * <code>DWT.ICON</code>, from the two given <code>ImageData</code>
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
 public this(Device device, ImageData source, ImageData mask) {
-if (device is null) device = Device.getDevice();
+super(device);
-if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 if (source is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 if (mask is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 if (source.width !is mask.width || source.height !is mask.height) {
 DWT.error(DWT.ERROR_INVALID_ARGUMENT);
 }
 mask = ImageData.convertMask(mask);
-init_(device, this, source, mask);
+init_(this.device, this, source, mask);
-if (device.tracking) device.new_Object(this);
+init_();
 }
 /**
 * Constructs an instance of this class by loading its representation
 * from the specified input stream. Throws an error if an error
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
 public this (Device device, InputStream stream) {
-if (device is null) device = Device.getDevice();
+super(device);
-if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+init_(new ImageData(stream));
-init_(device, new ImageData(stream));
+init_();
-if (device.tracking) device.new_Object(this);
 }
 /**
 * Constructs an instance of this class by loading its representation
 * from the file with the specified name. Throws an error if an error
 * @exception DWTError <ul>
 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for image creation</li>
 * </ul>
 */
 public this (Device device, String filename) {
-if (device is null) device = Device.getDevice();
+super(device);
-if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+device = this.device;
 if (filename is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
-this.device = device;
+bool gdip = true;
 try {
 device.checkGDIP();
+} catch (DWTException e) {
+gdip = false;
+}
+/*
+* Bug in GDI+.  For some reason, Bitmap.LockBits() segment faults
+* when loading GIF files in 64-bit Windows.  The fix is to not use
+* GDI+ image loading in this case.
+*/
+if (gdip && (void*).sizeof is 8 && filename.toLowerCase().endsWith(".gif")) gdip = false;
+if (gdip) {
 int length = filename.length;
 char[] chars = new char[length+1];
 filename.getChars(0, length, chars, 0);
 auto bitmap = Gdip.Bitmap_new( .StrToWCHARz( filename ), false);
 if (bitmap !is null) {
 Gdip.Bitmap_UnlockBits(bitmap, lockedBitmapData);
 Gdip.BitmapData_delete(lockedBitmapData);
 ImageData img = new ImageData(width, height, depth, paletteData, scanlinePad, data);
 img.transparentPixel = transparentPixel;
 img.alphaData = alphaData;
-init_(device, img);
+init_(img);
 }
 }
 }
 }
 }
 if (status is 0) {
 if (this.handle is null) DWT.error(error);
 return;
 }
 }
-} catch (DWTException e) {}
+}
-init_(device, new ImageData(filename));
+init_(new ImageData(filename));
-if(device.tracking) device.new_Object(this);
+init_();
 }
 /**
 * Create a DIB from a DDB without using GetDIBits. Note that
 * the DDB should not be selected into a HDC.
 bmi[offset + 2] = cast(byte)rgbs[j].red;
 bmi[offset + 3] = 0;
 offset += 4;
 }
 }
-int pBits;
+void* pBits;
 HBITMAP hDib = OS.CreateDIBSection(null, cast(BITMAPINFO*)bmi.ptr, OS.DIB_RGB_COLORS, &pBits, null, 0);
 if (hDib is null) DWT.error(DWT.ERROR_NO_HANDLES);
 /* Bitblt DDB into DIB */
 auto hdcSource = OS.CreateCompatibleDC(hDC);
 // returning them in an int[].  Since the D GC does not and cannot scan int's for
 // pointers, there is potential that the pointer's object could be collected while still
 // active, even though it might be unlikely given the short span of time that the
 // function has them stored in the int array.
-int[] createGdipImage() {
+int /*long*/ [] createGdipImage() {
 switch (type) {
 case DWT.BITMAP: {
 if (alpha !is -1 || alphaData !is null || transparentPixel !is -1) {
 BITMAP bm;
 OS.GetObject(handle, BITMAP.sizeof, &bm);
 OS.GetObject(hBitmap, BITMAP.sizeof, &bm);
 int imgWidth = bm.bmWidth;
 int imgHeight = hBitmap is iconInfo.hbmMask ? bm.bmHeight / 2 : bm.bmHeight;
 Gdip.Bitmap img;
 ubyte* pixels;
-if (imgWidth > imgHeight) {
+/*
+* Bug in GDI+.  Bitmap_new() segments fault if the image width
+* is greater than the image height.
+*
+* Note that it also fails to generated an appropriate alpha
+* channel when the icon depth is 32.
+*/
+if (imgWidth > imgHeight || bm.bmBitsPixel is 32) {
 auto hDC = device.internal_new_GC(null);
 auto srcHdc = OS.CreateCompatibleDC(hDC);
 auto oldSrcBitmap = OS.SelectObject(srcHdc, hBitmap);
 auto memHdc = OS.CreateCompatibleDC(hDC);
 auto memDib = createDIB(imgWidth, imgHeight, 32);
 OS.DeleteObject(memHdc);
 ubyte[] srcData = new ubyte[dibBM.bmWidthBytes * dibBM.bmHeight];
 OS.MoveMemory(srcData.ptr, dibBM.bmBits, srcData.length);
 OS.DeleteObject(memDib);
 OS.SelectObject(srcHdc, iconInfo.hbmMask);
-for (int y = 0, dp = 0; y < imgHeight; ++y) {
+for (int y = 0, dp = 3; y < imgHeight; ++y) {
 for (int x = 0; x < imgWidth; ++x) {
-if (OS.GetPixel(srcHdc, x, y) !is 0) {
+if (srcData[dp] is 0) {
-srcData[dp + 3] = cast(ubyte)0;
+if (OS.GetPixel(srcHdc, x, y) !is 0) {
-} else {
+srcData[dp] = cast(ubyte)0;
-srcData[dp + 3] = cast(ubyte)0xFF;
+} else {
+srcData[dp] = cast(ubyte)0xFF;
+}
 }
 dp += 4;
 }
 }
 OS.SelectObject(srcHdc, oldSrcBitmap);
 default: DWT.error(DWT.ERROR_INVALID_IMAGE);
 }
 return null;
 }
-/**
+void destroy () {
-* Disposes of the operating system resources associated with
-* the image. Applications must dispose of all images which
-* they allocate.
-*/
-override public void dispose () {
-if (handle is null) return;
-if (device.isDisposed()) return;
 if (memGC !is null) memGC.dispose();
 if (type is DWT.ICON) {
 static if (OS.IsWinCE) data = null;
 OS.DestroyIcon (handle);
 } else {
 OS.DeleteObject (handle);
 }
 handle = null;
 memGC = null;
-if (device.tracking) device.dispose_Object(this);
-device = null;
 }
 /**
 * Compares the argument to the receiver, and returns true
 * if they represent the <em>same</em> object using a class
 */
 override public hash_t toHash () {
 return cast(hash_t)handle;
 }
-void init_(Device device, int width, int height) {
+void init_(int width, int height) {
 if (width <= 0 || height <= 0) {
 DWT.error (DWT.ERROR_INVALID_ARGUMENT);
 }
-this.device = device;
 type = DWT.BITMAP;
 auto hDC = device.internal_new_GC(null);
 handle = OS.CreateCompatibleBitmap(hDC, width, height);
 /*
 * Feature in Windows.  CreateCompatibleBitmap() may fail
 bmi[offset + 9] = cast(byte)((blueMask & 0xFF0000) >> 16);
 bmi[offset + 10] = cast(byte)((blueMask & 0xFF00) >> 8);
 bmi[offset + 11] = cast(byte)((blueMask & 0xFF) >> 0);
 }
-int[1] pBits;
+void* pBits;
-return OS.CreateDIBSection(null, cast(BITMAPINFO*)bmi.ptr, OS.DIB_RGB_COLORS, pBits.ptr, null, 0);
+return OS.CreateDIBSection(null, cast(BITMAPINFO*)bmi.ptr, OS.DIB_RGB_COLORS, &pBits, null, 0);
 }
 /**
 * Feature in WinCE.  GetIconInfo is not available in WinCE.
 * The workaround is to cache the object ImageData for images
 info.hbmColor = cast(HBITMAP)result[0];
 info.hbmMask = cast(HBITMAP)result[1];
 }
 static int[] init_(Device device, Image image, ImageData i) {
-if (image !is null) image.device = device;
 /*
 * BUG in Windows 98:
 * A monochrome DIBSection will display as solid black
 * on Windows 98 machines, even though it contains the
 if (i.scanlinePad !is 4 && (i.bytesPerLine % 4 !is 0)) {
 data = ImageData.convertPad(data, i.width, i.height, i.depth, i.scanlinePad, 4);
 }
 OS.MoveMemory(pBits, data.ptr, data.length);
-int[] result = null;
+int /*long*/ [] result = null;
 if (i.getTransparencyType() is DWT.TRANSPARENCY_MASK) {
 /* Get the HDC for the device */
 auto hDC = device.internal_new_GC(null);
 /* Create the color bitmap */
 }
 imageData.maskPad = mask.scanlinePad;
 imageData.maskData = mask.data;
 return init_(device, image, imageData);
 }
-void init_(Device device, ImageData i) {
+void init_(ImageData i) {
 if (i is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 init_(device, this, i);
 }
 /**
 } else {
 data.style |= DWT.LEFT_TO_RIGHT;
 }
 data.device = device;
 data.image = this;
-data.hFont = device.systemFont;
+data.font = device.systemFont;
 }
 return imageDC;
 }
 /**
 * @param type the type of the image (<code>DWT.BITMAP</code> or <code>DWT.ICON</code>)
 * @param handle the OS handle for the image
 * @return a new image object containing the specified device, type and handle
 */
 public static Image win32_new(Device device, int type, HGDIOBJ handle) {
-if (device is null) device = Device.getDevice();
+Image image = new Image(device);
-Image image = new Image();
 image.type = type;
 image.handle = handle;
-image.device = device;
 return image;
 }
 }

Mercurial > projects > dwt-win

comparison dwt/graphics/Image.d @ 213:36f5cb12e1a2