-//
-// Copyright (c) 2014 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Flora License, Version 1.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://floralicense.org/license/
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
// CLASS HEADER
#include <dali/internal/event/actors/image-actor-impl.h>
// INTERNAL INCLUDES
#include <dali/public-api/object/type-registry.h>
-#include <dali/internal/event/common/property-index-ranges.h>
-#include <dali/internal/event/images/image-connector.h>
#include <dali/public-api/scripting/scripting.h>
+#include <dali/internal/event/common/property-helper.h>
+#include <dali/internal/event/images/image-connector.h>
+#include <dali/internal/event/images/nine-patch-image-impl.h>
namespace Dali
{
-const Property::Index ImageActor::PIXEL_AREA = RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT;
-const Property::Index ImageActor::FADE_IN = RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT + 1;
-const Property::Index ImageActor::FADE_IN_DURATION = RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT + 2;
-const Property::Index ImageActor::STYLE = RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT + 3;
-const Property::Index ImageActor::BORDER = RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT + 4;
-const Property::Index ImageActor::IMAGE = RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT + 5;
-
namespace Internal
{
-bool ImageActor::mFirstInstance = true;
-Actor::DefaultPropertyLookup* ImageActor::mDefaultImageActorPropertyLookup = NULL;
namespace
{
+// Properties
+
+// Name Type writable animatable constraint-input enum for index-checking
+DALI_PROPERTY_TABLE_BEGIN
+DALI_PROPERTY( "pixel-area", RECTANGLE, true, false, true, Dali::ImageActor::Property::PIXEL_AREA )
+DALI_PROPERTY( "style", STRING, true, false, true, Dali::ImageActor::Property::STYLE )
+DALI_PROPERTY( "border", VECTOR4, true, false, true, Dali::ImageActor::Property::BORDER )
+DALI_PROPERTY( "image", MAP, true, false, false, Dali::ImageActor::Property::IMAGE )
+DALI_PROPERTY_TABLE_END( DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX )
+
BaseHandle Create()
{
return Dali::ImageActor::New();
}
-TypeRegistration mType( typeid(Dali::ImageActor), typeid(Dali::RenderableActor), Create );
-
-const std::string DEFAULT_IMAGE_ACTOR_PROPERTY_NAMES[] =
-{
- "pixel-area",
- "fade-in",
- "fade-in-duration",
- "style",
- "border",
- "image"
-};
-const int DEFAULT_IMAGE_ACTOR_PROPERTY_COUNT = sizeof( DEFAULT_IMAGE_ACTOR_PROPERTY_NAMES ) / sizeof( std::string );
-
-const Property::Type DEFAULT_IMAGE_ACTOR_PROPERTY_TYPES[DEFAULT_IMAGE_ACTOR_PROPERTY_COUNT] =
-{
- Property::RECTANGLE, // "pixel-area",
- Property::BOOLEAN, // "fade-in",
- Property::FLOAT, // "fade-in-duration",
- Property::STRING, // "style",
- Property::VECTOR4, // "border",
- Property::MAP, // "image",
-};
+TypeRegistration mType( typeid( Dali::ImageActor ), typeid( Dali::RenderableActor ), Create );
ImageActor::Style StyleEnum(const std::string &s)
{
- if(s == "NINE_PATCH")
+ if(s == "STYLE_NINE_PATCH")
{
return Dali::ImageActor::STYLE_NINE_PATCH;
}
+ else if(s == "STYLE_NINE_PATCH_NO_CENTER")
+ {
+ return Dali::ImageActor::STYLE_NINE_PATCH_NO_CENTER;
+ }
else // if(s == "QUAD")
{
return Dali::ImageActor::STYLE_QUAD;
{
if(style == Dali::ImageActor::STYLE_NINE_PATCH)
{
- return "NINE_PATCH";
+ return "STYLE_NINE_PATCH";
+ }
+ else if(style == Dali::ImageActor::STYLE_NINE_PATCH_NO_CENTER)
+ {
+ return "STYLE_NINE_PATCH_NO_CENTER";
}
else // if(s == "QUAD")
{
return "STYLE_QUAD";
}
}
-
}
-ImageActorPtr ImageActor::New( Image* image )
+ImageActorPtr ImageActor::New()
{
- ImageActorPtr actor( new ImageActor() );
+ ImageActorPtr actor( new ImageActor );
- // Second-phase construction
+ // Second-phase construction of base class
actor->Initialize();
// Create the attachment
- actor->mImageAttachment = ImageAttachment::New( *actor->mNode, image );
+ actor->mImageAttachment = ImageAttachment::New( *actor->mStage, *actor->mNode );
actor->Attach( *actor->mImageAttachment );
- // Adjust the actor's size
- if( image )
- {
- actor->mImageNext.Set( image, false );
- actor->OnImageSet( *image );
- }
-
- return actor;
-}
-
-ImageActorPtr ImageActor::New( Image* image, const PixelArea& pixelArea )
-{
- // re-use basic New
- ImageActorPtr actor = New( image );
- // then set the pixel area
- actor->mImageAttachment->SetPixelArea( pixelArea );
return actor;
}
void ImageActor::OnInitialize()
{
- if(ImageActor::mFirstInstance)
- {
- mDefaultImageActorPropertyLookup = new DefaultPropertyLookup();
- const int start = RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT;
- for ( int i = 0; i < DEFAULT_IMAGE_ACTOR_PROPERTY_COUNT; ++i )
- {
- (*mDefaultImageActorPropertyLookup)[DEFAULT_IMAGE_ACTOR_PROPERTY_NAMES[i]] = i + start;
- }
- ImageActor::mFirstInstance = false;
- }
}
-void ImageActor::SetImage( Image* image )
+void ImageActor::SetImage( ImagePtr& image )
{
- Image* currentImage = static_cast<Image*>(mImageAttachment->GetImage().GetObjectPtr());
- // early exit if it's the same image
- if ( currentImage == image || mImageNext.Get() == image )
+ ImagePtr currentImage = mImageAttachment->GetImage();
+ // early exit if it's the same image as we already have
+ if ( currentImage == image )
{
return;
}
- mLoadedConnection.DisconnectAll();
-
- mImageNext.Set( image, OnStage() );
-
- if ( image == NULL )
+ // NOTE! image might be pointing to NULL, which is fine as in that case app wants to just remove the image
+ ImagePtr newImage( image );
+ // if image is not NULL, check for 9 patch
+ if( newImage )
{
- mImageAttachment->SetImage( NULL );
- }
- else
- {
- // don't disconnect currently shown image until we made sure that the new one is loaded
- OnImageSet( *image );
+ // Automatically convert nine-patch images to cropped bitmap
+ NinePatchImage* ninePatchImage = NinePatchImage::DownCast( image.Get() );
+ if( ninePatchImage )
+ {
+ newImage = ninePatchImage->CreateCroppedBufferImage();
+ SetStyle( Dali::ImageActor::STYLE_NINE_PATCH );
+ SetNinePatchBorder( ninePatchImage->GetStretchBorders(), true );
+ }
}
+ // set the actual image (normal or 9 patch) and natural size based on that
+ mImageAttachment->SetImage( newImage );
+ SetNaturalSize();
}
-Dali::Image ImageActor::GetImage()
+ImagePtr ImageActor::GetImage()
{
return mImageAttachment->GetImage();
}
+void ImageActor::SetToNaturalSize()
+{
+ mUsingNaturalSize = true;
+
+ SetNaturalSize();
+}
+
void ImageActor::SetPixelArea( const PixelArea& pixelArea )
{
mImageAttachment->SetPixelArea( pixelArea );
+
+ SetNaturalSize();
}
const ImageActor::PixelArea& ImageActor::GetPixelArea() const
void ImageActor::ClearPixelArea()
{
mImageAttachment->ClearPixelArea();
+
+ if( mUsingNaturalSize )
+ {
+ ImagePtr image = mImageAttachment->GetImage();
+ if( image )
+ {
+ mInternalSetSize = true;
+ SetSize( image->GetNaturalSize() );
+ mInternalSetSize = false;
+ }
+ }
}
void ImageActor::SetStyle( Style style )
return mImageAttachment->GetNinePatchBorder();
}
-void ImageActor::SetFadeIn( bool enableFade )
-{
- mFadeIn = enableFade;
-}
-
-bool ImageActor::GetFadeIn() const
+ImageAttachment& ImageActor::GetImageAttachment()
{
- return mFadeIn;
+ return *mImageAttachment;
}
-void ImageActor::SetFadeInDuration( float durationSeconds )
+RenderableAttachment& ImageActor::GetRenderableAttachment() const
{
- mFadeInDuration = durationSeconds;
+ DALI_ASSERT_DEBUG( mImageAttachment && "ImageAttachment missing from ImageActor" );
+ return *mImageAttachment;
}
-float ImageActor::GetFadeInDuration() const
+ImageActor::ImageActor()
+: RenderableActor(),
+ mUsingNaturalSize(true),
+ mInternalSetSize(false)
{
- return mFadeInDuration;
}
-ImageAttachment& ImageActor::GetImageAttachment()
+ImageActor::~ImageActor()
{
- return *mImageAttachment;
}
-Vector2 ImageActor::GetCurrentImageSize() const
+void ImageActor::SetNaturalSize()
{
- Vector3 size;
- Vector3 currentSize;
-
- // get the texture size / pixel area if only a subset of it is displayed
- if (IsPixelAreaSet())
+ if( mUsingNaturalSize )
{
- PixelArea area(GetPixelArea());
- return Vector2(area.width, area.height );
- }
- else
- {
- return Vector2( GetCurrentSize() );
+ mInternalSetSize = true;
+ SetSize( CalculateNaturalSize() );
+ mInternalSetSize = false;
}
}
-RenderableAttachment& ImageActor::GetRenderableAttachment() const
+Vector3 ImageActor::GetNaturalSize() const
{
- DALI_ASSERT_DEBUG( mImageAttachment && "ImageAttachment missing from ImageActor" );
- return *mImageAttachment;
+ Vector2 naturalSize( CalculateNaturalSize() );
+ return Vector3( naturalSize.width, naturalSize.height, CalculateSizeZ( naturalSize ) );
}
-ImageActor::ImageActor()
-: RenderableActor(),
- mCustomSizeSet( false ),
- mFadeIn( false ),
- mFadeInitial( true ),
- mLoadedConnection( this ),
- mFadeInDuration( 1.0f )
+Vector2 ImageActor::CalculateNaturalSize() const
{
-}
+ // if no image then natural size is 0
+ Vector2 size( 0.0f, 0.0f );
-ImageActor::~ImageActor()
-{
- // ScopedConnection disconnects automatically
+ ImagePtr image = mImageAttachment->GetImage();
+ if( image )
+ {
+ if( IsPixelAreaSet() )
+ {
+ PixelArea area(GetPixelArea());
+ size.width = area.width;
+ size.height = area.height;
+ }
+ else
+ {
+ size = image->GetNaturalSize();
+ }
+ }
+
+ return size;
}
-void ImageActor::OnImageSet( Image& image )
+void ImageActor::OnSizeSet( const Vector3& targetSize )
{
- // observe image loaded
- if( Dali::ResourceLoadingSucceeded == image.GetLoadingState() )
- {
- //image already loaded
- ImageLoaded( Dali::Image(&image) );
- }
- else
+ if( !mInternalSetSize )
{
- image.LoadingFinishedSignal().Connect( mLoadedConnection, &ImageActor::ImageLoaded );
+ mUsingNaturalSize = false;
}
}
-void ImageActor::OnSizeSet( const Vector3& targetSize )
+void ImageActor::OnSizeAnimation(Animation& animation, const Vector3& targetSize)
{
- // True if SizeSet() has ever been called
- mCustomSizeSet = true;
+ mUsingNaturalSize = false;
}
void ImageActor::OnStageConnectionInternal()
{
- FadeIn();
-
- mImageNext.OnStageConnect();
}
void ImageActor::OnStageDisconnectionInternal()
{
- mImageNext.OnStageDisconnect();
}
-void ImageActor::ImageLoaded( Dali::Image image )
+unsigned int ImageActor::GetDefaultPropertyCount() const
{
- DALI_ASSERT_DEBUG (image && "Image handle empty!");
-
- // TODO: Handle case where image loading failed
+ return RenderableActor::GetDefaultPropertyCount() + DEFAULT_PROPERTY_COUNT;
+}
- // Need to keep mUploadedConnection connected as image may change later through Reload
- // Note: Reloaded images may have changed size.
+void ImageActor::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
+{
+ RenderableActor::GetDefaultPropertyIndices( indices ); // RenderableActor class properties
- // Set the attachment's image once we know the image has loaded to prevent
- // blank frames during load / reload.
- mImageAttachment->SetImage( &GetImplementation( image ) );
+ indices.reserve( indices.size() + DEFAULT_PROPERTY_COUNT );
- // If size has never been set
- if( !mCustomSizeSet )
+ int index = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX;
+ for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i, ++index )
{
- // If a pixel area has been set, use this size
- if (mImageAttachment->IsPixelAreaSet())
- {
- const PixelArea& area = mImageAttachment->GetPixelArea();
- SetSize(area.width, area.height);
- }
- else
- {
- SetSize(image.GetWidth(), image.GetHeight());
- }
+ indices.push_back( index );
}
-
- // fade in if required
- FadeIn();
}
-void ImageActor::FadeIn()
+bool ImageActor::IsDefaultPropertyWritable( Property::Index index ) const
{
- // only fade in if enabled and newly displayed on screen
- if( mFadeIn && mFadeInitial && ( mFadeInDuration > 0.0f ) )
+ if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT )
{
- // need to set opacity immediately to 0 otherwise child actors might get rendered
- SetOpacity( 0.0f );
-
- Dali::Image image = mImageAttachment->GetImage();
+ return RenderableActor::IsDefaultPropertyWritable(index);
+ }
- // Fade-in when on-stage & the image is loaded
- if (OnStage() &&
- image &&
- image.GetLoadingState() == Dali::ResourceLoadingSucceeded)
- {
- // fire and forget animation; will clean up after it's finished
- Dali::Animation animation = Dali::Animation::New( mFadeInDuration );
- animation.OpacityTo( Dali::Actor( this ), 1.0f, AlphaFunctions::EaseOut );
- animation.Play();
- mFadeInitial = false;
- }
+ index -= DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX;
+ if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) )
+ {
+ return DEFAULT_PROPERTY_DETAILS[ index ].writable;
}
-}
-unsigned int ImageActor::GetDefaultPropertyCount() const
-{
- return RenderableActor::GetDefaultPropertyCount() + DEFAULT_IMAGE_ACTOR_PROPERTY_COUNT;
+ return false;
}
-bool ImageActor::IsDefaultPropertyWritable( Property::Index index ) const
+bool ImageActor::IsDefaultPropertyAnimatable( Property::Index index ) const
{
- if(static_cast<unsigned int>(index) < RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT)
+ if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT )
{
- return RenderableActor::IsDefaultPropertyWritable(index);
+ return RenderableActor::IsDefaultPropertyAnimatable( index );
}
- else
+
+ index -= DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX;
+ if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) )
{
- return true;
+ return DEFAULT_PROPERTY_DETAILS[ index ].animatable;
}
+
+ return false;
}
-bool ImageActor::IsDefaultPropertyAnimatable( Property::Index index ) const
+bool ImageActor::IsDefaultPropertyAConstraintInput( Property::Index index ) const
{
- if(static_cast<unsigned int>(index) < RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT)
+ if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT )
{
- return RenderableActor::IsDefaultPropertyAnimatable(index);
+ return RenderableActor::IsDefaultPropertyAConstraintInput( index );
}
- else
+
+ index -= DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX;
+ if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) )
{
- return false;
+ return DEFAULT_PROPERTY_DETAILS[ index ].constraintInput;
}
+
+ return false;
}
Property::Type ImageActor::GetDefaultPropertyType( Property::Index index ) const
{
- if(static_cast<unsigned int>(index) < RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT)
+ if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT )
{
- return RenderableActor::GetDefaultPropertyType(index);
+ return RenderableActor::GetDefaultPropertyType( index );
}
- else
+
+ index -= DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX;
+ if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) )
{
- // ProxyObject guarantees that index is within range
- return DEFAULT_IMAGE_ACTOR_PROPERTY_TYPES[index - RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT];
+ return DEFAULT_PROPERTY_DETAILS[index].type;
}
+
+ // index out-of-bounds
+ return Property::NONE;
}
-const std::string& ImageActor::GetDefaultPropertyName( Property::Index index ) const
+const char* ImageActor::GetDefaultPropertyName( Property::Index index ) const
{
- if(static_cast<unsigned int>(index) < RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT)
+ if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT)
{
return RenderableActor::GetDefaultPropertyName(index);
}
- else
+
+ index -= DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX;
+ if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) )
{
- // ProxyObject guarantees that index is within range
- return DEFAULT_IMAGE_ACTOR_PROPERTY_NAMES[index - RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT];
+ return DEFAULT_PROPERTY_DETAILS[index].name;
}
+
+ // index out-of-bounds
+ return NULL;
}
Property::Index ImageActor::GetDefaultPropertyIndex(const std::string& name) const
{
Property::Index index = Property::INVALID_INDEX;
- DALI_ASSERT_DEBUG( NULL != mDefaultImageActorPropertyLookup );
-
- // Look for name in current class' default properties
- DefaultPropertyLookup::const_iterator result = mDefaultImageActorPropertyLookup->find( name );
- if ( mDefaultImageActorPropertyLookup->end() != result )
+ // Look for name in default properties
+ for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
- index = result->second;
+ const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
+ if( 0 == strcmp( name.c_str(), property->name ) ) // Don't want to convert rhs to string
+ {
+ index = i + DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX;
+ break;
+ }
}
- else
+
+ // If not found, check in base class
+ if( Property::INVALID_INDEX == index )
{
- // If not found, check in base class
index = RenderableActor::GetDefaultPropertyIndex( name );
}
-
return index;
}
void ImageActor::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue )
{
- // ProxyObject guarantees the property is writable and index is in range
-
- if(index < RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT)
+ if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT )
{
- RenderableActor::SetDefaultProperty(index, propertyValue);
+ RenderableActor::SetDefaultProperty( index, propertyValue );
}
else
{
switch(index)
{
- case Dali::ImageActor::PIXEL_AREA:
+ case Dali::ImageActor::Property::PIXEL_AREA:
{
SetPixelArea(propertyValue.Get<Rect<int> >());
break;
}
- case Dali::ImageActor::FADE_IN:
- {
- SetFadeIn(propertyValue.Get<bool>());
- break;
- }
- case Dali::ImageActor::FADE_IN_DURATION:
+ case Dali::ImageActor::Property::STYLE:
{
- SetFadeInDuration(propertyValue.Get<float>());
+ SetStyle( StyleEnum( propertyValue.Get<std::string>() ) );
break;
}
- case Dali::ImageActor::STYLE:
+ case Dali::ImageActor::Property::BORDER:
{
- SetStyle(StyleEnum(propertyValue.Get<std::string>()));
+ SetNinePatchBorder( propertyValue.Get<Vector4>(), true /*in pixels*/ );
break;
}
- case Dali::ImageActor::BORDER:
- {
- SetNinePatchBorder(propertyValue.Get<Vector4>());
- break;
- }
- case Dali::ImageActor::IMAGE:
+ case Dali::ImageActor::Property::IMAGE:
{
Dali::Image img = Scripting::NewImage( propertyValue );
if(img)
{
- SetImage( &GetImplementation(img) );
+ ImagePtr image( &GetImplementation(img) );
+ SetImage( image );
}
else
{
Property::Value ImageActor::GetDefaultProperty( Property::Index index ) const
{
Property::Value ret;
- if(index < RENDERABLE_ACTOR_DEFAULT_PROPERTY_MAX_COUNT)
+ if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT )
{
- ret = RenderableActor::GetDefaultProperty(index);
+ ret = RenderableActor::GetDefaultProperty( index );
}
else
{
- switch(index)
+ switch( index )
{
- case Dali::ImageActor::PIXEL_AREA:
+ case Dali::ImageActor::Property::PIXEL_AREA:
{
Rect<int> r = GetPixelArea();
ret = r;
break;
}
- case Dali::ImageActor::FADE_IN:
+ case Dali::ImageActor::Property::STYLE:
{
- ret = GetFadeIn();
+ ret = StyleString( GetStyle() );
break;
}
- case Dali::ImageActor::FADE_IN_DURATION:
- {
- ret = GetFadeInDuration();
- break;
- }
- case Dali::ImageActor::STYLE:
- {
- ret = StyleString(GetStyle());
- break;
- }
- case Dali::ImageActor::BORDER:
+ case Dali::ImageActor::Property::BORDER:
{
ret = GetNinePatchBorder();
break;
}
- case Dali::ImageActor::IMAGE:
+ case Dali::ImageActor::Property::IMAGE:
{
- ret = Property::Value(Property::MAP);
+ Property::Map map;
+ Scripting::CreatePropertyMap( Dali::Image( mImageAttachment->GetImage().Get() ), map );
+ ret = Property::Value( map );
break;
}
default:
{
- DALI_LOG_WARNING("Unknown property (%d)\n", index);
+ DALI_LOG_WARNING( "Unknown property (%d)\n", index );
break;
}
} // switch(index)
return ret;
}
-
} // namespace Internal
} // namespace Dali