Rename of Control Renderers to Visuals

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / renderers / image / image-visual.cpp

diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp b/dali-toolkit/internal/controls/renderers/image/image-visual.cpp
similarity index 87%
rename from dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
rename to dali-toolkit/internal/controls/renderers/image/image-visual.cpp
index 058f2b9..e77c046 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/image/image-visual.cpp
@@ -16,7 +16,7 @@
  */
 
 // CLASS HEADER
-#include "image-renderer.h"
+#include "image-visual.h"
 
 // EXTERNAL HEADER
 #include <cstring> // for strncasecmp
@@ -28,11 +28,11 @@
 #include <dali/integration-api/debug.h>
 
 // INTERNAL HEADER
-#include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
-#include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
-#include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
-#include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
-#include <dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h>
+#include <dali-toolkit/internal/controls/renderers/visual-string-constants.h>
+#include <dali-toolkit/internal/controls/renderers/visual-factory-impl.h>
+#include <dali-toolkit/internal/controls/renderers/visual-factory-cache.h>
+#include <dali-toolkit/internal/controls/renderers/visual-impl.h>
+#include <dali-toolkit/internal/controls/renderers/visual-data-impl.h>
 #include <dali-toolkit/internal/controls/renderers/image-atlas-manager.h>
 
 namespace Dali
@@ -108,22 +108,22 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
   }\n
 );
 
-Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gridSize )
+Geometry CreateGeometry( VisualFactoryCache& factoryCache, ImageDimensions gridSize )
 {
   Geometry geometry;
 
   if( gridSize == ImageDimensions( 1, 1 ) )
   {
-    geometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
+    geometry = factoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
     if( !geometry )
     {
-      geometry =  RendererFactoryCache::CreateQuadGeometry();
-      factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );
+      geometry =  VisualFactoryCache::CreateQuadGeometry();
+      factoryCache.SaveGeometry( VisualFactoryCache::QUAD_GEOMETRY, geometry );
     }
   }
   else
   {
-    geometry = RendererFactoryCache::CreateGridGeometry( gridSize );
+    geometry = VisualFactoryCache::CreateGridGeometry( gridSize );
   }
 
   return geometry;
@@ -131,8 +131,8 @@ Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gri
 
 } //unnamed namespace
 
-ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
-: ControlRenderer( factoryCache ),
+ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
+: Visual( factoryCache ),
   mAtlasManager( atlasManager ),
   mDesiredSize(),
   mFittingMode( FittingMode::DEFAULT ),
@@ -142,11 +142,11 @@ ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache, ImageAtlasMana
 {
 }
 
-ImageRenderer::~ImageRenderer()
+ImageVisual::~ImageVisual()
 {
 }
 
-void ImageRenderer::DoInitialize( Actor& actor, const Property::Map& propertyMap )
+void ImageVisual::DoInitialize( Actor& actor, const Property::Map& propertyMap )
 {
   std::string oldImageUrl = mImageUrl;
 
@@ -304,12 +304,12 @@ void ImageRenderer::DoInitialize( Actor& actor, const Property::Map& propertyMap
   }
 }
 
-void ImageRenderer::SetSize( const Vector2& size )
+void ImageVisual::SetSize( const Vector2& size )
 {
-  ControlRenderer::SetSize( size );
+  Visual::SetSize( size );
 }
 
-void ImageRenderer::GetNaturalSize( Vector2& naturalSize ) const
+void ImageVisual::GetNaturalSize( Vector2& naturalSize ) const
 {
   if(mImage)
   {
@@ -334,16 +334,16 @@ void ImageRenderer::GetNaturalSize( Vector2& naturalSize ) const
   naturalSize = Vector2::ZERO;
 }
 
-void ImageRenderer::SetClipRect( const Rect<int>& clipRect )
+void ImageVisual::SetClipRect( const Rect<int>& clipRect )
 {
-  ControlRenderer::SetClipRect( clipRect );
+  Visual::SetClipRect( clipRect );
 }
 
-void ImageRenderer::SetOffset( const Vector2& offset )
+void ImageVisual::SetOffset( const Vector2& offset )
 {
 }
 
-Renderer ImageRenderer::CreateRenderer() const
+Renderer ImageVisual::CreateRenderer() const
 {
   Geometry geometry;
   Shader shader;
@@ -352,7 +352,7 @@ Renderer ImageRenderer::CreateRenderer() const
   // Renderer can't be shared between NativeImage and other image types.
   if( !mNativeFragmentShaderCode.empty() )
   {
-    return CreateNativeImageRenderer();
+    return CreateNativeImageVisual();
   }
 
   if( !mImpl->mCustomShader )
@@ -386,7 +386,7 @@ Renderer ImageRenderer::CreateRenderer() const
   return renderer;
 }
 
-Renderer ImageRenderer::CreateNativeImageRenderer() const
+Renderer ImageVisual::CreateNativeImageVisual() const
 {
   Geometry geometry;
   Shader shader;
@@ -420,12 +420,12 @@ Renderer ImageRenderer::CreateNativeImageRenderer() const
 }
 
 
-bool ImageRenderer::IsSynchronousResourceLoading() const
+bool ImageVisual::IsSynchronousResourceLoading() const
 {
   return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
 }
 
-void ImageRenderer::DoSynchronousResourceLoading()
+void ImageVisual::DoSynchronousResourceLoading()
 {
   if( !mImageUrl.empty() )
   {
@@ -435,14 +435,14 @@ void ImageRenderer::DoSynchronousResourceLoading()
   }
 }
 
-Image ImageRenderer::LoadImage( const std::string& url, bool synchronousLoading )
+Image ImageVisual::LoadImage( const std::string& url, bool synchronousLoading )
 {
   if( synchronousLoading )
   {
     if( !mPixels )
     {
       // use broken image
-      return RendererFactory::GetBrokenRendererImage();
+      return VisualFactory::GetBrokenRendererImage();
     }
     Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
     image.Upload( mPixels, 0, 0 );
@@ -451,12 +451,12 @@ Image ImageRenderer::LoadImage( const std::string& url, bool synchronousLoading
   else
   {
     ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
-    resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+    resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
     return resourceImage;
   }
 }
 
-TextureSet ImageRenderer::CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading )
+TextureSet ImageVisual::CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading )
 {
   TextureSet textureSet;
   textureRect = FULL_TEXTURE_RECT;
@@ -466,7 +466,7 @@ TextureSet ImageRenderer::CreateTextureSet( Vector4& textureRect, const std::str
     {
       // use broken image
       textureSet = TextureSet::New();
-      TextureSetImage( textureSet, 0u, RendererFactory::GetBrokenRendererImage() );
+      TextureSetImage( textureSet, 0u, VisualFactory::GetBrokenRendererImage() );
     }
     else
     {
@@ -486,7 +486,7 @@ TextureSet ImageRenderer::CreateTextureSet( Vector4& textureRect, const std::str
     if( !textureSet ) // big image, no atlasing
     {
       ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
-      resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+      resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
       textureSet = TextureSet::New();
       TextureSetImage( textureSet, 0u, resourceImage );
     }
@@ -495,7 +495,7 @@ TextureSet ImageRenderer::CreateTextureSet( Vector4& textureRect, const std::str
   return textureSet;
 }
 
-void ImageRenderer::InitializeRenderer( const std::string& imageUrl )
+void ImageVisual::InitializeRenderer( const std::string& imageUrl )
 {
   if( imageUrl.empty() )
   {
@@ -538,7 +538,7 @@ void ImageRenderer::InitializeRenderer( const std::string& imageUrl )
   }
 }
 
-void ImageRenderer::InitializeRenderer( const Image& image )
+void ImageVisual::InitializeRenderer( const Image& image )
 {
   mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
 
@@ -551,7 +551,7 @@ void ImageRenderer::InitializeRenderer( const Image& image )
 }
 
 
-void ImageRenderer::DoSetOnStage( Actor& actor )
+void ImageVisual::DoSetOnStage( Actor& actor )
 {
   if( !mImageUrl.empty() )
   {
@@ -564,7 +564,7 @@ void ImageRenderer::DoSetOnStage( Actor& actor )
 
 }
 
-void ImageRenderer::DoSetOffStage( Actor& actor )
+void ImageVisual::DoSetOffStage( Actor& actor )
 {
   //If we own the image then make sure we release it when we go off stage
   if( !mImageUrl.empty() )
@@ -580,7 +580,7 @@ void ImageRenderer::DoSetOffStage( Actor& actor )
   }
 }
 
-void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const
+void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
 {
   map.Clear();
   map.Insert( RENDERER_TYPE, IMAGE_RENDERER );
@@ -679,20 +679,20 @@ void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const
   }
 }
 
-Shader ImageRenderer::GetImageShader( RendererFactoryCache& factoryCache )
+Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache )
 {
-  Shader shader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
+  Shader shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
   if( !shader )
   {
     shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-    factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
+    factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
     shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
   }
   return shader;
 }
 
-void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
+void ImageVisual::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
 {
   if( mImageUrl != imageUrl )
   {
@@ -738,7 +738,7 @@ void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDi
   }
 }
 
-void ImageRenderer::SetImage( Actor& actor, const Image& image )
+void ImageVisual::SetImage( Actor& actor, const Image& image )
 {
   if( mImage != image )
   {
@@ -817,7 +817,7 @@ void ImageRenderer::SetImage( Actor& actor, const Image& image )
   }
 }
 
-void ImageRenderer::ApplyImageToSampler( const Image& image )
+void ImageVisual::ApplyImageToSampler( const Image& image )
 {
   if( image )
   {
@@ -831,11 +831,11 @@ void ImageRenderer::ApplyImageToSampler( const Image& image )
   }
 }
 
-void ImageRenderer::OnImageLoaded( ResourceImage image )
+void ImageVisual::OnImageLoaded( ResourceImage image )
 {
   if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
   {
-    Image brokenImage = RendererFactory::GetBrokenRendererImage();
+    Image brokenImage = VisualFactory::GetBrokenRendererImage();
     if( mImpl->mRenderer )
     {
       ApplyImageToSampler( brokenImage );
@@ -843,7 +843,7 @@ void ImageRenderer::OnImageLoaded( ResourceImage image )
   }
 }
 
-void ImageRenderer::CleanCache(const std::string& url)
+void ImageVisual::CleanCache(const std::string& url)
 {
   TextureSet textureSet = mImpl->mRenderer.GetTextures();
 
@@ -862,7 +862,7 @@ void ImageRenderer::CleanCache(const std::string& url)
   }
 }
 
-void ImageRenderer::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
+void ImageVisual::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
 {
   const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
   const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();