src/ui/ResizableLib/ResizableGrip.cpp

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