Added a RendererCache and utilise it for ImageRenderer.

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / renderers / npatch / npatch-renderer.cpp

diff --git a/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp b/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp
index d757712..63e2f5d 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp
@@ -41,6 +41,8 @@ namespace Internal
 
 namespace
 {
+const char * const RENDERER_TYPE("renderer-type");
+const char * const RENDERER_TYPE_VALUE("n-patch-renderer");
 
 const char * const IMAGE_URL_NAME("image-url");
 const char * const BORDER_ONLY("border-only");
@@ -148,8 +150,8 @@ void AddVertex( Vector< Vector2 >& vertices, unsigned int x, unsigned int y )
 
 /////////////////NPatchRenderer////////////////
 
-NPatchRenderer::NPatchRenderer()
-: ControlRenderer(),
+NPatchRenderer::NPatchRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache ),
   mBorderOnly( false )
 {
 }
@@ -158,10 +160,8 @@ NPatchRenderer::~NPatchRenderer()
 {
 }
 
-void NPatchRenderer::Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void NPatchRenderer::DoInitialize( const Property::Map& propertyMap )
 {
-  Initialize(factoryCache);
-
   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
   if( imageURLValue )
   {
@@ -185,6 +185,25 @@ void NPatchRenderer::Initialize( RendererFactoryCache& factoryCache, const Prope
   }
 }
 
+void NPatchRenderer::GetNaturalSize( Vector2& naturalSize ) const
+{
+  if( mImage )
+  {
+    naturalSize.x = mImage.GetWidth();
+    naturalSize.y = mImage.GetHeight();
+    return;
+  }
+  else if( !mImageUrl.empty() )
+  {
+    ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl );
+    naturalSize.x = dimentions.GetWidth();
+    naturalSize.y = dimentions.GetHeight();
+    return;
+  }
+
+  naturalSize = Vector2::ZERO;
+}
+
 void NPatchRenderer::SetClipRect( const Rect<int>& clipRect )
 {
   ControlRenderer::SetClipRect( clipRect );
@@ -196,6 +215,51 @@ void NPatchRenderer::SetOffset( const Vector2& offset )
   //ToDo: renderer applies the offset
 }
 
+void NPatchRenderer::InitializeRenderer( Renderer& renderer )
+{
+  Geometry geometry;
+  if( !mBorderOnly )
+  {
+    geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY );
+    if( !geometry )
+    {
+      geometry = CreateGeometry( Uint16Pair( 3, 3 ) );
+      mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY, geometry );
+    }
+  }
+  else
+  {
+    geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY );
+    if( !geometry )
+    {
+      geometry = CreateGeometryBorder( Uint16Pair( 3, 3 ) );
+      mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY, geometry );
+    }
+  }
+
+  Shader shader = mFactoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
+  if( !shader )
+  {
+    shader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
+    mFactoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, shader );
+  }
+
+  if( !renderer )
+  {
+    Material material = Material::New( shader );
+    renderer = Renderer::New( geometry, material );
+  }
+  else
+  {
+    mImpl->mRenderer.SetGeometry( geometry );
+    Material material = mImpl->mRenderer.GetMaterial();
+    if( material )
+    {
+      material.SetShader( shader );
+    }
+  }
+}
+
 void NPatchRenderer::DoSetOnStage( Actor& actor )
 {
   if( !mCroppedImage )
@@ -222,33 +286,19 @@ void NPatchRenderer::DoSetOffStage( Actor& actor )
   mCroppedImage.Reset();
 }
 
-void NPatchRenderer::Initialize( RendererFactoryCache& factoryCache )
+void NPatchRenderer::DoCreatePropertyMap( Property::Map& map ) const
 {
-  mNinePatchGeometry = factoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY );
-  if( !(mNinePatchGeometry) )
+  map.Clear();
+  map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
+  if( !mImageUrl.empty() )
   {
-    mNinePatchGeometry = CreateGeometry( Uint16Pair( 3, 3 ) );
-    factoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY, mNinePatchGeometry );
+    map.Insert( IMAGE_URL_NAME, mImageUrl );
   }
-
-  mNinePatchBorderGeometry = factoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY );
-  if( !(mNinePatchBorderGeometry) )
+  else if( mImage )
   {
-    mNinePatchBorderGeometry = CreateGeometryBorder( Uint16Pair( 3, 3 ) );
-    factoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY, mNinePatchBorderGeometry );
+    map.Insert( IMAGE_URL_NAME, mImage.GetUrl() );
   }
-
-  mNinePatchShader = factoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
-  if( !mNinePatchShader )
-  {
-    mNinePatchShader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
-    factoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, mNinePatchShader );
-  }
-
-  mImpl->mGeometry = mNinePatchGeometry;
-  mImpl->mShader = mNinePatchShader;
-
-  mImageUrl.clear();
+  map.Insert( BORDER_ONLY, mBorderOnly );
 }
 
 void NPatchRenderer::SetImage( const std::string& imageUrl, bool borderOnly )
@@ -302,13 +352,6 @@ void NPatchRenderer::InitialiseFromImage( NinePatchImage nPatch )
 
   mStretchPixelsX = nPatch.GetStretchPixelsX();
   mStretchPixelsY = nPatch.GetStretchPixelsY();
-
-  if( mStretchPixelsX.Size() > 0 && mStretchPixelsY.Size() > 0 )
-  {
-    //only 9 patch supported for now
-    mImpl->mGeometry = !mBorderOnly ? mNinePatchGeometry : mNinePatchBorderGeometry;
-    mImpl->mShader = mNinePatchShader;
-  }
 }
 
 void NPatchRenderer::CreateErrorImage()
@@ -331,9 +374,6 @@ void NPatchRenderer::CreateErrorImage()
   mStretchPixelsX.PushBack( Uint16Pair( 0, mImageSize.GetWidth() ) );
   mStretchPixelsY.Clear();
   mStretchPixelsY.PushBack( Uint16Pair( 0, mImageSize.GetHeight() ) );
-
-  mImpl->mGeometry = mNinePatchGeometry;
-  mImpl->mShader = mNinePatchShader;
 }
 
 void NPatchRenderer::ApplyImageToSampler()