/*
- * 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.
// INTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/trace.h>
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/common/scene-impl.h>
#include <dali/internal/event/events/gesture-requests.h>
{
namespace
{
-constexpr uint32_t DEFAULT_MAXIMUM_ALLOWED_TIME = 500u;
+DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_PERFORMANCE_MARKER, false);
+constexpr uint32_t DEFAULT_MAXIMUM_ALLOWED_TIME = 330u;
+constexpr uint32_t DEFAULT_RECOGNIZER_TIME = 330u;
/**
* Creates a TapGesture and asks the specified detector to emit its detected signal.
tap->SetNumberOfTouches(tapEvent.numberOfTouches);
tap->SetScreenPoint(tapEvent.point);
tap->SetLocalPoint(localPoint);
- tap->SetGestureSourceType(tapEvent.gestureSourceType);
+ tap->SetSourceType(tapEvent.sourceType);
+ tap->SetSourceData(tapEvent.sourceData);
+
+ DALI_TRACE_BEGIN_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_EMIT_TAP_GESTURE_SIGNAL", [&](std::ostringstream& oss) {
+ oss << "[" << gestureDetectors.size() << "]";
+ });
Dali::Actor actorHandle(actor);
const GestureDetectorContainer::const_iterator endIter = gestureDetectors.end();
{
static_cast<TapGestureDetector*>(*iter)->EmitTapGestureSignal(actorHandle, Dali::TapGesture(tap.Get()));
}
+
+ DALI_TRACE_END_WITH_MESSAGE_GENERATOR(gTraceFilter, "DALI_EMIT_TAP_GESTURE_SIGNAL", [&](std::ostringstream& oss) {
+ oss << "[" << gestureDetectors.size() << "]";
+ });
}
} // unnamed namespace
TapGestureProcessor::TapGestureProcessor()
: GestureProcessor(GestureType::TAP),
mTapGestureDetectors(),
- mMinTapsRequired(1),
- mMaxTapsRequired(1),
mMinTouchesRequired(1),
mMaxTouchesRequired(1),
mCurrentTapEvent(nullptr),
mPossibleProcessed(false),
- mMaximumAllowedTime(DEFAULT_MAXIMUM_ALLOWED_TIME)
+ mMaximumAllowedTime(DEFAULT_MAXIMUM_ALLOWED_TIME),
+ mRecognizerTime(DEFAULT_RECOGNIZER_TIME)
{
}
void TapGestureProcessor::Process(Scene& scene, const TapGestureEvent& tapEvent)
{
+ DALI_TRACE_SCOPE(gTraceFilter, "DALI_PROCESS_TAP_GESTURE");
switch(tapEvent.state)
{
case GestureState::POSSIBLE:
{
// Do a hit test and if an actor has been hit then save to see if tap event is still valid on a tap( same actor being hit )
HitTestAlgorithm::Results hitTestResults;
- if(HitTest(scene, tapEvent.point, hitTestResults))
+ if(GetFeededActor())
+ {
+ SetActor(GetFeededActor());
+ mCurrentTapActor.SetActor(GetCurrentGesturedActor());
+
+ // Indicate that we've processed a touch down. Bool should be sufficient as a change in actor will result in a cancellation
+ mPossibleProcessed = true;
+ }
+ else if(HitTest(scene, tapEvent.point, hitTestResults))
{
SetActor(&GetImplementation(hitTestResults.actor));
mCurrentTapActor.SetActor(GetCurrentGesturedActor());
{
// Ensure that we're processing a hit on the current actor and that we've already processed a touch down
HitTestAlgorithm::Results hitTestResults;
- if(GetCurrentGesturedActor() && HitTest(scene, tapEvent.point, hitTestResults) && mPossibleProcessed)
+ if(GetCurrentGesturedActor())
{
- // Check that this actor is still the one that was used for the last touch down ?
- if(mCurrentTapActor.GetActor() == &GetImplementation(hitTestResults.actor))
+ if(GetFeededActor())
{
- mCurrentTapEvent = &tapEvent;
- ProcessAndEmit(hitTestResults);
+ hitTestResults.actor = Dali::Actor(GetFeededActor());
+ hitTestResults.renderTask = GetFeededRenderTask();
+ // Check that this actor is still the one that was used for the last touch down ?
+ if(mCurrentTapActor.GetActor() == &GetImplementation(hitTestResults.actor))
+ {
+ mCurrentTapEvent = &tapEvent;
+ ProcessAndEmitActor(hitTestResults, GetFeededGestureDetector());
+ }
+ mCurrentTapEvent = nullptr;
+ mPossibleProcessed = false;
+ }
+ else if(HitTest(scene, tapEvent.point, hitTestResults) && mPossibleProcessed)
+ {
+ // Check that this actor is still the one that was used for the last touch down ?
+ if(mCurrentTapActor.GetActor() == &GetImplementation(hitTestResults.actor))
+ {
+ mCurrentTapEvent = &tapEvent;
+ ProcessAndEmit(hitTestResults);
+ }
+ mCurrentTapEvent = nullptr;
+ mPossibleProcessed = false;
}
- mCurrentTapEvent = nullptr;
- mPossibleProcessed = false;
}
break;
}
mTapGestureDetectors.push_back(gestureDetector);
- const unsigned int minTapsRequired = gestureDetector->GetMinimumTapsRequired();
- const unsigned int maxTapsRequired = gestureDetector->GetMaximumTapsRequired();
const unsigned int touchesRequired = gestureDetector->GetTouchesRequired();
- DALI_ASSERT_ALWAYS(minTapsRequired <= maxTapsRequired && "Minimum taps requested is greater than the maximum requested");
-
if(firstRegistration)
{
// If this is the first tap gesture detector that has been added, then our minimum and maximum
// requirements are the same as each other.
- mMinTapsRequired = minTapsRequired;
- mMaxTapsRequired = maxTapsRequired;
mMinTouchesRequired = mMaxTouchesRequired = touchesRequired;
TapGestureRequest request;
- request.minTaps = mMinTapsRequired;
- request.maxTaps = mMaxTapsRequired;
request.minTouches = mMinTouchesRequired;
request.maxTouches = mMaxTouchesRequired;
Size size = scene.GetSize();
- mGestureRecognizer = new TapGestureRecognizer(*this, Vector2(size.width, size.height), static_cast<const TapGestureRequest&>(request), mMaximumAllowedTime);
+ mGestureRecognizer = new TapGestureRecognizer(*this, Vector2(size.width, size.height), static_cast<const TapGestureRequest&>(request), mMaximumAllowedTime, mRecognizerTime);
}
else
{
// This is quicker than calling UpdateDetection as there is no need to iterate through the container
- unsigned int minTaps = mMinTapsRequired < minTapsRequired ? mMinTapsRequired : minTapsRequired;
- unsigned int maxTaps = mMaxTapsRequired > maxTapsRequired ? mMaxTapsRequired : maxTapsRequired;
unsigned int minTouches = mMinTouchesRequired < touchesRequired ? mMinTouchesRequired : touchesRequired;
unsigned int maxTouches = mMaxTouchesRequired > touchesRequired ? mMaxTouchesRequired : touchesRequired;
- if((minTaps != mMinTapsRequired) || (maxTaps != mMaxTapsRequired) ||
- (minTouches != mMinTouchesRequired) || (maxTouches != mMaxTouchesRequired))
+ if((minTouches != mMinTouchesRequired) || (maxTouches != mMaxTouchesRequired))
{
TapGestureRequest request;
- request.minTaps = mMinTapsRequired = minTaps;
- request.maxTaps = mMaxTapsRequired = maxTaps;
request.minTouches = mMinTouchesRequired = minTouches;
request.maxTouches = mMaxTouchesRequired = maxTouches;
void TapGestureProcessor::GestureDetectorUpdated(TapGestureDetector* gestureDetector)
{
- DALI_ASSERT_DEBUG(find(mTapGestureDetectors.begin(), mTapGestureDetectors.end(), gestureDetector) != mTapGestureDetectors.end());
-
- const unsigned int minTapsRequired = gestureDetector->GetMinimumTapsRequired();
- const unsigned int maxTapsRequired = gestureDetector->GetMaximumTapsRequired();
-
- DALI_ASSERT_ALWAYS(minTapsRequired <= maxTapsRequired && "Minimum taps requested is greater than the maximum requested");
-
- UpdateDetection();
+ // Nothing to do.
}
void TapGestureProcessor::SetMaximumAllowedTime(uint32_t time)
}
}
+uint32_t TapGestureProcessor::GetMaximumAllowedTime() const
+{
+ return mMaximumAllowedTime;
+}
+
+void TapGestureProcessor::SetRecognizerTime(uint32_t time)
+{
+ if(time == 0u)
+ {
+ DALI_LOG_WARNING("RecognizerTime must be greater than zero.");
+ return;
+ }
+ if(mRecognizerTime != time)
+ {
+ mRecognizerTime = time;
+
+ if(mGestureRecognizer)
+ {
+ TapGestureRecognizer* tapRecognizer = dynamic_cast<TapGestureRecognizer*>(mGestureRecognizer.Get());
+ if(tapRecognizer)
+ {
+ tapRecognizer->SetRecognizerTime(time);
+ }
+ }
+ }
+}
+
void TapGestureProcessor::UpdateDetection()
{
DALI_ASSERT_DEBUG(!mTapGestureDetectors.empty());
- unsigned int minTaps = UINT_MAX;
- unsigned int maxTaps = 0;
unsigned int minTouches = UINT_MAX;
unsigned int maxTouches = 0;
if(detector)
{
- const unsigned int minTapsRequired = detector->GetMinimumTapsRequired();
- const unsigned int maxTapsRequired = detector->GetMaximumTapsRequired();
const unsigned int touchesRequired = detector->GetTouchesRequired();
- minTaps = minTapsRequired < minTaps ? minTapsRequired : minTaps;
- maxTaps = maxTapsRequired > maxTaps ? maxTapsRequired : maxTaps;
minTouches = touchesRequired < minTouches ? touchesRequired : minTouches;
maxTouches = touchesRequired > maxTouches ? touchesRequired : maxTouches;
}
}
- if((minTaps != mMinTapsRequired) || (maxTaps != mMaxTapsRequired) ||
- (minTouches != mMinTouchesRequired) || (maxTouches != mMaxTouchesRequired))
+ if((minTouches != mMinTouchesRequired) || (maxTouches != mMaxTouchesRequired))
{
TapGestureRequest request;
- request.minTaps = mMinTapsRequired = minTaps;
- request.maxTaps = mMaxTapsRequired = maxTaps;
request.minTouches = mMinTouchesRequired = minTouches;
request.maxTouches = mMaxTouchesRequired = maxTouches;
projects / platform / core / uifw / dali-core.git / blobdiff