dali-toolkit/internal/text/rendering/text-typesetter.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/internal/text/rendering/text-typesetter.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/text-abstraction/font-client.h>
  23 #include <memory.h>
  24 #include <dali/public-api/common/constants.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/internal/text/rendering/view-model.h>
  28
  29 namespace Dali
  30 {
  31
  32 namespace Toolkit
  33 {
  34
  35 namespace Text
  36 {
  37
  38 namespace
  39 {
  40
  41 /**
  42  * @brief Data struct used to set the buffer of the glyph's bitmap into the final bitmap's buffer.
  43  */
  44 struct GlyphData
  45 {
  46   Devel::PixelBuffer                           bitmapBuffer;     ///< The buffer of the whole bitmap. The format is RGBA8888.
  47   Vector2*                                     position;         ///< The position of the glyph.
  48   TextAbstraction::FontClient::GlyphBufferData glyphBitmap;      ///< The glyph's bitmap.
  49   unsigned int                                 width;            ///< The bitmap's width.
  50   unsigned int                                 height;           ///< The bitmap's height.
  51   int                                          horizontalOffset; ///< The horizontal offset to be added to the 'x' glyph's position.
  52   int                                          verticalOffset;   ///< The vertical offset to be added to the 'y' glyph's position.
  53 };
  54
  55 /**
  56  * @brief Sets the glyph's buffer into the bitmap's buffer.
  57  *
  58  * @param[in] data Struct which contains the glyph's data and the bitmap's data.
  59  * @param[in] position The position of the glyph.
  60  * @param[in] color The color of the glyph.
  61  * @param[in] style The style of the text.
  62  * @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).
  63  */
  64 void TypesetGlyph( GlyphData& data,
  65                    const Vector2* const position,
  66                    const Vector4* const color,
  67                    Typesetter::Style style,
  68                    Pixel::Format pixelFormat )
  69 {
  70   if( ( 0u == data.glyphBitmap.width ) || ( 0u == data.glyphBitmap.height ) )
  71   {
  72     // Nothing to do if the width or height of the buffer is zero.
  73     return;
  74   }
  75
  76   const int widthMinusOne = static_cast<int>( data.width - 1u );
  77   const int heightMinusOne = static_cast<int>( data.height - 1u );
  78
  79   if ( Pixel::RGBA8888 == pixelFormat )
  80   {
  81     // Whether the given glyph is a color one.
  82     const bool isColorGlyph = Pixel::BGRA8888 == data.glyphBitmap.format;
  83
  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;
  86
  87     // Pack the given color into a 32bit buffer. The alpha channel will be updated later for each pixel.
  88     // The format is RGBA8888.
  89     uint32_t packedColor = 0u;
  90     uint8_t* packedColorBuffer = reinterpret_cast<uint8_t*>( &packedColor );
  91     *( packedColorBuffer + 2 ) = static_cast<uint8_t>( color->b * 255.f );
  92     *( packedColorBuffer + 1 ) = static_cast<uint8_t>( color->g * 255.f );
  93       *packedColorBuffer       = static_cast<uint8_t>( color->r * 255.f );
  94
  95     // Initial vertical offset.
  96     const int yOffset = data.verticalOffset + position->y;
  97
  98     // Traverse the pixels of the glyph line per line.
  99     for( int lineIndex = 0, glyphHeight = static_cast<int>( data.glyphBitmap.height ); lineIndex < glyphHeight; ++lineIndex )
 100     {
 101       const int yOffsetIndex = yOffset + lineIndex;
 102       if( ( 0 > yOffsetIndex ) || ( yOffsetIndex > heightMinusOne ) )
 103       {
 104         // Do not write out of bounds.
 105         continue;
 106       }
 107
 108       const int verticalOffset = yOffsetIndex * data.width;
 109       const int xOffset = data.horizontalOffset + position->x;
 110       const int glyphBufferOffset = lineIndex * static_cast<int>( data.glyphBitmap.width );
 111       for( int index = 0, glyphWidth = static_cast<int>( data.glyphBitmap.width ); index < glyphWidth; ++index )
 112       {
 113         const int xOffsetIndex = xOffset + index;
 114         if( ( 0 > xOffsetIndex ) || ( xOffsetIndex > widthMinusOne ) )
 115         {
 116           // Don't write out of bounds.
 117           continue;
 118         }
 119
 120         uint32_t* bitmapBuffer = reinterpret_cast< uint32_t* >( data.bitmapBuffer.GetBuffer() );
 121
 122         if( isColorGlyph )
 123         {
 124           // Retrieves the color from the color glyph. The format is BGRA8888.
 125           uint32_t packedColorGlyph = *( colorGlyphBuffer + glyphBufferOffset + index );
 126           uint8_t* packedColorGlyphBuffer = reinterpret_cast<uint8_t*>( &packedColorGlyph );
 127
 128           if( Typesetter::STYLE_SHADOW == style )
 129           {
 130             // The shadow of color glyph needs to have the shadow color.
 131             *( packedColorGlyphBuffer + 2 ) = static_cast<uint8_t>( color->b * 255.f );
 132             *( packedColorGlyphBuffer + 1 ) = static_cast<uint8_t>( color->g * 255.f );
 133               *packedColorGlyphBuffer       = static_cast<uint8_t>( color->r * 255.f );
 134           }
 135           else
 136           {
 137             std::swap( *packedColorGlyphBuffer, *( packedColorGlyphBuffer + 2u ) ); // Swap B and R.
 138           }
 139
 140           // Update the alpha channel.
 141           if( Typesetter::STYLE_MASK == style || Typesetter::STYLE_OUTLINE == style ) // Outline not shown for color glyph
 142           {
 143             // Create an alpha mask for color glyph.
 144             *( packedColorGlyphBuffer + 3u ) = 0u;
 145           }
 146           else
 147           {
 148             *( packedColorGlyphBuffer + 3u ) = static_cast<uint8_t>( color->a * static_cast<float>( *( packedColorGlyphBuffer + 3u ) ) );
 149           }
 150
 151           // Set the color into the final pixel buffer.
 152           *( bitmapBuffer + verticalOffset + xOffsetIndex ) = packedColorGlyph;
 153         }
 154         else
 155         {
 156           // Update the alpha channel.
 157           const uint8_t alpha = *( data.glyphBitmap.buffer + glyphBufferOffset + index );
 158
 159           // Copy non-transparent pixels only
 160           if ( alpha > 0u )
 161           {
 162             // Check alpha of overlapped pixels
 163             uint32_t& currentColor = *( bitmapBuffer + verticalOffset + xOffsetIndex );
 164             uint8_t* packedCurrentColorBuffer = reinterpret_cast<uint8_t*>( &currentColor );
 165
 166             uint8_t currentAlpha = *( packedCurrentColorBuffer + 3u );
 167             uint8_t newAlpha = static_cast<uint8_t>( color->a * static_cast<float>( alpha ) );
 168
 169             // For any pixel overlapped with the pixel in previous glyphs, make sure we don't
 170             // overwrite a previous bigger alpha with a smaller alpha (in order to avoid
 171             // semi-transparent gaps between joint glyphs with overlapped pixels, which could
 172             // happen, for example, in the RTL text when we copy glyphs from right to left).
 173             *( packedColorBuffer + 3u ) = std::max( currentAlpha, newAlpha );
 174
 175             // Set the color into the final pixel buffer.
 176             currentColor = packedColor;
 177           }
 178         }
 179       }
 180     }
 181   }
 182   else
 183   {
 184     // Whether the given glyph is a color one.
 185     const bool isColorGlyph = Pixel::BGRA8888 == data.glyphBitmap.format;
 186
 187     // Initial vertical offset.
 188     const int yOffset = data.verticalOffset + position->y;
 189
 190     // Traverse the pixels of the glyph line per line.
 191     for( int lineIndex = 0, glyphHeight = static_cast<int>( data.glyphBitmap.height ); lineIndex < glyphHeight; ++lineIndex )
 192     {
 193       const int yOffsetIndex = yOffset + lineIndex;
 194       if( ( 0 > yOffsetIndex ) || ( yOffsetIndex > heightMinusOne ) )
 195       {
 196         // Do not write out of bounds.
 197         continue;
 198       }
 199
 200       const int verticalOffset = yOffsetIndex * data.width;
 201       const int xOffset = data.horizontalOffset + position->x;
 202       const int glyphBufferOffset = lineIndex * static_cast<int>( data.glyphBitmap.width );
 203       for( int index = 0, glyphWidth = static_cast<int>( data.glyphBitmap.width ); index < glyphWidth; ++index )
 204       {
 205         const int xOffsetIndex = xOffset + index;
 206         if( ( 0 > xOffsetIndex ) || ( xOffsetIndex > widthMinusOne ) )
 207         {
 208           // Don't write out of bounds.
 209           continue;
 210         }
 211
 212         uint8_t* bitmapBuffer = reinterpret_cast< uint8_t* >( data.bitmapBuffer.GetBuffer() );
 213
 214         if ( !isColorGlyph )
 215         {
 216           // Update the alpha channel.
 217           const uint8_t alpha = *( data.glyphBitmap.buffer + glyphBufferOffset + index );
 218
 219           // Copy non-transparent pixels only
 220           if ( alpha > 0u )
 221           {
 222             // Check alpha of overlapped pixels
 223             uint8_t& currentAlpha = *( bitmapBuffer + verticalOffset + xOffsetIndex );
 224             uint8_t newAlpha = static_cast<uint8_t>( color->a * static_cast<float>( alpha ) );
 225
 226             // For any pixel overlapped with the pixel in previous glyphs, make sure we don't
 227             // overwrite a previous bigger alpha with a smaller alpha (in order to avoid
 228             // semi-transparent gaps between joint glyphs with overlapped pixels, which could
 229             // happen, for example, in the RTL text when we copy glyphs from right to left).
 230             *( bitmapBuffer + verticalOffset + xOffsetIndex ) = std::max( currentAlpha, newAlpha );
 231           }
 232         }
 233       }
 234     }
 235   }
 236 }
 237
 238 bool IsGlyphUnderlined( GlyphIndex index,
 239                          const Vector<GlyphRun>& underlineRuns )
 240 {
 241   for( Vector<GlyphRun>::ConstIterator it = underlineRuns.Begin(),
 242          endIt = underlineRuns.End();
 243          it != endIt;
 244        ++it )
 245   {
 246     const GlyphRun& run = *it;
 247
 248     if( ( run.glyphIndex <= index ) && ( index < run.glyphIndex + run.numberOfGlyphs ) )
 249     {
 250       return true;
 251     }
 252   }
 253
 254   return false;
 255 }
 256
 257 } // namespace
 258
 259 TypesetterPtr Typesetter::New( const ModelInterface* const model )
 260 {
 261   return TypesetterPtr( new Typesetter( model ) );
 262 }
 263
 264 ViewModel* Typesetter::GetViewModel()
 265 {
 266   return mModel;
 267 }
 268
 269 PixelData Typesetter::Render( const Vector2& size, RenderBehaviour behaviour, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat )
 270 {
 271   // @todo. This initial implementation for a TextLabel has only one visible page.
 272
 273   // Elides the text if needed.
 274   mModel->ElideGlyphs();
 275
 276   // Retrieves the layout size.
 277   const Size& layoutSize = mModel->GetLayoutSize();
 278
 279   // Set the offset for the vertical alignment.
 280   int penY = 0u;
 281
 282   switch( mModel->GetVerticalAlignment() )
 283   {
 284     case VerticalAlignment::TOP:
 285     {
 286       // No offset to add.
 287       break;
 288     }
 289     case VerticalAlignment::CENTER:
 290     {
 291       penY = static_cast<int>( 0.5f * ( size.height - layoutSize.height ) );
 292       break;
 293     }
 294     case VerticalAlignment::BOTTOM:
 295     {
 296       penY = static_cast<int>( size.height - layoutSize.height );
 297       break;
 298     }
 299   }
 300
 301   // Generate the image buffers of the text for each different style first,
 302   // then combine all of them together as one final image buffer. We try to
 303   // do all of these in CPU only, so that once the final texture is generated,
 304   // no calculation is needed in GPU during each frame.
 305
 306   const unsigned int bufferWidth = static_cast<unsigned int>( size.width );
 307   const unsigned int bufferHeight = static_cast<unsigned int>( size.height );
 308
 309   const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
 310   const unsigned int bufferSizeChar = 4u * bufferSizeInt;
 311
 312   Length numberOfGlyphs = mModel->GetNumberOfGlyphs();
 313
 314   Devel::PixelBuffer imageBuffer;
 315
 316   if( RENDER_MASK == behaviour )
 317   {
 318     // Generate the image buffer as an alpha mask for color glyphs.
 319     imageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_MASK, ignoreHorizontalAlignment, pixelFormat, penY, 0u, numberOfGlyphs - 1 );
 320   }
 321   else if( RENDER_NO_TEXT == behaviour )
 322   {
 323     // Generate an empty image buffer so that it can been combined with the image buffers for styles
 324     imageBuffer = Devel::PixelBuffer::New( bufferWidth, bufferHeight, Pixel::RGBA8888 );
 325     memset( imageBuffer.GetBuffer(), 0u, bufferSizeChar );
 326   }
 327   else
 328   {
 329     // Generate the image buffer for the text with no style.
 330     imageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_NONE, ignoreHorizontalAlignment, pixelFormat, penY, 0u, numberOfGlyphs -1 );
 331   }
 332
 333   if ( ( RENDER_NO_STYLES != behaviour ) && ( RENDER_MASK != behaviour ) )
 334   {
 335
 336     // Generate the outline if enabled
 337     const float outlineWidth = mModel->GetOutlineWidth();
 338     if ( outlineWidth > Math::MACHINE_EPSILON_1 )
 339     {
 340       // Create the image buffer for outline
 341       Devel::PixelBuffer outlineImageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_OUTLINE, ignoreHorizontalAlignment, pixelFormat, penY, 0u, numberOfGlyphs -1 );
 342
 343       // Combine the two buffers
 344       imageBuffer = CombineImageBuffer( imageBuffer, outlineImageBuffer, bufferWidth, bufferHeight );
 345     }
 346
 347     // @todo. Support shadow and underline for partial text later on.
 348
 349     // Generate the shadow if enabled
 350     const Vector2& shadowOffset = mModel->GetShadowOffset();
 351     if ( fabsf( shadowOffset.x ) > Math::MACHINE_EPSILON_1 || fabsf( shadowOffset.y ) > Math::MACHINE_EPSILON_1 )
 352     {
 353       // Create the image buffer for shadow
 354       Devel::PixelBuffer shadowImageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_SHADOW, ignoreHorizontalAlignment, pixelFormat, penY, 0u, numberOfGlyphs - 1 );
 355
 356       // Check whether it will be a soft shadow
 357       const float& blurRadius = mModel->GetShadowBlurRadius();
 358
 359       if ( blurRadius > Math::MACHINE_EPSILON_1 )
 360       {
 361         shadowImageBuffer.ApplyGaussianBlur( blurRadius );
 362       }
 363
 364       // Combine the two buffers
 365       imageBuffer = CombineImageBuffer( imageBuffer, shadowImageBuffer, bufferWidth, bufferHeight );
 366     }
 367
 368     // Generate the underline if enabled
 369     const bool underlineEnabled = mModel->IsUnderlineEnabled();
 370     if ( underlineEnabled )
 371     {
 372       // Create the image buffer for underline
 373       Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer( bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, penY, 0u, numberOfGlyphs - 1 );
 374
 375       // Combine the two buffers
 376       imageBuffer = CombineImageBuffer( imageBuffer, underlineImageBuffer, bufferWidth, bufferHeight );
 377     }
 378   }
 379
 380   // Create the final PixelData for the combined image buffer
 381   PixelData pixelData = Devel::PixelBuffer::Convert( imageBuffer );
 382
 383   return pixelData;
 384 }
 385
 386 Devel::PixelBuffer Typesetter::CreateImageBuffer( const unsigned int bufferWidth, const unsigned int bufferHeight, Typesetter::Style style, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int verticalOffset, GlyphIndex fromGlyphIndex, GlyphIndex toGlyphIndex )
 387 {
 388   // Retrieve lines, glyphs, positions and colors from the view model.
 389   const Length modelNumberOfLines = mModel->GetNumberOfLines();
 390   const LineRun* const modelLinesBuffer = mModel->GetLines();
 391   const Length numberOfGlyphs = mModel->GetNumberOfGlyphs();
 392   const GlyphInfo* const glyphsBuffer = mModel->GetGlyphs();
 393   const Vector2* const positionBuffer = mModel->GetLayout();
 394   const Vector4* const colorsBuffer = mModel->GetColors();
 395   const ColorIndex* const colorIndexBuffer = mModel->GetColorIndices();
 396
 397   // Whether to use the default color.
 398   const bool useDefaultColor = ( NULL == colorsBuffer );
 399   const Vector4& defaultColor = mModel->GetDefaultColor();
 400
 401   // Create and initialize the pixel buffer.
 402   GlyphData glyphData;
 403   glyphData.verticalOffset = verticalOffset;
 404   glyphData.width = bufferWidth;
 405   glyphData.height = bufferHeight;
 406   glyphData.bitmapBuffer = Devel::PixelBuffer::New( bufferWidth, bufferHeight, pixelFormat );
 407   glyphData.horizontalOffset = 0;
 408
 409   if ( Pixel::RGBA8888 == pixelFormat )
 410   {
 411     const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
 412     const unsigned int bufferSizeChar = 4u * bufferSizeInt;
 413     memset( glyphData.bitmapBuffer.GetBuffer(), 0u, bufferSizeChar );
 414   }
 415   else
 416   {
 417     memset( glyphData.bitmapBuffer.GetBuffer(), 0, bufferWidth * bufferHeight );
 418   }
 419
 420   // Get a handle of the font client. Used to retrieve the bitmaps of the glyphs.
 421   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 422
 423   // Traverses the lines of the text.
 424   for( LineIndex lineIndex = 0u; lineIndex < modelNumberOfLines; ++lineIndex )
 425   {
 426     const LineRun& line = *( modelLinesBuffer + lineIndex );
 427
 428     // Sets the horizontal offset of the line.
 429     glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int>( line.alignmentOffset );
 430
 431     // Increases the vertical offset with the line's ascender.
 432     glyphData.verticalOffset += static_cast<int>( line.ascender );
 433
 434     // Retrieves the glyph's outline width
 435     float outlineWidth = mModel->GetOutlineWidth();
 436
 437     if( style == Typesetter::STYLE_OUTLINE )
 438     {
 439       glyphData.horizontalOffset -= outlineWidth;
 440       if( lineIndex == 0u )
 441       {
 442         // Only need to add the vertical outline offset for the first line
 443         glyphData.verticalOffset -= outlineWidth;
 444       }
 445     }
 446     else if ( style == Typesetter::STYLE_SHADOW )
 447     {
 448       const Vector2& shadowOffset = mModel->GetShadowOffset();
 449       glyphData.horizontalOffset += shadowOffset.x - outlineWidth; // if outline enabled then shadow should offset from outline
 450
 451       if ( lineIndex == 0u )
 452       {
 453         // Only need to add the vertical shadow offset for first line
 454         glyphData.verticalOffset += shadowOffset.y - outlineWidth;
 455       }
 456     }
 457
 458     const bool underlineEnabled = mModel->IsUnderlineEnabled();
 459     const Vector4& underlineColor = mModel->GetUnderlineColor();
 460     const float underlineHeight = mModel->GetUnderlineHeight();
 461
 462     // Get the underline runs.
 463     const Length numberOfUnderlineRuns = mModel->GetNumberOfUnderlineRuns();
 464     Vector<GlyphRun> underlineRuns;
 465     underlineRuns.Resize( numberOfUnderlineRuns );
 466     mModel->GetUnderlineRuns( underlineRuns.Begin(), 0u, numberOfUnderlineRuns );
 467
 468     bool thereAreUnderlinedGlyphs = false;
 469
 470     float currentUnderlinePosition = 0.0f;
 471     float currentUnderlineThickness = underlineHeight;
 472     float maxUnderlineThickness = currentUnderlineThickness;
 473
 474     FontId lastUnderlinedFontId = 0;
 475
 476     float lineExtentLeft = bufferWidth;
 477     float lineExtentRight = 0.0f;
 478     float baseline = 0.0f;
 479
 480     // Traverses the glyphs of the line.
 481     const GlyphIndex endGlyphIndex = std::min( numberOfGlyphs, line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs );
 482     for( GlyphIndex glyphIndex = line.glyphRun.glyphIndex; glyphIndex < endGlyphIndex; ++glyphIndex )
 483     {
 484       if ( glyphIndex < fromGlyphIndex || glyphIndex > toGlyphIndex )
 485       {
 486         // Ignore any glyph that out of the specified range
 487         continue;
 488       }
 489
 490       // Retrieve the glyph's info.
 491       const GlyphInfo* const glyphInfo = glyphsBuffer + glyphIndex;
 492
 493       if( ( glyphInfo->width < Math::MACHINE_EPSILON_1000 ) ||
 494           ( glyphInfo->height < Math::MACHINE_EPSILON_1000 ) )
 495       {
 496         // Nothing to do if the glyph's width or height is zero.
 497         continue;
 498       }
 499
 500       const bool underlineGlyph = underlineEnabled || IsGlyphUnderlined( glyphIndex, underlineRuns );
 501       thereAreUnderlinedGlyphs = thereAreUnderlinedGlyphs || underlineGlyph;
 502
 503       // Are we still using the same fontId as previous
 504       if( underlineGlyph && ( glyphInfo->fontId != lastUnderlinedFontId ) )
 505       {
 506         // We need to fetch fresh font underline metrics
 507         FontMetrics fontMetrics;
 508         fontClient.GetFontMetrics( glyphInfo->fontId, fontMetrics );
 509         currentUnderlinePosition = ceil( fabsf( fontMetrics.underlinePosition ) );
 510         const float descender = ceil( fabsf( fontMetrics.descender ) );
 511
 512         if( fabsf( underlineHeight ) < Math::MACHINE_EPSILON_1000 )
 513         {
 514           currentUnderlineThickness = fontMetrics.underlineThickness;
 515
 516           // Ensure underline will be at least a pixel high
 517           if ( currentUnderlineThickness < 1.0f )
 518           {
 519             currentUnderlineThickness = 1.0f;
 520           }
 521           else
 522           {
 523             currentUnderlineThickness = ceil( currentUnderlineThickness );
 524           }
 525         }
 526
 527         // The underline thickness should be the max underline thickness of all glyphs of the line.
 528         if ( currentUnderlineThickness > maxUnderlineThickness )
 529         {
 530           maxUnderlineThickness = currentUnderlineThickness;
 531         }
 532
 533         // Clamp the underline position at the font descender and check for ( as EFL describes it ) a broken font
 534         if( currentUnderlinePosition > descender )
 535         {
 536           currentUnderlinePosition = descender;
 537         }
 538
 539         if( fabsf( currentUnderlinePosition ) < Math::MACHINE_EPSILON_1000 )
 540         {
 541           // Move offset down by one ( EFL behavior )
 542           currentUnderlinePosition = 1.0f;
 543         }
 544
 545         lastUnderlinedFontId = glyphInfo->fontId;
 546       } // underline
 547
 548       // Retrieves the glyph's position.
 549       const Vector2* const position = positionBuffer + glyphIndex;
 550       if ( baseline < position->y + glyphInfo->yBearing )
 551       {
 552         baseline = position->y + glyphInfo->yBearing;
 553       }
 554
 555       // Calculate the positions of leftmost and rightmost glyphs in the current line
 556       if ( position->x < lineExtentLeft)
 557       {
 558         lineExtentLeft = position->x;
 559       }
 560
 561       if ( position->x + glyphInfo->width > lineExtentRight)
 562       {
 563         lineExtentRight = position->x + glyphInfo->width;
 564       }
 565
 566       // Retrieves the glyph's color.
 567       const ColorIndex colorIndex = *( colorIndexBuffer + glyphIndex );
 568
 569       const Vector4* color;
 570       if ( style == Typesetter::STYLE_SHADOW )
 571       {
 572         color = &( mModel->GetShadowColor() );
 573       }
 574       else if ( style == Typesetter::STYLE_OUTLINE )
 575       {
 576         color = &( mModel->GetOutlineColor() );
 577       }
 578       else
 579       {
 580         color = ( useDefaultColor || ( 0u == colorIndex ) ) ? &defaultColor : colorsBuffer + ( colorIndex - 1u );
 581       }
 582
 583       // Retrieves the glyph's bitmap.
 584       glyphData.glyphBitmap.buffer = NULL;
 585       glyphData.glyphBitmap.width = glyphInfo->width;   // Desired width and height.
 586       glyphData.glyphBitmap.height = glyphInfo->height;
 587
 588       if( style != Typesetter::STYLE_OUTLINE && style != Typesetter::STYLE_SHADOW )
 589       {
 590         // Don't render outline for other styles
 591         outlineWidth = 0.0f;
 592       }
 593
 594       fontClient.CreateBitmap( glyphInfo->fontId,
 595                                glyphInfo->index,
 596                                glyphData.glyphBitmap,
 597                                outlineWidth );
 598
 599       // Sets the glyph's bitmap into the bitmap of the whole text.
 600       if( NULL != glyphData.glyphBitmap.buffer )
 601       {
 602         TypesetGlyph( glyphData,
 603                       position,
 604                       color,
 605                       style,
 606                       pixelFormat);
 607         // delete the glyphBitmap.buffer as it is now copied into glyphData.bitmapBuffer
 608         delete []glyphData.glyphBitmap.buffer;
 609         glyphData.glyphBitmap.buffer = NULL;
 610       }
 611     }
 612
 613     // Draw the underline from the leftmost glyph to the rightmost glyph
 614     if ( thereAreUnderlinedGlyphs && style == Typesetter::STYLE_UNDERLINE )
 615     {
 616       int underlineYOffset = glyphData.verticalOffset + baseline + currentUnderlinePosition;
 617
 618       for( unsigned int y = underlineYOffset; y < underlineYOffset + maxUnderlineThickness; y++ )
 619       {
 620         if( y > bufferHeight - 1 )
 621         {
 622           // Do not write out of bounds.
 623           break;
 624         }
 625
 626         for( unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++ )
 627         {
 628           if( x > bufferWidth - 1 )
 629           {
 630             // Do not write out of bounds.
 631             break;
 632           }
 633
 634           // Always RGBA image for text with styles
 635           uint32_t* bitmapBuffer = reinterpret_cast< uint32_t* >( glyphData.bitmapBuffer.GetBuffer() );
 636           uint32_t underlinePixel = *( bitmapBuffer + y * glyphData.width + x );
 637           uint8_t* underlinePixelBuffer = reinterpret_cast<uint8_t*>( &underlinePixel );
 638
 639           // Write the underline color to the pixel buffer
 640           *( underlinePixelBuffer ) = static_cast<uint8_t>( underlineColor.r * 255.f );
 641           *( underlinePixelBuffer + 1u ) = static_cast<uint8_t>( underlineColor.g * 255.f );
 642           *( underlinePixelBuffer + 2u ) = static_cast<uint8_t>( underlineColor.b * 255.f );
 643           *( underlinePixelBuffer + 3u ) = static_cast<uint8_t>( underlineColor.a * 255.f );
 644
 645           *( bitmapBuffer + y * glyphData.width + x ) = underlinePixel;
 646         }
 647       }
 648     }
 649
 650     // Increases the vertical offset with the line's descender.
 651     glyphData.verticalOffset += static_cast<int>( -line.descender );
 652   }
 653
 654   return glyphData.bitmapBuffer;
 655 }
 656
 657 Devel::PixelBuffer Typesetter::CombineImageBuffer( Devel::PixelBuffer topPixelBuffer, Devel::PixelBuffer bottomPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight )
 658 {
 659   unsigned char* topBuffer = topPixelBuffer.GetBuffer();
 660   unsigned char* bottomBuffer = bottomPixelBuffer.GetBuffer();
 661
 662   Devel::PixelBuffer combinedPixelBuffer;
 663
 664   if ( topBuffer == NULL && bottomBuffer == NULL )
 665   {
 666     // Nothing to do if both buffers are empty.
 667     return combinedPixelBuffer;
 668   }
 669
 670   if ( topBuffer == NULL )
 671   {
 672     // Nothing to do if topBuffer is empty.
 673     return bottomPixelBuffer;
 674   }
 675
 676   if ( bottomBuffer == NULL )
 677   {
 678     // Nothing to do if bottomBuffer is empty.
 679     return topPixelBuffer;
 680   }
 681
 682   // Always combine two RGBA images
 683   const unsigned int bufferSizeInt = bufferWidth * bufferHeight;
 684   const unsigned int bufferSizeChar = 4u * bufferSizeInt;
 685
 686   combinedPixelBuffer = Devel::PixelBuffer::New( bufferWidth, bufferHeight, Pixel::RGBA8888 );
 687   uint8_t* combinedBuffer = reinterpret_cast< uint8_t* >( combinedPixelBuffer.GetBuffer() );
 688   memset( combinedBuffer, 0u, bufferSizeChar );
 689
 690   for (unsigned int pixelIndex = 0; pixelIndex < bufferSizeInt; pixelIndex++)
 691   {
 692     // If the alpha of the pixel in either buffer is not fully opaque, blend the two pixels.
 693     // Otherwise, copy pixel from topBuffer to combinedBuffer.
 694
 695     unsigned int alphaBuffer1 = topBuffer[pixelIndex*4+3];
 696     unsigned int alphaBuffer2 = bottomBuffer[pixelIndex*4+3];
 697
 698     if ( alphaBuffer1 != 255 || alphaBuffer2 != 255 )
 699     {
 700       // At least one pixel is not fully opaque
 701       // "Over" blend the the pixel from topBuffer with the pixel in bottomBuffer
 702       combinedBuffer[pixelIndex*4] = ( topBuffer[pixelIndex*4] * topBuffer[pixelIndex*4+3] / 255 ) + ( bottomBuffer[pixelIndex*4] * bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / ( 255*255 ) );
 703       combinedBuffer[pixelIndex*4+1] = ( topBuffer[pixelIndex*4+1] * topBuffer[pixelIndex*4+3] / 255 ) + ( bottomBuffer[pixelIndex*4+1] * bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / ( 255*255 ) );
 704       combinedBuffer[pixelIndex*4+2] = ( topBuffer[pixelIndex*4+2] * topBuffer[pixelIndex*4+3] / 255 ) + ( bottomBuffer[pixelIndex*4+2] * bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / ( 255*255 ) );
 705       combinedBuffer[pixelIndex*4+3] = topBuffer[pixelIndex*4+3] + ( bottomBuffer[pixelIndex*4+3] * ( 255 - topBuffer[pixelIndex*4+3] ) / 255 );
 706     }
 707     else
 708     {
 709       // Copy the pixel from topBuffer to combinedBuffer
 710       combinedBuffer[pixelIndex*4] = topBuffer[pixelIndex*4];
 711       combinedBuffer[pixelIndex*4+1] = topBuffer[pixelIndex*4+1];
 712       combinedBuffer[pixelIndex*4+2] = topBuffer[pixelIndex*4+2];
 713       combinedBuffer[pixelIndex*4+3] = topBuffer[pixelIndex*4+3];
 714     }
 715   }
 716
 717   return combinedPixelBuffer;
 718 }
 719
 720 Typesetter::Typesetter( const ModelInterface* const model )
 721 : mModel( new ViewModel( model ) )
 722 {
 723 }
 724
 725 Typesetter::~Typesetter()
 726 {
 727   delete mModel;
 728 }
 729
 730 } // namespace Text
 731
 732 } // namespace Toolkit
 733
 734 } // namespace Dali