X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fwindow-system%2Fcommon%2Fwindow-impl.cpp;h=a22420732b5a1d16bd78931213b3d85bbc200920;hb=06db2cc40c59daa1f29b8a2a375285030439d823;hp=1e9e79b2408bf61c770e49a5d1d25b4143360938;hpb=1fc1a37d04407c0cb746d0de381c68637821c376;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 1e9e79b..e0a6cc5 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) 2022 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,25 +19,30 @@ #include // EXTERNAL HEADERS +#include #include +#include #include -#include #include -#include +#include +#include #include +#include #include -#include -#include +#include // INTERNAL HEADERS +#include +#include #include +#include #include #include #include -#include #include -#include +#include #include +#include #include namespace Dali @@ -46,92 +51,119 @@ 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) { - Window* window = new Window(); + 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->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 ), - mParentWindow( NULL ), - mPreferredAngle( 0 ), - mRotationAngle( 0 ), - mWindowWidth( 0 ), - mWindowHeight( 0 ), - mOrientationMode( Internal::Adaptor::Window::OrientationMode::PORTRAIT ), - mFocusChangedSignal(), - mResizedSignal(), + mIsTransparent(false), + mIsFocusAcceptable(true), + mIconified(false), + mOpaqueState(false), + mWindowRotationAcknowledgement(false), + mFocused(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() + mTransitionEffectEventSignal(), + mKeyboardRepeatSettingsChangedSignal(), + mAuxiliaryMessageSignal() { } Window::~Window() { - if ( mEventHandler ) + if(mScene) + { + auto bridge = Accessibility::Bridge::GetCurrentBridge(); + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer, true); + bridge->RemoveTopLevelWindow(accessible); + // Related to multi-window case. This is called for default window and non-default window, but it is effective for non-default window. + bridge->Emit(accessible, Accessibility::WindowEvent::DESTROY); + } + + if(mAdaptor) { - mEventHandler->RemoveObserver( *this ); + 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 ); - mWindowBase->TransitionEffectEventSignal().Connect( this, &Window::OnTransitionEffectEvent ); - - 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); + mWindowBase->AuxiliaryMessageSignal().Connect(this, &Window::OnAuxiliaryMessage); + + mWindowSurface->OutputTransformedSignal().Connect(this, &Window::OnOutputTransformed); - mWindowSurface->Map(); + AddAuxiliaryHint("wm.policy.win.user.geometry", "1"); - mOrientation = Orientation::New( this ); + SetClass(name, className); + + mOrientation = Orientation::New(this); // Get OrientationMode int screenWidth, screenHeight; - WindowSystem::GetScreenSize( screenWidth, screenHeight ); - if( screenWidth > screenHeight ) + WindowSystem::GetScreenSize(screenWidth, screenHeight); + if(screenWidth > screenHeight) { mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE; } @@ -139,36 +171,42 @@ void Window::Initialize(const PositionSize& positionSize, const std::string& nam { mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT; } + // For Debugging + mNativeWindowId = mWindowBase->GetNativeWindowId(); } void Window::OnAdaptorSet(Dali::Adaptor& adaptor) { - mEventHandler = EventHandlerPtr(new EventHandler( mWindowSurface, *mAdaptor ) ); - mEventHandler->AddObserver( *this ); -} + mEventHandler = EventHandlerPtr(new EventHandler(mWindowSurface->GetWindowBase(), *mAdaptor)); + mEventHandler->AddObserver(*this); -void Window::OnSurfaceSet( Dali::RenderSurfaceInterface* surface ) -{ - mWindowSurface = static_cast( surface ); -} + // Add Window to bridge for ATSPI + auto bridge = Accessibility::Bridge::GetCurrentBridge(); + if(bridge->IsUp()) + { + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer, true); + bridge->AddTopLevelWindow(accessible); + } -void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode ) -{ -} + bridge->EnabledSignal().Connect(this, &Window::OnAccessibilityEnabled); + bridge->DisabledSignal().Connect(this, &Window::OnAccessibilityDisabled); -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 @@ -179,19 +217,52 @@ std::string Window::GetClassName() const void Window::Raise() { mWindowBase->Raise(); - DALI_LOG_RELEASE_INFO( "Window (%p) Raise() \n", this ); + + mSurface->SetFullSwapNextFrame(); + + 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 ); + + mSurface->SetFullSwapNextFrame(); + + 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 ); + + mSurface->SetFullSwapNextFrame(); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId); +} + +void Window::Maximize(bool maximize) +{ + mWindowBase->Maximize(maximize); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Maximize: %d\n", this, mNativeWindowId, maximize); +} + +bool Window::IsMaximized() const +{ + return mWindowBase->IsMaximized(); +} + +void Window::Minimize(bool minimize) +{ + mWindowBase->Minimize(minimize); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Minimize: %d\n", this, mNativeWindowId, minimize); +} + +bool Window::IsMinimized() const +{ + return mWindowBase->IsMinimized(); } uint32_t Window::GetLayerCount() const @@ -199,9 +270,9 @@ 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); } Dali::RenderTaskList Window::GetRenderTaskList() const @@ -209,125 +280,169 @@ Dali::RenderTaskList Window::GetRenderTaskList() const return mScene.GetRenderTaskList(); } -void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation ) +std::string Window::GetNativeResourceId() const +{ + return mWindowBase->GetNativeWindowResourceId(); +} + +void Window::AddAvailableOrientation(WindowOrientation orientation) { - bool found = false; - if( orientation <= Dali::Window::LANDSCAPE_INVERSE ) + if(IsOrientationAvailable(orientation) == false) { - int convertedAngle = ConvertToAngle( orientation ); - for( std::size_t i = 0; i < mAvailableAngles.size(); i++ ) - { - if( mAvailableAngles[i] == convertedAngle ) - { - 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) { - mAvailableAngles.push_back( convertedAngle ); - SetAvailableAnlges( mAvailableAngles ); + found = true; + break; } } + + if(!found) + { + mAvailableAngles.push_back(convertedAngle); + SetAvailableAnlges(mAvailableAngles); + } } -void Window::RemoveAvailableOrientation( Dali::Window::WindowOrientation orientation ) +void Window::RemoveAvailableOrientation(WindowOrientation orientation) { - int convertedAngle = ConvertToAngle( orientation ); - for( std::vector< int >::iterator iter = mAvailableAngles.begin(); - iter != mAvailableAngles.end(); ++iter ) + if(IsOrientationAvailable(orientation) == false) { - if( *iter == convertedAngle ) + 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) { - mAvailableAngles.erase( iter ); + mAvailableAngles.erase(iter); break; } } - SetAvailableAnlges( mAvailableAngles ); + SetAvailableAnlges(mAvailableAngles); } -void Window::SetPreferredOrientation( Dali::Window::WindowOrientation orientation ) +void Window::SetPreferredOrientation(WindowOrientation orientation) { - mPreferredAngle = ConvertToAngle( orientation ); - mWindowBase->SetPreferredAngle( mPreferredAngle ); + if(orientation < WindowOrientation::NO_ORIENTATION_PREFERENCE || orientation > WindowOrientation::LANDSCAPE_INVERSE) + { + 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); } -Dali::Window::WindowOrientation Window::GetPreferredOrientation() +WindowOrientation Window::GetPreferredOrientation() { - Dali::Window::WindowOrientation preferredOrientation = ConvertToOrientation( mPreferredAngle ); + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle); + WindowOrientation preferredOrientation = ConvertToOrientation(mPreferredAngle); return preferredOrientation; } -void Window::SetAvailableAnlges( const std::vector< int >& angles ) +void Window::SetPositionSizeWithOrientation(PositionSize positionSize, WindowOrientation orientation) { - if( angles.size() > 4 ) + int angle = ConvertToAngle(orientation); + mWindowBase->SetPositionSizeWithAngle(positionSize, angle); +} + +void Window::EmitAccessibilityHighlightSignal(bool highlight) +{ + Dali::Window handle(this); + mAccessibilityHighlightSignal.Emit(handle, highlight); +} + +void Window::SetAvailableAnlges(const std::vector& angles) +{ + if(angles.size() > 4) { - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size() ); + DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size()); return; } - mWindowBase->SetAvailableAnlges( angles ); + mWindowBase->SetAvailableAnlges(angles); } -int Window::ConvertToAngle( Dali::Window::WindowOrientation orientation ) +int Window::ConvertToAngle(WindowOrientation orientation) { - int convertAngle = static_cast< int >( orientation ); - if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE ) + int convertAngle = static_cast(orientation); + if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE) { - switch( orientation ) + switch(orientation) { - case Dali::Window::LANDSCAPE: + case WindowOrientation::LANDSCAPE: { convertAngle = 0; break; } - case Dali::Window::PORTRAIT: + case WindowOrientation::PORTRAIT: { convertAngle = 90; break; } - case Dali::Window::LANDSCAPE_INVERSE: + case WindowOrientation::LANDSCAPE_INVERSE: { convertAngle = 180; break; } - case Dali::Window::PORTRAIT_INVERSE: + case WindowOrientation::PORTRAIT_INVERSE: { convertAngle = 270; break; } + case WindowOrientation::NO_ORIENTATION_PREFERENCE: + { + convertAngle = -1; + break; + } } } return convertAngle; } -Dali::Window::WindowOrientation Window::ConvertToOrientation( int angle ) +WindowOrientation Window::ConvertToOrientation(int angle) const { - Dali::Window::WindowOrientation orientation = static_cast< Dali::Window::WindowOrientation >( angle ); - if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE ) + WindowOrientation orientation = static_cast(angle); + if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE) { - switch( angle ) + switch(angle) { case 0: { - orientation = Dali::Window::LANDSCAPE; + orientation = WindowOrientation::LANDSCAPE; break; } case 90: { - orientation = Dali::Window::PORTRAIT; + orientation = WindowOrientation::PORTRAIT; break; } case 180: { - orientation = Dali::Window::LANDSCAPE_INVERSE; + orientation = WindowOrientation::LANDSCAPE_INVERSE; break; } case 270: { - orientation = Dali::Window::PORTRAIT_INVERSE; + orientation = WindowOrientation::PORTRAIT_INVERSE; + break; + } + case -1: + { + orientation = WindowOrientation::NO_ORIENTATION_PREFERENCE; break; } } @@ -335,16 +450,26 @@ Dali::Window::WindowOrientation Window::ConvertToOrientation( int angle ) return orientation; } +bool Window::IsOrientationAvailable(WindowOrientation orientation) const +{ + 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 { 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 @@ -358,16 +483,19 @@ void Window::Show() mWindowBase->Show(); - if( !mIconified ) + if(!mIconified) { - WindowVisibilityObserver* observer( mAdaptor ); - observer->OnWindowShown(); + Dali::Window handle(this); + mVisibilityChangedSignal.Emit(handle, true); + Dali::Accessibility::Bridge::GetCurrentBridge()->WindowShown(handle); - Dali::Window handle( this ); - mVisibilityChangedSignal.Emit( handle, true ); + WindowVisibilityObserver* observer(mAdaptor); + observer->OnWindowShown(); } - 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() @@ -376,20 +504,22 @@ void Window::Hide() mWindowBase->Hide(); - if( !mIconified ) + if(!mIconified) { - WindowVisibilityObserver* observer( mAdaptor ); - observer->OnWindowHidden(); + Dali::Window handle(this); + mVisibilityChangedSignal.Emit(handle, false); + Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden(handle); - Dali::Window handle( this ); - mVisibilityChangedSignal.Emit( handle, false ); + WindowVisibilityObserver* observer(mAdaptor); + observer->OnWindowHidden(); } - 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; } @@ -398,87 +528,86 @@ 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 ); + Rect convertRegion = RecalculateRect(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 (%p), WinId (%d), SetInputRegion, RecalculateRegion, (%d,%d), (%d x %d)\n", this, mNativeWindowId, convertRegion.x, convertRegion.y, convertRegion.width, convertRegion.height); + + mWindowBase->SetInputRegion(convertRegion); } -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 @@ -486,25 +615,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 @@ -512,92 +641,98 @@ 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); + + mWindowWidth = newRect.width; + mWindowHeight = newRect.height; SurfaceResized(); - mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize ); + mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize); - Dali::Window handle( this ); - mResizedSignal.Emit( newSize ); - mResizeSignal.Emit( handle, newSize ); + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), SetSize(): resize signal [%d x %d]\n", this, mNativeWindowId, mRotationAngle, newRect.width, newRect.height); - mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize ); + 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<>(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); + + mWindowWidth = newRect.width; + mWindowHeight = newRect.height; SurfaceResized(); - mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize ); + mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize); - Dali::Window handle( this ); - mResizedSignal.Emit( newSize ); - mResizeSignal.Emit( handle, newSize ); - mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize ); + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), SetPositionSize():resize signal [%d x %d]\n", this, mNativeWindowId, mRotationAngle, 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 @@ -605,78 +740,99 @@ Dali::Layer Window::GetRootLayer() const return mScene.GetRootLayer(); } -void Window::SetTransparency( bool transparent ) +void Window::SetTransparency(bool transparent) { - mWindowSurface->SetTransparency( transparent ); + mWindowSurface->SetTransparency(transparent); } -bool Window::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode ) +bool Window::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode) { - return mWindowBase->GrabKey( key, grabMode ); + return mWindowBase->GrabKey(key, grabMode); } -bool Window::UngrabKey( Dali::KEY key ) +bool Window::UngrabKey(Dali::KEY key) { - return mWindowBase->UngrabKey( key ); + return mWindowBase->UngrabKey(key); } -bool Window::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result ) +bool Window::GrabKeyList(const Dali::Vector& key, const Dali::Vector& grabMode, Dali::Vector& result) { - return mWindowBase->GrabKeyList( key, grabMode, result ); + return mWindowBase->GrabKeyList(key, grabMode, result); } -bool Window::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result ) +bool Window::UngrabKeyList(const Dali::Vector& key, Dali::Vector& result) { - return mWindowBase->UngrabKeyList( key, result ); + 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 ); - observer->OnWindowHidden(); + Dali::Window handle(this); + mVisibilityChangedSignal.Emit(handle, false); + Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden(handle); - Dali::Window handle( this ); - mVisibilityChangedSignal.Emit( handle, false ); + WindowVisibilityObserver* observer(mAdaptor); + observer->OnWindowHidden(); } - 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 ); - observer->OnWindowShown(); + Dali::Window handle(this); + mVisibilityChangedSignal.Emit(handle, true); + Dali::Accessibility::Bridge::GetCurrentBridge()->WindowShown(handle); - Dali::Window handle( this ); - mVisibilityChangedSignal.Emit( handle, true ); + WindowVisibilityObserver* observer(mAdaptor); + observer->OnWindowShown(); } - 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) { - Dali::Window handle( this ); - mFocusChangedSignal.Emit( focusIn ); - mFocusChangeSignal.Emit( handle, focusIn ); + Dali::Window handle(this); + mFocusChangeSignal.Emit(handle, focusIn); + + mSurface->SetFullSwapNextFrame(); + + if(auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge()) + { + if(focusIn) + { + bridge->WindowFocused(handle); + } + else + { + bridge->WindowUnfocused(handle); + } + } + mFocused = focusIn; } 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 ) ); + + 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() @@ -684,53 +840,95 @@ void Window::OnDeleteRequest() mDeleteRequestSignal.Emit(); } -void Window::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type ) +void Window::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type) +{ + Dali::Window handle(this); + mTransitionEffectEventSignal.Emit(handle, state, type); +} + +void Window::OnKeyboardRepeatSettingsChanged() { - Dali::Window handle( this ); - mTransitionEffectEventSignal.Emit( handle, state, type ); + Dali::Window handle(this); + mKeyboardRepeatSettingsChangedSignal.Emit(); } -void Window::OnTouchPoint( Dali::Integration::Point& point, int timeStamp ) +void Window::OnWindowRedrawRequest() { - FeedTouchPoint( point, timeStamp ); + mAdaptor->RenderOnce(); +} + +void Window::OnUpdatePositionSize(Dali::PositionSize& positionSize) +{ + PositionSize oldRect = mSurface->GetPositionSize(); + + mWindowSurface->UpdatePositionSize(positionSize); + + PositionSize newRect = positionSize; + + // When surface size is updated, inform adaptor of resizing and emit ResizeSignal + if((oldRect.width != newRect.width) || (oldRect.height != newRect.height)) + { + Uint16Pair newSize(newRect.width, newRect.height); + + SurfaceResized(); + + mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Updated PositionSize by server :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)); } -void Window::OnWheelEvent( Dali::Integration::WheelEvent& wheelEvent ) +void Window::OnTouchPoint(Dali::Integration::Point& point, int timeStamp) { - FeedWheelEvent( wheelEvent ); + FeedTouchPoint(point, timeStamp); } -void Window::OnKeyEvent( Dali::Integration::KeyEvent& keyEvent ) +void Window::OnWheelEvent(Dali::Integration::WheelEvent& wheelEvent) { - FeedKeyEvent( keyEvent ); + FeedWheelEvent(wheelEvent); } -void Window::OnRotation( const RotationEvent& rotation ) +void Window::OnKeyEvent(Dali::Integration::KeyEvent& keyEvent) { + FeedKeyEvent(keyEvent); +} + +void Window::OnRotation(const RotationEvent& rotation) +{ + PositionSize newPositionSize(rotation.x, rotation.y, rotation.width, rotation.height); + mRotationAngle = rotation.angle; - mWindowWidth = rotation.width; - mWindowHeight = rotation.height; + mWindowWidth = rotation.width; + mWindowHeight = rotation.height; // Notify that the orientation is changed - mOrientation->OnOrientationChange( rotation ); + mOrientation->OnOrientationChange(rotation); - mWindowSurface->RequestRotation( mRotationAngle, mWindowWidth, mWindowHeight ); + mWindowSurface->RequestRotation(mRotationAngle, newPositionSize); - SurfaceResized(); + int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360; + SurfaceRotated(mWindowWidth, mWindowHeight, orientation); - mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) ); + mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight)); + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), OnRotation(): x[%d], y[%d], resize signal emit [%d x %d]\n", this, mNativeWindowId, newPositionSize.x, newPositionSize.y, mWindowWidth, mWindowHeight); // Emit signal - Dali::Window handle( this ); - mResizedSignal.Emit( Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) ); - mResizeSignal.Emit( handle, Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) ); + Dali::Window handle(this); + mResizeSignal.Emit(handle, Dali::Window::WindowSize(mWindowWidth, mWindowHeight)); - mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) ); + mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight)); } void Window::OnPause() { - if( mEventHandler ) + if(mEventHandler) { mEventHandler->Pause(); } @@ -738,35 +936,64 @@ void Window::OnPause() void Window::OnResume() { - if( mEventHandler ) + if(mEventHandler) { mEventHandler->Resume(); } + + mSurface->SetFullSwapNextFrame(); +} + +void Window::OnAuxiliaryMessage(const std::string& key, const std::string& value, const Property::Array& options) +{ + mAuxiliaryMessageSignal.Emit(key, value, options); +} + +void Window::OnAccessibilityEnabled() +{ + auto bridge = Accessibility::Bridge::GetCurrentBridge(); + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer, true); + bridge->AddTopLevelWindow(accessible); + + if(mFocused) + { + Dali::Window handle(this); + bridge->WindowFocused(handle); + } +} + +void Window::OnAccessibilityDisabled() +{ + auto bridge = Accessibility::Bridge::GetCurrentBridge(); + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer, true); + bridge->RemoveTopLevelWindow(accessible); } -void Window::RecalculateTouchPosition( Integration::Point& point ) +void Window::RecalculateTouchPosition(Integration::Point& point) { Vector2 position = point.GetScreenPosition(); Vector2 convertedPosition; - switch( mRotationAngle ) + switch(mRotationAngle) { case 90: { - convertedPosition.x = static_cast( mWindowWidth ) - position.y; + 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; + 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; + convertedPosition.y = static_cast(mWindowHeight) - position.x; break; } default: @@ -776,40 +1003,59 @@ void Window::RecalculateTouchPosition( Integration::Point& point ) } } - point.SetScreenPosition( convertedPosition ); + 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 = static_cast( adaptor.GetWindow( actor ) ); + 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( 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, false); + } } -void Window::SetParent( Dali::Window& parent ) +void Window::SetParent(Dali::Window& parent, bool belowParent) { - if ( DALI_UNLIKELY( parent ) ) + if(DALI_UNLIKELY(parent)) { - mParentWindow = parent; - Dali::Window self = Dali::Window( this ); + mParentWindow = parent; + Dali::Window self = Dali::Window(this); // check circular parent window setting - if ( Dali::DevelWindow::GetParent( parent ) == self ) + if(Dali::DevelWindow::GetParent(parent) == self) { - Dali::DevelWindow::Unparent( parent ); + Dali::DevelWindow::Unparent(parent); } - mWindowBase->SetParent( GetImplementation( mParentWindow ).mWindowBase ); + mWindowBase->SetParent(GetImplementation(mParentWindow).mWindowBase, belowParent); } } void Window::Unparent() { - mWindowBase->SetParent( nullptr ); + mWindowBase->SetParent(nullptr, false); mParentWindow.Reset(); } @@ -818,8 +1064,146 @@ Dali::Window Window::GetParent() return mParentWindow; } -} // Adaptor +WindowOrientation Window::GetCurrentOrientation() const +{ + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mRotationAngle); + return ConvertToOrientation(mRotationAngle); +} + +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); +} + +Rect Window::RecalculateRect(const Rect& rect) +{ + Rect newRect; + int screenWidth, screenHeight; + + WindowSystem::GetScreenSize(screenWidth, screenHeight); + + if(mRotationAngle == 90) + { + newRect.x = rect.y; + newRect.y = screenHeight - (rect.x + rect.width); + newRect.width = rect.height; + newRect.height = rect.width; + } + else if(mRotationAngle == 180) + { + newRect.x = screenWidth - (rect.x + rect.width); + newRect.y = screenHeight - (rect.y + rect.height); + newRect.width = rect.width; + newRect.height = rect.height; + } + else if(mRotationAngle == 270) + { + newRect.x = screenWidth - (rect.y + rect.height); + newRect.y = rect.x; + newRect.width = rect.height; + newRect.height = rect.width; + } + else + { + newRect.x = rect.x; + newRect.y = rect.y; + newRect.width = rect.width; + newRect.height = rect.height; + } + return newRect; +} + +void Window::IncludeInputRegion(const Rect& inputRegion) +{ + Rect convertRegion = RecalculateRect(inputRegion); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), IncludeInputRegion, RecalculateRegion, (%d,%d), (%d x %d)\n", this, mNativeWindowId, convertRegion.x, convertRegion.y, convertRegion.width, convertRegion.height); + mWindowBase->IncludeInputRegion(convertRegion); +} + +void Window::ExcludeInputRegion(const Rect& inputRegion) +{ + Rect convertRegion = RecalculateRect(inputRegion); + + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), ExcludeInputRegion, RecalculateRegion, (%d,%d), (%d x %d)\n", this, mNativeWindowId, convertRegion.x, convertRegion.y, convertRegion.width, convertRegion.height); + mWindowBase->ExcludeInputRegion(convertRegion); +} + +void Window::SetNeedsRotationCompletedAcknowledgement(bool needAcknowledgement) +{ + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), needAcknowledgement(%d) Set needs Rotation Completed Acknowledgement\n", this, mNativeWindowId, needAcknowledgement); + mWindowSurface->SetNeedsRotationCompletedAcknowledgement(needAcknowledgement); + mWindowRotationAcknowledgement = needAcknowledgement; +} + +void Window::SendRotationCompletedAcknowledgement() +{ + DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SendRotationCompletedAcknowledgement(): orientation: %d, mWindowRotationAcknowledgement: %d\n", this, mNativeWindowId, mRotationAngle, mWindowRotationAcknowledgement); + if(mWindowRotationAcknowledgement) + { + SetRotationCompletedAcknowledgement(); + } +} + +bool Window::IsWindowRotating() const +{ + return mWindowSurface->IsWindowRotating(); +} + +} // namespace Adaptor -} // Internal +} // namespace Internal -} // Dali +} // namespace Dali