X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Ftext-view.cpp;h=9e8d0bee9d71bba392a737965bfe2b6dd216038c;hp=976635a350a971d5145740dcffb720c6a3dfa5cb;hb=3a23cbcd64ab5780928e4a141e497242c9989110;hpb=2071317d301e9d5af326a3a2efcd2996263fbead

diff --git a/dali-toolkit/internal/text/text-view.cpp b/dali-toolkit/internal/text/text-view.cpp
index 976635a..9e8d0be 100644
--- a/dali-toolkit/internal/text/text-view.cpp
+++ b/dali-toolkit/internal/text/text-view.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55,8 +55,46 @@ void View::SetVisualModel( VisualModelPtr visualModel )
   mImpl->mVisualModel = visualModel;
 }
 
+const Vector2& View::GetControlSize() const
+{
+  if ( mImpl->mVisualModel )
+  {
+    return mImpl->mVisualModel->mControlSize;
+  }
+
+  return Vector2::ZERO;
+}
+
+const Vector2& View::GetLayoutSize() const
+{
+  if ( mImpl->mVisualModel )
+  {
+    return mImpl->mVisualModel->GetLayoutSize();
+  }
+
+  return Vector2::ZERO;
+}
+
+Length View::GetNumberOfGlyphs() const
+{
+  if( mImpl->mVisualModel )
+  {
+    const VisualModel& model = *mImpl->mVisualModel;
+
+    const Length glyphCount = model.mGlyphs.Count();
+    const Length positionCount = model.mGlyphPositions.Count();
+
+    DALI_ASSERT_DEBUG( positionCount <= glyphCount && "Invalid glyph positions in Model" );
+
+    return (positionCount < glyphCount) ? positionCount : glyphCount;
+  }
+
+  return 0;
+}
+
 Length View::GetGlyphs( GlyphInfo* glyphs,
                         Vector2* glyphPositions,
+                        float& minLineOffset,
                         GlyphIndex glyphIndex,
                         Length numberOfGlyphs ) const
 {
@@ -67,7 +105,7 @@ Length View::GetGlyphs( GlyphInfo* glyphs,
     // If ellipsis is enabled, the number of glyphs the layout engine has laid out may be less than 'numberOfGlyphs'.
     // Check the last laid out line to know if the layout engine elided some text.
 
-    const Length numberOfLines = mImpl->mVisualModel->GetNumberOfLines();
+    const Length numberOfLines = mImpl->mVisualModel->mLines.Count();
     if( numberOfLines > 0u )
     {
       const LineRun& lastLine = *( mImpl->mVisualModel->mLines.Begin() + ( numberOfLines - 1u ) );
@@ -76,111 +114,191 @@ Length View::GetGlyphs( GlyphInfo* glyphs,
       // Otherwise use the given number of glyphs.
       if( lastLine.ellipsis )
       {
-        numberOfLaidOutGlyphs = lastLine.glyphIndex + lastLine.numberOfGlyphs;
+        numberOfLaidOutGlyphs = lastLine.glyphRun.glyphIndex + lastLine.glyphRun.numberOfGlyphs;
       }
       else
       {
         numberOfLaidOutGlyphs = numberOfGlyphs;
       }
 
-      // Retrieve from the visual model the glyphs and positions.
-      mImpl->mVisualModel->GetGlyphs( glyphs,
-                                      glyphIndex,
-                                      numberOfLaidOutGlyphs );
-
-      mImpl->mVisualModel->GetGlyphPositions( glyphPositions,
-                                              glyphIndex,
-                                              numberOfLaidOutGlyphs );
-
-      if( 1u == numberOfLaidOutGlyphs )
+      if( 0u < numberOfLaidOutGlyphs )
       {
-        // not a point try to do ellipsis with only one laid out character.
-        return numberOfLaidOutGlyphs;
-      }
-
-      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 )
+        // 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.
+
+        minLineOffset = line->alignmentOffset;
+        float penY = line->ascender;
+        for( Length index = 0u; index < numberOfLaidOutGlyphs; ++index )
         {
-          const GlyphInfo& glyphToRemove = *( glyphs + index );
+          Vector2& position =  *( glyphPositions + index );
+          position.x += line->alignmentOffset;
+          position.y += penY;
 
-          // 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( !firstPenSet )
+          if( lastGlyphIndexOfLine == index )
           {
-            const Vector2& position = *( glyphPositions + index );
+            penY += -line->descender;
 
-            // Calculates the penY of the current line. It will be used to position the ellipsis glyph.
-            penY = position.y + glyphToRemove.yBearing;
+            // Get the next line.
+            ++lineIndex;
 
-            // Calculates the first penX which will be used if rtl text is elided.
-            firstPenX = position.x - glyphToRemove.xBearing;
-            if( firstPenX < -ellipsisGlyph.xBearing )
+            if( lineIndex < numberOfLines )
             {
-              // Avoids to exceed the bounding box when rtl text is elided.
-              firstPenX = -ellipsisGlyph.xBearing;
-            }
+              line = lineBuffer + lineIndex;
+              minLineOffset = std::min( minLineOffset, line->alignmentOffset );
 
-            removedGlypsWidth = -ellipsisGlyph.xBearing;
+              lastGlyphIndexOfLine = line->glyphRun.glyphIndex + line->glyphRun.numberOfGlyphs - 1u;
 
-            firstPenSet = true;
+              penY += line->ascender;
+            }
           }
+        }
 
-          removedGlypsWidth += std::min( glyphToRemove.advance, ( glyphToRemove.xBearing + glyphToRemove.width ) );
+        if( 1u == numberOfLaidOutGlyphs )
+        {
+          // not a point try to do ellipsis with only one laid out character.
+          return numberOfLaidOutGlyphs;
+        }
 
-          // Calculate the width of the ellipsis glyph and check if it fits.
-          const float ellipsisGlyphWidth = ellipsisGlyph.width + ellipsisGlyph.xBearing;
-          if( ellipsisGlyphWidth < removedGlypsWidth )
+        if( lastLine.ellipsis )
+        {
+          if( ( 1u == numberOfLines ) &&
+              ( lastLine.ascender - lastLine.descender > mImpl->mVisualModel->mControlSize.height ) )
           {
-            GlyphInfo& glyphInfo = *( glyphs + index );
-            Vector2& position = *( glyphPositions + index );
-            position.x -= glyphInfo.xBearing;
+            // Get the first glyph which is going to be replaced and the ellipsis glyph.
+            GlyphInfo& glyphInfo = *glyphs;
+            const GlyphInfo& ellipsisGlyph = mImpl->mFontClient.GetEllipsisGlyph( mImpl->mFontClient.GetPointSize( glyphInfo.fontId ) );
+
+            // Change the 'x' and 'y' position of the ellipsis glyph.
+            Vector2& position = *glyphPositions;
+            position.x = ellipsisGlyph.xBearing;
+            position.y = mImpl->mVisualModel->mControlSize.height - ellipsisGlyph.yBearing;
 
             // Replace the glyph by the ellipsis glyph.
             glyphInfo = ellipsisGlyph;
 
-            // Change the 'x' and 'y' position of the ellipsis glyph.
+             return 1u;
+          }
 
-            if( position.x > firstPenX )
-            {
-              position.x = firstPenX + removedGlypsWidth - ellipsisGlyphWidth;
-            }
+          // 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;
 
-            position.x += ellipsisGlyph.xBearing;
-            position.y = penY - ellipsisGlyph.yBearing;
+          // Add the ellipsis glyph.
+          bool inserted = false;
+          float removedGlypsWidth = 0.f;
+          Length numberOfRemovedGlyphs = 0u;
+          GlyphIndex index = numberOfLaidOutGlyphs - 1u;
 
-            inserted = true;
-          }
-          else
+          // The ellipsis glyph has to fit in the place where the last glyph(s) is(are) removed.
+          while( !inserted )
           {
-            if( index > 0u )
+            const GlyphInfo& glyphToRemove = *( glyphs + index );
+
+            if( 0u != glyphToRemove.fontId )
             {
-              --index;
+              // i.e. The font id of the glyph shaped from the '\n' character is zero.
+
+              // 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( !firstPenSet )
+              {
+                const Vector2& position = *( glyphPositions + index );
+
+                // Calculates the penY of the current line. It will be used to position the ellipsis glyph.
+                penY = position.y + glyphToRemove.yBearing;
+
+                // 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 = -ellipsisGlyph.xBearing;
+
+                firstPenSet = true;
+              }
+
+              removedGlypsWidth += std::min( glyphToRemove.advance, ( glyphToRemove.xBearing + glyphToRemove.width ) );
+
+              // 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;
+
+                // Change the 'x' and 'y' position of the ellipsis glyph.
+
+                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;
+        }
       }
     }
   }
@@ -188,81 +306,100 @@ Length View::GetGlyphs( GlyphInfo* glyphs,
   return numberOfLaidOutGlyphs;
 }
 
+const Vector4* const View::GetColors() const
+{
+  if( mImpl->mVisualModel )
+  {
+    return mImpl->mVisualModel->mColors.Begin();
+  }
+
+  return NULL;
+}
+
+const ColorIndex* const View::GetColorIndices() const
+{
+  if( mImpl->mVisualModel )
+  {
+    return mImpl->mVisualModel->mColorIndices.Begin();
+  }
+
+  return NULL;
+}
+
 const Vector4& View::GetTextColor() const
 {
-  if ( mImpl->mVisualModel )
+  if( mImpl->mVisualModel )
   {
-    VisualModel& model = *mImpl->mVisualModel;
-    return model.GetTextColor();
+    return mImpl->mVisualModel->GetTextColor();
   }
   return Vector4::ZERO;
 }
 
 const Vector2& View::GetShadowOffset() const
 {
-  if ( mImpl->mVisualModel )
+  if( mImpl->mVisualModel )
   {
-    VisualModel& model = *mImpl->mVisualModel;
-    return model.GetShadowOffset();
+    return mImpl->mVisualModel->GetShadowOffset();
   }
   return Vector2::ZERO;
 }
 
 const Vector4& View::GetShadowColor() const
 {
-  if ( mImpl->mVisualModel )
+  if( mImpl->mVisualModel )
   {
-    VisualModel& model = *mImpl->mVisualModel;
-    return model.GetShadowColor();
+    return mImpl->mVisualModel->GetShadowColor();
   }
   return Vector4::ZERO;
 }
 
 const Vector4& View::GetUnderlineColor() const
 {
-  if ( mImpl->mVisualModel )
+  if( mImpl->mVisualModel )
   {
-    VisualModel& model = *mImpl->mVisualModel;
-    return model.GetUnderlineColor();
+    return mImpl->mVisualModel->GetUnderlineColor();
   }
   return Vector4::ZERO;
 }
 
 bool View::IsUnderlineEnabled() const
 {
-  if ( mImpl->mVisualModel )
+  if( mImpl->mVisualModel )
   {
-    VisualModel& model = *mImpl->mVisualModel;
-    return model.IsUnderlineEnabled();
+    return mImpl->mVisualModel->IsUnderlineEnabled();
   }
   return false;
 }
 
 float View::GetUnderlineHeight() const
 {
-  if ( mImpl->mVisualModel )
+  if( mImpl->mVisualModel )
   {
-    VisualModel& model = *mImpl->mVisualModel;
-    return model.GetUnderlineHeight();
+    return mImpl->mVisualModel->GetUnderlineHeight();
   }
   return 0.0f;
 }
 
-Length View::GetNumberOfGlyphs() const
+Length View::GetNumberOfUnderlineRuns() const
 {
   if( mImpl->mVisualModel )
   {
-    VisualModel& model = *mImpl->mVisualModel;
-
-    Length glyphCount = model.GetNumberOfGlyphs();
-    Length positionCount = model.GetNumberOfGlyphPositions();
+    return mImpl->mVisualModel->GetNumberOfUnderlineRuns();
+  }
 
-    DALI_ASSERT_DEBUG( positionCount <= glyphCount && "Invalid glyph positions in Model" );
+  return 0u;
+}
 
-    return (positionCount < glyphCount) ? positionCount : glyphCount;
+void View::GetUnderlineRuns( GlyphRun* underlineRuns,
+                             UnderlineRunIndex index,
+                             Length numberOfRuns ) const
+{
+  if( mImpl->mVisualModel )
+  {
+    mImpl->mVisualModel->GetUnderlineRuns( underlineRuns,
+                                           index,
+                                           numberOfRuns );
   }
-
-  return 0;
 }
 
 } // namespace Text