Selection Rectangle: An Implementation in "Explorer style" :)

• Download EXE - 64.1 KB
• Download project - 131.92 KB
• Download source - 1.83 KB

Introduction

Hello.

I could not find a complete replacement for the old API function DrawFocusRect(...) to use it in my views...

So I did it my way. Now it's here, for your response too.

Background

A layered window could play the role of such selection rectangle in an excellent manner - because of its possibility to be shown with the alpha blending. In this case, we don't need to control the repainting of the client area of the parent view of selection (it would be necessary when we would draw something dynamically changeable in its dimensions in the device context of the parent view).

I have written a class CCoverWnd : public CWnd to implement the behaviour of the selection rectangle. This window must be semi-transparent now layered in its job.

Step 1. Creating of a Layered Window

We have to set a special extension window style WS_EX_LAYERED at creation of a layered window. In addition, we must remember that a layered window may not be a child. Since the selection rectangle has no title bar, we can specify the normal window style as WS_POPUP:

bool CCoverWnd::Create(CWnd* pParentView)
{
  bool bResult = false;

  if (pParentView) {
    // The special style of the layered windows (WS_EX_LAYERED) will be used:
    CreateEx(WS_EX_LAYERED,                          // to be created as a layered window
             _T("STATIC"),                           // using of an existing window class
             NULL,                                   // there is no title 
                                                     // for the rectangle
             WS_POPUP | WS_VISIBLE,                  // common window styles
             -1, -1, 0, 0,                           // initial position and dimensions
             pParentView->GetSafeHwnd(),             // parent view of the rectangle
             NULL);                                  // not used menu identifier
    if (GetSafeHwnd()) {
      pParentView->GetClientRect(m_cParentCliRect);  // client area of the parent view
      pParentView->ClientToScreen(m_cParentCliRect); // our coordinates 
                                                     // are screen related
      pParentView->SetFocus();                       // return the focus at parent
      bResult = true;
    }
  }

  return bResult;
}

Now we can create our covering window and need a possibility to show it at some position, in some size and with some painted surface... :)

Step 2. Updating of a Layered Window

There is an API function to update the placement and the content of a layered window (WinUser.h):

WINUSERAPI
BOOL
WINAPI
UpdateLayeredWindow(
    __in HWND hWnd,                  // handle of the layered window
    __in_opt HDC hdcDst,             // destination DC (in our case screen DC)
    __in_opt POINT *pptDst,          // destination position at the screen
    __in_opt SIZE *psize,            // dimensions of window at the screen
    __in_opt HDC hdcSrc,             // source (memory) DC of prepainting
    __in_opt POINT *pptSrc,          // source position for the surface bits transfer
    __in COLORREF crKey,             // color to be fully transparent (not our case)
    __in_opt BLENDFUNCTION *pblend,  // blending parameters
    __in DWORD dwFlags);             // kind of the transfer 
                                     // (in our case ULW_ALPHA - for alpha blending)

The parameter pblend is a pointer of type struct BLENDFUNCTION that is described below (WinGDI.h):

typedef struct _BLENDFUNCTION
{
    BYTE   BlendOp;                  // must be AC_SRC_OVER currently
    BYTE   BlendFlags;               // must be zero
    BYTE   SourceConstantAlpha;      // general surface transparency 
                                     // [0(opaque) -255(transparent)]
    BYTE   AlphaFormat;              // 0 - the transparency of the surface bits 
                                     // has no role
                                     // AC_SRC_ALPHA - the transparency of the 
                                     // surface bits has a role
                                     // this parameter is independent from 
                                     // SourceConstantAlpha
} BLENDFUNCTION, *PBLENDFUNCTION;

Implementation of the Updating

Now we can provide our own function for CCoverWnd to show it :).

// Placing the window at the screen position crPos
void CCoverWnd::ShowAt(const CRect& crPos)
{
  if (GetSafeHwnd()) {
    CRect cMoveRect(crPos);
    cMoveRect.NormalizeRect();

    CRect cIntersectRect(cMoveRect);
    cIntersectRect.IntersectRect(m_cDrawRect, cMoveRect); // allowed area for placing

    int iWidth(cMoveRect.Width());   // painting dimension per X
    int iHeight(cMoveRect.Height()); // painting dimension per Y

    HDC hdcScreen = ::GetDC(NULL);           // destination screen DC
    HDC hDC = ::CreateCompatibleDC(hdcScreen); // source memory DC

    // We have to create a bitmap by CreateDIBSection(..)
    // to operate with its bits directly. Thanks to SledgeHammer01
    BITMAPINFO sBI              = {0};
    sBI.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
    sBI.bmiHeader.biWidth       = iWidth; 
    sBI.bmiHeader.biHeight      = iHeight; 
    sBI.bmiHeader.biPlanes      = 1; 
    sBI.bmiHeader.biBitCount    = 32; 
    sBI.bmiHeader.biCompression = BI_RGB;

    HBITMAP hBmp = ::CreateDIBSection(hDC, &sBI, DIB_RGB_COLORS, NULL, NULL, 0);
    HBITMAP hBmpOld = (HBITMAP) ::SelectObject(hDC, hBmp);
    
    bool bFillAlphaOK = FillAlpha(hBmp); // try to fill the surface bits 
                                         // with alpha channel
    if (!bFillAlphaOK) {
      FillRGB(hDC, iWidth, iHeight); // else - without the alpha channel
    }

    // Preparing the blend parameters
    BLENDFUNCTION blend       = {0};
    blend.BlendOp             = AC_SRC_OVER;
    blend.SourceConstantAlpha = bFillAlphaOK ? 160 : 64;
    blend.AlphaFormat         = bFillAlphaOK ? AC_SRC_ALPHA : 0;

    // Destination position at the screen
    POINT ptPos   = {cIntersectRect.left,
                     cIntersectRect.top};

    // Dimensions of the bits transfer
    SIZE sizeWnd  = {cIntersectRect.Width(),
                     cIntersectRect.Height()};

    // Source position in source (memory DC)
    POINT ptSrc   = {cIntersectRect.left - cMoveRect.left,
                     cIntersectRect.top  - cMoveRect.top};

    // Call the wizard :)
    ::UpdateLayeredWindow(m_hWnd, hdcScreen, &ptPos, &sizeWnd,
                          hDC, &ptSrc, 0, &blend, ULW_ALPHA);

    // Clearance
    ::SelectObject(hDC, hBmpOld);
    ::DeleteObject(hBmp);
    ::DeleteDC(hDC);
    ::ReleaseDC(NULL, hdcScreen);
  }
}

The fill-out procedures are encapsulated in CCoverWnd and could be observed in the source files (the third download set above).

Using of Code

It would be enough to instance and create an object of the CCoverWnd class in a CWnd-inherited object, that should provide the selection on its surface.

class CCoverTestDlg : public CDialog
{
  bool      m_bCaptured;
  
  CPoint    m_cpStart,
            m_cpEnd;

  CCoverWnd m_cCoverWnd; // An own test instance, could be static :)
...

Now it would be possible to show the cover, for example:

void CCoverTestDlg::ShowCover()
{
  if (!m_cCoverWnd.GetSafeHwnd()) {
    m_cCoverWnd.Create(this); // The info of the client area will be used
                              // by the child-cover, see CCoverWnd::Create(..)
  }

  if (m_cCoverWnd.GetSafeHwnd()) {
    CRect cShowRect(m_cpStart, m_cpEnd);
    ClientToScreen(cShowRect); // The cover is screen related

    m_cCoverWnd.ShowAt(cShowRect); // Good luck...
  }
}

... as well to "hide" it:

void CCoverTestDlg::DestroyCover()
{
  if (m_cCoverWnd.GetSafeHwnd()) {
    m_cCoverWnd.DestroyWindow(); // Thanks...
  }
}

Points of Interest

Thanks to SledgeHammer01 - for the advice to write the color data directly, without the function CBitmap::SetBitmapBits(..).

The touched function has the following state now:

bool CCoverWnd::FillAlpha(HBITMAP hBmp)
{
  bool bResult = false;

  if (hBmp) {
    BITMAP bmp;
    GetObject(hBmp, sizeof(BITMAP), &bmp);

    DWORD dwCount = bmp.bmWidthBytes * bmp.bmHeight;
    if (dwCount >= sizeof(DWORD)) {
      DWORD* pcBitsWords = (DWORD*) bmp.bmBits;
      if (pcBitsWords) {
        DWORD dwIndex(dwCount / sizeof(DWORD));
        DWORD dwUp = bmp.bmWidth;
        DWORD dwDn = dwIndex -dwUp;
        DWORD dwR  = bmp.bmWidth -1;
        while (dwIndex--)  {
          DWORD dwSides = dwIndex % bmp.bmWidth;
          if (dwIndex < dwUp ||
              dwIndex > dwDn ||
              0   == dwSides ||
              dwR == dwSides) {
            pcBitsWords[dwIndex] = sm_clrPenA;   // 0xFF0080FF (Edge, AA =0xFF)
          } else {
            pcBitsWords[dwIndex] = sm_clrBrushA; // 0x400020FF (Plain, AA =0x40)
          }
        }
        bResult = true;
      }
    }
  }

  return bResult;
}

I would be glad to read the next advice to improve the bits writing.

Thank you!

History

• Mon Jan 25 12:46:50 UTC+0100 2010 -- Created
• Mon Jan 25 17:48:01 UTC+0100 2010 -- Modified section "Background"
• Mon Jan 25 18:01:36 UTC+0100 2010 -- Modified section "Points of Interest"
• Thu Jan 28 12:13:54 UTC+0100 2010 -- Improved code