*
*/
+// EXTERNAL INCLUDES
+#include <string>
+#include <dali/public-api/math/rect.h>
+
// INTERNAL INCLUDES
#ifdef DALI_ADAPTOR_COMPILATION // full path doesn't exist until adaptor is installed so we have to use relative
#include <window.h>
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 bool IsVisible( Window window );
+/**
+ * @brief Gets the count of supported auxiliary hints of the window.
+ * @param[in] window The window to get the hint count
+ * @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.
+ */
+DALI_IMPORT_API unsigned int GetSupportedAuxiliaryHintCount( Window window );
+
+/**
+ * @brief Gets the supported auxiliary hint string of the window.
+ * @param[in] window The window to get the hint
+ * @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.
+ */
+DALI_IMPORT_API std::string GetSupportedAuxiliaryHint( Window window, unsigned int index );
+
+/**
+ * @brief Creates an auxiliary hint of the window.
+ * @param[in] window The window to create a hint
+ * @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.
+ */
+DALI_IMPORT_API unsigned int AddAuxiliaryHint( Window window, const std::string& hint, const std::string& value );
+
+/**
+ * @brief Removes an auxiliary hint of the window.
+ * @param[in] window The window to remove a hint
+ * @param[in] id The ID of the auxiliary hint.
+ * @return True if no error occurred, false otherwise.
+ */
+DALI_IMPORT_API bool RemoveAuxiliaryHint( Window window, unsigned int id );
+
+/**
+ * @brief Changes a value of the auxiliary hint.
+ * @param[in] window The window to set a value
+ * @param[in] id The auxiliary hint ID.
+ * @param[in] value The value string to be set.
+ * @return True if no error occurred, false otherwise.
+ */
+DALI_IMPORT_API bool SetAuxiliaryHintValue( Window window, unsigned int id, const std::string& value );
+
+/**
+ * @brief Gets a value of the auxiliary hint.
+ * @param[in] window The window to get a value
+ * @param[in] id The auxiliary hint ID.
+ * @return The string value of the auxiliary hint ID, or an empty string if none exists.
+ */
+DALI_IMPORT_API std::string GetAuxiliaryHintValue( Window window, unsigned int id );
+
+/**
+ * @brief Gets a ID of the auxiliary hint string.
+ * @param[in] window The window to get an ID
+ * @param[in] hint The auxiliary hint string.
+ * @return The ID of the auxiliary hint string, or @c 0 if none exists.
+ */
+DALI_IMPORT_API unsigned int GetAuxiliaryHintId( Window window, const std::string& hint );
+
+/**
+ * @brief Sets a region to accept input events.
+ * @param[in] window The window to set a region
+ * @param[in] inputRegion The region to accept input events.
+ */
+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::Concise, false, "LOG_WINDOW");
+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 ),
+ mBrightness( 0 ),
+ mBrightnessChangeState( 0 ),
+ mBrightnessChangeDone( 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)
ECore::WindowRenderSurface* wlSurface( dynamic_cast< ECore::WindowRenderSurface * >( mSurface ) );
DALI_ASSERT_DEBUG(wlSurface);
- Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
- mIndicatorVisible = visibleMode;
-
- if ( mIndicatorVisible == Dali::Window::VISIBLE )
+ if( wlSurface )
{
- // when the indicator is visible, set proper mode for indicator server according to bg mode
- if ( mIndicatorOpacityMode == Dali::Window::OPAQUE )
- {
- ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
- }
- else if ( mIndicatorOpacityMode == Dali::Window::TRANSLUCENT )
+ Ecore_Wl_Window* wlWindow = wlSurface->GetWlWindow();
+
+ mIndicatorVisible = visibleMode;
+
+ if ( mIndicatorVisible == Dali::Window::VISIBLE )
{
- ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSLUCENT);
+ // when the indicator is visible, set proper mode for indicator server according to bg mode
+ if ( mIndicatorOpacityMode == Dali::Window::OPAQUE )
+ {
+ ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
+ }
+ else if ( mIndicatorOpacityMode == Dali::Window::TRANSLUCENT )
+ {
+ ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSLUCENT);
+ }
+ else if ( mIndicatorOpacityMode == Dali::Window::TRANSPARENT )
+ {
+ ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
+ }
}
- else if ( mIndicatorOpacityMode == Dali::Window::TRANSPARENT )
+ else
{
- ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_OPAQUE);
+ // when the indicator is not visible, set TRANSPARENT mode for indicator server
+ ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSPARENT); // it means hidden indicator
}
}
- else
- {
- // when the indicator is not visible, set TRANSPARENT mode for indicator server
- ecore_wl_window_indicator_opacity_set(wlWindow, ECORE_WL_INDICATOR_TRANSPARENT); // it means hidden indicator
- }
DoShowIndicator( mIndicatorOrientation );
}
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 )
+ mPreferredOrientation( Dali::Window::PORTRAIT ),
+ mSupportedAuxiliaryHints(),
+ mAuxiliaryHints()
{
}
}
delete mSurface;
+
+ mSupportedAuxiliaryHints.clear();
+ mAuxiliaryHints.clear();
}
void Window::Initialize(const PositionSize& windowPosition, const std::string& name, const std::string& className)
// create event handler for Wayland window
mEventHandler = new EventHandler( this );
+
+ // get auxiliary hint
+ Eina_List* hints = ecore_wl_window_aux_hints_supported_get( mEventHandler->mEcoreWindow );
+ if( hints )
+ {
+ Eina_List* l = NULL;
+ char* hint = NULL;
+
+ for( l = hints, ( hint = static_cast< char* >( eina_list_data_get(l) ) ); l; l = eina_list_next(l), ( hint = static_cast< char* >( eina_list_data_get(l) ) ) )
+ {
+ mSupportedAuxiliaryHints.push_back( hint );
+
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::Initialize: %s\n", hint );
+ }
+ }
}
void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )
ecore_wl_window_rotation_change_done_send( mEventHandler->mEcoreWindow );
}
+unsigned int Window::GetSupportedAuxiliaryHintCount()
+{
+ return mSupportedAuxiliaryHints.size();
+}
+
+std::string Window::GetSupportedAuxiliaryHint( unsigned int index )
+{
+ if( index >= GetSupportedAuxiliaryHintCount() )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetSupportedAuxiliaryHint: Invalid index! [%d]\n", index );
+ }
+
+ return mSupportedAuxiliaryHints[index];
+}
+
+unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
+{
+ bool supported = false;
+
+ // Check if the hint is suppported
+ for( std::vector< std::string >::iterator iter = mSupportedAuxiliaryHints.begin(); iter != mSupportedAuxiliaryHints.end(); ++iter )
+ {
+ if( *iter == hint )
+ {
+ supported = true;
+ break;
+ }
+ }
+
+ if( !supported )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint.c_str() );
+ return 0;
+ }
+
+ // Check if the hint is already added
+ for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
+ {
+ if( mAuxiliaryHints[i].first == hint )
+ {
+ // Just change the value
+ mAuxiliaryHints[i].second = value;
+
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), i + 1 );
+
+ return i + 1; // id is index + 1
+ }
+ }
+
+ // Add the hint
+ mAuxiliaryHints.push_back( std::pair< std::string, std::string >( hint, value ) );
+
+ unsigned int id = mAuxiliaryHints.size();
+
+ ecore_wl_window_aux_hint_add( mEventHandler->mEcoreWindow, static_cast< int >( id ), hint.c_str(), value.c_str() );
+
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id );
+
+ return id;
+}
+
+bool Window::RemoveAuxiliaryHint( unsigned int id )
+{
+ if( id == 0 || id > mAuxiliaryHints.size() )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::RemoveAuxiliaryHint: Invalid id [%d]\n", id );
+ return false;
+ }
+
+ mAuxiliaryHints[id - 1].second = std::string();
+
+ ecore_wl_window_aux_hint_del( mEventHandler->mEcoreWindow, static_cast< int >( id ) );
+
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str() );
+
+ return true;
+}
+
+bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
+{
+ if( id == 0 || id > mAuxiliaryHints.size() )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::SetAuxiliaryHintValue: Invalid id [%d]\n", id );
+ return false;
+ }
+
+ mAuxiliaryHints[id - 1].second = value;
+
+ ecore_wl_window_aux_hint_change( mEventHandler->mEcoreWindow, static_cast< int >( id ), value.c_str() );
+
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::SetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str() );
+
+ return true;
+}
+
+std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
+{
+ if( id == 0 || id > mAuxiliaryHints.size() )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Concise, "Window::GetAuxiliaryHintValue: Invalid id [%d]\n", id );
+ return std::string();
+ }
+
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str() );
+
+ return mAuxiliaryHints[id - 1].second;
+}
+
+unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
+{
+ for( unsigned int i = 0; i < mAuxiliaryHints.size(); i++ )
+ {
+ if( mAuxiliaryHints[i].first == hint )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: hint = %s, id = %d\n", hint.c_str(), i + 1 );
+ return i + 1;
+ }
+ }
+
+ DALI_LOG_INFO( gWindowLogFilter, Debug::Verbose, "Window::GetAuxiliaryHintId: Invalid hint! [%s]\n", hint.c_str() );
+
+ return 0;
+}
+
+void Window::SetInputRegion( const Rect< int >& inputRegion )
+{
+ ecore_wl_window_input_region_set( mEventHandler->mEcoreWindow, inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height );
+
+ 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