X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fecore%2Fwayland%2Fwindow-impl-ecore-wl.cpp;h=97ee23e182ba8d2c1eb6393684a21e971b53fac0;hb=4a014cd851e4128f8efadcc3cf3aa77fda82bcc6;hp=692749b4a9fbac72d91dbbb290599a4be97b0371;hpb=a23bd76bc3499ef6d56b3bc060ab29b9df0e982c;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/adaptors/ecore/wayland/window-impl-ecore-wl.cpp b/adaptors/ecore/wayland/window-impl-ecore-wl.cpp index 692749b..97ee23e 100644 --- a/adaptors/ecore/wayland/window-impl-ecore-wl.cpp +++ b/adaptors/ecore/wayland/window-impl-ecore-wl.cpp @@ -41,9 +41,13 @@ namespace { + const float INDICATOR_ANIMATION_DURATION( 0.18f ); // 180 milli seconds const float INDICATOR_SHOW_Y_POSITION( 0.0f ); const float INDICATOR_HIDE_Y_POSITION( -52.0f ); + +const uint32_t MAX_TIZEN_CLIENT_VERSION = 7; + } namespace Dali @@ -68,11 +72,7 @@ struct Window::EventHandler */ EventHandler( Window* window ) : mWindow( window ), - mWindowPropertyHandler( NULL ), - mWindowIconifyStateHandler( NULL ), - mWindowVisibilityStateHandler( NULL ), - mWindowFocusInHandler( NULL ), - mWindowFocusOutHandler( NULL ), + mEcoreEventHandler(), mEcoreWindow( 0 ), mDisplay( NULL ), mEventQueue( NULL ), @@ -81,9 +81,9 @@ struct Window::EventHandler mNotificationLevel( -1 ), mNotificationChangeState( 0 ), mNotificationLevelChangeDone( true ), - mScreenMode( 0 ), - mScreenModeChangeState( 0 ), - mScreenModeChangeDone( true ), + mScreenOffMode( 0 ), + mScreenOffModeChangeState( 0 ), + mScreenOffModeChangeDone( true ), mBrightness( 0 ), mBrightnessChangeState( 0 ), mBrightnessChangeDone( true ) @@ -98,10 +98,11 @@ struct Window::EventHandler if( mWindow->mEcoreEventHander ) { - mWindowIconifyStateHandler = ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ); - mWindowVisibilityStateHandler = ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE, EcoreEventWindowVisibilityChanged, this ); - mWindowFocusInHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this ); - mWindowFocusOutHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this ); + mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this ) ); + mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this ) ); + mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this ) ); + mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_OUTPUT_TRANSFORM, EcoreEventOutputTransform, this) ); + mEcoreEventHandler.PushBack( ecore_event_handler_add( ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM, EcoreEventIgnoreOutputTransform, this) ); } mDisplay = ecore_wl_display_get(); @@ -130,30 +131,11 @@ struct Window::EventHandler */ ~EventHandler() { - if ( mWindowPropertyHandler ) - { - ecore_event_handler_del( mWindowPropertyHandler ); - } - - if ( mWindowIconifyStateHandler ) - { - ecore_event_handler_del( mWindowIconifyStateHandler ); - } - - if ( mWindowVisibilityStateHandler ) - { - ecore_event_handler_del( mWindowVisibilityStateHandler ); - } - - if( mWindowFocusInHandler ) + for( Dali::Vector< Ecore_Event_Handler* >::Iterator iter = mEcoreEventHandler.Begin(), endIter = mEcoreEventHandler.End(); iter != endIter; ++iter ) { - ecore_event_handler_del( mWindowFocusInHandler ); - } - - if( mWindowFocusOutHandler ) - { - ecore_event_handler_del( mWindowFocusOutHandler ); + ecore_event_handler_del( *iter ); } + mEcoreEventHandler.Clear(); if( mEventQueue ) { @@ -163,12 +145,6 @@ struct Window::EventHandler // Static methods - /// Called when the window properties are changed. - static Eina_Bool EcoreEventWindowPropertyChanged( void* data, int type, void* event ) - { - return EINA_FALSE; - } - /// Called when the window iconify state is changed. static Eina_Bool EcoreEventWindowIconifyStateChanged( void* data, int type, void* event ) { @@ -183,42 +159,21 @@ struct Window::EventHandler { if( iconifyChangedEvent->iconified == EINA_TRUE ) { - observer->OnWindowHidden(); - DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Iconfied\n", handler->mEcoreWindow ); + handler->mWindow->mIconified = true; + if( handler->mWindow->mVisible ) + { + observer->OnWindowHidden(); + } + DALI_LOG_RELEASE_INFO( "EcoreEventWindowIconifyStateChanged: Iconified, mVisible [%d]\n", handler->mWindow->mVisible ); } else { - observer->OnWindowShown(); - DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Shown\n", handler->mEcoreWindow ); - } - handled = ECORE_CALLBACK_DONE; - } - } - - return handled; - } - - /// Called when the window visibility is changed. - static Eina_Bool EcoreEventWindowVisibilityChanged( void* data, int type, void* event ) - { - Ecore_Wl_Event_Window_Visibility_Change* visibilityChangedEvent( static_cast< Ecore_Wl_Event_Window_Visibility_Change* >( event ) ); - EventHandler* handler( static_cast< EventHandler* >( data ) ); - Eina_Bool handled( ECORE_CALLBACK_PASS_ON ); - - if ( handler && handler->mWindow ) - { - WindowVisibilityObserver* observer( handler->mWindow->mAdaptor ); - if ( observer && ( visibilityChangedEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( handler->mEcoreWindow ) ) ) ) - { - if( visibilityChangedEvent->fully_obscured == 1 ) - { - observer->OnWindowHidden(); - DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) full obscured\n", handler->mEcoreWindow ); - } - else - { - observer->OnWindowShown(); - DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Shown\n", handler->mEcoreWindow ); + handler->mWindow->mIconified = false; + if( handler->mWindow->mVisible ) + { + observer->OnWindowShown(); + } + DALI_LOG_RELEASE_INFO( "EcoreEventWindowIconifyStateChanged: Deiconified, mVisible [%d]\n", handler->mWindow->mVisible ); } handled = ECORE_CALLBACK_DONE; } @@ -259,13 +214,63 @@ struct Window::EventHandler return ECORE_CALLBACK_PASS_ON; } + /// Called when the output is transformed + static Eina_Bool EcoreEventOutputTransform( void* data, int type, void* event ) + { + Ecore_Wl_Event_Output_Transform* transformEvent( static_cast< Ecore_Wl_Event_Output_Transform* >( event ) ); + EventHandler* handler( static_cast< EventHandler* >( data ) ); + + if ( handler && handler->mWindow && transformEvent->output == ecore_wl_window_output_find( handler->mEcoreWindow ) ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", handler->mEcoreWindow ); + + ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) ); + if( wlSurface ) + { + wlSurface->OutputTransformed(); + + PositionSize positionSize = wlSurface->GetPositionSize(); + handler->mWindow->mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); + handler->mWindow->mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); + } + } + + return ECORE_CALLBACK_PASS_ON; + } + + /// Called when the output transform should be ignored + static Eina_Bool EcoreEventIgnoreOutputTransform( void* data, int type, void* event ) + { + Ecore_Wl_Event_Ignore_Output_Transform* ignoreTransformEvent( static_cast< Ecore_Wl_Event_Ignore_Output_Transform* >( event ) ); + EventHandler* handler( static_cast< EventHandler* >( data ) ); + + if ( handler && handler->mWindow && ignoreTransformEvent->win == handler->mEcoreWindow ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", handler->mEcoreWindow ); + + ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( handler->mWindow->mSurface ) ); + if( wlSurface ) + { + wlSurface->OutputTransformed(); + + PositionSize positionSize = wlSurface->GetPositionSize(); + handler->mWindow->mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); + handler->mWindow->mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); + } + } + + return ECORE_CALLBACK_PASS_ON; + } + static void RegistryGlobalCallback( void* data, struct wl_registry *registry, uint32_t name, const char* interface, uint32_t version ) { Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data ); if( strcmp( interface, tizen_policy_interface.name ) == 0 ) { - eventHandler->mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, version ) ); + uint32_t clientVersion = std::min( version, MAX_TIZEN_CLIENT_VERSION ); + + eventHandler->mTizenPolicy = static_cast< tizen_policy* >( wl_registry_bind( registry, name, &tizen_policy_interface, clientVersion ) ); if( !eventHandler->mTizenPolicy ) { DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" ); @@ -298,6 +303,14 @@ struct Window::EventHandler eventHandler->mTizenDisplayPolicy = NULL; } + static void TizenPolicyConformant( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t isConformant ) + { + } + + static void TizenPolicyConformantArea( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h ) + { + } + static void TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state ) { Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data ); @@ -309,18 +322,42 @@ struct Window::EventHandler DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::TizenPolicyNotificationChangeDone: level = %d, state = %d\n", level, state ); } - static void TizenPolicyScreenModeChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state ) + static void TizenPolicyTransientForDone( void* data, struct tizen_policy* tizenPolicy, uint32_t childId ) + { + } + + static void TizenPolicyScreenModeChangeDone( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t mode, uint32_t state ) { Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data ); - eventHandler->mScreenMode = mode; - eventHandler->mScreenModeChangeState = state; - eventHandler->mScreenModeChangeDone = true; + eventHandler->mScreenOffMode = mode; + eventHandler->mScreenOffModeChangeState = state; + eventHandler->mScreenOffModeChangeDone = true; DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::TizenPolicyScreenModeChangeDone: mode = %d, state = %d\n", mode, state ); } - static void DisplayPolicyBrightnessChangeDone(void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state ) + static void TizenPolicyIconifyStateChanged( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t iconified, uint32_t force ) + { + } + + static void TizenPolicySupportedAuxiliaryHints( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, struct wl_array* hints, uint32_t numNints ) + { + } + + static void TizenPolicyAllowedAuxiliaryHint( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int id ) + { + } + + static void TizenPolicyAuxiliaryMessage( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, const char* key, const char* val, struct wl_array* options ) + { + } + + static void TizenPolicyConformantRegion( void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h, uint32_t serial ) + { + } + + static void DisplayPolicyBrightnessChangeDone( void* data, struct tizen_display_policy *displayPolicy, struct wl_surface* surface, int32_t brightness, uint32_t state ) { Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data ); @@ -339,15 +376,16 @@ struct Window::EventHandler const struct tizen_policy_listener mTizenPolicyListener = { - NULL, - NULL, + TizenPolicyConformant, + TizenPolicyConformantArea, TizenPolicyNotificationChangeDone, - NULL, + TizenPolicyTransientForDone, TizenPolicyScreenModeChangeDone, - NULL, - NULL, - NULL, - NULL + TizenPolicyIconifyStateChanged, + TizenPolicySupportedAuxiliaryHints, + TizenPolicyAllowedAuxiliaryHint, + TizenPolicyAuxiliaryMessage, + TizenPolicyConformantRegion }; const struct tizen_display_policy_listener mTizenDisplayPolicyListener = @@ -357,11 +395,7 @@ struct Window::EventHandler // Data Window* mWindow; - Ecore_Event_Handler* mWindowPropertyHandler; - Ecore_Event_Handler* mWindowIconifyStateHandler; - Ecore_Event_Handler* mWindowVisibilityStateHandler; - Ecore_Event_Handler* mWindowFocusInHandler; - Ecore_Event_Handler* mWindowFocusOutHandler; + Dali::Vector< Ecore_Event_Handler* > mEcoreEventHandler; Ecore_Wl_Window* mEcoreWindow; wl_display* mDisplay; @@ -373,20 +407,20 @@ struct Window::EventHandler uint32_t mNotificationChangeState; bool mNotificationLevelChangeDone; - int mScreenMode; - uint32_t mScreenModeChangeState; - bool mScreenModeChangeDone; + int mScreenOffMode; + uint32_t mScreenOffModeChangeState; + bool mScreenOffModeChangeDone; int mBrightness; uint32_t mBrightnessChangeState; bool mBrightnessChangeDone; }; -Window* Window::New(const PositionSize& posSize, 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 ) { Window* window = new Window(); window->mIsTransparent = isTransparent; - window->Initialize(posSize, name, className); + window->Initialize( positionSize, name, className ); return window; } @@ -510,14 +544,16 @@ Window::Window() mEcoreEventHander( true ), mIsFocusAcceptable( true ), mVisible( true ), + mIconified( false ), mOpaqueState( false ), + mResizeEnabled( false ), mIndicator( NULL ), mIndicatorOrientation( Dali::Window::PORTRAIT ), mNextIndicatorOrientation( Dali::Window::PORTRAIT ), mIndicatorOpacityMode( Dali::Window::OPAQUE ), mOverlay( NULL ), mAdaptor( NULL ), - mType( Dali::DevelWindow::NORMAL ), + mType( Dali::Window::NORMAL ), mEventHandler( NULL ), mPreferredOrientation( Dali::Window::PORTRAIT ), mSupportedAuxiliaryHints(), @@ -552,17 +588,13 @@ Window::~Window() mAuxiliaryHints.clear(); } -void Window::Initialize(const PositionSize& windowPosition, const std::string& name, const std::string& className) +void Window::Initialize(const PositionSize& positionSize, const std::string& name, const std::string& className) { // create an Wayland window by default Any surface; - ECore::WindowRenderSurface* windowSurface = new ECore::WindowRenderSurface( windowPosition, surface, name, mIsTransparent ); + ECore::WindowRenderSurface* windowSurface = new ECore::WindowRenderSurface( positionSize, surface, name, mIsTransparent ); mSurface = windowSurface; - SetClass( name, className ); - windowSurface->Map(); - - mOrientation = Orientation::New(this); // create event handler for Wayland window mEventHandler = new EventHandler( this ); @@ -581,6 +613,17 @@ void Window::Initialize(const PositionSize& windowPosition, const std::string& n DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::Initialize: %s\n", hint ); } } + + if( !positionSize.IsEmpty() ) + { + AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" ); + mResizeEnabled = true; + } + + SetClass( name, className ); + windowSurface->Map(); + + mOrientation = Orientation::New(this); } void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation ) @@ -735,17 +778,24 @@ void Window::SetIndicatorActorRotation() void Window::Raise() { - ecore_wl_window_raise( mEventHandler->mEcoreWindow ); + // Use ecore_wl_window_activate to prevent the window shown without rendering + ecore_wl_window_activate( mEventHandler->mEcoreWindow ); + + DALI_LOG_RELEASE_INFO( "Window::Raise is called.\n" ); } void Window::Lower() { ecore_wl_window_lower( mEventHandler->mEcoreWindow ); + + DALI_LOG_RELEASE_INFO( "Window::Lower is called.\n" ); } void Window::Activate() { ecore_wl_window_activate( mEventHandler->mEcoreWindow ); + + DALI_LOG_RELEASE_INFO( "Window::Activate is called.\n" ); } Dali::DragAndDropDetector Window::GetDragAndDropDetector() const @@ -805,19 +855,22 @@ void Window::AddAvailableOrientation(Dali::Window::WindowOrientation orientation { bool found = false; - for( std::size_t i=0; i& orientations) { - int rotations[4]; + int rotations[4] = { 0 }; for( std::size_t i = 0; i < mAvailableOrientations.size(); ++i ) { rotations[i] = static_cast< int >( mAvailableOrientations[i] ); @@ -869,7 +922,7 @@ void Window::SetAcceptFocus( bool accept ) ecore_wl_window_focus_skip_set( mEventHandler->mEcoreWindow, !accept ); } -bool Window::IsFocusAcceptable() +bool Window::IsFocusAcceptable() const { return mIsFocusAcceptable; } @@ -879,10 +932,15 @@ void Window::Show() mVisible = true; ecore_wl_window_show( mEventHandler->mEcoreWindow ); - // Need an update request - if( mAdaptor ) + DALI_LOG_RELEASE_INFO( "Window::Show is called : mIconified [%d]\n", mIconified ); + + if( !mIconified ) { - mAdaptor->RequestUpdateOnce(); + if( mAdaptor ) + { + WindowVisibilityObserver* observer( mAdaptor ); + observer->OnWindowShown(); + } } } @@ -890,6 +948,17 @@ void Window::Hide() { mVisible = false; ecore_wl_window_hide( mEventHandler->mEcoreWindow ); + + DALI_LOG_RELEASE_INFO( "Window::Hide is called : mIconified [%d]\n", mIconified ); + + if( !mIconified ) + { + if( mAdaptor ) + { + WindowVisibilityObserver* observer( mAdaptor ); + observer->OnWindowHidden(); + } + } } bool Window::IsVisible() const @@ -899,53 +968,31 @@ bool Window::IsVisible() const void Window::RotationDone( int orientation, int width, int height ) { - PositionSize positionSize( 0, 0, width, height ); + ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) ); + if( wlSurface ) + { + wlSurface->RequestRotation( orientation, width, height ); + } - mAdaptor->SurfaceSizeChanged( positionSize ); + mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( width, height ) ); // Emit signal - mResizedSignal.Emit( positionSize.width, positionSize.height ); + mResizedSignal.Emit( Dali::Window::WindowSize( width, height ) ); - Dali::Window::WindowOrientation windowOrientation; - switch( orientation ) - { - case 0: - { - windowOrientation = Dali::Window::PORTRAIT; - break; - } - case 90: - { - windowOrientation = Dali::Window::LANDSCAPE; - break; - } - case 180: - { - windowOrientation = Dali::Window::PORTRAIT_INVERSE; - break; - } - case 270: - { - windowOrientation = Dali::Window::LANDSCAPE_INVERSE; - break; - } - default: - { - windowOrientation = Dali::Window::PORTRAIT; - break; - } - } + mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( width, height ) ); +} - ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) ); - wlSurface->RequestRotation( windowOrientation, positionSize.width, positionSize.height ); +void Window::SetIndicatorVisibleMode( Dali::Window::IndicatorVisibleMode mode ) +{ + mIndicatorVisible = mode; } -unsigned int Window::GetSupportedAuxiliaryHintCount() +unsigned int Window::GetSupportedAuxiliaryHintCount() const { return mSupportedAuxiliaryHints.size(); } -std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) +std::string Window::GetSupportedAuxiliaryHint( unsigned int index ) const { if( index >= GetSupportedAuxiliaryHintCount() ) { @@ -1071,7 +1118,7 @@ void Window::SetInputRegion( const Rect< int >& 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 ); } -void Window::SetType( Dali::DevelWindow::Type type ) +void Window::SetType( Dali::Window::Type type ) { Ecore_Wl_Window_Type windowType; @@ -1079,22 +1126,22 @@ void Window::SetType( Dali::DevelWindow::Type type ) { switch( type ) { - case Dali::DevelWindow::NORMAL: + case Dali::Window::NORMAL: { windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL; break; } - case Dali::DevelWindow::NOTIFICATION: + case Dali::Window::NOTIFICATION: { windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION; break; } - case Dali::DevelWindow::UTILITY: + case Dali::Window::UTILITY: { windowType = ECORE_WL_WINDOW_TYPE_UTILITY; break; } - case Dali::DevelWindow::DIALOG: + case Dali::Window::DIALOG: { windowType = ECORE_WL_WINDOW_TYPE_DIALOG; break; @@ -1112,14 +1159,14 @@ void Window::SetType( Dali::DevelWindow::Type type ) mType = type; } -Dali::DevelWindow::Type Window::GetType() const +Dali::Window::Type Window::GetType() const { return mType; } -bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level ) +bool Window::SetNotificationLevel( Dali::Window::NotificationLevel::Type level ) { - if( mType != Dali::DevelWindow::NOTIFICATION ) + if( mType != Dali::Window::NOTIFICATION ) { DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType ); return false; @@ -1134,27 +1181,27 @@ bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type le switch( level ) { - case Dali::DevelWindow::NotificationLevel::NONE: + case Dali::Window::NotificationLevel::NONE: { notificationLevel = TIZEN_POLICY_LEVEL_NONE; break; } - case Dali::DevelWindow::NotificationLevel::BASE: + case Dali::Window::NotificationLevel::BASE: { notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT; break; } - case Dali::DevelWindow::NotificationLevel::MEDIUM: + case Dali::Window::NotificationLevel::MEDIUM: { notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM; break; } - case Dali::DevelWindow::NotificationLevel::HIGH: + case Dali::Window::NotificationLevel::HIGH: { notificationLevel = TIZEN_POLICY_LEVEL_HIGH; break; } - case Dali::DevelWindow::NotificationLevel::TOP: + case Dali::Window::NotificationLevel::TOP: { notificationLevel = TIZEN_POLICY_LEVEL_TOP; break; @@ -1197,12 +1244,12 @@ bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type le return true; } -Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel() +Dali::Window::NotificationLevel::Type Window::GetNotificationLevel() const { - if( mType != Dali::DevelWindow::NOTIFICATION ) + if( mType != Dali::Window::NOTIFICATION ) { DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType ); - return Dali::DevelWindow::NotificationLevel::NONE; + return Dali::Window::NotificationLevel::NONE; } while( !mEventHandler->mTizenPolicy ) @@ -1222,42 +1269,42 @@ Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel() if( !mEventHandler->mNotificationLevelChangeDone ) { DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Error! [%d]\n", mEventHandler->mNotificationChangeState ); - return Dali::DevelWindow::NotificationLevel::NONE; + return Dali::Window::NotificationLevel::NONE; } - Dali::DevelWindow::NotificationLevel::Type level; + Dali::Window::NotificationLevel::Type level; switch( mEventHandler->mNotificationLevel ) { case TIZEN_POLICY_LEVEL_NONE: { - level = Dali::DevelWindow::NotificationLevel::NONE; + level = Dali::Window::NotificationLevel::NONE; break; } case TIZEN_POLICY_LEVEL_DEFAULT: { - level = Dali::DevelWindow::NotificationLevel::BASE; + level = Dali::Window::NotificationLevel::BASE; break; } case TIZEN_POLICY_LEVEL_MEDIUM: { - level = Dali::DevelWindow::NotificationLevel::MEDIUM; + level = Dali::Window::NotificationLevel::MEDIUM; break; } case TIZEN_POLICY_LEVEL_HIGH: { - level = Dali::DevelWindow::NotificationLevel::HIGH; + level = Dali::Window::NotificationLevel::HIGH; break; } case TIZEN_POLICY_LEVEL_TOP: { - level = Dali::DevelWindow::NotificationLevel::TOP; + level = Dali::Window::NotificationLevel::TOP; break; } default: { DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: invalid level [%d]\n", mEventHandler->mNotificationLevel ); - level = Dali::DevelWindow::NotificationLevel::NONE; + level = Dali::Window::NotificationLevel::NONE; break; } } @@ -1281,31 +1328,31 @@ void Window::SetOpaqueState( bool opaque ) DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque ); } -bool Window::IsOpaqueState() +bool Window::IsOpaqueState() const { return mOpaqueState; } -bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode ) +bool Window::SetScreenOffMode(Dali::Window::ScreenOffMode::Type screenOffMode) { while( !mEventHandler->mTizenPolicy ) { wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); } - mEventHandler->mScreenModeChangeDone = false; - mEventHandler->mScreenModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE; + mEventHandler->mScreenOffModeChangeDone = false; + mEventHandler->mScreenOffModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE; unsigned int mode = 0; - switch( screenMode ) + switch( screenOffMode ) { - case Dali::DevelWindow::ScreenMode::DEFAULT: + case Dali::Window::ScreenOffMode::TIMEOUT: { mode = 0; break; } - case Dali::DevelWindow::ScreenMode::ALWAYS_ON: + case Dali::Window::ScreenOffMode::NEVER: { mode = 1; break; @@ -1316,30 +1363,30 @@ bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode ) int count = 0; - while( !mEventHandler->mScreenModeChangeDone && count < 3 ) + while( !mEventHandler->mScreenOffModeChangeDone && count < 3 ) { ecore_wl_flush(); wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); count++; } - if( !mEventHandler->mScreenModeChangeDone ) + if( !mEventHandler->mScreenOffModeChangeDone ) { - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode change is failed [%d, %d]\n", screenMode, mEventHandler->mScreenModeChangeState ); + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode change is failed [%d, %d]\n", screenOffMode, mEventHandler->mScreenOffModeChangeState ); return false; } - else if( mEventHandler->mScreenModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED ) + else if( mEventHandler->mScreenOffModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED ) { - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Permission denied! [%d]\n", screenMode ); + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Permission denied! [%d]\n", screenOffMode ); return false; } - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode is changed [%d]\n", mEventHandler->mScreenMode ); + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenOffMode: Screen mode is changed [%d]\n", mEventHandler->mScreenOffMode ); return true; } -Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode() +Dali::Window::ScreenOffMode::Type Window::GetScreenOffMode() const { while( !mEventHandler->mTizenPolicy ) { @@ -1348,36 +1395,36 @@ Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode() int count = 0; - while( !mEventHandler->mScreenModeChangeDone && count < 3 ) + while( !mEventHandler->mScreenOffModeChangeDone && count < 3 ) { ecore_wl_flush(); wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); count++; } - if( !mEventHandler->mScreenModeChangeDone ) + if( !mEventHandler->mScreenOffModeChangeDone ) { - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: Error! [%d]\n", mEventHandler->mScreenModeChangeState ); - return Dali::DevelWindow::ScreenMode::DEFAULT; + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: Error! [%d]\n", mEventHandler->mScreenOffModeChangeState ); + return Dali::Window::ScreenOffMode::TIMEOUT; } - Dali::DevelWindow::ScreenMode::Type screenMode = Dali::DevelWindow::ScreenMode::DEFAULT; + Dali::Window::ScreenOffMode::Type screenMode = Dali::Window::ScreenOffMode::TIMEOUT; - switch( mEventHandler->mScreenMode ) + switch( mEventHandler->mScreenOffMode ) { case 0: { - screenMode = Dali::DevelWindow::ScreenMode::DEFAULT; + screenMode = Dali::Window::ScreenOffMode::TIMEOUT; break; } case 1: { - screenMode = Dali::DevelWindow::ScreenMode::ALWAYS_ON; + screenMode = Dali::Window::ScreenOffMode::NEVER; break; } } - DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: screen mode [%d]\n", mEventHandler->mScreenMode ); + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenOffMode: screen mode [%d]\n", mEventHandler->mScreenOffMode ); return screenMode; } @@ -1425,7 +1472,7 @@ bool Window::SetBrightness( int brightness ) return true; } -int Window::GetBrightness() +int Window::GetBrightness() const { while( !mEventHandler->mTizenDisplayPolicy ) { @@ -1452,6 +1499,74 @@ int Window::GetBrightness() return mEventHandler->mBrightness; } +void Window::SetSize( Dali::Window::WindowSize size ) +{ + if( !mResizeEnabled ) + { + AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" ); + mResizeEnabled = true; + } + + PositionSize positionSize = mSurface->GetPositionSize(); + + if( positionSize.width != size.GetWidth() || positionSize.height != size.GetHeight() ) + { + positionSize.width = size.GetWidth(); + positionSize.height = size.GetHeight(); + + mSurface->MoveResize( positionSize ); + + mAdaptor->SurfaceResizePrepare( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); + + // Emit signal + mResizedSignal.Emit( Dali::Window::WindowSize( positionSize.width, positionSize.height ) ); + + mAdaptor->SurfaceResizeComplete( Adaptor::SurfaceSize( positionSize.width, positionSize.height ) ); + } +} + +Dali::Window::WindowSize Window::GetSize() const +{ + PositionSize positionSize = mSurface->GetPositionSize(); + + return Dali::Window::WindowSize( positionSize.width, positionSize.height ); +} + +void Window::SetPosition( Dali::Window::WindowPosition position ) +{ + if( !mResizeEnabled ) + { + AddAuxiliaryHint( "wm.policy.win.user.geometry", "1" ); + mResizeEnabled = true; + } + + PositionSize positionSize = mSurface->GetPositionSize(); + + if( positionSize.x != position.GetX() || positionSize.y != position.GetY() ) + { + positionSize.x = position.GetX(); + positionSize.y = position.GetY(); + + mSurface->MoveResize( positionSize ); + } +} + +Dali::Window::WindowPosition Window::GetPosition() const +{ + PositionSize positionSize = mSurface->GetPositionSize(); + + return Dali::Window::WindowPosition( positionSize.x, positionSize.y ); +} + +void Window::SetTransparency( bool transparent ) +{ + ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) ); + if( wlSurface ) + { + wlSurface->SetTransparency( transparent ); + } +} + } // Adaptor } // Internal