#include <dali/internal/window-system/common/window-impl.h>
// EXTERNAL HEADERS
+#include <thread>
#include <dali/integration-api/core.h>
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/layer.h>
#include <dali/devel-api/adaptor-framework/orientation.h>
#include <dali/integration-api/events/touch-event-integ.h>
-#ifdef DALI_ADAPTOR_COMPILATION
-#include <dali/integration-api/render-surface-interface.h>
-#else
-#include <dali/integration-api/adaptors/render-surface-interface.h>
-#endif
-
// INTERNAL HEADERS
+#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
#include <dali/internal/window-system/common/event-handler.h>
#include <dali/internal/window-system/common/orientation-impl.h>
#include <dali/internal/window-system/common/render-surface-factory.h>
#include <dali/internal/window-system/common/window-factory.h>
#include <dali/internal/window-system/common/window-base.h>
+#include <dali/internal/window-system/common/window-system.h>
#include <dali/internal/window-system/common/window-render-surface.h>
#include <dali/internal/window-system/common/window-visibility-observer.h>
} // unnamed namespace
-Window* Window::New( const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent )
+Window* Window::New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
+{
+ Any surface;
+ return Window::New(surface, positionSize, name, className, isTransparent);
+}
+
+Window* Window::New(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
{
Window* window = new Window();
window->mIsTransparent = isTransparent;
- window->Initialize( positionSize, name, className );
+ window->Initialize(surface, positionSize, name, className);
return window;
}
mResizeEnabled( false ),
mType( Dali::Window::NORMAL ),
mParentWindow( NULL ),
- mPreferredOrientation( Dali::Window::PORTRAIT ),
- mRotationAngle( 0 ),
+ mPreferredAngle( Dali::Window::NO_ORIENTATION_PREFERENCE ),
+ mRotationAngle( -1 ),
mWindowWidth( 0 ),
mWindowHeight( 0 ),
+ mOrientationMode( Internal::Adaptor::Window::OrientationMode::PORTRAIT ),
+ mNativeWindowId( -1 ),
mFocusChangedSignal(),
mResizedSignal(),
- mDeleteRequestSignal()
+ mDeleteRequestSignal(),
+ mFocusChangeSignal(),
+ mResizeSignal(),
+ mVisibilityChangedSignal(),
+ mTransitionEffectEventSignal()
{
}
Window::~Window()
{
+ mIsBeingDeleted = true;
+
+ while ( mAdaptor && mAdaptor->IsRenderingWindows() )
+ {
+ std::this_thread::yield(); // to allow other threads to run
+ }
+
if ( mEventHandler )
{
mEventHandler->RemoveObserver( *this );
}
}
-void Window::Initialize(const PositionSize& positionSize, const std::string& name, const std::string& className)
+void Window::Initialize(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className)
{
// Create a window render surface
- Any surface;
auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();
mSurface = renderSurfaceFactory->CreateWindowRenderSurface( positionSize, surface, mIsTransparent );
mWindowSurface = static_cast<WindowRenderSurface*>( mSurface.get() );
mWindowBase->IconifyChangedSignal().Connect( this, &Window::OnIconifyChanged );
mWindowBase->FocusChangedSignal().Connect( this, &Window::OnFocusChanged );
mWindowBase->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest );
+ mWindowBase->TransitionEffectEventSignal().Connect( this, &Window::OnTransitionEffectEvent );
mWindowSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed );
mWindowSurface->Map();
mOrientation = Orientation::New( this );
+
+ // Get OrientationMode
+ int screenWidth, screenHeight;
+ WindowSystem::GetScreenSize( screenWidth, screenHeight );
+ if( screenWidth > screenHeight )
+ {
+ mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE;
+ }
+ else
+ {
+ mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT;
+ }
+ // For Debugging
+ mNativeWindowId = mWindowBase->GetNativeWindowId();
}
void Window::OnAdaptorSet(Dali::Adaptor& adaptor)
void Window::Raise()
{
mWindowBase->Raise();
- DALI_LOG_RELEASE_INFO( "Window (%p) Raise() \n", this );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Raise() \n", this, mNativeWindowId );
}
void Window::Lower()
{
mWindowBase->Lower();
- DALI_LOG_RELEASE_INFO( "Window (%p) Lower() \n", this );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Lower() \n", this, mNativeWindowId );
}
void Window::Activate()
{
mWindowBase->Activate();
- DALI_LOG_RELEASE_INFO( "Window (%p) Activate() \n", this );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId );
}
uint32_t Window::GetLayerCount() const
void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation )
{
- bool found = false;
+ if( IsOrientationAvailable( orientation ) == false )
+ {
+ return;
+ }
- if( orientation <= Dali::Window::LANDSCAPE_INVERSE )
+ bool found = false;
+ int convertedAngle = ConvertToAngle( orientation );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), AddAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle );
+ for( std::size_t i = 0; i < mAvailableAngles.size(); i++ )
{
- for( std::size_t i = 0; i < mAvailableOrientations.size(); i++ )
+ if( mAvailableAngles[i] == convertedAngle )
{
- if( mAvailableOrientations[i] == orientation )
- {
- found = true;
- break;
- }
+ found = true;
+ break;
}
+ }
- if( !found )
- {
- mAvailableOrientations.push_back( orientation );
- SetAvailableOrientations( mAvailableOrientations );
- }
+ if( !found )
+ {
+ mAvailableAngles.push_back( convertedAngle );
+ SetAvailableAnlges( mAvailableAngles );
}
}
void Window::RemoveAvailableOrientation( Dali::Window::WindowOrientation orientation )
{
- for( std::vector<Dali::Window::WindowOrientation>::iterator iter = mAvailableOrientations.begin();
- iter != mAvailableOrientations.end(); ++iter )
+ if( IsOrientationAvailable( orientation ) == false )
+ {
+ return;
+ }
+
+ int convertedAngle = ConvertToAngle( orientation );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), RemoveAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle );
+ for( std::vector< int >::iterator iter = mAvailableAngles.begin();
+ iter != mAvailableAngles.end(); ++iter )
{
- if( *iter == orientation )
+ if( *iter == convertedAngle )
{
- mAvailableOrientations.erase( iter );
+ mAvailableAngles.erase( iter );
break;
}
}
- SetAvailableOrientations( mAvailableOrientations );
+
+ SetAvailableAnlges( mAvailableAngles );
}
-void Window::SetAvailableOrientations( const std::vector< Dali::Window::WindowOrientation >& orientations )
+void Window::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
{
- if( orientations.size() > 4 )
+ if( orientation < Dali::Window::NO_ORIENTATION_PREFERENCE || orientation > Dali::Window::LANDSCAPE_INVERSE )
{
- DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAvailableOrientations: Invalid vector size! [%d]\n", orientations.size() );
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::CheckOrientation: Invalid input orientation [%d]\n", orientation );
return;
}
+ mPreferredAngle = ConvertToAngle( orientation );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle );
+ mWindowBase->SetPreferredAngle( mPreferredAngle );
+}
- mAvailableOrientations = orientations;
-
- mWindowBase->SetAvailableOrientations( mAvailableOrientations );
+Dali::Window::WindowOrientation Window::GetPreferredOrientation()
+{
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle );
+ Dali::Window::WindowOrientation preferredOrientation = ConvertToOrientation( mPreferredAngle );
+ return preferredOrientation;
}
-const std::vector< Dali::Window::WindowOrientation >& Window::GetAvailableOrientations()
+void Window::SetAvailableAnlges( const std::vector< int >& angles )
{
- return mAvailableOrientations;
+ if( angles.size() > 4 )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size() );
+ return;
+ }
+
+ mWindowBase->SetAvailableAnlges( angles );
}
-void Window::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
+int Window::ConvertToAngle( Dali::Window::WindowOrientation orientation )
{
- mPreferredOrientation = orientation;
+ int convertAngle = static_cast< int >( orientation );
+ if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE )
+ {
+ switch( orientation )
+ {
+ case Dali::Window::LANDSCAPE:
+ {
+ convertAngle = 0;
+ break;
+ }
+ case Dali::Window::PORTRAIT:
+ {
+ convertAngle = 90;
+ break;
+ }
+ case Dali::Window::LANDSCAPE_INVERSE:
+ {
+ convertAngle = 180;
+ break;
+ }
+ case Dali::Window::PORTRAIT_INVERSE:
+ {
+ convertAngle = 270;
+ break;
+ }
+ case Dali::Window::NO_ORIENTATION_PREFERENCE:
+ {
+ convertAngle = -1;
+ break;
+ }
+ }
+ }
+ return convertAngle;
+}
- mWindowBase->SetPreferredOrientation( mPreferredOrientation );
+Dali::Window::WindowOrientation Window::ConvertToOrientation( int angle ) const
+{
+ Dali::Window::WindowOrientation orientation = static_cast< Dali::Window::WindowOrientation >( angle );
+ if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE )
+ {
+ switch( angle )
+ {
+ case 0:
+ {
+ orientation = Dali::Window::LANDSCAPE;
+ break;
+ }
+ case 90:
+ {
+ orientation = Dali::Window::PORTRAIT;
+ break;
+ }
+ case 180:
+ {
+ orientation = Dali::Window::LANDSCAPE_INVERSE;
+ break;
+ }
+ case 270:
+ {
+ orientation = Dali::Window::PORTRAIT_INVERSE;
+ break;
+ }
+ case -1:
+ {
+ orientation = Dali::Window::NO_ORIENTATION_PREFERENCE;
+ break;
+ }
+ }
+ }
+ return orientation;
}
-Dali::Window::WindowOrientation Window::GetPreferredOrientation()
+bool Window::IsOrientationAvailable( Dali::Window::WindowOrientation orientation ) const
{
- return mPreferredOrientation;
+ if( orientation <= Dali::Window::NO_ORIENTATION_PREFERENCE || orientation > Dali::Window::LANDSCAPE_INVERSE )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::IsOrientationAvailable: Invalid input orientation [%d]\n", orientation );
+ return false;
+ }
+ return true;
}
Dali::Any Window::GetNativeHandle() const
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowShown();
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, true );
}
- DALI_LOG_RELEASE_INFO( "Window (%p) Show(): iconified = %d\n", this, mIconified );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
}
void Window::Hide()
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowHidden();
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, false );
}
- DALI_LOG_RELEASE_INFO( "Window (%p) Hide(): iconified = %d\n", this, mIconified );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
}
bool Window::IsVisible() const
{
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), IsVisible(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
return mVisible && !mIconified;
}
mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetSize(): resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height );
+
+ Dali::Window handle( this );
mResizedSignal.Emit( newSize );
+ mResizeSignal.Emit( handle, newSize );
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetPositionSize():resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height );
+ Dali::Window handle( this );
mResizedSignal.Emit( newSize );
-
+ mResizeSignal.Emit( handle, newSize );
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
}
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowHidden();
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, false );
}
- DALI_LOG_RELEASE_INFO( "Window (%p) Iconified: visible = %d\n", this, mVisible );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Iconified: visible = %d\n", this, mNativeWindowId, mVisible );
}
else
{
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowShown();
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, true );
}
- DALI_LOG_RELEASE_INFO( "Window (%p) Deiconified: visible = %d\n", this, mVisible );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible );
}
}
void Window::OnFocusChanged( bool focusIn )
{
+ Dali::Window handle( this );
mFocusChangedSignal.Emit( focusIn );
+ mFocusChangeSignal.Emit( handle, focusIn );
}
void Window::OnOutputTransformed()
mDeleteRequestSignal.Emit();
}
+void Window::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type )
+{
+ Dali::Window handle( this );
+ mTransitionEffectEventSignal.Emit( handle, state, type );
+}
+
void Window::OnTouchPoint( Dali::Integration::Point& point, int timeStamp )
{
FeedTouchPoint( point, timeStamp );
SurfaceResized();
- mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mRotationAngle, mWindowHeight ) );
+ mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), OnRotation(): resize signal emit [%d x %d]\n", this, mNativeWindowId, mWindowWidth, mWindowHeight );
// Emit signal
- mResizedSignal.Emit( Dali::Window::WindowSize( mRotationAngle, mWindowHeight ) );
+ Dali::Window handle( this );
+ mResizedSignal.Emit( Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) );
+ mResizeSignal.Emit( handle, Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) );
- mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mRotationAngle, mWindowHeight ) );
+ mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
}
void Window::OnPause()
if ( Internal::Adaptor::Adaptor::IsAvailable() )
{
Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() );
- windowImpl = static_cast<Internal::Adaptor::Window*>( adaptor.GetWindow( actor ) );
+ windowImpl = dynamic_cast<Internal::Adaptor::Window*>( adaptor.GetWindow( actor ) );
+ if( windowImpl )
+ {
+ return Dali::Window( windowImpl );
+ }
}
- return Dali::Window( windowImpl );
+ return Dali::Window();
}
void Window::SetParent( Dali::Window& parent )
if ( DALI_UNLIKELY( parent ) )
{
mParentWindow = parent;
- Dali::Window grandParent = Dali::DevelWindow::GetParent( parent );
+ Dali::Window self = Dali::Window( this );
// check circular parent window setting
- if ( DALI_UNLIKELY( grandParent ) && mWindowBase->IsMatchedWindow( grandParent.GetNativeHandle() ) )
+ if ( Dali::DevelWindow::GetParent( parent ) == self )
{
Dali::DevelWindow::Unparent( parent );
}
- mWindowBase->SetParent( parent.GetNativeHandle() );
+ mWindowBase->SetParent( GetImplementation( mParentWindow ).mWindowBase );
}
}
void Window::Unparent()
{
- Any parent;
- mWindowBase->SetParent( parent );
+ mWindowBase->SetParent( nullptr );
+ mParentWindow.Reset();
}
Dali::Window Window::GetParent()
return mParentWindow;
}
+Dali::Window::WindowOrientation Window::GetCurrentOrientation() const
+{
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mRotationAngle );
+ return ConvertToOrientation( mRotationAngle );
+}
+
+void Window::SetAvailableOrientations( const Dali::Vector<Dali::Window::WindowOrientation>& orientations )
+{
+ Dali::Vector<float>::SizeType count = orientations.Count();
+ for( Dali::Vector<float>::SizeType index = 0; index < count; ++index )
+ {
+ if( IsOrientationAvailable( orientations[index] ) == false )
+ {
+ DALI_LOG_ERROR("Window::SetAvailableOrientations, invalid orientation: %d\n", orientations[index]);
+ continue;
+ }
+
+ bool found = false;
+ int convertedAngle = ConvertToAngle( orientations[index] );
+
+ for( std::size_t i = 0; i < mAvailableAngles.size(); i++ )
+ {
+ if( mAvailableAngles[i] == convertedAngle )
+ {
+ found = true;
+ break;
+ }
+ }
+
+ if( !found )
+ {
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetAvailableOrientations: %d\n", this, mNativeWindowId, convertedAngle );
+ mAvailableAngles.push_back( convertedAngle );
+ }
+ }
+ SetAvailableAnlges( mAvailableAngles );
+}
+
} // Adaptor
} // Internal
projects / platform / core / uifw / dali-adaptor.git / blobdiff