Prevent Image visuals creating a renderer and putting it on stage even if url provide...
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-effects-style.cpp
1 /*
2  * Copyright (c) 2016 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 // FILE HEADER
19 #include <dali-toolkit/internal/text/text-effects-style.h>
20
21 // INTERNAL INCLUDES
22 #include <dali-toolkit/internal/text/markup-processor-helper-functions.h>
23 #include <dali-toolkit/internal/text/property-string-parser.h>
24
25 namespace Dali
26 {
27
28 namespace Toolkit
29 {
30
31 namespace Text
32 {
33
34 namespace
35 {
36 const std::string COLOR_KEY( "color" );
37 const std::string OFFSET_KEY( "offset" );
38 const std::string HEIGHT_KEY( "height" );
39 const std::string ENABLE_KEY( "enable" );
40 const std::string TRUE_TOKEN( "true" );
41 }
42
43 bool ParseProperties( const std::string& shadowProperties,
44                       bool& colorDefined,
45                       Vector4& color,
46                       bool& offsetDefined,
47                       Vector2& offset )
48 {
49   // Parses and applies the style.
50   Property::Map map;
51   Text::ParsePropertyString( shadowProperties, map );
52
53   const bool empty = map.Empty();
54
55   if( !empty )
56   {
57     /// Color key.
58     Property::Value* colorValue = map.Find( COLOR_KEY );
59
60     colorDefined = colorValue != NULL;
61     if( colorDefined )
62     {
63       const std::string colorStr = colorValue->Get<std::string>();
64
65       Text::ColorStringToVector4( colorStr.c_str(), colorStr.size(), color );
66     }
67
68     /// Offset key.
69     Property::Value* offsetValue = map.Find( OFFSET_KEY );
70
71     offsetDefined = offsetValue != NULL;
72     if( offsetDefined )
73     {
74       const std::string offsetStr = offsetValue->Get<std::string>();
75
76       StringToVector2( offsetStr.c_str(), offsetStr.size(), offset );
77     }
78   }
79
80   return empty;
81 }
82
83 bool ParseProperties( const std::string& underlineProperties,
84                       bool& enabled,
85                       bool& colorDefined,
86                       Vector4& color,
87                       bool& heightDefined,
88                       float& height )
89 {
90   // Parses and applies the style.
91   Property::Map map;
92   Text::ParsePropertyString( underlineProperties, map );
93
94   const bool empty = map.Empty();
95
96   if( !empty )
97   {
98     /// Enable key.
99     Property::Value* enableValue = map.Find( ENABLE_KEY );
100
101     enabled = false;
102     const bool enabledDefined = enableValue != NULL;
103     if( enabledDefined )
104     {
105       const std::string enableStr = enableValue->Get<std::string>();
106       enabled = Text::TokenComparison( TRUE_TOKEN, enableStr.c_str(), enableStr.size() );
107     }
108
109     /// Color key.
110     Property::Value* colorValue = map.Find( COLOR_KEY );
111
112     colorDefined = colorValue != NULL;
113     if( colorDefined )
114     {
115       const std::string colorStr = colorValue->Get<std::string>();
116
117       Text::ColorStringToVector4( colorStr.c_str(), colorStr.size(), color );
118     }
119
120     /// Height key.
121     Property::Value* heightValue = map.Find( HEIGHT_KEY );
122
123     height = 0.f;
124     heightDefined = heightValue != NULL;
125     if( heightDefined )
126     {
127       const std::string heightStr = heightValue->Get<std::string>();
128
129       height = StringToFloat( heightStr.c_str() );
130     }
131   }
132
133   return empty;
134 }
135
136 bool SetUnderlineProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
137 {
138   bool update = false;
139
140   if( controller )
141   {
142     const std::string properties = value.Get<std::string>();
143
144     bool enabled = false;
145     bool colorDefined = false;
146     Vector4 color;
147     bool heightDefined = false;
148     float height = 0.f;
149
150     const bool empty = ParseProperties( properties,
151                                         enabled,
152                                         colorDefined,
153                                         color,
154                                         heightDefined,
155                                         height );
156
157     if( !empty )
158     {
159       switch( type )
160       {
161         case EffectStyle::DEFAULT:
162         {
163           if( enabled != controller->IsUnderlineEnabled() )
164           {
165             controller->SetUnderlineEnabled( enabled );
166             update = true;
167           }
168
169           // Sets the default underline values.
170           if( colorDefined && ( controller->GetUnderlineColor() != color ) )
171           {
172             controller->SetUnderlineColor( color );
173             update = true;
174           }
175
176           if( heightDefined && ( fabsf( controller->GetUnderlineHeight() - height ) > Math::MACHINE_EPSILON_1000 ) )
177           {
178             controller->SetUnderlineHeight( height );
179             update = true;
180           }
181           break;
182         }
183         case EffectStyle::INPUT:
184         {
185           // Sets the input underline values.
186           // TODO: to be implemented.
187           break;
188         }
189       }
190     }
191     else
192     {
193       switch( type )
194       {
195         case EffectStyle::DEFAULT:
196         {
197           // Disable underline.
198           if( controller->IsUnderlineEnabled() )
199           {
200             controller->SetUnderlineEnabled( false );
201             update = true;
202           }
203           break;
204         }
205         case EffectStyle::INPUT:
206         {
207           // Sets the input underline values.
208           // TODO: to be implemented.
209           controller->SetInputUnderlineProperties( properties );
210           break;
211         }
212       }
213     }
214   }
215
216   return update;
217 }
218
219 void GetUnderlineProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
220 {
221   if( controller )
222   {
223     switch( type )
224     {
225       case EffectStyle::DEFAULT:
226       {
227         const bool enabled = controller->IsUnderlineEnabled();
228         const Vector4& color = controller->GetUnderlineColor();
229         const float height = controller->GetUnderlineHeight();
230
231         std::string underlineProperties = "{\"enable\":";
232         const std::string enabledStr = enabled ? "true" : "false";
233         underlineProperties += "\"" + enabledStr + "\",";
234
235         std::string colorStr;
236         Vector4ToColorString( color, colorStr );
237         underlineProperties += "\"color\":\"" + colorStr + "\",";
238
239         std::string heightStr;
240         FloatToString( height, heightStr );
241         underlineProperties += "\"height\":\"" + heightStr + "\"}";
242
243         value = underlineProperties;
244         break;
245       }
246       case EffectStyle::INPUT:
247       {
248         value = controller->GetInputUnderlineProperties();
249         break;
250       }
251     }
252   }
253 }
254
255 bool SetShadowProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
256 {
257   bool update = false;
258
259   if( controller )
260   {
261     const std::string properties = value.Get< std::string >();
262
263     bool colorDefined = false;
264     Vector4 color;
265     bool offsetDefined = false;
266     Vector2 offset;
267
268     const bool empty = ParseProperties( properties,
269                                         colorDefined,
270                                         color,
271                                         offsetDefined,
272                                         offset );
273
274     if( !empty )
275     {
276       switch( type )
277       {
278         case EffectStyle::DEFAULT:
279         {
280           // Sets the default shadow values.
281           if( colorDefined && ( controller->GetShadowColor() != color ) )
282           {
283             controller->SetShadowColor( color );
284             update = true;
285           }
286
287           if( offsetDefined && ( controller->GetShadowOffset() != offset ) )
288           {
289             controller->SetShadowOffset( offset );
290             update = true;
291           }
292           break;
293         }
294         case EffectStyle::INPUT:
295         {
296           // Sets the input shadow values.
297           // TODO: to be implemented.
298           break;
299         }
300       }
301     }
302     else
303     {
304       switch( type )
305       {
306         case EffectStyle::DEFAULT:
307         {
308           // Disable shadow.
309           if( Vector2::ZERO != controller->GetShadowOffset() )
310           {
311             controller->SetShadowOffset( Vector2::ZERO );
312           }
313           break;
314         }
315         case EffectStyle::INPUT:
316         {
317           // Sets the input shadow values.
318           // TODO: to be implemented.
319           controller->SetInputShadowProperties( properties );
320           break;
321         }
322       }
323     }
324   }
325
326   return update;
327 }
328
329 void GetShadowProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
330 {
331   if( controller )
332   {
333     switch( type )
334     {
335       case EffectStyle::DEFAULT:
336       {
337         const Vector4& color = controller->GetShadowColor();
338         const Vector2& offset = controller->GetShadowOffset();
339
340         std::string shadowProperties = "{";
341
342         std::string colorStr;
343         Vector4ToColorString( color, colorStr );
344         shadowProperties += "\"color\":\"" + colorStr + "\",";
345
346         std::string offsetStr;
347         Vector2ToString( offset, offsetStr );
348         shadowProperties += "\"offset\":\"" + offsetStr + "\"}";
349
350         value = shadowProperties;
351         break;
352       }
353       case EffectStyle::INPUT:
354       {
355         value = controller->GetInputShadowProperties();
356         break;
357       }
358     }
359   }
360 }
361
362 bool SetEmbossProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
363 {
364   bool update = false;
365
366   if( controller )
367   {
368     const std::string properties = value.Get< std::string >();
369
370     switch( type )
371     {
372       case EffectStyle::DEFAULT:
373       {
374         // Stores the default emboss's properties string to be recovered by the GetEmbossProperties() function.
375         controller->SetDefaultEmbossProperties( properties );
376         break;
377       }
378       case EffectStyle::INPUT:
379       {
380         // Stores the input emboss's properties string to be recovered by the GetEmbossProperties() function.
381         controller->SetInputEmbossProperties( properties );
382         break;
383       }
384     }
385   }
386
387   return update;
388 }
389
390 void GetEmbossProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
391 {
392   if( controller )
393   {
394     switch( type )
395     {
396       case EffectStyle::DEFAULT:
397       {
398         value = controller->GetDefaultEmbossProperties();
399         break;
400       }
401       case EffectStyle::INPUT:
402       {
403         value = controller->GetInputEmbossProperties();
404         break;
405       }
406     }
407   }
408 }
409
410 bool SetOutlineProperties( ControllerPtr controller, const Property::Value& value, EffectStyle::Type type )
411 {
412   bool update = false;
413
414   if( controller )
415   {
416     const std::string properties = value.Get< std::string >();
417
418     switch( type )
419     {
420       case EffectStyle::DEFAULT:
421       {
422         // Stores the default outline's properties string to be recovered by the GetOutlineProperties() function.
423         controller->SetDefaultOutlineProperties( properties );
424         break;
425       }
426       case EffectStyle::INPUT:
427       {
428         // Stores the input outline's properties string to be recovered by the GetOutlineProperties() function.
429         controller->SetInputOutlineProperties( properties );
430         break;
431       }
432     }
433   }
434
435   return update;
436 }
437
438 void GetOutlineProperties( ControllerPtr controller, Property::Value& value, EffectStyle::Type type )
439 {
440   if( controller )
441   {
442     switch( type )
443     {
444       case EffectStyle::DEFAULT:
445       {
446         value = controller->GetDefaultOutlineProperties();
447         break;
448       }
449       case EffectStyle::INPUT:
450       {
451         value = controller->GetInputOutlineProperties();
452         break;
453       }
454     }
455   }
456 }
457
458 } // namespace Text
459
460 } // namespace Toolkit
461
462 } // namespace Dali