src/Utils/MiscUI/SplitterControl.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2019-2021 - TortoiseGit
   4 // Copyright (C) 2003-2006, 2008-2013, 2017, 2020 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21 #include "SplitterControl.h"
  22 #include "MyMemDC.h"
  23 #include "Theme.h"
  24
  25 #ifdef _DEBUG
  26 #define new DEBUG_NEW
  27 #undef THIS_FILE
  28 static char THIS_FILE[] = __FILE__;
  29 #endif
  30
  31 /////////////////////////////////////////////////////////////////////////////
  32 // CSplitterControl
  33
  34 // hCursor1 is for vertical one
  35 // and hCursor2 is for horizontal one
  36 static HCURSOR SplitterControl_hCursor1 = nullptr;
  37 static HCURSOR SplitterControl_hCursor2 = nullptr;
  38
  39 CSplitterControl::CSplitterControl()
  40         : m_bIsPressed(false)
  41         , m_nMin(-1)
  42         , m_nMax(-1)
  43         , m_bMouseOverControl(false)
  44         , m_nType(0)
  45         , m_nX(0)
  46         , m_nY(0)
  47         , m_nSavePos(0)
  48 {
  49         m_AnimVarHot = Animator::Instance().CreateAnimationVariable(0.0);
  50
  51         // GDI+ initialization
  52         Gdiplus::GdiplusStartupInput input;
  53         Gdiplus::GdiplusStartup(&m_gdiPlusToken, &input, nullptr);
  54 }
  55
  56 CSplitterControl::~CSplitterControl()
  57 {
  58         // GDI+ cleanup
  59         Gdiplus::GdiplusShutdown(m_gdiPlusToken);
  60 }
  61
  62
  63 BEGIN_MESSAGE_MAP(CSplitterControl, CStatic)
  64         ON_WM_PAINT()
  65         ON_WM_MOUSEMOVE()
  66         ON_WM_SETCURSOR()
  67         ON_WM_LBUTTONDOWN()
  68         ON_WM_LBUTTONUP()
  69         ON_WM_ERASEBKGND()
  70         ON_MESSAGE(WM_MOUSELEAVE, OnMouseLeave)
  71 END_MESSAGE_MAP()
  72
  73 /////////////////////////////////////////////////////////////////////////////
  74 // CSplitterControl message handlers
  75
  76
  77 // Set style for splitter control
  78 // nStyle = SPS_VERTICAL or SPS_HORIZONTAL
  79 int CSplitterControl::SetSplitterStyle(int nStyle)
  80 {
  81         int m_nOldStyle = m_nType;
  82         m_nType = nStyle;
  83         return m_nOldStyle;
  84 }
  85 int CSplitterControl::GetSplitterStyle()
  86 {
  87         return m_nType;
  88 }
  89
  90 void CSplitterControl::OnPaint()
  91 {
  92         CPaintDC dcreal(this); // device context for painting
  93         {
  94                 CRect rcClient;
  95                 GetClientRect(rcClient);
  96                 Gdiplus::Rect rc(rcClient.left, rcClient.top, rcClient.Width(), rcClient.Height());
  97                 Gdiplus::Graphics g(dcreal);
  98
  99                 Gdiplus::Color c1;
 100                 c1.SetFromCOLORREF(CTheme::Instance().IsDarkTheme() ? CTheme::darkBkColor : GetSysColor(COLOR_3DFACE));
 101                 Gdiplus::Color c2;
 102                 c2.SetFromCOLORREF(CTheme::Instance().GetThemeColor(GetSysColor(COLOR_BTNSHADOW)));
 103
 104                 Gdiplus::SolidBrush bkgBrush(c1);
 105                 g.FillRectangle(&bkgBrush, rc);
 106
 107                 // m_AnimVarHot changes from 0.0 (not hot) to 1.0 (hot)
 108                 auto alpha = Animator::GetValue(m_AnimVarHot);
 109                 c1.SetValue(Gdiplus::Color::MakeARGB(BYTE(alpha*255.0), c1.GetRed(), c1.GetBlue(), c1.GetGreen()));
 110                 c2.SetValue(Gdiplus::Color::MakeARGB(BYTE(alpha*255.0), c2.GetRed(), c2.GetBlue(), c2.GetGreen()));
 111
 112                 if (m_nType == SPS_VERTICAL)
 113                 {
 114                         Gdiplus::LinearGradientBrush b1(Gdiplus::Point(rc.GetLeft(), rc.GetBottom()), Gdiplus::Point(rc.GetLeft() + rc.Width/2, rc.GetBottom()), c1, c2);
 115
 116                         Gdiplus::LinearGradientBrush b2(Gdiplus::Point(rc.GetLeft() + rc.Width / 2, rc.GetBottom()), Gdiplus::Point(rc.GetRight(), rc.GetBottom()), c2, c1);
 117
 118                         g.FillRectangle(&b1, Gdiplus::Rect(rcClient.left, rcClient.top, rcClient.Width()/2, rcClient.Height()));
 119                         g.FillRectangle(&b2, Gdiplus::Rect(rcClient.left+rcClient.Width()/2, rcClient.top, rcClient.Width()/2, rcClient.Height()));
 120                 }
 121                 else
 122                 {
 123                         Gdiplus::LinearGradientBrush b1(Gdiplus::Point(rc.GetLeft(), rc.GetBottom()), Gdiplus::Point(rc.GetLeft(), rc.GetTop() + rc.Height / 2), c1, c2);
 124
 125                         Gdiplus::LinearGradientBrush b2(Gdiplus::Point(rc.GetLeft(), rc.GetTop() + rc.Height / 2), Gdiplus::Point(rc.GetLeft(), rc.GetTop()), c2, c1);
 126
 127                         g.FillRectangle(&b1, Gdiplus::Rect(rcClient.left, rcClient.top + rcClient.Height() / 2, rcClient.Width(), rcClient.Height()));
 128                         g.FillRectangle(&b2, Gdiplus::Rect(rcClient.left, rcClient.top, rcClient.Width(), rcClient.Height() / 2));
 129                 }
 130
 131
 132                 //dc.SetBkColor(GetSysColor(COLOR_3DFACE));
 133                 //dc.ExtTextOut(0, 0, ETO_OPAQUE, &rcClient, NULL, 0, NULL);
 134
 135                 //auto c2 = ::GetSysColor(COLOR_BTNSHADOW);
 136                 //auto c1 = ::GetSysColor(COLOR_3DFACE);
 137
 138                 //// m_AnimVarHot changes from 0.0 (not hot) to 1.0 (hot)
 139                 //auto fraction = Animator::GetValue(m_AnimVarHot);
 140
 141                 //int r1 = static_cast<int>(GetRValue(c1)); int g1 = static_cast<int>(GetGValue(c1)); int b1 = static_cast<int>(GetBValue(c1));
 142                 //int r2 = static_cast<int>(GetRValue(c2)); int g2 = static_cast<int>(GetGValue(c2)); int b2 = static_cast<int>(GetBValue(c2));
 143                 //auto clr = RGB((r2 - r1)*fraction + r1, (g2 - g1)*fraction + g1, (b2 - b1)*fraction + b1);
 144
 145                 //CBrush brush;
 146                 //brush.CreateHatchBrush(HS_DIAGCROSS, clr);
 147
 148                 //auto oldBrush = dc.SelectObject(&brush);
 149                 //rcClient.DeflateRect(1, 1, 1, 1);
 150                 //dc.FillRect(&rcClient, &brush);
 151                 //dc.SelectObject(&oldBrush);
 152         }
 153 }
 154
 155 void CSplitterControl::OnMouseMove(UINT nFlags, CPoint point)
 156 {
 157         if (m_bIsPressed)
 158         {
 159                 CWnd * pParent = GetParent();
 160                 {
 161                         CPoint pt = point;
 162                         ClientToScreen(&pt);
 163                         pParent->ScreenToClient(&pt);
 164
 165                         if (pt.x < m_nMin)
 166                                 pt.x = m_nMin;
 167                         if (pt.y < m_nMin)
 168                                 pt.y = m_nMin;
 169
 170                         if (pt.x > m_nMax)
 171                                 pt.x = m_nMax;
 172                         if (pt.y > m_nMax)
 173                                 pt.y = m_nMax;
 174
 175                         GetParent()->ClientToScreen(&pt);
 176                         m_nX = pt.x;
 177                         m_nY = pt.y;
 178                 }
 179                 CPoint pt(m_nX, m_nY);
 180                 CWnd* pOwner = GetOwner();
 181                 if (pOwner && IsWindow(pOwner->m_hWnd))
 182                 {
 183                         CRect rc;
 184                         int delta;
 185                         pOwner->GetClientRect(rc);
 186                         pOwner->ScreenToClient(&pt);
 187                         MoveWindowTo(pt);
 188
 189                         if (m_nType == SPS_VERTICAL)
 190                                 delta = m_nX - m_nSavePos;
 191                         else
 192                                 delta = m_nY - m_nSavePos;
 193
 194                         SPC_NMHDR nmsp;
 195                         nmsp.hdr.hwndFrom = m_hWnd;
 196                         nmsp.hdr.idFrom = GetDlgCtrlID();
 197                         nmsp.hdr.code = SPN_SIZED;
 198                         nmsp.delta = delta;
 199
 200                         pOwner->SendMessage(WM_NOTIFY, nmsp.hdr.idFrom, reinterpret_cast<LPARAM>(&nmsp));
 201                         if (m_nType == SPS_VERTICAL)
 202                                 m_nSavePos = m_nX;
 203                         else
 204                                 m_nSavePos = m_nY;
 205                         pOwner->Invalidate();
 206                 }
 207
 208         }
 209         else if (!m_bMouseOverControl)
 210         {
 211                 TRACKMOUSEEVENT Tme;
 212                 Tme.cbSize = sizeof(TRACKMOUSEEVENT);
 213                 Tme.dwFlags = TME_LEAVE;
 214                 Tme.hwndTrack = m_hWnd;
 215                 TrackMouseEvent(&Tme);
 216
 217                 m_bMouseOverControl = true;
 218                 auto transHot = Animator::Instance().CreateLinearTransition(0.3, 1.0);
 219                 auto storyBoard = Animator::Instance().CreateStoryBoard();
 220                 if (storyBoard && transHot && m_AnimVarHot)
 221                 {
 222                         storyBoard->AddTransition(m_AnimVarHot, transHot);
 223                         Animator::Instance().RunStoryBoard(storyBoard, [this]()
 224                         {
 225                                 if (!this->GetSafeHwnd())
 226                                         return;
 227                                 InvalidateRect(nullptr, false);
 228                         });
 229                 }
 230         }
 231         CStatic::OnMouseMove(nFlags, point);
 232 }
 233
 234 LRESULT CSplitterControl::OnMouseLeave(WPARAM /*wParam*/, LPARAM /*lParam*/)
 235 {
 236         if (m_bMouseOverControl)
 237         {
 238                 auto transHot = Animator::Instance().CreateLinearTransition(0.3, 0.0);
 239                 auto storyBoard = Animator::Instance().CreateStoryBoard();
 240                 if (storyBoard && transHot && m_AnimVarHot)
 241                 {
 242                         storyBoard->AddTransition(m_AnimVarHot, transHot);
 243                         Animator::Instance().RunStoryBoard(storyBoard, [this]()
 244                         {
 245                                 if (!this->GetSafeHwnd())
 246                                         return;
 247                                 InvalidateRect(nullptr, false);
 248                         });
 249                 }
 250         }
 251         m_bMouseOverControl = false;
 252         return 0;
 253 }
 254
 255 BOOL CSplitterControl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 256 {
 257         if (nHitTest == HTCLIENT)
 258         {
 259                 (m_nType == SPS_VERTICAL)?(::SetCursor(SplitterControl_hCursor1))
 260                         :(::SetCursor(SplitterControl_hCursor2));
 261                 return 0;
 262         }
 263         else
 264                 return CStatic::OnSetCursor(pWnd, nHitTest, message);
 265 }
 266
 267 void CSplitterControl::OnLButtonDown(UINT nFlags, CPoint point)
 268 {
 269         CStatic::OnLButtonDown(nFlags, point);
 270
 271         m_bIsPressed = true;
 272         SetCapture();
 273         CRect rcWnd;
 274         GetWindowRect(rcWnd);
 275
 276         if (m_nType == SPS_VERTICAL)
 277                 m_nX = rcWnd.left + rcWnd.Width() / 2;
 278
 279         else
 280                 m_nY = rcWnd.top  + rcWnd.Height() / 2;
 281
 282         if (m_nType == SPS_VERTICAL)
 283                 m_nSavePos = m_nX;
 284         else
 285                 m_nSavePos = m_nY;
 286 }
 287
 288 void CSplitterControl::OnLButtonUp(UINT nFlags, CPoint point)
 289 {
 290         CStatic::OnLButtonUp(nFlags, point);
 291         m_bIsPressed = false;
 292         ReleaseCapture();
 293 }
 294
 295 void CSplitterControl::MoveWindowTo(CPoint pt)
 296 {
 297         CRect rc;
 298         GetWindowRect(rc);
 299         CWnd* pParent;
 300         pParent = GetParent();
 301         if (!pParent || !::IsWindow(pParent->m_hWnd))
 302                 return;
 303
 304         pParent->ScreenToClient(rc);
 305         if (m_nType == SPS_VERTICAL)
 306         {
 307                 int nMidX = (rc.left + rc.right) / 2;
 308                 int dx = pt.x - nMidX;
 309                 rc.OffsetRect(dx, 0);
 310         }
 311         else
 312         {
 313                 int nMidY = (rc.top + rc.bottom) / 2;
 314                 int dy = pt.y - nMidY;
 315                 rc.OffsetRect(0, dy);
 316         }
 317         MoveWindow(rc);
 318 }
 319
 320 HDWP CSplitterControl::ChangeRect(HDWP hdwp, CWnd * pWnd, int dleft, int dtop, int dright, int dbottom)
 321 {
 322         CWnd* pParent = pWnd->GetParent();
 323         if (pParent && ::IsWindow(pParent->m_hWnd))
 324         {
 325                 CRect rcWnd;
 326                 pWnd->GetWindowRect(rcWnd);
 327                 pParent->ScreenToClient(rcWnd);
 328                 rcWnd.left += dleft;
 329                 rcWnd.top += dtop;
 330                 rcWnd.right += dright;
 331                 rcWnd.bottom += dbottom;
 332
 333                 return DeferWindowPos(hdwp, pWnd->GetSafeHwnd(), nullptr, rcWnd.left, rcWnd.top, rcWnd.Width(), rcWnd.Height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOREDRAW | SWP_NOZORDER);
 334                 //pWnd->MoveWindow(rcWnd);
 335         }
 336         return hdwp;
 337 }
 338
 339 void CSplitterControl::SetRange(int nMin, int nMax)
 340 {
 341         m_nMin = nMin;
 342         m_nMax = nMax;
 343 }
 344
 345 // Set splitter range from (nRoot - nSubtraction) to (nRoot + nAddition)
 346 // If (nRoot < 0)
 347 //              nRoot =  <current position of the splitter>
 348 void CSplitterControl::SetRange(int nSubtraction, int nAddition, int nRoot)
 349 {
 350         if (nRoot < 0)
 351         {
 352                 CRect rcWnd;
 353                 GetWindowRect(rcWnd);
 354                 if (m_nType == SPS_VERTICAL)
 355                         nRoot = rcWnd.left + rcWnd.Width() / 2;
 356                 else // if m_nType == SPS_HORIZONTAL
 357                         nRoot = rcWnd.top + rcWnd.Height() / 2;
 358         }
 359         m_nMin = nRoot - nSubtraction;
 360         m_nMax = nRoot + nAddition;
 361 }
 362 void CSplitterControl::PreSubclassWindow()
 363 {
 364         // Enable notifications - CStatic has this disabled by default
 365         ModifyStyle(0, SS_NOTIFY);
 366
 367         CRect rc;
 368         GetClientRect(rc);
 369
 370         // Determine default type base on it's size.
 371         m_nType = (rc.Width() < rc.Height())?SPS_VERTICAL:SPS_HORIZONTAL;
 372
 373         if (!SplitterControl_hCursor1)
 374         {
 375                 SplitterControl_hCursor1 = AfxGetApp()->LoadStandardCursor(IDC_SIZEWE);
 376                 SplitterControl_hCursor2 = AfxGetApp()->LoadStandardCursor(IDC_SIZENS);
 377         }
 378
 379         // force the splitter not to be splitted.
 380         SetRange(0, 0, -1);
 381
 382
 383         CStatic::PreSubclassWindow();
 384 }
 385
 386 BOOL CSplitterControl::OnEraseBkgnd(CDC* /*pDC*/)
 387 {
 388         return TRUE;
 389 }
 390