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



module dfl.textbox;

private import dfl.internal.dlib;

private import dfl.control, dfl.base, dfl.internal.winapi, dfl.application;
private import dfl.drawing, dfl.event, dfl.internal.utf;
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 { // docmain

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

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



   @property void borderStyle(BorderStyle bs) { // setter
      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();
      }
   }

   /// ditto
   @property BorderStyle borderStyle() { // getter
      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() { // getter
      if(!created) {
         return false;
      }
      return SendMessageA(handle, EM_CANUNDO, 0, 0) != 0;
   }



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

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



   final @property void lines(Dstring[] lns) { // setter
      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;
   }

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



   @property void maxLength(uint len) { // setter
      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);
      }
   }

   /// ditto
   @property uint maxLength() { // getter
      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) { // setter
      if(created) {
         SendMessageA(handle, EM_SETMODIFY, byes, 0);
      }
   }

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



   @property void multiline(bool byes) { // setter
      /+
      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();
   }

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



   final @property void readOnly(bool byes) { // setter
      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);
         }
      }
   }

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



   @property void selectedText(Dstring sel) { // setter
      /+
      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);
      }
   }

   /// ditto
   @property Dstring selectedText() { // getter
      /+
      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) { // setter
      if(created) {
         uint v1, v2;
         SendMessageA(handle, EM_GETSEL, cast(WPARAM)&v1, cast(LPARAM)&v2);
         v2 = v1 + len;
         SendMessageA(handle, EM_SETSEL, v1, v2);
      }
   }

   /// ditto
   // 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() { // getter
      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) { // setter
      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);
      }
   }

   /// ditto
   // 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() { // getter
      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() { // getter
      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) { // setter
      /+
      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();
   }

   /// ditto
   final @property bool wordWrap() { // getter
      //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 Control.select 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() { // getter
      if(Color.empty == backc) {
         return defaultBackColor;
      }
      return backc;
   }

   alias Control.backColor backColor; // Overload.


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


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

   alias Control.foreColor foreColor; // Overload.


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


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

   alias Control.cursor cursor; // Overload.



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

   /// ditto
   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);
   }

   /// ditto
   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() { // getter
      static Cursor def = null;

      if(!def) {
         synchronized {
            if(!def) {
               def = new SafeCursor(LoadCursorA(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() { // getter
      return Size(120, 23); // ?
   }


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

   bool atab = false;

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

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


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

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


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



class TextBox: TextBoxBase { // docmain

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

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



   final @property void characterCasing(CharacterCasing cc) { // setter
      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);
   }

   /// ditto
   final @property CharacterCasing characterCasing() { // getter
      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) { // setter
      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;
   }

   /// ditto
   final @property dchar passwordChar() { // getter
      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) { // setter
      /+
      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();
      }
   }

   /// ditto
   final @property ScrollBars scrollBars() { // getter
      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) { // setter
      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();
   }

   /// ditto
   final @property HorizontalAlignment textAlign() { // getter
      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;
}