X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fwindow-system%2Fcommon%2Fwindow-impl.cpp;h=981ede0748435eb04ff5763dcf6ae96e2627ad47;hb=1d0d7873858fd2010b71e5db8f03654fb307370f;hp=fd9d99abe97a891d0ae523eb6f1d355283cbc492;hpb=09e6892adcddf6d2bf7c88dc8442a42da2ac57f5;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/window-system/common/window-impl.cpp b/dali/internal/window-system/common/window-impl.cpp old mode 100644 new mode 100755 index fd9d99a..5fa120c --- a/dali/internal/window-system/common/window-impl.cpp +++ b/dali/internal/window-system/common/window-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 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. @@ -19,8 +19,8 @@ #include // EXTERNAL HEADERS +#include #include -#include #include #include #include @@ -28,15 +28,19 @@ #include #include #include +#include // INTERNAL HEADERS -#include -#include +#include +#include +#include #include #include #include #include +#include #include +#include namespace Dali { @@ -45,8 +49,6 @@ namespace Internal namespace Adaptor { -uint32_t Window::mWindowCounter = 0; - namespace { @@ -56,76 +58,72 @@ Debug::Filter* gWindowLogFilter = Debug::Filter::New( Debug::NoLogging, false, " } // 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; } Window::Window() -: mId( mWindowCounter++ ), - mSurface( nullptr ), +: mWindowSurface( nullptr ), mWindowBase(), - mIndicatorVisible( Dali::Window::INVISIBLE ), // TODO: Enable this after indicator implementation based on tizen 5. - mIndicatorIsShown( false ), - mShowRotatedIndicatorOnClose( false ), - mStarted( false ), + mIsTransparent( false ), mIsFocusAcceptable( true ), - mVisible( true ), mIconified( false ), mOpaqueState( false ), mResizeEnabled( false ), - mIndicator(), - mIndicatorOrientation( Dali::Window::PORTRAIT ), - mNextIndicatorOrientation( Dali::Window::PORTRAIT ), - mIndicatorOpacityMode( Dali::Window::OPAQUE ), - mAdaptor( NULL ), mType( Dali::Window::NORMAL ), - mPreferredOrientation( Dali::Window::PORTRAIT ), - mIndicatorVisibilityChangedSignal(), - mFocusChangedSignal(), - mResizedSignal(), - mDeleteRequestSignal() + mParentWindow( NULL ), + mPreferredAngle( Dali::Window::NO_ORIENTATION_PREFERENCE ), + mRotationAngle( -1 ), + mWindowWidth( 0 ), + mWindowHeight( 0 ), + mOrientationMode( Internal::Adaptor::Window::OrientationMode::PORTRAIT ), + mNativeWindowId( -1 ), + mDeleteRequestSignal(), + mFocusChangeSignal(), + mResizeSignal(), + mVisibilityChangedSignal(), + mTransitionEffectEventSignal(), + mKeyboardRepeatSettingsChangedSignal() { } Window::~Window() { - if( mIndicator ) - { - mIndicator->Close(); - } - - if ( mAdaptor ) + if ( mEventHandler ) { - mAdaptor->RemoveObserver( *this ); - mAdaptor->SetDragAndDropDetector( NULL ); - mAdaptor->RemoveWindow( this ); - mAdaptor = NULL; + mEventHandler->RemoveObserver( *this ); } - - mSurface.reset( nullptr ); } -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( mSurface.get() ); // Get a window base - mWindowBase = mSurface->GetWindowBase(); + mWindowBase = mWindowSurface->GetWindowBase(); // Connect signals mWindowBase->IconifyChangedSignal().Connect( this, &Window::OnIconifyChanged ); mWindowBase->FocusChangedSignal().Connect( this, &Window::OnFocusChanged ); mWindowBase->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest ); - mWindowBase->IndicatorFlickedSignal().Connect( this, &Window::OnIndicatorFlicked ); + mWindowBase->TransitionEffectEventSignal().Connect( this, &Window::OnTransitionEffectEvent ); + mWindowBase->KeyboardRepeatSettingsChangedSignal().Connect( this, &Window::OnKeyboardRepeatSettingsChanged ); + mWindowBase->WindowRedrawRequestSignal().Connect( this, &Window::OnWindowRedrawRequest ); - mSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed ); + mWindowSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed ); if( !positionSize.IsEmpty() ) { @@ -135,119 +133,73 @@ void Window::Initialize(const PositionSize& positionSize, const std::string& nam SetClass( name, className ); - mSurface->Map(); + mWindowSurface->Map(); mOrientation = Orientation::New( this ); -} - -void Window::SetAdaptor(Dali::Adaptor& adaptor) -{ - DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" ); - mStarted = true; - - PositionSize positionSize = mSurface->GetPositionSize(); - mScene = Dali::Integration::Scene::New( Vector2(positionSize.width, positionSize.height) ); - mScene.SetSurface( *mSurface.get() ); - - unsigned int dpiHorizontal, dpiVertical; - dpiHorizontal = dpiVertical = 0; - mSurface->GetDpi( dpiHorizontal, dpiVertical ); - mScene.SetDpi( Vector2( static_cast( dpiHorizontal ), static_cast( dpiVertical ) ) ); - - // Create one overlay for the main window only - Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor); - mAdaptor = &adaptorImpl; - mAdaptor->AddObserver( *this ); - - // Can only create the detector when we know the Core has been instantiated. - mDragAndDropDetector = DragAndDropDetector::New(); - mAdaptor->SetDragAndDropDetector( &GetImplementation( mDragAndDropDetector ) ); - - if( mOrientation ) + // Get OrientationMode + int screenWidth, screenHeight; + WindowSystem::GetScreenSize( screenWidth, screenHeight ); + if( screenWidth > screenHeight ) { - mOrientation->SetAdaptor(adaptor); + mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE; } - - if( mIndicator != NULL ) + else { - mIndicator->SetAdaptor(mAdaptor); + mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT; } - - mSurface->SetAdaptor( *mAdaptor ); -} - -WindowRenderSurface* Window::GetSurface() -{ - return mSurface.get(); + // For Debugging + mNativeWindowId = mWindowBase->GetNativeWindowId(); } -void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode ) +void Window::OnAdaptorSet(Dali::Adaptor& adaptor) { - // TODO: Enable this after indicator implementation based on tizen 5. -// mIndicatorVisible = visibleMode; - - mWindowBase->ShowIndicator( mIndicatorVisible, mIndicatorOpacityMode ); - - DoShowIndicator( mIndicatorOrientation ); + mEventHandler = EventHandlerPtr(new EventHandler( mWindowSurface, *mAdaptor ) ); + mEventHandler->AddObserver( *this ); } -void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode ) +void Window::OnSurfaceSet( Dali::RenderSurfaceInterface* surface ) { - mIndicatorOpacityMode = opacityMode; - - if( mIndicator != NULL ) - { - mIndicator->SetOpacityMode( opacityMode ); - } + mWindowSurface = static_cast( surface ); } -void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode ) -{ - // TODO: Enable this after indicator implementation based on tizen 5. -// mIndicatorVisible = mode; -} - -void Window::RotateIndicator( Dali::Window::WindowOrientation orientation ) +void Window::SetClass( std::string name, std::string className ) { - DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "Orientation: %d\n", orientation ); - - DoRotateIndicator( orientation ); + mName = name; + mClassName = className; + mWindowBase->SetClass( name, className ); } -void Window::SetClass( std::string name, std::string className ) +std::string Window::GetClassName() const { - mWindowBase->SetClass( name, className ); + return mClassName; } void Window::Raise() { mWindowBase->Raise(); + + mSurface->SetFullSwapNextFrame(); + + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Raise() \n", this, mNativeWindowId ); } void Window::Lower() { mWindowBase->Lower(); + + mSurface->SetFullSwapNextFrame(); + + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Lower() \n", this, mNativeWindowId ); } void Window::Activate() { mWindowBase->Activate(); -} -void Window::Add( Dali::Actor actor ) -{ - mScene.Add( actor ); -} + mSurface->SetFullSwapNextFrame(); -void Window::Remove( Dali::Actor actor ) -{ - mScene.Remove( actor ); -} - -Dali::Layer Window::GetRootLayer() const -{ - return mScene.GetRootLayer(); + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId ); } uint32_t Window::GetLayerCount() const @@ -260,94 +212,176 @@ Dali::Layer Window::GetLayer( uint32_t depth ) const return mScene.GetLayer( depth ); } -void Window::SetBackgroundColor( Vector4 color ) -{ - if ( mSurface ) - { - mSurface->SetBackgroundColor( color ); - } -} - -Vector4 Window::GetBackgroundColor() const +Dali::RenderTaskList Window::GetRenderTaskList() const { - return mSurface ? mSurface->GetBackgroundColor() : Vector4(); + return mScene.GetRenderTaskList(); } 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::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; } - - mAvailableOrientations = orientations; - - mWindowBase->SetAvailableOrientations( mAvailableOrientations ); + mPreferredAngle = ConvertToAngle( orientation ); + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle ); + mWindowBase->SetPreferredAngle( mPreferredAngle ); } -const std::vector< Dali::Window::WindowOrientation >& Window::GetAvailableOrientations() +Dali::Window::WindowOrientation Window::GetPreferredOrientation() { - return mAvailableOrientations; + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle ); + Dali::Window::WindowOrientation preferredOrientation = ConvertToOrientation( mPreferredAngle ); + return preferredOrientation; } -void Window::SetPreferredOrientation( Dali::Window::WindowOrientation orientation ) +void Window::SetAvailableAnlges( const std::vector< int >& angles ) { - mPreferredOrientation = orientation; + if( angles.size() > 4 ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size() ); + return; + } - mWindowBase->SetPreferredOrientation( mPreferredOrientation ); + mWindowBase->SetAvailableAnlges( angles ); } -Dali::Window::WindowOrientation Window::GetPreferredOrientation() +int Window::ConvertToAngle( Dali::Window::WindowOrientation 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; +} + +Dali::Window::WindowOrientation Window::ConvertToOrientation( int angle ) const { - return mPreferredOrientation; + 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::DragAndDropDetector Window::GetDragAndDropDetector() const +bool Window::IsOrientationAvailable( Dali::Window::WindowOrientation orientation ) const { - return mDragAndDropDetector; + 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 { - return mSurface->GetNativeWindow(); + return mWindowSurface->GetNativeWindow(); } void Window::SetAcceptFocus( bool accept ) @@ -372,8 +406,14 @@ void Window::Show() { WindowVisibilityObserver* observer( mAdaptor ); observer->OnWindowShown(); - DALI_LOG_RELEASE_INFO( "Window (%p) ::Show()\n", this ); + + Dali::Window handle( this ); + mVisibilityChangedSignal.Emit( handle, true ); } + + mSurface->SetFullSwapNextFrame(); + + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible ); } void Window::Hide() @@ -386,13 +426,18 @@ void Window::Hide() { WindowVisibilityObserver* observer( mAdaptor ); observer->OnWindowHidden(); - DALI_LOG_RELEASE_INFO( "Window (%p) ::Hide() \n", this ); + + Dali::Window handle( this ); + mVisibilityChangedSignal.Emit( handle, false ); } + + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible ); } bool Window::IsVisible() const { - return mVisible; + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), IsVisible(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible ); + return mVisible && !mIconified; } unsigned int Window::GetSupportedAuxiliaryHintCount() const @@ -524,7 +569,7 @@ void Window::SetSize( Dali::Window::WindowSize size ) PositionSize oldRect = mSurface->GetPositionSize(); - mSurface->MoveResize( PositionSize( oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight() ) ); + mWindowSurface->MoveResize( PositionSize( oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight() ) ); PositionSize newRect = mSurface->GetPositionSize(); @@ -533,12 +578,19 @@ void Window::SetSize( Dali::Window::WindowSize size ) { Uint16Pair newSize( newRect.width, newRect.height ); + SurfaceResized(); + mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize ); - mResizedSignal.Emit( 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 ); + mResizeSignal.Emit( handle, newSize ); mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize ); } + + mSurface->SetFullSwapNextFrame(); } Dali::Window::WindowSize Window::GetSize() const @@ -558,7 +610,9 @@ void Window::SetPosition( Dali::Window::WindowPosition position ) PositionSize oldRect = mSurface->GetPositionSize(); - mSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) ); + mWindowSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) ); + + mSurface->SetFullSwapNextFrame(); } Dali::Window::WindowPosition Window::GetPosition() const @@ -578,7 +632,7 @@ void Window::SetPositionSize( PositionSize positionSize ) PositionSize oldRect = mSurface->GetPositionSize(); - mSurface->MoveResize( positionSize ); + mWindowSurface->MoveResize( positionSize ); PositionSize newRect = mSurface->GetPositionSize(); @@ -587,17 +641,27 @@ void Window::SetPositionSize( PositionSize positionSize ) { Uint16Pair newSize( newRect.width, newRect.height ); - mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize ); + SurfaceResized(); - mResizedSignal.Emit( 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 ); + mResizeSignal.Emit( handle, newSize ); mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize ); } + + mSurface->SetFullSwapNextFrame(); +} + +Dali::Layer Window::GetRootLayer() const +{ + return mScene.GetRootLayer(); } void Window::SetTransparency( bool transparent ) { - mSurface->SetTransparency( transparent ); + mWindowSurface->SetTransparency( transparent ); } bool Window::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) @@ -620,117 +684,6 @@ bool Window::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< return mWindowBase->UngrabKeyList( key, result ); } -void Window::RotationDone( int orientation, int width, int height ) -{ - mSurface->RequestRotation( orientation, width, height ); - - mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( width, height ) ); - - // Emit signal - mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) ); - - mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( width, height ) ); -} - -void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation ) -{ - if( mIndicator == NULL ) - { - if( mIndicatorVisible != Dali::Window::INVISIBLE ) - { - auto windowFactory = Dali::Internal::Adaptor::GetWindowFactory(); - mIndicator = windowFactory->CreateIndicator( mAdaptor, mIndicatorOrientation, this ); - if( mIndicator ) - { - mIndicator->SetOpacityMode( mIndicatorOpacityMode ); - Dali::Actor actor = mIndicator->GetActor(); - SetIndicatorActorRotation(); - } - } - // else don't create a hidden indicator - } - else // Already have indicator - { - if( mIndicatorVisible == Dali::Window::VISIBLE ) - { - // If we are resuming, and rotation has changed, - if( mIndicatorIsShown == false && mIndicatorOrientation != mNextIndicatorOrientation ) - { - // then close current indicator and open new one - mShowRotatedIndicatorOnClose = true; - mIndicator->Close(); // May synchronously call IndicatorClosed() callback & 1 level of recursion - // Don't show actor - will contain indicator for old orientation. - } - } - } - - // set indicator visible mode - if( mIndicator != NULL ) - { - mIndicator->SetVisible( mIndicatorVisible ); - } - - bool show = (mIndicatorVisible != Dali::Window::INVISIBLE ); - SetIndicatorProperties( show, lastOrientation ); - mIndicatorIsShown = show; -} - -void Window::DoRotateIndicator( Dali::Window::WindowOrientation orientation ) -{ - if( mIndicatorIsShown ) - { - mShowRotatedIndicatorOnClose = true; - mNextIndicatorOrientation = orientation; - if( mIndicator ) - { - mIndicator->Close(); // May synchronously call IndicatorClosed() callback - } - } - else - { - // Save orientation for when the indicator is next shown - mShowRotatedIndicatorOnClose = false; - mNextIndicatorOrientation = orientation; - } -} - -void Window::SetIndicatorActorRotation() -{ - DALI_LOG_TRACE_METHOD( gWindowLogFilter ); - if( mIndicator ) - { - Dali::Actor actor = mIndicator->GetActor(); - switch( mIndicatorOrientation ) - { - case Dali::Window::PORTRAIT: - actor.SetParentOrigin( ParentOrigin::TOP_CENTER ); - actor.SetAnchorPoint( AnchorPoint::TOP_CENTER ); - actor.SetOrientation( Degree(0), Vector3::ZAXIS ); - break; - case Dali::Window::PORTRAIT_INVERSE: - actor.SetParentOrigin( ParentOrigin::BOTTOM_CENTER ); - actor.SetAnchorPoint( AnchorPoint::TOP_CENTER ); - actor.SetOrientation( Degree(180), Vector3::ZAXIS ); - break; - case Dali::Window::LANDSCAPE: - actor.SetParentOrigin( ParentOrigin::CENTER_LEFT ); - actor.SetAnchorPoint( AnchorPoint::TOP_CENTER ); - actor.SetOrientation( Degree(270), Vector3::ZAXIS ); - break; - case Dali::Window::LANDSCAPE_INVERSE: - actor.SetParentOrigin( ParentOrigin::CENTER_RIGHT ); - actor.SetAnchorPoint( AnchorPoint::TOP_CENTER ); - actor.SetOrientation( Degree(90), Vector3::ZAXIS ); - break; - } - } -} - -void Window::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientation lastOrientation ) -{ - mWindowBase->SetIndicatorProperties( isShow, lastOrientation ); -} - void Window::OnIconifyChanged( bool iconified ) { if( iconified ) @@ -741,8 +694,12 @@ void Window::OnIconifyChanged( bool iconified ) { WindowVisibilityObserver* observer( mAdaptor ); observer->OnWindowHidden(); - DALI_LOG_RELEASE_INFO( "Window (%p) Iconified\n", this ); + + Dali::Window handle( this ); + mVisibilityChangedSignal.Emit( handle, false ); } + + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Iconified: visible = %d\n", this, mNativeWindowId, mVisible ); } else { @@ -752,19 +709,29 @@ void Window::OnIconifyChanged( bool iconified ) { WindowVisibilityObserver* observer( mAdaptor ); observer->OnWindowShown(); - DALI_LOG_RELEASE_INFO( "Window (%p) Deiconified\n", this ); + + Dali::Window handle( this ); + mVisibilityChangedSignal.Emit( handle, true ); } + + DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible ); } + + mSurface->SetFullSwapNextFrame(); } void Window::OnFocusChanged( bool focusIn ) { - mFocusChangedSignal.Emit( focusIn ); + Dali::Window handle( this ); + mFocusChangeSignal.Emit( handle, focusIn ); + + mSurface->SetFullSwapNextFrame(); } void Window::OnOutputTransformed() { PositionSize positionSize = mSurface->GetPositionSize(); + SurfaceResized(); mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); } @@ -774,79 +741,198 @@ void Window::OnDeleteRequest() mDeleteRequestSignal.Emit(); } -void Window::OnIndicatorFlicked() +void Window::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type ) { - if( mIndicator ) - { - mIndicator->Flicked(); - } + Dali::Window handle( this ); + mTransitionEffectEventSignal.Emit( handle, state, type ); } -void Window::IndicatorTypeChanged( IndicatorInterface::Type type ) +void Window::OnKeyboardRepeatSettingsChanged() { - mWindowBase->IndicatorTypeChanged( type ); + Dali::Window handle( this ); + mKeyboardRepeatSettingsChangedSignal.Emit(); } -void Window::IndicatorClosed( IndicatorInterface* indicator ) +void Window::OnWindowRedrawRequest() { - DALI_LOG_TRACE_METHOD( gWindowLogFilter ); + mAdaptor->RenderOnce(); +} - if( mShowRotatedIndicatorOnClose ) - { - Dali::Window::WindowOrientation currentOrientation = mIndicatorOrientation; - if( mIndicator ) - { - mIndicator->Open( mNextIndicatorOrientation ); - } - mIndicatorOrientation = mNextIndicatorOrientation; - SetIndicatorActorRotation(); - DoShowIndicator( currentOrientation ); - } +void Window::OnTouchPoint( Dali::Integration::Point& point, int timeStamp ) +{ + FeedTouchPoint( point, timeStamp ); } -void Window::IndicatorVisibilityChanged( bool isVisible ) +void Window::OnWheelEvent( Dali::Integration::WheelEvent& wheelEvent ) { - mIndicatorVisibilityChangedSignal.Emit( isVisible ); + FeedWheelEvent( wheelEvent ); } -void Window::OnStart() +void Window::OnKeyEvent( Dali::Integration::KeyEvent& keyEvent ) { - DoShowIndicator( mIndicatorOrientation ); + FeedKeyEvent( keyEvent ); +} + +void Window::OnRotation( const RotationEvent& rotation ) +{ + mRotationAngle = rotation.angle; + mWindowWidth = rotation.width; + mWindowHeight = rotation.height; + + // Notify that the orientation is changed + mOrientation->OnOrientationChange( rotation ); + + mWindowSurface->RequestRotation( mRotationAngle, mWindowWidth, mWindowHeight ); + + SurfaceResized(); + + 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 + Dali::Window handle( this ); + mResizeSignal.Emit( handle, Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) ); + + mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) ); } void Window::OnPause() { + if( mEventHandler ) + { + mEventHandler->Pause(); + } } void Window::OnResume() { - // resume indicator status - if( mIndicator != NULL ) + if( mEventHandler ) { - // Restore own indicator opacity - // Send opacity mode to indicator service when app resumed - mIndicator->SetOpacityMode( mIndicatorOpacityMode ); + mEventHandler->Resume(); } + + mSurface->SetFullSwapNextFrame(); } -void Window::OnStop() +void Window::RecalculateTouchPosition( Integration::Point& point ) { - if( mIndicator ) + Vector2 position = point.GetScreenPosition(); + Vector2 convertedPosition; + + switch( mRotationAngle ) { - mIndicator->Close(); + case 90: + { + convertedPosition.x = static_cast( mWindowWidth ) - position.y; + convertedPosition.y = position.x; + break; + } + case 180: + { + convertedPosition.x = static_cast( mWindowWidth ) - position.x; + convertedPosition.y = static_cast( mWindowHeight ) - position.y; + break; + } + case 270: + { + convertedPosition.x = position.y; + convertedPosition.y = static_cast( mWindowHeight ) - position.x; + break; + } + default: + { + convertedPosition = position; + break; + } } - mIndicator.release(); + point.SetScreenPosition( convertedPosition ); } -void Window::OnDestroy() +Dali::Window Window::Get( Dali::Actor actor ) { - mAdaptor = NULL; + Internal::Adaptor::Window* windowImpl = nullptr; + + if ( Internal::Adaptor::Adaptor::IsAvailable() ) + { + Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() ); + windowImpl = dynamic_cast( adaptor.GetWindow( actor ) ); + if( windowImpl ) + { + return Dali::Window( windowImpl ); + } + } + + return Dali::Window(); +} + +void Window::SetParent( Dali::Window& parent ) +{ + if ( DALI_UNLIKELY( parent ) ) + { + mParentWindow = parent; + Dali::Window self = Dali::Window( this ); + // check circular parent window setting + if ( Dali::DevelWindow::GetParent( parent ) == self ) + { + Dali::DevelWindow::Unparent( parent ); + } + mWindowBase->SetParent( GetImplementation( mParentWindow ).mWindowBase ); + } +} + +void Window::Unparent() +{ + 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& orientations ) +{ + Dali::Vector::SizeType count = orientations.Count(); + for( Dali::Vector::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 ); } -uint32_t Window::GetId() const +int32_t Window::GetNativeId() const { - return mId; + return mWindowBase->GetNativeWindowId(); } } // Adaptor