// EXTERNAL HEADERS
#include <dali/integration-api/core.h>
-#include <dali/integration-api/render-task-list-integ.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-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>
+
+#ifdef DALI_ADAPTOR_COMPILATION
+#include <dali/integration-api/render-surface-interface.h>
+#else
+#include <dali/integration-api/adaptors/render-surface-interface.h>
+#endif
// 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/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-render-surface.h>
+#include <dali/internal/window-system/common/window-visibility-observer.h>
namespace Dali
{
namespace Adaptor
{
-uint32_t Window::mWindowCounter = 0;
-
namespace
{
}
Window::Window()
-: mId( mWindowCounter++ ),
- mSurface( nullptr ),
+: mWindowSurface( nullptr ),
mWindowBase(),
- mStarted( false ),
+ mIsTransparent( false ),
mIsFocusAcceptable( true ),
- mVisible( true ),
mIconified( false ),
mOpaqueState( false ),
mResizeEnabled( false ),
- mAdaptor( NULL ),
mType( Dali::Window::NORMAL ),
+ mParentWindow( NULL ),
mPreferredOrientation( Dali::Window::PORTRAIT ),
+ mRotationAngle( 0 ),
+ mWindowWidth( 0 ),
+ mWindowHeight( 0 ),
mFocusChangedSignal(),
mResizedSignal(),
- mDeleteRequestSignal()
+ mDeleteRequestSignal(),
+ mFocusChangeSignal(),
+ mResizeSignal()
{
}
Window::~Window()
{
- if ( mAdaptor )
+ if ( mEventHandler )
{
- mAdaptor->RemoveObserver( *this );
- mAdaptor->SetDragAndDropDetector( NULL );
- mAdaptor->RemoveWindow( this );
- mAdaptor = NULL;
+ mEventHandler->RemoveObserver( *this );
}
-
- mSurface.reset( nullptr );
}
void Window::Initialize(const PositionSize& positionSize, const std::string& name, const std::string& className)
Any surface;
auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();
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->DeleteRequestSignal().Connect( this, &Window::OnDeleteRequest );
- mSurface->OutputTransformedSignal().Connect( this, &Window::OnOutputTransformed );
+ 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)
+void Window::OnAdaptorSet(Dali::Adaptor& adaptor)
{
- DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" );
- mStarted = true;
-
- PositionSize positionSize = mSurface->GetPositionSize();
- mScene = Dali::Integration::Scene::New( Vector2(positionSize.width, positionSize.height) );
- mScene.SetSurface( *mSurface.get() );
-
- unsigned int dpiHorizontal, dpiVertical;
- dpiHorizontal = dpiVertical = 0;
-
- mSurface->GetDpi( dpiHorizontal, dpiVertical );
- mScene.SetDpi( Vector2( static_cast<float>( dpiHorizontal ), static_cast<float>( dpiVertical ) ) );
-
- // Create one overlay for the main window only
- Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
- mAdaptor = &adaptorImpl;
- mAdaptor->AddObserver( *this );
-
- // Can only create the detector when we know the Core has been instantiated.
- mDragAndDropDetector = DragAndDropDetector::New();
- mAdaptor->SetDragAndDropDetector( &GetImplementation( mDragAndDropDetector ) );
-
- if( mOrientation )
- {
- mOrientation->SetAdaptor(adaptor);
- }
-
- mSurface->SetAdaptor( *mAdaptor );
+ mEventHandler = EventHandlerPtr(new EventHandler( mWindowSurface, *mAdaptor ) );
+ mEventHandler->AddObserver( *this );
}
-WindowRenderSurface* Window::GetSurface()
+void Window::OnSurfaceSet( Dali::RenderSurfaceInterface* surface )
{
- return mSurface.get();
+ mWindowSurface = static_cast<WindowRenderSurface*>( surface );
}
void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
void Window::SetClass( std::string name, std::string className )
{
+ mName = name;
+ mClassName = className;
mWindowBase->SetClass( name, className );
}
+std::string Window::GetClassName() const
+{
+ return mClassName;
+}
+
void Window::Raise()
{
mWindowBase->Raise();
+ DALI_LOG_RELEASE_INFO( "Window (%p) Raise() \n", this );
}
void Window::Lower()
{
mWindowBase->Lower();
+ DALI_LOG_RELEASE_INFO( "Window (%p) Lower() \n", this );
}
void Window::Activate()
{
mWindowBase->Activate();
-}
-
-void Window::Add( Dali::Actor actor )
-{
- mScene.Add( actor );
-}
-
-void Window::Remove( Dali::Actor actor )
-{
- mScene.Remove( actor );
-}
-
-Dali::Layer Window::GetRootLayer() const
-{
- return mScene.GetRootLayer();
+ DALI_LOG_RELEASE_INFO( "Window (%p) Activate() \n", this );
}
uint32_t Window::GetLayerCount() const
return mScene.GetLayer( depth );
}
-void Window::SetBackgroundColor( Vector4 color )
+Dali::RenderTaskList Window::GetRenderTaskList() const
{
- if ( mSurface )
- {
- mSurface->SetBackgroundColor( color );
- }
-}
-
-Vector4 Window::GetBackgroundColor() const
-{
- return mSurface ? mSurface->GetBackgroundColor() : Vector4();
+ return mScene.GetRenderTaskList();
}
void Window::AddAvailableOrientation( Dali::Window::WindowOrientation orientation )
return mPreferredOrientation;
}
-Dali::DragAndDropDetector Window::GetDragAndDropDetector() const
-{
- return mDragAndDropDetector;
-}
-
Dali::Any Window::GetNativeHandle() const
{
- return mSurface->GetNativeWindow();
+ return mWindowSurface->GetNativeWindow();
}
void Window::SetAcceptFocus( bool accept )
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowShown();
- DALI_LOG_RELEASE_INFO( "Window (%p) ::Show()\n", this );
}
+
+ DALI_LOG_RELEASE_INFO( "Window (%p) Show(): iconified = %d\n", this, mIconified );
}
void Window::Hide()
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowHidden();
- DALI_LOG_RELEASE_INFO( "Window (%p) ::Hide() \n", this );
}
+
+ DALI_LOG_RELEASE_INFO( "Window (%p) Hide(): iconified = %d\n", this, mIconified );
}
bool Window::IsVisible() const
{
- return mVisible;
+ return mVisible && !mIconified;
}
unsigned int Window::GetSupportedAuxiliaryHintCount() const
PositionSize oldRect = mSurface->GetPositionSize();
- mSurface->MoveResize( PositionSize( oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight() ) );
+ mWindowSurface->MoveResize( PositionSize( oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight() ) );
PositionSize newRect = mSurface->GetPositionSize();
{
Uint16Pair newSize( newRect.width, newRect.height );
+ bool forceUpdate = false;
+ if( mWindowBase->IsEglWindowRotationSupported() )
+ {
+ forceUpdate = true;
+ }
+
+ SurfaceResized( forceUpdate );
+
mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
+ Dali::Window handle( this );
mResizedSignal.Emit( newSize );
+ mResizeSignal.Emit( handle, newSize );
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
PositionSize oldRect = mSurface->GetPositionSize();
- mSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) );
+ mWindowSurface->MoveResize( PositionSize( position.GetX(), position.GetY(), oldRect.width, oldRect.height ) );
}
Dali::Window::WindowPosition Window::GetPosition() const
PositionSize oldRect = mSurface->GetPositionSize();
- mSurface->MoveResize( positionSize );
+ mWindowSurface->MoveResize( positionSize );
PositionSize newRect = mSurface->GetPositionSize();
{
Uint16Pair newSize( newRect.width, newRect.height );
+ bool forceUpdate = false;
+ if( mWindowBase->IsEglWindowRotationSupported() )
+ {
+ forceUpdate = true;
+ }
+
+ SurfaceResized( forceUpdate );
+
mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
+ Dali::Window handle( this );
mResizedSignal.Emit( newSize );
-
+ mResizeSignal.Emit( handle, newSize );
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
}
+Dali::Layer Window::GetRootLayer() const
+{
+ return mScene.GetRootLayer();
+}
+
void Window::SetTransparency( bool transparent )
{
- mSurface->SetTransparency( transparent );
+ mWindowSurface->SetTransparency( transparent );
}
bool Window::GrabKey( Dali::KEY key, KeyGrab::KeyGrabMode grabMode )
return mWindowBase->UngrabKeyList( key, result );
}
-void Window::RotationDone( int orientation, int width, int height )
-{
- mSurface->RequestRotation( orientation, width, height );
-
- mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( width, height ) );
-
- // Emit signal
- mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) );
-
- mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( width, height ) );
-}
-
void Window::OnIconifyChanged( bool iconified )
{
if( iconified )
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowHidden();
- DALI_LOG_RELEASE_INFO( "Window (%p) Iconified\n", this );
}
+
+ DALI_LOG_RELEASE_INFO( "Window (%p) Iconified: visible = %d\n", this, mVisible );
}
else
{
{
WindowVisibilityObserver* observer( mAdaptor );
observer->OnWindowShown();
- DALI_LOG_RELEASE_INFO( "Window (%p) Deiconified\n", this );
}
+
+ DALI_LOG_RELEASE_INFO( "Window (%p) Deiconified: visible = %d\n", this, mVisible );
}
}
void Window::OnFocusChanged( bool focusIn )
{
+ Dali::Window handle( this );
mFocusChangedSignal.Emit( focusIn );
+ mFocusChangeSignal.Emit( handle, focusIn );
}
void Window::OnOutputTransformed()
{
+ bool forceUpdate = false;
+ if( mWindowBase->IsEglWindowRotationSupported() )
+ {
+ forceUpdate = true;
+ }
PositionSize positionSize = mSurface->GetPositionSize();
+ SurfaceResized( forceUpdate );
mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( positionSize.width, positionSize.height ) );
}
mDeleteRequestSignal.Emit();
}
-void Window::OnStart()
+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 );
+
+ bool forceUpdate = false;
+ if( mWindowBase->IsEglWindowRotationSupported() )
+ {
+ forceUpdate = true;
+ }
+
+ SurfaceResized( forceUpdate );
+
+ mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
+
+ // Emit signal
+ Dali::Window handle( this );
+ mResizedSignal.Emit( Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) );
+ mResizeSignal.Emit( handle, Dali::Window::WindowSize( mWindowWidth, mWindowHeight ) );
+
+ mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mWindowWidth, mWindowHeight ) );
}
void Window::OnPause()
{
+ if( mEventHandler )
+ {
+ mEventHandler->Pause();
+ }
}
void Window::OnResume()
{
+ if( mEventHandler )
+ {
+ mEventHandler->Resume();
+ }
}
-void Window::OnStop()
+void Window::RecalculateTouchPosition( Integration::Point& point )
{
+ Vector2 position = point.GetScreenPosition();
+ Vector2 convertedPosition;
+
+ switch( mRotationAngle )
+ {
+ case 90:
+ {
+ convertedPosition.x = static_cast<float>( mWindowWidth ) - position.y;
+ convertedPosition.y = position.x;
+ break;
+ }
+ case 180:
+ {
+ 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;
+ }
+ }
+
+ point.SetScreenPosition( convertedPosition );
+}
+
+Dali::Window Window::Get( Dali::Actor actor )
+{
+ Internal::Adaptor::Window* windowImpl = nullptr;
+
+ if ( Internal::Adaptor::Adaptor::IsAvailable() )
+ {
+ Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation( Internal::Adaptor::Adaptor::Get() );
+ windowImpl = static_cast<Internal::Adaptor::Window*>( adaptor.GetWindow( actor ) );
+ }
+
+ return Dali::Window( windowImpl );
+}
+
+void Window::SetParent( Dali::Window& parent )
+{
+ if ( DALI_UNLIKELY( parent ) )
+ {
+ mParentWindow = parent;
+ Dali::Window grandParent = Dali::DevelWindow::GetParent( parent );
+ // check circular parent window setting
+ if ( DALI_UNLIKELY( grandParent ) && mWindowBase->IsMatchedWindow( grandParent.GetNativeHandle() ) )
+ {
+ Dali::DevelWindow::Unparent( parent );
+ }
+ mWindowBase->SetParent( parent.GetNativeHandle() );
+ }
}
-void Window::OnDestroy()
+void Window::Unparent()
{
- mAdaptor = NULL;
+ Any parent;
+ mWindowBase->SetParent( parent );
}
-uint32_t Window::GetId() const
+Dali::Window Window::GetParent()
{
- return mId;
+ return mParentWindow;
}
} // Adaptor
projects / platform / core / uifw / dali-adaptor.git / blobdiff