/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/window-system/common/window-impl.h>
// EXTERNAL HEADERS
+#include <thread>
#include <dali/integration-api/core.h>
-#include <dali/integration-api/system-overlay.h>
+#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/actors/camera-actor.h>
#include <dali/public-api/render-tasks/render-task.h>
#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/public-api/rendering/frame-buffer.h>
#include <dali/devel-api/adaptor-framework/orientation.h>
+#include <dali/integration-api/events/touch-event-integ.h>
// INTERNAL HEADERS
-#include <dali/internal/input/common/drag-and-drop-detector-impl.h>
-#include <dali/internal/window-system/common/window-visibility-observer.h>
+#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
+#include <dali/internal/graphics/gles/egl-graphics.h>
+#include <dali/internal/window-system/common/event-handler.h>
#include <dali/internal/window-system/common/orientation-impl.h>
#include <dali/internal/window-system/common/render-surface-factory.h>
#include <dali/internal/window-system/common/window-factory.h>
#include <dali/internal/window-system/common/window-base.h>
+#include <dali/internal/window-system/common/window-system.h>
#include <dali/internal/window-system/common/window-render-surface.h>
+#include <dali/internal/window-system/common/window-visibility-observer.h>
namespace Dali
{
} // unnamed namespace
-Window* Window::New( const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent )
+Window* Window::New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
+{
+ Any surface;
+ return Window::New(surface, positionSize, name, className, isTransparent);
+}
+
+Window* Window::New(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
{
Window* window = new Window();
window->mIsTransparent = isTransparent;
- window->Initialize( positionSize, name, className );
+ window->Initialize(surface, positionSize, name, className);
return window;
}
Window::Window()
-: mSurface( NULL ),
+: 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 ),
- mOverlay( NULL ),
- mAdaptor( NULL ),
mType( Dali::Window::NORMAL ),
- mPreferredOrientation( Dali::Window::PORTRAIT ),
- mIndicatorVisibilityChangedSignal(),
- mFocusChangedSignal(),
- mResizedSignal(),
- mDeleteRequestSignal()
+ mParentWindow( NULL ),
+ mPreferredAngle( Dali::Window::NO_ORIENTATION_PREFERENCE ),
+ mRotationAngle( -1 ),
+ mWindowWidth( 0 ),
+ mWindowHeight( 0 ),
+ mOrientationMode( Internal::Adaptor::Window::OrientationMode::PORTRAIT ),
+ mNativeWindowId( -1 ),
+ mDeleteRequestSignal(),
+ mFocusChangeSignal(),
+ mResizeSignal(),
+ mVisibilityChangedSignal(),
+ mTransitionEffectEventSignal(),
+ mKeyboardRepeatSettingsChangedSignal()
{
}
Window::~Window()
{
- if( mIndicator )
+ if ( mEventHandler )
{
- mOverlay->Remove( mIndicator->GetActor() );
- Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
- Dali::RenderTask indicatorTask = taskList.GetTask(0);
- mOverlay->GetOverlayRenderTasks().RemoveTask(indicatorTask);
- mIndicator->Close();
+ mEventHandler->RemoveObserver( *this );
}
-
- if ( mAdaptor )
- {
- mAdaptor->RemoveObserver( *this );
- mAdaptor->SetDragAndDropDetector( NULL );
- mAdaptor = NULL;
- }
-
- delete mSurface;
}
-void Window::Initialize(const PositionSize& positionSize, const std::string& name, const std::string& className)
+void Window::Initialize(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className)
{
// Create a window render surface
- Any surface;
auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();
- auto windowRenderSurface = renderSurfaceFactory->CreateWindowRenderSurface( positionSize, surface, mIsTransparent );
- mSurface = windowRenderSurface.release();
+ mSurface = renderSurfaceFactory->CreateWindowRenderSurface( positionSize, surface, mIsTransparent );
+ mWindowSurface = static_cast<WindowRenderSurface*>( 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->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed );
mWindowBase->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest );
- mWindowBase->IndicatorFlickedSignal().Connect( this, &Window::OnIndicatorFlicked );
+ mWindowBase->TransitionEffectEventSignal().Connect( this, &Window::OnTransitionEffectEvent );
+ mWindowBase->KeyboardRepeatSettingsChangedSignal().Connect( this, &Window::OnKeyboardRepeatSettingsChanged );
+ mWindowBase->WindowRedrawRequestSignal().Connect( this, &Window::OnWindowRedrawRequest );
+
+ mWindowSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed );
if( !positionSize.IsEmpty() )
{
SetClass( name, className );
- mSurface->Map();
+ mWindowSurface->Map();
mOrientation = Orientation::New( this );
-}
-
-void Window::SetAdaptor(Dali::Adaptor& adaptor)
-{
- DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" );
- mStarted = true;
-
- // Only create one overlay per window
- Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
- Integration::Core& core = adaptorImpl.GetCore();
- mOverlay = &core.GetSystemOverlay();
-
- Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
- taskList.CreateTask();
-
- mAdaptor = &adaptorImpl;
- mAdaptor->AddObserver( *this );
-
- // Can only create the detector when we know the Core has been instantiated.
- mDragAndDropDetector = DragAndDropDetector::New();
- mAdaptor->SetDragAndDropDetector( &GetImplementation( mDragAndDropDetector ) );
- if( mOrientation )
+ // Get OrientationMode
+ int screenWidth, screenHeight;
+ WindowSystem::GetScreenSize( screenWidth, screenHeight );
+ if( screenWidth > screenHeight )
{
- mOrientation->SetAdaptor(adaptor);
+ mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE;
}
-
- if( mIndicator != NULL )
+ else
{
- mIndicator->SetAdaptor(mAdaptor);
+ mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT;
}
+ // For Debugging
+ mNativeWindowId = mWindowBase->GetNativeWindowId();
}
-WindowRenderSurface* Window::GetSurface()
+void Window::OnAdaptorSet(Dali::Adaptor& adaptor)
{
- return mSurface;
+ mEventHandler = EventHandlerPtr(new EventHandler( mWindowSurface, *mAdaptor ) );
+ mEventHandler->AddObserver( *this );
}
-void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
+void Window::OnSurfaceSet( Dali::RenderSurfaceInterface* surface )
{
- // TODO: Enable this after indicator implementation based on tizen 5.
-// mIndicatorVisible = visibleMode;
-
- mWindowBase->ShowIndicator( mIndicatorVisible, mIndicatorOpacityMode );
-
- DoShowIndicator( mIndicatorOrientation );
+ mWindowSurface = static_cast<WindowRenderSurface*>( surface );
}
-void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode )
+void Window::SetClass( std::string name, std::string className )
{
- mIndicatorOpacityMode = opacityMode;
+ mName = name;
+ mClassName = className;
+ mWindowBase->SetClass( name, className );
+}
- if( mIndicator != NULL )
- {
- mIndicator->SetOpacityMode( opacityMode );
- }
+std::string Window::GetClassName() const
+{
+ return mClassName;
}
-void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode )
+void Window::Raise()
{
- // TODO: Enable this after indicator implementation based on tizen 5.
-// mIndicatorVisible = mode;
+ mWindowBase->Raise();
+
+ mSurface->SetFullSwapNextFrame();
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Raise() \n", this, mNativeWindowId );
}
-void Window::RotateIndicator( Dali::Window::WindowOrientation orientation )
+void Window::Lower()
{
- DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "Orientation: %d\n", orientation );
+ mWindowBase->Lower();
- DoRotateIndicator( orientation );
+ mSurface->SetFullSwapNextFrame();
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Lower() \n", this, mNativeWindowId );
}
-void Window::SetClass( std::string name, std::string className )
+void Window::Activate()
{
- mWindowBase->SetClass( name, className );
+ mWindowBase->Activate();
+
+ mSurface->SetFullSwapNextFrame();
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId );
}
-void Window::Raise()
+uint32_t Window::GetLayerCount() const
{
- mWindowBase->Raise();
+ return mScene.GetLayerCount();
}
-void Window::Lower()
+Dali::Layer Window::GetLayer( uint32_t depth ) const
{
- mWindowBase->Lower();
+ return mScene.GetLayer( depth );
}
-void Window::Activate()
+Dali::RenderTaskList Window::GetRenderTaskList() const
{
- mWindowBase->Activate();
+ return mScene.GetRenderTaskList();
}
void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation )
{
- bool found = false;
+ if( IsOrientationAvailable( orientation ) == false )
+ {
+ return;
+ }
- if( orientation <= Dali::Window::LANDSCAPE_INVERSE )
+ bool found = false;
+ int convertedAngle = ConvertToAngle( orientation );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), AddAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle );
+ for( std::size_t i = 0; i < mAvailableAngles.size(); i++ )
{
- for( std::size_t i = 0; i < mAvailableOrientations.size(); i++ )
+ if( mAvailableAngles[i] == convertedAngle )
{
- if( mAvailableOrientations[i] == orientation )
- {
- found = true;
- break;
- }
+ found = true;
+ break;
}
+ }
- if( !found )
- {
- mAvailableOrientations.push_back( orientation );
- SetAvailableOrientations( mAvailableOrientations );
- }
+ if( !found )
+ {
+ mAvailableAngles.push_back( convertedAngle );
+ SetAvailableAnlges( mAvailableAngles );
}
}
void Window::RemoveAvailableOrientation( Dali::Window::WindowOrientation orientation )
{
- for( std::vector<Dali::Window::WindowOrientation>::iterator iter = mAvailableOrientations.begin();
- iter != mAvailableOrientations.end(); ++iter )
+ if( IsOrientationAvailable( orientation ) == false )
+ {
+ return;
+ }
+
+ int convertedAngle = ConvertToAngle( orientation );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), RemoveAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle );
+ for( std::vector< int >::iterator iter = mAvailableAngles.begin();
+ iter != mAvailableAngles.end(); ++iter )
{
- if( *iter == orientation )
+ if( *iter == convertedAngle )
{
- mAvailableOrientations.erase( iter );
+ mAvailableAngles.erase( iter );
break;
}
}
- SetAvailableOrientations( mAvailableOrientations );
+
+ SetAvailableAnlges( mAvailableAngles );
}
-void Window::SetAvailableOrientations( const std::vector< Dali::Window::WindowOrientation >& orientations )
+void Window::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
{
- if( orientations.size() > 4 )
+ if( orientation < Dali::Window::NO_ORIENTATION_PREFERENCE || orientation > Dali::Window::LANDSCAPE_INVERSE )
{
- DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAvailableOrientations: Invalid vector size! [%d]\n", orientations.size() );
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::CheckOrientation: Invalid input orientation [%d]\n", orientation );
return;
}
-
- mAvailableOrientations = orientations;
-
- mWindowBase->SetAvailableOrientations( mAvailableOrientations );
+ mPreferredAngle = ConvertToAngle( orientation );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle );
+ mWindowBase->SetPreferredAngle( mPreferredAngle );
}
-const std::vector< Dali::Window::WindowOrientation >& Window::GetAvailableOrientations()
+Dali::Window::WindowOrientation Window::GetPreferredOrientation()
{
- return mAvailableOrientations;
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle );
+ Dali::Window::WindowOrientation preferredOrientation = ConvertToOrientation( mPreferredAngle );
+ return preferredOrientation;
}
-void Window::SetPreferredOrientation( Dali::Window::WindowOrientation orientation )
+void Window::SetAvailableAnlges( const std::vector< int >& angles )
{
- mPreferredOrientation = orientation;
+ if( angles.size() > 4 )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size() );
+ return;
+ }
- mWindowBase->SetPreferredOrientation( mPreferredOrientation );
+ mWindowBase->SetAvailableAnlges( angles );
}
-Dali::Window::WindowOrientation Window::GetPreferredOrientation()
+int Window::ConvertToAngle( Dali::Window::WindowOrientation orientation )
{
- return mPreferredOrientation;
+ int convertAngle = static_cast< int >( orientation );
+ if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE )
+ {
+ switch( orientation )
+ {
+ case Dali::Window::LANDSCAPE:
+ {
+ convertAngle = 0;
+ break;
+ }
+ case Dali::Window::PORTRAIT:
+ {
+ convertAngle = 90;
+ break;
+ }
+ case Dali::Window::LANDSCAPE_INVERSE:
+ {
+ convertAngle = 180;
+ break;
+ }
+ case Dali::Window::PORTRAIT_INVERSE:
+ {
+ convertAngle = 270;
+ break;
+ }
+ case Dali::Window::NO_ORIENTATION_PREFERENCE:
+ {
+ convertAngle = -1;
+ break;
+ }
+ }
+ }
+ return convertAngle;
}
-Dali::DragAndDropDetector Window::GetDragAndDropDetector() const
+Dali::Window::WindowOrientation Window::ConvertToOrientation( int angle ) const
{
- return mDragAndDropDetector;
+ Dali::Window::WindowOrientation orientation = static_cast< Dali::Window::WindowOrientation >( angle );
+ if( mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE )
+ {
+ switch( angle )
+ {
+ case 0:
+ {
+ orientation = Dali::Window::LANDSCAPE;
+ break;
+ }
+ case 90:
+ {
+ orientation = Dali::Window::PORTRAIT;
+ break;
+ }
+ case 180:
+ {
+ orientation = Dali::Window::LANDSCAPE_INVERSE;
+ break;
+ }
+ case 270:
+ {
+ orientation = Dali::Window::PORTRAIT_INVERSE;
+ break;
+ }
+ case -1:
+ {
+ orientation = Dali::Window::NO_ORIENTATION_PREFERENCE;
+ break;
+ }
+ }
+ }
+ return orientation;
+}
+
+bool Window::IsOrientationAvailable( Dali::Window::WindowOrientation orientation ) const
+{
+ if( orientation <= Dali::Window::NO_ORIENTATION_PREFERENCE || orientation > Dali::Window::LANDSCAPE_INVERSE )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::IsOrientationAvailable: Invalid input orientation [%d]\n", orientation );
+ return false;
+ }
+ return true;
}
Dali::Any Window::GetNativeHandle() const
{
- return mSurface->GetNativeWindow();
+ return mWindowSurface->GetNativeWindow();
}
void Window::SetAcceptFocus( bool accept )
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowShown();
- DALI_LOG_RELEASE_INFO( "Window (%p) ::Show()\n", this );
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, true );
}
+
+ mSurface->SetFullSwapNextFrame();
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
}
void Window::Hide()
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowHidden();
- DALI_LOG_RELEASE_INFO( "Window (%p) ::Hide() \n", this );
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, false );
}
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
}
bool Window::IsVisible() const
{
- return mVisible;
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), IsVisible(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible );
+ return mVisible && !mIconified;
}
unsigned int Window::GetSupportedAuxiliaryHintCount() const
mResizeEnabled = true;
}
- PositionSize positionSize = mSurface->GetPositionSize();
+ PositionSize oldRect = mSurface->GetPositionSize();
+
+ mWindowSurface->MoveResize( PositionSize( oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight() ) );
- if( positionSize.width != size.GetWidth() || positionSize.height != 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 ) )
{
- positionSize.width = size.GetWidth();
- positionSize.height = size.GetHeight();
+ Uint16Pair newSize( newRect.width, newRect.height );
+
+ SurfaceResized();
- mSurface->MoveResize( positionSize );
+ mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
- mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetSize(): resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height );
- // Emit signal
- mResizedSignal.Emit( Dali::Window::WindowSize( positionSize.width, positionSize.height ) );
+ Dali::Window handle( this );
+ mResizeSignal.Emit( handle, newSize );
- mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+ mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
+
+ mSurface->SetFullSwapNextFrame();
}
Dali::Window::WindowSize Window::GetSize() const
mResizeEnabled = true;
}
- PositionSize positionSize = mSurface->GetPositionSize();
+ PositionSize oldRect = mSurface->GetPositionSize();
- if( positionSize.x != position.GetX() || positionSize.y != position.GetY() )
- {
- positionSize.x = position.GetX();
- positionSize.y = position.GetY();
+ mWindowSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) );
- mSurface->MoveResize( positionSize );
- }
+ mSurface->SetFullSwapNextFrame();
}
Dali::Window::WindowPosition Window::GetPosition() const
return Dali::Window::WindowPosition( positionSize.x, positionSize.y );
}
-void Window::SetTransparency( bool transparent )
+void Window::SetPositionSize( PositionSize positionSize )
{
- mSurface->SetTransparency( transparent );
-}
+ if( !mResizeEnabled )
+ {
+ AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" );
+ mResizeEnabled = true;
+ }
-bool Window::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
-{
- return mWindowBase->GrabKey( key, grabMode );
-}
+ PositionSize oldRect = mSurface->GetPositionSize();
-bool Window::UngrabKey( Dali::KEY key )
-{
- return mWindowBase->UngrabKey( key );
-}
+ mWindowSurface->MoveResize( positionSize );
-bool Window::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
-{
- return mWindowBase->GrabKeyList( key, grabMode, result );
-}
+ PositionSize newRect = mSurface->GetPositionSize();
-bool Window::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
-{
- return mWindowBase->UngrabKeyList( key, result );
-}
+ // 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 );
-void Window::RotationDone( int orientation, int width, int height )
-{
- mSurface->RequestRotation( orientation, width, height );
+ SurfaceResized();
- mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( width, height ) );
+ mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
- // Emit signal
- mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
+ 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 );
+ }
- mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( width, height ) );
+ mSurface->SetFullSwapNextFrame();
}
-void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )
+Dali::Layer Window::GetRootLayer() const
{
- 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();
- mOverlay->Add(actor);
- }
- }
- // 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.
- }
- }
- }
+ return mScene.GetRootLayer();
+}
- // set indicator visible mode
- if( mIndicator != NULL )
- {
- mIndicator->SetVisible( mIndicatorVisible );
- }
+void Window::SetTransparency( bool transparent )
+{
+ mWindowSurface->SetTransparency( transparent );
+}
- bool show = (mIndicatorVisible != Dali::Window::INVISIBLE );
- SetIndicatorProperties( show, lastOrientation );
- mIndicatorIsShown = show;
+bool Window::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
+{
+ return mWindowBase->GrabKey( key, grabMode );
}
-void Window::DoRotateIndicator( Dali::Window::WindowOrientation orientation )
+bool Window::UngrabKey( Dali::KEY key )
{
- 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;
- }
+ return mWindowBase->UngrabKey( key );
}
-void Window::SetIndicatorActorRotation()
+bool Window::GrabKeyList( const Dali::Vector< Dali::KEY >& key, const Dali::Vector< KeyGrab::KeyGrabMode >& grabMode, Dali::Vector< bool >& result )
{
- 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;
- }
- }
+ return mWindowBase->GrabKeyList( key, grabMode, result );
}
-void Window::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientation lastOrientation )
+bool Window::UngrabKeyList( const Dali::Vector< Dali::KEY >& key, Dali::Vector< bool >& result )
{
- mWindowBase->SetIndicatorProperties( isShow, lastOrientation );
+ return mWindowBase->UngrabKeyList( key, result );
}
void Window::OnIconifyChanged( bool iconified )
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowHidden();
- DALI_LOG_RELEASE_INFO( "Window (%p) Iconified\n", this );
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, false );
}
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Iconified: visible = %d\n", this, mNativeWindowId, mVisible );
}
else
{
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowShown();
- DALI_LOG_RELEASE_INFO( "Window (%p) Deiconified\n", this );
+
+ Dali::Window handle( this );
+ mVisibilityChangedSignal.Emit( handle, true );
}
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible );
}
+
+ mSurface->SetFullSwapNextFrame();
}
void Window::OnFocusChanged( bool focusIn )
{
- mFocusChangedSignal.Emit( focusIn );
+ Dali::Window handle( this );
+ mFocusChangeSignal.Emit( handle, focusIn );
+
+ mSurface->SetFullSwapNextFrame();
}
void Window::OnOutputTransformed()
{
PositionSize positionSize = mSurface->GetPositionSize();
- mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
- mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+ SurfaceResized();
+ mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
+ mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
}
void Window::OnDeleteRequest()
mDeleteRequestSignal.Emit();
}
-void Window::OnIndicatorFlicked()
+void Window::OnTransitionEffectEvent( DevelWindow::EffectState state, DevelWindow::EffectType type )
+{
+ Dali::Window handle( this );
+ mTransitionEffectEventSignal.Emit( handle, state, type );
+}
+
+void Window::OnKeyboardRepeatSettingsChanged()
{
- if( mIndicator )
+ Dali::Window handle( this );
+ mKeyboardRepeatSettingsChangedSignal.Emit();
+}
+
+void Window::OnWindowRedrawRequest()
+{
+ mAdaptor->RenderOnce();
+}
+
+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 );
+
+ SurfaceResized();
+
+ mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
+
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), OnRotation(): resize signal emit [%d x %d]\n", this, mNativeWindowId, mWindowWidth, mWindowHeight );
+ // Emit signal
+ Dali::Window handle( this );
+ mResizeSignal.Emit( handle, Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) );
+
+ mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
+}
+
+void Window::OnPause()
+{
+ if( mEventHandler )
{
- mIndicator->Flicked();
+ mEventHandler->Pause();
}
}
-void Window::IndicatorTypeChanged( IndicatorInterface::Type type )
+void Window::OnResume()
{
- mWindowBase->IndicatorTypeChanged( type );
+ if( mEventHandler )
+ {
+ mEventHandler->Resume();
+ }
+
+ mSurface->SetFullSwapNextFrame();
}
-void Window::IndicatorClosed( IndicatorInterface* indicator )
+void Window::RecalculateTouchPosition( Integration::Point& point )
{
- DALI_LOG_TRACE_METHOD( gWindowLogFilter );
+ Vector2 position = point.GetScreenPosition();
+ Vector2 convertedPosition;
- if( mShowRotatedIndicatorOnClose )
+ switch( mRotationAngle )
{
- Dali::Window::WindowOrientation currentOrientation = mIndicatorOrientation;
- if( mIndicator )
+ case 90:
+ {
+ convertedPosition.x = static_cast<float>( mWindowWidth ) - position.y;
+ convertedPosition.y = position.x;
+ break;
+ }
+ case 180:
{
- mIndicator->Open( mNextIndicatorOrientation );
+ convertedPosition.x = static_cast<float>( mWindowWidth ) - position.x;
+ convertedPosition.y = static_cast<float>( mWindowHeight ) - position.y;
+ break;
+ }
+ case 270:
+ {
+ convertedPosition.x = position.y;
+ convertedPosition.y = static_cast<float>( mWindowHeight ) - position.x;
+ break;
+ }
+ default:
+ {
+ convertedPosition = position;
+ break;
}
- mIndicatorOrientation = mNextIndicatorOrientation;
- SetIndicatorActorRotation();
- DoShowIndicator( currentOrientation );
}
+
+ point.SetScreenPosition( convertedPosition );
}
-void Window::IndicatorVisibilityChanged( bool isVisible )
+Dali::Window Window::Get( Dali::Actor actor )
{
- mIndicatorVisibilityChangedSignal.Emit( isVisible );
+ Internal::Adaptor::Window* windowImpl = nullptr;
+
+ if ( Internal::Adaptor::Adaptor::IsAvailable() )
+ {
+ Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() );
+ windowImpl = dynamic_cast<Internal::Adaptor::Window*>( adaptor.GetWindow( actor ) );
+ if( windowImpl )
+ {
+ return Dali::Window( windowImpl );
+ }
+ }
+
+ return Dali::Window();
}
-void Window::OnStart()
+void Window::SetParent( Dali::Window& parent )
{
- DoShowIndicator( mIndicatorOrientation );
+ 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::OnPause()
+void Window::Unparent()
{
+ mWindowBase->SetParent( nullptr );
+ mParentWindow.Reset();
}
-void Window::OnResume()
+Dali::Window Window::GetParent()
{
- // resume indicator status
- if( mIndicator != NULL )
- {
- // Restore own indicator opacity
- // Send opacity mode to indicator service when app resumed
- mIndicator->SetOpacityMode( mIndicatorOpacityMode );
- }
+ return mParentWindow;
}
-void Window::OnStop()
+Dali::Window::WindowOrientation Window::GetCurrentOrientation() const
{
- if( mIndicator )
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mRotationAngle );
+ return ConvertToOrientation( mRotationAngle );
+}
+
+void Window::SetAvailableOrientations( const Dali::Vector<Dali::Window::WindowOrientation>& orientations )
+{
+ Dali::Vector<float>::SizeType count = orientations.Count();
+ for( Dali::Vector<float>::SizeType index = 0; index < count; ++index )
{
- mIndicator->Close();
- }
+ 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;
+ }
+ }
- mIndicator.release();
+ if( !found )
+ {
+ DALI_LOG_RELEASE_INFO( "Window (%p), WinId (%d), SetAvailableOrientations: %d\n", this, mNativeWindowId, convertedAngle );
+ mAvailableAngles.push_back( convertedAngle );
+ }
+ }
+ SetAvailableAnlges( mAvailableAngles );
}
-void Window::OnDestroy()
+int32_t Window::GetNativeId() const
{
- mAdaptor = NULL;
+ return mWindowBase->GetNativeWindowId();
}
} // Adaptor