Dali::Vector<uint8_t> data;
data.Resize(size);
fseek(fp, 0, SEEK_SET);
- fread(data.Begin(), size, sizeof(uint8_t), fp);
+ size_t realSize = fread(data.Begin(), sizeof(uint8_t), size, fp);
fclose(fp);
+ data.Resize(realSize);
buffer = EncodedImageBuffer::New(data);
}
return buffer;
{"sTextureRect", GL_SAMPLER_2D, 1},
{"sGloss", GL_SAMPLER_2D, 1},
{"uColor", GL_FLOAT_VEC4, 1},
+ {"uActorColor", GL_FLOAT_VEC4, 1},
{"uModelMatrix", GL_FLOAT_MAT4, 1},
{"uModelView", GL_FLOAT_MAT4, 1},
{"uMvpMatrix", GL_FLOAT_MAT4, 1},
UniformData("sTextureRect", Property::Type::FLOAT),
UniformData("sGloss", Property::Type::FLOAT),
UniformData("uColor", Property::Type::VECTOR4),
+ UniformData("uActorColor", Property::Type::VECTOR4),
UniformData("uModelMatrix", Property::Type::MATRIX),
UniformData("uModelView", Property::Type::MATRIX),
UniformData("uMvpMatrix", Property::Type::MATRIX),
return Internal::Adaptor::GetImplementation( *this ).GetUrl();
}
-NativeImageInterfacePtr WebEngine::GetNativeImageSource()
+NativeImageSourcePtr WebEngine::GetNativeImageSource()
{
Any source;
Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
END_TEST;
}
+int UtcDaliImageViewTVGLoading(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline("ImageView Testing TVG image loading");
+
+ {
+ ImageView imageView = ImageView::New( );
+
+ imageView.SetImage( TEST_RESOURCE_DIR "/test.tvg" );
+
+ application.GetScene().Add( imageView );
+ DALI_TEST_CHECK( imageView );
+ Vector3 naturalSize = imageView.GetNaturalSize();
+
+ DALI_TEST_EQUALS( naturalSize.width, 100.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS( naturalSize.height, 100.0f, TEST_LOCATION );
+ }
+ END_TEST;
+}
+
namespace
{
#include <dali-toolkit-test-suite-utils.h>
#include <dali-toolkit/dali-toolkit.h>
#include <dali/integration-api/events/key-event-integ.h>
+#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
#include <dali/devel-api/common/stage-devel.h>
END_TEST;
}
+int UtcDaliKeyInputFocusManagerDispatchKeyEvents(void)
+{
+
+ ToolkitTestApplication application;
+ Integration::Scene stage = application.GetScene();
+
+ tet_infoline("Test KeyEvents propagation. If DISPATCH_KEY_EVENTS property is false, the KeyEvent is also not received.");
+
+ KeyInputFocusManager manager = KeyInputFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ DummyControl dummy1 = DummyControl::New(true);
+ dummy1.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
+ KeyEventCallback callback1( false );
+ dummy1.KeyEventSignal().Connect( &callback1, &KeyEventCallback::Callback );
+ stage.Add( dummy1 );
+
+ DummyControl dummy2 = DummyControl::New(true);
+ dummy2.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
+ KeyEventCallback callback2( false );
+ dummy2.KeyEventSignal().Connect( &callback2, &KeyEventCallback::Callback );
+ // dummy2 set DISPATCH_KEY_EVENTS property to false.
+ dummy2.SetProperty( Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS, false);
+ dummy1.Add( dummy2 );
+
+ DummyControl dummy3 = DummyControl::New(true);
+ Impl::DummyControl& dummy3Impl = static_cast<Impl::DummyControl&>(dummy3.GetImplementation());
+ dummy3.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
+ KeyEventCallback callback3( false );
+ dummy3.KeyEventSignal().Connect( &callback3, &KeyEventCallback::Callback );
+ dummy2.Add( dummy3 );
+ DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusGained );
+ DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusLost );
+
+ manager.SetFocus( dummy3 );
+ DALI_TEST_CHECK( dummy3Impl.keyInputFocusGained );
+
+ Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "", "", Device::Class::TOUCH, Device::Subclass::NONE );
+ application.ProcessEvent(event);
+
+ DALI_TEST_CHECK( !callback1.mIsCalled );
+ DALI_TEST_CHECK( !callback2.mIsCalled );
+ DALI_TEST_CHECK( !callback3.mIsCalled );
+
+ END_TEST;
+}
+
int UtcDaliKeyInputFocusManagerGetCurrentFocusControl(void)
{
ToolkitTestApplication application;
END_TEST;
}
+int UtcDaliVisualBorderlineBlendModeTest(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliVisualBorderlineBlendModeTest" );
+ VisualFactory factory = VisualFactory::Get();
+
+ // Case 1 : Test which doesn't support borderline feature.
+ {
+ tet_printf("Test Unsupported visual type\n");
+ Property::Map propertyMap;
+ propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
+ propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
+ propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
+ Visual::Base borderVisual = factory.CreateVisual( propertyMap );
+
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, borderVisual );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+ application.GetScene().Add(actor);
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
+
+ Renderer renderer = actor.GetRendererAt(0);
+
+ Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ // Visual::BORDER doesn't support BORDERLINE. BlendMode is AUTO.
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
+
+ application.GetScene().Remove(actor);
+ }
+
+ // Case 2 : Test which support borderline feature.
+ {
+ tet_printf("Test normal case\n");
+ Property::Map propertyMap;
+ propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
+ propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
+ propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
+ Visual::Base colorVisual = factory.CreateVisual( propertyMap );
+
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, colorVisual );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+ application.GetScene().Add(actor);
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
+
+ Renderer renderer = actor.GetRendererAt(0);
+
+ Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ // Visual::COLOR support BORDERLINE. BlendMode is ON_WITHOUT_CULL.
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION );
+
+ application.GetScene().Remove(actor);
+ }
+
+ // Case 3 : Test which animated borderline.
+ {
+ tet_printf("Test borderline animate case\n");
+ Property::Map propertyMap;
+ propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
+ propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
+ Visual::Base colorVisual = factory.CreateVisual( propertyMap );
+
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, colorVisual );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+ application.GetScene().Add(actor);
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
+
+ Renderer renderer = actor.GetRendererAt(0);
+
+ Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ // BlendMode is AUTO.
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION );
+
+ Animation animation = Animation::New(0.1f);
+ animation.AnimateTo( DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 1.0f );
+ animation.Play();
+
+ application.SendNotification();
+ application.Render();
+ application.Render(101u); // End of animation
+
+ blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ // BlendMode is ON_WITHOUT_CULL.
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION );
+
+ Animation revanimation = Animation::New(0.1f);
+ revanimation.AnimateTo( DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_WIDTH), 0.0f );
+ revanimation.Play();
+
+ application.SendNotification();
+ application.Render();
+ application.Render(101u); // End of animation
+
+ blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ // BlendMode is still ON_WITHOUT_CULL.
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION );
+
+ application.GetScene().Remove(actor);
+ }
+
+ // Case 4 : Test which animated corner radius occur.
+ {
+ tet_printf("Test borderline animate case\n");
+ Property::Map propertyMap;
+ propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
+ propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
+ propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
+ Visual::Base colorVisual = factory.CreateVisual( propertyMap );
+
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, colorVisual );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+ application.GetScene().Add(actor);
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
+
+ Renderer renderer = actor.GetRendererAt(0);
+
+ Property::Value blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ // BlendMode is ON_WITHOUT_CULL.
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION );
+
+ Animation animation = Animation::New(0.1f);
+ animation.AnimateTo( DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::CORNER_RADIUS), Vector4(1.0f, 1.0f, 1.0f, 1.0f) );
+ animation.Play();
+
+ application.SendNotification();
+ application.Render();
+ application.Render(101u); // End of animation
+
+ blendModeValue = renderer.GetProperty( Renderer::Property::BLEND_MODE );
+ // BlendMode is ON_WITHOUT_CULL.
+ DALI_TEST_EQUALS( blendModeValue.Get<int>(), (int)BlendMode::ON_WITHOUT_CULL, TEST_LOCATION );
+
+ application.GetScene().Remove(actor);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliVisualBorderlineColorAnimateTest(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliVisualBorderlineColorAnimateTest color" );
+
+ TestGraphicsController& graphics = application.GetGraphicsController();
+ static std::vector<UniformData> customUniforms =
+ {
+ UniformData("mixColor", Property::Type::VECTOR3),
+ UniformData("cornerRadius", Property::Type::VECTOR4),
+ UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
+ UniformData("borderlineWidth", Property::Type::FLOAT),
+ UniformData("borderlineColor", Property::Type::VECTOR4),
+ UniformData("borderlineOffset", Property::Type::FLOAT),
+ };
+ graphics.AddCustomUniforms(customUniforms);
+
+ {
+ const Vector3 INITIAL_MIX_COLOR( 1.0f,0.0f,1.0f );
+ const float INITIAL_MIX_OPACITY( 0.5f );
+ const Vector4 INITIAL_BORDERLINE_COLOR( 0.0f,1.0f,0.0f,1.0f );
+ const float INITIAL_ACTOR_OPACITY( 1.0f );
+ const Vector3 TARGET_MIX_COLOR( 1.0f, 0.0f, 0.0f );
+ const float TARGET_MIX_OPACITY( 0.8f );
+ const Vector4 TARGET_BORDERLINE_COLOR( 1.0f, 0.0f, 1.0f, 0.2f);
+ const float TARGET_ACTOR_OPACITY( 0.5f );
+
+ VisualFactory factory = VisualFactory::Get();
+ Property::Map propertyMap;
+ propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
+ propertyMap.Insert(Visual::Property::MIX_COLOR, INITIAL_MIX_COLOR);
+ propertyMap.Insert(Visual::Property::OPACITY, INITIAL_MIX_OPACITY);
+ propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 1.0f);
+ propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, INITIAL_BORDERLINE_COLOR);
+ Visual::Base visual = factory.CreateVisual( propertyMap );
+
+ DummyControl actor = DummyControl::New(true);
+ Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 2000.f, 2000.f ) );
+ actor.SetProperty( Actor::Property::OPACITY, INITIAL_ACTOR_OPACITY );
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+ application.GetScene().Add(actor);
+
+ DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION);
+
+ Animation animation = Animation::New(4.0f);
+ animation.AnimateTo( DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::MIX_COLOR), TARGET_MIX_COLOR );
+ animation.AnimateTo( DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), TARGET_MIX_OPACITY);
+ animation.AnimateTo( DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, DevelVisual::Property::BORDERLINE_COLOR), TARGET_BORDERLINE_COLOR );
+ animation.AnimateTo( Property(actor, Actor::Property::OPACITY), TARGET_ACTOR_OPACITY);
+ animation.Play();
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+
+ application.SendNotification();
+ application.Render(0);
+ application.Render(2000u); // halfway point
+ application.SendNotification();
+
+ Vector3 halfwayMixColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR ) * 0.5f;
+ float halfwayMixOpacity = (INITIAL_MIX_OPACITY + TARGET_MIX_OPACITY ) * 0.5f;
+ Vector4 halfwayBorderlineColor = (INITIAL_BORDERLINE_COLOR + TARGET_BORDERLINE_COLOR) * 0.5f;
+ float halfwayActorOpacity = (INITIAL_ACTOR_OPACITY + TARGET_ACTOR_OPACITY ) * 0.5f;
+ halfwayMixOpacity *= halfwayActorOpacity;
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector3>("mixColor", halfwayMixColor), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, halfwayMixOpacity)), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, halfwayActorOpacity)), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector4>("borderlineColor", halfwayBorderlineColor), true, TEST_LOCATION );
+
+ application.Render(2001u); // go past end
+ application.SendNotification(); // Trigger signals
+
+ DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY), TEST_LOCATION );
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector3>("mixColor", TARGET_MIX_COLOR), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_OPACITY * TARGET_ACTOR_OPACITY) ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector4>("uActorColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_ACTOR_OPACITY)), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( glAbstraction.CheckUniformValue<Vector4>("borderlineColor", TARGET_BORDERLINE_COLOR ), true, TEST_LOCATION );
+
+ actor.Unparent();
+ }
+
+ END_TEST;
+}
int UtcDaliColorVisualBlurRadius(void)
{
* @brief Set of accessibility attributes describing object in accessibility hierarchy
* @details Name "accessibilityAttributes", type Property::MAP
*/
- ACCESSIBILITY_ATTRIBUTES
+ ACCESSIBILITY_ATTRIBUTES,
+
+ /**
+ * @brief Whether a Control and its descendants can emit key signals.
+ * @details Name "dispatchKeyEvents", type Property::BOOLEAN
+ * @note If a control's dispatchKeyEvents is set to false, then it's children will not emit a key event signal either.
+ */
+ DISPATCH_KEY_EVENTS,
};
} // namespace Property
}
const unsigned int bytesPerPixel = Dali::Pixel::GetBytesPerPixel(pixelFormat);
- if(bytesPerPixel == 0u || bytesPerPixel == 12u || bytesPerPixel == 24u)
+ // Ignore when pixelFormat is invalid or contain float
+ if(bytesPerPixel == 0u || bytesPerPixel == 6u || bytesPerPixel == 12u)
{
return;
}
const PropertyRegistration Control::Impl::PROPERTY_19(typeRegistration, "accessibilityRole", Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty);
const PropertyRegistration Control::Impl::PROPERTY_20(typeRegistration, "accessibilityHighlightable", Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty);
const PropertyRegistration Control::Impl::PROPERTY_21(typeRegistration, "accessibilityAttributes", Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty);
+const PropertyRegistration Control::Impl::PROPERTY_22(typeRegistration, "dispatchKeyEvents", Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS, Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty);
+
// clang-format on
Control::Impl::Impl(Control& controlImpl)
mIsKeyboardNavigationSupported(false),
mIsKeyboardFocusGroup(false),
mIsEmittingResourceReadySignal(false),
- mNeedToEmitResourceReady(false)
+ mNeedToEmitResourceReady(false),
+ mDispatchKeyEvents(true)
{
Dali::Accessibility::Accessible::RegisterControlAccessibilityGetter(
[](Dali::Actor actor) -> Dali::Accessibility::Accessible* {
}
break;
}
+
+ case Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS:
+ {
+ bool dispatch;
+ if(value.Get(dispatch))
+ {
+ controlImpl.mImpl->mDispatchKeyEvents = dispatch;
+ }
+ break;
+ }
}
}
}
value = controlImpl.mImpl->mAccessibilityAttributes;
break;
}
+ case Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS:
+ {
+ value = controlImpl.mImpl->mDispatchKeyEvents;
+ break;
+ }
}
}
bool mIsKeyboardFocusGroup : 1; ///< Stores whether the control is a focus group.
bool mIsEmittingResourceReadySignal : 1; ///< True during ResourceReady().
bool mNeedToEmitResourceReady : 1; ///< True if need to emit the resource ready signal again.
+ bool mDispatchKeyEvents : 1; ///< Whether the actor emits key event signals
RegisteredVisualContainer mRemoveVisuals; ///< List of visuals that are being replaced by another visual once ready
#include <dali-toolkit/devel-api/controls/web-view/web-context.h>
#include <dali-toolkit/devel-api/controls/web-view/web-cookie-manager.h>
#include <dali-toolkit/devel-api/controls/web-view/web-settings.h>
-#include <dali-toolkit/devel-api/image-loader/texture-manager.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
#include <dali-toolkit/public-api/image-loader/image.h>
-#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
#include <dali-toolkit/public-api/image-loader/image-url.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
namespace Dali
{
return Dali::Toolkit::ImageView();
}
- Dali::Toolkit::ImageUrl url = Dali::Toolkit::Image::GenerateUrl(pixel);
+ Dali::Toolkit::ImageUrl url = Dali::Toolkit::Image::GenerateUrl(pixel);
Dali::Toolkit::ImageView imageView = Dali::Toolkit::ImageView::New(url.GetUrl());
imageView.SetProperty(Dali::Actor::Property::SIZE, Vector2(pixel.GetWidth(), pixel.GetHeight()));
return imageView;
{
mWebEngine.FrameRenderedSignal().Disconnect(this, &WebView::OnInitialFrameRendered);
- Texture texture = Dali::Texture::New(*mWebEngine.GetNativeImageSource());
- const std::string nativeImageUrl = Dali::Toolkit::TextureManager::AddTexture(texture);
- mVisual = Toolkit::VisualFactory::Get().CreateVisual({{Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE}, {Toolkit::ImageVisual::Property::URL, nativeImageUrl}});
+ Dali::Toolkit::ImageUrl nativeImageUrl = Dali::Toolkit::Image::GenerateUrl(mWebEngine.GetNativeImageSource());
+ mVisual = Toolkit::VisualFactory::Get().CreateVisual({{Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE}, {Toolkit::ImageVisual::Property::URL, nativeImageUrl.GetUrl()}});
if(mVisual)
{
#include <dali/public-api/actors/layer.h>
#include <cstring> // for strcmp
+// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/controls/control-devel.h>
+
namespace Dali
{
namespace Toolkit
Toolkit::Control control = GetCurrentFocusControl();
if(control)
{
+ Dali::Actor dispatch = control;
+ while(dispatch)
+ {
+ // If the DISPATCH_KEY_EVENTS is false, it cannot emit key event.
+ Toolkit::Control dispatchControl = Toolkit::Control::DownCast(dispatch);
+ if(dispatchControl && !dispatchControl.GetProperty<bool>(Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS))
+ {
+ return true;
+ }
+ dispatch = dispatch.GetParent();
+ }
+
// Notify the control about the key event
consumed = EmitKeyEventSignal(control, event);
}
uniform mediump float borderlineWidth;
uniform mediump float borderlineOffset;
uniform lowp vec4 borderlineColor;
+uniform lowp vec4 uActorColor;
#endif
#if IS_REQUIRED_BLUR
uniform mediump float blurRadius;
borderlineOpacity = smoothstep(gMinInlinePotential, gMaxInlinePotential, potential);
}
+ lowp vec3 BorderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
+ lowp float BorderlineColorAlpha = borderlineColor.a * uActorColor.a;
+
//calculate inside of borderline when outilneColor.a < 1.0
if(borderlineColor.a < 1.0)
{
if(potential > MaxTexturelinePotential)
{
// potential is out of texture range. use borderline color instead of texture
- textureColor = vec4(borderlineColor.xyz, 0.0);
+ textureColor = vec4(BorderlineColorRGB, 0.0);
}
else if(potential > MinTexturelinePotential)
{
// potential is in texture range
- textureColor = mix(textureColor, vec4(borderlineColor.xyz, 0.0), smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
+ textureColor = mix(textureColor, vec4(BorderlineColorRGB, 0.0), smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
}
+ // TODO : need to fix here when uColor.a = 0.0 and uActorColor.a != 0
borderlineOpacity *= borderlineColor.a;
- return mix(textureColor, vec4(borderlineColor.xyz, 1.0), borderlineOpacity);
+ return mix(textureColor, vec4(BorderlineColorRGB, 1.0), borderlineOpacity);
}
- return mix(textureColor, borderlineColor, borderlineOpacity);
+ return mix(textureColor, vec4(BorderlineColorRGB, BorderlineColorAlpha), borderlineOpacity);
}
#endif
void main()
{
- lowp vec4 targetColor = vec4(mixColor, 1.0);
+ lowp vec4 targetColor = vec4(mixColor, 1.0) * uColor;
#if IS_REQUIRED_BLUR || IS_REQUIRED_ROUNDED_CORNER || IS_REQUIRED_BORDERLINE
// skip most potential calculate for performance
if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- OUT_COLOR = targetColor * uColor;
+ OUT_COLOR = targetColor;
return;
}
PreprocessPotential();
#if !IS_REQUIRED_BLUR && IS_REQUIRED_BORDERLINE
targetColor = convertBorderlineColor(targetColor);
#endif
- OUT_COLOR = targetColor * uColor;
+ OUT_COLOR = targetColor;
#if IS_REQUIRED_BLUR
mediump float opacity = calculateBlurOpacity();
uniform mediump float borderlineWidth;
uniform mediump float borderlineOffset;
uniform lowp vec4 borderlineColor;
+uniform lowp vec4 uActorColor;
#endif
#if IS_REQUIRED_ROUNDED_CORNER || IS_REQUIRED_BORDERLINE
borderlineOpacity = smoothstep(gMinInlinePotential, gMaxInlinePotential, potential);
}
+ lowp vec3 BorderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
+ lowp float BorderlineColorAlpha = borderlineColor.a * uActorColor.a;
+ // Gradient is always preMultiplied.
+ BorderlineColorRGB *= BorderlineColorAlpha;
+
//calculate inside of borderline when outilneColor.a < 1.0
if(borderlineColor.a < 1.0)
{
// potential is in texture range
textureColor = mix(textureColor, vec4(BorderlineColorRGB, 0.0), smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
}
+ // TODO : need to fix here when uColor.a = 0.0 and uActorColor.a != 0
borderlineOpacity *= borderlineColor.a;
return mix(textureColor, vec4(BorderlineColorRGB, 1.0), borderlineOpacity);
}
- return mix(textureColor, borderlineColor, borderlineOpacity);
+ return mix(textureColor, vec4(BorderlineColorRGB, BorderlineColorAlpha), borderlineOpacity);
}
#endif
void main()
{
#if RADIAL
- lowp vec4 textureColor = TEXTURE(sTexture, vec2(length(vTexCoord), 0.5)) * vec4(mixColor, 1.0);
+ lowp vec4 textureColor = TEXTURE(sTexture, vec2(length(vTexCoord), 0.5)) * vec4(mixColor, 1.0) * uColor;
#else
- lowp vec4 textureColor = TEXTURE(sTexture, vec2(vTexCoord.y, 0.5)) * vec4(mixColor, 1.0);
+ lowp vec4 textureColor = TEXTURE(sTexture, vec2(vTexCoord.y, 0.5)) * vec4(mixColor, 1.0) * uColor;
#endif
#if IS_REQUIRED_ROUNDED_CORNER || IS_REQUIRED_BORDERLINE
// skip most potential calculate for performance
if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- OUT_COLOR = textureColor * uColor;
+ OUT_COLOR = textureColor;
return;
}
PreprocessPotential();
#if IS_REQUIRED_BORDERLINE
textureColor = convertBorderlineColor(textureColor);
#endif
- OUT_COLOR = textureColor * uColor;
+ OUT_COLOR = textureColor;
#if IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
uniform mediump float borderlineWidth;
uniform mediump float borderlineOffset;
uniform lowp vec4 borderlineColor;
+uniform lowp vec4 uActorColor;
#endif
#if ATLAS_CUSTOM_WARP
borderlineOpacity = smoothstep(gMinInlinePotential, gMaxInlinePotential, potential);
}
+ lowp vec3 BorderlineColorRGB = borderlineColor.rgb * uActorColor.rgb;
+ lowp float BorderlineColorAlpha = borderlineColor.a * uActorColor.a;
+ BorderlineColorRGB *= mix(1.0, BorderlineColorAlpha, preMultipliedAlpha);
+
//calculate inside of borderline when outilneColor.a < 1.0
if(borderlineColor.a < 1.0)
{
mediump float tCornerRadius = -gCenterPosition;
mediump float MaxTexturelinePotential = tCornerRadius + gPotentialRange;
mediump float MinTexturelinePotential = tCornerRadius - gPotentialRange;
- lowp vec3 BorderlineColorRGB = borderlineColor.xyz;
- BorderlineColorRGB *= mix(1.0, borderlineColor.a, preMultipliedAlpha);
if(potential > MaxTexturelinePotential)
{
// potential is out of texture range. use borderline color instead of texture
// potential is in texture range
textureColor = mix(textureColor, vec4(BorderlineColorRGB, 0.0), smoothstep(MinTexturelinePotential, MaxTexturelinePotential, potential));
}
+ // TODO : need to fix here when uColor.a = 0.0 and uActorColor.a != 0
borderlineOpacity *= borderlineColor.a;
return mix(textureColor, vec4(BorderlineColorRGB, 1.0), borderlineOpacity);
}
- return mix(textureColor, borderlineColor, borderlineOpacity);
+ return mix(textureColor, vec4(BorderlineColorRGB, BorderlineColorAlpha), borderlineOpacity);
}
#endif
mediump vec2 texCoord = vTexCoord;
#endif
- lowp vec4 textureColor = TEXTURE( sTexture, texCoord ) * vec4( mixColor, 1.0 );
+ lowp vec4 textureColor = TEXTURE( sTexture, texCoord ) * vec4( mixColor, 1.0 ) * uColor;
#if IS_REQUIRED_ROUNDED_CORNER || IS_REQUIRED_BORDERLINE
// skip most potential calculate for performance
if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- OUT_COLOR = textureColor * uColor;
+ OUT_COLOR = textureColor;
return;
}
PreprocessPotential();
#if IS_REQUIRED_BORDERLINE
textureColor = convertBorderlineColor(textureColor);
#endif
- OUT_COLOR = textureColor * uColor;
+ OUT_COLOR = textureColor;
#if IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
// is casted to use the default duration.
mNextFrameStartTime = std::chrono::time_point_cast<TimePoint::duration>(mNextFrameStartTime + std::chrono::microseconds(mFrameDurationMicroSeconds));
auto current = std::chrono::steady_clock::now();
+ mDroppedFrames = 0;
+
if(renderNow)
{
mNextFrameStartTime = current;
- mDroppedFrames = 0;
}
else if(mNextFrameStartTime < current)
{
: Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::COLOR),
mBlurRadius(0.0f),
mBlurRadiusIndex(Property::INVALID_INDEX),
- mNeedBlurRadius(false)
+ mAlwaysUsingBlurRadius(false)
{
}
bool roundedCorner = IsRoundedCornerRequired();
bool borderline = IsBorderlineRequired();
- bool blur = !EqualsZero(mBlurRadius) || mNeedBlurRadius;
+ bool blur = !EqualsZero(mBlurRadius) || mAlwaysUsingBlurRadius;
int shaderTypeFlag = ColorVisualRequireFlag::DEFAULT;
if(roundedCorner)
{
mBlurRadiusIndex = mImpl->mRenderer.RegisterProperty(DevelColorVisual::Property::BLUR_RADIUS, BLUR_RADIUS_NAME, mBlurRadius);
- mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
+ // Blur is animated now. we always have to use blur feature.
+ mAlwaysUsingBlurRadius = true;
- mNeedBlurRadius = true;
+ mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
// Change shader
UpdateShader();
ColorVisual& operator=(const ColorVisual& colorRenderer);
private:
- float mBlurRadius; ///< The blur radius
- Property::Index mBlurRadiusIndex; ///< The blur radius property index
- bool mNeedBlurRadius; ///< Whether we need the blur radius in shader.
+ float mBlurRadius; ///< The blur radius
+ Property::Index mBlurRadiusIndex; ///< The blur radius property index
+ bool mAlwaysUsingBlurRadius : 1; ///< Whether we need the blur radius in shader always.
};
} // namespace Internal
mFlags(0),
mResourceStatus(Toolkit::Visual::ResourceStatus::PREPARING),
mType(type),
- mNeedCornerRadius(false),
- mNeedBorderline(false)
+ mAlwaysUsingBorderline(false),
+ mAlwaysUsingCornerRadius(false)
{
}
Property::Index mBorderlineColorIndex;
Property::Index mBorderlineOffsetIndex;
Property::Index mCornerRadiusIndex;
- FittingMode mFittingMode; //< How the contents should fit the view
+ FittingMode mFittingMode; ///< How the contents should fit the view
int mFlags;
Toolkit::Visual::ResourceStatus mResourceStatus;
const Toolkit::Visual::Type mType;
- bool mNeedCornerRadius;
- bool mNeedBorderline;
+ bool mAlwaysUsingBorderline : 1; ///< Whether we need the borderline in shader always.
+ bool mAlwaysUsingCornerRadius : 1; ///< Whether we need the corner radius in shader always.
};
} // namespace Visual
DALI_ENUM_TO_STRING_WITH_SCOPE(Visual::FittingMode, FIT_HEIGHT)
DALI_ENUM_TO_STRING_TABLE_END(VISUAL_FITTING_MODE)
+/**
+ * @brief Check whether this visual type can use corner radius feature or not.
+ * @param type VisualType that want to checkup
+ * @return true if type can use corner radius feature.
+ */
+static bool IsTypeAvailableForCornerRadius(Toolkit::Visual::Type type)
+{
+ switch(static_cast<Toolkit::DevelVisual::Type>(type))
+ {
+ case Toolkit::Visual::Type::COLOR:
+ case Toolkit::Visual::Type::GRADIENT:
+ case Toolkit::Visual::Type::IMAGE:
+ case Toolkit::Visual::Type::SVG:
+ case Toolkit::Visual::Type::ANIMATED_IMAGE:
+ case Toolkit::DevelVisual::Type::ANIMATED_VECTOR_IMAGE:
+ {
+ return true;
+ }
+ default:
+ {
+ return false;
+ }
+ }
+}
+
+/**
+ * @brief Check whether this visual type can use borderline feature or not.
+ * @param type VisualType that want to checkup
+ * @return true if type can use borderline feature.
+ */
+static bool IsTypeAvailableForBorderline(Toolkit::Visual::Type type)
+{
+ switch(static_cast<Toolkit::DevelVisual::Type>(type))
+ {
+ case Toolkit::Visual::Type::COLOR:
+ case Toolkit::Visual::Type::GRADIENT:
+ case Toolkit::Visual::Type::IMAGE:
+ case Toolkit::Visual::Type::SVG:
+ case Toolkit::Visual::Type::ANIMATED_IMAGE:
+ case Toolkit::DevelVisual::Type::ANIMATED_VECTOR_IMAGE:
+ {
+ return true;
+ }
+ default:
+ {
+ return false;
+ }
+ }
+}
+
} // namespace
Visual::Base::Base(VisualFactoryCache& factoryCache, FittingMode fittingMode, Toolkit::Visual::Type type)
mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor);
mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset);
- mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
+ mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL);
}
}
}
bool Visual::Base::IsRoundedCornerRequired() const
{
- if(mImpl->mRenderer && mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)
+ // If VisualType doesn't support rounded corner, always return false.
+ if(IsTypeAvailableForCornerRadius(mImpl->mType))
{
- // Update values from Renderer
- mImpl->mCornerRadius = mImpl->mRenderer.GetProperty<Vector4>(mImpl->mCornerRadiusIndex);
+ if(mImpl->mRenderer && mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)
+ {
+ // Update values from Renderer
+ mImpl->mCornerRadius = mImpl->mRenderer.GetProperty<Vector4>(mImpl->mCornerRadiusIndex);
+ }
+ return !(mImpl->mCornerRadius == Vector4::ZERO) || mImpl->mAlwaysUsingCornerRadius;
}
- return !(mImpl->mCornerRadius == Vector4::ZERO) || mImpl->mNeedCornerRadius;
+ return false;
}
bool Visual::Base::IsBorderlineRequired() const
{
- if(mImpl->mRenderer && mImpl->mBorderlineWidthIndex != Property::INVALID_INDEX)
+ // If VisualType doesn't support borderline, always return false.
+ if(IsTypeAvailableForBorderline(mImpl->mType))
{
- // Update values from Renderer
- mImpl->mBorderlineWidth = mImpl->mRenderer.GetProperty<float>(mImpl->mBorderlineWidthIndex);
+ if(mImpl->mRenderer && mImpl->mBorderlineWidthIndex != Property::INVALID_INDEX)
+ {
+ // Update values from Renderer
+ mImpl->mBorderlineWidth = mImpl->mRenderer.GetProperty<float>(mImpl->mBorderlineWidthIndex);
+ }
+ return !EqualsZero(mImpl->mBorderlineWidth) || mImpl->mAlwaysUsingBorderline;
}
- return !EqualsZero(mImpl->mBorderlineWidth) || mImpl->mNeedBorderline;
+ return false;
}
void Visual::Base::OnDoAction(const Property::Index actionId, const Property::Value& attributes)
Property::Index index = GetPropertyIndex(key);
if(index == Property::INVALID_INDEX)
{
- if((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_WIDTH) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_WIDTH) ||
- (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_COLOR) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_COLOR) ||
- (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_OFFSET) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_OFFSET))
+ if(IsTypeAvailableForBorderline(mImpl->mType) &&
+ ((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_WIDTH) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_WIDTH) ||
+ (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_COLOR) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_COLOR) ||
+ (key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::BORDERLINE_OFFSET) || (key.type == Property::Key::STRING && key.stringKey == BORDERLINE_OFFSET)))
{
- mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
+ mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL);
// Register borderline properties
mImpl->mBorderlineWidthIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_WIDTH, BORDERLINE_WIDTH, mImpl->mBorderlineWidth);
mImpl->mBorderlineColorIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_COLOR, BORDERLINE_COLOR, mImpl->mBorderlineColor);
mImpl->mBorderlineOffsetIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::BORDERLINE_OFFSET, BORDERLINE_OFFSET, mImpl->mBorderlineOffset);
- mImpl->mNeedBorderline = true;
+
+ // Borderline is animated now. we always have to use borderline feature.
+ mImpl->mAlwaysUsingBorderline = true;
index = mImpl->mRenderer.GetPropertyIndex(key);
// Change shader
UpdateShader();
}
- else if((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::CORNER_RADIUS) || (key.type == Property::Key::STRING && key.stringKey == CORNER_RADIUS))
+ else if(IsTypeAvailableForCornerRadius(mImpl->mType) && ((key.type == Property::Key::INDEX && key.indexKey == DevelVisual::Property::CORNER_RADIUS) || (key.type == Property::Key::STRING && key.stringKey == CORNER_RADIUS)))
{
// Register CORNER_RADIUS property
mImpl->mCornerRadiusIndex = mImpl->mRenderer.RegisterProperty(DevelVisual::Property::CORNER_RADIUS, CORNER_RADIUS, mImpl->mCornerRadius);
mImpl->mRenderer.RegisterProperty(CORNER_RADIUS_POLICY, mImpl->mCornerRadiusPolicy);
- mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
+ // ConerRadius is animated now. we always have to use corner radius feature.
+ mImpl->mAlwaysUsingCornerRadius = true;
+
+ if(!IsBorderlineRequired())
+ {
+ // If mNeedBorderline is true, BLEND_MODE is already BlendMode::ON_WITHOUT_CULL. So we don't overwrite it.
+ mImpl->mRenderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
+ }
- index = mImpl->mCornerRadiusIndex;
- mImpl->mNeedCornerRadius = true;
+ index = mImpl->mCornerRadiusIndex;
// Change shader
UpdateShader();
visualPtr = NPatchVisual::New(GetFactoryCache(), GetImageVisualShaderFactory(), visualUrl, propertyMap);
break;
}
+ case VisualUrl::TVG:
case VisualUrl::SVG:
{
visualPtr = SvgVisual::New(GetFactoryCache(), GetImageVisualShaderFactory(), visualUrl, propertyMap);
visualPtr = NPatchVisual::New(GetFactoryCache(), GetImageVisualShaderFactory(), visualUrl);
break;
}
+ case VisualUrl::TVG:
case VisualUrl::SVG:
{
visualPtr = SvgVisual::New(GetFactoryCache(), GetImageVisualShaderFactory(), visualUrl);
char GIF[4] = {'f', 'i', 'g', '.'};
char WEBP[5] = {'p', 'b', 'e', 'w', '.'};
char JSON[5] = {'n', 'o', 's', 'j', '.'};
+ char TVG[4] = {'g', 'v', 't', '.'};
unsigned int svgScore = 0;
+ unsigned int tvgScore = 0;
unsigned int gifScore = 0;
unsigned int webpScore = 0;
unsigned int jsonScore = 0;
return VisualUrl::SVG;
}
}
+ if((offsetFromEnd < sizeof(TVG)) && (currentChar == TVG[offsetFromEnd]))
+ {
+ // early out if TVG as can't be used in N patch for now
+ if(++tvgScore == sizeof(TVG))
+ {
+ return VisualUrl::TVG;
+ }
+ }
if((offsetFromEnd < sizeof(GIF)) && (currentChar == GIF[offsetFromEnd]))
{
// early out if GIF as can't be used in N patch for now
SVG,
GIF,
WEBP,
- JSON
+ JSON,
+ TVG
};
enum ProtocolType
{
const unsigned int TOOLKIT_MAJOR_VERSION = 2;
const unsigned int TOOLKIT_MINOR_VERSION = 0;
-const unsigned int TOOLKIT_MICRO_VERSION = 45;
+const unsigned int TOOLKIT_MICRO_VERSION = 46;
const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-toolkit
Summary: Dali 3D engine Toolkit
-Version: 2.0.45
+Version: 2.0.46
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff