/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
// CLASS HEADER
-#include "window-impl.h"
+#include <window-impl.h>
// EXTERNAL HEADERS
#include <Ecore.h>
#include <ecore-indicator-impl.h>
#include <window-visibility-observer.h>
#include <orientation-impl.h>
+
namespace
{
const float INDICATOR_ANIMATION_DURATION( 0.18f ); // 180 milli seconds
EventHandler( Window* window )
: mWindow( window ),
mWindowPropertyHandler( NULL ),
- mClientMessageHandler( NULL ),
+ mWindowIconifyStateHandler( NULL ),
+ mWindowFocusInHandler( NULL ),
+ mWindowFocusOutHandler( NULL ),
mEcoreWindow( 0 )
{
// store ecore window handle
mEcoreWindow = wlWindow->GetWlWindow();
}
DALI_ASSERT_ALWAYS( mEcoreWindow != 0 && "There is no ecore Wl window");
+
+ if( mWindow->mEcoreEventHander )
+ {
+ mWindowIconifyStateHandler = ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this );
+ mWindowFocusInHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this );
+ mWindowFocusOutHandler = ecore_event_handler_add( ECORE_WL_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this );
+ }
}
/**
{
ecore_event_handler_del( mWindowPropertyHandler );
}
- if ( mClientMessageHandler )
+ if ( mWindowIconifyStateHandler )
+ {
+ ecore_event_handler_del( mWindowIconifyStateHandler );
+ }
+ if( mWindowFocusInHandler )
+ {
+ ecore_event_handler_del( mWindowFocusInHandler );
+ }
+ if( mWindowFocusOutHandler )
{
- ecore_event_handler_del( mClientMessageHandler );
+ ecore_event_handler_del( mWindowFocusOutHandler );
}
}
return EINA_FALSE;
}
- /// Called when the window properties are changed.
- static Eina_Bool EcoreEventClientMessage( void* data, int type, void* event )
+ /// Called when the window iconify state is changed.
+ static Eina_Bool EcoreEventWindowIconifyStateChanged( void* data, int type, void* event )
{
- return EINA_FALSE;
+ Ecore_Wl_Event_Window_Iconify_State_Change* iconifyChangedEvent( static_cast< Ecore_Wl_Event_Window_Iconify_State_Change* >( event ) );
+ EventHandler* handler( static_cast< EventHandler* >( data ) );
+ Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
+
+ if ( handler && handler->mWindow )
+ {
+ WindowVisibilityObserver* observer( handler->mWindow->mAdaptor );
+ if ( observer && ( iconifyChangedEvent->win == static_cast< unsigned int> ( ecore_wl_window_id_get( handler->mEcoreWindow ) ) ) )
+ {
+ if( iconifyChangedEvent->iconified == EINA_TRUE )
+ {
+ observer->OnWindowHidden();
+ DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Iconfied\n", handler->mEcoreWindow );
+ }
+ else
+ {
+ observer->OnWindowShown();
+ DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window (%d) Shown\n", handler->mEcoreWindow );
+ }
+ handled = ECORE_CALLBACK_DONE;
+ }
+ }
+
+ return handled;
+ }
+
+ /// Called when the window gains focus
+ static Eina_Bool EcoreEventWindowFocusIn( void* data, int type, void* event )
+ {
+ Ecore_Wl_Event_Focus_In* focusInEvent( static_cast< Ecore_Wl_Event_Focus_In* >( event ) );
+ EventHandler* handler( static_cast< EventHandler* >( data ) );
+
+ if ( handler && handler->mWindow && focusInEvent->win == static_cast< unsigned int >( ecore_wl_window_id_get( handler->mEcoreWindow ) ) )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n" );
+
+ handler->mWindow->mFocusChangedSignal.Emit( true );
+ }
+
+ return ECORE_CALLBACK_PASS_ON;
+ }
+
+ /// Called when the window loses focus
+ static Eina_Bool EcoreEventWindowFocusOut( void* data, int type, void* event )
+ {
+ Ecore_Wl_Event_Focus_Out* focusOutEvent( static_cast< Ecore_Wl_Event_Focus_Out* >( event ) );
+ EventHandler* handler( static_cast< EventHandler* >( data ) );
+
+ if ( handler && handler->mWindow && focusOutEvent->win == static_cast< unsigned int >(ecore_wl_window_id_get( handler->mEcoreWindow ) ) )
+ {
+ DALI_LOG_INFO( gWindowLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n" );
+
+ handler->mWindow->mFocusChangedSignal.Emit( false );
+ }
+
+ return ECORE_CALLBACK_PASS_ON;
}
// Data
Window* mWindow;
Ecore_Event_Handler* mWindowPropertyHandler;
- Ecore_Event_Handler* mClientMessageHandler;
+ Ecore_Event_Handler* mWindowIconifyStateHandler;
+ Ecore_Event_Handler* mWindowFocusInHandler;
+ Ecore_Event_Handler* mWindowFocusOutHandler;
Ecore_Wl_Window* mEcoreWindow;
};
-
Window* Window::New(const PositionSize& posSize, const std::string& name, const std::string& className, bool isTransparent)
{
Window* window = new Window();
DoShowIndicator( mIndicatorOrientation );
}
-void Window::RotateIndicator(Dali::Window::WindowOrientation orientation)
+void Window::RotateIndicator( Dali::Window::WindowOrientation orientation )
{
DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "Orientation: %d\n", orientation );
}
Window::Window()
-: mSurface(NULL),
- mIndicatorVisible(Dali::Window::VISIBLE),
- mIndicatorIsShown(false),
- mShowRotatedIndicatorOnClose(false),
- mStarted(false),
- mIsTransparent(false),
- mWMRotationAppSet(false),
- mEcoreEventHander(true),
- mIndicator(NULL),
- mIndicatorOrientation(Dali::Window::PORTRAIT),
- mNextIndicatorOrientation(Dali::Window::PORTRAIT),
- mIndicatorOpacityMode(Dali::Window::OPAQUE),
- mOverlay(NULL),
- mAdaptor(NULL),
- mEventHandler(NULL),
- mPreferredOrientation(Dali::Window::PORTRAIT)
+: mSurface( NULL ),
+ mIndicatorVisible( Dali::Window::VISIBLE ),
+ mIndicatorIsShown( false ),
+ mShowRotatedIndicatorOnClose( false ),
+ mStarted( false ),
+ mIsTransparent( false ),
+ mWMRotationAppSet( false ),
+ mEcoreEventHander( true ),
+ mIsFocusAcceptable( true ),
+ mVisible( true ),
+ mIndicator( NULL ),
+ mIndicatorOrientation( Dali::Window::PORTRAIT ),
+ mNextIndicatorOrientation( Dali::Window::PORTRAIT ),
+ mIndicatorOpacityMode( Dali::Window::OPAQUE ),
+ mOverlay( NULL ),
+ mAdaptor( NULL ),
+ mEventHandler( NULL ),
+ mPreferredOrientation( Dali::Window::PORTRAIT )
{
}
void Window::Raise()
{
+ ecore_wl_window_raise( mEventHandler->mEcoreWindow );
}
void Window::Lower()
{
+ ecore_wl_window_lower( mEventHandler->mEcoreWindow );
}
void Window::Activate()
{
+ ecore_wl_window_activate( mEventHandler->mEcoreWindow );
}
Dali::DragAndDropDetector Window::GetDragAndDropDetector() const
void Window::SetAvailableOrientations(const std::vector<Dali::Window::WindowOrientation>& orientations)
{
- DALI_ASSERT_ALWAYS( mAvailableOrientations.size() <= 4 && "Incorrect number of available orientations" );
+ int rotations[4];
+ for( std::size_t i = 0; i < mAvailableOrientations.size(); ++i )
+ {
+ rotations[i] = static_cast< int >( mAvailableOrientations[i] );
+ }
+ ecore_wl_window_rotation_available_rotations_set( mEventHandler->mEcoreWindow, rotations, mAvailableOrientations.size() );
}
const std::vector<Dali::Window::WindowOrientation>& Window::GetAvailableOrientations()
void Window::SetPreferredOrientation(Dali::Window::WindowOrientation orientation)
{
mPreferredOrientation = orientation;
+
+ ecore_wl_window_rotation_preferred_rotation_set( mEventHandler->mEcoreWindow, orientation );
}
Dali::Window::WindowOrientation Window::GetPreferredOrientation()
return mPreferredOrientation;
}
-void Window::RotationDone( int orientation, int width, int height )
+void Window::SetAcceptFocus( bool accept )
+{
+ mIsFocusAcceptable = accept;
+
+ ecore_wl_window_focus_skip_set( mEventHandler->mEcoreWindow, !accept );
+}
+
+bool Window::IsFocusAcceptable()
+{
+ return mIsFocusAcceptable;
+}
+
+void Window::Show()
+{
+ mVisible = true;
+ ecore_wl_window_show( mEventHandler->mEcoreWindow );
+
+ // Need an update request
+ if( mAdaptor )
+ {
+ mAdaptor->RequestUpdateOnce();
+ }
+}
+
+void Window::Hide()
+{
+ mVisible = false;
+ ecore_wl_window_hide( mEventHandler->mEcoreWindow );
+}
+
+bool Window::IsVisible() const
{
+ return mVisible;
}
+void Window::RotationDone( int orientation, int width, int height )
+{
+ ecore_wl_window_rotation_change_done_send( mEventHandler->mEcoreWindow );
+}
} // Adaptor
} // Internal