Fix for text renderer. Set the right size in order to cull the actor correctly.
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-view.cpp
index ea074fa..caee1f8 100644 (file)
@@ -65,6 +65,16 @@ const Vector2& View::GetControlSize() const
   return Vector2::ZERO;
 }
 
+const Vector2& View::GetActualSize() const
+{
+  if ( mImpl->mVisualModel )
+  {
+    return mImpl->mVisualModel->GetActualSize();
+  }
+
+  return Vector2::ZERO;
+}
+
 Length View::GetNumberOfGlyphs() const
 {
   if( mImpl->mVisualModel )
@@ -84,6 +94,7 @@ Length View::GetNumberOfGlyphs() const
 
 Length View::GetGlyphs( GlyphInfo* glyphs,
                         Vector2* glyphPositions,
+                        Vector4* glyphColors,
                         GlyphIndex glyphIndex,
                         Length numberOfGlyphs ) const
 {
@@ -110,152 +121,179 @@ Length View::GetGlyphs( GlyphInfo* glyphs,
         numberOfLaidOutGlyphs = numberOfGlyphs;
       }
 
-      // Retrieve from the visual model the glyphs and positions.
-      mImpl->mVisualModel->GetGlyphs( glyphs,
-                                      glyphIndex,
-                                      numberOfLaidOutGlyphs );
-
-      mImpl->mVisualModel->GetGlyphPositions( glyphPositions,
-                                              glyphIndex,
-                                              numberOfLaidOutGlyphs );
-
-      // Get the lines for the given range of glyphs.
-      // The lines contain the alignment offset which needs to be added to the glyph's position.
-      LineIndex firstLine = 0u;
-      Length numberOfLines = 0u;
-      mImpl->mVisualModel->GetNumberOfLines( glyphIndex,
-                                             numberOfLaidOutGlyphs,
-                                             firstLine,
-                                             numberOfLines );
-
-      Vector<LineRun> lines;
-      lines.Resize( numberOfLines );
-      LineRun* lineBuffer = lines.Begin();
-
-      mImpl->mVisualModel->GetLinesOfGlyphRange( lineBuffer,
-                                                 glyphIndex,
-                                                 numberOfLaidOutGlyphs );
-
-      // Get the first line for the given glyph range.
-      LineIndex lineIndex = firstLine;
-      LineRun* line = lineBuffer + lineIndex;
-
-      // Index of the last glyph of the line.
-      GlyphIndex lastGlyphIndexOfLine = line->glyphRun.glyphIndex + line->glyphRun.numberOfGlyphs - 1u;
-
-      // Add the alignment offset to the glyph's position.
-      for( Length index = 0u; index < numberOfLaidOutGlyphs; ++index )
+      if( 0u < numberOfLaidOutGlyphs )
       {
-        ( *( glyphPositions + index ) ).x += line->alignmentOffset;
-
-        if( lastGlyphIndexOfLine == index )
+        // Retrieve from the visual model the glyphs and positions.
+        mImpl->mVisualModel->GetGlyphs( glyphs,
+                                        glyphIndex,
+                                        numberOfLaidOutGlyphs );
+
+        mImpl->mVisualModel->GetGlyphPositions( glyphPositions,
+                                                glyphIndex,
+                                                numberOfLaidOutGlyphs );
+
+        // Set the colors.
+        const GlyphIndex lastLaidOutGlyphIndex = glyphIndex + numberOfLaidOutGlyphs;
+
+        for( Vector<ColorGlyphRun>::ConstIterator it = mImpl->mVisualModel->mColorRuns.Begin(),
+               endIt = mImpl->mVisualModel->mColorRuns.End();
+             it != endIt;
+             ++it )
         {
-          // Get the next line.
-          ++lineIndex;
+          const ColorGlyphRun& colorGlyphRun = *it;
+          const GlyphIndex lastGlyphIndex = colorGlyphRun.glyphRun.glyphIndex + colorGlyphRun.glyphRun.numberOfGlyphs;
 
-          if( lineIndex < numberOfLines )
+          if( ( colorGlyphRun.glyphRun.glyphIndex < lastLaidOutGlyphIndex ) &&
+              ( glyphIndex < lastGlyphIndex ) )
           {
-            line = lineBuffer + lineIndex;
-            lastGlyphIndexOfLine = line->glyphRun.glyphIndex + line->glyphRun.numberOfGlyphs - 1u;
+            for( GlyphIndex index = glyphIndex < colorGlyphRun.glyphRun.glyphIndex ? colorGlyphRun.glyphRun.glyphIndex : glyphIndex,
+                   endIndex = lastLaidOutGlyphIndex < lastGlyphIndex ? lastLaidOutGlyphIndex : lastGlyphIndex;
+                 index < endIndex;
+                 ++index )
+            {
+              *( glyphColors + index - glyphIndex ) = colorGlyphRun.color;
+            }
           }
         }
-      }
 
-      if( 1u == numberOfLaidOutGlyphs )
-      {
-        // not a point try to do ellipsis with only one laid out character.
-        return numberOfLaidOutGlyphs;
-      }
+        // Get the lines for the given range of glyphs.
+        // The lines contain the alignment offset which needs to be added to the glyph's position.
+        LineIndex firstLine = 0u;
+        Length numberOfLines = 0u;
+        mImpl->mVisualModel->GetNumberOfLines( glyphIndex,
+                                               numberOfLaidOutGlyphs,
+                                               firstLine,
+                                               numberOfLines );
 
-      if( lastLine.ellipsis )
-      {
-        // firstPenX, penY and firstPenSet are used to position the ellipsis glyph if needed.
-        float firstPenX = 0.f; // Used if rtl text is elided.
-        float penY = 0.f;
-        bool firstPenSet = false;
-
-        // Add the ellipsis glyph.
-        bool inserted = false;
-        float removedGlypsWidth = 0.f;
-        Length numberOfRemovedGlyphs = 0u;
-        GlyphIndex index = numberOfLaidOutGlyphs - 1u;
-
-        // The ellipsis glyph has to fit in the place where the last glyph(s) is(are) removed.
-        while( !inserted )
+        Vector<LineRun> lines;
+        lines.Resize( numberOfLines );
+        LineRun* lineBuffer = lines.Begin();
+
+        mImpl->mVisualModel->GetLinesOfGlyphRange( lineBuffer,
+                                                   glyphIndex,
+                                                   numberOfLaidOutGlyphs );
+
+        // Get the first line for the given glyph range.
+        LineIndex lineIndex = firstLine;
+        LineRun* line = lineBuffer + lineIndex;
+
+        // Index of the last glyph of the line.
+        GlyphIndex lastGlyphIndexOfLine = line->glyphRun.glyphIndex + line->glyphRun.numberOfGlyphs - 1u;
+
+        // Add the alignment offset to the glyph's position.
+        for( Length index = 0u; index < numberOfLaidOutGlyphs; ++index )
         {
-          const GlyphInfo& glyphToRemove = *( glyphs + index );
+          ( *( glyphPositions + index ) ).x += line->alignmentOffset;
 
-          if( 0u != glyphToRemove.fontId )
+          if( lastGlyphIndexOfLine == index )
           {
-            // i.e. The font id of the glyph shaped from the '\n' character is zero.
+            // Get the next line.
+            ++lineIndex;
+
+            if( lineIndex < numberOfLines )
+            {
+              line = lineBuffer + lineIndex;
+              lastGlyphIndexOfLine = line->glyphRun.glyphIndex + line->glyphRun.numberOfGlyphs - 1u;
+            }
+          }
+        }
 
-            // Need to reshape the glyph as the font may be different in size.
-            const GlyphInfo& ellipsisGlyph = mImpl->mFontClient.GetEllipsisGlyph( mImpl->mFontClient.GetPointSize( glyphToRemove.fontId ) );
+        if( 1u == numberOfLaidOutGlyphs )
+        {
+          // not a point try to do ellipsis with only one laid out character.
+          return numberOfLaidOutGlyphs;
+        }
 
-            if( !firstPenSet )
+        if( lastLine.ellipsis )
+        {
+          // firstPenX, penY and firstPenSet are used to position the ellipsis glyph if needed.
+          float firstPenX = 0.f; // Used if rtl text is elided.
+          float penY = 0.f;
+          bool firstPenSet = false;
+
+          // Add the ellipsis glyph.
+          bool inserted = false;
+          float removedGlypsWidth = 0.f;
+          Length numberOfRemovedGlyphs = 0u;
+          GlyphIndex index = numberOfLaidOutGlyphs - 1u;
+
+          // The ellipsis glyph has to fit in the place where the last glyph(s) is(are) removed.
+          while( !inserted )
+          {
+            const GlyphInfo& glyphToRemove = *( glyphs + index );
+
+            if( 0u != glyphToRemove.fontId )
             {
-              const Vector2& position = *( glyphPositions + index );
+              // i.e. The font id of the glyph shaped from the '\n' character is zero.
 
-              // Calculates the penY of the current line. It will be used to position the ellipsis glyph.
-              penY = position.y + glyphToRemove.yBearing;
+              // Need to reshape the glyph as the font may be different in size.
+              const GlyphInfo& ellipsisGlyph = mImpl->mFontClient.GetEllipsisGlyph( mImpl->mFontClient.GetPointSize( glyphToRemove.fontId ) );
 
-              // Calculates the first penX which will be used if rtl text is elided.
-              firstPenX = position.x - glyphToRemove.xBearing;
-              if( firstPenX < -ellipsisGlyph.xBearing )
+              if( !firstPenSet )
               {
-                // Avoids to exceed the bounding box when rtl text is elided.
-                firstPenX = -ellipsisGlyph.xBearing;
-              }
+                const Vector2& position = *( glyphPositions + index );
 
-              removedGlypsWidth = -ellipsisGlyph.xBearing;
+                // Calculates the penY of the current line. It will be used to position the ellipsis glyph.
+                penY = position.y + glyphToRemove.yBearing;
 
-              firstPenSet = true;
-            }
+                // Calculates the first penX which will be used if rtl text is elided.
+                firstPenX = position.x - glyphToRemove.xBearing;
+                if( firstPenX < -ellipsisGlyph.xBearing )
+                {
+                  // Avoids to exceed the bounding box when rtl text is elided.
+                  firstPenX = -ellipsisGlyph.xBearing;
+                }
 
-            removedGlypsWidth += std::min( glyphToRemove.advance, ( glyphToRemove.xBearing + glyphToRemove.width ) );
+                removedGlypsWidth = -ellipsisGlyph.xBearing;
 
-            // Calculate the width of the ellipsis glyph and check if it fits.
-            const float ellipsisGlyphWidth = ellipsisGlyph.width + ellipsisGlyph.xBearing;
-            if( ellipsisGlyphWidth < removedGlypsWidth )
-            {
-              GlyphInfo& glyphInfo = *( glyphs + index );
-              Vector2& position = *( glyphPositions + index );
-              position.x -= ( 0.f > glyphInfo.xBearing ) ? glyphInfo.xBearing : 0.f;
-
-              // Replace the glyph by the ellipsis glyph.
-              glyphInfo = ellipsisGlyph;
+                firstPenSet = true;
+              }
 
-              // Change the 'x' and 'y' position of the ellipsis glyph.
+              removedGlypsWidth += std::min( glyphToRemove.advance, ( glyphToRemove.xBearing + glyphToRemove.width ) );
 
-              if( position.x > firstPenX )
+              // Calculate the width of the ellipsis glyph and check if it fits.
+              const float ellipsisGlyphWidth = ellipsisGlyph.width + ellipsisGlyph.xBearing;
+              if( ellipsisGlyphWidth < removedGlypsWidth )
               {
-                position.x = firstPenX + removedGlypsWidth - ellipsisGlyphWidth;
-              }
+                GlyphInfo& glyphInfo = *( glyphs + index );
+                Vector2& position = *( glyphPositions + index );
+                position.x -= ( 0.f > glyphInfo.xBearing ) ? glyphInfo.xBearing : 0.f;
 
-              position.x += ellipsisGlyph.xBearing;
-              position.y = penY - ellipsisGlyph.yBearing;
+                // Replace the glyph by the ellipsis glyph.
+                glyphInfo = ellipsisGlyph;
 
-              inserted = true;
-            }
-          }
+                // Change the 'x' and 'y' position of the ellipsis glyph.
 
-          if( !inserted )
-          {
-            if( index > 0u )
-            {
-              --index;
+                if( position.x > firstPenX )
+                {
+                  position.x = firstPenX + removedGlypsWidth - ellipsisGlyphWidth;
+                }
+
+                position.x += ellipsisGlyph.xBearing;
+                position.y = penY - ellipsisGlyph.yBearing;
+
+                inserted = true;
+              }
             }
-            else
+
+            if( !inserted )
             {
-              // No space for the ellipsis.
-              inserted = true;
+              if( index > 0u )
+              {
+                --index;
+              }
+              else
+              {
+                // No space for the ellipsis.
+                inserted = true;
+              }
+              ++numberOfRemovedGlyphs;
             }
-            ++numberOfRemovedGlyphs;
           }
-        }
 
-        // 'Removes' all the glyphs after the ellipsis glyph.
-        numberOfLaidOutGlyphs -= numberOfRemovedGlyphs;
+          // 'Removes' all the glyphs after the ellipsis glyph.
+          numberOfLaidOutGlyphs -= numberOfRemovedGlyphs;
+        }
       }
     }
   }