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

module dfl.textbox;

import core.sys.windows.windows;

import dfl.internal.dlib;
import dfl.internal.utf;
import dfl.control;
import dfl.base;
import dfl.application;
import dfl.drawing;
import dfl.event;

debug (APP_PRINT) {
   private import dfl.internal.clib;
}

version (DFL_NO_MENUS) {
} else {
   private import dfl.menu;
}

private extern (Windows) void _initTextBox();

// Note: ControlStyles.CACHE_TEXT might not work correctly with a text box.
// It's not actually a bug, but a limitation of this control.

abstract class TextBoxBase : ControlSuperClass {

   final @property void acceptsTab(bool byes) {
      atab = byes;
      setStyle(ControlStyles.WANT_TAB_KEY, atab);
   }

   final @property bool acceptsTab() {
      return atab;
   }

   @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 (created) {
         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;
   }

   final @property bool canUndo() {
      if (!created) {
         return false;
      }
      return SendMessageA(handle, EM_CANUNDO, 0, 0) != 0;
   }

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

   final @property bool hideSelection() {
      return (_style() & ES_NOHIDESEL) == 0;
   }

   final @property void lines(Dstring[] lns) {
      Dstring result;
      foreach (Dstring s; lns) {
         result ~= s ~ "\r\n";
      }
      if (result.length) { // Remove last \r\n.
         result = result[0 .. result.length - 2];
      }
      text = result;
   }

   final @property Dstring[] lines() {
      return stringSplitLines(text);
   }

   @property void maxLength(uint len) {
      if (!len) {
         if (multiline) {
            lim = 0xFFFFFFFF;
         } else {
            lim = 0x7FFFFFFE;
         }
      } else {
         lim = len;
      }

      if (created) {
         Message m;
         m = Message(handle, EM_SETLIMITTEXT, cast(WPARAM) lim, 0);
         prevWndProc(m);
      }
   }

   @property uint maxLength() {
      if (created) {
         lim = cast(uint) SendMessageA(handle, EM_GETLIMITTEXT, 0, 0);
      }
      return lim;
   }

   final uint getLineCount() {
      if (!multiline) {
         return 1;
      }

      if (created) {
         return cast(uint) SendMessageA(handle, EM_GETLINECOUNT, 0, 0);
      }

      Dstring s;
      size_t iw = 0;
      uint count = 1;
      s = text;
      for (; iw != s.length; iw++) {
         if ('\r' == s[iw]) {
            if (iw + 1 == s.length) {
               break;
            }
            if ('\n' == s[iw + 1]) {
               iw++;
               count++;
            }
         }
      }
      return count;
   }

   final @property void modified(bool byes) {
      if (created) {
         SendMessageA(handle, EM_SETMODIFY, byes, 0);
      }
   }

   final @property bool modified() {
      if (!created) {
         return false;
      }
      return SendMessageA(handle, EM_GETMODIFY, 0, 0) != 0;
   }

   @property void multiline(bool byes) {
      /+
         if(byes) {
            _style(_style() & ~ES_AUTOHSCROLL | ES_MULTILINE);
         } else {
            _style(_style() & ~ES_MULTILINE | ES_AUTOHSCROLL);
         }
      +/

      // TODO: check if correct implementation.

      LONG st;

      if (byes) {
         st = _style() | ES_MULTILINE | ES_AUTOVSCROLL;

         if (_wrap) {
            st &= ~ES_AUTOHSCROLL;
         } else {
            st |= ES_AUTOHSCROLL;
         }
      } else {
         st = _style() & ~(ES_MULTILINE | ES_AUTOVSCROLL);

         // Always H-scroll when single line.
         st |= ES_AUTOHSCROLL;
      }

      _style(st);

      _crecreate();
   }

   @property bool multiline() {
      return (_style() & ES_MULTILINE) != 0;
   }

   final @property void readOnly(bool byes) {
      if (created) {
         SendMessageA(handle, EM_SETREADONLY, byes, 0); // Should trigger WM_STYLECHANGED.
         invalidate(); // ?
      } else {
         if (byes) {
            _style(_style() | ES_READONLY);
         } else {
            _style(_style() & ~ES_READONLY);
         }
      }
   }

   final @property bool readOnly() {
      return (_style() & ES_READONLY) != 0;
   }

   @property void selectedText(Dstring sel) {
      /+
         if(created) {
            SendMessageA(handle, EM_REPLACESEL, FALSE, cast(LPARAM)unsafeStringz(sel));
         }
      +/

      if (created) {
         //dfl.internal.utf.sendMessage(handle, EM_REPLACESEL, FALSE, sel);
         dfl.internal.utf.sendMessageUnsafe(handle, EM_REPLACESEL, FALSE, sel);
      }
   }

   @property Dstring selectedText() {
      /+
         if(created) {
            uint v1, v2;
            SendMessageA(handle, EM_GETSEL, cast(WPARAM)&v1, cast(LPARAM)&v2);
            if(v1 == v2) {
               return null;
            }
            assert(v2 > v1);
            Dstring result = new char[v2 - v1 + 1];
            result[result.length - 1] = 0;
            result = result[0 .. result.length - 1];
            result[] = text[v1 .. v2];
            return result;
         }
      return null;
      +/

      if (created) {
         return dfl.internal.utf.getSelectedText(handle);
      }
      return null;
   }

   @property void selectionLength(uint len) {
      if (created) {
         uint v1, v2;
         SendMessageA(handle, EM_GETSEL, cast(WPARAM)&v1, cast(LPARAM)&v2);
         v2 = v1 + len;
         SendMessageA(handle, EM_SETSEL, v1, v2);
      }
   }

   // Current selection length, in characters.
   // This does not necessarily correspond to the length of chars; some characters use multiple chars.
   // An end of line (\r\n) takes up 2 characters.
   @property uint selectionLength() {
      if (created) {
         uint v1, v2;
         SendMessageA(handle, EM_GETSEL, cast(WPARAM)&v1, cast(LPARAM)&v2);
         assert(v2 >= v1);
         return v2 - v1;
      }
      return 0;
   }

   @property void selectionStart(uint pos) {
      if (created) {
         uint v1, v2;
         SendMessageA(handle, EM_GETSEL, cast(WPARAM)&v1, cast(LPARAM)&v2);
         assert(v2 >= v1);
         v2 = pos + (v2 - v1);
         SendMessageA(handle, EM_SETSEL, pos, v2);
      }
   }

   // Current selection starting index, in characters.
   // This does not necessarily correspond to the index of chars; some characters use multiple chars.
   // An end of line (\r\n) takes up 2 characters.
   @property uint selectionStart() {
      if (created) {
         uint v1, v2;
         SendMessageA(handle, EM_GETSEL, cast(WPARAM)&v1, cast(LPARAM)&v2);
         return v1;
      }
      return 0;
   }

   // Number of characters in the textbox.
   // This does not necessarily correspond to the number of chars; some characters use multiple chars.
   // An end of line (\r\n) takes up 2 characters.
   // Return may be larger than the amount of characters.
   // This is a lot faster than retrieving the text, but retrieving the text is completely accurate.
   @property uint textLength() {
      if (!(ctrlStyle & ControlStyles.CACHE_TEXT) && created()) //return cast(uint)SendMessageA(handle, WM_GETTEXTLENGTH, 0, 0);
      {
         return cast(uint) dfl.internal.utf.sendMessage(handle, WM_GETTEXTLENGTH, 0,
            0);
      }
      return wtext.length;
   }

   @property final void wordWrap(bool byes) {
      /+
         if(byes) {
            _style(_style() | ES_AUTOVSCROLL);
         } else {
            _style(_style() & ~ES_AUTOVSCROLL);
         }
      +/

      // TODO: check if correct implementation.

      if (_wrap == byes) {
         return;
      }

      _wrap = byes;

      // Always H-scroll when single line.
      if (multiline) {
         if (byes) {
            _style(_style() & ~(ES_AUTOHSCROLL | WS_HSCROLL));
         } else {
            LONG st;
            st = _style();

            st |= ES_AUTOHSCROLL;

            if (_hscroll) {
               st |= WS_HSCROLL;
            }

            _style(st);
         }
      }

      _crecreate();
   }

   final @property bool wordWrap() {
      //return (_style() & ES_AUTOVSCROLL) != 0;

      return _wrap;
   }

   final void appendText(Dstring txt) {
      if (created) {
         selectionStart = textLength;
         selectedText = txt;
      } else {
         text = text ~ txt;
      }
   }

   final void clear() {
      /+
         // WM_CLEAR only clears the selection ?
         if(created) {
            SendMessageA(handle, WM_CLEAR, 0, 0);
         } else {
            wtext = null;
         }
      +/

      text = null;
   }

   final void clearUndo() {
      if (created) {
         SendMessageA(handle, EM_EMPTYUNDOBUFFER, 0, 0);
      }
   }

   final void copy() {
      if (created) {
         SendMessageA(handle, WM_COPY, 0, 0);
      } else {
         // There's never a selection if the window isn't created; so just empty the clipboard.

         if (!OpenClipboard(null)) {
            debug (APP_PRINT)
               cprintf("Unable to OpenClipboard().\n");
            //throw new DflException("Unable to set clipboard data.");
            return;
         }
         EmptyClipboard();
         CloseClipboard();
      }
   }

   final void cut() {
      if (created) {
         SendMessageA(handle, WM_CUT, 0, 0);
      } else {
         // There's never a selection if the window isn't created; so just empty the clipboard.

         if (!OpenClipboard(null)) {
            debug (APP_PRINT)
               cprintf("Unable to OpenClipboard().\n");
            //throw new DflException("Unable to set clipboard data.");
            return;
         }
         EmptyClipboard();
         CloseClipboard();
      }
   }

   final void paste() {
      if (created) {
         SendMessageA(handle, WM_PASTE, 0, 0);
      } else {
         // Can't do anything because there's no selection ?
      }
   }

   final void scrollToCaret() {
      if (created) {
         SendMessageA(handle, EM_SCROLLCARET, 0, 0);
      }
   }

   final void select(uint start, uint length) {
      if (created) {
         SendMessageA(handle, EM_SETSEL, start, start + length);
      }
   }

   alias select = Control.select; // Overload.

   final void selectAll() {
      if (created) {
         SendMessageA(handle, EM_SETSEL, 0, -1);
      }
   }

   override Dstring toString() {
      return text; // ?
   }

   final void undo() {
      if (created) {
         SendMessageA(handle, EM_UNDO, 0, 0);
      }
   }

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

         createClassHandle(TEXTBOX_CLASSNAME);

         onHandleCreated(EventArgs.empty);
      }
   +/

   override void createHandle() {
      if (!isHandleCreated) {
         Dstring txt;
         txt = wtext;

         super.createHandle();

         //dfl.internal.utf.setWindowText(hwnd, txt);
         text = txt; // So that it can be overridden.
      }
   }

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

      cp.className = TEXTBOX_CLASSNAME;
      cp.caption = null; // Set in createHandle() to allow larger buffers.
   }

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

      //SendMessageA(hwnd, EM_SETLIMITTEXT, cast(WPARAM)lim, 0);
      maxLength = lim; // Call virtual function.
   }

   private {
      version (DFL_NO_MENUS) {
      } else {
         void menuUndo(Object sender, EventArgs ea) {
            undo();
         }

         void menuCut(Object sender, EventArgs ea) {
            cut();
         }

         void menuCopy(Object sender, EventArgs ea) {
            copy();
         }

         void menuPaste(Object sender, EventArgs ea) {
            paste();
         }

         void menuDelete(Object sender, EventArgs ea) {
            // Only clear selection.
            SendMessageA(handle, WM_CLEAR, 0, 0);
         }

         void menuSelectAll(Object sender, EventArgs ea) {
            selectAll();
         }

         bool isClipboardText() {
            if (!OpenClipboard(handle)) {
               return false;
            }

            bool result;
            result = GetClipboardData(CF_TEXT) != null;

            CloseClipboard();

            return result;
         }

         void menuPopup(Object sender, EventArgs ea) {
            int slen, tlen;
            bool issel;

            slen = selectionLength;
            tlen = textLength;
            issel = slen != 0;

            miundo.enabled = canUndo;
            micut.enabled = !readOnly() && issel;
            micopy.enabled = issel;
            mipaste.enabled = !readOnly() && isClipboardText();
            midel.enabled = !readOnly() && issel;
            misel.enabled = tlen != 0 && tlen != slen;
         }

         MenuItem miundo, micut, micopy, mipaste, midel, misel;
      }
   }

   this() {
      _initTextBox();

      wstyle |= WS_TABSTOP | ES_AUTOHSCROLL;
      wexstyle |= WS_EX_CLIENTEDGE;
      ctrlStyle |= ControlStyles.SELECTABLE;
      wclassStyle = textBoxClassStyle;

      version (DFL_NO_MENUS) {
      } else {
         MenuItem mi;

         cmenu = new ContextMenu;
         cmenu.popup ~= &menuPopup;

         miundo = new MenuItem;
         miundo.text = "&Undo";
         miundo.click ~= &menuUndo;
         miundo.index = 0;
         cmenu.menuItems.add(miundo);

         mi = new MenuItem;
         mi.text = "-";
         mi.index = 1;
         cmenu.menuItems.add(mi);

         micut = new MenuItem;
         micut.text = "Cu&t";
         micut.click ~= &menuCut;
         micut.index = 2;
         cmenu.menuItems.add(micut);

         micopy = new MenuItem;
         micopy.text = "&Copy";
         micopy.click ~= &menuCopy;
         micopy.index = 3;
         cmenu.menuItems.add(micopy);

         mipaste = new MenuItem;
         mipaste.text = "&Paste";
         mipaste.click ~= &menuPaste;
         mipaste.index = 4;
         cmenu.menuItems.add(mipaste);

         midel = new MenuItem;
         midel.text = "&Delete";
         midel.click ~= &menuDelete;
         midel.index = 5;
         cmenu.menuItems.add(midel);

         mi = new MenuItem;
         mi.text = "-";
         mi.index = 6;
         cmenu.menuItems.add(mi);

         misel = new MenuItem;
         misel.text = "Select &All";
         misel.click ~= &menuSelectAll;
         misel.index = 7;
         cmenu.menuItems.add(misel);
      }
   }

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

   alias backColor = Control.backColor; // Overload.

   static @property Color defaultBackColor() {
      return Color.systemColor(COLOR_WINDOW);
   }

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

   alias foreColor = Control.foreColor; // Overload.

   static @property Color defaultForeColor() {
      return Color.systemColor(COLOR_WINDOWTEXT);
   }

   override @property Cursor cursor() {
      if (!wcurs) {
         return _defaultCursor;
      }
      return wcurs;
   }

   alias cursor = Control.cursor; // Overload.

   int getFirstCharIndexFromLine(int line) {
      if (!isHandleCreated) {
         return -1; // ...
      }
      if (line < 0) {
         return -1;
      }
      return SendMessageA(hwnd, EM_LINEINDEX, line, 0);
   }

   int getFirstCharIndexOfCurrentLine() {
      if (!isHandleCreated) {
         return -1; // ...
      }
      return SendMessageA(hwnd, EM_LINEINDEX, -1, 0);
   }

   int getLineFromCharIndex(int charIndex) {
      if (!isHandleCreated) {
         return -1; // ...
      }
      if (charIndex < 0) {
         return -1;
      }
      return SendMessageA(hwnd, EM_LINEFROMCHAR, charIndex, 0);
   }

   Point getPositionFromCharIndex(int charIndex) {
      if (!isHandleCreated) {
         return Point(0, 0); // ...
      }
      if (charIndex < 0) {
         return Point(0, 0);
      }
      POINT point;
      SendMessageA(hwnd, EM_POSFROMCHAR, cast(WPARAM)&point, charIndex);
      return Point(point.x, point.y);
   }

   int getCharIndexFromPosition(Point pt) {
      if (!isHandleCreated) {
         return -1; // ...
      }
      if (!multiline) {
         return 0;
      }
      auto lresult = SendMessageA(hwnd, EM_CHARFROMPOS, 0, MAKELPARAM(pt.x, pt.y));
      if (-1 == lresult) {
         return -1;
      }
      return cast(int) cast(short)(lresult & 0xFFFF);
   }

   package static @property Cursor _defaultCursor() {
      static Cursor def = null;

      if (!def) {
         synchronized {
            if (!def) {
               def = new SafeCursor(LoadCursor(null, IDC_IBEAM));
            }
         }
      }

      return def;
   }

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

      switch (m.msg) {
      case WM_COMMAND:
         switch (HIWORD(m.wParam)) {
         case EN_CHANGE:
            onTextChanged(EventArgs.empty);
            break;

         default:
         }
         break;

         /+
         case WM_CTLCOLORSTATIC:
         case WM_CTLCOLOREDIT:
               /+
                  //SetBkColor(cast(HDC)m.wParam, backColor.toRgb()); // ?
                  SetBkMode(cast(HDC)m.wParam, OPAQUE); // ?
               +/
                  break;
               +/

      default:
      }
   }

   override void prevWndProc(ref Message msg) {
      version (DFL_NO_MENUS) {
         // Don't prevent WM_CONTEXTMENU so at least it'll have a default menu.
      } else {
         if (msg.msg == WM_CONTEXTMENU) { // Ignore the default context menu.
            return;
         }
      }

      //msg.result = CallWindowProcA(textBoxPrevWndProc, msg.hWnd, msg.msg, msg.wParam, msg.lParam);
      msg.result = dfl.internal.utf.callWindowProc(textBoxPrevWndProc, msg.hWnd,
         msg.msg, msg.wParam, msg.lParam);
   }

   protected override bool processKeyEventArgs(ref Message msg) { // package
      switch (msg.msg) {
      case WM_KEYDOWN:
      case WM_KEYUP:
      case WM_CHAR:
         if ('\t' == msg.wParam) {
            // TODO: fix this. This case shouldn't be needed.
            if (atab) {
               if (super.processKeyEventArgs(msg)) {
                  return true; // Handled.
               }
               if (WM_KEYDOWN == msg.msg) {
                  if (multiline) { // Only multiline textboxes can have real tabs..
                     //selectedText = "\t";
                     //SendMessageA(handle, EM_REPLACESEL, TRUE, cast(LPARAM)"\t".ptr); // Allow undo. // Crashes DMD 0.161.
                     auto str = "\t".ptr;
                     SendMessageA(handle, EM_REPLACESEL, TRUE, cast(LPARAM) str); // Allow undo.
                  }
               }
               return true; // Handled.
            }
         }
         break;

      default:
      }
      return super.processKeyEventArgs(msg);
   }

   override void wndProc(ref Message msg) {
      switch (msg.msg) {
      case WM_GETDLGCODE:
         super.wndProc(msg);
         if (atab) {
            //if(GetKeyState(Keys.TAB) & 0x8000)
            {
               //msg.result |= DLGC_WANTALLKEYS;
               msg.result |= DLGC_WANTTAB;
            }
         } else {
            msg.result &= ~DLGC_WANTTAB;
         }
         return;

      default:
         super.wndProc(msg);
      }
   }

   override @property Size defaultSize() {
      return Size(120, 23); // ?
   }

private:
   package uint lim = 30_000; // Documented as default.
   bool _wrap = true;
   bool _hscroll;

   bool atab = false;

   /+
      @property bool atab() {
         if(_style() & X) {
            return true;
         }
         return false;
      }

   @property void atab(bool byes) {
      if(byes) {
         _style(_style() | X);
      } else {
         _style(_style() & ~X);
      }
   }
   +/

   @property void hscroll(bool byes) {
      _hscroll = byes;

      if (byes && (!_wrap || !multiline)) {
         _style(_style() | WS_HSCROLL | ES_AUTOHSCROLL);
      }
   }

   @property bool hscroll() {
      return _hscroll;
   }
}

class TextBox : TextBoxBase {

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

   final @property bool acceptsReturn() {
      return (_style() & ES_WANTRETURN) != 0;
   }

   final @property void characterCasing(CharacterCasing cc) {
      LONG wl = _style() & ~(ES_UPPERCASE | ES_LOWERCASE);

      final switch (cc) {
      case CharacterCasing.UPPER:
         wl |= ES_UPPERCASE;
         break;

      case CharacterCasing.LOWER:
         wl |= ES_LOWERCASE;
         break;

      case CharacterCasing.NORMAL:
         break;
      }

      _style(wl);
   }

   final @property CharacterCasing characterCasing() {
      LONG wl = _style();
      if (wl & ES_UPPERCASE) {
         return CharacterCasing.UPPER;
      } else if (wl & ES_LOWERCASE) {
         return CharacterCasing.LOWER;
      }
      return CharacterCasing.NORMAL;
   }

   // Set to 0 (NUL) to remove.
   final @property void passwordChar(dchar pwc) {
      if (pwc) {
         // When the EM_SETPASSWORDCHAR message is received by an edit control,
         // the edit control redraws all visible characters by using the
         // character specified by the ch parameter.

         if (created) //SendMessageA(handle, EM_SETPASSWORDCHAR, pwc, 0);
         {
            dfl.internal.utf.emSetPasswordChar(handle, pwc);
         } else {
            _style(_style() | ES_PASSWORD);
         }
      } else {
         // The style ES_PASSWORD is removed if an EM_SETPASSWORDCHAR message
         // is sent with the ch parameter set to zero.

         if (created) //SendMessageA(handle, EM_SETPASSWORDCHAR, 0, 0);
         {
            dfl.internal.utf.emSetPasswordChar(handle, 0);
         } else {
            _style(_style() & ~ES_PASSWORD);
         }
      }

      passchar = pwc;
   }

   final @property dchar passwordChar() {
      if (created) //passchar = cast(dchar)SendMessageA(handle, EM_GETPASSWORDCHAR, 0, 0);
      {
         passchar = dfl.internal.utf.emGetPasswordChar(handle);
      }
      return passchar;
   }

   final @property void scrollBars(ScrollBars sb) {
      /+
         switch(sb) {
            case ScrollBars.BOTH:
               _style(_style() | WS_HSCROLL | WS_VSCROLL);
               break;

            case ScrollBars.HORIZONTAL:
               _style(_style() & ~WS_VSCROLL | WS_HSCROLL);
               break;

            case ScrollBars.VERTICAL:
               _style(_style() & ~WS_HSCROLL | WS_VSCROLL);
               break;

            case ScrollBars.NONE:
               _style(_style() & ~(WS_HSCROLL | WS_VSCROLL));
               break;
         }
      +/
      final switch (sb) {
      case ScrollBars.BOTH:
         _style(_style() | WS_VSCROLL);
         hscroll = true;
         break;

      case ScrollBars.HORIZONTAL:
         _style(_style() & ~WS_VSCROLL);
         hscroll = true;
         break;

      case ScrollBars.VERTICAL:
         _style(_style() | WS_VSCROLL);
         hscroll = false;
         break;

      case ScrollBars.NONE:
         _style(_style() & ~WS_VSCROLL);
         hscroll = false;
         break;
      }

      if (created) {
         redrawEntire();
      }
   }

   final @property ScrollBars scrollBars() {
      LONG wl = _style();

      //if(wl & WS_HSCROLL)
      if (hscroll) {
         if (wl & WS_VSCROLL) {
            return ScrollBars.BOTH;
         }
         return ScrollBars.HORIZONTAL;
      }
      if (wl & WS_VSCROLL) {
         return ScrollBars.VERTICAL;
      }
      return ScrollBars.NONE;
   }

   final @property void textAlign(HorizontalAlignment ha) {
      LONG wl = _style() & ~(ES_RIGHT | ES_CENTER | ES_LEFT);

      final switch (ha) {
      case HorizontalAlignment.RIGHT:
         wl |= ES_RIGHT;
         break;

      case HorizontalAlignment.CENTER:
         wl |= ES_CENTER;
         break;

      case HorizontalAlignment.LEFT:
         wl |= ES_LEFT;
         break;
      }

      _style(wl);

      _crecreate();
   }

   final @property HorizontalAlignment textAlign() {
      LONG wl = _style();

      if (wl & ES_RIGHT) {
         return HorizontalAlignment.RIGHT;
      }
      if (wl & ES_CENTER) {
         return HorizontalAlignment.CENTER;
      }
      return HorizontalAlignment.LEFT;
   }

   this() {
      wstyle |= ES_LEFT;
   }

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

      if (passchar) {
         SendMessageA(hwnd, EM_SETPASSWORDCHAR, passchar, 0);
      }
   }

   /+
      override @property void wndProc(ref Message msg) {
         switch(msg.msg) {
            /+
            case WM_GETDLGCODE:
               if(!acceptsReturn && (GetKeyState(Keys.RETURN) & 0x8000)) {
                  // Hack.
                  msg.result = DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
                  return;
               }
               break;
               +/

            default:
         }

         super.wndProc(msg);
      }
   +/

private:
   dchar passchar = 0;
}