C++ IDWriteGdiInterop类代码示例

IDWriteFont* CreateDWriteFontFromGDIFamilyName(IDWriteFactory* factory, const WCHAR* gdiFamilyName)
{
	IDWriteGdiInterop* dwGdiInterop;
	HRESULT hr = factory->GetGdiInterop(&dwGdiInterop);
	if (SUCCEEDED(hr))
	{
		LOGFONT lf = {};
		wcscpy_s(lf.lfFaceName, gdiFamilyName);
		lf.lfHeight = -12;
		lf.lfWeight = FW_DONTCARE;
		lf.lfCharSet = DEFAULT_CHARSET;
		lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
		lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
		lf.lfQuality = ANTIALIASED_QUALITY;
		lf.lfPitchAndFamily = VARIABLE_PITCH;

		IDWriteFont* dwFont;
		hr = dwGdiInterop->CreateFontFromLOGFONT(&lf, &dwFont);
		if (SUCCEEDED(hr))
		{
			return dwFont;
		}

		dwGdiInterop->Release();
	}

	return nullptr;
}

bool
gfxDWriteFontEntry::InitLogFont(IDWriteFont *aFont, LOGFONTW *aLogFont)
{
    HRESULT hr;

    BOOL isInSystemCollection;
    IDWriteGdiInterop *gdi = 
        gfxDWriteFontList::PlatformFontList()->GetGDIInterop();
    hr = gdi->ConvertFontToLOGFONT(aFont, aLogFont, &isInSystemCollection);
    return (FAILED(hr) ? false : true);
}

FX_BOOL CDWriteExt::DwCreateRenderingTarget(CFX_DIBitmap* pBitmap, void** renderTarget)
{
    if (pBitmap->GetFormat() > FXDIB_Argb) {
        return FALSE;
    }
    IDWriteFactory* pDwFactory = (IDWriteFactory*)m_pDWriteFactory;
    IDWriteGdiInterop* pGdiInterop = NULL;
    IDWriteBitmapRenderTarget* pBitmapRenderTarget = NULL;
    IDWriteRenderingParams* pRenderingParams = NULL;
    HRESULT hr = S_OK;
    hr = pDwFactory->GetGdiInterop(&pGdiInterop);
    if (FAILED(hr)) {
        goto failed;
    }
    hr = pGdiInterop->CreateBitmapRenderTarget(NULL, pBitmap->GetWidth(), pBitmap->GetHeight(),
            &pBitmapRenderTarget);
    if (FAILED(hr)) {
        goto failed;
    }
    hr = pDwFactory->CreateCustomRenderingParams(
             1.0f,
             0.0f,
             1.0f,
             DWRITE_PIXEL_GEOMETRY_RGB,
             DWRITE_RENDERING_MODE_DEFAULT,
             &pRenderingParams
         );
    if (FAILED(hr)) {
        goto failed;
    }
    hr = pBitmapRenderTarget->SetPixelsPerDip(1.0f);
    if (FAILED(hr)) {
        goto failed;
    }
    *(CDwGdiTextRenderer**)renderTarget = FX_NEW CDwGdiTextRenderer(pBitmap, pBitmapRenderTarget, pRenderingParams);
    if (*(CDwGdiTextRenderer**)renderTarget == NULL) {
        goto failed;
    }
    SafeRelease(&pGdiInterop);
    SafeRelease(&pBitmapRenderTarget);
    SafeRelease(&pRenderingParams);
    return TRUE;
failed:
    SafeRelease(&pGdiInterop);
    SafeRelease(&pBitmapRenderTarget);
    SafeRelease(&pRenderingParams);
    return FALSE;
}

    /* IDWriteGdiInterop methods */
    virtual HRESULT STDMETHODCALLTYPE CreateFontFromLOGFONT(
        LOGFONTW const *logFont,
        IDWriteFont **font)
    {
        OutputDebugString("delegate_dwrite_gdi_interop::CreateFontFromLOGFONT");
        HRESULT result;
        UINT32 index;
        BOOL exists;
        result = mycoll_->FindFamilyName(logFont->lfFaceName, &index, &exists);
        if (SUCCEEDED(result)) {
            result = E_FAIL;
            if (exists != FALSE) {
                IDWriteFontFamily *family;
                result = mycoll_->GetFontFamily(index, &family);
                if (SUCCEEDED(result)) {
                    result = family->GetFirstMatchingFont(
                        (DWRITE_FONT_WEIGHT)logFont->lfWeight,
                        DWRITE_FONT_STRETCH_NORMAL,
                        DWRITE_FONT_STYLE_NORMAL,
                        font);
                    iunknown_release(family);
                }
            }
        }
	if (FAILED(result)) {
            OutputDebugString("delegate_dwrite_gdi_interop::CreateFontFromLOGFONT -> fallback");
            result = orig_this->CreateFontFromLOGFONT(logFont, font);
        }
        return result; 
    }

HRESULT GdiTextRenderer::Initialize(HWND referenceHwnd, HDC referenceDC, UINT width, UINT height)
{
    HRESULT hr;
    IDWriteGdiInterop* gdiInterop = NULL;

    hr = g_dwrite->GetGdiInterop(&gdiInterop);
    if (SUCCEEDED(hr))
    {
        hr = gdiInterop->CreateBitmapRenderTarget(referenceDC, width, height, &m_renderTarget);
    }
    if (SUCCEEDED(hr))
    {
        hr = g_dwrite->CreateMonitorRenderingParams(
                MonitorFromWindow(referenceHwnd, MONITOR_DEFAULTTONULL),
                &m_renderingParams);
    }

    SafeRelease(&gdiInterop);

    return hr;
}

HRESULT DWriteRenderer::PrepareMagnifier(HDC hdc)
{
    HRESULT hr = S_OK;

    if (!magnifier_.visible)
    {
        SafeRelease(&magnifierTarget_);
        return hr;
    }

    // Determine the size and scale factor for the magnifier render target. In vector
    // mode we render using a scale transform. In all other modes we render at normal
    // size and then scale up the pixels afterwards.
    SIZE targetSize = magnifier_.magnifierSize;
    int targetScale = magnifier_.scale;
    if (magnifier_.type != MagnifierInfo::Vector)
    {
        targetSize.cx /= targetScale;
        targetSize.cy /= targetScale;
        targetScale = 1;
    }

    // Create a separate render target for the magnifier if we haven't already.
    if (SUCCEEDED(hr) && magnifierTarget_ == NULL)
    {
        IDWriteGdiInterop* gdiInterop = NULL;

        if (SUCCEEDED(hr))
        {
            hr = g_dwriteFactory->GetGdiInterop(&gdiInterop);
        }
        if (SUCCEEDED(hr))
        {
            hr = gdiInterop->CreateBitmapRenderTarget(hdc, targetSize.cx, targetSize.cy, &magnifierTarget_);
        }

        SafeRelease(&gdiInterop);
    }

    DWRITE_MATRIX zoomTransform;;
    if (SUCCEEDED(hr))
    {
        // Clear the background.
        HDC hdcMagnifier = magnifierTarget_->GetMemoryDC();
        SelectObject(hdcMagnifier, GetSysColorBrush(COLOR_WINDOW));
        PatBlt(hdcMagnifier, 0, 0, magnifier_.magnifierSize.cx, magnifier_.magnifierSize.cy, PATCOPY);

        // Create a transform that translates and scales the focus rect to the origin of the magnifier target.
        float focusLeft = PixelsToDipsX(magnifier_.focusPos.x);
        float focusTop = PixelsToDipsY(magnifier_.focusPos.y);

        zoomTransform.m11 = transform_.m11 * targetScale;
        zoomTransform.m12 = transform_.m12 * targetScale;
        zoomTransform.m21 = transform_.m21 * targetScale;
        zoomTransform.m22 = transform_.m22 * targetScale;
        zoomTransform.dx = (transform_.dx - focusLeft) * targetScale;
        zoomTransform.dy = (transform_.dy - focusTop) * targetScale;
    }

    if (SUCCEEDED(hr))
    {
        hr = magnifierTarget_->SetCurrentTransform(&zoomTransform);
    }

    return hr;
}

HRESULT DWriteRenderer::Draw(HDC hdc)
{
    HRESULT hr = S_OK;

    // Create the bitmap render target if we don't already have it.
    if (renderTarget_ == NULL)
    {
        IDWriteGdiInterop* gdiInterop = NULL;

        if (SUCCEEDED(hr))
        {
            hr = g_dwriteFactory->GetGdiInterop(&gdiInterop);
        }
        if (SUCCEEDED(hr))
        {
            hr = gdiInterop->CreateBitmapRenderTarget(hdc, width_, height_, &renderTarget_);
        }
        if (SUCCEEDED(hr))
        {
            hr = renderTarget_->SetPixelsPerDip(g_dpiY / 96.0f);
        }

        SafeRelease(&gdiInterop);
    }

    // Create the rendering params object if we haven't already.
    if (SUCCEEDED(hr) && renderingParams_ == NULL)
    {
        hr = g_dwriteFactory->CreateRenderingParams(&renderingParams_);
    }

    HDC hdcMem = NULL;
    if (SUCCEEDED(hr))
    {
        // Clear the background.
        hdcMem = renderTarget_->GetMemoryDC();
        SelectObject(hdcMem, GetSysColorBrush(COLOR_WINDOW));
        PatBlt(hdcMem, 0, 0, width_, height_, PATCOPY);

        // Set the rendering transform.
        renderTarget_->SetCurrentTransform(&transform_);

        // Prepare the render target we use for the magnifier.
        PrepareMagnifier(hdc);
    }

    if (SUCCEEDED(hr))
    {
        hr = InitializeTextLayout();
    }

    if (SUCCEEDED(hr))
    {
        // Render the text. The Draw method will call back to the IDWriteTextRenderer
        // methods implemented by this class.
        hr = textLayout_->Draw(
                 NULL,           // optional client drawing context
                 this,           // renderer callback
                 textOriginX_,
                 textOriginY_
             );
    }

    if (SUCCEEDED(hr))
    {
        DrawMagnifier();

        // Do the final BitBlt to the specified HDC.
        BitBlt(hdc, 0, 0, width_, height_, hdcMem, 0, 0, SRCCOPY | NOMIRRORBITMAP);
    }

    return hr;
}

 virtual HRESULT STDMETHODCALLTYPE ConvertFontToLOGFONT(
     IDWriteFont *font,
     LOGFONTW *logFont,
     WINBOOL *isSystemFont)
 {
     return orig_this->ConvertFontToLOGFONT(font, logFont, isSystemFont); 
 }

 virtual HRESULT STDMETHODCALLTYPE CreateBitmapRenderTarget(
     HDC hdc,
     UINT32 width,
     UINT32 height,
     IDWriteBitmapRenderTarget **renderTarget)
 {
     return orig_this->CreateBitmapRenderTarget(hdc, width, height, renderTarget); 
 }

    void
DWriteContext::DrawText(HDC hdc, const WCHAR* text, int len,
	int x, int y, int w, int h, int cellWidth, COLORREF color)
{
    HRESULT hr = S_OK;
    IDWriteBitmapRenderTarget *bmpRT = NULL;

    // Skip when any fonts are not set.
    if (mTextFormat == NULL)
	return;

    // Check possibility of zero divided error.
    if (cellWidth == 0 || mDpiScaleX == 0.0f || mDpiScaleY == 0.0f)
	return;

    if (SUCCEEDED(hr))
	hr = mGdiInterop->CreateBitmapRenderTarget(hdc, w, h, &bmpRT);

    if (SUCCEEDED(hr))
    {
	IDWriteTextLayout *textLayout = NULL;

	HDC memdc = bmpRT->GetMemoryDC();
	BitBlt(memdc, 0, 0, w, h, hdc, x, y, SRCCOPY);

	hr = mDWriteFactory->CreateGdiCompatibleTextLayout(
		text, len, mTextFormat, PixelsToDipsX(w),
		PixelsToDipsY(h), mDpiScaleX, NULL, TRUE, &textLayout);

	if (SUCCEEDED(hr))
	{
	    DWRITE_TEXT_RANGE textRange = { 0, (UINT32)len };
	    textLayout->SetFontWeight(mFontWeight, textRange);
	    textLayout->SetFontStyle(mFontStyle, textRange);
	}

	if (SUCCEEDED(hr))
	{
	    GdiTextRenderer *renderer = new GdiTextRenderer(bmpRT,
		    mRenderingParams);
	    GdiTextRendererContext data = {
		color,
		PixelsToDipsX(cellWidth),
		0.0f
	    };
	    textLayout->Draw(&data, renderer, 0, 0);
	    SafeRelease(&renderer);
	}

	BitBlt(hdc, x, y, w, h, memdc, 0, 0, SRCCOPY);

	SafeRelease(&textLayout);
    }

    SafeRelease(&bmpRT);
}

    HRESULT
DWriteContext::SetLOGFONT(const LOGFONTW &logFont, float fontSize)
{
    // Most of this function is copy from: http://msdn.microsoft.com/en-us/library/windows/desktop/dd941783(v=vs.85).aspx
    HRESULT hr = S_OK;

    IDWriteFont *font = NULL;
    IDWriteFontFamily *fontFamily = NULL;
    IDWriteLocalizedStrings *localizedFamilyNames = NULL;

    if (SUCCEEDED(hr))
    {
	hr = mGdiInterop->CreateFontFromLOGFONT(&logFont, &font);
    }

    // Get the font family to which this font belongs.
    if (SUCCEEDED(hr))
    {
	hr = font->GetFontFamily(&fontFamily);
    }

    // Get the family names. This returns an object that encapsulates one or
    // more names with the same meaning but in different languages.
    if (SUCCEEDED(hr))
    {
	hr = fontFamily->GetFamilyNames(&localizedFamilyNames);
    }

    // Get the family name at index zero. If we were going to display the name
    // we'd want to try to find one that matched the use locale, but for
    // purposes of creating a text format object any language will do.

    wchar_t familyName[100];
    if (SUCCEEDED(hr))
    {
	hr = localizedFamilyNames->GetString(0, familyName,
		ARRAYSIZE(familyName));
    }

    if (SUCCEEDED(hr))
    {
	// If no font size was passed in use the lfHeight of the LOGFONT.
	if (fontSize == 0)
	{
	    // Convert from pixels to DIPs.
	    fontSize = PixelsToDipsY(logFont.lfHeight);
	    if (fontSize < 0)
	    {
		// Negative lfHeight represents the size of the em unit.
		fontSize = -fontSize;
	    }
	    else
	    {
		// Positive lfHeight represents the cell height (ascent +
		// descent).
		DWRITE_FONT_METRICS fontMetrics;
		font->GetMetrics(&fontMetrics);

		// Convert the cell height (ascent + descent) from design units
		// to ems.
		float cellHeight = static_cast<float>(
			fontMetrics.ascent + fontMetrics.descent)
					       / fontMetrics.designUnitsPerEm;

		// Divide the font size by the cell height to get the font em
		// size.
		fontSize /= cellHeight;
	    }
	}
    }

    // The text format includes a locale name. Ideally, this would be the
    // language of the text, which may or may not be the same as the primary
    // language of the user. However, for our purposes the user locale will do.
    wchar_t localeName[LOCALE_NAME_MAX_LENGTH];
    if (SUCCEEDED(hr))
    {
	if (GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH) == 0)
	    hr = HRESULT_FROM_WIN32(GetLastError());
    }

    if (SUCCEEDED(hr))
    {
	// Create the text format object.
	hr = mDWriteFactory->CreateTextFormat(
		familyName,
		NULL, // no custom font collection
		font->GetWeight(),
		font->GetStyle(),
		font->GetStretch(),
		fontSize,
		localeName,
		&mTextFormat);
    }

    if (SUCCEEDED(hr))
    {
	mFontWeight = static_cast<DWRITE_FONT_WEIGHT>(logFont.lfWeight);
	mFontStyle = logFont.lfItalic ? DWRITE_FONT_STYLE_ITALIC
	    : DWRITE_FONT_STYLE_NORMAL;
//.........这里部分代码省略.........

 virtual HRESULT STDMETHODCALLTYPE CreateFontFaceFromHdc(
     HDC hdc,
     IDWriteFontFace **fontFace)
 {
     return orig_this->CreateFontFaceFromHdc(hdc, fontFace); 
 }

 virtual HRESULT STDMETHODCALLTYPE ConvertFontFaceToLOGFONT(
     IDWriteFontFace *font,
     LOGFONTW *logFont)
 {
     return orig_this->ConvertFontFaceToLOGFONT(font, logFont); 
 }