--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/graphics/Device.d	Sat Aug 09 17:00:02 2008 +0200
@@ -0,0 +1,636 @@
+/*******************************************************************************
+ * 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;
+
+import dwt.dwthelper.utils;
+
+import dwt.DWT;
+import dwt.DWTException;
+import dwt.internal.Compatibility;
+import dwt.internal.cocoa.NSArray;
+import dwt.internal.cocoa.NSDictionary;
+import dwt.internal.cocoa.NSFont;
+import dwt.internal.cocoa.NSFontManager;
+import dwt.internal.cocoa.NSRect;
+import dwt.internal.cocoa.NSScreen;
+import dwt.internal.cocoa.NSSize;
+import dwt.internal.cocoa.NSString;
+import dwt.internal.cocoa.NSValue;
+import dwt.internal.cocoa.OS;
+import dwt.internal.cocoa.id;
+
+/**
+ * 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 implements Drawable {
+    
+    /* Debugging */
+    public static bool DEBUG;
+    bool debug = DEBUG;
+    bool tracking = DEBUG;
+    Error [] errors;
+    Object [] objects;
+    Object trackingLock;
+    
+    /* Disposed flag */
+    bool disposed, warnings;
+    
+    Color COLOR_BLACK, COLOR_DARK_RED, COLOR_DARK_GREEN, COLOR_DARK_YELLOW, COLOR_DARK_BLUE;
+    Color COLOR_DARK_MAGENTA, COLOR_DARK_CYAN, COLOR_GRAY, COLOR_DARK_GRAY, COLOR_RED;
+    Color COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE;
+
+    /* System Font */
+    Font systemFont;
+
+    /*
+    * 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;
+    static {
+        try {
+            Class.forName ("dwt.widgets.Display");
+        } catch (Throwable e) {}
+    }   
+
+/*
+* 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 Device() {
+    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 Device(DeviceData data) {
+    synchronized (Device.class) {
+        if (data !is null) {
+            debug = data.debug;
+            tracking = data.tracking;
+        }
+        if (tracking) {
+            errors = new Error [128];
+            objects = new Object [128];
+            trackingLock = new Object ();
+        }
+        create (data);
+        init ();
+    }
+}
+
+/**
+ * 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);
+}
+
+/**
+ * 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) {
+}
+
+/**
+ * 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 () {
+    synchronized (Device.class) {
+        if (isDisposed()) return;
+        checkDevice ();
+        release ();
+        destroy ();
+        disposed = true;
+        if (tracking) {
+            synchronized (trackingLock) {
+                objects = null;
+                errors = null;
+                trackingLock = null;
+            }
+        }
+    }
+}
+
+void dispose_Object (Object object) {
+    synchronized (trackingLock) {
+        for (int i=0; i<objects.length; i++) {
+            if (objects [i] is object) {
+                objects [i] = null;
+                errors [i] = null;
+                return;
+            }
+        }
+    }
+}
+
+/**
+ * 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 () {
+}
+
+/**
+ * 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 ();
+    NSScreen screen = NSScreen.mainScreen();
+    NSRect rect = screen.frame();
+    return new Rectangle((int)rect.x, (int)rect.y, (int)rect.width, (int)rect.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;
+    if (tracking) {
+        synchronized (trackingLock) {
+            int count = 0, 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 Error [count];
+            for (int i=0; i<length; i++) {
+                if (objects [i] !is null) {
+                    data.objects [index] = objects [i];
+                    data.errors [index] = errors [i];
+                    index++;
+                }
+            }
+        }
+    } else {
+        data.objects = new Object [0];
+        data.errors = new Error [0];
+    }
+    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 () {
+    checkDevice ();
+    NSScreen screen = NSScreen.mainScreen();
+    NSRect rect = screen.visibleFrame();
+    return new Rectangle((int)rect.x, (int)rect.y, (int)rect.width, (int)rect.height);
+}
+
+/**
+ * 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 (); 
+    return OS.NSBitsPerPixelFromDepth(NSScreen.mainScreen().depth());
+}
+
+/**
+ * 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 ();
+    NSDictionary dictionary = NSScreen.mainScreen().deviceDescription();
+    NSValue value = new NSValue(dictionary.objectForKey(new id(OS.NSDeviceResolution())).id);
+    NSSize size = value.sizeValue();
+    return new Point((int)size.width, (int)size.height);
+}
+
+/**
+ * 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 (String faceName, bool scalable) {
+    checkDevice ();
+    if (!scalable) return new FontData[0];
+    NSArray fonts = NSFontManager.sharedFontManager().availableFonts();
+    int count = 0;
+    FontData[] fds = new FontData[fonts.count()];
+    for (int i = 0; i < fds.length; i++) {
+        NSString str = new NSString(fonts.objectAtIndex(i));
+        char[] buffer = new char[str.length()];
+        str.getCharacters_(buffer);
+        String nsName = new String(buffer);
+        String name = nsName;
+        int index = nsName.indexOf('-');
+        if (index !is -1) name = name.substring(0, index);
+        int style = DWT.NORMAL;
+        if (nsName.indexOf("Italic") !is -1) style |= DWT.ITALIC;
+        if (nsName.indexOf("Bold") !is -1) style |= DWT.BOLD;
+        if (faceName is null || Compatibility.equalsIgnoreCase(faceName, name)) {
+            FontData data = new FontData(name, 0, style);
+            data.nsName = nsName;
+            fds[count++] = data;
+        }
+    }
+    if (count is fds.length) return fds;
+    FontData[] result = new FontData[count];
+    System.arraycopy(fds, 0, result, 0, count);
+    return result;
+}
+
+/**
+ * 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 ();
+    switch (id) {
+        case DWT.COLOR_BLACK:               return COLOR_BLACK;
+        case DWT.COLOR_DARK_RED:            return COLOR_DARK_RED;
+        case DWT.COLOR_DARK_GREEN:          return COLOR_DARK_GREEN;
+        case DWT.COLOR_DARK_YELLOW:         return COLOR_DARK_YELLOW;
+        case DWT.COLOR_DARK_BLUE:           return COLOR_DARK_BLUE;
+        case DWT.COLOR_DARK_MAGENTA:        return COLOR_DARK_MAGENTA;
+        case DWT.COLOR_DARK_CYAN:           return COLOR_DARK_CYAN;
+        case DWT.COLOR_GRAY:                return COLOR_GRAY;
+        case DWT.COLOR_DARK_GRAY:           return COLOR_DARK_GRAY;
+        case DWT.COLOR_RED:                 return COLOR_RED;
+        case DWT.COLOR_GREEN:               return COLOR_GREEN;
+        case DWT.COLOR_YELLOW:              return COLOR_YELLOW;
+        case DWT.COLOR_BLUE:                return COLOR_BLUE;
+        case DWT.COLOR_MAGENTA:             return COLOR_MAGENTA;
+        case DWT.COLOR_CYAN:                return COLOR_CYAN;
+        case DWT.COLOR_WHITE:               return COLOR_WHITE;
+    }
+    return COLOR_BLACK;
+}
+
+/**
+ * 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 ();
+    return systemFont;
+}
+
+/**
+ * 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 warnings;
+}
+
+/**
+ * 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 () {
+    /* Create the standard colors */
+    COLOR_BLACK = new Color (this, 0,0,0);
+    COLOR_DARK_RED = new Color (this, 0x80,0,0);
+    COLOR_DARK_GREEN = new Color (this, 0,0x80,0);
+    COLOR_DARK_YELLOW = new Color (this, 0x80,0x80,0);
+    COLOR_DARK_BLUE = new Color (this, 0,0,0x80);
+    COLOR_DARK_MAGENTA = new Color (this, 0x80,0,0x80);
+    COLOR_DARK_CYAN = new Color (this, 0,0x80,0x80);
+    COLOR_GRAY = new Color (this, 0xC0,0xC0,0xC0);
+    COLOR_DARK_GRAY = new Color (this, 0x80,0x80,0x80);
+    COLOR_RED = new Color (this, 0xFF,0,0);
+    COLOR_GREEN = new Color (this, 0,0xFF,0);
+    COLOR_YELLOW = new Color (this, 0xFF,0xFF,0);
+    COLOR_BLUE = new Color (this, 0,0,0xFF);
+    COLOR_MAGENTA = new Color (this, 0xFF,0,0xFF);
+    COLOR_CYAN = new Color (this, 0,0xFF,0xFF);
+    COLOR_WHITE = new Color (this, 0xFF,0xFF,0xFF);
+    
+    /* Initialize the system font slot */
+    NSFont font = NSFont.systemFontOfSize(NSFont.systemFontSize());
+    systemFont = Font.cocoa_new(this, font);
+}
+
+/**  
+ * 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 int 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 (int handle, 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 () {
+    synchronized (Device.class) {
+        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 (String path) {
+    checkDevice();
+    if (path is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
+    bool result = false;
+    char [] chars = new char [path.length ()];
+    path.getChars (0, chars.length, chars, 0);
+    return result;
+}
+
+void new_Object (Object object) {
+    synchronized (trackingLock) {
+        for (int i=0; i<objects.length; i++) {
+            if (objects [i] is null) {
+                objects [i] = object;
+                errors [i] = new Error ();
+                return;
+            }
+        }
+        Object [] newObjects = new Object [objects.length + 128];
+        System.arraycopy (objects, 0, newObjects, 0, objects.length);
+        newObjects [objects.length] = object;
+        objects = newObjects;
+        Error [] newErrors = new Error [errors.length + 128];
+        System.arraycopy (errors, 0, newErrors, 0, errors.length);
+        newErrors [errors.length] = new Error ();
+        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 () {
+    COLOR_BLACK = COLOR_DARK_RED = COLOR_DARK_GREEN = COLOR_DARK_YELLOW = COLOR_DARK_BLUE =
+    COLOR_DARK_MAGENTA = COLOR_DARK_CYAN = COLOR_GRAY = COLOR_DARK_GRAY = COLOR_RED =
+    COLOR_GREEN = COLOR_YELLOW = COLOR_BLUE = COLOR_MAGENTA = COLOR_CYAN = COLOR_WHITE = null;
+}
+
+/**
+ * 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 ();
+    this.warnings = warnings;
+}
+
+}