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.
bool mEcoreEventHander:1;
bool mIsFocusAcceptable:1;
bool mVisible:1;
+ bool mOpaqueState:1;
IndicatorInterface* mIndicator;
Dali::Window::WindowOrientation mIndicatorOrientation;
Dali::Window::WindowOrientation mNextIndicatorOrientation;
Integration::SystemOverlay* mOverlay;
Adaptor* mAdaptor;
Dali::DragAndDropDetector mDragAndDropDetector;
+ Dali::DevelWindow::Type mType;
struct EventHandler;
EventHandler* mEventHandler;
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
/**
*/
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
// EXTERNAL HEADERS
#include <Ecore.h>
#include <Ecore_Wayland.h>
+#include <tizen-extension-client-protocol.h>
#include <dali/integration-api/core.h>
#include <dali/integration-api/system-overlay.h>
{
namespace Adaptor
{
+
#if defined(DEBUG_ENABLED)
Debug::Filter* gWindowLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW");
#endif
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 ) );
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 );
+ }
}
/**
{
ecore_event_handler_del( mWindowFocusOutHandler );
}
+ if( mEventQueue )
+ {
+ wl_event_queue_destroy( mEventQueue );
+ }
}
// Static methods
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;
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)
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(),
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
projects / platform / core / uifw / dali-adaptor.git / commitdiff