ShiftOS-C-/source/ShiftUI/Internal/XplatUICosmos.cs

/* Cosmos XplatUI driver
 * 
 * Author: Michael VanOverbeek
 * Based off: XplatUIWin32 driver (ShiftUI\Internal\XplatUIWin32.cs), copyright info can be found there.
 * 
 * Cosmos is a C# open source managed operating system, capable of basic graphics using either
 * VGA or VESA BIOS Extensions, it can do full console IO, has a working FAT driver, and is
 * written entirely in C# and their homebrewed high-level assembly language, X#.
 * 
 * ShiftUI cannot access Cosmos APIs directly, so to compensate, the CosmosInterface
 * class exists. This is an interface between ShiftUI and Cosmos, and it is used
 * to tell the operating system where to draw pixels, what colors to use, and when
 * something happens, like a window opening or closing, or an error occurring.
 * 
 * This makes it so that ShiftUI doesn't care what graphics driver you use, as long as it
 * supports 32bit RGB and you are capable of converting RGB values thrown by ShiftUI
 * to the values that your graphics driver wants.
 * 
 * This also means that your OS can deal with actually drawing windows, much like how
 * Win32 and X11 does it. It's sort of a "you be the puppet, ShiftUI'll pull the strings"
 * situation.
 * 
 * The Cosmos driver is UNFINISHED, and many Win32 code remains. So, if you can continue
 * on, or you want to use Cosmos features when I'm done, simply uncomment this:
 */

 //#define COSMOS

 /*
  * and the C# compiler and Visual Studio will compile all of the Cosmos stuff.
  * 
  * If you're planning on using ShiftUI for a Windows application or even Linux/Mac,
  * DO NOT UNCOMMENT THAT #DEFINE. YOU WILL BREAK LOTS OF THINGS. There is a lot of
  * platform-dependent stuff in Mono Winforms which is what ShiftUI is HEAVILY based
  * off of, for example, when the app starts, it detects if you're on Windows, Mac or
  * Linux, so that it knows whether to use Win32, X11, or Carbon. Cosmos can't really
  * determine what OS it's running on because it IS an OS, so the COSMOS #define is
  * used to bypass the platform-dependent stuff and make ShiftUI work specifically on
  * Cosmos.
  * 
  * Michael VanOverbeek out. 
  */

#if COSMOS
using ShiftUI;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ShiftUI.Internal
{
    public struct CosmosScreen
    {
        public int Width { get; set; }
        public int Height { get; set; }
        public CosmosGfxDriver Driver { get; set; }
    }

    public enum CosmosGfxDriver
    {
        VGA,
        VESA,
        VMware,
        Dummy
    }

    public enum CosmosWindowState
    {
        Maximized,
        Minimized,
        Normal,
    }

    public enum CosmosWindowHint
    {
        MESSAGEBOX,
        TOPLEVEL,
        DEFAULT,
        BORDERLESS,
        DESKTOP,
        TOOL,
    }

    public class CosmosWindow
    {
        public IntPtr Handle { get; set; }
        public Hwnd Hwnd { get; set; }
        public string Title { get; set; }
        public CosmosWindowState WindowState { get; set; }
        public CosmosWindowHint Style { get; set; }
    }

    /// <summary>
    /// Because Cosmos cannot do dynamic loading and therefore
    /// can't do P/Invokes, I'll let the operating system developer
    /// use this interface as a backbone for letting XplatUI actually
    /// interact with their operating system.
    /// 
    /// ShiftOS won't use this, however Memphis will, and it's entire window manager
    /// will reside in a class deriving from this class.
    /// </summary>
    public abstract class CosmosInterface
    {
        public abstract void SetPixel(int x, int y, Color col);
        public abstract Color GetPixel(int x, int y);
        public abstract CosmosScreen GetScreenInfo();
        public abstract int MouseX { get; }
        public abstract int MouseY { get; }
        public abstract bool MouseWheelPressed { get; }
        internal List<CosmosWindow> Windows = null;
        public abstract void Redraw();



        public bool IsWindow(IntPtr handle)
        {
            if(Windows == null)
            {
                Windows = new List<Hwnd>();
                return false;
            }
            foreach(var win in Windows)
            {
                if (win.Handle == handle)
                    return true;
            }
            return false;
        }
        
        /// <summary>
        /// Clears the screen with a specified color.
        /// </summary>
        /// <param name="c">The color to clear to.</param>
        public void Clear(Color c) {
            var scr = GetScreenInfo();
            int w = scr.Width;
            int h = scr.Height;
            DrawRectangle(c, new Rectangle(0, 0, w, h));
        }

        /// <summary>
        /// Draws a rectangle with the specified Rectangle and color.
        /// </summary>
        /// <param name="c">The color to use. (Note that depending on the graphics config of the current OS, color quality may be reduced.</param>
        /// <param name="rect">The Rectangle struct containing the X and Y coordinates and the width and height.</param>
        public void DrawRectangle(Color c, Rectangle rect)
        {
            int x = rect.X;
            int y = rect.Y;
            int max_width = rect.Width;
            int max_height = rect.Height;
            for(int i = x; i < max_width; i++)
            {
                for(int i2 = y; i2 < max_height; i2++)
                {
                    if (GetPixel(i, i2) != c)
                        SetPixel(i, i2, c);
                }
            }
        }

        /// <summary>
        /// Draws an unfilled rectangle using the specified Rectangle, line width and color.
        /// </summary>
        public void DrawUnfilledRectangle(Rectangle rect, int width, Color c)
        {
            //top & bottom border
            for(int x = rect.X; x < rect.Width; x++)
            {
                //top
                for(int y = rect.Y; y < rect.Y + width; y++)
                {
                    if (GetPixel(x, y) != c)
                        SetPixel(x, y, c);
                }

                //bottom
                for(int y = rect.Height - width; y < rect.Height; y++)
                {
                    if (GetPixel(x, y) != c)
                        SetPixel(x, y, c);
                }
            }

            //In theory that code should work for left & right.
            for (int y = rect.Y; y < rect.Height; y++)
            {
                //left
                for (int x = rect.X; x < rect.X + width; x++)
                {
                    if (GetPixel(x, y) != c)
                        SetPixel(x, y, c);
                }

                //right
                for (int x = rect.Width - width; x < rect.Width; x++)
                {
                    if (GetPixel(x, y) != c)
                        SetPixel(x, y, c);
                }
            }

        }
    }

    public class DefaultCosmosInterface : CosmosInterface
    {
        public const string SUI_ERR_NODRIVER = "[ShiftUI] You cannot use ShiftUI yet. You still need to load in a proper CosmosInterface.";

        public override bool MouseWheelPressed
        {
            get
            {
                Console.WriteLine(SUI_ERR_NODRIVER);
            }
        }

        public override int MouseX
        {
            get
            {
                Console.WriteLine(SUI_ERR_NODRIVER);
            }
        }

        public override int MouseY
        {
            get
            {
                Console.WriteLine(SUI_ERR_NODRIVER);
            }
        }

        public override Color GetPixel(int x, int y)
        {
            Console.WriteLine(SUI_ERR_NODRIVER);
            return Color.Empty;
        }

        public override CosmosScreen GetScreenInfo()
        {
            Console.WriteLine(SUI_ERR_NODRIVER);
            var s = new CosmosScreen();
            s.Driver = CosmosGfxDriver.Dummy;
            s.Width = 0;
            s.Height = 0;
            return s;
        }

        public override void Redraw()
        {
            Console.WriteLine(SUI_ERR_NODRIVER);
        }

        public override void SetPixel(int x, int y, Color col)
        {
            Console.WriteLine(SUI_ERR_NODRIVER);
        }
    }

    internal class XplatUICosmos : XplatUIDriver
    {
#region Local Variables
        private CosmosInterface cosmos = new DefaultCosmosInterface();
        private static XplatUICosmos instance;
        private static int ref_count;
        private static IntPtr FosterParentLast;

        internal static MouseButtons mouse_state;
        internal static Point mouse_position;
        internal static bool grab_confined;
        internal static IntPtr grab_hwnd;
        internal static Rectangle grab_area;
        internal static WndProc wnd_proc;
        internal static IntPtr prev_mouse_hwnd;
        internal static bool caret_visible;

        internal static bool themes_enabled;
        private Hashtable timer_list;
        private static Queue message_queue;
        private static IntPtr clip_magic = new IntPtr(27051977);
        private static int scroll_width;
        private static int scroll_height;
        private static Hashtable wm_nc_registered;
        private static Rectangle clipped_cursor_rect;
        private Hashtable registered_classes;
        private Hwnd HwndCreating; // the Hwnd we are currently creating (see CreateWindow)

#endregion    // Local Variables

#region Constructor & Destructor
        private XplatUICosmos()
        {
            // Handle singleton stuff first
            ref_count = 0;

            mouse_state = MouseButtons.None;
            mouse_position = Point.Empty;

            grab_confined = false;
            grab_area = Rectangle.Empty;

            message_queue = new List<CosmosMessage>();

            themes_enabled = true;

            FosterParentLast = IntPtr.Zero;

            scroll_height = 25;
            scroll_width = 25;

            timer_list = new Hashtable();
            registered_classes = new Hashtable();
        }
#endregion // Constructor & Destructor

#region Private Support Methods

        private IntPtr GetFosterParent()
        {
            if (!cosmos.IsWindow(FosterParentLast))
            {
                FosterParentLast = cosmos.CreateWindow("Foster Parent", BorderStyle.None, 0, 0, 0, 0, IntPtr.Zero);

                if (FosterParentLast == IntPtr.Zero)
                {
                    MessageBox.Show("Could not create foster window, system error \"" + cosmos.GetLastError().ToString() = "\".", "Fatal error.");
                }
            }
            return FosterParentLast;
        }

#region Static Properties
        internal override int ActiveWindowTrackingDelay
        {
            get { return 0; }
        }

        internal override int CaretWidth
        {
            get
            {
                return Application.CurrentSkin.CaretWidth;
            }
        }

        internal override int FontSmoothingContrast
        {
            get
            {
                return 0;
            }
        }

        internal override int FontSmoothingType
        {
            get
            {
                return 0;
            }
        }

        internal override int HorizontalResizeBorderThickness
        {
            get { return 5; }
        }

        internal override bool IsActiveWindowTrackingEnabled
        {
            get { return false; }
        }

        internal override bool IsComboBoxAnimationEnabled
        {
            get { return false; }
        }

        internal override bool IsDropShadowEnabled
        {
            get
            {
                return false;
            }
        }

        internal override bool IsFontSmoothingEnabled
        {
            get { return false; }
        }

        internal override bool IsHotTrackingEnabled
        {
            get { return true; }
        }

        internal override bool IsIconTitleWrappingEnabled
        {
            get { return true; }
        }

        internal override bool IsKeyboardPreferred
        {
            get { return false; }
        }

        internal override bool IsListBoxSmoothScrollingEnabled
        {
            get { return false; }
        }

        internal override bool IsMenuAnimationEnabled
        {
            get { return false; }
        }

        internal override bool IsMenuFadeEnabled
        {
            get { return false; }
        }

        internal override bool IsMinimizeRestoreAnimationEnabled
        {
            get
            {
                return false;
            }
        }

        internal override bool IsSelectionFadeEnabled
        {
            get { return false; }
        }

        internal override bool IsSnapToDefaultEnabled
        {
            get { return false; }
        }

        internal override bool IsTitleBarGradientEnabled
        {
            get { return false; }
        }

        internal override bool IsToolTipAnimationEnabled
        {
            get { return false; }
        }

        internal override Size MenuBarButtonSize
        {
            get
            {
                return new Size(32, 32);
            }
        }

        public override Size MenuButtonSize
        {
            get
            {
                return new Size(32, 32);
            }
        }

        internal override int MenuShowDelay
        {
            get { return 0; }
        }

        internal override int MouseSpeed
        {
            get { return Application.CurrentSkin.MouseSpeed; }
        }

        internal override LeftRightAlignment PopupMenuAlignment
        {
            get { return LeftRightAlignment.Left; }
        }

        internal override PowerStatus PowerStatus
        {
            get
            {
                //Cosmos doesn't have power management. Sadly.
                return new PowerStatus(BatteryChargeStatus.Unknown, "No power status for you.".Length, 0.0, 0, PowerLineStatus.Unknown);
            }
        }

        internal override int SizingBorderWidth
        {
            get { return Application.CurrentSkin.SizeBorderWidth; }
        }

        internal override Size SmallCaptionButtonSize
        {
            get
            {
                return new Size(32, 32);
            }
        }

        internal override bool UIEffectsEnabled
        {
            get { return false; }
        }

        internal override int VerticalResizeBorderThickness
        {
            get { return 5; }
        }

        internal override void RaiseIdle(EventArgs e)
        {
            if (Idle != null)
                Idle(this, e);
        }

        internal override Keys ModifierKeys
        {
            get
            {
                short state;
                Keys key_state;

                key_state = Keys.None;
                
                return key_state;
            }
        }

        internal override MouseButtons MouseButtons
        {
            get
            {
                return cosmos.MouseState;
            }
        }

        internal override Point MousePosition
        {
            get
            {
                return new Point(cosmos.MouseX, cosmos.MouseY);
            }
        }

        internal override Size MouseHoverSize
        {
            get
            {
                int width = 4;
                int height = 4;
                return new Size(width, height);
            }
        }

        internal override int MouseHoverTime
        {
            get
            {
                int time = 500;
                return time;
            }
        }

        internal override int MouseWheelScrollDelta
        {
            get
            {
                int delta = 120;
                return delta;
            }
        }

        internal override int HorizontalScrollBarHeight
        {
            get
            {
                return scroll_height;
            }
        }

        internal override bool UserClipWontExposeParent
        {
            get
            {
                return false;
            }
        }


        internal override int VerticalScrollBarWidth
        {
            get
            {
                return scroll_width;
            }
        }

        internal override int MenuHeight
        {
            get
            {
                return 32;
            }
        }

        internal override Size Border3DSize
        {
            get
            {
                return new Size(2, 2);
            }
        }

        internal override Size BorderSize
        {
            get
            {
                return new Size(2, 2);
            }
        }

        internal override bool DropTarget
        {
            get
            {
                return false;
            }

            set
            {
                if (value)
                {
                    //throw new NotImplementedException("Need to figure out D'n'D for Win32");
                }
            }
        }

        internal override Size CaptionButtonSize
        {
            get
            {
                return new Size(64, 32);
            }
        }

        internal override int CaptionHeight
        {
            get
            {
                return 35;
            }
        }

        internal override Size CursorSize
        {
            get
            {
                return new Size(32, 32);
            }
        }

        internal override bool DragFullWindows
        {
            get
            {
                return false;
            }
        }

        internal override Size DragSize
        {
            get
            {
                return new Size(32, 32);
            }
        }

        internal override Size DoubleClickSize
        {
            get
            {
                return new Size(36, 36); //thanks to @InternetUnexploder from the Cosmos Gitter chat, I know the raw value I need to put here :P
            }
        }

        internal override int DoubleClickTime
        {
            get
            {
                return 1000;
            }
        }

        internal override Size FixedFrameBorderSize
        {
            get
            {
                return new Size(2, 2);
            }
        }

        internal override Size FrameBorderSize
        {
            get
            {
                return new Size(4, 4);
            }
        }

        internal override Size IconSize
        {
            get
            {
                return new Size(16, 16);
            }
        }

        internal override Size MaxWindowTrackSize
        {
            get
            {
                return new Size(59, 60);
            }
        }

        internal override bool MenuAccessKeysUnderlined
        {
            get
            {
                return false;
            }
        }

        internal override Size MinimizedWindowSize
        {
            get
            {
                return new Size(0, 0);
            }
        }

        internal override Size MinimizedWindowSpacingSize
        {
            get
            {
                return new Size(0, 0);
            }
        }

        internal override Size MinimumWindowSize
        {
            get
            {
                return new Size(50, 50);
            }
        }

        internal override Size MinWindowTrackSize
        {
            get
            {
                return new Size(50, 50);
            }
        }

        internal override Size SmallIconSize
        {
            get
            {
                return new Size(8, 8);
            }
        }

        internal override int MouseButtonCount
        {
            get
            {
                return 3;
            }
        }

        internal override bool MouseButtonsSwapped
        {
            get
            {
                return false;
            }
        }

        internal override bool MouseWheelPresent
        {
            get
            {
                return cosmos.MouseWheelPressed;
            }
        }

        internal override Rectangle VirtualScreen
        {
            get
            {
                var s = cosmos.GetScreenInfo();
                return new Rectangle(s.X, s.Y, s.Width, s.Height);
            }
        }

        internal override Rectangle WorkingArea
        {
            get
            {
                return VirtualScreen;
            }
        }

        [MonoTODO]
        internal override Screen[] AllScreens
        {
            get
            {
                // Can't use this sadly.
                return null;
            }
        }

        internal override bool ThemesEnabled
        {
            get
            {
                return true;
            }
        }

        internal override bool RequiresPositiveClientAreaSize
        {
            get
            {
                return false;
            }
        }

        public override int ToolWindowCaptionHeight
        {
            get
            {
                return 35; //Drawing will be done entirely by the developer itself. Do we really care about the tool window size?
            }
        }

        public override Size ToolWindowCaptionButtonSize
        {
            get
            {
                return new Size(32, 32);
            }
        }
#endregion // Static Properties

#region Singleton Specific Code
        public static XplatUICosmos GetInstance()
        {
            if (instance == null)
            {
                instance = new XplatUICosmos();
            }
            ref_count++;
            return instance;
        }

        public int Reference
        {
            get
            {
                return ref_count;
            }
        }
#endregion

#region Public Static Methods
        internal override IntPtr InitializeDriver()
        {
            cosmos.OnInit();
            return IntPtr.Zero;
        }

        internal override void ShutdownDriver(IntPtr token)
        {
            Console.WriteLine("[ShiftUI] Stopping Cosmos driver...");
            cosmos.OnShutdown();
        }


        internal void Version()
        {
            Console.WriteLine($"ShiftUI version {Application.ShiftUIVersionString}, running in the cosmos, on {cosmos.OSName} version {cosmos.OSVersionString}.");
        }

        string GetSoundAlias(AlertType alert)
        {
            return "";
        }

        internal override void AudibleAlert(AlertType alert)
        {
            //Cosmos cannot do audio.
        }

        internal override void BeginMoveResize(IntPtr handle)
        {
            //If the Mono devs that worked on the Win32 driver didn't know what this did, what
            //makes you think I will?
        }

        internal override void GetDisplaySize(out Size size)
        {
            //get screen metrics from OS
            var screen = cosmos.GetScreenInfo();
            //push the data out.
            size = new Size(screen.Width, screen.Height);
        }

        internal override void EnableThemes()
        {
            //Themes will forever be enabled.
        }

        //[MichaelComment(Message = "Yay. I just LOVE messing with Win32 stuff and porting it to Cosmos.")]
        internal override IntPtr CreateWindow(CreateParams cp)
        {
            //I think I'll let this do it's thing it's own way but just change where the new Hwnd gets placed.
            if (cosmos.Windows == null)
                cosmos.Windows = new List<Hwnd>();
            IntPtr WindowHandle;
            IntPtr ParentHandle;
            Hwnd hwnd;

            hwnd = new Hwnd();

            ParentHandle = cp.Parent;

            if ((ParentHandle == IntPtr.Zero) && (cp.Style & (int)(WindowStyles.WS_CHILD)) != 0)
            {
                // We need to use our foster parent window until this poor child gets it's parent assigned
                ParentHandle = GetFosterParent();
            }

            if (((cp.Style & (int)(WindowStyles.WS_CHILD | WindowStyles.WS_POPUP)) == 0) && ((cp.ExStyle & (int)WindowExStyles.WS_EX_APPWINDOW) == 0))
            {
                // If we want to be hidden from the taskbar we need to be 'owned' by 
                // something not on the taskbar. FosterParent is just that
                ParentHandle = GetFosterParent();
            }

            Point location;
            if (cp.HasWindowManager)
            {
                location = Hwnd.GetNextStackedFormLocation(cp, Hwnd.ObjectFromHandle(cp.Parent));
            }
            else
            {
                location = new Point(cp.X, cp.Y);
            }

            string class_name = RegisterWindowClass(cp.ClassStyle);
            HwndCreating = hwnd;

            // We cannot actually send the WS_EX_MDICHILD flag to Windows because we
            // are faking MDI, not uses Windows' version.
            if ((cp.WindowExStyle & WindowExStyles.WS_EX_MDICHILD) == WindowExStyles.WS_EX_MDICHILD)
                cp.WindowExStyle ^= WindowExStyles.WS_EX_MDICHILD;

            WindowHandle = cosmos.Windows.Count + 1;

            HwndCreating = null;

            if (WindowHandle == IntPtr.Zero)
            {
                MessageBox.Show("An error happened while showing a window... Fascinating.", "Fatal error.");
            }

            hwnd.ClientWindow = WindowHandle;
            hwnd.Mapped = true;
            cosmos.Windows.Add(hwnd);
            
            return WindowHandle;
        }

        internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height)
        {
            CreateParams create_params = new CreateParams();

            create_params.Caption = "";
            create_params.X = X;
            create_params.Y = Y;
            create_params.Width = Width;
            create_params.Height = Height;

            create_params.ClassName = XplatUI.GetDefaultClassName(GetType());
            create_params.ClassStyle = 0;
            create_params.ExStyle = 0;
            create_params.Parent = IntPtr.Zero;
            create_params.Param = 0;

            return CreateWindow(create_params);
        }

        internal override void DestroyWindow(IntPtr handle)
        {
            Hwnd hwnd;

            foreach(var win in cosmos.Windows)
            {
                if (win.Handle == handle)
                    hwnd = win;
            }
            if (hwnd == null)
                MessageBox.Show("An error occurred while destroying a window.", "Fatal error.");
            cosmos.Windows.Remove(hwnd);
            cosmos.OnDestroyWindow(hwnd); //tell the OS to redraw that area...
            hwnd.Dispose();
            return;
        }

        internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max)
        {
            // We do nothing, Form has to handle WM_GETMINMAXINFO
        }


        internal override FormWindowState GetWindowState(IntPtr handle)
        {
            CosmosWindowStyle style;

            style = cosmos.GetWindowState(handle);
            switch(style)
            {
                case CosmosWindowStyle.Maximized:
                    return FormWindowState.Maximized;
                case CosmosWindowStyle.Minimized:
                    return FormWindowState.Minimized;
            }
            return FormWindowState.Normal;
        }

        internal override void SetWindowState(IntPtr hwnd, FormWindowState state)
        {
            switch (state)
            {
                case FormWindowState.Normal:
                    {
                        Win32ShowWindow(hwnd, WindowPlacementFlags.SW_RESTORE);
                        return;
                    }

                case FormWindowState.Minimized:
                    {
                        Win32ShowWindow(hwnd, WindowPlacementFlags.SW_MINIMIZE);
                        return;
                    }

                case FormWindowState.Maximized:
                    {
                        Win32ShowWindow(hwnd, WindowPlacementFlags.SW_MAXIMIZE);
                        return;
                    }
            }
        }

        internal override void SetWindowStyle(IntPtr handle, CreateParams cp)
        {

            Win32SetWindowLong(handle, WindowLong.GWL_STYLE, (uint)cp.Style);
            Win32SetWindowLong(handle, WindowLong.GWL_EXSTYLE, (uint)cp.ExStyle);

            // From MSDN:
            // Certain window data is cached, so changes you make using SetWindowLong
            // will not take effect until you call the SetWindowPos function. Specifically, 
            // if you change any of the frame styles, you must call SetWindowPos with
            // the SWP_FRAMECHANGED flag for the cache to be updated properly.
            if (cp.control is Form)
                XplatUI.RequestNCRecalc(handle);
        }

        internal override double GetWindowTransparency(IntPtr handle)
        {
            LayeredWindowAttributes lwa;
            COLORREF clrRef;
            byte alpha;

            if (0 == Win32GetLayeredWindowAttributes(handle, out clrRef, out alpha, out lwa))
                return 1.0;

            return ((double)alpha) / 255.0;
        }

        internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key)
        {
            LayeredWindowAttributes lwa = LayeredWindowAttributes.LWA_ALPHA;
            byte opacity = (byte)(transparency * 255);
            COLORREF clrRef = new COLORREF();
            if (key != Color.Empty)
            {
                clrRef.R = key.R;
                clrRef.G = key.G;
                clrRef.B = key.B;
                lwa = (LayeredWindowAttributes)((int)lwa | (int)LayeredWindowAttributes.LWA_COLORKEY);
            }
            RECT rc;
            rc.right = 1000;
            rc.bottom = 1000;
            Win32SetLayeredWindowAttributes(handle, clrRef, opacity, lwa);
        }

        TransparencySupport support;
        bool queried_transparency_support;
        internal override TransparencySupport SupportsTransparency()
        {
            if (queried_transparency_support)
                return support;

            bool flag;
            support = TransparencySupport.None;

            flag = true;
            try
            {
                Win32SetLayeredWindowAttributes(IntPtr.Zero, new COLORREF(), 255, LayeredWindowAttributes.LWA_ALPHA);
            }
            catch (EntryPointNotFoundException) { flag = false; }
            catch { /* swallow everything else */ }

            if (flag) support |= TransparencySupport.Set;

            flag = true;
            try
            {
                LayeredWindowAttributes lwa;
                COLORREF clrRef;
                byte alpha;

                Win32GetLayeredWindowAttributes(IntPtr.Zero, out clrRef, out alpha, out lwa);
            }
            catch (EntryPointNotFoundException) { flag = false; }
            catch { /* swallow everything else */ }

            if (flag) support |= TransparencySupport.Get;

            queried_transparency_support = true;
            return support;
        }

        internal override void UpdateWindow(IntPtr handle)
        {
            Win32UpdateWindow(handle);
        }

        internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client)
        {
            IntPtr hdc;
            PAINTSTRUCT ps;
            PaintEventArgs paint_event;
            RECT rect;
            Rectangle clip_rect;
            Hwnd hwnd;

            clip_rect = new Rectangle();
            rect = new RECT();
            ps = new PAINTSTRUCT();

            hwnd = Hwnd.ObjectFromHandle(msg.HWnd);

            if (client)
            {
                if (Win32GetUpdateRect(msg.HWnd, ref rect, false))
                {
                    if (handle != msg.HWnd)
                    {
                        // We need to validate the window where the paint message
                        // was generated, otherwise we'll never stop getting paint 
                        // messages.
                        Win32GetClientRect(msg.HWnd, out rect);
                        Win32ValidateRect(msg.HWnd, ref rect);
                        hdc = Win32GetDC(handle);
                    }
                    else
                    {
                        hdc = Win32BeginPaint(handle, ref ps);
                        rect = ps.rcPaint;
                    }
                }
                else
                {
                    hdc = Win32GetDC(handle);
                }
                clip_rect = rect.ToRectangle();
            }
            else
            {
                hdc = Win32GetWindowDC(handle);

                // HACK this in for now
                Win32GetWindowRect(handle, out rect);
                clip_rect = new Rectangle(0, 0, rect.Width, rect.Height);
            }

            // If we called BeginPaint, store the PAINTSTRUCT,
            // otherwise store hdc, so that PaintEventEnd can know
            // whether to call EndPaint or ReleaseDC.
            if (ps.hdc != IntPtr.Zero)
            {
                hwnd.drawing_stack.Push(ps);
            }
            else
            {
                hwnd.drawing_stack.Push(hdc);
            }

            Graphics dc = Graphics.FromHdc(hdc);
            hwnd.drawing_stack.Push(dc);

            paint_event = new PaintEventArgs(dc, clip_rect);

            return paint_event;
        }

        internal override void PaintEventEnd(ref Message m, IntPtr handle, bool client)
        {
            Hwnd hwnd;

            hwnd = Hwnd.ObjectFromHandle(m.HWnd);

            Graphics dc = (Graphics)hwnd.drawing_stack.Pop();
            dc.Dispose();

            object o = hwnd.drawing_stack.Pop();
            if (o is IntPtr)
            {
                IntPtr hdc = (IntPtr)o;
                Win32ReleaseDC(handle, hdc);
            }
            else if (o is PAINTSTRUCT)
            {
                PAINTSTRUCT ps = (PAINTSTRUCT)o;
                Win32EndPaint(handle, ref ps);
            }
        }


        internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height)
        {
            Win32MoveWindow(handle, x, y, width, height, true);
            return;
        }

        internal override void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height)
        {
            IntPtr parent;
            RECT rect;
            POINT pt;

            Win32GetWindowRect(handle, out rect);
            width = rect.right - rect.left;
            height = rect.bottom - rect.top;

            pt.x = rect.left;
            pt.y = rect.top;

            parent = Win32GetAncestor(handle, AncestorType.GA_PARENT);
            if (parent != IntPtr.Zero && parent != Win32GetDesktopWindow())
                Win32ScreenToClient(parent, ref pt);

            x = pt.x;
            y = pt.y;

            Win32GetClientRect(handle, out rect);
            client_width = rect.right - rect.left;
            client_height = rect.bottom - rect.top;
            return;
        }

        internal override void Activate(IntPtr handle)
        {
            Win32SetActiveWindow(handle);
            // delayed timer enabled
            lock (timer_list)
            {
                foreach (Timer t in timer_list.Values)
                {
                    if (t.Enabled && t.window == IntPtr.Zero)
                    {
                        t.window = handle;
                        int id = t.GetHashCode();
                        Win32SetTimer(handle, id, (uint)t.Interval, IntPtr.Zero);
                    }
                }
            }
        }

        internal override void Invalidate(IntPtr handle, Rectangle rc, bool clear)
        {
            cosmos.Redraw(); //I don't want to make it too hard for devs to deal with this...
        }


        internal override void InvalidateNC(IntPtr handle)
        {
            cosmos.Redraw();
        }

        private IntPtr InternalWndProc(IntPtr hWnd, Msg msg, IntPtr wParam, IntPtr lParam)
        {
            if (HwndCreating != null && HwndCreating.ClientWindow == IntPtr.Zero)
                HwndCreating.ClientWindow = hWnd;
            return NativeWindow.WndProc(hWnd, msg, wParam, lParam);
        }

        internal override IntPtr DefWndProc(ref Message msg)
        {
            msg.Result = Win32DefWindowProc(msg.HWnd, (Msg)msg.Msg, msg.WParam, msg.LParam);
            return msg.Result;
        }

        internal override void HandleException(Exception e)
        {
            StackTrace st = new StackTrace(e);
            Win32MessageBox(IntPtr.Zero, e.Message + st.ToString(), "Exception", 0);
            Console.WriteLine("{0}{1}", e.Message, st.ToString());
        }

        internal override void DoEvents()
        {
            MSG msg = new MSG();

            while (GetMessage(ref msg, IntPtr.Zero, 0, 0, false))
            {
                Message m = Message.Create(msg.hwnd, (int)msg.message, msg.wParam, msg.lParam);

                if (Application.FilterMessage(ref m))
                    continue;

                XplatUI.TranslateMessage(ref msg);
                XplatUI.DispatchMessage(ref msg);
            }
        }

        internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags)
        {
            return Win32PeekMessage(ref msg, hWnd, wFilterMin, wFilterMax, flags);
        }

        internal override void PostQuitMessage(int exitCode)
        {
            Win32PostQuitMessage(exitCode);
        }

        internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave)
        {
            if (wm_nc_registered == null)
                wm_nc_registered = new Hashtable();

            TMEFlags flags = TMEFlags.TME_NONCLIENT;
            if (hover)
                flags |= TMEFlags.TME_HOVER;
            if (leave)
                flags |= TMEFlags.TME_LEAVE;

            if (flags == TMEFlags.TME_NONCLIENT)
            {
                if (wm_nc_registered.Contains(hwnd))
                {
                    wm_nc_registered.Remove(hwnd);
                }
            }
            else
            {
                if (!wm_nc_registered.Contains(hwnd))
                {
                    wm_nc_registered.Add(hwnd, flags);
                }
                else
                {
                    wm_nc_registered[hwnd] = flags;
                }
            }
        }

        internal override void RequestNCRecalc(IntPtr handle)
        {
            Win32SetWindowPos(handle, IntPtr.Zero, 0, 0, 0, 0, SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOOWNERZORDER | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE);
        }

        internal override void ResetMouseHover(IntPtr handle)
        {
            TRACKMOUSEEVENT tme;

            tme = new TRACKMOUSEEVENT();
            tme.size = Marshal.SizeOf(tme);
            tme.hWnd = handle;
            tme.dwFlags = TMEFlags.TME_LEAVE | TMEFlags.TME_HOVER;
            Win32TrackMouseEvent(ref tme);
        }


        internal override bool GetMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax)
        {
            return GetMessage(ref msg, hWnd, wFilterMin, wFilterMax, true);
        }

        private bool GetMessage(ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, bool blocking)
        {
            bool result;

            msg.refobject = 0;
            if (RetrieveMessage(ref msg))
            {
                return true;
            }

            if (blocking)
            {
                result = Win32GetMessage(ref msg, hWnd, wFilterMin, wFilterMax);
            }
            else
            {
                result = Win32PeekMessage(ref msg, hWnd, wFilterMin, wFilterMax, (uint)PeekMessageFlags.PM_REMOVE);
                if (!result)
                {
                    return false;
                }
            }

            // We need to fake WM_MOUSE_ENTER
            switch (msg.message)
            {
                case Msg.WM_LBUTTONDOWN:
                    {
                        mouse_state |= MouseButtons.Left;
                        break;
                    }

                case Msg.WM_MBUTTONDOWN:
                    {
                        mouse_state |= MouseButtons.Middle;
                        break;
                    }

                case Msg.WM_RBUTTONDOWN:
                    {
                        mouse_state |= MouseButtons.Right;
                        break;
                    }

                case Msg.WM_LBUTTONUP:
                    {
                        mouse_state &= ~MouseButtons.Left;
                        break;
                    }

                case Msg.WM_MBUTTONUP:
                    {
                        mouse_state &= ~MouseButtons.Middle;
                        break;
                    }

                case Msg.WM_RBUTTONUP:
                    {
                        mouse_state &= ~MouseButtons.Right;
                        break;
                    }

                case Msg.WM_ASYNC_MESSAGE:
                    {
                        XplatUIDriverSupport.ExecuteClientMessage((GCHandle)msg.lParam);
                        break;
                    }

                case Msg.WM_MOUSEMOVE:
                    {
                        if (msg.hwnd != prev_mouse_hwnd)
                        {
                            TRACKMOUSEEVENT tme;

                            mouse_state = Widget.FromParamToMouseButtons((int)msg.lParam.ToInt32());

                            // The current message will be sent out next time around
                            StoreMessage(ref msg);

                            // This is the message we want to send at this point
                            msg.message = Msg.WM_MOUSE_ENTER;

                            prev_mouse_hwnd = msg.hwnd;

                            tme = new TRACKMOUSEEVENT();
                            tme.size = Marshal.SizeOf(tme);
                            tme.hWnd = msg.hwnd;
                            tme.dwFlags = TMEFlags.TME_LEAVE | TMEFlags.TME_HOVER;
                            Win32TrackMouseEvent(ref tme);
                            return result;
                        }
                        break;
                    }

                case Msg.WM_NCMOUSEMOVE:
                    {
                        if (wm_nc_registered == null || !wm_nc_registered.Contains(msg.hwnd))
                            break;

                        mouse_state = Widget.FromParamToMouseButtons((int)msg.lParam.ToInt32());

                        TRACKMOUSEEVENT tme;

                        tme = new TRACKMOUSEEVENT();
                        tme.size = Marshal.SizeOf(tme);
                        tme.hWnd = msg.hwnd;
                        tme.dwFlags = (TMEFlags)wm_nc_registered[msg.hwnd];
                        Win32TrackMouseEvent(ref tme);
                        return result;
                    }

                case Msg.WM_DROPFILES:
                    {
                        return Win32DnD.HandleWMDropFiles(ref msg);
                    }

                case Msg.WM_MOUSELEAVE:
                    {
                        prev_mouse_hwnd = IntPtr.Zero;
                        break;
                    }

                case Msg.WM_TIMER:
                    {
                        Timer timer = (Timer)timer_list[(int)msg.wParam];

                        if (timer != null)
                        {
                            timer.FireTick();
                        }
                        break;
                    }
            }

            return result;
        }

        internal override bool TranslateMessage(ref MSG msg)
        {
            return Win32TranslateMessage(ref msg);
        }

        internal override IntPtr DispatchMessage(ref MSG msg)
        {
            return Win32DispatchMessage(ref msg);
        }

        internal override bool SetZOrder(IntPtr hWnd, IntPtr AfterhWnd, bool Top, bool Bottom)
        {
            if (Top)
            {
                Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_TOP, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE);
                return true;
            }
            else if (!Bottom)
            {
                Win32SetWindowPos(hWnd, AfterhWnd, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE);
            }
            else
            {
                Win32SetWindowPos(hWnd, (IntPtr)SetWindowPosZOrder.HWND_BOTTOM, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE);
                return true;
            }
            return false;
        }

        internal override bool SetTopmost(IntPtr hWnd, bool Enabled)
        {
            if (Enabled)
            {
                Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_TOPMOST, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE);
                return true;
            }
            else
            {
                Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_NOTOPMOST, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE);
                return true;
            }
        }

        internal override bool SetOwner(IntPtr hWnd, IntPtr hWndOwner)
        {
            Win32SetWindowLong(hWnd, WindowLong.GWL_HWNDPARENT, (uint)hWndOwner);
            return true;
        }

        internal override bool Text(IntPtr handle, string text)
        {
            Win32SetWindowText(handle, text);
            return true;
        }

        internal override bool GetText(IntPtr handle, out string text)
        {
            StringBuilder sb;

            sb = new StringBuilder(256);
            Win32GetWindowText(handle, sb, sb.Capacity);
            text = sb.ToString();
            return true;
        }

        internal override bool SetVisible(IntPtr handle, bool visible, bool activate)
        {
            if (visible)
            {
                Widget c = Widget.FromHandle(handle);
                if (c is Form)
                {
                    Form f;

                    f = (Form)Widget.FromHandle(handle);
                    WindowPlacementFlags flags = WindowPlacementFlags.SW_SHOWNORMAL;
                    switch (f.WindowState)
                    {
                        case FormWindowState.Normal: flags = WindowPlacementFlags.SW_SHOWNORMAL; break;
                        case FormWindowState.Minimized: flags = WindowPlacementFlags.SW_MINIMIZE; break;
                        case FormWindowState.Maximized: flags = WindowPlacementFlags.SW_MAXIMIZE; break;
                    }

                    if (!f.ActivateOnShow)
                        flags = WindowPlacementFlags.SW_SHOWNOACTIVATE;

                    Win32ShowWindow(handle, flags);
                }
                else
                {
                    if (c.ActivateOnShow)
                        Win32ShowWindow(handle, WindowPlacementFlags.SW_SHOWNORMAL);
                    else
                        Win32ShowWindow(handle, WindowPlacementFlags.SW_SHOWNOACTIVATE);
                }
            }
            else
            {
                Win32ShowWindow(handle, WindowPlacementFlags.SW_HIDE);
            }
            return true;
        }

        internal override bool IsEnabled(IntPtr handle)
        {
            return IsWindowEnabled(handle);
        }

        internal override bool IsKeyLocked(VirtualKeys key)
        {
            return (Win32GetKeyState(key) & 1) == 1;
        }

        internal override bool IsVisible(IntPtr handle)
        {
            return IsWindowVisible(handle);
        }

        internal override IntPtr SetParent(IntPtr handle, IntPtr parent)
        {
            Widget c = Widget.FromHandle(handle);
            if (parent == IntPtr.Zero)
            {
                if (!(c is Form))
                {
                    Win32ShowWindow(handle, WindowPlacementFlags.SW_HIDE);
                }
            }
            else
            {
                if (!(c is Form))
                {
                    SetVisible(handle, c.is_visible, true);
                }
            }
            // The Win32SetParent is lame, it can very well move the window
            // ref: http://groups.google.com/group/microsoft.public.vb.winapi/browse_thread/thread/1b82ccc54231ecee/afa82835bfc0422a%23afa82835bfc0422a
            // Here we save the position before changing the parent, and if it has changed afterwards restore it.
            // Another possibility would be to intercept WM_WINDOWPOSCHANGING and restore the coords there, but this would require plumbing in weird places
            // (either inside Widget or add handling to InternalWndProc)
            // We also need to remove WS_CHILD if making the window parent-less, and add it if we're parenting it.
            RECT rect, rect2;
            IntPtr result;
            WindowStyles style, new_style;

            Win32GetWindowRect(handle, out rect);
            style = (WindowStyles)Win32GetWindowLong(handle, WindowLong.GWL_STYLE);

            if (parent == IntPtr.Zero)
            {
                new_style = style & ~WindowStyles.WS_CHILD;
                result = Win32SetParent(handle, GetFosterParent());
            }
            else
            {
                new_style = style | WindowStyles.WS_CHILD;
                result = Win32SetParent(handle, parent);
            }
            if (style != new_style && c is Form)
            {
                Win32SetWindowLong(handle, WindowLong.GWL_STYLE, (uint)new_style);
            }
            Win32GetWindowRect(handle, out rect2);
            if (rect.top != rect2.top && rect.left != rect2.left && c is Form)
            {
                Win32SetWindowPos(handle, IntPtr.Zero, rect.top, rect.left, rect.Width, rect.Height, SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOREDRAW | SetWindowPosFlags.SWP_NOOWNERZORDER | SetWindowPosFlags.SWP_NOENDSCHANGING | SetWindowPosFlags.SWP_NOACTIVATE);
            }
            return result;
        }

        // If we ever start using this, we should probably replace FosterParent with IntPtr.Zero
        internal override IntPtr GetParent(IntPtr handle)
        {
            return Win32GetParent(handle);
        }

        // This is a nop on win32 and x11
        internal override IntPtr GetPreviousWindow(IntPtr handle)
        {
            return handle;
        }

        internal override void GrabWindow(IntPtr hWnd, IntPtr ConfineToHwnd)
        {
            grab_hwnd = hWnd;
            Win32SetCapture(hWnd);

            if (ConfineToHwnd != IntPtr.Zero)
            {
                RECT window_rect;
                Win32GetWindowRect(ConfineToHwnd, out window_rect);
                Win32GetClipCursor(out clipped_cursor_rect);
                Win32ClipCursor(ref window_rect);
            }
        }

        internal override void GrabInfo(out IntPtr hWnd, out bool GrabConfined, out Rectangle GrabArea)
        {
            hWnd = grab_hwnd;
            GrabConfined = grab_confined;
            GrabArea = grab_area;
        }

        internal override void UngrabWindow(IntPtr hWnd)
        {
            if (!(clipped_cursor_rect.top == 0 && clipped_cursor_rect.bottom == 0 && clipped_cursor_rect.left == 0 && clipped_cursor_rect.right == 0))
            {
                Win32ClipCursor(ref clipped_cursor_rect);
                clipped_cursor_rect = new RECT();
            }

            Win32ReleaseCapture();
            grab_hwnd = IntPtr.Zero;
        }

        internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect)
        {
            RECT rect;

            rect.left = ClientRect.Left;
            rect.top = ClientRect.Top;
            rect.right = ClientRect.Right;
            rect.bottom = ClientRect.Bottom;

            if (!Win32AdjustWindowRectEx(ref rect, cp.Style, menu != null, cp.ExStyle))
            {
                WindowRect = new Rectangle(ClientRect.Left, ClientRect.Top, ClientRect.Width, ClientRect.Height);
                return false;
            }

            WindowRect = new Rectangle(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
            return true;
        }

        internal override void SetCursor(IntPtr window, IntPtr cursor)
        {
            Win32SetCursor(cursor);
            return;
        }

        internal override void ShowCursor(bool show)
        {
            Win32ShowCursor(show);
        }

        internal override void OverrideCursor(IntPtr cursor)
        {
            Win32SetCursor(cursor);
        }

        internal override IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot)
        {
            IntPtr cursor;
            Bitmap cursor_bitmap;
            Bitmap cursor_mask;
            Byte[] cursor_bits;
            Byte[] mask_bits;
            Color pixel;
            int width;
            int height;

            // Win32 only allows creation cursors of a certain size
            if ((bitmap.Width != Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR)) || (bitmap.Width != Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR)))
            {
                cursor_bitmap = new Bitmap(bitmap, new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR), Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR)));
                cursor_mask = new Bitmap(mask, new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR), Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR)));
            }
            else
            {
                cursor_bitmap = bitmap;
                cursor_mask = mask;
            }

            width = cursor_bitmap.Width;
            height = cursor_bitmap.Height;

            cursor_bits = new Byte[(width / 8) * height];
            mask_bits = new Byte[(width / 8) * height];

            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    pixel = cursor_bitmap.GetPixel(x, y);

                    if (pixel == cursor_pixel)
                    {
                        cursor_bits[y * width / 8 + x / 8] |= (byte)(0x80 >> (x % 8));
                    }

                    pixel = cursor_mask.GetPixel(x, y);

                    if (pixel == mask_pixel)
                    {
                        mask_bits[y * width / 8 + x / 8] |= (byte)(0x80 >> (x % 8));
                    }
                }
            }

            cursor = Win32CreateCursor(IntPtr.Zero, xHotSpot, yHotSpot, width, height, mask_bits, cursor_bits);

            return cursor;
        }

        internal override Bitmap DefineStdCursorBitmap(StdCursor id)
        {
            // We load the cursor, create a bitmap, draw the cursor onto the bitmap and return the bitmap.
            IntPtr cursor = DefineStdCursor(id);
            // Windows only have one possible cursor size!
            int width = Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR);
            int height = Win32GetSystemMetrics(SystemMetrics.SM_CYCURSOR);
            Bitmap bmp = new Bitmap(width, height);
            Graphics gc = Graphics.FromImage(bmp);
            IntPtr hdc = gc.GetHdc();
            Win32DrawIcon(hdc, 0, 0, cursor);
            gc.ReleaseHdc(hdc);
            gc.Dispose();
            return bmp;
        }

        [MonoTODO("Define the missing cursors")]
        internal override IntPtr DefineStdCursor(StdCursor id)
        {
            switch (id)
            {
                case StdCursor.AppStarting: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_APPSTARTING);
                case StdCursor.Arrow: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);
                case StdCursor.Cross: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_CROSS);
                case StdCursor.Default: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);
                case StdCursor.Hand: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_HAND);
                case StdCursor.Help: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_HELP);
                case StdCursor.HSplit: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);       // FIXME
                case StdCursor.IBeam: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_IBEAM);
                case StdCursor.No: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_NO);
                case StdCursor.NoMove2D: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);     // FIXME
                case StdCursor.NoMoveHoriz: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);      // FIXME
                case StdCursor.NoMoveVert: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);       // FIXME
                case StdCursor.PanEast: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);      // FIXME
                case StdCursor.PanNE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);        // FIXME
                case StdCursor.PanNorth: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);     // FIXME
                case StdCursor.PanNW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);        // FIXME
                case StdCursor.PanSE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);        // FIXME
                case StdCursor.PanSouth: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);     // FIXME
                case StdCursor.PanSW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);        // FIXME
                case StdCursor.PanWest: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);      // FIXME
                case StdCursor.SizeAll: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZEALL);
                case StdCursor.SizeNESW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENESW);
                case StdCursor.SizeNS: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENS);
                case StdCursor.SizeNWSE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENWSE);
                case StdCursor.SizeWE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZEWE);
                case StdCursor.UpArrow: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_UPARROW);
                case StdCursor.VSplit: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW);       // FIXME
                case StdCursor.WaitCursor: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_WAIT);
            }
            throw new NotImplementedException();
        }

        internal override void DestroyCursor(IntPtr cursor)
        {
            if ((cursor.ToInt32() < (int)LoadCursorType.First) || (cursor.ToInt32() > (int)LoadCursorType.Last))
            {
                Win32DestroyCursor(cursor);
            }
        }

        [MonoTODO]
        internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y)
        {
            ICONINFO ii = new ICONINFO();

            if (!Win32GetIconInfo(cursor, out ii))
                throw new Win32Exception();

            width = 20;
            height = 20;
            hotspot_x = ii.xHotspot;
            hotspot_y = ii.yHotspot;
        }

        internal override void SetCursorPos(IntPtr handle, int x, int y)
        {
            Win32SetCursorPos(x, y);
        }

        internal override Region GetClipRegion(IntPtr hwnd)
        {
            Region region;

            region = new Region();

            Win32GetWindowRgn(hwnd, region.GetHrgn(Graphics.FromHwnd(hwnd)));

            return region;
        }

        internal override void SetClipRegion(IntPtr hwnd, Region region)
        {
            if (region == null)
                Win32SetWindowRgn(hwnd, IntPtr.Zero, true);
            else
                Win32SetWindowRgn(hwnd, region.GetHrgn(Graphics.FromHwnd(hwnd)), true);
        }

        internal override void EnableWindow(IntPtr handle, bool Enable)
        {
            Win32EnableWindow(handle, Enable);
        }

        internal override void EndLoop(System.Threading.Thread thread)
        {
            // Nothing to do
        }

        internal override object StartLoop(System.Threading.Thread thread)
        {
            return null;
        }

        internal override void SetModal(IntPtr handle, bool Modal)
        {
            // we do nothing on Win32
        }

        internal override void GetCursorPos(IntPtr handle, out int x, out int y)
        {
            POINT pt;

            Win32GetCursorPos(out pt);

            if (handle != IntPtr.Zero)
            {
                Win32ScreenToClient(handle, ref pt);
            }

            x = pt.x;
            y = pt.y;
        }

        internal override void ScreenToClient(IntPtr handle, ref int x, ref int y)
        {
            POINT pnt = new POINT();

            pnt.x = x;
            pnt.y = y;
            Win32ScreenToClient(handle, ref pnt);

            x = pnt.x;
            y = pnt.y;
        }

        internal override void ClientToScreen(IntPtr handle, ref int x, ref int y)
        {
            POINT pnt = new POINT();

            pnt.x = x;
            pnt.y = y;

            Win32ClientToScreen(handle, ref pnt);

            x = pnt.x;
            y = pnt.y;
        }

        internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y)
        {
            RECT rect;

            Win32GetWindowRect(handle, out rect);
            x -= rect.left + SystemInformation.FrameBorderSize.Width;
            y -= rect.top + SystemInformation.FrameBorderSize.Height;

            WindowStyles style = (WindowStyles)Win32GetWindowLong(handle, WindowLong.GWL_STYLE);
            if (CreateParams.IsSet(style, WindowStyles.WS_CAPTION))
            {
                y -= ThemeEngine.Current.CaptionHeight;
            }
        }

        internal override void MenuToScreen(IntPtr handle, ref int x, ref int y)
        {
            RECT rect;

            Win32GetWindowRect(handle, out rect);
            x += rect.left + SystemInformation.FrameBorderSize.Width;
            y += rect.top + SystemInformation.FrameBorderSize.Height + ThemeEngine.Current.CaptionHeight;
            return;
        }

        internal override void SendAsyncMethod(AsyncMethodData method)
        {
            Win32PostMessage(GetFosterParent(), Msg.WM_ASYNC_MESSAGE, IntPtr.Zero, (IntPtr)GCHandle.Alloc(method));
        }

        internal override void SetTimer(Timer timer)
        {
            IntPtr FosterParent = GetFosterParent();
            int index;

            index = timer.GetHashCode();

            lock (timer_list)
            {
                timer_list[index] = timer;
            }

            if (Win32SetTimer(FosterParent, index, (uint)timer.Interval, IntPtr.Zero) != IntPtr.Zero)
                timer.window = FosterParent;
            else
                timer.window = IntPtr.Zero;
        }

        internal override void KillTimer(Timer timer)
        {
            int index;

            index = timer.GetHashCode();

            Win32KillTimer(timer.window, index);

            lock (timer_list)
            {
                timer_list.Remove(index);
            }
        }

        internal override void CreateCaret(IntPtr hwnd, int width, int height)
        {
            Win32CreateCaret(hwnd, IntPtr.Zero, width, height);
            caret_visible = false;
        }

        internal override void DestroyCaret(IntPtr hwnd)
        {
            Win32DestroyCaret();
        }

        internal override void SetCaretPos(IntPtr hwnd, int x, int y)
        {
            Win32SetCaretPos(x, y);
        }

        internal override void CaretVisible(IntPtr hwnd, bool visible)
        {
            if (visible)
            {
                if (!caret_visible)
                {
                    Win32ShowCaret(hwnd);
                    caret_visible = true;
                }
            }
            else
            {
                if (caret_visible)
                {
                    Win32HideCaret(hwnd);
                    caret_visible = false;
                }
            }
        }

        internal override IntPtr GetFocus()
        {
            return Win32GetFocus();
        }

        internal override void SetFocus(IntPtr hwnd)
        {
            Win32SetFocus(hwnd);
        }

        internal override IntPtr GetActive()
        {
            return Win32GetActiveWindow();
        }

        internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent)
        {
            IntPtr dc;
            IntPtr prevobj;
            TEXTMETRIC tm;

            tm = new TEXTMETRIC();

            dc = Win32GetDC(IntPtr.Zero);
            prevobj = Win32SelectObject(dc, font.ToHfont());

            if (Win32GetTextMetrics(dc, ref tm) == false)
            {
                prevobj = Win32SelectObject(dc, prevobj);
                Win32DeleteObject(prevobj);
                Win32ReleaseDC(IntPtr.Zero, dc);
                ascent = 0;
                descent = 0;
                return false;
            }
            prevobj = Win32SelectObject(dc, prevobj);
            Win32DeleteObject(prevobj);
            Win32ReleaseDC(IntPtr.Zero, dc);

            ascent = tm.tmAscent;
            descent = tm.tmDescent;

            return true;
        }

        internal override void ScrollWindow(IntPtr hwnd, Rectangle rectangle, int XAmount, int YAmount, bool with_children)
        {
            RECT rect;

            rect = new RECT();
            rect.left = rectangle.X;
            rect.top = rectangle.Y;
            rect.right = rectangle.Right;
            rect.bottom = rectangle.Bottom;

            Win32ScrollWindowEx(hwnd, XAmount, YAmount, IntPtr.Zero, ref rect, IntPtr.Zero, IntPtr.Zero, ScrollWindowExFlags.SW_INVALIDATE | ScrollWindowExFlags.SW_ERASE | (with_children ? ScrollWindowExFlags.SW_SCROLLCHILDREN : ScrollWindowExFlags.SW_NONE));
            Win32UpdateWindow(hwnd);
        }

        internal override void ScrollWindow(IntPtr hwnd, int XAmount, int YAmount, bool with_children)
        {
            Win32ScrollWindowEx(hwnd, XAmount, YAmount, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, ScrollWindowExFlags.SW_INVALIDATE | ScrollWindowExFlags.SW_ERASE | (with_children ? ScrollWindowExFlags.SW_SCROLLCHILDREN : ScrollWindowExFlags.SW_NONE));
        }

        internal override bool SystrayAdd(IntPtr hwnd, string tip, Icon icon, out ToolTip tt)
        {
            NOTIFYICONDATA nid;

            nid = new NOTIFYICONDATA();

            nid.cbSize = (uint)Marshal.SizeOf(nid);
            nid.hWnd = hwnd;
            nid.uID = 1;
            nid.uCallbackMessage = (uint)Msg.WM_USER;
            nid.uFlags = NotifyIconFlags.NIF_MESSAGE;

            if (tip != null)
            {
                nid.szTip = tip;
                nid.uFlags |= NotifyIconFlags.NIF_TIP;
            }

            if (icon != null)
            {
                nid.hIcon = icon.Handle;
                nid.uFlags |= NotifyIconFlags.NIF_ICON;
            }

            tt = null;

            return Win32Shell_NotifyIcon(NotifyIconMessage.NIM_ADD, ref nid);
        }

        internal override bool SystrayChange(IntPtr hwnd, string tip, Icon icon, ref ToolTip tt)
        {
            NOTIFYICONDATA nid;

            nid = new NOTIFYICONDATA();

            nid.cbSize = (uint)Marshal.SizeOf(nid);
            nid.hIcon = icon.Handle;
            nid.hWnd = hwnd;
            nid.uID = 1;
            nid.uCallbackMessage = (uint)Msg.WM_USER;
            nid.uFlags = NotifyIconFlags.NIF_MESSAGE;

            if (tip != null)
            {
                nid.szTip = tip;
                nid.uFlags |= NotifyIconFlags.NIF_TIP;
            }

            if (icon != null)
            {
                nid.hIcon = icon.Handle;
                nid.uFlags |= NotifyIconFlags.NIF_ICON;
            }

            return Win32Shell_NotifyIcon(NotifyIconMessage.NIM_MODIFY, ref nid);
        }

        internal override void SystrayRemove(IntPtr hwnd, ref ToolTip tt)
        {
            NOTIFYICONDATA nid;

            nid = new NOTIFYICONDATA();

            nid.cbSize = (uint)Marshal.SizeOf(nid);
            nid.hWnd = hwnd;
            nid.uID = 1;
            nid.uFlags = 0;

            Win32Shell_NotifyIcon(NotifyIconMessage.NIM_DELETE, ref nid);
        }

        internal override void SystrayBalloon(IntPtr hwnd, int timeout, string title, string text, ToolTipIcon icon)
        {
            NOTIFYICONDATA nid;

            nid = new NOTIFYICONDATA();

            nid.cbSize = (uint)Marshal.SizeOf(nid);
            nid.hWnd = hwnd;
            nid.uID = 1;
            nid.uFlags = NotifyIconFlags.NIF_INFO;
            nid.uTimeoutOrVersion = timeout;
            nid.szInfoTitle = title;
            nid.szInfo = text;
            nid.dwInfoFlags = icon;

            Win32Shell_NotifyIcon(NotifyIconMessage.NIM_MODIFY, ref nid);
        }

        internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style)
        {
            // Nothing to do on Win32
        }

        internal override void SetMenu(IntPtr handle, Menu menu)
        {
            // Trigger WM_NCCALC
            Win32SetWindowPos(handle, IntPtr.Zero, 0, 0, 0, 0, SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE);
        }

        internal override Point GetMenuOrigin(IntPtr handle)
        {
            Form form = Widget.FromHandle(handle) as Form;

            if (form != null)
            {
                if (form.FormBorderStyle == FormBorderStyle.None)
                    return Point.Empty;

                int bordersize = (form.Width - form.ClientSize.Width) / 2;

                if (form.FormBorderStyle == FormBorderStyle.FixedToolWindow || form.FormBorderStyle == FormBorderStyle.SizableToolWindow)
                    return new Point(bordersize, bordersize + SystemInformation.ToolWindowCaptionHeight);
                else
                    return new Point(bordersize, bordersize + SystemInformation.CaptionHeight);
            }

            return new Point(SystemInformation.FrameBorderSize.Width, SystemInformation.FrameBorderSize.Height + ThemeEngine.Current.CaptionHeight);
        }

        internal override void SetIcon(IntPtr hwnd, Icon icon)
        {
            Win32SendMessage(hwnd, Msg.WM_SETICON, (IntPtr)1, icon == null ? IntPtr.Zero : icon.Handle);    // 1 = large icon (0 would be small)
        }

        internal override void ClipboardClose(IntPtr handle)
        {
            if (handle != clip_magic)
            {
                throw new ArgumentException("handle is not a valid clipboard handle");
            }
            Win32CloseClipboard();
        }

        internal override int ClipboardGetID(IntPtr handle, string format)
        {
            if (handle != clip_magic)
            {
                throw new ArgumentException("handle is not a valid clipboard handle");
            }
            if (format == "Text") return 1;
            else if (format == "Bitmap") return 2;
            else if (format == "MetaFilePict") return 3;
            else if (format == "SymbolicLink") return 4;
            else if (format == "DataInterchangeFormat") return 5;
            else if (format == "Tiff") return 6;
            else if (format == "OEMText") return 7;
            else if (format == "DeviceIndependentBitmap") return 8;
            else if (format == "Palette") return 9;
            else if (format == "PenData") return 10;
            else if (format == "RiffAudio") return 11;
            else if (format == "WaveAudio") return 12;
            else if (format == "UnicodeText") return 13;
            else if (format == "EnhancedMetafile") return 14;
            else if (format == "FileDrop") return 15;
            else if (format == "Locale") return 16;

            return (int)Win32RegisterClipboardFormat(format);
        }

        internal override IntPtr ClipboardOpen(bool primary_selection)
        {
            // Win32 does not have primary selection
            Win32OpenClipboard(GetFosterParent());
            return clip_magic;
        }

        internal override int[] ClipboardAvailableFormats(IntPtr handle)
        {
            uint format;
            int[] result;
            int count;

            if (handle != clip_magic)
            {
                return null;
            }

            // Count first
            count = 0;
            format = 0;
            do
            {
                format = Win32EnumClipboardFormats(format);
                if (format != 0)
                {
                    count++;
                }
            } while (format != 0);

            // Now assign
            result = new int[count];
            count = 0;
            format = 0;
            do
            {
                format = Win32EnumClipboardFormats(format);
                if (format != 0)
                {
                    result[count++] = (int)format;
                }
            } while (format != 0);

            return result;
        }


        internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter)
        {
            IntPtr hmem;
            IntPtr data;
            object obj;

            if (handle != clip_magic)
            {
                throw new ArgumentException("handle is not a valid clipboard handle");
            }

            hmem = Win32GetClipboardData((uint)type);
            if (hmem == IntPtr.Zero)
            {
                return null;
            }

            data = Win32GlobalLock(hmem);
            if (data == IntPtr.Zero)
            {
                uint error = Win32GetLastError();
                Console.WriteLine("Error: {0}", error);
                return null;
            }

            obj = null;

            if (type == DataFormats.GetFormat(DataFormats.Rtf).Id)
            {
                obj = AnsiToString(data);
            }
            else switch ((ClipboardFormats)type)
                {
                    case ClipboardFormats.CF_TEXT:
                        {
                            obj = AnsiToString(data);
                            break;
                        }

                    case ClipboardFormats.CF_DIB:
                        {
                            obj = DIBtoImage(data);
                            break;
                        }

                    case ClipboardFormats.CF_UNICODETEXT:
                        {
                            obj = UnicodeToString(data);
                            break;
                        }

                    default:
                        {
                            if (converter != null && !converter(type, data, out obj))
                            {
                                obj = null;
                            }
                            break;
                        }
                }
            Win32GlobalUnlock(hmem);

            return obj;

        }

        internal override void ClipboardStore(IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter, bool copy)
        {
            byte[] data = null;

            if (handle != clip_magic)
            {
                throw new ArgumentException("handle is not a valid clipboard handle");
            }

            if (obj == null)
            {
                // Just clear it
                if (!Win32EmptyClipboard())
                    throw new ExternalException("Win32EmptyClipboard");
                return;
            }

            if (type == -1)
            {
                if (obj is string)
                {
                    type = (int)ClipboardFormats.CF_UNICODETEXT;
                }
                else if (obj is Image)
                {
                    type = (int)ClipboardFormats.CF_DIB;
                }
            }

            if (type == DataFormats.GetFormat(DataFormats.Rtf).Id)
            {
                data = StringToAnsi((string)obj);
            }
            else switch ((ClipboardFormats)type)
                {
                    case ClipboardFormats.CF_UNICODETEXT:
                        {
                            data = StringToUnicode((string)obj);
                            break;
                        }

                    case ClipboardFormats.CF_TEXT:
                        {
                            data = StringToAnsi((string)obj);
                            break;
                        }

                    case ClipboardFormats.CF_BITMAP:
                    case ClipboardFormats.CF_DIB:
                        {
                            data = ImageToDIB((Image)obj);
                            type = (int)ClipboardFormats.CF_DIB;
                            break;
                        }

                    default:
                        {
                            if (converter != null && !converter(ref type, obj, out data))
                            {
                                data = null; // ensure that a failed conversion leaves null.
                            }
                            break;
                        }
                }
            if (data != null)
            {
                SetClipboardData((uint)type, data);
            }
        }

        internal static byte[] StringToUnicode(string text)
        {
            return Encoding.Unicode.GetBytes(text + "\0");
        }

        internal static byte[] StringToAnsi(string text)
        {
            // FIXME, follow the behaviour of the previous code using UTF-8,
            // but this should be 'ANSI' on Windows, i.e. the current code page.
            // Does Encoding.Default work on Windows?
            return Encoding.UTF8.GetBytes(text + "\0");
        }

        private void SetClipboardData(uint type, byte[] data)
        {
            if (data.Length == 0)
                // Shouldn't call Win32SetClipboard with NULL, as, from MSDN:
                // "This parameter can be NULL, indicating that the window provides data 
                //  in the specified clipboard format (renders the format) upon request."
                // and I don't think we support that...
                // Note this is unrelated to the fact that passing a null obj to 
                // ClipboardStore is actually a request to empty the clipboard!
                return;
            IntPtr hmem = CopyToMoveableMemory(data);
            if (hmem == IntPtr.Zero)
                // As above, should not call with null.
                // (Not that CopyToMoveableMemory should ever return null!)
                throw new ExternalException("CopyToMoveableMemory failed.");
            if (Win32SetClipboardData(type, hmem) == IntPtr.Zero)
                throw new ExternalException("Win32SetClipboardData");
        }

        /// <summary>
        /// Creates a memory block with GlobalAlloc(GMEM_MOVEABLE), copies the data 
        /// into it, and returns the handle to the memory.
        /// </summary>
        /// -
        /// <param name="data">The data.  Must not be null or zero-length &#x2014; 
        /// see the exception notes.</param>
        /// -
        /// <returns>The *handle* to the allocated GMEM_MOVEABLE block.</returns>
        /// -
        /// <exception cref="T:System.ArgumentException">The data was null or zero 
        /// length.  This is disallowed since a zero length allocation can't be made
        /// </exception>
        /// <exception cref="T:System.ComponentModel.Win32Exception">The allocation, 
        /// or locking (handle->pointer) failed.
        /// Either out of memory or the handle table is full (256 max currently).
        /// Note Win32Exception is a subclass of ExternalException so this is OK in 
        /// the documented Clipboard interface.
        /// </exception>
        internal static IntPtr CopyToMoveableMemory(byte[] data)
        {
            if (data == null || data.Length == 0)
                // detect this before GlobalAlloc does.
                throw new ArgumentException("Can't create a zero length memory block.");

            IntPtr hmem = Win32GlobalAlloc(GAllocFlags.GMEM_MOVEABLE | GAllocFlags.GMEM_DDESHARE, data.Length);
            if (hmem == IntPtr.Zero)
                throw new Win32Exception();
            IntPtr hmem_ptr = Win32GlobalLock(hmem);
            if (hmem_ptr == IntPtr.Zero) // If the allocation was valid this shouldn't occur.
                throw new Win32Exception();
            Marshal.Copy(data, 0, hmem_ptr, data.Length);
            Win32GlobalUnlock(hmem);
            return hmem;
        }


        internal override void SetAllowDrop(IntPtr hwnd, bool allowed)
        {
            if (allowed)
            {
                Win32DnD.RegisterDropTarget(hwnd);
            }
            else
            {
                Win32DnD.UnregisterDropTarget(hwnd);
            }
        }

        internal override DragDropEffects StartDrag(IntPtr hwnd, object data, DragDropEffects allowedEffects)
        {
            return Win32DnD.StartDrag(hwnd, data, allowedEffects);
        }

        // XXX this doesn't work at all for FrameStyle.Dashed - it draws like Thick, and in the Thick case
        // the corners are drawn incorrectly.
        internal override void DrawReversibleFrame(Rectangle rectangle, Color backColor, FrameStyle style)
        {
            IntPtr hdc;
            IntPtr pen;
            IntPtr oldpen;
            COLORREF clrRef = new COLORREF();

            // If we want the standard hatch pattern we would
            // need to create a brush

            clrRef.R = backColor.R;
            clrRef.G = backColor.G;
            clrRef.B = backColor.B;

            // Grab a pen
            pen = Win32CreatePen(style == FrameStyle.Thick ? PenStyle.PS_SOLID : PenStyle.PS_DASH,
                          style == FrameStyle.Thick ? 4 : 2, ref clrRef);

            hdc = Win32GetDC(IntPtr.Zero);
            Win32SetROP2(hdc, ROP2DrawMode.R2_NOT);
            oldpen = Win32SelectObject(hdc, pen);

            Win32MoveToEx(hdc, rectangle.Left, rectangle.Top, IntPtr.Zero);
            if ((rectangle.Width > 0) && (rectangle.Height > 0))
            {
                Win32LineTo(hdc, rectangle.Right, rectangle.Top);
                Win32LineTo(hdc, rectangle.Right, rectangle.Bottom);
                Win32LineTo(hdc, rectangle.Left, rectangle.Bottom);
                Win32LineTo(hdc, rectangle.Left, rectangle.Top);
            }
            else
            {
                if (rectangle.Width > 0)
                {
                    Win32LineTo(hdc, rectangle.Right, rectangle.Top);
                }
                else
                {
                    Win32LineTo(hdc, rectangle.Left, rectangle.Bottom);
                }
            }

            Win32SelectObject(hdc, oldpen);
            Win32DeleteObject(pen);

            Win32ReleaseDC(IntPtr.Zero, hdc);
        }

        internal override void DrawReversibleLine(Point start, Point end, Color backColor)
        {
            IntPtr hdc;
            IntPtr pen;
            IntPtr oldpen;
            POINT pt;
            COLORREF clrRef = new COLORREF();

            pt = new POINT();
            pt.x = 0;
            pt.y = 0;
            Win32ClientToScreen(IntPtr.Zero, ref pt);

            // If we want the standard hatch pattern we would
            // need to create a brush

            clrRef.R = backColor.R;
            clrRef.G = backColor.G;
            clrRef.B = backColor.B;

            // Grab a pen
            pen = Win32CreatePen(PenStyle.PS_SOLID, 1, ref clrRef);

            hdc = Win32GetDC(IntPtr.Zero);
            Win32SetROP2(hdc, ROP2DrawMode.R2_NOT);
            oldpen = Win32SelectObject(hdc, pen);

            Win32MoveToEx(hdc, pt.x + start.X, pt.y + start.Y, IntPtr.Zero);
            Win32LineTo(hdc, pt.x + end.X, pt.y + end.Y);

            Win32SelectObject(hdc, oldpen);
            Win32DeleteObject(pen);

            Win32ReleaseDC(IntPtr.Zero, hdc);
        }

        internal override void FillReversibleRectangle(Rectangle rectangle, Color backColor)
        {
            RECT rect;

            rect = new RECT();
            rect.left = rectangle.Left;
            rect.top = rectangle.Top;
            rect.right = rectangle.Right;
            rect.bottom = rectangle.Bottom;

            IntPtr hdc;
            IntPtr brush;
            IntPtr oldbrush;
            COLORREF clrRef = new COLORREF();

            clrRef.R = backColor.R;
            clrRef.G = backColor.G;
            clrRef.B = backColor.B;

            // Grab a brush
            brush = Win32CreateSolidBrush(clrRef);

            hdc = Win32GetDC(IntPtr.Zero);
            oldbrush = Win32SelectObject(hdc, brush);

            Win32PatBlt(hdc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height, PatBltRop.DSTINVERT);

            Win32SelectObject(hdc, oldbrush);
            Win32DeleteObject(brush);

            Win32ReleaseDC(IntPtr.Zero, hdc);
        }

        internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width)
        {
            IntPtr hdc;
            IntPtr pen;
            IntPtr oldpen;
            POINT pt;

            pt = new POINT();
            pt.x = 0;
            pt.y = 0;
            Win32ClientToScreen(handle, ref pt);

            // If we want the standard hatch pattern we would
            // need to create a brush

            // Grab a pen
            pen = Win32CreatePen(PenStyle.PS_SOLID, line_width, IntPtr.Zero);

            hdc = Win32GetDC(IntPtr.Zero);
            Win32SetROP2(hdc, ROP2DrawMode.R2_NOT);
            oldpen = Win32SelectObject(hdc, pen);

            Widget c = Widget.FromHandle(handle);
            if (c != null)
            {
                RECT window_rect;
                Win32GetWindowRect(c.Handle, out window_rect);
                Region r = new Region(new Rectangle(window_rect.left, window_rect.top, window_rect.right - window_rect.left, window_rect.bottom - window_rect.top));
                Win32ExtSelectClipRgn(hdc, r.GetHrgn(Graphics.FromHdc(hdc)), (int)ClipCombineMode.RGN_AND);
            }

            Win32MoveToEx(hdc, pt.x + rect.Left, pt.y + rect.Top, IntPtr.Zero);
            if ((rect.Width > 0) && (rect.Height > 0))
            {
                Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Top);
                Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Bottom);
                Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Bottom);
                Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Top);
            }
            else
            {
                if (rect.Width > 0)
                {
                    Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Top);
                }
                else
                {
                    Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Bottom);
                }
            }

            Win32SelectObject(hdc, oldpen);
            Win32DeleteObject(pen);
            if (c != null)
                Win32ExtSelectClipRgn(hdc, IntPtr.Zero, (int)ClipCombineMode.RGN_COPY);

            Win32ReleaseDC(IntPtr.Zero, hdc);
        }

        internal override SizeF GetAutoScaleSize(Font font)
        {
            Graphics g;
            float width;
            string magic_string = "The quick brown fox jumped over the lazy dog.";
            double magic_number = 44.549996948242189;

            g = Graphics.FromHwnd(GetFosterParent());

            width = (float)(g.MeasureString(magic_string, font).Width / magic_number);
            return new SizeF(width, font.Height);
        }

        internal override IntPtr SendMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam)
        {
            return Win32SendMessage(hwnd, message, wParam, lParam);
        }

        internal override bool PostMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam)
        {
            return Win32PostMessage(hwnd, message, wParam, lParam);
        }

        internal override int SendInput(IntPtr hwnd, Queue keys)
        {
            INPUT[] inputs = new INPUT[keys.Count];
            const Int32 INPUT_KEYBOARD = 1;
            uint returns = 0;
            int i = 0;
            while (keys.Count > 0)
            {
                MSG msg = (MSG)keys.Dequeue();


                inputs[i].ki.wScan = 0;
                inputs[i].ki.time = 0;
                inputs[i].ki.dwFlags = (Int32)(msg.message == Msg.WM_KEYUP ? InputFlags.KEYEVENTF_KEYUP : 0);
                inputs[i].ki.wVk = (short)msg.wParam.ToInt32();
                inputs[i].type = INPUT_KEYBOARD;
                i++;
            }
            returns = Win32SendInput((UInt32)inputs.Length, inputs, Marshal.SizeOf(typeof(INPUT)));

            return (int)returns;
        }

        internal override int KeyboardSpeed
        {
            get
            {
                int speed = 0;
                Win32SystemParametersInfo(SPIAction.SPI_GETKEYBOARDSPEED, 0, ref speed, 0);
                //
                // Return values range from 0 to 31 which map to 2.5 to 30 repetitions per second.
                //
                return speed;
            }
        }

        internal override int KeyboardDelay
        {
            get
            {
                int delay = 1;
                Win32SystemParametersInfo(SPIAction.SPI_GETKEYBOARDDELAY, 0, ref delay, 0);
                //
                // Return values must range from 0 to 4, 0 meaning 250ms,
                // and 4 meaning 1000 ms.
                //
                return delay;
            }
        }

        private class WinBuffer
        {
            public IntPtr hdc;
            public IntPtr bitmap;

            public WinBuffer(IntPtr hdc, IntPtr bitmap)
            {
                this.hdc = hdc;
                this.bitmap = bitmap;
            }
        }

        internal override void CreateOffscreenDrawable(IntPtr handle, int width, int height, out object offscreen_drawable)
        {
            Graphics destG = Graphics.FromHwnd(handle);
            IntPtr destHdc = destG.GetHdc();

            IntPtr srcHdc = Win32CreateCompatibleDC(destHdc);
            IntPtr srcBmp = Win32CreateCompatibleBitmap(destHdc, width, height);
            Win32SelectObject(srcHdc, srcBmp);

            offscreen_drawable = new WinBuffer(srcHdc, srcBmp);

            destG.ReleaseHdc(destHdc);
        }

        internal override Graphics GetOffscreenGraphics(object offscreen_drawable)
        {
            return Graphics.FromHdc(((WinBuffer)offscreen_drawable).hdc);
        }

        internal override void BlitFromOffscreen(IntPtr dest_handle, Graphics dest_dc, object offscreen_drawable, Graphics offscreen_dc, Rectangle r)
        {
            WinBuffer wb = (WinBuffer)offscreen_drawable;

            IntPtr destHdc = dest_dc.GetHdc();
            Win32BitBlt(destHdc, r.Left, r.Top, r.Width, r.Height, wb.hdc, r.Left, r.Top, TernaryRasterOperations.SRCCOPY);
            dest_dc.ReleaseHdc(destHdc);
        }

        internal override void DestroyOffscreenDrawable(object offscreen_drawable)
        {
            WinBuffer wb = (WinBuffer)offscreen_drawable;

            Win32DeleteObject(wb.bitmap);
            Win32DeleteDC(wb.hdc);
        }

        internal override void SetForegroundWindow(IntPtr handle)
        {
            Win32SetForegroundWindow(handle);
        }

        internal override event EventHandler Idle;
#endregion    // Public Static Methods
        
    }
}
#endregion
#endif