utc-Dali-ItemView.cpp
utc-Dali-KeyboardFocusManager.cpp
utc-Dali-Magnifier.cpp
- utc-Dali-NinePatchMaskEffect.cpp
utc-Dali-Popup.cpp
utc-Dali-PushButton.cpp
utc-Dali-RadioButton.cpp
utc-Dali-Model3dView.cpp
utc-Dali-ControlRenderer.cpp
utc-Dali-RendererFactory.cpp
+ utc-Dali-DebugRenderer.cpp
utc-Dali-ImageAtlas.cpp
)
dali-toolkit-test-utils/toolkit-application.cpp
dali-toolkit-test-utils/toolkit-clipboard.cpp
dali-toolkit-test-utils/toolkit-event-thread-callback.cpp
+ dali-toolkit-test-utils/toolkit-environment-variable.cpp
dali-toolkit-test-utils/toolkit-imf-manager.cpp
dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
dali-toolkit-test-utils/toolkit-style-monitor.cpp
{
case SuspendFunc: return mTrace.FindMethod("Suspend");
case ResumeFunc: return mTrace.FindMethod("Resume");
- case LoadResourceFunc: return mTrace.FindMethod("LoadResource");
+ case LoadResourceFunc: return mTrace.FindMethod("LoadResource") || mTrace.FindMethod("LoadResourceSynchronously");
case LoadFileFunc: return mTrace.FindMethod("LoadFile");
case LoadShaderBinaryFileFunc: return mTrace.FindMethod("LoadShaderBinaryFile");
case SaveShaderBinaryFileFunc: return mTrace.FindMethod("SaveShaderBinaryFile");
--- /dev/null
+/*
+ * Copyright (c) 2015 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 "toolkit-environment-variable.h"
+
+// EXTERNAL INCLUDE
+#include <cstddef>
+
+namespace Dali
+{
+
+namespace EnvironmentVariable
+{
+
+namespace
+{
+const char * gReturnValue = NULL;
+}
+
+const char * GetEnvironmentVariable( const char * variable )
+{
+ return gReturnValue;
+}
+
+void SetTestingEnvironmentVariable( bool testing)
+{
+ if( testing )
+ {
+ gReturnValue = "1";
+ }
+ else
+ {
+ gReturnValue = NULL;
+ }
+}
+
+} // namespace EnvironmentVariable
+
+} // namespace Dali
--- /dev/null
+#ifndef __DALI_TOOLKIT_ENVIRONMENT_VARIABLE_H__
+#define __DALI_TOOLKIT_ENVIRONMENT_VARIABLE_H__
+
+/*
+ * Copyright (c) 2015 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.
+ *
+ */
+#define __DALI_ENVIRONMENT_VARIABLE_H__
+
+#include <cstddef>
+
+namespace Dali
+{
+
+namespace EnvironmentVariable
+{
+
+const char * GetEnvironmentVariable( const char * variable );
+
+void SetTestingEnvironmentVariable( bool );
+
+} // namespace EnvironmentVariable
+
+} // namespace Dali
+
+
+#endif /* __DALI_TOOLKIT_ENVIRONMENT_VARIABLE_H__ */
DALI_TEST_EQUALS( actor.OnStageSignal().GetConnectionCount(), 0u, TEST_LOCATION );
Toolkit::Internal::Control& control = Toolkit::Internal::GetImplementation( dummy );
DummyControlImpl* dummyImpl = dynamic_cast<DummyControlImpl*>(&control);
- DALI_TEST_CHECK( dummyImpl );
+
+ if( dummyImpl == NULL )
+ {
+ tet_result( TET_FAIL );
+ END_TEST;
+ }
actor.OnStageSignal().Connect( dummyImpl, &DummyControlImpl::CustomSlot1 );
DALI_TEST_EQUALS( actor.OnStageSignal().GetConnectionCount(), 1u, TEST_LOCATION );
DummyControl dummy = DummyControlImpl::New();
Toolkit::Internal::Control& control = Toolkit::Internal::GetImplementation( dummy );
DummyControlImpl* dummyImpl = dynamic_cast<DummyControlImpl*>(&control);
- DALI_TEST_CHECK( dummyImpl );
+
+ if( dummyImpl == NULL )
+ {
+ tet_result( TET_FAIL );
+ END_TEST;
+ }
actor.OnStageSignal().Connect( dummyImpl, &DummyControlImpl::CustomSlot1 );
DALI_TEST_EQUALS( actor.OnStageSignal().GetConnectionCount(), 1u, TEST_LOCATION );
--- /dev/null
+/*
+ * Copyright (c) 2015 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.
+ *
+ */
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
+#include <dali/devel-api/rendering/renderer.h>
+#include <dali/devel-api/rendering/geometry.h>
+
+#include <toolkit-environment-variable.h> // for setting environment variable: DALI_DEBUG_RENDERING
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+namespace
+{
+const char* TEST_IMAGE_FILE_NAME = "image_01.jpg";
+const char* TEST_NPATCH_FILE_NAME = "image_01.9.jpg";
+
+bool IsDebugRenderer( ControlRenderer& renderer )
+{
+ bool isDebugRendererType = false;
+ bool isGeometryLineType = false;
+
+ Property::Map propertyMap;
+ renderer.CreatePropertyMap( propertyMap );
+ Property::Value* typeValue = propertyMap.Find( "rendererType", Property::STRING );
+ if ( typeValue )
+ {
+ isDebugRendererType = ( typeValue->Get<std::string>() == "debugRenderer" );
+ }
+
+ Actor actor = Actor::New();
+ renderer.SetOnStage( actor );
+ Geometry geometry = actor.GetRendererAt( 0 ).GetGeometry();
+ isGeometryLineType = ( geometry.GetGeometryType() == Geometry::LINES );
+
+ return isDebugRendererType && isGeometryLineType;
+}
+}
+
+void dali_debug_renderer_startup(void)
+{
+ test_return_value = TET_UNDEF;
+}
+
+void dali_debug_renderer_cleanup(void)
+{
+ test_return_value = TET_PASS;
+}
+
+int UtcDaliDebugRendererGetRenderer1(void)
+{
+ EnvironmentVariable::SetTestingEnvironmentVariable(true);
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliDebugRendererGetRenderer1: Request renderer with a Property::Map" );
+
+ RendererFactory factory = RendererFactory::Get();
+ DALI_TEST_CHECK( factory );
+
+ // Test that color renderer is replaced with debug renderer
+ Property::Map propertyMap1;
+ propertyMap1.Insert("rendererType", "colorRenderer");
+ propertyMap1.Insert("blendColor", Color::BLUE);
+ ControlRenderer colorRenderer = factory.GetControlRenderer(propertyMap1);
+ DALI_TEST_CHECK( colorRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( colorRenderer ) );
+
+ // Test that border renderer is replaced with debug renderer
+ Property::Map propertyMap2;
+ propertyMap2.Insert("rendererType", "borderRenderer");
+ propertyMap2.Insert("borderColor", Color::BLUE);
+ propertyMap2.Insert("borderSize", 2.f);
+ ControlRenderer borderRenderer = factory.GetControlRenderer(propertyMap2);
+ DALI_TEST_CHECK( borderRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( borderRenderer ) );
+
+ // Test that gradient renderer is replaced with debug renderer
+ Property::Map propertyMap3;
+ propertyMap3.Insert("rendererType", "gradientRenderer");
+ Vector2 start(-1.f, -1.f);
+ Vector2 end(1.f, 1.f);
+ propertyMap3.Insert("gradientStartPosition", start);
+ propertyMap3.Insert("gradientEndPosition", end);
+ propertyMap3.Insert("gradientSpreadMethod", "repeat");
+ Property::Array stopOffsets;
+ stopOffsets.PushBack( 0.2f );
+ stopOffsets.PushBack( 0.8f );
+ propertyMap3.Insert("gradientStopOffset", stopOffsets);
+ Property::Array stopColors;
+ stopColors.PushBack( Color::RED );
+ stopColors.PushBack( Color::GREEN );
+ propertyMap3.Insert("gradientStopColor", stopColors);
+ ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap3);
+ DALI_TEST_CHECK( gradientRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( gradientRenderer ) );
+
+ // Test that image renderer is replaced with debug renderer
+ Property::Map propertyMap4;
+ propertyMap4.Insert( "rendererType", "imageRenderer" );
+ propertyMap4.Insert( "imageUrl", TEST_IMAGE_FILE_NAME );
+ ControlRenderer imageRenderer = factory.GetControlRenderer( propertyMap4 );
+ DALI_TEST_CHECK( imageRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( imageRenderer ) );
+
+ // Test that n patch renderer is replaced with debug renderer
+ Property::Map propertyMap5;
+ propertyMap5.Insert( "rendererType", "nPatchRenderer" );
+ propertyMap5.Insert( "imageUrl", TEST_NPATCH_FILE_NAME );
+ ControlRenderer nPatchRenderer = factory.GetControlRenderer( propertyMap4 );
+ DALI_TEST_CHECK( nPatchRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( nPatchRenderer ) );
+
+ EnvironmentVariable::SetTestingEnvironmentVariable(false);
+ END_TEST;
+}
+
+int UtcDaliDebugRendererGetRenderer2(void)
+{
+ EnvironmentVariable::SetTestingEnvironmentVariable(true);
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliDebugRendererGetRenderer2: Request renderer with various parameters" );
+
+ RendererFactory factory = RendererFactory::Get();
+ DALI_TEST_CHECK( factory );
+
+ // Test that color renderer is replaced with debug renderer
+ ControlRenderer colorRenderer = factory.GetControlRenderer(Color::CYAN);
+ DALI_TEST_CHECK( colorRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( colorRenderer ) );
+
+ // Test that border renderer is replaced with debug renderer
+ ControlRenderer borderRenderer = factory.GetControlRenderer(2.f, Color::GREEN);
+ DALI_TEST_CHECK( borderRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( borderRenderer ) );
+
+ // Test that image renderer is replaced with debug renderer
+ Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
+ ControlRenderer imageRenderer = factory.GetControlRenderer( image );
+ DALI_TEST_CHECK( imageRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( imageRenderer ) );
+
+ // Test that n patch renderer is replaced with debug renderer
+ ControlRenderer nPatchRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
+ DALI_TEST_CHECK( nPatchRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( nPatchRenderer ) );
+
+ EnvironmentVariable::SetTestingEnvironmentVariable(false);
+ END_TEST;
+}
+
+int UtcDaliDebugRendererResetRenderer(void)
+{
+ EnvironmentVariable::SetTestingEnvironmentVariable(true);
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliDebugRendererResetRenderer: Reset renderer with various parameters" );
+
+ RendererFactory factory = RendererFactory::Get();
+ DALI_TEST_CHECK( factory );
+
+ // Test that color renderer is replaced with debug renderer
+ ControlRenderer controlRenderer = factory.GetControlRenderer(Color::CYAN);
+ DALI_TEST_CHECK( controlRenderer );
+ DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
+
+ Actor actor;
+ // Reset to render another color
+ // Test that color renderer is replaced with debug renderer
+ factory.ResetRenderer( controlRenderer, actor, Color::BLUE );
+ DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
+
+ // Reset to render an image
+ // Test that image renderer is replaced with debug renderer
+ Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
+ factory.ResetRenderer( controlRenderer, actor, image );
+ DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
+
+ // Reset with a property map of border renderer
+ // Test that border renderer is replaced with debug renderer
+ Property::Map propertyMap;
+ propertyMap.Insert("rendererType", "borderRenderer");
+ propertyMap.Insert("borderColor", Color::BLUE);
+ propertyMap.Insert("borderSize", 2.f);
+ factory.ResetRenderer( controlRenderer, actor, propertyMap );
+ DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
+
+ EnvironmentVariable::SetTestingEnvironmentVariable(false);
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliImageViewSetImageTypeChangesP(void)
+{
+ ToolkitTestApplication application;
+
+ ImageView imageView = ImageView::New();
+
+
+ std::string url;
+ Property::Map map;
+
+ Property::Value value = imageView.GetProperty( imageView.GetPropertyIndex( "image" ) );
+ DALI_TEST_CHECK( ! value.Get( url ) ); // Value should be empty
+ DALI_TEST_CHECK( ! value.Get( map ) ); // Value should be empty
+
+ // Set a URL
+ imageView.SetImage( "TEST_URL" );
+ value = imageView.GetProperty( imageView.GetPropertyIndex( "image" ) );
+
+ DALI_TEST_CHECK( value.Get( url ) ); // Value should NOT be empty
+ DALI_TEST_CHECK( ! value.Get( map ) ); // Value should be empty
+
+ // Set an empty Image
+ imageView.SetImage( Image() );
+ value = imageView.GetProperty( imageView.GetPropertyIndex( "image" ) );
+
+ DALI_TEST_CHECK( ! value.Get( url ) ); // Value should be empty
+ DALI_TEST_CHECK( ! value.Get( map ) ); // Value should be empty
+
+ // Set an Image
+ ResourceImage image1 = ResourceImage::New( TEST_IMAGE_FILE_NAME );
+ imageView.SetImage( image1 );
+ value = imageView.GetProperty( imageView.GetPropertyIndex( "image" ) );
+
+ DALI_TEST_CHECK( ! value.Get( url ) ); // Value should be empty
+ DALI_TEST_CHECK( value.Get( map ) ); // Value should NOT be empty
+
+ // Set an empty URL
+ imageView.SetImage( "" );
+ value = imageView.GetProperty( imageView.GetPropertyIndex( "image" ) );
+
+ DALI_TEST_CHECK( ! value.Get( url ) ); // Value should be empty
+ DALI_TEST_CHECK( ! value.Get( map ) ); // Value should be empty
+
+ END_TEST;
+}
+++ /dev/null
-/*
- * 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.
- *
- */
-
-#include <iostream>
-#include <stdlib.h>
-
-// Need to override adaptor classes for toolkit test harness, so include
-// test harness headers before dali headers.
-#include <dali-toolkit-test-suite-utils.h>
-
-#include <dali.h>
-#include <dali-toolkit/dali-toolkit.h>
-#include <dali-toolkit/devel-api/shader-effects/nine-patch-mask-effect.h>
-
-using namespace Dali;
-
-void utc_dali_toolkit_nine_patch_startup(void)
-{
- test_return_value = TET_UNDEF;
-}
-
-void utc_dali_toolkit_nine_patch_cleanup(void)
-{
- test_return_value = TET_PASS;
-}
-
-
-int UtcDaliNinePatchMaskEffectApply(void)
-{
- ToolkitTestApplication application;
-
- BufferImage image = CreateBufferImage();
- ImageActor actor0 = ImageActor::New( image );
- Toolkit::NinePatchMaskEffect::Apply( actor0, "" );
-
- Stage::GetCurrent().Add( actor0 );
-
- application.SendNotification(); // Force usage of constraint
- application.Render();
-
- DALI_TEST_CHECK( actor0.GetStyle() == ImageActor::STYLE_NINE_PATCH );
-
- ImageActor actor1 = ImageActor::New( image );
- Vector4 border( 0, 0, 0, 0 );
- Toolkit::NinePatchMaskEffect::Apply( actor1, "", border );
-
- Stage::GetCurrent().Add( actor1 );
-
- application.SendNotification();
- application.Render();
-
- DALI_TEST_CHECK( actor1.GetStyle() == ImageActor::STYLE_NINE_PATCH );
- END_TEST;
-}
return resourcePtr;
}
-void TestControlRendererRender( ToolkitTestApplication& application, Actor& actor, ControlRenderer& controlRenderer, Integration::ResourcePointer resourcePtr = Integration::ResourcePointer(), std::size_t expectedSamplers = 0)
+void TestControlRendererRender( ToolkitTestApplication& application,
+ Actor& actor,
+ ControlRenderer& controlRenderer,
+ std::size_t expectedSamplers = 0,
+ ImageDimensions imageDimensions = ImageDimensions(),
+ Integration::ResourcePointer resourcePtr = Integration::ResourcePointer())
{
+ if( resourcePtr )
+ {
+ // set the image size, for test case, this needs to be set before loading started
+ application.GetPlatform().SetClosestImageSize( Vector2(imageDimensions.GetWidth(), imageDimensions.GetHeight()) );
+ }
+
actor.SetSize( 200.f, 200.f );
Stage::GetCurrent().Add( actor );
controlRenderer.SetSize( Vector2(200.f, 200.f) );
// A lookup texture is generated and pass to shader as sampler
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(), 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u );
controlRenderer.SetOffStage( actor );
DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
// A lookup texture is generated and pass to shader as sampler
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(), 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u );
Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
alignMatrix.Invert();
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
+ // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
+ // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(512, 513),
+ Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)));
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
ControlRenderer controlRenderer = factory.GetControlRenderer( image );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
+ // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
+ // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(512, 513),
+ Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)) );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
+ ninePatchResource );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
+ ninePatchResource );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
+ ninePatchResource );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
+ ninePatchResource );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
+ ninePatchResource );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
+ ninePatchResource );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
Actor actor = Actor::New();
//The testkit still has to load a bitmap for the broken renderer image
- TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(),
+ Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)) );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
Actor actor = Actor::New();
//The testkit still has to load a bitmap for the broken renderer image
- TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
+ TestControlRendererRender( application, actor, controlRenderer, 1u,
+ ImageDimensions(),
+ Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)) );
TestGlAbstraction& gl = application.GetGlAbstraction();
int textureUnit = -1;
#include <dali-toolkit/devel-api/shader-effects/mirror-effect.h>
#include <dali-toolkit/devel-api/shader-effects/motion-blur-effect.h>
#include <dali-toolkit/devel-api/shader-effects/motion-stretch-effect.h>
-#include <dali-toolkit/devel-api/shader-effects/nine-patch-mask-effect.h>
#include <dali-toolkit/devel-api/shader-effects/overlay-effect.h>
#include <dali-toolkit/devel-api/shader-effects/quadratic-bezier.h>
#include <dali-toolkit/devel-api/shader-effects/ripple-effect.h>
{
ToolkitTestApplication application;
- ShaderEffect effect = Toolkit::CreateAlphaDiscardEffect();
- DALI_TEST_CHECK( effect );
+ Property::Map effect = Toolkit::CreateAlphaDiscardEffect();
+ DALI_TEST_CHECK( !effect.Empty() );
+
+ Property::Value* customShaderValue = effect.Find( "shader" );
+ DALI_TEST_CHECK( customShaderValue );
+
+ Property::Map customShader;
+ DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
+
+ Property::Value* vertexShaderValue = customShader.Find( "vertexShader" );
+ DALI_TEST_CHECK( !vertexShaderValue );
+
+ Property::Value* fragmentShaderValue = customShader.Find( "fragmentShader" );
+ DALI_TEST_CHECK( fragmentShaderValue );
+
+ std::string fragmentShader;
+ DALI_TEST_CHECK( fragmentShaderValue->Get( fragmentShader ) );
+ DALI_TEST_CHECK( !fragmentShader.empty() );
+
+ Property::Value* gridXValue = customShader.Find( "subdivideGridX" );
+ DALI_TEST_CHECK( !gridXValue );
+
+ Property::Value* gridYValue = customShader.Find( "subdivideGridY" );
+ DALI_TEST_CHECK( !gridYValue );
+
+ Property::Value* hintsValue = customShader.Find( "hints" );
+ DALI_TEST_CHECK( !hintsValue );
END_TEST;
}
{
ToolkitTestApplication application;
- ShaderEffect effect = Toolkit::CreateImageRegionEffect();
- DALI_TEST_CHECK( effect );
+ Property::Map effect = Toolkit::CreateImageRegionEffect();
+ DALI_TEST_CHECK( !effect.Empty() );
+
+ Property::Value* customShaderValue = effect.Find( "shader" );
+ DALI_TEST_CHECK( customShaderValue );
+
+ Property::Map customShader;
+ DALI_TEST_CHECK( customShaderValue->Get( customShader ) );
+
+ Property::Value* vertexShaderValue = customShader.Find( "vertexShader" );
+ DALI_TEST_CHECK( vertexShaderValue );
+
+ std::string vertexShader;
+ DALI_TEST_CHECK( vertexShaderValue->Get( vertexShader ) );
+ DALI_TEST_CHECK( !vertexShader.empty() );
+
+ Property::Value* fragmentShaderValue = customShader.Find( "fragmentShader" );
+ DALI_TEST_CHECK( !fragmentShaderValue );
+
+ Property::Value* gridXValue = customShader.Find( "subdivideGridX" );
+ DALI_TEST_CHECK( !gridXValue );
+
+ Property::Value* gridYValue = customShader.Find( "subdivideGridY" );
+ DALI_TEST_CHECK( !gridYValue );
+
+ Property::Value* hintsValue = customShader.Find( "hints" );
+ DALI_TEST_CHECK( !hintsValue );
END_TEST;
}
// EXTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/adaptor-framework/environment-variable.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
-
namespace Dali
{
namespace Toolkit
{
+namespace
+{
+ const char * const DALI_DEBUG_RENDERING("DALI_DEBUG_RENDERING");
+}
+
RendererFactory RendererFactory::Get()
{
RendererFactory factory;
factory = RendererFactory( dynamic_cast<Internal::RendererFactory*>(handle.GetObjectPtr()) );
}
- if( !factory )
+ if( !factory )// If not, create the RendererFactory and register it as a singleton
{
- // If not, create the RendererFactory and register it as a singleton
- factory = RendererFactory( new Internal::RendererFactory() );
+ // Check whether debug rendering is required
+ if( EnvironmentVariable::GetEnvironmentVariable( DALI_DEBUG_RENDERING ) )
+ {
+ factory = RendererFactory( new Internal::RendererFactory(true) );
+ }
+ else
+ {
+ factory = RendererFactory( new Internal::RendererFactory(false) );
+ }
singletonService.Register( typeid(RendererFactory), factory );
}
/**
* @brief RendererFactory is a singleton object that provides and shares renderers for controls
*
+ * By setting environment variable 'DALI_DEBUG_RENDERING', all concrete renderer is replaced with the debug renderer which renders a quad wireframe.
+ *
* The renderer type is required in the property map for requesting a control renderer.
*
* | %Property Name | Type |
$(devel_api_src_dir)/shader-effects/mirror-effect.h \
$(devel_api_src_dir)/shader-effects/motion-blur-effect.h \
$(devel_api_src_dir)/shader-effects/motion-stretch-effect.h \
- $(devel_api_src_dir)/shader-effects/nine-patch-mask-effect.h \
$(devel_api_src_dir)/shader-effects/overlay-effect.h \
$(devel_api_src_dir)/shader-effects/quadratic-bezier.h \
$(devel_api_src_dir)/shader-effects/ripple-effect.h \
*
* Usage example:
*
- * ImageActor actor = ImageActor::New( Image( EXAMPLE_IMAGE_PATH ) );
- * ShaderEffect alphaDiscardEffect = CreateAlphaDiscardEffect();
- * actor.SetShaderEffect( alphaDiscardEffect );
+ * ImageView actor = ImageView::New( EXAMPLE_IMAGE_PATH );
+ * Property::Map alphaDiscardEffect = CreateAlphaDiscardEffect();
+ * actor.SetProperty( ImageView::Property::IMAGE, alphaDiscardEffect );
*
* @return A handle to a newly allocated ShaderEffect.
*/
-inline ShaderEffect CreateAlphaDiscardEffect()
+inline Property::Map CreateAlphaDiscardEffect()
{
const char* ALPHA_DISCARD_FRAGMENT_SHADER_SOURCE =
+ "varying mediump vec2 vTexCoord; \n"
+ " \n"
+ "uniform sampler2D sTexture; \n"
+ "uniform lowp vec4 uColor; \n"
"void main() \n"
"{ \n"
" mediump vec4 color = texture2D( sTexture, vTexCoord ); \n"
" gl_FragColor = color * uColor; \n"
"} \n";
- return ShaderEffect::New( "", // Use default
- ALPHA_DISCARD_FRAGMENT_SHADER_SOURCE );
-}
+ Property::Map map;
+
+ Property::Map customShader;
+ customShader[ "fragmentShader" ] = ALPHA_DISCARD_FRAGMENT_SHADER_SOURCE;
+
+ map[ "shader" ] = customShader;
+ return map;}
} // namespace Toolkit
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/shader-effects/shader-effect.h>
+#include <dali/public-api/object/property-map.h>
namespace Dali
{
*
* @return A handle to a newly allocated ShaderEffect
*/
-inline ShaderEffect CreateImageRegionEffect()
+inline Property::Map CreateImageRegionEffect()
{
std::string vertexShader(
+ "attribute mediump vec2 aPosition;\n"
+ "\n"
+ "uniform mediump mat4 uMvpMatrix;\n"
+ "uniform vec3 uSize;\n"
+ "uniform vec4 uTextureRect;"
+ "\n"
+ "varying vec2 vTexCoord;\n"
+
"uniform mediump vec2 uTopLeft;\n"
"uniform mediump vec2 uBottomRight;\n"
"void main()\n"
"{\n"
- " mediump vec4 position = vec4(aPosition,1.0);\n"
+ " mediump vec4 position = vec4(aPosition, 0.0, 1.0);\n"
+ " position.xyz *= uSize;\n"
" gl_Position = uMvpMatrix * position;\n"
// The line below is doing the same as the following commented lines:
//" vec2 imageSize = sTextureRect.zw - sTextureRect.xy;\n"
//" vec2 bottomRight = sTextureRect.xy + uBottomRight * imageSize;\n"
//" vec2 texCoord = (aTexCoord - sTextureRect.xy) / imageSize;\n"
//" vTexCoord = topLeft + texCoord * ( bottomRight - topLeft );\n"
- " vTexCoord = sTextureRect.xy + uTopLeft * ( sTextureRect.zw - sTextureRect.xy ) + ( aTexCoord - sTextureRect.xy ) * ( uBottomRight - uTopLeft );\n"
+
+ " vec2 texCoord = aPosition + vec2(0.5);\n"
+ " vTexCoord = uTextureRect.xy + uTopLeft * ( uTextureRect.zw - uTextureRect.xy ) + ( texCoord - uTextureRect.xy ) * ( uBottomRight - uTopLeft );\n"
"}\n"
);
- Dali::ShaderEffect shaderEffect = Dali::ShaderEffect::New( vertexShader, "" );
- shaderEffect.SetUniform( "uTopLeft", Vector2( 0.f, 0.f ) );
- shaderEffect.SetUniform( "uBottomRight", Vector2( 1.f, 1.f ) );
+ Property::Map map;
+
+ Property::Map customShader;
+ customShader[ "vertexShader" ] = vertexShader;
- return shaderEffect;
+ map[ "shader" ] = customShader;
+ return map;
}
} // namespace Toolkit
+++ /dev/null
-#ifndef __DALI_TOOLKIT_NINE_PATCH_MASK_EFFECT_H__
-#define __DALI_TOOLKIT_NINE_PATCH_MASK_EFFECT_H__
-
-/*
- * Copyright (c) 2015 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.
- *
- */
-
-// EXTERNAL INCLUDES
-#include <dali/public-api/actors/image-actor.h>
-
-namespace Dali
-{
-
-namespace Toolkit
-{
-
-/**
- * @brief NinePatchMaskEffect is used to control which parts of an image are visible, using the alpha channel of a separate mask image.
- *
- * The mask image is expected to be smaller than the main image being viewed.
- * Conceptually the mask image is divided into a 3x3 grid (9 patches). The middle patch is stretched whilst the outer border is not.
- *
- * Usage example:
- *
- * @code
- * ImageActor actor = ImageActor::New( Image( EXAMPLE_IMAGE_PATH ) );
- * NinePatchMaskEffect::Apply( actor, MASK_IMAGE_PATH );
- * @endcode
- *
- * NinePatchMaskEffect is mutually exclusive with ImageActor::STYLE_NINE_PATCH i.e. the actor's main image should not be a nine-patch.
- */
-namespace NinePatchMaskEffect
-{
-
-static void NinePatchMaskEffectSizeConstraint( Vector2& current, const PropertyInputContainer& inputs )
-{
- const Vector3& actorSize = inputs[0]->GetVector3();
- current.x = actorSize.x;
- current.y = actorSize.y;
-}
-
-inline void DoApply( ImageActor actor, const std::string& maskImage, const Vector2& maskSize, Vector4 maskBorder )
-{
- const char* ALPHA_MASK_VERTEX_SHADER_SOURCE =
- "precision mediump float;\n"
- "uniform vec2 uImageSize; \n"
- "uniform vec2 uMaskSize; \n"
- "varying vec2 vMaskTexCoord; \n"
- " \n"
- "void main() \n"
- "{ \n"
- " gl_Position = uMvpMatrix * vec4(aPosition, 1.0); \n"
- " \n"
- " // Ignore mask UVs for image \n"
- " \n"
- " highp vec2 halfImageSize = uImageSize * 0.5; \n"
- " vTexCoord = (aPosition.xy + halfImageSize) / uImageSize; \n"
- " \n"
- " // UVs were calculated for image size, so convert for mask size \n"
- " \n"
- " highp vec2 halfMaskSize = uMaskSize * 0.5; \n"
- " highp vec2 halfSizeDelta = halfImageSize - halfMaskSize; \n"
- " \n"
- " highp vec2 maskPosition = aPosition.xy; \n"
- " maskPosition.x -= halfSizeDelta.x * sign(aPosition.x); \n"
- " maskPosition.y -= halfSizeDelta.y * sign(aPosition.y); \n"
- " \n"
- " vMaskTexCoord = (maskPosition + halfMaskSize) / uMaskSize; \n"
- "} \n";
-
- const char* ALPHA_MASK_FRAGMENT_SHADER_SOURCE =
- "varying mediump vec2 vMaskTexCoord; \n"
- " \n"
- "void main() \n"
- "{ \n"
- " highp vec4 mask = texture2D(sEffect, vMaskTexCoord); \n"
- " gl_FragColor = texture2D(sTexture, vTexCoord) * uColor * vec4(1,1,1,mask.a); \n"
- "} \n";
-
- ShaderEffect maskEffect = ShaderEffect::New(
- ALPHA_MASK_VERTEX_SHADER_SOURCE,
- ALPHA_MASK_FRAGMENT_SHADER_SOURCE,
- ShaderEffect::GeometryHints( ShaderEffect::HINT_BLENDING ) );
-
- maskEffect.SetEffectImage( ResourceImage::New( maskImage ) );
-
- maskEffect.SetUniform( "uImageSize", Vector2(0,0) /*Constrained to actor size*/ );
-
- Constraint constraint = Constraint::New<Vector2>( maskEffect, maskEffect.GetPropertyIndex("uImageSize"), NinePatchMaskEffectSizeConstraint );
- constraint.AddSource( Source(actor, Actor::Property::SIZE) );
- constraint.Apply();
-
- maskEffect.SetUniform( "uMaskSize", maskSize );
-
- // Actor must provide nine-patch style geometry for this effect to work
- actor.SetStyle( ImageActor::STYLE_NINE_PATCH );
- actor.SetNinePatchBorder( maskBorder );
-
- actor.SetShaderEffect( maskEffect );
-}
-
-/**
- * @brief Apply the mask effect to an ImageActor.
- *
- * NinePatchMaskEffect is mutually exclusive with ImageActor::STYLE_NINE_PATCH i.e. the actor's main image should not be a nine-patch.
- * @param [in] actor The actor which needs the effect. To remove the effect call actor.RemoveShaderEffect().
- * @param [in] maskImage The path to a file containing the mask. The center pixels of the mask will be stretched.
- */
-inline void Apply( ImageActor actor, const std::string& maskImage )
-{
- const Uint16Pair maskSize = ResourceImage::GetImageSize( maskImage );
-
- const float leftRight = (maskSize.GetWidth() - 1.0f) * 0.5f;
- const float topBottom = (maskSize.GetHeight() - 1.0f) * 0.5f;
-
- DoApply( actor, maskImage, Vector2( maskSize.GetWidth(), maskSize.GetHeight() ), Vector4( leftRight, topBottom, leftRight, topBottom ) );
-}
-
-/**
- * @brief Apply the mask effect to an ImageActor.
- *
- * NinePatchMaskEffect is mutually exclusive with ImageActor::STYLE_NINE_PATCH i.e. the actor's main image should not be a nine-patch.
- * @param [in] actor The actor which needs the effect. To remove the effect call actor.RemoveShaderEffect().
- * @param [in] maskImage The path to a file containing the mask.
- * @param [in] maskBorder Specifies the part of the mask image that will be stretched (left, top, right, bottom).
- */
-inline void Apply( ImageActor actor, const std::string& maskImage, const Vector4& maskBorder )
-{
- const Uint16Pair maskSize = ResourceImage::GetImageSize( maskImage );
-
- DoApply( actor, maskImage, Vector2( maskSize.GetWidth(), maskSize.GetHeight() ), maskBorder );
-}
-
-} // namespace NinePatchMaskEffect
-
-} // namespace Toolkit
-
-} // namespace Dali
-
-#endif // __DALI_TOOLKIT_NINE_PATCH_MASK_EFFECT_H__
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/default-controls/solid-color-actor.h>
#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
/**
* Button states and contents
void Button::SetUnselectedImage( const std::string& filename )
{
- ImageActor newContent;
+ Toolkit::ImageView newContent;
if( !filename.empty() )
{
- Image resourceimage = Dali::ResourceImage::New( filename );
- if( resourceimage )
- {
- newContent = ImageActor::New( resourceimage );
- }
+ newContent = Toolkit::ImageView::New( filename );
}
else
{
- newContent = ImageActor::New();
+ newContent = Toolkit::ImageView::New();
}
if( newContent )
void Button::SetSelectedImage( const std::string& filename )
{
- ImageActor newContent;
+ Toolkit::ImageView newContent;
if( !filename.empty() )
{
- Image resourceimage = Dali::ResourceImage::New( filename );
- if( resourceimage )
- {
- newContent = ImageActor::New( resourceimage );
- }
+ newContent = Toolkit::ImageView::New( filename );
}
else
{
- newContent = ImageActor::New();
+ newContent = Toolkit::ImageView::New();
}
if( newContent )
void Button::SetBackgroundImage( const std::string& filename )
{
- Image resourceimage = Dali::ResourceImage::New( filename );
- if( resourceimage )
- {
- SetupContent( mBackgroundContent, ImageActor::New( resourceimage ) );
+ SetupContent( mBackgroundContent, Toolkit::ImageView::New( filename ) );
- OnBackgroundImageSet();
- RelayoutRequest();
- }
+ OnBackgroundImageSet();
+ RelayoutRequest();
}
Actor& Button::GetBackgroundImage()
void Button::SetSelectedBackgroundImage( const std::string& filename )
{
- Image resourceimage = Dali::ResourceImage::New( filename );
- if( resourceimage )
- {
- SetupContent( mSelectedBackgroundContent, ImageActor::New( resourceimage ) );
+ SetupContent( mSelectedBackgroundContent, Toolkit::ImageView::New( filename ) );
- OnSelectedBackgroundImageSet();
- RelayoutRequest();
- }
+ OnSelectedBackgroundImageSet();
+ RelayoutRequest();
}
Actor& Button::GetSelectedBackgroundImage()
void Button::SetDisabledImage( const std::string& filename )
{
- Image resourceimage = Dali::ResourceImage::New( filename );
- if( resourceimage )
- {
- SetupContent( mDisabledContent, ImageActor::New( resourceimage ) );
+ SetupContent( mDisabledContent, Toolkit::ImageView::New( filename ) );
- OnDisabledImageSet();
- RelayoutRequest();
- }
+ OnDisabledImageSet();
+ RelayoutRequest();
}
Actor& Button::GetDisabledImage()
void Button::SetDisabledSelectedImage( const std::string& filename )
{
- Image resourceimage = Dali::ResourceImage::New( filename );
- if( resourceimage )
- {
- SetupContent( mDisabledSelectedContent, ImageActor::New( resourceimage ) );
+ SetupContent( mDisabledSelectedContent, Toolkit::ImageView::New( filename ) );
- OnDisabledSelectedImageSet();
- RelayoutRequest();
- }
+ OnDisabledSelectedImageSet();
+ RelayoutRequest();
}
Actor& Button::GetDisabledSelectedImage()
void Button::SetDisabledBackgroundImage( const std::string& filename )
{
- Image resourceimage = Dali::ResourceImage::New( filename );
- if( resourceimage )
- {
- SetupContent( mDisabledBackgroundContent, ImageActor::New( resourceimage ) );
+ SetupContent( mDisabledBackgroundContent, Toolkit::ImageView::New( filename ) );
- OnDisabledBackgroundImageSet();
- RelayoutRequest();
- }
+ OnDisabledBackgroundImageSet();
+ RelayoutRequest();
}
Actor& Button::GetDisabledBackgroundImage()
{
if( actor )
{
- actor.Unparent();
Self().Add( actor );
PrepareForTranstionOut( actor );
}
{
if( actor )
{
- actor.Unparent();
Self().Add( actor );
}
}
#include "check-box-button-impl.h"
// EXTERNAL INCLUDES
-#include <dali/public-api/actors/image-actor.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/images/resource-image.h>
//INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-depth-index-ranges.h>
+#include <dali-toolkit/internal/controls/image-view/image-view-impl.h>
#include <dali-toolkit/devel-api/shader-effects/image-region-effect.h>
namespace Dali
const float DISTANCE_BETWEEN_IMAGE_AND_LABEL( 5.0f );
const float ANIMATION_TIME( 0.26f ); // EFL checkbox tick time
-// Required for the UV reveal shader to render the tick on top of the rest of the checkbox.
-const float SHADER_DEPTH_OFFSET = 1.0f;
BaseHandle Create()
{
{
}
+void CheckBoxButton::SetTickUVEffect()
+{
+ Toolkit::ImageView imageView = Toolkit::ImageView::DownCast( mSelectedImage );
+ if( imageView )
+ {
+ imageView.RegisterProperty( "uTextureRect", Vector4(0.f, 0.f, 1.f, 1.f ) );
+ imageView.RegisterProperty( "uTopLeft", Vector2::ZERO );
+
+ Property::Map shaderMap = CreateImageRegionEffect();
+ imageView.SetProperty( Toolkit::ImageView::Property::IMAGE, shaderMap );
+
+ GetImpl( imageView ).SetDepthIndex( DECORATION_DEPTH_INDEX );
+ }
+}
+
void CheckBoxButton::OnButtonInitialize()
{
// Wrap around all children
SetSelectedImage( SELECTED_BUTTON_IMAGE_DIR );
SetDisabledImage( DISABLED_UNSELECTED_BUTTON_IMAGE_DIR );
SetDisabledSelectedImage( DISABLED_SELECTED_BUTTON_IMAGE_DIR );
+
+ mSelectedImage = GetSelectedImage();
+ SetTickUVEffect();
}
void CheckBoxButton::OnLabelSet( bool noPadding )
if( actor == selectedImage )
{
actor.SetScale( Vector3( 0.0f, 1.0f, 1.0f ) );
+ actor.RegisterProperty( "uBottomRight", Vector2( 0.0f, 1.0f ) );
- if( !mTickUVEffect )
+ if( mSelectedImage != selectedImage )
{
- mTickUVEffect = CreateImageRegionEffect();
- }
- mTickUVEffect.SetUniform( "uBottomRight", Vector2( 0.0f, 1.0f ) );
-
- ImageActor imageActor = ImageActor::DownCast( actor );
- if( imageActor )
- {
- // Ensure the tick effect is rendered above the reset of the checkbox.
- imageActor.SetSortModifier( SHADER_DEPTH_OFFSET );
- imageActor.SetShaderEffect( mTickUVEffect );
+ mSelectedImage = selectedImage;
+ SetTickUVEffect();
}
}
}
if( actor == selectedImage )
{
actor.SetScale( Vector3::ONE );
+ actor.RegisterProperty( "uBottomRight", Vector2::ONE );
- if( !mTickUVEffect )
+ if( mSelectedImage != selectedImage )
{
- mTickUVEffect = CreateImageRegionEffect();
- }
- mTickUVEffect.SetUniform( "uBottomRight", Vector2::ONE );
-
- ImageActor imageActor = ImageActor::DownCast( actor );
- if( imageActor )
- {
- imageActor.SetShaderEffect( mTickUVEffect );
+ mSelectedImage = selectedImage;
+ SetTickUVEffect();
}
}
}
Dali::Animation transitionAnimation = GetTransitionAnimation();
if( transitionAnimation )
{
- DALI_ASSERT_DEBUG( mTickUVEffect );
- if( mTickUVEffect )
- {
- // UV anim
- transitionAnimation.AnimateTo( Property( mTickUVEffect, "uBottomRight" ), Vector2::ONE );
- }
+ // UV anim
+ transitionAnimation.AnimateTo( Property( actor, "uBottomRight" ), Vector2::ONE );
+
// Actor size anim
transitionAnimation.AnimateTo( Property( actor, Actor::Property::SCALE_X ), 1.0f );
}
{
//explicitly end the swipe animation
actor.SetScale( Vector3::ONE );
- if( mTickUVEffect )
+ if( mSelectedImage == selectedImage )
{
- mTickUVEffect.SetUniform( "uBottomRight", Vector2::ONE );
+ actor.RegisterProperty( "uBottomRight", Vector2::ONE );
}
}
}
*/
virtual ~CheckBoxButton();
+ /**
+ * Setup the ticking effect to the selected image.
+ */
+ void SetTickUVEffect();
+
private: // From Button
CheckBoxButton& operator=( const CheckBoxButton& );
private:
- ShaderEffect mTickUVEffect; ///< ImageRegionEffect to expand the tick across
+ Actor mSelectedImage;
};
} // namespace Internal
#include <dali/devel-api/scripting/scripting.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
namespace Dali
void PushButton::SetIcon( DecorationState state, const std::string iconFilename )
{
mIconName[ state ] = iconFilename;
- SetDecoration( state, ImageActor::New( Dali::ResourceImage::New( iconFilename ) ) );
+ SetDecoration( state, Toolkit::ImageView::New( iconFilename ) );
ConfigureSizeNegotiation();
}
void ImageView::SetImage( Image image )
{
- if( mImage != image )
+ if( ( mImage != image ) ||
+ ! mUrl.empty() || // If we're changing from a URL type to an Image type
+ ! mPropertyMap.Empty() ) // If we're changing from a property map type to an Image type
{
mUrl.clear();
mPropertyMap.Clear();
Actor self = Self();
Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, image );
mImageSize = image ? ImageDimensions( image.GetWidth(), image.GetHeight() ) : ImageDimensions( 0, 0 );
+
+ RelayoutRequest();
}
}
void ImageView::SetImage( Property::Map map )
{
+ mUrl.clear();
+ mImage.Reset();
mPropertyMap = map;
Actor self = Self();
Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mPropertyMap );
- int width = 0;
Property::Value* widthValue = mPropertyMap.Find( "width" );
if( widthValue )
{
- widthValue->Get( width );
+ int width;
+ if( widthValue->Get( width ) )
+ {
+ mImageSize = ImageDimensions( width, mImageSize.GetHeight() );
+ }
}
- int height = 0;
Property::Value* heightValue = mPropertyMap.Find( "height" );
if( heightValue )
{
- heightValue->Get( height );
+ int height;
+ if( heightValue->Get( height ) )
+ {
+ mImageSize = ImageDimensions( mImageSize.GetWidth(), height );
+ }
}
- mImageSize = ImageDimensions( width, height );
+ RelayoutRequest();
}
void ImageView::SetImage( const std::string& url, ImageDimensions size )
{
- if( mUrl != url )
+ if( ( mUrl != url ) ||
+ mImage || // If we're changing from an Image type to a URL type
+ ! mPropertyMap.Empty() ) // If we're changing from a property map type to a URL type
{
mImage.Reset();
mPropertyMap.Clear();
Actor self = Self();
Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mUrl, mImageSize );
+
+ RelayoutRequest();
}
}
+void ImageView::SetDepthIndex( int depthIndex )
+{
+ mRenderer.SetDepthIndex( depthIndex );
+}
+
Vector3 ImageView::GetNaturalSize()
{
Vector3 size;
*/
static Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex );
+ /**
+ * @brief Set the depth index of this image renderer
+ *
+ * Renderer with higher depth indices are rendered in front of other renderers with smaller values
+ *
+ * @param[in] depthIndex The depth index of this renderer
+ */
+ void SetDepthIndex( int depthIndex );
+
private: // From Control
/**
#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/object/type-registry-helper.h>
#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/devel-api/rendering/cull-face.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/page-turn-view/page-turn-effect.h>
#include <dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/default-controls/solid-color-actor.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/accessibility-manager/accessibility-manager.h>
#include <dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h>
mPopupLayout = Toolkit::TableView::New( 3, 1 );
// Adds the default background image.
- SetPopupBackgroundImage( ImageActor::New( ResourceImage::New( DEFAULT_BACKGROUND_IMAGE_PATH ) ) );
+ SetPopupBackgroundImage( Toolkit::ImageView::New( ResourceImage::New( DEFAULT_BACKGROUND_IMAGE_PATH ) ) );
mPopupLayout.SetName( "popupLayoutTable" );
mPopupLayout.SetParentOrigin( ParentOrigin::CENTER );
{
// Adds the tail actor.
Image tail = ResourceImage::New( image );
- mTailImage = ImageActor::New( tail );
+ mTailImage = Toolkit::ImageView::New( tail );
mTailImage.SetName( "tailImage" );
const Vector3 anchorPoint = AnchorPoint::BOTTOM_RIGHT - position;
mTailImage.SetParentOrigin( position );
Image image = ResourceImage::New( valueString );
if( image )
{
- ImageActor actor = ImageActor::New( image );
+ Toolkit::ImageView actor = Toolkit::ImageView::New( image );
popupImpl.SetPopupBackgroundImage( actor );
}
}
void ControlRenderer::CreatePropertyMap( Property::Map& map ) const
{
+ DoCreatePropertyMap( map );
+
if( mImpl->mCustomShader )
{
mImpl->mCustomShader->CreatePropertyMap( map );
}
- DoCreatePropertyMap( map );
}
bool ControlRenderer::GetIsOnStage() const
* @param[in] actor The Actor the renderer is applied to if, empty if the renderer has not been applied to any Actor
* @param[in] propertyMap The properties for the requested ControlRenderer object.
*/
- virtual void DoInitialize( Actor& actor, const Property::Map& propertyMap ) = 0;
+ virtual void DoInitialize( Actor& actor, const Property::Map& propertyMap ) {};
protected:
--- /dev/null
+/*
+ * Copyright (c) 2015 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 "debug-renderer.h"
+
+//INTERNAL INCLUDES
+#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-data-impl.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+namespace
+{
+const char * const RENDERER_TYPE("rendererType");
+const char * const RENDERER_TYPE_VALUE("debugRenderer");
+
+const char * const POSITION_ATTRIBUTE_NAME("aPosition");
+const char * const INDEX_NAME("indices");
+
+const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
+attribute mediump vec2 aPosition;\n
+uniform mediump mat4 uMvpMatrix;\n
+uniform mediump vec3 uSize;\n
+\n
+void main()\n
+{\n
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
+ vertexPosition.xyz *= uSize;\n
+ gl_Position = uMvpMatrix * vertexPosition;\n
+}\n
+);
+
+const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(\n
+uniform lowp vec4 uColor;\n
+\n
+void main()\n
+{\n
+ gl_FragColor = uColor;\n
+}\n
+);
+
+}
+
+
+DebugRenderer::DebugRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache )
+{
+}
+
+DebugRenderer::~DebugRenderer()
+{}
+
+void DebugRenderer::DoSetOnStage( Actor& actor )
+{
+ InitializeRenderer();
+}
+
+void DebugRenderer::DoCreatePropertyMap( Property::Map& map ) const
+{
+ map.Clear();
+ map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
+}
+
+void DebugRenderer::InitializeRenderer()
+{
+ mImpl->mRenderer = mFactoryCache.GetDebugRenderer();
+ if( !mImpl->mRenderer )
+ {
+ Geometry geometry = CreateQuadWireframeGeometry();
+ Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+ Material material = Material::New( shader );
+ mImpl->mRenderer = Renderer::New( geometry,
+ material );
+ mFactoryCache.CacheDebugRenderer( mImpl->mRenderer );
+ }
+}
+
+Geometry DebugRenderer::CreateQuadWireframeGeometry()
+{
+ const float halfWidth = 0.5f;
+ const float halfHeight = 0.5f;
+ struct QuadVertex { Vector2 position;};
+ QuadVertex quadVertexData[4] =
+ {
+ { Vector2(-halfWidth, -halfHeight) },
+ { Vector2( halfWidth, -halfHeight) },
+ { Vector2( halfWidth, halfHeight) },
+ { Vector2(-halfWidth, halfHeight) }
+ };
+
+ Property::Map quadVertexFormat;
+ quadVertexFormat[POSITION_ATTRIBUTE_NAME] = Property::VECTOR2;
+ PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat, 4 );
+ quadVertices.SetData(quadVertexData);
+
+ // Create indices
+ unsigned int indexData[10] = { 0, 1, 1, 2, 2, 3, 3, 0 };
+ Property::Map indexFormat;
+ indexFormat[INDEX_NAME] = Property::INTEGER;
+ PropertyBuffer indices = PropertyBuffer::New( indexFormat, sizeof(indexData)/sizeof(indexData[0]) );
+ indices.SetData(indexData);
+
+ // Create the geometry object
+ Geometry geometry = Geometry::New();
+ geometry.AddVertexBuffer( quadVertices );
+ geometry.SetIndexBuffer( indices );
+ geometry.SetGeometryType( Geometry::LINES );
+
+ return geometry;
+}
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
--- /dev/null
+#ifndef __DALI_TOOLKIT_INTERNAL_DEBUG_RENDERER_H__
+#define __DALI_TOOLKIT_INTERNAL_DEBUG_RENDERER_H__
+
+/*
+ * Copyright (c) 2015 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.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+/**
+ * The renderer which renders a wireframe outline to the control's quad for debugging
+ *
+ */
+class DebugRenderer: public ControlRenderer
+{
+public:
+
+ /**
+ * @brief Constructor.
+ *
+ * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object
+ */
+ DebugRenderer( RendererFactoryCache& factoryCache );
+
+ /**
+ * @brief A reference counted object may only be deleted by calling Unreference().
+ */
+ virtual ~DebugRenderer();
+
+protected:
+
+ /**
+ * @copydoc ControlRenderer::DoSetOnStage
+ */
+ virtual void DoSetOnStage( Actor& actor );
+
+ /**
+ * @copydoc ControlRenderer::CreatePropertyMap
+ */
+ virtual void DoCreatePropertyMap( Property::Map& map ) const;
+
+
+private:
+ /**
+ * Create the geometry which presents the quad wireframe.
+ * @return The border geometry
+ */
+ Geometry CreateQuadWireframeGeometry();
+
+ /**
+ * @brief Initialise the renderer from the cache, if not available, create and save to the cache for sharing.
+ */
+ void InitializeRenderer();
+
+private:
+
+ // Undefined
+ DebugRenderer( const DebugRenderer& debugRenderer );
+
+ // Undefined
+ DebugRenderer& operator=( const DebugRenderer& debugRenderer );
+
+};
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif /* __DALI_TOOLKIT_INTERNAL_DEBUG_RENDERER_H__ */
#include "image-renderer.h"
// EXTERNAL HEADER
+#include <cstring> // for strncasecmp
#include <dali/public-api/images/resource-image.h>
#include <dali/integration-api/debug.h>
namespace
{
+const char HTTP_URL[] = "http://";
+const char HTTPS_URL[] = "https://";
+
const char * const RENDERER_TYPE("rendererType");
const char * const RENDERER_TYPE_VALUE("imageRenderer");
mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
}
+ // remove old renderer if exit
if( mImpl->mRenderer )
{
- //remove old renderer
- if( actor )
+ if( actor ) //remove old renderer from actor
{
actor.RemoveRenderer( mImpl->mRenderer );
}
-
- //clean the cache
- if( !oldImageUrl.empty() )
+ if( !oldImageUrl.empty() ) //clean old renderer from cache
{
CleanCache( oldImageUrl );
}
+ }
- //Initialize the renderer
- if( !mImageUrl.empty() )
- {
- InitializeRenderer( mImageUrl );
- }
- else if( mImage )
- {
- InitializeRenderer( mImage );
- }
-
- //add the new renderer to the actor
- if( actor && mImpl->mRenderer )
- {
- actor.AddRenderer( mImpl->mRenderer );
- }
+ // if actor is on stage, create new renderer and apply to actor
+ if( actor && actor.OnStage() )
+ {
+ SetOnStage( actor );
}
}
void ImageRenderer::InitializeRenderer( const std::string& imageUrl )
{
- if( mImageUrl.empty() )
+ if( imageUrl.empty() )
{
- mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
return;
}
+ mImageUrl = imageUrl;
mImpl->mRenderer.Reset();
- if( !mImpl->mCustomShader )
+
+ if( !mImpl->mCustomShader &&
+ ( strncasecmp( imageUrl.c_str(), HTTP_URL, sizeof(HTTP_URL) -1 ) != 0 ) && // ignore remote images
+ ( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof(HTTPS_URL) -1 ) != 0 ) )
{
mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
if( !mImpl->mRenderer )
{
- Material material = mAtlasManager.Add(mTextureRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- if( material )
- {
- Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
- mImpl->mRenderer = Renderer::New( geometry, material );
- SetTextureRectUniform(mTextureRect);
- }
- else // big image, atlasing is not applied
- {
- mImpl->mRenderer = CreateRenderer();
- SetTextureRectUniform(FULL_TEXTURE_RECT);
+ Material material = mAtlasManager.Add(mTextureRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+ if( material )
+ {
+ Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+ mImpl->mRenderer = Renderer::New( geometry, material );
+ SetTextureRectUniform(mTextureRect);
+ }
+ else // big image, atlasing is not applied
+ {
+ mImpl->mRenderer = CreateRenderer();
+ mTextureRect = FULL_TEXTURE_RECT;
+ SetTextureRectUniform(mTextureRect);
- ResourceImage image = Dali::ResourceImage::New( imageUrl );
- image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- Material material = mImpl->mRenderer.GetMaterial();
- material.AddTexture( image, TEXTURE_UNIFORM_NAME );
- }
+ ResourceImage image = Dali::ResourceImage::New( imageUrl );
+ image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+ Material material = mImpl->mRenderer.GetMaterial();
+ material.AddTexture( image, TEXTURE_UNIFORM_NAME );
+ }
- mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
+ mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
}
else
{
}
else
{
+ // for custom shader or remote image, renderer is not cached and atlas is not applied
+
mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
mImpl->mRenderer = CreateRenderer();
- ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- ApplyImageToSampler( image );
+ ResourceImage resourceImage = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+ resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+ ApplyImageToSampler( resourceImage );
+
+ // custom vertex shader does not need texture rect uniform
+ if( mImpl->mCustomShader && !mImpl->mCustomShader->mVertexShader.empty() )
+ {
+ return;
+ }
+
+ mTextureRect = FULL_TEXTURE_RECT;
+ SetTextureRectUniform( mTextureRect );
}
}
mImpl->mRenderer = CreateRenderer();
ApplyImageToSampler( image );
- SetTextureRectUniform( FULL_TEXTURE_RECT );
+
+ // default shader or custom shader with the default image vertex shader
+ if( !mImpl->mCustomShader || mImpl->mCustomShader->mVertexShader.empty() )
+ {
+ mTextureRect = FULL_TEXTURE_RECT;
+ SetTextureRectUniform( mTextureRect );
+ }
}
{
InitializeRenderer( mImage );
}
-
- if( !GetIsFromCache() )
- {
- Image image = mImage;
- if( !mImageUrl.empty() )
- {
- ResourceImage resourceImage = Dali::ResourceImage::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- image = resourceImage;
-
- // Set value to the uTextureRect uniform
- SetTextureRectUniform( FULL_TEXTURE_RECT );
- }
-
- ApplyImageToSampler( image );
- }
}
void ImageRenderer::DoSetOffStage( Actor& actor )
void ImageRenderer::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
{
- mDesiredSize = size;
- mFittingMode = fittingMode;
- mSamplingMode = samplingMode;
-
if( mImageUrl != imageUrl )
{
+ std::string oldImageUrl = mImageUrl;
+ mImageUrl = imageUrl;
+ mDesiredSize = size;
+ mFittingMode = fittingMode;
+ mSamplingMode = samplingMode;
+ mImage.Reset();
+
if( mImpl->mRenderer )
{
- if( GetIsFromCache() )
+ if( GetIsFromCache() ) // if renderer is from cache, remove the old one
{
//remove old renderer
if( actor )
}
//clean the cache
- if( !mImageUrl.empty() )
+ if( !oldImageUrl.empty() )
{
- CleanCache(mImageUrl);
+ CleanCache(oldImageUrl);
}
- //Initialize the renderer
- InitializeRenderer( imageUrl );
-
- //add the new renderer to the actor
- if( actor && mImpl->mRenderer )
+ if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
{
- actor.AddRenderer( mImpl->mRenderer );
+ SetOnStage(actor);
}
}
- else
+ else // if renderer is not from cache, reuse the same renderer and only change the texture
{
ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
ApplyImageToSampler( image );
}
}
-
- mImageUrl = imageUrl;
-
- mImage.Reset();
}
}
{
if( mImage != image )
{
+ mImage = image;
+
if( mImpl->mRenderer )
{
- if( GetIsFromCache() )
+ if( GetIsFromCache() ) // if renderer is from cache, remove the old one
{
//remove old renderer
if( actor )
{
CleanCache(mImageUrl);
}
+ mImageUrl.clear();
- //Initialize the renderer
- InitializeRenderer( image );
-
- //add the new renderer to the actor
- if( actor && mImpl->mRenderer )
+ if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
{
- actor.AddRenderer( mImpl->mRenderer );
+ SetOnStage(actor);
}
}
- else
+ else // if renderer is not from cache, reuse the same renderer and only change the texture
{
ApplyImageToSampler( image );
}
}
- SetTextureRectUniform( FULL_TEXTURE_RECT );
- mImage = image;
mImageUrl.clear();
mDesiredSize = ImageDimensions();
mFittingMode = FittingMode::DEFAULT;
Shader NPatchRenderer::CreateShader()
{
Shader shader;
- if( mStretchPixelsX.Size() == 1 && mStretchPixelsY.Size() == 1 )
+ if( !mImpl->mCustomShader )
{
- shader = mFactoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
- if( !shader )
+ if( mStretchPixelsX.Size() == 1 && mStretchPixelsY.Size() == 1 )
+ {
+ shader = mFactoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
+ if( !shader )
+ {
+ shader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
+ mFactoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, shader );
+ }
+ }
+ else if( mStretchPixelsX.Size() > 0 || mStretchPixelsY.Size() > 0)
{
- shader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
- mFactoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, shader );
+ std::stringstream vertexShader;
+ vertexShader << "#define FACTOR_SIZE_X " << mStretchPixelsX.Size() + 2 << "\n"
+ << "#define FACTOR_SIZE_Y " << mStretchPixelsY.Size() + 2 << "\n"
+ << VERTEX_SHADER;
+
+ shader = Shader::New( vertexShader.str(), FRAGMENT_SHADER );
}
}
- else if( mStretchPixelsX.Size() > 0 || mStretchPixelsY.Size() > 0)
+ else
{
- std::stringstream vertexShader;
- vertexShader << "#define FACTOR_SIZE_X " << mStretchPixelsX.Size() + 2 << "\n"
- << "#define FACTOR_SIZE_Y " << mStretchPixelsY.Size() + 2 << "\n"
- << VERTEX_SHADER;
+ const char* fragmentShader = FRAGMENT_SHADER;
+ Dali::Shader::ShaderHints hints = Dali::Shader::HINT_NONE;
- shader = Shader::New( vertexShader.str(), FRAGMENT_SHADER );
+ if( !mImpl->mCustomShader->mFragmentShader.empty() )
+ {
+ fragmentShader = mImpl->mCustomShader->mFragmentShader.c_str();
+ }
+ hints = mImpl->mCustomShader->mHints;
+
+ if( mStretchPixelsX.Size() == 1 && mStretchPixelsY.Size() == 1 )
+ {
+ shader = Shader::New( VERTEX_SHADER_3X3, fragmentShader, hints );
+ }
+ else if( mStretchPixelsX.Size() > 0 || mStretchPixelsY.Size() > 0)
+ {
+ std::stringstream vertexShader;
+ vertexShader << "#define FACTOR_SIZE_X " << mStretchPixelsX.Size() + 2 << "\n"
+ << "#define FACTOR_SIZE_Y " << mStretchPixelsY.Size() + 2 << "\n"
+ << VERTEX_SHADER;
+
+ shader = Shader::New( vertexShader.str(), fragmentShader, hints );
+ }
}
+
return shader;
}
return false;
}
+void RendererFactoryCache::CacheDebugRenderer( Renderer& renderer )
+{
+ mDebugRenderer = renderer;
+}
+
+Renderer RendererFactoryCache::GetDebugRenderer()
+{
+ return mDebugRenderer;
+}
+
Geometry RendererFactoryCache::CreateQuadGeometry()
{
const float halfWidth = 0.5f;
*/
bool CleanRendererCache( const std::string& key );
+ /**
+ * @brief Cache the debug renderer
+ */
+ void CacheDebugRenderer( Renderer& renderer );
+
+ /**
+ * @brief Request the debug renderer;
+ */
+ Renderer GetDebugRenderer();
+
protected:
/**
HashVector mRendererHashes;
CachedRenderers mRenderers;
+
+ Renderer mDebugRenderer;
};
} // namespace Internal
// Internal HEADER
#include <dali-toolkit/internal/controls/renderers/border/border-renderer.h>
#include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
+#include <dali-toolkit/internal/controls/renderers/debug/debug-renderer.h>
#include <dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h>
#include <dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h>
#include <dali-toolkit/internal/controls/renderers/image/image-renderer.h>
} // namespace
-RendererFactory::RendererFactory()
+RendererFactory::RendererFactory( bool debugEnabled )
+:mDebugEnabled( debugEnabled )
{
}
mFactoryCache = new RendererFactoryCache();
}
+ if( mDebugEnabled )
+ {
+ return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
+ }
+
if( typeValue == COLOR_RENDERER )
{
rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
mFactoryCache = new RendererFactoryCache();
}
+ if( mDebugEnabled )
+ {
+ return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
+ }
+
ColorRenderer* rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
rendererPtr->SetColor( color );
void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Vector4& color )
{
+ if( mDebugEnabled && renderer )
+ {
+ return;
+ }
+
if( renderer )
{
ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
{
mFactoryCache = new RendererFactoryCache();
}
- BorderRenderer* rendererPtr = new BorderRenderer( *mFactoryCache.Get() );
- if( !mFactoryCache )
+ if( mDebugEnabled )
{
- mFactoryCache = new RendererFactoryCache();
+ return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
}
+ BorderRenderer* rendererPtr = new BorderRenderer( *mFactoryCache.Get() );
+
rendererPtr->SetBorderSize( borderSize );
rendererPtr->SetBorderColor( borderColor );
mFactoryCache = new RendererFactoryCache();
}
+ if( mDebugEnabled )
+ {
+ return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
+ }
+
NinePatchImage npatchImage = NinePatchImage::DownCast( image );
if( npatchImage )
{
void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Image& image )
{
+ if( mDebugEnabled && renderer )
+ {
+ return;
+ }
+
if( renderer )
{
+ if( ! image )
+ {
+ // If the image is empty, then reset the renderer and return
+ renderer.RemoveAndReset( actor );
+ return;
+ }
+
NinePatchImage npatchImage = NinePatchImage::DownCast( image );
if( npatchImage )
{
mFactoryCache = new RendererFactoryCache();
}
+ if( mDebugEnabled )
+ {
+ return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
+ }
+
if( NinePatchImage::IsNinePatchUrl( url ) )
{
NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const std::string& url, ImageDimensions size )
{
+ if( mDebugEnabled && renderer )
+ {
+ return;
+ }
+
if( renderer )
{
- if( NinePatchImage::IsNinePatchUrl( url ) )
+ if( url.empty() )
+ {
+ // If the URL is empty, then reset the renderer and return
+ renderer.RemoveAndReset( actor );
+ return;
+ }
+ else if( NinePatchImage::IsNinePatchUrl( url ) )
{
NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
if( rendererPtr )
void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
{
+ if( mDebugEnabled && renderer )
+ {
+ return;
+ }
+
if( renderer )
{
ControlRenderer& controlRenderer = GetImplementation( renderer );
/**
* @brief Constructor
+ *
+ * @param[in] debugEnabled If true, use debug renderer to replace all the concrete renderer.
*/
- RendererFactory();
+ RendererFactory( bool debugEnabled );
/**
* @copydoc Toolkit::RenderFactory::GetControlRenderer( const Property::Map& )
private:
RendererFactoryCachePtr mFactoryCache;
- ImageAtlasManagerPtr mAtlasManager;
+ ImageAtlasManagerPtr mAtlasManager;
+ bool mDebugEnabled;
};
} // namespace Internal
// INTERNAL INCLUDES
#include <dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
using namespace Dali;
namespace
{
-const char* DEFAULT_INDICATOR_IMAGE_PATH = DALI_IMAGE_DIR "popup_scroll.png";
-const Vector4 DEFAULT_INDICATOR_NINE_PATCH_BORDER(4.0f, 9.0f, 7.0f, 11.0f);
+const char* DEFAULT_INDICATOR_IMAGE_PATH = DALI_IMAGE_DIR "popup_scroll.9.png";
const float MINIMUM_INDICATOR_HEIGHT(20.0f); // The minimum indicator height for the nine patch border
const float DEFAULT_SLIDER_DEPTH(1.0f);
const float DEFAULT_INDICATOR_SHOW_DURATION(0.5f);
void ScrollBar::CreateDefaultIndicatorActor()
{
- Image indicatorImage = ResourceImage::New( DEFAULT_INDICATOR_IMAGE_PATH );
- ImageActor indicator = ImageActor::New( indicatorImage );
- indicator.SetNinePatchBorder( DEFAULT_INDICATOR_NINE_PATCH_BORDER );
- indicator.SetStyle( ImageActor::STYLE_NINE_PATCH );
+ Toolkit::ImageView indicator = Toolkit::ImageView::New( DEFAULT_INDICATOR_IMAGE_PATH );
indicator.SetParentOrigin( ParentOrigin::TOP_LEFT );
indicator.SetAnchorPoint( AnchorPoint::TOP_LEFT );
// EXTERNAL INCLUDES
#include <dali/public-api/adaptor-framework/timer.h>
-#include <dali/public-api/actors/image-actor.h>
#include <dali/public-api/animation/constraint.h>
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/common/dali-vector.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
using namespace Dali;
DALI_TYPE_REGISTRATION_END()
-const float BACKING_Z = -0.1f;
-const float PROGRESS_Z = 0.1f;
-const float HANDLE_Z = 1.0f;
-const float VALUE_TEXT_INCREMENT = 0.01f;
-const float HANDLE_VALUE_DISPLAY_TEXT_Z = HANDLE_Z + VALUE_TEXT_INCREMENT;
-const float VALUE_DISPLAY_TEXT_Z = VALUE_TEXT_INCREMENT + VALUE_TEXT_INCREMENT; // Put above HANDLE_VALUE_DISPLAY_TEXT_Z (parented to handle)
-
const float MARK_SNAP_TOLERANCE = 0.05f; // 5% of slider width
const int VALUE_VIEW_SHOW_DURATION = 1000; // millisec
Slider::Slider()
: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ),
mState( NORMAL ),
+ mPopupImageName(""),
+ mPopupArrowImageName(""),
+ mBackingImageName(""),
+ mHandleImageName(""),
+ mProgressImageName(""),
mDisableColor( 0.0f, 0.0f, 0.0f, 0.0f ),
mPopupTextColor( 0.0f, 0.0f, 0.0f, 0.0f ),
mHitRegion( 0.0f, 0.0f ),
float x = mDomain.from.x + percent * ( mDomain.to.x - mDomain.from.x );
- mHandle.SetPosition( x, 0.0f, HANDLE_Z );
+ mHandle.SetX( x );
// Progress bar
if( mProgress )
return hitRegion;
}
-ImageActor Slider::CreateBacking()
+Toolkit::ImageView Slider::CreateBacking()
{
- ImageActor backing = ImageActor::New();
+ Toolkit::ImageView backing = Toolkit::ImageView::New();
backing.SetParentOrigin( ParentOrigin::CENTER );
backing.SetAnchorPoint( AnchorPoint::CENTER );
- backing.SetZ( BACKING_Z );
return backing;
}
{
if( mBacking && ( imageName.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mBacking.SetImage( image );
+ mBacking.SetImage( imageName );
+ mBackingImageName = imageName;
}
}
std::string Slider::GetBackingImageName()
{
- if( mBacking )
- {
- return ResourceImage::DownCast( mBacking.GetImage() ).GetUrl();
- }
-
- return std::string( "" );
+ return mBackingImageName;
}
-ImageActor Slider::CreateProgress()
+Toolkit::ImageView Slider::CreateProgress()
{
- ImageActor progress = ImageActor::New();
+ Toolkit::ImageView progress = Toolkit::ImageView::New();
progress.SetParentOrigin( ParentOrigin::CENTER_LEFT );
progress.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
- progress.SetZ( PROGRESS_Z );
return progress;
}
{
if( mProgress && ( imageName.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mProgress.SetImage( image );
+ mProgress.SetImage( imageName );
+ mProgressImageName = imageName;
}
}
std::string Slider::GetProgressImageName()
{
- if( mProgress )
- {
- return ResourceImage::DownCast( mProgress.GetImage()).GetUrl();
- }
-
- return std::string( "" );
+ return mProgressImageName;
}
void Slider::SetPopupImageName( const std::string& imageName )
}
}
-ImageActor Slider::CreateHandle()
+Toolkit::ImageView Slider::CreateHandle()
{
- ImageActor handle = ImageActor::New();
+ Toolkit::ImageView handle = Toolkit::ImageView::New();
handle.SetParentOrigin( ParentOrigin::CENTER_LEFT );
handle.SetAnchorPoint( AnchorPoint::CENTER );
- handle.SetZ( HANDLE_Z );
return handle;
}
-ImageActor Slider::CreatePopupArrow()
+Toolkit::ImageView Slider::CreatePopupArrow()
{
- ImageActor arrow = ImageActor::New();
+ Toolkit::ImageView arrow = Toolkit::ImageView::New();
arrow.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
arrow.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
- arrow.SetZ( HANDLE_Z );
return arrow;
}
textLabel.SetProperty( Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
textLabel.SetProperty( Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT, "CENTER" );
textLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, DEFAULT_POPUP_TEXT_COLOR );
- textLabel.SetZ( VALUE_DISPLAY_TEXT_Z );
textLabel.SetPadding( Padding( POPUP_TEXT_PADDING, POPUP_TEXT_PADDING, 0.0f, 0.0f ) );
return textLabel;
}
-ImageActor Slider::CreatePopup()
+Toolkit::ImageView Slider::CreatePopup()
{
- ImageActor popup = ImageActor::New();
+ Toolkit::ImageView popup = Toolkit::ImageView::New();
popup.SetParentOrigin( ParentOrigin::TOP_CENTER );
popup.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
popup.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::WIDTH );
{
if( mHandle && ( imageName.size() > 0 ) )
{
- Image image = ResourceImage::New( imageName );
- mHandle.SetImage( image );
+ mHandle.SetImage( imageName );
+ mHandleImageName = imageName;
}
}
std::string Slider::GetHandleImageName()
{
- if( mHandle )
- {
- return ResourceImage::DownCast( mHandle.GetImage() ).GetUrl();
- }
-
- return std::string( "" );
+ return mHandleImageName;
}
void Slider::ResizeHandleRegion( const Vector2& region )
// Handle
mHandle = CreateHandle();
- mBacking.Add( mHandle );
+ mProgress.Add( mHandle );
}
void Slider::SetHitRegion( const Vector2& size )
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/devel-api/controls/slider/slider.h>
#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
namespace Dali
{
*
* @return The backing actor
*/
- ImageActor CreateBacking();
+ Toolkit::ImageView CreateBacking();
/**
* Create the progress backing for the slider
*
* @return The backing actor
*/
- ImageActor CreateProgress();
+ Toolkit::ImageView CreateProgress();
/**
* Create the handle for the slider
*
* @return The created image handle
*/
- ImageActor CreateHandle();
+ Toolkit::ImageView CreateHandle();
/**
* Create the popup arrow
*
* @return The created image handle
*/
- ImageActor CreatePopupArrow();
+ Toolkit::ImageView CreatePopupArrow();
/**
* Create the popup
*
* @return The created image handle
*/
- ImageActor CreatePopup();
+ Toolkit::ImageView CreatePopup();
/**
* Create the textview for the popup
Domain mDomain; ///< Current domain of the handle
Actor mHitArea; ///< The input handler
- ImageActor mBacking; ///< Backing image
- ImageActor mHandle; ///< Slider handle
- ImageActor mProgress; ///< Progress backing
Actor mValueDisplay; ///< Display of the value
- ImageActor mPopup; ///< Popup backing
- ImageActor mPopupArrow; ///< Popup arrow backing
-
- Toolkit::TextLabel mValueTextLabel; //< The text value in popup
- Toolkit::TextLabel mHandleValueTextLabel; ///< The text value on handle
+ Toolkit::ImageView mBacking; ///< Backing image
+ Toolkit::ImageView mHandle; ///< Slider handle
+ Toolkit::ImageView mProgress; ///< Progress backing
+ Toolkit::ImageView mPopup; ///< Popup backing
+ Toolkit::ImageView mPopupArrow; ///< Popup arrow backing
+
+ Toolkit::TextLabel mValueTextLabel; //< The text value in popup
+ Toolkit::TextLabel mHandleValueTextLabel; ///< The text value on handle
Vector2 mHandleLastTouchPoint; ///< The last touch point for the handle
Timer mValueTimer; ///< Timer used to hide value view
std::string mPopupImageName; ///< Image name for popup image
std::string mPopupArrowImageName; ///< Image name for popup arrow
+ std::string mBackingImageName; ///< Image name for backing image
+ std::string mHandleImageName; ///< Image name for handle image
+ std::string mProgressImageName; ///< Image name for progress image
Vector4 mDisableColor; ///< The color to tint the slider when disabled
Vector4 mPopupTextColor; ///< The color of the popup text
$(toolkit_src_dir)/controls/renderers/renderer-factory-impl.cpp \
$(toolkit_src_dir)/controls/renderers/border/border-renderer.cpp \
$(toolkit_src_dir)/controls/renderers/color/color-renderer.cpp \
+ $(toolkit_src_dir)/controls/renderers/debug/debug-renderer.cpp \
$(toolkit_src_dir)/controls/renderers/image/image-renderer.cpp \
$(toolkit_src_dir)/controls/renderers/npatch/npatch-renderer.cpp \
$(toolkit_src_dir)/controls/renderers/gradient/gradient.cpp \
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/accessibility-manager/accessibility-manager.h>
#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
const char* const IS_FOCUS_GROUP_PROPERTY_NAME = "isKeyboardFocusGroup"; // This property will be replaced by a flag in Control.
-const char* const FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "keyboard_focus.png";
-const Vector4 FOCUS_BORDER_IMAGE_BORDER = Vector4(7.0f, 7.0f, 7.0f, 7.0f);
+const char* const FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "keyboard_focus.9.png";
BaseHandle Create()
{
void KeyboardFocusManager::CreateDefaultFocusIndicatorActor()
{
// Create a focus indicator actor shared by all the keyboard focusable actors
- Image borderImage = ResourceImage::New(FOCUS_BORDER_IMAGE_PATH);
-
- ImageActor focusIndicator = ImageActor::New(borderImage);
+ Toolkit::ImageView focusIndicator = Toolkit::ImageView::New(FOCUS_BORDER_IMAGE_PATH);
focusIndicator.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
- focusIndicator.SetStyle( ImageActor::STYLE_NINE_PATCH );
- focusIndicator.SetNinePatchBorder(FOCUS_BORDER_IMAGE_BORDER);
focusIndicator.SetPosition(Vector3(0.0f, 0.0f, 1.0f));
// Apply size constraint to the focus indicator
if( mActiveCopyPastePopup )
{
ShowPopup();
+ mPopupSetNewPosition = true;
}
else
{
void Decorator::SetPosition( HandleType handleType, float x, float y, float height )
{
- // Adjust grab handle displacement
+ // Adjust handle's displacement
Impl::HandleImpl& handle = mImpl->mHandle[handleType];
handle.grabDisplacementX -= x - handle.position.x;
positions,
glyphs,
depth );
+
+ /* In the case where AddGlyphs does not create a renderable Actor for example when glyphs are all whitespace create a new Actor. */
+ /* This renderable actor is used to position the text, other "decorations" can rely on there always being an Actor regardless of it is whitespace or regular text*/
+ if ( !mImpl->mActor )
+ {
+ mImpl->mActor = Actor::New();
+ }
}
return mImpl->mActor;
{
if( mFontDefaults )
{
- DALI_LOG_INFO( gLogFilter, Debug::Concise, "Controller::GetDefaultFonts font family(%s)\n", mFontDefaults->mFontDescription.family.c_str() );
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::GetDefaultFonts font family(%s)\n", mFontDefaults->mFontDescription.family.c_str() );
FontRun fontRun;
fontRun.characterRun.characterIndex = 0;
fontRun.characterRun.numberOfCharacters = numberOfCharacters;
void Controller::Impl::OnLongPressEvent( const Event& event )
{
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::OnLongPressEvent\n" );
+
if ( EventData::EDITING == mEventData->mState )
{
ChangeState ( EventData::EDITING_WITH_POPUP );
{
mEventData->mUpdateCursorPosition = true;
- ChangeState( EventData::EDITING_WITH_POPUP );
+ if ( !IsClipboardEmpty() )
+ {
+ ChangeState( EventData::EDITING_WITH_PASTE_POPUP ); // Moving grabhandle will show Paste Popup
+ }
if( handleStopScrolling )
{
void Controller::Impl::OnSelectAllEvent()
{
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "OnSelectAllEvent mEventData->mSelectionEnabled%s \n", mEventData->mSelectionEnabled?"true":"false");
+
if( NULL == mEventData )
{
// Nothing to do if there is no text.
buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::SELECT_ALL ) );
}
}
- else if ( EventData::EDITING_WITH_POPUP == mEventData->mState )
+ else if ( EventData::EDITING_WITH_POPUP == mEventData->mState )
{
if ( mLogicalModel->mText.Count() && !IsShowingPlaceholderText())
{
buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
}
}
+ else if ( EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState )
+ {
+ if ( !IsClipboardEmpty() )
+ {
+ buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::PASTE ) );
+ buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
+ }
+ }
mEventData->mDecorator->SetEnabledPopupButtons( buttonsToShow );
}
return;
}
+ DALI_LOG_INFO( gLogFilter, Debug::General, "ChangeState state:%d newstate:%d\n", mEventData->mState, newState );
+
if( mEventData->mState != newState )
{
mEventData->mState = newState;
}
else if( EventData::EDITING_WITH_POPUP == mEventData->mState )
{
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_POPUP \n", newState );
+
mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
if( mEventData->mCursorBlinkEnabled )
{
}
else if( EventData::EDITING_WITH_GRAB_HANDLE == mEventData->mState )
{
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_GRAB_HANDLE \n", newState );
+
mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
if( mEventData->mCursorBlinkEnabled )
{
}
else if ( EventData::GRAB_HANDLE_PANNING == mEventData->mState )
{
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GRAB_HANDLE_PANNING \n", newState );
+
mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
if( mEventData->mCursorBlinkEnabled )
{
}
mEventData->mDecoratorUpdated = true;
}
+ else if ( EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState )
+ {
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_PASTE_POPUP \n", newState );
+
+ mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
+ if( mEventData->mCursorBlinkEnabled )
+ {
+ mEventData->mDecorator->StartCursorBlink();
+ }
+
+ mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
+ mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
+ mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+
+ if( mEventData->mGrabHandlePopupEnabled )
+ {
+ SetPopupButtons();
+ mEventData->mDecorator->SetPopupActive( true );
+ }
+ HideClipboard();
+ mEventData->mDecoratorUpdated = true;
+ }
}
}
startIndex = hitCharacter;
endIndex = hitCharacter;
+ bool isHitCharacterWhitespace = TextAbstraction::IsWhiteSpace( mLogicalModel->mText[hitCharacter] );
- if( !TextAbstraction::IsWhiteSpace( mLogicalModel->mText[hitCharacter] ) )
+ // Find the start and end of the text
+ for( startIndex = hitCharacter; startIndex > 0; --startIndex )
{
- // Find the start and end of the text
- for( startIndex = hitCharacter; startIndex > 0; --startIndex )
+ if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( mLogicalModel->mText[ startIndex-1 ] ) )
{
- Character charCode = mLogicalModel->mText[ startIndex-1 ];
- if( TextAbstraction::IsWhiteSpace( charCode ) )
- {
- break;
- }
+ break;
}
- const CharacterIndex pastTheEnd = mLogicalModel->mText.Count();
- for( endIndex = hitCharacter + 1u; endIndex < pastTheEnd; ++endIndex )
+ }
+ const CharacterIndex pastTheEnd = mLogicalModel->mText.Count();
+ for( endIndex = hitCharacter + 1u; endIndex < pastTheEnd; ++endIndex )
+ {
+ if( isHitCharacterWhitespace != TextAbstraction::IsWhiteSpace( mLogicalModel->mText[ endIndex ] ) )
{
- Character charCode = mLogicalModel->mText[ endIndex ];
- if( TextAbstraction::IsWhiteSpace( charCode ) )
- {
- break;
- }
+ break;
}
}
}
}
// Set which cursors are active according the state.
- if( ( EventData::EDITING == mEventData->mState ) ||
- ( EventData::EDITING_WITH_POPUP == mEventData->mState ) ||
- ( EventData::EDITING_WITH_GRAB_HANDLE == mEventData->mState ) ||
- ( EventData::GRAB_HANDLE_PANNING == mEventData->mState ) )
+ if( EventData::IsEditingState( mEventData->mState ) || ( EventData::GRAB_HANDLE_PANNING == mEventData->mState ) )
{
if( cursorInfo.isSecondaryCursor )
{
const Vector2 cursorPosition = cursorInfo.primaryPosition + mEventData->mScrollPosition + mAlignmentOffset;
- // Sets the grab handle position.
+ // Sets the handle's position.
mEventData->mDecorator->SetPosition( handleType,
cursorPosition.x,
cursorPosition.y,
EDITING,
EDITING_WITH_POPUP,
EDITING_WITH_GRAB_HANDLE,
+ EDITING_WITH_PASTE_POPUP,
GRAB_HANDLE_PANNING,
SELECTION_HANDLE_PANNING
};
~EventData();
+ static bool IsEditingState( State stateToCheck )
+ {
+ return ( stateToCheck == EDITING || stateToCheck == EDITING_WITH_POPUP || stateToCheck == EDITING_WITH_GRAB_HANDLE || stateToCheck == EDITING_WITH_PASTE_POPUP );
+ }
+
DecoratorPtr mDecorator; ///< Pointer to the decorator.
ImfManager mImfManager; ///< The Input Method Framework Manager.
std::string mPlaceholderTextActive; ///< The text to display when the TextField is empty with key-input focus.
bool mRecalculateNaturalSize:1; ///< Whether the natural size needs to be recalculated.
bool mUserDefinedFontFamily:1; ///< Whether the Font family was set by the user instead of being left as sytem default.
+
};
} // namespace Text
// If popup shown then hide it by switching to Editing state
if( ( EventData::SELECTING == mImpl->mEventData->mState ) ||
( EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState ) ||
- ( EventData::EDITING_WITH_GRAB_HANDLE == mImpl->mEventData->mState ) )
+ ( EventData::EDITING_WITH_GRAB_HANDLE == mImpl->mEventData->mState ) ||
+ ( EventData::EDITING_WITH_PASTE_POPUP == mImpl->mEventData->mState ) )
{
mImpl->ChangeState( EventData::EDITING );
}
mImpl->mEventData->mPrimaryCursorPosition = cursorIndex;
// Update the cursor if it's in editing mode.
- if( ( EventData::EDITING == mImpl->mEventData->mState ) ||
- ( EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState ) ||
- ( EventData::EDITING_WITH_GRAB_HANDLE == mImpl->mEventData->mState ) )
+ if ( EventData::IsEditingState( mImpl->mEventData->mState ) )
{
mImpl->mEventData->mUpdateCursorPosition = true;
}
REORDER );
// Queue a cursor reposition event; this must wait until after DoRelayout()
- if( ( EventData::EDITING == mImpl->mEventData->mState ) ||
- ( EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState ) ||
- ( EventData::EDITING_WITH_GRAB_HANDLE == mImpl->mEventData->mState ) )
+ if ( EventData::IsEditingState( mImpl->mEventData->mState ) )
{
mImpl->mEventData->mUpdateCursorPosition = true;
mImpl->mEventData->mScrollAfterUpdatePosition = true;
if( NULL != mImpl->mEventData )
{
+ DALI_LOG_INFO( gLogFilter, Debug::Concise, "TapEvent state:%d \n", mImpl->mEventData->mState );
+
if( 1u == tapCount )
{
// This is to avoid unnecessary relayouts when tapping an empty text-field
bool relayoutNeeded( false );
- if( mImpl->IsShowingRealText() &&
- EventData::EDITING == mImpl->mEventData->mState )
+ if ( EventData::EDITING_WITH_PASTE_POPUP == mImpl->mEventData->mState || EventData::EDITING_WITH_PASTE_POPUP == mImpl->mEventData->mState )
+ {
+ mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE); // If Popup shown hide it here so can be shown again if required.
+ }
+
+ if( mImpl->IsShowingRealText() && ( EventData::INACTIVE != mImpl->mEventData->mState ) )
{
- // Show grab handle on second tap
- mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
+ // Already in an active state so show a popup
+ if ( !mImpl->IsClipboardEmpty() )
+ {
+ // Shows Paste popup but could show full popup with Selection options. ( EDITING_WITH_POPUP )
+ mImpl->ChangeState( EventData::EDITING_WITH_PASTE_POPUP );
+ }
+ else
+ {
+ mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
+ }
relayoutNeeded = true;
}
- else if( EventData::EDITING != mImpl->mEventData->mState &&
- EventData::EDITING_WITH_GRAB_HANDLE != mImpl->mEventData->mState )
+ else
{
if( mImpl->IsShowingPlaceholderText() && !mImpl->IsFocusedPlaceholderAvailable() )
{
// Hide placeholder text
ResetText();
}
- // Show cursor on first tap
- mImpl->ChangeState( EventData::EDITING );
- relayoutNeeded = true;
- }
- else if( mImpl->IsShowingRealText() )
- {
- // Move the cursor
+
+ if ( EventData::INACTIVE == mImpl->mEventData->mState )
+ {
+ mImpl->ChangeState( EventData::EDITING );
+ }
+ else if ( !mImpl->IsClipboardEmpty() )
+ {
+ mImpl->ChangeState( EventData::EDITING_WITH_POPUP );
+ }
relayoutNeeded = true;
}
}
void Controller::PanEvent( Gesture::State state, const Vector2& displacement )
+ // Show cursor and grabhandle on first tap, this matches the behaviour of tapping when already editing
{
DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected PanEvent" );
void Controller::SelectEvent( float x, float y, bool selectAll )
{
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SelectEvent\n" );
+
if( mImpl->mEventData )
{
mImpl->ChangeState( EventData::SELECTING );
return mImpl->mStyleName;
}
+void Control::UpdateBackgroundState()
+{
+ // Set the depth of the background renderer after creating/modifying it.
+ // We do this regardless of whether or not it is on stage as the index
+ // is relative and still valid if this control is re-parented.
+ if( mImpl->mBackgroundRenderer )
+ {
+ mImpl->mBackgroundRenderer.SetDepthIndex( BACKGROUND_DEPTH_INDEX );
+
+ Actor self( Self() );
+ if( self.OnStage() )
+ {
+ mImpl->mBackgroundRenderer.SetOnStage( self );
+ }
+ }
+}
+
void Control::SetBackgroundColor( const Vector4& color )
{
Actor self( Self() );
else
{
mImpl->mBackgroundRenderer = factory.GetControlRenderer( color );
-
- if( self.OnStage() )
- {
- mImpl->mBackgroundRenderer.SetDepthIndex( BACKGROUND_DEPTH_INDEX );
- mImpl->mBackgroundRenderer.SetOnStage( self );
- }
}
+
+ UpdateBackgroundState();
}
Vector4 Control::GetBackgroundColor() const
Toolkit::RendererFactory factory = Toolkit::RendererFactory::Get();
mImpl->mBackgroundRenderer = factory.GetControlRenderer( map );
- // mBackgroundRenderer might be empty, if an invalid map is provided, no background.
- if( self.OnStage() && mImpl->mBackgroundRenderer)
- {
- mImpl->mBackgroundRenderer.SetDepthIndex( BACKGROUND_DEPTH_INDEX );
- mImpl->mBackgroundRenderer.SetOnStage( self );
- }
+ UpdateBackgroundState();
}
void Control::SetBackgroundImage( Image image )
else
{
mImpl->mBackgroundRenderer = factory.GetControlRenderer( image );
-
- if( self.OnStage() )
- {
- mImpl->mBackgroundRenderer.SetDepthIndex( BACKGROUND_DEPTH_INDEX );
- mImpl->mBackgroundRenderer.SetOnStage( self );
- }
}
+
+ UpdateBackgroundState();
}
void Control::ClearBackground()
{
if( mImpl->mBackgroundRenderer)
{
- mImpl->mBackgroundRenderer.SetDepthIndex( BACKGROUND_DEPTH_INDEX );
- Actor self(Self());
+ Actor self( Self() );
mImpl->mBackgroundRenderer.SetOnStage( self );
}
}
void Control::OnStageDisconnection()
{
- if( mImpl->mBackgroundRenderer)
+ if( mImpl->mBackgroundRenderer )
{
- Actor self(Self());
+ Actor self( Self() );
mImpl->mBackgroundRenderer.SetOffStage( self );
}
}
*/
DALI_INTERNAL bool EmitKeyEventSignal( const KeyEvent& event );
+private:
+
+ /**
+ * Sets up the background image/color based on the current state.
+ * This will set the depth index (always), and add to stage if the control is on stage.
+ *
+ */
+ void UpdateBackgroundState();
+
protected: // For derived classes to call
/**
return ImageView( imageView );
}
-ImageView ImageView::New( const std::string& url,
- ImageDimensions size)
+ImageView ImageView::New( const std::string& url )
+{
+ ImageView imageView = Internal::ImageView::New();
+ imageView.SetImage( url, ImageDimensions() );
+ return imageView;
+}
+
+ImageView ImageView::New( const std::string& url, ImageDimensions size )
{
ImageView imageView = Internal::ImageView::New();
imageView.SetImage( url, size );
Dali::Toolkit::GetImpl( *this ).SetImage( image );
}
-void ImageView::SetImage( const std::string& url,
- ImageDimensions size )
+void ImageView::SetImage( const std::string& url )
+{
+ Dali::Toolkit::GetImpl( *this ).SetImage( url, ImageDimensions() );
+}
+
+void ImageView::SetImage( const std::string& url, ImageDimensions size )
{
Dali::Toolkit::GetImpl( *this ).SetImage( url, size );
}
* @brief Create an initialized ImageView.
*
* @return A handle to a newly allocated Dali ImageView.
+ *
+ * @note ImageView will not display anything.
*/
static ImageView New();
/**
* @brief Create an initialized ImageView from an Image.
*
- * If the handle is empty, ImageView will display nothing
+ * If the handle is empty, ImageView will not display anything.
+ *
* @param[in] image The Image to display.
* @return A handle to a newly allocated ImageView.
*/
static ImageView New( Image image );
/**
- * @brief Create an initialized ImageView from an Image resource url
+ * @brief Create an initialized ImageView from an Image resource URL
*
- * @note A valid size is preferable for efficiency.
- * However, do not set size that is bigger than the actual image size, as the up-scaling is not available,
- * the content of the area not covered by actual image is undefined, it will not be cleared.
+ * If the string is empty, ImageView will not display anything.
+ *
+ * @param[in] url The url of the image resource to display.
+ * @return A handle to a newly allocated ImageView.
+ */
+ static ImageView New( const std::string& url );
+
+ /**
+ * @brief Create an initialized ImageView from an Image resource URL
+ *
+ * If the string is empty, ImageView will not display anything.
+ *
+ * @since DALi 1.1.10
*
- * If the string is empty, ImageView will display nothing
* @param[in] url The url of the image resource to display.
* @param [in] size The width and height to fit the loaded image to.
* @return A handle to a newly allocated ImageView.
+ *
+ * @note A valid size is preferable for efficiency.
+ * However, do not set a size that is bigger than the actual image size, as up-scaling is not available.
+ * The content of the area not covered by the actual image is undefined and will not be cleared.
*/
- static ImageView New( const std::string& url,
- ImageDimensions size = ImageDimensions() );
+ static ImageView New( const std::string& url, ImageDimensions size );
/**
* @brief Destructor
void SetImage( Image image );
/**
- * @brief Sets this ImageView from an Image url
+ * @brief Sets this ImageView from an Image URL
*
- * If the handle is empty, ImageView will display nothing
+ * If the URL is empty, ImageView will not display anything.
*
* @since DALi 1.1.4
*
* @param[in] url The Image resource to display.
+ */
+ void SetImage( const std::string& url );
+
+ /**
+ * @brief Sets this ImageView from an Image URL
+ *
+ * If the URL is empty, ImageView will not display anything.
+ *
+ * @since DALi 1.1.10
+ *
+ * @param[in] url A URL to the image resource to display.
* @param [in] size The width and height to fit the loaded image to.
*/
- void SetImage( const std::string& url,
- ImageDimensions size = ImageDimensions() );
+ void SetImage( const std::string& url, ImageDimensions size );
/**
* @deprecated Gets the Image
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 1;
-const unsigned int TOOLKIT_MICRO_VERSION = 10;
+const unsigned int TOOLKIT_MICRO_VERSION = 11;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
+ [Event Handling](@ref event-system)
+ [Layouting](@ref size-negotiation)
+ [Image Actor](@ref image-actor)
+ + [Image View](@ref image-view)
+ [Animation](@ref animation)
+ [Basic Framework](@ref animation-basics)
+ [Key Frame Animations](@ref animation-key-frame)
+ Environment Variables
+ [Resource Tracking](@ref resourcetracking)
+ Logging
+ + [Debug Renderer](@ref debugrenderer)
+ [Stagehand - DALi Visual Debugger](@ref stagehand)
### Viewing Modes
</td>
</table>
+@section background-renderer Background Renderer
+
+The background can be set to use a specified renderer, e.g the border renderer
+@code
+Property::Map renderer;
+renderer.Insert("rendererType","borderRenderer");
+renderer.Insert("borderColor",COLOR::RED);
+renderer.Insert("borderSize",20.f);
+
+control.SetProperty( Control::Property::BACKGROUND, renderer);
+@endcode
+
+then the above image will look like:
+<table border=0 cellpadding=10><tr>
+<td>
+\image html BackgroundBorder.png
+</td>
+</table>
+
*
*/
* section.
*
* <h2 class="pg">Style</h2>
- * The Actor can render an image in two different ways.<br>
+ * The Actor can render an image in only as a quad. Use ImageView for nine-patch/n-patch image rendering.<br>
* -# STYLE_QUAD: A simple flat quad style for rendering images.<br>
- * -# STYLE_NINE_PATCH: This style gives the flexibility to stretch images by dividing it into 9 sections.
- * The four corners are not scaled; the four edges are scaled in one axis, and the middle is scaled in both axes.<br>
- *
- * @code
- * // default : ImageActor::STYLE_QUAD
- * myImageActor.SetStyle (Dali::ImageActor::STYLE_NINE_PATCH);
- * @endcode
- *
- *
- * <h2 class="pg">Border</h2>
- * The border is used in the ImageActor::STYLE_NINE_PATCH. It defines the border values of the image for stretching.<br>
- *
- * @code
- * Dali::ImageActor::Border border(0.45,0.15,0.45,0.15);
- * myImageActor.SetBorder(border);
- * @endcode
- *
+ * -# STYLE_NINE_PATCH: This is deprecated as of Dali 1.1.11.
*
* <h2 class="pg">Pixel area</h2>
* The area of the image to be displayed by the Image Actor can be set by setting the Pixel area. Pixel area is relative to the top-left (0,0) of the image.
--- /dev/null
+/*! \page image-view Image Views
+ *
+ *
+ * <h1 class="pg">Overview</h1>
+ * The Dali::Toolkit::ImageView inherits from Dali::Toolkit::Control and provide means to display resources like Images on the stage.<br>
+ *
+ * - <b>ImageView:</b> An actor for displaying Images. It allows the developer to display a Dali::Image object or an image from a url path on the stage.<br>
+ *
+ * <h1 class="pg">Image View</h1>
+ *
+ * <h2 class="pg">Construction</h2>
+ * The Image View is constructed by passing a Dali::Image object or by a url path.<br>
+ *
+ * <h3 class="pg">Loading from a url path</h3>
+ * Image View will load a file from a given url path. Using a url path is the prefered way of displaying an image as the Dali engine can do optimsations to
+ * reuse shaders and perform automatic image atlassing.<br>
+ * This can be a path to a image file:
+ * @code
+ * Dali::Toolkit::ImageView myImageView = ImageView::New( "source-image-url.png" );
+ * @endcode
+ *
+ * A path to a nine-patch/n-patch image file:
+ * @code
+ * Dali::Toolkit::ImageView myImageView = ImageView::New( "source-image-url.9.png" );
+ * @endcode
+ *
+ * <h3 class="pg">Loading from a Image handle</h3>
+ * Dali::Image is an abstract base class with multiple derived classes.
+ *
+ * @code
+ * Dali::Image image = BufferImage::New( 100, 100 );
+ * Dali::Toolkit::ImageView myImageView = Toolkit::ImageView::New( image );
+ * @endcode
+ *
+ * <h3 class="pg">The IMAGE property</h3>
+ * the IMAGE property allows you to change many aspects of the image that is renderered.
+ * This property can either be a string for a image url path or a Property::Map that specifies
+ * the image in more detail.
+ *
+ * <h3 class="pg">Renderers</h3>
+ * You can specify a specific renderer instead of using the default Image Renderer, e.g to use the Border Renderer.
+ *
+ * @code
+ * Property::Map renderer;
+ * renderer.Insert("rendererType","borderRenderer");
+ * renderer.Insert("borderColor",COLOR::RED);
+ * renderer.Insert("borderSize",20.f);
+ *
+ * Dali::Toolkit::ImageView myImageView = Dali::Toolkit::ImageView::New();
+ * myImageView.SetProperty( Control::Property::IMAGE, renderer);
+ * @endcode
+
+ * <h3 class="pg">Resizing at Load Time</h3>
+ * An application loading images from an external source will often want to
+ * display those images at a lower resolution than their native ones.
+ * To support this, DALi can resize an image at load time so that its
+ * in-memory copy uses less space and its visual quality benefits from being
+ * prefiltered.
+ * There are four algorithms which can be used to fit an image to a desired
+ * rectangle, a desired width or a desired height
+ * (see Dali::FittingMode).
+ *
+ * Here is an example doing rescaling:
+ *
+ * @code
+ * Property::Map imageProperty;
+ * imageProperty.Insert("imageUrl", "source-image-url.png");
+ * imageProperty.Insert("imageFittingMode", "scaleToFill");
+ * imageProperty.Insert("fitWidth", 240);
+ * imageProperty.Insert("fitHeight", 240);
+ * Dali::Toolkit::ImageView myImageView = Dali::Toolkit::ImageView::New();
+ * myImageView.SetProperty( Control::Property::IMAGE, imageProperty);
+
+ * @endcode
+ *
+ * This example sets the size and fitting mode appropriately for a large thumbnail
+ * during Dali::ResourceImage construction.
+ * In general, to enable scaling on load, pass a non-zero width or height and
+ * one of the four fitting modes to the Dali::ResourceImage creator function
+ * as shown above.
+ *
+ * The fitting modes and a suggested use-case for each are as follows:
+ * <ol>
+ * <li> "shrinkToFit" Full-screen image display: Limit loaded image resolution to device resolution but show all of image.
+ * <li> "scaleToFill" Thumbnail gallery grid: Limit loaded image resolution to screen tile, filling whole tile but losing a few pixels to match the tile shape.
+ * <li> "fitWidth" Image columns: Limit loaded image resolution to column.
+ * <li> "fitHeight" Image rows: Limit loaded image resolution to row height.
+ * </ol>
+ *
+ * The dali-demo project contains a full example under
+ * <code>examples/image-scaling-and-filtering</code>
+ * and a specific sampling mode example under
+ * <code>examples/image-scaling-irregular-grid</code>.
+ *
+ * There are more details on this topic in the
+ * \link resourceimagescaling Rescaling Images \endlink
+ * section.
+ *
+ * <h2 class="pg">Style</h2>
+ * The Actor can render an image in only as a quad or as a nine-patch/n-patch image. This is done by using a nine-patch filename naming scheme of ending with
+ * a ".9" or a ".#". There is no special treatment if the file encodes a nine-patch image or n-patch image as long as it has either ".9" or ".#" the image will be correctly loaded.<br>
+ * @code
+ * Dali::Toolkit::ImageView myImageView1 = Dali::Toolkit::ImageView::New("source-to-nine-patch-image.9.png");
+ * Dali::Toolkit::ImageView myImageView2 = Dali::Toolkit::ImageView::New("source-to-nine-patch-image.#.png");
+ * @endcode
+ *
+ * <h2 class="pg">Changing the image</h2>
+ * The Image View can be changed by calling Dali::Toolkit::ImageView::SetImage methods or by changing the IMAGE property.
+ * @code
+ * myImageActor.SetImage( newImage );
+ * @endcode
+ *
+ */
/*! \page shader-intro Shader Effects
*
-
-<h2 class="pg">Introduction</h2>
-
-The shader effects allow the developer to apply visual deformations on the actors.
-They can affect the geometry, the colors and textures of the actor.
-
-
-<br>
-<br>
-<h2 class="pg">Custom Shader Effects</h2>
-The \ref Dali::ShaderEffect "ShaderEffect" lets the developers create their own shader effects by specifying the vertex and pixel shaders.
-
-A custom shader effect can be created like this:
-@code
-String myVertexShader; // This variable would contain the code for a vertex shader.
-Dali::ShaderEffect myEffect = Dali::ShaderEffect::New( myVertexShader,
- "" // use default pixel shader
- );
-@endcode
-
-The value of a uniform can be set like this:
-@code
-// if the uniform was declared like this in the shader: uniform float myUniform;
-myEffect.SetUniform( "myUniform", 0.5f );
-@endcode
-
-The custom shader effect can be applied to an actor like any other shader:
-@code
-actor.SetShaderEffect( myEffect );
-@endcode
-
+ *
+ * <h2 class="pg">Introduction</h2>
+ *
+ * The shader effects allow the developer to apply visual deformations on Image Views.
+ * They can affect the geometry, the colors and textures of the Image View.
+ *
+ * <br>
+ * <br>
+ * <h2 class="pg">Custom Shader Effects</h2>
+ * The custom shader lets the developers create their own shader effects by specifying the vertex and pixel shaders.
+ *
+ * To set a custom shader to ImageRenderer you have to pass it through as a Property::Map
+ * @code
+ * //an example vertex shader
+ * const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
+ * attribute mediump vec2 aPosition;\n
+ * varying mediump vec2 vTexCoord;\n
+ * uniform mediump mat4 uMvpMatrix;\n
+ * uniform mediump vec3 uSize;\n
+ * \n
+ * void main()\n
+ * {\n
+ * mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
+ * vertexPosition.xyz *= uSize;\n
+ * vertexPosition = uMvpMatrix * vertexPosition;\n
+ * \n
+ * vTexCoord = aPosition + vec2(0.5);\n
+ * gl_Position = vertexPosition;\n
+ * }\n
+ * );
+ *
+ * //an example fragment shader
+ * const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
+ * varying mediump vec2 vTexCoord;\n
+ * uniform sampler2D sTexture;\n
+ * uniform lowp vec4 uColor;\n
+ * \n
+ * void main()\n
+ * {\n
+ * gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
+ * }\n
+ * );
+ *
+ * Property::Map customShader;
+ *
+ * customShader.Insert(“vertex-shader”, VERTEX_SHADER); //if this is not set then the default ImageView vertex shader will be used
+ * customShader.Insert(“fragment-shader”, FRAGMENT_SHADER); //if this is not set then the default ImageView fragment shader will be used
+ *
+ * Property::Map map;
+ * map.Insert(“shader”, customShader);
+ *
+ * ImageView imageView = ImageView::New("image-url.png")
+ * imageView.SetProperty(ImageView::Property::IMAGE, map);
+ * @endcode
+ *
+ * Optionally, you can subdivide the grid horizontally or vertically before you add it to the map but you should not do this if a quad is used.
+ * @code
+ * int X_SUB_DIVISIONS = 20;
+ * int Y_SUB_DIVISIONS = 20;
+ * customShader.Insert(“subdivide-grid-x”, X_SUB_DIVISIONS); //optional number of times to subdivide the grid horizontally, don’t add if you just want to use a quad
+ * customShader.Insert(“subdivide-grid-y”, Y_SUB_DIVISIONS); //optional number of times to subdivide the grid vertically, don’t add if you just want to use a quad
+ *
+ * //shader hints can be an array or a string
+ * optional array of shader hints
+ *
+ * Property::Array shaderHints;
+ * shaderHints.PushBack(“requires-self-depth-test”);
+ * shaderHints.PushBack(“output-is-transparent”);
+ * shaderHints.PushBack(“output-is-opaque”);
+ * shaderHints.PushBack(“modifies-geometry”);
+ * customShader.Insert(“hints”, shaderHints);
+ *
+ * //or optional single shader hint as a string
+ * //customShader.Insert(“hints”, “output-is-transparent”);
+ * @endcode
+ *
+ * The value of a uniform can be set on the imageView
+ * @code
+ * // if the uniform was declared like this in the shader: uniform float myUniform;
+ * imageView.RegisterProperty( "myUniform", 0.5f );
+ * @endcode
+ *
*
*/
--- /dev/null
+<!--
+/**-->
+
+# Debug Renderer {#debugrenderer}
+
+## Enable debug rendering
+
+Setting DALI_DEBUG_RENDERING environment variable will enable the renderer debuging.
+
+Then, every concrete control renderer( ColorRenderer, BorderRenderer, ImageRenderer, GradientRenderer, etc. ) is replaced with a DebugRenderer object.
+Debug renderer renders a simple quad wireframe, so that the control layout and scene structure is clearly displayed.
+
+### Example:
+~~~{.bash}
+sh-4.1$ DALI_DEBUG_RENDERING=1 /usr/apps/com.samsung.dali-demo/bin/blocks.example
+~~~
+
+
+
+
+
field.HorizontalAlignment = "BEGIN"; // "CENTER" or "END"
~~~
+### Copy and Paste (Selection)
+
+Text can be selected by a long press or double tapping it. Depending on certain conditions a popup could be shown giving options including [CUT][COPY][PASTE], [SELECT ALL] or [CLIPBOARD]. Below these conditions will be explained.
+
+[CUT] or [COPY] send the selected text to the clipboard ready to be pasted directly or via the clipboard UI. Pressing [PASTE] will paste the top item from the clipboard (what has just been copied, possibly from another application). If the system supports a clipboard UI this can be displayed by pressing the [CLIPBOARD] button.
+
+Empty text means the user has not inputted any text, a TextField containing special characters or purely whitespace is not empty.
+
+Below shows how the popup will look depending on the state of the TextField
+
+| | |
+|--|--|
+| Condition: Long press/double tap when empty text but clipboard has content | Condition: Long press/double tap when TextField contains text |
+|[PASTE][CLIPBOARD] buttons shown| [CUT][COPY], [SELECT ALL] unless all text selected and [PASTE][CLIPBOARD] if content to paste. |
+|   |   |
+| Condition: Long press/double tap popup when TextField contains just whitespace | Condition: Empty text & clipboard empty |
+| Whitespace treated as regular text, [CUT][COPY] shown and [PASTE][CLIPBOARD] if content to paste. As all text is selected there is no need for [SELECT ALL] | No popup shown after longpress/double tap|
+|   |  |
+| Condition: Longpress/(double tap) on whitespace which is following text | Condition: Tapping text or panning grab handle |
+| [PASTE][CLIPBOARD] shown if something to paste. [SELECT ALL] as more text to select | If content in clipboard [PASTE][CLIPBOARD] popup will be shown. |
+|   |   |
+
### TextField Decorations
#### Color
Name: dali-toolkit
Summary: The OpenGLES Canvas Core Library Toolkit
-Version: 1.1.10
+Version: 1.1.11
Release: 1
Group: System/Libraries
License: Apache-2.0, BSD-2.0, MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff
