module dfl.toolbar;

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

version(DFL_NO_IMAGELIST) {
}
else {
   private import dfl.imagelist;
}

version(DFL_NO_MENUS)
version = DFL_TOOLBAR_NO_MENU;

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



enum ToolBarButtonStyle: ubyte {
   PUSH_BUTTON = TBSTYLE_BUTTON, ///
   TOGGLE_BUTTON = TBSTYLE_CHECK, /// ditto
   SEPARATOR = TBSTYLE_SEP, /// ditto
   //DROP_DOWN_BUTTON = TBSTYLE_DROPDOWN, /// ditto
   DROP_DOWN_BUTTON = TBSTYLE_DROPDOWN | BTNS_WHOLEDROPDOWN, /// ditto
}



class ToolBarButton {

   this() {
      Application.ppin(cast(void*)this);
   }


   this(Dstring text) {
      this();

      this.text = text;
   }


   version(DFL_NO_IMAGELIST) {
   }
   else {

      final @property void imageIndex(int index) { // setter
         this._imgidx = index;

         //if(tbar && tbar.created)
         // tbar.updateItem(this);
      }

      /// ditto
      final @property int imageIndex() { // getter
         return _imgidx;
      }
   }



   @property void text(Dstring newText) { // setter
      _text = newText;

      //if(tbar && tbar.created)
      //
   }

   /// ditto
   @property Dstring text() { // getter
      return _text;
   }



   final @property void style(ToolBarButtonStyle st) { // setter
      this._style = st;

      //if(tbar && tbar.created)
      //
   }

   /// ditto
   final @property ToolBarButtonStyle style() { // getter
      return _style;
   }


   override Dstring toString() {
      return text;
   }


   override Dequ opEquals(Object o) {
      return text == getObjectString(o);
   }


   Dequ opEquals(Dstring val) {
      return text == val;
   }


   override int opCmp(Object o) {
      return stringICmp(text, getObjectString(o));
   }


   int opCmp(Dstring val) {
      return stringICmp(text, val);
   }



   final @property void tag(Object o) { // setter
      _tag = o;
   }

   /// ditto
   final @property Object tag() { // getter
      return _tag;
   }


   version(DFL_TOOLBAR_NO_MENU) {
   }
   else {

      final @property void dropDownMenu(ContextMenu cmenu) { // setter
         _cmenu = cmenu;
      }

      /// ditto
      final @property ContextMenu dropDownMenu() { // getter
         return _cmenu;
      }
   }



   final @property ToolBar parent() { // getter
      return tbar;
   }



   final @property Rect rectangle() { // getter
      //if(!tbar || !tbar.created)
      if(!visible) {
         return Rect(0, 0, 0, 0);   // ?
      }
      assert(tbar !is null);
      RECT rect;
      //assert(-1 != tbar.buttons.indexOf(this));
      tbar.prevwproc(TB_GETITEMRECT, tbar.buttons.indexOf(this), cast(LPARAM)&rect); // Fails if item is hidden.
      return Rect(&rect); // Should return all 0`s if TB_GETITEMRECT failed.
   }



   final @property void visible(bool byes) { // setter
      if(byes) {
         _state &= ~TBSTATE_HIDDEN;
      } else {
         _state |= TBSTATE_HIDDEN;
      }

      if(tbar && tbar.created) {
         tbar.prevwproc(TB_SETSTATE, _id, MAKELPARAM(_state, 0));
      }
   }

   /// ditto
   final @property bool visible() { // getter
      if(!tbar || !tbar.created) {
         return false;
      }
      return true; // To-do: get actual hidden state.
   }



   final @property void enabled(bool byes) { // setter
      if(byes) {
         _state |= TBSTATE_ENABLED;
      } else {
         _state &= ~TBSTATE_ENABLED;
      }

      if(tbar && tbar.created) {
         tbar.prevwproc(TB_SETSTATE, _id, MAKELPARAM(_state, 0));
      }
   }

   /// ditto
   final @property bool enabled() { // getter
      if(_state & TBSTATE_ENABLED) {
         return true;
      }
      return false;
   }



   final @property void pushed(bool byes) { // setter
      if(byes) {
         _state = (_state & ~TBSTATE_INDETERMINATE) | TBSTATE_CHECKED;
      } else {
         _state &= ~TBSTATE_CHECKED;
      }

      if(tbar && tbar.created) {
         tbar.prevwproc(TB_SETSTATE, _id, MAKELPARAM(_state, 0));
      }
   }

   /// ditto
   final @property bool pushed() { // getter
      if(TBSTATE_CHECKED == (_state & TBSTATE_CHECKED)) {
         return true;
      }
      return false;
   }



   final @property void partialPush(bool byes) { // setter
      if(byes) {
         _state = (_state & ~TBSTATE_CHECKED) | TBSTATE_INDETERMINATE;
      } else {
         _state &= ~TBSTATE_INDETERMINATE;
      }

      if(tbar && tbar.created) {
         tbar.prevwproc(TB_SETSTATE, _id, MAKELPARAM(_state, 0));
      }
   }

   /// ditto
   final @property bool partialPush() { // getter
      if(TBSTATE_INDETERMINATE == (_state & TBSTATE_INDETERMINATE)) {
         return true;
      }
      return false;
   }


 private:
   ToolBar tbar;
   int _id = 0;
   Dstring _text;
   Object _tag;
   ToolBarButtonStyle _style = ToolBarButtonStyle.PUSH_BUTTON;
   BYTE _state = TBSTATE_ENABLED;
   version(DFL_TOOLBAR_NO_MENU) {
   }
   else {
      ContextMenu _cmenu;
   }
   version(DFL_NO_IMAGELIST) {
   }
   else {
      int _imgidx = -1;
   }
}



class ToolBarButtonClickEventArgs: EventArgs {
   this(ToolBarButton tbbtn) {
      _btn = tbbtn;
   }



   final @property ToolBarButton button() { // getter
      return _btn;
   }


 private:

   ToolBarButton _btn;
}



class ToolBar: ControlSuperClass { // docmain
   class ToolBarButtonCollection {
      protected this() {
      }


    private:

      ToolBarButton[] _buttons;


      void _adding(size_t idx, ToolBarButton val) {
         if(val.tbar) {
            throw new DflException("ToolBarButton already belongs to a ToolBar");
         }
      }


      void _added(size_t idx, ToolBarButton val) {
         val.tbar = tbar;
         val._id = tbar._allocTbbID();

         if(created) {
            _ins(idx, val);
         }
      }


      void _removed(size_t idx, ToolBarButton val) {
         if(size_t.max == idx) { // Clear all.
         } else {
            if(created) {
               prevwproc(TB_DELETEBUTTON, idx, 0);
            }
            val.tbar = null;
         }
      }


    public:

      mixin ListWrapArray!(ToolBarButton, _buttons,
                           _adding, _added,
                           _blankListCallback!(ToolBarButton), _removed,
                           true, false, false,
                           true); // CLEAR_EACH
   }


   private @property ToolBar tbar() {
      return this;
   }


   this() {
      _initToolbar();

      _tbuttons = new ToolBarButtonCollection();

      dock = DockStyle.TOP;

      //wexstyle |= WS_EX_CLIENTEDGE;
      wclassStyle = toolbarClassStyle;
   }



   final @property ToolBarButtonCollection buttons() { // getter
      return _tbuttons;
   }


   // buttonSize...



   final @property Size imageSize() { // getter
      version(DFL_NO_IMAGELIST) {
      }
      else {
         if(_imglist) {
            return _imglist.imageSize;
         }
      }
      return Size(16, 16); // ?
   }


   version(DFL_NO_IMAGELIST) {
   }
   else {

      final @property void imageList(ImageList imglist) { // setter
         if(isHandleCreated) {
            prevwproc(TB_SETIMAGELIST, 0, cast(WPARAM)imglist.handle);
         }

         _imglist = imglist;
      }

      /// ditto
      final @property ImageList imageList() { // getter
         return _imglist;
      }
   }



   Event!(ToolBar, ToolBarButtonClickEventArgs) buttonClick;



   protected void onButtonClick(ToolBarButtonClickEventArgs ea) {
      buttonClick(this, ea);
   }


   protected override void onReflectedMessage(ref Message m) {
      switch(m.msg) {
         case WM_NOTIFY: {
               auto nmh = cast(LPNMHDR)m.lParam;
               switch(nmh.code) {
                  case NM_CLICK: {
                        auto nmm = cast(LPNMMOUSE)nmh;
                        if(nmm.dwItemData) {
                           auto tbb = cast(ToolBarButton)cast(void*)nmm.dwItemData;
                           scope ToolBarButtonClickEventArgs bcea = new ToolBarButtonClickEventArgs(tbb);
                           onButtonClick(bcea);
                        }
                     }
                     break;

                  case TBN_DROPDOWN:
                     version(DFL_TOOLBAR_NO_MENU) { // This condition might be removed later.
                     }
                     else { // Ditto.
                        auto nmtb = cast(LPNMTOOLBARA)nmh; // NMTOOLBARA/NMTOOLBARW doesn't matter here; string fields not used.
                        auto tbb = buttomFromID(nmtb.iItem);
                        if(tbb) {
                           version(DFL_TOOLBAR_NO_MENU) { // Keep this here in case the other condition is removed.
                           }
                           else { // Ditto.
                              if(tbb._cmenu) {
                                 auto brect = tbb.rectangle;
                                 tbb._cmenu.show(this, pointToScreen(Point(brect.x, brect.bottom)));
                                 // Note: showing a menu also triggers a click!
                              }
                           }
                        }
                     }
                     m.result = TBDDRET_DEFAULT;
                     return;

                  default:
               }
            }
            break;

         default:
            super.onReflectedMessage(m);
      }
   }


   protected override @property Size defaultSize() { // getter
      return Size(100, 16);
   }


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

      cp.className = TOOLBAR_CLASSNAME;
   }



   // Used internally
   /+package+/ final ToolBarButton buttomFromID(int id) { // package
      foreach(tbb; _tbuttons._buttons) {
         if(id == tbb._id) {
            return tbb;
         }
      }
      return null;
   }


   package int _lastTbbID = 0;

   package final int _allocTbbID() {
      for(int j = 0; j != 250; j++) {
         _lastTbbID++;
         if(_lastTbbID >= short.max) {
            _lastTbbID = 1;
         }

         if(!buttomFromID(_lastTbbID)) {
            return _lastTbbID;
         }
      }
      return 0;
   }



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

      static assert(TBBUTTON.sizeof == 20);
      prevwproc(TB_BUTTONSTRUCTSIZE, TBBUTTON.sizeof, 0);

      //prevwproc(TB_SETPADDING, 0, MAKELPARAM(0, 0));

      version(DFL_NO_IMAGELIST) {
      }
      else {
         if(_imglist) {
            prevwproc(TB_SETIMAGELIST, 0, cast(WPARAM)_imglist.handle);
         }
      }

      foreach(idx, tbb; _tbuttons._buttons) {
         _ins(idx, tbb);
      }

      //prevwproc(TB_AUTOSIZE, 0, 0);
   }


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


 private:

   ToolBarButtonCollection _tbuttons;

   version(DFL_NO_IMAGELIST) {
   }
   else {
      ImageList _imglist;
   }


   void _ins(size_t idx, ToolBarButton tbb) {
      // To change: TB_SETBUTTONINFO

      TBBUTTON xtb;
      version(DFL_NO_IMAGELIST) {
         xtb.iBitmap = -1;
      }
      else {
         xtb.iBitmap = tbb._imgidx;
      }
      xtb.idCommand = tbb._id;
      xtb.dwData = cast(DWORD)cast(void*)tbb;
      xtb.fsState = tbb._state;
      xtb.fsStyle = TBSTYLE_AUTOSIZE | tbb._style; // TBSTYLE_AUTOSIZE factors in the text's width instead of default button size.
      LRESULT lresult;
      // MSDN says iString can be either an int offset or pointer to a string buffer.
      if(dfl.internal.utf.useUnicode) {
         if(tbb._text.length) {
            xtb.iString = cast(typeof(xtb.iString))dfl.internal.utf.toUnicodez(tbb._text);
         }
         //prevwproc(TB_ADDBUTTONSW, 1, cast(LPARAM)&xtb);
         lresult = prevwproc(TB_INSERTBUTTONW, idx, cast(LPARAM)&xtb);
      } else {
         if(tbb._text.length) {
            xtb.iString = cast(typeof(xtb.iString))dfl.internal.utf.toAnsiz(tbb._text);
         }
         //prevwproc(TB_ADDBUTTONSA, 1, cast(LPARAM)&xtb);
         lresult = prevwproc(TB_INSERTBUTTONA, idx, cast(LPARAM)&xtb);
      }
      //if(!lresult)
      // throw new DflException("Unable to add ToolBarButton");
   }


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


private {
   enum TOOLBAR_CLASSNAME = "DFL_ToolBar";

   WNDPROC toolbarPrevWndProc;

   LONG toolbarClassStyle;

   void _initToolbar() {
      if(!toolbarPrevWndProc) {
         _initCommonControls(ICC_BAR_CLASSES);

         dfl.internal.utf.WndClass info;
         toolbarPrevWndProc = superClass(HINSTANCE.init, "ToolbarWindow32", TOOLBAR_CLASSNAME, info);
         if(!toolbarPrevWndProc) {
            _unableToInit(TOOLBAR_CLASSNAME);
         }
         toolbarClassStyle = info.wc.style;
      }
   }
}