Category Archives: DirectWrite

MFC Support for DirectWrite – Part 11: About Trimming Again

In a previous article, I showed how to trim a text which overflows the layout box. In the example presented there, the ellipsis is added at the end of truncated text. But if, let’s say, we have to show a long path and file name, it is not meaningful if the file name is not displayed. No problem, this can be easily resolved if have a look at DWRITE_TRIMMING structure which passed to IDWriteTextFormat::SetTrimming. The second parameter is a character code used as delimiter and the third one is the delimiter count. The text is preserved from the end until is found the delimiter which coresponds to delimiter count. For example, if the delimiter is backslash and the delimiter count is 2, a text like “e:\Articles\MFC Support for DirectWrite\DirectWrite Trimming Demo\D2DStaticCtrl.cpp” may be displayed as follows “e:\Articles…\DirectWrite Trimming Demo\D2DStaticCtrl.cpp”.

An example of trimming by using a delimiter

LRESULT CD2DStaticCtrl::OnAfxDraw2D(WPARAM wParam, LPARAM lParam)
{
    // ...

    // Set text trimming
    CComPtr<IDWriteInlineObject> spInlineObject;
    IDWriteFactory* pDirectWriteFactory = AfxGetD2DState()->GetWriteFactory();
    hr = pDirectWriteFactory->CreateEllipsisTrimmingSign(textFormat.Get(), 
        &spInlineObject);
    if (FAILED(hr))
        return FALSE;

    DWRITE_TRIMMING trimming = { DWRITE_TRIMMING_GRANULARITY_CHARACTER, '\\', 2 };

    hr = textFormat.Get()->SetTrimming(&trimming, spInlineObject);
    if (FAILED(hr))
        return FALSE;

    // ...

    return TRUE;
}

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

{

// ...

// Set text trimming

CComPtr<IDWriteInlineObject> spInlineObject;

IDWriteFactory* pDirectWriteFactory = AfxGetD2DState()->GetWriteFactory();

hr = pDirectWriteFactory->CreateEllipsisTrimmingSign(textFormat.Get(),

&spInlineObject);

if (FAILED(hr))

return FALSE;

DWRITE_TRIMMING trimming = { DWRITE_TRIMMING_GRANULARITY_CHARACTER, '\\', 2 };

hr = textFormat.Get()->SetTrimming(&trimming, spInlineObject);

if (FAILED(hr))

return FALSE;

// ...

return TRUE;

}

Demo project

Download: DirectWrite Trimming Demo.zip (82)
The demo project is a simple MFC application which demonstrate how to trim text rendered with DirectWrite. You can choose the granularity, the delimiter and the delimiter count and see what is displayed.

DirectWrite Trimming Demo

Resources and related articles

MSDN: DWRITE_TRIMMING structure
Codexpert: MFC Support for DirectWrite – Part 8: Trimming

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 (232)

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 (238)

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 (257)

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 DirectWrite – Part 8: Trimming

Leave a reply

When using “classic” GDI functions i.e. CDC::DrawText, it’s no sweat to trim with ellipsis a single-line text when that text does not fit in the drawing rectangle width, by specifying DT_WORDBREAK flag. We cannot find a similar flag for CRenderTarget::DrawText or CRenderTarget::DrawTextLayout. However, trimming a text is also possible with DirectDraw. All we have to do is the following:

call IDWriteFactory::CreateEllipsisTrimmingSign to create an inline object for trimming, using ellipsis as the omission sign;
pass the created inline object to IDWriteTextFormat::SetTrimming.

Here is a simple code example in an MFC-based application:

Direct2D text trimming code sample

    // ...
    CD2DTextFormat textFormat(pRenderTarget, m_strFontFamilyName, m_fFontSize);
    IDWriteTextFormat* pTextFormat = textFormat.Get();

    // Set single-line text
    pTextFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);

    // Get IDWriteFactory
    _AFX_D2D_STATE* pD2DState = AfxGetD2DState();
    IDWriteFactory* pDirectWriteFactory = pD2DState->GetWriteFactory();

    // Create an inline object for trimming
    CComPtr<IDWriteInlineObject> spInlineObject;
    pDirectWriteFactory->CreateEllipsisTrimmingSign(textFormat.Get(), &spInlineObject);

    // Call IDWriteTextFormat::SetTrimming to set trimming for text overflowing the layout width.
    // Note: use DWRITE_TRIMMING_GRANULARITY_CHARACTER for trimming at character cluster boundary
    //       or DWRITE_TRIMMING_GRANULARITY_WORD for trimming at word boundary.
    DWRITE_TRIMMING trimming = { DWRITE_TRIMMING_GRANULARITY_CHARACTER, 0, 0 };
    pTextFormat->SetTrimming(&trimming, spInlineObject);
    // ...

    // Draw the text in render target
    pRenderTarget->DrawText(m_strText, rcDraw, m_pTextBrush, &textFormat);

// ...

CD2DTextFormat textFormat(pRenderTarget, m_strFontFamilyName, m_fFontSize);

IDWriteTextFormat* pTextFormat = textFormat.Get();

// Set single-line text

pTextFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);

// Get IDWriteFactory

_AFX_D2D_STATE* pD2DState = AfxGetD2DState();

IDWriteFactory* pDirectWriteFactory = pD2DState->GetWriteFactory();

// Create an inline object for trimming

CComPtr<IDWriteInlineObject> spInlineObject;

pDirectWriteFactory->CreateEllipsisTrimmingSign(textFormat.Get(), &spInlineObject);

// Call IDWriteTextFormat::SetTrimming to set trimming for text overflowing the layout width.

// Note: use DWRITE_TRIMMING_GRANULARITY_CHARACTER for trimming at character cluster boundary

// or DWRITE_TRIMMING_GRANULARITY_WORD for trimming at word boundary.

DWRITE_TRIMMING trimming = { DWRITE_TRIMMING_GRANULARITY_CHARACTER, 0, 0 };

pTextFormat->SetTrimming(&trimming, spInlineObject);

// ...

// Draw the text in render target

pRenderTarget->DrawText(m_strText, rcDraw, m_pTextBrush, &textFormat);

Demo project

Download: MFC Support for DirectWrite Demo (Part 8).zip (205)

The demo project contains sample code for all my DirectWrite-related articles. To demonstrate this one, in Trimming granularity combo, select “Character” or “Word”. Also select “No wrap” in Word wrapping combo then have fun.

MFC DirectWrite Demo Project

Resources and related articles

MSDN: IDWriteTextFormat::SetTrimming
MSDN: IDWriteFactory::CreateEllipsisTrimmingSign
Codexpert blog: MFC Support for DirectWrite articles
Codexpert blog: MFC Support for Direct2D articles

Codexpert – 2016 Articles Summary

Leave a reply

C++ Programming Language

Microsoft Libraries

Visual C++

Getting Direct2D, DirectWrite and WIC Factories in MFC

Leave a reply

MFC library offers a series of wrapper classes over Direct2D and DirectWrite interfaces (see CRenderTarget and CD2D classes). That’s pretty cool because allows to easily load and render images and draw texts, without care too much of direct dealing with COM interfaces.
However, let’s say we have to implemented something different so we need to start creating Direct2D or DirectWrite factories. Of course, we can call D2D1CreateFactory or DWriteCreateFactory functions, but a little bit handier is to use the factories instances created and kept by the MFC framework.

Getting Direct2D, DirectWrite and WIC factories in Visual Studio 2010

In MFC framework shipped with Visual Studio 2010, the instances of ID2D1Factory and IDWriteFactory are created and kept in a global AFX_GLOBAL_DATA structure named afxGlobalData. So, we have to do something like this:

    ID2D1Factory* pDirect2dFactory = afxGlobalData.GetDirect2dFactory();
    IDWriteFactory* pDirectWriteFactory = afxGlobalData.GetWriteFactory();
    IWICImagingFactory* pImagingFactory = afxGlobalData.GetWICFactory();
    // ...

ID2D1Factory* pDirect2dFactory = afxGlobalData.GetDirect2dFactory();

IDWriteFactory* pDirectWriteFactory = afxGlobalData.GetWriteFactory();

IWICImagingFactory* pImagingFactory = afxGlobalData.GetWICFactory();

// ...

Getting Direct2D, DirectWrite and WIC factories in Visual Studio 2012 – 2015

In Visual Studio 2012, these factory instances have been moved in a D2D-specific structure of type _AFX_D2D_STATE that can be accessed by calling AfxGetD2DState.

    _AFX_D2D_STATE* pD2DState = AfxGetD2DState();

    ID2D1Factory* pDirect2dFactory = pD2DState->GetDirect2dFactory();
    IDWriteFactory* pDirectWriteFactory = pD2DState->GetWriteFactory();
    IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();
    // ...

_AFX_D2D_STATE* pD2DState = AfxGetD2DState();

ID2D1Factory* pDirect2dFactory = pD2DState->GetDirect2dFactory();

IDWriteFactory* pDirectWriteFactory = pD2DState->GetWriteFactory();

IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();

// ...

Now, we can note that MFC framework keeps also an instance of IWICImagingFactory which is internally used by CD2D classes. That’s also pretty cool; we’ll use it in the following example.

An example of getting and using IWICImagingFactory

Here is a brief example of getting IWICImagingFactory to further read metadata stored in JPEG, TIFF and other image formats.

void CWhateverMFCClass::ListImageFileMetadata(LPCWSTR wzFilePath)
{
    // get IWICImagingFactory from global _AFX_D2D_STATE structure
    _AFX_D2D_STATE* pD2DState = AfxGetD2DState();
    IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();
    ATLASSERT(pImagingFactory);

    try
    {
        // create bitmap decoder based on the given file
        CComPtr<IWICBitmapDecoder> spBitmapDecoder;
        HRESULT hr = pImagingFactory->CreateDecoderFromFilename(wzFilePath, NULL,
            GENERIC_READ, WICDecodeMetadataCacheOnLoad, &spBitmapDecoder);
        ATLENSURE_SUCCEEDED(hr);

        // get first image frame
        CComPtr<IWICBitmapFrameDecode> spBitmapFrameDecode;
        hr = spBitmapDecoder->GetFrame(0, &spBitmapFrameDecode);
        ATLENSURE_SUCCEEDED(hr);

        // get metadata reader
        CComPtr<IWICMetadataQueryReader> spMetadataQueryReader;
        hr = spBitmapFrameDecode->GetMetadataQueryReader(&spMetadataQueryReader);
        ATLENSURE_SUCCEEDED(hr);

        // further, just a little sweat to read metadata :)
        // ...
    }
    catch (CException* e)
    {
        e->ReportError();
        e->Delete();
    }
}

void CWhateverMFCClass::ListImageFileMetadata(LPCWSTR wzFilePath)

{

// get IWICImagingFactory from global _AFX_D2D_STATE structure

_AFX_D2D_STATE* pD2DState = AfxGetD2DState();

IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();

ATLASSERT(pImagingFactory);

try

{

// create bitmap decoder based on the given file

CComPtr<IWICBitmapDecoder> spBitmapDecoder;

HRESULT hr = pImagingFactory->CreateDecoderFromFilename(wzFilePath, NULL,

GENERIC_READ, WICDecodeMetadataCacheOnLoad, &spBitmapDecoder);

ATLENSURE_SUCCEEDED(hr);

// get first image frame

CComPtr<IWICBitmapFrameDecode> spBitmapFrameDecode;

hr = spBitmapDecoder->GetFrame(0, &spBitmapFrameDecode);

ATLENSURE_SUCCEEDED(hr);

// get metadata reader

CComPtr<IWICMetadataQueryReader> spMetadataQueryReader;

hr = spBitmapFrameDecode->GetMetadataQueryReader(&spMetadataQueryReader);

ATLENSURE_SUCCEEDED(hr);

// further, just a little sweat to read metadata :)

// ...

}

catch (CException* e)

{

e->ReportError();

e->Delete();

}

References and related articles

MSDN: IWICImagingFactory interface
MSDN: Breaking Changes in Visual C++ 2012
Codexpert blog: MFC Support for DirectWrite – Part 5: Typography

MFC Support for DirectWrite – Part 7: A Step to Custom Rendering

Leave a reply

The previous articles from this series show how to format the text layout using built-in DirectWrite methods. However, as said earlier, we can do more custom formatting (e.g. draw double/triple underline/strikethrough, highlight text and so on). How can be done? First, let’s note that ID2D1RenderTarget::DrawTextLayout internally calls IDWriteTextLayout::Draw which has the following prototype:

HRESULT Draw(
   void*                clientDrawingContext,
   IDWriteTextRenderer* renderer,
   FLOAT                originX,
   FLOAT                originY)

HRESULT Draw(

void* clientDrawingContext,

IDWriteTextRenderer* renderer,

FLOAT originX,

FLOAT originY)

We can write our own implementation of IDWriteTextRenderer interface providing custom text rendering then directly call IDWriteTextLayout::Draw instead of CRenderTarget::DrawTextLayout.

Code samples

class CCustomTextRenderer : public CCmdTarget
{
	DECLARE_DYNAMIC(CCustomTextRenderer)
public:
	CCustomTextRenderer() = default;
	virtual ~CCustomTextRenderer() = default;
    IDWriteTextRenderer* Get();
public:
    DECLARE_INTERFACE_MAP()
    BEGIN_INTERFACE_PART(CustomTextRenderer, IDWriteTextRenderer)
        // override IDWriteTextRenderer methods
        STDMETHOD(DrawGlyphRun)(void*, FLOAT, FLOAT, DWRITE_MEASURING_MODE, const DWRITE_GLYPH_RUN*, 
                                const DWRITE_GLYPH_RUN_DESCRIPTION*, IUnknown*);
        STDMETHOD(DrawInlineObject)(void*, FLOAT, FLOAT, IDWriteInlineObject*, BOOL, BOOL, IUnknown*);
        STDMETHOD(DrawStrikethrough)(void*, FLOAT, FLOAT, const DWRITE_STRIKETHROUGH*, IUnknown*);
        STDMETHOD(DrawUnderline)(void*, FLOAT, FLOAT, const DWRITE_UNDERLINE*, IUnknown*);
        // override IDWritePixelSnapping methods
        STDMETHOD(GetCurrentTransform)(void*, DWRITE_MATRIX*);
        STDMETHOD(GetPixelsPerDip)(void*, FLOAT*);
        STDMETHOD(IsPixelSnappingDisabled)(void*, BOOL*);
        // implementation helpers
        void _FillRectangle(void*, IUnknown*, FLOAT, FLOAT, FLOAT, FLOAT, 
                            DWRITE_READING_DIRECTION, DWRITE_FLOW_DIRECTION);
    END_INTERFACE_PART(CustomTextRenderer)
};

class CCustomTextRenderer : public CCmdTarget

{

DECLARE_DYNAMIC(CCustomTextRenderer)

public:

CCustomTextRenderer() = default;

virtual ~CCustomTextRenderer() = default;

IDWriteTextRenderer* Get();

public:

DECLARE_INTERFACE_MAP()

BEGIN_INTERFACE_PART(CustomTextRenderer, IDWriteTextRenderer)

// override IDWriteTextRenderer methods

STDMETHOD(DrawGlyphRun)(void*, FLOAT, FLOAT, DWRITE_MEASURING_MODE, const DWRITE_GLYPH_RUN*,

const DWRITE_GLYPH_RUN_DESCRIPTION*, IUnknown*);

STDMETHOD(DrawInlineObject)(void*, FLOAT, FLOAT, IDWriteInlineObject*, BOOL, BOOL, IUnknown*);

STDMETHOD(DrawStrikethrough)(void*, FLOAT, FLOAT, const DWRITE_STRIKETHROUGH*, IUnknown*);

STDMETHOD(DrawUnderline)(void*, FLOAT, FLOAT, const DWRITE_UNDERLINE*, IUnknown*);

// override IDWritePixelSnapping methods

STDMETHOD(GetCurrentTransform)(void*, DWRITE_MATRIX*);

STDMETHOD(GetPixelsPerDip)(void*, FLOAT*);

STDMETHOD(IsPixelSnappingDisabled)(void*, BOOL*);

// implementation helpers

void _FillRectangle(void*, IUnknown*, FLOAT, FLOAT, FLOAT, FLOAT,

DWRITE_READING_DIRECTION, DWRITE_FLOW_DIRECTION);

END_INTERFACE_PART(CustomTextRenderer)

};

BEGIN_INTERFACE_MAP(CCustomTextRenderer, CCmdTarget)
    INTERFACE_PART(CCustomTextRenderer, __uuidof(IDWriteTextRenderer), CustomTextRenderer)
END_INTERFACE_MAP()

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)
{
    // NOTE: This does the same as the default implementation.
    // In a future version will be modified in order to perform some custom rendering.

    CDrawingContext* pDrawingContext = static_cast<CDrawingContext*>(pClientDrawingContext);
    ASSERT_VALID(pDrawingContext);

    ID2D1Brush* pBrush = pDrawingContext->GetDefaultBrush()->Get();
    if(NULL != pClientDrawingEffect)
    {
        pBrush = static_cast<ID2D1Brush*>(pClientDrawingEffect);
    }

    CRenderTarget* pRenderTarget = pDrawingContext->GetRenderTarget();
    ASSERT_VALID(pRenderTarget);
    pRenderTarget->GetRenderTarget()->DrawGlyphRun(CD2DPointF(fBaselineOriginX, fBaselineOriginY), 
        pGlyphRun, pBrush, measuringMode);

    return S_OK;
}
// ...
// Please, find the other methods implementation in the attached demo project!
// ...

BEGIN_INTERFACE_MAP(CCustomTextRenderer, CCmdTarget)

INTERFACE_PART(CCustomTextRenderer, __uuidof(IDWriteTextRenderer), CustomTextRenderer)

END_INTERFACE_MAP()

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)

{

// NOTE: This does the same as the default implementation.

// In a future version will be modified in order to perform some custom rendering.

CDrawingContext* pDrawingContext = static_cast<CDrawingContext*>(pClientDrawingContext);

ASSERT_VALID(pDrawingContext);

ID2D1Brush* pBrush = pDrawingContext->GetDefaultBrush()->Get();

if(NULL != pClientDrawingEffect)

{

pBrush = static_cast<ID2D1Brush*>(pClientDrawingEffect);

}

CRenderTarget* pRenderTarget = pDrawingContext->GetRenderTarget();

ASSERT_VALID(pRenderTarget);

pRenderTarget->GetRenderTarget()->DrawGlyphRun(CD2DPointF(fBaselineOriginX, fBaselineOriginY),

pGlyphRun, pBrush, measuringMode);

return S_OK;

}

// ...

// Please, find the other methods implementation in the attached demo project!

// ...

void CDirectWriteStaticCtrl::_DrawTextLayout(CHwndRenderTarget* pRenderTarget)
{
    CD2DTextFormat textFormat(pRenderTarget,
        m_strFontFamilyName, m_fFontSize, m_eFontWeight, m_eFontStyle, m_eFontStretch);

    textFormat.Get()->SetTextAlignment(m_eTextAlignment);
    textFormat.Get()->SetWordWrapping(m_eWordWrapping);
    textFormat.Get()->SetParagraphAlignment(m_eParagraphAlignment);

    CD2DSizeF sizeTarget = pRenderTarget->GetSize();
    CD2DSizeF sizeDraw(sizeTarget.width - 2 * m_fMargin, sizeTarget.height - 2 * m_fMargin);
    CD2DTextLayout textLayout(pRenderTarget, m_strText, textFormat, sizeDraw);

    POSITION pos = m_listTextRangeFormat.GetHeadPosition();
    while (NULL != pos)
        m_listTextRangeFormat.GetNext(pos)->Apply(textLayout);

    CD2DSolidColorBrush* pDefaultBrush = new CD2DSolidColorBrush(pRenderTarget, m_crTextColor);
    pDefaultBrush->Create(pRenderTarget);
    CDrawingContext* pDrawingContext = new CDrawingContext(pRenderTarget, pDefaultBrush);

    // call IDWriteTextLayout::Draw passing custom IDWriteTextRenderer 
    textLayout.Get()->Draw(pDrawingContext, m_textRenderer.Get(), m_fMargin, m_fMargin);
}

void CDirectWriteStaticCtrl::_DrawTextLayout(CHwndRenderTarget* pRenderTarget)

{

CD2DTextFormat textFormat(pRenderTarget,

m_strFontFamilyName, m_fFontSize, m_eFontWeight, m_eFontStyle, m_eFontStretch);

textFormat.Get()->SetTextAlignment(m_eTextAlignment);

textFormat.Get()->SetWordWrapping(m_eWordWrapping);

textFormat.Get()->SetParagraphAlignment(m_eParagraphAlignment);

CD2DSizeF sizeTarget = pRenderTarget->GetSize();

CD2DSizeF sizeDraw(sizeTarget.width - 2 * m_fMargin, sizeTarget.height - 2 * m_fMargin);

CD2DTextLayout textLayout(pRenderTarget, m_strText, textFormat, sizeDraw);

POSITION pos = m_listTextRangeFormat.GetHeadPosition();

while (NULL != pos)

m_listTextRangeFormat.GetNext(pos)->Apply(textLayout);

CD2DSolidColorBrush* pDefaultBrush = new CD2DSolidColorBrush(pRenderTarget, m_crTextColor);

pDefaultBrush->Create(pRenderTarget);

CDrawingContext* pDrawingContext = new CDrawingContext(pRenderTarget, pDefaultBrush);

// call IDWriteTextLayout::Draw passing custom IDWriteTextRenderer

textLayout.Get()->Draw(pDrawingContext, m_textRenderer.Get(), m_fMargin, m_fMargin);

}

Demo project

So far, it contains an implementation of IDWriteTextRenderer which does the same as the default one. In a further article I will update it in order to perform custom rendering.
Download: MFC Support for DirectWrite Demo (Part 7).zip (609)

Notes

You can find an excellent related article on Petzold Book Blog; see the link below.

Resources and related articles

Codexpert blog: MFC Support for DirectWrite – Part 10: Outlined Text
Petzold Book Blog: Character Formatting Extensions with DirectWrite
MSDN: IDWriteTextLayout::Draw method
MSDN: IDWriteTextRenderer interface
MSDN: IDWritePixelSnapping interface

An example of trimming by using a delimiter

Demo project

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:

Direct2D text trimming code sample

Demo project

Resources and related articles

Share this:

Like this:

C++ Programming Language

Microsoft Libraries

Visual C++

See also

Share this:

Like this:

Getting Direct2D, DirectWrite and WIC factories in Visual Studio 2010

Getting Direct2D, DirectWrite and WIC factories in Visual Studio 2012 – 2015

An example of getting and using IWICImagingFactory

References and related articles

Share this:

Like this:

Code samples

Demo project

Notes

Resources and related articles

Share this:

Like this: