dali/public-api/scripting/scripting.cpp

   1 /*
   2  * Copyright (c) 2014 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/public-api/scripting/scripting.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/actors/actor.h>
  23 #include <dali/public-api/images/image.h>
  24 #include <dali/public-api/images/image-attributes.h>
  25 #include <dali/public-api/object/type-registry.h>
  26 #include <dali/internal/event/images/image-impl.h>
  27 #include <dali/internal/event/images/frame-buffer-image-impl.h>
  28 #include <dali/internal/event/images/bitmap-image-impl.h>
  29 #include <dali/internal/event/effects/shader-effect-impl.h>
  30
  31 namespace Dali
  32 {
  33
  34 namespace Scripting
  35 {
  36
  37 namespace
  38 {
  39
  40 // Tables used here for converting strings to the enumerations and vice versa
  41
  42 const StringEnum< ColorMode > COLOR_MODE_TABLE[] =
  43 {
  44   { "USE_OWN_COLOR",                    USE_OWN_COLOR                    },
  45   { "USE_PARENT_COLOR",                 USE_PARENT_COLOR                 },
  46   { "USE_OWN_MULTIPLY_PARENT_COLOR",    USE_OWN_MULTIPLY_PARENT_COLOR    },
  47   { "USE_OWN_MULTIPLY_PARENT_ALPHA",    USE_OWN_MULTIPLY_PARENT_ALPHA    },
  48 };
  49 const unsigned int COLOR_MODE_TABLE_COUNT = sizeof( COLOR_MODE_TABLE ) / sizeof( COLOR_MODE_TABLE[0] );
  50
  51 const StringEnum< PositionInheritanceMode > POSITION_INHERITANCE_MODE_TABLE[] =
  52 {
  53   { "INHERIT_PARENT_POSITION",                    INHERIT_PARENT_POSITION                    },
  54   { "USE_PARENT_POSITION",                        USE_PARENT_POSITION                        },
  55   { "USE_PARENT_POSITION_PLUS_LOCAL_POSITION",    USE_PARENT_POSITION_PLUS_LOCAL_POSITION    },
  56   { "DONT_INHERIT_POSITION",                      DONT_INHERIT_POSITION                      },
  57 };
  58 const unsigned int POSITION_INHERITANCE_MODE_TABLE_COUNT = sizeof( POSITION_INHERITANCE_MODE_TABLE ) / sizeof( POSITION_INHERITANCE_MODE_TABLE[0] );
  59
  60 const StringEnum< DrawMode::Type > DRAW_MODE_TABLE[] =
  61 {
  62   { "NORMAL",     DrawMode::NORMAL     },
  63   { "OVERLAY",    DrawMode::OVERLAY    },
  64   { "STENCIL",    DrawMode::STENCIL    },
  65 };
  66 const unsigned int DRAW_MODE_TABLE_COUNT = sizeof( DRAW_MODE_TABLE ) / sizeof( DRAW_MODE_TABLE[0] );
  67
  68 const StringEnum< Vector3 > ANCHOR_CONSTANT_TABLE[] =
  69 {
  70   { "BACK_TOP_LEFT",          ParentOrigin::BACK_TOP_LEFT          },
  71   { "BACK_TOP_CENTER",        ParentOrigin::BACK_TOP_CENTER        },
  72   { "BACK_TOP_RIGHT",         ParentOrigin::BACK_TOP_RIGHT         },
  73   { "BACK_CENTER_LEFT",       ParentOrigin::BACK_CENTER_LEFT       },
  74   { "BACK_CENTER",            ParentOrigin::BACK_CENTER            },
  75   { "BACK_CENTER_RIGHT",      ParentOrigin::BACK_CENTER_RIGHT      },
  76   { "BACK_BOTTOM_LEFT",       ParentOrigin::BACK_BOTTOM_LEFT       },
  77   { "BACK_BOTTOM_CENTER",     ParentOrigin::BACK_BOTTOM_CENTER     },
  78   { "BACK_BOTTOM_RIGHT",      ParentOrigin::BACK_BOTTOM_RIGHT      },
  79   { "TOP_LEFT",               ParentOrigin::TOP_LEFT               },
  80   { "TOP_CENTER",             ParentOrigin::TOP_CENTER             },
  81   { "TOP_RIGHT",              ParentOrigin::TOP_RIGHT              },
  82   { "CENTER_LEFT",            ParentOrigin::CENTER_LEFT            },
  83   { "CENTER",                 ParentOrigin::CENTER                 },
  84   { "CENTER_RIGHT",           ParentOrigin::CENTER_RIGHT           },
  85   { "BOTTOM_LEFT",            ParentOrigin::BOTTOM_LEFT            },
  86   { "BOTTOM_CENTER",          ParentOrigin::BOTTOM_CENTER          },
  87   { "BOTTOM_RIGHT",           ParentOrigin::BOTTOM_RIGHT           },
  88   { "FRONT_TOP_LEFT",         ParentOrigin::FRONT_TOP_LEFT         },
  89   { "FRONT_TOP_CENTER",       ParentOrigin::FRONT_TOP_CENTER       },
  90   { "FRONT_TOP_RIGHT",        ParentOrigin::FRONT_TOP_RIGHT        },
  91   { "FRONT_CENTER_LEFT",      ParentOrigin::FRONT_CENTER_LEFT      },
  92   { "FRONT_CENTER",           ParentOrigin::FRONT_CENTER           },
  93   { "FRONT_CENTER_RIGHT",     ParentOrigin::FRONT_CENTER_RIGHT     },
  94   { "FRONT_BOTTOM_LEFT",      ParentOrigin::FRONT_BOTTOM_LEFT      },
  95   { "FRONT_BOTTOM_CENTER",    ParentOrigin::FRONT_BOTTOM_CENTER    },
  96   { "FRONT_BOTTOM_RIGHT",     ParentOrigin::FRONT_BOTTOM_RIGHT     },
  97 };
  98 const unsigned int ANCHOR_CONSTANT_TABLE_COUNT = sizeof( ANCHOR_CONSTANT_TABLE ) / sizeof( ANCHOR_CONSTANT_TABLE[0] );
  99
 100 const StringEnum< Image::LoadPolicy > IMAGE_LOAD_POLICY_TABLE[] =
 101 {
 102   { "IMMEDIATE", Image::Immediate },
 103   { "ON_DEMAND", Image::OnDemand  },
 104 };
 105 const unsigned int IMAGE_LOAD_POLICY_TABLE_COUNT = sizeof( IMAGE_LOAD_POLICY_TABLE ) / sizeof( IMAGE_LOAD_POLICY_TABLE[0] );
 106
 107 const StringEnum< Image::ReleasePolicy > IMAGE_RELEASE_POLICY_TABLE[] =
 108 {
 109   { "UNUSED", Image::Unused },
 110   { "NEVER",  Image::Never  },
 111 };
 112 const unsigned int IMAGE_RELEASE_POLICY_TABLE_COUNT = sizeof( IMAGE_RELEASE_POLICY_TABLE ) / sizeof( IMAGE_RELEASE_POLICY_TABLE[0] );
 113
 114 const StringEnum< Pixel::Format > PIXEL_FORMAT_TABLE[] =
 115 {
 116   { "A8",                                           Pixel::A8                                           },
 117   { "L8",                                           Pixel::L8                                           },
 118   { "LA88",                                         Pixel::LA88                                         },
 119   { "RGB565",                                       Pixel::RGB565                                       },
 120   { "BGR565",                                       Pixel::BGR565                                       },
 121   { "RGBA4444",                                     Pixel::RGBA4444                                     },
 122   { "BGRA4444",                                     Pixel::BGRA4444                                     },
 123   { "RGBA5551",                                     Pixel::RGBA5551                                     },
 124   { "BGRA5551",                                     Pixel::BGRA5551                                     },
 125   { "RGB888",                                       Pixel::RGB888                                       },
 126   { "RGB8888",                                      Pixel::RGB8888                                      },
 127   { "BGR8888",                                      Pixel::BGR8888                                      },
 128   { "RGBA8888",                                     Pixel::RGBA8888                                     },
 129   { "BGRA8888",                                     Pixel::BGRA8888                                     },
 130   { "COMPRESSED_R11_EAC",                           Pixel::COMPRESSED_R11_EAC                           },
 131   { "COMPRESSED_SIGNED_R11_EAC",                    Pixel::COMPRESSED_SIGNED_R11_EAC                    },
 132   { "COMPRESSED_RG11_EAC",                          Pixel::COMPRESSED_RG11_EAC                          },
 133   { "COMPRESSED_SIGNED_RG11_EAC",                   Pixel::COMPRESSED_SIGNED_RG11_EAC                   },
 134   { "COMPRESSED_RGB8_ETC2",                         Pixel::COMPRESSED_RGB8_ETC2                         },
 135   { "COMPRESSED_SRGB8_ETC2",                        Pixel::COMPRESSED_SRGB8_ETC2                        },
 136   { "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2",     Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2     },
 137   { "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2",    Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2    },
 138   { "COMPRESSED_RGBA8_ETC2_EAC",                    Pixel::COMPRESSED_RGBA8_ETC2_EAC                    },
 139   { "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC",             Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC             },
 140   { "COMPRESSED_RGB8_ETC1",                         Pixel::COMPRESSED_RGB8_ETC1                         },
 141   { "COMPRESSED_RGB_PVRTC_4BPPV1",                  Pixel::COMPRESSED_RGB_PVRTC_4BPPV1                  },
 142 };
 143 const unsigned int PIXEL_FORMAT_TABLE_COUNT = sizeof( PIXEL_FORMAT_TABLE ) / sizeof( PIXEL_FORMAT_TABLE[0] );
 144
 145 const StringEnum< ImageAttributes::ScalingMode > IMAGE_SCALING_MODE_TABLE[] =
 146 {
 147   { "SHRINK_TO_FIT", ImageAttributes::ShrinkToFit },
 148   { "SCALE_TO_FILL", ImageAttributes::ScaleToFill },
 149   { "FIT_WIDTH",     ImageAttributes::FitWidth    },
 150   { "FIT_HEIGHT",    ImageAttributes::FitHeight   },
 151 };
 152 const unsigned int IMAGE_SCALING_MODE_TABLE_COUNT = sizeof( IMAGE_SCALING_MODE_TABLE ) / sizeof( IMAGE_SCALING_MODE_TABLE[0] );
 153
 154 } // unnamed namespace
 155
 156 bool CompareEnums(const std::string& a, const std::string& b)
 157 {
 158   std::string::const_iterator ia = a.begin();
 159   std::string::const_iterator ib = b.begin();
 160
 161   while( (ia != a.end()) && (ib != b.end()) )
 162   {
 163     char ca = *ia;
 164     char cb = *ib;
 165
 166     if(ca == '-' || ca == '_')
 167     {
 168       ++ia;
 169       continue;
 170     }
 171
 172     if(cb == '-' || cb == '_')
 173     {
 174       ++ib;
 175       continue;
 176     }
 177
 178     if( 'A' <= ca && ca <= 'Z')
 179     {
 180       ca = ca + ('a' - 'A');
 181     }
 182
 183     if( 'A' <= cb && cb <= 'Z')
 184     {
 185       cb = cb + ('a' - 'A');
 186     }
 187
 188     if( ca != cb )
 189     {
 190       return false;
 191     }
 192
 193     ++ia;
 194     ++ib;
 195   }
 196
 197   if( (ia == a.end() && ib == b.end() ) )
 198   {
 199     return true;
 200   }
 201   else
 202   {
 203     return false;
 204   }
 205
 206 }
 207
 208
 209 ColorMode GetColorMode( const std::string& value )
 210 {
 211   return GetEnumeration< ColorMode >( value, COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT );
 212 }
 213
 214
 215 std::string GetColorMode( ColorMode value )
 216 {
 217   return GetEnumerationName< ColorMode >( value, COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT );
 218 }
 219
 220 PositionInheritanceMode GetPositionInheritanceMode( const std::string& value )
 221 {
 222   return GetEnumeration< PositionInheritanceMode >( value, POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT );
 223 }
 224
 225
 226 std::string GetPositionInheritanceMode( PositionInheritanceMode value )
 227 {
 228   return GetEnumerationName< PositionInheritanceMode >( value, POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT );
 229 }
 230
 231
 232 DrawMode::Type GetDrawMode( const std::string& value )
 233 {
 234   return GetEnumeration< DrawMode::Type >( value, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
 235 }
 236
 237
 238 std::string GetDrawMode( DrawMode::Type value )
 239 {
 240   return GetEnumerationName< DrawMode::Type >( value, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
 241 }
 242
 243
 244 Vector3 GetAnchorConstant( const std::string& value )
 245 {
 246   return GetEnumeration< Vector3 >( value, ANCHOR_CONSTANT_TABLE, ANCHOR_CONSTANT_TABLE_COUNT );
 247 }
 248
 249
 250 Image NewImage( const Property::Value& map )
 251 {
 252   Image ret;
 253
 254   std::string filename;
 255   Image::LoadPolicy loadPolicy       = Dali::Internal::ImageLoadPolicyDefault;
 256   Image::ReleasePolicy releasePolicy = Dali::Internal::ImageReleasePolicyDefault;
 257   ImageAttributes attributes         = ImageAttributes::New();
 258
 259   if( Property::MAP == map.GetType() )
 260   {
 261     std::string field = "filename";
 262     if( map.HasKey(field) )
 263     {
 264       DALI_ASSERT_ALWAYS(map.GetValue(field).GetType() == Property::STRING && "Image filename property is not a string" );
 265       filename = map.GetValue(field).Get<std::string>();
 266     }
 267
 268     field = "load-policy";
 269     if( map.HasKey(field) )
 270     {
 271       DALI_ASSERT_ALWAYS(map.GetValue(field).GetType() == Property::STRING && "Image load-policy property is not a string" );
 272       std::string v(map.GetValue(field).Get<std::string>());
 273       loadPolicy = GetEnumeration< Image::LoadPolicy >( v, IMAGE_LOAD_POLICY_TABLE, IMAGE_LOAD_POLICY_TABLE_COUNT );
 274     }
 275
 276     field = "release-policy";
 277     if( map.HasKey(field) )
 278     {
 279       DALI_ASSERT_ALWAYS(map.GetValue(field).GetType() == Property::STRING && "Image release-policy property is not a string" );
 280       std::string v(map.GetValue(field).Get<std::string>());
 281       releasePolicy = GetEnumeration< Image::ReleasePolicy >( v, IMAGE_RELEASE_POLICY_TABLE, IMAGE_RELEASE_POLICY_TABLE_COUNT );
 282     }
 283
 284     if( map.HasKey("width") && map.HasKey("height") )
 285     {
 286       Property::Value &value = map.GetValue("width");
 287       unsigned int w = 0, h = 0;
 288       // handle floats and integer the same for json script
 289       if( value.GetType() == Property::FLOAT)
 290       {
 291         w = static_cast<unsigned int>( value.Get<float>() );
 292       }
 293       else
 294       {
 295         DALI_ASSERT_ALWAYS(value.GetType() == Property::INTEGER && "Image width property is not a number" );
 296         w = value.Get<int>();
 297       }
 298
 299       value = map.GetValue("height");
 300       if( value.GetType() == Property::FLOAT)
 301       {
 302         h = static_cast<unsigned int>( value.Get<float>() );
 303       }
 304       else
 305       {
 306         DALI_ASSERT_ALWAYS(value.GetType() == Property::INTEGER && "Image width property is not a number" );
 307         h = value.Get<int>();
 308       }
 309
 310       attributes.SetSize( w, h );
 311     }
 312
 313     field = "pixel-format";
 314     if( map.HasKey(field) )
 315     {
 316       DALI_ASSERT_ALWAYS(map.GetValue(field).GetType() == Property::STRING && "Image release-policy property is not a string" );
 317       std::string s(map.GetValue(field).Get<std::string>());
 318       attributes.SetPixelFormat( GetEnumeration< Pixel::Format >( s, PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT ));
 319     }
 320
 321     field = "scaling-mode";
 322     if( map.HasKey(field) )
 323     {
 324       DALI_ASSERT_ALWAYS(map.GetValue(field).GetType() == Property::STRING && "Image release-policy property is not a string" );
 325       std::string s(map.GetValue(field).Get<std::string>());
 326       attributes.SetScalingMode( GetEnumeration< ImageAttributes::ScalingMode >( s, IMAGE_SCALING_MODE_TABLE, IMAGE_SCALING_MODE_TABLE_COUNT ) );
 327     }
 328
 329     if( map.HasKey("type") )
 330     {
 331       DALI_ASSERT_ALWAYS( map.GetValue("type").GetType() == Property::STRING );
 332       std::string s(map.GetValue("type").Get<std::string>());
 333       if("FrameBufferImage" == s)
 334       {
 335         ret = Image( new Internal::FrameBufferImage(attributes.GetWidth(),
 336                                                     attributes.GetHeight(),
 337                                                     attributes.GetPixelFormat(),
 338                                                     releasePolicy) );
 339       }
 340       else if("BitmapImage" == s)
 341       {
 342         ret = Image( new Internal::BitmapImage(attributes.GetWidth(),
 343                                                attributes.GetHeight(),
 344                                                attributes.GetPixelFormat(),
 345                                                loadPolicy,
 346                                                releasePolicy) );
 347       }
 348       else if("Image" == s)
 349       {
 350         ret = Image::New(filename, attributes, loadPolicy, releasePolicy);
 351       }
 352       else
 353       {
 354         DALI_ASSERT_ALWAYS( !"Unknown image type" );
 355       }
 356     }
 357     else
 358     {
 359       ret = Image::New(filename, attributes, loadPolicy, releasePolicy);
 360     }
 361   }
 362
 363   return ret;
 364
 365 } // Image NewImage( Property::Value map )
 366
 367
 368 ShaderEffect NewShaderEffect( const Property::Value& map )
 369 {
 370   Internal::ShaderEffectPtr ret;
 371
 372   if( map.GetType() == Property::MAP )
 373   {
 374     ret = Internal::ShaderEffect::New(Dali::ShaderEffect::HINT_NONE); // hint can be reset if in map
 375
 376     if( map.HasKey("program") )
 377     {
 378       Property::Index index = ret->GetPropertyIndex("program");
 379       DALI_ASSERT_DEBUG( map.GetValue("program").GetType() == Property::MAP );
 380       ret->SetProperty(index, map.GetValue("program"));
 381     }
 382
 383     for(int i = 0; i < map.GetSize(); ++i)
 384     {
 385       const std::string& key = map.GetKey(i);
 386       if(key != "program")
 387       {
 388         Property::Index index = ret->GetPropertyIndex( key );
 389
 390         if( Property::INVALID_INDEX != index )
 391         {
 392           ret->SetProperty(index, map.GetItem(i));
 393         }
 394         else
 395         {
 396           // if its not a property then register it as a uniform (making a custom property)
 397
 398           if(map.GetItem(i).GetType() == Property::INTEGER)
 399           {
 400             // valid uniforms are floats, vec3's etc so we recast if the user accidentally
 401             // set as integer. Note the map could have come from json script.
 402             Property::Value asFloat( static_cast<float>( map.GetItem(i).Get<int>() ) );
 403             ret->SetUniform( key, asFloat, Dali::ShaderEffect::COORDINATE_TYPE_DEFAULT );
 404           }
 405           else
 406           {
 407             ret->SetUniform( key, map.GetItem(i), Dali::ShaderEffect::COORDINATE_TYPE_DEFAULT );
 408           }
 409         }
 410       }
 411     }
 412   }
 413
 414   return Dali::ShaderEffect(ret.Get());
 415 }
 416
 417
 418 Actor NewActor( const Property::Map& map )
 419 {
 420   BaseHandle handle;
 421
 422   // First find type and create Actor
 423   Property::Value* typeValue = map.Find( "type" );
 424   if ( typeValue )
 425   {
 426     TypeInfo type = TypeRegistry::Get().GetTypeInfo( typeValue->Get< std::string >() );
 427     if ( type )
 428     {
 429       handle = type.CreateInstance();
 430     }
 431   }
 432
 433   if ( !handle )
 434   {
 435     DALI_LOG_ERROR( "Actor type not provided, returning empty handle" );
 436     return Actor();
 437   }
 438
 439   Actor actor( Actor::DownCast( handle ) );
 440
 441   if ( actor )
 442   {
 443     // Now set the properties, or create children
 444     for ( unsigned int i = 0, mapCount = map.Count(); i < mapCount; ++i )
 445     {
 446       const StringValuePair& pair( map.GetPair( i ) );
 447       const std::string& key( pair.first );
 448       if ( key == "type" )
 449       {
 450         continue;
 451       }
 452
 453       const Property::Value& value( pair.second );
 454
 455       if ( key == "actors" )
 456       {
 457         // Create children
 458
 459         Property::Array actorArray = value.Get< Property::Array >();
 460         for ( Property::Array::iterator arrayIter = actorArray.begin(), arrayEndIter = actorArray.end(); arrayIter != arrayEndIter; ++arrayIter )
 461         {
 462           actor.Add( NewActor( arrayIter->Get< Property::Map >() ) );
 463         }
 464       }
 465       else if ( key == "signals" )
 466       {
 467         DALI_LOG_ERROR( "signals not supported" );
 468       }
 469       else if( key ==  "parent-origin" )
 470       {
 471         // Parent Origin can be a string constant as well as a Vector3
 472
 473         const Property::Type type( value.GetType() );
 474         if ( type == Property::VECTOR3 )
 475         {
 476           actor.SetParentOrigin( value.Get< Vector3 >() );
 477         }
 478         else if( type == Property::STRING )
 479         {
 480           actor.SetParentOrigin( GetAnchorConstant( value.Get< std::string >() ) );
 481         }
 482       }
 483       else if( key ==  "anchor-point" )
 484       {
 485         // Anchor Point can be a string constant as well as a Vector3
 486
 487         const Property::Type type( value.GetType() );
 488         if ( type == Property::VECTOR3 )
 489         {
 490           actor.SetAnchorPoint( value.Get< Vector3 >() );
 491         }
 492         else if( type == Property::STRING )
 493         {
 494           actor.SetAnchorPoint( GetAnchorConstant( value.Get< std::string >() ) );
 495         }
 496       }
 497       else
 498       {
 499         Property::Index index( actor.GetPropertyIndex( key ) );
 500
 501         if ( index != Property::INVALID_INDEX )
 502         {
 503           actor.SetProperty( index, value );
 504         }
 505       }
 506     }
 507   }
 508
 509   return actor;
 510 }
 511
 512 void CreatePropertyMap( Actor actor, Property::Map& map )
 513 {
 514   map.Clear();
 515
 516   if ( actor )
 517   {
 518     map[ "type" ] = actor.GetTypeName();
 519
 520     // Default properties
 521     Property::IndexContainer indices;
 522     actor.GetPropertyIndices( indices );
 523     const Property::IndexContainer::const_iterator endIter = indices.end();
 524     for ( Property::IndexContainer::iterator iter = indices.begin(); iter != endIter; ++iter )
 525     {
 526       map[ actor.GetPropertyName( *iter ) ] = actor.GetProperty( *iter );
 527     }
 528
 529     // Children
 530     unsigned int childCount( actor.GetChildCount() );
 531     if ( childCount )
 532     {
 533       Property::Array childArray;
 534       for ( unsigned int child = 0; child < childCount; ++child )
 535       {
 536         Property::Map childMap;
 537         CreatePropertyMap( actor.GetChildAt( child ), childMap );
 538         childArray.push_back( childMap );
 539       }
 540       map[ "actors" ] = childArray;
 541     }
 542   }
 543 }
 544
 545 void CreatePropertyMap( Image image, Property::Map& map )
 546 {
 547   map.Clear();
 548
 549   if ( image )
 550   {
 551     std::string imageType( "Image" );
 552
 553     // Get Type - cannot use TypeRegistry as Image is not a ProxyObject and thus, not registered
 554     if ( BitmapImage::DownCast( image ) )
 555     {
 556       imageType = "BitmapImage";
 557     }
 558     else if ( FrameBufferImage::DownCast( image ) )
 559     {
 560       imageType = "FrameBufferImage";
 561     }
 562
 563     map[ "type" ] = imageType;
 564     map[ "filename" ] = image.GetFilename();
 565     map[ "load-policy" ] = GetEnumerationName< Image::LoadPolicy >( image.GetLoadPolicy(), IMAGE_LOAD_POLICY_TABLE, IMAGE_LOAD_POLICY_TABLE_COUNT );
 566     map[ "release-policy" ] = GetEnumerationName< Image::ReleasePolicy >( image.GetReleasePolicy(), IMAGE_RELEASE_POLICY_TABLE, IMAGE_RELEASE_POLICY_TABLE_COUNT );
 567
 568     ImageAttributes attributes( image.GetAttributes() );
 569     map[ "pixel-format" ] = GetEnumerationName< Pixel::Format >( attributes.GetPixelFormat(), PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT );
 570     map[ "scaling-mode" ] = GetEnumerationName< ImageAttributes::ScalingMode >( attributes.GetScalingMode(), IMAGE_SCALING_MODE_TABLE, IMAGE_SCALING_MODE_TABLE_COUNT );
 571
 572     int width( image.GetWidth() );
 573     int height( image.GetHeight() );
 574
 575     if ( width && height )
 576     {
 577       map[ "width" ] = width;
 578       map[ "height" ] = height;
 579     }
 580   }
 581 }
 582
 583 } // namespace scripting
 584
 585 } // namespace Dali
 586
 587
 588
 589