Tag Archives: mfc

Easy Screen Capture with MFC

In an older article published at Codeguru, I showed how easy is to make screen capture using CImage ATL/MFC class. Here is the sample code from that article:

BOOL CScreenImage::CaptureRect(const CRect& rect)
{
   // detach and destroy the old bitmap if any attached
   CImage::Destroy();
   
   // create a screen and a memory device context
   HDC hDCScreen = ::CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
   HDC hDCMem = ::CreateCompatibleDC(hDCScreen);
   // create a compatible bitmap and select it in the memory DC
   HBITMAP hBitmap = 
      ::CreateCompatibleBitmap(hDCScreen, rect.Width(), rect.Height());
   HBITMAP hBmpOld = (HBITMAP)::SelectObject(hDCMem, hBitmap);
 
   // bit-blit from screen to memory device context
   // note: CAPTUREBLT flag is required to capture layered windows
   DWORD dwRop = SRCCOPY | CAPTUREBLT;
   BOOL bRet = ::BitBlt(hDCMem, 0, 0, rect.Width(), rect.Height(), 
                        hDCScreen, rect.left, rect.top, dwRop);
   // attach bitmap handle to this object
   Attach(hBitmap);
 
   // restore the memory DC and perform cleanup
   ::SelectObject(hDCMem, hBmpOld);
   ::DeleteDC(hDCMem);
   ::DeleteDC(hDCScreen);
 
   return bRet;
}

BOOL CScreenImage::CaptureRect(const CRect& rect)

{

// detach and destroy the old bitmap if any attached

CImage::Destroy();

// create a screen and a memory device context

HDC hDCScreen = ::CreateDC(_T("DISPLAY"), NULL, NULL, NULL);

HDC hDCMem = ::CreateCompatibleDC(hDCScreen);

// create a compatible bitmap and select it in the memory DC

HBITMAP hBitmap =

::CreateCompatibleBitmap(hDCScreen, rect.Width(), rect.Height());

HBITMAP hBmpOld = (HBITMAP)::SelectObject(hDCMem, hBitmap);

// bit-blit from screen to memory device context

// note: CAPTUREBLT flag is required to capture layered windows

DWORD dwRop = SRCCOPY | CAPTUREBLT;

BOOL bRet = ::BitBlt(hDCMem, 0, 0, rect.Width(), rect.Height(),

hDCScreen, rect.left, rect.top, dwRop);

// attach bitmap handle to this object

Attach(hBitmap);

// restore the memory DC and perform cleanup

::SelectObject(hDCMem, hBmpOld);

::DeleteDC(hDCMem);

::DeleteDC(hDCScreen);

return bRet;

}

Like a walking in the park. 🙂 However, it can be made even easier, with fewer lines of code.

BOOL CCaptureImage::CaptureRect(const CRect& rcCapture)
{
    // destroy the currently contained bitmap to create a new one
    Destroy();

    // create bitmap and attach it to this object 
    Create(rcCapture.Width(), rcCapture.Height(), 32, 0);

    // create virtual screen DC
    CDC dcScreen;
    dcScreen.CreateDC(_T("DISPLAY"), NULL, NULL, NULL);

    // copy the contents from the virtual screen DC 
    BOOL bRet = ::BitBlt(GetDC(), 0, 0, rcCapture.Width(), rcCapture.Height(),
        dcScreen.m_hDC, rcCapture.left, rcCapture.top,
        SRCCOPY | CAPTUREBLT);

    // do cleanup and return
    dcScreen.DeleteDC();
    ReleaseDC();

    return bRet;
}

BOOL CCaptureImage::CaptureRect(const CRect& rcCapture)

{

// destroy the currently contained bitmap to create a new one

Destroy();

// create bitmap and attach it to this object

Create(rcCapture.Width(), rcCapture.Height(), 32, 0);

// create virtual screen DC

CDC dcScreen;

dcScreen.CreateDC(_T("DISPLAY"), NULL, NULL, NULL);

// copy the contents from the virtual screen DC

BOOL bRet = ::BitBlt(GetDC(), 0, 0, rcCapture.Width(), rcCapture.Height(),

dcScreen.m_hDC, rcCapture.left, rcCapture.top,

SRCCOPY | CAPTUREBLT);

// do cleanup and return

dcScreen.DeleteDC();

ReleaseDC();

return bRet;

}

Now, let’s add two more methods, one for capturing a given display monitor and one for capture a window.

BOOL CCaptureImage::CaptureDisplayMonitor(const MONITORINFO& monitorInfo)
{
    return CaptureRect(CRect(monitorInfo.rcMonitor));
}

BOOL CCaptureImage::CaptureWindow(CWnd* pWnd)
{
    ASSERT_VALID(pWnd);

    CRect rcWindow;
    pWnd->GetWindowRect(rcWindow);
    return CaptureRect(rcWindow);
}

BOOL CCaptureImage::CaptureDisplayMonitor(const MONITORINFO& monitorInfo)

{

return CaptureRect(CRect(monitorInfo.rcMonitor));

}

BOOL CCaptureImage::CaptureWindow(CWnd* pWnd)

{

ASSERT_VALID(pWnd);

CRect rcWindow;

pWnd->GetWindowRect(rcWindow);

return CaptureRect(rcWindow);

}

Demo aplication

Download: Screen Capture Demo.zip (1553)
The demo application makes per-monitor capture.

Monitor capture demo

Resources and related articles

MSDN: CImage Class
Codeguru: Easy Screen Capture Using MFC/ATL

Double-click in MDI Client

1 Reply

It’s hard to believe that handling mouse double-clicks in MDI Client windows can be super useful, but I found this problem in a discussion forum. I presumed that it was not only for fun, so I tried to resolve it. First, I subclassed the MDI Client window in a CWnd-derived class. That is possible for a standard MFC project in this way:

class CMainFrame : public CMDIFrameWnd
{
    // ...
    // Attributes
private:
    CMDIClientWnd m_wndMDIClient;
    // ...

class CMainFrame : public CMDIFrameWnd

{

// ...

// Attributes

private:

CMDIClientWnd m_wndMDIClient;

// ...

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
        return -1;

    // NOTE: m_hWndMDIClient is a public member of CMDIFrameWnd
    // keeping the MDI Client window handle
    m_wndMDIClient.SubclassWindow(m_hWndMDIClient);
    // ...
    return 0;
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)

return -1;

// NOTE: m_hWndMDIClient is a public member of CMDIFrameWnd

// keeping the MDI Client window handle

m_wndMDIClient.SubclassWindow(m_hWndMDIClient);

// ...

return 0;

}

But no success: WM_LBUTTONDBLCLK message handler is not called in CMDIClientWnd class. Then I tried to catch it in overridden PreTranslateMessage or even in a WH_MOUSE hook with the same result. Finally, I had a look using Spy++ tool. Bingo! The MDI Client (of predefined window class named “MdiClient“) has no CS_DBLCLKS style so it does not deal with mouse double-clicks.

MDIClient

All wat he have to do is to create the The MDI Client window with our own registered window class. This is possible by overriding CMDIFrameWnd::CreateClient.

Create a MDI client window which belongs to a window class having CS_DBLCLKS style

BOOL CMainFrame::CreateClient(LPCREATESTRUCT lpCreateStruct, CMenu* pWindowMenu)
{
    // NOTE: do not call CMDIFrameWnd::CreateClient

    // get MDiCLient predefined window class info
    WNDCLASS wndClass = { 0 };
    if (!::GetClassInfo(AfxGetInstanceHandle(), _T("MdiClient"), &wndClass))
        return FALSE;

    // put our own window class name in WNDCLASS structure
    wndClass.lpszClassName = OUR_OWN_CLASS_NAME;
    // set CS_DBLCLKS flag in class style
    wndClass.style |= CS_DBLCLKS;
    // register window class
    AfxRegisterClass(&wndClass);

    ////////////////////////////////////////////////////////////////////////
    // Next is copy-pasted from MFC framework implementation, 
    // except that use our own registered window class
 
    // ...
    // ...

    // Create MDICLIENT control with special IDC
    if ((m_hWndMDIClient = CreateWindowEx(dwExStyle,
        /*_T("mdiclient")*/ OUR_OWN_CLASS_NAME, // use our own window class
        NULL,
        dwStyle, 0, 0, 0, 0, m_hWnd, (HMENU)AFX_IDW_PANE_FIRST,
        AfxGetInstanceHandle(), (LPVOID)&ccs)) == NULL)
    {
        TRACE(traceAppMsg, 0, 
            _T("Warning: CMDIFrameWnd::OnCreateClient: failed to create MDICLIENT.")
            _T(" GetLastError returns 0x%8.8X\n"), ::GetLastError());
        return FALSE;
    }
    // Move it to the top of z-order
    ::BringWindowToTop(m_hWndMDIClient);

    return TRUE;
}

BOOL CMainFrame::CreateClient(LPCREATESTRUCT lpCreateStruct, CMenu* pWindowMenu)

{

// NOTE: do not call CMDIFrameWnd::CreateClient

// get MDiCLient predefined window class info

WNDCLASS wndClass = { 0 };

if (!::GetClassInfo(AfxGetInstanceHandle(), _T("MdiClient"), &wndClass))

return FALSE;

// put our own window class name in WNDCLASS structure

wndClass.lpszClassName = OUR_OWN_CLASS_NAME;

// set CS_DBLCLKS flag in class style

wndClass.style |= CS_DBLCLKS;

// register window class

AfxRegisterClass(&wndClass);

////////////////////////////////////////////////////////////////////////

// Next is copy-pasted from MFC framework implementation,

// except that use our own registered window class

// ...

// Create MDICLIENT control with special IDC

if ((m_hWndMDIClient = CreateWindowEx(dwExStyle,

/*_T("mdiclient")*/ OUR_OWN_CLASS_NAME, // use our own window class

NULL,

dwStyle, 0, 0, 0, 0, m_hWnd, (HMENU)AFX_IDW_PANE_FIRST,

AfxGetInstanceHandle(), (LPVOID)&ccs)) == NULL)

{

TRACE(traceAppMsg, 0,

_T("Warning: CMDIFrameWnd::OnCreateClient: failed to create MDICLIENT.")

_T(" GetLastError returns 0x%8.8X\n"), ::GetLastError());

return FALSE;

}

// Move it to the top of z-order

::BringWindowToTop(m_hWndMDIClient);

return TRUE;

}

Handle MDI Client double-clicks in standard MFC applications

Once we have created the MDI Client window and subclassed it as shown above, can simply handle (for example) WM_LBUTTONDBLCLK in our CWnd-derived class.

BEGIN_MESSAGE_MAP(CMDIClientWnd, CWnd)
    ON_WM_LBUTTONDBLCLK()
END_MESSAGE_MAP()

// CMDIClientWnd message handlers

void CMDIClientWnd::OnLButtonDblClk(UINT nFlags, CPoint point)
{
    // Do something cool!
    // ...
    CWnd::OnLButtonDblClk(nFlags, point);
}

BEGIN_MESSAGE_MAP(CMDIClientWnd, CWnd)

ON_WM_LBUTTONDBLCLK()

END_MESSAGE_MAP()

// CMDIClientWnd message handlers

void CMDIClientWnd::OnLButtonDblClk(UINT nFlags, CPoint point)

{

// Do something cool!

// ...

CWnd::OnLButtonDblClk(nFlags, point);

}

Handle MDI Client double-clicks in Visual Studio or Office-style MFC applications

CMDIFrameWndEx uses its own CWnd-derived class for the MDI Client window, so we cannot use another one in main frame class. However, this is not so big problem because we can now catch WM_LBUTTONDBLCLK in overridden PreTranslateMessage method.

BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
    if ((pMsg->message == WM_LBUTTONDBLCLK) && (pMsg->hwnd == m_hWndMDIClient))
    {
        // do something cool!
    }
    return CMDIFrameWndEx::PreTranslateMessage(pMsg);
}

BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)

{

if ((pMsg->message == WM_LBUTTONDBLCLK) && (pMsg->hwnd == m_hWndMDIClient))

{

// do something cool!

}

return CMDIFrameWndEx::PreTranslateMessage(pMsg);

}

Or, you can catch it in a WH_MOUSE hook, if think that can be more exciting. 🙂

class CMainFrame : public CMDIFrameWndEx
{
    static HHOOK m_hHook;
    static HWND m_hWndClient;
    static LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam);
// ...
};

    // ...

    DWORD dwThreadID = ::GetCurrentThreadId();
    m_hHook = ::SetWindowsHookEx(WH_MOUSE, &CMainFrame::MouseProc, NULL, dwThreadID);

         // ...

LRESULT CALLBACK CMainFrame::MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    if (nCode < 0) 
        return ::CallNextHookEx(m_hHook, nCode, wParam, lParam); 

    UINT nMsg = (UINT)wParam; 
    MOUSEHOOKSTRUCT* pMHS = (MOUSEHOOKSTRUCT*)lParam; 
    if (m_hWndClient && pMHS && (WM_LBUTTONDBLCLK == nMsg) && (pMHS->hwnd == m_hWndClient))
    {
        // do something coo!
    }
    return ::CallNextHookEx(m_hHook, nCode, wParam, lParam);
}
    // ...

    if (NULL != m_hHook)
    {
        ::UnhookWindowsHookEx(m_hHook);
        m_hHook = NULL;
    }

class CMainFrame : public CMDIFrameWndEx

{

static HHOOK m_hHook;

static HWND m_hWndClient;

static LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam);

// ...

};

// ...

DWORD dwThreadID = ::GetCurrentThreadId();

m_hHook = ::SetWindowsHookEx(WH_MOUSE, &CMainFrame::MouseProc, NULL, dwThreadID);

// ...

LRESULT CALLBACK CMainFrame::MouseProc(int nCode, WPARAM wParam, LPARAM lParam)

{

if (nCode < 0)

return ::CallNextHookEx(m_hHook, nCode, wParam, lParam);

UINT nMsg = (UINT)wParam;

MOUSEHOOKSTRUCT* pMHS = (MOUSEHOOKSTRUCT*)lParam;

if (m_hWndClient && pMHS && (WM_LBUTTONDBLCLK == nMsg) && (pMHS->hwnd == m_hWndClient))

{

// do something coo!

}

return ::CallNextHookEx(m_hHook, nCode, wParam, lParam);

}

// ...

if (NULL != m_hHook)

{

::UnhookWindowsHookEx(m_hHook);

m_hHook = NULL;

}

Note that creating the MDI Client window in overridden CMDIFrameWnd::CreateClient cand be done in all cases in the same way.

Demo solution

Download: MDI client double-click samples.zip (1195)
The sample Visual Studio solution contains two projects: one is a standard MDI application, and the other one is Office-style. Just enjoy of MDI Client double-clicks! 🙂

Resources and related articles

Codeguru thread: Handle WM_LBUTTONDBLCLK on CMainFrame
Codexpert blog: Custom Paint in MDI Client

MFC Support for Direct2D – Part 5: Interoperability with GDI

3 Replies

There are two ways to combine Direct2D with Windows GDI API in the same application:

Drawing Direct2D content to a GDI device context
Drawing GDI content to a Direct2D GDI-compatible render target

Let’s see each one!

Drawing Direct2D content to a GDI device context

For this purpose, use ID2D1DCRenderTarget instead of ID2D1HwndRenderTarget interface. If using MFC shipped with Visual Studio 2015 or newer, then CDCRenderTarget wrapper class makes the programmer life easier. Here are the steps:

In the WM_CREATE message handler call CWnd::EnableD2DSupport passing TRUE as second parameter. This way, the MFC framework creates a CDCRenderTarget instead of a CHwndRenderTarget object.

int CChildView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (__super::OnCreate(lpCreateStruct) == -1)
        return -1;

    // Note: need Visual Studio 2015 or newer (_MFC_VER >= 0x0E00)
    BOOL bUseDCRenderTarget = TRUE;
    EnableD2DSupport(TRUE, bUseDCRenderTarget);

    if (!IsD2DSupportEnabled())
        return -1;

    return 0;
}

int CChildView::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

if (__super::OnCreate(lpCreateStruct) == -1)

return -1;

// Note: need Visual Studio 2015 or newer (_MFC_VER >= 0x0E00)

BOOL bUseDCRenderTarget = TRUE;

EnableD2DSupport(TRUE, bUseDCRenderTarget);

if (!IsD2DSupportEnabled())

return -1;

return 0;

}

Map AFX_WM_DRAW2D registered messge.

C++

class CChildView : public CWnd { // ... afx_msg LRESULT OnAfxDraw2D(WPARAM wParam, LPARAM lParam); };

1
2
3
4
5

class CChildView : public CWnd
{
    // ...
    afx_msg LRESULT OnAfxDraw2D(WPARAM wParam, LPARAM lParam);
};

C++

BEGIN_MESSAGE_MAP(CChildView, CWnd) // ... ON_REGISTERED_MESSAGE(AFX_WM_DRAW2D, &CChildView::OnAfxDraw2D) END_MESSAGE_MAP()

1
2
3
4

BEGIN_MESSAGE_MAP(CChildView, CWnd)
    // ...
    ON_REGISTERED_MESSAGE(AFX_WM_DRAW2D, &CChildView::OnAfxDraw2D)
END_MESSAGE_MAP()

Finally, get the CDCRenderTarget* passed by MFC framework in LPARAM and enjoy.

LRESULT CChildView::OnAfxDraw2D(WPARAM wParam, LPARAM lParam)
{
    CDCRenderTarget* pDCRenderTarget = (CDCRenderTarget*)lParam;
    ASSERT_KINDOF(CDCRenderTarget, pDCRenderTarget);

    // Draw Direct2D content in GDI device context
    _DrawDirect2DContent(pDCRenderTarget);

    pDCRenderTarget->EndDraw();

    // Draw using GDI
    CWindowDC dc(this);
    _DrawGDIContent(&dc);

    return TRUE;
}

LRESULT CChildView::OnAfxDraw2D(WPARAM wParam, LPARAM lParam)

{

CDCRenderTarget* pDCRenderTarget = (CDCRenderTarget*)lParam;

ASSERT_KINDOF(CDCRenderTarget, pDCRenderTarget);

// Draw Direct2D content in GDI device context

_DrawDirect2DContent(pDCRenderTarget);

pDCRenderTarget->EndDraw();

// Draw using GDI

CWindowDC dc(this);

_DrawGDIContent(&dc);

return TRUE;

}

Drawing GDI content to a Direct2D GDI-compatible render target

So far, MFC has not a wrapper class for ID2D1GdiInteropRenderTarget interface. Also, CWnd::EnableD2DSupport creates a CHwndRenderTarget which is not GDI-compatible. So, we must do it ourselves. Here is the sample code:

class CChildView : public CWnd
{
    // ...
    CComQIPtr<ID2D1GdiInteropRenderTarget> m_spGdiInteropRenderTarget;
    // ...
    afx_msg LRESULT OnAfxDraw2D(WPARAM wParam, LPARAM lParam);
};

class CChildView : public CWnd

{

// ...

CComQIPtr<ID2D1GdiInteropRenderTarget> m_spGdiInteropRenderTarget;

// ...

afx_msg LRESULT OnAfxDraw2D(WPARAM wParam, LPARAM lParam);

};

int CChildView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (__super::OnCreate(lpCreateStruct) == -1)
        return -1;

    // get global Direct2D factory
    ID2D1Factory* pDirect2DFactory = AfxGetD2DState()->GetDirect2dFactory();

    // create GDI-compatible window render target
    D2D1_RENDER_TARGET_PROPERTIES rtProps = D2D1::RenderTargetProperties();
    rtProps.usage = D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE;
    rtProps.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;
    rtProps.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;

    ID2D1HwndRenderTarget* pHwndRenderTarget = NULL;
    HRESULT hr = pDirect2DFactory->CreateHwndRenderTarget(
        &rtProps,
        &D2D1::HwndRenderTargetProperties(m_hWnd, CD2DSizeU()),
        &pHwndRenderTarget);
    if (FAILED(hr))
        return -1;

    // instantiate new CHwndRenderTarget and attach the GDI-compatible render target
    m_pRenderTarget = new CHwndRenderTarget;
    GetRenderTarget()->Attach(pHwndRenderTarget);

    // create ID2D1GdiInteropRenderTarget instance
    m_spGdiInteropRenderTarget = pHwndRenderTarget;
    if (!m_spGdiInteropRenderTarget)
        return -1;

    return 0;
}

int CChildView::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

if (__super::OnCreate(lpCreateStruct) == -1)

return -1;

// get global Direct2D factory

ID2D1Factory* pDirect2DFactory = AfxGetD2DState()->GetDirect2dFactory();

// create GDI-compatible window render target

D2D1_RENDER_TARGET_PROPERTIES rtProps = D2D1::RenderTargetProperties();

rtProps.usage = D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE;

rtProps.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;

rtProps.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;

ID2D1HwndRenderTarget* pHwndRenderTarget = NULL;

HRESULT hr = pDirect2DFactory->CreateHwndRenderTarget(

&rtProps,

&D2D1::HwndRenderTargetProperties(m_hWnd, CD2DSizeU()),

&pHwndRenderTarget);

if (FAILED(hr))

return -1;

// instantiate new CHwndRenderTarget and attach the GDI-compatible render target

m_pRenderTarget = new CHwndRenderTarget;

GetRenderTarget()->Attach(pHwndRenderTarget);

// create ID2D1GdiInteropRenderTarget instance

m_spGdiInteropRenderTarget = pHwndRenderTarget;

if (!m_spGdiInteropRenderTarget)

return -1;

return 0;

}

LRESULT CChildView::OnAfxDraw2D(WPARAM wParam, LPARAM lParam)
{
    CHwndRenderTarget* pHwndRenderTarget = (CHwndRenderTarget*)lParam;
    ASSERT_VALID(pHwndRenderTarget);

    // draw using Direct2D
    _DrawDirect2DContent(pHwndRenderTarget);

    HDC hDC = NULL;
    HRESULT hr = m_spGdiInteropRenderTarget->GetDC(
        D2D1_DC_INITIALIZE_MODE_COPY, &hDC);

    if (FAILED(hr) || (NULL == hDC))
        return FALSE;

    // draw GDI content in a GDI-compatible window render target
    _DrawGDIContent(CDC::FromHandle(hDC));

    CRect rcClient;
    GetClientRect(rcClient);
    hr = m_spGdiInteropRenderTarget->ReleaseDC(rcClient);
    if (FAILED(hr))
        return FALSE;

    return TRUE;
}

LRESULT CChildView::OnAfxDraw2D(WPARAM wParam, LPARAM lParam)

{

CHwndRenderTarget* pHwndRenderTarget = (CHwndRenderTarget*)lParam;

ASSERT_VALID(pHwndRenderTarget);

// draw using Direct2D

_DrawDirect2DContent(pHwndRenderTarget);

HDC hDC = NULL;

HRESULT hr = m_spGdiInteropRenderTarget->GetDC(

D2D1_DC_INITIALIZE_MODE_COPY, &hDC);

if (FAILED(hr) || (NULL == hDC))

return FALSE;

// draw GDI content in a GDI-compatible window render target

_DrawGDIContent(CDC::FromHandle(hDC));

CRect rcClient;

GetClientRect(rcClient);

hr = m_spGdiInteropRenderTarget->ReleaseDC(rcClient);

if (FAILED(hr))

return FALSE;

return TRUE;

}

Demo projects

Download: Direct2D and GDI Interop Demo.zip (1326)

The Visual C++ solution attached here has two simple projects showing the both Direct2D and GDI interoperatibily methods listed above.

Direct2D and GDI Interop – Demo Application

Notes

can be observed that Direct2D drawing quality is higher than GDI drawing, because Direct2D is capable of rendering with antialiasing;
given the first note, my opinion is that GDI drawing has no much sense once using Direct2D but never know…

Resources and related articles

MSDN: Direct2D and GDI Interoperability Overview
MSDN: CDCRenderTarget Class
MSDN: ID2D1GdiInteropRenderTarget interface

MFC Support for Direct2D – Part 4: Built-in Effects

Leave a reply

Direct2D has built-in support for image processing like changing brightness or contrast, blurring, creating drop shadows, and so on. Basically, we can use for this purpose the CreateEffect and DrawImage methods of ID2D1DeviceContext interface. So far, there is no MFC wrapper class for ID2D1DeviceContext but that’s not so big issue. Once having a valid ID2D1RenderTarget instance (wrapped in CRenderTarget class) we can easily get the ID2D1DeviceContext interface by calling QueryInterface. No sweat!

Getting ID2D1DeviceContext interface in an MFC application

    CComPtr<ID2D1DeviceContext> spDeviceContext;
    pRenderTarget->GetRenderTarget()->QueryInterface(__uuidof(ID2D1DeviceContext), 
        reinterpret_cast<void**>(&spDeviceContext));
    // ...

CComPtr<ID2D1DeviceContext> spDeviceContext;

pRenderTarget->GetRenderTarget()->QueryInterface(__uuidof(ID2D1DeviceContext),

reinterpret_cast<void**>(&spDeviceContext));

// ...

Or, a little bit easier, use CComQIPtr which calls QueryInterface for you.

    CComQIPtr<ID2D1DeviceContext> spDeviceContext = pRenderTarget->GetRenderTarget();
    // ...

1 2	CComQIPtr<ID2D1DeviceContext> spDeviceContext = pRenderTarget->GetRenderTarget(); // ...

Drawing an image using the Gaussian Blur built-in effect

Here is an example:

void CChildView::_DrawBlurredImage(CRenderTarget* pRenderTarget)
{
    // ...
    // get ID2D1DeviceContext interface
    CComQIPtr<ID2D1DeviceContext> spDeviceContext = 
        pRenderTarget->GetRenderTarget();

    // create Gaussian Blur effect
    CComPtr<ID2D1Effect> spEffect;
    HRESULT hr = spDeviceContext->CreateEffect(CLSID_D2D1GaussianBlur, &spEffect);
    ATLASSERT(SUCCEEDED(hr));
    // ...

    // set the input image
    spEffect->SetInput(0, m_pBitmap->Get());

    // finally, call ID2D1DeviceContext::DrawImage
    spDeviceContext->DrawImage(spEffect);
    //
    // if it doesn't blew up until here, means that it works. :)
    // ...  
}

void CChildView::_DrawBlurredImage(CRenderTarget* pRenderTarget)

{

// ...

// get ID2D1DeviceContext interface

CComQIPtr<ID2D1DeviceContext> spDeviceContext =

pRenderTarget->GetRenderTarget();

// create Gaussian Blur effect

CComPtr<ID2D1Effect> spEffect;

HRESULT hr = spDeviceContext->CreateEffect(CLSID_D2D1GaussianBlur, &spEffect);

ATLASSERT(SUCCEEDED(hr));

// ...

// set the input image

spEffect->SetInput(0, m_pBitmap->Get());

// finally, call ID2D1DeviceContext::DrawImage

spDeviceContext->DrawImage(spEffect);

// if it doesn't blew up until here, means that it works. :)

// ...

}

Just note that you should additionally include d2d1_1.h header and link your project to dxguid.lib. More details can be found in the attached demo project.

The demo project

Download: Gaussian Blur Effect demo.zip (1313)

Notes

Picture used in the demo application is taken from http://www.icondrawer.com/gift-icons.php
I have to apologize for blurring the little cute dog. 🙂

Resources and related articles

MFC Support for DirectWrite – Part 10: Outlined Text

Leave a reply

In a previous article, I showed the basics of custom text rendering with DirectWrite (see MFC Support for DirectWrite – Part 7: A Step to Custom Rendering). So far so good but it just mimics the default text rendering. Let’s now modify the overridden IDWriteTextRenderer::DrawGlyphRun in order to draw outlined text.

Overridden IDWriteTextRenderer::DrawGlyphRun implementation

STDMETHODIMP CCustomTextRenderer::XCustomTextRenderer::DrawGlyphRun(
    void* pClientDrawingContext, 
    FLOAT fBaselineOriginX, 
    FLOAT fBaselineOriginY, 
    DWRITE_MEASURING_MODE measuringMode,
    const DWRITE_GLYPH_RUN* pGlyphRun, 
    const DWRITE_GLYPH_RUN_DESCRIPTION* pGlyphRunDescription, 
    IUnknown* pClientDrawingEffect)
{
    METHOD_PROLOGUE(CCustomTextRenderer, CustomTextRenderer);
    CRenderTarget* pRenderTarget = pThis->GetRenderTarget();
    ASSERT(pRenderTarget && pRenderTarget->IsValid());

    CD2DPointF point(fBaselineOriginX, fBaselineOriginY);
    CCustomEffect* pCustomEffect = static_cast<CCustomEffect*>(pClientDrawingContext);
    if (NULL == pCustomEffect)
    {
        return _DrawDefaultGlyphRun(pRenderTarget, point, pGlyphRun, measuringMode);
    }
    
    HRESULT hr = E_FAIL;
    switch (pCustomEffect->GetType())
    {
    case CustomEffectType::outlined_text:
        hr = _DrawOutlinedGlyphRun(pRenderTarget,
            dynamic_cast<COutlinedTextEffect*>(pCustomEffect),
            point,
            pGlyphRun,
            measuringMode);
    // ...
    // may add other types of custom effects here
    }

    return hr;
}

STDMETHODIMP CCustomTextRenderer::XCustomTextRenderer::DrawGlyphRun(

void* pClientDrawingContext,

FLOAT fBaselineOriginX,

FLOAT fBaselineOriginY,

DWRITE_MEASURING_MODE measuringMode,

const DWRITE_GLYPH_RUN* pGlyphRun,

const DWRITE_GLYPH_RUN_DESCRIPTION* pGlyphRunDescription,

IUnknown* pClientDrawingEffect)

{

METHOD_PROLOGUE(CCustomTextRenderer, CustomTextRenderer);

CRenderTarget* pRenderTarget = pThis->GetRenderTarget();

ASSERT(pRenderTarget && pRenderTarget->IsValid());

CD2DPointF point(fBaselineOriginX, fBaselineOriginY);

CCustomEffect* pCustomEffect = static_cast<CCustomEffect*>(pClientDrawingContext);

if (NULL == pCustomEffect)

{

return _DrawDefaultGlyphRun(pRenderTarget, point, pGlyphRun, measuringMode);

}

HRESULT hr = E_FAIL;

switch (pCustomEffect->GetType())

{

case CustomEffectType::outlined_text:

hr = _DrawOutlinedGlyphRun(pRenderTarget,

dynamic_cast<COutlinedTextEffect*>(pCustomEffect),

point,

pGlyphRun,

measuringMode);

// ...

// may add other types of custom effects here

}

return hr;

}

A method for drawing outlined text

HRESULT CCustomTextRenderer::XCustomTextRenderer::_DrawOutlinedGlyphRun(
    CRenderTarget* pRenderTarget,
    COutlinedTextEffect* pEffect, 
    const CD2DPointF& point,
    const DWRITE_GLYPH_RUN* pGlyphRun,
    DWRITE_MEASURING_MODE measuringMode)
{
    ASSERT(pRenderTarget && pRenderTarget->IsValid());
    ASSERT(pEffect && pEffect->IsValid());

    // get the Direct2D resources contained the COutlinedTextEffect object
    CD2DBrush* pOutlineBrush = pEffect->GetOutlineBrush();
    ASSERT(pOutlineBrush && pOutlineBrush->IsValid());

    CD2DBrush* pFillBrush = pEffect->GetFillBrush();
    ASSERT(pFillBrush && pFillBrush->IsValid());

    // get outline stroke width and RTL flag
    FLOAT fStrokeWidth = pEffect->GetStrokeWidth();
    BOOL bIsRightToLeft = pEffect->IsRightToLeft();

    // create path geometry
    CD2DPathGeometry pathGeometry = (pRenderTarget);
    HRESULT hr = pathGeometry.Create(pRenderTarget);
    ASSERT(SUCCEEDED(hr));
    if (FAILED(hr)) return hr;

    // create a geometry sink which will be called back 
    // to perform outline drawing operations
    CD2DGeometrySink geometrySink(pathGeometry);
    ASSERT(geometrySink.IsValid());
        
    // get IDWriteFontFace interface from DWRITE_GLYPH_RUN structure
    IDWriteFontFace* pFontFace = pGlyphRun->fontFace;

    // call IDWriteFontFace::GetGlyphRunOutline passing data 
    // contained in DWRITE_GLYPH_RUN and the geometry sink
    hr = pFontFace->GetGlyphRunOutline(pGlyphRun->fontEmSize,
        pGlyphRun->glyphIndices, pGlyphRun->glyphAdvances, 
        pGlyphRun->glyphOffsets, pGlyphRun->glyphCount, 
        pGlyphRun->isSideways, bIsRightToLeft, geometrySink);

    if (FAILED(hr)) return hr;

    geometrySink.Close();

    // keep in mind the render target transform matrix
    D2D1_MATRIX_3X2_F oldMatrix;
    pRenderTarget->GetTransform(&oldMatrix);
    // translate the render target according to baseline coordinates 
    pRenderTarget->SetTransform(D2D1::Matrix3x2F::Translation(point.x, point.y));

    // draw the outline and fill the geometry path
    pRenderTarget->DrawGeometry(&pathGeometry, pOutlineBrush, fStrokeWidth);
    pRenderTarget->FillGeometry(&pathGeometry, pFillBrush);

    // restore the initial render target transform
    pRenderTarget->SetTransform(oldMatrix);

    return S_OK; 
    // well, maybe this method needs a little bit of refactoring. :)
}

HRESULT CCustomTextRenderer::XCustomTextRenderer::_DrawOutlinedGlyphRun(

CRenderTarget* pRenderTarget,

COutlinedTextEffect* pEffect,

const CD2DPointF& point,

const DWRITE_GLYPH_RUN* pGlyphRun,

DWRITE_MEASURING_MODE measuringMode)

{

ASSERT(pRenderTarget && pRenderTarget->IsValid());

ASSERT(pEffect && pEffect->IsValid());

// get the Direct2D resources contained the COutlinedTextEffect object

CD2DBrush* pOutlineBrush = pEffect->GetOutlineBrush();

ASSERT(pOutlineBrush && pOutlineBrush->IsValid());

CD2DBrush* pFillBrush = pEffect->GetFillBrush();

ASSERT(pFillBrush && pFillBrush->IsValid());

// get outline stroke width and RTL flag

FLOAT fStrokeWidth = pEffect->GetStrokeWidth();

BOOL bIsRightToLeft = pEffect->IsRightToLeft();

// create path geometry

CD2DPathGeometry pathGeometry = (pRenderTarget);

HRESULT hr = pathGeometry.Create(pRenderTarget);

ASSERT(SUCCEEDED(hr));

if (FAILED(hr)) return hr;

// create a geometry sink which will be called back

// to perform outline drawing operations

CD2DGeometrySink geometrySink(pathGeometry);

ASSERT(geometrySink.IsValid());

// get IDWriteFontFace interface from DWRITE_GLYPH_RUN structure

IDWriteFontFace* pFontFace = pGlyphRun->fontFace;

// call IDWriteFontFace::GetGlyphRunOutline passing data

// contained in DWRITE_GLYPH_RUN and the geometry sink

hr = pFontFace->GetGlyphRunOutline(pGlyphRun->fontEmSize,

pGlyphRun->glyphIndices, pGlyphRun->glyphAdvances,

pGlyphRun->glyphOffsets, pGlyphRun->glyphCount,

pGlyphRun->isSideways, bIsRightToLeft, geometrySink);

if (FAILED(hr)) return hr;

geometrySink.Close();

// keep in mind the render target transform matrix

D2D1_MATRIX_3X2_F oldMatrix;

pRenderTarget->GetTransform(&oldMatrix);

// translate the render target according to baseline coordinates

pRenderTarget->SetTransform(D2D1::Matrix3x2F::Translation(point.x, point.y));

// draw the outline and fill the geometry path

pRenderTarget->DrawGeometry(&pathGeometry, pOutlineBrush, fStrokeWidth);

pRenderTarget->FillGeometry(&pathGeometry, pFillBrush);

// restore the initial render target transform

pRenderTarget->SetTransform(oldMatrix);

return S_OK;

// well, maybe this method needs a little bit of refactoring. :)

}

Basically, the steps where the following:

if pClientDrawingContext parameter is null then perform the default drawing;
otherwhise, call _DrawOutlinedGlyphRun pasing an object that contains the brushes for text outline and fill (COutlinedTextEffect);
create a path geometry (CD2DPathGeometry);
instantiate a geometry sink that is used to populate the path geometry (CD2DGeometrySink);
get IDWriteFontFace interface from DWRITE_GLYPH_RUN structure;
call IDWriteFontFace::GetGlyphRunOutline, passing a bunch of parameters, most of them contained in DWRITE_GLYPH_RUN structure plus our geometry sink;
close the geometry sink;
translate the render target according to the glyph run baseline origin (baselineOriginX and baselineOriginY parameters of DrawGlyphRun);
finally, call CRenderTarget::DrawGeometry and CRenderTarget::FillGeometry and…
…do not forget to restore the initial render target transform.

You can find more details in the demo application attached here. Also you can have a look in the related articles mentioned at the bottom of this page.

Demo project

The demo project draws outlined text in order to make it readable over any background image.
Download: Outlined Text Demo.zip (1264)

Outlined Text demo project

Resources and related articles

Codexpert: MFC Support for DirectWrite – Part 7: A Step to Custom Rendering
Petzold Book Blog: Character Formatting Extensions with DirectWrite
MSDN Magazine: DirectX Factor – Who’s Afraid of Glyph Runs?
Codeproject: Outline Text With DirectWrite
MSDN: IDWriteTextRenderer::DrawGlyphRun method
MSDN: CRenderTarget::DrawGeometry
MSDN: CRenderTarget::FillGeometry
MSDN: CD2DPathGeometry Class
MSDN: CD2DGeometrySink Class
MSDN: Render Using a Custom Text Renderer

MFC Support for DirectWrite – Part 9: Hit-Test

Leave a reply

DirectWrite has hit-testing support that can be useful for showing a caret, making a selection, doing some action if the user chicks in a given text range, and so on. The hit-test methods of IDWriteTextLayout interface are HitTestPoint, HitTestTextPosition and HitTestTextRange. Let me show a simple example for each one.

Hit-testing a point

This example calls IDWriteTextLayout::HitTestPoint in the WM_LBUTTONDOWN message handler and keeps in mind the text position in which the user has clicked.

void CChildView::OnLButtonDown(UINT nFlags, CPoint point)
{
    // ...
    // Get  IDWriteTextLayout interface from CD2DTextLayout object
    IDWriteTextLayout* pTextLayout = m_pTextLayout->Get();

    // pixel location X to hit-test, 
    // relative to the top-left location of the layout box. 
    FLOAT fPointX = static_cast<FLOAT>(point.x);
    // pixel location Y to hit-test, 
    // relative to the top-left location of the layout box.
    FLOAT fPointY = static_cast<FLOAT>(point.y);
    // an output flag that indicates whether the hit-test location 
    // is at the leading or the trailing side of the character.
    BOOL bIsTrailingHit = FALSE;
    // an output flag that indicates whether the hit-test location 
    // is inside the text string
    BOOL bIsInside = FALSE;
    // output geometry fully enclosing the hit-test location
    DWRITE_HIT_TEST_METRICS hitTestMetrics = { 0 };

    HRESULT hr = pTextLayout->HitTestPoint(IN fPointX, IN fPointY,
        OUT &bIsTrailingHit, OUT &bIsInside, OUT &hitTestMetrics);

    if (SUCCEEDED(hr))
    {
        // keep in mind the hit-test text position
        m_nCaretPosition = hitTestMetrics.textPosition;
        Invalidate();
    }

    CWnd::OnLButtonDown(nFlags, point);
}

void CChildView::OnLButtonDown(UINT nFlags, CPoint point)

{

// ...

// Get IDWriteTextLayout interface from CD2DTextLayout object

IDWriteTextLayout* pTextLayout = m_pTextLayout->Get();

// pixel location X to hit-test,

// relative to the top-left location of the layout box.

FLOAT fPointX = static_cast<FLOAT>(point.x);

// pixel location Y to hit-test,

// relative to the top-left location of the layout box.

FLOAT fPointY = static_cast<FLOAT>(point.y);

// an output flag that indicates whether the hit-test location

// is at the leading or the trailing side of the character.

BOOL bIsTrailingHit = FALSE;

// an output flag that indicates whether the hit-test location

// is inside the text string

BOOL bIsInside = FALSE;

// output geometry fully enclosing the hit-test location

DWRITE_HIT_TEST_METRICS hitTestMetrics = { 0 };

HRESULT hr = pTextLayout->HitTestPoint(IN fPointX, IN fPointY,

OUT &bIsTrailingHit, OUT &bIsInside, OUT &hitTestMetrics);

if (SUCCEEDED(hr))

{

// keep in mind the hit-test text position

m_nCaretPosition = hitTestMetrics.textPosition;

Invalidate();

}

CWnd::OnLButtonDown(nFlags, point);

}

Hit-testing a text position

Further, use the previousy kept in mind text position and call IDWriteTextLayout::HitTestTextPosition when need to draw the caret.

void CChildView::_DrawCaret(CHwndRenderTarget* pRenderTarget)
{
    ASSERT_VALID(m_pTextLayout);
    ASSERT(m_pTextLayout->IsValid());

    // Get  IDWriteTextLayout interface from CD2DTextLayout object
    IDWriteTextLayout* pTextLayout = m_pTextLayout->Get();

    // flag that indicates whether the pixel location is of the 
    // leading or the trailing side of the specified text position
    BOOL bIsTrailingHit = FALSE;
    FLOAT fPointX = 0.0f, fPointY = 0.0f;
    DWRITE_HIT_TEST_METRICS hitTestMetrics = { 0 };
    HRESULT hr = pTextLayout->HitTestTextPosition(
        IN m_nCaretPosition,
        IN bIsTrailingHit,
        OUT &fPointX,
        OUT &fPointY,
        OUT &hitTestMetrics);

    if (SUCCEEDED(hr))
    {
        // Draw the caret
        // Note: this is just for demo purpose and
        // you may want to make something more elaborated here
        CD2DRectF rcCaret(fPointX + TEXT_MARGIN, fPointY + TEXT_MARGIN,
            fPointX + TEXT_MARGIN + 2, fPointY + TEXT_MARGIN + hitTestMetrics.height);
        pRenderTarget->FillRectangle(&rcCaret,
            &CD2DSolidColorBrush(pRenderTarget, CARET_COLOR));
    }
}

void CChildView::_DrawCaret(CHwndRenderTarget* pRenderTarget)

{

ASSERT_VALID(m_pTextLayout);

ASSERT(m_pTextLayout->IsValid());

// Get IDWriteTextLayout interface from CD2DTextLayout object

IDWriteTextLayout* pTextLayout = m_pTextLayout->Get();

// flag that indicates whether the pixel location is of the

// leading or the trailing side of the specified text position

BOOL bIsTrailingHit = FALSE;

FLOAT fPointX = 0.0f, fPointY = 0.0f;

DWRITE_HIT_TEST_METRICS hitTestMetrics = { 0 };

HRESULT hr = pTextLayout->HitTestTextPosition(

IN m_nCaretPosition,

IN bIsTrailingHit,

OUT &fPointX,

OUT &fPointY,

OUT &hitTestMetrics);

if (SUCCEEDED(hr))

{

// Draw the caret

// Note: this is just for demo purpose and

// you may want to make something more elaborated here

CD2DRectF rcCaret(fPointX + TEXT_MARGIN, fPointY + TEXT_MARGIN,

fPointX + TEXT_MARGIN + 2, fPointY + TEXT_MARGIN + hitTestMetrics.height);

pRenderTarget->FillRectangle(&rcCaret,

&CD2DSolidColorBrush(pRenderTarget, CARET_COLOR));

}

Hit-testing a text range

And finally, here is an example of using IDWriteTextLayout::HitTestTextRange

BOOL CChildView::_TextRangeHitTest(const CPoint& point, const DWRITE_TEXT_RANGE& textRange)
{
    ASSERT_VALID(m_pTextLayout);
    ASSERT(m_pTextLayout->IsValid());

    // Get  IDWriteTextLayout interface from CD2DTextLayout object
    IDWriteTextLayout* pTextLayout = m_pTextLayout->Get();

    FLOAT nOriginX = 0.0f, nOriginY = 0.0f;
    UINT32 nActualHitTestMetricsCount = 0;
    // Call once IDWriteTextLayout::HitTestTextRange in order to find out
    // the place required for DWRITE_HIT_TEST_METRICS structures
    // See MSDN documentation:
    // https://msdn.microsoft.com/en-us/library/windows/desktop/dd371473(v=vs.85).aspx
    HRESULT hr = pTextLayout->HitTestTextRange(textRange.startPosition, textRange.length,
        nOriginX, nOriginY, NULL, 0, &nActualHitTestMetricsCount);

    if (HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) != hr)
        return FALSE;

    // Allocate enough room for all hit-test metrics.
    std::vector<DWRITE_HIT_TEST_METRICS> vHitTestMetrics(nActualHitTestMetricsCount);

    // Call IDWriteTextLayout::HitTestTextRange again to effectively 
    // get the DWRITE_HIT_TEST_METRICS structures
    hr = pTextLayout->HitTestTextRange(textRange.startPosition, textRange.length,
        nOriginX, nOriginY,
        &vHitTestMetrics[0],
        static_cast(vHitTestMetrics.size()),
        &nActualHitTestMetricsCount);

    if (FAILED(hr))
        return FALSE;

    for (UINT32 nIndex = 0; nIndex < nActualHitTestMetricsCount; nIndex++)
    {
        DWRITE_HIT_TEST_METRICS& hitTestMetrics = vHitTestMetrics[nIndex];
        CRect rcHit((int)hitTestMetrics.left, (int)hitTestMetrics.top,
            (int)hitTestMetrics.left + (int)hitTestMetrics.width,
            (int)hitTestMetrics.top + (int)hitTestMetrics.height);

        if (rcHit.PtInRect(point))
            return TRUE;
    }
    return FALSE;
}

BOOL CChildView::_TextRangeHitTest(const CPoint& point, const DWRITE_TEXT_RANGE& textRange)

{

ASSERT_VALID(m_pTextLayout);

ASSERT(m_pTextLayout->IsValid());

// Get IDWriteTextLayout interface from CD2DTextLayout object

IDWriteTextLayout* pTextLayout = m_pTextLayout->Get();

FLOAT nOriginX = 0.0f, nOriginY = 0.0f;

UINT32 nActualHitTestMetricsCount = 0;

// Call once IDWriteTextLayout::HitTestTextRange in order to find out

// the place required for DWRITE_HIT_TEST_METRICS structures

// See MSDN documentation:

// https://msdn.microsoft.com/en-us/library/windows/desktop/dd371473(v=vs.85).aspx

HRESULT hr = pTextLayout->HitTestTextRange(textRange.startPosition, textRange.length,

nOriginX, nOriginY, NULL, 0, &nActualHitTestMetricsCount);

if (HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) != hr)

return FALSE;

// Allocate enough room for all hit-test metrics.

std::vector<DWRITE_HIT_TEST_METRICS> vHitTestMetrics(nActualHitTestMetricsCount);

// Call IDWriteTextLayout::HitTestTextRange again to effectively

// get the DWRITE_HIT_TEST_METRICS structures

hr = pTextLayout->HitTestTextRange(textRange.startPosition, textRange.length,

nOriginX, nOriginY,

&vHitTestMetrics[0],

static_cast(vHitTestMetrics.size()),

&nActualHitTestMetricsCount);

if (FAILED(hr))

return FALSE;

for (UINT32 nIndex = 0; nIndex < nActualHitTestMetricsCount; nIndex++)

{

DWRITE_HIT_TEST_METRICS& hitTestMetrics = vHitTestMetrics[nIndex];

CRect rcHit((int)hitTestMetrics.left, (int)hitTestMetrics.top,

(int)hitTestMetrics.left + (int)hitTestMetrics.width,

(int)hitTestMetrics.top + (int)hitTestMetrics.height);

if (rcHit.PtInRect(point))

return TRUE;

}

return FALSE;

}

It can be used, for example, to set the hand cursor when the mouse is moved over the given text range:

void CChildView::OnMouseMove(UINT nFlags, CPoint point)
{
    DWRITE_TEXT_RANGE textRange = _GetHyperlinkTextRange();

    if (_TextRangeHitTest(point, textRange))
        ::SetCursor(m_hCursorHand);
    else
        ::SetCursor(m_hCursorArrow);

    CWnd::OnMouseMove(nFlags, point);
}

void CChildView::OnMouseMove(UINT nFlags, CPoint point)

{

DWRITE_TEXT_RANGE textRange = _GetHyperlinkTextRange();

if (_TextRangeHitTest(point, textRange))

::SetCursor(m_hCursorHand);

else

::SetCursor(m_hCursorArrow);

CWnd::OnMouseMove(nFlags, point);

}

or can show some internet page when te user clicks on a “hyperlink”.

void CChildView::OnLButtonUp(UINT nFlags, CPoint point)
{
    DWRITE_TEXT_RANGE textRange = _GetHyperlinkTextRange();

    if (_TextRangeHitTest(point, textRange))
    {
        ::ShellExecute(m_hWnd, _T("open"), TEXT_URL, NULL, NULL, SW_SHOWNORMAL);
    }

    CWnd::OnLButtonUp(nFlags, point);
}

void CChildView::OnLButtonUp(UINT nFlags, CPoint point)

{

DWRITE_TEXT_RANGE textRange = _GetHyperlinkTextRange();

if (_TextRangeHitTest(point, textRange))

{

::ShellExecute(m_hWnd, _T("open"), TEXT_URL, NULL, NULL, SW_SHOWNORMAL);

}

CWnd::OnLButtonUp(nFlags, point);

}

More details can be found in the demo examples attached to this article.

Demo projects

I’ve added the hit-test features to DirectWrite Static Control.
Download: Download: MFC Support for DirectWrite Demo (Part 9).zip (1070)

MFC DirectWrite – Hit-Test Demo

Also here can be found a simpler application, only showing the DirectWrite hit-test features, to be easier understand: Simple DirectWrite Hit-Test Demo.zip (1187)

Resources and related articles

MSDN: IDWriteTextLayout::HitTestPoint method
MSDN: IDWriteTextLayout::HitTestTextPosition method
MSDN: IDWriteTextLayout::HitTestTextRange method
MSDN: How to Perform Hit Testing on a Text Layout
pauldotknopf/WindowsSDK7-Samples: PadWrite

MFC Support for Direct2D – Part 3: Multithreading

Leave a reply

As shown in previous articles, we can enable MFC Direct2D support for a window by a call of CWnd::EnableD2DSupport.
Example:

int CSlideShowWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CWnd::OnCreate(lpCreateStruct) == -1)
        return -1;

    // Enable MFC Direct2D support
    EnableD2DSupport();
    // ...

    return 0;
}

int CSlideShowWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

if (CWnd::OnCreate(lpCreateStruct) == -1)

return -1;

// Enable MFC Direct2D support

EnableD2DSupport();

// ...

return 0;

}

So far so good as long as all windows which use Direct2D are running in the same thread (usually the application main thread). But let’s say we have more than one window with intensive rendering (e.g. some images slide show). In this case we would like to create each window in a separate thread. But this could cause the drawing to freeze or even application to crash. So, what should we do?

Create multi-threaded Direct2D factory

If step into MFC code starting with CWnd::EnableD2DSupport, we can notice the following:

check if Direct2D and DirectWrite (kept in a global object of type _AFX_D2D_STATE) are already created;
if not, call _AFX_D2D_STATE::InitD2D with default parameters D2D1_FACTORY_TYPE_SINGLE_THREADED and DWRITE_FACTORY_TYPE_SHARED.

Now, lets see the comments from D2D1_FACTORY_TYPE enumeration.

typedef enum D2D1_FACTORY_TYPE
{
    //
    // The resulting factory and derived resources may only be invoked serially.
    // Reference counts on resources are interlocked, however, resource and render
    // target state is not protected from multi-threaded access.
    //
    D2D1_FACTORY_TYPE_SINGLE_THREADED = 0,

    //
    // The resulting factory may be invoked from multiple threads. Returned resources
    // use interlocked reference counting and their state is protected.
    //
    D2D1_FACTORY_TYPE_MULTI_THREADED = 1,
    D2D1_FACTORY_TYPE_FORCE_DWORD = 0xffffffff

} D2D1_FACTORY_TYPE;

typedef enum D2D1_FACTORY_TYPE

{

// The resulting factory and derived resources may only be invoked serially.

// Reference counts on resources are interlocked, however, resource and render

// target state is not protected from multi-threaded access.

D2D1_FACTORY_TYPE_SINGLE_THREADED = 0,

// The resulting factory may be invoked from multiple threads. Returned resources

// use interlocked reference counting and their state is protected.

D2D1_FACTORY_TYPE_MULTI_THREADED = 1,

D2D1_FACTORY_TYPE_FORCE_DWORD = 0xffffffff

} D2D1_FACTORY_TYPE;

Also, let’s see what MSDN documentation states:

D2D1_FACTORY_TYPE_SINGLE_THREADED
No synchronization is provided for accessing or writing to the factory or the objects it creates. If the factory or the objects are called from multiple threads, it is up to the application to provide access locking.
D2D1_FACTORY_TYPE_MULTI_THREADED
Direct2D provides synchronization for accessing and writing to the factory and the objects it creates, enabling safe access from multiple threads.

Making the synchronization is not so handy so we have to find a way to create a Direct2D factory that uses multi-threaded model. Fortunately, that’s very easy by a single call of CWinApp::EnableD2DSupport.

BOOL CDemoApp::InitInstance()
{
    // NOTE: Just for testing purpose, comment the below line of code
    //       then open more than one slide-show windows which are running 
    //       in different threads. See what happens.
    VERIFY(EnableD2DSupport(D2D1_FACTORY_TYPE_MULTI_THREADED));
    // ...

    return FALSE;
}

BOOL CDemoApp::InitInstance()

{

// NOTE: Just for testing purpose, comment the below line of code

// then open more than one slide-show windows which are running

// in different threads. See what happens.

VERIFY(EnableD2DSupport(D2D1_FACTORY_TYPE_MULTI_THREADED));

// ...

return FALSE;

}

That’s all. Hurray!

Demo application

Download: MFC Direct2D Multithreading Demo.zip (1179)

The demo application can create multiple windows that perform image slideshow with Direct2D, each one in its own thread. Just push the button then select a folder containing image files.

MFC Direct2D Multithreading – Demo

Resources and related articles

MSDN: CWinApp::EnableD2DSupport
MSDN: D2D1CreateFactory function
MSDN: D2D1_FACTORY_TYPE enumeration
Codexpert blog: MFC Support for Direct2D articles

Demo aplication

Resources and related articles

Share this:

Like this:

Create a MDI client window which belongs to a window class having CS_DBLCLKS style

Handle MDI Client double-clicks in standard MFC applications

Handle MDI Client double-clicks in Visual Studio or Office-style MFC applications

Demo solution

Resources and related articles

Share this:

Like this:

Drawing Direct2D content to a GDI device context

Drawing GDI content to a Direct2D GDI-compatible render target

Demo projects

Notes

Resources and related articles

Share this:

Like this:

Getting ID2D1DeviceContext interface in an MFC application

Drawing an image using the Gaussian Blur built-in effect

The demo project

Notes

Resources and related articles

Share this:

Like this:

Overridden IDWriteTextRenderer::DrawGlyphRun implementation

A method for drawing outlined text

Demo project

Resources and related articles

Share this:

Like this:

Hit-testing a point

Hit-testing a text position

Hit-testing a text range

Demo projects

Resources and related articles

Share this:

Like this:

Create multi-threaded Direct2D factory

Demo application

Resources and related articles

Share this:

Like this: