const char* TEST_IMAGE_FILE_NAME = "image_01.jpg";
const char* TEST_NPATCH_FILE_NAME = "image_01.9.jpg";
-bool IsDebugVisual( Visual& renderer )
+bool IsDebugVisual( Visual::Base& visual )
{
bool isDebugVisualType = false;
bool isGeometryLineType = false;
Property::Map propertyMap;
- renderer.CreatePropertyMap( propertyMap );
+ visual.CreatePropertyMap( propertyMap );
Property::Value* typeValue = propertyMap.Find( "rendererType", Property::STRING );
if ( typeValue )
{
}
Actor actor = Actor::New();
- renderer.SetOnStage( actor );
+ visual.SetOnStage( actor );
Geometry geometry = actor.GetRendererAt( 0 ).GetGeometry();
isGeometryLineType = ( geometry.GetGeometryType() == Geometry::LINES );
Property::Map propertyMap1;
propertyMap1.Insert("rendererType", "COLOR");
propertyMap1.Insert("mixColor", Color::BLUE);
- Visual colorRenderer = factory.CreateVisual(propertyMap1);
- DALI_TEST_CHECK( colorRenderer );
- DALI_TEST_CHECK( IsDebugVisual( colorRenderer ) );
+ Visual::Base colorVisual = factory.CreateVisual(propertyMap1);
+ DALI_TEST_CHECK( colorVisual );
+ DALI_TEST_CHECK( IsDebugVisual( colorVisual ) );
// Test that border renderer is replaced with debug renderer
Property::Map propertyMap2;
propertyMap2.Insert("rendererType", "BORDER");
propertyMap2.Insert("borderColor", Color::BLUE);
propertyMap2.Insert("borderSize", 2.f);
- Visual borderRenderer = factory.CreateVisual(propertyMap2);
+ Visual::Base borderRenderer = factory.CreateVisual(propertyMap2);
DALI_TEST_CHECK( borderRenderer );
DALI_TEST_CHECK( IsDebugVisual( borderRenderer ) );
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
propertyMap3.Insert("stopColor", stopColors);
- Visual gradientRenderer = factory.CreateVisual(propertyMap3);
+ Visual::Base gradientRenderer = factory.CreateVisual(propertyMap3);
DALI_TEST_CHECK( gradientRenderer );
DALI_TEST_CHECK( IsDebugVisual( gradientRenderer ) );
Property::Map propertyMap4;
propertyMap4.Insert( "rendererType", "IMAGE" );
propertyMap4.Insert( "url", TEST_IMAGE_FILE_NAME );
- Visual imageRenderer = factory.CreateVisual( propertyMap4 );
+ Visual::Base imageRenderer = factory.CreateVisual( propertyMap4 );
DALI_TEST_CHECK( imageRenderer );
DALI_TEST_CHECK( IsDebugVisual( imageRenderer ) );
Property::Map propertyMap5;
propertyMap5.Insert( "rendererType", "IMAGE" );
propertyMap5.Insert( "url", TEST_NPATCH_FILE_NAME );
- Visual nPatchRenderer = factory.CreateVisual( propertyMap4 );
+ Visual::Base nPatchRenderer = factory.CreateVisual( propertyMap4 );
DALI_TEST_CHECK( nPatchRenderer );
DALI_TEST_CHECK( IsDebugVisual( nPatchRenderer ) );
map[ "rendererType" ] = "COLOR";
map[ "mixColor" ] = Color::CYAN;
- Visual colorRenderer = factory.CreateVisual( map);
- DALI_TEST_CHECK( colorRenderer );
- DALI_TEST_CHECK( IsDebugVisual( colorRenderer ) );
+ Visual::Base colorVisual = factory.CreateVisual( map);
+ DALI_TEST_CHECK( colorVisual );
+ DALI_TEST_CHECK( IsDebugVisual( colorVisual ) );
// Test that border renderer is replaced with debug renderer
map.Clear();
map[ "rendererType" ] = "BORDER";
map[ "borderColor" ] = Color::GREEN;
map[ "borderSize" ] = 2.f;
- Visual borderRenderer = factory.CreateVisual( map );
+ Visual::Base borderRenderer = factory.CreateVisual( map );
DALI_TEST_CHECK( borderRenderer );
DALI_TEST_CHECK( IsDebugVisual( borderRenderer ) );
// Test that image renderer is replaced with debug renderer
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
- Visual imageRenderer = factory.CreateVisual( image );
+ Visual::Base imageRenderer = factory.CreateVisual( image );
DALI_TEST_CHECK( imageRenderer );
DALI_TEST_CHECK( IsDebugVisual( imageRenderer ) );
// Test that n patch renderer is replaced with debug renderer
- Visual nPatchRenderer = factory.CreateVisual( TEST_NPATCH_FILE_NAME, ImageDimensions() );
+ Visual::Base nPatchRenderer = factory.CreateVisual( TEST_NPATCH_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( nPatchRenderer );
DALI_TEST_CHECK( IsDebugVisual( nPatchRenderer ) );
Dali::Property::Map map;
map[ "rendererType" ] = "COLOR";
map[ "mixColor" ] = color;
- Visual colorRenderer = factory.CreateVisual( map );
- colorRenderer.SetOnStage( solidColorActor );
+ Visual::Base colorVisual = factory.CreateVisual( map );
+ colorVisual.SetOnStage( solidColorActor );
return solidColorActor;
}
Property::Map propertyMap;
propertyMap.Insert("rendererType", "COLOR");
propertyMap.Insert("mixColor", Color::BLUE);
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
- Visual visualCopy( visual );
+ Visual::Base visualCopy( visual );
DALI_TEST_CHECK(visual == visualCopy);
- Visual emptyVisual;
- Visual emptyVisualCopy( emptyVisual );
+ Visual::Base emptyVisual;
+ Visual::Base emptyVisualCopy( emptyVisual );
DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
- Visual visualEquals;
+ Visual::Base visualEquals;
visualEquals = visual;
DALI_TEST_CHECK(visual == visualEquals);
- Visual emptyVisualEquals;
+ Visual::Base emptyVisualEquals;
emptyVisualEquals = emptyVisual;
DALI_TEST_CHECK( emptyVisual == emptyVisualEquals );
Property::Map propertyMap;
propertyMap.Insert("rendererType", "COLOR");
propertyMap.Insert("mixColor", Color::BLUE);
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
visual.SetDepthIndex( 1.f );
Vector2 visualSize( 20.f, 30.f );
Vector2 naturalSize;
- // color colorVisual
+ // color colorVisual
Dali::Property::Map map;
map[ "rendererType" ] = "COLOR";
map[ "mixColor" ] = Color::MAGENTA;
- Visual colorVisual = factory.CreateVisual( map );
+ Visual::Base colorVisual = factory.CreateVisual( map );
colorVisual.SetSize( visualSize );
DALI_TEST_EQUALS( colorVisual.GetSize(), visualSize, TEST_LOCATION );
colorVisual.GetNaturalSize(naturalSize);
// image visual
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
- Visual imageVisual = factory.CreateVisual( image );
+ Visual::Base imageVisual = factory.CreateVisual( image );
imageVisual.SetSize( visualSize );
DALI_TEST_EQUALS( imageVisual.GetSize(), visualSize, TEST_LOCATION );
imageVisual.GetNaturalSize(naturalSize);
Vector2 testSize(80.f, 160.f);
platform.SetClosestImageSize(testSize);
image = ResourceImage::New(TEST_NPATCH_FILE_NAME);
- Visual nPatchVisual = factory.CreateVisual( image );
+ Visual::Base nPatchVisual = factory.CreateVisual( image );
nPatchVisual.SetSize( visualSize );
DALI_TEST_EQUALS( nPatchVisual.GetSize(), visualSize, TEST_LOCATION );
nPatchVisual.GetNaturalSize(naturalSize);
map[ "rendererType" ] = "BORDER";
map[ "borderColor" ] = Color::RED;
map[ "borderSize" ] = borderSize;
- Visual borderVisual = factory.CreateVisual( map );
+ Visual::Base borderVisual = factory.CreateVisual( map );
borderVisual.SetSize( visualSize );
DALI_TEST_EQUALS( borderVisual.GetSize(), visualSize, TEST_LOCATION );
borderVisual.GetNaturalSize(naturalSize);
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- Visual gradientVisual = factory.CreateVisual(propertyMap);
+ Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
gradientVisual.SetSize( visualSize );
DALI_TEST_EQUALS( gradientVisual.GetSize(), visualSize, TEST_LOCATION );
gradientVisual.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
//svg visual
- Visual svgVisual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
+ Visual::Base svgVisual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
svgVisual.SetSize( visualSize );
DALI_TEST_EQUALS( svgVisual.GetSize(), visualSize, TEST_LOCATION );
svgVisual.GetNaturalSize(naturalSize);
Property::Map propertyMap;
propertyMap.Insert("rendererType", "COLOR");
propertyMap.Insert("mixColor", Color::BLUE);
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
Actor actor = Actor::New();
actor.SetSize(200.f, 200.f);
actor.SetSize(200.f, 200.f);
Stage::GetCurrent().Add( actor );
- Visual imageVisual;
+ Visual::Base imageVisual;
// test calling RemoveAndReset with an empty handle
try
{
Property::Map propertyMap;
propertyMap.Insert("rendererType", "COLOR");
propertyMap.Insert("mixColor", Color::BLUE);
- Visual colorVisual = factory.CreateVisual( propertyMap );
+ Visual::Base colorVisual = factory.CreateVisual( propertyMap );
Property::Map resultMap;
colorVisual.CreatePropertyMap( resultMap );
propertyMap.Insert("rendererType", "BORDER");
propertyMap.Insert("borderColor", Color::BLUE);
propertyMap.Insert("borderSize", 5.f);
- Visual borderVisual = factory.CreateVisual( propertyMap );
+ Visual::Base borderVisual = factory.CreateVisual( propertyMap );
Property::Map resultMap;
borderVisual.CreatePropertyMap( resultMap );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- Visual gradientVisual = factory.CreateVisual(propertyMap);
+ Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
Property::Map resultMap;
gradientVisual.CreatePropertyMap( resultMap );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- Visual gradientVisual = factory.CreateVisual(propertyMap);
+ Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK( gradientVisual );
Property::Map resultMap;
propertyMap.Insert( "samplingMode", "BOX_THEN_NEAREST" );
propertyMap.Insert( "synchronousLoading", true );
- Visual imageVisual = factory.CreateVisual(propertyMap);
+ Visual::Base imageVisual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK( imageVisual );
Property::Map resultMap;
propertyMap.Insert( "rendererType", "IMAGE" );
propertyMap.Insert( "url", TEST_NPATCH_FILE_NAME );
propertyMap.Insert( "borderOnly", true );
- Visual nPatchVisual = factory.CreateVisual( propertyMap );
+ Visual::Base nPatchVisual = factory.CreateVisual( propertyMap );
Property::Map resultMap;
nPatchVisual.CreatePropertyMap( resultMap );
Property::Map propertyMap;
propertyMap.Insert( "rendererType", "IMAGE" );
propertyMap.Insert( "url", TEST_SVG_FILE_NAME );
- Visual svgVisual = factory.CreateVisual( propertyMap );
+ Visual::Base svgVisual = factory.CreateVisual( propertyMap );
Property::Map resultMap;
svgVisual.CreatePropertyMap( resultMap );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
// request SvgVisual with an URL
- Visual svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
+ Visual::Base svgVisual2 = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
resultMap.Clear();
svgVisual2.CreatePropertyMap( resultMap );
// check the property values from the returned map from a visual
propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
propertyMap.Insert( "shaderType", "TEXTURELESS" );
propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
- Visual meshVisual = factory.CreateVisual( propertyMap );
+ Visual::Base meshVisual = factory.CreateVisual( propertyMap );
Property::Map resultMap;
meshVisual.CreatePropertyMap( resultMap );
propertyMap.Insert( "bevelPercentage", 0.3f );
propertyMap.Insert( "bevelSmoothness", 0.6f );
propertyMap.Insert( "lightPosition", Vector3( 5.0f, 10.0f, 15.0f) );
- Visual primitiveVisual = factory.CreateVisual( propertyMap );
+ Visual::Base primitiveVisual = factory.CreateVisual( propertyMap );
Property::Map resultMap;
primitiveVisual.CreatePropertyMap( resultMap );
void TestVisualRender( ToolkitTestApplication& application,
Actor& actor,
- Visual& visual,
+ Visual::Base& visual,
std::size_t expectedSamplers = 0,
ImageDimensions imageDimensions = ImageDimensions(),
Integration::ResourcePointer resourcePtr = Integration::ResourcePointer())
propertyMap.Insert("rendererType", "COLOR");
propertyMap.Insert("mixColor", testColor);
- Visual visual = factory.CreateVisual(propertyMap);
+ Visual::Base visual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
Dali::Property::Map map;
map[ "rendererType" ] = "COLOR";
map[ "mixColor" ] = testColor;
- Visual visual = factory.CreateVisual( map );
+ Visual::Base visual = factory.CreateVisual( map );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
propertyMap.Insert("borderColor", testColor);
propertyMap.Insert("borderSize", testSize);
- Visual visual = factory.CreateVisual(propertyMap);
+ Visual::Base visual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
propertyMap[ "rendererType" ] = "BORDER";
propertyMap[ "borderColor" ] = testColor;
propertyMap[ "borderSize" ] = testSize;
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- Visual visual = factory.CreateVisual(propertyMap);
+ Visual::Base visual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK( visual );
// A lookup texture is generated and pass to shader as sampler
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- Visual visual = factory.CreateVisual(propertyMap);
+ Visual::Base visual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK( visual );
// A lookup texture is generated and pass to shader as sampler
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- Visual visual = factory.CreateVisual(propertyMap);
+ Visual::Base visual = factory.CreateVisual(propertyMap);
DALI_TEST_CHECK( visual );
// A lookup texture is generated and pass to shader as sampler
propertyMap.Insert( "rendererType", "IMAGE" );
propertyMap.Insert( "url", TEST_IMAGE_FILE_NAME );
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
DALI_TEST_CHECK( factory );
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
- Visual visual = factory.CreateVisual( image );
+ Visual::Base visual = factory.CreateVisual( image );
Actor actor = Actor::New();
// For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
propertyMap.Insert( "url", TEST_NPATCH_FILE_NAME );
{
tet_infoline( "whole grid" );
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
propertyMap.Insert( "borderOnly", true );
{
tet_infoline( "border only" );
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
propertyMap.Insert( "rendererType", "IMAGE" );
propertyMap.Insert( "url", TEST_NPATCH_FILE_NAME );
{
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
propertyMap.Insert( "borderOnly", true );
{
tet_infoline( "border only" );
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
TestGlAbstraction& gl = application.GetGlAbstraction();
stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
- Visual visual = factory.CreateVisual( TEST_NPATCH_FILE_NAME, ImageDimensions() );
+ Visual::Base visual = factory.CreateVisual( TEST_NPATCH_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
- Visual visual = factory.CreateVisual( TEST_NPATCH_FILE_NAME, ImageDimensions() );
+ Visual::Base visual = factory.CreateVisual( TEST_NPATCH_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
VisualFactory factory = VisualFactory::Get();
DALI_TEST_CHECK( factory );
- Visual visual = factory.CreateVisual( "ERROR.9.jpg", ImageDimensions() );
+ Visual::Base visual = factory.CreateVisual( "ERROR.9.jpg", ImageDimensions() );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
propertyMap.Insert( "rendererType", 111 );
propertyMap.Insert( "url", "ERROR.9.jpg" );
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
Actor actor = Actor::New();
tet_infoline( "UtcDaliVisualFactoryGetSvgVisual: Request svg visual with a svg url" );
VisualFactory factory = VisualFactory::Get();
- Visual visual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
+ Visual::Base visual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( visual );
TestGlAbstraction& gl = application.GetGlAbstraction();
DALI_TEST_CHECK( factory );
//Create a mesh visual.
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
//Create an actor on stage to house the visual.
DALI_TEST_CHECK( factory );
//Create a mesh visual.
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
//Create an actor on stage to house the visual.
DALI_TEST_CHECK( factory );
//Create a primitive visual.
- Visual visual = factory.CreateVisual( propertyMap );
+ Visual::Base visual = factory.CreateVisual( propertyMap );
DALI_TEST_CHECK( visual );
//Create an actor on stage to house the visual.
$(devel_api_src_dir)/transition-effects/cube-transition-fold-effect.cpp \
$(devel_api_src_dir)/transition-effects/cube-transition-wave-effect.cpp \
$(devel_api_src_dir)/visual-factory/visual-factory.cpp \
- $(devel_api_src_dir)/visual-factory/visual.cpp
+ $(devel_api_src_dir)/visual-factory/visual-base.cpp
# Add devel header files here
devel_api_visual_factory_header_files = \
$(devel_api_src_dir)/visual-factory/visual-factory.h \
- $(devel_api_src_dir)/visual-factory/visual.h
+ $(devel_api_src_dir)/visual-factory/visual-base.h
devel_api_shadow_view_header_files = \
$(devel_api_src_dir)/controls/shadow-view/shadow-view.h
*/
// CLASS HEADER
-#include <dali-toolkit/internal/visuals/visual-impl.h>
-#include "visual.h"
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+
+// INTERAL INCLUDES
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
{
namespace Toolkit
{
-Visual::Visual()
+namespace Visual
+{
+
+Base::Base()
{
}
-Visual::~Visual()
+Base::~Base()
{
}
-Visual::Visual( const Visual& handle )
+Base::Base( const Base& handle )
: BaseHandle( handle )
{
}
-Visual& Visual::operator=( const Visual& handle )
+Base& Base::operator=( const Base& handle )
{
BaseHandle::operator=( handle );
return *this;
}
-Visual::Visual(Internal::Visual *impl)
+Base::Base(Internal::Visual::Base *impl)
: BaseHandle( impl )
{
}
-void Visual::SetSize( const Vector2& size )
+void Base::SetSize( const Vector2& size )
{
GetImplementation( *this ).SetSize( size );
}
-const Vector2& Visual::GetSize() const
+const Vector2& Base::GetSize() const
{
return GetImplementation( *this ).GetSize();
}
-void Visual::GetNaturalSize(Vector2& naturalSize ) const
+void Base::GetNaturalSize(Vector2& naturalSize ) const
{
GetImplementation( *this ).GetNaturalSize( naturalSize );
}
-void Visual::SetDepthIndex( float index )
+void Base::SetDepthIndex( float index )
{
GetImplementation( *this ).SetDepthIndex( index );
}
-float Visual::GetDepthIndex() const
+float Base::GetDepthIndex() const
{
return GetImplementation( *this ).GetDepthIndex();
}
-void Visual::SetOnStage( Actor& actor )
+void Base::SetOnStage( Actor& actor )
{
GetImplementation( *this ).SetOnStage( actor );
}
-void Visual::SetOffStage( Actor& actor )
+void Base::SetOffStage( Actor& actor )
{
GetImplementation( *this ).SetOffStage( actor );
}
-void Visual::RemoveAndReset( Actor& actor )
+void Base::RemoveAndReset( Actor& actor )
{
if( actor && *this )
{
Reset();
}
-void Visual::CreatePropertyMap( Property::Map& map ) const
+void Base::CreatePropertyMap( Property::Map& map ) const
{
GetImplementation( *this ).CreatePropertyMap( map );
}
+} // namespace Visual
+
} // namespace Toolkit
} // namespace Dali
-#ifndef __DALI_TOOLKIT_CONTROL_RENDERER_H__
-#define __DALI_TOOLKIT_CONTROL_RENDERER_H__
+#ifndef DALI_TOOLKIT_VISUAL_BASE_H
+#define DALI_TOOLKIT_VISUAL_BASE_H
/*
* Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
namespace Internal DALI_INTERNAL
{
-class Visual;
+namespace Visual
+{
+class Base;
+}
}
+namespace Visual
+{
/**
* @brief Visual provides renderer for rendering the controls. A control may have multiple ControlRenders.
*
* It also responds to actor size and color change, and provides the clipping at the renderer level.
* Note: The control renderer responds to the the Actor::COLOR by blending it with the 'Multiply' operator.
*/
-class DALI_IMPORT_API Visual : public BaseHandle
+class DALI_IMPORT_API Base : public BaseHandle
{
public:
/**
* @brief Create an empty Visual Handle
*/
- Visual();
+ Base();
/**
* @brief Destructor
*
* This is non-virtual since derived Handle types must not contain data or virtual methods.
*/
- ~Visual();
+ ~Base();
/**
* @brief This copy constructor is required for (smart) pointer semantics.
*
* @param[in] handle A reference to the copied handle.
*/
- Visual( const Visual& handle );
+ Base( const Base& handle );
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param [in] handle A reference to the copied handle.
* @return A reference to this.
*/
- Visual& operator=( const Visual& handle );
+ Base& operator=( const Base& handle );
/**
* @brief Set the size of the painting area.
public: // Not intended for application developers
- explicit DALI_INTERNAL Visual(Internal::Visual *impl);
+ explicit DALI_INTERNAL Base(Internal::Visual::Base *impl);
};
+} // namespace Visual
+
} // namespace Toolkit
} // namespace Dali
-#endif /*__DALI_TOOLKIT_CONTROL_RENDERER_H__*/
+#endif /*DALI_TOOLKIT_VISUAL_BASE_H*/
{
}
-Visual VisualFactory::CreateVisual( const Property::Map& propertyMap )
+Visual::Base VisualFactory::CreateVisual( const Property::Map& propertyMap )
{
return GetImplementation( *this ).CreateVisual( propertyMap );
}
-Visual VisualFactory::CreateVisual( const Image& image )
+Visual::Base VisualFactory::CreateVisual( const Image& image )
{
return GetImplementation( *this ).CreateVisual( image );
}
-Visual VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
+Visual::Base VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
{
return GetImplementation( *this ).CreateVisual( url, size );
}
#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/devel-api/visual-factory/visual.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
namespace Dali
{
/**
* @brief VisualFactory is a singleton object that provides and shares visuals between controls
*
- * By setting environment variable 'DALI_DEBUG_RENDERING', all concrete renderer is replaced with the debug renderer which renders a quad wireframe.
+ * By setting environment variable 'DALI_DEBUG_RENDERING', a debug visual is used which renders a quad wireframe.
*
- * The renderer type is required in the property map for requesting a control renderer.
+ * The visual type is required in the property map for requesting a visual.
*
* | %Property Name | Type |
* |--------------------------|------------------|
VisualFactory& operator=( const VisualFactory& handle );
/**
- * @brief Request the control renderer
+ * @brief Request the visual
*
* @param[in] propertyMap The map contains the properties required by the control renderer
* Depends on the content of the map, different kind of renderer would be returned.
- * @return The pointer pointing to control renderer
+ * @return The pointer pointing to visual
*/
- Visual CreateVisual( const Property::Map& propertyMap );
+ Visual::Base CreateVisual( const Property::Map& propertyMap );
/**
- * @brief Request the control renderer to render the image.
+ * @brief Request the visual to render the image.
*
* @param[in] image The image to be rendered.
- * @return The pointer pointing to the control renderer
+ * @return The pointer pointing to the visual
*/
- Visual CreateVisual( const Image& image );
+ Visual::Base CreateVisual( const Image& image );
/**
- * @brief Request the control renderer to render the given resource at the url.
+ * @brief Request the visual to render the given resource at the url.
*
* @param[in] url The URL to the resource to be rendered.
* @param[in] size The width and height to fit the loaded image to.
- * @return The pointer pointing to the control renderer
+ * @return The pointer pointing to the visual
*/
- Visual CreateVisual( const std::string& url, ImageDimensions size );
+ Visual::Base CreateVisual( const std::string& url, ImageDimensions size );
private:
/**
- * @brief Template to allow discard old renderer, get new one and set it on stage if possible
+ * @brief Template to allow discard old visual, get new one and set it on stage if possible
*
* @tparam ParameterType0 The type of first argument passed to the CreateVisual()
* @tparam ParameterType1 The type of second argument passed to the CreateVisual()
* @SINCE_1_0.39
* @param[in] actor Actor for which the renderer will be replaced
- * @param[in,out] renderer The renderer object to be replaced
+ * @param[in,out] visual The visual to be replaced
* @param[in] param0 First template based argument passed to the renderer factory
* @param[in] param1 Second template based argument passed to the renderer factory
*/
template< class ParameterType0, class ParameterType1 >
-void InitializeVisual( Actor& actor, Visual& renderer, ParameterType0& param0, ParameterType1& param1 )
+void InitializeVisual( Actor& actor, Visual::Base& visual, ParameterType0& param0, ParameterType1& param1 )
{
- renderer.RemoveAndReset( actor );
- renderer = Toolkit::VisualFactory::Get().CreateVisual( param0, param1 );
- if( renderer && actor && actor.OnStage() )
+ visual.RemoveAndReset( actor );
+ visual = Toolkit::VisualFactory::Get().CreateVisual( param0, param1 );
+ if( visual && actor && actor.OnStage() )
{
- renderer.SetOnStage( actor );
+ visual.SetOnStage( actor );
}
}
/**
- * @brief Template to allow discard old renderer, get new one and set it on stage if possible
+ * @brief Template to allow discard old visual, get new one and set it on stage if possible
*
* @tparam ParameterType The type of argument passed to the CreateVisual()
* @SINCE_1_0.39
* @param[in] actor Actor for which the renderer will be replaced
- * @param[in,out] renderer The renderer object to be replaced
+ * @param[in,out] visual The visual to be replaced
* @param[in] param Template based argument passed to the renderer factory
*/
template< class ParameterType >
-void InitializeVisual( Actor& actor, Visual& renderer, ParameterType& param )
+void InitializeVisual( Actor& actor, Visual::Base& visual, ParameterType& param )
{
- renderer.RemoveAndReset( actor );
- renderer = Toolkit::VisualFactory::Get().CreateVisual( param );
- if( renderer && actor && actor.OnStage() )
+ visual.RemoveAndReset( actor );
+ visual = Toolkit::VisualFactory::Get().CreateVisual( param );
+ if( visual && actor && actor.OnStage() )
{
- renderer.SetOnStage( actor );
+ visual.SetOnStage( actor );
}
}
// If there is no existing content, create a new actor to use for flat color.
Actor placementActor = Actor::New();
Toolkit::VisualFactory rendererFactory = Toolkit::VisualFactory::Get();
- Toolkit::Visual colorRenderer;
+ Toolkit::Visual::Base colorRenderer;
Property::Map map;
map["rendererType"] = "COLOR";
customShader[ "vertexShader" ] = EFFECTS_VIEW_VERTEX_SOURCE;
customShader[ "fragmentShader" ] = EFFECTS_VIEW_FRAGMENT_SOURCE;
rendererMap[ "shader" ] = customShader;
- InitializeVisual( self, mRendererPostFilter, rendererMap );
+ InitializeVisual( self, mVisualPostFilter, rendererMap );
mEffectType = type;
}
Enable();
Actor self = Self();
- if( mRendererPostFilter )
+ if( mVisualPostFilter )
{
- mRendererPostFilter.SetOnStage( self );
+ mVisualPostFilter.SetOnStage( self );
}
- if( mRendererForChildren )
+ if( mVisualForChildren )
{
- mRendererForChildren.SetOnStage( self );
+ mVisualForChildren.SetOnStage( self );
}
}
}
Actor self = Self();
- if( mRendererPostFilter )
+ if( mVisualPostFilter )
{
- mRendererPostFilter.SetOffStage( self );
+ mVisualPostFilter.SetOffStage( self );
}
- if( mRendererForChildren )
+ if( mVisualForChildren )
{
- mRendererForChildren.SetOffStage( self );
+ mVisualForChildren.SetOffStage( self );
}
Control::OnStageDisconnection();
Actor self( Self() );
mImageForChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
- InitializeVisual( self, mRendererForChildren, mImageForChildren );
- mRendererForChildren.SetDepthIndex( DepthIndex::CONTENT+1 );
+ InitializeVisual( self, mVisualForChildren, mImageForChildren );
+ mVisualForChildren.SetDepthIndex( DepthIndex::CONTENT+1 );
mImagePostFilter = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
TextureSet textureSet = TextureSet::New();
TextureSetImage( textureSet, 0u, mImagePostFilter );
self.GetRendererAt( 0 ).SetTextures( textureSet );
- mRendererPostFilter.SetDepthIndex( DepthIndex::CONTENT );
+ mVisualPostFilter.SetDepthIndex( DepthIndex::CONTENT );
SetupFilters();
}
/////////////////////////////////////////////////////////////
// for rendering all user added children to offscreen target
- FrameBufferImage mImageForChildren;
- Toolkit::Visual mRendererForChildren;
- RenderTask mRenderTaskForChildren;
- CameraActor mCameraForChildren;
- Actor mChildrenRoot; // for creating a subtree for all user added child actors
+ FrameBufferImage mImageForChildren;
+ Toolkit::Visual::Base mVisualForChildren;
+ RenderTask mRenderTaskForChildren;
+ CameraActor mCameraForChildren;
+ Actor mChildrenRoot; // for creating a subtree for all user added child actors
/////////////////////////////////////////////////////////////
// background fill color
Vector2 mLastSize;
/////////////////////////////////////////////////////////////
// post blur image
- FrameBufferImage mImagePostFilter;
- Toolkit::Visual mRendererPostFilter;
+ FrameBufferImage mImagePostFilter;
+ Toolkit::Visual::Base mVisualPostFilter;
Vector<ImageFilter*> mFilters;
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
{
mImage = image;
Actor self( Self() );
- InitializeVisual( self, mRenderer, image );
+ InitializeVisual( self, mVisual, image );
mImageSize = image ? ImageDimensions( image.GetWidth(), image.GetHeight() ) : ImageDimensions( 0, 0 );
RelayoutRequest();
mPropertyMap = map;
Actor self( Self() );
- InitializeVisual( self, mRenderer, mPropertyMap );
+ InitializeVisual( self, mVisual, mPropertyMap );
Property::Value* widthValue = mPropertyMap.Find( "width" );
if( widthValue )
}
Actor self( Self() );
- InitializeVisual( self, mRenderer, url, size );
+ InitializeVisual( self, mVisual, url, size );
- mRenderer.SetSize( mSizeSet );
+ mVisual.SetSize( mSizeSet );
RelayoutRequest();
}
void ImageView::EnablePreMultipliedAlpha( bool preMultipled )
{
- if( mRenderer )
+ if( mVisual )
{
- GetImplementation( mRenderer ).EnablePreMultipliedAlpha( preMultipled );
+ Toolkit::GetImplementation( mVisual ).EnablePreMultipliedAlpha( preMultipled );
}
}
bool ImageView::IsPreMultipliedAlphaEnabled() const
{
- if( mRenderer )
+ if( mVisual )
{
- return GetImplementation( mRenderer ).IsPreMultipliedAlphaEnabled();
+ return Toolkit::GetImplementation( mVisual ).IsPreMultipliedAlphaEnabled();
}
return false;
}
void ImageView::SetDepthIndex( int depthIndex )
{
- if( mRenderer )
+ if( mVisual )
{
- mRenderer.SetDepthIndex( depthIndex );
+ mVisual.SetDepthIndex( depthIndex );
}
}
Vector3 ImageView::GetNaturalSize()
{
- if( mRenderer )
+ if( mVisual )
{
Vector2 rendererNaturalSize;
- mRenderer.GetNaturalSize( rendererNaturalSize );
+ mVisual.GetNaturalSize( rendererNaturalSize );
return Vector3( rendererNaturalSize );
}
{
Control::OnStageConnection( depth );
- if( mRenderer )
+ if( mVisual )
{
CustomActor self = Self();
- mRenderer.SetOnStage( self );
+ mVisual.SetOnStage( self );
}
}
void ImageView::OnStageDisconnection()
{
- if( mRenderer )
+ if( mVisual )
{
CustomActor self = Self();
- mRenderer.SetOffStage( self );
+ mVisual.SetOffStage( self );
}
Control::OnStageDisconnection();
Control::OnSizeSet( targetSize );
mSizeSet = targetSize;
- if( mRenderer )
+ if( mVisual )
{
Vector2 size( targetSize );
- mRenderer.SetSize( size );
+ mVisual.SetSize( size );
}
}
impl.SetImage( map );
}
// the property map contains only the custom shader
- else if( impl.mRenderer && map.Count() == 1u && shaderValue )
+ else if( impl.mVisual && map.Count() == 1u && shaderValue )
{
Property::Map shaderMap;
if( shaderValue->Get( shaderMap ) )
{
- Internal::Visual& renderer = GetImplementation( impl.mRenderer );
- renderer.SetCustomShader( shaderMap );
+ Internal::Visual::Base& visual = Toolkit::GetImplementation( impl.mVisual );
+ visual.SetCustomShader( shaderMap );
if( imageView.OnStage() )
{
// force to create new core renderer to use the newly set shader
- renderer.SetOffStage( imageView );
- renderer.SetOnStage( imageView );
+ visual.SetOffStage( imageView );
+ visual.SetOnStage( imageView );
}
}
}
ImageView& operator=( const ImageView& );
private:
- Toolkit::Visual mRenderer;
- ImageDimensions mImageSize;
- Vector2 mSizeSet;
+ Toolkit::Visual::Base mVisual;
+ ImageDimensions mImageSize;
+ Vector2 mSizeSet;
std::string mUrl; ///< the url for the image if the image came from a URL, empty otherwise
Image mImage; ///< the Image if the image came from a Image, null otherwise
Vector3 sizeOffset(IMAGE_BORDER_INDENT*2.f - 2.f, IMAGE_BORDER_INDENT*2.f - 2.f, 0.0f);
mFrame.SetSizeModeFactor( sizeOffset );
- Toolkit::VisualFactory rendererFactory = Toolkit::VisualFactory::Get();
+ Toolkit::VisualFactory visualFactory = Toolkit::VisualFactory::Get();
Property::Map map;
map[ RENDERER_TYPE ] = BORDER_RENDERER;
map[ "borderColor" ] = Color::WHITE;
map[ "borderSize" ] = IMAGE_BORDER_INDENT;
- Toolkit::Visual borderRenderer = rendererFactory.CreateVisual( map );
- borderRenderer.SetOnStage( mFrame );
+ Toolkit::Visual::Base borderVisual = visualFactory.CreateVisual( map );
+ borderVisual.SetOnStage( mFrame );
Constraint constraint = Constraint::New<Vector3>( mFrame, Actor::Property::POSITION, EqualToConstraint() );
constraint.AddSource( ParentSource( Actor::Property::WORLD_POSITION ) );
#include <dali/integration-api/debug.h>
// INTERNAL_INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace //Unnamed namespace
{
DALI_ASSERT_ALWAYS( mBlurLevels > 0 && " Minimal blur level is one, otherwise no blur is needed" );
mGaussianBlurView.assign( blurLevels, Toolkit::GaussianBlurView() );
mBlurredImage.assign( blurLevels, FrameBufferImage() );
- mRenderers.assign( blurLevels+1, Toolkit::Visual() );
+ mVisuals.assign( blurLevels+1, Toolkit::Visual::Base() );
}
SuperBlurView::~SuperBlurView()
mInputImage = inputImage;
Actor self( Self() );
- InitializeVisual( self, mRenderers[0], mInputImage );
- mRenderers[0].SetDepthIndex(0);
- SetShaderEffect( mRenderers[0] );
+ InitializeVisual( self, mVisuals[0], mInputImage );
+ mVisuals[0].SetDepthIndex(0);
+ SetShaderEffect( mVisuals[0] );
if( self.OnStage() )
{
- mRenderers[0].SetOnStage( self );
+ mVisuals[0].SetOnStage( self );
}
BlurImage( 0, inputImage);
mResourcesCleared = true;
}
}
-void SuperBlurView::SetShaderEffect( Toolkit::Visual& renderer )
+void SuperBlurView::SetShaderEffect( Toolkit::Visual::Base& visual )
{
Property::Map shaderMap;
std::stringstream verterShaderString;
shaderMap[ "fragmentShader" ] = FRAGMENT_SHADER;
- Internal::Visual& rendererImpl = GetImplementation( renderer );
+ Internal::Visual::Base& rendererImpl = Toolkit::GetImplementation( visual );
rendererImpl.SetCustomShader( shaderMap );
}
{
mTargetSize = Vector2(targetSize);
- Toolkit::VisualFactory rendererFactory = Toolkit::VisualFactory::Get();
Actor self = Self();
for( unsigned int i = 1; i <= mBlurLevels; i++ )
{
float exponent = static_cast<float>(i);
mBlurredImage[i-1] = FrameBufferImage::New( mTargetSize.width/std::pow(2.f,exponent) , mTargetSize.height/std::pow(2.f,exponent),
GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT, Dali::Image::NEVER );
- InitializeVisual( self, mRenderers[i], mBlurredImage[i - 1] );
- mRenderers[ i ].SetDepthIndex( i );
- SetShaderEffect( mRenderers[ i ] );
+ InitializeVisual( self, mVisuals[i], mBlurredImage[i - 1] );
+ mVisuals[ i ].SetDepthIndex( i );
+ SetShaderEffect( mVisuals[ i ] );
}
if( mInputImage )
{
for( unsigned int i = 1; i <= mBlurLevels; i++ )
{
- mRenderers[i].SetOnStage( self );
+ mVisuals[i].SetOnStage( self );
}
}
}
}
Actor self = Self();
- if( mRenderers[0] )
+ if( mVisuals[0] )
{
- mRenderers[0].SetOnStage( self );
+ mVisuals[0].SetOnStage( self );
}
for(unsigned int i=1; i<=mBlurLevels;i++)
{
- if( mRenderers[i] )
+ if( mVisuals[i] )
{
- mRenderers[i].SetOnStage( self );
+ mVisuals[i].SetOnStage( self );
}
Renderer renderer = self.GetRendererAt( i );
Actor self = Self();
for(unsigned int i=0; i<mBlurLevels+1;i++)
{
- mRenderers[i].SetOffStage( self );
+ mVisuals[i].SetOffStage( self );
}
Control::OnStageDisconnection();
/**
* Sets shader effect on the control renderer
- * @param[in,out] Sets custom shader effect on the given renderer
+ * @param[in,out] Sets custom shader effect on the given visual
*/
- void SetShaderEffect( Toolkit::Visual& renderer );
+ void SetShaderEffect( Toolkit::Visual::Base& visual );
private:
std::vector<Toolkit::GaussianBlurView> mGaussianBlurView;
std::vector<FrameBufferImage> mBlurredImage;
- std::vector<Toolkit::Visual> mRenderers;
+ std::vector<Toolkit::Visual::Base> mVisuals;
Image mInputImage;
Vector2 mTargetSize;
mPropertyMap = map;
Actor self( Self() );
- InitializeVisual( self, mRenderer, mPropertyMap );
+ InitializeVisual( self, mVisual, mPropertyMap );
Property::Value* widthValue = mPropertyMap.Find( "width" );
if( widthValue )
void VideoView::SetDepthIndex( int depthIndex )
{
- if( mRenderer )
+ if( mVisual )
{
- mRenderer.SetDepthIndex( depthIndex );
+ mVisual.SetDepthIndex( depthIndex );
}
}
{
Control::OnStageConnection( depth );
- if( mRenderer )
+ if( mVisual )
{
CustomActor self = Self();
- mRenderer.SetOnStage( self );
+ mVisual.SetOnStage( self );
}
}
void VideoView::OnStageDisconnection()
{
- if( mRenderer )
+ if( mVisual )
{
CustomActor self = Self();
- mRenderer.SetOffStage( self );
+ mVisual.SetOffStage( self );
}
Control::OnStageDisconnection();
int curPos = mVideoPlayer.GetPlayPosition();
mSetRenderingTarget = true;
- mRenderer.RemoveAndReset( self );
+ mVisual.RemoveAndReset( self );
mVideoPlayer.SetRenderingTarget( Dali::Adaptor::Get().GetNativeWindowHandle() );
mVideoPlayer.SetUrl( mUrl );
mVideoPlayer.SetUrl( mUrl );
mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
- InitializeVisual( self, mRenderer, mNativeImage );
+ InitializeVisual( self, mVisual, mNativeImage );
if( mIsPlay )
{
Dali::VideoPlayer mVideoPlayer;
Dali::ImageDimensions mVideoSize;
- Toolkit::Visual mRenderer;
+ Toolkit::Visual::Base mVisual;
Dali::Property::Map mPropertyMap;
Dali::NativeImage mNativeImage; ///< Native image handle for video rendering by texture streaming
Dali::Toolkit::VideoView::VideoViewSignalType mFinishedSignal;
$(toolkit_src_dir)/builder/json-parser-impl.cpp \
$(toolkit_src_dir)/builder/tree-node-manipulator.cpp \
$(toolkit_src_dir)/builder/replacement.cpp \
- $(toolkit_src_dir)/visuals/visual-impl.cpp \
- $(toolkit_src_dir)/visuals/visual-data-impl.cpp \
+ $(toolkit_src_dir)/visuals/visual-base-impl.cpp \
+ $(toolkit_src_dir)/visuals/visual-base-data-impl.cpp \
$(toolkit_src_dir)/visuals/image-atlas-manager.cpp \
$(toolkit_src_dir)/visuals/visual-factory-cache.cpp \
$(toolkit_src_dir)/visuals/visual-factory-impl.cpp \
mRootActor.Add( mActorForComposite );
- InitializeVisual( mActorForComposite, mRendererForEmboss1, rendererMap );
- InitializeVisual( mActorForComposite, mRendererForEmboss2, rendererMap );
+ InitializeVisual( mActorForComposite, mVisualForEmboss1, rendererMap );
+ InitializeVisual( mActorForComposite, mVisualForEmboss2, rendererMap );
TextureSet textureSet1 = TextureSet::New();
TextureSetImage( textureSet1, 0, mImageForEmboss1 );
if( mActorForComposite )
{
- mRendererForEmboss1.SetOffStage( mActorForComposite );
- mRendererForEmboss2.SetOffStage( mActorForComposite );
- mRendererForEmboss1.Reset();
- mRendererForEmboss2.Reset();
+ mVisualForEmboss1.SetOffStage( mActorForComposite );
+ mVisualForEmboss2.SetOffStage( mActorForComposite );
+ mVisualForEmboss1.Reset();
+ mVisualForEmboss2.Reset();
mRootActor.Remove( mActorForComposite );
mActorForComposite.Reset();
}
// EXTERNAL INCLUDES
#include <dali/public-api/render-tasks/render-task.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
-#include <dali-toolkit/devel-api/visual-factory/visual.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
#include "image-filter.h"
namespace Dali
private: // Attributes
- RenderTask mRenderTaskForEmboss1;
- RenderTask mRenderTaskForEmboss2;
- RenderTask mRenderTaskForOutput;
- FrameBufferImage mImageForEmboss1;
- FrameBufferImage mImageForEmboss2;
- Toolkit::ImageView mActorForInput1;
- Toolkit::ImageView mActorForInput2;
- Toolkit::Visual mRendererForEmboss1;
- Toolkit::Visual mRendererForEmboss2;
- Actor mActorForComposite;
+ RenderTask mRenderTaskForEmboss1;
+ RenderTask mRenderTaskForEmboss2;
+ RenderTask mRenderTaskForOutput;
+ FrameBufferImage mImageForEmboss1;
+ FrameBufferImage mImageForEmboss2;
+ Toolkit::ImageView mActorForInput1;
+ Toolkit::ImageView mActorForInput2;
+ Toolkit::Visual::Base mVisualForEmboss1;
+ Toolkit::Visual::Base mVisualForEmboss2;
+ Actor mActorForComposite;
}; // class EmbossFilter
} // namespace Internal
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
{
}
BorderVisual::BorderVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mBorderColor( Color::TRANSPARENT ),
mBorderSize( 0.f ),
mBorderColorIndex( Property::INVALID_INDEX ),
void BorderVisual::SetClipRect( const Rect<int>& clipRect )
{
- Visual::SetClipRect( clipRect );
+ Visual::Base::SetClipRect( clipRect );
//ToDo: renderer responds to the clipRect change
}
#include <dali/public-api/rendering/geometry.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
{
* | antiAliasing | BOOLEAN |
*/
-class BorderVisual : public Visual
+class BorderVisual : public Visual::Base
{
public:
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
{
}
ColorVisual::ColorVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mMixColorIndex( Property::INVALID_INDEX )
{
}
void ColorVisual::SetSize( const Vector2& size )
{
- Visual::SetSize( size );
+ Visual::Base::SetSize( size );
// ToDo: renderer responds to the size change
}
void ColorVisual::SetClipRect( const Rect<int>& clipRect )
{
- Visual::SetClipRect( clipRect );
+ Visual::Base::SetClipRect( clipRect );
//ToDo: renderer responds to the clipRect change
}
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
{
* |-----------------|-------------|
* | mixColor | VECTOR4 |
*/
-class ColorVisual: public Visual
+class ColorVisual: public Visual::Base
{
public:
//INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
{
DebugVisual::DebugVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache )
+: Visual::Base( factoryCache )
{
}
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
{
* The visual which renders a wireframe outline to the control's quad for debugging
*
*/
-class DebugVisual: public Visual
+class DebugVisual: public Visual::Base
{
public:
//INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/gradient/linear-gradient.h>
#include <dali-toolkit/internal/visuals/gradient/radial-gradient.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
{
GradientVisual::GradientVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mGradientType( LINEAR )
{
mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
void GradientVisual::SetSize( const Vector2& size )
{
- Visual::SetSize( size );
+ Visual::Base::SetSize( size );
}
void GradientVisual::SetClipRect( const Rect<int>& clipRect )
{
- Visual::SetClipRect( clipRect );
+ Visual::Base::SetClipRect( clipRect );
//ToDo: renderer responds to the clipRect change
}
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/visuals/gradient/gradient.h>
namespace Dali
* Valid values for spreadMethod are 'pad', 'repeat' and 'reflect.'
* If not provided, 'objectBoundingBox' is used as default gradient units, and 'pad' is used as default spread method.
*/
-class GradientVisual: public Visual
+class GradientVisual: public Visual::Base
{
public:
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
-#include <dali-toolkit/internal/visuals/visual-impl.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
{
} //unnamed namespace
ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mAtlasManager( atlasManager ),
mDesiredSize(),
mFittingMode( FittingMode::DEFAULT ),
void ImageVisual::SetSize( const Vector2& size )
{
- Visual::SetSize( size );
+ Visual::Base::SetSize( size );
}
void ImageVisual::GetNaturalSize( Vector2& naturalSize ) const
void ImageVisual::SetClipRect( const Rect<int>& clipRect )
{
- Visual::SetClipRect( clipRect );
+ Visual::Base::SetClipRect( clipRect );
}
void ImageVisual::SetOffset( const Vector2& offset )
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
// EXTERNAL INCLUDES
* "DEFAULT"
*
*/
-class ImageVisual: public Visual, public ConnectionTracker
+class ImageVisual: public Visual::Base, public ConnectionTracker
{
public:
//INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
{
} // namespace
MeshVisual::MeshVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mShaderType( ALL_TEXTURES ),
mUseTexture( true ),
mUseMipmapping( true ),
void MeshVisual::SetSize( const Vector2& size )
{
- Visual::SetSize( size );
+ Visual::Base::SetSize( size );
// ToDo: renderer responds to the size change
}
void MeshVisual::SetClipRect( const Rect<int>& clipRect )
{
- Visual::SetClipRect( clipRect );
+ Visual::Base::SetClipRect( clipRect );
//ToDo: renderer responds to the clipRect change
}
#include <string.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/controls/model3d-view/obj-loader.h>
namespace Dali
* | useSoftNormals | BOOLEAN | If true, average normals at points for smooth textures. Default true. |
* | lightPosition | VECTOR3 | The position (on stage) of the light |
*/
-class MeshVisual: public Visual
+class MeshVisual: public Visual::Base
{
public:
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-impl.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
/////////////////NPatchVisual////////////////
NPatchVisual::NPatchVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mBorderOnly( false )
{
}
void NPatchVisual::SetClipRect( const Rect<int>& clipRect )
{
- Visual::SetClipRect( clipRect );
+ Visual::Base::SetClipRect( clipRect );
//ToDo: renderer responds to the clipRect change
}
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
// EXTERNAL INCLUDES
#include <dali/public-api/images/image.h>
* | borderOnly | BOOLEAN
*
*/
-class NPatchVisual: public Visual
+class NPatchVisual: public Visual::Base
{
public:
//INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace Dali
{
} // namespace
PrimitiveVisual::PrimitiveVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mColor( DEFAULT_COLOR ),
mScaleDimensions( Vector3::ONE ),
mScaleTopRadius( DEFAULT_SCALE_TOP_RADIUS ),
void PrimitiveVisual::SetSize( const Vector2& size )
{
- Visual::SetSize( size );
+ Visual::Base::SetSize( size );
// ToDo: renderer responds to the size change
}
void PrimitiveVisual::SetClipRect( const Rect<int>& clipRect )
{
- Visual::SetClipRect( clipRect );
+ Visual::Base::SetClipRect( clipRect );
//ToDo: renderer responds to the clipRect change
}
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
{
* |-----------------|-------------|-----------------------------------------|
* | lightPosition | VECTOR3 | The position (on stage) of the light |
*/
-class PrimitiveVisual: public Visual
+class PrimitiveVisual: public Visual::Base
{
public:
#include <dali-toolkit/internal/visuals/image/image-visual.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace
{
SvgVisual::SvgVisual( VisualFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
-: Visual( factoryCache ),
+: Visual::Base( factoryCache ),
mAtlasRect( FULL_TEXTURE_RECT ),
mAtlasManager( atlasManager ),
mParsedImage( NULL )
*/
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
struct NSVGimage;
* | url | STRING |
*
*/
-class SvgVisual: public Visual
+class SvgVisual: public Visual::Base
{
public:
*/
// CLASS HEADER
-#include "visual-data-impl.h"
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
-// EXTERNAL HEADER
+// EXTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
#include <dali/integration-api/debug.h>
#include <dali/public-api/object/property-array.h>
-// EXTERNAL HEADER
-
namespace Dali
{
}// unnamed namespace
-Internal::Visual::Impl::Impl()
+Internal::Visual::Base::Impl::Impl()
: mCustomShader(NULL),
mDepthIndex( 0.0f ),
mFlags( 0 )
{
}
-Internal::Visual::Impl::~Impl()
+Internal::Visual::Base::Impl::~Impl()
{
delete mCustomShader;
}
-Internal::Visual::Impl::CustomShader::CustomShader( const Property::Map& map )
+Internal::Visual::Base::Impl::CustomShader::CustomShader( const Property::Map& map )
: mGridSize( 1, 1 ),
mHints( Shader::Hint::NONE )
{
SetPropertyMap( map );
}
-void Internal::Visual::Impl::CustomShader::SetPropertyMap( const Property::Map& shaderMap )
+void Internal::Visual::Base::Impl::CustomShader::SetPropertyMap( const Property::Map& shaderMap )
{
mVertexShader.clear();
mFragmentShader.clear();
}
}
-void Internal::Visual::Impl::CustomShader::CreatePropertyMap( Property::Map& map ) const
+void Internal::Visual::Base::Impl::CustomShader::CreatePropertyMap( Property::Map& map ) const
{
if( !mVertexShader.empty() || !mFragmentShader.empty() )
{
-#ifndef DALI_TOOLKIT_INTERNAL_VISUAL_DATA_IMPL_H
-#define DALI_TOOLKIT_INTERNAL_VISUAL_DATA_IMPL_H
+#ifndef DALI_TOOLKIT_INTERNAL_VISUAL_BASE_DATA_IMPL_H
+#define DALI_TOOLKIT_INTERNAL_VISUAL_BASE_DATA_IMPL_H
/*
* Copyright (c) 2016 Samsung Electronics Co., Ltd.
#include <dali/public-api/rendering/renderer.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/visuals/visual-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-impl.h>
namespace Dali
{
namespace Internal
{
-struct Internal::Visual::Impl
+namespace Visual
+{
+
+struct Base::Impl
{
enum Flags
{
~Impl();
};
+} // namespace Visual
+
} // namespace Internal
} // namespace Toolkit
} // namespace Dali
-#endif // DALI_TOOLKIT_INTERNAL_VISUAL_DATA_IMPL_H
+#endif // DALI_TOOLKIT_INTERNAL_VISUAL_BASE_DATA_IMPL_H
*/
// CLASS HEADER
-#include "visual-impl.h"
+#include "visual-base-impl.h"
// EXTERNAL HEADER
#include <dali/public-api/common/dali-common.h>
#include <dali/integration-api/debug.h>
//INTERNAL HEARDER
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
namespace
{
namespace Internal
{
-Visual::Visual( VisualFactoryCache& factoryCache )
+namespace Visual
+{
+
+Base::Base( VisualFactoryCache& factoryCache )
: mImpl( new Impl() ),
mFactoryCache( factoryCache )
{
}
-Visual::~Visual()
+Base::~Base()
{
delete mImpl;
}
-void Visual::SetCustomShader( const Property::Map& shaderMap )
+void Base::SetCustomShader( const Property::Map& shaderMap )
{
if( mImpl->mCustomShader )
{
}
}
-void Visual::Initialize( Actor& actor, const Property::Map& propertyMap )
+void Base::Initialize( Actor& actor, const Property::Map& propertyMap )
{
Property::Value* customShaderValue = propertyMap.Find( CUSTOM_SHADER );
if( customShaderValue )
DoInitialize( actor, propertyMap );
}
-void Visual::SetSize( const Vector2& size )
+void Base::SetSize( const Vector2& size )
{
mImpl->mSize = size;
}
-const Vector2& Visual::GetSize() const
+const Vector2& Base::GetSize() const
{
return mImpl->mSize;
}
-void Visual::GetNaturalSize( Vector2& naturalSize ) const
+void Base::GetNaturalSize( Vector2& naturalSize ) const
{
naturalSize = Vector2::ZERO;
}
-void Visual::SetClipRect( const Rect<int>& clipRect )
+void Base::SetClipRect( const Rect<int>& clipRect )
{
}
-void Visual::SetOffset( const Vector2& offset )
+void Base::SetOffset( const Vector2& offset )
{
mImpl->mOffset = offset;
}
-void Visual::SetDepthIndex( float index )
+void Base::SetDepthIndex( float index )
{
mImpl->mDepthIndex = index;
if( mImpl->mRenderer )
}
}
-float Visual::GetDepthIndex() const
+float Base::GetDepthIndex() const
{
return mImpl->mDepthIndex;
}
-void Visual::SetOnStage( Actor& actor )
+void Base::SetOnStage( Actor& actor )
{
DoSetOnStage( actor );
mImpl->mFlags |= Impl::IS_ON_STAGE;
}
-void Visual::SetOffStage( Actor& actor )
+void Base::SetOffStage( Actor& actor )
{
if( GetIsOnStage() )
{
}
}
-void Visual::EnablePreMultipliedAlpha( bool preMultipled )
+void Base::EnablePreMultipliedAlpha( bool preMultipled )
{
if(preMultipled)
{
}
}
-bool Visual::IsPreMultipliedAlphaEnabled() const
+bool Base::IsPreMultipliedAlphaEnabled() const
{
return mImpl->mFlags & Impl::IS_PREMULTIPLIED_ALPHA;
}
-void Visual::DoSetOnStage( Actor& actor )
+void Base::DoSetOnStage( Actor& actor )
{
}
-void Visual::DoSetOffStage( Actor& actor )
+void Base::DoSetOffStage( Actor& actor )
{
actor.RemoveRenderer( mImpl->mRenderer );
mImpl->mRenderer.Reset();
}
-void Visual::CreatePropertyMap( Property::Map& map ) const
+void Base::CreatePropertyMap( Property::Map& map ) const
{
DoCreatePropertyMap( map );
}
}
-bool Visual::GetIsOnStage() const
+bool Base::GetIsOnStage() const
{
return mImpl->mFlags & Impl::IS_ON_STAGE;
}
-bool Visual::GetIsFromCache() const
+bool Base::GetIsFromCache() const
{
return mImpl->mFlags & Impl::IS_FROM_CACHE;
}
+} // namespace Visual
+
} // namespace Internal
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
-#include <dali-toolkit/devel-api/visual-factory/visual.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
namespace Dali
{
namespace Internal
{
+namespace Visual
+{
+
/**
* Base class for all Control rendering logic. A control may have multiple visuals.
*
* | subdivideGridY | INT |
* | shaderHints | INT |
*/
-class Visual : public BaseObject
+class Base : public BaseObject
{
public:
/**
- * Initialisation of the visual, this API should only called by the VisualFactory:
+ * Initialisation of the visual, this API should only called by the VisualFactory:
* request the geometry and shader from the cache, if not available, create and save to the cache for sharing;
* record the property values.
*
void Initialize( Actor& actor, const Property::Map& propertyMap );
/**
- * @copydoc Toolkit::Visual::SetSize
+ * @copydoc Toolkit::Visual::Base::SetSize
*/
virtual void SetSize( const Vector2& size );
/**
- * @copydoc Toolkit::Visual::GetSize
+ * @copydoc Toolkit::Visual::Base::GetSize
*/
const Vector2& GetSize() const;
/**
- * @copydoc Toolkit::Visual::GetNaturalSize
+ * @copydoc Toolkit::Visual::Base::GetNaturalSize
*/
virtual void GetNaturalSize( Vector2& naturalSize ) const;
virtual void SetOffset( const Vector2& offset );
/**
- * @copydoc Toolkit::Visual::SetDepthIndex
+ * @copydoc Toolkit::Visual::Base::SetDepthIndex
*/
void SetDepthIndex( float index );
/**
- * @copydoc Toolkit::Visual::GetDepthIndex
+ * @copydoc Toolkit::Visual::Base::GetDepthIndex
*/
float GetDepthIndex() const;
/**
- * @copydoc Toolkit::Visual::SetOnStage
+ * @copydoc Toolkit::Visual::Base::SetOnStage
* @pre Impl->mGeometry must be created before this method is called
*/
void SetOnStage( Actor& actor );
/**
- * @copydoc Toolkit::Visual::SetOffStage
+ * @copydoc Toolkit::Visual::Base::SetOffStage
*/
void SetOffStage( Actor& actor );
/**
- * @copydoc Toolkit::Visual::CreatePropertyMap
+ * @copydoc Toolkit::Visual::Base::CreatePropertyMap
*/
void CreatePropertyMap( Property::Map& map ) const;
*
* @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
*/
- Visual( VisualFactoryCache& factoryCache );
+ Base( VisualFactoryCache& factoryCache );
/**
* @brief A reference counted object may only be deleted by calling Unreference().
*/
- virtual ~Visual();
+ virtual ~Base();
protected:
/**
private:
// Undefined
- Visual( const Visual& visual );
+ Base( const Visual::Base& visual );
// Undefined
- Visual& operator=( const Visual& visual );
+ Base& operator=( const Visual::Base& visual );
protected:
struct Impl;
VisualFactoryCache& mFactoryCache;
};
+} // namspace Visual
+
} // namespace Internal
-inline const Internal::Visual& GetImplementation(const Toolkit::Visual& visual)
+inline const Internal::Visual::Base& GetImplementation(const Toolkit::Visual::Base& visualBase )
{
- DALI_ASSERT_ALWAYS( visual && "Visual handle is empty" );
+ DALI_ASSERT_ALWAYS( visualBase && "visual base handle is empty" );
- const BaseObject& handle = visual.GetBaseObject();
+ const BaseObject& handle = visualBase.GetBaseObject();
- return static_cast<const Internal::Visual&>(handle);
+ return static_cast<const Internal::Visual::Base&>(handle);
}
-inline Internal::Visual& GetImplementation(Toolkit::Visual& visual)
+inline Internal::Visual::Base& GetImplementation(Toolkit::Visual::Base& visualBase)
{
- DALI_ASSERT_ALWAYS( visual && "Visual handle is empty" );
+ DALI_ASSERT_ALWAYS( visualBase && "visual base handle is empty" );
- BaseObject& handle = visual.GetBaseObject();
+ BaseObject& handle = visualBase.GetBaseObject();
- return static_cast<Internal::Visual&>(handle);
+ return static_cast<Internal::Visual::Base&>(handle);
}
} // namespace Toolkit
return rendererType;
}
-Toolkit::Visual VisualFactory::CreateVisual( const Property::Map& propertyMap )
+Toolkit::Visual::Base VisualFactory::CreateVisual( const Property::Map& propertyMap )
{
- Visual* rendererPtr = NULL;
+ Visual::Base* rendererPtr = NULL;
RendererType type = GetRendererType( propertyMap );
if( type != UNDEFINED)
if( mDebugEnabled )
{
- return Toolkit::Visual( new DebugVisual( *( mFactoryCache.Get() ) ) );
+ return Toolkit::Visual::Base( new DebugVisual( *( mFactoryCache.Get() ) ) );
}
}
DALI_LOG_ERROR( "Renderer type unknown" );
}
- return Toolkit::Visual( rendererPtr );
+ return Toolkit::Visual::Base( rendererPtr );
}
-Toolkit::Visual VisualFactory::CreateVisual( const Image& image )
+Toolkit::Visual::Base VisualFactory::CreateVisual( const Image& image )
{
if( !mFactoryCache )
{
if( mDebugEnabled )
{
- return Toolkit::Visual( new DebugVisual( *( mFactoryCache.Get() ) ) );
+ return Toolkit::Visual::Base( new DebugVisual( *( mFactoryCache.Get() ) ) );
}
NinePatchImage npatchImage = NinePatchImage::DownCast( image );
NPatchVisual* rendererPtr = new NPatchVisual( *( mFactoryCache.Get() ) );
rendererPtr->SetImage( npatchImage );
- return Toolkit::Visual( rendererPtr );
+ return Toolkit::Visual::Base( rendererPtr );
}
else
{
Actor actor;
rendererPtr->SetImage( actor, image );
- return Toolkit::Visual( rendererPtr );
+ return Toolkit::Visual::Base( rendererPtr );
}
}
-Toolkit::Visual VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
+Toolkit::Visual::Base VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
{
if( !mFactoryCache )
{
if( mDebugEnabled )
{
- return Toolkit::Visual( new DebugVisual( *( mFactoryCache.Get() ) ) );
+ return Toolkit::Visual::Base( new DebugVisual( *( mFactoryCache.Get() ) ) );
}
if( NinePatchImage::IsNinePatchUrl( url ) )
NPatchVisual* rendererPtr = new NPatchVisual( *( mFactoryCache.Get() ) );
rendererPtr->SetImage( url );
- return Toolkit::Visual( rendererPtr );
+ return Toolkit::Visual::Base( rendererPtr );
}
else if( SvgVisual::IsSvgUrl( url ) )
{
CreateAtlasManager();
SvgVisual* rendererPtr = new SvgVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
rendererPtr->SetImage( url, size );
- return Toolkit::Visual( rendererPtr );
+ return Toolkit::Visual::Base( rendererPtr );
}
else
{
Actor actor;
rendererPtr->SetImage( actor, url, size );
- return Toolkit::Visual( rendererPtr );
+ return Toolkit::Visual::Base( rendererPtr );
}
}
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
-#include <dali-toolkit/devel-api/visual-factory/visual.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
namespace Dali
{
/**
* @copydoc Toolkit::RenderFactory::CreateVisual( const Property::Map& )
*/
- Toolkit::Visual CreateVisual( const Property::Map& propertyMap );
+ Toolkit::Visual::Base CreateVisual( const Property::Map& propertyMap );
/**
* @copydoc Toolkit::RenderFactory::CreateVisual( const Image& )
*/
- Toolkit::Visual CreateVisual( const Image& image );
+ Toolkit::Visual::Base CreateVisual( const Image& image );
/**
* @copydoc Toolkit::RenderFactory::CreateVisual( const std::string&, ImageDimensions )
*/
- Toolkit::Visual CreateVisual( const std::string& image, ImageDimensions size );
+ Toolkit::Visual::Base CreateVisual( const std::string& image, ImageDimensions size );
public:
/**
Control& mControlImpl;
std::string mStyleName;
- Toolkit::Visual mBackgroundRenderer; ///< The control renderer to render the background
+ Toolkit::Visual::Base mBackgroundRenderer; ///< The control renderer to render the background
Vector4 mBackgroundColor; ///< The color of the background renderer
Vector3* mStartingPinchScale; ///< The scale when a pinch gesture starts, TODO: consider removing this
Toolkit::Control::KeyEventSignalType mKeyEventSignal;
projects / platform / core / uifw / dali-toolkit.git / commitdiff