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

module dfl.splitter;
import core.sys.windows.windows;

import dfl.control;
import dfl.exception;
import dfl.base;
import dfl.drawing;
import dfl.event;

class SplitterEventArgs : EventArgs {

   this(int x, int y, int splitX, int splitY) {
      _x = x;
      _y = y;
      _splitX = splitX;
      _splitY = splitY;
   }

   final @property int x() {
      return _x;
   }

   final @property int y() {
      return _y;
   }

   final @property void splitX(int val) {
      _splitX = val;
   }

   final @property int splitX() {
      return _splitX;
   }

   final @property void splitY(int val) {
      _splitY = val;
   }

   final @property int splitY() {
      return _splitY;
   }

private:
   int _x, _y, _splitX, _splitY;
}

class Splitter : Control {
   this() {
      // DMD 0.95: need 'this' to access member dock
      this.dock = DockStyle.LEFT;

      if (HBRUSH.init == hbrxor) {
         inithbrxor();
      }
   }

   /+
   override @property void anchor(AnchorStyles a) {
      throw new DflException("Splitter cannot be anchored");
   }

   alias Control.anchor anchor; // Overload.
   +/

   override @property void dock(DockStyle ds) {
      switch (ds) {
      case DockStyle.LEFT:
      case DockStyle.RIGHT:
         //cursor = new Cursor(LoadCursorA(null, IDC_SIZEWE), false);
         cursor = Cursors.vSplit;
         break;

      case DockStyle.TOP:
      case DockStyle.BOTTOM:
         //cursor = new Cursor(LoadCursorA(null, IDC_SIZENS), false);
         cursor = Cursors.hSplit;
         break;

      default:
         throw new DflException("Invalid splitter dock");
      }

      super.dock(ds);
   }

   alias dock = Control.dock; // Overload.

   package void initsplit(int sx, int sy) {
      capture = true;

      downing = true;
      //downpos = Point(mea.x, mea.y);

      switch (dock) {
      case DockStyle.TOP:
      case DockStyle.BOTTOM:
         downpos = sy;
         lastpos = 0;
         drawxorClient(0, lastpos);
         break;

      default: // LEFT / RIGHT.
         downpos = sx;
         lastpos = 0;
         drawxorClient(lastpos, 0);
      }
   }

   final void resumeSplit(int sx, int sy) { // package
      if (Control.mouseButtons & MouseButtons.LEFT) {
         initsplit(sx, sy);

         if (cursor) {
            Cursor.current = cursor;
         }
      }
   }

   //
   final void resumeSplit() { // package
      Point pt = pointToClient(Cursor.position);
      return resumeSplit(pt.x, pt.y);
   }

   @property void movingGrip(bool byes) {
      if (mgrip == byes) {
         return;
      }

      this.mgrip = byes;

      if (created) {
         invalidate();
      }
   }

   @property bool movingGrip() {
      return mgrip;
   }

   deprecated alias moveingGrip = movingGrip;
   deprecated alias moveGrip = movingGrip;
   deprecated alias sizingGrip = movingGrip;

   protected override void onPaint(PaintEventArgs ea) {
      super.onPaint(ea);

      if (mgrip) {
         ea.graphics.drawMoveGrip(displayRectangle, DockStyle.LEFT == dock
            || DockStyle.RIGHT == dock);
      }
   }

   protected override void onResize(EventArgs ea) {
      if (mgrip) {
         invalidate();
      }

      resize(this, ea);
   }

   protected override void onMouseDown(MouseEventArgs mea) {
      super.onMouseDown(mea);

      if (mea.button == MouseButtons.LEFT && 1 == mea.clicks) {
         initsplit(mea.x, mea.y);
      }
   }

   protected override void onMouseMove(MouseEventArgs mea) {
      super.onMouseMove(mea);

      if (downing) {
         switch (dock) {
         case DockStyle.TOP:
         case DockStyle.BOTTOM:
            drawxorClient(0, mea.y - downpos, 0, lastpos);
            lastpos = mea.y - downpos;
            break;

         default: // LEFT / RIGHT.
            drawxorClient(mea.x - downpos, 0, lastpos, 0);
            lastpos = mea.x - downpos;
         }

         scope sea = new SplitterEventArgs(mea.x, mea.y, left, top);
         onSplitterMoving(sea);
      }
   }

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

      if (downing) { // ?
         Point curpos = Cursor.position;
         curpos = pointToClient(curpos);
         scope sea = new SplitterEventArgs(curpos.x, curpos.y, left, top);
         onSplitterMoved(sea);
      }
   }

   final Control getSplitControl() { // package
      Control splat; // Splitted.
      // DMD 0.95: need 'this' to access member dock
      //switch(dock())
      final switch (this.dock()) {
      case DockStyle.LEFT:
         foreach (Control ctrl; parent.controls()) {
            if (DockStyle.LEFT != ctrl.dock) { //if(this.dock != ctrl.dock)
               continue;
            }
            // DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
            //if(ctrl == this)
            if (ctrl == cast(Control) this) {
               return splat;
            }
            splat = ctrl;
         }
         break;

      case DockStyle.RIGHT:
         foreach (Control ctrl; parent.controls()) {
            if (DockStyle.RIGHT != ctrl.dock) { //if(this.dock != ctrl.dock)
               continue;
            }
            // DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
            //if(ctrl == this)
            if (ctrl == cast(Control) this) {
               return splat;
            }
            splat = ctrl;
         }
         break;

      case DockStyle.TOP:
         foreach (Control ctrl; parent.controls()) {
            if (DockStyle.TOP != ctrl.dock) { //if(this.dock != ctrl.dock)
               continue;
            }
            // DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
            //if(ctrl == this)
            if (ctrl == cast(Control) this) {
               return splat;
            }
            splat = ctrl;
         }
         break;

      case DockStyle.BOTTOM:
         foreach (Control ctrl; parent.controls()) {
            if (DockStyle.BOTTOM != ctrl.dock) { //if(this.dock != ctrl.dock)
               continue;
            }
            // DMD 0.95: overloads int(Object o) and int(Control ctrl) both match argument list for opEquals
            //if(ctrl == this)
            if (ctrl == cast(Control) this) {
               return splat;
            }
            splat = ctrl;
         }
         break;

      case DockStyle.FILL:
         assert("DockStyle.FILL is not allowed in Splitter");
         break;

      case DockStyle.NONE:
         assert("DockStyle.NONE is not allowed in Splitter");
         break;
      }
      return null;
   }

   protected override void onMouseUp(MouseEventArgs mea) {
      if (downing) {
         capture = false;

         downing = false;

         if (mea.button != MouseButtons.LEFT) {
            // Abort.
            switch (dock) {
            case DockStyle.TOP:
            case DockStyle.BOTTOM:
               drawxorClient(0, lastpos);
               break;

            default: // LEFT / RIGHT.
               drawxorClient(lastpos, 0);
            }
            super.onMouseUp(mea);
            return;
         }

         int adj, val, vx;
         auto splat = getSplitControl(); // Splitted.
         if (splat) {
            // DMD 0.95: need 'this' to access member dock
            //switch(dock())
            switch (this.dock()) {
            case DockStyle.LEFT:
               drawxorClient(lastpos, 0);
               //val = left - splat.left + mea.x - downpos.x;
               val = left - splat.left + mea.x - downpos;
               if (val < msize) {
                  val = msize;
               }
               splat.width = val;
               break;

            case DockStyle.RIGHT:
               drawxorClient(lastpos, 0);
               //adj = right - splat.left + mea.x - downpos.x;
               adj = right - splat.left + mea.x - downpos;
               val = splat.width - adj;
               vx = splat.left + adj;
               if (val < msize) {
                  vx -= msize - val;
                  val = msize;
               }
               splat.bounds = Rect(vx, splat.top, val, splat.height);
               break;

            case DockStyle.TOP:
               drawxorClient(0, lastpos);
               //val = top - splat.top + mea.y - downpos.y;
               val = top - splat.top + mea.y - downpos;
               if (val < msize) {
                  val = msize;
               }
               splat.height = val;
               break;

            case DockStyle.BOTTOM:
               drawxorClient(0, lastpos);
               //adj = bottom - splat.top + mea.y - downpos.y;
               adj = bottom - splat.top + mea.y - downpos;
               val = splat.height - adj;
               vx = splat.top + adj;
               if (val < msize) {
                  vx -= msize - val;
                  val = msize;
               }
               splat.bounds = Rect(splat.left, vx, splat.width, val);
               break;

            default:
            }
         }

         // This is needed when the moved control first overlaps the splitter and the splitter
         // gets bumped over, causing a little area to not be updated correctly.
         // I'll fix it someday.
         parent.invalidate(true);

         // Event..
      }

      super.onMouseUp(mea);
   }

   /+
   // Not quite sure how to implement this yet.
   // Might need to scan all controls until one of:
   //    Control with opposite dock (right if left dock): stay -mextra- away from it,
   //    Control with fill dock: that control can't have less than -mextra- width,
   //    Reached end of child controls: stay -mextra- away from the edge.


   final @property void minExtra(int min) {
      mextra = min;
   }


   final @property int minExtra() {
      return mextra;
   }
   +/

   final @property void minSize(int min) {
      msize = min;
   }

   final @property int minSize() {
      return msize;
   }

   final @property void splitPosition(int pos) {
      auto splat = getSplitControl(); // Splitted.
      if (splat) {
         // DMD 0.95: need 'this' to access member dock
         //switch(dock())
         switch (this.dock()) {
         case DockStyle.LEFT:
         case DockStyle.RIGHT:
            splat.width = pos;
            break;

         case DockStyle.TOP:
         case DockStyle.BOTTOM:
            splat.height = pos;
            break;

         default:
         }
      }
   }

   // -1 if not docked to a control.
   final @property int splitPosition() {
      auto splat = getSplitControl(); // Splitted.
      if (splat) {
         // DMD 0.95: need 'this' to access member dock
         //switch(dock())
         switch (this.dock()) {
         case DockStyle.LEFT:
         case DockStyle.RIGHT:
            return splat.width;

         case DockStyle.TOP:
         case DockStyle.BOTTOM:
            return splat.height;

         default:
         }
      }
      return -1;
   }

   //SplitterEventHandler splitterMoved;
   Event!(Splitter, SplitterEventArgs) splitterMoved;
   //SplitterEventHandler splitterMoving;
   Event!(Splitter, SplitterEventArgs) splitterMoving;

protected:

   override @property Size defaultSize() {
      //return Size(GetSystemMetrics(SM_CXSIZEFRAME), GetSystemMetrics(SM_CYSIZEFRAME));
      int sx = GetSystemMetrics(SM_CXSIZEFRAME);
      int sy = GetSystemMetrics(SM_CYSIZEFRAME);
      // Need a bit extra room for the move-grips.
      if (sx < 5) {
         sx = 5;
      }
      if (sy < 5) {
         sy = 5;
      }
      return Size(sx, sy);
   }

   void onSplitterMoving(SplitterEventArgs sea) {
      splitterMoving(this, sea);
   }

   void onSplitterMoved(SplitterEventArgs sea) {
      splitterMoving(this, sea);
   }

private:

   bool downing = false;
   bool mgrip = true;
   //Point downpos;
   int downpos;
   int lastpos;
   int msize = 25; // Min size of control that's being sized from the splitter.
   int mextra = 25; // Min size of the control on the opposite side.

   static HBRUSH hbrxor;

   static void inithbrxor() {
      static ubyte[] bmbits = [
         0xAA, 0, 0x55, 0, 0xAA, 0, 0x55, 0, 0xAA, 0, 0x55, 0, 0xAA, 0, 0x55, 0,
      ];

      HBITMAP hbm;
      hbm = CreateBitmap(8, 8, 1, 1, bmbits.ptr);
      hbrxor = CreatePatternBrush(hbm);
      DeleteObject(hbm);
   }

   static void drawxor(HDC hdc, Rect r) {
      SetBrushOrgEx(hdc, r.x, r.y, null);
      HGDIOBJ hbrold = SelectObject(hdc, hbrxor);
      PatBlt(hdc, r.x, r.y, r.width, r.height, PATINVERT);
      SelectObject(hdc, hbrold);
   }

   void drawxorClient(HDC hdc, int x, int y) {
      POINT pt;
      pt.x = x;
      pt.y = y;
      //ClientToScreen(handle, &pt);
      MapWindowPoints(handle, parent.handle, &pt, 1);

      drawxor(hdc, Rect(pt.x, pt.y, width, height));
   }

   void drawxorClient(int x, int y, int xold = int.min, int yold = int.min) {
      HDC hdc;
      //hdc = GetWindowDC(null);
      hdc = GetDCEx(parent.handle, null, DCX_CACHE);

      if (xold != int.min) {
         drawxorClient(hdc, xold, yold);
      }

      drawxorClient(hdc, x, y);

      ReleaseDC(null, hdc);
   }
}