X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fwindow-system%2Fcommon%2Fwindow-impl.cpp;h=514a490b6dd71cc0deba24dbbbcf411d8d54c53a;hb=0f89686c3137b7972e41c44e48c0da5de385a360;hp=443f86a3ff543c8eb6a593658e38b78b3ba10d40;hpb=95780f5e547854421fe3a310481a9a047f90c4cf;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 443f86a..44f8b66 100644 --- 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) 2021 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,29 +19,29 @@ #include // EXTERNAL HEADERS +#include #include -#include +#include #include -#include #include -#include +#include +#include #include +#include #include -#include - -#ifdef DALI_ADAPTOR_COMPILATION -#include -#else -#include -#endif +#include // INTERNAL HEADERS +#include +#include +#include #include #include #include -#include #include +#include #include +#include #include namespace Dali @@ -50,112 +50,146 @@ namespace Internal { namespace Adaptor { - namespace { - #if defined(DEBUG_ENABLED) -Debug::Filter* gWindowLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_WINDOW" ); +Debug::Filter* gWindowLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW"); #endif } // 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, Dali::WindowType type, bool isTransparent) +{ + Any surface; + return Window::New(surface, positionSize, name, className, type, isTransparent); +} + +Window* Window::New(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, Dali::WindowType type, bool isTransparent) { - Window* window = new Window(); + Window* window = new Window(); window->mIsTransparent = isTransparent; - window->Initialize( positionSize, name, className ); + window->Initialize(surface, positionSize, name, className, type); return window; } Window::Window() -: mWindowSurface( nullptr ), +: mWindowSurface(nullptr), mWindowBase(), - mIsTransparent( false ), - mIsFocusAcceptable( true ), - mIconified( false ), - mOpaqueState( false ), - mResizeEnabled( false ), - mType( Dali::Window::NORMAL ), - mPreferredOrientation( Dali::Window::PORTRAIT ), - mFocusChangedSignal(), - mResizedSignal(), - mDeleteRequestSignal() + mIsTransparent(false), + mIsFocusAcceptable(true), + mIconified(false), + mOpaqueState(false), + mParentWindow(NULL), + mPreferredAngle(static_cast(WindowOrientation::NO_ORIENTATION_PREFERENCE)), + mRotationAngle(0), + mWindowWidth(0), + mWindowHeight(0), + mOrientationMode(Internal::Adaptor::Window::OrientationMode::PORTRAIT), + mNativeWindowId(-1), + mDeleteRequestSignal(), + mFocusChangeSignal(), + mResizeSignal(), + mVisibilityChangedSignal(), + mTransitionEffectEventSignal(), + mKeyboardRepeatSettingsChangedSignal() { } Window::~Window() { - if ( mEventHandler ) + if(mAdaptor) { - mEventHandler->SetRotationObserver( nullptr ); + auto bridge = Accessibility::Bridge::GetCurrentBridge(); + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer); + bridge->RemoveTopLevelWindow(accessible); + + mAdaptor->RemoveWindow(this); + } + + 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, WindowType type) { // Create a window render surface - Any surface; auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory(); - mSurface = renderSurfaceFactory->CreateWindowRenderSurface( positionSize, surface, mIsTransparent ); - mWindowSurface = static_cast( mSurface.get() ); + mSurface = renderSurfaceFactory->CreateWindowRenderSurface(positionSize, surface, mIsTransparent); + mWindowSurface = static_cast(mSurface.get()); // Get a window base mWindowBase = mWindowSurface->GetWindowBase(); - // Connect signals - mWindowBase->IconifyChangedSignal().Connect( this, &Window::OnIconifyChanged ); - mWindowBase->FocusChangedSignal().Connect( this, &Window::OnFocusChanged ); - mWindowBase->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest ); - - mWindowSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed ); + // Set Window Type + mWindowBase->SetType(type); - if( !positionSize.IsEmpty() ) + // Initialize for Ime window type + if(type == WindowType::IME) { - AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" ); - mResizeEnabled = true; + mWindowBase->InitializeIme(); + mWindowSurface->InitializeImeSurface(); } - SetClass( name, className ); + // Connect signals + mWindowBase->IconifyChangedSignal().Connect(this, &Window::OnIconifyChanged); + mWindowBase->FocusChangedSignal().Connect(this, &Window::OnFocusChanged); + mWindowBase->DeleteRequestSignal().Connect(this, &Window::OnDeleteRequest); + mWindowBase->TransitionEffectEventSignal().Connect(this, &Window::OnTransitionEffectEvent); + mWindowBase->KeyboardRepeatSettingsChangedSignal().Connect(this, &Window::OnKeyboardRepeatSettingsChanged); + mWindowBase->WindowRedrawRequestSignal().Connect(this, &Window::OnWindowRedrawRequest); + mWindowBase->UpdatePositionSizeSignal().Connect(this, &Window::OnUpdatePositionSize); + + mWindowSurface->OutputTransformedSignal().Connect(this, &Window::OnOutputTransformed); - mWindowSurface->Map(); + AddAuxiliaryHint("wm.policy.win.user.geometry", "1"); - mOrientation = Orientation::New( this ); -} + SetClass(name, className); -void Window::OnAdaptorSet(Dali::Adaptor& adaptor) -{ - mEventHandler = EventHandlerPtr(new EventHandler( mScene, *mAdaptor, *mAdaptor ) ); + mOrientation = Orientation::New(this); - // TODO: Orientation should be passed into the constructor of EventHandler - if( mOrientation ) + // Get OrientationMode + int screenWidth, screenHeight; + WindowSystem::GetScreenSize(screenWidth, screenHeight); + if(screenWidth > screenHeight) { - SetRotationObserver( &(*mOrientation) ); + mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE; } + else + { + mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT; + } + // For Debugging + mNativeWindowId = mWindowBase->GetNativeWindowId(); } -void Window::OnSurfaceSet( Dali::RenderSurfaceInterface* surface ) +void Window::OnAdaptorSet(Dali::Adaptor& adaptor) { - mWindowSurface = static_cast( surface ); -} + mEventHandler = EventHandlerPtr(new EventHandler(mWindowSurface->GetWindowBase(), *mAdaptor)); + mEventHandler->AddObserver(*this); -void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode ) -{ -} + auto bridge = Accessibility::Bridge::GetCurrentBridge(); + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer, true); + bridge->AddTopLevelWindow(accessible); -void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode ) -{ + // If you call the 'Show' before creating the adaptor, the application cannot know the app resource id. + // The show must be called after the adaptor is initialized. + Show(); } -void Window::RotateIndicator( Dali::Window::WindowOrientation orientation ) +void Window::OnSurfaceSet(Dali::RenderSurfaceInterface* surface) { + mWindowSurface = static_cast(surface); } -void Window::SetClass( std::string name, std::string className ) +void Window::SetClass(std::string name, std::string className) { - mName = name; + mName = name; mClassName = className; - mWindowBase->SetClass( name, className ); + mWindowBase->SetClass(name, className); } std::string Window::GetClassName() const @@ -166,16 +200,28 @@ std::string Window::GetClassName() const 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(); + + mSurface->SetFullSwapNextFrame(); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId); } uint32_t Window::GetLayerCount() const @@ -183,76 +229,183 @@ uint32_t Window::GetLayerCount() const return mScene.GetLayerCount(); } -Dali::Layer Window::GetLayer( uint32_t depth ) const +Dali::Layer Window::GetLayer(uint32_t depth) const { - return mScene.GetLayer( depth ); + return mScene.GetLayer(depth); } -void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation ) +Dali::RenderTaskList Window::GetRenderTaskList() const { - bool found = false; + return mScene.GetRenderTaskList(); +} - if( orientation <= Dali::Window::LANDSCAPE_INVERSE ) +void Window::AddAvailableOrientation(WindowOrientation orientation) +{ + if(IsOrientationAvailable(orientation) == false) { - for( std::size_t i = 0; i < mAvailableOrientations.size(); i++ ) - { - if( mAvailableOrientations[i] == orientation ) - { - found = true; - break; - } - } + return; + } - if( !found ) + 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++) + { + if(mAvailableAngles[i] == convertedAngle) { - mAvailableOrientations.push_back( orientation ); - SetAvailableOrientations( mAvailableOrientations ); + found = true; + break; } } + + if(!found) + { + mAvailableAngles.push_back(convertedAngle); + SetAvailableAnlges(mAvailableAngles); + } } -void Window::RemoveAvailableOrientation( Dali::Window::WindowOrientation orientation ) +void Window::RemoveAvailableOrientation(WindowOrientation orientation) { - for( std::vector::iterator iter = mAvailableOrientations.begin(); - iter != mAvailableOrientations.end(); ++iter ) + if(IsOrientationAvailable(orientation) == false) { - if( *iter == orientation ) + return; + } + + int convertedAngle = ConvertToAngle(orientation); + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), RemoveAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle); + for(std::vector::iterator iter = mAvailableAngles.begin(); + iter != mAvailableAngles.end(); + ++iter) + { + 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(WindowOrientation orientation) { - if( orientations.size() > 4 ) + if(orientation < WindowOrientation::NO_ORIENTATION_PREFERENCE || orientation > WindowOrientation::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; +WindowOrientation Window::GetPreferredOrientation() +{ + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle); + WindowOrientation preferredOrientation = ConvertToOrientation(mPreferredAngle); + return preferredOrientation; +} - mWindowBase->SetAvailableOrientations( mAvailableOrientations ); +void Window::SetPositionSizeWithOrientation(PositionSize positionSize, WindowOrientation orientation) +{ + int angle = ConvertToAngle(orientation); + mWindowBase->SetPositionSizeWithAngle(positionSize, angle); } -const std::vector< Dali::Window::WindowOrientation >& Window::GetAvailableOrientations() +void Window::SetAvailableAnlges(const std::vector& 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(WindowOrientation orientation) { - mPreferredOrientation = orientation; + int convertAngle = static_cast(orientation); + if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE) + { + switch(orientation) + { + case WindowOrientation::LANDSCAPE: + { + convertAngle = 0; + break; + } + case WindowOrientation::PORTRAIT: + { + convertAngle = 90; + break; + } + case WindowOrientation::LANDSCAPE_INVERSE: + { + convertAngle = 180; + break; + } + case WindowOrientation::PORTRAIT_INVERSE: + { + convertAngle = 270; + break; + } + case WindowOrientation::NO_ORIENTATION_PREFERENCE: + { + convertAngle = -1; + break; + } + } + } + return convertAngle; +} - mWindowBase->SetPreferredOrientation( mPreferredOrientation ); +WindowOrientation Window::ConvertToOrientation(int angle) const +{ + WindowOrientation orientation = static_cast(angle); + if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE) + { + switch(angle) + { + case 0: + { + orientation = WindowOrientation::LANDSCAPE; + break; + } + case 90: + { + orientation = WindowOrientation::PORTRAIT; + break; + } + case 180: + { + orientation = WindowOrientation::LANDSCAPE_INVERSE; + break; + } + case 270: + { + orientation = WindowOrientation::PORTRAIT_INVERSE; + break; + } + case -1: + { + orientation = WindowOrientation::NO_ORIENTATION_PREFERENCE; + break; + } + } + } + return orientation; } -Dali::Window::WindowOrientation Window::GetPreferredOrientation() +bool Window::IsOrientationAvailable(WindowOrientation orientation) const { - return mPreferredOrientation; + if(orientation <= WindowOrientation::NO_ORIENTATION_PREFERENCE || orientation > WindowOrientation::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 @@ -260,11 +413,11 @@ Dali::Any Window::GetNativeHandle() const return mWindowSurface->GetNativeWindow(); } -void Window::SetAcceptFocus( bool accept ) +void Window::SetAcceptFocus(bool accept) { mIsFocusAcceptable = accept; - mWindowBase->SetAcceptFocus( accept ); + mWindowBase->SetAcceptFocus(accept); } bool Window::IsFocusAcceptable() const @@ -278,13 +431,18 @@ void Window::Show() mWindowBase->Show(); - if( !mIconified ) + if(!mIconified) { - WindowVisibilityObserver* observer( mAdaptor ); + 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 ); + mSurface->SetFullSwapNextFrame(); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible); } void Window::Hide() @@ -293,17 +451,21 @@ void Window::Hide() mWindowBase->Hide(); - if( !mIconified ) + if(!mIconified) { - WindowVisibilityObserver* observer( mAdaptor ); + 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; } @@ -312,87 +474,84 @@ unsigned int Window::GetSupportedAuxiliaryHintCount() const return mWindowBase->GetSupportedAuxiliaryHintCount(); } -std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const +std::string Window::GetSupportedAuxiliaryHint(unsigned int index) const { - return mWindowBase->GetSupportedAuxiliaryHint( index ); + return mWindowBase->GetSupportedAuxiliaryHint(index); } -unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value ) +unsigned int Window::AddAuxiliaryHint(const std::string& hint, const std::string& value) { - return mWindowBase->AddAuxiliaryHint( hint, value ); + return mWindowBase->AddAuxiliaryHint(hint, value); } -bool Window::RemoveAuxiliaryHint( unsigned int id ) +bool Window::RemoveAuxiliaryHint(unsigned int id) { - return mWindowBase->RemoveAuxiliaryHint( id ); + return mWindowBase->RemoveAuxiliaryHint(id); } -bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value ) +bool Window::SetAuxiliaryHintValue(unsigned int id, const std::string& value) { - return mWindowBase->SetAuxiliaryHintValue( id, value ); + return mWindowBase->SetAuxiliaryHintValue(id, value); } -std::string Window::GetAuxiliaryHintValue( unsigned int id ) const +std::string Window::GetAuxiliaryHintValue(unsigned int id) const { - return mWindowBase->GetAuxiliaryHintValue( id ); + return mWindowBase->GetAuxiliaryHintValue(id); } -unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const +unsigned int Window::GetAuxiliaryHintId(const std::string& hint) const { - return mWindowBase->GetAuxiliaryHintId( hint ); + return mWindowBase->GetAuxiliaryHintId(hint); } -void Window::SetInputRegion( const Rect< int >& inputRegion ) +void Window::SetInputRegion(const Rect& inputRegion) { - mWindowBase->SetInputRegion( inputRegion ); + mWindowBase->SetInputRegion(inputRegion); - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetInputRegion: x = %d, y = %d, w = %d, h = %d\n", inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height ); + DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetInputRegion: x = %d, y = %d, w = %d, h = %d\n", inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height); } -void Window::SetType( Dali::Window::Type type ) +void Window::SetType(WindowType type) { - if( type != mType ) - { - mWindowBase->SetType( type ); - - mType = type; - } + mWindowBase->SetType(type); } -Dali::Window::Type Window::GetType() const +WindowType Window::GetType() const { - return mType; + return mWindowBase->GetType(); } -bool Window::SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) +WindowOperationResult Window::SetNotificationLevel(WindowNotificationLevel level) { - if( mType != Dali::Window::NOTIFICATION ) + WindowType type = mWindowBase->GetType(); + if(type != WindowType::NOTIFICATION) { - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType ); - return false; + DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", type); + return WindowOperationResult::INVALID_OPERATION; } - return mWindowBase->SetNotificationLevel( level ); + return mWindowBase->SetNotificationLevel(level); } -Dali::Window::NotificationLevel::Type Window::GetNotificationLevel() const +WindowNotificationLevel Window::GetNotificationLevel() const { - if( mType != Dali::Window::NOTIFICATION ) + WindowType type = mWindowBase->GetType(); + if(type != WindowType::NOTIFICATION) { - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType ); - return Dali::Window::NotificationLevel::NONE; + DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", type); + return WindowNotificationLevel::NONE; } return mWindowBase->GetNotificationLevel(); } -void Window::SetOpaqueState( bool opaque ) +void Window::SetOpaqueState(bool opaque) { mOpaqueState = opaque; - mWindowBase->SetOpaqueState( opaque ); + mWindowBase->SetOpaqueState(opaque); - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque ); + DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque); } bool Window::IsOpaqueState() const @@ -400,25 +559,25 @@ bool Window::IsOpaqueState() const return mOpaqueState; } -bool Window::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) +WindowOperationResult Window::SetScreenOffMode(WindowScreenOffMode screenOffMode) { - return mWindowBase->SetScreenOffMode( screenOffMode ); + return mWindowBase->SetScreenOffMode(screenOffMode); } -Dali::Window::ScreenOffMode::Type Window::GetScreenOffMode() const +WindowScreenOffMode Window::GetScreenOffMode() const { return mWindowBase->GetScreenOffMode(); } -bool Window::SetBrightness( int brightness ) +WindowOperationResult Window::SetBrightness(int brightness) { - if( brightness < 0 || brightness > 100 ) + if(brightness < 0 || brightness > 100) { - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness ); - return false; + DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness); + return WindowOperationResult::INVALID_OPERATION; } - return mWindowBase->SetBrightness( brightness ); + return mWindowBase->SetBrightness(brightness); } int Window::GetBrightness() const @@ -426,85 +585,92 @@ int Window::GetBrightness() const return mWindowBase->GetBrightness(); } -void Window::SetSize( Dali::Window::WindowSize size ) +void Window::SetSize(Dali::Window::WindowSize size) { - if( !mResizeEnabled ) - { - AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" ); - mResizeEnabled = true; - } - PositionSize oldRect = mSurface->GetPositionSize(); - mWindowSurface->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(); // When surface size is updated, inform adaptor of resizing and emit ResizeSignal - if( ( oldRect.width != newRect.width ) || ( oldRect.height != newRect.height ) ) + if((oldRect.width != newRect.width) || (oldRect.height != newRect.height)) { - Uint16Pair newSize( newRect.width, newRect.height ); + Uint16Pair newSize(newRect.width, newRect.height); + + SurfaceResized(); + + mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize); - 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); - mResizedSignal.Emit( newSize ); + Dali::Window handle(this); + mResizeSignal.Emit(handle, newSize); - mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize ); + mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize); } + + mSurface->SetFullSwapNextFrame(); + + Dali::Accessibility::Accessible::Get(mScene.GetRootLayer(), true)->EmitBoundsChanged(Dali::Rect<>(oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight())); } Dali::Window::WindowSize Window::GetSize() const { PositionSize positionSize = mSurface->GetPositionSize(); - return Dali::Window::WindowSize( positionSize.width, positionSize.height ); + return Dali::Window::WindowSize(positionSize.width, positionSize.height); } -void Window::SetPosition( Dali::Window::WindowPosition position ) +void Window::SetPosition(Dali::Window::WindowPosition position) { - if( !mResizeEnabled ) - { - AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" ); - mResizeEnabled = true; - } - PositionSize oldRect = mSurface->GetPositionSize(); - mWindowSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) ); + mWindowSurface->MoveResize(PositionSize(position.GetX(), position.GetY(), oldRect.width, oldRect.height)); + + mSurface->SetFullSwapNextFrame(); + + Dali::Accessibility::Accessible::Get(mScene.GetRootLayer(), true)->EmitBoundsChanged(Dali::Rect<>(position.GetX(), position.GetY(), oldRect.width, oldRect.height)); } Dali::Window::WindowPosition Window::GetPosition() const { PositionSize positionSize = mSurface->GetPositionSize(); - return Dali::Window::WindowPosition( positionSize.x, positionSize.y ); + return Dali::Window::WindowPosition(positionSize.x, positionSize.y); } -void Window::SetPositionSize( PositionSize positionSize ) +PositionSize Window::GetPositionSize() const { - if( !mResizeEnabled ) - { - AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" ); - mResizeEnabled = true; - } + return mSurface->GetPositionSize(); +} +void Window::SetPositionSize(PositionSize positionSize) +{ PositionSize oldRect = mSurface->GetPositionSize(); - mWindowSurface->MoveResize( positionSize ); + mWindowSurface->MoveResize(positionSize); PositionSize newRect = mSurface->GetPositionSize(); // When surface size is updated, inform adaptor of resizing and emit ResizeSignal - if( ( oldRect.width != newRect.width ) || ( oldRect.height != newRect.height ) ) + if((oldRect.width != newRect.width) || (oldRect.height != newRect.height)) { - Uint16Pair newSize( newRect.width, newRect.height ); + Uint16Pair newSize(newRect.width, newRect.height); - mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize ); + SurfaceResized(); - mResizedSignal.Emit( newSize ); + mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize); - mAdaptor->SurfaceResizeComplete( 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::Accessibility::Accessible::Get(mScene.GetRootLayer(), true)->EmitBoundsChanged(Dali::Rect<>(positionSize.x, positionSize.y, positionSize.width, positionSize.height)); } Dali::Layer Window::GetRootLayer() const @@ -512,81 +678,96 @@ Dali::Layer Window::GetRootLayer() const return mScene.GetRootLayer(); } -void Window::SetTransparency( bool transparent ) -{ - mWindowSurface->SetTransparency( transparent ); -} - -bool Window::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) +void Window::SetTransparency(bool transparent) { - return mWindowBase->GrabKey( key, grabMode ); + mWindowSurface->SetTransparency(transparent); } -bool Window::UngrabKey( Dali::KEY key ) +bool Window::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode) { - return mWindowBase->UngrabKey( key ); + return mWindowBase->GrabKey(key, grabMode); } -bool Window::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) +bool Window::UngrabKey(Dali::KEY key) { - return mWindowBase->GrabKeyList( key, grabMode, result ); + return mWindowBase->UngrabKey(key); } -bool Window::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) +bool Window::GrabKeyList(const Dali::Vector& key, const Dali::Vector& grabMode, Dali::Vector& result) { - return mWindowBase->UngrabKeyList( key, result ); + return mWindowBase->GrabKeyList(key, grabMode, result); } -void Window::RotationDone( int orientation, int width, int height ) +bool Window::UngrabKeyList(const Dali::Vector& key, Dali::Vector& result) { - mWindowSurface->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 ) ); + return mWindowBase->UngrabKeyList(key, result); } -void Window::OnIconifyChanged( bool iconified ) +void Window::OnIconifyChanged(bool iconified) { - if( iconified ) + if(iconified) { mIconified = true; - if( mVisible ) + if(mVisible) { - WindowVisibilityObserver* observer( mAdaptor ); + 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 { mIconified = false; - if( mVisible ) + if(mVisible) { - WindowVisibilityObserver* observer( mAdaptor ); + 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); } + + mSurface->SetFullSwapNextFrame(); } -void Window::OnFocusChanged( bool focusIn ) +void Window::OnFocusChanged(bool focusIn) { - mFocusChangedSignal.Emit( focusIn ); + Dali::Window handle(this); + mFocusChangeSignal.Emit(handle, focusIn); + + mSurface->SetFullSwapNextFrame(); + + if(auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge()) + { + if(focusIn) + { + bridge->ApplicationShown(); + } + else + { + bridge->ApplicationHidden(); + } + } } void Window::OnOutputTransformed() { PositionSize positionSize = mSurface->GetPositionSize(); - mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); - mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); + + int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360; + SurfaceRotated(static_cast(positionSize.width), static_cast(positionSize.height), orientation); + + mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height)); + mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height)); } void Window::OnDeleteRequest() @@ -594,33 +775,70 @@ void Window::OnDeleteRequest() mDeleteRequestSignal.Emit(); } -void Window::FeedTouchPoint( TouchPoint& point, int timeStamp ) +void Window::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type) { - if( mEventHandler ) - { - mEventHandler->FeedTouchPoint( point, timeStamp ); - } + Dali::Window handle(this); + mTransitionEffectEventSignal.Emit(handle, state, type); } -void Window::FeedWheelEvent( WheelEvent& wheelEvent ) +void Window::OnKeyboardRepeatSettingsChanged() { - if( mEventHandler ) - { - mEventHandler->FeedWheelEvent( wheelEvent ); - } + Dali::Window handle(this); + mKeyboardRepeatSettingsChangedSignal.Emit(); } -void Window::FeedKeyEvent( KeyEvent& keyEvent ) +void Window::OnWindowRedrawRequest() { - if( mEventHandler ) - { - mEventHandler->FeedKeyEvent( keyEvent ); - } + mAdaptor->RenderOnce(); +} + +void Window::OnUpdatePositionSize(Dali::PositionSize& positionSize) +{ + SetPositionSize(positionSize); +} + +void Window::OnTouchPoint(Dali::Integration::Point& point, int timeStamp) +{ + FeedTouchPoint(point, timeStamp); +} + +void Window::OnWheelEvent(Dali::Integration::WheelEvent& wheelEvent) +{ + FeedWheelEvent(wheelEvent); +} + +void Window::OnKeyEvent(Dali::Integration::KeyEvent& keyEvent) +{ + 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); + + int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360; + SurfaceRotated(mWindowWidth, mWindowHeight, orientation); + + 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 ) + if(mEventHandler) { mEventHandler->Pause(); } @@ -628,38 +846,157 @@ void Window::OnPause() void Window::OnResume() { - if( mEventHandler ) + if(mEventHandler) { mEventHandler->Resume(); } + + mSurface->SetFullSwapNextFrame(); } -bool Window::SetRotationObserver( RotationObserver* observer ) +void Window::RecalculateTouchPosition(Integration::Point& point) { - if( mEventHandler ) + Vector2 position = point.GetScreenPosition(); + Vector2 convertedPosition; + + switch(mRotationAngle) { - mEventHandler->SetRotationObserver( observer ); - return true; + 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; + } } - return false; + point.SetScreenPosition(convertedPosition); } -Dali::Window Window::Get( Dali::Actor actor ) +Dali::Window Window::Get(Dali::Actor actor) { Internal::Adaptor::Window* windowImpl = nullptr; - if ( Internal::Adaptor::Adaptor::IsAvailable() ) + 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)) { - Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() ); - windowImpl = static_cast( adaptor.GetWindow( actor ) ); + 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; +} + +WindowOrientation Window::GetCurrentOrientation() const +{ + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mRotationAngle); + return ConvertToOrientation(mRotationAngle); +} - return Dali::Window( windowImpl ); +int Window::GetPhysicalOrientation() const +{ + return (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360; +} + +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); +} + +int32_t Window::GetNativeId() const +{ + return mWindowBase->GetNativeWindowId(); +} + +void Window::RequestMoveToServer() +{ + mWindowBase->RequestMoveToServer(); +} + +void Window::RequestResizeToServer(WindowResizeDirection direction) +{ + mWindowBase->RequestResizeToServer(direction); +} + +void Window::EnableFloatingMode(bool enable) +{ + mWindowBase->EnableFloatingMode(enable); } -} // Adaptor +} // namespace Adaptor -} // Internal +} // namespace Internal -} // Dali +} // namespace Dali