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);
604 // Create the final PixelData for the combined image buffer
605 PixelData pixelData = Devel::PixelBuffer::Convert(imageBuffer);
610 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)
612 // Retrieve lines, glyphs, positions and colors from the view model.
613 const Length modelNumberOfLines = mModel->GetNumberOfLines();
614 const LineRun* const modelLinesBuffer = mModel->GetLines();
615 const Length numberOfGlyphs = mModel->GetNumberOfGlyphs();
616 const GlyphInfo* const glyphsBuffer = mModel->GetGlyphs();
617 const Vector2* const positionBuffer = mModel->GetLayout();
618 const Vector4* const colorsBuffer = mModel->GetColors();
619 const ColorIndex* const colorIndexBuffer = mModel->GetColorIndices();
620 const GlyphInfo* hyphens = mModel->GetHyphens();
621 const Length* hyphenIndices = mModel->GetHyphenIndices();
622 const Length hyphensCount = mModel->GetHyphensCount();
624 // Whether to use the default color.
625 const bool useDefaultColor = (NULL == colorsBuffer);
626 const Vector4& defaultColor = mModel->GetDefaultColor();
628 // Create and initialize the pixel buffer.
630 glyphData.verticalOffset = verticalOffset;
631 glyphData.width = bufferWidth;
632 glyphData.height = bufferHeight;
633 glyphData.bitmapBuffer = Devel::PixelBuffer::New(bufferWidth, bufferHeight, pixelFormat);
634 glyphData.horizontalOffset = 0;
636 if(Pixel::RGBA8888 == pixelFormat)
638 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
639 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
640 memset(glyphData.bitmapBuffer.GetBuffer(), 0u, bufferSizeChar);
644 memset(glyphData.bitmapBuffer.GetBuffer(), 0, bufferWidth * bufferHeight);
647 // Get a handle of the font client. Used to retrieve the bitmaps of the glyphs.
648 TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
649 Length hyphenIndex = 0;
651 // Traverses the lines of the text.
652 for(LineIndex lineIndex = 0u; lineIndex < modelNumberOfLines; ++lineIndex)
654 const LineRun& line = *(modelLinesBuffer + lineIndex);
656 // Sets the horizontal offset of the line.
657 glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int>(line.alignmentOffset);
658 glyphData.horizontalOffset += horizontalOffset;
660 // Increases the vertical offset with the line's ascender.
661 glyphData.verticalOffset += static_cast<int>(line.ascender);
663 // Include line spacing after first line
666 glyphData.verticalOffset += static_cast<int>(line.lineSpacing);
669 // Retrieves the glyph's outline width
670 float outlineWidth = static_cast<float>(mModel->GetOutlineWidth());
672 if(style == Typesetter::STYLE_OUTLINE)
674 glyphData.horizontalOffset -= outlineWidth;
677 // Only need to add the vertical outline offset for the first line
678 glyphData.verticalOffset -= outlineWidth;
681 else if(style == Typesetter::STYLE_SHADOW)
683 const Vector2& shadowOffset = mModel->GetShadowOffset();
684 glyphData.horizontalOffset += shadowOffset.x - outlineWidth; // if outline enabled then shadow should offset from outline
688 // Only need to add the vertical shadow offset for first line
689 glyphData.verticalOffset += shadowOffset.y - outlineWidth;
693 const bool underlineEnabled = mModel->IsUnderlineEnabled();
694 const Vector4& underlineColor = mModel->GetUnderlineColor();
695 const float underlineHeight = mModel->GetUnderlineHeight();
697 // Get the underline runs.
698 const Length numberOfUnderlineRuns = mModel->GetNumberOfUnderlineRuns();
699 Vector<GlyphRun> underlineRuns;
700 underlineRuns.Resize(numberOfUnderlineRuns);
701 mModel->GetUnderlineRuns(underlineRuns.Begin(), 0u, numberOfUnderlineRuns);
703 bool thereAreUnderlinedGlyphs = false;
705 float currentUnderlinePosition = 0.0f;
706 float currentUnderlineThickness = underlineHeight;
707 float maxUnderlineThickness = currentUnderlineThickness;
709 FontId lastUnderlinedFontId = 0;
711 float lineExtentLeft = bufferWidth;
712 float lineExtentRight = 0.0f;
713 float baseline = 0.0f;
714 bool addHyphen = false;
716 // Traverses the glyphs of the line.
717 const GlyphIndex endGlyphIndex = std::min(numberOfGlyphs, line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs);
718 for(GlyphIndex glyphIndex = line.glyphRun.glyphIndex; glyphIndex < endGlyphIndex; ++glyphIndex)
720 if(glyphIndex < fromGlyphIndex || glyphIndex > toGlyphIndex)
722 // Ignore any glyph that out of the specified range
726 // Retrieve the glyph's info.
727 const GlyphInfo* glyphInfo;
729 if(addHyphen && hyphens)
731 glyphInfo = hyphens + hyphenIndex;
736 glyphInfo = glyphsBuffer + glyphIndex;
739 if((glyphInfo->width < Math::MACHINE_EPSILON_1000) ||
740 (glyphInfo->height < Math::MACHINE_EPSILON_1000))
742 // Nothing to do if the glyph's width or height is zero.
746 const bool underlineGlyph = underlineEnabled || IsGlyphUnderlined(glyphIndex, underlineRuns);
747 thereAreUnderlinedGlyphs = thereAreUnderlinedGlyphs || underlineGlyph;
749 // Are we still using the same fontId as previous
750 if(underlineGlyph && (glyphInfo->fontId != lastUnderlinedFontId))
752 // We need to fetch fresh font underline metrics
753 FetchFontUnderlineMetrics(fontClient, glyphInfo, currentUnderlinePosition, underlineHeight, currentUnderlineThickness, maxUnderlineThickness, lastUnderlinedFontId);
756 // Retrieves the glyph's position.
757 Vector2 position = *(positionBuffer + glyphIndex);
761 GlyphInfo tempInfo = *(glyphsBuffer + glyphIndex);
762 position.x = position.x + tempInfo.advance - tempInfo.xBearing + glyphInfo->xBearing;
763 position.y = -glyphInfo->yBearing;
766 if(baseline < position.y + glyphInfo->yBearing)
768 baseline = position.y + glyphInfo->yBearing;
771 // Calculate the positions of leftmost and rightmost glyphs in the current line
772 if(position.x < lineExtentLeft)
774 lineExtentLeft = position.x;
777 if(position.x + glyphInfo->width > lineExtentRight)
779 lineExtentRight = position.x + glyphInfo->width;
782 // Retrieves the glyph's color.
783 const ColorIndex colorIndex = useDefaultColor ? 0u : *(colorIndexBuffer + glyphIndex);
786 if(style == Typesetter::STYLE_SHADOW)
788 color = mModel->GetShadowColor();
790 else if(style == Typesetter::STYLE_OUTLINE)
792 color = mModel->GetOutlineColor();
796 color = (useDefaultColor || (0u == colorIndex)) ? defaultColor : *(colorsBuffer + (colorIndex - 1u));
804 // Retrieves the glyph's bitmap.
805 glyphData.glyphBitmap.buffer = NULL;
806 glyphData.glyphBitmap.width = glyphInfo->width; // Desired width and height.
807 glyphData.glyphBitmap.height = glyphInfo->height;
809 if(style != Typesetter::STYLE_OUTLINE && style != Typesetter::STYLE_SHADOW)
811 // Don't render outline for other styles
815 if(style != Typesetter::STYLE_UNDERLINE)
817 fontClient.CreateBitmap(glyphInfo->fontId,
819 glyphInfo->isItalicRequired,
820 glyphInfo->isBoldRequired,
821 glyphData.glyphBitmap,
822 static_cast<int>(outlineWidth));
825 // Sets the glyph's bitmap into the bitmap of the whole text.
826 if(NULL != glyphData.glyphBitmap.buffer)
828 if(style == Typesetter::STYLE_OUTLINE)
830 // Set the position offset for the current glyph
831 glyphData.horizontalOffset -= glyphData.glyphBitmap.outlineOffsetX;
832 glyphData.verticalOffset -= glyphData.glyphBitmap.outlineOffsetY;
835 // Set the buffer of the glyph's bitmap into the final bitmap's buffer
836 TypesetGlyph(glyphData,
842 if(style == Typesetter::STYLE_OUTLINE)
844 // Reset the position offset for the next glyph
845 glyphData.horizontalOffset += glyphData.glyphBitmap.outlineOffsetX;
846 glyphData.verticalOffset += glyphData.glyphBitmap.outlineOffsetY;
849 // delete the glyphBitmap.buffer as it is now copied into glyphData.bitmapBuffer
850 delete[] glyphData.glyphBitmap.buffer;
851 glyphData.glyphBitmap.buffer = NULL;
856 while((hyphenIndex < hyphensCount) && (glyphIndex > hyphenIndices[hyphenIndex]))
861 addHyphen = ((hyphenIndex < hyphensCount) && ((glyphIndex + 1) == hyphenIndices[hyphenIndex]));
869 // Draw the underline from the leftmost glyph to the rightmost glyph
870 if(thereAreUnderlinedGlyphs && style == Typesetter::STYLE_UNDERLINE)
872 DrawUnderline(underlineColor, bufferWidth, bufferHeight, glyphData, baseline, currentUnderlinePosition, maxUnderlineThickness, lineExtentLeft, lineExtentRight);
875 // Draw the background color from the leftmost glyph to the rightmost glyph
876 if(style == Typesetter::STYLE_BACKGROUND)
878 DrawBackgroundColor(mModel->GetBackgroundColor(), bufferWidth, bufferHeight, glyphData, baseline, line, lineExtentLeft, lineExtentRight);
881 // Increases the vertical offset with the line's descender.
882 glyphData.verticalOffset += static_cast<int>(-line.descender);
885 return glyphData.bitmapBuffer;
888 Devel::PixelBuffer Typesetter::CombineImageBuffer(Devel::PixelBuffer topPixelBuffer, Devel::PixelBuffer bottomPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight)
890 unsigned char* topBuffer = topPixelBuffer.GetBuffer();
891 unsigned char* bottomBuffer = bottomPixelBuffer.GetBuffer();
893 Devel::PixelBuffer combinedPixelBuffer;
895 if(topBuffer == NULL && bottomBuffer == NULL)
897 // Nothing to do if both buffers are empty.
898 return combinedPixelBuffer;
901 if(topBuffer == NULL)
903 // Nothing to do if topBuffer is empty.
904 return bottomPixelBuffer;
907 if(bottomBuffer == NULL)
909 // Nothing to do if bottomBuffer is empty.
910 return topPixelBuffer;
913 // Always combine two RGBA images
914 const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
915 const unsigned int bufferSizeChar = 4u * bufferSizeInt;
917 combinedPixelBuffer = Devel::PixelBuffer::New(bufferWidth, bufferHeight, Pixel::RGBA8888);
918 uint8_t* combinedBuffer = reinterpret_cast<uint8_t*>(combinedPixelBuffer.GetBuffer());
919 memset(combinedBuffer, 0u, bufferSizeChar);
921 for(unsigned int pixelIndex = 0; pixelIndex < bufferSizeInt; pixelIndex++)
923 // If the alpha of the pixel in either buffer is not fully opaque, blend the two pixels.
924 // Otherwise, copy pixel from topBuffer to combinedBuffer.
926 unsigned int alphaBuffer1 = topBuffer[pixelIndex * 4 + 3];
928 if(alphaBuffer1 != 255)
930 // At least one pixel is not fully opaque
931 // "Over" blend the the pixel from topBuffer with the pixel in bottomBuffer
932 combinedBuffer[pixelIndex * 4] = topBuffer[pixelIndex * 4] + (bottomBuffer[pixelIndex * 4] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
933 combinedBuffer[pixelIndex * 4 + 1] = topBuffer[pixelIndex * 4 + 1] + (bottomBuffer[pixelIndex * 4 + 1] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
934 combinedBuffer[pixelIndex * 4 + 2] = topBuffer[pixelIndex * 4 + 2] + (bottomBuffer[pixelIndex * 4 + 2] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
935 combinedBuffer[pixelIndex * 4 + 3] = topBuffer[pixelIndex * 4 + 3] + (bottomBuffer[pixelIndex * 4 + 3] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
939 // Copy the pixel from topBuffer to combinedBuffer
940 combinedBuffer[pixelIndex * 4] = topBuffer[pixelIndex * 4];
941 combinedBuffer[pixelIndex * 4 + 1] = topBuffer[pixelIndex * 4 + 1];
942 combinedBuffer[pixelIndex * 4 + 2] = topBuffer[pixelIndex * 4 + 2];
943 combinedBuffer[pixelIndex * 4 + 3] = topBuffer[pixelIndex * 4 + 3];
947 return combinedPixelBuffer;
950 Devel::PixelBuffer Typesetter::ApplyMarkupProcessorOnPixelBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset)
952 // Apply the markup-Processor if enabled
953 const bool markupProcessorEnabled = mModel->IsMarkupProcessorEnabled();
954 if(markupProcessorEnabled)
956 // Underline-tags (this is for Markup case)
957 // Get the underline runs.
958 const Length numberOfUnderlineRuns = mModel->GetNumberOfUnderlineRuns();
959 Vector<GlyphRun> underlineRuns;
960 underlineRuns.Resize(numberOfUnderlineRuns);
961 mModel->GetUnderlineRuns(underlineRuns.Begin(), 0u, numberOfUnderlineRuns);
963 // Iterate on the consecutive underlined glyph run and connect them into one chunk of underlined characters.
964 Vector<GlyphRun>::ConstIterator itGlyphRun = underlineRuns.Begin();
965 Vector<GlyphRun>::ConstIterator endItGlyphRun = underlineRuns.End();
966 GlyphIndex startGlyphIndex, endGlyphIndex;
968 //The outer loop to iterate on the separated chunks of underlined glyph runs
969 while(itGlyphRun != endItGlyphRun)
971 startGlyphIndex = itGlyphRun->glyphIndex;
972 endGlyphIndex = startGlyphIndex;
973 //The inner loop to make a connected underline for the consecutive characters
976 endGlyphIndex += itGlyphRun->numberOfGlyphs;
978 } while(itGlyphRun != endItGlyphRun && itGlyphRun->glyphIndex == endGlyphIndex);
982 // Create the image buffer for underline
983 Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, horizontalOffset, verticalOffset, startGlyphIndex, endGlyphIndex);
984 // Combine the two buffers
985 topPixelBuffer = CombineImageBuffer(topPixelBuffer, underlineImageBuffer, bufferWidth, bufferHeight);
989 return topPixelBuffer;
992 Typesetter::Typesetter(const ModelInterface* const model)
993 : mModel(new ViewModel(model))
997 Typesetter::~Typesetter()
1004 } // namespace Toolkit