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

module dfl.listbox;

import std.algorithm;
import core.sys.windows.windows;

import dfl.exception;
import dfl.application;
import dfl.base;
import dfl.collections;
import dfl.control;
import dfl.drawing;
import dfl.event;
import dfl.internal.dlib;


private extern (C) void* memmove(void*, void*, size_t len);

private extern (Windows) void _initListbox();

alias ListString = StringObject;

abstract class ListControl : ControlSuperClass {

   final Dstring getItemText(Object item) {
      return getObjectString(item);
   }

   //EventHandler selectedValueChanged;
   Event!(ListControl, EventArgs) selectedValueChanged;

   abstract @property void selectedIndex(int idx);

   abstract @property int selectedIndex();

   abstract @property void selectedValue(Object val);

   abstract @property void selectedValue(Dstring str);

   abstract @property Object selectedValue();

   static @property Color defaultBackColor() {
      return SystemColors.window;
   }

   override @property Color backColor() {
      if (Color.empty == backc) {
         return defaultBackColor;
      }
      return backc;
   }

   alias backColor = Control.backColor; // Overload.

   static @property Color defaultForeColor() {
      return SystemColors.windowText;
   }

   override @property Color foreColor() {
      if (Color.empty == forec) {
         return defaultForeColor;
      }
      return forec;
   }

   alias foreColor = Control.foreColor; // Overload.

   this() {
   }

protected:

   void onSelectedValueChanged(EventArgs ea) {
      selectedValueChanged(this, ea);
   }

   // Index change causes the value to be changed.
   void onSelectedIndexChanged(EventArgs ea) {
      onSelectedValueChanged(ea); // This appears to be correct.
   }
}

enum SelectionMode : ubyte {
   ONE,
   NONE,
   MULTI_SIMPLE,
   MULTI_EXTENDED,
}

class ListBox : ListControl {

   static class SelectedIndexCollection {
      deprecated alias count = length;

      @property int length() {
         if (!lbox.isHandleCreated) {
            return 0;
         }

         if (lbox.isMultSel()) {
            return lbox.prevwproc(LB_GETSELCOUNT, 0, 0);
         } else {
            return (lbox.selectedIndex == -1) ? 0 : 1;
         }
      }

      int opIndex(int idx) {
         foreach (int onidx; this) {
            if (!idx) {
               return onidx;
            }
            idx--;
         }

         // If it's not found it's out of bounds and bad things happen.
         assert(0);
      }

      bool contains(int idx) {
         return indexOf(idx) != -1;
      }

      int indexOf(int idx) {
         int i = 0;
         foreach (int onidx; this) {
            if (onidx == idx) {
               return i;
            }
            i++;
         }
         return -1;
      }

      int opApply(int delegate(ref int) dg) {
         int result = 0;

         if (lbox.isMultSel()) {
            int[] items;
            items = new int[length];
            if (items.length != lbox.prevwproc(LB_GETSELITEMS, items.length,
                  cast(LPARAM) cast(int*) items)) {
               throw new DflException("Unable to enumerate selected list items");
            }
            foreach (int _idx; items) {
               int idx = _idx; // Prevent ref.
               result = dg(idx);
               if (result) {
                  break;
               }
            }
         } else {
            int idx;
            idx = lbox.selectedIndex;
            if (-1 != idx) {
               result = dg(idx);
            }
         }
         return result;
      }

      mixin OpApplyAddIndex!(opApply, int);

      protected this(ListBox lb) {
         lbox = lb;
      }

   package:
      ListBox lbox;
   }

   static class SelectedObjectCollection {
      deprecated alias count = length;

      @property int length() {
         if (!lbox.isHandleCreated) {
            return 0;
         }

         if (lbox.isMultSel()) {
            return lbox.prevwproc(LB_GETSELCOUNT, 0, 0);
         } else {
            return (lbox.selectedIndex == -1) ? 0 : 1;
         }
      }

      Object opIndex(int idx) {
         foreach (Object obj; this) {
            if (!idx) {
               return obj;
            }
            idx--;
         }

         // If it's not found it's out of bounds and bad things happen.
         assert(0);
      }

      bool contains(Object obj) {
         return indexOf(obj) != -1;
      }

      bool contains(Dstring str) {
         return indexOf(str) != -1;
      }

      int indexOf(Object obj) {
         int idx = 0;
         foreach (Object onobj; this) {
            if (onobj == obj) { // Not using is.
               return idx;
            }
            idx++;
         }
         return -1;
      }

      int indexOf(Dstring str) {
         int idx = 0;
         foreach (Object onobj; this) {
            //if(getObjectString(onobj) is str && getObjectString(onobj).length == str.length)
            if (getObjectString(onobj) == str) {
               return idx;
            }
            idx++;
         }
         return -1;
      }

      // Used internally.
      int _opApply(int delegate(ref Object) dg) { // package
         int result = 0;

         if (lbox.isMultSel()) {
            int[] items;
            items = new int[length];
            if (items.length != lbox.prevwproc(LB_GETSELITEMS, items.length,
                  cast(LPARAM) cast(int*) items)) {
               throw new DflException("Unable to enumerate selected list items");
            }
            foreach (int idx; items) {
               Object obj;
               obj = lbox.items[idx];
               result = dg(obj);
               if (result) {
                  break;
               }
            }
         } else {
            Object obj;
            obj = lbox.selectedItem;
            if (obj) {
               result = dg(obj);
            }
         }
         return result;
      }

      // Used internally.
      int _opApply(int delegate(ref Dstring) dg) { // package
         int result = 0;

         if (lbox.isMultSel()) {
            int[] items;
            items = new int[length];
            if (items.length != lbox.prevwproc(LB_GETSELITEMS, items.length,
                  cast(LPARAM) cast(int*) items)) {
               throw new DflException("Unable to enumerate selected list items");
            }
            foreach (int idx; items) {
               Dstring str;
               str = getObjectString(lbox.items[idx]);
               result = dg(str);
               if (result) {
                  break;
               }
            }
         } else {
            Object obj;
            Dstring str;
            obj = lbox.selectedItem;
            if (obj) {
               str = getObjectString(obj);
               result = dg(str);
            }
         }
         return result;
      }

      mixin OpApplyAddIndex!(_opApply, Dstring);

      mixin OpApplyAddIndex!(_opApply, Object);

      // Had to do it this way because: DMD 1.028: -H is broken for mixin identifiers
      // Note that this way probably prevents opApply from being overridden.
      alias opApply = _opApply;

      protected this(ListBox lb) {
         lbox = lb;
      }

   package:
      ListBox lbox;
   }

   enum int DEFAULT_ITEM_HEIGHT = 13;

   enum int NO_MATCHES = LB_ERR;

   protected override @property Size defaultSize() {
      return Size(120, 95);
   }

   @property void borderStyle(BorderStyle bs) {
      final switch (bs) {
      case BorderStyle.FIXED_3D:
         _style(_style() & ~WS_BORDER);
         _exStyle(_exStyle() | WS_EX_CLIENTEDGE);
         break;

      case BorderStyle.FIXED_SINGLE:
         _exStyle(_exStyle() & ~WS_EX_CLIENTEDGE);
         _style(_style() | WS_BORDER);
         break;

      case BorderStyle.NONE:
         _style(_style() & ~WS_BORDER);
         _exStyle(_exStyle() & ~WS_EX_CLIENTEDGE);
         break;
      }

      if (isHandleCreated) {
         redrawEntire();
      }
   }

   @property BorderStyle borderStyle() {
      if (_exStyle() & WS_EX_CLIENTEDGE) {
         return BorderStyle.FIXED_3D;
      } else if (_style() & WS_BORDER) {
         return BorderStyle.FIXED_SINGLE;
      }
      return BorderStyle.NONE;
   }

   @property void drawMode(DrawMode dm) {
      LONG wl = _style() & ~(LBS_OWNERDRAWVARIABLE | LBS_OWNERDRAWFIXED);

      final switch (dm) {
      case DrawMode.OWNER_DRAW_VARIABLE:
         wl |= LBS_OWNERDRAWVARIABLE;
         break;

      case DrawMode.OWNER_DRAW_FIXED:
         wl |= LBS_OWNERDRAWFIXED;
         break;

      case DrawMode.NORMAL:
         break;
      }

      _style(wl);

      _crecreate();
   }

   @property DrawMode drawMode() {
      LONG wl = _style();

      if (wl & LBS_OWNERDRAWVARIABLE) {
         return DrawMode.OWNER_DRAW_VARIABLE;
      }
      if (wl & LBS_OWNERDRAWFIXED) {
         return DrawMode.OWNER_DRAW_FIXED;
      }
      return DrawMode.NORMAL;
   }

   final @property void horizontalExtent(int he) {
      if (isHandleCreated) {
         prevwproc(LB_SETHORIZONTALEXTENT, he, 0);
      }

      hextent = he;
   }

   final @property int horizontalExtent() {
      if (isHandleCreated) {
         hextent = cast(int) prevwproc(LB_GETHORIZONTALEXTENT, 0, 0);
      }
      return hextent;
   }

   final @property void horizontalScrollbar(bool byes) {
      if (byes) {
         _style(_style() | WS_HSCROLL);
      } else {
         _style(_style() & ~WS_HSCROLL);
      }

      _crecreate();
   }

   final @property bool horizontalScrollbar() {
      return (_style() & WS_HSCROLL) != 0;
   }

   final @property void integralHeight(bool byes) {
      if (byes) {
         _style(_style() & ~LBS_NOINTEGRALHEIGHT);
      } else {
         _style(_style() | LBS_NOINTEGRALHEIGHT);
      }

      _crecreate();
   }

   final @property bool integralHeight() {
      return (_style() & LBS_NOINTEGRALHEIGHT) == 0;
   }

   // This function has no effect if the drawMode is OWNER_DRAW_VARIABLE.
   final @property void itemHeight(int h) {
      if (drawMode == DrawMode.OWNER_DRAW_VARIABLE) {
         return;
      }

      iheight = h;

      if (isHandleCreated) {
         prevwproc(LB_SETITEMHEIGHT, 0, MAKELPARAM(h, 0));
      }
   }

   // Return value is meaningless when drawMode is OWNER_DRAW_VARIABLE.
   final @property int itemHeight() {
      // Requesting it like this when owner draw variable doesn't work.
      /+
      if(!isHandleCreated) {
         return iheight;
      }

      int result = prevwproc(LB_GETITEMHEIGHT, 0, 0);
      if(result == LB_ERR) {
         result = iheight;   // ?
      } else {
         iheight = result;
      }

      return result;
      +/

      return iheight;
   }

   final @property ObjectCollection items() {
      return icollection;
   }

   final @property void multiColumn(bool byes) {
      // TODO: is this the correct implementation?

      if (byes) {
         _style(_style() | LBS_MULTICOLUMN | WS_HSCROLL);
      } else {
         _style(_style() & ~(LBS_MULTICOLUMN | WS_HSCROLL));
      }

      _crecreate();
   }

   final @property bool multiColumn() {
      return (_style() & LBS_MULTICOLUMN) != 0;
   }

   final @property void scrollAlwaysVisible(bool byes) {
      if (byes) {
         _style(_style() | LBS_DISABLENOSCROLL);
      } else {
         _style(_style() & ~LBS_DISABLENOSCROLL);
      }

      _crecreate();
   }

   final @property bool scrollAlwaysVisible() {
      return (_style() & LBS_DISABLENOSCROLL) != 0;
   }

   override @property void selectedIndex(int idx) {
      if (isHandleCreated) {
         if (isMultSel()) {
            if (idx == -1) {
               // Remove all selection.

               // Not working right.
               //prevwproc(LB_SELITEMRANGE, false, MAKELPARAM(0, ushort.max));

               // Get the indices directly because deselecting them during
               // selidxcollection.foreach could screw it up.

               int[] items;

               items = new int[selidxcollection.length];
               if (items.length != prevwproc(LB_GETSELITEMS, items.length,
                     cast(LPARAM) cast(int*) items)) {
                  throw new DflException("Unable to clear selected list items");
               }

               foreach (int _idx; items) {
                  prevwproc(LB_SETSEL, false, _idx);
               }
            } else {
               // ?
               prevwproc(LB_SETSEL, true, idx);
            }
         } else {
            prevwproc(LB_SETCURSEL, idx, 0);
         }
      }
   }

   override @property int selectedIndex() {
      if (isHandleCreated) {
         if (isMultSel()) {
            if (selidxcollection.length) {
               return selidxcollection[0];
            }
         } else {
            LRESULT result;
            result = prevwproc(LB_GETCURSEL, 0, 0);
            if (LB_ERR != result) { // Redundant.
               return cast(int) result;
            }
         }
      }
      return -1;
   }

   final @property void selectedItem(Object o) {
      int i;
      i = items.indexOf(o);
      if (i != -1) {
         selectedIndex = i;
      }
   }

   final @property void selectedItem(Dstring str) {
      int i;
      i = items.indexOf(str);
      if (i != -1) {
         selectedIndex = i;
      }
   }

   final @property Object selectedItem() {
      int idx;
      idx = selectedIndex;
      if (idx == -1) {
         return null;
      }
      return items[idx];
   }

   override @property void selectedValue(Object val) {
      selectedItem = val;
   }

   override @property void selectedValue(Dstring str) {
      selectedItem = str;
   }

   override @property Object selectedValue() {
      return selectedItem;
   }

   final @property SelectedIndexCollection selectedIndices() {
      return selidxcollection;
   }

   final @property SelectedObjectCollection selectedItems() {
      return selobjcollection;
   }

   @property void selectionMode(SelectionMode selmode) {
      LONG wl = _style() & ~(LBS_NOSEL | LBS_EXTENDEDSEL | LBS_MULTIPLESEL);

      final switch (selmode) {
      case SelectionMode.ONE:
         break;

      case SelectionMode.MULTI_SIMPLE:
         wl |= LBS_MULTIPLESEL;
         break;

      case SelectionMode.MULTI_EXTENDED:
         wl |= LBS_EXTENDEDSEL;
         break;

      case SelectionMode.NONE:
         wl |= LBS_NOSEL;
         break;
      }

      _style(wl);

      _crecreate();
   }

   @property SelectionMode selectionMode() {
      LONG wl = _style();

      if (wl & LBS_NOSEL) {
         return SelectionMode.NONE;
      }
      if (wl & LBS_EXTENDEDSEL) {
         return SelectionMode.MULTI_EXTENDED;
      }
      if (wl & LBS_MULTIPLESEL) {
         return SelectionMode.MULTI_SIMPLE;
      }
      return SelectionMode.ONE;
   }

   final @property void sorted(bool byes) {
      /+
      if(byes) {
         _style(_style() | LBS_SORT);
      } else {
         _style(_style() & ~LBS_SORT);
      }
      +/
      _sorting = byes;
   }

   final @property bool sorted() {
      //return (_style() & LBS_SORT) != 0;
      return _sorting;
   }

   final @property void topIndex(int idx) {
      if (isHandleCreated) {
         prevwproc(LB_SETTOPINDEX, idx, 0);
      }
   }

   final @property int topIndex() {
      if (isHandleCreated) {
         return prevwproc(LB_GETTOPINDEX, 0, 0);
      }
      return 0;
   }

   final @property void useTabStops(bool byes) {
      if (byes) {
         _style(_style() | LBS_USETABSTOPS);
      } else {
         _style(_style() & ~LBS_USETABSTOPS);
      }

      _crecreate();
   }

   final @property bool useTabStops() {
      return (_style() & LBS_USETABSTOPS) != 0;
   }

   final void beginUpdate() {
      prevwproc(WM_SETREDRAW, false, 0);
   }

   final void endUpdate() {
      prevwproc(WM_SETREDRAW, true, 0);
      invalidate(true); // Show updates.
   }

   package final bool isMultSel() {
      return (_style() & (LBS_EXTENDEDSEL | LBS_MULTIPLESEL)) != 0;
   }

   final void clearSelected() {
      if (created) {
         selectedIndex = -1;
      }
   }

   final int findString(Dstring str, int startIndex) {
      // TODO: find string if control not created ?

      int result = NO_MATCHES;

      if (created) {
         if (dfl.internal.utf.useUnicode) {
            result = prevwproc(LB_FINDSTRING, startIndex,
               cast(LPARAM) dfl.internal.utf.toUnicodez(str));
         } else {
            result = prevwproc(LB_FINDSTRING, startIndex,
               cast(LPARAM) dfl.internal.utf.unsafeAnsiz(str));
         }
         if (result == LB_ERR) { // Redundant.
            result = NO_MATCHES;
         }
      }

      return result;
   }

   final int findString(Dstring str) {
      return findString(str, -1); // Start at beginning.
   }

   final int findStringExact(Dstring str, int startIndex) {
      // TODO: find string if control not created ?

      int result = NO_MATCHES;

      if (created) {
         if (dfl.internal.utf.useUnicode) {
            result = prevwproc(LB_FINDSTRINGEXACT, startIndex,
               cast(LPARAM) dfl.internal.utf.toUnicodez(str));
         } else {
            result = prevwproc(LB_FINDSTRINGEXACT, startIndex,
               cast(LPARAM) dfl.internal.utf.unsafeAnsiz(str));
         }
         if (result == LB_ERR) { // Redundant.
            result = NO_MATCHES;
         }
      }

      return result;
   }

   final int findStringExact(Dstring str) {
      return findStringExact(str, -1); // Start at beginning.
   }

   final int getItemHeight(int idx) {
      int result = prevwproc(LB_GETITEMHEIGHT, idx, 0);
      if (LB_ERR == result) {
         throw new DflException("Unable to obtain item height");
      }
      return result;
   }

   final Rect getItemRectangle(int idx) {
      RECT rect;
      if (LB_ERR == prevwproc(LB_GETITEMRECT, idx, cast(LPARAM)&rect)) {
         //if(idx >= 0 && idx < items.length)
         return Rect(0, 0, 0, 0); // ?
         //throw new DflException("Unable to obtain item rectangle");
      }
      return Rect(&rect);
   }

   final bool getSelected(int idx) {
      return prevwproc(LB_GETSEL, idx, 0) > 0;
   }

   final int indexFromPoint(int x, int y) {
      // LB_ITEMFROMPOINT is "nearest", so also check with the item rectangle to
      // see if the point is directly in the item.

      // Maybe use LBItemFromPt() from common controls.

      int result = NO_MATCHES;

      if (created) {
         result = prevwproc(LB_ITEMFROMPOINT, 0, MAKELPARAM(x, y));
         if (!HIWORD(result)) { // In client area
            //result = LOWORD(result); // High word already 0.
            if (result < 0 || !getItemRectangle(result).contains(x, y)) {
               result = NO_MATCHES;
            }
         } else { // Outside client area.
            result = NO_MATCHES;
         }
      }

      return result;
   }

   final int indexFromPoint(Point pt) {
      return indexFromPoint(pt.x, pt.y);
   }

   final void setSelected(int idx, bool byes) {
      if (created) {
         prevwproc(LB_SETSEL, byes, idx);
      }
   }

   protected ObjectCollection createItemCollection() {
      return new ObjectCollection(this);
   }

   void sort() {
      if (icollection._items.length) {
         Object[] itemscopy;
         itemscopy = icollection._items.dup;
         std.algorithm.sort(itemscopy);

         items.clear();

         beginUpdate();
         scope (exit)
            endUpdate();

         foreach (int i, Object o; itemscopy) {
            items.insert(i, o);
         }
      }
   }

   static class ObjectCollection {
      protected this(ListBox lbox) {
         this.lbox = lbox;
      }

      protected this(ListBox lbox, Object[] range) {
         this.lbox = lbox;
         addRange(range);
      }

      protected this(ListBox lbox, Dstring[] range) {
         this.lbox = lbox;
         addRange(range);
      }

      /+
      protected this(ListBox lbox, ObjectCollection range) {
         this.lbox = lbox;
         addRange(range);
      }
      +/

      void add(Object value) {
         add2(value);
      }

      void add(Dstring value) {
         add(new ListString(value));
      }

      void addRange(Object[] range) {
         if (lbox.sorted) {
            foreach (Object value; range) {
               add(value);
            }
         } else {
            _wraparray.addRange(range);
         }
      }

      void addRange(Dstring[] range) {
         foreach (Dstring value; range) {
            add(value);
         }
      }

   private:

      ListBox lbox;
      Object[] _items;

      LRESULT insert2(WPARAM idx, Dstring val) {
         insert(idx, val);
         return idx;
      }

      LRESULT add2(Object val) {
         int i;
         if (lbox.sorted) {
            for (i = 0; i != _items.length; i++) {
               if (val < _items[i]) {
                  break;
               }
            }
         } else {
            i = _items.length;
         }

         insert(i, val);

         return i;
      }

      LRESULT add2(Dstring val) {
         return add2(new ListString(val));
      }

      void _added(size_t idx, Object val) {
         if (lbox.created) {
            if (dfl.internal.utf.useUnicode) {
               lbox.prevwproc(LB_INSERTSTRING, idx,
                  cast(LPARAM) dfl.internal.utf.toUnicodez(getObjectString(val)));
            } else {
               lbox.prevwproc(LB_INSERTSTRING, idx,
                  cast(LPARAM) dfl.internal.utf.toAnsiz(getObjectString(val))); // Can this be unsafeAnsiz()?
            }
         }
      }

      void _removed(size_t idx, Object val) {
         if (size_t.max == idx) { // Clear all.
            if (lbox.created) {
               lbox.prevwproc(LB_RESETCONTENT, 0, 0);
            }
         } else {
            if (lbox.created) {
               lbox.prevwproc(LB_DELETESTRING, cast(WPARAM) idx, 0);
            }
         }
      }

   public:

      mixin ListWrapArray!(Object, _items, _blankListCallback!(Object),
         _added, _blankListCallback!(Object), _removed, true, false, false) _wraparray;
   }

   this() {
      _initListbox();

      // Default useTabStops and vertical scrolling.
      wstyle |= WS_TABSTOP | LBS_USETABSTOPS | LBS_HASSTRINGS | WS_VSCROLL | LBS_NOTIFY;
      wexstyle |= WS_EX_CLIENTEDGE;
      ctrlStyle |= ControlStyles.SELECTABLE;
      wclassStyle = listboxClassStyle;

      icollection = createItemCollection();
      selidxcollection = new SelectedIndexCollection(this);
      selobjcollection = new SelectedObjectCollection(this);
   }

   protected override void onHandleCreated(EventArgs ea) {
      super.onHandleCreated(ea);

      // Set the Ctrl ID to the HWND so that it is unique
      // and WM_MEASUREITEM will work properly.
      SetWindowLongA(hwnd, GWL_ID, cast(LONG) hwnd);

      if (hextent != 0) {
         prevwproc(LB_SETHORIZONTALEXTENT, hextent, 0);
      }

      if (iheight != DEFAULT_ITEM_HEIGHT) {
         prevwproc(LB_SETITEMHEIGHT, 0, MAKELPARAM(iheight, 0));
      }

      Message m;
      m.hWnd = handle;
      m.msg = LB_INSERTSTRING;
      // Note: duplicate code.
      if (dfl.internal.utf.useUnicode) {
         foreach (int i, Object obj; icollection._items) {
            m.wParam = i;
            m.lParam = cast(LPARAM) dfl.internal.utf.toUnicodez(getObjectString(obj)); // <--

            prevWndProc(m);
            //if(LB_ERR == m.result || LB_ERRSPACE == m.result)
            if (m.result < 0) {
               throw new DflException("Unable to add list item");
            }

            //prevwproc(LB_SETITEMDATA, m.result, cast(LPARAM)cast(void*)obj);
         }
      } else {
         foreach (int i, Object obj; icollection._items) {
            m.wParam = i;
            m.lParam = cast(LPARAM) dfl.internal.utf.toAnsiz(getObjectString(obj)); // Can this be unsafeAnsiz? // <--

            prevWndProc(m);
            //if(LB_ERR == m.result || LB_ERRSPACE == m.result)
            if (m.result < 0) {
               throw new DflException("Unable to add list item");
            }

            //prevwproc(LB_SETITEMDATA, m.result, cast(LPARAM)cast(void*)obj);
         }
      }

      //redrawEntire();
   }

   /+
   override void createHandle() {
      if(isHandleCreated) {
         return;
      }

      createClassHandle(LISTBOX_CLASSNAME);

      onHandleCreated(EventArgs.empty);
   }
   +/

   protected override void createParams(ref CreateParams cp) {
      super.createParams(cp);

      cp.className = LISTBOX_CLASSNAME;
   }

   //DrawItemEventHandler drawItem;
   Event!(ListBox, DrawItemEventArgs) drawItem;
   //MeasureItemEventHandler measureItem;
   Event!(ListBox, MeasureItemEventArgs) measureItem;

protected:

   void onDrawItem(DrawItemEventArgs dieh) {
      drawItem(this, dieh);
   }

   void onMeasureItem(MeasureItemEventArgs miea) {
      measureItem(this, miea);
   }

   package final void _WmDrawItem(DRAWITEMSTRUCT* dis)
   in {
      assert(dis.hwndItem == handle);
      assert(dis.CtlType == ODT_LISTBOX);
   }
   body {
      DrawItemState state;
      state = cast(DrawItemState) dis.itemState;

      if (dis.itemID == -1) {
         FillRect(dis.hDC, &dis.rcItem, hbrBg);
         if (state & DrawItemState.FOCUS) {
            DrawFocusRect(dis.hDC, &dis.rcItem);
         }
      } else {
         DrawItemEventArgs diea;
         Color bc, fc;

         if (state & DrawItemState.SELECTED) {
            bc = Color.systemColor(COLOR_HIGHLIGHT);
            fc = Color.systemColor(COLOR_HIGHLIGHTTEXT);
         } else {
            bc = backColor;
            fc = foreColor;
         }

         prepareDc(dis.hDC);
         diea = new DrawItemEventArgs(new Graphics(dis.hDC, false), wfont,
            Rect(&dis.rcItem), dis.itemID, state, fc, bc);

         onDrawItem(diea);
      }
   }

   package final void _WmMeasureItem(MEASUREITEMSTRUCT* mis)
   in {
      assert(mis.CtlType == ODT_LISTBOX);
   }
   body {
      MeasureItemEventArgs miea;
      scope Graphics gpx = new CommonGraphics(handle(), GetDC(handle));
      miea = new MeasureItemEventArgs(gpx, mis.itemID, /+ mis.itemHeight +/ iheight);
      miea.itemWidth = mis.itemWidth;

      onMeasureItem(miea);

      mis.itemHeight = miea.itemHeight;
      mis.itemWidth = miea.itemWidth;
   }

   override void prevWndProc(ref Message msg) {
      //msg.result = CallWindowProcA(listboxPrevWndProc, msg.hWnd, msg.msg, msg.wParam, msg.lParam);
      msg.result = dfl.internal.utf.callWindowProc(listboxPrevWndProc, msg.hWnd,
         msg.msg, msg.wParam, msg.lParam);
   }

   protected override void onReflectedMessage(ref Message m) {
      super.onReflectedMessage(m);

      switch (m.msg) {
      case WM_DRAWITEM:
         _WmDrawItem(cast(DRAWITEMSTRUCT*) m.lParam);
         m.result = 1;
         break;

      case WM_MEASUREITEM:
         _WmMeasureItem(cast(MEASUREITEMSTRUCT*) m.lParam);
         m.result = 1;
         break;

      case WM_COMMAND:
         assert(cast(HWND) m.lParam == handle);
         switch (HIWORD(m.wParam)) {
         case LBN_SELCHANGE:
            onSelectedIndexChanged(EventArgs.empty);
            break;

         case LBN_SELCANCEL:
            onSelectedIndexChanged(EventArgs.empty);
            break;

         default:
         }
         break;

      default:
      }
   }

   override void wndProc(ref Message msg) {
      switch (msg.msg) {
      case LB_ADDSTRING:
         //msg.result = icollection.add2(stringFromStringz(cast(char*)msg.lParam).dup); // TODO: fix.
         //msg.result = icollection.add2(stringFromStringz(cast(char*)msg.lParam).idup); // TODO: fix. // Needed in D2. Doesn't work in D1.
         msg.result = icollection.add2(cast(Dstring) stringFromStringz(cast(char*) msg.lParam).dup); // TODO: fix. // Needed in D2.
         return;

      case LB_INSERTSTRING:
         //msg.result = icollection.insert2(msg.wParam, stringFromStringz(cast(char*)msg.lParam).dup); // TODO: fix.
         //msg.result = icollection.insert2(msg.wParam, stringFromStringz(cast(char*)msg.lParam).idup); // TODO: fix. // Needed in D2. Doesn't work in D1.
         msg.result = icollection.insert2(msg.wParam,
            cast(Dstring) stringFromStringz(cast(char*) msg.lParam).dup); // TODO: fix. // Needed in D2.
         return;

      case LB_DELETESTRING:
         icollection.removeAt(msg.wParam);
         msg.result = icollection.length;
         return;

      case LB_RESETCONTENT:
         icollection.clear();
         return;

      case LB_SETITEMDATA:
         // Cannot set item data from outside DFL.
         msg.result = LB_ERR;
         return;

      case LB_ADDFILE:
         msg.result = LB_ERR;
         return;

      case LB_DIR:
         msg.result = LB_ERR;
         return;

      default:
      }
      super.wndProc(msg);
   }

private:
   int hextent = 0;
   int iheight = DEFAULT_ITEM_HEIGHT;
   ObjectCollection icollection;
   SelectedIndexCollection selidxcollection;
   SelectedObjectCollection selobjcollection;
   bool _sorting = false;

package:
final:
   LRESULT prevwproc(UINT msg, WPARAM wparam, LPARAM lparam) {
      //return CallWindowProcA(listviewPrevWndProc, hwnd, msg, wparam, lparam);
      return dfl.internal.utf.callWindowProc(listboxPrevWndProc, hwnd, msg, wparam,
         lparam);
   }
}