C++ AttributedString::getCharAttribute方法代码示例

void SimpleTypeLayout::getGlyphLayout (const AttributedString& text, GlyphLayout& glyphLayout)
{
    clear();
    int stringLength = text.getText().length();
    int numCharacterAttributes = text.getCharAttributesSize();
    int rangeStart = 0;
    // Character attributes are applied as a series of ranges. These ranges may overlap or there may
    // be multiple attributes for the same range. We need to come up with a single set of unique and
    // non overlapping ranges.
    // The approach below iterates through every character, looks through all the attributes and their
    // ranges and stores the last font or color that was applied. It think constructs a set of unique
    // and non overlapping ranges by comparing each character's attributes to the previous characters
    // attributes.
    // A more efficient approach may be to split and combine the individual ranges to construct the
    // set of unique and non overlapping ranges. This more efficient approach, if possible, would only
    // need to iterate through all the attributes once. This would be much faster than the current
    // approach which loops through all the attributes for every character.
    Font defaultFont;
    Colour defaultColour (Colours::black);
    Array<RunAttribute> runAttributes;
    Array<CharAttribute> charAttributes;
    charAttributes.ensureStorageAllocated (stringLength);
    // Iterate through every character in the string
    for (int i = 0; i < stringLength; ++i)
    {
        CharAttribute attribute;
        attribute.font = &defaultFont;
        attribute.colour = &defaultColour;
        // Iterate through every character attribute
        for (int j = 0; j < numCharacterAttributes; ++j)
        {
            Attr* attr = text.getCharAttribute (j);
            // Check if the current character falls within the range of a font attribute
            if (attr->attribute == Attr::font && (i >= attr->range.getStart()) && (i < attr->range.getEnd()))
            {
                AttrFont* attrFont = static_cast<AttrFont*>(attr);
                attribute.font = &(attrFont->font);
            }
            // Check if the current character falls within the range of a foreground colour attribute
            if (attr->attribute == Attr::foregroundColour && (i >= attr->range.getStart()) && (i < attr->range.getEnd()))
            {
                AttrColour* attrColour = static_cast<AttrColour*>(attr);
                attribute.colour = &(attrColour->colour);
            }
        }
        charAttributes.add(attribute);
        // Skip the first character since we are comparing to previous characters
        if (i == 0)
            continue;
        if ((charAttributes[i-1].font != charAttributes[i].font) ||
            (charAttributes[i-1].colour != charAttributes[i].colour) ||
            (*(charAttributes[i-1].font) != *(charAttributes[i].font)) ||
            (*(charAttributes[i-1].colour) != *(charAttributes[i].colour)) ||
            (i + 1 == stringLength))
        {
            // The current character has a new font or new color or there is no next character
            RunAttribute attribute;
            attribute.range.setStart (rangeStart);
            attribute.range.setEnd (i);
            if (i + 1 == stringLength)
                attribute.range.setEnd (i+1);
            attribute.font = charAttributes[i-1].font;
            attribute.colour = charAttributes[i-1].colour;
            runAttributes.add (attribute);
            rangeStart = i;
        }

    }
    charAttributes.clear();
    for (int i = 0; i < runAttributes.size(); ++i)
    {
        appendText (text, runAttributes[i].range, *(runAttributes[i].font), *(runAttributes[i].colour));
    }
    runAttributes.clear();
    // Run layout to break strings into words and create lines from words
    layout ((int) glyphLayout.getWidth());
    // Use tokens to create Glyph Structures
    glyphLayout.setNumLines (getNumLines());
    // Set Starting Positions to 0
    int charPosition = 0;
    int lineStartPosition = 0;
    int runStartPosition = 0;
    // Create first GlyphLine and GlyphRun
    GlyphLine* glyphLine = new GlyphLine();
    GlyphRun* glyphRun = new GlyphRun();
    for (int i = 0; i < tokens.size(); ++i)
    {
        const Token* const t = tokens.getUnchecked (i);
        // See TextLayout::draw
        const float xOffset = (float) t->x;
        const float yOffset = (float) t->y;
        // See GlyphArrangement::addCurtailedLineOfText
        Array <int> newGlyphs;
        Array <float> xOffsets;
        t->font.getGlyphPositions (t->text.trimEnd(), newGlyphs, xOffsets);
        // Resize glyph run array
        glyphRun->setNumGlyphs (glyphRun->getNumGlyphs() + newGlyphs.size());
        // Add each glyph in the token to the current GlyphRun
        for (int j = 0; j < newGlyphs.size(); ++j)
        {
//.........这里部分代码省略.........

    // This method takes an attributed string and outputs a GlyphLayout data
    // structure that contains the glyph number and location of each inidividual glyph
    void getGlyphLayout (const AttributedString& text, GlyphLayout& glyphLayout)
    {
        // For now we are creating the DirectWrite Factory, System Font Collection,
        // D2D Factory and GDI Render target every time we layout text.
        // This is inefficient and we may be loading and unloading libraries each layout.
        // These four things should be created once at application startup and be destroyed
        // when the application exits. I'm not sure where the best place to do this so
        // for now I will just use the inefficient method.

        IDWriteFactory* dwFactory = nullptr;
        HRESULT hr = DWriteCreateFactory (DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory),
            reinterpret_cast<IUnknown**>(&dwFactory));

        IDWriteFontCollection* dwFontCollection = nullptr;
        hr = dwFactory->GetSystemFontCollection (&dwFontCollection);

        // To add color to text, we need to create a D2D render target
        // Since we are not actually rendering to a D2D context we create a temporary GDI render target
        ID2D1Factory *d2dFactory = nullptr;
        hr = D2D1CreateFactory (D2D1_FACTORY_TYPE_SINGLE_THREADED, &d2dFactory);
        D2D1_RENDER_TARGET_PROPERTIES d2dRTProp = D2D1::RenderTargetProperties(
            D2D1_RENDER_TARGET_TYPE_SOFTWARE,
            D2D1::PixelFormat(
            DXGI_FORMAT_B8G8R8A8_UNORM,
            D2D1_ALPHA_MODE_IGNORE),
            0,
            0,
            D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE,
            D2D1_FEATURE_LEVEL_DEFAULT
            );
        ID2D1DCRenderTarget* d2dDCRT = nullptr;
        hr = d2dFactory->CreateDCRenderTarget (&d2dRTProp, &d2dDCRT);

        // Initially we set the paragraph up with a default font and then apply the attributed string ranges later
        Font defaultFont;
        const float defaultFontHeightToEmSizeFactor = getFontHeightToEmSizeFactor (defaultFont, *dwFontCollection);
        // We should probably be detecting the locale instead of hard coding it to en-us
        String localeName("en-us");

        // We multiply the font height by the size factor so we layout text at the correct size
        IDWriteTextFormat* dwTextFormat = nullptr;
        hr = dwFactory->CreateTextFormat (
            defaultFont.getTypefaceName().toWideCharPointer(),
            dwFontCollection,
            DWRITE_FONT_WEIGHT_REGULAR,
            DWRITE_FONT_STYLE_NORMAL,
            DWRITE_FONT_STRETCH_NORMAL,
            defaultFont.getHeight() * defaultFontHeightToEmSizeFactor,
            localeName.toWideCharPointer(),
            &dwTextFormat
            );

        // Paragraph Attributes
        // Set Paragraph Alignment
        if (text.getTextAlignment() == AttributedString::left)
            dwTextFormat->SetTextAlignment (DWRITE_TEXT_ALIGNMENT_LEADING);
        if (text.getTextAlignment() == AttributedString::right)
            dwTextFormat->SetTextAlignment (DWRITE_TEXT_ALIGNMENT_TRAILING);
        if (text.getTextAlignment() == AttributedString::center)
            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;
//.........这里部分代码省略.........