Merge "Disable pixel alignment while scrolling the text" into devel/master
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / rendering / view-model.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/view-model.h>
20
21 // EXTERNAL INCLUDES
22 #include <memory.h>
23 #include <dali/devel-api/text-abstraction/font-client.h>
24
25 // INTERNAL INCLUDES
26 #include <dali-toolkit/internal/text/line-run.h>
27
28 namespace Dali
29 {
30
31 namespace Toolkit
32 {
33
34 namespace Text
35 {
36
37 ViewModel::ViewModel( const ModelInterface* const model )
38 : mModel( model ),
39   mElidedGlyphs(),
40   mElidedLayout(),
41   mIsTextElided( false )
42 {
43 }
44
45 ViewModel::~ViewModel()
46 {
47 }
48
49 const Size& ViewModel::GetControlSize() const
50 {
51   return mModel->GetControlSize();
52 }
53
54 const Size& ViewModel::GetLayoutSize() const
55 {
56   return mModel->GetLayoutSize();
57 }
58
59 const Vector2& ViewModel::GetScrollPosition() const
60 {
61   return mModel->GetScrollPosition();
62 }
63
64 HorizontalAlignment::Type ViewModel::GetHorizontalAlignment() const
65 {
66   return mModel->GetHorizontalAlignment();
67 }
68
69 VerticalAlignment::Type ViewModel::GetVerticalAlignment() const
70 {
71   return mModel->GetVerticalAlignment();
72 }
73
74 DevelText::VerticalLineAlignment::Type ViewModel::GetVerticalLineAlignment() const
75 {
76   return mModel->GetVerticalLineAlignment();
77 }
78
79 bool ViewModel::IsTextElideEnabled() const
80 {
81   return mModel->IsTextElideEnabled();
82 }
83
84 Length ViewModel::GetNumberOfLines() const
85 {
86   return mModel->GetNumberOfLines();
87 }
88
89 const LineRun* const ViewModel::GetLines() const
90 {
91   return mModel->GetLines();
92 }
93
94 Length ViewModel::GetNumberOfScripts() const
95 {
96   return mModel->GetNumberOfScripts();
97 }
98
99 const ScriptRun* const ViewModel::GetScriptRuns() const
100 {
101   return mModel->GetScriptRuns();
102 }
103
104 Length ViewModel::GetNumberOfGlyphs() const
105 {
106   if( mIsTextElided && mModel->IsTextElideEnabled() )
107   {
108      return mElidedGlyphs.Count();
109   }
110   else
111   {
112     return mModel->GetNumberOfGlyphs();
113   }
114
115   return 0u;
116 }
117
118 const GlyphInfo* const ViewModel::GetGlyphs() const
119 {
120   if( mIsTextElided && mModel->IsTextElideEnabled() )
121   {
122     return mElidedGlyphs.Begin();
123   }
124   else
125   {
126     return mModel->GetGlyphs();
127   }
128
129   return NULL;
130 }
131
132 const Vector2* const ViewModel::GetLayout() const
133 {
134   if( mIsTextElided && mModel->IsTextElideEnabled() )
135   {
136     return mElidedLayout.Begin();
137   }
138   else
139   {
140     return mModel->GetLayout();
141   }
142
143   return NULL;
144 }
145
146 const Vector4* const ViewModel::GetColors() const
147 {
148   return mModel->GetColors();
149 }
150
151 const ColorIndex* const ViewModel::GetColorIndices() const
152 {
153   return mModel->GetColorIndices();
154 }
155
156 const Vector4& ViewModel::GetDefaultColor() const
157 {
158   return mModel->GetDefaultColor();
159 }
160
161 const Vector2& ViewModel::GetShadowOffset() const
162 {
163   return mModel->GetShadowOffset();
164 }
165
166 const Vector4& ViewModel::GetShadowColor() const
167 {
168   return mModel->GetShadowColor();
169 }
170
171 const float& ViewModel::GetShadowBlurRadius() const
172 {
173   return mModel->GetShadowBlurRadius();
174 }
175
176 const Vector4& ViewModel::GetUnderlineColor() const
177 {
178   return mModel->GetUnderlineColor();
179 }
180
181 bool ViewModel::IsUnderlineEnabled() const
182 {
183   return mModel->IsUnderlineEnabled();
184 }
185
186 float ViewModel::GetUnderlineHeight() const
187 {
188   return mModel->GetUnderlineHeight();
189 }
190
191 Length ViewModel::GetNumberOfUnderlineRuns() const
192 {
193   return mModel->GetNumberOfUnderlineRuns();
194 }
195
196 void ViewModel::GetUnderlineRuns( GlyphRun* underlineRuns, UnderlineRunIndex index, Length numberOfRuns ) const
197 {
198   mModel->GetUnderlineRuns( underlineRuns, index, numberOfRuns );
199 }
200
201 const Vector4& ViewModel::GetOutlineColor() const
202 {
203   return mModel->GetOutlineColor();
204 }
205
206 float ViewModel::GetOutlineWidth() const
207 {
208   return mModel->GetOutlineWidth();
209 }
210
211 void ViewModel::ElideGlyphs()
212 {
213   mIsTextElided = false;
214
215   if( mModel->IsTextElideEnabled() )
216   {
217     const Length numberOfLines = mModel->GetNumberOfLines();
218     if( 0u != numberOfLines )
219     {
220       const LineRun* const lines = mModel->GetLines();
221
222       const LineRun& lastLine = *( lines + ( numberOfLines - 1u ) );
223       const Length numberOfLaidOutGlyphs = lastLine.glyphRun.glyphIndex + lastLine.glyphRun.numberOfGlyphs;
224
225       if( lastLine.ellipsis && ( 0u != numberOfLaidOutGlyphs ) )
226       {
227         mIsTextElided = true;
228         TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
229
230         const GlyphInfo* const glyphs = mModel->GetGlyphs();
231         const Vector2* const positions = mModel->GetLayout();
232
233         // Copy the glyphs to be elided.
234         mElidedGlyphs.Resize( numberOfLaidOutGlyphs );
235         mElidedLayout.Resize( numberOfLaidOutGlyphs );
236
237         GlyphInfo* elidedGlyphsBuffer = mElidedGlyphs.Begin();
238         Vector2* elidedPositionsBuffer = mElidedLayout.Begin();
239
240         memcpy( elidedGlyphsBuffer, glyphs, numberOfLaidOutGlyphs * sizeof( GlyphInfo ) );
241         memcpy( elidedPositionsBuffer, positions, numberOfLaidOutGlyphs * sizeof( Vector2 ) );
242
243         const Size& controlSize = mModel->GetControlSize();
244
245         if( ( 1u == numberOfLines ) &&
246             ( lastLine.ascender - lastLine.descender > controlSize.height ) )
247         {
248           // Get the first glyph which is going to be replaced and the ellipsis glyph.
249           GlyphInfo& glyphToRemove = *elidedGlyphsBuffer;
250           const GlyphInfo& ellipsisGlyph = fontClient.GetEllipsisGlyph( fontClient.GetPointSize( glyphToRemove.fontId ) );
251
252           // Change the 'x' and 'y' position of the ellipsis glyph.
253           Vector2& position = *elidedPositionsBuffer;
254
255           position.x = ellipsisGlyph.xBearing;
256           position.y = -lastLine.ascender + controlSize.height - ellipsisGlyph.yBearing;
257
258           // Replace the glyph by the ellipsis glyph and resize the buffers.
259           glyphToRemove = ellipsisGlyph;
260
261           mElidedGlyphs.Resize( 1u );
262           mElidedLayout.Resize( 1u );
263
264           return;
265         }
266
267         // firstPenX, penY and firstPenSet are used to position the ellipsis glyph if needed.
268         float firstPenX = 0.f; // Used if rtl text is elided.
269         float penY = 0.f;
270         bool firstPenSet = false;
271
272         // Add the ellipsis glyph.
273         bool inserted = false;
274         float removedGlypsWidth = 0.f;
275         Length numberOfRemovedGlyphs = 0u;
276         GlyphIndex index = numberOfLaidOutGlyphs - 1u;
277
278         // The ellipsis glyph has to fit in the place where the last glyph(s) is(are) removed.
279         while( !inserted )
280         {
281           const GlyphInfo& glyphToRemove = *( elidedGlyphsBuffer + index );
282
283           if( 0u != glyphToRemove.fontId )
284           {
285             // i.e. The font id of the glyph shaped from the '\n' character is zero.
286
287             // Need to reshape the glyph as the font may be different in size.
288             const GlyphInfo& ellipsisGlyph = fontClient.GetEllipsisGlyph( fontClient.GetPointSize( glyphToRemove.fontId ) );
289
290             if( !firstPenSet )
291             {
292               const Vector2& position = *( elidedPositionsBuffer + index );
293
294               // Calculates the penY of the current line. It will be used to position the ellipsis glyph.
295               penY = position.y + glyphToRemove.yBearing;
296
297               // Calculates the first penX which will be used if rtl text is elided.
298               firstPenX = position.x - glyphToRemove.xBearing;
299               if( firstPenX < -ellipsisGlyph.xBearing )
300               {
301                 // Avoids to exceed the bounding box when rtl text is elided.
302                 firstPenX = -ellipsisGlyph.xBearing;
303               }
304
305               removedGlypsWidth = -ellipsisGlyph.xBearing;
306
307               firstPenSet = true;
308             }
309
310             removedGlypsWidth += std::min( glyphToRemove.advance, ( glyphToRemove.xBearing + glyphToRemove.width ) );
311
312             // Calculate the width of the ellipsis glyph and check if it fits.
313             const float ellipsisGlyphWidth = ellipsisGlyph.width + ellipsisGlyph.xBearing;
314
315             if( ellipsisGlyphWidth < removedGlypsWidth )
316             {
317               GlyphInfo& glyphInfo = *( elidedGlyphsBuffer + index );
318               Vector2& position = *( elidedPositionsBuffer + index );
319               position.x -= ( 0.f > glyphInfo.xBearing ) ? glyphInfo.xBearing : 0.f;
320
321               // Replace the glyph by the ellipsis glyph.
322               glyphInfo = ellipsisGlyph;
323
324               // Change the 'x' and 'y' position of the ellipsis glyph.
325
326               if( position.x > firstPenX )
327               {
328                 position.x = firstPenX + removedGlypsWidth - ellipsisGlyphWidth;
329               }
330
331               position.x += ellipsisGlyph.xBearing;
332               position.y = penY - ellipsisGlyph.yBearing;
333
334               inserted = true;
335             }
336           }
337
338           if( !inserted )
339           {
340             if( index > 0u )
341             {
342               --index;
343             }
344             else
345             {
346               // No space for the ellipsis.
347               inserted = true;
348             }
349             ++numberOfRemovedGlyphs;
350           }
351         } // while( !inserted )
352
353           // 'Removes' all the glyphs after the ellipsis glyph.
354         const Length numberOfGlyphs = numberOfLaidOutGlyphs - numberOfRemovedGlyphs;
355         mElidedGlyphs.Resize( numberOfGlyphs );
356         mElidedLayout.Resize( numberOfGlyphs );
357       }
358     }
359   }
360 }
361
362 } // namespace Text
363
364 } // namespace Toolkit
365
366 } // namespace Dali