#include "toolkit-timer.h"
#include <dali/devel-api/adaptor-framework/web-engine.h>
+#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list.h>
+#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
+#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-frame.h>
+#include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
+#include <dali/devel-api/adaptor-framework/web-engine-settings.h>
+#include <dali/public-api/adaptor-framework/native-image-source.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/adaptor-framework/native-image-source.h>
#include <toolkit-application.h>
namespace Dali
namespace
{
-static WebEngine* gInstance = NULL;
+
+// Generally only one WebEngine instance exists.
+// If > 1, a new web engine has been created by NewWindowCreated callback.
+static WebEngine* gInstance = nullptr;
static int gInstanceCount = 0;
bool OnGoBack();
bool OnLoadUrl();
bool OnEvaluteJavaScript();
bool OnClearHistory();
+bool OnPlainTextReceived();
static void ConnectToGlobalSignal( bool (*func)() )
{
}
}
+class MockWebEngineContext : public Dali::WebEngineContext
+{
+public:
+ MockWebEngineContext()
+ : mockModel( Dali::WebEngineContext::CacheModel::DOCUMENT_VIEWER )
+ {
+ }
+
+ Dali::WebEngineContext::CacheModel GetCacheModel() const override
+ {
+ return mockModel;
+ }
+
+ void SetCacheModel( Dali::WebEngineContext::CacheModel cacheModel ) override
+ {
+ mockModel = cacheModel;
+ }
+
+ void SetProxyUri( const std::string& uri ) override
+ {
+ }
+
+ void SetDefaultProxyAuth( const std::string& username, const std::string& password ) override
+ {
+ }
+
+ void SetCertificateFilePath( const std::string& certificatePath ) override
+ {
+ }
+
+ void DeleteWebDatabase() override
+ {
+ }
+
+ void DeleteWebStorage() override
+ {
+ }
+
+ void DeleteLocalFileSystem() override
+ {
+ }
+
+ void DisableCache( bool cacheDisabled ) override
+ {
+ }
+
+ void ClearCache() override
+ {
+ }
+
+private:
+ Dali::WebEngineContext::CacheModel mockModel;
+};
+
+class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
+{
+public:
+ MockWebEngineCookieManager()
+ : mockCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy::NO_THIRD_PARTY )
+ {
+ }
+
+ void SetCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy policy ) override
+ {
+ mockCookieAcceptPolicy = policy;
+ }
+
+ Dali::WebEngineCookieManager::CookieAcceptPolicy GetCookieAcceptPolicy() const override
+ {
+ return mockCookieAcceptPolicy;
+ }
+
+ void ClearCookies() override
+ {
+ }
+
+ void SetPersistentStorage( const std::string& path, Dali::WebEngineCookieManager::CookiePersistentStorage storage ) override
+ {
+ }
+
+private:
+ Dali::WebEngineCookieManager::CookieAcceptPolicy mockCookieAcceptPolicy;
+};
+
+class MockWebEngineBackForwardListItem : public Dali::WebEngineBackForwardListItem
+{
+public:
+ MockWebEngineBackForwardListItem()
+ : mockUrl( "http://url" ),
+ mockTitle( "title" ),
+ mockOriginalUrl( "http://originalurl" )
+ {
+ }
+
+ std::string GetUrl() const override
+ {
+ return mockUrl;
+ }
+
+ std::string GetTitle() const override
+ {
+ return mockTitle;
+ }
+
+ std::string GetOriginalUrl() const override
+ {
+ return mockOriginalUrl;
+ }
+
+private:
+ std::string mockUrl;
+ std::string mockTitle;
+ std::string mockOriginalUrl;
+};
+
+class MockWebEngineBackForwardList : public Dali::WebEngineBackForwardList
+{
+public:
+ MockWebEngineBackForwardList( )
+ : mockItem(),
+ pMockItem( &mockItem )
+ {
+ }
+
+ Dali::WebEngineBackForwardListItem& GetCurrentItem() const override
+ {
+ return *pMockItem;
+ }
+
+ Dali::WebEngineBackForwardListItem& GetItemAtIndex( uint32_t index ) const override
+ {
+ return *pMockItem;
+ }
+
+ uint32_t GetItemCount() const override
+ {
+ return 1;
+ }
+
+private:
+ MockWebEngineBackForwardListItem mockItem;
+ WebEngineBackForwardListItem* pMockItem;
+};
+
+class MockWebEngineFrame : public Dali::WebEngineFrame
+{
+public:
+ MockWebEngineFrame()
+ {
+ }
+
+ bool IsMainFrame() const override
+ {
+ return true;
+ }
+};
+
+class MockWebEnginePolicyDecision : public Dali::WebEnginePolicyDecision
+{
+public:
+ MockWebEnginePolicyDecision()
+ {
+ }
+
+ std::string GetUrl() const override
+ {
+ return "http://test.html";
+ }
+
+ std::string GetCookie() const override
+ {
+ return "test:abc";
+ }
+
+ Dali::WebEnginePolicyDecision::DecisionType GetDecisionType() const
+ {
+ return Dali::WebEnginePolicyDecision::DecisionType::USE;
+ }
+
+ std::string GetResponseMime() const
+ {
+ return "txt/xml";
+ }
+
+ int32_t GetResponseStatusCode() const
+ {
+ return 500;
+ }
+
+ Dali::WebEnginePolicyDecision::NavigationType GetNavigationType() const
+ {
+ return Dali::WebEnginePolicyDecision::NavigationType::LINK_CLICKED;
+ }
+
+ Dali::WebEngineFrame& GetFrame() const
+ {
+ return *(Dali::WebEngineFrame*)(&mockWebFrame);
+ }
+
+ std::string GetScheme() const
+ {
+ return "test";
+ }
+
+ bool Use()
+ {
+ return true;
+ }
+
+ bool Ignore()
+ {
+ return true;
+ }
+
+ bool Suspend()
+ {
+ return true;
+ }
+
+private:
+ MockWebEngineFrame mockWebFrame;
+};
+
+class MockWebEngineSettings : public WebEngineSettings
+{
+public:
+ MockWebEngineSettings()
+ : mockDefaultFontSize( 16 ),
+ mockJavaScriptEnabled( true ),
+ mockImageLoadedAutomatically( true ),
+ mockDefaultTextEncodingName()
+ {
+ }
+
+ uint32_t GetDefaultFontSize() const override
+ {
+ return mockDefaultFontSize;
+ }
+
+ void SetDefaultFontSize( uint32_t size ) override
+ {
+ mockDefaultFontSize = size;
+ }
+
+ bool IsJavaScriptEnabled() const override
+ {
+ return mockJavaScriptEnabled;
+ }
+
+ void EnableJavaScript( bool enabled ) override
+ {
+ mockJavaScriptEnabled = enabled;
+ }
+
+ bool AreImagesLoadedAutomatically() const override
+ {
+ return mockImageLoadedAutomatically;
+ }
+
+ void AllowImagesLoadAutomatically( bool automatic ) override
+ {
+ mockImageLoadedAutomatically = automatic;
+ }
+
+ std::string GetDefaultTextEncodingName() const override
+ {
+ return mockDefaultTextEncodingName;
+ }
+
+ void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName ) override
+ {
+ mockDefaultTextEncodingName = defaultTextEncodingName;
+ }
+
+ void AllowMixedContents( bool allowed ) override
+ {
+ }
+
+ void EnableSpatialNavigation( bool enabled ) override
+ {
+ }
+
+ void EnableWebSecurity( bool enabled ) override
+ {
+ }
+
+ void AllowFileAccessFromExternalUrl( bool allowed ) override
+ {
+ }
+
+ void AllowScriptsOpenWindows( bool allowed ) override
+ {
+ }
+
+private:
+ int mockDefaultFontSize;
+ bool mockJavaScriptEnabled;
+ bool mockImageLoadedAutomatically;
+ std::string mockDefaultTextEncodingName;
+};
+
class WebEngine: public Dali::BaseObject
{
public:
WebEngine()
: mUrl()
, mCurrentPlusOnePos( 0 )
- , mCacheModel( Dali::WebEnginePlugin::CacheModel::DOCUMENT_VIEWER )
- , mCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy::NO_THIRD_PARTY )
, mUserAgent()
- , mEnableJavaScript( true )
- , mLoadImagesAutomatically( true )
- , mDefaultTextEncodingName()
- , mDefaultFontSize( 16 )
, mEvaluating( false )
+ , mScrollPosition( 0, 0 )
+ , mScrollSize( 500, 500 )
+ , mContentSize( 500, 500 )
{
gInstanceCount++;
- gInstance = this;
+ if (gInstanceCount == 1) // only first web engine need be saved.
+ {
+ gInstance = this;
+ }
+
+ mockWebEngineSettings = new MockWebEngineSettings();
+ mockWebEngineContext = new MockWebEngineContext();
+ mockWebEngineCookieManager = new MockWebEngineCookieManager();
+ mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
}
virtual ~WebEngine()
{
gInstanceCount--;
- if( !gInstanceCount )
+ if(!gInstanceCount)
{
- gInstance = NULL;
+ gInstance = nullptr;
}
+
+ delete mockWebEngineSettings;
+ delete mockWebEngineContext;
+ delete mockWebEngineCookieManager;
+ delete mockWebEngineBackForwardList;
+ }
+
+ Dali::WebEngineSettings& GetSettings() const
+ {
+ return *mockWebEngineSettings;
+ }
+
+ Dali::WebEngineContext& GetContext() const
+ {
+ return *mockWebEngineContext;
+ }
+
+ Dali::WebEngineCookieManager& GetCookieManager() const
+ {
+ return *mockWebEngineCookieManager;
+ }
+
+ Dali::WebEngineBackForwardList& GetBackForwardList() const
+ {
+ return *mockWebEngineBackForwardList;
+ }
+
+ Dali::WebEnginePlugin* GetPlugin() const
+ {
+ return nullptr;
}
void LoadUrl( const std::string& url )
return mUrl;
}
+ std::string GetTitle() const
+ {
+ return std::string("title");
+ }
+
+ Dali::PixelData GetFavicon() const
+ {
+ uint8_t* faviconData = new uint8_t[ 16 ];
+
+ faviconData[ 0 ] = 0xff;
+ faviconData[ 1 ] = 0x00;
+ faviconData[ 2 ] = 0x00;
+ faviconData[ 3 ] = 0xff;
+ faviconData[ 4 ] = 0xff;
+ faviconData[ 5 ] = 0x00;
+ faviconData[ 6 ] = 0x00;
+ faviconData[ 7 ] = 0xff;
+ faviconData[ 8 ] = 0xff;
+ faviconData[ 9 ] = 0x00;
+ faviconData[ 10 ] = 0x00;
+ faviconData[ 11 ] = 0xff;
+ faviconData[ 12 ] = 0xff;
+ faviconData[ 13 ] = 0x00;
+ faviconData[ 14 ] = 0x00;
+ faviconData[ 15 ] = 0xff;
+
+ return Dali::PixelData::New( faviconData, 16, 2, 2,
+ Dali::Pixel::Format::RGBA8888,
+ Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
+ }
+
bool CanGoForward() const
{
return mHistory.size() > mCurrentPlusOnePos;
ConnectToGlobalSignal( &OnGoBack );
}
- void EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
+ void EvaluateJavaScript( const std::string& script, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback resultHandler )
{
if( resultHandler )
{
ConnectToGlobalSignal( &OnClearHistory );
}
- Dali::WebEnginePlugin::CacheModel GetCacheModel() const
- {
- return mCacheModel;
- }
-
- void SetCacheModel( Dali::WebEnginePlugin::CacheModel cacheModel )
- {
- mCacheModel = cacheModel;
- }
-
- Dali::WebEnginePlugin::CookieAcceptPolicy GetCookieAcceptPolicy() const
+ const std::string& GetUserAgent() const
{
- return mCookieAcceptPolicy;
+ return mUserAgent;
}
- void SetCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy policy )
+ void SetUserAgent( const std::string& userAgent )
{
- mCookieAcceptPolicy = policy;
+ mUserAgent = userAgent;
}
- const std::string& GetUserAgent() const
+ void ScrollBy( int dx, int dy )
{
- return mUserAgent;
+ mScrollPosition += Dali::Vector2( dx, dy );
+ if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
+ {
+ gInstance->mScrollEdgeReachedCallback( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
+ }
}
- void SetUserAgent( const std::string& userAgent )
+ void SetScrollPosition( int x, int y )
{
- mUserAgent = userAgent;
+ mScrollPosition.x = x;
+ mScrollPosition.y = y;
}
- bool IsJavaScriptEnabled() const
+ void GetScrollPosition( int& x, int& y ) const
{
- return mEnableJavaScript;
+ x = mScrollPosition.x;
+ y = mScrollPosition.y;
}
- void EnableJavaScript( bool enabled )
+ void GetScrollSize( int& w, int& h ) const
{
- mEnableJavaScript = enabled;
+ w = mScrollSize.width;
+ h = mScrollSize.height;
}
- bool AreImagesAutomaticallyLoaded() const
+ void GetContentSize( int& w, int& h ) const
{
- return mLoadImagesAutomatically;
+ w = mContentSize.width;
+ h = mContentSize.height;
}
- void LoadImagesAutomatically( bool automatic )
+ void RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- mLoadImagesAutomatically = automatic;
+ mPageLoadStartedCallback = callback;
}
- const std::string& GetDefaultTextEncodingName() const
+ void RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return mDefaultTextEncodingName;
+ mPageLoadFinishedCallback = callback;
}
- void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName )
+ void RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
{
- mDefaultTextEncodingName = defaultTextEncodingName;
+ mPageLoadErrorCallback = callback;
}
- int GetDefaultFontSize() const
+ void RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
{
- return mDefaultFontSize;
+ mScrollEdgeReachedCallback = callback;
}
- void SetDefaultFontSize( int defaultFontSize )
+ void RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
{
- mDefaultFontSize = defaultFontSize;
+ mUrlChangedCallback = callback;
}
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadStartedSignal()
+ void RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
{
- return mPageLoadStartedSignal;
+ mNavigationPolicyDecisionCallback = callback;
}
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadFinishedSignal()
+ void RegisterNewWindowCreatedCallback(Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback callback)
{
- return mPageLoadFinishedSignal;
+ mNewWindowCreatedCallback = callback;
}
- Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& PageLoadErrorSignal()
+ void GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
{
- return mPageLoadErrorSignal;
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnPlainTextReceived);
+ mPlainTextReceivedCallback = callback;
+ }
}
std::string mUrl;
std::vector< std::string > mHistory;
size_t mCurrentPlusOnePos;
- Dali::WebEnginePlugin::CacheModel mCacheModel;
- Dali::WebEnginePlugin::CookieAcceptPolicy mCookieAcceptPolicy;
std::string mUserAgent;
- bool mEnableJavaScript;
- bool mLoadImagesAutomatically;
- std::string mDefaultTextEncodingName;
- int mDefaultFontSize;
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType mPageLoadStartedSignal;
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType mPageLoadFinishedSignal;
- Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType mPageLoadErrorSignal;
- std::vector< std::function< void( const std::string& ) > > mResultCallbacks;
- bool mEvaluating;
+
+ Dali::WebEnginePlugin::WebEnginePageLoadCallback mPageLoadStartedCallback;
+ Dali::WebEnginePlugin::WebEnginePageLoadCallback mPageLoadFinishedCallback;
+ Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback mPageLoadErrorCallback;
+ Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback mScrollEdgeReachedCallback;
+ Dali::WebEnginePlugin::WebEngineUrlChangedCallback mUrlChangedCallback;
+ Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback mNavigationPolicyDecisionCallback;
+ Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback mNewWindowCreatedCallback;
+
+ std::vector<Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback> mResultCallbacks;
+ bool mEvaluating;
+
+ Dali::Vector2 mScrollPosition;
+ Dali::Vector2 mScrollSize;
+ Dali::Vector2 mContentSize;
+ WebEngineBackForwardList* mockWebEngineBackForwardList;
+ WebEngineContext* mockWebEngineContext;
+ WebEngineCookieManager* mockWebEngineCookieManager;
+ WebEngineSettings* mockWebEngineSettings;
+ Dali::WebEnginePlugin::PlainTextReceivedCallback mPlainTextReceivedCallback;
};
inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
}
gInstance->mHistory.push_back( gInstance->mUrl );
gInstance->mCurrentPlusOnePos++;
- gInstance->mPageLoadStartedSignal.Emit( gInstance->mUrl );
- gInstance->mPageLoadFinishedSignal.Emit( gInstance->mUrl );
+ if (gInstance->mPageLoadStartedCallback)
+ {
+ gInstance->mPageLoadStartedCallback( gInstance->mUrl );
+ }
+ if (gInstance->mPageLoadFinishedCallback)
+ {
+ gInstance->mPageLoadFinishedCallback( gInstance->mUrl );
+ }
+ if (gInstance->mPageLoadErrorCallback)
+ {
+ gInstance->mPageLoadErrorCallback(gInstance->mUrl, WebView::LoadErrorCode::UNKNOWN);
+ }
+ if (gInstance->mUrlChangedCallback)
+ {
+ gInstance->mUrlChangedCallback("http://new-test");
+ }
+ if (gInstance->mNavigationPolicyDecisionCallback)
+ {
+ std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
+ gInstance->mNavigationPolicyDecisionCallback(std::move(policyDecision));
+ }
+ if (gInstance->mNewWindowCreatedCallback)
+ {
+ Dali::WebEnginePlugin* plugin = 0;
+ gInstance->mNewWindowCreatedCallback(plugin);
+ }
}
return false;
}
}
return false;
}
+
+bool OnPlainTextReceived()
+{
+ DisconnectFromGlobalSignal(&OnPlainTextReceived);
+ if (gInstance)
+ {
+ std::string dummyResultText;
+ gInstance->mPlainTextReceivedCallback(dummyResultText);
+ }
+ return false;
+}
+
} // namespace
} // namespace Adaptor
{
}
+void WebEngine::Create( int width, int height, int argc, char** argv )
+{
+}
+
void WebEngine::Destroy()
{
}
+WebEngineSettings& WebEngine::GetSettings() const
+{
+ return Internal::Adaptor::GetImplementation( *this ).GetSettings();
+}
+
+WebEngineContext& WebEngine::GetContext() const
+{
+ return Internal::Adaptor::GetImplementation( *this ).GetContext();
+}
+
+WebEngineCookieManager& WebEngine::GetCookieManager() const
+{
+ return Internal::Adaptor::GetImplementation( *this ).GetCookieManager();
+}
+
+WebEngineBackForwardList& WebEngine::GetBackForwardList() const
+{
+ return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
+}
+
void WebEngine::LoadUrl( const std::string& url )
{
return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
}
+std::string WebEngine::GetTitle() const
+{
+ return Internal::Adaptor::GetImplementation( *this ).GetTitle();
+}
+
+Dali::PixelData WebEngine::GetFavicon() const
+{
+ return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
+}
+
const std::string& WebEngine::GetUrl()
{
return Internal::Adaptor::GetImplementation( *this ).GetUrl();
return sourcePtr;
}
-void WebEngine::LoadHTMLString( const std::string& htmlString )
+void WebEngine::LoadHtmlString( const std::string& htmlString )
{
}
Internal::Adaptor::GetImplementation( *this ).GoBack();
}
-void WebEngine::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
+void WebEngine::EvaluateJavaScript( const std::string& script, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback resultHandler )
{
Internal::Adaptor::GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
}
-void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void(const std::string&) > handler )
+void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback handler )
+{
+}
+
+void WebEngine::ClearAllTilesResources()
{
}
Internal::Adaptor::GetImplementation( *this ).ClearHistory();
}
-void WebEngine::ClearCache()
+const std::string& WebEngine::GetUserAgent() const
{
+ return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
}
-void WebEngine::ClearCookies()
+void WebEngine::SetUserAgent( const std::string& userAgent )
{
+ Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
}
-Dali::WebEnginePlugin::CacheModel WebEngine::GetCacheModel() const
+void WebEngine::ScrollBy( int dx, int dy )
{
- return Internal::Adaptor::GetImplementation( *this ).GetCacheModel();
+ Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
}
-void WebEngine::SetCacheModel( Dali::WebEnginePlugin::CacheModel cacheModel )
+void WebEngine::SetScrollPosition( int x, int y )
{
- Internal::Adaptor::GetImplementation( *this ).SetCacheModel( cacheModel );
+ Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
}
-Dali::WebEnginePlugin::CookieAcceptPolicy WebEngine::GetCookieAcceptPolicy() const
+void WebEngine::GetScrollPosition( int& x, int& y ) const
{
- return Internal::Adaptor::GetImplementation( *this ).GetCookieAcceptPolicy();
+ Internal::Adaptor::GetImplementation( *this ).GetScrollPosition( x, y );
}
-void WebEngine::SetCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy policy )
+void WebEngine::GetScrollSize( int& w, int& h ) const
{
- Internal::Adaptor::GetImplementation( *this ).SetCookieAcceptPolicy( policy );
+ Internal::Adaptor::GetImplementation( *this ).GetScrollSize( w, h );
}
-const std::string& WebEngine::GetUserAgent() const
+void WebEngine::GetContentSize( int& w, int& h ) const
{
- return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
+ Internal::Adaptor::GetImplementation( *this ).GetContentSize( w, h );
}
-void WebEngine::SetUserAgent( const std::string& userAgent )
+void WebEngine::SetSize( int width, int height )
{
- Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
}
-bool WebEngine::IsJavaScriptEnabled() const
+bool WebEngine::SendTouchEvent( const TouchEvent& touch )
{
- return Internal::Adaptor::GetImplementation( *this ).IsJavaScriptEnabled();
+ return true;
}
-void WebEngine::EnableJavaScript( bool enabled )
+bool WebEngine::SendKeyEvent( const KeyEvent& event )
{
- Internal::Adaptor::GetImplementation( *this ).EnableJavaScript( enabled );
+ return true;
}
-bool WebEngine::AreImagesAutomaticallyLoaded() const
+void WebEngine::SetFocus( bool focused )
{
- return Internal::Adaptor::GetImplementation( *this ).AreImagesAutomaticallyLoaded();
}
-void WebEngine::LoadImagesAutomatically( bool automatic )
+void WebEngine::UpdateDisplayArea( Dali::Rect< int > displayArea )
{
- Internal::Adaptor::GetImplementation( *this ).LoadImagesAutomatically( automatic );
}
-const std::string& WebEngine::GetDefaultTextEncodingName() const
+void WebEngine::EnableVideoHole( bool enabled )
{
- return Internal::Adaptor::GetImplementation( *this ).GetDefaultTextEncodingName();
}
-void WebEngine::SetDefaultTextEncodingName( const std::string& defaultTextEncodingName )
+void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- Internal::Adaptor::GetImplementation( *this ).SetDefaultTextEncodingName( defaultTextEncodingName );
+ Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadStartedCallback(callback);
}
-int WebEngine::GetDefaultFontSize() const
+void WebEngine::RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).GetDefaultFontSize();
+ Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadFinishedCallback(callback);
}
-void WebEngine::SetDefaultFontSize( int defaultFontSize )
+void WebEngine::RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
{
- Internal::Adaptor::GetImplementation( *this ).SetDefaultFontSize( defaultFontSize );
+ Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadErrorCallback(callback);
}
-void WebEngine::SetSize( int width, int height )
+void WebEngine::RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
{
+ Internal::Adaptor::GetImplementation(*this).RegisterScrollEdgeReachedCallback(callback);
}
-bool WebEngine::SendTouchEvent( const TouchEvent& touch )
+void WebEngine::RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
{
- return true;
+ Internal::Adaptor::GetImplementation(*this).RegisterUrlChangedCallback(callback);
}
-bool WebEngine::SendKeyEvent( const KeyEvent& event )
+void WebEngine::RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
{
- return true;
+ Internal::Adaptor::GetImplementation(*this).RegisterNavigationPolicyDecidedCallback(callback);
}
-Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadStartedSignal()
+void WebEngine::RegisterNewWindowCreatedCallback(Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).PageLoadStartedSignal();
+ Internal::Adaptor::GetImplementation(*this).RegisterNewWindowCreatedCallback(callback);
}
-Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadFinishedSignal()
+void WebEngine::RegisterFrameRenderedCallback(Dali::WebEnginePlugin::WebEngineFrameRenderedCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).PageLoadFinishedSignal();
+ // NOT IMPLEMENTED...
}
-Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& WebEngine::PageLoadErrorSignal()
+void WebEngine::GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).PageLoadErrorSignal();
+ Internal::Adaptor::GetImplementation(*this).GetPlainTextAsynchronously(callback);
}
} // namespace Dali;
projects / platform / core / uifw / dali-toolkit.git / blobdiff