Merge "Stop setting crazy Z value with controls (at the moment depth is ignored by...
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / visual-model-impl.cpp
1 /*
2  * Copyright (c) 2015 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/visual-model-impl.h>
20
21 // EXTERNAL INCLUDES
22 #include <memory.h>
23
24 namespace Dali
25 {
26
27 namespace Toolkit
28 {
29
30 namespace Text
31 {
32
33 VisualModelPtr VisualModel::New()
34 {
35   return VisualModelPtr( new VisualModel() );
36 }
37
38 void VisualModel::CreateCharacterToGlyphTable( Length numberOfCharacters )
39 {
40   // 1) Reserve some space for the characters to avoid reallocations.
41   if( 0u == numberOfCharacters )
42   {
43     // If no number of characters is given, just set something sensible to avoid reallocations.
44     numberOfCharacters = static_cast<Length> ( static_cast<float>( mGlyphs.Count() ) * 1.3f );
45   }
46   mCharactersToGlyph.Reserve( numberOfCharacters );
47
48   DALI_ASSERT_DEBUG( mGlyphsPerCharacter.Count() != 0u ||
49                      ( 0u == numberOfCharacters ) );
50
51   const Length* const glyphsPerCharacterBuffer = mGlyphsPerCharacter.Begin();
52
53   // 2) Traverse the glyphs and set the glyph indices per character.
54
55   // Index to the glyph.
56   GlyphIndex glyphIndex = 0u;
57   CharacterIndex characterIndex = 0u;
58   for( Vector<Length>::ConstIterator it = mCharactersPerGlyph.Begin(),
59          endIt = mCharactersPerGlyph.End();
60        it != endIt;
61        ++it )
62   {
63     const Length numberOfCharactersPerGlyph = *it;
64
65     Length numberOfGlyphs = 0u;
66     // Set the glyph indices.
67     for( Length index = 0u; index < numberOfCharactersPerGlyph; ++index, ++characterIndex )
68     {
69       mCharactersToGlyph.PushBack( glyphIndex );
70       numberOfGlyphs += *( glyphsPerCharacterBuffer + characterIndex );
71     }
72     glyphIndex += numberOfGlyphs;
73   }
74 }
75
76 void VisualModel::CreateGlyphsPerCharacterTable( Length numberOfCharacters )
77 {
78   // 1) Reserve some space for the characters to avoid reallocations.
79   if( 0u == numberOfCharacters )
80   {
81     // If no number of characters is given, just set something sensible to avoid reallocations.
82     numberOfCharacters = static_cast<Length> ( static_cast<float>( mGlyphs.Count() ) * 1.3f );
83   }
84   mGlyphsPerCharacter.Reserve( numberOfCharacters );
85
86   // 2) Traverse the glyphs and set the number of glyphs per character.
87
88   // The number of 'characters per glyph' equal to zero.
89   Length zeroCharactersPerGlyph = 0u;
90
91   for( Vector<Length>::ConstIterator it = mCharactersPerGlyph.Begin(),
92          endIt = mCharactersPerGlyph.End();
93        it != endIt;
94        ++it )
95   {
96     const Length numberOfCharactersPerGlyph = *it;
97
98     // Set the glyphs per character.
99     if( 0u == numberOfCharactersPerGlyph )
100     {
101       ++zeroCharactersPerGlyph;
102     }
103     else
104     {
105       const Length numberOfZeroGlyphsPerCharacter = ( numberOfCharactersPerGlyph - 1u );
106       for( Length zeroIndex = 0u; zeroIndex < numberOfZeroGlyphsPerCharacter ; ++zeroIndex )
107       {
108         mGlyphsPerCharacter.PushBack( 0u );
109       }
110
111       mGlyphsPerCharacter.PushBack( 1u + zeroCharactersPerGlyph );
112
113       zeroCharactersPerGlyph = 0u;
114     }
115   }
116 }
117
118 void VisualModel::GetGlyphs( GlyphInfo* glyphs,
119                              GlyphIndex glyphIndex,
120                              Length numberOfGlyphs ) const
121 {
122   memcpy( glyphs, mGlyphs.Begin() + glyphIndex, numberOfGlyphs * sizeof( GlyphInfo ) );
123 }
124
125 void VisualModel::GetGlyphPositions( Vector2* glyphPositions,
126                                      GlyphIndex glyphIndex,
127                                      Length numberOfGlyphs ) const
128 {
129   memcpy( glyphPositions, mGlyphPositions.Begin() + glyphIndex, numberOfGlyphs * sizeof( Vector2 ) );
130 }
131
132 void VisualModel::GetNumberOfLines( GlyphIndex glyphIndex,
133                                     Length numberOfGlyphs,
134                                     LineIndex& firstLine,
135                                     Length& numberOfLines ) const
136 {
137   // Initialize the number of lines and the first line.
138   firstLine = 0u;
139   numberOfLines = 0u;
140   bool firstLineFound = false;
141
142   const GlyphIndex lastGlyphIndex = glyphIndex + numberOfGlyphs;
143
144   // Traverse the lines and count those lines within the range of glyphs.
145   for( Vector<LineRun>::ConstIterator it = mLines.Begin(),
146          endIt = mLines.End();
147        it != endIt;
148        ++it )
149   {
150     const LineRun& line = *it;
151
152     if( ( line.glyphIndex + line.numberOfGlyphs > glyphIndex ) &&
153         ( lastGlyphIndex > line.glyphIndex ) )
154     {
155       firstLineFound = true;
156       ++numberOfLines;
157     }
158     else if( lastGlyphIndex <= line.glyphIndex )
159     {
160       // nothing else to do.
161       break;
162     }
163
164     if( !firstLineFound )
165     {
166       ++firstLine;
167     }
168   }
169 }
170
171 void VisualModel::GetLinesOfGlyphRange( LineRun* lines,
172                                         GlyphIndex glyphIndex,
173                                         Length numberOfGlyphs ) const
174 {
175   LineIndex firstLine = 0u;
176   Length numberOfLines = 0u;
177
178   GetNumberOfLines( glyphIndex,
179                     numberOfGlyphs,
180                     firstLine,
181                     numberOfLines );
182
183   memcpy( lines, mLines.Begin() + firstLine, numberOfLines * sizeof( LineRun ) );
184 }
185
186 LineIndex VisualModel::GetLineOfCharacter( CharacterIndex characterIndex )
187 {
188   // 1) Check first in the cached line.
189
190   const LineRun& lineRun = *( mLines.Begin() + mCachedLineIndex );
191
192   if( ( lineRun.characterRun.characterIndex <= characterIndex ) &&
193       ( characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters ) )
194   {
195     return mCachedLineIndex;
196   }
197
198   // 2) Is not in the cached line. Check in the other lines.
199
200   LineIndex index = characterIndex < lineRun.characterRun.characterIndex ? 0u : mCachedLineIndex + 1u;
201
202   for( Vector<LineRun>::ConstIterator it = mLines.Begin() + index,
203          endIt = mLines.End();
204        it != endIt;
205        ++it, ++index )
206   {
207     const LineRun& lineRun = *it;
208
209     if( characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters )
210     {
211       mCachedLineIndex = index;
212       break;
213     }
214   }
215
216   return index;
217 }
218
219 void VisualModel::SetNaturalSize( const Vector2& size  )
220 {
221   mNaturalSize = size;
222 }
223
224 const Vector2& VisualModel::GetNaturalSize() const
225 {
226   return mNaturalSize;
227 }
228
229 void VisualModel::SetActualSize( const Vector2& size )
230 {
231   mActualSize = size;
232 }
233
234 const Vector2& VisualModel::GetActualSize() const
235 {
236   return mActualSize;
237 }
238
239 void VisualModel::SetTextColor( const Vector4& textColor )
240 {
241   mTextColor = textColor;
242
243   if ( !mUnderlineColorSet )
244   {
245     mUnderlineColor = textColor;
246   }
247 }
248
249 void VisualModel::SetShadowOffset( const Vector2& shadowOffset )
250 {
251   mShadowOffset = shadowOffset;
252 }
253
254 void VisualModel::SetShadowColor( const Vector4& shadowColor )
255 {
256   mShadowColor = shadowColor;
257 }
258
259 void VisualModel::SetUnderlineColor( const Vector4& color )
260 {
261   mUnderlineColor = color;
262   mUnderlineColorSet = true;
263 }
264
265 void VisualModel::SetUnderlineEnabled( bool enabled )
266 {
267   mUnderlineEnabled = enabled;
268 }
269
270 void VisualModel::SetUnderlineHeight( float height )
271 {
272   mUnderlineHeight = height;
273 }
274
275 const Vector4& VisualModel::GetTextColor() const
276 {
277   return mTextColor;
278 }
279
280 const Vector2& VisualModel::GetShadowOffset() const
281 {
282   return mShadowOffset;
283 }
284
285 const Vector4& VisualModel::GetShadowColor() const
286 {
287   return mShadowColor;
288 }
289
290 const Vector4& VisualModel::GetUnderlineColor() const
291 {
292   return mUnderlineColor;
293 }
294
295 bool VisualModel::IsUnderlineEnabled() const
296 {
297   return mUnderlineEnabled;
298 }
299
300 float VisualModel::GetUnderlineHeight() const
301 {
302   return mUnderlineHeight;
303 }
304
305 void VisualModel::ClearCaches()
306 {
307   mCachedLineIndex = 0u;
308 }
309
310 VisualModel::~VisualModel()
311 {
312 }
313
314 VisualModel::VisualModel()
315 : mGlyphs(),
316   mGlyphsToCharacters(),
317   mCharactersToGlyph(),
318   mCharactersPerGlyph(),
319   mGlyphsPerCharacter(),
320   mGlyphPositions(),
321   mLines(),
322   mTextColor( Color::BLACK ),
323   mShadowColor( Color::BLACK ),
324   mUnderlineColor( Color::BLACK ),
325   mShadowOffset( Vector2::ZERO ),
326   mUnderlineHeight( 0.0f ),
327   mNaturalSize(),
328   mActualSize(),
329   mCachedLineIndex( 0u ),
330   mUnderlineEnabled( false ),
331   mUnderlineColorSet( false )
332 {
333 }
334
335 } // namespace Text
336
337 } // namespace Toolkit
338
339 } // namespace Dali