コード例 #1
0
ファイル: dynfont.cpp プロジェクト: s-yukikaze/dynfont
 virtual HRESULT STDMETHODCALLTYPE CreateBitmapRenderTarget(
     HDC hdc,
     UINT32 width,
     UINT32 height,
     IDWriteBitmapRenderTarget **renderTarget)
 {
     return orig_this->CreateBitmapRenderTarget(hdc, width, height, renderTarget); 
 }
コード例 #2
0
ファイル: gui_dwrite.cpp プロジェクト: Qubit0-1/vim
    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);
}
コード例 #3
0
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;
}
コード例 #4
0
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;
}
コード例 #5
0
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;
}
コード例 #6
0
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;
}