C++ IDWriteTextLayout::SetFontSize方法代码示例

	IDWriteTextLayout* createTextLayout(IDWriteFactory1* writeFactory, IDWriteTextFormat* textFormat, const Int2& layoutSize, float scale, const wchar_t* wtext)
	{
		IDWriteTextLayout* textLayout;

		// Create a DirectWrite Text Layout object.
		DX::ThrowIfFailed(
			writeFactory->CreateTextLayout(
			wtext,              // Text to be displayed
			(UINT32)wcslen(wtext),      // Length of the text
			textFormat,				// DirectWrite Text Format object
			layoutSize.width() / scale,         // Width of the Text Layout
			layoutSize.height() / scale,        // Height of the Text Layout
			&textLayout
			)
			);

		// Create a text range corresponding to the entire string.
		DWRITE_TEXT_RANGE textRange = { 0 };
		textRange.length = static_cast<UINT32>(wcslen(wtext));
		textRange.startPosition = 0;

		// Set the font size and weight on the text range.
		textLayout->SetFontSize(100.f, textRange);
		textLayout->SetFontWeight(DWRITE_FONT_WEIGHT_BOLD, textRange);
		//m_textLayout->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);

		return textLayout;
	}

void ClixRenderer::DText(std::wstring text, float x, float y, float w, float h, float size, CColor color)
{
	IDWriteTextLayout* textLayout;
	D2Brush->SetColor(CColor::ColorF(color));
	pDWriteFactory->CreateTextLayout(text.c_str(), text.length(), pTextFormat, w, h, &textLayout);
	DWRITE_TEXT_RANGE range = { 0, text.length() };
	textLayout->SetFontSize(size, range);
	D2Render->DrawTextLayout(D2D1::Point2F(x, y), textLayout, D2Brush);
	textLayout->Release();
}

    void addAttributedRange (const AttributedString::Attribute& attr, IDWriteTextLayout& textLayout,
                             const int textLen, ID2D1RenderTarget& renderTarget, IDWriteFontCollection& fontCollection)
    {
        DWRITE_TEXT_RANGE range;
        range.startPosition = attr.range.getStart();
        range.length = jmin (attr.range.getLength(), textLen - attr.range.getStart());

        if (const Font* const font = attr.getFont())
        {
            const String familyName (FontStyleHelpers::getConcreteFamilyName (*font));

            BOOL fontFound = false;
            uint32 fontIndex;
            fontCollection.FindFamilyName (familyName.toWideCharPointer(), &fontIndex, &fontFound);

            if (! fontFound)
                fontIndex = 0;

            ComSmartPtr<IDWriteFontFamily> fontFamily;
            HRESULT hr = fontCollection.GetFontFamily (fontIndex, fontFamily.resetAndGetPointerAddress());

            ComSmartPtr<IDWriteFont> dwFont;
            uint32 fontFacesCount = 0;
            fontFacesCount = fontFamily->GetFontCount();

            for (int i = fontFacesCount; --i >= 0;)
            {
                hr = fontFamily->GetFont (i, dwFont.resetAndGetPointerAddress());

                if (font->getTypefaceStyle() == getFontFaceName (dwFont))
                    break;
            }

            textLayout.SetFontFamilyName (familyName.toWideCharPointer(), range);
            textLayout.SetFontWeight (dwFont->GetWeight(), range);
            textLayout.SetFontStretch (dwFont->GetStretch(), range);
            textLayout.SetFontStyle (dwFont->GetStyle(), range);

            const float fontHeightToEmSizeFactor = getFontHeightToEmSizeFactor (*dwFont);
            textLayout.SetFontSize (font->getHeight() * fontHeightToEmSizeFactor, range);
        }

        if (const Colour* const colour = attr.getColour())
        {
            ComSmartPtr<ID2D1SolidColorBrush> d2dBrush;
            renderTarget.CreateSolidColorBrush (D2D1::ColorF (colour->getFloatRed(),
                                                              colour->getFloatGreen(),
                                                              colour->getFloatBlue(),
                                                              colour->getFloatAlpha()),
                                                d2dBrush.resetAndGetPointerAddress());

            // We need to call SetDrawingEffect with a legimate brush to get DirectWrite to break text based on colours
            textLayout.SetDrawingEffect (d2dBrush, range);
        }
    }

// Create text layout from string
IDWriteTextLayout* CFW1FontWrapper::createTextLayout(
    const WCHAR *pszString,
    const WCHAR *pszFontFamily,
    FLOAT fontSize,
    const FW1_RECTF *pLayoutRect,
    UINT flags
) {
    if(m_defaultTextInited) {
        UINT32 stringLength = 0;
        while(pszString[stringLength] != 0)
            ++stringLength;

        // Create DWrite text layout for the string
        IDWriteTextLayout *pTextLayout;
        HRESULT hResult = m_pDWriteFactory->CreateTextLayout(
                              pszString,
                              stringLength,
                              m_pDefaultTextFormat,
                              pLayoutRect->Right - pLayoutRect->Left,
                              pLayoutRect->Bottom - pLayoutRect->Top,
                              &pTextLayout
                          );
        if(SUCCEEDED(hResult)) {
            // Layout settings
            DWRITE_TEXT_RANGE allText = {0, stringLength};
            pTextLayout->SetFontSize(fontSize, allText);

            if(pszFontFamily != NULL)
                pTextLayout->SetFontFamilyName(pszFontFamily, allText);

            if((flags & FW1_NOWORDWRAP) != 0)
                pTextLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);

            if(flags & FW1_RIGHT)
                pTextLayout->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_TRAILING);
            else if(flags & FW1_CENTER)
                pTextLayout->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
            if(flags & FW1_BOTTOM)
                pTextLayout->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_FAR);
            else if(flags & FW1_VCENTER)
                pTextLayout->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);

            return pTextLayout;
        }
    }

    return NULL;
}

   Glyph* D3DGlyphProvider::getGlyph(UChar ch, float emsize)
   {
      HRESULT hr = S_OK;
      IDWriteTextLayout* ptextlayout = NULL;

      ASSERT_PTR(mpTextFormat);

      hr = mpDWriteFactory->CreateTextLayout(&ch, 1, mpTextFormat, 512, 512, &ptextlayout);
      if ( SUCCEEDED(hr) )
      {
         DWRITE_TEXT_RANGE range = { 0, 0 };
         ptextlayout->SetFontSize(emsize, range);

         AutoPtr<Glyph> glyph = new Glyph();
         hr = ptextlayout->Draw(glyph.getPointer(), mpTextRenderer, 0, 0);
         if ( SUCCEEDED(hr) )
         {
            return glyph.release();
         }
      }

      return NULL;
   }

//.........这里部分代码省略.........
            dwTextFormat->SetTextAlignment (DWRITE_TEXT_ALIGNMENT_CENTER);
        // DirectWrite cannot justify text, default to left alignment
        if (text.getTextAlignment() == AttributedString::justified)
            dwTextFormat->SetTextAlignment (DWRITE_TEXT_ALIGNMENT_LEADING);
        // Set Word Wrap
        if (text.getWordWrap() == AttributedString::none)
            dwTextFormat->SetWordWrapping (DWRITE_WORD_WRAPPING_NO_WRAP);
        if (text.getWordWrap() == AttributedString::byWord)
            dwTextFormat->SetWordWrapping (DWRITE_WORD_WRAPPING_WRAP);
        // DirectWrite does not support wrapping by character, default to wrapping by word
        if (text.getWordWrap() == AttributedString::byChar)
            dwTextFormat->SetWordWrapping (DWRITE_WORD_WRAPPING_WRAP);
        // DirectWrite does not automatically set reading direction
        // This must be set correctly and manually when using RTL Scripts (Hebrew, Arabic)
        if (text.getReadingDirection() == AttributedString::rightToLeft)
            dwTextFormat->SetReadingDirection (DWRITE_READING_DIRECTION_RIGHT_TO_LEFT);

        IDWriteTextLayout* dwTextLayout = nullptr;
        hr = dwFactory->CreateTextLayout (
            text.getText().toWideCharPointer(),
            text.getText().length(),
            dwTextFormat,
            glyphLayout.getWidth(),
            glyphLayout.getHeight(),
            &dwTextLayout
            );

        // Character Attributes
        int numCharacterAttributes = text.getCharAttributesSize();
        for (int i = 0; i < numCharacterAttributes; ++i)
        {
            Attr* attr = text.getCharAttribute (i);
            // Character Range Error Checking
            if (attr->range.getStart() > text.getText().length()) continue;
            if (attr->range.getEnd() > text.getText().length()) attr->range.setEnd (text.getText().length());
            if (attr->attribute == Attr::font)
            {
                AttrFont* attrFont = static_cast<AttrFont*>(attr);
                DWRITE_TEXT_RANGE dwRange;
                dwRange.startPosition = attrFont->range.getStart();
                dwRange.length = attrFont->range.getLength();
                dwTextLayout->SetFontFamilyName (attrFont->font.getTypefaceName().toWideCharPointer(), dwRange);
                // We multiply the font height by the size factor so we layout text at the correct size
                const float fontHeightToEmSizeFactor = getFontHeightToEmSizeFactor (attrFont->font, *dwFontCollection);
                dwTextLayout->SetFontSize (attrFont->font.getHeight() * fontHeightToEmSizeFactor, dwRange);
            }
            if (attr->attribute == Attr::foregroundColour)
            {
                AttrColour* attrColour = static_cast<AttrColour*>(attr);
                DWRITE_TEXT_RANGE dwRange;
                dwRange.startPosition = attrColour->range.getStart();
                dwRange.length = attrColour->range.getLength();
                ID2D1SolidColorBrush* d2dBrush = nullptr;
                d2dDCRT->CreateSolidColorBrush (D2D1::ColorF (D2D1::ColorF(attrColour->colour.getFloatRed(),
                    attrColour->colour.getFloatGreen(), attrColour->colour.getFloatBlue(),
                    attrColour->colour.getFloatAlpha())), &d2dBrush);
                // We need to call SetDrawingEffect with a legimate brush to get DirectWrite to break text based on colours
                dwTextLayout->SetDrawingEffect (d2dBrush, dwRange);
                safeRelease (&d2dBrush);
            }
        }

        UINT32 actualLineCount = 0;
        hr = dwTextLayout->GetLineMetrics (nullptr, 0, &actualLineCount);
        // Preallocate GlyphLayout Line Array
        glyphLayout.setNumLines (actualLineCount);
        HeapBlock <DWRITE_LINE_METRICS> dwLineMetrics (actualLineCount);
        hr = dwTextLayout->GetLineMetrics (dwLineMetrics, actualLineCount, &actualLineCount);
        int location = 0;
        // Create GlyphLine structures for each line in the layout
        for (UINT32 i = 0; i < actualLineCount; ++i)
        {
            // Get string range
            Range<int> lineStringRange (location, (int) location + dwLineMetrics[i].length);
            location = dwLineMetrics[i].length;
            GlyphLine* glyphLine = new GlyphLine();
            glyphLine->setStringRange (lineStringRange);
            glyphLayout.addGlyphLine (glyphLine);
        }

        // To copy glyph data from DirectWrite into our own data structures we must create our
        // own CustomTextRenderer. Instead of passing the draw method an actual graphics context,
        // we pass it the GlyphLayout object that needs to be filled with glyphs.
        CustomDirectWriteTextRenderer* textRenderer = nullptr;
        textRenderer = new CustomDirectWriteTextRenderer();
        hr = dwTextLayout->Draw (
            &glyphLayout,
            textRenderer,
            glyphLayout.getX(),
            glyphLayout.getY()
            );

        safeRelease (&textRenderer);
        safeRelease (&dwTextLayout);
        safeRelease (&dwTextFormat);
        safeRelease (&d2dDCRT);
        safeRelease (&d2dFactory);
        safeRelease (&dwFontCollection);
        safeRelease (&dwFactory);
    }