Mercurial > projects > dwt-win
view dwt/graphics/Device.d @ 19:ded98545bb1f
Device
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Sat, 26 Jan 2008 14:06:27 +0100 |
parents | 437c59646731 |
children | f5482da87ed8 |
line wrap: on
line source
/******************************************************************************* * Copyright (c) 2000, 2007 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 dwt.graphics.Device; /++ //PORTING_TYPE import dwt.internal.win32.OS; class Device{ static Device getDevice(); void new_Object (Object object); bool tracking; public bool isDisposed () ; void dispose_Object (Object object) ; float computePoints(LOGFONT* logFont, HFONT hFont); int computePixels(float height) ; public HPALETTE hPalette; int [] colorRefCount; } ++/ import dwt.DWT; import dwt.DWTException; import dwt.internal.gdip.Gdip; import dwt.internal.win32.OS; import dwt.graphics.Drawable; import dwt.graphics.DeviceData; import dwt.graphics.Rectangle; import dwt.graphics.FontData; import dwt.graphics.Font; import dwt.graphics.GCData; import dwt.graphics.Color; import dwt.dwthelper.Runnable; import dwt.dwthelper.System; import dwt.dwthelper.utils; import tango.core.Exception; /** * This class is the abstract superclass of all device objects, * such as the Display device and the Printer device. Devices * can have a graphics context (GC) created for them, and they * can be drawn on by sending messages to the associated GC. */ public abstract class Device : Drawable { private struct CallbackData { Device device; bool scalable; } /* Debugging */ public static bool DEBUG; bool debug_; bool tracking; TracedException [] errors; Object [] objects; /** * Palette * (Warning: This field is platform dependent) * <p> * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT * public API. It is marked public only so that it can be shared * within the packages provided by DWT. It is not available on all * platforms and should never be accessed from application code. * </p> */ public HPALETTE hPalette; int [] colorRefCount; /* System Font */ HFONT systemFont; /* Font Enumeration */ int nFonts = 256; LOGFONT* [] logFonts; TEXTMETRIC metrics; int[] pixels; /* Scripts */ SCRIPT_PROPERTIES*[] scripts; /* Advanced Graphics */ uint* gdipToken; bool disposed; /* * TEMPORARY CODE. When a graphics object is * created and the device parameter is null, * the current Display is used. This presents * a problem because DWT graphics does not * reference classes in DWT widgets. The correct * fix is to remove this feature. Unfortunately, * too many application programs rely on this * feature. * * This code will be removed in the future. */ protected static Device CurrentDevice; protected static Runnable DeviceFinder; /* * TEMPORARY CODE. */ static synchronized Device getDevice () { if (DeviceFinder !is null) DeviceFinder.run(); Device device = CurrentDevice; CurrentDevice = null; return device; } /** * Constructs a new instance of this class. * <p> * You must dispose the device when it is no longer required. * </p> * * @see #create * @see #init * * @since 3.1 */ public this() { this(null); } /** * Constructs a new instance of this class. * <p> * You must dispose the device when it is no longer required. * </p> * * @param data the DeviceData which describes the receiver * * @see #create * @see #init * @see DeviceData */ public this(DeviceData data) { synchronized (this.classinfo) { debug_ = DEBUG; tracking = DEBUG; if (data !is null) { debug_ = data.debug_; tracking = data.tracking; } create (data); init (); if (tracking) { errors = new TracedException [128]; objects = new Object [128]; } /* Initialize the system font slot */ systemFont = getSystemFont().handle; } } /** * Throws an <code>DWTException</code> if the receiver can not * be accessed by the caller. This may include both checks on * the state of the receiver and more generally on the entire * execution context. This method <em>should</em> be called by * device implementors to enforce the standard DWT invariants. * <p> * Currently, it is an error to invoke any method (other than * <code>isDisposed()</code> and <code>dispose()</code>) on a * device that has had its <code>dispose()</code> method called. * </p><p> * In future releases of DWT, there may be more or fewer error * checks and exceptions may be thrown for different reasons. * <p> * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * </ul> */ protected void checkDevice () { if (disposed) DWT.error(DWT.ERROR_DEVICE_DISPOSED); } void checkGDIP() { if (gdipToken !is null) return; if (OS.IsWinCE) DWT.error(DWT.ERROR_NOT_IMPLEMENTED); int oldErrorMode = OS.SetErrorMode (OS.SEM_FAILCRITICALERRORS); try { uint* token; GdiplusStartupInput input; input.GdiplusVersion = 1; if (Gdip.GdiplusStartup (&token, &input, null) is 0) { gdipToken = token; } } catch (TracedException t) { DWT.error (DWT.ERROR_NO_GRAPHICS_LIBRARY, t, " [GDI+ is required]"); //$NON-NLS-1$ } finally { OS.SetErrorMode (oldErrorMode); } } /** * Creates the device in the operating system. If the device * does not have a handle, this method may do nothing depending * on the device. * <p> * This method is called before <code>init</code>. * </p><p> * Subclasses are supposed to reimplement this method and not * call the <code>super</code> implementation. * </p> * * @param data the DeviceData which describes the receiver * * @see #init */ protected void create (DeviceData data) { } int computePixels(float height) { auto hDC = internal_new_GC (null); int pixels = -cast(int)(0.5f + (height * OS.GetDeviceCaps(hDC, OS.LOGPIXELSY) / 72f)); internal_dispose_GC (hDC, null); return pixels; } float computePoints(LOGFONT* logFont, HFONT hFont) { auto hDC = internal_new_GC (null); int logPixelsY = OS.GetDeviceCaps(hDC, OS.LOGPIXELSY); int pixels = 0; if (logFont.lfHeight > 0) { /* * Feature in Windows. If the lfHeight of the LOGFONT structure * is positive, the lfHeight measures the height of the entire * cell, including internal leading, in logical units. Since the * height of a font in points does not include the internal leading, * we must subtract the internal leading, which requires a TEXTMETRIC. */ auto oldFont = OS.SelectObject(hDC, hFont); TEXTMETRIC* lptm = new TEXTMETRIC(); OS.GetTextMetrics(hDC, lptm); OS.SelectObject(hDC, oldFont); pixels = logFont.lfHeight - lptm.tmInternalLeading; } else { pixels = -logFont.lfHeight; } internal_dispose_GC (hDC, null); return pixels * 72f / logPixelsY; } /** * Destroys the device in the operating system and releases * the device's handle. If the device does not have a handle, * this method may do nothing depending on the device. * <p> * This method is called after <code>release</code>. * </p><p> * Subclasses are supposed to reimplement this method and not * call the <code>super</code> implementation. * </p> * * @see #dispose * @see #release */ protected void destroy () { } /** * Disposes of the operating system resources associated with * the receiver. After this method has been invoked, the receiver * will answer <code>true</code> when sent the message * <code>isDisposed()</code>. * * @see #release * @see #destroy * @see #checkDevice */ public void dispose () { if (isDisposed()) return; checkDevice (); release (); destroy (); disposed = true; if (tracking) { objects = null; errors = null; } } void dispose_Object (Object object) { for (int i=0; i<objects.length; i++) { if (objects [i] is object) { objects [i] = null; errors [i] = null; return; } } } static extern(Windows) int EnumFontFamFunc (ENUMLOGFONT* lpelfe, NEWTEXTMETRIC* lpntme, int FontType, int lParam) { auto cbdata = cast(CallbackData*)lParam; return cbdata.device.EnumFontFamProc( lpelfe, lpntme, FontType, cbdata.scalable ); } int EnumFontFamProc (ENUMLOGFONT* lpelfe, NEWTEXTMETRIC* lpntme, DWORD FontType, bool scalable) { bool isScalable = (FontType & OS.RASTER_FONTTYPE) is 0; if (isScalable is scalable) { /* Add the log font to the list of log fonts */ if (nFonts is logFonts.length) { LOGFONT* [] newLogFonts = new LOGFONT* [logFonts.length + 128]; SimpleType!(LOGFONT*).arraycopy (logFonts, 0, newLogFonts, 0, nFonts); logFonts = newLogFonts; int[] newPixels = new int[newLogFonts.length]; System.arraycopy (pixels, 0, newPixels, 0, nFonts); pixels = newPixels; } LOGFONT* logFont = logFonts [nFonts]; if (logFont is null) logFont = new LOGFONT (); *logFont = *cast(LOGFONT*)lpelfe; logFonts [nFonts] = logFont; if (logFont.lfHeight > 0) { /* * Feature in Windows. If the lfHeight of the LOGFONT structure * is positive, the lfHeight measures the height of the entire * cell, including internal leading, in logical units. Since the * height of a font in points does not include the internal leading, * we must subtract the internal leading, which requires a TEXTMETRIC, * which in turn requires font creation. */ metrics = *cast(TEXTMETRIC*)lpntme; pixels[nFonts] = logFont.lfHeight - metrics.tmInternalLeading; } else { pixels[nFonts] = -logFont.lfHeight; } nFonts++; } return 1; } /** * Returns a rectangle describing the receiver's size and location. * * @return the bounding rectangle * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> */ public Rectangle getBounds () { checkDevice (); auto hDC = internal_new_GC (null); int width = OS.GetDeviceCaps (hDC, OS.HORZRES); int height = OS.GetDeviceCaps (hDC, OS.VERTRES); internal_dispose_GC (hDC, null); return new Rectangle (0, 0, width, height); } /** * Returns a <code>DeviceData</code> based on the receiver. * Modifications made to this <code>DeviceData</code> will not * affect the receiver. * * @return a <code>DeviceData</code> containing the device's data and attributes * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> * * @see DeviceData */ public DeviceData getDeviceData () { checkDevice(); DeviceData data = new DeviceData (); data.debug_ = debug_; data.tracking = tracking; int count = 0, length = 0; if (tracking) length = objects.length; for (int i=0; i<length; i++) { if (objects [i] !is null) count++; } int index = 0; data.objects = new Object [count]; data.errors = new TracedException [count]; for (int i=0; i<length; i++) { if (objects [i] !is null) { data.objects [index] = objects [i]; data.errors [index] = errors [i]; index++; } } return data; } /** * Returns a rectangle which describes the area of the * receiver which is capable of displaying data. * * @return the client area * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> * * @see #getBounds */ public Rectangle getClientArea () { return getBounds (); } /** * Returns the bit depth of the screen, which is the number of * bits it takes to represent the number of unique colors that * the screen is currently capable of displaying. This number * will typically be one of 1, 8, 15, 16, 24 or 32. * * @return the depth of the screen * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> */ public int getDepth () { checkDevice (); auto hDC = internal_new_GC (null); int bits = OS.GetDeviceCaps (hDC, OS.BITSPIXEL); int planes = OS.GetDeviceCaps (hDC, OS.PLANES); internal_dispose_GC (hDC, null); return bits * planes; } /** * Returns a point whose x coordinate is the horizontal * dots per inch of the display, and whose y coordinate * is the vertical dots per inch of the display. * * @return the horizontal and vertical DPI * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> */ public Point getDPI () { checkDevice (); auto hDC = internal_new_GC (null); int dpiX = OS.GetDeviceCaps (hDC, OS.LOGPIXELSX); int dpiY = OS.GetDeviceCaps (hDC, OS.LOGPIXELSY); internal_dispose_GC (hDC, null); return new Point (dpiX, dpiY); } /** * Returns <code>FontData</code> objects which describe * the fonts that match the given arguments. If the * <code>faceName</code> is null, all fonts will be returned. * * @param faceName the name of the font to look for, or null * @param scalable if true only scalable fonts are returned, otherwise only non-scalable fonts are returned. * @return the matching font data * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> */ public FontData [] getFontList (char[] faceName, bool scalable) { checkDevice (); /* Create the callback */ CallbackData cbdata; cbdata.device = this; /* Initialize the instance variables */ metrics = TEXTMETRIC.init; pixels = new int[nFonts]; logFonts = new LOGFONT* [nFonts]; for (int i=0; i<logFonts.length; i++) { logFonts [i] = new LOGFONT(); } nFonts = 0; /* Enumerate */ int offset = 0; auto hDC = internal_new_GC (null); if (faceName is null) { /* The user did not specify a face name, so they want all versions of all available face names */ cbdata.scalable = scalable; OS.EnumFontFamilies (hDC, null, &EnumFontFamFunc, cast(int)&cbdata ); /** * For bitmapped fonts, EnumFontFamilies only enumerates once for each font, regardless * of how many styles are available. If the user wants bitmapped fonts, enumerate on * each face name now. */ offset = nFonts; for (int i=0; i<offset; i++) { LOGFONT* lf = logFonts [i]; /** * Bug in Windows 98. When EnumFontFamiliesEx is called with a specified face name, it * should enumerate for each available style of that font. Instead, it only enumerates * once. The fix is to call EnumFontFamilies, which works as expected. */ cbdata.scalable = scalable; if (OS.IsUnicode) { OS.EnumFontFamiliesW (hDC, (cast(LOGFONTW*)lf).lfFaceName.ptr, &EnumFontFamFunc, cast(int)&cbdata); } else { OS.EnumFontFamiliesA (hDC, (cast(LOGFONTA*)lf).lfFaceName.ptr, &EnumFontFamFunc, cast(int)&cbdata); } } } else { /* Use the character encoding for the default locale */ /** * Bug in Windows 98. When EnumFontFamiliesEx is called with a specified face name, it * should enumerate for each available style of that font. Instead, it only enumerates * once. The fix is to call EnumFontFamilies, which works as expected. */ cbdata.scalable = scalable; OS.EnumFontFamilies (hDC, .StrToTCHARz(faceName), &EnumFontFamFunc, cast(int)&cbdata); } int logPixelsY = OS.GetDeviceCaps(hDC, OS.LOGPIXELSY); internal_dispose_GC (hDC, null); /* Create the fontData from the logfonts */ int count = 0; FontData [] result = new FontData [nFonts - offset]; for (int i=offset; i<nFonts; i++) { FontData fd = FontData.win32_new (logFonts [i], pixels [i] * 72f / logPixelsY); int j; for (j = 0; j < count; j++) { if (fd == result [j]) break; } if (j is count) result [count++] = fd; } if (count !is result.length) { FontData [] newResult = new FontData [count]; System.arraycopy (result, 0, newResult, 0, count); result = newResult; } /* Clean up */ logFonts = null; pixels = null; metrics = TEXTMETRIC.init; return result; } char[] getLastError () { int error = OS.GetLastError(); if (error is 0) return ""; //$NON-NLS-1$ return " [GetLastError=0x" ~ .toHex(error) ~ "]"; //$NON-NLS-1$ //$NON-NLS-2$ } char[] getLastErrorText () { int error = OS.GetLastError(); if (error is 0) return ""; //$NON-NLS-1$ TCHAR* buffer = null; int dwFlags = OS.FORMAT_MESSAGE_ALLOCATE_BUFFER | OS.FORMAT_MESSAGE_FROM_SYSTEM | OS.FORMAT_MESSAGE_IGNORE_INSERTS; int length = OS.FormatMessage(dwFlags, null, error, OS.LANG_USER_DEFAULT, cast(TCHAR*)&buffer, 0, null); char[] errorNum = ("[GetLastError=") ~ .toHex(error) ~ "] "; if (length == 0) return errorNum; char[] buffer1 = .TCHARzToStr(buffer, length); if ( *buffer != 0) OS.LocalFree(cast(HLOCAL)buffer); return errorNum ~ buffer1; } /** * Returns the matching standard color for the given * constant, which should be one of the color constants * specified in class <code>DWT</code>. Any value other * than one of the DWT color constants which is passed * in will result in the color black. This color should * not be freed because it was allocated by the system, * not the application. * * @param id the color constant * @return the matching color * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> * * @see DWT */ public Color getSystemColor (int id) { checkDevice (); int pixel = 0x00000000; switch (id) { case DWT.COLOR_WHITE: pixel = 0x00FFFFFF; break; case DWT.COLOR_BLACK: pixel = 0x00000000; break; case DWT.COLOR_RED: pixel = 0x000000FF; break; case DWT.COLOR_DARK_RED: pixel = 0x00000080; break; case DWT.COLOR_GREEN: pixel = 0x0000FF00; break; case DWT.COLOR_DARK_GREEN: pixel = 0x00008000; break; case DWT.COLOR_YELLOW: pixel = 0x0000FFFF; break; case DWT.COLOR_DARK_YELLOW: pixel = 0x00008080; break; case DWT.COLOR_BLUE: pixel = 0x00FF0000; break; case DWT.COLOR_DARK_BLUE: pixel = 0x00800000; break; case DWT.COLOR_MAGENTA: pixel = 0x00FF00FF; break; case DWT.COLOR_DARK_MAGENTA: pixel = 0x00800080; break; case DWT.COLOR_CYAN: pixel = 0x00FFFF00; break; case DWT.COLOR_DARK_CYAN: pixel = 0x00808000; break; case DWT.COLOR_GRAY: pixel = 0x00C0C0C0; break; case DWT.COLOR_DARK_GRAY: pixel = 0x00808080; break; } return Color.win32_new (this, pixel); } /** * Returns a reasonable font for applications to use. * On some platforms, this will match the "default font" * or "system font" if such can be found. This font * should not be freed because it was allocated by the * system, not the application. * <p> * Typically, applications which want the default look * should simply not set the font on the widgets they * create. Widgets are always created with the correct * default font for the class of user-interface component * they represent. * </p> * * @return a font * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> */ public Font getSystemFont () { checkDevice (); auto hFont = OS.GetStockObject (OS.SYSTEM_FONT); return Font.win32_new (this, hFont); } /** * Returns <code>true</code> if the underlying window system prints out * warning messages on the console, and <code>setWarnings</code> * had previously been called with <code>true</code>. * * @return <code>true</code>if warnings are being handled, and <code>false</code> otherwise * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> */ public bool getWarnings () { checkDevice (); return false; } /** * Initializes any internal resources needed by the * device. * <p> * This method is called after <code>create</code>. * </p><p> * If subclasses reimplement this method, they must * call the <code>super</code> implementation. * </p> * * @see #create */ protected void init () { if (debug_) { if (!OS.IsWinCE) OS.GdiSetBatchLimit(1); } /* Initialize scripts list */ if (!OS.IsWinCE) { SCRIPT_PROPERTIES** ppSp; int piNumScripts; OS.ScriptGetProperties (&ppSp, &piNumScripts); scripts = ppSp[ 0 .. piNumScripts ].dup; } /* * If we're not on a device which supports palettes, * don't create one. */ auto hDC = internal_new_GC (null); int rc = OS.GetDeviceCaps (hDC, OS.RASTERCAPS); int bits = OS.GetDeviceCaps (hDC, OS.BITSPIXEL); int planes = OS.GetDeviceCaps (hDC, OS.PLANES); bits *= planes; if ((rc & OS.RC_PALETTE) is 0 || bits !is 8) { internal_dispose_GC (hDC, null); return; } int numReserved = OS.GetDeviceCaps (hDC, OS.NUMRESERVED); int numEntries = OS.GetDeviceCaps (hDC, OS.SIZEPALETTE); if (OS.IsWinCE) { /* * Feature on WinCE. For some reason, certain 8 bit WinCE * devices return 0 for the number of reserved entries in * the system palette. Their system palette correctly contains * the usual 20 system colors. The workaround is to assume * there are 20 reserved system colors instead of 0. */ if (numReserved is 0 && numEntries >= 20) numReserved = 20; } /* Create the palette and reference counter */ colorRefCount = new int [numEntries]; /* 4 bytes header + 4 bytes per entry * numEntries entries */ byte [] logPalette = new byte [4 + 4 * numEntries]; /* 2 bytes = special header */ logPalette [0] = 0x00; logPalette [1] = 0x03; /* 2 bytes = number of colors, LSB first */ logPalette [2] = 0; logPalette [3] = 1; /* * Create a palette which contains the system entries * as they are located in the system palette. The * MSDN article 'Memory Device Contexts' describes * where system entries are located. On an 8 bit * display with 20 reserved colors, the system colors * will be the first 10 entries and the last 10 ones. */ byte[] lppe = new byte [4 * numEntries]; OS.GetSystemPaletteEntries (hDC, 0, numEntries, cast(PALETTEENTRY*)lppe.ptr); /* Copy all entries from the system palette */ System.arraycopy (lppe, 0, logPalette, 4, 4 * numEntries); /* Lock the indices corresponding to the system entries */ for (int i = 0; i < numReserved / 2; i++) { colorRefCount [i] = 1; colorRefCount [numEntries - 1 - i] = 1; } internal_dispose_GC (hDC, null); hPalette = OS.CreatePalette (cast(LOGPALETTE*)logPalette.ptr); } /** * Invokes platform specific functionality to allocate a new GC handle. * <p> * <b>IMPORTANT:</b> This method is <em>not</em> part of the public * API for <code>Device</code>. It is marked public only so that it * can be shared within the packages provided by DWT. It is not * available on all platforms, and should never be called from * application code. * </p> * * @param data the platform specific GC data * @return the platform specific GC handle */ public abstract HDC internal_new_GC (GCData data); /** * Invokes platform specific functionality to dispose a GC handle. * <p> * <b>IMPORTANT:</b> This method is <em>not</em> part of the public * API for <code>Device</code>. It is marked public only so that it * can be shared within the packages provided by DWT. It is not * available on all platforms, and should never be called from * application code. * </p> * * @param hDC the platform specific GC handle * @param data the platform specific GC data */ public abstract void internal_dispose_GC (HDC hDC, GCData data); /** * Returns <code>true</code> if the device has been disposed, * and <code>false</code> otherwise. * <p> * This method gets the dispose state for the device. * When a device has been disposed, it is an error to * invoke any other method using the device. * * @return <code>true</code> when the device is disposed and <code>false</code> otherwise */ public bool isDisposed () { return disposed; } /** * Loads the font specified by a file. The font will be * present in the list of fonts available to the application. * * @param path the font file path * @return whether the font was successfully loaded * * @exception DWTException <ul> * <li>ERROR_NULL_ARGUMENT - if path is null</li> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> * * @see Font * * @since 3.3 */ public bool loadFont (char[] path) { checkDevice(); if (path is null) DWT.error (DWT.ERROR_NULL_ARGUMENT); if (OS.IsWinNT && OS.WIN32_VERSION >= OS.VERSION (4, 10)) { //TCHAR lpszFilename = new TCHAR (0, path, true); return OS.AddFontResourceEx ( .StrToTCHARz(path), OS.FR_PRIVATE, null) !is 0; } return false; } void new_Object (Object object) { for (int i=0; i<objects.length; i++) { if (objects [i] is null) { objects [i] = object; errors [i] = new TracedException ( "" ); return; } } Object [] newObjects = new Object [objects.length + 128]; System.arraycopy (objects, 0, newObjects, 0, objects.length); newObjects [objects.length] = object; objects = newObjects; TracedException [] newErrors = new TracedException [errors.length + 128]; System.arraycopy (errors, 0, newErrors, 0, errors.length); newErrors [errors.length] = new TracedException (""); errors = newErrors; } /** * Releases any internal resources back to the operating * system and clears all fields except the device handle. * <p> * When a device is destroyed, resources that were acquired * on behalf of the programmer need to be returned to the * operating system. For example, if the device allocated a * font to be used as the system font, this font would be * freed in <code>release</code>. Also,to assist the garbage * collector and minimize the amount of memory that is not * reclaimed when the programmer keeps a reference to a * disposed device, all fields except the handle are zero'd. * The handle is needed by <code>destroy</code>. * </p> * This method is called before <code>destroy</code>. * </p><p> * If subclasses reimplement this method, they must * call the <code>super</code> implementation. * </p> * * @see #dispose * @see #destroy */ protected void release () { if (gdipToken !is null) { Gdip.GdiplusShutdown ( &gdipToken ); } gdipToken = null; scripts = null; if (hPalette !is null) OS.DeleteObject (hPalette); hPalette = null; colorRefCount = null; logFonts = null; nFonts = 0; } /** * If the underlying window system supports printing warning messages * to the console, setting warnings to <code>false</code> prevents these * messages from being printed. If the argument is <code>true</code> then * message printing is not blocked. * * @param warnings <code>true</code>if warnings should be printed, and <code>false</code> otherwise * * @exception DWTException <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> * </ul> */ public void setWarnings (bool warnings) { checkDevice (); } }