#include <dali/integration-api/context-notifier.h>
#include <dali/integration-api/profiling.h>
#include <dali/integration-api/input-options.h>
+#include <dali/integration-api/events/key-event-integ.h>
#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
#include <dali/integration-api/processor-interface.h>
// INTERNAL INCLUDES
#include <dali/internal/graphics/gles/egl-sync-implementation.h>
#include <dali/internal/graphics/common/egl-image-extensions.h>
#include <dali/internal/clipboard/common/clipboard-impl.h>
-#include <dali/internal/graphics/common/vsync-monitor.h>
#include <dali/internal/system/common/object-profiler.h>
#include <dali/internal/window-system/common/display-connection.h>
#include <dali/internal/window-system/common/window-impl.h>
defaultWindow->SetAdaptor( Get() );
+ Dali::Window window( dynamic_cast<Dali::Internal::Adaptor::Window*>( ( &defaultWindow )->Get() ) );
+ if ( window )
+ {
+ mWindowCreatedSignal.Emit( window );
+ }
+
const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval();
if( 0u < timeInterval )
{
mNotificationTrigger = mTriggerEventFactory.CreateTriggerEvent( MakeCallback( this, &Adaptor::ProcessCoreEvents ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER);
- mVSyncMonitor = new VSyncMonitor;
-
mDisplayConnection = Dali::DisplayConnection::New( *mGraphics, defaultWindow->GetSurface()->GetSurfaceType() );
mThreadController = new ThreadController( *this, *mEnvironmentOptions );
mWindows.clear();
delete mThreadController; // this will shutdown render thread, which will call Core::ContextDestroyed before exit
- delete mVSyncMonitor;
delete mObjectProfiler;
delete mCore;
void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp )
{
- mWindows.front()->FeedTouchPoint( point, timeStamp );
+ Integration::Point convertedPoint( point );
+ mWindows.front()->FeedTouchPoint( convertedPoint, timeStamp );
}
void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent )
{
- mWindows.front()->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 )
{
- mWindows.front()->FeedKeyEvent( keyEvent );
+ Integration::KeyEvent convertedEvent( keyEvent );
+ mWindows.front()->FeedKeyEvent( convertedEvent );
}
void Adaptor::ReplaceSurface( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& newSurface )
mThreadController->SetPreRenderCallback( callback );
}
-bool Adaptor::AddWindow( Dali::Integration::SceneHolder* 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 )
{
- Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( *childWindow );
+ Internal::Adaptor::SceneHolder& windowImpl = Dali::GetImplementation( childWindow );
windowImpl.SetAdaptor( Get() );
// Add the new Window to the container - the order is not important
mWindows.push_back( SceneHolderPtr( &windowImpl ) );
+
+ Dali::Window window( dynamic_cast<Dali::Internal::Adaptor::Window*>( &windowImpl ) );
+ if ( window )
+ {
+ mWindowCreatedSignal.Emit( window );
+ }
+
return true;
}
mThreadController->SetRenderRefreshRate( numberOfVSyncsPerRender );
}
-void Adaptor::SetUseHardwareVSync( bool useHardware )
-{
- mVSyncMonitor->SetUseHardwareVSync( useHardware );
-}
-
Dali::DisplayConnection& Adaptor::GetDisplayConnectionInterface()
{
DALI_ASSERT_DEBUG( mDisplayConnection && "Display connection not created" );
return nullptr;
}
-VSyncMonitorInterface* Adaptor::GetVSyncMonitorInterface()
-{
- return mVSyncMonitor;
-}
-
TraceInterface& Adaptor::GetKernelTraceInterface()
{
return mKernelTracer;
void Adaptor::OnWindowShown()
{
- if ( PAUSED_WHILE_HIDDEN == mState )
+ if( PAUSED_WHILE_HIDDEN == mState )
{
// Adaptor can now be resumed
mState = PAUSED;
// Force a render task
RequestUpdateOnce();
}
+ else if( RUNNING == mState )
+ {
+ // Force a render task
+ RequestUpdateOnce();
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Update requested.\n" );
+ }
else
{
- DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Not shown [%d]\n", mState );
+ // Force a render task
+ RequestUpdateOnce();
+
+ 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 )
{
bool allWindowsHidden = true;
}
// Only pause the adaptor when all the windows are hidden
- if ( allWindowsHidden )
+ if( allWindowsHidden )
{
- Pause();
+ if( mState == RUNNING )
+ {
+ Pause();
- // Adaptor cannot be resumed until any window is shown
- mState = PAUSED_WHILE_HIDDEN;
+ // 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: Not hidden [%d]\n", mState );
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowHidden: Adaptor is not running state.[%d]\n", mState );
}
}
// 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\n" );
+ DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated: Adaptor is paused\n" );
+ }
}
void Adaptor::NotifyLanguageChanged()
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<Dali::Internal::Adaptor::Window*>( 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(),