From f538b659a113bf816a7d9e7326cf0ddaac83b3c7 Mon Sep 17 00:00:00 2001 From: Heeyong Song Date: Tue, 2 May 2017 17:50:52 +0900 Subject: [PATCH] Add Window APIs - type, notification level, screen mode, brightness Change-Id: Iefacc92cc8c5fa08ef3979dfa18e4c71a96ead71 --- adaptors/common/window-impl.h | 121 +++-- .../devel-api/adaptor-framework/window-devel.cpp | 50 ++ .../devel-api/adaptor-framework/window-devel.h | 137 ++++++ adaptors/ecore/wayland/window-impl-ecore-wl.cpp | 531 ++++++++++++++++++++- adaptors/wayland/window-impl-wl.cpp | 52 ++ adaptors/x11/window-impl-x.cpp | 52 ++ 6 files changed, 893 insertions(+), 50 deletions(-) diff --git a/adaptors/common/window-impl.h b/adaptors/common/window-impl.h index ceed80a..09a7541 100644 --- a/adaptors/common/window-impl.h +++ b/adaptors/common/window-impl.h @@ -160,104 +160,125 @@ public: Dali::Any GetNativeHandle() const; /** - * @brief Sets whether window accepts focus or not. - * - * @param[in] accept If focus is accepted or not. Default is true. + * @copydoc Dali::DevelWindow::SetAcceptFocus() */ void SetAcceptFocus( bool accept ); /** - * @brief Returns whether window accepts focus or not. - * - * @param[in] window The window to accept focus - * @return True if the window accept focus, false otherwise + * @copydoc Dali::DevelWindow::IsFocusAcceptable() */ bool IsFocusAcceptable(); /** - * @brief Shows the window if it is hidden. + * @copydoc Dali::DevelWindow::Show() */ void Show(); /** - * @brief Hides the window if it is showing. + * @copydoc Dali::DevelWindow::Hide() */ void Hide(); /** - * @brief Returns whether the window is showing or not. - * @return True if the window is showing, false otherwise. + * @copydoc Dali::DevelWindow::IsVisible() const */ bool IsVisible() const; /** - * Called from Orientation after the Change signal has been sent - */ - void RotationDone( int orientation, int width, int height ); - - /** - * @brief Gets the count of supported auxiliary hints of the window. - * @return The number of supported auxiliary hints. - * - * @note The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the window manager. - * If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints. + * @copydoc Dali::DevelWindow::GetSupportedAuxiliaryHintCount() */ unsigned int GetSupportedAuxiliaryHintCount(); - /** - * @brief Gets the supported auxiliary hint string of the window. - * @param[in] index The index of the supported auxiliary hint lists - * @return The auxiliary hint string of the index. - * - * @note The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the window manager. - * If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints. - */ + /** + * @copydoc Dali::DevelWindow::GetSupportedAuxiliaryHint() + */ std::string GetSupportedAuxiliaryHint( unsigned int index ); /** - * @brief Creates an auxiliary hint of the window. - * @param[in] hint The auxiliary hint string. - * @param[in] value The value string. - * @return The ID of created auxiliary hint, or @c 0 on failure. + * @copydoc Dali::DevelWindow::AddAuxiliaryHint() */ unsigned int AddAuxiliaryHint( const std::string& hint, const std::string& value ); /** - * @brief Removes an auxiliary hint of the window. - * @param[in] id The ID of the auxiliary hint. - * @return True if no error occurred, false otherwise. + * @copydoc Dali::DevelWindow::RemoveAuxiliaryHint() */ bool RemoveAuxiliaryHint( unsigned int id ); /** - * @brief Changes a value of the auxiliary hint. - * @param[in] id The auxiliary hint ID. - * @param[in] value The value string to be set. - * @return True if no error occurred, false otherwise. + * @copydoc Dali::DevelWindow::SetAuxiliaryHintValue() */ bool SetAuxiliaryHintValue( unsigned int id, const std::string& value ); /** - * @brief Gets a value of the auxiliary hint. - * @param[in] id The auxiliary hint ID. - * @return The string value of the auxiliary hint ID, or an empty string if none exists. + * @copydoc Dali::DevelWindow::GetAuxiliaryHintValue() */ std::string GetAuxiliaryHintValue( unsigned int id ) const; /** - * @brief Gets a ID of the auxiliary hint string. - * @param[in] hint The auxiliary hint string. - * @return The ID of the auxiliary hint string, or @c 0 if none exists. + * @copydoc Dali::DevelWindow::GetAuxiliaryHintId() */ unsigned int GetAuxiliaryHintId( const std::string& hint ) const; /** - * @brief Sets a region to get input events. - * @param[in] inputRegion The rectangle region to get input events. - * @note To set an empty region, pass width and height as 0. An empty input region means the entire window will accept input events. + * @copydoc Dali::DevelWindow::SetInputRegion() */ void SetInputRegion( const Rect< int >& inputRegion ); + /** + * @copydoc Dali::DevelWindow::SetType() + */ + void SetType( Dali::DevelWindow::Type type ); + + /** + * @copydoc Dali::DevelWindow::GetType() const + */ + Dali::DevelWindow::Type GetType() const; + + /** + * @copydoc Dali::DevelWindow::SetNotificationLevel() + */ + bool SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level ); + + /** + * @copydoc Dali::DevelWindow::GetNotificationLevel() + */ + Dali::DevelWindow::NotificationLevel::Type GetNotificationLevel(); + + /** + * @copydoc Dali::DevelWindow::SetOpaqueState() + */ + void SetOpaqueState( bool opaque ); + + /** + * @copydoc Dali::DevelWindow::IsOpaqueState() + */ + bool IsOpaqueState(); + + /** + * @copydoc Dali::DevelWindow::SetScreenMode() + */ + bool SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode ); + + /** + * @copydoc Dali::DevelWindow::GetScreenMode() + */ + Dali::DevelWindow::ScreenMode::Type GetScreenMode(); + + /** + * @copydoc Dali::DevelWindow::SetBrightness() + */ + bool SetBrightness( int brightness ); + + /** + * @copydoc Dali::DevelWindow::GetBrightness() + */ + int GetBrightness(); + + /** + * Called from Orientation after the Change signal has been sent + */ + void RotationDone( int orientation, int width, int height ); + private: /** * Private constructor. @@ -372,6 +393,7 @@ private: bool mEcoreEventHander:1; bool mIsFocusAcceptable:1; bool mVisible:1; + bool mOpaqueState:1; IndicatorInterface* mIndicator; Dali::Window::WindowOrientation mIndicatorOrientation; Dali::Window::WindowOrientation mNextIndicatorOrientation; @@ -379,6 +401,7 @@ private: Integration::SystemOverlay* mOverlay; Adaptor* mAdaptor; Dali::DragAndDropDetector mDragAndDropDetector; + Dali::DevelWindow::Type mType; struct EventHandler; EventHandler* mEventHandler; diff --git a/adaptors/devel-api/adaptor-framework/window-devel.cpp b/adaptors/devel-api/adaptor-framework/window-devel.cpp index 40a3ee0..b6f977c 100644 --- a/adaptors/devel-api/adaptor-framework/window-devel.cpp +++ b/adaptors/devel-api/adaptor-framework/window-devel.cpp @@ -95,6 +95,56 @@ void SetInputRegion( Window window, const Rect< int >& inputRegion ) return GetImplementation( window ).SetInputRegion( inputRegion ); } +void SetType( Window window, Type type ) +{ + GetImplementation( window ).SetType( type ); +} + +Type GetType( Window window ) +{ + return GetImplementation( window ).GetType(); +} + +bool SetNotificationLevel( Window window, NotificationLevel::Type level ) +{ + return GetImplementation( window ).SetNotificationLevel( level ); +} + +NotificationLevel::Type GetNotificationLevel( Window window ) +{ + return GetImplementation( window ).GetNotificationLevel(); +} + +void SetOpaqueState( Window window, bool opaque ) +{ + GetImplementation( window ).SetOpaqueState( opaque ); +} + +bool IsOpaqueState( Window window ) +{ + return GetImplementation( window ).IsOpaqueState(); +} + +bool SetScreenMode( Window window, ScreenMode::Type screenMode ) +{ + return GetImplementation( window ).SetScreenMode( screenMode ); +} + +ScreenMode::Type GetScreenMode( Window window ) +{ + return GetImplementation( window ).GetScreenMode(); +} + +bool SetBrightness( Window window, int brightness ) +{ + return GetImplementation( window ).SetBrightness( brightness ); +} + +int GetBrightness( Window window ) +{ + return GetImplementation( window ).GetBrightness(); +} + } // namespace DevelWindow } // namespace Dali diff --git a/adaptors/devel-api/adaptor-framework/window-devel.h b/adaptors/devel-api/adaptor-framework/window-devel.h index 10325ed..6d07c71 100644 --- a/adaptors/devel-api/adaptor-framework/window-devel.h +++ b/adaptors/devel-api/adaptor-framework/window-devel.h @@ -35,6 +35,48 @@ namespace Dali namespace DevelWindow { +namespace NotificationLevel +{ + +/** + * @brief An enum of notification window's priority level. + */ +enum Type +{ + NONE = -1, ///< No notification level. Default level. This value makes the notification window place in the layer of the normal window. + BASE = 10, ///< Base notification level. + MEDIUM = 20, ///< Higher notification level than base. + HIGH = 30, ///< Higher notification level than medium. + TOP = 40 ///< The highest notification level. +}; + +} // namespace NotificationLevel + +namespace ScreenMode +{ + +/** + * @brief An enum of screen mode. + */ +enum Type +{ + DEFAULT, ///< The mode which turns the screen off after a timeout. + ALWAYS_ON ///< The mode which keeps the screen turned on. +}; + +} // namespace ScreenMode + +/** + * @brief An enum of Window types. + */ +enum Type +{ + NORMAL, ///< A default window type. Indicates a normal, top-level window. Almost every window will be created with this type. + NOTIFICATION, ///< A notification window, like a warning about battery life or a new E-Mail received. + UTILITY, ///< A persistent utility window, like a toolbox or palette. + DIALOG ///< Used for simple dialog windows. +}; + typedef Signal< void (bool) > FocusSignalType; ///< Window focus signal type /** @@ -156,6 +198,101 @@ DALI_IMPORT_API unsigned int GetAuxiliaryHintId( Window window, const std::strin */ DALI_IMPORT_API void SetInputRegion( Window window, const Rect< int >& inputRegion ); +/** + * @brief Sets a window type. + * @param[in] window The window to set a type + * @param[in] type The window type. + * @remarks The default window type is NORMAL. + */ +DALI_IMPORT_API void SetType( Window window, Type type ); + +/** + * @brief Gets a window type. + * @param[in] window The window to get a type + * @return A window type. + */ +DALI_IMPORT_API Type GetType( Window window ); + +/** + * @brief Sets a priority level for the specified notification window. + * @param[in] window The window to set a notification level + * @param[in] level The notification window level. + * @return True if no error occurred, false otherwise. + * @PRIVLEVEL_PUBLIC + * @PRIVILEGE_WINDOW_PRIORITY + * @remarks This can be used for a notification type window only. The default level is NotificationLevel::NONE. + */ +DALI_IMPORT_API bool SetNotificationLevel( Window window, NotificationLevel::Type level ); + +/** + * @brief Gets a priority level for the specified notification window. + * @param[in] window The window to get a notification level + * @return The notification window level. + * @remarks This can be used for a notification type window only. + */ +DALI_IMPORT_API NotificationLevel::Type GetNotificationLevel( Window window ); + +/** + * @brief Sets a transparent window's visual state to opaque. + * @details If a visual state of a transparent window is opaque, + * then the window manager could handle it as an opaque window when calculating visibility. + * @param[in] window The window to set a state + * @param[in] opaque Whether the window's visual state is opaque. + * @remarks This will have no effect on an opaque window. + * It doesn't change transparent window to opaque window but lets the window manager know the visual state of the window. + */ +DALI_IMPORT_API void SetOpaqueState( Window window, bool opaque ); + +/** + * @brief Returns whether a transparent window's visual state is opaque or not. + * @param[in] window The window to get a state + * @return True if the window's visual state is opaque, false otherwise. + * @remarks The return value has no meaning on an opaque window. + */ +DALI_IMPORT_API bool IsOpaqueState( Window window ); + +/** + * @brief Sets a window's screen mode. + * @details This API is useful when the application needs to keep the display turned on. + * If the application sets the screen mode to #ScreenMode::ALWAYS_ON to its window and the window is shown, + * the window manager requests the display system to keep the display on as long as the window is shown. + * If the window is no longer shown, then the window manager requests the display system to go back to normal operation. + * @param[in] window The window to set a screen mode + * @param[in] screenMode The screen mode. + * @return True if no error occurred, false otherwise. + * @PRIVLEVEL_PUBLIC + * @PRIVILEGE_DISPLAY + */ +DALI_IMPORT_API bool SetScreenMode( Window window, ScreenMode::Type screenMode ); + +/** + * @brief Gets a screen mode of the window. + * @param[in] window The window to get a screen mode + * @return The screen mode. + */ +DALI_IMPORT_API ScreenMode::Type GetScreenMode( Window window ); + +/** + * @brief Sets preferred brightness of the window. + * @details This API is useful when the application needs to change the brightness of the screen when it is appeared on the screen. + * If the brightness has been set and the window is shown, the window manager requests the display system to change the brightness to the provided value. + * If the window is no longer shown, then the window manager requests the display system to go back to default brightness. + * A value less than 0 results in default brightness and a value greater than 100 results in maximum brightness. + * @param[in] window The window to set a brightness + * @param[in] brightness The preferred brightness (0 to 100). + * @return True if no error occurred, false otherwise. + * @PRIVLEVEL_PUBLIC + * @PRIVILEGE_DISPLAY + */ +DALI_IMPORT_API bool SetBrightness( Window window, int brightness ); + +/** + * @brief Gets preffered brightness of the window. + * @param[in] window The window to get brightness + * @return The preffered brightness. + */ +DALI_IMPORT_API int GetBrightness( Window window ); + } // namespace DevelWindow } // namespace Dali diff --git a/adaptors/ecore/wayland/window-impl-ecore-wl.cpp b/adaptors/ecore/wayland/window-impl-ecore-wl.cpp index ad286f4..3ca3887 100644 --- a/adaptors/ecore/wayland/window-impl-ecore-wl.cpp +++ b/adaptors/ecore/wayland/window-impl-ecore-wl.cpp @@ -21,6 +21,7 @@ // EXTERNAL HEADERS #include #include +#include #include #include @@ -48,6 +49,7 @@ namespace Internal { namespace Adaptor { + #if defined(DEBUG_ENABLED) Debug::Filter* gWindowLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW"); #endif @@ -67,7 +69,17 @@ struct Window::EventHandler mWindowIconifyStateHandler( NULL ), mWindowFocusInHandler( NULL ), mWindowFocusOutHandler( NULL ), - mEcoreWindow( 0 ) + mEcoreWindow( 0 ), + mDisplay( NULL ), + mEventQueue( NULL ), + mTizenPolicy( NULL ), + mTizenDisplayPolicy( NULL ), + mNotificationLevel( -1 ), + mNotificationChangeState( 0 ), + mNotificationLevelChangeDone( true ), + mScreenMode( 0 ), + mScreenModeChangeState( 0 ), + mScreenModeChangeDone( true ) { // store ecore window handle ECore::WindowRenderSurface* wlWindow( dynamic_cast< ECore::WindowRenderSurface * >( mWindow->mSurface ) ); @@ -83,6 +95,23 @@ struct Window::EventHandler mWindowFocusInHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this ); mWindowFocusOutHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this ); } + + mDisplay = ecore_wl_display_get(); + + wl_display* displayWrapper = static_cast< wl_display* >( wl_proxy_create_wrapper( mDisplay ) ); + if( displayWrapper ) + { + mEventQueue = wl_display_create_queue( mDisplay ); + if( mEventQueue ) + { + wl_proxy_set_queue( reinterpret_cast< wl_proxy* >( displayWrapper ), mEventQueue ); + + wl_registry* registry = wl_display_get_registry( displayWrapper ); + wl_registry_add_listener( registry, &mRegistryListener, this ); + } + + wl_proxy_wrapper_destroy( displayWrapper ); + } } /** @@ -106,6 +135,10 @@ struct Window::EventHandler { ecore_event_handler_del( mWindowFocusOutHandler ); } + if( mEventQueue ) + { + wl_event_queue_destroy( mEventQueue ); + } } // Static methods @@ -177,6 +210,102 @@ struct Window::EventHandler 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 ) ); + if( !eventHandler->mTizenPolicy ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: wl_registry_bind(tizen_policy_interface) is failed.\n" ); + return; + } + + tizen_policy_add_listener( eventHandler->mTizenPolicy, &eventHandler->mTizenPolicyListener, data ); + + DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: tizen_policy_add_listener is called.\n" ); + } + else if( strcmp( interface, tizen_display_policy_interface.name ) == 0 ) + { + eventHandler->mTizenDisplayPolicy = static_cast< tizen_display_policy* >( wl_registry_bind( registry, name, &tizen_display_policy_interface, version ) ); + if( !eventHandler->mTizenDisplayPolicy ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: wl_registry_bind(tizen_display_policy_interface) is failed.\n" ); + return; + } + + tizen_display_policy_add_listener( eventHandler->mTizenDisplayPolicy, &eventHandler->mTizenDisplayPolicyListener, data ); + + DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::RegistryGlobalCallback: tizen_display_policy_add_listener is called.\n" ); + } + } + + static void RegistryGlobalCallbackRemove( void* data, struct wl_registry* registry, uint32_t id ) + { + Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data ); + eventHandler->mTizenPolicy = NULL; + eventHandler->mTizenDisplayPolicy = NULL; + } + + 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 ); + + eventHandler->mNotificationLevel = level; + eventHandler->mNotificationChangeState = state; + eventHandler->mNotificationLevelChangeDone = true; + + 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 ) + { + Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data ); + + eventHandler->mScreenMode = mode; + eventHandler->mScreenModeChangeState = state; + eventHandler->mScreenModeChangeDone = 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 ) + { + Window::EventHandler* eventHandler = static_cast< Window::EventHandler* >( data ); + + eventHandler->mBrightness = brightness; + eventHandler->mBrightnessChangeState = state; + eventHandler->mBrightnessChangeDone = true; + + DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window::EventHandler::DisplayPolicyBrightnessChangeDone: brightness = %d, state = %d\n", brightness, state ); + } + + const struct wl_registry_listener mRegistryListener = + { + RegistryGlobalCallback, + RegistryGlobalCallbackRemove + }; + + const struct tizen_policy_listener mTizenPolicyListener = + { + NULL, + NULL, + TizenPolicyNotificationChangeDone, + NULL, + TizenPolicyScreenModeChangeDone, + NULL, + NULL, + NULL, + NULL + }; + + const struct tizen_display_policy_listener mTizenDisplayPolicyListener = + { + DisplayPolicyBrightnessChangeDone + }; + // Data Window* mWindow; Ecore_Event_Handler* mWindowPropertyHandler; @@ -184,6 +313,23 @@ struct Window::EventHandler Ecore_Event_Handler* mWindowFocusInHandler; Ecore_Event_Handler* mWindowFocusOutHandler; Ecore_Wl_Window* mEcoreWindow; + + wl_display* mDisplay; + wl_event_queue* mEventQueue; + tizen_policy* mTizenPolicy; + tizen_display_policy* mTizenDisplayPolicy; + + int mNotificationLevel; + uint32_t mNotificationChangeState; + bool mNotificationLevelChangeDone; + + int mScreenMode; + uint32_t mScreenModeChangeState; + bool mScreenModeChangeDone; + + int mBrightness; + uint32_t mBrightnessChangeState; + bool mBrightnessChangeDone; }; Window* Window::New(const PositionSize& posSize, const std::string& name, const std::string& className, bool isTransparent) @@ -314,12 +460,14 @@ Window::Window() mEcoreEventHander( true ), mIsFocusAcceptable( true ), mVisible( true ), + mOpaqueState( false ), mIndicator( NULL ), mIndicatorOrientation( Dali::Window::PORTRAIT ), mNextIndicatorOrientation( Dali::Window::PORTRAIT ), mIndicatorOpacityMode( Dali::Window::OPAQUE ), mOverlay( NULL ), mAdaptor( NULL ), + mType( Dali::DevelWindow::NORMAL ), mEventHandler( NULL ), mPreferredOrientation( Dali::Window::PORTRAIT ), mSupportedAuxiliaryHints(), @@ -831,6 +979,387 @@ 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 ) +{ + Ecore_Wl_Window_Type windowType; + + if( type != mType ) + { + switch( type ) + { + case Dali::DevelWindow::NORMAL: + { + windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL; + break; + } + case Dali::DevelWindow::NOTIFICATION: + { + windowType = ECORE_WL_WINDOW_TYPE_NOTIFICATION; + break; + } + case Dali::DevelWindow::UTILITY: + { + windowType = ECORE_WL_WINDOW_TYPE_UTILITY; + break; + } + case Dali::DevelWindow::DIALOG: + { + windowType = ECORE_WL_WINDOW_TYPE_DIALOG; + break; + } + default: + { + windowType = ECORE_WL_WINDOW_TYPE_TOPLEVEL; + break; + } + } + + ecore_wl_window_type_set( mEventHandler->mEcoreWindow, windowType ); + } + + mType = type; +} + +Dali::DevelWindow::Type Window::GetType() const +{ + return mType; +} + +bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level ) +{ + if( mType != Dali::DevelWindow::NOTIFICATION ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType ); + return false; + } + + while( !mEventHandler->mTizenPolicy ) + { + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + } + + int notificationLevel; + + switch( level ) + { + case Dali::DevelWindow::NotificationLevel::NONE: + { + notificationLevel = TIZEN_POLICY_LEVEL_NONE; + break; + } + case Dali::DevelWindow::NotificationLevel::BASE: + { + notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT; + break; + } + case Dali::DevelWindow::NotificationLevel::MEDIUM: + { + notificationLevel = TIZEN_POLICY_LEVEL_MEDIUM; + break; + } + case Dali::DevelWindow::NotificationLevel::HIGH: + { + notificationLevel = TIZEN_POLICY_LEVEL_HIGH; + break; + } + case Dali::DevelWindow::NotificationLevel::TOP: + { + notificationLevel = TIZEN_POLICY_LEVEL_TOP; + break; + } + default: + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: invalid level [%d]\n", level ); + notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT; + break; + } + } + + mEventHandler->mNotificationLevelChangeDone = false; + mEventHandler->mNotificationChangeState = TIZEN_POLICY_ERROR_STATE_NONE; + + tizen_policy_set_notification_level( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), notificationLevel ); + + int count = 0; + + while( !mEventHandler->mNotificationLevelChangeDone && count < 3 ) + { + ecore_wl_flush(); + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + count++; + } + + if( !mEventHandler->mNotificationLevelChangeDone ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level change is failed [%d, %d]\n", level, mEventHandler->mNotificationChangeState ); + return false; + } + else if( mEventHandler->mNotificationChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Permission denied! [%d]\n", level ); + return false; + } + + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Level is changed [%d]\n", mEventHandler->mNotificationLevel ); + + return true; +} + +Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel() +{ + if( mType != Dali::DevelWindow::NOTIFICATION ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType ); + return Dali::DevelWindow::NotificationLevel::NONE; + } + + while( !mEventHandler->mTizenPolicy ) + { + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + } + + int count = 0; + + while( !mEventHandler->mNotificationLevelChangeDone && count < 3 ) + { + ecore_wl_flush(); + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + count++; + } + + if( !mEventHandler->mNotificationLevelChangeDone ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Error! [%d]\n", mEventHandler->mNotificationChangeState ); + return Dali::DevelWindow::NotificationLevel::NONE; + } + + Dali::DevelWindow::NotificationLevel::Type level; + + switch( mEventHandler->mNotificationLevel ) + { + case TIZEN_POLICY_LEVEL_NONE: + { + level = Dali::DevelWindow::NotificationLevel::NONE; + break; + } + case TIZEN_POLICY_LEVEL_DEFAULT: + { + level = Dali::DevelWindow::NotificationLevel::BASE; + break; + } + case TIZEN_POLICY_LEVEL_MEDIUM: + { + level = Dali::DevelWindow::NotificationLevel::MEDIUM; + break; + } + case TIZEN_POLICY_LEVEL_HIGH: + { + level = Dali::DevelWindow::NotificationLevel::HIGH; + break; + } + case TIZEN_POLICY_LEVEL_TOP: + { + level = Dali::DevelWindow::NotificationLevel::TOP; + break; + } + default: + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: invalid level [%d]\n", mEventHandler->mNotificationLevel ); + level = Dali::DevelWindow::NotificationLevel::NONE; + break; + } + } + + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: level [%d]\n", mEventHandler->mNotificationLevel ); + + return level; +} + +void Window::SetOpaqueState( bool opaque ) +{ + while( !mEventHandler->mTizenPolicy ) + { + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + } + + tizen_policy_set_opaque_state( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), ( opaque ? 1 : 0 ) ); + + mOpaqueState = opaque; + + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque ); +} + +bool Window::IsOpaqueState() +{ + return mOpaqueState; +} + +bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode ) +{ + while( !mEventHandler->mTizenPolicy ) + { + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + } + + mEventHandler->mScreenModeChangeDone = false; + mEventHandler->mScreenModeChangeState = TIZEN_POLICY_ERROR_STATE_NONE; + + unsigned int mode = 0; + + switch( screenMode ) + { + case Dali::DevelWindow::ScreenMode::DEFAULT: + { + mode = 0; + break; + } + case Dali::DevelWindow::ScreenMode::ALWAYS_ON: + { + mode = 1; + break; + } + } + + tizen_policy_set_window_screen_mode( mEventHandler->mTizenPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), mode ); + + int count = 0; + + while( !mEventHandler->mScreenModeChangeDone && count < 3 ) + { + ecore_wl_flush(); + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + count++; + } + + if( !mEventHandler->mScreenModeChangeDone ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode change is failed [%d, %d]\n", screenMode, mEventHandler->mScreenModeChangeState ); + return false; + } + else if( mEventHandler->mScreenModeChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Permission denied! [%d]\n", screenMode ); + return false; + } + + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetScreenMode: Screen mode is changed [%d]\n", mEventHandler->mScreenMode ); + + return true; +} + +Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode() +{ + while( !mEventHandler->mTizenPolicy ) + { + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + } + + int count = 0; + + while( !mEventHandler->mScreenModeChangeDone && count < 3 ) + { + ecore_wl_flush(); + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + count++; + } + + if( !mEventHandler->mScreenModeChangeDone ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: Error! [%d]\n", mEventHandler->mScreenModeChangeState ); + return Dali::DevelWindow::ScreenMode::DEFAULT; + } + + Dali::DevelWindow::ScreenMode::Type screenMode = Dali::DevelWindow::ScreenMode::DEFAULT; + + switch( mEventHandler->mScreenMode ) + { + case 0: + { + screenMode = Dali::DevelWindow::ScreenMode::DEFAULT; + break; + } + case 1: + { + screenMode = Dali::DevelWindow::ScreenMode::ALWAYS_ON; + break; + } + } + + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetScreenMode: screen mode [%d]\n", mEventHandler->mScreenMode ); + + return screenMode; +} + +bool Window::SetBrightness( int brightness ) +{ + if( brightness < 0 || brightness > 100 ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness ); + return false; + } + + while( !mEventHandler->mTizenDisplayPolicy ) + { + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + } + + mEventHandler->mBrightnessChangeDone = false; + mEventHandler->mBrightnessChangeState = TIZEN_POLICY_ERROR_STATE_NONE; + + tizen_display_policy_set_window_brightness( mEventHandler->mTizenDisplayPolicy, ecore_wl_window_surface_get( mEventHandler->mEcoreWindow ), brightness ); + + int count = 0; + + while( !mEventHandler->mBrightnessChangeDone && count < 3 ) + { + ecore_wl_flush(); + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + count++; + } + + if( !mEventHandler->mBrightnessChangeDone ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness change is failed [%d, %d]\n", brightness, mEventHandler->mBrightnessChangeState ); + return false; + } + else if( mEventHandler->mBrightnessChangeState == TIZEN_POLICY_ERROR_STATE_PERMISSION_DENIED ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Permission denied! [%d]\n", brightness ); + return false; + } + + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Brightness is changed [%d]\n", mEventHandler->mBrightness ); + + return true; +} + +int Window::GetBrightness() +{ + while( !mEventHandler->mTizenDisplayPolicy ) + { + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + } + + int count = 0; + + while( !mEventHandler->mBrightnessChangeDone && count < 3 ) + { + ecore_wl_flush(); + wl_display_dispatch_queue( mEventHandler->mDisplay, mEventHandler->mEventQueue ); + count++; + } + + if( !mEventHandler->mBrightnessChangeDone ) + { + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Error! [%d]\n", mEventHandler->mBrightnessChangeState ); + return 0; + } + + DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetBrightness: Brightness [%d]\n", mEventHandler->mBrightness ); + + return mEventHandler->mBrightness; +} + } // Adaptor } // Internal } // Dali diff --git a/adaptors/wayland/window-impl-wl.cpp b/adaptors/wayland/window-impl-wl.cpp index 18e17b7..631681f 100644 --- a/adaptors/wayland/window-impl-wl.cpp +++ b/adaptors/wayland/window-impl-wl.cpp @@ -111,12 +111,14 @@ Window::Window() mWMRotationAppSet( false ), mIsFocusAcceptable( true ), mVisible( true ), + mOpaqueState( false ), mIndicator( NULL ), mIndicatorOrientation( Dali::Window::PORTRAIT ), mNextIndicatorOrientation( Dali::Window::PORTRAIT ), mIndicatorOpacityMode( Dali::Window::OPAQUE ), mOverlay( NULL ), mAdaptor( NULL ), + mType( Dali::DevelWindow::NORMAL ), mPreferredOrientation( Dali::Window::PORTRAIT ), mSupportedAuxiliaryHints(), mAuxiliaryHints() @@ -351,6 +353,56 @@ void Window::SetInputRegion( const Rect< int >& inputRegion ) { } +void Window::SetType( Dali::DevelWindow::Type type ) +{ + mType = type; +} + +Dali::DevelWindow::Type Window::GetType() const +{ + return mType; +} + +bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level ) +{ + return false; +} + +Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel() +{ + return Dali::DevelWindow::NotificationLevel::NONE; +} + +void Window::SetOpaqueState( bool opaque ) +{ + mOpaqueState = opaque; +} + +bool Window::IsOpaqueState() +{ + return mOpaqueState; +} + +bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode ) +{ + return false; +} + +Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode() +{ + return Dali::DevelWindow::ScreenMode::DEFAULT; +} + +bool Window::SetBrightness( int brightness ) +{ + return false; +} + +int Window::GetBrightness() +{ + return 0; +} + } // Adaptor } // Internal } // Dali diff --git a/adaptors/x11/window-impl-x.cpp b/adaptors/x11/window-impl-x.cpp index e3e3e2f..357cafe 100644 --- a/adaptors/x11/window-impl-x.cpp +++ b/adaptors/x11/window-impl-x.cpp @@ -345,12 +345,14 @@ Window::Window() mEcoreEventHander( true ), mIsFocusAcceptable( true ), mVisible( true ), + mOpaqueState( false ), mIndicator( NULL ), mIndicatorOrientation( Dali::Window::PORTRAIT ), mNextIndicatorOrientation( Dali::Window::PORTRAIT ), mIndicatorOpacityMode( Dali::Window::OPAQUE ), mOverlay( NULL ), mAdaptor( NULL ), + mType( Dali::DevelWindow::NORMAL ), mEventHandler( NULL ), mPreferredOrientation( Dali::Window::PORTRAIT ), mSupportedAuxiliaryHints(), @@ -852,6 +854,56 @@ void Window::SetInputRegion( const Rect< int >& inputRegion ) { } +void Window::SetType( Dali::DevelWindow::Type type ) +{ + mType = type; +} + +Dali::DevelWindow::Type Window::GetType() const +{ + return mType; +} + +bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level ) +{ + return false; +} + +Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel() +{ + return Dali::DevelWindow::NotificationLevel::NONE; +} + +void Window::SetOpaqueState( bool opaque ) +{ + mOpaqueState = opaque; +} + +bool Window::IsOpaqueState() +{ + return mOpaqueState; +} + +bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode ) +{ + return false; +} + +Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode() +{ + return Dali::DevelWindow::ScreenMode::DEFAULT; +} + +bool Window::SetBrightness( int brightness ) +{ + return false; +} + +int Window::GetBrightness() +{ + return 0; +} + } // Adaptor } // Internal } // Dali -- 2.7.4