/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 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.
// INTERNAL HEADERS
#include <dali/internal/input/common/key-impl.h>
+#include <dali/internal/system/common/time-service.h>
#include <dali/internal/window-system/common/window-impl.h>
#include <dali/internal/window-system/common/window-render-surface.h>
#include <dali/internal/window-system/common/window-system.h>
#include <vconf.h>
#endif
+#define START_DURATION_CHECK() \
+ uint32_t durationMilliSeconds = static_cast<uint32_t>(-1); \
+ uint32_t startTime, endTime; \
+ startTime = TimeService::GetMilliSeconds();
+
+#define FINISH_DURATION_CHECK(functionName) \
+ endTime = TimeService::GetMilliSeconds(); \
+ durationMilliSeconds = endTime - startTime; \
+ if(durationMilliSeconds > 0) \
+ { \
+ DALI_LOG_DEBUG_INFO("%s : duration [%u ms]\n", functionName, durationMilliSeconds); \
+ }
+
#include <wayland-egl-tizen.h>
namespace Dali
return ECORE_CALLBACK_PASS_ON;
}
+#ifdef OVER_TIZEN_VERSION_8
+/**
+ * Called when a touch motion is received.
+ */
+static Eina_Bool EcoreEventMouseFrame(void* data, int type, void* event)
+{
+ WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
+ if(windowBase)
+ {
+ windowBase->OnMouseFrame(data, type, event);
+ }
+ return ECORE_CALLBACK_PASS_ON;
+}
+
+/**
+ * Called when a touch motion is received.
+ */
+static Eina_Bool EcoreEventMouseButtonRelativeMove(void* data, int type, void* event)
+{
+ WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
+ if(windowBase)
+ {
+ windowBase->OnMouseButtonRelativeMove(data, type, event);
+ }
+ return ECORE_CALLBACK_PASS_ON;
+}
+#endif
+
/**
* Called when a touch is canceled.
*/
return ECORE_CALLBACK_PASS_ON;
}
+#ifdef OVER_TIZEN_VERSION_8
+/**
+ * Called when pointer constraints event is recevied.
+ */
+static Eina_Bool EcoreEventPointerConstraints(void* data, int type, void* event)
+{
+ WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
+ if(windowBase)
+ {
+ windowBase->OnPointerConstraints(data, type, event);
+ }
+ return ECORE_CALLBACK_PASS_ON;
+}
+#endif
+
/**
* Called when a mouse wheel is received.
*/
return ECORE_CALLBACK_RENEW;
}
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Window is Moved/Resized By Server Callbacks
+/////////////////////////////////////////////////////////////////////////////////////////////////
+static Eina_Bool EcoreEventWindowMoveCompleted(void* data, int type, void* event)
+{
+ WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
+ if(windowBase)
+ {
+ windowBase->OnMoveCompleted(event);
+ }
+ return ECORE_CALLBACK_RENEW;
+}
+
+static Eina_Bool EcoreEventWindowResizeCompleted(void* data, int type, void* event)
+{
+ WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
+ if(windowBase)
+ {
+ windowBase->OnResizeCompleted(event);
+ }
+ return ECORE_CALLBACK_RENEW;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Conformant Change Callback
+/////////////////////////////////////////////////////////////////////////////////////////////////
+static Eina_Bool EcoreEventConformantChange(void* data, int type, void* event)
+{
+ WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
+ if(windowBase)
+ {
+ windowBase->OnEcoreEventConformantChange(event);
+ }
+ return ECORE_CALLBACK_RENEW;
+}
+
static void RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
{
WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
static void TizenPolicyConformantArea(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h)
{
+ WindowBaseEcoreWl2* windowBase = static_cast<WindowBaseEcoreWl2*>(data);
+ if(windowBase)
+ {
+ windowBase->TizenPolicyConformantArea(data, tizenPolicy, surface, conformantPart, state, x, y, w, h);
+ }
}
static void TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
mScreenOffModeChangeDone(true),
mVisible(true),
mOwnSurface(false),
- mBrightnessChangeDone(true)
+ mBrightnessChangeDone(true),
+ mIsFrontBufferRendering(false),
+ mIsIMEWindowInitialized(false)
{
Initialize(positionSize, surface, isTransparent);
}
if(mOwnSurface)
{
- ecore_wl2_window_free(mEcoreWindow);
+ try
+ {
+ ecore_wl2_window_free(mEcoreWindow);
+ }
+ catch(std::bad_weak_ptr const& ex)
+ {
+ DALI_LOG_ERROR("WindowBaseEcoreWl2::~WindowBaseEcoreWl2() - window (%p) std::bad_weak_ptr caught: %s\n", mEcoreWindow, ex.what());
+ }
}
}
SetTransparency(isTransparent);
+ Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
+ Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(display);
+
+ if(ecoreWlInput)
+ {
+ mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
+
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SEAT_KEYMAP_CHANGED, EcoreEventSeatKeymapChanged, this));
+ }
+
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_ICONIFY_STATE_CHANGE, EcoreEventWindowIconifyStateChanged, this));
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_IN, EcoreEventWindowFocusIn, this));
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_OUT, EcoreEventWindowFocusOut, this));
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, EcoreEventMouseButtonUp, this));
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, EcoreEventMouseButtonMove, this));
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_CANCEL, EcoreEventMouseButtonCancel, this));
+#ifdef OVER_TIZEN_VERSION_8
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_RELATIVE_MOVE, EcoreEventMouseButtonRelativeMove, this));
+
+ // Register pointer lock/unlock event
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_POINTER_CONSTRAINTS, EcoreEventPointerConstraints, this));
+
+ // Register mouse frame events
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_FRAME, EcoreEventMouseFrame, this));
+#endif
// Register Mouse wheel events
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_EVENT_MOUSE_WHEEL, EcoreEventMouseWheel, this));
// Register Selection event - clipboard selection
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_SEND, EcoreEventDataSend, this));
- mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SELECTION_DATA_READY, EcoreEventDataReceive, this));
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_OFFER_DATA_READY, EcoreEventDataReceive, this));
// Register Effect Start/End event
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_EFFECT_START, EcoreEventEffectStart, this));
// Register Window auxiliary event
mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_AUX_MESSAGE, EcoreEventWindowAuxiliaryMessage, this));
+ // Register Conformant change event
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_CONFORMANT_CHANGE, EcoreEventConformantChange, this));
+
#if defined(VCONF_ENABLED)
// Register Vconf notify - font name and size
vconf_notify_key_changed_for_ui_thread(DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, this);
vconf_notify_key_changed_for_ui_thread(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, this);
#endif
- Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
- mDisplay = ecore_wl2_display_get(display);
+ // Register Window is moved and resized done event.
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_INTERACTIVE_MOVE_DONE, EcoreEventWindowMoveCompleted, this));
+ mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_INTERACTIVE_RESIZE_DONE, EcoreEventWindowResizeCompleted, this));
+ mDisplay = ecore_wl2_display_get(display);
if(mDisplay)
{
wl_display* displayWrapper = static_cast<wl_display*>(wl_proxy_create_wrapper(mDisplay));
wl_registry* registry = wl_display_get_registry(displayWrapper);
wl_registry_add_listener(registry, ®istryListener, this);
+
+ // To support ECORE_WL2_EVENT_CONFORMANT_CHANGE event handler
+ ecore_wl2_window_conformant_set(mEcoreWindow, true);
}
wl_proxy_wrapper_destroy(displayWrapper);
}
}
- Ecore_Wl2_Input* ecoreWlInput = ecore_wl2_input_default_input_get(display);
-
- if(ecoreWlInput)
- {
- mKeyMap = ecore_wl2_input_keymap_get(ecoreWlInput);
-
- mEcoreEventHandler.PushBack(ecore_event_handler_add(ECORE_WL2_EVENT_SEAT_KEYMAP_CHANGED, EcoreEventSeatKeymapChanged, this));
- }
-
// get auxiliary hint
Eina_List* hints = ecore_wl2_window_aux_hints_supported_get(mEcoreWindow);
if(hints)
Ecore_Wl2_Event_Window_Iconify_State_Change* iconifyChangedEvent(static_cast<Ecore_Wl2_Event_Window_Iconify_State_Change*>(event));
Eina_Bool handled(ECORE_CALLBACK_PASS_ON);
- if(iconifyChangedEvent->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(iconifyChangedEvent->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
if(iconifyChangedEvent->iconified == EINA_TRUE)
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnIconifyStateChanged, the window (%p) is iconified\n", mEcoreWindow);
mIconifyChangedSignal.Emit(true);
}
else
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnIconifyStateChanged, the window (%p) is not iconified\n", mEcoreWindow);
mIconifyChangedSignal.Emit(false);
}
handled = ECORE_CALLBACK_DONE;
{
Ecore_Wl2_Event_Focus_In* focusInEvent(static_cast<Ecore_Wl2_Event_Focus_In*>(event));
- if(focusInEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(focusInEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n");
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnFocusIn, Window (%p) EcoreEventWindowFocusIn\n", mEcoreWindow);
mFocusChangedSignal.Emit(true);
}
{
Ecore_Wl2_Event_Focus_Out* focusOutEvent(static_cast<Ecore_Wl2_Event_Focus_Out*>(event));
- if(focusOutEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(focusOutEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n");
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnFocusOut, Window (%p) EcoreEventWindowFocusOut\n", mEcoreWindow);
mFocusChangedSignal.Emit(false);
}
{
Ecore_Wl2_Event_Output_Transform* transformEvent(static_cast<Ecore_Wl2_Event_Output_Transform*>(event));
- if(transformEvent->output == ecore_wl2_window_output_find(mEcoreWindow))
+ if(transformEvent->output == ecore_wl2_window_output_find(mEcoreWindow) && Dali::Adaptor::IsAvailable())
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnOutputTransform, Window (%p) EcoreEventOutputTransform\n", mEcoreWindow);
mScreenRotationAngle = GetScreenRotationAngle();
{
Ecore_Wl2_Event_Ignore_Output_Transform* ignoreTransformEvent(static_cast<Ecore_Wl2_Event_Ignore_Output_Transform*>(event));
- if(ignoreTransformEvent->win == mEcoreWindow)
+ if(ignoreTransformEvent->win == mEcoreWindow && Dali::Adaptor::IsAvailable())
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnIgnoreOutputTransform, Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow);
mScreenRotationAngle = GetScreenRotationAngle();
{
Ecore_Wl2_Event_Window_Rotation* ev(static_cast<Ecore_Wl2_Event_Window_Rotation*>(event));
- if(ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
- DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnRotation, angle: %d, width: %d, height: %d\n", ev->angle, ev->w, ev->h);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnRotation, Window (%p), angle: %d, width: %d, height: %d\n", mEcoreWindow, ev->angle, ev->w, ev->h);
RotationEvent rotationEvent;
rotationEvent.angle = ev->angle;
{
Ecore_Wl2_Event_Window_Configure* ev(static_cast<Ecore_Wl2_Event_Window_Configure*>(event));
- if(ev && ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(ev && ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
// Note: To comply with the wayland protocol, Dali should make an ack_configure
// by calling ecore_wl2_window_commit
mWindowPositionSize.y = ev->y;
mWindowPositionSize.width = newWidth;
mWindowPositionSize.height = newHeight;
- DALI_LOG_RELEASE_INFO("Update position & resize signal by server, current angle [%d] x[%d] y[%d] w[%d] h[%d]\n", mWindowRotationAngle, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnConfiguration, Window (%p), Update position & resize signal by Ecore, current angle [%d] x[%d] y[%d] w[%d] h[%d]\n", mEcoreWindow, mWindowRotationAngle, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
{
Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
- if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_DOWN");
point.SetMouseButton(static_cast<MouseButton::Type>(touchEvent->buttons));
mTouchEventSignal.Emit(point, touchEvent->timestamp);
+
+#ifndef OVER_TIZEN_VERSION_8
+ mMouseFrameEventSignal.Emit();
+#endif
}
}
{
Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
- if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_UP");
point.SetMouseButton(static_cast<MouseButton::Type>(touchEvent->buttons));
mTouchEventSignal.Emit(point, touchEvent->timestamp);
+
+#ifndef OVER_TIZEN_VERSION_8
+ mMouseFrameEventSignal.Emit();
+#endif
}
}
{
Ecore_Event_Mouse_Move* touchEvent = static_cast<Ecore_Event_Mouse_Move*>(event);
- if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_MOVE");
point.SetDeviceSubclass(deviceSubclass);
mTouchEventSignal.Emit(point, touchEvent->timestamp);
+
+#ifndef OVER_TIZEN_VERSION_8
+ mMouseFrameEventSignal.Emit();
+#endif
+ }
+}
+
+#ifdef OVER_TIZEN_VERSION_8
+void WindowBaseEcoreWl2::OnMouseFrame(void* data, int type, void* event)
+{
+ Ecore_Event_Mouse_Frame* MouseFrameEvent = static_cast<Ecore_Event_Mouse_Frame*>(event);
+
+ if(MouseFrameEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
+ {
+ DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_FRAME");
+ mMouseFrameEventSignal.Emit();
+ }
+}
+
+void WindowBaseEcoreWl2::OnMouseButtonRelativeMove(void* data, int type, void* event)
+{
+ Ecore_Event_Mouse_Relative_Move* relativeMoveEvent = static_cast<Ecore_Event_Mouse_Relative_Move*>(event);
+
+ if(relativeMoveEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
+ {
+ DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_RELATIVE_MOVE");
+
+ Device::Class::Type deviceClass;
+ Device::Subclass::Type deviceSubclass;
+
+ GetDeviceClass(ecore_device_class_get(relativeMoveEvent->dev), deviceClass);
+ GetDeviceSubclass(ecore_device_subclass_get(relativeMoveEvent->dev), deviceSubclass);
+
+ Dali::DevelWindow::MouseRelativeEvent mouseRelativeEvent(Dali::DevelWindow::MouseRelativeEvent::Type::RELATIVE_MOVE, relativeMoveEvent->modifiers, relativeMoveEvent->timestamp, Vector2(relativeMoveEvent->dx, relativeMoveEvent->dy), Vector2(relativeMoveEvent->dx_unaccel, relativeMoveEvent->dy_unaccel), deviceClass, deviceSubclass);
+
+ mMouseRelativeEventSignal.Emit(mouseRelativeEvent);
}
}
+#endif
void WindowBaseEcoreWl2::OnMouseButtonCancel(void* data, int type, void* event)
{
Ecore_Event_Mouse_Button* touchEvent = static_cast<Ecore_Event_Mouse_Button*>(event);
- if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(touchEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_CANCEL");
+ Device::Class::Type deviceClass;
+ Device::Subclass::Type deviceSubclass;
+
+ GetDeviceClass(ecore_device_class_get(touchEvent->dev), deviceClass);
+ GetDeviceSubclass(ecore_device_subclass_get(touchEvent->dev), deviceSubclass);
+
Integration::Point point;
point.SetDeviceId(touchEvent->multi.device);
point.SetState(PointState::INTERRUPTED);
- point.SetScreenPosition(Vector2(0.0f, 0.0f));
+ point.SetScreenPosition(Vector2(touchEvent->x, touchEvent->y));
+ point.SetRadius(touchEvent->multi.radius, Vector2(touchEvent->multi.radius_x, touchEvent->multi.radius_y));
+ point.SetPressure(touchEvent->multi.pressure);
+ point.SetAngle(Degree(touchEvent->multi.angle));
+ point.SetDeviceClass(deviceClass);
+ point.SetDeviceSubclass(deviceSubclass);
mTouchEventSignal.Emit(point, touchEvent->timestamp);
+#ifndef OVER_TIZEN_VERSION_8
+ mMouseFrameEventSignal.Emit();
+#endif
+
DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnMouseButtonCancel\n");
}
}
+#ifdef OVER_TIZEN_VERSION_8
+void WindowBaseEcoreWl2::OnPointerConstraints(void* data, int type, void* event)
+{
+ Ecore_Wl2_Event_Pointer_Constraints* constraintsEvent = static_cast<Ecore_Wl2_Event_Pointer_Constraints*>(event);
+
+ if(constraintsEvent && constraintsEvent->win == static_cast<uint32_t>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
+ {
+ DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_POINTER_CONSTRAINTS");
+ Dali::Int32Pair position(constraintsEvent->x, constraintsEvent->y);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnPointerConstraints[%d, %d]\n", position.GetX(), position.GetY());
+
+ mPointerConstraintsSignal.Emit(position, constraintsEvent->locked, constraintsEvent->confined);
+ }
+}
+#endif
+
void WindowBaseEcoreWl2::OnMouseWheel(void* data, int type, void* event)
{
Ecore_Event_Mouse_Wheel* mouseWheelEvent = static_cast<Ecore_Event_Mouse_Wheel*>(event);
- if(mouseWheelEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(mouseWheelEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_WHEEL");
{
Ecore_Event_Mouse_IO* mouseInOutEvent = static_cast<Ecore_Event_Mouse_IO*>(event);
- if(mouseInOutEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(mouseInOutEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
DALI_TRACE_SCOPE(gTraceFilter, "DALI_ON_MOUSE_IN_OUT");
{
Ecore_Event_Detent_Rotate* detentEvent = static_cast<Ecore_Event_Detent_Rotate*>(event);
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::OnDetentRotation\n");
-
- int32_t clockwise = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnDetentRotation, Window (%p)\n", mEcoreWindow);
+ if(Dali::Adaptor::IsAvailable())
+ {
+ int32_t clockwise = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
- Integration::WheelEvent wheelEvent(Integration::WheelEvent::CUSTOM_WHEEL, detentEvent->direction, 0, Vector2(0.0f, 0.0f), clockwise, detentEvent->timestamp);
+ Integration::WheelEvent wheelEvent(Integration::WheelEvent::CUSTOM_WHEEL, detentEvent->direction, 0, Vector2(0.0f, 0.0f), clockwise, detentEvent->timestamp);
- mWheelEventSignal.Emit(wheelEvent);
+ mWheelEventSignal.Emit(wheelEvent);
+ }
}
void WindowBaseEcoreWl2::OnKeyDown(void* data, int type, void* event)
{
Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
- if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
std::string keyName(keyEvent->keyname);
std::string logicalKey("");
GetDeviceClass(ecore_device_class_get(keyEvent->dev), deviceClass);
GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
+ bool isRepeat = false;
+#ifdef OVER_TIZEN_VERSION_8
+ if(keyEvent->event_flags & ECORE_EVENT_FLAG_REPEAT)
+ {
+ isRepeat = true;
+ }
+#endif
+
Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::DOWN, compose, deviceName, deviceClass, deviceSubclass);
+ keyEvent.isRepeat = isRepeat;
+ keyEvent.windowId = GetNativeWindowId();
mKeyEventSignal.Emit(keyEvent);
}
{
Ecore_Event_Key* keyEvent = static_cast<Ecore_Event_Key*>(event);
- if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ if(keyEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
{
#if defined(ECORE_VERSION_MAJOR) && (ECORE_VERSION_MAJOR >= 1) && defined(ECORE_VERSION_MINOR) && (ECORE_VERSION_MINOR >= 23)
// Cancel processing flag is sent because this key event will combine with the previous key. So, the event should not actually perform anything.
GetDeviceSubclass(ecore_device_subclass_get(keyEvent->dev), deviceSubclass);
Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, modifier, time, Integration::KeyEvent::UP, compose, deviceName, deviceClass, deviceSubclass);
+ keyEvent.windowId = GetNativeWindowId();
mKeyEventSignal.Emit(keyEvent);
}
void WindowBaseEcoreWl2::OnDataSend(void* data, int type, void* event)
{
- mSelectionDataSendSignal.Emit(event);
+ if(Dali::Adaptor::IsAvailable())
+ {
+ mSelectionDataSendSignal.Emit(event);
+ }
}
void WindowBaseEcoreWl2::OnDataReceive(void* data, int type, void* event)
{
- mSelectionDataReceivedSignal.Emit(event);
+ if(Dali::Adaptor::IsAvailable())
+ {
+ mSelectionDataReceivedSignal.Emit(event);
+ }
}
void WindowBaseEcoreWl2::OnFontNameChanged()
{
- mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
+ if(Dali::Adaptor::IsAvailable())
+ {
+ mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_CHANGE);
+ }
}
void WindowBaseEcoreWl2::OnFontSizeChanged()
{
- mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
+ if(Dali::Adaptor::IsAvailable())
+ {
+ mStyleChangedSignal.Emit(StyleChange::DEFAULT_FONT_SIZE_CHANGE);
+ }
}
void WindowBaseEcoreWl2::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
{
- mTransitionEffectEventSignal.Emit(state, type);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnTransitionEffectEvent, Window (%p)\n", mEcoreWindow);
+
+ if(Dali::Adaptor::IsAvailable())
+ {
+ mTransitionEffectEventSignal.Emit(state, type);
+ }
}
void WindowBaseEcoreWl2::OnKeyboardRepeatSettingsChanged()
{
- mKeyboardRepeatSettingsChangedSignal.Emit();
+ if(Dali::Adaptor::IsAvailable())
+ {
+ mKeyboardRepeatSettingsChangedSignal.Emit();
+ }
}
void WindowBaseEcoreWl2::OnEcoreEventWindowRedrawRequest()
{
- mWindowRedrawRequestSignal.Emit();
+ if(Dali::Adaptor::IsAvailable())
+ {
+ mWindowRedrawRequestSignal.Emit();
+ }
}
void WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage(void* event)
{
- Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
- if(message)
+ if(Dali::Adaptor::IsAvailable())
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, key:%s, value:%s \n", message->key, message->val);
- std::string key(message->key);
- std::string value(message->val);
- Dali::Property::Array options;
-
- if(message->options)
+ Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
+ if(message)
{
- Eina_List* l;
- void* data;
- EINA_LIST_FOREACH(message->options, l, data)
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, Window (%p), key:%s, value:%s \n", mEcoreWindow, message->key, message->val);
+ std::string key(message->key);
+ std::string value(message->val);
+ Dali::Property::Array options;
+
+ if(message->options)
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, option: %s\n", (char*)data);
- std::string option(static_cast<char*>(data));
- options.Add(option);
+ Eina_List* l;
+ void* data;
+ EINA_LIST_FOREACH(message->options, l, data)
+ {
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, Window (%p), option: %s\n", mEcoreWindow, (char*)data);
+ std::string option(static_cast<char*>(data));
+ options.Add(option);
+ }
}
+
+ mAuxiliaryMessageSignal.Emit(key, value, options);
}
+ }
+}
+
+void WindowBaseEcoreWl2::OnEcoreEventConformantChange(void* event)
+{
+ if(Dali::Adaptor::IsAvailable())
+ {
+ Ecore_Wl2_Event_Conformant_Change* ev = static_cast<Ecore_Wl2_Event_Conformant_Change*>(event);
+ if(ev && ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
+ {
+ WindowInsetsPartType partType = WindowInsetsPartType::STATUS_BAR;
+
+ int x = 0;
+ int y = 0;
+ int w = 0;
+ int h = 0;
+
+ switch(ev->part_type)
+ {
+ case ECORE_WL2_INDICATOR_PART:
+ {
+ partType = WindowInsetsPartType::STATUS_BAR;
+ ecore_wl2_window_indicator_geometry_get(mEcoreWindow, &x, &y, &w, &h);
+ break;
+ }
+ case ECORE_WL2_KEYBOARD_PART:
+ {
+ partType = WindowInsetsPartType::KEYBOARD;
+ ecore_wl2_window_keyboard_geometry_get(mEcoreWindow, &x, &y, &w, &h);
+ break;
+ }
+ case ECORE_WL2_CLIPBOARD_PART:
+ {
+ partType = WindowInsetsPartType::CLIPBOARD;
+ ecore_wl2_window_clipboard_geometry_get(mEcoreWindow, &x, &y, &w, &h);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ WindowInsetsPartState partState = WindowInsetsPartState::INVISIBLE;
- mAuxiliaryMessageSignal.Emit(key, value, options);
+ int left = 0;
+ int right = 0;
+ int top = 0;
+ int bottom = 0;
+
+ // Insets are applied only if system UI(e.g. virtual keyboard) satisfies the following 2 conditions.
+ // 1. System UI fits to the window width or height.
+ // 2. System UI begins or ends from the edge of window.
+ // Otherwise, we should not resize window content because there would be empty space around system UI.
+ bool applyInsets = false;
+
+ // Zero insets are applied if state is invisible
+ if(!ev->state)
+ {
+ applyInsets = true;
+ }
+ else
+ {
+ partState = WindowInsetsPartState::VISIBLE;
+
+ int winX = mWindowPositionSize.x;
+ int winY = mWindowPositionSize.y;
+ int winW = mWindowPositionSize.width;
+ int winH = mWindowPositionSize.height;
+
+ if((x <= winX) && (x + w >= winX + winW))
+ {
+ if((y <= winY) && (y + h >= winY) && (y + h <= winY + winH))
+ {
+ top = y + h - winY;
+ applyInsets = true;
+ }
+ else if((y + h >= winY + winH) && (y >= winY) && (y <= winY + winH))
+ {
+ bottom = winY + winH - y;
+ applyInsets = true;
+ }
+ }
+ else if((y <= winY) && (y + h >= winY + winH))
+ {
+ if((x <= winX) && (x + w >= winX) && (x + w <= winX + winW))
+ {
+ left = x + w - winX;
+ applyInsets = true;
+ }
+ else if((x + w >= winX + winW) && (x >= winX) && (x <= winX + winW))
+ {
+ right = winX + winW - x;
+ applyInsets = true;
+ }
+ }
+ }
+
+ if(applyInsets)
+ {
+ mInsetsChangedSignal.Emit(partType, partState, Extents(left, right, top, bottom));
+ }
+ }
}
}
}
}
+void WindowBaseEcoreWl2::OnMoveCompleted(void* event)
+{
+ Ecore_Wl2_Event_Window_Interactive_Move_Done* movedDoneEvent = static_cast<Ecore_Wl2_Event_Window_Interactive_Move_Done*>(event);
+ if(movedDoneEvent && movedDoneEvent->win == static_cast<uint32_t>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
+ {
+ Dali::PositionSize orgPositionSize(movedDoneEvent->x, movedDoneEvent->y, movedDoneEvent->w, movedDoneEvent->h);
+ Dali::PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(orgPositionSize);
+ Dali::Int32Pair newPosition(newPositionSize.x, newPositionSize.y);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnMoveCompleted, window(%p) has been moved by server[%d, %d]\n", mEcoreWindow, newPositionSize.x, newPositionSize.y);
+ mMoveCompletedSignal.Emit(newPosition);
+ }
+}
+
+void WindowBaseEcoreWl2::OnResizeCompleted(void* event)
+{
+ Ecore_Wl2_Event_Window_Interactive_Resize_Done* resizedDoneEvent = static_cast<Ecore_Wl2_Event_Window_Interactive_Resize_Done*>(event);
+ if(resizedDoneEvent && resizedDoneEvent->win == static_cast<uint32_t>(ecore_wl2_window_id_get(mEcoreWindow)) && Dali::Adaptor::IsAvailable())
+ {
+ Dali::PositionSize orgPositionSize(resizedDoneEvent->x, resizedDoneEvent->y, resizedDoneEvent->w, resizedDoneEvent->h);
+ Dali::PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(orgPositionSize);
+ Dali::Uint16Pair newSize(newPositionSize.width, newPositionSize.height);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnResizeCompleted, window(%p) has been resized by server[%d, %d]\n", mEcoreWindow, newPositionSize.width, newPositionSize.height);
+ mResizeCompletedSignal.Emit(newSize);
+ }
+}
+
void WindowBaseEcoreWl2::RegistryGlobalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
{
if(strcmp(interface, tizen_policy_interface.name) == 0)
mTizenDisplayPolicy = NULL;
}
+void WindowBaseEcoreWl2::TizenPolicyConformantArea(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, uint32_t conformantPart, uint32_t state, int32_t x, int32_t y, int32_t w, int32_t h)
+{
+ int originalX, originalY, originalWidth, originalHeight;
+ bool changed = false;
+
+ if(!surface)
+ {
+ DALI_LOG_ERROR("Failed to get wayland surface in WindowBaseEcoreWl2::TizenPolicyConformantArea()\n");
+ return;
+ }
+
+ if(conformantPart == TIZEN_POLICY_CONFORMANT_PART_INDICATOR)
+ {
+ ecore_wl2_window_indicator_geometry_get(mEcoreWindow, &originalX, &originalY, &originalWidth, &originalHeight);
+ if((originalX != x) || (originalY != y) || (originalWidth != w) || (originalHeight != h))
+ {
+ ecore_wl2_window_indicator_geometry_set(mEcoreWindow, x, y, w, h);
+ changed = true;
+ }
+
+ /**
+ * The given state is based on the visibility value of indicator.
+ * Thus we need to add 1 to it before comparing with indicator state.
+ */
+ Ecore_Wl2_Indicator_State indState = ecore_wl2_window_indicator_state_get(mEcoreWindow);
+ if((state + 1) != indState)
+ {
+ ecore_wl2_window_indicator_state_set(mEcoreWindow, static_cast<Ecore_Wl2_Indicator_State>(state + 1));
+ changed = true;
+ }
+ }
+ else if(conformantPart == TIZEN_POLICY_CONFORMANT_PART_KEYBOARD)
+ {
+ ecore_wl2_window_keyboard_geometry_get(mEcoreWindow, &originalX, &originalY, &originalWidth, &originalHeight);
+ if((originalX != x) || (originalY != y) || (originalWidth != w) || (originalHeight != h))
+ {
+ ecore_wl2_window_keyboard_geometry_set(mEcoreWindow, x, y, w, h);
+ changed = true;
+ }
+
+ /**
+ * The given state is based on the visibility value of virtual keyboard window.
+ * Thus we need to add 1 to it before comparing with keyboard state.
+ */
+ Ecore_Wl2_Virtual_Keyboard_State kbdState = ecore_wl2_window_keyboard_state_get(mEcoreWindow);
+ if((state + 1) != (kbdState))
+ {
+ ecore_wl2_window_keyboard_state_set(mEcoreWindow, static_cast<Ecore_Wl2_Virtual_Keyboard_State>(state + 1));
+ changed = true;
+ }
+ }
+ else if(conformantPart == TIZEN_POLICY_CONFORMANT_PART_CLIPBOARD)
+ {
+ ecore_wl2_window_clipboard_geometry_get(mEcoreWindow, &originalX, &originalY, &originalWidth, &originalHeight);
+ if((originalX != x) || (originalY != y) || (originalWidth != w) || (originalHeight != h))
+ {
+ ecore_wl2_window_clipboard_geometry_set(mEcoreWindow, x, y, w, h);
+ changed = true;
+ }
+
+ /**
+ * The given state is based on the visibility value of clipboard window.
+ * Thus we need to add 1 to it before comparing with clipboard state.
+ */
+ Ecore_Wl2_Clipboard_State clipState = ecore_wl2_window_clipboard_state_get(mEcoreWindow);
+ if((state + 1) != clipState)
+ {
+ ecore_wl2_window_clipboard_state_set(mEcoreWindow, static_cast<Ecore_Wl2_Clipboard_State>(state + 1));
+ changed = true;
+ }
+ }
+
+ if(changed)
+ {
+ Ecore_Wl2_Event_Conformant_Change* ev = static_cast<Ecore_Wl2_Event_Conformant_Change*>(calloc(1, sizeof(Ecore_Wl2_Event_Conformant_Change)));
+
+ if(DALI_UNLIKELY(!ev))
+ {
+ DALI_LOG_ERROR("Failed to allocate Ecore_Wl2_Event_Conformant_Change. calloc size : %zu\n", sizeof(Ecore_Wl2_Event_Conformant_Change));
+ return;
+ }
+ ev->win = GetNativeWindowId();
+ ev->part_type = static_cast<Ecore_Wl2_Conformant_Part_Type>(conformantPart);
+ ev->state = state;
+ ecore_event_add(ECORE_WL2_EVENT_CONFORMANT_CHANGE, ev, NULL, NULL);
+ }
+
+ DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::TizenPolicyConformantArea: conformantPart = %u, state = %u, position = (%d, %d), size = (%d, %d)\n", conformantPart, state, x, y, w, h);
+}
+
void WindowBaseEcoreWl2::TizenPolicyNotificationChangeDone(void* data, struct tizen_policy* tizenPolicy, struct wl_surface* surface, int32_t level, uint32_t state)
{
mNotificationLevel = level;
KeyCodeMap foundKeyCode;
sym = xkb_keysym_from_name(keyName.c_str(), XKB_KEYSYM_NO_FLAGS);
- if(sym == XKB_KEY_NoSymbol)
+ if(sym == XKB_KEY_NoSymbol || !mKeyMap)
{
- DALI_LOG_ERROR("Failed to get keysym in WindowBaseEcoreWl2\n");
+ DALI_LOG_ERROR("Failed to get keysym or keymap in WindowBaseEcoreWl2\n");
return;
}
EGLNativeWindowType WindowBaseEcoreWl2::CreateEglWindow(int width, int height)
{
int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
+
+ START_DURATION_CHECK();
if(totalAngle == 90 || totalAngle == 270)
{
mEglWindow = wl_egl_window_create(mWlSurface, height, width);
{
mEglWindow = wl_egl_window_create(mWlSurface, width, height);
}
+ FINISH_DURATION_CHECK("wl_egl_window_create");
return static_cast<EGLNativeWindowType>(mEglWindow);
}
{
if(mEglWindow != NULL)
{
+ START_DURATION_CHECK();
wl_egl_window_destroy(mEglWindow);
+ FINISH_DURATION_CHECK("wl_egl_window_destroy");
+
mEglWindow = NULL;
}
}
}
}
+ START_DURATION_CHECK();
wl_egl_window_tizen_set_rotation(mEglWindow, rotation);
+ FINISH_DURATION_CHECK("wl_egl_window_tizen_set_rotation");
}
void WindowBaseEcoreWl2::SetEglWindowBufferTransform(int angle)
}
DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_buffer_transform() with buffer Transform [%d]\n", bufferTransform);
+ START_DURATION_CHECK();
wl_egl_window_tizen_set_buffer_transform(mEglWindow, bufferTransform);
+ FINISH_DURATION_CHECK("wl_egl_window_tizen_set_buffer_transform");
}
void WindowBaseEcoreWl2::SetEglWindowTransform(int angle)
}
DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_window_transform() with window Transform [%d]\n", windowTransform);
+ START_DURATION_CHECK();
wl_egl_window_tizen_set_window_transform(mEglWindow, windowTransform);
+ FINISH_DURATION_CHECK("wl_egl_window_tizen_set_window_transform");
}
void WindowBaseEcoreWl2::ResizeEglWindow(PositionSize positionSize)
{
DALI_LOG_RELEASE_INFO("wl_egl_window_resize(), (%d, %d) [%d x %d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height);
+ START_DURATION_CHECK();
wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
// Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
wl_egl_window_tizen_set_window_serial(mEglWindow, mMoveResizeSerial);
mLastSubmittedMoveResizeSerial = mMoveResizeSerial;
}
+ FINISH_DURATION_CHECK("wl_egl_window functions");
}
bool WindowBaseEcoreWl2::IsEglWindowRotationSupported()
{
+ START_DURATION_CHECK();
// Check capability
wl_egl_window_tizen_capability capability = static_cast<wl_egl_window_tizen_capability>(wl_egl_window_tizen_get_capabilities(mEglWindow));
+ FINISH_DURATION_CHECK("wl_egl_window_tizen_get_capabilities");
+
if(capability == WL_EGL_WINDOW_TIZEN_CAPABILITY_ROTATION_SUPPORTED)
{
mSupportedPreProtation = true;
mWindowPositionSize = newPositionSize;
DALI_LOG_RELEASE_INFO("ecore_wl2_window_position_set x[%d], y[%d]\n", newPositionSize.x, newPositionSize.y);
+ START_DURATION_CHECK();
ecore_wl2_window_position_set(mEcoreWindow, newPositionSize.x, newPositionSize.y);
+ FINISH_DURATION_CHECK("ecore_wl2_window_position_set");
}
void WindowBaseEcoreWl2::Resize(PositionSize positionSize)
mWindowPositionSize = newPositionSize;
DALI_LOG_RELEASE_INFO("ecore_wl2_window_sync_geometry_set, x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
+ START_DURATION_CHECK();
ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
+ FINISH_DURATION_CHECK("ecore_wl2_window_sync_geometry_set");
}
void WindowBaseEcoreWl2::MoveResize(PositionSize positionSize)
mWindowPositionSize = newPositionSize;
DALI_LOG_RELEASE_INFO("ecore_wl2_window_sync_geometry_set, x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
+ START_DURATION_CHECK();
ecore_wl2_window_sync_geometry_set(mEcoreWindow, ++mMoveResizeSerial, newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
+ FINISH_DURATION_CHECK("ecore_wl2_window_sync_geometry_set");
}
void WindowBaseEcoreWl2::SetLayout(unsigned int numCols, unsigned int numRows, unsigned int column, unsigned int row, unsigned int colSpan, unsigned int rowSpan)
{
+#ifdef OVER_TIZEN_VERSION_8
DALI_LOG_RELEASE_INFO("ecore_wl2_window_layout_set, numCols[%d], numRows[%d], column[%d], row[%d], colSpan[%d], rowSpan[%d]\n", numCols, numRows, column, row, colSpan, rowSpan);
+ START_DURATION_CHECK();
ecore_wl2_window_layout_set(mEcoreWindow, numCols, numRows, column, row, colSpan, rowSpan);
+ FINISH_DURATION_CHECK("ecore_wl2_window_layout_set");
+#endif
}
void WindowBaseEcoreWl2::SetClass(const std::string& name, const std::string& className)
void WindowBaseEcoreWl2::Raise()
{
+ START_DURATION_CHECK();
// Use ecore_wl2_window_activate to prevent the window shown without rendering
ecore_wl2_window_activate(mEcoreWindow);
+ FINISH_DURATION_CHECK("ecore_wl2_window_activate");
}
void WindowBaseEcoreWl2::Lower()
{
+ START_DURATION_CHECK();
ecore_wl2_window_lower(mEcoreWindow);
+ FINISH_DURATION_CHECK("ecore_wl2_window_lower");
}
void WindowBaseEcoreWl2::Activate()
{
+ START_DURATION_CHECK();
ecore_wl2_window_activate(mEcoreWindow);
+ FINISH_DURATION_CHECK("ecore_wl2_window_activate");
}
void WindowBaseEcoreWl2::Maximize(bool maximize)
{
+ START_DURATION_CHECK();
ecore_wl2_window_maximized_set(mEcoreWindow, maximize);
+ FINISH_DURATION_CHECK("ecore_wl2_window_maximized_set");
}
bool WindowBaseEcoreWl2::IsMaximized() const
void WindowBaseEcoreWl2::SetMaximumSize(Dali::Window::WindowSize size)
{
DALI_LOG_RELEASE_INFO("ecore_wl2_window_maximum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
+ START_DURATION_CHECK();
ecore_wl2_window_maximum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
+ FINISH_DURATION_CHECK("ecore_wl2_window_maximum_size_set");
ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
}
void WindowBaseEcoreWl2::Minimize(bool minimize)
{
+ START_DURATION_CHECK();
ecore_wl2_window_iconified_set(mEcoreWindow, minimize);
+ FINISH_DURATION_CHECK("ecore_wl2_window_iconified_set");
}
bool WindowBaseEcoreWl2::IsMinimized() const
void WindowBaseEcoreWl2::SetMimimumSize(Dali::Window::WindowSize size)
{
DALI_LOG_RELEASE_INFO("ecore_wl2_window_minimum_size_set, width: %d, height: %d\n", size.GetWidth(), size.GetHeight());
+ START_DURATION_CHECK();
ecore_wl2_window_minimum_size_set(mEcoreWindow, size.GetWidth(), size.GetHeight());
+ FINISH_DURATION_CHECK("ecore_wl2_window_minimum_size_set");
ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
}
rotations[i] = static_cast<int>(angles[i]);
DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "%d ", rotations[i]);
}
+
+ START_DURATION_CHECK();
ecore_wl2_window_available_rotations_set(mEcoreWindow, rotations, angles.size());
+ FINISH_DURATION_CHECK("ecore_wl2_window_available_rotations_set");
}
void WindowBaseEcoreWl2::SetPreferredAngle(int angle)
{
DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetPreferredAngle, angle: %d\n", angle);
+ START_DURATION_CHECK();
ecore_wl2_window_preferred_rotation_set(mEcoreWindow, angle);
+ FINISH_DURATION_CHECK("ecore_wl2_window_preferred_rotation_set");
}
void WindowBaseEcoreWl2::SetAcceptFocus(bool accept)
{
+ START_DURATION_CHECK();
ecore_wl2_window_focus_skip_set(mEcoreWindow, !accept);
+ FINISH_DURATION_CHECK("ecore_wl2_window_focus_skip_set");
}
void WindowBaseEcoreWl2::Show()
{
if(!mVisible)
{
+ START_DURATION_CHECK();
ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
+ FINISH_DURATION_CHECK("ecore_wl2_window_geometry_set");
}
mVisible = true;
unsigned int id = mAuxiliaryHints.size();
+ START_DURATION_CHECK();
ecore_wl2_window_aux_hint_add(mEcoreWindow, static_cast<int>(id), hint.c_str(), value.c_str());
+ FINISH_DURATION_CHECK("ecore_wl2_window_aux_hint_add");
DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint.c_str(), value.c_str(), id);
mAuxiliaryHints[id - 1].second = std::string();
+ START_DURATION_CHECK();
ecore_wl2_window_aux_hint_del(mEcoreWindow, static_cast<int>(id));
+ FINISH_DURATION_CHECK("ecore_wl2_window_aux_hint_del");
DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::RemoveAuxiliaryHint: id = %d, hint = %s\n", id, mAuxiliaryHints[id - 1].first.c_str());
mAuxiliaryHints[id - 1].second = value;
+ START_DURATION_CHECK();
ecore_wl2_window_aux_hint_change(mEcoreWindow, static_cast<int>(id), value.c_str());
+ FINISH_DURATION_CHECK("ecore_wl2_window_aux_hint_change");
DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, mAuxiliaryHints[id - 1].first.c_str(), mAuxiliaryHints[id - 1].second.c_str());
return 0;
}
-Rect<int> WindowBaseEcoreWl2::RecalculateInputRect(const Rect<int>& rect)
-{
- Rect<int> newRect;
-
- if(mWindowRotationAngle == 90)
- {
- newRect.x = rect.y;
- newRect.y = mWindowPositionSize.height - (rect.x + rect.width);
- newRect.width = rect.height;
- newRect.height = rect.width;
- }
- else if(mWindowRotationAngle == 180)
- {
- newRect.x = mWindowPositionSize.width - (rect.x + rect.width);
- newRect.y = mWindowPositionSize.height - (rect.y + rect.height);
- newRect.width = rect.width;
- newRect.height = rect.height;
- }
- else if(mWindowRotationAngle == 270)
- {
- newRect.x = mWindowPositionSize.width - (rect.y + rect.height);
- newRect.y = rect.x;
- newRect.width = rect.height;
- newRect.height = rect.width;
- }
- else
- {
- newRect.x = rect.x;
- newRect.y = rect.y;
- newRect.width = rect.width;
- newRect.height = rect.height;
- }
- return newRect;
-}
-
void WindowBaseEcoreWl2::SetInputRegion(const Rect<int>& inputRegion)
{
- Rect<int> convertRegion = RecalculateInputRect(inputRegion);
+ Rect<int> convertRegion = RecalculatePositionSizeToSystem(inputRegion);
Eina_Rectangle rect;
rect.x = convertRegion.x;
rect.h = convertRegion.height;
DALI_LOG_RELEASE_INFO("%p, Set input rect (%d, %d, %d x %d)\n", mEcoreWindow, rect.x, rect.y, rect.w, rect.h);
+ START_DURATION_CHECK();
ecore_wl2_window_input_rect_set(mEcoreWindow, &rect);
+ FINISH_DURATION_CHECK("ecore_wl2_window_input_rect_set");
ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
}
{
case Dali::WindowType::NORMAL:
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::NORMAL\n");
windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
break;
}
case Dali::WindowType::NOTIFICATION:
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::NOTIFICATION\n");
windowType = ECORE_WL2_WINDOW_TYPE_NOTIFICATION;
break;
}
case Dali::WindowType::UTILITY:
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::UTILITY\n");
windowType = ECORE_WL2_WINDOW_TYPE_UTILITY;
break;
}
case Dali::WindowType::DIALOG:
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::DIALOG\n");
windowType = ECORE_WL2_WINDOW_TYPE_DIALOG;
break;
}
case Dali::WindowType::IME:
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::IME\n");
windowType = ECORE_WL2_WINDOW_TYPE_NONE;
break;
}
case Dali::WindowType::DESKTOP:
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, Dali::WindowType::DESKTOP\n");
windowType = ECORE_WL2_WINDOW_TYPE_DESKTOP;
break;
}
default:
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetType, default window type\n");
windowType = ECORE_WL2_WINDOW_TYPE_TOPLEVEL;
break;
}
}
+
+ START_DURATION_CHECK();
ecore_wl2_window_type_set(mEcoreWindow, windowType);
+ FINISH_DURATION_CHECK("ecore_wl2_window_type_set");
}
}
Dali::WindowType WindowBaseEcoreWl2::GetType() const
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::GetType(), Window (%p), DALI WindType: %d, mIsIMEWindowInitialized: %d\n", mEcoreWindow, mType, mIsIMEWindowInitialized);
return mType;
}
Dali::WindowOperationResult WindowBaseEcoreWl2::SetNotificationLevel(Dali::WindowNotificationLevel level)
{
+ START_DURATION_CHECK();
while(!mTizenPolicy)
{
wl_display_dispatch_queue(mDisplay, mEventQueue);
int notificationLevel;
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetNotificationLevel(), Window (%p), level [%d]\n", mEcoreWindow, level);
switch(level)
{
case Dali::WindowNotificationLevel::NONE:
}
default:
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Verbose, "WindowBaseEcoreWl2::SetNotificationLevel: invalid level [%d]\n", level);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetNotificationLevel(), invalid level [%d]\n", level);
notificationLevel = TIZEN_POLICY_LEVEL_DEFAULT;
break;
}
wl_display_dispatch_queue(mDisplay, mEventQueue);
count++;
}
+ FINISH_DURATION_CHECK("ecore_wl2 & wl_display");
if(!mNotificationLevelChangeDone)
{
Dali::WindowOperationResult WindowBaseEcoreWl2::SetBrightness(int brightness)
{
+ START_DURATION_CHECK();
while(!mTizenDisplayPolicy)
{
wl_display_dispatch_queue(mDisplay, mEventQueue);
wl_display_dispatch_queue(mDisplay, mEventQueue);
count++;
}
+ FINISH_DURATION_CHECK("ecore_wl2_display_flush");
if(!mBrightnessChangeDone)
{
int WindowBaseEcoreWl2::GetBrightness() const
{
+ START_DURATION_CHECK();
while(!mTizenDisplayPolicy)
{
wl_display_dispatch_queue(mDisplay, mEventQueue);
wl_display_dispatch_queue(mDisplay, mEventQueue);
count++;
}
+ FINISH_DURATION_CHECK("ecore_wl2_display_flush");
if(!mBrightnessChangeDone)
{
keyList = eina_list_append(keyList, &info);
}
+ START_DURATION_CHECK();
Eina_List* grabList = ecore_wl2_window_keygrab_list_set(mEcoreWindow, keyList);
+ FINISH_DURATION_CHECK("ecore_wl2_window_keygrab_list_set");
result.Resize(keyCount, true);
keyList = eina_list_append(keyList, &info);
}
+ START_DURATION_CHECK();
Eina_List* ungrabList = ecore_wl2_window_keygrab_list_unset(mEcoreWindow, keyList);
+ FINISH_DURATION_CHECK("ecore_wl2_window_keygrab_list_unset");
result.Resize(keyCount, true);
void WindowBaseEcoreWl2::WindowRotationCompleted(int degree, int width, int height)
{
+ START_DURATION_CHECK();
ecore_wl2_window_rotation_change_done_send(mEcoreWindow, degree, width, height);
+ FINISH_DURATION_CHECK("ecore_wl2_window_rotation_change_done_send");
}
void WindowBaseEcoreWl2::SetTransparency(bool transparent)
{
+ START_DURATION_CHECK();
ecore_wl2_window_alpha_set(mEcoreWindow, transparent);
+ FINISH_DURATION_CHECK("ecore_wl2_window_alpha_set");
}
void WindowBaseEcoreWl2::CreateWindow(PositionSize positionSize)
DALI_ASSERT_ALWAYS(0 && "Failed to get display");
}
+ START_DURATION_CHECK();
ecore_wl2_display_sync(display);
mEcoreWindow = ecore_wl2_window_new(display, NULL, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
// Set default type
ecore_wl2_window_type_set(mEcoreWindow, ECORE_WL2_WINDOW_TYPE_TOPLEVEL);
+ FINISH_DURATION_CHECK("ecore_wl2 functions");
}
void WindowBaseEcoreWl2::SetParent(WindowBase* parentWinBase, bool belowParent)
WindowBaseEcoreWl2* winBaseEcore2 = static_cast<WindowBaseEcoreWl2*>(parentWinBase);
ecoreParent = winBaseEcore2->mEcoreWindow;
}
+
+ START_DURATION_CHECK();
ecore_wl2_window_transient_parent_set(mEcoreWindow, ecoreParent, belowParent);
+ FINISH_DURATION_CHECK("ecore_wl2_window_transient_parent_set");
}
int WindowBaseEcoreWl2::CreateFrameRenderedSyncFence()
void WindowBaseEcoreWl2::SetPositionSizeWithAngle(PositionSize positionSize, int angle)
{
DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::SetPositionSizeWithAngle, angle: %d, x: %d, y: %d, w: %d, h: %d\n", angle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
+ START_DURATION_CHECK();
ecore_wl2_window_rotation_geometry_set(mEcoreWindow, angle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
+ FINISH_DURATION_CHECK("ecore_wl2_window_rotation_geometry_set");
}
void WindowBaseEcoreWl2::InitializeIme()
Ecore_Wl2_Global* global;
Ecore_Wl2_Display* ecoreWl2Display;
+ if(mIsIMEWindowInitialized)
+ {
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::InitializeIme, IME Window is already initialized\n");
+ return;
+ }
+
if(!(ecoreWl2Display = ecore_wl2_connected_display_get(NULL)))
{
DALI_LOG_ERROR("WindowBaseEcoreWl2::InitializeIme(), fail to get ecore_wl2 connected display\n");
return;
}
- DALI_LOG_RELEASE_INFO("InitializeIme: Ecore_Wl2_Display: %p, ecore wl window: %p\n", ecoreWl2Display, mEcoreWindow);
+ DALI_LOG_RELEASE_INFO("InitializeIme: Ecore_Wl2_Display: %p, ecore wl window: %p, mIsIMEWindowInitialized: %d\n", ecoreWl2Display, mEcoreWindow, mIsIMEWindowInitialized);
if(!(registry = ecore_wl2_display_registry_get(ecoreWl2Display)))
{
return;
}
+ START_DURATION_CHECK();
EINA_ITERATOR_FOREACH(globals, global)
{
#ifdef OVER_TIZEN_VERSION_7
#else
wl_input_panel_surface_set_toplevel(mWlInputPanelSurface, mWlOutput, WL_INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM);
#endif
+ FINISH_DURATION_CHECK("zwp_input_panel_surface_v1_set_toplevel");
+ mIsIMEWindowInitialized = true;
}
void WindowBaseEcoreWl2::ImeWindowReadyToRender()
DALI_LOG_ERROR("WindowBaseEcoreWl2::ImeWindowReadyToRender(), wayland input panel surface is null\n");
return;
}
+
+ START_DURATION_CHECK();
#ifdef OVER_TIZEN_VERSION_7
zwp_input_panel_surface_v1_set_ready(mWlInputPanelSurface, 1);
#else
wl_input_panel_surface_set_ready(mWlInputPanelSurface, 1);
#endif
+ FINISH_DURATION_CHECK("zwp_input_panel_surface_v1_set_ready");
}
void WindowBaseEcoreWl2::RequestMoveToServer()
return;
}
+ START_DURATION_CHECK();
ecore_wl2_window_move(mEcoreWindow, input);
+ FINISH_DURATION_CHECK("ecore_wl2_window_move");
DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestMoveToServer, starts the window[%p] is moved by server\n", mEcoreWindow);
}
ResizeLocation location = RecalculateLocationToCurrentOrientation(direction, mWindowRotationAngle);
+ START_DURATION_CHECK();
ecore_wl2_window_resize(mEcoreWindow, input, static_cast<int>(location));
+ FINISH_DURATION_CHECK("ecore_wl2_window_resize");
DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::RequestResizeToServer, starts the window[%p] is resized by server, direction:%d oriention:%d mode:%d\n", mEcoreWindow, direction, mWindowRotationAngle, location);
}
void WindowBaseEcoreWl2::EnableFloatingMode(bool enable)
{
DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::EnableFloatingMode, floating mode flag: [%p], enable [%d]\n", mEcoreWindow, enable);
+ START_DURATION_CHECK();
if(enable == true)
{
ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_TRUE);
{
ecore_wl2_window_floating_mode_set(mEcoreWindow, EINA_FALSE);
}
+ FINISH_DURATION_CHECK("ecore_wl2_window_floating_mode_set");
}
bool WindowBaseEcoreWl2::IsFloatingModeEnabled() const
void WindowBaseEcoreWl2::IncludeInputRegion(const Rect<int>& inputRegion)
{
- Rect<int> convertRegion = RecalculateInputRect(inputRegion);
+ Rect<int> convertRegion = RecalculatePositionSizeToSystem(inputRegion);
Eina_Rectangle rect;
rect.x = convertRegion.x;
rect.h = convertRegion.height;
DALI_LOG_RELEASE_INFO("%p, Add input_rect(%d, %d, %d x %d)\n", mEcoreWindow, rect.x, rect.y, rect.w, rect.h);
+ START_DURATION_CHECK();
ecore_wl2_window_input_rect_add(mEcoreWindow, &rect);
+ FINISH_DURATION_CHECK("ecore_wl2_window_input_rect_add");
ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
}
void WindowBaseEcoreWl2::ExcludeInputRegion(const Rect<int>& inputRegion)
{
- Rect<int> convertRegion = RecalculateInputRect(inputRegion);
+ Rect<int> convertRegion = RecalculatePositionSizeToSystem(inputRegion);
Eina_Rectangle rect;
rect.x = convertRegion.x;
rect.h = convertRegion.height;
DALI_LOG_RELEASE_INFO("%p, Subtract input_rect(%d, %d, %d x %d)\n", mEcoreWindow, rect.x, rect.y, rect.w, rect.h);
+ START_DURATION_CHECK();
ecore_wl2_window_input_rect_subtract(mEcoreWindow, &rect);
+ FINISH_DURATION_CHECK("ecore_wl2_window_input_rect_subtract");
+ ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
+}
+
+bool WindowBaseEcoreWl2::PointerConstraintsLock()
+{
+#ifdef OVER_TIZEN_VERSION_8
+ return ecore_wl2_window_pointer_constraints_lock_pointer(mEcoreWindow);
+#else
+ return false;
+#endif
+}
+
+bool WindowBaseEcoreWl2::PointerConstraintsUnlock()
+{
+#ifdef OVER_TIZEN_VERSION_8
+ return ecore_wl2_window_pointer_constraints_unlock_pointer(mEcoreWindow);
+#else
+ return false;
+#endif
+}
+
+void WindowBaseEcoreWl2::LockedPointerRegionSet(int32_t x, int32_t y, int32_t width, int32_t height)
+{
+#ifdef OVER_TIZEN_VERSION_8
+ ecore_wl2_window_locked_pointer_region_set(mEcoreWindow, x, y, width, height);
+ ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
+#endif
+}
+
+void WindowBaseEcoreWl2::LockedPointerCursorPositionHintSet(int32_t x, int32_t y)
+{
+#ifdef OVER_TIZEN_VERSION_8
+ ecore_wl2_window_locked_pointer_cursor_position_hint_set(mEcoreWindow, x, y);
+ ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
+#endif
+}
+
+bool WindowBaseEcoreWl2::PointerWarp(int32_t x, int32_t y)
+{
+ return ecore_wl2_window_pointer_warp(mEcoreWindow, x, y);
+}
+
+void WindowBaseEcoreWl2::CursorVisibleSet(bool visible)
+{
+#ifdef OVER_TIZEN_VERSION_8
+ ecore_wl2_window_cursor_visible_set(mEcoreWindow, visible);
+#endif
+}
+
+// Request grab key events according to the requested device subtype
+//(For now, subtype could be '0'/'11'/'12' which equals to ECORE_DEVICE_SUBCLASS_NONE/REMOCON/VIRTUAL_KEYBOARD)
+bool WindowBaseEcoreWl2::KeyboardGrab(Device::Subclass::Type deviceSubclass)
+{
+#ifdef OVER_TIZEN_VERSION_8
+ Ecore_Device_Subclass ecoreDeviceSubclass;
+ switch(deviceSubclass)
+ {
+ case Device::Subclass::NONE:
+ {
+ ecoreDeviceSubclass = ECORE_DEVICE_SUBCLASS_NONE;
+ break;
+ }
+ case Device::Subclass::REMOCON:
+ {
+ ecoreDeviceSubclass = ECORE_DEVICE_SUBCLASS_REMOCON;
+ break;
+ }
+ case Device::Subclass::VIRTUAL_KEYBOARD:
+ {
+ ecoreDeviceSubclass = ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD;
+ break;
+ }
+ default:
+ {
+ DALI_LOG_ERROR("deviceSubclass : %d type is not support, subtype could be 'NONE', 'REMOCON', 'VIRTUAL_KEYBOARD'\n");
+ return false;
+ }
+ }
+ return ecore_wl2_window_keyboard_grab(mEcoreWindow, ecoreDeviceSubclass);
+#else
+ return false;
+#endif
+}
+
+// Request ungrab key events
+bool WindowBaseEcoreWl2::KeyboardUnGrab()
+{
+#ifdef OVER_TIZEN_VERSION_8
+ return ecore_wl2_window_keyboard_ungrab(mEcoreWindow);
+#else
+ return false;
+#endif
+}
+
+void WindowBaseEcoreWl2::SetFullScreen(bool fullscreen)
+{
+ DALI_LOG_RELEASE_INFO("ecore_wl2_window_fullscreen_set, window: [%p], fullscreen [%d]\n", mEcoreWindow, fullscreen);
+ START_DURATION_CHECK();
+ ecore_wl2_window_fullscreen_set(mEcoreWindow, fullscreen);
ecore_wl2_window_commit(mEcoreWindow, EINA_TRUE);
+ FINISH_DURATION_CHECK("ecore_wl2_window_fullscreen_set");
+}
+
+bool WindowBaseEcoreWl2::GetFullScreen()
+{
+ return ecore_wl2_window_fullscreen_get(mEcoreWindow);
+}
+
+void WindowBaseEcoreWl2::SetFrontBufferRendering(bool enable)
+{
+ mIsFrontBufferRendering = enable;
+}
+
+bool WindowBaseEcoreWl2::GetFrontBufferRendering()
+{
+ return mIsFrontBufferRendering;
+}
+
+void WindowBaseEcoreWl2::SetEglWindowFrontBufferMode(bool enable)
+{
+ wl_egl_window_tizen_set_frontbuffer_mode(mEglWindow, enable);
+}
+
+void WindowBaseEcoreWl2::SetModal(bool modal)
+{
+ DALI_LOG_RELEASE_INFO("ecore_wl2_window_modal_set, window: [%p], flag [%d]\n", mEcoreWindow, modal);
+ START_DURATION_CHECK();
+ ecore_wl2_window_modal_set(mEcoreWindow, modal);
+ FINISH_DURATION_CHECK("ecore_wl2_window_modal_set");
+}
+
+bool WindowBaseEcoreWl2::IsModal()
+{
+ bool ret = ecore_wl2_window_modal_get(mEcoreWindow);
+ DALI_LOG_RELEASE_INFO("ecore_wl2_window_modal_get, window: [%p], flag [%d]\n", mEcoreWindow, ret);
+ return ret;
+}
+
+void WindowBaseEcoreWl2::SetAlwaysOnTop(bool alwaysOnTop)
+{
+ DALI_LOG_RELEASE_INFO("ecore_wl2_window_pin_mode_set, window: [%p], flag [%d]\n", mEcoreWindow, alwaysOnTop);
+ START_DURATION_CHECK();
+ ecore_wl2_window_pin_mode_set(mEcoreWindow, alwaysOnTop);
+ FINISH_DURATION_CHECK("ecore_wl2_window_pin_mode_set");
+}
+
+bool WindowBaseEcoreWl2::IsAlwaysOnTop()
+{
+ bool ret = ecore_wl2_window_pin_mode_get(mEcoreWindow);
+ DALI_LOG_RELEASE_INFO("ecore_wl2_window_pin_mode_get, window: [%p], flag [%d]\n", mEcoreWindow, ret);
+ return ret;
}
} // namespace Adaptor
projects / platform / core / uifw / dali-adaptor.git / blobdiff