dali/internal/event/events/wheel-event-processor.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/events/wheel-event-processor.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/events/wheel-event.h>
  23
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/integration-api/events/wheel-event-integ.h>
  26 #include <dali/internal/event/actors/actor-impl.h>
  27 #include <dali/internal/event/common/scene-impl.h>
  28 #include <dali/internal/event/events/hit-test-algorithm-impl.h>
  29 #include <dali/internal/event/events/wheel-event-impl.h>
  30 #include <dali/public-api/math/vector2.h>
  31
  32 namespace Dali
  33 {
  34 namespace Internal
  35 {
  36 namespace
  37 {
  38 #if defined(DEBUG_ENABLED)
  39 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WHEEL_PROCESSOR");
  40 #endif
  41
  42 /**
  43  *  Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
  44  */
  45 Dali::Actor EmitWheelSignals(Dali::Actor actor, const Dali::WheelEvent& event)
  46 {
  47   Dali::Actor consumedActor;
  48
  49   if(actor)
  50   {
  51     Dali::Actor oldParent(actor.GetParent());
  52
  53     Actor& actorImpl(GetImplementation(actor));
  54
  55     bool consumed(false);
  56
  57     // Only do the conversion and emit the signal if the actor's wheel signal has connections.
  58     if(actorImpl.GetWheelEventRequired())
  59     {
  60       // Emit the signal to the parent
  61       consumed = actorImpl.EmitWheelEventSignal(event);
  62     }
  63
  64     if(consumed)
  65     {
  66       // One of this actor's listeners has consumed the event so set this actor as the consumed actor.
  67       consumedActor = Dali::Actor(&actorImpl);
  68     }
  69     else
  70     {
  71       // The actor may have been removed/reparented during the signal callbacks.
  72       Dali::Actor parent = actor.GetParent();
  73
  74       if(parent &&
  75          (parent == oldParent))
  76       {
  77         // One of the actor's parents may consumed the event and they should be set as the consumed actor.
  78         consumedActor = EmitWheelSignals(parent, event);
  79       }
  80     }
  81   }
  82
  83   return consumedActor;
  84 }
  85
  86 /**
  87  * The function to be used in the hit-test algorithm to check whether the actor is wheelable.
  88  */
  89 bool IsActorWheelableFunction(Dali::Actor actor, Dali::HitTestAlgorithm::TraverseType type)
  90 {
  91   bool hittable = false;
  92
  93   switch(type)
  94   {
  95     case Dali::HitTestAlgorithm::CHECK_ACTOR:
  96     {
  97       if(GetImplementation(actor).GetWheelEventRequired() && // Does the Application or derived actor type require a wheel event?
  98          GetImplementation(actor).IsHittable())
  99       {
 100         hittable = true;
 101       }
 102       break;
 103     }
 104     case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
 105     {
 106       if(actor.GetProperty<bool>(Dali::Actor::Property::VISIBLE)) // Actor is visible, if not visible then none of its children are visible.
 107       {
 108         hittable = true;
 109       }
 110       break;
 111     }
 112     default:
 113     {
 114       break;
 115     }
 116   }
 117
 118   return hittable;
 119 };
 120
 121 } // unnamed namespace
 122
 123 WheelEventProcessor::WheelEventProcessor(Scene& scene)
 124 : mScene(scene)
 125 {
 126 }
 127
 128 WheelEventProcessor::~WheelEventProcessor() = default;
 129
 130 void WheelEventProcessor::ProcessWheelEvent(const Integration::WheelEvent& event)
 131 {
 132   WheelEventPtr    wheelEvent = WheelEvent::New(static_cast<Dali::WheelEvent::Type>(event.type), event.direction, event.modifiers, event.point, event.delta, event.timeStamp);
 133   Dali::WheelEvent wheelEventHandle(wheelEvent.Get());
 134
 135   if(wheelEvent->GetType() == Dali::WheelEvent::MOUSE_WHEEL)
 136   {
 137     Dali::HitTestAlgorithm::Results hitTestResults;
 138     HitTestAlgorithm::HitTest(mScene.GetSize(), mScene.GetRenderTaskList(), mScene.GetLayerList(), event.point, hitTestResults, IsActorWheelableFunction);
 139
 140     DALI_LOG_INFO(gLogFilter, Debug::General, "  Screen(%.0f, %.0f), HitActor(%p, %s), Local(%.2f, %.2f)\n", event.point.x, event.point.y, (hitTestResults.actor ? reinterpret_cast<void*>(&hitTestResults.actor.GetBaseObject()) : NULL), (hitTestResults.actor ? hitTestResults.actor.GetProperty<std::string>(Dali::Actor::Property::NAME).c_str() : ""), hitTestResults.actorCoordinates.x, hitTestResults.actorCoordinates.y);
 141
 142     // Recursively deliver events to the actor and its parents, until the event is consumed or the stage is reached.
 143     Dali::Actor consumedActor = EmitWheelSignals(hitTestResults.actor, wheelEventHandle);
 144
 145     DALI_LOG_INFO(gLogFilter, Debug::Concise, "HitActor:      (%p) %s\n", hitTestResults.actor ? reinterpret_cast<void*>(&hitTestResults.actor.GetBaseObject()) : NULL, hitTestResults.actor ? hitTestResults.actor.GetProperty<std::string>(Dali::Actor::Property::NAME).c_str() : "");
 146     DALI_LOG_INFO(gLogFilter, Debug::Concise, "ConsumedActor: (%p) %s\n", consumedActor ? reinterpret_cast<void*>(&consumedActor.GetBaseObject()) : NULL, consumedActor ? consumedActor.GetProperty<std::string>(Dali::Actor::Property::NAME).c_str() : "");
 147   }
 148   else
 149   {
 150     // if CUSTOM_WHEEL, emit the wheel event signal from the scene.
 151     mScene.EmitWheelEventSignal(wheelEventHandle);
 152   }
 153 }
 154
 155 } // namespace Internal
 156
 157 } // namespace Dali