src/Utils/MiscUI/SplitterControl.cpp

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