[dali_1.9.28] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / text / text-visual.cpp
1 /*
2  * Copyright (c) 2020 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/visuals/text/text-visual.h>
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/animation/constraints.h>
23 #include <dali/devel-api/rendering/renderer-devel.h>
24 #include <dali/devel-api/text-abstraction/text-abstraction-definitions.h>
25 #include <dali/devel-api/adaptor-framework/image-loading.h>
26 #include <dali/devel-api/adaptor-framework/window-devel.h>
27 #include <dali/devel-api/images/pixel-data-devel.h>
28 #include <string.h>
29
30 // INTERNAL HEADER
31 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
32 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
33 #include <dali-toolkit/public-api/visuals/visual-properties.h>
34 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
35 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
36 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
37 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
38 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
39 #include <dali-toolkit/internal/text/text-font-style.h>
40 #include <dali-toolkit/internal/text/text-effects-style.h>
41 #include <dali-toolkit/internal/text/script-run.h>
42 #include <dali-toolkit/internal/text/text-enumerations-impl.h>
43 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
44
45 namespace Dali
46 {
47
48 namespace Toolkit
49 {
50
51 namespace Internal
52 {
53
54 namespace
55 {
56 const Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
57
58 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
59   attribute mediump vec2 aPosition;\n
60   uniform highp   mat4 uMvpMatrix;\n
61   uniform mediump vec3 uSize;\n
62   uniform mediump vec4 pixelArea;\n
63
64   varying mediump vec2 vTexCoord;\n
65
66   //Visual size and offset
67   uniform mediump vec2 offset;\n
68   uniform mediump vec2 size;\n
69   uniform mediump vec4 offsetSizeMode;\n
70   uniform mediump vec2 origin;\n
71   uniform mediump vec2 anchorPoint;\n
72
73   vec4 ComputeVertexPosition()\n
74   {\n
75     vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
76     vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
77     return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );\n
78   }\n
79
80   void main()\n
81   {\n
82     gl_Position = uMvpMatrix * ComputeVertexPosition();\n
83     vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
84   }\n
85 );
86
87 const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT = DALI_COMPOSE_SHADER(
88   varying mediump vec2 vTexCoord;\n
89   uniform sampler2D sTexture;\n
90   uniform lowp vec4 uTextColorAnimatable;\n
91   uniform lowp vec4 uColor;\n
92   uniform lowp vec3 mixColor;\n
93   \n
94   void main()\n
95   {\n
96     mediump float textTexture = texture2D( sTexture, vTexCoord ).r;\n
97
98     // Set the color of the text to what it is animated to.
99     gl_FragColor = uTextColorAnimatable * textTexture * uColor * vec4( mixColor, 1.0 );
100   }\n
101 );
102
103 const char* FRAGMENT_SHADER_MULTI_COLOR_TEXT = DALI_COMPOSE_SHADER(
104   varying mediump vec2 vTexCoord;\n
105   uniform sampler2D sTexture;\n
106   uniform lowp vec4 uColor;\n
107   uniform lowp vec3 mixColor;\n
108   \n
109   void main()\n
110   {\n
111     mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n
112
113     gl_FragColor = textTexture * uColor * vec4( mixColor, 1.0 );
114   }\n
115 );
116
117 const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE = DALI_COMPOSE_SHADER(
118   varying mediump vec2 vTexCoord;\n
119   uniform sampler2D sTexture;\n
120   uniform sampler2D sStyle;\n
121   uniform lowp vec4 uTextColorAnimatable;\n
122   uniform lowp vec4 uColor;\n
123   uniform lowp vec3 mixColor;\n
124   \n
125   void main()\n
126   {\n
127     mediump float textTexture = texture2D( sTexture, vTexCoord ).r;\n
128     mediump vec4 styleTexture = texture2D( sStyle, vTexCoord );\n
129
130     // Draw the text as overlay above the style
131     gl_FragColor = ( uTextColorAnimatable * textTexture + styleTexture * ( 1.0 - uTextColorAnimatable.a * textTexture ) ) * uColor * vec4( mixColor, 1.0 );\n
132   }\n
133 );
134
135 const char* FRAGMENT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE = DALI_COMPOSE_SHADER(
136   varying mediump vec2 vTexCoord;\n
137   uniform sampler2D sTexture;\n
138   uniform sampler2D sStyle;\n
139   uniform lowp vec4 uColor;\n
140   uniform lowp vec3 mixColor;\n
141   \n
142   void main()\n
143   {\n
144     mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n
145     mediump vec4 styleTexture = texture2D( sStyle, vTexCoord );\n
146
147     // Draw the text as overlay above the style
148     gl_FragColor = ( textTexture + styleTexture * ( 1.0 - textTexture.a ) ) * uColor * vec4( mixColor, 1.0 );\n
149   }\n
150 );
151
152 const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI = DALI_COMPOSE_SHADER(
153   varying mediump vec2 vTexCoord;\n
154   uniform sampler2D sTexture;\n
155   uniform sampler2D sMask;\n
156   uniform lowp vec4 uTextColorAnimatable;\n
157   uniform lowp vec4 uColor;\n
158   uniform lowp vec3 mixColor;\n
159   \n
160   void main()\n
161   {\n
162     mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n
163     mediump float maskTexture = texture2D( sMask, vTexCoord ).r;\n
164
165     // Set the color of non-transparent pixel in text to what it is animated to.
166     // Markup text with multiple text colors are not animated (but can be supported later on if required).
167     // Emoji color are not animated.
168     mediump float vstep = step( 0.0001, textTexture.a );\n
169     textTexture.rgb = mix( textTexture.rgb, uTextColorAnimatable.rgb, vstep * maskTexture );\n
170
171     // Draw the text as overlay above the style
172     gl_FragColor = textTexture * uColor * vec4( mixColor, 1.0 );\n
173   }\n
174 );
175
176 const char* FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI = DALI_COMPOSE_SHADER(
177   varying mediump vec2 vTexCoord;\n
178   uniform sampler2D sTexture;\n
179   uniform sampler2D sStyle;\n
180   uniform sampler2D sMask;\n
181   uniform lowp float uHasMultipleTextColors;\n
182   uniform lowp vec4 uTextColorAnimatable;\n
183   uniform lowp vec4 uColor;\n
184   uniform lowp vec3 mixColor;\n
185   \n
186   void main()\n
187   {\n
188     mediump vec4 textTexture = texture2D( sTexture, vTexCoord );\n
189     mediump vec4 styleTexture = texture2D( sStyle, vTexCoord );\n
190     mediump float maskTexture = texture2D( sMask, vTexCoord ).r;\n
191
192     // Set the color of non-transparent pixel in text to what it is animated to.
193     // Markup text with multiple text colors are not animated (but can be supported later on if required).
194     // Emoji color are not animated.
195     mediump float vstep = step( 0.0001, textTexture.a );\n
196     textTexture.rgb = mix( textTexture.rgb, uTextColorAnimatable.rgb, vstep * maskTexture * ( 1.0 - uHasMultipleTextColors ) );\n
197
198     // Draw the text as overlay above the style
199     gl_FragColor = ( textTexture + styleTexture * ( 1.0 - textTexture.a ) ) * uColor * vec4( mixColor, 1.0 );\n
200   }\n
201 );
202
203 /**
204  * Return Property index for the given string key
205  * param[in] stringKey the string index key
206  * return the key as an index
207  */
208
209 Dali::Property::Index StringKeyToIndexKey( const std::string& stringKey )
210 {
211   Dali::Property::Index result = Property::INVALID_KEY;
212
213   if( stringKey == VISUAL_TYPE )
214   {
215     result = Toolkit::Visual::Property::TYPE;
216   }
217   else if( stringKey == TEXT_PROPERTY )
218   {
219     result = Toolkit::TextVisual::Property::TEXT;
220   }
221   else if( stringKey == FONT_FAMILY_PROPERTY )
222   {
223     result = Toolkit::TextVisual::Property::FONT_FAMILY;
224   }
225   else if( stringKey == FONT_STYLE_PROPERTY )
226   {
227     result = Toolkit::TextVisual::Property::FONT_STYLE;
228   }
229   else if( stringKey == POINT_SIZE_PROPERTY )
230   {
231     result = Toolkit::TextVisual::Property::POINT_SIZE;
232   }
233   else if( stringKey == MULTI_LINE_PROPERTY )
234   {
235     result = Toolkit::TextVisual::Property::MULTI_LINE;
236   }
237   else if( stringKey == HORIZONTAL_ALIGNMENT_PROPERTY )
238   {
239     result = Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
240   }
241   else if( stringKey == VERTICAL_ALIGNMENT_PROPERTY )
242   {
243     result = Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
244   }
245   else if( stringKey == TEXT_COLOR_PROPERTY )
246   {
247     result = Toolkit::TextVisual::Property::TEXT_COLOR;
248   }
249   else if( stringKey == ENABLE_MARKUP_PROPERTY )
250   {
251     result = Toolkit::TextVisual::Property::ENABLE_MARKUP;
252   }
253   else if( stringKey == SHADOW_PROPERTY )
254   {
255     result = Toolkit::TextVisual::Property::SHADOW;
256   }
257   else if( stringKey == UNDERLINE_PROPERTY )
258   {
259     result = Toolkit::TextVisual::Property::UNDERLINE;
260   }
261   else if( stringKey == OUTLINE_PROPERTY )
262   {
263     result = Toolkit::DevelTextVisual::Property::OUTLINE;
264   }
265   else if( stringKey == BACKGROUND_PROPERTY )
266   {
267     result = Toolkit::DevelTextVisual::Property::BACKGROUND;
268   }
269
270   return result;
271 }
272
273 void TextColorConstraint( Vector4& current, const PropertyInputContainer& inputs )
274 {
275   Vector4 color = inputs[0]->GetVector4();
276   current.r = color.r * color.a;
277   current.g = color.g * color.a;
278   current.b = color.b * color.a;
279   current.a = color.a;
280 }
281
282 void OpacityConstraint( float& current, const PropertyInputContainer& inputs )
283 {
284   // Make zero if the alpha value of text color is zero to skip rendering text
285   if( EqualsZero( inputs[0]->GetVector4().a ) )
286   {
287     current = 0.0f;
288   }
289   else
290   {
291     current = 1.0f;
292   }
293 }
294
295 } // unnamed namespace
296
297 TextVisualPtr TextVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
298 {
299   TextVisualPtr TextVisualPtr( new TextVisual( factoryCache ) );
300   TextVisualPtr->SetProperties( properties );
301   return TextVisualPtr;
302 }
303
304 void TextVisual::ConvertStringKeysToIndexKeys( Property::Map& propertyMap )
305 {
306   Property::Map outMap;
307
308   for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index )
309   {
310     const KeyValuePair& keyValue = propertyMap.GetKeyValue( index );
311
312     Property::Index indexKey = keyValue.first.indexKey;
313
314     if ( keyValue.first.type == Property::Key::STRING )
315     {
316       indexKey = StringKeyToIndexKey( keyValue.first.stringKey );
317     }
318
319     outMap.Insert( indexKey, keyValue.second );
320   }
321
322   propertyMap = outMap;
323 }
324
325 float TextVisual::GetHeightForWidth( float width )
326 {
327   return mController->GetHeightForWidth( width );
328 }
329
330 void TextVisual::GetNaturalSize( Vector2& naturalSize )
331 {
332   naturalSize = mController->GetNaturalSize().GetVectorXY();
333 }
334
335 void TextVisual::DoCreatePropertyMap( Property::Map& map ) const
336 {
337   Property::Value value;
338
339   map.Clear();
340   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT );
341
342   std::string text;
343   mController->GetText( text );
344   map.Insert( Toolkit::TextVisual::Property::TEXT, text );
345
346   map.Insert( Toolkit::TextVisual::Property::FONT_FAMILY, mController->GetDefaultFontFamily() );
347
348   GetFontStyleProperty( mController, value, Text::FontStyle::DEFAULT );
349   map.Insert( Toolkit::TextVisual::Property::FONT_STYLE, value );
350
351   map.Insert( Toolkit::TextVisual::Property::POINT_SIZE, mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ) );
352
353   map.Insert( Toolkit::TextVisual::Property::MULTI_LINE, mController->IsMultiLineEnabled() );
354
355   map.Insert( Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT, mController->GetHorizontalAlignment() );
356
357   map.Insert( Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT, mController->GetVerticalAlignment() );
358
359   map.Insert( Toolkit::TextVisual::Property::TEXT_COLOR, mController->GetDefaultColor() );
360
361   map.Insert( Toolkit::TextVisual::Property::ENABLE_MARKUP, mController->IsMarkupProcessorEnabled() );
362
363   GetShadowProperties( mController, value, Text::EffectStyle::DEFAULT );
364   map.Insert( Toolkit::TextVisual::Property::SHADOW, value );
365
366   GetUnderlineProperties( mController, value, Text::EffectStyle::DEFAULT );
367   map.Insert( Toolkit::TextVisual::Property::UNDERLINE, value );
368
369   GetOutlineProperties( mController, value, Text::EffectStyle::DEFAULT );
370   map.Insert( Toolkit::DevelTextVisual::Property::OUTLINE, value );
371
372   GetBackgroundProperties( mController, value, Text::EffectStyle::DEFAULT );
373   map.Insert( Toolkit::DevelTextVisual::Property::BACKGROUND, value );
374 }
375
376 void TextVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
377 {
378   map.Clear();
379   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::Visual::TEXT );
380   std::string text;
381   mController->GetText( text );
382   map.Insert( Toolkit::TextVisual::Property::TEXT, text );
383 }
384
385
386 TextVisual::TextVisual( VisualFactoryCache& factoryCache )
387 : Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO, Toolkit::Visual::TEXT ),
388   mController( Text::Controller::New() ),
389   mTypesetter( Text::Typesetter::New( mController->GetTextModel() ) ),
390   mAnimatableTextColorPropertyIndex( Property::INVALID_INDEX ),
391   mRendererUpdateNeeded( false )
392 {
393 }
394
395 TextVisual::~TextVisual()
396 {
397 }
398
399 void TextVisual::DoSetProperties( const Property::Map& propertyMap )
400 {
401   for( Property::Map::SizeType index = 0u, count = propertyMap.Count(); index < count; ++index )
402   {
403     const KeyValuePair& keyValue = propertyMap.GetKeyValue( index );
404
405     Property::Index indexKey = keyValue.first.indexKey;
406
407     if( keyValue.first.type == Property::Key::STRING )
408     {
409       indexKey = StringKeyToIndexKey( keyValue.first.stringKey );
410     }
411
412     DoSetProperty( indexKey, keyValue.second );
413   }
414
415   // Elide the text if it exceeds the boundaries.
416   mController->SetTextElideEnabled( true );
417
418   // Retrieve the layout engine to set the cursor's width.
419   Text::Layout::Engine& engine = mController->GetLayoutEngine();
420
421   // Sets 0 as cursor's width.
422   engine.SetCursorWidth( 0u ); // Do not layout space for the cursor.
423 }
424
425 void TextVisual::DoSetOnScene( Actor& actor )
426 {
427   mControl = actor;
428
429   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
430   Shader shader = GetTextShader(mFactoryCache, TextType::SINGLE_COLOR_TEXT, TextType::NO_EMOJI, TextType::NO_STYLES);
431
432   mImpl->mRenderer = Renderer::New( geometry, shader );
433   mImpl->mRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT );
434
435   // Enable the pre-multiplied alpha to improve the text quality
436   EnablePreMultipliedAlpha(true);
437
438   const Vector4& defaultColor = mController->GetTextModel()->GetDefaultColor();
439   Dali::Property::Index shaderTextColorIndex = mImpl->mRenderer.RegisterProperty( "uTextColorAnimatable", defaultColor );
440
441   if ( mAnimatableTextColorPropertyIndex != Property::INVALID_INDEX )
442   {
443     // Create constraint for the animatable text's color Property with uTextColorAnimatable in the renderer.
444     if( shaderTextColorIndex != Property::INVALID_INDEX )
445     {
446       Constraint colorConstraint = Constraint::New<Vector4>( mImpl->mRenderer, shaderTextColorIndex, TextColorConstraint );
447       colorConstraint.AddSource( Source( actor, mAnimatableTextColorPropertyIndex ) );
448       colorConstraint.Apply();
449
450       // Make zero if the alpha value of text color is zero to skip rendering text
451       Constraint opacityConstraint = Constraint::New< float >( mImpl->mRenderer, Dali::DevelRenderer::Property::OPACITY, OpacityConstraint );
452       opacityConstraint.AddSource( Source( actor, mAnimatableTextColorPropertyIndex ) );
453       opacityConstraint.Apply();
454     }
455   }
456
457   // Renderer needs textures and to be added to control
458   mRendererUpdateNeeded = true;
459
460   mRendererList.push_back( mImpl->mRenderer );
461
462   UpdateRenderer();
463 }
464
465 void TextVisual::RemoveRenderer( Actor& actor )
466 {
467   for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter)
468   {
469     Renderer renderer = (*iter);
470     if( renderer )
471     {
472       // Removes the renderer from the actor.
473       actor.RemoveRenderer( renderer );
474     }
475   }
476   // Clear the renderer list
477   mRendererList.clear();
478 }
479
480 void TextVisual::DoSetOffScene( Actor& actor )
481 {
482   RemoveRenderer( actor );
483
484   // Resets the renderer.
485   mImpl->mRenderer.Reset();
486
487   // Resets the control handle.
488   mControl.Reset();
489 }
490
491 void TextVisual::OnSetTransform()
492 {
493   UpdateRenderer();
494 }
495
496 void TextVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
497 {
498   switch( index )
499   {
500     case Toolkit::TextVisual::Property::ENABLE_MARKUP:
501     {
502       const bool enableMarkup = propertyValue.Get<bool>();
503       mController->SetMarkupProcessorEnabled( enableMarkup );
504       break;
505     }
506     case Toolkit::TextVisual::Property::TEXT:
507     {
508       mController->SetText( propertyValue.Get<std::string>() );
509       break;
510     }
511     case Toolkit::TextVisual::Property::FONT_FAMILY:
512     {
513       SetFontFamilyProperty( mController, propertyValue );
514       break;
515     }
516     case Toolkit::TextVisual::Property::FONT_STYLE:
517     {
518       SetFontStyleProperty( mController, propertyValue, Text::FontStyle::DEFAULT );
519       break;
520     }
521     case Toolkit::TextVisual::Property::POINT_SIZE:
522     {
523       const float pointSize = propertyValue.Get<float>();
524       if( !Equals( mController->GetDefaultFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
525       {
526         mController->SetDefaultFontSize( pointSize, Text::Controller::POINT_SIZE );
527       }
528       break;
529     }
530     case Toolkit::TextVisual::Property::MULTI_LINE:
531     {
532       mController->SetMultiLineEnabled( propertyValue.Get<bool>() );
533       break;
534     }
535     case Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT:
536     {
537       if( mController )
538       {
539         Text::HorizontalAlignment::Type alignment( static_cast< Text::HorizontalAlignment::Type >( -1 ) ); // Set to invalid value to ensure a valid mode does get set
540         if( Toolkit::Text::GetHorizontalAlignmentEnumeration( propertyValue, alignment ) )
541         {
542           mController->SetHorizontalAlignment( alignment );
543         }
544       }
545       break;
546     }
547     case Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT:
548     {
549       if( mController )
550       {
551         Toolkit::Text::VerticalAlignment::Type alignment( static_cast< Text::VerticalAlignment::Type >( -1 ) ); // Set to invalid value to ensure a valid mode does get set
552         if( Toolkit::Text::GetVerticalAlignmentEnumeration( propertyValue, alignment) )
553         {
554           mController->SetVerticalAlignment( alignment );
555         }
556       }
557       break;
558     }
559     case Toolkit::TextVisual::Property::TEXT_COLOR:
560     {
561       const Vector4& textColor = propertyValue.Get< Vector4 >();
562       if( mController->GetDefaultColor() != textColor )
563       {
564         mController->SetDefaultColor( textColor );
565       }
566       break;
567     }
568     case Toolkit::TextVisual::Property::SHADOW:
569     {
570       SetShadowProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
571       break;
572     }
573     case Toolkit::TextVisual::Property::UNDERLINE:
574     {
575       SetUnderlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
576       break;
577     }
578     case Toolkit::DevelTextVisual::Property::OUTLINE:
579     {
580       SetOutlineProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
581       break;
582     }
583     case Toolkit::DevelTextVisual::Property::BACKGROUND:
584     {
585       SetBackgroundProperties( mController, propertyValue, Text::EffectStyle::DEFAULT );
586       break;
587     }
588   }
589 }
590
591 void TextVisual::UpdateRenderer()
592 {
593   Actor control = mControl.GetHandle();
594   if( !control )
595   {
596     // Nothing to do.
597     return;
598   }
599
600   // Calculates the size to be used to relayout.
601   Vector2 relayoutSize;
602
603   const bool isWidthRelative = fabsf( mImpl->mTransform.mOffsetSizeMode.z ) < Math::MACHINE_EPSILON_1000;
604   const bool isHeightRelative = fabsf( mImpl->mTransform.mOffsetSizeMode.w ) < Math::MACHINE_EPSILON_1000;
605
606   // Round the size and offset to avoid pixel alignement issues.
607   relayoutSize.width = floorf( 0.5f + ( isWidthRelative ? mImpl->mControlSize.width * mImpl->mTransform.mSize.x : mImpl->mTransform.mSize.width ) );
608   relayoutSize.height = floorf( 0.5f + ( isHeightRelative ? mImpl->mControlSize.height * mImpl->mTransform.mSize.y : mImpl->mTransform.mSize.height ) );
609
610   std::string text;
611   mController->GetText( text );
612
613   if( ( fabsf( relayoutSize.width ) < Math::MACHINE_EPSILON_1000 ) || ( fabsf( relayoutSize.height ) < Math::MACHINE_EPSILON_1000 ) || text.empty() )
614   {
615     // Remove the texture set and any renderer previously set.
616     RemoveRenderer( control );
617
618     // Nothing else to do if the relayout size is zero.
619     ResourceReady( Toolkit::Visual::ResourceStatus::READY );
620     return;
621   }
622
623
624   Dali::LayoutDirection::Type layoutDirection;
625   if( mController->IsMatchSystemLanguageDirection() )
626   {
627     layoutDirection = static_cast<Dali::LayoutDirection::Type>( DevelWindow::Get( control ).GetRootLayer().GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
628   }
629   else
630   {
631     layoutDirection = static_cast<Dali::LayoutDirection::Type>( control.GetProperty( Dali::Actor::Property::LAYOUT_DIRECTION ).Get<int>() );
632   }
633
634   const Text::Controller::UpdateTextType updateTextType = mController->Relayout( relayoutSize, layoutDirection );
635
636   if( Text::Controller::NONE_UPDATED != ( Text::Controller::MODEL_UPDATED & updateTextType )
637    || mRendererUpdateNeeded )
638   {
639     mRendererUpdateNeeded = false;
640
641     // Remove the texture set and any renderer previously set.
642     RemoveRenderer( control );
643
644     if( ( relayoutSize.width > Math::MACHINE_EPSILON_1000 ) &&
645         ( relayoutSize.height > Math::MACHINE_EPSILON_1000 ) )
646     {
647       // Check whether it is a markup text with multiple text colors
648       const Vector4* const colorsBuffer = mController->GetTextModel()->GetColors();
649       bool hasMultipleTextColors = ( NULL != colorsBuffer );
650
651       // Check whether the text contains any color glyph
652       bool containsColorGlyph = false;
653
654       TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
655       const Text::GlyphInfo* const glyphsBuffer = mController->GetTextModel()->GetGlyphs();
656       const Text::Length numberOfGlyphs = mController->GetTextModel()->GetNumberOfGlyphs();
657       for ( Text::Length glyphIndex = 0; glyphIndex < numberOfGlyphs; glyphIndex++ )
658       {
659         // Retrieve the glyph's info.
660         const Text::GlyphInfo* const glyphInfo = glyphsBuffer + glyphIndex;
661
662         // Whether the current glyph is a color one.
663         if( fontClient.IsColorGlyph( glyphInfo->fontId, glyphInfo->index ) )
664         {
665           containsColorGlyph = true;
666           break;
667         }
668       }
669
670       // Check whether the text contains any style colors (e.g. underline color, shadow color, etc.)
671
672       bool shadowEnabled = false;
673       const Vector2& shadowOffset = mController->GetTextModel()->GetShadowOffset();
674       if ( fabsf( shadowOffset.x ) > Math::MACHINE_EPSILON_1 || fabsf( shadowOffset.y ) > Math::MACHINE_EPSILON_1 )
675       {
676         shadowEnabled = true;
677       }
678
679       const bool underlineEnabled = mController->GetTextModel()->IsUnderlineEnabled();
680       const bool outlineEnabled = ( mController->GetTextModel()->GetOutlineWidth() > Math::MACHINE_EPSILON_1 );
681       const bool backgroundEnabled = mController->GetTextModel()->IsBackgroundEnabled();;
682
683       const bool styleEnabled = ( shadowEnabled || underlineEnabled || outlineEnabled || backgroundEnabled );
684
685
686       AddRenderer( control, relayoutSize, hasMultipleTextColors, containsColorGlyph, styleEnabled );
687
688       // Text rendered and ready to display
689       ResourceReady( Toolkit::Visual::ResourceStatus::READY );
690     }
691   }
692 }
693
694 void TextVisual::AddTexture( TextureSet& textureSet, PixelData& data, Sampler& sampler, unsigned int textureSetIndex )
695 {
696   Texture texture = Texture::New( Dali::TextureType::TEXTURE_2D,
697                                   data.GetPixelFormat(),
698                                   data.GetWidth(),
699                                   data.GetHeight() );
700   texture.Upload( data );
701
702   textureSet.SetTexture( textureSetIndex, texture );
703   textureSet.SetSampler( textureSetIndex, sampler );
704 }
705
706 PixelData TextVisual::ConvertToPixelData( unsigned char* buffer, int width, int height, int offsetPosition, const Pixel::Format textPixelFormat )
707 {
708   int bpp = Pixel::GetBytesPerPixel( textPixelFormat );
709   unsigned int bufferSize = width * height * bpp;
710   unsigned char* dstBuffer = static_cast<unsigned char*>( malloc ( bufferSize ) );
711   memcpy( dstBuffer, buffer + offsetPosition * bpp, bufferSize );
712   PixelData pixelData = Dali::PixelData::New( dstBuffer,
713                                               bufferSize,
714                                               width,
715                                               height,
716                                               textPixelFormat,
717                                               Dali::PixelData::FREE );
718   return pixelData;
719 }
720
721 void TextVisual::CreateTextureSet( TilingInfo& info, Renderer& renderer, Sampler& sampler, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
722 {
723
724   TextureSet textureSet = TextureSet::New();
725   unsigned int textureSetIndex = 0u;
726
727   // Convert the buffer to pixel data to make it a texture.
728   if( info.textBuffer )
729   {
730     PixelData data = ConvertToPixelData( info.textBuffer, info.width, info.height, info.offsetPosition, info.textPixelFormat );
731     AddTexture( textureSet, data, sampler, textureSetIndex );
732     ++textureSetIndex;
733   }
734
735   if( styleEnabled && info.styleBuffer )
736   {
737     PixelData styleData = ConvertToPixelData( info.styleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888 );
738     AddTexture( textureSet, styleData, sampler, textureSetIndex );
739     ++textureSetIndex;
740   }
741
742   if( containsColorGlyph && !hasMultipleTextColors && info.maskBuffer )
743   {
744     PixelData maskData = ConvertToPixelData( info.maskBuffer, info.width, info.height, info.offsetPosition, Pixel::L8 );
745     AddTexture( textureSet, maskData, sampler, textureSetIndex );
746   }
747
748   renderer.SetTextures( textureSet );
749
750   //Register transform properties
751   mImpl->mTransform.RegisterUniforms( renderer, Direction::LEFT_TO_RIGHT );
752
753   // Enable the pre-multiplied alpha to improve the text quality
754   renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true );
755   renderer.RegisterProperty( PREMULTIPLIED_ALPHA, 1.0f );
756
757   // Set size and offset for the tiling.
758   renderer.RegisterProperty( SIZE, Vector2( info.width, info.height ) );
759   renderer.RegisterProperty( OFFSET, Vector2( info.offSet.x, info.offSet.y ) );
760   renderer.RegisterProperty( "uHasMultipleTextColors", static_cast<float>( hasMultipleTextColors ) );
761   renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON);
762
763   mRendererList.push_back( renderer );
764 }
765
766
767 void TextVisual::AddRenderer( Actor& actor, const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
768 {
769   Shader shader = GetTextShader( mFactoryCache, hasMultipleTextColors, containsColorGlyph, styleEnabled );
770   mImpl->mRenderer.SetShader( shader );
771
772   // Get the maximum size.
773   const int maxTextureSize = Dali::GetMaxTextureSize();
774
775   // No tiling required. Use the default renderer.
776   if( size.height < maxTextureSize )
777   {
778     TextureSet textureSet = GetTextTexture( size, hasMultipleTextColors, containsColorGlyph, styleEnabled );
779
780     mImpl->mRenderer.SetTextures( textureSet );
781     //Register transform properties
782     mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
783     mImpl->mRenderer.RegisterProperty( "uHasMultipleTextColors", static_cast<float>( hasMultipleTextColors ) );
784     mImpl->mRenderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON);
785
786     mRendererList.push_back( mImpl->mRenderer );
787   }
788   // If the pixel data exceeds the maximum size, tiling is required.
789   else
790   {
791     // Filter mode needs to be set to linear to produce better quality while scaling.
792     Sampler sampler = Sampler::New();
793     sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
794
795     // Create RGBA texture if the text contains emojis or multiple text colors, otherwise L8 texture
796     Pixel::Format textPixelFormat = ( containsColorGlyph || hasMultipleTextColors ) ? Pixel::RGBA8888 : Pixel::L8;
797
798     // Check the text direction
799     Toolkit::DevelText::TextDirection::Type textDirection = mController->GetTextDirection();
800
801     // Create a texture for the text without any styles
802     PixelData data = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_STYLES, false, textPixelFormat );
803
804     int verifiedWidth = data.GetWidth();
805     int verifiedHeight = data.GetHeight();
806
807     // Set information for creating textures.
808     TilingInfo info( verifiedWidth, maxTextureSize, textPixelFormat );
809
810     // Get the buffer of text.
811     Dali::DevelPixelData::PixelDataBuffer textPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( data );
812     info.textBuffer = textPixelData.buffer;
813
814     if( styleEnabled )
815     {
816       // Create RGBA texture for all the text styles (without the text itself)
817       PixelData styleData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888 );
818       Dali::DevelPixelData::PixelDataBuffer stylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( styleData );
819       info.styleBuffer = stylePixelData.buffer;
820     }
821
822     if ( containsColorGlyph && !hasMultipleTextColors )
823     {
824       // Create a L8 texture as a mask to avoid color glyphs (e.g. emojis) to be affected by text color animation
825       PixelData maskData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_MASK, false, Pixel::L8 );
826       Dali::DevelPixelData::PixelDataBuffer maskPixelData = Dali::DevelPixelData::ReleasePixelDataBuffer( maskData );
827       info.maskBuffer = maskPixelData.buffer;
828     }
829
830     // Get the current offset for recalculate the offset when tiling.
831     Property::Map retMap;
832     mImpl->mTransform.GetPropertyMap( retMap );
833     Property::Value* offsetValue = retMap.Find( Dali::Toolkit::Visual::Transform::Property::OFFSET );
834     if( offsetValue )
835     {
836       offsetValue->Get( info.offSet );
837     }
838
839     // Create a textureset in the default renderer.
840     CreateTextureSet( info, mImpl->mRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled );
841
842     verifiedHeight -= maxTextureSize;
843
844     Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
845
846     int offsetPosition = verifiedWidth * maxTextureSize;
847     // Create a renderer by cutting maxTextureSize.
848     while( verifiedHeight > 0 )
849     {
850       Renderer tilingRenderer = Renderer::New( geometry, shader );
851       tilingRenderer.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, Toolkit::DepthIndex::CONTENT );
852       // New offset position of buffer for tiling.
853       info.offsetPosition += offsetPosition;
854       // New height for tiling.
855       info.height = ( verifiedHeight - maxTextureSize ) > 0 ? maxTextureSize : verifiedHeight;
856       // New offset for tiling.
857       info.offSet.y += maxTextureSize;
858       // Create a textureset int the new tiling renderer.
859       CreateTextureSet( info, tilingRenderer, sampler, hasMultipleTextColors, containsColorGlyph, styleEnabled );
860
861       verifiedHeight -= maxTextureSize;
862     }
863   }
864
865   mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
866
867   for( RendererContainer::iterator iter = mRendererList.begin(); iter != mRendererList.end(); ++iter)
868   {
869     Renderer renderer = (*iter);
870     if( renderer )
871     {
872       actor.AddRenderer( renderer );
873     }
874   }
875 }
876
877
878 TextureSet TextVisual::GetTextTexture( const Vector2& size, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
879 {
880   // Filter mode needs to be set to linear to produce better quality while scaling.
881   Sampler sampler = Sampler::New();
882   sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
883
884   TextureSet textureSet = TextureSet::New();
885
886   // Create RGBA texture if the text contains emojis or multiple text colors, otherwise L8 texture
887   Pixel::Format textPixelFormat = ( containsColorGlyph || hasMultipleTextColors ) ? Pixel::RGBA8888 : Pixel::L8;
888
889   // Check the text direction
890   Toolkit::DevelText::TextDirection::Type textDirection = mController->GetTextDirection();
891
892   // Create a texture for the text without any styles
893   PixelData data = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_STYLES, false, textPixelFormat );
894
895   // It may happen the image atlas can't handle a pixel data it exceeds the maximum size.
896   // In that case, create a texture. TODO: should tile the text.
897   unsigned int textureSetIndex = 0u;
898
899   AddTexture( textureSet, data, sampler, textureSetIndex );
900   ++textureSetIndex;
901
902   if ( styleEnabled )
903   {
904     // Create RGBA texture for all the text styles (without the text itself)
905     PixelData styleData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888 );
906
907     AddTexture( textureSet, styleData, sampler, textureSetIndex );
908     ++textureSetIndex;
909   }
910
911   if ( containsColorGlyph && !hasMultipleTextColors )
912   {
913     // Create a L8 texture as a mask to avoid color glyphs (e.g. emojis) to be affected by text color animation
914     PixelData maskData = mTypesetter->Render( size, textDirection, Text::Typesetter::RENDER_MASK, false, Pixel::L8 );
915
916     AddTexture( textureSet, maskData, sampler, textureSetIndex );
917   }
918
919   return textureSet;
920 }
921
922 Shader TextVisual::GetTextShader( VisualFactoryCache& factoryCache, bool hasMultipleTextColors, bool containsColorGlyph, bool styleEnabled )
923 {
924   Shader shader;
925
926   if( hasMultipleTextColors && !styleEnabled )
927   {
928     // We don't animate text color if the text contains multiple colors
929     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT );
930     if( !shader )
931     {
932       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_MULTI_COLOR_TEXT );
933       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
934       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT, shader );
935     }
936   }
937   else if( hasMultipleTextColors && styleEnabled )
938   {
939     // We don't animate text color if the text contains multiple colors
940     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE );
941     if( !shader )
942     {
943       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE );
944       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
945       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE, shader );
946     }
947   }
948   else if( !hasMultipleTextColors && !containsColorGlyph && !styleEnabled )
949   {
950     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT );
951     if( !shader )
952     {
953       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT );
954       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
955       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT, shader );
956     }
957   }
958   else if( !hasMultipleTextColors && !containsColorGlyph && styleEnabled )
959   {
960     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE );
961     if( !shader )
962     {
963       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE );
964       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
965       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE, shader );
966     }
967   }
968   else if( !hasMultipleTextColors && containsColorGlyph && !styleEnabled )
969   {
970     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI );
971     if( !shader )
972     {
973       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI );
974       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
975       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI, shader );
976     }
977   }
978   else // if( !hasMultipleTextColors && containsColorGlyph && styleEnabled )
979   {
980     shader = factoryCache.GetShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI );
981     if( !shader )
982     {
983       shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI );
984       shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
985       factoryCache.SaveShader( VisualFactoryCache::TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI, shader );
986     }
987   }
988
989   return shader;
990 }
991
992 } // namespace Internal
993
994 } // namespace Toolkit
995
996 } // namespace Dali