Dali::Accessibility::TestEnableSC( true );
+ /* add to scene and remove from scene to touch AccessibilityDeregister */
+ application.GetScene().Add( pushbutton );
+
auto states = accessible->GetStates();
DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::PRESSED ] ), false, TEST_LOCATION );
states = accessible->GetStates();
DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::PRESSED ] ), true, TEST_LOCATION );
+ /* add to scene and remove from scene to touch AccessibilityDeregister */
+ application.GetScene().Remove( pushbutton );
+
Dali::Accessibility::TestEnableSC( false );
END_TEST;
#include <dali/devel-api/adaptor-framework/web-engine-cookie-manager.h>
#include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
#include <dali/devel-api/adaptor-framework/web-engine-frame.h>
+#include <dali/devel-api/adaptor-framework/web-engine-hit-test.h>
#include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
#include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
#include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
#include <dali/public-api/images/pixel-data.h>
#include <dali/public-api/object/any.h>
#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/object/property-map.h>
#include <memory>
#include <string.h>
#include <toolkit-application.h>
bool OnJavaScriptAlert();
bool OnJavaScriptConfirm();
bool OnJavaScriptPrompt();
+bool OnHitTestCreated();
bool OnScrollEdge();
bool OnScreenshotCaptured();
bool OnVideoPlaying();
Dali::WebEngineContext::CacheModel mockModel;
};
-class MockWebEngineSecurityOrigin : public Dali::WebEngineSecurityOrigin
-{
-public:
- MockWebEngineSecurityOrigin()
- : mockUrl("https://test.html")
- , mockPotocol("https")
- {
- }
-
- std::string GetHost() const
- {
- return mockUrl;
- }
-
- std::string GetProtocol() const
- {
- return mockPotocol;
- }
-
-private:
- std::string mockUrl;
- std::string mockPotocol;
-};
-
class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
{
public:
{
public:
MockWebEngineBackForwardList()
- : mockItem(),
- pMockItem( &mockItem )
{
}
- Dali::WebEngineBackForwardListItem& GetCurrentItem() const override
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetCurrentItem() const override
+ {
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
+ }
+
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetPreviousItem() const override
+ {
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
+ }
+
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetNextItem() const override
{
- return *pMockItem;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
}
- Dali::WebEngineBackForwardListItem& GetItemAtIndex( uint32_t index ) const override
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetItemAtIndex( uint32_t index ) const override
{
- return *pMockItem;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
}
uint32_t GetItemCount() const override
return 1;
}
-private:
- MockWebEngineBackForwardListItem mockItem;
- WebEngineBackForwardListItem* pMockItem;
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> GetBackwardItems(int limit) override
+ {
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> ret;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> item(new MockWebEngineBackForwardListItem());
+ ret.push_back(std::move(item));
+ return ret;
+ }
+
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> GetForwardItems(int limit) override
+ {
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> ret;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> item(new MockWebEngineBackForwardListItem());
+ ret.push_back(std::move(item));
+ return ret;
+ }
};
+
class MockWebEngineCertificate : public Dali::WebEngineCertificate
{
public:
}
};
+class MockWebEngineHitTest : public Dali::WebEngineHitTest
+{
+public:
+ MockWebEngineHitTest()
+ {
+ }
+
+ ResultContext GetResultContext() const override
+ {
+ return ResultContext::DOCUMENT;
+ }
+
+ std::string GetLinkUri() const override
+ {
+ return "http://test.html";
+ }
+
+ std::string GetLinkTitle() const override
+ {
+ return "test";
+ }
+
+ std::string GetLinkLabel() const override
+ {
+ return "label";
+ }
+
+ std::string GetImageUri() const override
+ {
+ return "http://test.jpg";
+ }
+
+ std::string GetMediaUri() const override
+ {
+ return "http://test.mp4";
+ }
+
+ std::string GetTagName() const override
+ {
+ return "img";
+ }
+
+ std::string GetNodeValue() const override
+ {
+ return "test";
+ }
+
+ Dali::Property::Map& GetAttributes() const override
+ {
+ return mockAttributesMap;
+ }
+
+ std::string GetImageFileNameExtension() const override
+ {
+ return "jpg";
+ }
+
+ Dali::PixelData GetImageBuffer() override
+ {
+ uint8_t* faviconData = new uint8_t[ 16 ];
+ memset(faviconData, 0xff, 16);
+ return Dali::PixelData::New( faviconData, 16, 2, 2,
+ Dali::Pixel::Format::RGBA8888,
+ Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
+ }
+
+private:
+ mutable Dali::Property::Map mockAttributesMap;
+};
+
+class MockWebEngineSecurityOrigin : public Dali::WebEngineSecurityOrigin
+{
+public:
+ MockWebEngineSecurityOrigin()
+ : mockUrl("https://test.html")
+ , mockPotocol("https")
+ {
+ }
+
+ std::string GetHost() const
+ {
+ return mockUrl;
+ }
+
+ std::string GetProtocol() const
+ {
+ return mockPotocol;
+ }
+
+private:
+ std::string mockUrl;
+ std::string mockPotocol;
+};
+
class MockWebEngineSettings : public WebEngineSettings
{
public:
{
}
+ bool SetViewportMetaTag(bool enable) override
+ {
+ return true;
+ }
+
+ bool SetForceZoom(bool enable) override
+ {
+ return true;
+ }
+
+ bool IsZoomForced() const override
+ {
+ return true;
+ }
+
+ bool SetTextZoomEnabled(bool enable) override
+ {
+ return true;
+ }
+
+ bool IsTextZoomEnabled() const override
+ {
+ return true;
+ }
+
+ void SetExtraFeature(const std::string& feature, bool enable) override
+ {
+ }
+
+ bool IsExtraFeatureEnabled(const std::string& feature) const override
+ {
+ return true;
+ }
+
private:
int mockDefaultFontSize;
bool mockJavaScriptEnabled;
}
}
+ std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
+ {
+ std::unique_ptr<Dali::WebEngineHitTest> hitTest(new MockWebEngineHitTest());
+ return hitTest;
+ }
+
+ bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal( &OnHitTestCreated );
+ mHitTestCreatedCallback = callback;
+ }
+ return true;
+ }
+
void ClearHistory()
{
ConnectToGlobalSignal( &OnClearHistory );
mUserAgent = userAgent;
}
- void ScrollBy( int dx, int dy )
+ void ScrollBy( int32_t dx, int32_t dy )
{
mScrollPosition += Dali::Vector2( dx, dy );
if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
}
}
- bool ScrollEdgeBy( int dx, int dy )
+ bool ScrollEdgeBy( int32_t dx, int32_t dy )
{
mScrollPosition += Dali::Vector2( dx, dy );
if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
return true;
}
- void SetScrollPosition( int x, int y )
+ void SetScrollPosition( int32_t x, int32_t y )
{
mScrollPosition.x = x;
mScrollPosition.y = y;
return mScaleFactor;
}
- Dali::PixelData GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
+ Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
{
uint32_t bufferSize = viewArea.width * viewArea.height * 4 ;
uint8_t* pixel = new uint8_t[ bufferSize ];
Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
}
- bool GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
+ bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
{
if ( callback )
{
WebEngineCookieManager* mockWebEngineCookieManager;
WebEngineSettings* mockWebEngineSettings;
- std::vector<JavaScriptEvaluatedResultCallback> mResultCallbacks;
- Dali::WebEnginePlugin::JavaScriptAlertCallback mJavaScriptAlertCallback;
- Dali::WebEnginePlugin::JavaScriptConfirmCallback mJavaScriptConfirmCallback;
- Dali::WebEnginePlugin::JavaScriptPromptCallback mJavaScriptPromptCallback;
- Dali::WebEnginePlugin::ScreenshotCapturedCallback mScreenshotCapturedCallback;
- Dali::WebEnginePlugin::VideoPlayingCallback mVideoPlayingCallback;
- Dali::WebEnginePlugin::GeolocationPermissionCallback mGeolocationPermissionCallback;
+ std::vector<JavaScriptEvaluatedResultCallback> mResultCallbacks;
+ Dali::WebEnginePlugin::JavaScriptAlertCallback mJavaScriptAlertCallback;
+ Dali::WebEnginePlugin::JavaScriptConfirmCallback mJavaScriptConfirmCallback;
+ Dali::WebEnginePlugin::JavaScriptPromptCallback mJavaScriptPromptCallback;
+ Dali::WebEnginePlugin::ScreenshotCapturedCallback mScreenshotCapturedCallback;
+ Dali::WebEnginePlugin::VideoPlayingCallback mVideoPlayingCallback;
+ Dali::WebEnginePlugin::GeolocationPermissionCallback mGeolocationPermissionCallback;
+ Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback mHitTestCreatedCallback;
};
return false;
}
+bool OnHitTestCreated()
+{
+ DisconnectFromGlobalSignal(&OnHitTestCreated);
+ if (gInstance)
+ {
+ std::unique_ptr<Dali::WebEngineHitTest> test(new MockWebEngineHitTest());
+ gInstance->mHitTestCreatedCallback(std::move(test));
+ }
+ return false;
+}
+
bool OnClearHistory()
{
DisconnectFromGlobalSignal( &OnClearHistory );
return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
}
-void WebEngine::Create( int width, int height, const std::string& locale, const std::string& timezoneId )
+void WebEngine::Create( uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId )
{
}
-void WebEngine::Create( int width, int height, int argc, char** argv )
+void WebEngine::Create( uint32_t width, uint32_t height, uint32_t argc, char** argv )
{
}
{
}
+std::unique_ptr<Dali::WebEngineHitTest> WebEngine::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
+{
+ return Internal::Adaptor::GetImplementation(*this).CreateHitTest(x, y, mode);
+}
+
+bool WebEngine::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
+{
+ return Internal::Adaptor::GetImplementation(*this).CreateHitTestAsynchronously(x, y, mode, callback);
+}
+
void WebEngine::ClearAllTilesResources()
{
}
{
}
-Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
+Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
{
return Internal::Adaptor::GetImplementation( *this ).GetScreenshot(viewArea, scaleFactor);
}
-bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
+bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
{
return Internal::Adaptor::GetImplementation( *this ).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
}
Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
}
-void WebEngine::ScrollBy( int dx, int dy )
+void WebEngine::ScrollBy( int32_t dx, int32_t dy )
{
Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
}
-bool WebEngine::ScrollEdgeBy( int dx, int dy )
+bool WebEngine::ScrollEdgeBy( int32_t dx, int32_t dy )
{
return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeBy( dx, dy );
}
-void WebEngine::SetScrollPosition( int x, int y )
+void WebEngine::SetScrollPosition( int32_t x, int32_t y )
{
Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
}
return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
}
-void WebEngine::SetSize( int width, int height )
+void WebEngine::SetSize( uint32_t width, uint32_t height )
{
}
return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
}
-void WebEngine::UpdateDisplayArea( Dali::Rect< int > displayArea )
+void WebEngine::UpdateDisplayArea( Dali::Rect< int32_t > displayArea )
{
}
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_GIF_FILE_NAME );
- value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::FLOAT );
+ value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4 );
DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( value->Get<float>(), 22.2f, TEST_LOCATION );
+ DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4(22.2f, 22.2f, 22.2f, 22.2f), TEST_LOCATION );
value = resultMap.Find( Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER );
DALI_TEST_CHECK( value );
.Add( "pixelArea", Vector4() )
.Add( "wrapModeU", WrapMode::REPEAT )
.Add( "wrapModeV", WrapMode::DEFAULT )
- .Add( "cornerRadius", 50.0f )
+ .Add( "cornerRadius", Vector4(50.0f, 25.0f, 12.5f, 33.0f) )
.Add( "cornerRadiusPolicy", Visual::Transform::Policy::RELATIVE ));
Property::Map resultMap;
value = resultMap.Find( Toolkit::DevelVisual::Property::CORNER_RADIUS, "cornerRadius" );
DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( value->Get<float>(), 50.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4(50.0f, 25.0f, 12.5f, 33.0f), TEST_LOCATION );
value = resultMap.Find( Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, "cornerRadiusPolicy" );
DALI_TEST_CHECK( value );
value = resultMap.Find( Toolkit::DevelVisual::Property::CORNER_RADIUS, "cornerRadius" );
DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( value->Get<float>(), 50.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS( value->Get<Vector4>(), Vector4(50.5f, 50.5f, 50.5f, 50.5f), TEST_LOCATION );
value = resultMap.Find( Toolkit::DevelVisual::Property::CORNER_RADIUS_POLICY, "cornerRadiusPolicy" );
DALI_TEST_CHECK( value );
tet_infoline( "UtcDaliVisualFactoryGetAnimatedVectorImageVisual04: Request animated vector image visual with a Property::Map" );
int startFrame = 1, endFrame = 3;
- float cornerRadius = 50.0f;
+ float cornerRadius = 22.0f;
Property::Array playRange;
playRange.PushBack( startFrame );
playRange.PushBack( endFrame );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get< bool >() == false );
- value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::FLOAT );
+ value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4 );
DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( value->Get< float >(), cornerRadius, TEST_LOCATION );
+ DALI_TEST_EQUALS( value->Get< Vector4 >(), Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius), TEST_LOCATION );
value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS_POLICY, "cornerRadiusPolicy" );
DALI_TEST_CHECK( value );
tet_infoline( "UtcDaliAnimatedVectorImageVisualGetPropertyMap01" );
int startFrame = 1, endFrame = 3;
- float cornerRadius = 50.0f;
+ Vector4 cornerRadius(50.0f, 22.0f, 0.0f, 3.0f);
Property::Array playRange;
playRange.PushBack( startFrame );
playRange.PushBack( endFrame );
DALI_TEST_CHECK( value );
DALI_TEST_CHECK( value->Get< bool >() == true ); // Check default value
- value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::FLOAT );
+ value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4 );
DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( value->Get< float >(), cornerRadius, TEST_LOCATION );
+ DALI_TEST_EQUALS( value->Get< Vector4 >(), cornerRadius, TEST_LOCATION );
value = resultMap.Find( DevelVisual::Property::CORNER_RADIUS_POLICY, "cornerRadiusPolicy" );
DALI_TEST_CHECK( value );
END_TEST;
}
+
+// test max length when set after setting long text
+int utcDaliTextFieldMaxCharactersReachedAfterSetText(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" utcDaliTextFieldMaxCharactersReachedAfterSetText");
+ TextField field = TextField::New();
+ DALI_TEST_CHECK( field );
+
+ application.GetScene().Add( field );
+
+ field.SetProperty(TextField::Property::TEXT, "123456789");
+
+ const int maxNumberOfCharacters = 3;
+ field.SetProperty( TextField::Property::MAX_LENGTH, maxNumberOfCharacters );
+
+ field.SetKeyInputFocus();
+
+ // connect to the text max lengh reached signal.
+ ConnectionTracker* testTracker = new ConnectionTracker();
+ bool maxLengthReachedSignal = false;
+ field.ConnectSignal( testTracker, "maxLengthReached", CallbackFunctor(&maxLengthReachedSignal) );
+
+ application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
+ application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
+
+ DALI_TEST_CHECK( maxLengthReachedSignal );
+
+ DALI_TEST_EQUALS( field.GetProperty( TextField::Property::TEXT ).Get<std::string>(), "123456789", TEST_LOCATION );
+
+ END_TEST;
+}
\ No newline at end of file
DALI_TEST_CHECK( colorValue );
DALI_TEST_CHECK( colorValue->Get<Vector4>() == Color::BLUE );
- Property::Value* cornerRadiusValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::FLOAT );
+ Property::Value* cornerRadiusValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4 );
DALI_TEST_CHECK( cornerRadiusValue );
- DALI_TEST_CHECK( cornerRadiusValue->Get< float >() == 10.0f );
+ DALI_TEST_CHECK( cornerRadiusValue->Get< Vector4 >() == Vector4(10.0f, 10.0f, 10.0f, 10.0f) );
Property::Value* cornerRadiusPolicyValue = resultMap.Find( DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER );
DALI_TEST_CHECK( cornerRadiusPolicyValue );
static std::vector<UniformData> customUniforms =
{
- UniformData("cornerRadius", Property::Type::FLOAT),
+ UniformData("cornerRadius", Property::Type::VECTOR4),
UniformData("cornerRadiusPolicy", Property::Type::FLOAT),
};
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
// Default corner radius policy is absolute.
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
}
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
}
{
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float cornerRadius = 0.5f;
+ Vector4 cornerRadius(0.5f, 0.5f, 0.5f, 0.3f);
properties[Visual::Property::TYPE] = Visual::COLOR;
properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
}
{
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float cornerRadius = 30.0f;
+ Vector4 cornerRadius(30.0f, 30.0f, 30.0f, 20.0f);
properties[Visual::Property::TYPE] = Visual::COLOR;
properties[ColorVisual::Property::MIX_COLOR] = Color::BLUE;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
// Default corner radius policy is absolute.
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
}
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
// Default corner radius policy is absolute.
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
}
{
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float cornerRadius = 24.0f;
+ Vector4 cornerRadius(24.0f, 23.0f, 22.0f, 21.0f);
properties[Visual::Property::TYPE] = Visual::ANIMATED_IMAGE;
properties[ImageVisual::Property::URL] = TEST_GIF_FILE_NAME;
- properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius + 10.0f; // Dummy Input
+ properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius.x + 10.0f; // Dummy Input
properties[DevelVisual::Property::CORNER_RADIUS] = cornerRadius;
properties["cornerRadiusPolicy"] = Toolkit::Visual::Transform::Policy::ABSOLUTE;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
}
{
VisualFactory factory = VisualFactory::Get();
Property::Map properties;
- float cornerRadius = 27.0f;
+ Vector4 cornerRadius(27.0f, 72.0f, 11.0f, 500.5f);
properties[Visual::Property::TYPE] = Visual::SVG;
properties[ImageVisual::Property::URL] = TEST_SVG_FILE_NAME;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
// Default corner radius policy is absolute.
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::ABSOLUTE ), true, TEST_LOCATION );
}
properties[Visual::Property::TYPE] = DevelVisual::ANIMATED_VECTOR_IMAGE;
properties[ImageVisual::Property::URL] = TEST_VECTOR_IMAGE_FILE_NAME;
+ properties["cornerRadius"] = Vector4(1.0f, 100.0f, 10.0f, 0.1f); // Dummy Input
properties["cornerRadius"] = cornerRadius;
properties[DevelVisual::Property::CORNER_RADIUS_POLICY] = Toolkit::Visual::Transform::Policy::RELATIVE;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadius", cornerRadius ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< Vector4 >( "cornerRadius", Vector4(cornerRadius, cornerRadius, cornerRadius, cornerRadius) ), true, TEST_LOCATION );
DALI_TEST_EQUALS( application.GetGlAbstraction().CheckUniformValue< float >( "cornerRadiusPolicy", Toolkit::Visual::Transform::Policy::RELATIVE ), true, TEST_LOCATION );
}
#else
UniformData("mixColor", Property::Type::VECTOR3),
UniformData("offset", Property::Type::VECTOR2),
UniformData("size", Property::Type::VECTOR2),
- UniformData("cornerRadius", Property::Type::FLOAT),
+ UniformData("cornerRadius", Property::Type::VECTOR4),
UniformData("blurRadius", Property::Type::FLOAT),
};
Property::Map propertyMap;
propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
- propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
+ propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, Vector4(10.0f, 0.0f, 2.0f, 4.0f));
propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
Visual::Base colorVisual = factory.CreateVisual(propertyMap);
Vector2 targetOffset(0.05f, 0.05f);
Vector2 targetSize(1.1f, 1.1f);
float targetOpacity = 0.5f;
- float targetCornerRadius = 20.0f;
+ Vector4 targetCornerRadius(0.0f, 0.0f, 0.0f, 0.0f);
float targetBlurRadius = 10.0f;
Animation animation = Animation::New(1.0f);
DALI_TEST_CHECK(sizeValue);
DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
- Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
+ Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
DALI_TEST_CHECK(cornerRadiusValue);
- DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
+ DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
DALI_TEST_CHECK(blurRadiusValue);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
- DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
// Test not-supported property
int UtcDaliVisualGetVisualProperty02(void)
{
-#ifdef OLD_GRAPHICS_TEST
ToolkitTestApplication application;
tet_infoline( "UtcDaliVisualGetVisualProperty02: Test animatable property" );
UniformData("mixColor", Property::Type::VECTOR3),
UniformData("offset", Property::Type::VECTOR2),
UniformData("size", Property::Type::VECTOR2),
- UniformData("cornerRadius", Property::Type::FLOAT),
+ UniformData("cornerRadius", Property::Type::VECTOR4),
UniformData("blurRadius", Property::Type::FLOAT),
};
Vector2 targetOffset(0.05f, 0.05f);
Vector2 targetSize(1.1f, 1.1f);
float targetOpacity = 0.5f;
- float targetCornerRadius = 20.0f;
+ Vector4 targetCornerRadius(20.0f, 0.0f, 20.0f, 0.0f);
float targetBlurRadius = 10.0f;
// Should work when the properties are not set before
DALI_TEST_CHECK(sizeValue);
DALI_TEST_EQUALS(sizeValue->Get<Vector2>(), targetSize, TEST_LOCATION);
- Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
+ Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
DALI_TEST_CHECK(cornerRadiusValue);
- DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
+ DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
DALI_TEST_CHECK(blurRadiusValue);
DALI_TEST_EQUALS(blurRadiusValue->Get< float >(), targetBlurRadius, TEST_LOCATION);
+#ifdef OLD_GRAPHICS_TEST
// Test uniform values
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", targetColor), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("offset", targetOffset), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("size", targetSize), true, TEST_LOCATION);
- DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("blurRadius", targetBlurRadius), true, TEST_LOCATION);
-#else
- tet_result(TET_PASS);
#endif
END_TEST;
static std::vector<UniformData> customUniforms =
{
- UniformData("cornerRadius", Property::Type::FLOAT),
+ UniformData("cornerRadius", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
application.Render();
float targetOpacity = 0.5f;
- float targetCornerRadius = 20.0f;
+ Vector4 targetCornerRadius(20.0f, 20.0f, 0.0f, 0.0f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
DALI_TEST_CHECK(colorValue);
DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
- Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
+ Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
DALI_TEST_CHECK(cornerRadiusValue);
- DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
+ DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
// Test uniform value
- DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
#else
tet_result(TET_PASS);
#endif
static std::vector<UniformData> customUniforms =
{
- UniformData("cornerRadius", Property::Type::FLOAT),
+ UniformData("cornerRadius", Property::Type::VECTOR4),
};
TestGraphicsController& graphics = application.GetGraphicsController();
application.Render();
float targetOpacity = 0.5f;
- float targetCornerRadius = 20.0f;
+ Vector4 targetCornerRadius(20.0f, 30.0f, 10.0f, 20.0f);
Animation animation = Animation::New(1.0f);
animation.AnimateTo(DevelControl::GetVisualProperty(dummyControl, DummyControl::Property::TEST_VISUAL, Visual::Property::OPACITY), targetOpacity);
DALI_TEST_CHECK(colorValue);
DALI_TEST_EQUALS(colorValue->Get<Vector4>(), Vector4(1.0f, 1.0f, 1.0f, targetOpacity), TEST_LOCATION);
- Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::FLOAT);
+ Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
DALI_TEST_CHECK(cornerRadiusValue);
- DALI_TEST_EQUALS(cornerRadiusValue->Get< float >(), targetCornerRadius, TEST_LOCATION);
+ DALI_TEST_EQUALS(cornerRadiusValue->Get< Vector4 >(), targetCornerRadius, TEST_LOCATION);
// Test uniform value
- DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("cornerRadius", targetCornerRadius), true, TEST_LOCATION);
#else
tet_result(TET_PASS);
#endif
#include <dali/devel-api/adaptor-framework/web-engine-console-message.h>
#include <dali/devel-api/adaptor-framework/web-engine-context-menu.h>
#include <dali/devel-api/adaptor-framework/web-engine-context-menu-item.h>
+#include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
#include <dali/devel-api/adaptor-framework/web-engine-frame.h>
+#include <dali/devel-api/adaptor-framework/web-engine-hit-test.h>
#include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
#include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
#include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
#include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list.h>
-#include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list-item.h>
#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-form-repost-decision.h>
#include <dali-toolkit/devel-api/controls/web-view/web-settings.h>
#include <dali-toolkit/devel-api/controls/web-view/web-view.h>
static bool gHovered = false;
static bool gWheelEventHandled = false;
static int gFormRepostDecisionCallbackCalled = 0;
-static std::shared_ptr<Dali::Toolkit::WebFormRepostDecision> gFormRepostDecisionInstance = nullptr;
+static std::shared_ptr<Dali::WebEngineFormRepostDecision> gFormRepostDecisionInstance = nullptr;
static int gFrameRenderedCallbackCalled = 0;
static int gRequestInterceptorCallbackCalled = 0;
static std::shared_ptr<Dali::WebEngineRequestInterceptor> gRequestInterceptorInstance = nullptr;
static std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> gSecurityOriginList;
static std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> gPasswordDataList;
static int gContextMenuCustomizedCallbackCalled = 0;
-static std::shared_ptr<Dali::WebEngineContextMenu> gContextMenuInstance = 0;
+static std::shared_ptr<Dali::WebEngineContextMenu> gContextMenuInstance = nullptr;
static int gContextMenuItemSelectedCallbackCalled = 0;
-static std::shared_ptr<Dali::WebEngineContextMenuItem> gContextMenuItemInstance = 0;
+static std::shared_ptr<Dali::WebEngineContextMenuItem> gContextMenuItemInstance = nullptr;
+static int gHitTestCreatedCallbackCalled = 0;
struct CallbackFunctor
{
gUrlChangedCallbackCalled++;
}
+static bool OnHitTestCreated(std::unique_ptr<Dali::WebEngineHitTest> test)
+{
+ gHitTestCreatedCallbackCalled++;
+ return true;
+}
+
static void OnPageLoadError(WebView view, std::shared_ptr<Dali::WebEngineLoadError> error)
{
gPageLoadErrorCallbackCalled++;
return true;
}
-static void OnFormRepostDecision(WebView, std::shared_ptr<Dali::Toolkit::WebFormRepostDecision> decision)
+static void OnFormRepostDecision(WebView, std::shared_ptr<Dali::WebEngineFormRepostDecision> decision)
{
gFormRepostDecisionCallbackCalled++;
gFormRepostDecisionInstance = std::move(decision);
END_TEST;
}
+int UtcDaliWebViewHitTest(void)
+{
+ ToolkitTestApplication application;
+
+ WebView view = WebView::New();
+ DALI_TEST_CHECK( view );
+
+ // load url.
+ view.LoadUrl( TEST_URL1 );
+
+ // sync hit test.
+ std::unique_ptr<Dali::WebEngineHitTest> hitTest = view.CreateHitTest(100, 100, Dali::WebEngineHitTest::HitTestMode::DEFAULT);
+ DALI_TEST_CHECK(hitTest != 0);
+ DALI_TEST_EQUALS(hitTest->GetResultContext(), Dali::WebEngineHitTest::ResultContext::DOCUMENT, TEST_LOCATION);
+ std::string testLinkUri("http://test.html");
+ DALI_TEST_EQUALS(hitTest->GetLinkUri(), testLinkUri, TEST_LOCATION);
+ std::string testLinkTitle("test");
+ DALI_TEST_EQUALS(hitTest->GetLinkTitle(), testLinkTitle, TEST_LOCATION);
+ std::string testLinkLabel("label");
+ DALI_TEST_EQUALS(hitTest->GetLinkLabel(), testLinkLabel, TEST_LOCATION);
+ std::string testImageUri("http://test.jpg");
+ DALI_TEST_EQUALS(hitTest->GetImageUri(), testImageUri, TEST_LOCATION);
+ std::string testMediaUri("http://test.mp4");
+ DALI_TEST_EQUALS(hitTest->GetMediaUri(), testMediaUri, TEST_LOCATION);
+ std::string testTagName("img");
+ DALI_TEST_EQUALS(hitTest->GetTagName(), testTagName, TEST_LOCATION);
+ std::string testNodeValue("test");
+ DALI_TEST_EQUALS(hitTest->GetNodeValue(), testNodeValue, TEST_LOCATION);
+ Dali::Property::Map* testMap = &hitTest->GetAttributes();
+ DALI_TEST_CHECK(testMap);
+ std::string testImageFileNameExtension("jpg");
+ DALI_TEST_EQUALS(hitTest->GetImageFileNameExtension(), testImageFileNameExtension, TEST_LOCATION);
+ Dali::PixelData testImageBuffer = hitTest->GetImageBuffer();
+ DALI_TEST_CHECK((int)testImageBuffer.GetWidth() == 2 && (int)testImageBuffer.GetHeight() == 2);
+
+ // async...
+ bool result = view.CreateHitTestAsynchronously(100, 100, Dali::WebEngineHitTest::HitTestMode::DEFAULT, &OnHitTestCreated);
+ DALI_TEST_CHECK(result);
+ Test::EmitGlobalTimerSignal();
+ DALI_TEST_EQUALS( gHitTestCreatedCallbackCalled, 1, TEST_LOCATION );
+
+ END_TEST;
+}
+
int UtcDaliWebViewEvaluteJavaScript(void)
{
ToolkitTestApplication application;
unsigned int itemCount = bfList->GetItemCount();
DALI_TEST_CHECK( itemCount == 1 )
- Dali::Toolkit::WebBackForwardListItem* citem = bfList->GetCurrentItem();
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> citem = bfList->GetCurrentItem();
DALI_TEST_CHECK( citem != 0 );
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> citemP = bfList->GetPreviousItem();
+ DALI_TEST_CHECK( citemP != 0 );
+
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> citemN = bfList->GetNextItem();
+ DALI_TEST_CHECK( citemN != 0 );
+
const std::string kDefaultUrl( "http://url" );
std::string testValue = citem->GetUrl();
DALI_TEST_EQUALS( testValue, kDefaultUrl, TEST_LOCATION );
testValue = citem->GetOriginalUrl();
DALI_TEST_EQUALS( testValue, kDefaultOriginalUrl, TEST_LOCATION );
- Dali::Toolkit::WebBackForwardListItem* item = bfList->GetItemAtIndex( 0 );
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> item = bfList->GetItemAtIndex( 0 );
DALI_TEST_CHECK( item != 0 );
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> vecBack = bfList->GetBackwardItems(-1);
+ DALI_TEST_CHECK( vecBack.size() == 1 );
+
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> vecForward = bfList->GetForwardItems(-1);
+ DALI_TEST_CHECK( vecForward.size() == 1 );
+
END_TEST;
}
END_TEST;
}
+int UtcDaliWebSettingsSetViewportMetaTag(void)
+{
+ ToolkitTestApplication application;
+
+ WebView view = WebView::New();
+ DALI_TEST_CHECK( view );
+
+ Dali::Toolkit::WebSettings* settings = view.GetSettings();
+ DALI_TEST_CHECK( settings != 0 )
+
+ // Check the value is true or not
+ bool value = settings->SetViewportMetaTag(true);
+ DALI_TEST_CHECK( value );
+
+ END_TEST;
+}
+
+int UtcDaliWebSettingsSetForceZoom(void)
+{
+ ToolkitTestApplication application;
+
+ WebView view = WebView::New();
+ DALI_TEST_CHECK( view );
+
+ Dali::Toolkit::WebSettings* settings = view.GetSettings();
+ DALI_TEST_CHECK( settings != 0 )
+
+ // Check the value is true or not
+ bool value = settings->SetForceZoom(true);
+ DALI_TEST_CHECK( value );
+
+ value = settings->IsZoomForced();
+ DALI_TEST_CHECK( value );
+
+ END_TEST;
+}
+
+int UtcDaliWebSettingsSetTextZoomEnabled(void)
+{
+ ToolkitTestApplication application;
+
+ WebView view = WebView::New();
+ DALI_TEST_CHECK( view );
+
+ Dali::Toolkit::WebSettings* settings = view.GetSettings();
+ DALI_TEST_CHECK( settings != 0 )
+
+ // Check the value is true or not
+ bool value = settings->SetTextZoomEnabled(true);
+ DALI_TEST_CHECK( value );
+
+ value = settings->IsTextZoomEnabled();
+ DALI_TEST_CHECK( value );
+
+ END_TEST;
+}
+
+int UtcDaliWebSettingsSetExtraFeature(void)
+{
+ ToolkitTestApplication application;
+
+ WebView view = WebView::New();
+ DALI_TEST_CHECK( view );
+
+ Dali::Toolkit::WebSettings* settings = view.GetSettings();
+ DALI_TEST_CHECK( settings != 0 )
+
+ // Check the value is true or not
+ settings->SetExtraFeature("test", true);
+ bool value = settings->IsExtraFeatureEnabled("test");
+ DALI_TEST_CHECK( value );
+
+ END_TEST;
+}
+
+++ /dev/null
-/*
- * Copyright (c) 2021 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 <dali-toolkit/devel-api/controls/web-view/web-back-forward-list-item.h>
-
-// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
-
-namespace Dali
-{
-namespace Toolkit
-{
-const std::string EMPTY_STRING;
-
-WebBackForwardListItem::WebBackForwardListItem(const Dali::WebEngineBackForwardListItem* item)
-: mWebEngineBackForwardListItem(item)
-{
-}
-
-WebBackForwardListItem::~WebBackForwardListItem()
-{
-}
-
-std::string WebBackForwardListItem::GetUrl() const
-{
- return mWebEngineBackForwardListItem ? mWebEngineBackForwardListItem->GetUrl() : EMPTY_STRING;
-}
-
-std::string WebBackForwardListItem::GetTitle() const
-{
- return mWebEngineBackForwardListItem ? mWebEngineBackForwardListItem->GetTitle() : EMPTY_STRING;
-}
-
-std::string WebBackForwardListItem::GetOriginalUrl() const
-{
- return mWebEngineBackForwardListItem ? mWebEngineBackForwardListItem->GetOriginalUrl() : EMPTY_STRING;
-}
-
-} // namespace Toolkit
-
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_TOOLKIT_WEB_BACK_FORWARD_LIST_ITEM_H
-#define DALI_TOOLKIT_WEB_BACK_FORWARD_LIST_ITEM_H
-
-/*
- * Copyright (c) 2021 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 <string>
-
-// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/dali-toolkit-common.h>
-
-namespace Dali
-{
-class WebEngineBackForwardListItem;
-
-namespace Toolkit
-{
-/**
- * @addtogroup dali_toolkit_controls_web_view
- * @{
- */
-
-/**
- * @brief WebBackForwardListItem is a class for back-forward list item of WebView.
- *
- *
- * For working WebBackForwardListItem, a Dali::WebBackForwardListItem should be provided.
- *
- */
-class DALI_TOOLKIT_API WebBackForwardListItem
-{
-public:
- /**
- * @brief Creates a WebBackForwardListItem.
- */
- WebBackForwardListItem(const Dali::WebEngineBackForwardListItem* item);
-
- /**
- * @brief Destructor.
- */
- virtual ~WebBackForwardListItem() final;
-
- /**
- * @brief Returns the URL of the item.
- *
- * @details The returned URL may differ from the original URL (For example,
- * if the page is redirected).
- *
- * @return The URL of the @a item, otherwise "" in case of an error
- */
- std::string GetUrl() const;
-
- /**
- * @brief Returns the title of the item.
- *
- * @return The title of the @a item, otherwise "" in case of an error
- */
- std::string GetTitle() const;
-
- /**
- * @brief Returns the original URL of the item.
- *
- * @return The original URL of the @a item, otherwise "" in case of an error
- */
- std::string GetOriginalUrl() const;
-
-private:
- const Dali::WebEngineBackForwardListItem* mWebEngineBackForwardListItem;
-};
-
-/**
- * @}
- */
-
-} // namespace Toolkit
-
-} // namespace Dali
-
-#endif // DALI_TOOLKIT_WEB_BACK_FORWARD_LIST_ITEM_H
#include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list.h>
// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list.h>
namespace Dali
{
namespace Toolkit
{
-WebBackForwardList::WebBackForwardList(const Dali::WebEngineBackForwardList& list)
-: mWebEngineBackForwardList(list),
- mWebBackForwardListItem(0)
+WebBackForwardList::WebBackForwardList(Dali::WebEngineBackForwardList& list)
+: mWebEngineBackForwardList(list)
{
}
{
}
-WebBackForwardListItem* WebBackForwardList::GetCurrentItem()
+std::unique_ptr<Dali::WebEngineBackForwardListItem> WebBackForwardList::GetCurrentItem()
{
- mWebBackForwardListItem = WebBackForwardListItem(&mWebEngineBackForwardList.GetCurrentItem());
- return &mWebBackForwardListItem;
+ return mWebEngineBackForwardList.GetCurrentItem();
}
-WebBackForwardListItem* WebBackForwardList::GetItemAtIndex(uint32_t index)
+std::unique_ptr<Dali::WebEngineBackForwardListItem> WebBackForwardList::GetPreviousItem()
{
- mWebBackForwardListItem = WebBackForwardListItem(&mWebEngineBackForwardList.GetItemAtIndex(index));
- return &mWebBackForwardListItem;
+ return mWebEngineBackForwardList.GetPreviousItem();
+}
+
+std::unique_ptr<Dali::WebEngineBackForwardListItem> WebBackForwardList::GetNextItem()
+{
+ return mWebEngineBackForwardList.GetNextItem();
+}
+
+std::unique_ptr<Dali::WebEngineBackForwardListItem> WebBackForwardList::GetItemAtIndex(uint32_t index)
+{
+ return mWebEngineBackForwardList.GetItemAtIndex(index);
}
uint32_t WebBackForwardList::GetItemCount() const
return mWebEngineBackForwardList.GetItemCount();
}
+std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> WebBackForwardList::GetBackwardItems(int limit)
+{
+ return mWebEngineBackForwardList.GetBackwardItems(limit);
+}
+
+std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> WebBackForwardList::GetForwardItems(int limit)
+{
+ return mWebEngineBackForwardList.GetForwardItems(limit);
+}
+
} // namespace Toolkit
} // namespace Dali
*
*/
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
+#include <vector>
+#include <memory>
+
// INTERNAL INCLUDES
-#include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list-item.h>
#include <dali-toolkit/public-api/dali-toolkit-common.h>
namespace Dali
/**
* @brief Creates a WebBackForwardList.
*/
- WebBackForwardList(const Dali::WebEngineBackForwardList& list);
+ WebBackForwardList(Dali::WebEngineBackForwardList& list);
/**
* @brief Destructor.
* @brief Returns the current item in the @a list.
* @return The current item in list.
*/
- WebBackForwardListItem* GetCurrentItem();
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetCurrentItem();
+
+ /**
+ * @brief Returns the previous item in the @a list.
+ * @return The previous item in list.
+ */
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetPreviousItem();
+
+ /**
+ * @brief Returns the next item in the @a list.
+ * @return The next item in list.
+ */
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetNextItem();
/**
* @brief Returns the item at a given @a index relative to the current item.
* @param[in] index The index of the item
* @return The current item in list.
*/
- WebBackForwardListItem* GetItemAtIndex(uint32_t index);
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetItemAtIndex(uint32_t index);
/**
* @brief Returns the length of the back-forward list including the current
*/
uint32_t GetItemCount() const;
+ /**
+ * @brief Creates a list containing the items preceding the current item limited
+ * by @a limit.
+ *
+ * @details The WebEngineBackForwardListItem elements are located in the result
+ list starting with the oldest one.\n
+ * If @a limit is equal to @c -1 all the items preceding the current
+ * item are returned.
+ *
+ * @param[in] limit The number of items to retrieve
+ *
+ * @return @c vector containing @c WebEngineBackForwardListItem elements,\n
+ */
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> GetBackwardItems(int limit);
+
+ /**
+ * @brief Creates the list containing the items following the current item
+ * limited by @a limit.
+ *
+ * @details The @c WebEngineBackForwardListItem elements are located in the result
+ * list starting with the oldest one.\n
+ * If @a limit is equal to @c -1 all the items preceding the current
+ * item are returned.
+ *
+ * @param[in] limit The number of items to retrieve
+ *
+ * @return @c vector containing @c WebEngineBackForwardListItem elements,\n
+ */
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> GetForwardItems(int limit);
+
private:
- const Dali::WebEngineBackForwardList& mWebEngineBackForwardList;
- Dali::Toolkit::WebBackForwardListItem mWebBackForwardListItem;
+ Dali::WebEngineBackForwardList& mWebEngineBackForwardList;
};
/**
+++ /dev/null
-/*
- * Copyright (c) 2021 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 <dali-toolkit/devel-api/controls/web-view/web-form-repost-decision.h>
-
-// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
-
-namespace Dali
-{
-namespace Toolkit
-{
-WebFormRepostDecision::WebFormRepostDecision(std::shared_ptr<Dali::WebEngineFormRepostDecision> decision)
-: mFormRepostDecision(std::move(decision))
-{
-}
-
-WebFormRepostDecision::~WebFormRepostDecision()
-{
-}
-
-void WebFormRepostDecision::Reply(bool allowed)
-{
- if(mFormRepostDecision)
- {
- mFormRepostDecision->Reply(allowed);
- }
-}
-
-} // namespace Toolkit
-
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_TOOLKIT_WEB_FORM_REPOST_DECISION_H
-#define DALI_TOOLKIT_WEB_FORM_REPOST_DECISION_H
-
-/*
- * Copyright (c) 2021 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 <memory>
-#include <string>
-
-// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/dali-toolkit-common.h>
-
-namespace Dali
-{
-class WebEngineFormRepostDecision;
-
-namespace Toolkit
-{
-/**
- * @addtogroup dali_toolkit_controls_web_view
- * @{
- */
-
-/**
- * @brief WebFormRepostDecision is a class for form repost decision of WebView.
- *
- *
- * For working WebFormRepostDecision, a Dali::WebEngineFormRepostDecision should be provided.
- *
- */
-class DALI_TOOLKIT_API WebFormRepostDecision
-{
-public:
- /**
- * @brief Creates a WebFormRepostDecision.
- */
- WebFormRepostDecision(std::shared_ptr<Dali::WebEngineFormRepostDecision> decision);
-
- /**
- * @brief Destructor.
- */
- virtual ~WebFormRepostDecision() final;
-
- /**
- * @brief Reply the result about form repost decision.
- *
- * @param[in] allowed Whether allow form repost decision request or not
- */
- void Reply(bool allowed);
-
-private:
- std::shared_ptr<Dali::WebEngineFormRepostDecision> mFormRepostDecision;
-};
-
-/**
- * @}
- */
-
-} // namespace Toolkit
-
-} // namespace Dali
-
-#endif // DALI_TOOLKIT_WEB_FORM_REPOST_DECISION_H
mWebEngineSettings.SetDefaultTextEncodingName(defaultTextEncodingName);
}
+bool WebSettings::SetViewportMetaTag(bool enable)
+{
+ return mWebEngineSettings.SetViewportMetaTag(enable);
+}
+
+bool WebSettings::SetForceZoom(bool enable)
+{
+ return mWebEngineSettings.SetForceZoom(enable);
+}
+
+bool WebSettings::IsZoomForced() const
+{
+ return mWebEngineSettings.IsZoomForced();
+}
+
+bool WebSettings::SetTextZoomEnabled(bool enable)
+{
+ return mWebEngineSettings.SetTextZoomEnabled(enable);
+}
+
+bool WebSettings::IsTextZoomEnabled() const
+{
+ return mWebEngineSettings.IsTextZoomEnabled();
+}
+
+void WebSettings::SetExtraFeature(const std::string& feature, bool enable)
+{
+ mWebEngineSettings.SetExtraFeature(feature, enable);
+}
+
+bool WebSettings::IsExtraFeatureEnabled(const std::string& feature) const
+{
+ return mWebEngineSettings.IsExtraFeatureEnabled(feature);
+}
+
+
} // namespace Toolkit
} // namespace Dali
*/
void SetDefaultTextEncodingName(const std::string& defaultTextEncodingName);
+ /**
+ * @brief Enables/disables the viewport meta tag.
+ *
+ * By default, the viewport meta tag is enabled on mobile and wearable,
+ * but it is disabled on TV.
+ *
+ * @param[in] enable @c true to enable the viewport meta tag
+ * @c false to disable
+ *
+ * @return @c true on success or @c false on failure
+ */
+ bool SetViewportMetaTag(bool enable);
+
+ /**
+ * @brief Requests setting of force zoom.
+ *
+ * @param[in] enable to force zoom
+ *
+ * @return @c true on success or @c false on failure
+ */
+ bool SetForceZoom(bool enable);
+
+ /**
+ * @brief Returns the force zoom status.
+ *
+ * @return @c true if enable force zoom or @c false.
+ */
+ bool IsZoomForced() const;
+
+ /**
+ * @brief Requests setting use of text zoom.
+ *
+ * @param[in] enable to text zoom.
+ *
+ * @return @c true on success or @c false on failure
+ */
+ bool SetTextZoomEnabled(bool enable);
+
+ /**
+ * @brief Returns whether text zoom is enabled or not.
+ *
+ * @return @c true if enable text zoom or @c false.
+ */
+ bool IsTextZoomEnabled() const;
+
+ /**
+ * @brief Requests enables/disables to the specific extra feature
+ *
+ * @param[in] feature feature name
+ * @param[in] enable @c true to enable the specific extra feature
+ * @c false to disable
+ */
+ void SetExtraFeature(const std::string& feature, bool enable);
+
+ /**
+ * @brief Returns enable/disable to the specific extra feature
+ *
+ * @param[in] feature feature name
+ *
+ * @return @c true on enable or @c false on disable
+ */
+ bool IsExtraFeatureEnabled(const std::string& feature) const;
+
private:
Dali::WebEngineSettings& mWebEngineSettings;
};
return Internal::WebView::New(locale, timezoneId);
}
-WebView WebView::New(int argc, char** argv)
+WebView WebView::New(uint32_t argc, char** argv)
{
return Internal::WebView::New(argc, argv);
}
return Dali::Toolkit::GetImpl(*this).StopInspectorServer();
}
-void WebView::ScrollBy(int deltaX, int deltaY)
+void WebView::ScrollBy(int32_t deltaX, int32_t deltaY)
{
Dali::Toolkit::GetImpl(*this).ScrollBy(deltaX, deltaY);
}
-bool WebView::ScrollEdgeBy(int deltaX, int deltaY)
+bool WebView::ScrollEdgeBy(int32_t deltaX, int32_t deltaY)
{
return Dali::Toolkit::GetImpl(*this).ScrollEdgeBy(deltaX, deltaY);
}
Dali::Toolkit::GetImpl(*this).JavaScriptPromptReply(result);
}
+std::unique_ptr<Dali::WebEngineHitTest> WebView::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
+{
+ return Dali::Toolkit::GetImpl(*this).CreateHitTest(x, y, mode);
+}
+
+bool WebView::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
+{
+ return Dali::Toolkit::GetImpl(*this).CreateHitTestAsynchronously(x, y, mode, callback);
+}
+
void WebView::ClearHistory()
{
Dali::Toolkit::GetImpl(*this).ClearHistory();
Dali::Toolkit::GetImpl(*this).AddDynamicCertificatePath(host, certPath);
}
-Dali::Toolkit::ImageView WebView::GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
+Dali::Toolkit::ImageView WebView::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
{
return Dali::Toolkit::GetImpl(*this).GetScreenshot(viewArea, scaleFactor);
}
-bool WebView::GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback)
+bool WebView::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback)
{
return Dali::Toolkit::GetImpl(*this).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
}
/**
* @brief WebView signal type related with form repost decision.
*/
- using WebViewFormRepostDecisionSignalType = Signal<void(WebView, std::shared_ptr<Dali::Toolkit::WebFormRepostDecision>)>;
+ using WebViewFormRepostDecisionSignalType = Signal<void(WebView, std::shared_ptr<Dali::WebEngineFormRepostDecision>)>;
/**
* @brief WebView signal type related with frame rendered.
public:
/**
- * @brief Creates an initialized WebView.
+ * @brief Create an initialized WebView.
* @return A handle to a newly allocated Dali WebView
*
* @note WebView will not display anything
static WebView New();
/**
- * @brief Creates an initialized WebView.
+ * @brief Create an initialized WebView.
*
* @param [in] locale The locale of Web
* @param [in] timezoneId The timezoneId of Web
static WebView New(const std::string& locale, const std::string& timezoneId);
/**
- * @brief Creates an initialized WebView.
+ * @brief Create an initialized WebView.
*
* @param [in] argc The count of arguments of Applications
* @param [in] argv The string array of arguments of Applications
*/
- static WebView New(int argc, char** argv);
+ static WebView New(uint32_t argc, char** argv);
/**
- * @brief Creates an uninitialized WebView.
+ * @brief Create an uninitialized WebView.
*/
WebView();
WebView& operator=(const WebView& WebView);
/**
- * @brief Downcasts a handle to WebView handle.
+ * @brief Downcast a handle to WebView handle.
*
* If handle points to a WebView, the downcast produces valid handle.
* If not, the returned handle is left uninitialized.
Dali::Toolkit::ImageView& GetFavicon();
/**
- * @brief Loads a web page based on a given URL.
+ * @brief Load a web page based on a given URL.
*
* @param [in] url The URL of the resource to load
*/
void LoadUrl(const std::string& url);
/**
- * @brief Loads a given string as web contents.
+ * @brief Load a given string as web contents.
*
* @param [in] htmlString The string to use as the contents of the web page
*/
bool LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl);
/**
- * @brief Requests loading the given contents by MIME type into the view object
+ * @brief Request loading the given contents by MIME type into the view object
*
* @param[in] contents The content to load
* @param[in] contentSize The size of contents (in bytes)
bool LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri);
/**
- * @brief Reloads the Web.
+ * @brief Reload the Web.
*/
void Reload();
/**
- * @brief Reloads the current page's document without cache
+ * @brief Reload the current page's document without cache
*/
bool ReloadWithoutCache();
/**
- * @brief Stops loading web contents on the current page.
+ * @brief Stop loading web contents on the current page.
*/
void StopLoading();
/**
- * @brief Suspends the operation associated with the view.
+ * @brief Suspend the operation associated with the view.
*/
void Suspend();
/**
- * @brief Resumes the operation associated with the view object after calling Suspend().
+ * @brief Resume the operation associated with the view object after calling Suspend().
*/
void Resume();
bool StopInspectorServer();
/**
- * @brief Scrolls web page of view by deltaX and deltaY.
+ * @brief Scroll web page of view by deltaX and deltaY.
* @param[in] deltaX The delta x of scroll
* @param[in] deltaY The delta y of scroll
*/
- void ScrollBy(int deltaX, int deltaY);
+ void ScrollBy(int32_t deltaX, int32_t deltaY);
/**
- * @brief Scrolls edge of view by deltaX and deltaY.
+ * @brief Scroll edge of view by deltaX and deltaY.
*
* @param[in] deltaX horizontal offset to scroll
* @param[in] deltaY vertical offset to scroll
*
* @return true if succeeded, false otherwise
*/
- bool ScrollEdgeBy(int deltaX, int deltaY);
+ bool ScrollEdgeBy(int32_t deltaX, int32_t deltaY);
/**
- * @brief Returns whether forward is possible.
+ * @brief Return whether forward is possible.
*
* @return True if forward is possible, false otherwise
*/
bool CanGoForward();
/**
- * @brief Goes forward in the navigation history.
+ * @brief Go forward in the navigation history.
*/
void GoForward();
/**
- * @brief Returns whether backward is possible.
+ * @brief Return whether backward is possible.
*
* @return True if backward is possible, false otherwise
*/
bool CanGoBack();
/**
- * @brief Goes back in the navigation history.
+ * @brief Go back in the navigation history.
*/
void GoBack();
/**
- * @brief Evaluates JavaScript code represented as a string.
+ * @brief Evaluate JavaScript code represented as a string.
*
* @param[in] script The JavaScript code
* @param[in] resultHandler The callback function to be called by the JavaScript runtime. This carries evaluation result
void EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler);
/**
- * @brief Evaluates JavaScript code represented as a string.
+ * @brief Evaluate JavaScript code represented as a string.
*
* @param[in] script The JavaScript code
*/
void JavaScriptPromptReply(const std::string& result);
/**
- * @brief Clears the history of Web.
+ * @brief Create a new hit test.
+ *
+ * @param[in] x the horizontal position to query
+ * @param[in] y the vertical position to query
+ * @param[in] mode the mode of hit test
+ *
+ * @return a new hit test object.
+ */
+ std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode);
+
+ /**
+ * @brief Create a hit test asynchronously.
+ *
+ * @param[in] x the horizontal position to query
+ * @param[in] y the vertical position to query
+ * @param[in] mode the mode of hit test
+ * @param[in] callback The callback function
+ *
+ * @return true if succeeded, false otherwise.
+ */
+ bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback);
+
+ /**
+ * @brief Clear the history of Web.
*/
void ClearHistory();
/**
- * @brief Clears all tiles resources of Web.
+ * @brief Clear all tiles resources of Web.
*/
void ClearAllTilesResources();
/**
- * @brief Scales the current page, centered at the given point.
+ * @brief Scale the current page, centered at the given point.
* @param[in] scaleFactor a new factor to be scaled.
* @param[in] point a center coordinate.
*/
void SetScaleFactor(float scaleFactor, Dali::Vector2 point);
/**
- * @brief Gets the current scale factor of the page.
+ * @brief Get the current scale factor of the page.
* @return The current scale factor.
*/
float GetScaleFactor() const;
void ActivateAccessibility(bool activated);
/**
- * @brief Searches and highlights the given string in the document.
+ * @brief Search and highlights the given string in the document.
* @param[in] text The text to find
* @param[in] options The options to find
* @param[in] maxMatchCount The maximum match count to find
*
* @return image view of screen shot
*/
- Dali::Toolkit::ImageView GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor);
+ Dali::Toolkit::ImageView GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor);
/**
* @brief Request to get snapshot of the specified viewArea of page asynchronously.
*
* @return true if requested successfully, false otherwise
*/
- bool GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, WebViewScreenshotCapturedCallback callback);
+ bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, WebViewScreenshotCapturedCallback callback);
/**
* @brief Asynchronous request to check if there is a video playing in the given view.
public: // Not intended for application developers
/// @cond internal
/**
- * @brief Creates a handle using the Toolkit::Internal implementation.
+ * @brief Create a handle using the Toolkit::Internal implementation.
*
* @param[in] implementation The WebView implementation
*/
DALI_INTERNAL WebView(Internal::WebView& implementation);
/**
- * @brief Allows the creation of this WebView from an Internal::CustomActor pointer.
+ * @brief Allow the creation of this WebView from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor
*/
${devel_api_src_dir}/controls/tool-bar/tool-bar.cpp
${devel_api_src_dir}/controls/video-view/video-view-devel.cpp
${devel_api_src_dir}/controls/web-view/web-back-forward-list.cpp
- ${devel_api_src_dir}/controls/web-view/web-back-forward-list-item.cpp
${devel_api_src_dir}/controls/web-view/web-context.cpp
${devel_api_src_dir}/controls/web-view/web-cookie-manager.cpp
- ${devel_api_src_dir}/controls/web-view/web-form-repost-decision.cpp
${devel_api_src_dir}/controls/web-view/web-settings.cpp
${devel_api_src_dir}/controls/web-view/web-view.cpp
${devel_api_src_dir}/focus-manager/keyinput-focus-manager.cpp
SET( devel_api_web_view_header_files
${devel_api_src_dir}/controls/web-view/web-back-forward-list.h
- ${devel_api_src_dir}/controls/web-view/web-back-forward-list-item.h
${devel_api_src_dir}/controls/web-view/web-context.h
${devel_api_src_dir}/controls/web-view/web-cookie-manager.h
- ${devel_api_src_dir}/controls/web-view/web-form-repost-decision.h
${devel_api_src_dir}/controls/web-view/web-settings.h
${devel_api_src_dir}/controls/web-view/web-view.h
)
/**
* @brief The radius for the rounded corners of the visual
- * @details Name "cornerRadius", type Property::FLOAT, animatable
- * @note Optional.
+ * @details Name "cornerRadius", type Property::FLOAT or Prooperty::VECTOR4, animatable
+ * @note By default, it is Vector::ZERO.
+ * @note Only Property::Vector4 can be animated.
+ * @note Radius value are used in clockwise order from top-left-corner to bottom-left-corner.
+ * When radius is Vector4(x, y, z, w)
+ * x y
+ * +--+
+ * | |
+ * +--+
+ * w z
*/
CORNER_RADIUS = OPACITY + 2,
StopObservingVisual(iter->visual);
}
- AccessibilityDeregister();
+ AccessibilityDeregister(false);
// All gesture detectors will be destroyed so no need to disconnect.
delete mStartingPinchScale;
}
}
-void Control::Impl::AccessibilityDeregister()
+void Control::Impl::AccessibilityDeregister(bool remove)
{
if(accessibilityNotificationSet)
{
+ accessibilityNotificationPosition.NotifySignal().Disconnect(&Control::Impl::PositionOrSizeChangedCallback);
+ if(remove)
+ {
+ mControlImpl.Self().RemovePropertyNotification(accessibilityNotificationPosition);
+ }
+ accessibilityNotificationPosition.Reset();
accessibilityNotificationPosition = {};
+
+ accessibilityNotificationSize.NotifySignal().Disconnect(&Control::Impl::PositionOrSizeChangedCallback);
+ if(remove)
+ {
+ mControlImpl.Self().RemovePropertyNotification(accessibilityNotificationSize);
+ }
+ accessibilityNotificationSize.Reset();
accessibilityNotificationSize = {};
+
+ accessibilityNotificationCulled.NotifySignal().Disconnect(&Control::Impl::CulledChangedCallback);
+ if(remove)
+ {
+ mControlImpl.Self().RemovePropertyNotification(accessibilityNotificationCulled);
+ }
+ accessibilityNotificationCulled.Reset();
accessibilityNotificationCulled = {};
accessibilityNotificationSet = false;
}
Dali::Accessibility::Accessible* GetAccessibilityObject();
void AccessibilityRegister();
- void AccessibilityDeregister();
+ void AccessibilityDeregister(bool remove);
std::function<std::unique_ptr<Dali::Accessibility::Accessible>(Actor)> accessibilityConstructor;
std::unique_ptr<Dali::Accessibility::Accessible> accessibilityObject;
#include <dali/devel-api/adaptor-framework/web-engine-context.h>
#include <dali/devel-api/adaptor-framework/web-engine-cookie-manager.h>
#include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
+#include <dali/devel-api/adaptor-framework/web-engine-hit-test.h>
#include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
#include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
#include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
#include <dali-toolkit/devel-api/controls/web-view/web-back-forward-list.h>
#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-form-repost-decision.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>
}
}
-WebView::WebView(int argc, char** argv)
+WebView::WebView(uint32_t argc, char** argv)
: Control(ControlBehaviour(ACTOR_BEHAVIOUR_DEFAULT | DISABLE_STYLE_CHANGE_SIGNALS)),
mUrl(),
mVisual(),
return handle;
}
-Toolkit::WebView WebView::New(int argc, char** argv)
+Toolkit::WebView WebView::New(uint32_t argc, char** argv)
{
WebView* impl = new WebView(argc, argv);
Toolkit::WebView handle = Toolkit::WebView(*impl);
return mWebEngine ? mWebEngine.StopInspectorServer() : false;
}
-void WebView::ScrollBy(int deltaX, int deltaY)
+void WebView::ScrollBy(int32_t deltaX, int32_t deltaY)
{
if(mWebEngine)
{
}
}
-bool WebView::ScrollEdgeBy(int deltaX, int deltaY)
+bool WebView::ScrollEdgeBy(int32_t deltaX, int32_t deltaY)
{
return mWebEngine ? mWebEngine.ScrollEdgeBy(deltaX, deltaY) : false;
}
}
}
+std::unique_ptr<Dali::WebEngineHitTest> WebView::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
+{
+ std::unique_ptr<Dali::WebEngineHitTest> webHitTest;
+ if(!mWebEngine)
+ {
+ return webHitTest;
+ }
+
+ return mWebEngine.CreateHitTest(x, y, mode);
+}
+
+bool WebView::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
+{
+ bool result = false;
+ if(mWebEngine)
+ {
+ result = mWebEngine.CreateHitTestAsynchronously(x, y, mode, callback);
+ }
+ return result;
+}
+
void WebView::ClearHistory()
{
if(mWebEngine)
}
}
-Dali::Toolkit::ImageView WebView::GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
+Dali::Toolkit::ImageView WebView::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
{
Dali::Toolkit::ImageView imageView;
if(mWebEngine)
return imageView;
}
-bool WebView::GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback)
+bool WebView::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback)
{
mScreenshotCapturedCallback = callback;
return mWebEngine ? mWebEngine.GetScreenshotAsynchronously(viewArea, scaleFactor, std::bind(&WebView::OnScreenshotCaptured, this, std::placeholders::_1)) : false;
Vector3 anchorPointOffSet = actorSize * (positionUsesAnchorPoint ? self.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT) : AnchorPoint::TOP_LEFT);
Vector2 screenPosition = self.GetProperty<Vector2>(Actor::Property::SCREEN_POSITION);
- Dali::Rect<int> displayArea;
+ Dali::Rect<int32_t> displayArea;
displayArea.x = screenPosition.x - anchorPointOffSet.x;
displayArea.y = screenPosition.y - anchorPointOffSet.y;
displayArea.width = actorSize.x;
{
if(!mFormRepostDecisionSignal.Empty())
{
- Dali::Toolkit::WebView handle(GetOwner());
- std::shared_ptr<Dali::Toolkit::WebFormRepostDecision> repostDecision(new Dali::Toolkit::WebFormRepostDecision(decision));
- mFormRepostDecisionSignal.Emit(handle, std::move(repostDecision));
+ Dali::Toolkit::WebView handle(GetOwner());
+ mFormRepostDecisionSignal.Emit(handle, std::move(decision));
}
}
bool WebView::OnHoverEvent(Actor actor, const Dali::HoverEvent& hover)
{
bool result = false;
- if(mWebEngine)
+ if(mWebEngine && mMouseEventsEnabled)
{
result = mWebEngine.SendHoverEvent(hover);
}
bool WebView::OnWheelEvent(Actor actor, const Dali::WheelEvent& wheel)
{
bool result = false;
- if(mWebEngine)
+ if(mWebEngine && mMouseEventsEnabled)
{
result = mWebEngine.SendWheelEvent(wheel);
}
EmitKeyInputFocusSignal(false); // Calls back into the Control hence done last.
}
-void WebView::SetScrollPosition(int x, int y)
+void WebView::SetScrollPosition(int32_t x, int32_t y)
{
if(mWebEngine)
{
WebView(const std::string& locale, const std::string& timezoneId);
- WebView(int argc, char** argv);
+ WebView(uint32_t argc, char** argv);
virtual ~WebView();
static Toolkit::WebView New(const std::string& locale, const std::string& timezoneId);
/**
- * @copydoc Dali::Toolkit::WebView::New( int, char** )
+ * @copydoc Dali::Toolkit::WebView::New( uint32_t, char** )
*/
- static Toolkit::WebView New(int argc, char** argv);
+ static Toolkit::WebView New(uint32_t argc, char** argv);
/**
- * @brief Get settings of WebEngine.
+ * @copydoc Dali::Toolkit::WebView::GetSettings()
*/
Dali::Toolkit::WebSettings* GetSettings() const;
/**
- * @brief Get context of WebEngine.
+ * @copydoc Dali::Toolkit::WebView::GetContext()
*/
Dali::Toolkit::WebContext* GetContext() const;
/**
- * @brief Get cookie manager of WebEngine.
+ * @copydoc Dali::Toolkit::WebView::GetCookieManager()
*/
Dali::Toolkit::WebCookieManager* GetCookieManager() const;
/**
- * @brief Get WebBackForwardList of WebEngine.
+ * @copydoc Dali::Toolkit::WebView::GetBackForwardList()
*/
Dali::Toolkit::WebBackForwardList* GetBackForwardList() const;
/**
- * @brief Get Favicon of web page.
- *
- * @return Handle to a fav icon
+ * @copydoc Dali::Toolkit::WebView::GetFavicon()
*/
Dali::Toolkit::ImageView& GetFavicon();
/**
* @copydoc Dali::Toolkit::WebView::ScrollBy()
*/
- void ScrollBy(int deltaX, int deltaY);
+ void ScrollBy(int32_t deltaX, int32_t deltaY);
/**
* @copydoc Dali::WebEngine::ScrollEdgeBy()
*/
- bool ScrollEdgeBy(int deltaX, int deltaY);
+ bool ScrollEdgeBy(int32_t deltaX, int32_t deltaY);
/**
* @copydoc Dali::Toolkit::WebView::CanGoForward()
void JavaScriptPromptReply(const std::string& result);
/**
+ * @copydoc Dali::Toolkit::WebView::CreateHitTest()
+ */
+ std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode);
+
+ /**
+ * @copydoc Dali::Toolkit::WebView::CreateHitTestAsynchronously()
+ */
+ bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback);
+
+ /**
* @copydoc Dali::Toolkit::WebView::ClearHistory()
*/
void ClearHistory();
/**
* @copydoc Dali::Toolkit::WebView::GetScreenshot()
*/
- Dali::Toolkit::ImageView GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor);
+ Dali::Toolkit::ImageView GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor);
/**
* @copydoc Dali::Toolkit::WebView::GetScreenshotAsynchronously()
*/
- bool GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback);
+ bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::Toolkit::WebView::WebViewScreenshotCapturedCallback callback);
/**
* @copydoc Dali::Toolkit::WebView::CheckVideoPlayingAsynchronously()
* @param[in] x The coordinate x of scroll
* @param[in] y The coordinate y of scroll
*/
- void SetScrollPosition(int x, int y);
+ void SetScrollPosition(int32_t x, int32_t y);
/**
- * @brief Gets the current scroll position of the given view.
+ * @brief Get the current scroll position of the given view.
* @param[out] x The coordinate x of scroll
* @param[out] y The coordinate y of scroll
*/
void OnUrlChanged(const std::string& url);
/**
- * Signal occurs when the Web View has been touched.
+ * @brief Signal occurs when the Web View has been touched.
* @param[in] actor The Actor Touched
* @param[in] touch The Touch Data.
* @return Whether to consume event or not.
bool OnTouchEvent(Actor actor, const Dali::TouchEvent& touch);
/**
- * Signal occurs when the Web View has been hovered.
+ * @brief Signal occurs when the Web View has been hovered.
* @param[in] actor The Actor Hovered
* @param[in] hover The Hover Data.
* @return Whether to consume event or not.
bool OnHoverEvent(Actor actor, const Dali::HoverEvent& hover);
/**
- * Signal occurs when the Web View receives wheel event.
+ * @brief Signal occurs when the Web View receives wheel event.
* @param[in] actor The Actor that receives Wheel event.
* @param[in] wheel The Wheel Data.
* @return Whether to consume event or not.
Dali::PropertyNotification mPositionUpdateNotification;
Dali::PropertyNotification mSizeUpdateNotification;
Dali::PropertyNotification mScaleUpdateNotification;
- Dali::Rect<int> mWebViewArea;
+ Dali::Rect<int32_t> mWebViewArea;
bool mVideoHoleEnabled;
bool mMouseEventsEnabled;
bool mKeyEventsEnabled;
INPUT mediump vec2 vPosition;
INPUT mediump vec2 vRectSize;
-INPUT mediump float vCornerRadius;
+INPUT mediump vec2 vOptRectSize;
+INPUT mediump vec4 vCornerRadius;
uniform lowp vec4 uColor;
uniform lowp vec3 mixColor;
void main()
{
OUT_COLOR = vec4(mixColor, 1.0) * uColor;
+ if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
+ {
+ return;
+ }
+
+ mediump float radius =
+ mix(
+ mix(vCornerRadius.x, vCornerRadius.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(vCornerRadius.w, vCornerRadius.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ );
- mediump vec2 v = abs(vPosition) - vRectSize;
- mediump float cy = vCornerRadius + blurRadius;
- mediump float cr = vCornerRadius + blurRadius;
+ mediump vec2 v = abs(vPosition) - vRectSize + radius;
+ mediump float cy = radius + blurRadius;
+ mediump float cr = radius + blurRadius;
- cy = min(cy, min(vRectSize.x, vRectSize.y));
+ cy = min(cy, min(vRectSize.x, vRectSize.y) - radius);
v = vec2(min(v.x, v.y), max(v.x, v.y));
v = v + cy;
mediump float blur = 1.0;
mediump float potential = 0.0;
- mediump float alias = min(vCornerRadius, 1.0);
- mediump float potentialMin = cy + vCornerRadius - blurRadius - alias;
- mediump float potentialMax = cy + vCornerRadius + blurRadius + alias;
+ mediump float alias = min(radius, 1.0);
+ mediump float potentialMin = cy + radius - blurRadius - alias;
+ mediump float potentialMax = cy + radius + blurRadius + alias;
// move center of circles for reduce defact
mediump float cyDiff = min(cy, 0.2 * blurRadius);
INPUT mediump vec2 aPosition;
OUTPUT mediump vec2 vPosition;
OUTPUT mediump vec2 vRectSize;
-OUTPUT mediump float vCornerRadius;
+OUTPUT mediump vec2 vOptRectSize;
+OUTPUT mediump vec4 vCornerRadius;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
uniform mediump float blurRadius;
-uniform mediump float cornerRadius;
+uniform mediump vec4 cornerRadius;
uniform mediump float cornerRadiusPolicy;
vec4 ComputeVertexPosition()
mediump float minSize = min( visualSize.x, visualSize.y );
vCornerRadius = mix( cornerRadius * minSize, cornerRadius, cornerRadiusPolicy );
vCornerRadius = min( vCornerRadius, minSize * 0.5 );
- vRectSize = visualSize / 2.0 - vec2( vCornerRadius );
+ vRectSize = visualSize / 2.0;
+ // optimize fragment shader
+ mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+ vOptRectSize = vRectSize - 0.2929 * maxRadius - 1.0 - blurRadius;
+
vPosition = aPosition * (visualSize + 2.0 * blurRadius);
return vec4( vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );
}
INPUT mediump vec2 vPosition;
INPUT mediump vec2 vRectSize;
-INPUT mediump float vCornerRadius;
+INPUT mediump vec2 vOptRectSize;
+INPUT mediump vec4 vCornerRadius;
uniform lowp vec4 uColor;
uniform lowp vec3 mixColor;
void main()
{
OUT_COLOR = vec4(mixColor, 1.0) * uColor;
- mediump vec2 diff = abs( vPosition ) - vRectSize;
- mediump float dist = length( max( diff, vec2( 0.0 ) ) ) - vCornerRadius;
- if( dist > 1.0 )
+ if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
+ {
+ return;
+ }
+ mediump float radius =
+ mix(
+ mix(vCornerRadius.x, vCornerRadius.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(vCornerRadius.w, vCornerRadius.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ );
+
+ mediump vec2 diff = abs(vPosition) - vRectSize + radius;
+ mediump float dist = length(max(diff, vec2(0.0))) - radius;
+ if(dist > 1.0)
{
OUT_COLOR.a = 0.0;
}
- else if( dist > -1.0 )
+ else if(dist > -1.0)
{
- if( min( diff.x, diff.y ) < 0.0)
+ if(min(diff.x, diff.y) < 0.0)
{
- dist += min( diff.x, diff.y ) / vCornerRadius;
+ dist += min(diff.x, diff.y) / max(radius, 1.0);
}
- OUT_COLOR.a *= 1.0 - smoothstep( -1.0, 1.0, dist );
+ OUT_COLOR.a *= 1.0 - smoothstep(-1.0, 1.0, dist);
}
}
INPUT mediump vec2 aPosition;
OUTPUT mediump vec2 vPosition;
OUTPUT mediump vec2 vRectSize;
-OUTPUT mediump float vCornerRadius;
+OUTPUT mediump vec2 vOptRectSize;
+OUTPUT mediump vec4 vCornerRadius;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-uniform mediump float cornerRadius;
+uniform mediump vec4 cornerRadius;
uniform mediump float cornerRadiusPolicy;
vec4 ComputeVertexPosition()
mediump float minSize = min( visualSize.x, visualSize.y );
vCornerRadius = mix( cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
vCornerRadius = min( vCornerRadius, minSize * 0.5 );
- vRectSize = visualSize / 2.0 - vCornerRadius;
- vCornerRadius = max( vCornerRadius, 1.0 );
+ vRectSize = visualSize / 2.0;
+ // optimize fragment shader
+ mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+ vOptRectSize = vRectSize - 0.2929 * maxRadius - 1.0;
vPosition = aPosition* visualSize;
return vec4( vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );
}
varying mediump vec2 vTexCoord;
varying mediump vec2 vPosition;
varying mediump vec2 vRectSize;
-varying mediump float vCornerRadius;
+varying mediump vec2 vOptRectSize;
+varying mediump vec4 vCornerRadius;
//Visual size and offset
uniform mediump vec2 offset;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-uniform mediump float cornerRadius;
+uniform mediump vec4 cornerRadius;
uniform mediump float cornerRadiusPolicy;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );
- vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);
- mediump float minSize = min( visualSize.x, visualSize.y );
- vCornerRadius = mix( cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
- vCornerRadius = min( vCornerRadius, minSize * 0.5 );
- vRectSize = visualSize * 0.5 - vCornerRadius;
- vCornerRadius = max( vCornerRadius, 1.0 );
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw);
+ vec2 visualOffset = mix(offset, offset/uSize.xy, offsetSizeMode.xy);
+ mediump float minSize = min(visualSize.x, visualSize.y);
+ vCornerRadius = mix(cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
+ vCornerRadius = min(vCornerRadius, minSize * 0.5);
+ vRectSize = visualSize * 0.5;
+ // Optimize fragment shader
+ mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+ vOptRectSize = vRectSize - 0.2929 * maxRadius - 1.0;
vPosition = aPosition * visualSize;
- return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );
+ return vec4((aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0);
}
void main()
varying mediump vec2 vTexCoord;
varying mediump vec2 vPosition;
varying mediump vec2 vRectSize;
-varying mediump float vCornerRadius;
+varying mediump vec2 vOptRectSize;
+varying mediump vec4 vCornerRadius;
void main()
{
gl_FragColor = texture2D( sTexture, vec2( vTexCoord.y, 0.5 ) ) * vec4(mixColor, 1.0) * uColor;
- mediump vec2 diff = abs( vPosition ) - vRectSize;
- mediump float dist = length( max( diff, vec2( 0.0 ) ) ) - vCornerRadius;
- if( dist > 1.0 )
+ if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- gl_FragColor = vec4( 0.0 );
+ return;
}
- else if( dist > -1.0 )
+ mediump float radius =
+ mix(
+ mix(vCornerRadius.x, vCornerRadius.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(vCornerRadius.w, vCornerRadius.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ );
+
+ mediump vec2 diff = abs(vPosition) - vRectSize + radius;
+ mediump float dist = length(max(diff, vec2(0.0))) - radius;
+ if(dist > 1.0)
+ {
+ gl_FragColor = vec4(0.0);
+ }
+ else if(dist > -1.0)
{
- if( min( diff.x, diff.y ) < 0.0 )
+ if(min(diff.x, diff.y) < 0.0)
{
- dist += min( diff.x, diff.y ) / vCornerRadius;
+ dist += min(diff.x, diff.y) / max(radius, 1.0);
}
- gl_FragColor *= 1.0 - smoothstep( -1.0, 1.0, dist );
+ gl_FragColor *= 1.0 - smoothstep(-1.0, 1.0, dist);
}
}
varying mediump vec2 vTexCoord;
varying mediump vec2 vPosition;
varying mediump vec2 vRectSize;
-varying mediump float vCornerRadius;
+varying mediump vec2 vOptRectSize;
+varying mediump vec4 vCornerRadius;
void main()
{
gl_FragColor = texture2D( sTexture, vec2( length(vTexCoord), 0.5 ) ) * vec4(mixColor, 1.0) * uColor;
- mediump vec2 diff = abs( vPosition ) - vRectSize;
- mediump float dist = length( max( diff, vec2( 0.0 ) ) ) - vCornerRadius;
- if( dist > 1.0 )
+ if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- gl_FragColor = vec4( 0.0 );
+ return;
}
- else if( dist > -1.0 )
+ mediump float radius =
+ mix(
+ mix(vCornerRadius.x, vCornerRadius.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(vCornerRadius.w, vCornerRadius.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ );
+
+ mediump vec2 diff = abs(vPosition) - vRectSize + radius;
+ mediump float dist = length(max(diff, vec2(0.0))) - radius;
+ if(dist > 1.0)
+ {
+ gl_FragColor = vec4(0.0);
+ }
+ else if(dist > -1.0)
{
- if( min( diff.x, diff.y ) < 0.0)
+ if(min(diff.x, diff.y) < 0.0)
{
- dist += min( diff.x, diff.y ) / vCornerRadius;
+ dist += min(diff.x, diff.y) / max(radius, 1.0);
}
- gl_FragColor *= 1.0 - smoothstep( -1.0, 1.0, dist );
+ gl_FragColor *= 1.0 - smoothstep(-1.0, 1.0, dist);
}
}
varying mediump vec2 vTexCoord;
varying mediump vec2 vPosition;
varying mediump vec2 vRectSize;
-varying mediump float vCornerRadius;
+varying mediump vec2 vOptRectSize;
+varying mediump vec4 vCornerRadius;
//Visual size and offset
uniform mediump vec2 offset;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-uniform mediump float cornerRadius;
+uniform mediump vec4 cornerRadius;
uniform mediump float cornerRadiusPolicy;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );
- vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);
- mediump float minSize = min( visualSize.x, visualSize.y );
- vCornerRadius = mix( cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
- vCornerRadius = min( vCornerRadius, minSize * 0.5 );
- vRectSize = visualSize * 0.5 - vCornerRadius;
- vCornerRadius = max( vCornerRadius, 1.0 );
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw);
+ vec2 visualOffset = mix(offset, offset/uSize.xy, offsetSizeMode.xy);
+ mediump float minSize = min(visualSize.x, visualSize.y);
+ vCornerRadius = mix(cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
+ vCornerRadius = min(vCornerRadius, minSize * 0.5);
+ vRectSize = visualSize * 0.5;
+ // Optimze fragment shader
+ mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+ vOptRectSize = vRectSize - 0.2929 * maxRadius - 1.0;
+ vCornerRadius = max(vCornerRadius, 1.0);
vPosition = aPosition * visualSize;
- return vec4( (aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );
+ return vec4((aPosition + anchorPoint)*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0);
}
void main()
INPUT mediump vec2 vTexCoord;
INPUT mediump vec2 vPosition;
INPUT mediump vec2 vRectSize;
-INPUT mediump float vCornerRadius;
+INPUT mediump vec2 vOptRectSize;
+INPUT mediump vec4 vCornerRadius;
uniform sampler2D sTexture;
uniform lowp vec4 uColor;
void main()
{
- mediump vec2 diff = abs( vPosition ) - vRectSize;
- mediump float dist = length( max( diff, vec2( 0.0 ) ) ) - vCornerRadius;
+ if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
+ {
+ OUT_COLOR = TEXTURE(sTexture, vTexCoord) * uColor * vec4(mixColor, 1.0);
+ return;
+ }
+ mediump float radius =
+ mix(
+ mix(vCornerRadius.x, vCornerRadius.y, sign(vPosition.x) * 0.5 + 0.5),
+ mix(vCornerRadius.w, vCornerRadius.z, sign(vPosition.x) * 0.5 + 0.5),
+ sign(vPosition.y) * 0.5 + 0.5
+ );
+
+ mediump vec2 diff = abs(vPosition) - vRectSize + radius;
+ mediump float dist = length(max(diff, vec2(0.0))) - radius;
mediump float opacity = 1.0;
- if( dist > 1.0 )
+ if(dist > 1.0)
{
opacity = 0.0;
}
- else if( dist > -1.0 )
+ else if(dist > -1.0)
{
- if( min( diff.x, diff.y ) < 0.0 )
+ if(min(diff.x, diff.y) < 0.0)
{
- dist += min( diff.x, diff.y ) / vCornerRadius;
+ dist += min(diff.x, diff.y) / max(radius, 1.0);
}
- opacity = 1.0 - smoothstep( -1.0, 1.0, dist );
+ opacity = 1.0 - smoothstep(-1.0, 1.0, dist);
}
- OUT_COLOR = TEXTURE( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );
+ OUT_COLOR = TEXTURE(sTexture, vTexCoord) * uColor * vec4(mixColor, 1.0);
OUT_COLOR.a *= opacity;
- OUT_COLOR.rgb *= mix( 1.0, opacity, preMultipliedAlpha );
+ OUT_COLOR.rgb *= mix(1.0, opacity, preMultipliedAlpha);
}
OUTPUT mediump vec2 vTexCoord;
OUTPUT mediump vec2 vPosition;
OUTPUT mediump vec2 vRectSize;
-OUTPUT mediump float vCornerRadius;
+OUTPUT mediump vec2 vOptRectSize;
+OUTPUT mediump vec4 vCornerRadius;
uniform highp mat4 uMvpMatrix;
uniform highp vec3 uSize;
uniform mediump vec4 offsetSizeMode;
uniform mediump vec2 origin;
uniform mediump vec2 anchorPoint;
-uniform mediump float cornerRadius;
+uniform mediump vec4 cornerRadius;
uniform mediump float cornerRadiusPolicy;
uniform mediump vec2 extraSize;
vec4 ComputeVertexPosition()
{
- vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw ) + extraSize;
- vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);
- mediump float minSize = min( visualSize.x, visualSize.y );
- vCornerRadius = mix( cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
- vCornerRadius = min( vCornerRadius, minSize * 0.5 );
- vRectSize = visualSize * 0.5 - vCornerRadius;
- vCornerRadius = max( vCornerRadius, 1.0 );
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw) + extraSize;
+ vec2 visualOffset = mix(offset, offset/uSize.xy, offsetSizeMode.xy);
+ mediump float minSize = min(visualSize.x, visualSize.y);
+ vCornerRadius = mix(cornerRadius * minSize, cornerRadius, cornerRadiusPolicy);
+ vCornerRadius = min(vCornerRadius, minSize * 0.5);
+ vRectSize = visualSize * 0.5;
+ // Optimize fragment shader
+ mediump float maxRadius = max(max(vCornerRadius.x, vCornerRadius.y), max(vCornerRadius.z, vCornerRadius.w));
+ vOptRectSize = vRectSize - 0.2929 * maxRadius - 1.0;
vPosition = aPosition* visualSize;
- return vec4( vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0 );
+ return vec4(vPosition + anchorPoint*visualSize + (visualOffset + origin)*uSize.xy, 0.0, 1.0);
}
void main()
{
gl_Position = uMvpMatrix * ComputeVertexPosition();
- vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );
+ vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5));
}
const Length numberOfCharactersInModel = logicalModel->mText.Count();
// Restrict new text to fit within Maximum characters setting.
- Length maxSizeOfNewText = std::min((impl.mMaximumNumberOfCharacters - numberOfCharactersInModel), characterCount);
+ Length temp_length = (impl.mMaximumNumberOfCharacters > numberOfCharactersInModel ? impl.mMaximumNumberOfCharacters - numberOfCharactersInModel : 0);
+ Length maxSizeOfNewText = std::min(temp_length, characterCount);
maxLengthReached = (characterCount > maxSizeOfNewText);
// The cursor position.
mTransform(),
mMixColor(Color::WHITE),
mControlSize(Vector2::ZERO),
- mCornerRadius(0.0f),
+ mCornerRadius(Vector4::ZERO),
mCornerRadiusPolicy(1.0f),
mDepthIndex(0.0f),
mMixColorIndex(Property::INVALID_INDEX),
Transform mTransform;
Vector4 mMixColor;
Size mControlSize;
- float mCornerRadius;
+ Vector4 mCornerRadius;
float mCornerRadiusPolicy;
int mDepthIndex;
Property::Index mMixColorIndex;
}
case Toolkit::DevelVisual::Property::CORNER_RADIUS:
{
- float radius;
- if(value.Get(radius))
+ if(value.GetType() == Property::VECTOR4)
{
- mImpl->mCornerRadius = radius;
+ // If CORNER_RADIUS Property is Vector4,
+ // Each values mean the radius of
+ // (top-left, top-right, bottom-right, bottom-left)
+ Vector4 radius;
+ if(value.Get(radius))
+ {
+ mImpl->mCornerRadius = radius;
+ }
+ }
+ else
+ {
+ // If CORNER_RADIUS Property is float,
+ // Every corner radius have same value
+ float radius;
+ if(value.Get(radius))
+ {
+ mImpl->mCornerRadius = Vector4(radius, radius, radius, radius);
+ }
}
break;
}
}
if(mImpl->mCornerRadiusIndex != Property::INVALID_INDEX)
{
- mImpl->mCornerRadius = mImpl->mRenderer.GetProperty<float>(mImpl->mCornerRadiusIndex);
+ 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<float>(mImpl->mCornerRadiusIndex);
+ mImpl->mCornerRadius = mImpl->mRenderer.GetProperty<Vector4>(mImpl->mCornerRadiusIndex);
}
- return !EqualsZero(mImpl->mCornerRadius) || mImpl->mNeedCornerRadius;
+ return !(mImpl->mCornerRadius == Vector4::ZERO) || mImpl->mNeedCornerRadius;
}
void Visual::Base::OnDoAction(const Property::Index actionId, const Property::Value& attributes)
{
if(Accessibility::IsUp())
{
- mImpl->AccessibilityDeregister();
+ mImpl->AccessibilityDeregister(true);
}
mImpl->OnSceneDisconnection();
}
{
const unsigned int TOOLKIT_MAJOR_VERSION = 2;
const unsigned int TOOLKIT_MINOR_VERSION = 0;
-const unsigned int TOOLKIT_MICRO_VERSION = 21;
+const unsigned int TOOLKIT_MICRO_VERSION = 22;
const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-toolkit
Summary: Dali 3D engine Toolkit
-Version: 2.0.21
+Version: 2.0.22
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff