/*
- * 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.
#include <dali/integration-api/profiling.h>
#include <dali/integration-api/input-options.h>
#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/processor-interface.h>
// INTERNAL INCLUDES
#include <dali/public-api/dali-adaptor-common.h>
#include <dali/internal/system/common/performance-interface-factory.h>
#include <dali/internal/adaptor/common/lifecycle-observer.h>
-#include <dali/internal/graphics/gles20/egl-graphics-factory.h>
-#include <dali/internal/graphics/gles20/egl-graphics.h> // Temporary until Core is abstracted
+#include <dali/internal/graphics/gles/egl-graphics-factory.h>
+#include <dali/internal/graphics/gles/egl-graphics.h> // Temporary until Core is abstracted
#include <dali/devel-api/text-abstraction/font-client.h>
#include <dali/internal/accessibility/common/accessibility-adaptor-impl.h>
#include <dali/internal/input/common/gesture-manager.h>
#include <dali/internal/window-system/common/event-handler.h>
-#include <dali/internal/graphics/gles20/gl-proxy-implementation.h>
-#include <dali/internal/graphics/gles20/gl-implementation.h>
-#include <dali/internal/graphics/gles20/egl-sync-implementation.h>
+#include <dali/internal/graphics/gles/gl-proxy-implementation.h>
+#include <dali/internal/graphics/gles/gl-implementation.h>
+#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/window-system/common/window-render-surface.h>
#include <dali/internal/system/common/logging.h>
-#include <dali/devel-api/adaptor-framework/image-loading.h>
#include <dali/internal/system/common/locale-utils.h>
#include <dali/internal/imaging/common/image-loader-plugin-proxy.h>
+#include <dali/internal/imaging/common/image-loader.h>
using Dali::TextAbstraction::FontClient;
} // unnamed namespace
-Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
+Dali::Adaptor* Adaptor::New( Any nativeWindow, Dali::RenderSurfaceInterface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
{
Dali::Adaptor* adaptor = new Dali::Adaptor;
Adaptor* impl = new Adaptor( nativeWindow, *adaptor, surface, environmentOptions );
return adaptor;
}
-Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
+Dali::Adaptor* Adaptor::New( GraphicsFactory& graphicsFactory, Any nativeWindow, 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
mCallbackManager = CallbackManager::New();
WindowPane defaultWindow = mWindowFrame.front();
+
+ DALI_ASSERT_DEBUG( defaultWindow.surface && "Surface not initialized" );
+
PositionSize size = defaultWindow.surface->GetPositionSize();
+ defaultWindow.surface->SetAdaptor(*this);
+
mGestureManager = new GestureManager(*this, Vector2(size.width, size.height), mCallbackManager, *mEnvironmentOptions);
mGraphics = &( graphicsFactory.Create() );
auto eglGraphics = static_cast<EglGraphics *>( 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();
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.surface->GetSurfaceType() );
mThreadController = new ThreadController( *this, *mEnvironmentOptions );
// Set max texture size
if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
{
- Dali::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ Dali::TizenPlatform::ImageLoader::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
}
-
- SetupSystemInformation();
}
Adaptor::~Adaptor()
return;
}
+ mCore->Initialize();
+
+ SetupSystemInformation();
+
// Start the callback manager
mCallbackManager->Start();
defaultWindow.surface->GetDpi( dpiHor, dpiVer );
- // tell core about the DPI value
- mCore->SetDpi(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.surface );
// Initialize the thread controller
mThreadController->Initialize();
// 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 );
}
}
// 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 );
}
}
mCallbackManager->Stop();
mState = STOPPED;
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::Stop\n" );
}
}
mEventHandler->FeedKeyEvent( keyEvent );
}
-void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& newSurface )
+void Adaptor::ReplaceSurface( Any nativeWindow, Dali::RenderSurfaceInterface& newSurface )
{
- PositionSize positionSize = newSurface.GetPositionSize();
-
// Let the core know the surface size has changed
- mCore->SurfaceResized( positionSize.width, positionSize.height );
+ mCore->SurfaceResized( &newSurface );
mResizedSignal.Emit( mAdaptor );
WindowPane newDefaultWindow;
newDefaultWindow.nativeWindow = nativeWindow;
newDefaultWindow.surface = &newSurface;
+ newDefaultWindow.surface->SetAdaptor(*this);
- // Must delete the old Window first before replacing it with the new one
WindowPane oldDefaultWindow = mWindowFrame.front();
- oldDefaultWindow.surface->DestroySurface();
// Update WindowFrame
std::vector<WindowPane>::iterator iter = mWindowFrame.begin();
// This method blocks until the render thread has completed the replace.
mThreadController->ReplaceSurface( newDefaultWindow.surface );
+
+ // Must delete the old Window only after the render thread has completed the replace
+ oldDefaultWindow.surface->DestroySurface();
+ oldDefaultWindow.surface = nullptr;
}
-RenderSurface& Adaptor::GetSurface() const
+Dali::RenderSurfaceInterface& Adaptor::GetSurface() const
{
WindowPane defaultWindow = mWindowFrame.front();
return *(defaultWindow.surface);
bool Adaptor::AddWindow( Dali::Window* childWindow, const std::string& childWindowName, const std::string& childWindowClassName, const bool& childWindowMode )
{
+ Window& windowImpl = Dali::GetImplementation( *childWindow );
+ windowImpl.SetAdaptor( Get() );
+
// 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;
+ additionalWindow.surface = windowImpl.GetSurface();
+ additionalWindow.id = windowImpl.GetId();
// Add the new Window to the Frame - the order is not important
mWindowFrame.push_back( additionalWindow );
- Window& windowImpl = Dali::GetImplementation( *childWindow );
- windowImpl.SetAdaptor( Get() );
-
return true;
}
return false;
}
+bool Adaptor::RemoveWindow( Window* childWindow )
+{
+ for ( WindowFrames::iterator iter = mWindowFrame.begin(); iter != mWindowFrame.end(); ++iter )
+ {
+ if( iter->id == childWindow->GetId() )
+ {
+ mWindowFrame.erase( iter );
+ return true;
+ }
+ }
+
+ return false;
+}
+
Dali::Adaptor& Adaptor::Get()
{
DALI_ASSERT_ALWAYS( IsAvailable() && "Adaptor not instantiated" );
return mSocketFactory;
}
-RenderSurface* Adaptor::GetRenderSurfaceInterface()
+Dali::RenderSurfaceInterface* Adaptor::GetRenderSurfaceInterface()
{
if( !mWindowFrame.empty())
{
// Force a render task
RequestUpdateOnce();
}
+ else
+ {
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowShown: Not shown [%d]\n", mState );
+ }
}
void Adaptor::OnWindowHidden()
// Adaptor cannot be resumed until the window is shown
mState = PAUSED_WHILE_HIDDEN;
}
+ else
+ {
+ DALI_LOG_RELEASE_INFO( "Adaptor::OnWindowHidden: Not hidden [%d]\n", mState );
+ }
}
// Dali::Internal::Adaptor::Adaptor::OnDamaged
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
{
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();
SurfaceInitialized();
mState = RUNNING;
+
+ DALI_LOG_RELEASE_INFO( "Adaptor::NotifySceneCreated\n" );
}
void Adaptor::NotifyLanguageChanged()
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 )
}
}
-void Adaptor::IndicatorSizeChanged(int height)
-{
- // Let the core know the indicator height is changed
- mCore->SetTopMargin(height);
-}
-
bool Adaptor::ProcessCoreEventsFromIdle()
{
ProcessCoreEvents();
return false;
}
-Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions)
+Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions)
: mResizedSignal(),
mLanguageChangedSignal(),
mAdaptor( adaptor ),
mCore( nullptr ),
mThreadController( nullptr ),
mVSyncMonitor( nullptr ),
+ mGraphics( nullptr ),
mDisplayConnection( nullptr ),
+ mWindowFrame(),
mPlatformAbstraction( nullptr ),
mEventHandler( nullptr ),
mCallbackManager( nullptr ),
WindowPane defaultWindow;
defaultWindow.nativeWindow = nativeWindow;
defaultWindow.surface = surface;
+ defaultWindow.id = 0;
std::vector<WindowPane>::iterator iter = mWindowFrame.begin();
iter = mWindowFrame.insert( iter, defaultWindow );
gThreadLocalAdaptor = this;
}
-// Stereoscopy
-
-void Adaptor::SetViewMode( ViewMode viewMode )
-{
- WindowPane defaultWindow = mWindowFrame.front();
- defaultWindow.surface->SetViewMode( viewMode );
-
- mCore->SetViewMode( viewMode );
-}
-
-ViewMode Adaptor::GetViewMode() const
-{
- return mCore->GetViewMode();
-}
-
-void Adaptor::SetStereoBase( float stereoBase )
-{
- mCore->SetStereoBase( stereoBase );
-}
-
-float Adaptor::GetStereoBase() const
-{
- return mCore->GetStereoBase();
-}
-
void Adaptor::SetRootLayoutDirection( std::string locale )
{
Dali::Stage stage = Dali::Stage::GetCurrent();
projects / platform / core / uifw / dali-adaptor.git / blobdiff