ext/ResizableLib/ResizableGrip.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 //
   3 // This file is part of ResizableLib
   4 // http://sourceforge.net/projects/resizablelib
   5 //
   6 // Copyright (C) 2000-2004 by Paolo Messina
   7 // http://www.geocities.com/ppescher - mailto:ppescher@hotmail.com
   8 //
   9 // The contents of this file are subject to the Artistic License (the "License").
  10 // You may not use this file except in compliance with the License.
  11 // You may obtain a copy of the License at:
  12 // http://www.opensource.org/licenses/artistic-license.html
  13 //
  14 // If you find this code useful, credits would be nice!
  15 //
  16 /////////////////////////////////////////////////////////////////////////////
  17
  18 /*!
  19  *  @file
  20  *  @brief Implementation of the CResizableGrip class.
  21  */
  22
  23 #include "stdafx.h"
  24 #include "ResizableGrip.h"
  25
  26 #ifdef _DEBUG
  27 #undef THIS_FILE
  28 static char THIS_FILE[]=__FILE__;
  29 #define new DEBUG_NEW
  30 #endif
  31
  32 //////////////////////////////////////////////////////////////////////
  33 // Construction/Destruction
  34 //////////////////////////////////////////////////////////////////////
  35
  36 CResizableGrip::CResizableGrip()
  37 {
  38         m_nShowCount = 0;
  39 }
  40
  41 CResizableGrip::~CResizableGrip()
  42 {
  43
  44 }
  45
  46 void CResizableGrip::UpdateSizeGrip()
  47 {
  48         if (!::IsWindow(m_wndGrip.m_hWnd))
  49                 return;
  50
  51         // size-grip goes bottom right in the client area
  52         // (any right-to-left adjustment should go here)
  53
  54         RECT rect;
  55         GetResizableWnd()->GetClientRect(&rect);
  56
  57         rect.left = rect.right - m_wndGrip.m_size.cx;
  58         rect.top = rect.bottom - m_wndGrip.m_size.cy;
  59
  60         // must stay below other children
  61         m_wndGrip.SetWindowPos(&CWnd::wndBottom, rect.left, rect.top, 0, 0,
  62                 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOREPOSITION
  63                 | (IsSizeGripVisible() ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
  64 }
  65
  66 // pbStatus points to a variable, maintained by the caller, that
  67 // holds its visibility status. Initialize the variable with 1
  68 // to allow to temporarily hide the grip, 0 to allow to
  69 // temporarily show the grip (with respect to the dwMask bit).
  70
  71 // NB: visibility is effective only after an update
  72
  73 void CResizableGrip::ShowSizeGrip(DWORD* pStatus, DWORD dwMask /*= 1*/)
  74 {
  75         ASSERT(pStatus != NULL);
  76
  77         if (!(*pStatus & dwMask))
  78         {
  79                 m_nShowCount++;
  80                 (*pStatus) |= dwMask;
  81         }
  82 }
  83
  84 void CResizableGrip::HideSizeGrip(DWORD* pStatus, DWORD dwMask /*= 1*/)
  85 {
  86         ASSERT(pStatus != NULL);
  87
  88         if (*pStatus & dwMask)
  89         {
  90                 m_nShowCount--;
  91                 (*pStatus) &= ~dwMask;
  92         }
  93 }
  94
  95 BOOL CResizableGrip::IsSizeGripVisible()
  96 {
  97         // NB: visibility is effective only after an update
  98         return (m_nShowCount > 0);
  99 }
 100
 101 void CResizableGrip::SetSizeGripVisibility(BOOL bVisible)
 102 {
 103         if (bVisible)
 104                 m_nShowCount = 1;
 105         else
 106                 m_nShowCount = 0;
 107 }
 108
 109 BOOL CResizableGrip::SetSizeGripBkMode(int nBkMode)
 110 {
 111         if (::IsWindow(m_wndGrip.m_hWnd))
 112         {
 113                 if (nBkMode == OPAQUE)
 114                         m_wndGrip.SetTransparency(FALSE);
 115                 else if (nBkMode == TRANSPARENT)
 116                         m_wndGrip.SetTransparency(TRUE);
 117                 else
 118                         return FALSE;
 119                 return TRUE;
 120         }
 121         return FALSE;
 122 }
 123
 124 void CResizableGrip::SetSizeGripShape(BOOL bTriangular)
 125 {
 126         if (::IsWindow(m_wndGrip.m_hWnd))
 127                 m_wndGrip.SetTriangularShape(bTriangular);
 128 }
 129
 130 BOOL CResizableGrip::CreateSizeGrip(BOOL bVisible /*= TRUE*/,
 131                 BOOL bTriangular /*= TRUE*/, BOOL bTransparent /*= FALSE*/)
 132 {
 133         // create grip
 134         CRect rect(0 , 0, m_wndGrip.m_size.cx, m_wndGrip.m_size.cy);
 135         BOOL bRet = m_wndGrip.Create(WS_CHILD | WS_CLIPSIBLINGS
 136                 | SBS_SIZEGRIP, rect, GetResizableWnd(), 0);
 137
 138         if (bRet)
 139         {
 140                 // set options
 141                 m_wndGrip.SetTriangularShape(bTriangular);
 142                 m_wndGrip.SetTransparency(bTransparent);
 143                 SetSizeGripVisibility(bVisible);
 144
 145                 // update position
 146                 UpdateSizeGrip();
 147         }
 148
 149         return bRet;
 150 }
 151
 152 /////////////////////////////////////////////////////////////////////////////
 153 // CSizeGrip implementation
 154
 155 BOOL CResizableGrip::CSizeGrip::IsRTL()
 156 {
 157         return GetExStyle() & WS_EX_LAYOUTRTL;
 158 }
 159
 160 BOOL CResizableGrip::CSizeGrip::PreCreateWindow(CREATESTRUCT& cs)
 161 {
 162         // set window size
 163         m_size.cx = GetSystemMetrics(SM_CXVSCROLL);
 164         m_size.cy = GetSystemMetrics(SM_CYHSCROLL);
 165
 166         cs.cx = m_size.cx;
 167         cs.cy = m_size.cy;
 168
 169         return CScrollBar::PreCreateWindow(cs);
 170 }
 171
 172 LRESULT CResizableGrip::CSizeGrip::WindowProc(UINT message,
 173                                                                                           WPARAM wParam, LPARAM lParam)
 174 {
 175         switch (message)
 176         {
 177         case WM_GETDLGCODE:
 178                 // fix to prevent the control to gain focus, using arrow keys
 179                 // (standard grip returns DLGC_WANTARROWS, like any standard scrollbar)
 180                 return DLGC_STATIC;
 181
 182         case WM_SETFOCUS:
 183                 // fix to prevent the control to gain focus, if set directly
 184                 // (for example when it's the only one control in a dialog)
 185                 return 0;
 186
 187         case WM_NCHITTEST:
 188                 // choose proper cursor shape
 189                 if (IsRTL())
 190                         return HTBOTTOMLEFT;
 191                 else
 192                         return HTBOTTOMRIGHT;
 193                 break;
 194
 195         case WM_SETTINGCHANGE:
 196                 {
 197                         // update grip's size
 198                         CSize sizeOld = m_size;
 199                         m_size.cx = GetSystemMetrics(SM_CXVSCROLL);
 200                         m_size.cy = GetSystemMetrics(SM_CYHSCROLL);
 201
 202                         // resize transparency bitmaps
 203                         if (m_bTransparent)
 204                         {
 205                                 CClientDC dc(this);
 206
 207                                 // destroy bitmaps
 208                                 m_bmGrip.DeleteObject();
 209                                 m_bmMask.DeleteObject();
 210
 211                                 // re-create bitmaps
 212                                 m_bmGrip.CreateCompatibleBitmap(&dc, m_size.cx, m_size.cy);
 213                                 m_bmMask.CreateBitmap(m_size.cx, m_size.cy, 1, 1, NULL);
 214                         }
 215
 216                         // re-calc shape
 217                         if (m_bTriangular)
 218                                 SetTriangularShape(m_bTriangular);
 219
 220                         // reposition the grip
 221                         CRect rect;
 222                         GetWindowRect(rect);
 223                         rect.InflateRect(m_size.cx - sizeOld.cx, m_size.cy - sizeOld.cy, 0, 0);
 224                         ::MapWindowPoints(NULL, GetParent()->GetSafeHwnd(), (LPPOINT)&rect, 2);
 225                         MoveWindow(rect, TRUE);
 226                 }
 227                 break;
 228
 229         case WM_DESTROY:
 230                 // perform clean up
 231                 if (m_bTransparent)
 232                         SetTransparency(FALSE);
 233                 break;
 234
 235         case WM_PAINT:
 236         case WM_PRINTCLIENT:
 237                 if (m_bTransparent)
 238                 {
 239                         PAINTSTRUCT ps;
 240                         CDC* pDC = (message == WM_PAINT && wParam == 0) ?
 241                                 BeginPaint(&ps) : CDC::FromHandle((HDC)wParam);
 242
 243                         // select bitmaps
 244                         CBitmap *pOldGrip, *pOldMask;
 245
 246                         pOldGrip = m_dcGrip.SelectObject(&m_bmGrip);
 247                         pOldMask = m_dcMask.SelectObject(&m_bmMask);
 248
 249                         // obtain original grip bitmap, make the mask and prepare masked bitmap
 250                         CScrollBar::WindowProc(message, (WPARAM)m_dcGrip.GetSafeHdc(), lParam);
 251                         m_dcGrip.SetBkColor(m_dcGrip.GetPixel(0, 0));
 252                         m_dcMask.BitBlt(0, 0, m_size.cx, m_size.cy, &m_dcGrip, 0, 0, SRCCOPY);
 253                         m_dcGrip.BitBlt(0, 0, m_size.cx, m_size.cy, &m_dcMask, 0, 0, 0x00220326);
 254
 255                         // draw transparently
 256                         pDC->BitBlt(0, 0, m_size.cx, m_size.cy, &m_dcMask, 0, 0, SRCAND);
 257                         pDC->BitBlt(0, 0, m_size.cx, m_size.cy, &m_dcGrip, 0, 0, SRCPAINT);
 258
 259                         // unselect bitmaps
 260                         m_dcGrip.SelectObject(pOldGrip);
 261                         m_dcMask.SelectObject(pOldMask);
 262
 263                         if (message == WM_PAINT && wParam == 0)
 264                                 EndPaint(&ps);
 265                         return 0;
 266                 }
 267                 break;
 268         }
 269
 270         return CScrollBar::WindowProc(message, wParam, lParam);
 271 }
 272
 273 void CResizableGrip::CSizeGrip::SetTransparency(BOOL bActivate)
 274 {
 275         // creates or deletes DCs and Bitmaps used for
 276         // implementing a transparent size grip
 277
 278         if (bActivate && !m_bTransparent)
 279         {
 280                 m_bTransparent = TRUE;
 281
 282                 CClientDC dc(this);
 283
 284                 // create memory DCs and bitmaps
 285                 m_dcGrip.CreateCompatibleDC(&dc);
 286                 m_bmGrip.CreateCompatibleBitmap(&dc, m_size.cx, m_size.cy);
 287
 288                 m_dcMask.CreateCompatibleDC(&dc);
 289                 m_bmMask.CreateBitmap(m_size.cx, m_size.cy, 1, 1, NULL);
 290         }
 291         else if (!bActivate && m_bTransparent)
 292         {
 293                 m_bTransparent = FALSE;
 294
 295                 // destroy memory DCs and bitmaps
 296                 m_dcGrip.DeleteDC();
 297                 m_bmGrip.DeleteObject();
 298
 299                 m_dcMask.DeleteDC();
 300                 m_bmMask.DeleteObject();
 301         }
 302 }
 303
 304 void CResizableGrip::CSizeGrip::SetTriangularShape(BOOL bEnable)
 305 {
 306         m_bTriangular = bEnable;
 307
 308         if (bEnable)
 309         {
 310                 // set a triangular window region
 311                 CRect rect;
 312                 GetWindowRect(rect);
 313                 rect.OffsetRect(-rect.TopLeft());
 314                 POINT arrPoints[] =
 315                 {
 316                         { rect.left, rect.bottom },
 317                         { rect.right, rect.bottom },
 318                         { rect.right, rect.top }
 319                 };
 320                 CRgn rgnGrip;
 321                 rgnGrip.CreatePolygonRgn(arrPoints, 3, WINDING);
 322                 SetWindowRgn((HRGN)rgnGrip.Detach(), IsWindowVisible());
 323         }
 324         else
 325         {
 326                 SetWindowRgn((HRGN)NULL, IsWindowVisible());
 327         }
 328 }