Dali::Internal::Adaptor::WindowSystem::GetScreenSize(width, height);
}
+void SetGeometryHittestEnabled(bool enabled)
+{
+ Dali::Internal::Adaptor::WindowSystem::SetGeometryHittestEnabled(enabled);
+}
+
+bool IsGeometryHittestEnabled()
+{
+ return Dali::Internal::Adaptor::WindowSystem::IsGeometryHittestEnabled();
+}
+
} // namespace DevelWindowSystem
} // namespace Dali
namespace Dali
{
-
namespace DevelWindowSystem
{
-
/**
* @brief Get the screen size.
*
*/
DALI_ADAPTOR_API void GetScreenSize(int32_t& width, int32_t& height);
+/**
+ * @brief Sets the processes using geometry event propagation touch and hover events.
+ *
+ * @param[in] enabled True if the processes using geometry event propagation touch and hover events.
+ */
+DALI_ADAPTOR_API void SetGeometryHittestEnabled(bool enabled);
+
+/**
+ * @brief Queries whether the scene using geometry event propagation touch and hover events.
+ *
+ * @return True if the scene using geometry event propagation touch and hover events.
+ */
+DALI_ADAPTOR_API bool IsGeometryHittestEnabled();
+
} // namespace DevelWindowSystem
} // namespace Dali
CreateRenderTarget();
OnAdaptorSet(adaptor);
+
+ // Scene is newly created. Let we increase resize counter
+ mAdaptor->IncreaseSurfaceResizeCounter();
}
void SceneHolder::CreateRenderTarget()
mAdaptor->ProcessCoreEvents();
}
+void SceneHolder::SetGeometryHittestEnabled(bool enabled)
+{
+ mScene.SetGeometryHittestEnabled(enabled);
+}
+
+bool SceneHolder::IsGeometryHittestEnabled()
+{
+ return mScene.IsGeometryHittestEnabled();
+}
+
void SceneHolder::AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
{
mScene.AddFrameRenderedCallback(std::move(callback), frameId);
void FeedHoverEvent(Dali::Integration::Point& point);
/**
+ * @copydoc Dali::Integration::SceneHolder::SetGeometryHittestEnabled
+ */
+ void SetGeometryHittestEnabled(bool enabled);
+
+ /**
+ * @copydoc Dali::Integration::SceneHolder::IsGeometryHittestEnabled
+ */
+ bool IsGeometryHittestEnabled();
+
+ /**
* @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
*
* @param[in] callback The function to call
GetImplementation(*this).FeedHoverEvent(convertedPoint);
}
+void SceneHolder::SetGeometryHittestEnabled(bool enabled)
+{
+ GetImplementation(*this).SetGeometryHittestEnabled(enabled);
+}
+
+bool SceneHolder::IsGeometryHittestEnabled()
+{
+ return GetImplementation(*this).IsGeometryHittestEnabled();
+}
+
RenderTaskList SceneHolder::GetRenderTaskList()
{
return GetImplementation(*this).GetRenderTaskList();
void FeedHoverEvent(Dali::TouchPoint& point);
/**
+ * @brief Sets whether the processes using geometry event propagation touch and hover events.
+ *
+ * @param[in] enabled True if the processes using geometry event propagation touch and hover events.
+ */
+ void SetGeometryHittestEnabled(bool enabled);
+
+ /**
+ * @brief Queries whether the scene using geometry event propagation touch and hover events.
+ *
+ * @return True if the scene using geometry event propagation touch and hover events.
+ */
+ bool IsGeometryHittestEnabled();
+
+ /**
* @brief Retrieves the list of render-tasks.
* @return A valid handle to a RenderTaskList
*/
ProcessCoreEvents();
}
+void Adaptor::IncreaseSurfaceResizeCounter()
+{
+ // Nofify surface resizing before flushing event queue
+ if(mThreadController)
+ {
+ mThreadController->ResizeSurface();
+ }
+}
+
void Adaptor::NotifySceneCreated()
{
GetCore().SceneCreated();
void SurfaceResizeComplete(Dali::RenderSurfaceInterface* surface, SurfaceSize surfaceSize);
/**
+ * @brief Increase surface resize completed counter.
+ * This API will be ignored if thread controller is not exist.
+ */
+ void IncreaseSurfaceResizeCounter();
+
+ /**
* Sets layout direction of root by system language
* @param[in] locale System locale
*/
auto numberOfPrecompiledShader = precompiledShader->shaderCount;
for(int i = 0; i < numberOfPrecompiledShader; ++i)
{
- auto vertexShader = graphics.GetController().GetGlAbstraction().GetVertexShaderPrefix() + std::string(precompiledShader->vertexPrefix[i].data()) + std::string(precompiledShader->vertexShader.data());
+ auto vertexShader = graphics.GetController().GetGlAbstraction().GetVertexShaderPrefix() + std::string(precompiledShader->vertexPrefix[i].data()) + std::string(precompiledShader->vertexShader.data());
auto fragmentShader = graphics.GetController().GetGlAbstraction().GetFragmentShaderPrefix() + std::string(precompiledShader->fragmentPrefix[i].data()) + std::string(precompiledShader->fragmentShader.data());
PreCompileShader(std::move(vertexShader), std::move(fragmentShader));
}
TRACE_UPDATE_RENDER_SCOPE("DALI_RENDER_SCENE");
Integration::RenderStatus windowRenderStatus;
- const bool sceneSurfaceResized = scene.IsSurfaceRectChanged();
+ const uint32_t sceneSurfaceResized = scene.GetSurfaceRectChangedCount();
// clear previous frame damaged render items rects, buffer history is tracked on surface level
mDamagedRects.clear();
Rect<int> clippingRect; // Empty for fbo rendering
// Switch to the context of the surface, merge damaged areas for previous frames
- windowSurface->PreRender(sceneSurfaceResized, mDamagedRects, clippingRect); // Switch GL context
+ windowSurface->PreRender(sceneSurfaceResized > 0u, mDamagedRects, clippingRect); // Switch GL context
// Render the surface
mCore.RenderScene(windowRenderStatus, scene, false, clippingRect);
// Buffer swapping now happens when the surface render target is presented.
// If surface is resized, the surface resized count is decreased.
- if(DALI_UNLIKELY(sceneSurfaceResized))
+ if(DALI_UNLIKELY(sceneSurfaceResized > 0u))
{
- SurfaceResized();
+ SurfaceResized(sceneSurfaceResized);
}
}
}
mSurfaceSemaphore.Release(1);
}
-void CombinedUpdateRenderController::SurfaceResized()
+void CombinedUpdateRenderController::SurfaceResized(uint32_t resizedCount)
{
ConditionalWait::ScopedLock lock(mUpdateRenderThreadWaitCondition);
- if(mSurfaceResized)
+
+ if(mSurfaceResized >= resizedCount)
+ {
+ mSurfaceResized -= resizedCount;
+ }
+ else
{
- mSurfaceResized--;
+ mSurfaceResized = 0u;
}
}
namespace Internal
{
-
namespace Adaptor
{
class AdaptorInternalServices;
* Called by the Update/Render thread after a surface has been resized.
*
* This will lock the mutex in mEventThreadWaitCondition
+ * @param[in] resizedCount The number of resized count for given surface.
*/
- void SurfaceResized();
+ void SurfaceResized(uint32_t resizedCount);
/**
* PreCompile shaders for launching time
///< Ensures we do not go to sleep if we have not processed the most recent update-request.
volatile unsigned int mUseElapsedTimeAfterWait; ///< Whether we should use the elapsed time after waiting (set by the event-thread, read by the update-render-thread).
- volatile unsigned int mIsPreCompileCancelled; ///< Whether we need to do precompile shader.
+ volatile unsigned int mIsPreCompileCancelled; ///< Whether we need to do precompile shader.
Dali::RenderSurfaceInterface* volatile mNewSurface; ///< Will be set to the new-surface if requested (set by the event-thread, read & cleared by the update-render thread).
Dali::RenderSurfaceInterface* volatile mDeletedSurface; ///< Will be set to the deleted surface if requested (set by the event-thread, read & cleared by the update-render thread).
Ecore_Wl2_Event_Dnd_Motion* ev = reinterpret_cast<Ecore_Wl2_Event_Dnd_Motion*>(event);
Dali::DragAndDrop::DragEvent dragEvent;
+ dragEvent.SetMimeType((const char*)eina_array_data_get(ecore_wl2_offer_mimes_get(ev->offer), 0));
+
Dali::Vector2 curPosition(ev->x, ev->y);
for(std::size_t i = 0; i < mDropTargets.size(); i++)
hash ^= std::hash<uint32_t>{}(attr.location);
}
- auto& gl = *mController.GetGL();
- auto iter = mProgramVAOMap.find(program);
+ auto& gl = *mController.GetGL();
+
+ if(DALI_UNLIKELY(!mDiscardedVAOList.empty()))
+ {
+ gl.DeleteVertexArrays(static_cast<Dali::GLsizei>(mDiscardedVAOList.size()), mDiscardedVAOList.data());
+ mDiscardedVAOList.clear();
+ }
+
+ auto iter = mProgramVAOMap.find(program);
if(iter != mProgramVAOMap.end())
{
auto attributeIter = iter->second.find(hash);
std::unordered_map<const GLES::ProgramImpl*, std::map<std::size_t, uint32_t>> mProgramVAOMap; ///< GL program-VAO map
uint32_t mProgramVAOCurrentState{0u}; ///< Currently bound VAO
GLStateCache mGlStateCache{}; ///< GL status cache
+ std::vector<Dali::GLuint> mDiscardedVAOList{};
bool mGlContextCreated{false}; ///< True if the OpenGL context has been created
bool mVertexBuffersChanged{true}; ///< True if BindVertexBuffers changed any buffer bindings
for(auto& attributeHashPair : iter->second)
{
auto vao = attributeHashPair.second;
- gl->DeleteVertexArrays(1, &vao);
+
+ // Do not delete vao now. (Since Context might not be current.)
+ mImpl->mDiscardedVAOList.emplace_back(vao);
if(mImpl->mProgramVAOCurrentState == vao)
{
mImpl->mProgramVAOCurrentState = 0u;
}
}
+
+ // Clear cached Vertex buffer.
+ mImpl->mCurrentVertexBufferBindings.clear();
+
mImpl->mProgramVAOMap.erase(iter);
}
}
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
#include <dali/internal/window-system/common/window-system.h>
// EXTERNAL_HEADERS
+#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/adaptor-framework/android/android-framework.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
#include <dali/integration-api/debug.h>
namespace Dali
{
namespace WindowSystem
{
+namespace
+{
+static bool gGeometryHittest = false;
+}
+
void Initialize()
{
}
return false;
}
+void SetGeometryHittestEnabled(bool enable)
+{
+ DALI_LOG_RELEASE_INFO("GeometryHittest : %d \n", enable);
+ gGeometryHittest = enable;
+ if(gGeometryHittest)
+ {
+ Dali::SceneHolderList sceneHolders = Dali::Adaptor::Get().GetSceneHolders();
+ for(auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter)
+ {
+ if(*iter)
+ {
+ (*iter).SetGeometryHittestEnabled(enable);
+ }
+ }
+ }
+}
+
+bool IsGeometryHittestEnabled()
+{
+ return gGeometryHittest;
+}
+
} // namespace WindowSystem
} // namespace Adaptor
Window* Window::New(Any surface, const std::string& name, const std::string& className, const WindowData& windowData)
{
- Window* window = new Window();
- window->mIsTransparent = windowData.GetTransparency();
+ Window* window = new Window();
+ window->mIsTransparent = windowData.GetTransparency();
window->mIsFrontBufferRendering = windowData.GetFrontBufferRendering();
window->Initialize(surface, windowData.GetPositionSize(), name, className, windowData.GetWindowType());
return window;
OnAccessibilityDisabled();
}
+ if(mScene)
+ {
+ bool isGeometry = Dali::Internal::Adaptor::WindowSystem::IsGeometryHittestEnabled();
+ mScene.SetGeometryHittestEnabled(isGeometry);
+ }
+
// If you call the 'Show' before creating the adaptor, the application cannot know the app resource id.
// The show must be called after the adaptor is initialized.
Show();
*/
bool GetKeyboardVerticalRepeatInfo(float& rate, float& delay);
+/**
+ * @brief Sets whether the processes using geometry event propagation touch and hover events.
+ *
+ * @param[in] enabled True if the processes using geometry event propagation touch and hover events.
+ */
+void SetGeometryHittestEnabled(bool enabled);
+
+/**
+ * @brief Queries whether the scene using geometry event propagation touch and hover events.
+ *
+ * @return True if the scene using geometry event propagation touch and hover events.
+ */
+bool IsGeometryHittestEnabled();
+
} // namespace WindowSystem
/**
// INTERNAL HEADERS
#include <dali/internal/window-system/common/window-system.h>
+// EXTERNAL_HEADERS
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
+#include <dali/integration-api/debug.h>
+
namespace Dali::Internal::Adaptor::WindowSystem
{
+namespace
+{
+static bool gGeometryHittest = false;
+} // unnamed namespace
void Initialize()
{
return false;
}
-} // namespace Dali::Internal::Adaptor::WindowSystem
+void SetGeometryHittestEnabled(bool enable)
+{
+ DALI_LOG_RELEASE_INFO("GeometryHittest : %d \n", enable);
+ gGeometryHittest = enable;
+ if(gGeometryHittest)
+ {
+ Dali::SceneHolderList sceneHolders = Dali::Adaptor::Get().GetSceneHolders();
+ for(auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter)
+ {
+ if(*iter)
+ {
+ (*iter).SetGeometryHittestEnabled(enable);
+ }
+ }
+ }
+}
+bool IsGeometryHittestEnabled()
+{
+ return gGeometryHittest;
+}
+
+} // namespace Dali::Internal::Adaptor::WindowSystem
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
// EXTERNAL_HEADERS
#include <Ecore_Wayland.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
+#include <dali/integration-api/debug.h>
namespace Dali
{
{
namespace WindowSystem
{
+namespace
+{
+static bool gGeometryHittest = false;
+} // unnamed namespace
+
void Initialize()
{
ecore_wl_init(NULL);
return false;
}
+void SetGeometryHittestEnabled(bool enable)
+{
+ DALI_LOG_RELEASE_INFO("GeometryHittest : %d \n", enable);
+ gGeometryHittest = enable;
+ if(gGeometryHittest)
+ {
+ Dali::SceneHolderList sceneHolders = Dali::Adaptor::Get().GetSceneHolders();
+ for(auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter)
+ {
+ if(*iter)
+ {
+ (*iter).SetGeometryHittestEnabled(enable);
+ }
+ }
+ }
+}
+
+bool IsGeometryHittestEnabled()
+{
+ return gGeometryHittest;
+}
+
} // namespace WindowSystem
} // namespace Adaptor
{
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;
if(focusInEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusIn\n");
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnFocusIn, Window (%p) EcoreEventWindowFocusIn\n", mEcoreWindow);
mFocusChangedSignal.Emit(true);
}
if(focusOutEvent->window == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window EcoreEventWindowFocusOut\n");
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnFocusOut, Window (%p) EcoreEventWindowFocusOut\n", mEcoreWindow);
mFocusChangedSignal.Emit(false);
}
if(transformEvent->output == ecore_wl2_window_output_find(mEcoreWindow))
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventOutputTransform\n", mEcoreWindow);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnOutputTransform, Window (%p) EcoreEventOutputTransform\n", mEcoreWindow);
mScreenRotationAngle = GetScreenRotationAngle();
if(ignoreTransformEvent->win == mEcoreWindow)
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnIgnoreOutputTransform, Window (%p) EcoreEventIgnoreOutputTransform\n", mEcoreWindow);
mScreenRotationAngle = GetScreenRotationAngle();
if(ev->win == static_cast<unsigned int>(ecore_wl2_window_id_get(mEcoreWindow)))
{
- 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;
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_Detent_Rotate* detentEvent = static_cast<Ecore_Event_Detent_Rotate*>(event);
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::Concise, "WindowBaseEcoreWl2::OnDetentRotation\n");
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnDetentRotation, Window (%p)\n", mEcoreWindow);
int32_t clockwise = (detentEvent->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) ? 1 : -1;
void WindowBaseEcoreWl2::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
{
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::OnTransitionEffectEvent, Window (%p)\n", mEcoreWindow);
mTransitionEffectEventSignal.Emit(state, type);
}
Ecore_Wl2_Event_Aux_Message* message = static_cast<Ecore_Wl2_Event_Aux_Message*>(event);
if(message)
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, key:%s, value:%s \n", message->key, message->val);
+ 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;
void* data;
EINA_LIST_FOREACH(message->options, l, data)
{
- DALI_LOG_INFO(gWindowBaseLogFilter, Debug::General, "WindowBaseEcoreWl2::OnEcoreEventWindowAuxiliaryMessage, option: %s\n", (char*)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);
}
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("window(%p) has been moved by server[%d, %d]\n", mEcoreWindow, 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);
}
}
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("window(%p) has been resized by server[%d, %d]\n", mEcoreWindow, 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);
}
}
Dali::WindowType WindowBaseEcoreWl2::GetType() const
{
- DALI_LOG_RELEASE_INFO("GetType, DALI WindType: %d, mIsIMEWindowInitialized: %d\n", mType, mIsIMEWindowInitialized);
+ DALI_LOG_RELEASE_INFO("WindowBaseEcoreWl2::GetType(), Window (%p), DALI WindType: %d, mIsIMEWindowInitialized: %d\n", mEcoreWindow, mType, mIsIMEWindowInitialized);
return mType;
}
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;
}
// EXTERNAL_HEADERS
#include <Ecore_Wl2.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
#include <dali/integration-api/debug.h>
// INTERNAL HEADERS
{
namespace
{
-static int32_t gScreenWidth = 0;
-static int32_t gScreenHeight = 0;
+static int32_t gScreenWidth = 0;
+static int32_t gScreenHeight = 0;
+static bool gGeometryHittest = false;
} // unnamed namespace
void Initialize()
#endif
}
+void SetGeometryHittestEnabled(bool enable)
+{
+ DALI_LOG_RELEASE_INFO("GeometryHittest : %d \n", enable);
+ gGeometryHittest = enable;
+ if(gGeometryHittest)
+ {
+ Dali::SceneHolderList sceneHolders = Dali::Adaptor::Get().GetSceneHolders();
+ for(auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter)
+ {
+ if(*iter)
+ {
+ (*iter).SetGeometryHittestEnabled(enable);
+ }
+ }
+ }
+}
+
+bool IsGeometryHittestEnabled()
+{
+ return gGeometryHittest;
+}
+
} // namespace WindowSystem
} // namespace Adaptor
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
#include <dali/internal/window-system/common/window-system.h>
// EXTERNAL_HEADERS
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
+#include <dali/integration-api/debug.h>
#include <dali/internal/system/linux/dali-ecore-x.h>
namespace Dali
{
namespace WindowSystem
{
+namespace
+{
+static bool gGeometryHittest = false;
+} // unnamed namespace
+
void Initialize()
{
ecore_x_init(NULL);
return false;
}
+void SetGeometryHittestEnabled(bool enable)
+{
+ DALI_LOG_RELEASE_INFO("GeometryHittest : %d \n", enable);
+ gGeometryHittest = enable;
+ if(gGeometryHittest)
+ {
+ Dali::SceneHolderList sceneHolders = Dali::Adaptor::Get().GetSceneHolders();
+ for(auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter)
+ {
+ if(*iter)
+ {
+ (*iter).SetGeometryHittestEnabled(enable);
+ }
+ }
+ }
+}
+
+bool IsGeometryHittestEnabled()
+{
+ return gGeometryHittest;
+}
+
} // namespace WindowSystem
} // namespace Adaptor
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
// EXTERNAL HEADERS
#include <Windows.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
+#include <dali/integration-api/debug.h>
namespace Dali
{
{
namespace WindowSystem
{
+namespace
+{
+static bool gGeometryHittest = false;
+} // unnamed namespace
+
void Initialize()
{
}
return false;
}
+void SetGeometryHittestEnabled(bool enable)
+{
+ DALI_LOG_RELEASE_INFO("GeometryHittest : %d \n", enable);
+ gGeometryHittest = enable;
+ if(gGeometryHittest)
+ {
+ Dali::SceneHolderList sceneHolders = Dali::Adaptor::Get().GetSceneHolders();
+ for(auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter)
+ {
+ if(*iter)
+ {
+ (*iter).SetGeometryHittestEnabled(enable);
+ }
+ }
+ }
+}
+
+bool IsGeometryHittestEnabled()
+{
+ return gGeometryHittest;
+}
+
} // namespace WindowSystem
} // namespace Adaptor
// INTERNAL HEADERS
#include <dali/devel-api/adaptor-framework/keyboard.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
+#include <dali/integration-api/debug.h>
#include <dali/internal/system/common/file-descriptor-monitor.h>
#include <dali/internal/system/common/system-factory.h>
#include <dali/internal/window-system/common/window-system.h>
namespace WindowSystem
{
static WindowSystemX* gWindowSystem{nullptr};
+static bool gGeometryHittest = false;
/**
* Initialize the window system (currently run from the first window that gets created)
void WindowSystemX::Hide(::Window window)
{
- Window rootWindow = window;
+ ::Window rootWindow = window;
int x, y;
unsigned int width, height, border, depth;
if(ScreenCount(mImpl->mDisplay) == 1)
return false;
}
+void SetGeometryHittestEnabled(bool enable)
+{
+ DALI_LOG_RELEASE_INFO("GeometryHittest : %d \n", enable);
+ gGeometryHittest = enable;
+ if(gGeometryHittest)
+ {
+ Dali::SceneHolderList sceneHolders = Dali::Adaptor::Get().GetSceneHolders();
+ for(auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter)
+ {
+ if(*iter)
+ {
+ (*iter).SetGeometryHittestEnabled(enable);
+ }
+ }
+ }
+}
+
+bool IsGeometryHittestEnabled()
+{
+ return gGeometryHittest;
+}
+
} // namespace WindowSystem
} // namespace Adaptor
{
const unsigned int ADAPTOR_MAJOR_VERSION = 2;
const unsigned int ADAPTOR_MINOR_VERSION = 3;
-const unsigned int ADAPTOR_MICRO_VERSION = 2;
+const unsigned int ADAPTOR_MICRO_VERSION = 3;
const char* const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-adaptor
Summary: The DALi Tizen Adaptor
-Version: 2.3.2
+Version: 2.3.3
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-adaptor.git / commitdiff