mPendingRequestUpdate( FALSE ),
mUseElapsedTimeAfterWait( FALSE ),
mNewSurface( NULL ),
- mPostRendering( FALSE ),
- mSurfaceResized( FALSE )
+ mPostRendering( FALSE )
{
LOG_EVENT_TRACE;
LOG_EVENT( "Surface replaced, event-thread continuing" );
}
-void CombinedUpdateRenderController::ResizeSurface()
-{
- LOG_EVENT_TRACE;
-
- LOG_EVENT( "Starting to resize the surface, event-thread blocked" );
-
- // Start resizing the surface.
- {
- ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
- mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will resize the surface now
- mSurfaceResized = TRUE;
- mUpdateRenderThreadWaitCondition.Notify( lock );
- }
-
- // Wait until the surface has been resized
- sem_wait( &mEventThreadSemaphore );
-
- LOG_EVENT( "Surface resized, event-thread continuing" );
-}
-
void CombinedUpdateRenderController::SetRenderRefreshRate( unsigned int numberOfFramesPerRender )
{
// Not protected by lock, but written to rarely so not worth adding a lock when reading
}
//////////////////////////////
- // RESIZE SURFACE
- //////////////////////////////
-
- // The resizing will be applied in the next loop
- bool surfaceResized = ShouldSurfaceBeResized();
- if( DALI_UNLIKELY( surfaceResized ) )
- {
- LOG_UPDATE_RENDER_TRACE_FMT( "Resizing Surface" );
- mRenderHelper.ResizeSurface();
- SurfaceResized();
- }
-
- //////////////////////////////
// UPDATE
//////////////////////////////
while( ( ! mUpdateRenderRunCount || // Should try to wait if event-thread has paused the Update/Render thread
( mUpdateRenderThreadCanSleep && ! updateRequired && ! mPendingRequestUpdate ) ) && // Ensure we wait if we're supposed to be sleeping AND do not require another update
! mDestroyUpdateRenderThread && // Ensure we don't wait if the update-render-thread is supposed to be destroyed
- ! mNewSurface && // Ensure we don't wait if we need to replace the surface
- ! mSurfaceResized ) // Ensure we don't wait if we need to resize the surface
+ ! mNewSurface ) // Ensure we don't wait if we need to replace the surface
{
LOG_UPDATE_RENDER( "WAIT: mUpdateRenderRunCount: %d", mUpdateRenderRunCount );
LOG_UPDATE_RENDER( " mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate );
LOG_UPDATE_RENDER( " mDestroyUpdateRenderThread: %d", mDestroyUpdateRenderThread );
LOG_UPDATE_RENDER( " mNewSurface: %d", mNewSurface );
- LOG_UPDATE_RENDER( " mSurfaceResized: %d", mSurfaceResized );
// Reset the time when the thread is waiting, so the sleep-until time for
// the first frame after resuming should be based on the actual start time
LOG_COUNTER_UPDATE_RENDER( "mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate );
LOG_COUNTER_UPDATE_RENDER( "mDestroyUpdateRenderThread: %d", mDestroyUpdateRenderThread );
LOG_COUNTER_UPDATE_RENDER( "mNewSurface: %d", mNewSurface );
- LOG_COUNTER_UPDATE_RENDER( "mSurfaceResized: %d", mSurfaceResized );
mUseElapsedTimeAfterWait = FALSE;
mUpdateRenderThreadCanSleep = FALSE;
sem_post( &mEventThreadSemaphore );
}
-bool CombinedUpdateRenderController::ShouldSurfaceBeResized()
-{
- ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
-
- bool surfaceSized = mSurfaceResized;
- mSurfaceResized = FALSE;
-
- return surfaceSized;
-}
-
-void CombinedUpdateRenderController::SurfaceResized()
-{
- // Just increment the semaphore
- sem_post( &mEventThreadSemaphore );
-}
-
///////////////////////////////////////////////////////////////////////////////////////////////////
// ALL THREADS
///////////////////////////////////////////////////////////////////////////////////////////////////
ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
while( mPostRendering &&
! mNewSurface && // We should NOT wait if we're replacing the surface
- ! mSurfaceResized && // We should NOT wait if we're resizing the surface
! mDestroyUpdateRenderThread )
{
mUpdateRenderThreadWaitCondition.Wait( lock );
#define __DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
virtual void ReplaceSurface( RenderSurface* surface );
/**
- * @copydoc ThreadControllerInterface::ResizeSurface()
- */
- virtual void ResizeSurface();
-
- /**
* @copydoc ThreadControllerInterface::SetRenderRefreshRate()
*/
virtual void SetRenderRefreshRate( unsigned int numberOfFramesPerRender );
void SurfaceReplaced();
/**
- * Checks to see if the surface needs to be resized.
- * This will lock the mutex in mUpdateRenderThreadWaitCondition.
- *
- * @return true if the surface should be resized, false otherwise
- */
- bool ShouldSurfaceBeResized();
-
- /**
- * Called by the Update/Render thread after a surface has been resized.
- *
- * This will lock the mutex in mEventThreadWaitCondition
- */
- void SurfaceResized();
-
- /**
* Helper for the thread calling the entry function
* @param[in] This A pointer to the current object
*/
RenderSurface* volatile mNewSurface; ///< Will be set to the new-surface if requested (set by the event-thread, read & cleared by the update-render thread).
volatile unsigned int mPostRendering; ///< Whether post-rendering is taking place (set by the event & render threads, read by the render-thread).
- volatile unsigned int mSurfaceResized; ///< Will be set to resize the surface (set by the event-thread, read & cleared by the update-render thread).
};
} // namespace Adaptor
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
: mGLES( adaptorInterfaces.GetGlesInterface() ),
mEglFactory( &adaptorInterfaces.GetEGLFactoryInterface()),
mEGL( NULL ),
- mSurfaceReplaced( false ),
- mSurfaceResized( false )
+ mSurfaceReplaced( false )
{
// set the initial values before render thread starts
mSurface = adaptorInterfaces.GetRenderSurfaceInterface();
mSurfaceReplaced = true;
}
-void RenderHelper::ResizeSurface()
-{
- mSurfaceResized = true;
-}
-
void RenderHelper::ShutdownEgl()
{
if( mSurface )
{
if( mSurface )
{
- mSurface->PreRender( *mEGL, mGLES, mSurfaceResized );
+ mSurface->PreRender( *mEGL, mGLES );
}
mGLES.PreRender();
return true;
if( mSurface )
{
// Inform the surface that rendering this frame has finished.
- mSurface->PostRender( *mEGL, mGLES, mDisplayConnection, mSurfaceReplaced, mSurfaceResized );
+ mSurface->PostRender( *mEGL, mGLES, mDisplayConnection, mSurfaceReplaced );
}
mSurfaceReplaced = false;
- mSurfaceResized = false;
}
} // namespace Adaptor
#define __DALI_INTERNAL_RENDER_HELPER_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
void ReplaceSurface( RenderSurface* newSurface );
/**
- * Resize the rendering surface.
- *
- * @note Called from render thread
- */
- void ResizeSurface();
-
- /**
* Shuts down EGL.
*
* @note Called from render thread
RenderSurface* mSurface; ///< Current surface
Dali::DisplayConnection* mDisplayConnection; ///< Display connection
bool mSurfaceReplaced; ///< True when new surface has been initialized.
- bool mSurfaceResized; ///< True when the surface is resized.
};
} // namespace Adaptor
#define __DALI_INTERNAL_THREAD_CONTROLLER_INTERFACE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
virtual void ReplaceSurface( RenderSurface* surface ) = 0;
/**
- * Resize the surface.
- */
- virtual void ResizeSurface() = 0;
-
- /**
* @copydoc Dali::Adaptor::SetRenderRefreshRate()
*/
virtual void SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) = 0;
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
mThreadControllerInterface->ReplaceSurface( newSurface );
}
-void ThreadController::ResizeSurface()
-{
- mThreadControllerInterface->ResizeSurface();
-}
-
void ThreadController::SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender )
{
mThreadControllerInterface->SetRenderRefreshRate( numberOfVSyncsPerRender );
#define __DALI_INTERNAL_THREAD_CONTROLLER_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
void ReplaceSurface( RenderSurface* surface );
/**
- * Resize the surface.
- */
- void ResizeSurface();
-
- /**
* @copydoc Dali::Adaptor::SetRenderRefreshRate()
*/
void SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender );
void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface )
{
- PositionSize positionSize = surface.GetPositionSize();
-
- // let the core know the surface size has changed
- mCore->SurfaceResized( positionSize.width, positionSize.height );
-
- mResizedSignal.Emit( mAdaptor );
-
mNativeWindow = nativeWindow;
mSurface = &surface;
- // flush the event queue to give the update-render thread chance
+ // flush the event queue to give update and render threads chance
// to start processing messages for new camera setup etc as soon as possible
ProcessCoreEvents();
RequestUpdate();
}
-void Adaptor::SurfaceResizePrepare( Dali::Adaptor::SurfaceSize surfaceSize )
+void Adaptor::SurfaceSizeChanged( Dali::Adaptor::SurfaceSize surfaceSize )
{
// let the core know the surface size has changed
mCore->SurfaceResized( surfaceSize.GetWidth(), surfaceSize.GetHeight() );
mResizedSignal.Emit( mAdaptor );
}
-void Adaptor::SurfaceResizeComplete( Dali::Adaptor::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
- ProcessCoreEvents();
-
- // this method blocks until the render thread has completed the resizing.
- mThreadController->ResizeSurface();
-}
-
void Adaptor::NotifySceneCreated()
{
GetCore().SceneCreated();
/**
* Informs core the surface size has changed
*/
- void SurfaceResizePrepare( Dali::Adaptor::SurfaceSize surfaceSize );
-
- /**
- * Informs ThreadController the surface size has changed
- */
- void SurfaceResizeComplete( Dali::Adaptor::SurfaceSize surfaceSize );
+ void SurfaceSizeChanged( Dali::Adaptor::SurfaceSize surfaceSize );
public: //AdaptorInternalServices
mImpl->SetStereoBase( stereoBase );
}
+void Adaptor::SurfaceSizeChanged( SurfaceSize surfaceSize )
+{
+ mImpl->SurfaceSizeChanged( surfaceSize );
+}
+
Adaptor::Adaptor()
: mImpl( NULL )
{
Dali::RenderSurface* renderSurface = windowImpl.GetSurface();
Any nativeWindow = newWindow.GetNativeHandle();
+ Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).SurfaceSizeChanged( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
Internal::Adaptor::Adaptor::GetImplementation( *mAdaptor ).ReplaceSurface(nativeWindow, *renderSurface);
mWindow = newWindow;
mWindowPositionSize = positionSize;
#define __DALI_RENDER_SURFACE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
* a surface to render onto.
* @param[in] egl The Egl interface
* @param[in] glAbstraction OpenGLES abstraction interface
- * @param[in] resizingSurface True if the surface is being resized
* @return True if the operation is successful, False if the operation failed
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface ) = 0;
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction ) = 0;
/**
* @brief Invoked by render thread after Core::Render
* @param[in] glAbstraction OpenGLES abstraction interface
* @param[in] displayConnection display connection
* @param[in] replacingSurface True if the surface is being replaced.
- * @param[in] resizingSurface True if the surface is being resized.
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface ) = 0;
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface ) = 0;
/**
* @brief Invoked by render thread when the thread should be stop
// FIXME
}
-bool PixmapRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction&, bool )
+bool PixmapRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction& )
{
// nothing to do for pixmaps
return true;
}
-void PixmapRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface )
+void PixmapRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface )
{
// flush gl instruction queue
glAbstraction.Flush();
void PixmapRenderSurface::CreateWlRenderable()
{
// check we're creating one with a valid size
- DALI_ASSERT_ALWAYS( mPositionSize.width > 0 && mPositionSize.height > 0 && "Pixmap size is invalid" );
+ DALI_ASSERT_ALWAYS( mPosition.width > 0 && mPosition.height > 0 && "Pixmap size is invalid" );
// FIXME
}
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2014 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.
Any surface,
const std::string& name,
bool isTransparent)
-: mPositionSize( positionSize ),
- mTitle( name ),
- mRenderNotification( NULL ),
- mColorDepth( isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24 ),
- mOwnSurface( false )
+: mPosition(positionSize),
+ mTitle(name),
+ mRenderNotification(NULL),
+ mColorDepth(isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24),
+ mOwnSurface(false)
{
}
PositionSize EcoreWlRenderSurface::GetPositionSize() const
{
- return mPositionSize;
+ return mPosition;
}
void EcoreWlRenderSurface::MoveResize( Dali::PositionSize positionSize )
*/
EventHandler( Window* window )
: mWindow( window ),
- mEcoreEventHandler(),
+ mWindowPropertyHandler( NULL ),
+ mWindowIconifyStateHandler( NULL ),
+ mWindowVisibilityStateHandler( NULL ),
+ mWindowFocusInHandler( NULL ),
+ mWindowFocusOutHandler( NULL ),
mEcoreWindow( 0 ),
mDisplay( NULL ),
mEventQueue( NULL ),
if( mWindow->mEcoreEventHander )
{
- mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ) );
- mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE, EcoreEventWindowVisibilityChanged, this ) );
- mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this ) );
- mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this ) );
- mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_OUTPUT_TRANSFORM, EcoreEventOutputTransform, this) );
- mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM, EcoreEventIgnoreOutputTransform, this) );
+ mWindowIconifyStateHandler = ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this );
+ mWindowVisibilityStateHandler = ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE, EcoreEventWindowVisibilityChanged, this );
+ mWindowFocusInHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this );
+ mWindowFocusOutHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this );
}
mDisplay = ecore_wl_display_get();
*/
~EventHandler()
{
- for( Dali::Vector< Ecore_Event_Handler* >::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter )
+ if ( mWindowPropertyHandler )
{
- ecore_event_handler_del( *iter );
+ ecore_event_handler_del( mWindowPropertyHandler );
+ }
+
+ if ( mWindowIconifyStateHandler )
+ {
+ ecore_event_handler_del( mWindowIconifyStateHandler );
+ }
+
+ if ( mWindowVisibilityStateHandler )
+ {
+ ecore_event_handler_del( mWindowVisibilityStateHandler );
+ }
+
+ if( mWindowFocusInHandler )
+ {
+ ecore_event_handler_del( mWindowFocusInHandler );
+ }
+
+ if( mWindowFocusOutHandler )
+ {
+ ecore_event_handler_del( mWindowFocusOutHandler );
}
- mEcoreEventHandler.Clear();
if( mEventQueue )
{
// Static methods
+ /// Called when the window properties are changed.
+ static Eina_Bool EcoreEventWindowPropertyChanged( void* data, int type, void* event )
+ {
+ return EINA_FALSE;
+ }
+
/// Called when the window iconify state is changed.
static Eina_Bool EcoreEventWindowIconifyStateChanged( void* data, int type, void* event )
{
return ECORE_CALLBACK_PASS_ON;
}
- /// Called when the output is transformed
- static Eina_Bool EcoreEventOutputTransform( void* data, int type, void* event )
- {
- Ecore_Wl_Event_Output_Transform* transformEvent( static_cast< Ecore_Wl_Event_Output_Transform* >( event ) );
- EventHandler* handler( static_cast< EventHandler* >( data ) );
-
- if ( handler && handler->mWindow && transformEvent->output == ecore_wl_window_output_find( handler->mEcoreWindow ) )
- {
- ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) );
- wlSurface->OutputTransformed();
- }
-
- return ECORE_CALLBACK_PASS_ON;
- }
-
- /// Called when the output transform should be ignored
- static Eina_Bool EcoreEventIgnoreOutputTransform( void* data, int type, void* event )
- {
- Ecore_Wl_Event_Ignore_Output_Transform* ignoreTransformEvent( static_cast< Ecore_Wl_Event_Ignore_Output_Transform* >( event ) );
- EventHandler* handler( static_cast< EventHandler* >( data ) );
-
- if ( handler && handler->mWindow && ignoreTransformEvent->win == handler->mEcoreWindow )
- {
- ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) );
- wlSurface->OutputTransformed();
- }
-
- return ECORE_CALLBACK_PASS_ON;
- }
-
static void RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version )
{
Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data );
// Data
Window* mWindow;
- Dali::Vector< Ecore_Event_Handler* > mEcoreEventHandler;
+ Ecore_Event_Handler* mWindowPropertyHandler;
+ Ecore_Event_Handler* mWindowIconifyStateHandler;
+ Ecore_Event_Handler* mWindowVisibilityStateHandler;
+ Ecore_Event_Handler* mWindowFocusInHandler;
+ Ecore_Event_Handler* mWindowFocusOutHandler;
Ecore_Wl_Window* mEcoreWindow;
wl_display* mDisplay;
void Window::RotationDone( int orientation, int width, int height )
{
- ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
- wlSurface->RequestRotation( orientation, width, height );
-
- mAdaptor->SurfaceResizePrepare( Dali::Adaptor::SurfaceSize( width, height ) );
+ mAdaptor->SurfaceSizeChanged( Dali::Adaptor::SurfaceSize( width, height ) );
// Emit signal
mResizedSignal.Emit( Dali::DevelWindow::WindowSize( width, height ) );
- mAdaptor->SurfaceResizeComplete( Dali::Adaptor::SurfaceSize( width, height ) );
+ Dali::Window::WindowOrientation windowOrientation;
+ switch( orientation )
+ {
+ case 0:
+ {
+ windowOrientation = Dali::Window::PORTRAIT;
+ break;
+ }
+ case 90:
+ {
+ windowOrientation = Dali::Window::LANDSCAPE;
+ break;
+ }
+ case 180:
+ {
+ windowOrientation = Dali::Window::PORTRAIT_INVERSE;
+ break;
+ }
+ case 270:
+ {
+ windowOrientation = Dali::Window::LANDSCAPE_INVERSE;
+ break;
+ }
+ default:
+ {
+ windowOrientation = Dali::Window::PORTRAIT;
+ break;
+ }
+ }
+
+ ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
+ wlSurface->RequestRotation( windowOrientation, width, height );
}
unsigned int Window::GetSupportedAuxiliaryHintCount()
mSurface->MoveResize( positionSize );
- mAdaptor->SurfaceResizePrepare( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+ mAdaptor->SurfaceSizeChanged( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
// Emit signal
mResizedSignal.Emit( Dali::DevelWindow::WindowSize( positionSize.width, positionSize.height ) );
-
- mAdaptor->SurfaceResizeComplete( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
}
}
// INTERNAL INCLUDES
#include <wl-types.h>
#include <gl/egl-implementation.h>
+#include <base/display-connection.h>
#include <adaptors/common/adaptor-impl.h>
#include <integration-api/trigger-event-factory-interface.h>
{
const int MINIMUM_DIMENSION_CHANGE( 1 ); ///< Minimum change for window to be considered to have moved
+const char* WAYLAND_EGL_SO( "libwayland-egl.so" );
} // unnamed namespace
const std::string& name,
bool isTransparent)
: EcoreWlRenderSurface( positionSize, surface, name, isTransparent ),
+ mEglWinGetCapabilitiesPtr( NULL ),
+ mEglWinSetRotationPtr( NULL ),
+ mLibHandle( NULL ),
mWlWindow( NULL ),
mWlSurface( NULL ),
mEglWindow( NULL ),
mThreadSynchronization( NULL ),
mRotationTrigger( NULL ),
- mRotationAngle( 0 ),
- mScreenRotationAngle( 0 ),
mRotationSupported( false ),
- mRotationFinished( true ),
- mScreenRotationFinished( true ),
- mResizeFinished( true )
+ mRotated( false )
{
DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "Creating Window\n" );
Init( surface );
delete mRotationTrigger;
}
+ if( mLibHandle != NULL )
+ {
+ dlclose( mLibHandle );
+ }
}
Ecore_Wl_Window* WindowRenderSurface::GetDrawable()
return mWlWindow;
}
-void WindowRenderSurface::RequestRotation( int angle, int width, int height )
+void WindowRenderSurface::RequestRotation( Dali::Window::WindowOrientation orientation, int width, int height )
{
if( !mRotationSupported )
{
return;
}
+ DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::Rotate: orientation = %d\n", orientation );
+
if( !mRotationTrigger )
{
TriggerEventFactoryInterface& triggerFactory = Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() ).GetTriggerEventFactoryInterface();
mRotationTrigger = triggerFactory.CreateTriggerEvent( MakeCallback( this, &WindowRenderSurface::ProcessRotationRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
}
- mPositionSize.width = width;
- mPositionSize.height = height;
+ mPosition.width = width;
+ mPosition.height = height;
- mRotationAngle = angle;
- mRotationFinished = false;
+ mRotated = true;
- ecore_wl_window_rotation_set( mWlWindow, mRotationAngle );
+ int angle;
+ wl_egl_window_rotation rotation;
- DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::Rotate: angle = %d screen rotation = %d\n", mRotationAngle, mScreenRotationAngle );
-}
-
-void WindowRenderSurface::OutputTransformed()
-{
- int transform;
-
- if( ecore_wl_window_ignore_output_transform_get( mWlWindow ) )
+ switch( orientation )
{
- transform = 0;
- }
- else
- {
- transform = ecore_wl_output_transform_get( ecore_wl_window_output_find( mWlWindow ) );
+ case Dali::Window::PORTRAIT:
+ {
+ angle = 0;
+ rotation = ROTATION_0;
+ break;
+ }
+ case Dali::Window::LANDSCAPE:
+ {
+ angle = 90;
+ rotation = ROTATION_270;
+ break;
+ }
+ case Dali::Window::PORTRAIT_INVERSE:
+ {
+ angle = 180;
+ rotation = ROTATION_180;
+ break;
+ }
+ case Dali::Window::LANDSCAPE_INVERSE:
+ {
+ angle = 270;
+ rotation = ROTATION_90;
+ break;
+ }
+ default:
+ {
+ angle = 0;
+ rotation = ROTATION_0;
+ break;
+ }
}
- ecore_wl_window_buffer_transform_set( mWlWindow, transform );
+ ecore_wl_window_rotation_set( mWlWindow, angle );
- mScreenRotationAngle = transform * 90;
- mScreenRotationFinished = false;
-
- DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::OutputTransformed: angle = %d screen rotation = %d\n", mRotationAngle, mScreenRotationAngle );
+ if( mEglWinSetRotationPtr )
+ {
+ mEglWinSetRotationPtr( mEglWindow, rotation );
+ }
}
void WindowRenderSurface::SetTransparency( bool transparent )
Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( eglIf );
- // create the EGL window
- if( mScreenRotationAngle == 0 || mScreenRotationAngle == 180 )
+ // Temporary code for opaque window. We have to modify it after wayland team finish the work.
+ if( mColorDepth == COLOR_DEPTH_32 )
{
- mEglWindow = wl_egl_window_create( mWlSurface, mPositionSize.width, mPositionSize.height );
+ ecore_wl_window_alpha_set( mWlWindow, true );
}
else
{
- mEglWindow = wl_egl_window_create( mWlSurface, mPositionSize.height, mPositionSize.width );
+ ecore_wl_window_alpha_set( mWlWindow, false );
}
+ // create the EGL window
+ mEglWindow = wl_egl_window_create( mWlSurface, mPosition.width, mPosition.height );
EGLNativeWindowType windowType( mEglWindow );
eglImpl.CreateSurfaceWindow( windowType, mColorDepth );
// Check capability
- wl_egl_window_capability capability = static_cast< wl_egl_window_capability >( wl_egl_window_get_capabilities( mEglWindow ) );
- if( capability == WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED )
+ if( !mLibHandle )
{
- DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::CreateEglSurface: capability = %d\n", capability );
- mRotationSupported = true;
+ mLibHandle = dlopen( WAYLAND_EGL_SO, RTLD_LAZY );
+
+ char* error = dlerror();
+ if( mLibHandle == NULL || error != NULL )
+ {
+ DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::CreateEglSurface: dlopen error: %s\n", error );
+ return;
+ }
+
+ mEglWinGetCapabilitiesPtr = reinterpret_cast< EglWinGetCapabilitiesFunction >( dlsym( mLibHandle, "wl_egl_window_get_capabilities" ) );
+ if( !mEglWinGetCapabilitiesPtr )
+ {
+ DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::CreateEglSurface: Can't load wl_egl_window_get_capabilities\n" );
+ return;
+ }
+
+ mEglWinSetRotationPtr = reinterpret_cast< EglWinSetRotationFunction >( dlsym( mLibHandle, "wl_egl_window_set_rotation" ) );
+ if( !mEglWinSetRotationPtr )
+ {
+ DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::CreateEglSurface: Can't load wl_egl_window_set_rotation\n" );
+ return;
+ }
}
- DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::CreateEglSurface: w = %d h = %d angle = %d screen rotation = %d\n", mPositionSize.width, mPositionSize.height, mRotationAngle, mScreenRotationAngle );
+ if( mEglWinGetCapabilitiesPtr )
+ {
+ wl_egl_window_capability capability = static_cast< wl_egl_window_capability >( mEglWinGetCapabilitiesPtr( mEglWindow ) );
+ if( capability == WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED )
+ {
+ DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::CreateEglSurface: capability = %d\n", capability );
+ mRotationSupported = true;
+ }
+ }
}
void WindowRenderSurface::DestroyEglSurface( EglInterface& eglIf )
mEglWindow = NULL;
}
- if( mScreenRotationAngle == 0 || mScreenRotationAngle == 180 )
+ // Temporary code for opaque window. We have to modify it after wayland team finish the work.
+ if( mColorDepth == COLOR_DEPTH_32 )
{
- mEglWindow = wl_egl_window_create( mWlSurface, mPositionSize.width, mPositionSize.height );
+ ecore_wl_window_alpha_set( mWlWindow, true );
}
else
{
- mEglWindow = wl_egl_window_create( mWlSurface, mPositionSize.height, mPositionSize.width );
+ ecore_wl_window_alpha_set( mWlWindow, false );
}
- // Set screen rotation
- mScreenRotationFinished = false;
+ mEglWindow = wl_egl_window_create( mWlSurface, mPosition.width, mPosition.height );
Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
EGLNativeWindowType windowType( mEglWindow );
bool needToResize = false;
// check moving
- if( (fabs(positionSize.x - mPositionSize.x) > MINIMUM_DIMENSION_CHANGE) ||
- (fabs(positionSize.y - mPositionSize.y) > MINIMUM_DIMENSION_CHANGE) )
+ if( (fabs(positionSize.x - mPosition.x) > MINIMUM_DIMENSION_CHANGE) ||
+ (fabs(positionSize.y - mPosition.y) > MINIMUM_DIMENSION_CHANGE) )
{
needToMove = true;
}
// check resizing
- if( (fabs(positionSize.width - mPositionSize.width) > MINIMUM_DIMENSION_CHANGE) ||
- (fabs(positionSize.height - mPositionSize.height) > MINIMUM_DIMENSION_CHANGE) )
+ if( (fabs(positionSize.width - mPosition.width) > MINIMUM_DIMENSION_CHANGE) ||
+ (fabs(positionSize.height - mPosition.height) > MINIMUM_DIMENSION_CHANGE) )
{
needToResize = true;
}
- if( needToMove )
+ if(needToMove)
{
ecore_wl_window_position_set( mWlWindow, positionSize.x, positionSize.y );
}
- if( needToResize )
+ if (needToResize)
{
ecore_wl_window_update_size( mWlWindow, positionSize.width, positionSize.height );
- mResizeFinished = false;
}
- mPositionSize = positionSize;
+ mPosition = positionSize;
+
+ wl_egl_window_resize( mEglWindow, mPosition.width, mPosition.height, mPosition.x, mPosition.y );
- DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::MoveResize: %d, %d, %d, %d\n", mPositionSize.x, mPositionSize.y, mPositionSize.width, mPositionSize.height );
+ DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::MoveResize: %d, %d, %d, %d\n", mPosition.x, mPosition.y, mPosition.width, mPosition.height );
}
void WindowRenderSurface::Map()
{
}
-bool WindowRenderSurface::PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface )
+bool WindowRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction& )
{
- if( resizingSurface )
- {
-#ifdef OVER_TIZEN_VERSION_4
- // Window rotate or screen rotate
- if( !mRotationFinished || !mScreenRotationFinished )
- {
- wl_egl_window_rotation rotation;
- wl_output_transform bufferTransform;
- int totalAngle = (mRotationAngle + mScreenRotationAngle) % 360;
-
- switch( totalAngle )
- {
- case 0:
- {
- rotation = ROTATION_0;
- bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
- break;
- }
- case 90:
- {
- rotation = ROTATION_270;
- bufferTransform = WL_OUTPUT_TRANSFORM_90;
- break;
- }
- case 180:
- {
- rotation = ROTATION_180;
- bufferTransform = WL_OUTPUT_TRANSFORM_180;
- break;
- }
- case 270:
- {
- rotation = ROTATION_90;
- bufferTransform = WL_OUTPUT_TRANSFORM_270;
- break;
- }
- default:
- {
- rotation = ROTATION_0;
- bufferTransform = WL_OUTPUT_TRANSFORM_NORMAL;
- break;
- }
- }
-
- wl_egl_window_set_rotation( mEglWindow, rotation );
-
- wl_egl_window_set_buffer_transform( mEglWindow, bufferTransform );
-
- // Reset only screen rotation flag
- mScreenRotationFinished = true;
-
- DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PreRender: Set rotation [%d] [%d]\n", mRotationAngle, mScreenRotationAngle );
- }
-
- // Only window rotate
- if( !mRotationFinished )
- {
- wl_output_transform windowTransform;
-
- switch( mRotationAngle )
- {
- case 0:
- {
- windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
- break;
- }
- case 90:
- {
- windowTransform = WL_OUTPUT_TRANSFORM_90;
- break;
- }
- case 180:
- {
- windowTransform = WL_OUTPUT_TRANSFORM_180;
- break;
- }
- case 270:
- {
- windowTransform = WL_OUTPUT_TRANSFORM_270;
- break;
- }
- default:
- {
- windowTransform = WL_OUTPUT_TRANSFORM_NORMAL;
- break;
- }
- }
-
- wl_egl_window_set_window_transform( mEglWindow, windowTransform );
- }
-#endif
-
- // Resize case
- if( !mResizeFinished )
- {
- wl_egl_window_resize( mEglWindow, mPositionSize.width, mPositionSize.height, mPositionSize.x, mPositionSize.y );
- mResizeFinished = true;
-
- DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PreRender: Set resize\n" );
- }
- }
-
+ // nothing to do for windows
return true;
}
-void WindowRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface )
+void WindowRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface )
{
- if( resizingSurface )
+ if( mRotated )
{
- if( !mRotationFinished )
+ // Check viewport size
+ Dali::Vector< GLint > viewportSize;
+ viewportSize.Resize( 4 );
+
+ glAbstraction.GetIntegerv( GL_VIEWPORT, &viewportSize[0] );
+
+ if( viewportSize[2] == mPosition.width && viewportSize[3] == mPosition.height )
{
DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PostRender: Trigger rotation event\n" );
void WindowRenderSurface::CreateWlRenderable()
{
// if width or height are zero, go full screen.
- if ( (mPositionSize.width == 0) || (mPositionSize.height == 0) )
+ if ( (mPosition.width == 0) || (mPosition.height == 0) )
{
// Default window size == screen size
- mPositionSize.x = 0;
- mPositionSize.y = 0;
+ mPosition.x = 0;
+ mPosition.y = 0;
- ecore_wl_screen_size_get( &mPositionSize.width, &mPositionSize.height );
+ ecore_wl_screen_size_get( &mPosition.width, &mPosition.height );
}
- mWlWindow = ecore_wl_window_new( 0, mPositionSize.x, mPositionSize.y, mPositionSize.width, mPositionSize.height, ECORE_WL_WINDOW_BUFFER_TYPE_EGL_WINDOW );
+ mWlWindow = ecore_wl_window_new( 0, mPosition.x, mPosition.y, mPosition.width, mPosition.height, ECORE_WL_WINDOW_BUFFER_TYPE_EGL_WINDOW );
if ( mWlWindow == 0 )
{
}
mWlSurface = ecore_wl_window_surface_create( mWlWindow );
-
- if( mColorDepth == COLOR_DEPTH_32 )
- {
- ecore_wl_window_alpha_set( mWlWindow, true );
- }
- else
- {
- ecore_wl_window_alpha_set( mWlWindow, false );
- }
-
- // Get output transform
- if( !ecore_wl_window_ignore_output_transform_get( mWlWindow ) )
- {
- Ecore_Wl_Output* output = ecore_wl_window_output_find( mWlWindow );
-
- int transform = ecore_wl_output_transform_get( output );
- ecore_wl_window_buffer_transform_set( mWlWindow, transform );
-
- mScreenRotationAngle = transform * 90;
- mScreenRotationFinished = false;
- }
}
void WindowRenderSurface::UseExistingRenderable( unsigned int surfaceId )
void WindowRenderSurface::ProcessRotationRequest()
{
- mRotationFinished = true;
+ mRotated = false;
ecore_wl_window_rotation_change_done_send( mWlWindow );
// INTERNAL INCLUDES
#include <ecore-wl-render-surface.h>
+#include <window.h>
#include <integration-api/thread-synchronization-interface.h>
namespace Dali
/**
* Request surface rotation
- * @param[in] angle A new angle of the surface
+ * @param[in] orientation A new orientation of the surface
* @param[in] width A new width of the surface
* @param[in] height A new height of the surface
*/
- void RequestRotation( int angle, int width, int height );
-
- /**
- * Notify output is transformed.
- */
- void OutputTransformed();
+ void RequestRotation( Dali::Window::WindowOrientation orientation, int width, int height );
/**
* @brief Sets whether the surface is transparent or not.
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface );
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction );
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface );
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface );
/**
* @copydoc Dali::RenderSurface::StopRender()
private: // Data
+ typedef int (*EglWinGetCapabilitiesFunction)( wl_egl_window* eglWindow );
+ typedef int (*EglWinSetRotationFunction)( wl_egl_window* eglWindow, int rotation );
+
+ EglWinGetCapabilitiesFunction mEglWinGetCapabilitiesPtr;
+ EglWinSetRotationFunction mEglWinSetRotationPtr;
+
+ void* mLibHandle; ///< Handle for the loaded library
Ecore_Wl_Window* mWlWindow; ///< Wayland-Window
wl_surface* mWlSurface;
wl_egl_window* mEglWindow;
ThreadSynchronizationInterface* mThreadSynchronization;
TriggerEventInterface* mRotationTrigger;
- int mRotationAngle;
- int mScreenRotationAngle;
bool mRotationSupported;
- bool mRotationFinished;
- bool mScreenRotationFinished;
- bool mResizeFinished;
+ bool mRotated;
}; // class WindowRenderSurface
*/
void SetStereoBase( float stereoBase );
+ /**
+ * @brief Informs core the surface size has changed
+ */
+ void SurfaceSizeChanged( SurfaceSize surfaceSize );
+
public: // Signals
/**
#define __DALI_ECORE_WL_RENDER_SURFACE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2014 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.
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface ) = 0;
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction ) = 0;
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface ) = 0;
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface ) = 0;
/**
* @copydoc Dali::RenderSurface::ReleaseLock()
protected: // Data
- PositionSize mPositionSize; ///< Position
+ PositionSize mPosition; ///< Position
std::string mTitle; ///< Title of window which shows from "xinfo -topvwins" command
TriggerEventInterface* mRenderNotification; ///< Render notification trigger
ColorDepth mColorDepth; ///< Color depth of surface (32 bit or 24 bit)
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface );
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction );
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface );
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface );
/**
* @copydoc Dali::RenderSurface::StopRender()
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface );
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction );
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface );
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface );
/**
* @copydoc Dali::RenderSurface::StopRender()
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface ) = 0;
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction ) = 0;
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface ) = 0;
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface ) = 0;
/**
* @copydoc Dali::RenderSurface::ReleaseLock()
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface );
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction );
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface );
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface );
/**
* @copydoc Dali::RenderSurface::StopRender()
{
}
-bool NativeRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction&, bool )
+bool NativeRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction& )
{
// nothing to do for pixmaps
return true;
}
-void NativeRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface )
+void NativeRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface )
{
Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
eglImpl.SwapBuffers();
{
}
-bool RenderSurface::PreRender( EglInterface&, Integration::GlAbstraction&, bool )
+bool RenderSurface::PreRender( EglInterface&, Integration::GlAbstraction& )
{
return true;
}
-void RenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface )
+void RenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface )
{
Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
eglImpl.SwapBuffers();
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface );
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction );
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface );
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface );
/**
* @copydoc Dali::RenderSurface::StopRender();
mSurface->MoveResize( positionSize );
- mAdaptor->SurfaceResizePrepare( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+ mAdaptor->SurfaceSizeChanged( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
// Emit signal
mResizedSignal.Emit( Dali::DevelWindow::WindowSize( positionSize.width, positionSize.height ) );
-
- mAdaptor->SurfaceResizeComplete( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
}
}
{
}
-bool PixmapRenderSurface::PreRender( EglInterface& egl, Integration::GlAbstraction&, bool )
+bool PixmapRenderSurface::PreRender( EglInterface& egl, Integration::GlAbstraction& )
{
// Nothing to do for pixmaps
return true;
}
-void PixmapRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface )
+void PixmapRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface )
{
// flush gl instruction queue
glAbstraction.Flush();
ecore_x_window_prop_property_set( ecoreWindow,
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
ECORE_X_ATOM_CARDINAL, 32, &angles, 2 );
-
- mAdaptor->SurfaceResizePrepare( Dali::Adaptor::SurfaceSize( width, height ) );
-
- // Emit signal
- mResizedSignal.Emit( Dali::DevelWindow::WindowSize( width, height ) );
-
- mAdaptor->SurfaceResizeComplete( Dali::Adaptor::SurfaceSize( width, height ) );
#endif // DALI_PROFILE_UBUNTU
}
}
mSurface->MoveResize( positionSize );
- mAdaptor->SurfaceResizePrepare( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+ mAdaptor->SurfaceSizeChanged( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
// Emit signal
mResizedSignal.Emit( Dali::DevelWindow::WindowSize( positionSize.width, positionSize.height ) );
-
- mAdaptor->SurfaceResizeComplete( Dali::Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
}
}
{
}
-bool WindowRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction&, bool )
+bool WindowRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction& )
{
// nothing to do for windows
return true;
}
-void WindowRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface )
+void WindowRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface )
{
Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
eglImpl.SwapBuffers();
/**
* @copydoc Dali::RenderSurface::PreRender()
*/
- virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, bool resizingSurface );
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction );
/**
* @copydoc Dali::RenderSurface::PostRender()
*/
- virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface, bool resizingSurface );
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface );
/**
* @copydoc Dali::RenderSurface::StopRender()
projects / platform / core / uifw / dali-adaptor.git / commitdiff