2 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <dali-toolkit/internal/text/rendering/text-typesetter.h>
22 #include <dali/devel-api/text-abstraction/font-client.h>
23 #include <dali/public-api/common/constants.h>
27 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
28 #include <dali-toolkit/internal/text/rendering/view-model.h>
39 * @brief Data struct used to set the buffer of the glyph's bitmap into the final bitmap's buffer.
43 Devel::PixelBuffer bitmapBuffer; ///< The buffer of the whole bitmap. The format is RGBA8888.
44 Vector2* position; ///< The position of the glyph.
45 TextAbstraction::FontClient::GlyphBufferData glyphBitmap; ///< The glyph's bitmap.
46 unsigned int width; ///< The bitmap's width.
47 unsigned int height; ///< The bitmap's height.
48 int horizontalOffset; ///< The horizontal offset to be added to the 'x' glyph's position.
49 int verticalOffset; ///< The vertical offset to be added to the 'y' glyph's position.
53 * @brief Sets the glyph's buffer into the bitmap's buffer.
55 * @param[in] data Struct which contains the glyph's data and the bitmap's data.
56 * @param[in] position The position of the glyph.
57 * @param[in] color The color of the glyph.
58 * @param[in] style The style of the text.
59 * @param[in] pixelFormat The format of the pixel in the image that the text is rendered as (i.e. either Pixel::BGRA8888 or Pixel::L8).
61 void TypesetGlyph(GlyphData& data,
62 const Vector2* const position,
63 const Vector4* const color,
64 Typesetter::Style style,
65 Pixel::Format pixelFormat)
67 if((0u == data.glyphBitmap.width) || (0u == data.glyphBitmap.height))
69 // Nothing to do if the width or height of the buffer is zero.
73 const int widthMinusOne = static_cast<int>(data.width - 1u);
74 const int heightMinusOne = static_cast<int>(data.height - 1u);
76 if(Pixel::RGBA8888 == pixelFormat)
78 // Whether the given glyph is a color one.
79 const bool isColorGlyph = data.glyphBitmap.isColorEmoji || data.glyphBitmap.isColorBitmap;
80 const uint32_t glyphPixelSize = Pixel::GetBytesPerPixel(data.glyphBitmap.format);
81 const uint32_t alphaIndex = glyphPixelSize - 1u;
82 const bool swapChannelsBR = Pixel::BGRA8888 == data.glyphBitmap.format;
84 // Pointer to the color glyph if there is one.
85 const uint32_t* const colorGlyphBuffer = isColorGlyph ? reinterpret_cast<uint32_t*>(data.glyphBitmap.buffer) : NULL;
87 // Initial vertical offset.
88 const int yOffset = data.verticalOffset + position->y;
90 uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(data.bitmapBuffer.GetBuffer());
92 // Traverse the pixels of the glyph line per line.
93 for(int lineIndex = 0, glyphHeight = static_cast<int>(data.glyphBitmap.height); lineIndex < glyphHeight; ++lineIndex)
95 const int yOffsetIndex = yOffset + lineIndex;
96 if((0 > yOffsetIndex) || (yOffsetIndex > heightMinusOne))
98 // Do not write out of bounds.
102 const int verticalOffset = yOffsetIndex * data.width;
103 const int xOffset = data.horizontalOffset + position->x;
104 const int glyphBufferOffset = lineIndex * static_cast<int>(data.glyphBitmap.width);
105 for(int index = 0, glyphWidth = static_cast<int>(data.glyphBitmap.width); index < glyphWidth; ++index)
107 const int xOffsetIndex = xOffset + index;
108 if((0 > xOffsetIndex) || (xOffsetIndex > widthMinusOne))
110 // Don't write out of bounds.
116 // Retrieves the color from the color glyph.
117 uint32_t packedColorGlyph = *(colorGlyphBuffer + glyphBufferOffset + index);
118 uint8_t* packedColorGlyphBuffer = reinterpret_cast<uint8_t*>(&packedColorGlyph);
120 // Update the alpha channel.
121 if(Typesetter::STYLE_MASK == style || Typesetter::STYLE_OUTLINE == style) // Outline not shown for color glyph
123 // Create an alpha mask for color glyph.
124 *(packedColorGlyphBuffer + 3u) = 0u;
125 *(packedColorGlyphBuffer + 2u) = 0u;
126 *(packedColorGlyphBuffer + 1u) = 0u;
127 *packedColorGlyphBuffer = 0u;
131 const uint8_t colorAlpha = static_cast<uint8_t>(color->a * static_cast<float>(*(packedColorGlyphBuffer + 3u)));
132 *(packedColorGlyphBuffer + 3u) = colorAlpha;
134 if(Typesetter::STYLE_SHADOW == style)
136 // The shadow of color glyph needs to have the shadow color.
137 *(packedColorGlyphBuffer + 2u) = static_cast<uint8_t>(color->b * colorAlpha);
138 *(packedColorGlyphBuffer + 1u) = static_cast<uint8_t>(color->g * colorAlpha);
139 *packedColorGlyphBuffer = static_cast<uint8_t>(color->r * colorAlpha);
145 std::swap(*packedColorGlyphBuffer, *(packedColorGlyphBuffer + 2u)); // Swap B and R.
148 *(packedColorGlyphBuffer + 2u) = (*(packedColorGlyphBuffer + 2u) * colorAlpha / 255);
149 *(packedColorGlyphBuffer + 1u) = (*(packedColorGlyphBuffer + 1u) * colorAlpha / 255);
150 *packedColorGlyphBuffer = (*(packedColorGlyphBuffer)*colorAlpha / 255);
152 if(data.glyphBitmap.isColorBitmap)
154 *(packedColorGlyphBuffer + 2u) = static_cast<uint8_t>(*(packedColorGlyphBuffer + 2u) * color->b);
155 *(packedColorGlyphBuffer + 1u) = static_cast<uint8_t>(*(packedColorGlyphBuffer + 1u) * color->g);
156 *packedColorGlyphBuffer = static_cast<uint8_t>(*packedColorGlyphBuffer * color->r);
161 // Set the color into the final pixel buffer.
162 *(bitmapBuffer + verticalOffset + xOffsetIndex) = packedColorGlyph;
166 // Pack the given color into a 32bit buffer. The alpha channel will be updated later for each pixel.
167 // The format is RGBA8888.
168 uint32_t packedColor = 0u;
169 uint8_t* packedColorBuffer = reinterpret_cast<uint8_t*>(&packedColor);
171 // Update the alpha channel.
172 const uint8_t alpha = *(data.glyphBitmap.buffer + glyphPixelSize * (glyphBufferOffset + index) + alphaIndex);
174 // Copy non-transparent pixels only
177 // Check alpha of overlapped pixels
178 uint32_t& currentColor = *(bitmapBuffer + verticalOffset + xOffsetIndex);
179 uint8_t* packedCurrentColorBuffer = reinterpret_cast<uint8_t*>(¤tColor);
181 // For any pixel overlapped with the pixel in previous glyphs, make sure we don't
182 // overwrite a previous bigger alpha with a smaller alpha (in order to avoid
183 // semi-transparent gaps between joint glyphs with overlapped pixels, which could
184 // happen, for example, in the RTL text when we copy glyphs from right to left).
185 uint8_t currentAlpha = *(packedCurrentColorBuffer + 3u);
186 currentAlpha = std::max(currentAlpha, alpha);
188 // Color is pre-muliplied with its alpha.
189 *(packedColorBuffer + 3u) = static_cast<uint8_t>(color->a * currentAlpha);
190 *(packedColorBuffer + 2u) = static_cast<uint8_t>(color->b * currentAlpha);
191 *(packedColorBuffer + 1u) = static_cast<uint8_t>(color->g * currentAlpha);
192 *(packedColorBuffer) = static_cast<uint8_t>(color->r * currentAlpha);
194 // Set the color into the final pixel buffer.
195 currentColor = packedColor;
203 // Whether the given glyph is a color one.
204 const bool isColorGlyph = data.glyphBitmap.isColorEmoji || data.glyphBitmap.isColorBitmap;
205 const uint32_t glyphPixelSize = Pixel::GetBytesPerPixel(data.glyphBitmap.format);
206 const uint32_t alphaIndex = glyphPixelSize - 1u;
208 // Initial vertical offset.
209 const int yOffset = data.verticalOffset + position->y;
211 uint8_t* bitmapBuffer = reinterpret_cast<uint8_t*>(data.bitmapBuffer.GetBuffer());
213 // Traverse the pixels of the glyph line per line.
214 for(int lineIndex = 0, glyphHeight = static_cast<int>(data.glyphBitmap.height); lineIndex < glyphHeight; ++lineIndex)
216 const int yOffsetIndex = yOffset + lineIndex;
217 if((0 > yOffsetIndex) || (yOffsetIndex > heightMinusOne))
219 // Do not write out of bounds.
223 const int verticalOffset = yOffsetIndex * data.width;
224 const int xOffset = data.horizontalOffset + position->x;
225 const int glyphBufferOffset = lineIndex * static_cast<int>(data.glyphBitmap.width);
226 for(int index = 0, glyphWidth = static_cast<int>(data.glyphBitmap.width); index < glyphWidth; ++index)
228 const int xOffsetIndex = xOffset + index;
229 if((0 > xOffsetIndex) || (xOffsetIndex > widthMinusOne))
231 // Don't write out of bounds.
237 // Update the alpha channel.
238 const uint8_t alpha = *(data.glyphBitmap.buffer + glyphPixelSize * (glyphBufferOffset + index) + alphaIndex);
240 // Copy non-transparent pixels only
243 // Check alpha of overlapped pixels
244 uint8_t& currentAlpha = *(bitmapBuffer + verticalOffset + xOffsetIndex);
246 // For any pixel overlapped with the pixel in previous glyphs, make sure we don't
247 // overwrite a previous bigger alpha with a smaller alpha (in order to avoid
248 // semi-transparent gaps between joint glyphs with overlapped pixels, which could
249 // happen, for example, in the RTL text when we copy glyphs from right to left).
250 currentAlpha = std::max(currentAlpha, alpha);
258 bool IsGlyphUnderlined(GlyphIndex index,
259 const Vector<GlyphRun>& underlineRuns)
261 for(Vector<GlyphRun>::ConstIterator it = underlineRuns.Begin(),
262 endIt = underlineRuns.End();
266 const GlyphRun& run = *it;
268 if((run.glyphIndex <= index) && (index < run.glyphIndex + run.numberOfGlyphs))
277 /// Helper method to fetch the underline metrics for the specified font glyph
278 void FetchFontUnderlineMetrics(
279 TextAbstraction::FontClient& fontClient,
280 const GlyphInfo* const glyphInfo,
281 float& currentUnderlinePosition,
282 const float underlineHeight,
283 float& currentUnderlineThickness,
284 float& maxUnderlineThickness,
285 FontId& lastUnderlinedFontId)
287 FontMetrics fontMetrics;
288 fontClient.GetFontMetrics(glyphInfo->fontId, fontMetrics);
289 currentUnderlinePosition = ceil(fabsf(fontMetrics.underlinePosition));
290 const float descender = ceil(fabsf(fontMetrics.descender));
292 if(fabsf(underlineHeight) < Math::MACHINE_EPSILON_1000)
294 currentUnderlineThickness = fontMetrics.underlineThickness;
296 // Ensure underline will be at least a pixel high
297 if(currentUnderlineThickness < 1.0f)
299 currentUnderlineThickness = 1.0f;
303 currentUnderlineThickness = ceil(currentUnderlineThickness);
307 // The underline thickness should be the max underline thickness of all glyphs of the line.
308 if(currentUnderlineThickness > maxUnderlineThickness)
310 maxUnderlineThickness = currentUnderlineThickness;
313 // Clamp the underline position at the font descender and check for ( as EFL describes it ) a broken font
314 if(currentUnderlinePosition > descender)
316 currentUnderlinePosition = descender;
319 if(fabsf(currentUnderlinePosition) < Math::MACHINE_EPSILON_1000)
321 // Move offset down by one ( EFL behavior )
322 currentUnderlinePosition = 1.0f;
325 lastUnderlinedFontId = glyphInfo->fontId;
328 /// Draws the specified color to the pixel buffer
329 void WriteColorToPixelBuffer(
330 GlyphData& glyphData,
331 uint32_t* bitmapBuffer,
332 const Vector4& color,
333 const unsigned int x,
334 const unsigned int y)
336 // Always RGBA image for text with styles
337 uint32_t pixel = *(bitmapBuffer + y * glyphData.width + x);
338 uint8_t* pixelBuffer = reinterpret_cast<uint8_t*>(&pixel);
340 // Write the color to the pixel buffer
341 uint8_t colorAlpha = static_cast<uint8_t>(color.a * 255.f);
342 *(pixelBuffer + 3u) = colorAlpha;
343 *(pixelBuffer + 2u) = static_cast<uint8_t>(color.b * colorAlpha);
344 *(pixelBuffer + 1u) = static_cast<uint8_t>(color.g * colorAlpha);
345 *(pixelBuffer) = static_cast<uint8_t>(color.r * colorAlpha);
347 *(bitmapBuffer + y * glyphData.width + x) = pixel;
350 /// Draws the specified underline color to the buffer
352 const Vector4& underlineColor,
353 const unsigned int bufferWidth,
354 const unsigned int bufferHeight,
355 GlyphData& glyphData,
356 const float baseline,
357 const float currentUnderlinePosition,
358 const float maxUnderlineThickness,
359 const float lineExtentLeft,
360 const float lineExtentRight)
362 int underlineYOffset = glyphData.verticalOffset + baseline + currentUnderlinePosition;
363 uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer());
365 for(unsigned int y = underlineYOffset; y < underlineYOffset + maxUnderlineThickness; y++)
367 if(y > bufferHeight - 1)
369 // Do not write out of bounds.
373 for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++)
375 if(x > bufferWidth - 1)
377 // Do not write out of bounds.
381 WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y);
386 /// Draws the background color to the buffer
387 void DrawBackgroundColor(
388 Vector4 backgroundColor,
389 const unsigned int bufferWidth,
390 const unsigned int bufferHeight,
391 GlyphData& glyphData,
392 const float baseline,
394 const float lineExtentLeft,
395 const float lineExtentRight)
397 uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer());
399 for(int y = glyphData.verticalOffset + baseline - line.ascender; y < glyphData.verticalOffset + baseline - line.descender; y++)
401 if((y < 0) || (y > static_cast<int>(bufferHeight - 1)))
403 // Do not write out of bounds.
407 for(int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++)
409 if((x < 0) || (x > static_cast<int>(bufferWidth - 1)))
411 // Do not write out of bounds.
415 WriteColorToPixelBuffer(glyphData, bitmapBuffer, backgroundColor, x, y);
422 TypesetterPtr Typesetter::New(const ModelInterface* const model)
424 return TypesetterPtr(new Typesetter(model));
427 ViewModel* Typesetter::GetViewModel()
432 PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirection::Type textDirection, RenderBehaviour behaviour, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat)
434 // @todo. This initial implementation for a TextLabel has only one visible page.
436 // Elides the text if needed.
437 mModel->ElideGlyphs();
439 // Retrieves the layout size.
440 const Size& layoutSize = mModel->GetLayoutSize();
442 const int outlineWidth = static_cast<int>(mModel->GetOutlineWidth());
444 // Set the offset for the horizontal alignment according to the text direction and outline width.
447 switch(mModel->GetHorizontalAlignment())
449 case HorizontalAlignment::BEGIN:
454 case HorizontalAlignment::CENTER:
456 penX += (textDirection == Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT) ? -outlineWidth : outlineWidth;
459 case HorizontalAlignment::END:
461 penX += (textDirection == Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT) ? -outlineWidth * 2 : outlineWidth * 2;
466 // Set the offset for the vertical alignment.
469 switch(mModel->GetVerticalAlignment())
471 case VerticalAlignment::TOP:
476 case VerticalAlignment::CENTER:
478 penY = static_cast<int>(0.5f * (size.height - layoutSize.height));
479 penY = penY < 0.f ? 0.f : penY;
482 case VerticalAlignment::BOTTOM:
484 penY = static_cast<int>(size.height - layoutSize.height);
489 // Calculate vertical line alignment
490 switch(mModel->GetVerticalLineAlignment())
492 case DevelText::VerticalLineAlignment::TOP:
496 case DevelText::VerticalLineAlignment::MIDDLE:
498 const auto& line = *mModel->GetLines();
499 penY -= line.descender;
500 penY += static_cast<int>(line.lineSpacing * 0.5f + line.descender);
503 case DevelText::VerticalLineAlignment::BOTTOM:
505 const auto& line = *mModel->GetLines();
506 const auto lineHeight = line.ascender + (-line.descender) + line.lineSpacing;
507 penY += static_cast<int>(lineHeight - (line.ascender - line.descender));
512 // Generate the image buffers of the text for each different style first,
513 // then combine all of them together as one final image buffer. We try to
514 // do all of these in CPU only, so that once the final texture is generated,
515 // no calculation is needed in GPU during each frame.
517 const unsigned int bufferWidth = static_cast<unsigned int>(size.width);
518 const unsigned int bufferHeight = static_cast<unsigned int>(size.height);
520 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
521 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
523 Length numberOfGlyphs = mModel->GetNumberOfGlyphs();
525 Devel::PixelBuffer imageBuffer;
527 if(RENDER_MASK == behaviour)
529 // Generate the image buffer as an alpha mask for color glyphs.
530 imageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_MASK, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1);
532 else if(RENDER_NO_TEXT == behaviour)
534 // Generate an empty image buffer so that it can been combined with the image buffers for styles
535 imageBuffer = Devel::PixelBuffer::New(bufferWidth, bufferHeight, Pixel::RGBA8888);
536 memset(imageBuffer.GetBuffer(), 0u, bufferSizeChar);
540 // Generate the image buffer for the text with no style.
541 imageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_NONE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1);
544 if((RENDER_NO_STYLES != behaviour) && (RENDER_MASK != behaviour))
546 // Generate the outline if enabled
547 const uint16_t outlineWidth = mModel->GetOutlineWidth();
548 if(outlineWidth != 0u)
550 // Create the image buffer for outline
551 Devel::PixelBuffer outlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_OUTLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1);
553 // Combine the two buffers
554 imageBuffer = CombineImageBuffer(imageBuffer, outlineImageBuffer, bufferWidth, bufferHeight);
557 // @todo. Support shadow and underline for partial text later on.
559 // Generate the shadow if enabled
560 const Vector2& shadowOffset = mModel->GetShadowOffset();
561 if(fabsf(shadowOffset.x) > Math::MACHINE_EPSILON_1 || fabsf(shadowOffset.y) > Math::MACHINE_EPSILON_1)
563 // Create the image buffer for shadow
564 Devel::PixelBuffer shadowImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_SHADOW, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1);
566 // Check whether it will be a soft shadow
567 const float& blurRadius = mModel->GetShadowBlurRadius();
569 if(blurRadius > Math::MACHINE_EPSILON_1)
571 shadowImageBuffer.ApplyGaussianBlur(blurRadius);
574 // Combine the two buffers
575 imageBuffer = CombineImageBuffer(imageBuffer, shadowImageBuffer, bufferWidth, bufferHeight);
578 // Generate the underline if enabled
579 const bool underlineEnabled = mModel->IsUnderlineEnabled();
582 // Create the image buffer for underline
583 Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1);
585 // Combine the two buffers
586 imageBuffer = CombineImageBuffer(imageBuffer, underlineImageBuffer, bufferWidth, bufferHeight);
589 // Generate the background if enabled
590 const bool backgroundEnabled = mModel->IsBackgroundEnabled();
591 if(backgroundEnabled)
593 Devel::PixelBuffer backgroundImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_BACKGROUND, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, numberOfGlyphs - 1);
595 // Combine the two buffers
596 imageBuffer = CombineImageBuffer(imageBuffer, backgroundImageBuffer, bufferWidth, bufferHeight);
601 imageBuffer = ApplyMarkupProcessorOnPixelBuffer(imageBuffer, bufferWidth, bufferHeight, ignoreHorizontalAlignment, pixelFormat, penX, penY);
605 // Create the final PixelData for the combined image buffer
606 PixelData pixelData = Devel::PixelBuffer::Convert(imageBuffer);
611 Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, const unsigned int bufferHeight, Typesetter::Style style, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset, GlyphIndex fromGlyphIndex, GlyphIndex toGlyphIndex)
613 // Retrieve lines, glyphs, positions and colors from the view model.
614 const Length modelNumberOfLines = mModel->GetNumberOfLines();
615 const LineRun* const modelLinesBuffer = mModel->GetLines();
616 const Length numberOfGlyphs = mModel->GetNumberOfGlyphs();
617 const GlyphInfo* const glyphsBuffer = mModel->GetGlyphs();
618 const Vector2* const positionBuffer = mModel->GetLayout();
619 const Vector4* const colorsBuffer = mModel->GetColors();
620 const ColorIndex* const colorIndexBuffer = mModel->GetColorIndices();
622 // Whether to use the default color.
623 const bool useDefaultColor = (NULL == colorsBuffer);
624 const Vector4& defaultColor = mModel->GetDefaultColor();
626 // Create and initialize the pixel buffer.
628 glyphData.verticalOffset = verticalOffset;
629 glyphData.width = bufferWidth;
630 glyphData.height = bufferHeight;
631 glyphData.bitmapBuffer = Devel::PixelBuffer::New(bufferWidth, bufferHeight, pixelFormat);
632 glyphData.horizontalOffset = 0;
634 if(Pixel::RGBA8888 == pixelFormat)
636 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
637 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
638 memset(glyphData.bitmapBuffer.GetBuffer(), 0u, bufferSizeChar);
642 memset(glyphData.bitmapBuffer.GetBuffer(), 0, bufferWidth * bufferHeight);
645 // Get a handle of the font client. Used to retrieve the bitmaps of the glyphs.
646 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
648 // Traverses the lines of the text.
649 for(LineIndex lineIndex = 0u; lineIndex < modelNumberOfLines; ++lineIndex)
651 const LineRun& line = *(modelLinesBuffer + lineIndex);
653 // Sets the horizontal offset of the line.
654 glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int>(line.alignmentOffset);
655 glyphData.horizontalOffset += horizontalOffset;
657 // Increases the vertical offset with the line's ascender.
658 glyphData.verticalOffset += static_cast<int>(line.ascender);
660 // Include line spacing after first line
663 glyphData.verticalOffset += static_cast<int>(line.lineSpacing);
666 // Retrieves the glyph's outline width
667 float outlineWidth = static_cast<float>(mModel->GetOutlineWidth());
669 if(style == Typesetter::STYLE_OUTLINE)
671 glyphData.horizontalOffset -= outlineWidth;
674 // Only need to add the vertical outline offset for the first line
675 glyphData.verticalOffset -= outlineWidth;
678 else if(style == Typesetter::STYLE_SHADOW)
680 const Vector2& shadowOffset = mModel->GetShadowOffset();
681 glyphData.horizontalOffset += shadowOffset.x - outlineWidth; // if outline enabled then shadow should offset from outline
685 // Only need to add the vertical shadow offset for first line
686 glyphData.verticalOffset += shadowOffset.y - outlineWidth;
690 const bool underlineEnabled = mModel->IsUnderlineEnabled();
691 const Vector4& underlineColor = mModel->GetUnderlineColor();
692 const float underlineHeight = mModel->GetUnderlineHeight();
694 // Get the underline runs.
695 const Length numberOfUnderlineRuns = mModel->GetNumberOfUnderlineRuns();
696 Vector<GlyphRun> underlineRuns;
697 underlineRuns.Resize(numberOfUnderlineRuns);
698 mModel->GetUnderlineRuns(underlineRuns.Begin(), 0u, numberOfUnderlineRuns);
700 bool thereAreUnderlinedGlyphs = false;
702 float currentUnderlinePosition = 0.0f;
703 float currentUnderlineThickness = underlineHeight;
704 float maxUnderlineThickness = currentUnderlineThickness;
706 FontId lastUnderlinedFontId = 0;
708 float lineExtentLeft = bufferWidth;
709 float lineExtentRight = 0.0f;
710 float baseline = 0.0f;
712 // Traverses the glyphs of the line.
713 const GlyphIndex endGlyphIndex = std::min(numberOfGlyphs, line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs);
714 for(GlyphIndex glyphIndex = line.glyphRun.glyphIndex; glyphIndex < endGlyphIndex; ++glyphIndex)
716 if(glyphIndex < fromGlyphIndex || glyphIndex > toGlyphIndex)
718 // Ignore any glyph that out of the specified range
722 // Retrieve the glyph's info.
723 const GlyphInfo* const glyphInfo = glyphsBuffer + glyphIndex;
725 if((glyphInfo->width < Math::MACHINE_EPSILON_1000) ||
726 (glyphInfo->height < Math::MACHINE_EPSILON_1000))
728 // Nothing to do if the glyph's width or height is zero.
732 const bool underlineGlyph = underlineEnabled || IsGlyphUnderlined(glyphIndex, underlineRuns);
733 thereAreUnderlinedGlyphs = thereAreUnderlinedGlyphs || underlineGlyph;
735 // Are we still using the same fontId as previous
736 if(underlineGlyph && (glyphInfo->fontId != lastUnderlinedFontId))
738 // We need to fetch fresh font underline metrics
739 FetchFontUnderlineMetrics(fontClient, glyphInfo, currentUnderlinePosition, underlineHeight, currentUnderlineThickness, maxUnderlineThickness, lastUnderlinedFontId);
742 // Retrieves the glyph's position.
743 const Vector2* const position = positionBuffer + glyphIndex;
744 if(baseline < position->y + glyphInfo->yBearing)
746 baseline = position->y + glyphInfo->yBearing;
749 // Calculate the positions of leftmost and rightmost glyphs in the current line
750 if(position->x < lineExtentLeft)
752 lineExtentLeft = position->x;
755 if(position->x + glyphInfo->width > lineExtentRight)
757 lineExtentRight = position->x + glyphInfo->width;
760 // Retrieves the glyph's color.
761 const ColorIndex colorIndex = useDefaultColor ? 0u : *(colorIndexBuffer + glyphIndex);
764 if(style == Typesetter::STYLE_SHADOW)
766 color = mModel->GetShadowColor();
768 else if(style == Typesetter::STYLE_OUTLINE)
770 color = mModel->GetOutlineColor();
774 color = (useDefaultColor || (0u == colorIndex)) ? defaultColor : *(colorsBuffer + (colorIndex - 1u));
782 // Retrieves the glyph's bitmap.
783 glyphData.glyphBitmap.buffer = NULL;
784 glyphData.glyphBitmap.width = glyphInfo->width; // Desired width and height.
785 glyphData.glyphBitmap.height = glyphInfo->height;
787 if(style != Typesetter::STYLE_OUTLINE && style != Typesetter::STYLE_SHADOW)
789 // Don't render outline for other styles
793 if(style != Typesetter::STYLE_UNDERLINE)
795 fontClient.CreateBitmap(glyphInfo->fontId,
797 glyphInfo->isItalicRequired,
798 glyphInfo->isBoldRequired,
799 glyphData.glyphBitmap,
800 static_cast<int>(outlineWidth));
803 // Sets the glyph's bitmap into the bitmap of the whole text.
804 if(NULL != glyphData.glyphBitmap.buffer)
806 if(style == Typesetter::STYLE_OUTLINE)
808 // Set the position offset for the current glyph
809 glyphData.horizontalOffset -= glyphData.glyphBitmap.outlineOffsetX;
810 glyphData.verticalOffset -= glyphData.glyphBitmap.outlineOffsetY;
813 // Set the buffer of the glyph's bitmap into the final bitmap's buffer
814 TypesetGlyph(glyphData,
820 if(style == Typesetter::STYLE_OUTLINE)
822 // Reset the position offset for the next glyph
823 glyphData.horizontalOffset += glyphData.glyphBitmap.outlineOffsetX;
824 glyphData.verticalOffset += glyphData.glyphBitmap.outlineOffsetY;
827 // delete the glyphBitmap.buffer as it is now copied into glyphData.bitmapBuffer
828 delete[] glyphData.glyphBitmap.buffer;
829 glyphData.glyphBitmap.buffer = NULL;
833 // Draw the underline from the leftmost glyph to the rightmost glyph
834 if(thereAreUnderlinedGlyphs && style == Typesetter::STYLE_UNDERLINE)
836 DrawUnderline(underlineColor, bufferWidth, bufferHeight, glyphData, baseline, currentUnderlinePosition, maxUnderlineThickness, lineExtentLeft, lineExtentRight);
839 // Draw the background color from the leftmost glyph to the rightmost glyph
840 if(style == Typesetter::STYLE_BACKGROUND)
842 DrawBackgroundColor(mModel->GetBackgroundColor(), bufferWidth, bufferHeight, glyphData, baseline, line, lineExtentLeft, lineExtentRight);
845 // Increases the vertical offset with the line's descender.
846 glyphData.verticalOffset += static_cast<int>(-line.descender);
849 return glyphData.bitmapBuffer;
852 Devel::PixelBuffer Typesetter::CombineImageBuffer(Devel::PixelBuffer topPixelBuffer, Devel::PixelBuffer bottomPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight)
854 unsigned char* topBuffer = topPixelBuffer.GetBuffer();
855 unsigned char* bottomBuffer = bottomPixelBuffer.GetBuffer();
857 Devel::PixelBuffer combinedPixelBuffer;
859 if(topBuffer == NULL && bottomBuffer == NULL)
861 // Nothing to do if both buffers are empty.
862 return combinedPixelBuffer;
865 if(topBuffer == NULL)
867 // Nothing to do if topBuffer is empty.
868 return bottomPixelBuffer;
871 if(bottomBuffer == NULL)
873 // Nothing to do if bottomBuffer is empty.
874 return topPixelBuffer;
877 // Always combine two RGBA images
878 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
879 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
881 combinedPixelBuffer = Devel::PixelBuffer::New(bufferWidth, bufferHeight, Pixel::RGBA8888);
882 uint8_t* combinedBuffer = reinterpret_cast<uint8_t*>(combinedPixelBuffer.GetBuffer());
883 memset(combinedBuffer, 0u, bufferSizeChar);
885 for(unsigned int pixelIndex = 0; pixelIndex < bufferSizeInt; pixelIndex++)
887 // If the alpha of the pixel in either buffer is not fully opaque, blend the two pixels.
888 // Otherwise, copy pixel from topBuffer to combinedBuffer.
890 unsigned int alphaBuffer1 = topBuffer[pixelIndex * 4 + 3];
892 if(alphaBuffer1 != 255)
894 // At least one pixel is not fully opaque
895 // "Over" blend the the pixel from topBuffer with the pixel in bottomBuffer
896 combinedBuffer[pixelIndex * 4] = topBuffer[pixelIndex * 4] + (bottomBuffer[pixelIndex * 4] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
897 combinedBuffer[pixelIndex * 4 + 1] = topBuffer[pixelIndex * 4 + 1] + (bottomBuffer[pixelIndex * 4 + 1] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
898 combinedBuffer[pixelIndex * 4 + 2] = topBuffer[pixelIndex * 4 + 2] + (bottomBuffer[pixelIndex * 4 + 2] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
899 combinedBuffer[pixelIndex * 4 + 3] = topBuffer[pixelIndex * 4 + 3] + (bottomBuffer[pixelIndex * 4 + 3] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
903 // Copy the pixel from topBuffer to combinedBuffer
904 combinedBuffer[pixelIndex * 4] = topBuffer[pixelIndex * 4];
905 combinedBuffer[pixelIndex * 4 + 1] = topBuffer[pixelIndex * 4 + 1];
906 combinedBuffer[pixelIndex * 4 + 2] = topBuffer[pixelIndex * 4 + 2];
907 combinedBuffer[pixelIndex * 4 + 3] = topBuffer[pixelIndex * 4 + 3];
911 return combinedPixelBuffer;
914 Devel::PixelBuffer Typesetter::ApplyMarkupProcessorOnPixelBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset)
916 // Apply the markup-Processor if enabled
917 const bool markupProcessorEnabled = mModel->IsMarkupProcessorEnabled();
918 if(markupProcessorEnabled)
920 // Underline-tags (this is for Markup case)
921 // Get the underline runs.
922 const Length numberOfUnderlineRuns = mModel->GetNumberOfUnderlineRuns();
923 Vector<GlyphRun> underlineRuns;
924 underlineRuns.Resize(numberOfUnderlineRuns);
925 mModel->GetUnderlineRuns(underlineRuns.Begin(), 0u, numberOfUnderlineRuns);
927 // Iterate on the consecutive underlined glyph run and connect them into one chunk of underlined characters.
928 Vector<GlyphRun>::ConstIterator itGlyphRun = underlineRuns.Begin();
929 Vector<GlyphRun>::ConstIterator endItGlyphRun = underlineRuns.End();
930 GlyphIndex startGlyphIndex, endGlyphIndex;
932 //The outer loop to iterate on the separated chunks of underlined glyph runs
933 while(itGlyphRun != endItGlyphRun)
935 startGlyphIndex = itGlyphRun->glyphIndex;
936 endGlyphIndex = startGlyphIndex;
937 //The inner loop to make a connected underline for the consecutive characters
940 endGlyphIndex += itGlyphRun->numberOfGlyphs;
942 } while(itGlyphRun != endItGlyphRun && itGlyphRun->glyphIndex == endGlyphIndex);
946 // Create the image buffer for underline
947 Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, horizontalOffset, verticalOffset, startGlyphIndex, endGlyphIndex);
948 // Combine the two buffers
949 topPixelBuffer = CombineImageBuffer(topPixelBuffer, underlineImageBuffer, bufferWidth, bufferHeight);
953 return topPixelBuffer;
956 Typesetter::Typesetter(const ModelInterface* const model)
957 : mModel(new ViewModel(model))
961 Typesetter::~Typesetter()
968 } // namespace Toolkit