X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fwindow-system%2Fcommon%2Fwindow-impl.cpp;h=443f86a3ff543c8eb6a593658e38b78b3ba10d40;hb=ea1bf2eb95d5f8b3529580da2f20c824dafba3a0;hp=fd9d99abe97a891d0ae523eb6f1d355283cbc492;hpb=a588a60f8808b305babc5a94664bfa1b59cdc930;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 index fd9d99a..7e9a4fd 100644 --- a/dali/internal/window-system/common/window-impl.cpp +++ b/dali/internal/window-system/common/window-impl.cpp @@ -20,7 +20,6 @@ // EXTERNAL HEADERS #include -#include #include #include #include @@ -28,15 +27,17 @@ #include #include #include +#include // INTERNAL HEADERS -#include -#include +#include +#include #include #include #include #include #include +#include namespace Dali { @@ -45,8 +46,6 @@ namespace Internal namespace Adaptor { -uint32_t Window::mWindowCounter = 0; - namespace { @@ -65,48 +64,35 @@ Window* Window::New( const PositionSize& positionSize, const std::string& name, } 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 ), + mParentWindow( NULL ), mPreferredOrientation( Dali::Window::PORTRAIT ), - mIndicatorVisibilityChangedSignal(), + mRotationAngle( 0 ), + mWindowWidth( 0 ), + mWindowHeight( 0 ), mFocusChangedSignal(), mResizedSignal(), - mDeleteRequestSignal() + mDeleteRequestSignal(), + mFocusChangeSignal(), + mResizeSignal(), + mVisibilityChangedSignal(), + mTransitionEffectEventSignal() { } 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) @@ -115,17 +101,18 @@ void Window::Initialize(const PositionSize& positionSize, const std::string& nam 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 ); - mSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed ); + mWindowSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed ); if( !positionSize.IsEmpty() ) { @@ -135,119 +122,62 @@ 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) +void Window::OnAdaptorSet(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 ) - { - mOrientation->SetAdaptor(adaptor); - } - - if( mIndicator != NULL ) - { - mIndicator->SetAdaptor(mAdaptor); - } - - mSurface->SetAdaptor( *mAdaptor ); + mEventHandler = EventHandlerPtr(new EventHandler( mWindowSurface, *mAdaptor ) ); + mEventHandler->AddObserver( *this ); } -WindowRenderSurface* Window::GetSurface() +void Window::OnSurfaceSet( Dali::RenderSurfaceInterface* surface ) { - return mSurface.get(); + mWindowSurface = static_cast( surface ); } void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode ) { - // TODO: Enable this after indicator implementation based on tizen 5. -// mIndicatorVisible = visibleMode; - - mWindowBase->ShowIndicator( mIndicatorVisible, mIndicatorOpacityMode ); - - DoShowIndicator( mIndicatorOrientation ); } void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode ) { - mIndicatorOpacityMode = opacityMode; - - if( mIndicator != NULL ) - { - mIndicator->SetOpacityMode( opacityMode ); - } -} - -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 ) { - DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "Orientation: %d\n", orientation ); - - DoRotateIndicator( orientation ); } void Window::SetClass( std::string name, std::string className ) { + mName = name; + mClassName = className; mWindowBase->SetClass( name, className ); } +std::string Window::GetClassName() const +{ + return mClassName; +} + void Window::Raise() { mWindowBase->Raise(); + DALI_LOG_RELEASE_INFO( "Window (%p) Raise() \n", this ); } void Window::Lower() { mWindowBase->Lower(); + DALI_LOG_RELEASE_INFO( "Window (%p) Lower() \n", this ); } void Window::Activate() { mWindowBase->Activate(); -} - -void Window::Add( Dali::Actor actor ) -{ - mScene.Add( actor ); -} - -void Window::Remove( Dali::Actor actor ) -{ - mScene.Remove( actor ); -} - -Dali::Layer Window::GetRootLayer() const -{ - return mScene.GetRootLayer(); + DALI_LOG_RELEASE_INFO( "Window (%p) Activate() \n", this ); } uint32_t Window::GetLayerCount() const @@ -260,17 +190,9 @@ Dali::Layer Window::GetLayer( uint32_t depth ) const return mScene.GetLayer( depth ); } -void Window::SetBackgroundColor( Vector4 color ) +Dali::RenderTaskList Window::GetRenderTaskList() const { - if ( mSurface ) - { - mSurface->SetBackgroundColor( color ); - } -} - -Vector4 Window::GetBackgroundColor() const -{ - return mSurface ? mSurface->GetBackgroundColor() : Vector4(); + return mScene.GetRenderTaskList(); } void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation ) @@ -340,14 +262,9 @@ Dali::Window::WindowOrientation Window::GetPreferredOrientation() return mPreferredOrientation; } -Dali::DragAndDropDetector Window::GetDragAndDropDetector() const -{ - return mDragAndDropDetector; -} - Dali::Any Window::GetNativeHandle() const { - return mSurface->GetNativeWindow(); + return mWindowSurface->GetNativeWindow(); } void Window::SetAcceptFocus( bool accept ) @@ -372,8 +289,12 @@ 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 ); } + + DALI_LOG_RELEASE_INFO( "Window (%p) Show(): iconified = %d\n", this, mIconified ); } void Window::Hide() @@ -386,13 +307,17 @@ 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) Hide(): iconified = %d\n", this, mIconified ); } bool Window::IsVisible() const { - return mVisible; + return mVisible && !mIconified; } unsigned int Window::GetSupportedAuxiliaryHintCount() const @@ -524,7 +449,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,9 +458,19 @@ void Window::SetSize( Dali::Window::WindowSize size ) { Uint16Pair newSize( newRect.width, newRect.height ); + bool forceUpdate = false; + if( mWindowBase->IsEglWindowRotationSupported() ) + { + forceUpdate = true; + } + + SurfaceResized( forceUpdate ); + mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize ); + Dali::Window handle( this ); mResizedSignal.Emit( newSize ); + mResizeSignal.Emit( handle, newSize ); mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize ); } @@ -558,7 +493,7 @@ 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 ) ); } Dali::Window::WindowPosition Window::GetPosition() const @@ -578,7 +513,7 @@ void Window::SetPositionSize( PositionSize positionSize ) PositionSize oldRect = mSurface->GetPositionSize(); - mSurface->MoveResize( positionSize ); + mWindowSurface->MoveResize( positionSize ); PositionSize newRect = mSurface->GetPositionSize(); @@ -587,17 +522,31 @@ void Window::SetPositionSize( PositionSize positionSize ) { Uint16Pair newSize( newRect.width, newRect.height ); + bool forceUpdate = false; + if( mWindowBase->IsEglWindowRotationSupported() ) + { + forceUpdate = true; + } + + SurfaceResized( forceUpdate ); + mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize ); + Dali::Window handle( this ); mResizedSignal.Emit( newSize ); - + mResizeSignal.Emit( handle, newSize ); mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize ); } } +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 +569,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 +579,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) Iconified: visible = %d\n", this, mVisible ); } else { @@ -752,19 +594,31 @@ 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) Deiconified: visible = %d\n", this, mVisible ); } } void Window::OnFocusChanged( bool focusIn ) { + Dali::Window handle( this ); mFocusChangedSignal.Emit( focusIn ); + mFocusChangeSignal.Emit( handle, focusIn ); } void Window::OnOutputTransformed() { + bool forceUpdate = false; + if( mWindowBase->IsEglWindowRotationSupported() ) + { + forceUpdate = true; + } PositionSize positionSize = mSurface->GetPositionSize(); + SurfaceResized( forceUpdate ); mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); } @@ -774,79 +628,144 @@ 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::OnTouchPoint( Dali::Integration::Point& point, int timeStamp ) { - mWindowBase->IndicatorTypeChanged( type ); + FeedTouchPoint( point, timeStamp ); } -void Window::IndicatorClosed( IndicatorInterface* indicator ) +void Window::OnWheelEvent( Dali::Integration::WheelEvent& wheelEvent ) { - DALI_LOG_TRACE_METHOD( gWindowLogFilter ); - - if( mShowRotatedIndicatorOnClose ) - { - Dali::Window::WindowOrientation currentOrientation = mIndicatorOrientation; - if( mIndicator ) - { - mIndicator->Open( mNextIndicatorOrientation ); - } - mIndicatorOrientation = mNextIndicatorOrientation; - SetIndicatorActorRotation(); - DoShowIndicator( currentOrientation ); - } + FeedWheelEvent( wheelEvent ); } -void Window::IndicatorVisibilityChanged( bool isVisible ) +void Window::OnKeyEvent( Dali::Integration::KeyEvent& keyEvent ) { - mIndicatorVisibilityChangedSignal.Emit( isVisible ); + FeedKeyEvent( keyEvent ); } -void Window::OnStart() +void Window::OnRotation( const RotationEvent& rotation ) { - DoShowIndicator( mIndicatorOrientation ); + mRotationAngle = rotation.angle; + mWindowWidth = rotation.width; + mWindowHeight = rotation.height; + + // Notify that the orientation is changed + mOrientation->OnOrientationChange( rotation ); + + mWindowSurface->RequestRotation( mRotationAngle, mWindowWidth, mWindowHeight ); + + bool forceUpdate = false; + if( mWindowBase->IsEglWindowRotationSupported() ) + { + forceUpdate = true; + } + + SurfaceResized( forceUpdate ); + + mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) ); + + // Emit signal + 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( mWindowWidth, mWindowHeight ) ); } void Window::OnPause() { + if( mEventHandler ) + { + mEventHandler->Pause(); + } } void Window::OnResume() { - // resume indicator status - if( mIndicator != NULL ) + if( mEventHandler ) + { + mEventHandler->Resume(); + } +} + +void Window::RecalculateTouchPosition( Integration::Point& point ) +{ + Vector2 position = point.GetScreenPosition(); + Vector2 convertedPosition; + + switch( mRotationAngle ) { - // Restore own indicator opacity - // Send opacity mode to indicator service when app resumed - mIndicator->SetOpacityMode( mIndicatorOpacityMode ); + 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; + } } + + point.SetScreenPosition( convertedPosition ); } -void Window::OnStop() +Dali::Window Window::Get( Dali::Actor actor ) { - if( mIndicator ) + Internal::Adaptor::Window* windowImpl = nullptr; + + if ( Internal::Adaptor::Adaptor::IsAvailable() ) { - mIndicator->Close(); + Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() ); + windowImpl = static_cast( adaptor.GetWindow( actor ) ); } - mIndicator.release(); + return Dali::Window( windowImpl ); +} + +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::OnDestroy() +void Window::Unparent() { - mAdaptor = NULL; + mWindowBase->SetParent( nullptr ); + mParentWindow.Reset(); } -uint32_t Window::GetId() const +Dali::Window Window::GetParent() { - return mId; + return mParentWindow; } } // Adaptor