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
 347         unsigned int i = 0;
 348         TreeNode::ConstIterator iter(node.CBegin());
 349
 350         if( array )
 351         {
 352           for( ; i < node.Size(); ++i, ++iter)
 353           {
 354             Property::Value childValue;
 355             if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 356             {
 357               array->PushBack( childValue );
 358             }
 359           }
 360
 361           if( array->Count() == node.Size() )
 362           {
 363             done = true;
 364           }
 365           else
 366           {
 367             done = false;
 368           }
 369         }
 370       }
 371       break;
 372     }
 373     case Property::MAP:
 374     {
 375       if( replacer.IsMap( node, value ) )
 376       {
 377         done = true;
 378       }
 379       else if(node.Size())
 380       {
 381         value = Property::Value(Property::MAP);
 382         Property::Map* map = value.GetMap();
 383
 384         unsigned int i = 0;
 385         TreeNode::ConstIterator iter(node.CBegin());
 386
 387         if( map )
 388         {
 389           for( ; i < node.Size(); ++i, ++iter)
 390           {
 391             Property::Value childValue;
 392             if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 393             {
 394               map->Insert( (*iter).first, childValue );
 395             }
 396           }
 397
 398           if( map->Count() == node.Size() )
 399           {
 400             done = true;
 401           }
 402           else
 403           {
 404             done = false;
 405           }
 406         }
 407       }
 408       break;
 409     }
 410     case Property::NONE:
 411     {
 412       break;
 413     }
 414   } // switch type
 415
 416   return done;
 417 }
 418
 419 bool SetPropertyFromNode( const TreeNode& node, Property::Value& value )
 420
 421 {
 422   Replacement replacer;
 423   return SetPropertyFromNode( node, value, replacer );
 424 }
 425
 426 bool SetPropertyFromNode( const TreeNode& node, Property::Value& value,
 427                           const Replacement& replacer )
 428 {
 429   bool done = false;
 430
 431   // some values are ambiguous as we have no Property::Type but can be disambiguated in the json
 432
 433   // Currently Rotations and Rectangle must always be disambiguated when a type isnt available
 434   if( Disambiguated( node, value, replacer ) )
 435   {
 436     done = true;
 437   }
 438   else
 439   {
 440     if( node.Size() )
 441     {
 442       // our current heuristic for deciding an array is actually a vector and not say a map
 443       // is to check if the values are all floats
 444       bool allNumbers = true;
 445       for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter)
 446       {
 447         OptionalFloat f = IsFloat((*iter).second);
 448         if(!f)
 449         {
 450           allNumbers = false;
 451           break;
 452         }
 453       }
 454
 455       if( allNumbers )
 456       {
 457         // prefer finding vectors over presuming composite Property::Array...
 458         if( OptionalMatrix v = IsMatrix(node) )
 459         {
 460           value = *v;
 461           done = true;
 462         }
 463         else if( OptionalMatrix3 v = IsMatrix3(node) )
 464         {
 465           value = *v;
 466           done = true;
 467         }
 468         else if( OptionalVector4 v = IsVector4(node) )
 469         {
 470           value = *v;
 471           done = true;
 472         }
 473         else if( OptionalVector3 v = IsVector3(node) )
 474         {
 475           value = *v;
 476           done = true;
 477         }
 478         else if( OptionalVector2 v = IsVector2(node) )
 479         {
 480           value = *v;
 481           done = true;
 482         }
 483         else if( 4 == node.Size() )
 484         {
 485           if( OptionalVector4 v = IsVector4(node) )
 486           {
 487             value = *v;
 488             done = true;
 489           }
 490         }
 491         else
 492         {
 493           value = Property::Value(Property::ARRAY);
 494           Property::Array* array = value.GetArray();
 495
 496           if( array )
 497           {
 498             for(TreeConstIter iter = node.CBegin(); iter != node.CEnd(); ++iter)
 499             {
 500               Property::Value childValue;
 501               if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 502               {
 503                 array->PushBack( childValue );
 504                 done = true;
 505               }
 506             }
 507           }
 508         }
 509       }
 510
 511       if(!done)
 512       {
 513         // presume an array or map
 514         // container of size 1
 515         TreeNode::ConstIterator iter = node.CBegin();
 516
 517         // its seems legal with current json parser for a map to have an empty key
 518         // but here we take that to mean the structure is a list
 519         if( ((*iter).first) == 0 )
 520         {
 521           value = Property::Value(Property::ARRAY);
 522           Property::Array* array = value.GetArray();
 523
 524           if( array )
 525           {
 526             for(unsigned int i = 0; i < node.Size(); ++i, ++iter)
 527             {
 528               Property::Value childValue;
 529               if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 530               {
 531                 array->PushBack( childValue );
 532                 done = true;
 533               }
 534             }
 535           }
 536         }
 537         else
 538         {
 539           value = Property::Value(Property::MAP);
 540           Property::Map* map = value.GetMap();
 541
 542           if( map )
 543           {
 544             for(unsigned int i = 0; i < node.Size(); ++i, ++iter)
 545             {
 546               Property::Value childValue;
 547               if( SetPropertyFromNode( (*iter).second, childValue, replacer ) )
 548               {
 549                 map->Insert( (*iter).first, childValue );
 550                 done = true;
 551               }
 552             }
 553           }
 554         }
 555       } // if!done
 556     } // if node.size()
 557     else // if( 0 == node.size() )
 558     {
 559       // no children so either one of bool, float, integer, string
 560       OptionalBoolean aBool    = replacer.IsBoolean(node);
 561       OptionalInteger anInt    = replacer.IsInteger(node);
 562       OptionalFloat   aFloat   = replacer.IsFloat(node);
 563       OptionalString  aString  = replacer.IsString(node);
 564
 565       if(aBool)
 566       {
 567         // a bool is also an int but here we presume int
 568         if(anInt)
 569         {
 570           value = *anInt;
 571           done = true;
 572         }
 573         else
 574         {
 575           value = *aBool;
 576           done = true;
 577         }
 578       }
 579       else
 580       {
 581         // Note: These are both floats and strings
 582         // {"value":"123"}
 583         // {"value":123}
 584         // This means we can't have a string with purely numeric content without disambiguation.
 585         if(aFloat)
 586         {
 587           value = *aFloat;
 588           done = true;
 589         }
 590         else if(anInt)
 591         {
 592           value = *anInt;
 593           done = true;
 594         }
 595         else
 596         {
 597           // string always succeeds with the current json parser so its last
 598           value = *aString;
 599           done = true;
 600         }
 601
 602       } // if aBool
 603
 604     } // if( node.size() )
 605
 606   } // if Disambiguated()
 607
 608   return done;
 609 } // bool SetPropertyFromNode( const TreeNode& node, Property::Value& value )
 610
 611
 612 } // namespace Internal
 613
 614 } // namespace Toolkit
 615
 616 } // namespace Dali