X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Frendering%2Ftext-typesetter.cpp;h=e6f346ccc2cbc4feccde081179b30ed8e5a229a5;hp=6fadaed32e01b8cd5c9b0562c22895176252a665;hb=b7108fc5f28fd650a1ea08a8692c822a63baf5bd;hpb=d3a0ce5bb20589eb078cb4b86801482005b95b2c diff --git a/dali-toolkit/internal/text/rendering/text-typesetter.cpp b/dali-toolkit/internal/text/rendering/text-typesetter.cpp index 6fadaed..e6f346c 100644 --- a/dali-toolkit/internal/text/rendering/text-typesetter.cpp +++ b/dali-toolkit/internal/text/rendering/text-typesetter.cpp @@ -35,6 +35,7 @@ namespace Text { namespace { +const float HALF(0.5f); /** * @brief Data struct used to set the buffer of the glyph's bitmap into the final bitmap's buffer. */ @@ -275,14 +276,17 @@ bool IsGlyphUnderlined(GlyphIndex index, } /// Helper method to fetch the underline metrics for the specified font glyph -void FetchFontUnderlineMetrics( +void FetchFontDecorationlinesMetrics( TextAbstraction::FontClient& fontClient, const GlyphInfo* const glyphInfo, float& currentUnderlinePosition, const float underlineHeight, float& currentUnderlineThickness, float& maxUnderlineThickness, - FontId& lastUnderlinedFontId) + FontId& lastlinedFontId, + const float strikethroughHeight, + float& currentStrikethroughThickness, + float& maxStrikethroughThickness) { FontMetrics fontMetrics; fontClient.GetFontMetrics(glyphInfo->fontId, fontMetrics); @@ -304,12 +308,31 @@ void FetchFontUnderlineMetrics( } } + if(fabsf(strikethroughHeight) < Math::MACHINE_EPSILON_1000) + { + // Ensure strikethrough will be at least a pixel high + if(currentStrikethroughThickness < 1.0f) + { + currentStrikethroughThickness = 1.0f; + } + else + { + currentStrikethroughThickness = ceil(currentStrikethroughThickness); + } + } + // The underline thickness should be the max underline thickness of all glyphs of the line. if(currentUnderlineThickness > maxUnderlineThickness) { maxUnderlineThickness = currentUnderlineThickness; } + // The strikethrough thickness should be the max strikethrough thickness of all glyphs of the line. + if(currentStrikethroughThickness > maxStrikethroughThickness) + { + maxStrikethroughThickness = currentStrikethroughThickness; + } + // Clamp the underline position at the font descender and check for ( as EFL describes it ) a broken font if(currentUnderlinePosition > descender) { @@ -322,7 +345,7 @@ void FetchFontUnderlineMetrics( currentUnderlinePosition = 1.0f; } - lastUnderlinedFontId = glyphInfo->fontId; + lastlinedFontId = glyphInfo->fontId; } /// Draws the specified color to the pixel buffer @@ -349,15 +372,19 @@ void WriteColorToPixelBuffer( /// Draws the specified underline color to the buffer void DrawUnderline( - const Vector4& underlineColor, - const unsigned int bufferWidth, - const unsigned int bufferHeight, - GlyphData& glyphData, - const float baseline, - const float currentUnderlinePosition, - const float maxUnderlineThickness, - const float lineExtentLeft, - const float lineExtentRight) + const Vector4& underlineColor, + const unsigned int bufferWidth, + const unsigned int bufferHeight, + GlyphData& glyphData, + const float baseline, + const float currentUnderlinePosition, + const float maxUnderlineThickness, + const float lineExtentLeft, + const float lineExtentRight, + const Text::Underline::Type underlineType, + const float dashedUnderlineWidth, + const float dashedUnderlineGap, + const LineRun& line) { int underlineYOffset = glyphData.verticalOffset + baseline + currentUnderlinePosition; uint32_t* bitmapBuffer = reinterpret_cast(glyphData.bitmapBuffer.GetBuffer()); @@ -369,16 +396,67 @@ void DrawUnderline( // Do not write out of bounds. break; } + if(underlineType == Text::Underline::DASHED) + { + float dashWidth = dashedUnderlineWidth; + float dashGap = 0; - for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++) + for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++) + { + if(x > bufferWidth - 1) + { + // Do not write out of bounds. + break; + } + if(dashGap == 0 && dashWidth > 0) + { + WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y); + dashWidth--; + } + else if(dashGap < dashedUnderlineGap) + { + dashGap++; + } + else + { + //reset + dashWidth = dashedUnderlineWidth; + dashGap = 0; + } + } + } + else { - if(x > bufferWidth - 1) + for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++) + { + if(x > bufferWidth - 1) + { + // Do not write out of bounds. + break; + } + WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y); + } + } + } + if(underlineType == Text::Underline::DOUBLE) + { + int secondUnderlineYOffset = glyphData.verticalOffset - line.descender - maxUnderlineThickness; + for(unsigned int y = secondUnderlineYOffset; y < secondUnderlineYOffset + maxUnderlineThickness; y++) + { + if(y > bufferHeight - 1) { // Do not write out of bounds. break; } - - WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y); + for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++) + { + if(x > bufferWidth - 1) + { + // Do not write out of bounds. + break; + } + WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y); + } } } } @@ -527,6 +605,42 @@ Devel::PixelBuffer DrawGlyphsBackground(const ViewModel* model, Devel::PixelBuff return glyphData.bitmapBuffer; } +/// Draws the specified strikethrough color to the buffer +void DrawStrikethrough( + const Vector4& strikethroughColor, + const unsigned int bufferWidth, + const unsigned int bufferHeight, + GlyphData& glyphData, + const float baseline, + const LineRun& line, + const float maxStrikethroughThickness, + const float lineExtentLeft, + const float lineExtentRight, + float strikethroughStartingYPosition) +{ + uint32_t* bitmapBuffer = reinterpret_cast(glyphData.bitmapBuffer.GetBuffer()); + + for(unsigned int y = strikethroughStartingYPosition; y < strikethroughStartingYPosition + maxStrikethroughThickness; y++) + { + if(y > bufferHeight - 1) + { + // Do not write out of bounds. + break; + } + + for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++) + { + if(x > bufferWidth - 1) + { + // Do not write out of bounds. + break; + } + + WriteColorToPixelBuffer(glyphData, bitmapBuffer, strikethroughColor, x, y); + } + } +} + } // namespace TypesetterPtr Typesetter::New(const ModelInterface* const model) @@ -648,16 +762,18 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect const unsigned int bufferSizeInt = bufferWidth * bufferHeight; const unsigned int bufferSizeChar = 4u * bufferSizeInt; - Length numberOfGlyphs = mModel->GetNumberOfGlyphs(); + //Elided text in ellipsis at START could start on index greater than 0 + auto startIndexOfGlyphs = mModel->GetStartIndexOfElidedGlyphs(); + auto endIndexOfGlyphs = mModel->GetEndIndexOfElidedGlyphs(); Devel::PixelBuffer imageBuffer; if(RENDER_MASK == behaviour) { // Generate the image buffer as an alpha mask for color glyphs. - imageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_MASK, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1); + imageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_MASK, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs); } - else if(RENDER_NO_TEXT == behaviour) + else if(RENDER_NO_TEXT == behaviour || RENDER_OVERLAY_STYLE == behaviour) { // Generate an empty image buffer so that it can been combined with the image buffers for styles imageBuffer = Devel::PixelBuffer::New(bufferWidth, bufferHeight, Pixel::RGBA8888); @@ -666,17 +782,17 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect else { // Generate the image buffer for the text with no style. - imageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_NONE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1); + imageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_NONE, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs); } if((RENDER_NO_STYLES != behaviour) && (RENDER_MASK != behaviour)) { // Generate the outline if enabled const uint16_t outlineWidth = mModel->GetOutlineWidth(); - if(outlineWidth != 0u) + if(outlineWidth != 0u && RENDER_OVERLAY_STYLE != behaviour) { // Create the image buffer for outline - Devel::PixelBuffer outlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_OUTLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1); + Devel::PixelBuffer outlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_OUTLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs); // Combine the two buffers imageBuffer = CombineImageBuffer(imageBuffer, outlineImageBuffer, bufferWidth, bufferHeight); @@ -686,10 +802,10 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect // Generate the shadow if enabled const Vector2& shadowOffset = mModel->GetShadowOffset(); - if(fabsf(shadowOffset.x) > Math::MACHINE_EPSILON_1 || fabsf(shadowOffset.y) > Math::MACHINE_EPSILON_1) + if(RENDER_OVERLAY_STYLE != behaviour && (fabsf(shadowOffset.x) > Math::MACHINE_EPSILON_1 || fabsf(shadowOffset.y) > Math::MACHINE_EPSILON_1)) { // Create the image buffer for shadow - Devel::PixelBuffer shadowImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_SHADOW, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1); + Devel::PixelBuffer shadowImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_SHADOW, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs); // Check whether it will be a soft shadow const float& blurRadius = mModel->GetShadowBlurRadius(); @@ -705,10 +821,10 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect // Generate the underline if enabled const bool underlineEnabled = mModel->IsUnderlineEnabled(); - if(underlineEnabled) + if(underlineEnabled && RENDER_OVERLAY_STYLE == behaviour) { // Create the image buffer for underline - Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1); + Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs); // Combine the two buffers imageBuffer = CombineImageBuffer(imageBuffer, underlineImageBuffer, bufferWidth, bufferHeight); @@ -717,13 +833,13 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect // Generate the background if enabled const bool backgroundEnabled = mModel->IsBackgroundEnabled(); const bool backgroundMarkupSet = mModel->IsMarkupBackgroundColorSet(); - if(backgroundEnabled || backgroundMarkupSet) + if((backgroundEnabled || backgroundMarkupSet) && RENDER_OVERLAY_STYLE != behaviour) { Devel::PixelBuffer backgroundImageBuffer; if(backgroundEnabled) { - backgroundImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_BACKGROUND, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1); + backgroundImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_BACKGROUND, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs); } else { @@ -739,6 +855,17 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect imageBuffer = CombineImageBuffer(imageBuffer, backgroundImageBuffer, bufferWidth, bufferHeight); } + // Generate the strikethrough if enabled + const bool strikethroughEnabled = mModel->IsStrikethroughEnabled(); + if(strikethroughEnabled && RENDER_OVERLAY_STYLE == behaviour) + { + // Create the image buffer for strikethrough + Devel::PixelBuffer strikethroughImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_STRIKETHROUGH, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, endIndexOfGlyphs); + + // Combine the two buffers + imageBuffer = CombineImageBuffer(imageBuffer, strikethroughImageBuffer, bufferWidth, bufferHeight); + } + // Markup-Processor imageBuffer = ApplyMarkupProcessorOnPixelBuffer(imageBuffer, bufferWidth, bufferHeight, ignoreHorizontalAlignment, pixelFormat, penX, penY); @@ -755,7 +882,6 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, // Retrieve lines, glyphs, positions and colors from the view model. const Length modelNumberOfLines = mModel->GetNumberOfLines(); const LineRun* const modelLinesBuffer = mModel->GetLines(); - const Length numberOfGlyphs = mModel->GetNumberOfGlyphs(); const GlyphInfo* const glyphsBuffer = mModel->GetGlyphs(); const Vector2* const positionBuffer = mModel->GetLayout(); const Vector4* const colorsBuffer = mModel->GetColors(); @@ -764,6 +890,13 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, const Length* hyphenIndices = mModel->GetHyphenIndices(); const Length hyphensCount = mModel->GetHyphensCount(); + // Elided text info. Indices according to elided text and Ellipsis position. + const auto startIndexOfGlyphs = mModel->GetStartIndexOfElidedGlyphs(); + const auto endIndexOfGlyphs = mModel->GetEndIndexOfElidedGlyphs(); + const auto firstMiddleIndexOfElidedGlyphs = mModel->GetFirstMiddleIndexOfElidedGlyphs(); + const auto secondMiddleIndexOfElidedGlyphs = mModel->GetSecondMiddleIndexOfElidedGlyphs(); + const auto ellipsisPosition = mModel->GetEllipsisPosition(); + // Whether to use the default color. const bool useDefaultColor = (NULL == colorsBuffer); const Vector4& defaultColor = mModel->GetDefaultColor(); @@ -822,9 +955,16 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, } } - const bool underlineEnabled = mModel->IsUnderlineEnabled(); - const Vector4& underlineColor = mModel->GetUnderlineColor(); - const float underlineHeight = mModel->GetUnderlineHeight(); + const bool underlineEnabled = mModel->IsUnderlineEnabled(); + const Vector4& underlineColor = mModel->GetUnderlineColor(); + const float underlineHeight = mModel->GetUnderlineHeight(); + const Text::Underline::Type underlineType = mModel->GetUnderlineType(); + const float dashedUnderlineWidth = mModel->GetDashedUnderlineWidth(); + const float dashedUnderlineGap = mModel->GetDashedUnderlineGap(); + + const bool strikethroughEnabled = mModel->IsStrikethroughEnabled(); + const Vector4& strikethroughColor = mModel->GetStrikethroughColor(); + const float strikethroughHeight = mModel->GetStrikethroughHeight(); // Get the underline runs. const Length numberOfUnderlineRuns = mModel->GetNumberOfUnderlineRuns(); @@ -833,10 +973,14 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, mModel->GetUnderlineRuns(underlineRuns.Begin(), 0u, numberOfUnderlineRuns); bool thereAreUnderlinedGlyphs = false; + bool strikethroughGlyphsExist = false; - float currentUnderlinePosition = 0.0f; - float currentUnderlineThickness = underlineHeight; - float maxUnderlineThickness = currentUnderlineThickness; + float currentUnderlinePosition = 0.0f; + float currentUnderlineThickness = underlineHeight; + float maxUnderlineThickness = currentUnderlineThickness; + float currentStrikethroughThickness = strikethroughHeight; + float maxStrikethroughThickness = currentStrikethroughThickness; + float strikethroughStartingYPosition = 0.0f; FontId lastUnderlinedFontId = 0; @@ -846,8 +990,11 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, bool addHyphen = false; // Traverses the glyphs of the line. - const GlyphIndex endGlyphIndex = std::min(numberOfGlyphs, line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs); - for(GlyphIndex glyphIndex = line.glyphRun.glyphIndex; glyphIndex < endGlyphIndex; ++glyphIndex) + const GlyphIndex startGlyphIndex = std::max(line.glyphRun.glyphIndex, startIndexOfGlyphs); + GlyphIndex endGlyphIndex = (line.isSplitToTwoHalves ? line.glyphRunSecondHalf.glyphIndex + line.glyphRunSecondHalf.numberOfGlyphs : line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs) - 1u; + endGlyphIndex = std::min(endGlyphIndex, endIndexOfGlyphs); + + for(GlyphIndex glyphIndex = startGlyphIndex; glyphIndex <= endGlyphIndex; ++glyphIndex) { if(glyphIndex < fromGlyphIndex || glyphIndex > toGlyphIndex) { @@ -855,6 +1002,25 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, continue; } + //To handle START case of ellipsis, the first glyph has been shifted + //glyphIndex represent indices in whole glyphs but elidedGlyphIndex represents indices in elided Glyphs + GlyphIndex elidedGlyphIndex = glyphIndex - startIndexOfGlyphs; + + //To handle MIDDLE case of ellipsis, the first glyph in the second half of line has been shifted and skip the removed glyph from middle. + if(ellipsisPosition == DevelText::EllipsisPosition::MIDDLE) + { + if(glyphIndex > firstMiddleIndexOfElidedGlyphs && + glyphIndex < secondMiddleIndexOfElidedGlyphs) + { + // Ignore any glyph that removed for MIDDLE ellipsis + continue; + } + if(glyphIndex >= secondMiddleIndexOfElidedGlyphs) + { + elidedGlyphIndex -= (secondMiddleIndexOfElidedGlyphs - firstMiddleIndexOfElidedGlyphs - 1u); + } + } + // Retrieve the glyph's info. const GlyphInfo* glyphInfo; @@ -865,7 +1031,7 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, } else { - glyphInfo = glyphsBuffer + glyphIndex; + glyphInfo = glyphsBuffer + elidedGlyphIndex; } if((glyphInfo->width < Math::MACHINE_EPSILON_1000) || @@ -878,19 +1044,21 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, const bool underlineGlyph = underlineEnabled || IsGlyphUnderlined(glyphIndex, underlineRuns); thereAreUnderlinedGlyphs = thereAreUnderlinedGlyphs || underlineGlyph; + strikethroughGlyphsExist = strikethroughGlyphsExist || strikethroughEnabled; + // Are we still using the same fontId as previous - if(underlineGlyph && (glyphInfo->fontId != lastUnderlinedFontId)) + if((strikethroughEnabled || underlineGlyph) && (glyphInfo->fontId != lastUnderlinedFontId)) { // We need to fetch fresh font underline metrics - FetchFontUnderlineMetrics(fontClient, glyphInfo, currentUnderlinePosition, underlineHeight, currentUnderlineThickness, maxUnderlineThickness, lastUnderlinedFontId); + FetchFontDecorationlinesMetrics(fontClient, glyphInfo, currentUnderlinePosition, underlineHeight, currentUnderlineThickness, maxUnderlineThickness, lastUnderlinedFontId, strikethroughHeight, currentStrikethroughThickness, maxStrikethroughThickness); } // underline // Retrieves the glyph's position. - Vector2 position = *(positionBuffer + glyphIndex); + Vector2 position = *(positionBuffer + elidedGlyphIndex); if(addHyphen) { - GlyphInfo tempInfo = *(glyphsBuffer + glyphIndex); + GlyphInfo tempInfo = *(glyphsBuffer + elidedGlyphIndex); position.x = position.x + tempInfo.advance - tempInfo.xBearing + glyphInfo->xBearing; position.y = -glyphInfo->yBearing; } @@ -944,7 +1112,7 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, outlineWidth = 0.0f; } - if(style != Typesetter::STYLE_UNDERLINE) + if(style != Typesetter::STYLE_UNDERLINE && style != Typesetter::STYLE_STRIKETHROUGH) { fontClient.CreateBitmap(glyphInfo->fontId, glyphInfo->index, @@ -1001,7 +1169,7 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, // Draw the underline from the leftmost glyph to the rightmost glyph if(thereAreUnderlinedGlyphs && style == Typesetter::STYLE_UNDERLINE) { - DrawUnderline(underlineColor, bufferWidth, bufferHeight, glyphData, baseline, currentUnderlinePosition, maxUnderlineThickness, lineExtentLeft, lineExtentRight); + DrawUnderline(underlineColor, bufferWidth, bufferHeight, glyphData, baseline, currentUnderlinePosition, maxUnderlineThickness, lineExtentLeft, lineExtentRight, underlineType, dashedUnderlineWidth, dashedUnderlineGap, line); } // Draw the background color from the leftmost glyph to the rightmost glyph @@ -1010,6 +1178,14 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, DrawBackgroundColor(mModel->GetBackgroundColor(), bufferWidth, bufferHeight, glyphData, baseline, line, lineExtentLeft, lineExtentRight); } + // Draw the strikethrough from the leftmost glyph to the rightmost glyph + if(strikethroughGlyphsExist && style == Typesetter::STYLE_STRIKETHROUGH) + { + //TODO : The currently implemented strikethrough creates a strikethrough on the line level. We need to create different strikethroughs the case of glyphs with different sizes. + strikethroughStartingYPosition = (glyphData.verticalOffset + baseline + currentUnderlinePosition) - ((line.ascender) * HALF); // Since Free Type font doesn't contain the strikethrough-position property, strikethrough position will be calculated by moving the underline position upwards by half the value of the line height. + DrawStrikethrough(strikethroughColor, bufferWidth, bufferHeight, glyphData, baseline, line, maxStrikethroughThickness, lineExtentLeft, lineExtentRight, strikethroughStartingYPosition); + } + // Increases the vertical offset with the line's descender. glyphData.verticalOffset += static_cast(-line.descender); }