X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fadaptor%2Fcommon%2Fadaptor-impl.cpp;h=4dc5ffc0bbdf4bcbf9a1e29f3d90ad4e80dd3a62;hb=c5016ff383d62b3e035b2d6cc5b3007041983d67;hp=629a30eb725f19c1b70db31e5e0b180dfd9f6324;hpb=371c360a9d1f5fcf0b28ab01bfcd3ab718c752dc;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/adaptor/common/adaptor-impl.cpp b/dali/internal/adaptor/common/adaptor-impl.cpp index 629a30e..4dc5ffc 100755 --- a/dali/internal/adaptor/common/adaptor-impl.cpp +++ b/dali/internal/adaptor/common/adaptor-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 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. @@ -29,7 +29,10 @@ #include #include #include +#include #include +#include +#include // INTERNAL INCLUDES #include @@ -45,14 +48,12 @@ #include #include #include -#include #include #include #include #include #include #include -#include #include #include #include @@ -81,11 +82,10 @@ namespace thread_local Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get } // unnamed namespace - -Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) { Dali::Adaptor* adaptor = new Dali::Adaptor; - Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, environmentOptions ); + Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions ); adaptor->mImpl = impl; Dali::Internal::Adaptor::AdaptorBuilder* mAdaptorBuilder = new AdaptorBuilder(); @@ -97,20 +97,18 @@ Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Con return adaptor; } -Dali::Adaptor* Adaptor::New( Dali::Window window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( Dali::Integration::SceneHolder window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) { - Any winId = window.GetNativeHandle(); - - Window& windowImpl = Dali::GetImplementation( window ); - Dali::Adaptor* adaptor = New( winId, windowImpl.GetSurface(), configuration, environmentOptions ); + Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( window ); + Dali::Adaptor* adaptor = New( window, windowImpl.GetSurface(), configuration, environmentOptions ); windowImpl.SetAdaptor( *adaptor ); return adaptor; } -Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) { Dali::Adaptor* adaptor = new Dali::Adaptor; // Public adaptor - Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, environmentOptions ); // Impl adaptor + Adaptor* impl = new Adaptor( window, *adaptor, surface, environmentOptions ); // Impl adaptor adaptor->mImpl = impl; impl->Initialize( graphicsFactory, configuration ); @@ -118,12 +116,10 @@ Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Any nativeWindow, return adaptor; } // Called second -Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Window window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) +Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Dali::Integration::SceneHolder window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions ) { - Any winId = window.GetNativeHandle(); - - Window& windowImpl = Dali::GetImplementation( window ); - Dali::Adaptor* adaptor = New( graphicsFactory, winId, windowImpl.GetSurface(), configuration, environmentOptions ); + Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( window ); + Dali::Adaptor* adaptor = New( graphicsFactory, window, windowImpl.GetSurface(), configuration, environmentOptions ); windowImpl.SetAdaptor( *adaptor ); return adaptor; } // Called first @@ -159,16 +155,18 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: mCallbackManager = CallbackManager::New(); - WindowPane defaultWindow = mWindowFrame.front(); - PositionSize size = defaultWindow.surface->GetPositionSize(); + SceneHolderPtr defaultWindow = mWindows.front(); - mGestureManager = new GestureManager(*this, Vector2(size.width, size.height), mCallbackManager, *mEnvironmentOptions); + DALI_ASSERT_DEBUG( defaultWindow->GetSurface() && "Surface not initialized" ); mGraphics = &( graphicsFactory.Create() ); mGraphics->Initialize( mEnvironmentOptions ); auto eglGraphics = static_cast( mGraphics ); // This interface is temporary until Core has been updated to match + // This will only be created once + eglGraphics->Create(); + GlImplementation& mGLES = eglGraphics->GetGlesInterface(); EglSyncImplementation& eglSyncImpl = eglGraphics->GetSyncImplementation(); @@ -176,12 +174,19 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: *mPlatformAbstraction, mGLES, eglSyncImpl, - *mGestureManager, dataRetentionPolicy , ( 0u != mEnvironmentOptions->GetRenderToFboInterval() ) ? Integration::RenderToFrameBuffer::TRUE : Integration::RenderToFrameBuffer::FALSE, mGraphics->GetDepthBufferRequired(), mGraphics->GetStencilBufferRequired() ); + defaultWindow->SetAdaptor( Get() ); + + Dali::Window window( dynamic_cast( ( &defaultWindow )->Get() ) ); + if ( window ) + { + mWindowCreatedSignal.Emit( window ); + } + const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval(); if( 0u < timeInterval ) { @@ -190,16 +195,7 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER); - mVSyncMonitor = new VSyncMonitor; - - if( defaultWindow.surface ) - { - mDisplayConnection = Dali::DisplayConnection::New( *mGraphics, defaultWindow.surface->GetSurfaceType() ); - } - else - { - mDisplayConnection = Dali::DisplayConnection::New( *mGraphics ); - } + mDisplayConnection = Dali::DisplayConnection::New( *mGraphics, defaultWindow->GetSurface()->GetSurfaceType() ); mThreadController = new ThreadController( *this, *mEnvironmentOptions ); @@ -268,14 +264,24 @@ void Adaptor::Initialize( GraphicsFactory& graphicsFactory, Dali::Configuration: { Integration::SetPanGestureMultitapSmoothingRange( mEnvironmentOptions->GetPanGestureMultitapSmoothingRange() ); } + if( mEnvironmentOptions->GetMinimumPanDistance() >= 0 ) + { + Integration::SetPanGestureMinimumDistance( mEnvironmentOptions->GetMinimumPanDistance() ); + } + if( mEnvironmentOptions->GetMinimumPanEvents() >= 0 ) + { + Integration::SetPanGestureMinimumPanEvents( mEnvironmentOptions->GetMinimumPanEvents() ); + } + if( mEnvironmentOptions->GetMinimumPinchDistance() >= 0 ) + { + Integration::SetPinchGestureMinimumDistance( mEnvironmentOptions->GetMinimumPinchDistance() ); + } // Set max texture size if( mEnvironmentOptions->GetMaxTextureSize() > 0 ) { Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() ); } - - SetupSystemInformation(); } Adaptor::~Adaptor() @@ -291,14 +297,14 @@ Adaptor::~Adaptor() (*iter)->OnDestroy(); } + // Clear out all the handles to Windows + mWindows.clear(); + delete mThreadController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit - delete mVSyncMonitor; - delete mEventHandler; delete mObjectProfiler; delete mCore; - delete mGestureManager; delete mDisplayConnection; delete mPlatformAbstraction; delete mCallbackManager; @@ -324,36 +330,26 @@ void Adaptor::Start() return; } - // Start the callback manager - mCallbackManager->Start(); + mCore->Initialize(); - WindowPane defaultWindow = mWindowFrame.front(); + SetupSystemInformation(); - // Create event handler - mEventHandler = new EventHandler( defaultWindow.surface, *this, *mGestureManager, *this, mDragAndDropDetector ); + // Start the callback manager + mCallbackManager->Start(); - if( mDeferredRotationObserver != NULL ) - { - mEventHandler->SetRotationObserver(mDeferredRotationObserver); - mDeferredRotationObserver = NULL; - } + SceneHolderPtr defaultWindow = mWindows.front(); unsigned int dpiHor, dpiVer; dpiHor = dpiVer = 0; - defaultWindow.surface->GetDpi( dpiHor, dpiVer ); - - // tell core about the DPI value - mCore->SetDpi(dpiHor, dpiVer); + defaultWindow->GetSurface()->GetDpi( dpiHor, dpiVer ); // set the DPI value for font rendering FontClient fontClient = FontClient::Get(); fontClient.SetDpi( dpiHor, dpiVer ); // Tell the core the size of the surface just before we start the render-thread - PositionSize size = defaultWindow.surface->GetPositionSize(); - - mCore->SurfaceResized( size.width, size.height ); + mCore->SurfaceResized( defaultWindow->GetSurface() ); // Initialize the thread controller mThreadController->Initialize(); @@ -381,10 +377,10 @@ void Adaptor::Pause() (*iter)->OnPause(); } - // Reset the event handler when adaptor paused - if( mEventHandler ) + // Pause all windows event handlers when adaptor paused + for( SceneHolderPtr window : mWindows ) { - mEventHandler->Pause(); + window->Pause(); } mThreadController->Pause(); @@ -392,6 +388,12 @@ void Adaptor::Pause() // Ensure any messages queued during pause callbacks are processed by doing another update. RequestUpdateOnce(); + + DALI_LOG_RELEASE_INFO( "Adaptor::Pause: Paused\n" ); + } + else + { + DALI_LOG_RELEASE_INFO( "Adaptor::Pause: Not paused [%d]\n", mState ); } } @@ -403,10 +405,10 @@ void Adaptor::Resume() { mState = RUNNING; - // Reset the event handler when adaptor resumed - if( mEventHandler ) + // Reset the event handlers when adaptor resumed + for( SceneHolderPtr window : mWindows ) { - mEventHandler->Resume(); + window->Resume(); } // Inform observers that we have resumed. @@ -420,6 +422,12 @@ void Adaptor::Resume() // Do at end to ensure our first update/render after resumption includes the processed messages as well mThreadController->Resume(); + + DALI_LOG_RELEASE_INFO( "Adaptor::Resume: Resumed\n"); + } + else + { + DALI_LOG_RELEASE_INFO( "Adaptor::Resume: Not resumed [%d]\n", mState ); } } @@ -436,13 +444,10 @@ void Adaptor::Stop() mThreadController->Stop(); - // Clear out all the handles to Windows - mWindowFrame.clear(); - // Delete the TTS player - for(int i =0; i < Dali::TtsPlayer::MODE_NUM; i++) + for( int i =0; i < Dali::TtsPlayer::MODE_NUM; i++ ) { - if(mTtsPlayers[i]) + if( mTtsPlayers[i] ) { mTtsPlayers[i].Reset(); } @@ -451,15 +456,14 @@ void Adaptor::Stop() // Destroy the image loader plugin Internal::Adaptor::ImageLoaderPluginProxy::Destroy(); - delete mEventHandler; - mEventHandler = NULL; - delete mNotificationTrigger; mNotificationTrigger = NULL; mCallbackManager->Stop(); mState = STOPPED; + + DALI_LOG_RELEASE_INFO( "Adaptor::Stop\n" ); } } @@ -478,63 +482,60 @@ void Adaptor::ContextRegained() void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp ) { - mEventHandler->FeedTouchPoint( point, timeStamp ); + Integration::Point convertedPoint( point ); + mWindows.front()->FeedTouchPoint( convertedPoint, timeStamp ); } void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent ) { - mEventHandler->FeedWheelEvent( wheelEvent ); + Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >(wheelEvent.type), wheelEvent.direction, wheelEvent.modifiers, wheelEvent.point, wheelEvent.z, wheelEvent.timeStamp ); + mWindows.front()->FeedWheelEvent( event ); } void Adaptor::FeedKeyEvent( KeyEvent& keyEvent ) { - mEventHandler->FeedKeyEvent( keyEvent ); + Integration::KeyEvent convertedEvent( keyEvent ); + mWindows.front()->FeedKeyEvent( convertedEvent ); } -void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& newSurface ) +void Adaptor::ReplaceSurface( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& newSurface ) { - PositionSize positionSize = newSurface.GetPositionSize(); - - // Let the core know the surface size has changed - mCore->SurfaceResized( positionSize.width, positionSize.height ); - - mResizedSignal.Emit( mAdaptor ); + Internal::Adaptor::SceneHolder* windowImpl = &Dali::GetImplementation( window ); + for( SceneHolderPtr windowPtr : mWindows ) + { + if( windowPtr.Get() == windowImpl ) // the window is not deleted + { + // Let the core know the surface size has changed + mCore->SurfaceResized( &newSurface ); - WindowPane newDefaultWindow; - newDefaultWindow.nativeWindow = nativeWindow; - newDefaultWindow.surface = &newSurface; + mResizedSignal.Emit( mAdaptor ); - // Must delete the old Window first before replacing it with the new one - WindowPane oldDefaultWindow = mWindowFrame.front(); - oldDefaultWindow.surface->DestroySurface(); + windowImpl->SetSurface( &newSurface ); - // Update WindowFrame - std::vector::iterator iter = mWindowFrame.begin(); - iter = mWindowFrame.insert( iter, newDefaultWindow ); + // Flush the event queue to give the update-render thread chance + // to start processing messages for new camera setup etc as soon as possible + ProcessCoreEvents(); - // Flush the event queue to give the update-render thread chance - // to start processing messages for new camera setup etc as soon as possible - ProcessCoreEvents(); - - // This method blocks until the render thread has completed the replace. - mThreadController->ReplaceSurface( newDefaultWindow.surface ); + // This method blocks until the render thread has completed the replace. + mThreadController->ReplaceSurface( &newSurface ); + break; + } + } } -RenderSurface& Adaptor::GetSurface() const +Dali::RenderSurfaceInterface& Adaptor::GetSurface() const { - WindowPane defaultWindow = mWindowFrame.front(); - return *(defaultWindow.surface); + return *mWindows.front()->GetSurface(); } void Adaptor::ReleaseSurfaceLock() { - WindowPane defaultWindow = mWindowFrame.front(); - defaultWindow.surface->ReleaseLock(); + mWindows.front()->GetSurface()->ReleaseLock(); } Dali::TtsPlayer Adaptor::GetTtsPlayer(Dali::TtsPlayer::Mode mode) { - if(!mTtsPlayers[mode]) + if( !mTtsPlayers[mode] ) { // Create the TTS player when it needed, because it can reduce launching time. mTtsPlayers[mode] = TtsPlayer::New(mode); @@ -566,31 +567,31 @@ void Adaptor::SetPreRenderCallback( CallbackBase* callback ) mThreadController->SetPreRenderCallback( callback ); } -bool Adaptor::AddWindow( Dali::Window* childWindow, const std::string& childWindowName, const std::string& childWindowClassName, const bool& childWindowMode ) +bool Adaptor::AddWindow( Dali::Integration::SceneHolder childWindow, const std::string& childWindowName, const std::string& childWindowClassName, bool childWindowMode ) { - // This is any Window that is not the main (default) one - WindowPane additionalWindow; - additionalWindow.instance = childWindow; - additionalWindow.window_name = childWindowName; - additionalWindow.class_name = childWindowClassName; - additionalWindow.window_mode = childWindowMode; + Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( childWindow ); + windowImpl.SetAdaptor( Get() ); - // Add the new Window to the Frame - the order is not important - mWindowFrame.push_back( additionalWindow ); + // Add the new Window to the container - the order is not important + mWindows.push_back( SceneHolderPtr( &windowImpl ) ); - Window& windowImpl = Dali::GetImplementation( *childWindow ); - windowImpl.SetAdaptor( Get() ); + Dali::Window window( dynamic_cast( &windowImpl ) ); + if ( window ) + { + mWindowCreatedSignal.Emit( window ); + } return true; } -bool Adaptor::RemoveWindow( Dali::Window* childWindow ) +bool Adaptor::RemoveWindow( Dali::Integration::SceneHolder* childWindow ) { - for ( WindowFrames::iterator iter = mWindowFrame.begin(); iter != mWindowFrame.end(); ++iter ) + Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( *childWindow ); + for ( WindowContainer::iterator iter = mWindows.begin(); iter != mWindows.end(); ++iter ) { - if( iter->instance == childWindow ) + if( *iter == &windowImpl ) { - mWindowFrame.erase( iter ); + mWindows.erase( iter ); return true; } } @@ -600,11 +601,25 @@ bool Adaptor::RemoveWindow( Dali::Window* childWindow ) bool Adaptor::RemoveWindow( std::string childWindowName ) { - for ( WindowFrames::iterator iter = mWindowFrame.begin(); iter != mWindowFrame.end(); ++iter ) + for ( WindowContainer::iterator iter = mWindows.begin(); iter != mWindows.end(); ++iter ) { - if( iter->window_name == childWindowName ) + if( ( *iter )->GetName() == childWindowName ) { - mWindowFrame.erase( iter ); + mWindows.erase( iter ); + return true; + } + } + + return false; +} + +bool Adaptor::RemoveWindow( Internal::Adaptor::SceneHolder* childWindow ) +{ + for ( WindowContainer::iterator iter = mWindows.begin(); iter != mWindows.end(); ++iter ) + { + if( ( *iter )->GetId() == childWindow->GetId() ) + { + mWindows.erase( iter ); return true; } } @@ -638,11 +653,6 @@ void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender ); } -void Adaptor::SetUseHardwareVSync( bool useHardware ) -{ - mVSyncMonitor->SetUseHardwareVSync( useHardware ); -} - Dali::DisplayConnection& Adaptor::GetDisplayConnectionInterface() { DALI_ASSERT_DEBUG( mDisplayConnection && "Display connection not created" ); @@ -675,22 +685,14 @@ SocketFactoryInterface& Adaptor::GetSocketFactoryInterface() return mSocketFactory; } -RenderSurface* Adaptor::GetRenderSurfaceInterface() +Dali::RenderSurfaceInterface* Adaptor::GetRenderSurfaceInterface() { - if( !mWindowFrame.empty()) + if( !mWindows.empty() ) { - WindowPane defaultWindow = mWindowFrame.front(); - return defaultWindow.surface; + return mWindows.front()->GetSurface(); } - else - { - return nullptr; - } -} -VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface() -{ - return mVSyncMonitor; + return nullptr; } TraceInterface& Adaptor::GetKernelTraceInterface() @@ -714,49 +716,17 @@ Integration::PlatformAbstraction& Adaptor::GetPlatformAbstraction() const return *mPlatformAbstraction; } -void Adaptor::SetDragAndDropDetector( DragAndDropDetectorPtr detector ) -{ - mDragAndDropDetector = detector; - - if ( mEventHandler ) - { - mEventHandler->SetDragAndDropDetector( detector ); - } -} - -void Adaptor::SetRotationObserver( RotationObserver* observer ) -{ - if( mEventHandler ) - { - mEventHandler->SetRotationObserver( observer ); - } - else if( mState == READY ) - { - // Set once event handler exists - mDeferredRotationObserver = observer; - } -} - void Adaptor::DestroyTtsPlayer(Dali::TtsPlayer::Mode mode) { - if(mTtsPlayers[mode]) + if( mTtsPlayers[mode] ) { mTtsPlayers[mode].Reset(); } } -void Adaptor::SetMinimumPinchDistance(float distance) -{ - if( mGestureManager ) - { - mGestureManager->SetMinimumPinchDistance(distance); - } -} - Any Adaptor::GetNativeWindowHandle() { - WindowPane defaultWindow = mWindowFrame.front(); - return defaultWindow.nativeWindow; + return mWindows.front()->GetNativeHandle(); } Any Adaptor::GetGraphicsDisplay() @@ -865,7 +835,7 @@ void Adaptor::RequestProcessEventsOnIdle( bool forceProcess ) void Adaptor::OnWindowShown() { - if ( PAUSED_WHILE_HIDDEN == mState ) + if( PAUSED_WHILE_HIDDEN == mState ) { // Adaptor can now be resumed mState = PAUSED; @@ -875,16 +845,51 @@ void Adaptor::OnWindowShown() // Force a render task RequestUpdateOnce(); } + else + { + DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Adaptor is not paused state.[%d]\n", mState ); + } } void Adaptor::OnWindowHidden() { - if ( RUNNING == mState ) + if( RUNNING == mState || READY == mState ) { - Pause(); + bool allWindowsHidden = true; - // Adaptor cannot be resumed until the window is shown - mState = PAUSED_WHILE_HIDDEN; + for( SceneHolderPtr window : mWindows ) + { + if ( window->IsVisible() ) + { + allWindowsHidden = false; + break; + } + } + + // Only pause the adaptor when all the windows are hidden + if( allWindowsHidden ) + { + if( mState == RUNNING ) + { + Pause(); + + // Adaptor cannot be resumed until any window is shown + mState = PAUSED_WHILE_HIDDEN; + } + else // mState is READY + { + // Pause the adaptor after the state gets RUNNING + mState = PAUSED_WHILE_INITIALIZING; + } + } + else + { + DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowHidden: Some windows are shown. Don't pause adaptor.\n" ); + } + } + else + { + DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowHidden: Adaptor is not running state.[%d]\n", mState ); } } @@ -895,15 +900,15 @@ void Adaptor::OnDamaged( const DamageArea& area ) RequestUpdate( false ); } -void Adaptor::SurfaceResizePrepare( SurfaceSize surfaceSize ) +void Adaptor::SurfaceResizePrepare( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize ) { // Let the core know the surface size has changed - mCore->SurfaceResized( surfaceSize.GetWidth(), surfaceSize.GetHeight() ); + mCore->SurfaceResized( surface ); mResizedSignal.Emit( mAdaptor ); } -void Adaptor::SurfaceResizeComplete( SurfaceSize surfaceSize ) +void Adaptor::SurfaceResizeComplete( Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize ) { // Flush the event queue to give the update-render thread chance // to start processing messages for new camera setup etc as soon as possible @@ -916,13 +921,32 @@ void Adaptor::NotifySceneCreated() { GetCore().SceneCreated(); + // Flush the event queue to give the update-render thread chance + // to start processing messages for new camera setup etc as soon as possible + ProcessCoreEvents(); + // Start thread controller after the scene has been created mThreadController->Start(); // Process after surface is created (registering to remote surface provider if required) SurfaceInitialized(); - mState = RUNNING; + if( mState != PAUSED_WHILE_INITIALIZING ) + { + mState = RUNNING; + + DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated: Adaptor is running\n" ); + } + else + { + mState = RUNNING; + + Pause(); + + mState = PAUSED_WHILE_HIDDEN; + + DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated: Adaptor is paused\n" ); + } } void Adaptor::NotifyLanguageChanged() @@ -940,6 +964,16 @@ const LogFactoryInterface& Adaptor::GetLogFactory() return *mEnvironmentOptions; } +void Adaptor::RegisterProcessor( Integration::Processor& processor ) +{ + GetCore().RegisterProcessor(processor); +} + +void Adaptor::UnregisterProcessor( Integration::Processor& processor ) +{ + GetCore().UnregisterProcessor(processor); +} + void Adaptor::RequestUpdateOnce() { if( mThreadController ) @@ -948,12 +982,6 @@ void Adaptor::RequestUpdateOnce() } } -void Adaptor::IndicatorSizeChanged(int height) -{ - // Let the core know the indicator height is changed - mCore->SetTopMargin(height); -} - bool Adaptor::ProcessCoreEventsFromIdle() { ProcessCoreEvents(); @@ -964,27 +992,57 @@ bool Adaptor::ProcessCoreEventsFromIdle() return false; } -Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions) +Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow( Dali::Actor& actor ) +{ + Dali::Integration::Scene scene = Dali::Integration::Scene::Get( actor ); + + for( auto window : mWindows ) + { + if ( scene == window->GetScene() ) + { + return window.Get(); + } + } + + return nullptr; +} + +Dali::WindowContainer Adaptor::GetWindows() const +{ + Dali::WindowContainer windows; + + for ( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter ) + { + // Downcast to Dali::Window + Dali::Window window( dynamic_cast( iter->Get() ) ); + if ( window ) + { + windows.push_back( window ); + } + } + + return windows; +} + +Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions) : mResizedSignal(), mLanguageChangedSignal(), + mWindowCreatedSignal(), mAdaptor( adaptor ), mState( READY ), mCore( nullptr ), mThreadController( nullptr ), - mVSyncMonitor( nullptr ), + mGraphics( nullptr ), mDisplayConnection( nullptr ), + mWindows(), mPlatformAbstraction( nullptr ), - mEventHandler( nullptr ), mCallbackManager( nullptr ), mNotificationOnIdleInstalled( false ), mNotificationTrigger( nullptr ), - mGestureManager( nullptr ), mDaliFeedbackPlugin(), mFeedbackController( nullptr ), mTtsPlayers(), mObservers(), - mDragAndDropDetector(), - mDeferredRotationObserver( nullptr ), mEnvironmentOptions( environmentOptions ? environmentOptions : new EnvironmentOptions /* Create the options if not provided */), mPerformanceInterface( nullptr ), mKernelTracer(), @@ -996,13 +1054,7 @@ Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surfac mUseRemoteSurface( false ) { DALI_ASSERT_ALWAYS( !IsAvailable() && "Cannot create more than one Adaptor per thread" ); - - WindowPane defaultWindow; - defaultWindow.nativeWindow = nativeWindow; - defaultWindow.surface = surface; - - std::vector::iterator iter = mWindowFrame.begin(); - iter = mWindowFrame.insert( iter, defaultWindow ); + mWindows.insert( mWindows.begin(), SceneHolderPtr( &Dali::GetImplementation( window ) ) ); gThreadLocalAdaptor = this; }