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



module dfl.button;

private import dfl.base, dfl.control, dfl.application, dfl.internal.winapi;
private import dfl.event, dfl.drawing, dfl.internal.dlib;


private extern(Windows) void _initButton();



abstract class ButtonBase: ControlSuperClass { // docmain

   @property void textAlign(ContentAlignment calign) { // setter
      LONG wl = _bstyle() & ~(BS_BOTTOM | BS_CENTER | BS_TOP | BS_RIGHT | BS_LEFT | BS_VCENTER);

      final switch(calign) {
         case ContentAlignment.TOP_LEFT:
            wl |= BS_TOP | BS_LEFT;
            break;

         case ContentAlignment.BOTTOM_CENTER:
            wl |= BS_BOTTOM | BS_CENTER;
            break;

         case ContentAlignment.BOTTOM_LEFT:
            wl |= BS_BOTTOM | BS_LEFT;
            break;

         case ContentAlignment.BOTTOM_RIGHT:
            wl |= BS_BOTTOM | BS_RIGHT;
            break;

         case ContentAlignment.MIDDLE_CENTER:
            wl |= BS_CENTER | BS_VCENTER;
            break;

         case ContentAlignment.MIDDLE_LEFT:
            wl |= BS_VCENTER | BS_LEFT;
            break;

         case ContentAlignment.MIDDLE_RIGHT:
            wl |= BS_VCENTER | BS_RIGHT;
            break;

         case ContentAlignment.TOP_CENTER:
            wl |= BS_TOP | BS_CENTER;
            break;

         case ContentAlignment.TOP_RIGHT:
            wl |= BS_TOP | BS_RIGHT;
            break;
      }

      _bstyle(wl);

      _crecreate();
   }

   /// ditto
   @property ContentAlignment textAlign() { // getter
      LONG wl = _bstyle();

      if(wl & BS_VCENTER) { // Middle.
         if(wl & BS_CENTER) {
            return ContentAlignment.MIDDLE_CENTER;
         }
         if(wl & BS_RIGHT) {
            return ContentAlignment.MIDDLE_RIGHT;
         }
         return ContentAlignment.MIDDLE_LEFT;
      } else if(wl & BS_BOTTOM) { // Bottom.
         if(wl & BS_CENTER) {
            return ContentAlignment.BOTTOM_CENTER;
         }
         if(wl & BS_RIGHT) {
            return ContentAlignment.BOTTOM_RIGHT;
         }
         return ContentAlignment.BOTTOM_LEFT;
      } else { // Top.
         if(wl & BS_CENTER) {
            return ContentAlignment.TOP_CENTER;
         }
         if(wl & BS_RIGHT) {
            return ContentAlignment.TOP_RIGHT;
         }
         return ContentAlignment.TOP_LEFT;
      }
   }


   // Border stuff...


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

      createClassHandle(BUTTON_CLASSNAME);

      onHandleCreated(EventArgs.empty);
   }
   +/


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

      cp.className = BUTTON_CLASSNAME;
      if(isdef) {
         cp.menu = cast(HMENU)IDOK;
         if(!(cp.style & WS_DISABLED)) {
            cp.style |= BS_DEFPUSHBUTTON;
         }
      } else if(cp.style & WS_DISABLED) {
         cp.style &= ~BS_DEFPUSHBUTTON;
      }
   }


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


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

      switch(m.msg) {
         case WM_COMMAND:
            assert(cast(HWND)m.lParam == handle);

            switch(HIWORD(m.wParam)) {
               case BN_CLICKED:
                  onClick(EventArgs.empty);
                  break;

               default:
            }
            break;

         default:
      }
   }


   protected override void wndProc(ref Message msg) {
      switch(msg.msg) {
         case WM_LBUTTONDOWN:
            onMouseDown(new MouseEventArgs(MouseButtons.LEFT, 0, cast(short)LOWORD(msg.lParam), cast(short)HIWORD(msg.lParam), 0));
            break;

         case WM_LBUTTONUP:
            onMouseUp(new MouseEventArgs(MouseButtons.LEFT, 1, cast(short)LOWORD(msg.lParam), cast(short)HIWORD(msg.lParam), 0));
            break;

         default:
            super.wndProc(msg);
            return;
      }
      prevWndProc(msg);
   }


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

      /+
      // Done in createParams() now.
      if(isdef) {
         SetWindowLongA(handle, GWL_ID, IDOK);
      }
      +/
   }
   +/


   this() {
      _initButton();

      wstyle |= WS_TABSTOP /+ | BS_NOTIFY +/;
      ctrlStyle |= ControlStyles.SELECTABLE;
      wclassStyle = buttonClassStyle;
   }


 protected:


   final @property void isDefault(bool byes) { // setter
      isdef = byes;
   }

   /// ditto
   final @property bool isDefault() { // getter
      //return (_bstyle() & BS_DEFPUSHBUTTON) == BS_DEFPUSHBUTTON;
      //return GetDlgCtrlID(m.hWnd) == IDOK;
      return isdef;
   }


   protected override bool processMnemonic(dchar charCode) {
      if(canSelect) {
         if(isMnemonic(charCode, text)) {
            select();
            //Application.doEvents(); // ?
            //performClick();
            onClick(EventArgs.empty);
            return true;
         }
      }
      return false;
   }



   override @property Size defaultSize() { // getter
      return Size(75, 23);
   }


 private:
   bool isdef = false;


 package:
 final:
   // Automatically redraws button styles, unlike _style().
   // Don't use with regular window styles ?
   void _bstyle(LONG newStyle) {
      if(isHandleCreated)
         //SendMessageA(handle, BM_SETSTYLE, LOWORD(newStyle), MAKELPARAM(TRUE, 0));
      {
         SendMessageA(handle, BM_SETSTYLE, newStyle, MAKELPARAM(TRUE, 0));
      }

      wstyle = newStyle;
      //_style(newStyle);
   }


   LONG _bstyle() {
      return _style();
   }
}



class Button: ButtonBase, IButtonControl { // docmain
   this() {
   }



   @property DialogResult dialogResult() { // getter
      return dresult;
   }

   /// ditto
   @property void dialogResult(DialogResult dr) { // setter
      dresult = dr;
   }



   // True if default button.
   void notifyDefault(bool byes) {
      isDefault = byes;

      if(byes) {
         if(enabled) { // Only show thick border if enabled.
            _bstyle(_bstyle() | BS_DEFPUSHBUTTON);
         }
      } else {
         _bstyle(_bstyle() & ~BS_DEFPUSHBUTTON);
      }
   }



   void performClick() {
      if(!enabled || !visible || !isHandleCreated) { // ?
         return;   // ?
      }

      // This is actually not so good because it sets focus to the control.
      //SendMessageA(handle, BM_CLICK, 0, 0); // So that wndProc() gets it.

      onClick(EventArgs.empty);
   }


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

      if(!(Application._compat & DflCompat.FORM_DIALOGRESULT_096)) {
         if(DialogResult.NONE != this.dialogResult) {
            auto xx = cast(IDialogResult)topLevelControl;
            if(xx) {
               xx.dialogResult = this.dialogResult;
            }
         }
      }
   }


   protected override void wndProc(ref Message m) {
      switch(m.msg) {
         case WM_ENABLE: {
               // Fixing the thick border of a default button when enabling and disabling it.

               // To-do: check if correct implementation.

               DWORD bst;
               bst = _bstyle();
               if(bst & BS_DEFPUSHBUTTON) {
                  //_bstyle(bst); // Force the border to be updated. Only works when enabling.
                  if(!m.wParam) {
                     _bstyle(bst & ~BS_DEFPUSHBUTTON);
                  }
               } else if(m.wParam) {
                  //if(GetDlgCtrlID(m.hWnd) == IDOK)
                  if(isdef) {
                     _bstyle(bst | BS_DEFPUSHBUTTON);
                  }
               }
            }
            break;

         default:
      }

      super.wndProc(m);
   }


   override @property void text(Dstring txt) { // setter
      if(txt.length) {
         assert(!this.image, "Button image with text not supported");
      }

      super.text = txt;
   }

   alias Control.text text; // Overload.



   final @property Image image() { // getter
      return _img;
   }

   /// ditto
   final @property void image(Image img) // setter
   in {
      if(img) {
         assert(!this.text.length, "Button image with text not supported");
      }
   }
   body {
      /+
      if(_picbm) {
         _picbm.dispose();
         _picbm = null;
      }
      +/

      _img = null; // In case of exception.
      LONG imgst = 0;
      if(img) {
         /+
         if(cast(Bitmap)img) {
            imgst = BS_BITMAP;
         } else if(cast(Icon)img) {
            imgst = BS_ICON;
         } else {
            if(cast(Picture)img) {
               _picbm = (cast(Picture)img).toBitmap();
               imgst = BS_BITMAP;
               goto not_unsupported;
            }

            throw new DflException("Unsupported image format");
         not_unsupported: ;
         }
         +/
         switch(img._imgtype(null)) {
            case 1:
               imgst = BS_BITMAP;
               break;

            case 2:
               imgst = BS_ICON;
               break;

            default:
               throw new DflException("Unsupported image format");
            not_unsupported: ;
         }
      }

      _img = img;
      _style((_style() & ~(BS_BITMAP | BS_ICON)) | imgst); // Redrawn manually in setImg().
      if(img) {
         if(isHandleCreated) {
            setImg(imgst);
         }
      }
      //_bstyle((_bstyle() & ~(BS_BITMAP | BS_ICON)) | imgst);
   }


   private void setImg(LONG bsImageStyle)
   in {
      assert(isHandleCreated);
   }
   body {
      WPARAM wparam = 0;
      LPARAM lparam = 0;

      /+
      if(bsImageStyle & BS_BITMAP) {
         wparam = IMAGE_BITMAP;
         lparam = cast(LPARAM)(_picbm ? _picbm.handle : (cast(Bitmap)_img).handle);
      } else if(bsImageStyle & BS_ICON) {
         wparam = IMAGE_ICON;
         lparam = cast(LPARAM)((cast(Icon)(_img)).handle);
      } else
      {
         return;
      }
      +/
      if(!_img) {
         return;
      }
      HGDIOBJ hgo;
      switch(_img._imgtype(&hgo)) {
         case 1:
            wparam = IMAGE_BITMAP;
            break;

         case 2:
            wparam = IMAGE_ICON;
            break;

         default:
            return;
      }
      lparam = cast(LPARAM)hgo;

      //assert(lparam);
      SendMessageA(handle, BM_SETIMAGE, wparam, lparam);
      invalidate();
   }


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

      setImg(_bstyle());
   }


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

      /+
      if(_picbm) {
         _picbm.dispose();
         _picbm = null;
      }
      +/
   }


 private:
   DialogResult dresult = DialogResult.NONE;
   Image _img = null;
   //Bitmap _picbm = null; // If -_img- is a Picture, need to keep a separate Bitmap.
}



class CheckBox: ButtonBase { // docmain

   final @property void appearance(Appearance ap) { // setter
      final switch(ap) {
         case Appearance.NORMAL:
            _bstyle(_bstyle() & ~BS_PUSHLIKE);
            break;

         case Appearance.BUTTON:
            _bstyle(_bstyle() | BS_PUSHLIKE);
            break;
      }

      _crecreate();
   }

   /// ditto
   final @property Appearance appearance() { // getter
      if(_bstyle() & BS_PUSHLIKE) {
         return Appearance.BUTTON;
      }
      return Appearance.NORMAL;
   }



   final @property void autoCheck(bool byes) { // setter
      if(byes) {
         _bstyle((_bstyle() & ~BS_CHECKBOX) | BS_AUTOCHECKBOX);
      } else {
         _bstyle((_bstyle() & ~BS_AUTOCHECKBOX) | BS_CHECKBOX);
      }
      // Enabling/disabling the window before creation messes
      // up the autocheck style flag, so handle it manually.
      _autocheck = byes;
   }

   /// ditto
   final @property bool autoCheck() { // getter
      /+
      return (_bstyle() & BS_AUTOCHECKBOX) == BS_AUTOCHECKBOX;
      +/
      return _autocheck;
   }


   this() {
      wstyle |= BS_AUTOCHECKBOX | BS_LEFT | BS_VCENTER; // Auto check and MIDDLE_LEFT by default.
   }


   /+
   protected override void onClick(EventArgs ea) {
      _updateState();

      super.onClick(ea);
   }
   +/



   final @property void checked(bool byes) { // setter
      if(byes) {
         _check = CheckState.CHECKED;
      } else {
         _check = CheckState.UNCHECKED;
      }

      if(isHandleCreated) {
         SendMessageA(handle, BM_SETCHECK, cast(WPARAM)_check, 0);
      }
   }

   /// ditto
   // Returns true for indeterminate too.
   final @property bool checked() { // getter
      if(isHandleCreated) {
         _updateState();
      }
      return _check != CheckState.UNCHECKED;
   }



   final @property void checkState(CheckState st) { // setter
      _check = st;

      if(isHandleCreated) {
         SendMessageA(handle, BM_SETCHECK, cast(WPARAM)st, 0);
      }
   }

   /// ditto
   final @property CheckState checkState() { // getter
      if(isHandleCreated) {
         _updateState();
      }
      return _check;
   }


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

      if(_autocheck) {
         _bstyle((_bstyle() & ~BS_CHECKBOX) | BS_AUTOCHECKBOX);
      } else {
         _bstyle((_bstyle() & ~BS_AUTOCHECKBOX) | BS_CHECKBOX);
      }

      SendMessageA(handle, BM_SETCHECK, cast(WPARAM)_check, 0);
   }


 private:
   CheckState _check = CheckState.UNCHECKED; // Not always accurate.
   bool _autocheck = true;


   void _updateState() {
      _check = cast(CheckState)SendMessageA(handle, BM_GETCHECK, 0, 0);
   }
}



class RadioButton: ButtonBase { // docmain

   final @property void appearance(Appearance ap) { // setter
      final switch(ap) {
         case Appearance.NORMAL:
            _bstyle(_bstyle() & ~BS_PUSHLIKE);
            break;

         case Appearance.BUTTON:
            _bstyle(_bstyle() | BS_PUSHLIKE);
            break;
      }

      _crecreate();
   }

   /// ditto
   final @property Appearance appearance() { // getter
      if(_bstyle() & BS_PUSHLIKE) {
         return Appearance.BUTTON;
      }
      return Appearance.NORMAL;
   }



   final @property void autoCheck(bool byes) { // setter
      /+
      if(byes) {
         _bstyle((_bstyle() & ~BS_RADIOBUTTON) | BS_AUTORADIOBUTTON);
      } else {
         _bstyle((_bstyle() & ~BS_AUTORADIOBUTTON) | BS_RADIOBUTTON);
      }
      // Enabling/disabling the window before creation messes
      // up the autocheck style flag, so handle it manually.
      +/
      _autocheck = byes;
   }


   /// ditto
   final @property bool autoCheck() { // getter
      /+ // Also commented out when using BS_AUTORADIOBUTTON.
      return (_bstyle() & BS_AUTOCHECKBOX) == BS_AUTOCHECKBOX;
      +/
      return _autocheck;
   }


   this() {
      wstyle &= ~WS_TABSTOP;
      //wstyle |= BS_AUTORADIOBUTTON | BS_LEFT | BS_VCENTER; // MIDDLE_LEFT by default.
      wstyle |= BS_RADIOBUTTON | BS_LEFT | BS_VCENTER; // MIDDLE_LEFT by default.
   }


   protected override void onClick(EventArgs ea) {
      if(autoCheck) {
         if(parent) { // Sanity.
            foreach(Control ctrl; parent.controls) {
               if(ctrl is this) {
                  continue;
               }
               if((ctrl._rtype() & (1 | 8)) == (1 | 8)) { // Radio button + auto check.
                  (cast(RadioButton)ctrl).checked = false;
               }
            }
         }
         checked = true;
      }

      super.onClick(ea);
   }


   /+
   protected override void onClick(EventArgs ea) {
      _updateState();

      super.onClick(ea);
   }
   +/



   final @property void checked(bool byes) { // setter
      if(byes) {
         _check = CheckState.CHECKED;
      } else {
         _check = CheckState.UNCHECKED;
      }

      if(isHandleCreated) {
         SendMessageA(handle, BM_SETCHECK, cast(WPARAM)_check, 0);
      }
   }

   /// ditto
   // Returns true for indeterminate too.
   final @property bool checked() { // getter
      if(isHandleCreated) {
         _updateState();
      }
      return _check != CheckState.UNCHECKED;
   }



   final @property void checkState(CheckState st) { // setter
      _check = st;

      if(isHandleCreated) {
         SendMessageA(handle, BM_SETCHECK, cast(WPARAM)st, 0);
      }
   }

   /// ditto
   final @property CheckState checkState() { // getter
      if(isHandleCreated) {
         _updateState();
      }
      return _check;
   }



   void performClick() {
      //onClick(EventArgs.empty);
      SendMessageA(handle, BM_CLICK, 0, 0); // So that wndProc() gets it.
   }


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

      /+
      if(_autocheck) {
         _bstyle((_bstyle() & ~BS_RADIOBUTTON) | BS_AUTORADIOBUTTON);
      } else {
         _bstyle((_bstyle() & ~BS_AUTORADIOBUTTON) | BS_RADIOBUTTON);
      }
      +/

      SendMessageA(handle, BM_SETCHECK, cast(WPARAM)_check, 0);
   }


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

      switch(m.msg) {
            /+
         // Without this, with XP styles, the background just ends up transparent; not the requested color.
         // This erases the text when XP styles aren't enabled.
         case WM_CTLCOLORSTATIC:
         case WM_CTLCOLORBTN: {
               //if(hasVisualStyle)
               {
                  RECT rect;
                  rect.right = width;
                  rect.bottom = height;
                  FillRect(cast(HDC)m.wParam, &rect, hbrBg);
               }
            }
            break;
            +/

         default:
      }
   }
   +/


   /+ package +/ /+ protected +/ override int _rtype() { // package
      if(autoCheck) {
         return 1 | 8;   // Radio button + auto check.
      }
      return 1; // Radio button.
   }


 private:
   CheckState _check = CheckState.UNCHECKED; // Not always accurate.
   bool _autocheck = true;


   void _updateState() {
      _check = cast(CheckState)SendMessageA(handle, BM_GETCHECK, 0, 0);
   }
}