// napWritten by Christopher E. Miller
// See the included license.txt for copyright and license details.

module dfl.base;

import core.sys.windows.windows;
import core.sys.windows.winuser;
//import core.sys.wndows.winerror;

import core.stdc.stdlib : alloca;
import core.stdc..string : strcpy;

import dfl.internal.dlib;
static import dfl.internal.utf;
import dfl.internal.clib;

// FIX: import dfl.internal.winapi;
import dfl.drawing;
import dfl.event;
import dfl.exception;

alias HWindow = HWND;

interface IWindow {
   @property HWindow handle();
}

alias IWin32Window = IWindow; // deprecated

alias DflThrowable = DThrowable;

class StringObject : DObject {
   Dstring value;
   this(Dstring str) pure nothrow {
      this.value = str;
   }

   override Dstring toString() {
      return value;
   }

   override Dequ opEquals(Object o) {
      return value == getObjectString(o); // ?
   }

   Dequ opEquals(StringObject s) {
      return value == s.value;
   }

   override int opCmp(Object o) {
      return stringICmp(value, getObjectString(o)); // ?
   }

   int opCmp(StringObject s) {
      return stringICmp(value, s.value);
   }
}

enum Keys : uint {
   NONE = 0, /// No keys specified.

   SHIFT = 0x10000, /// Modifier keys.
   CONTROL = 0x20000,
   ALT = 0x40000,
   WINDOWS = 0x80000,

   A = 'A', /// Letters.
   B = 'B',
   C = 'C',
   D = 'D',
   E = 'E',
   F = 'F',
   G = 'G',
   H = 'H',
   I = 'I',
   J = 'J',
   K = 'K',
   L = 'L',
   M = 'M',
   N = 'N',
   O = 'O',
   P = 'P',
   Q = 'Q',
   R = 'R',
   S = 'S',
   T = 'T',
   U = 'U',
   V = 'V',
   W = 'W',
   X = 'X',
   Y = 'Y',
   Z = 'Z',

   D0 = '0', /// Digits.
   D1 = '1',
   D2 = '2',
   D3 = '3',
   D4 = '4',
   D5 = '5',
   D6 = '6',
   D7 = '7',
   D8 = '8',
   D9 = '9',

   F1 = 112, /// F - function keys.
   F2 = 113,
   F3 = 114,
   F4 = 115,
   F5 = 116,
   F6 = 117,
   F7 = 118,
   F8 = 119,
   F9 = 120,
   F10 = 121,
   F11 = 122,
   F12 = 123,
   F13 = 124,
   F14 = 125,
   F15 = 126,
   F16 = 127,
   F17 = 128,
   F18 = 129,
   F19 = 130,
   F20 = 131,
   F21 = 132,
   F22 = 133,
   F23 = 134,
   F24 = 135,

   NUM_PAD0 = 96, /// Numbers on keypad.
   NUM_PAD1 = 97,
   NUM_PAD2 = 98,
   NUM_PAD3 = 99,
   NUM_PAD4 = 100,
   NUM_PAD5 = 101,
   NUM_PAD6 = 102,
   NUM_PAD7 = 103,
   NUM_PAD8 = 104,
   NUM_PAD9 = 105,

   ADD = 107,
   APPS = 93, /// Application.
   ATTN = 246,
   BACK = 8, /// Backspace.
   CANCEL = 3,
   CAPITAL = 20,
   CAPS_LOCK = 20,
   CLEAR = 12,
   CONTROL_KEY = 17,
   CRSEL = 247,
   DECIMAL = 110,
   DEL = 46,
   DELETE = DEL,
   PERIOD = 190,
   DOT = PERIOD,
   DIVIDE = 111,
   DOWN = 40, /// Down arrow.
   END = 35,
   ENTER = 13,
   ERASE_EOF = 249,
   ESCAPE = 27,
   EXECUTE = 43,
   EXSEL = 248,
   FINAL_MODE = 4, /// IME final mode.
   HANGUL_MODE = 21, /// IME Hangul mode.
   HANGUEL_MODE = 21,
   HANJA_MODE = 25, /// IME Hanja mode.
   HELP = 47,
   HOME = 36,
   IME_ACCEPT = 30,
   IME_CONVERT = 28,
   IME_MODE_CHANGE = 31,
   IME_NONCONVERT = 29,
   INSERT = 45,
   JUNJA_MODE = 23,
   KANA_MODE = 21,
   KANJI_MODE = 25,
   LEFT_CONTROL = 162, /// Left Ctrl.
   LEFT = 37, /// Left arrow.
   LINE_FEED = 10,
   LEFT_MENU = 164, /// Left Alt.
   LEFT_SHIFT = 160,
   LEFT_WIN = 91, /// Left Windows logo.
   MENU = 18, /// Alt.
   MULTIPLY = 106,
   NEXT = 34, /// Page down.
   NO_NAME = 252, // Reserved for future use.
   NUM_LOCK = 144,
   OEM8 = 223, // OEM specific.
   OEM_CLEAR = 254,
   PA1 = 253,
   PAGE_DOWN = 34,
   PAGE_UP = 33,
   PAUSE = 19,
   PLAY = 250,
   PRINT = 42,
   PRINT_SCREEN = 44,
   PROCESS_KEY = 229,
   RIGHT_CONTROL = 163, /// Right Ctrl.
   RETURN = 13,
   RIGHT = 39, /// Right arrow.
   RIGHT_MENU = 165, /// Right Alt.
   RIGHT_SHIFT = 161,
   RIGHT_WIN = 92, /// Right Windows logo.
   SCROLL = 145, /// Scroll lock.
   SELECT = 41,
   SEPARATOR = 108,
   SHIFT_KEY = 16,
   SNAPSHOT = 44, /// Print screen.
   SPACE = 32,
   SPACEBAR = SPACE, // Extra.
   SUBTRACT = 109,
   TAB = 9,
   UP = 38, /// Up arrow.
   ZOOM = 251,

   // Windows 2000+
   BROWSER_BACK = 166,
   BROWSER_FAVORITES = 171,
   BROWSER_FORWARD = 167,
   BROWSER_HOME = 172,
   BROWSER_REFRESH = 168,
   BROWSER_SEARCH = 170,
   BROWSER_STOP = 169,
   LAUNCH_APPLICATION1 = 182,
   LAUNCH_APPLICATION2 = 183,
   LAUNCH_MAIL = 180,
   MEDIA_NEXT_TRACK = 176,
   MEDIA_PLAY_PAUSE = 179,
   MEDIA_PREVIOUS_TRACK = 177,
   MEDIA_STOP = 178,
   OEM_BACKSLASH = 226, // OEM angle bracket or backslash.
   OEM_CLOSE_BRACKETS = 221,
   OEM_COMMA = 188,
   OEM_MINUS = 189,
   OEM_OPEN_BRACKETS = 219,
   OEM_PERIOD = 190,
   OEM_PIPE = 220,
   OEM_PLUS = 187,
   OEM_QUESTION = 191,
   OEM_QUOTES = 222,
   OEM_SEMICOLON = 186,
   OEM_TILDE = 192,
   SELECT_MEDIA = 181,
   VOLUME_DOWN = 174,
   VOLUME_MUTE = 173,
   VOLUME_UP = 175,

   /// Bit mask to extract key code from key value.
   KEY_CODE = 0xFFFF,

   /// Bit mask to extract modifiers from key value.
   MODIFIERS = 0xFFFF0000,
}

enum MouseButtons : uint {
   /// No mouse buttons specified.
   NONE = 0,

   LEFT = 0x100000,
   RIGHT = 0x200000,
   MIDDLE = 0x400000,// Windows 2000+
   //XBUTTON1 =  0x800000,
   //XBUTTON2 =  0x1000000,
}

enum CheckState : ubyte {
   UNCHECKED = BST_UNCHECKED,
   CHECKED = BST_CHECKED,
   INDETERMINATE = BST_INDETERMINATE,
}

struct Message {
   union {
      struct {
         HWND hWnd;
         UINT msg;
         WPARAM wParam;
         LPARAM lParam;
      }

      package MSG _winMsg; // .time and .pt are not always valid.
   }

   LRESULT result;

   /// Construct a Message struct.
   this(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) pure nothrow {
      this.hWnd = hWnd;
      this.msg = msg;
      this.wParam = wParam;
      this.lParam = lParam;
      result = 0;
   }
}

interface IMessageFilter {
   // Return false to allow the message to be dispatched.
   // Filter functions cannot modify messages.
   bool preFilterMessage(ref Message m);
}

abstract class WaitHandle {
   // FIX: enum WAIT_TIMEOUT = WAIT_TIMEOUT; // DMD 1.028: needs fqn, otherwise conflicts with std.thread
   enum INVALID_HANDLE = INVALID_HANDLE_VALUE;

   this() {
      h = INVALID_HANDLE;
   }

   // Used internally.
   this(HANDLE h, bool owned = true) {
      this.h = h;
      this.owned = owned;
   }

   @property HANDLE handle() nothrow {
      return h;
   }

   @property void handle(HANDLE h) {
      this.h = h;
   }

   void close() {
      CloseHandle(h);
      h = INVALID_HANDLE;
   }

   ~this() {
      if (owned) {
         close();
      }
   }

   private static DWORD _wait(WaitHandle[] handles, BOOL waitall, DWORD msTimeout) {
      DWORD result;
      HANDLE* hs;
      // Some implementations fail with > 64 handles, but that will return WAIT_FAILED;
      // all implementations fail with >= 128 handles due to WAIT_ABANDONED_0 being 128.
      if (handles.length >= 128) {
         goto fail;
      }

      //hs = new HANDLE[handles.length];
      hs = cast(HANDLE*) alloca(HANDLE.sizeof * handles.length);

      foreach (size_t i, WaitHandle wh; handles) {
         hs[i] = wh.handle;
      }

      result = WaitForMultipleObjects(handles.length, hs, waitall, msTimeout);
      if (WAIT_FAILED == result) {
      fail:
         throw new DflException("Wait failure");
      }
      return result;
   }

   static void waitAll(WaitHandle[] handles) {
      return waitAll(handles, INFINITE);
   }

   static void waitAll(WaitHandle[] handles, DWORD msTimeout) {
      _wait(handles, true, msTimeout);
   }

   static int waitAny(WaitHandle[] handles) {
      return waitAny(handles, INFINITE);
   }

   static int waitAny(WaitHandle[] handles, DWORD msTimeout) {
      DWORD result;
      result = _wait(handles, false, msTimeout);
      return cast(int) result; // Same return info.
   }

   void waitOne() {
      return waitOne(INFINITE);
   }

   void waitOne(DWORD msTimeout) {
      DWORD result;
      result = WaitForSingleObject(handle, msTimeout);
      if (WAIT_FAILED == result) {
         throw new DflException("Wait failure");
      }
   }

   private HANDLE h;
   private bool owned = true;
}

interface IAsyncResult {
   @property WaitHandle asyncWaitHandle();

   // Usually just returns false.
   @property bool completedSynchronously();

   // When true, it is safe to release its resources.
   @property bool isCompleted();
}

/+
class AsyncResult: IAsyncResult {
}
+/

interface IButtonControl {
   @property DialogResult dialogResult();

   @property void dialogResult(DialogResult);

   void notifyDefault(bool); // True if default button.
   void performClick(); // Raise click event.
}

enum DialogResult : ubyte {
   NONE,

   ABORT = IDABORT,
   CANCEL = IDCANCEL,
   IGNORE = IDIGNORE,
   NO = IDNO,
   OK = IDOK,
   RETRY = IDRETRY,
   YES = IDYES,

   // Extra.
   CLOSE = IDCLOSE,
   HELP = IDHELP,
}

interface IDialogResult {
   //
   @property DialogResult dialogResult();
   //
   @property void dialogResult(DialogResult);
}

enum SortOrder : ubyte {
   NONE,

   ASCENDING,
   DESCENDING,
}

enum View : ubyte {
   LARGE_ICON,
   SMALL_ICON,
   LIST,
   DETAILS,
}

enum ItemBoundsPortion : ubyte {
   ENTIRE,
   ICON,
   ITEM_ONLY, /// Excludes other stuff like check boxes.
   LABEL, /// Item's text.
}

enum ItemActivation : ubyte {
   STANDARD,
   ONE_CLICK,
   TWO_CLICK,
}

enum ColumnHeaderStyle : ubyte {
   CLICKABLE,
   NONCLICKABLE,
   NONE, /// No column header.
}

enum BorderStyle : ubyte {
   NONE,

   FIXED_3D,
   FIXED_SINGLE,
}

enum FlatStyle : ubyte {
   STANDARD,
   FLAT,
   POPUP,
   SYSTEM,
}

enum Appearance : ubyte {
   NORMAL,
   BUTTON,
}

enum ContentAlignment : ubyte {
   TOP_LEFT,
   BOTTOM_CENTER,
   BOTTOM_LEFT,
   BOTTOM_RIGHT,
   MIDDLE_CENTER,
   MIDDLE_LEFT,
   MIDDLE_RIGHT,
   TOP_CENTER,
   TOP_RIGHT,
}

enum CharacterCasing : ubyte {
   NORMAL,
   LOWER,
   UPPER,
}

// Not flags.
enum ScrollBars : ubyte {
   NONE,

   HORIZONTAL,
   VERTICAL,
   BOTH,
}

enum HorizontalAlignment : ubyte {
   LEFT,
   RIGHT,
   CENTER,
}

enum DrawMode : ubyte {
   NORMAL,
   OWNER_DRAW_FIXED,
   OWNER_DRAW_VARIABLE,
}

enum DrawItemState : uint {
   NONE = 0,
   SELECTED = 1,
   DISABLED = 2,
   CHECKED = 8,
   FOCUS = 0x10,
   DEFAULT = 0x20,
   HOT_LIGHT = 0x40,
   NO_ACCELERATOR = 0x80,
   INACTIVE = 0x100,
   NO_FOCUS_RECT = 0x200,
   COMBO_BOX_EDIT = 0x1000,
}

enum RightToLeft : ubyte {
   INHERIT = 2,
   YES = 1,
   NO = 0,
}

enum ColorDepth : ubyte {
   DEPTH_4BIT = 0x04,
   DEPTH_8BIT = 0x08,
   DEPTH_16BIT = 0x10,
   DEPTH_24BIT = 0x18,
   DEPTH_32BIT = 0x20,
}

class PaintEventArgs : EventArgs {

   this(Graphics graphics, Rect clipRect) pure nothrow {
      g = graphics;
      cr = clipRect;
   }

   final @property Graphics graphics() pure nothrow {
      return g;
   }

   final @property Rect clipRectangle() pure nothrow {
      return cr;
   }

private:
   Graphics g;
   Rect cr;
}

class CancelEventArgs : EventArgs {

   // Initialize cancel to false.
   this() pure nothrow {
      cncl = false;
   }

   this(bool cancel) pure nothrow {
      cncl = cancel;
   }

   final @property void cancel(bool byes) pure nothrow {
      cncl = byes;
   }

   final @property bool cancel() pure nothrow {
      return cncl;
   }

private:
   bool cncl;
}

class SizingEventArgs : EventArgs {

   // Initialize cancel to false.
   this(Size sz) pure nothrow {
      _sz = sz;
   }

   @property Size size() pure nothrow {
      return _sz;
   }

   @property void size(Size sz) pure nothrow {
      _sz = sz;
   }

   @property void width(int w) pure nothrow {
      _sz.width = w;
   }

   @property int width() pure nothrow {
      return _sz.width;
   }

   @property void height(int h) pure nothrow {
      _sz.height = h;
   }

   @property int height() pure nothrow {
      return _sz.height;
   }

private:
   Size _sz;
}

class MovingEventArgs : EventArgs {

   // Initialize cancel to false.
   this(Point loc) pure nothrow {
      _loc = loc;
   }

   @property Point location() pure nothrow {
      return _loc;
   }

   @property void location(Point loc) pure nothrow {
      _loc = loc;
   }

   @property void x(int posX) pure nothrow {
      _loc.x = posX;
   }

   @property int x() pure nothrow {
      return _loc.x;
   }

   @property void y(int posY) pure nothrow {
      _loc.y = posY;
   }

   @property int y() pure nothrow {
      return _loc.y;
   }

private:
   Point _loc;
}

class KeyEventArgs : EventArgs {

   this(Keys keys) pure nothrow {
      ks = keys;
   }

   final @property bool alt() pure nothrow {
      return (ks & Keys.ALT) != 0;
   }

   final @property bool control() pure nothrow {
      return (ks & Keys.CONTROL) != 0;
   }

   final @property void handled(bool byes) pure nothrow {
      hand = byes;
   }

   final @property bool handled() pure nothrow {
      return hand;
   }

   final @property Keys keyCode() pure nothrow {
      return ks & Keys.KEY_CODE;
   }

   final @property Keys keyData() pure nothrow {
      return ks;
   }

   // -keyData- as an int.
   final @property int keyValue() pure nothrow {
      return cast(int) ks;
   }

   final @property Keys modifiers() pure nothrow {
      return ks & Keys.MODIFIERS;
   }

   final @property bool shift() pure nothrow {
      return (ks & Keys.SHIFT) != 0;
   }

   final @property bool windows() pure nothrow {
      return (ks & Keys.WINDOWS) != 0;
   }

private:
   Keys ks;
   bool hand = false;
}

class KeyPressEventArgs : KeyEventArgs {
   private dchar _keych;
   this(dchar ch) {
      this(ch, (ch >= 'A' && ch <= 'Z') ? Keys.SHIFT : Keys.NONE);
   }

   this(dchar ch, Keys modifiers)
   in {
      assert((modifiers & Keys.MODIFIERS) == modifiers,
         "modifiers parameter can only contain modifiers");
   }
   body {
      _keych = ch;

      int vk;
      if (dfl.internal.utf.useUnicode) {
         vk = 0xFF & VkKeyScanW(cast(WCHAR) ch);
      } else {
         vk = 0xFF & VkKeyScanA(cast(char) ch);
      }

      super(cast(Keys)(vk | modifiers));
   }

   final @property dchar keyChar() {
      return _keych;
   }
}

class MouseEventArgs : EventArgs {
   private MouseButtons btn;
   private int clks;
   private int _x, _y;
   private int dlt;
   // -delta- is mouse wheel rotations.
   this(MouseButtons button, int clicks, int x, int y, int delta) pure nothrow {
      btn = button;
      clks = clicks;
      _x = x;
      _y = y;
      dlt = delta;
   }

   final @property MouseButtons button() pure nothrow {
      return btn;
   }

   final @property int clicks() pure nothrow {
      return clks;
   }

   final @property int delta() pure nothrow {
      return dlt;
   }

   final @property int x() pure nothrow {
      return _x;
   }

   final @property int y() pure nothrow {
      return _y;
   }
}

/+

class LabelEditEventArgs: EventArgs {

   this(int index) {

   }


   this(int index, Dstring labelText) {
      this.idx = index;
      this.ltxt = labelText;
   }



   final @property void cancelEdit(bool byes) {
      cancl = byes;
   }


   final @property bool cancelEdit() {
      return cancl;
   }



   // The text of the label's edit.
   final @property Dstring label() {
      return ltxt;
   }



   // Gets the item's index.
   final @property int item() {
      return idx;
   }


   private:
   int idx;
   Dstring ltxt;
   bool cancl = false;
}
+/

class ColumnClickEventArgs : EventArgs {

   private int col;
   this(int col) pure nothrow {
      this.col = col;
   }

   final @property int column() pure nothrow {
      return col;
   }
}

class DrawItemEventArgs : EventArgs {
   private Graphics gpx;
   private Font fnt; // Suggestion; the parent's font.
   private Rect rect;
   private int idx;
   private DrawItemState distate;
   private Color fcolor, bcolor; // Suggestion; depends on item state.
   this(Graphics g, Font f, Rect r, int i, DrawItemState dis) pure nothrow {
      this(g, f, r, i, dis, Color.empty, Color.empty);
   }

   this(Graphics g, Font f, Rect r, int i, DrawItemState dis, Color fc, Color bc) pure nothrow {
      gpx = g;
      fnt = f;
      rect = r;
      idx = i;
      distate = dis;
      fcolor = fc;
      bcolor = bc;
   }

   final @property Color backColor() pure nothrow {
      return bcolor;
   }

   final @property Rect bounds() pure nothrow {
      return rect;
   }

   final @property Font font() pure nothrow {
      return fnt;
   }

   final @property Color foreColor() pure nothrow {
      return fcolor;
   }

   final @property Graphics graphics() pure nothrow {
      return gpx;
   }

   final @property int index() pure nothrow {
      return idx;
   }

   final @property DrawItemState state() pure nothrow {
      return distate;
   }

   void drawBackground() {
      /+
         HBRUSH hbr;
      RECT _rect;

      hbr = bcolor.createBrush();
      try {
         rect.getRect(&_rect);
         FillRect(gpx.handle, &_rect, hbr);
      }
      finally {
         DeleteObject(hbr);
      }
      +/

      gpx.fillRectangle(bcolor, rect);
   }

   void drawFocusRectangle() {
      if (distate & DrawItemState.FOCUS) {
         RECT _rect;
         rect.getRect(&_rect);
         DrawFocusRect(gpx.handle, &_rect);
      }
   }
}

class MeasureItemEventArgs : EventArgs {

   this(Graphics g, int index, int itemHeight) {
      gpx = g;
      idx = index;
      iheight = itemHeight;
   }

   this(Graphics g, int index) {
      this(g, index, 0);
   }

   final @property Graphics graphics() {
      return gpx;
   }

   final @property int index() {
      return idx;
   }

   final @property void itemHeight(int height) {
      iheight = height;
   }

   final @property int itemHeight() {
      return iheight;
   }

   final @property void itemWidth(int width) {
      iwidth = width;
   }

   final @property int itemWidth() {
      return iwidth;
   }

private:
   Graphics gpx;
   int idx, iheight, iwidth = 0;
}

class Cursor {
   private static Cursor _cur;

   // Used internally.
   this(HCURSOR hcur, bool owned = true) {
      this.hcur = hcur;
      this.owned = owned;
   }

   ~this() {
      if (owned) {
         dispose();
      }
   }

   void dispose() {
      assert(owned);
      DestroyCursor(hcur);
      hcur = HCURSOR.init;
   }

   static @property void current(Cursor cur) {
      // Keep a reference so that it doesn't get garbage collected until set again.
      _cur = cur;

      SetCursor(cur ? cur.hcur : HCURSOR.init);
   }

   static @property Cursor current() {
      HCURSOR hcur = GetCursor();
      return hcur ? new Cursor(hcur, false) : null;
   }

   static @property void clip(Rect r) {
      RECT rect;
      r.getRect(&rect);
      ClipCursor(&rect);
   }

   static @property Rect clip() {
      RECT rect;
      GetClipCursor(&rect);
      return Rect(&rect);
   }

   final @property HCURSOR handle() {
      return hcur;
   }

   /+
      // TODO:
      final @property Size size() {
         Size result;
         ICONINFO iinfo;

         if(GetIconInfo(hcur, &iinfo)) {

         }

         return result;
      }
   +/

   // Uses the actual size.
   final void draw(Graphics g, Point pt) {
      DrawIconEx(g.handle, pt.x, pt.y, hcur, 0, 0, 0, HBRUSH.init, DI_NORMAL);
   }

   /+

      // Should not stretch if bigger, but should crop if smaller.
      final void draw(Graphics g, Rect r) {
      }
   +/

   final void drawStretched(Graphics g, Rect r) {
      // DrawIconEx operates differently if the width or height is zero
      // so bail out if zero and pretend the zero size cursor was drawn.
      int width = r.width;
      if (!width) {
         return;
      }
      int height = r.height;
      if (!height) {
         return;
      }

      DrawIconEx(g.handle, r.x, r.y, hcur, width, height, 0, HBRUSH.init, DI_NORMAL);
   }

   override Dequ opEquals(Object o) {
      Cursor cur = cast(Cursor) o;
      if (!cur) {
         return 0; // Not equal.
      }
      return opEquals(cur);
   }

   Dequ opEquals(Cursor cur) {
      return hcur == cur.hcur;
   }

   /// Show/hide the current mouse cursor; reference counted.
   // show/hide are ref counted.
   static void hide() {
      ShowCursor(false);
   }

   // show/hide are ref counted.
   static void show() {
      ShowCursor(true);
   }

   /// The position of the current mouse cursor.
   static @property void position(Point pt) {
      SetCursorPos(pt.x, pt.y);
   }

   static @property Point position() {
      Point pt;
      GetCursorPos(&pt.point);
      return pt;
   }

private:
   HCURSOR hcur;
   bool owned = true;
}

class Cursors {
   private this() {
   }

   static {

      @property Cursor appStarting() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_APPSTARTING), false);
      }

      @property Cursor arrow() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_ARROW), false);
      }

      @property Cursor cross() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_CROSS), false);
      }

      //@property Cursor default()
      @property Cursor defaultCursor() {
         return arrow;
      }

      @property Cursor hand() {
         version (SUPPORTS_HAND_CURSOR) { // Windows 98+
            return new Cursor(LoadCursor(HINSTANCE.init, IDC_HAND), false);
         } else {
            static HCURSOR hcurHand;

            if (!hcurHand) {
               hcurHand = LoadCursor(HINSTANCE.init, IDC_HAND);
               if (!hcurHand) { // Must be Windows 95, so load the cursor from winhlp32.exe.
                  UINT len;
                  char[MAX_PATH] winhlppath = void;

                  len = GetWindowsDirectoryA(winhlppath.ptr, winhlppath.length - 16);
                  if (!len || len > winhlppath.length - 16) {
                  load_failed:
                     return arrow; // Just fall back to a normal arrow.
                  }
                  strcpy(winhlppath.ptr + len, "\\winhlp32.exe");

                  HINSTANCE hinstWinhlp;
                  hinstWinhlp = LoadLibraryExA(winhlppath.ptr, HANDLE.init,
                     LOAD_LIBRARY_AS_DATAFILE);
                  if (!hinstWinhlp) {
                     goto load_failed;
                  }

                  HCURSOR hcur;
                  hcur = LoadCursorA(hinstWinhlp, cast(char*) 106);
                  if (!hcur) { // No such cursor resource.
                     FreeLibrary(hinstWinhlp);
                     goto load_failed;
                  }
                  hcurHand = CopyCursor(hcur);
                  if (!hcurHand) {
                     FreeLibrary(hinstWinhlp);
                     //throw new DflException("Unable to copy cursor resource");
                     goto load_failed;
                  }

                  FreeLibrary(hinstWinhlp);
               }
            }

            assert(hcurHand);
            // Copy the cursor and own it here so that it's safe to dispose it.
            return new Cursor(CopyCursor(hcurHand));
         }
      }

      @property Cursor help() {
         HCURSOR hcur;
         hcur = LoadCursor(HINSTANCE.init, IDC_HELP);
         if (!hcur) { // IDC_HELP might not be supported on Windows 95, so fall back to a normal arrow.
            return arrow;
         }
         return new Cursor(hcur);
      }

      @property Cursor hSplit() {
         // ...
         return sizeNS;
      }

      @property Cursor vSplit() {
         // ...
         return sizeWE;
      }

      @property Cursor iBeam() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_IBEAM), false);
      }

      @property Cursor no() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_NO), false);
      }

      @property Cursor sizeAll() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_SIZEALL), false);
      }

      @property Cursor sizeNESW() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_SIZENESW), false);
      }

      @property Cursor sizeNS() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_SIZENS), false);
      }

      @property Cursor sizeNWSE() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_SIZENWSE), false);
      }

      @property Cursor sizeWE() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_SIZEWE), false);
      }

      /*

      // Insertion point.
      @property Cursor upArrow() {
      }
       */

      @property Cursor waitCursor() {
         return new Cursor(LoadCursor(HINSTANCE.init, IDC_WAIT), false);
      }
   }
}