dali-toolkit/internal/builder/builder-set-property.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 // EXTERNAL INCLUDES
  19 #include <sstream>
  20 #include <dali/public-api/object/property-array.h>
  21 #include <dali/public-api/object/property-map.h>
  22 #include <dali/devel-api/adaptor-framework/color-controller.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali-toolkit/internal/builder/builder-impl.h>
  26 #include <dali-toolkit/internal/builder/builder-get-is.inl.h>
  27 #include <dali-toolkit/internal/builder/replacement.h>
  28
  29
  30 namespace Dali
  31 {
  32
  33 namespace Toolkit
  34 {
  35
  36 namespace Internal
  37 {
  38
  39 /*
  40  * Set a property value from a tree node.
  41  * This function guesses the type of the property from the format of the string in the node.
  42  * This is not always possible and could be surprising.
  43  * @param node  The node string to convert from
  44  * @param value The property value to set
  45  * @return true if the string could be converted.
  46  */
  47 bool SetPropertyFromNode( const TreeNode& node, Property::Value& value );
  48
  49 /*
  50  * Set a property value from a tree node as SetPropertyFromNode() above
  51  * @param node  The node string to convert from
  52  * @param value The property value to set
  53  * @param replacement The overriding replacement map (if any)
  54  * @return true if the string could be converted.
  55  */
  56 bool SetPropertyFromNode( const TreeNode& node, Property::Value& value,
  57                           const Replacement& replacement );
  58
  59 /*
  60  * Set a property value as the given type from a tree node.
  61  * @param node The node string to convert from
  62  * @param type The property type to convert to.
  63  * @param value The property value to set
  64  * @return true if the string could be converted to the correct type.
  65  */
  66 bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value );
  67
  68 /*
  69  * Set a property value as the given type from a tree node as SetPropertyFromNode() above
  70  * @param node The node string to convert from
  71  * @param type The property type to convert to.
  72  * @param value The property value to set
  73  * @param replacement The overriding replacement map (if any)
  74  * @return true if the string could be converted to the correct type.
  75  */
  76 bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value,
  77                           const Replacement& replacement );
  78
  79
  80 namespace
  81 {
  82
  83 /**
  84  * Converts a HTML style 'color' hex string ("#FF0000" for bright red) to a Vector4.
  85  * The Vector4 alpha component will be set to 1.0f
  86  * @param hexString The HTML style hex string
  87  * @return a Vector4 containing the new color value
  88  */
  89 Vector4 HexStringToVector4( const char* s )
  90 {
  91   unsigned int value(0u);
  92   std::istringstream( s ) >> std::hex >> value;
  93   return Vector4( ((value >> 16 ) & 0xff ) / 255.0f,
  94                   ((value >> 8 ) & 0xff ) / 255.0f,
  95                   (value & 0xff ) / 255.0f,
  96                   1.0f );
  97 }
  98
  99 } // anon namespace
 100
 101
 102 /**
 103  * A property value type can be forced when its unknown by a disambiguation convention in the json
 104  * ie  "myarray": [1,2,3,4] ; would be a vector but
 105  *     "myarray": {'type-cast':'array', 'value':[1,2,3,4]} would be an array
 106  * @param child The node whos string to search for a disambiguated type
 107  * @param value The value to set
 108  * @param overrideMap The user overriding constant map
 109  * @param defaultMap The default map.
 110  * @return True if child contained a disambiguated string that could be converted.
 111  */
 112 bool Disambiguated(const TreeNode& child, // ConstantLut& constantLut,
 113                    Dali::Property::Value& value,
 114                    const Replacement& replacement )
 115 {
 116   OptionalString childType = IsString( IsChild(child, "type-cast") );
 117   OptionalChild childValue = IsChild(child, "value");
 118
 119   if( childType && childValue && (2 == child.Size()) )
 120   {
 121     // this case allows disambiguation but normally the type is guessed
 122     // 2 == child.count() is an extra check as the user could have a user dictionary/map with
 123     // type-cast and value keys. If they do then a work around is to add a bogus key to not run this case.
 124     if(*childType == "boolean")
 125     {
 126       return SetPropertyFromNode( *childValue, Dali::Property::BOOLEAN, value, replacement);
 127     }
 128     else if(*childType == "float")
 129     {
 130       return SetPropertyFromNode( *childValue, Dali::Property::FLOAT, value, replacement);
 131     }
 132     else if(*childType == "vector2")
 133     {
 134       return SetPropertyFromNode( *childValue, Dali::Property::VECTOR2, value, replacement);
 135     }
 136     else if(*childType == "vector3")
 137     {
 138       return SetPropertyFromNode( *childValue, Dali::Property::VECTOR3, value, replacement);
 139     }
 140     else if(*childType == "vector4")
 141     {
 142       return SetPropertyFromNode( *childValue, Dali::Property::VECTOR4, value, replacement);
 143     }
 144     else if(*childType == "rotation")
 145     {
 146       return SetPropertyFromNode( *childValue, Dali::Property::ROTATION, value, replacement);
 147     }
 148     else if(*childType == "rect")
 149     {
 150       return SetPropertyFromNode( *childValue, Dali::Property::RECTANGLE, value, replacement);
 151     }
 152     else if(*childType == "string")
 153     {
 154       return SetPropertyFromNode( *childValue, Dali::Property::STRING, value, replacement);
 155     }
 156     else if(*childType == "map")
 157     {
 158       return SetPropertyFromNode( *childValue, Dali::Property::MAP, value, replacement);
 159     }
 160     else if(*childType == "array")
 161     {
 162       return SetPropertyFromNode( *childValue, Dali::Property::ARRAY, value, replacement);
 163     }
 164   }
 165
 166   // else we failed to disambiguate
 167   return false;
 168 }
 169
 170
 171 bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value)
 172 {
 173   Replacement noReplacement;
 174   return SetPropertyFromNode( node, type, value, noReplacement );
 175 }
 176
 177 bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value,
 178                           const Replacement& replacer )
 179 {
 180   bool done = false;
 181
 182   switch(type)
 183   {
 184     case Property::BOOLEAN:
 185     {
 186       if( OptionalBoolean v = replacer.IsBoolean(node) )
 187       {
 188         value = *v;
 189         done = true;
 190       }
 191       break;
 192     }
 193     case Property::FLOAT:
 194     {
 195       if( OptionalFloat v = replacer.IsFloat(node) )
 196       {
 197         value = *v;
 198         done = true;
 199       }
 200       break;
 201     }
 202     case Property::INTEGER:
 203     {
 204       if( OptionalInteger v = replacer.IsInteger(node) )
 205       {
 206         value = *v;
 207         done = true;
 208       }
 209       break;
 210     }
 211     case Property::VECTOR2:
 212     {
 213       if( OptionalVector2 v = replacer.IsVector2(node) )
 214       {
 215         value = *v;
 216         done = true;
 217       }
 218       break;
 219     }
 220     case Property::VECTOR3:
 221     {
 222       if( OptionalVector3 v = replacer.IsVector3(node) )
 223       {
 224         value = *v;
 225         done = true;
 226       }
 227       break;
 228     }
 229     case Property::VECTOR4:
 230     {
 231       if( OptionalVector4 v = replacer.IsVector4(node) )
 232       {
 233         value = *v;
 234         done = true;
 235       }
 236       else if( OptionalString s = replacer.IsString(node) )
 237       {
 238         if( (*s)[0] == '#' && 7 == (*s).size() )
 239         {
 240           value = HexStringToVector4( &(*s)[1] );
 241           done = true;
 242         }
 243         else if( Dali::ColorController::Get() )
 244         {
 245           Vector4 color;
 246           done = Dali::ColorController::Get().RetrieveColor( *s, color );
 247           value = color;
 248         }
 249       }
 250       else if( TreeNode::OBJECT == node.GetType() )
 251       {
 252         // check for "r", "g" and "b" child color component nodes
 253         OptionalInteger r = replacer.IsInteger( IsChild(node, "r") );
 254         OptionalInteger g = replacer.IsInteger( IsChild(node, "g") );
 255         OptionalInteger b = replacer.IsInteger( IsChild(node, "b") );
 256         if( r && g && b )
 257         {
 258           float red( (*r) * (1.0f/255.0f) );
 259           float green( (*g) * (1.0f/255.0f) );
 260           float blue( (*b) * (1.0f/255.0f) );
 261           // check for optional "a" (alpha) node, default to fully opaque if it is not found.
 262           float alpha( 1.0f );
 263           OptionalInteger a = replacer.IsInteger( IsChild(node, "a") );
 264           if( a )
 265           {
 266             alpha = (*a) * (1.0f/255.0f);
 267           }
 268           value = Vector4( red, green, blue, alpha );
 269           done = true;
 270         }
 271       }
 272       break;
 273     }
 274     case Property::MATRIX3:
 275     {
 276       if( OptionalMatrix3 v = replacer.IsMatrix3(node) )
 277       {
 278         value = *v;
 279         done = true;
 280       }
 281       break;
 282     }
 283     case Property::MATRIX:
 284     {
 285       if( OptionalMatrix v = replacer.IsMatrix(node) )
 286       {
 287         value = *v;
 288         done = true;
 289       }
 290       break;
 291     }
 292     case Property::RECTANGLE:
 293     {
 294       if( OptionalRect v = replacer.IsRect(node) )
 295       {
 296         value = *v;
 297         done = true;
 298       }
 299       break;
 300     }
 301     case Property::ROTATION:
 302     {
 303       if(4 == node.Size())
 304       {
 305         if( OptionalVector4 ov = replacer.IsVector4(node) )
 306         {
 307           const Vector4& v = *ov;
 308           // angle, axis as per spec
 309           value = Quaternion(Radian(Degree(v[3])),
 310                              Vector3(v[0],v[1],v[2]));
 311           done = true;
 312         }
 313       }
 314       else
 315       {
 316         // degrees Euler as per spec
 317         if( OptionalVector3 v = replacer.IsVector3(node) )
 318         {
 319           value = Quaternion(Radian(Degree((*v).x)),
 320                              Radian(Degree((*v).y)),
 321                              Radian(Degree((*v).z)));
 322           done = true;
 323         }
 324       }
 325       break;
 326     }
 327     case Property::STRING:
 328     {
 329       if( OptionalString v = replacer.IsString(node) )
 330       {
 331         value = *v;
 332         done = true;
 333       }
 334       break;
 335     }
 336     case Property::ARRAY:
 337     {
 338       if( replacer.IsArray( node, value ) )
 339       {
 340         done = true;
 341       }
 342       else if(node.Size())
 343       {
 344         value = Property::Value(Property::ARRAY);
 345         Property::Array* array = value.GetArray();
 346         unsigned int i = 0;
 347         TreeNode::ConstIterator iter(node.CBegin());
 348         for( ; i < node.Size(); ++i, ++iter)
 349         {
 350           Property::Value childValue;
 351           if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 352           {
 353             array->PushBack( childValue );
 354           }
 355         }
 356
 357         if( array->Count() == node.Size() )
 358         {
 359           done = true;
 360         }
 361         else
 362         {
 363           done = false;
 364         }
 365       }
 366       break;
 367     }
 368     case Property::MAP:
 369     {
 370       if( replacer.IsMap( node, value ) )
 371       {
 372         done = true;
 373       }
 374       else if(node.Size())
 375       {
 376         value = Property::Value(Property::MAP);
 377         Property::Map* map = value.GetMap();
 378         unsigned int i = 0;
 379         TreeNode::ConstIterator iter(node.CBegin());
 380         for( ; i < node.Size(); ++i, ++iter)
 381         {
 382           Property::Value childValue;
 383           if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 384           {
 385             map->Insert( (*iter).first, childValue );
 386           }
 387         }
 388
 389         if( map->Count() == node.Size() )
 390         {
 391           done = true;
 392         }
 393         else
 394         {
 395           done = false;
 396         }
 397       }
 398       break;
 399     }
 400     case Property::NONE:
 401     {
 402       break;
 403     }
 404   } // switch type
 405
 406   return done;
 407 }
 408
 409 bool SetPropertyFromNode( const TreeNode& node, Property::Value& value )
 410
 411 {
 412   Replacement replacer;
 413   return SetPropertyFromNode( node, value, replacer );
 414 }
 415
 416 bool SetPropertyFromNode( const TreeNode& node, Property::Value& value,
 417                           const Replacement& replacer )
 418 {
 419   bool done = false;
 420
 421   // some values are ambiguous as we have no Property::Type but can be disambiguated in the json
 422
 423   // Currently Rotations and Rectangle must always be disambiguated when a type isnt available
 424   if( Disambiguated( node, value, replacer ) )
 425   {
 426     done = true;
 427   }
 428   else
 429   {
 430     if( node.Size() )
 431     {
 432       // our current heuristic for deciding an array is actually a vector and not say a map
 433       // is to check if the values are all floats
 434       bool allNumbers = true;
 435       for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter)
 436       {
 437         OptionalFloat f = IsFloat((*iter).second);
 438         if(!f)
 439         {
 440           allNumbers = false;
 441           break;
 442         }
 443       }
 444
 445       if( allNumbers )
 446       {
 447         // prefer finding vectors over presuming composite Property::Array...
 448         if( OptionalMatrix v = IsMatrix(node) )
 449         {
 450           value = *v;
 451           done = true;
 452         }
 453         else if( OptionalMatrix3 v = IsMatrix3(node) )
 454         {
 455           value = *v;
 456           done = true;
 457         }
 458         else if( OptionalVector4 v = IsVector4(node) )
 459         {
 460           value = *v;
 461           done = true;
 462         }
 463         else if( OptionalVector3 v = IsVector3(node) )
 464         {
 465           value = *v;
 466           done = true;
 467         }
 468         else if( OptionalVector2 v = IsVector2(node) )
 469         {
 470           value = *v;
 471           done = true;
 472         }
 473         else if( 4 == node.Size() )
 474         {
 475           if( OptionalVector4 v = IsVector4(node) )
 476           {
 477             value = *v;
 478             done = true;
 479           }
 480         }
 481         else
 482         {
 483           value = Property::Value(Property::ARRAY);
 484           Property::Array* array = value.GetArray();
 485
 486           for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter)
 487           {
 488             Property::Value childValue;
 489             if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 490             {
 491               array->PushBack( childValue );
 492               done = true;
 493             }
 494           }
 495         }
 496       }
 497
 498       if(!done)
 499       {
 500         // presume an array or map
 501         // container of size 1
 502         TreeNode::ConstIterator iter = node.CBegin();
 503
 504         // its seems legal with current json parser for a map to have an empty key
 505         // but here we take that to mean the structure is a list
 506         if( ((*iter).first) == 0 )
 507         {
 508           value = Property::Value(Property::ARRAY);
 509           Property::Array* array = value.GetArray();
 510           for(unsigned int i = 0; i < node.Size(); ++i, ++iter)
 511           {
 512             Property::Value childValue;
 513             if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 514             {
 515               array->PushBack( childValue );
 516               done = true;
 517             }
 518           }
 519         }
 520         else
 521         {
 522           value = Property::Value(Property::MAP);
 523           Property::Map* map = value.GetMap();
 524           for(unsigned int i = 0; i < node.Size(); ++i, ++iter)
 525           {
 526             Property::Value childValue;
 527             if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 528             {
 529               map->Insert( (*iter).first, childValue );
 530               done = true;
 531             }
 532           }
 533         }
 534       } // if!done
 535     } // if node.size()
 536     else // if( 0 == node.size() )
 537     {
 538       // no children so either one of bool, float, integer, string
 539       OptionalBoolean aBool    = replacer.IsBoolean(node);
 540       OptionalInteger anInt    = replacer.IsInteger(node);
 541       OptionalFloat   aFloat   = replacer.IsFloat(node);
 542       OptionalString  aString  = replacer.IsString(node);
 543
 544       if(aBool)
 545       {
 546         // a bool is also an int but here we presume int
 547         if(anInt)
 548         {
 549           value = *anInt;
 550           done = true;
 551         }
 552         else
 553         {
 554           value = *aBool;
 555           done = true;
 556         }
 557       }
 558       else
 559       {
 560         // Note: These are both floats and strings
 561         // {"value":"123"}
 562         // {"value":123}
 563         // This means we can't have a string with purely numeric content without disambiguation.
 564         if(aFloat)
 565         {
 566           value = *aFloat;
 567           done = true;
 568         }
 569         else if(anInt)
 570         {
 571           value = *anInt;
 572           done = true;
 573         }
 574         else
 575         {
 576           // string always succeeds with the current json parser so its last
 577           value = *aString;
 578           done = true;
 579         }
 580
 581       } // if aBool
 582
 583     } // if( node.size() )
 584
 585   } // if Disambiguated()
 586
 587   return done;
 588 } // bool SetPropertyFromNode( const TreeNode& node, Property::Value& value )
 589
 590
 591 } // namespace Internal
 592
 593 } // namespace Toolkit
 594
 595 } // namespace Dali