#include <dali/integration-api/system-overlay.h>
#include <dali/public-api/render-tasks/render-task.h>
#include <dali/public-api/render-tasks/render-task-list.h>
-#include <orientation.h>
// INTERNAL HEADERS
#include <window-render-surface.h>
#include <drag-and-drop-detector-impl.h>
#include <indicator-impl.h>
#include <window-visibility-observer.h>
+#include <orientation.h>
#include <orientation-impl.h>
namespace
*/
EventHandler( Window* window )
: mWindow( window ),
- mWindowPropertyHandler( ecore_event_handler_add( ECORE_X_EVENT_WINDOW_PROPERTY, EcoreEventWindowPropertyChanged, this ) ),
- mClientMessagehandler( ecore_event_handler_add( ECORE_X_EVENT_CLIENT_MESSAGE, EcoreEventClientMessage, this ) ),
+ mWindowPropertyHandler( NULL ),
+ mClientMessagehandler( NULL ),
+ mWindowDeleteRequestHandler( NULL ),
mEcoreWindow( 0 )
{
// store ecore window handle
}
DALI_ASSERT_ALWAYS( mEcoreWindow != 0 && "There is no ecore x window");
+#ifndef DALI_PROFILE_UBUNTU
// set property on window to get deiconify approve client message
unsigned int tmp = 1;
ecore_x_window_prop_card32_set(mEcoreWindow,
ECORE_X_ATOM_E_DEICONIFY_APPROVE,
&tmp, 1);
+#endif // DALI_PROFILE_UBUNTU
+
+ if( mWindow->mEcoreEventHander )
+ {
+ ecore_x_input_multi_select( mEcoreWindow );
+
+ // This ensures that we catch the window close (or delete) request
+ ecore_x_icccm_protocol_set( mEcoreWindow, ECORE_X_WM_PROTOCOL_DELETE_REQUEST, EINA_TRUE );
+
+ mWindowPropertyHandler= ecore_event_handler_add( ECORE_X_EVENT_WINDOW_PROPERTY, EcoreEventWindowPropertyChanged, this );
+ mClientMessagehandler = ecore_event_handler_add( ECORE_X_EVENT_CLIENT_MESSAGE, EcoreEventClientMessage, this );
+ mWindowDeleteRequestHandler = ecore_event_handler_add( ECORE_X_EVENT_WINDOW_DELETE_REQUEST, EcoreEventWindowDeleteRequest, this );
+ }
}
/**
{
ecore_event_handler_del( mClientMessagehandler );
}
+ if ( mWindowDeleteRequestHandler )
+ {
+ ecore_event_handler_del( mWindowDeleteRequestHandler );
+ }
}
// Static methods
static Eina_Bool EcoreEventClientMessage( void* data, int type, void* event )
{
Eina_Bool handled( ECORE_CALLBACK_PASS_ON );
+#ifndef DALI_PROFILE_UBUNTU
Ecore_X_Event_Client_Message* clientMessageEvent( (Ecore_X_Event_Client_Message*)event );
EventHandler* handler( (EventHandler*)data );
}
}
}
+#endif // DALI_PROFILE_UBUNTU
return handled;
}
+ /// Called when the window receives a delete request
+ static Eina_Bool EcoreEventWindowDeleteRequest( void* data, int type, void* event )
+ {
+ EventHandler* handler( (EventHandler*)data );
+ handler->mWindow->mDeleteRequestSignal.Emit();
+ return ECORE_CALLBACK_DONE;
+ }
+
// Data
Window* mWindow;
Ecore_Event_Handler* mWindowPropertyHandler;
Ecore_Event_Handler* mClientMessagehandler;
+ Ecore_Event_Handler* mWindowDeleteRequestHandler;
Ecore_X_Window mEcoreWindow;
};
-Window* Window::New(const PositionSize& posSize, const std::string& name, bool isTransparent)
+Window* Window::New(const PositionSize& posSize, const std::string& name, const std::string& className, bool isTransparent)
{
Window* window = new Window();
window->mIsTransparent = isTransparent;
- window->Initialize(posSize, name);
+ window->Initialize(posSize, name, className);
return window;
}
return mSurface;
}
-void Window::SetIndicatorStyle( Dali::Window::IndicatorStyle style )
-{
- mIndicatorStyle = style;
-}
-
-void Window::ShowIndicator( bool show )
-{
- DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "%s\n", show?"SHOW":"HIDE" );
- DALI_ASSERT_DEBUG(mOverlay);
-
- if(show)
- {
- mIndicatorVisible = Dali::Window::VISIBLE;
- }
- else
- {
- mIndicatorVisible = Dali::Window::INVISIBLE;
- }
-
- DoShowIndicator( mIndicatorOrientation );
-}
-
void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
{
DALI_LOG_TRACE_METHOD_FMT( gWindowLogFilter, "visible : %d\n", visibleMode );
#if defined(DALI_PROFILE_MOBILE)
else if ( mIndicatorOpacityMode == Dali::Window::TRANSPARENT )
{
- ecore_x_e_illume_indicator_opacity_set(xWinId, ECORE_X_ILLUME_INDICATOR_BG_TRANSPARENT);
+ ecore_x_e_illume_indicator_opacity_set(xWinId, ECORE_X_ILLUME_INDICATOR_OPAQUE);
}
#endif
}
Window::Window()
: mSurface(NULL),
- mIndicatorStyle(Dali::Window::CHANGEABLE_COLOR),
- mIndicatorVisible(Dali::Window::VISIBLE),
+ mIndicatorVisible(Dali::Window::INVISIBLE),
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)
+ mAdaptor(NULL),
+ mEventHandler(NULL),
+ mPreferredOrientation(Dali::Window::PORTRAIT)
{
+
+ // Detect if we're not running in a ecore main loop (e.g. libuv).
+ // Typically ecore_x_init is called by app_efl_main->elm_init
+ // but if we're not using app_efl_main then we have to call it ourselves
+ // This is a hack until we create a pure X Window class
+ if( ecore_x_display_get() == NULL )
+ {
+ mEcoreEventHander = false;
+ ecore_x_init (NULL); // internally calls _ecore_x_input_init
+ }
+
}
Window::~Window()
{
delete mEventHandler;
- if ( mAdaptor )
+ if( mIndicator )
+ {
+ mOverlay->Remove( mIndicator->GetActor() );
+ Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
+ Dali::RenderTask indicatorTask = taskList.GetTask(0);
+ mOverlay->GetOverlayRenderTasks().RemoveTask(indicatorTask);
+ mIndicator->Close();
+ delete mIndicator;
+ }
+
+ if( mAdaptor )
{
mAdaptor->RemoveObserver( *this );
mAdaptor->SetDragAndDropDetector( NULL );
delete mSurface;
}
-void Window::Initialize(const PositionSize& windowPosition, const std::string& name)
+void Window::Initialize(const PositionSize& windowPosition, const std::string& name, const std::string& className)
{
// create an X11 window by default
Any surface;
- Any display;
- mSurface = new ECore::WindowRenderSurface( windowPosition, surface, display, name, mIsTransparent );
+ ECore::WindowRenderSurface* windowSurface = new ECore::WindowRenderSurface( windowPosition, surface, name, className, mIsTransparent );
+ windowSurface->Map();
+
+ mSurface = windowSurface;
+
mOrientation = Orientation::New(this);
// create event handler for X11 window
{
if( mIndicatorVisible != Dali::Window::INVISIBLE )
{
- mIndicator = new Indicator( mAdaptor, mIndicatorOrientation, mIndicatorStyle, this );
+ mIndicator = new Indicator( mAdaptor, mIndicatorOrientation, this );
mIndicator->SetOpacityMode( mIndicatorOpacityMode );
Dali::Actor actor = mIndicator->GetActor();
SetIndicatorActorRotation();
ECore::WindowRenderSurface* x11Window = dynamic_cast< ECore::WindowRenderSurface * >( mSurface );
if( x11Window )
{
+#ifndef DALI_PROFILE_UBUNTU
Ecore_X_Window win = x11Window->GetXWindow();
switch(type)
{
default:
break;
}
+#endif // DALI_PROFILE_UBUNTU
}
}
}
}
+void Window::IndicatorVisibilityChanged(bool isVisible)
+{
+ mIndicatorVisibilityChangedSignal.Emit(isVisible);
+}
+
void Window::SetIndicatorActorRotation()
{
DALI_LOG_TRACE_METHOD( gWindowLogFilter );
case Dali::Window::PORTRAIT:
actor.SetParentOrigin( ParentOrigin::TOP_CENTER );
actor.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- actor.SetRotation( Degree(0), Vector3::ZAXIS );
+ actor.SetOrientation( Degree(0), Vector3::ZAXIS );
break;
case Dali::Window::PORTRAIT_INVERSE:
actor.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
actor.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- actor.SetRotation( Degree(180), Vector3::ZAXIS );
+ actor.SetOrientation( Degree(180), Vector3::ZAXIS );
break;
case Dali::Window::LANDSCAPE:
actor.SetParentOrigin( ParentOrigin::CENTER_LEFT );
actor.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- actor.SetRotation( Degree(270), Vector3::ZAXIS );
+ actor.SetOrientation( Degree(270), Vector3::ZAXIS );
break;
case Dali::Window::LANDSCAPE_INVERSE:
actor.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
actor.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- actor.SetRotation( Degree(90), Vector3::ZAXIS );
+ actor.SetOrientation( Degree(90), Vector3::ZAXIS );
break;
}
}
return mDragAndDropDetector;
}
+Dali::Any Window::GetNativeHandle() const
+{
+ if(mEventHandler)
+ {
+ return mEventHandler->mEcoreWindow;
+ }
+ else
+ {
+ return Dali::Any();
+ }
+}
+
void Window::OnStart()
{
- DoShowIndicator( mIndicatorOrientation );
+ ShowIndicator( mIndicatorVisible );
}
void Window::OnPause()
mAdaptor = NULL;
}
-OrientationPtr Window::GetOrientation()
-{
- return mOrientation;
-}
-
void Window::AddAvailableOrientation(Dali::Window::WindowOrientation orientation)
{
bool found = false;
ECore::WindowRenderSurface* x11Window = dynamic_cast< ECore::WindowRenderSurface * >( mSurface );
if( x11Window )
{
+#ifndef DALI_PROFILE_UBUNTU
Ecore_X_Window ecoreWindow = x11Window->GetXWindow();
if( ! mWMRotationAppSet )
{
rotations[i] = static_cast<int>(mAvailableOrientations[i]);
}
ecore_x_e_window_rotation_available_rotations_set(ecoreWindow, rotations, mAvailableOrientations.size() );
-
+#endif // DALI_PROFILE_UBUNTU
}
}
ECore::WindowRenderSurface* x11Window = dynamic_cast< ECore::WindowRenderSurface * >( mSurface );
if( x11Window )
{
+#ifndef DALI_PROFILE_UBUNTU
Ecore_X_Window ecoreWindow = x11Window->GetXWindow();
if( ! mWMRotationAppSet )
}
ecore_x_e_window_rotation_preferred_rotation_set(ecoreWindow, orientation);
+#endif // DALI_PROFILE_UBUNTU
}
}
ECore::WindowRenderSurface* x11Window = dynamic_cast< ECore::WindowRenderSurface * >( mSurface );
if( x11Window )
{
+#ifndef DALI_PROFILE_UBUNTU
Ecore_X_Window ecoreWindow = x11Window->GetXWindow();
Ecore_X_Window root = ecore_x_window_root_get(ecoreWindow);
ecore_x_window_prop_property_set( ecoreWindow,
ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
ECORE_X_ATOM_CARDINAL, 32, &angles, 2 );
+#endif // DALI_PROFILE_UBUNTU
}
}
projects / platform / core / uifw / dali-adaptor.git / blobdiff