dali/internal/window-system/common/event-handler.cpp

   1 /*
   2  * Copyright (c) 2024 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/window-system/common/event-handler.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <sys/time.h>
  23 #include <cstring>
  24
  25 #include <dali/devel-api/events/touch-point.h>
  26 #include <dali/integration-api/debug.h>
  27 #include <dali/integration-api/events/hover-event-integ.h>
  28 #include <dali/integration-api/events/key-event-integ.h>
  29 #include <dali/integration-api/events/touch-event-integ.h>
  30 #include <dali/integration-api/events/wheel-event-integ.h>
  31 #include <dali/public-api/events/key-event.h>
  32 #include <dali/public-api/events/wheel-event.h>
  33
  34 // INTERNAL INCLUDES
  35 #include <dali/internal/clipboard/common/clipboard-impl.h>
  36 #include <dali/internal/styling/common/style-monitor-impl.h>
  37 #include <dali/internal/window-system/common/window-render-surface.h>
  38
  39 namespace Dali
  40 {
  41 namespace Internal
  42 {
  43 namespace Adaptor
  44 {
  45 #if defined(DEBUG_ENABLED)
  46 namespace
  47 {
  48 Integration::Log::Filter* gSelectionEventLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_SELECTION");
  49 } // unnamed namespace
  50 #endif
  51
  52 EventHandler::EventHandler(WindowBase* windowBase, DamageObserver& damageObserver)
  53 : mStyleMonitor(StyleMonitor::Get()),
  54   mDamageObserver(damageObserver),
  55   mPaused(false)
  56 {
  57   // Connect signals
  58   if(windowBase)
  59   {
  60     windowBase->WindowDamagedSignal().Connect(this, &EventHandler::OnWindowDamaged);
  61     windowBase->FocusChangedSignal().Connect(this, &EventHandler::OnFocusChanged);
  62     windowBase->RotationSignal().Connect(this, &EventHandler::OnRotation);
  63     windowBase->TouchEventSignal().Connect(this, &EventHandler::OnTouchEvent);
  64     windowBase->MouseFrameEventSignal().Connect(this, &EventHandler::OnMouseFrameEvent);
  65     windowBase->WheelEventSignal().Connect(this, &EventHandler::OnWheelEvent);
  66     windowBase->KeyEventSignal().Connect(this, &EventHandler::OnKeyEvent);
  67     windowBase->SelectionDataSendSignal().Connect(this, &EventHandler::OnSelectionDataSend);
  68     windowBase->SelectionDataReceivedSignal().Connect(this, &EventHandler::OnSelectionDataReceived);
  69     windowBase->StyleChangedSignal().Connect(this, &EventHandler::OnStyleChanged);
  70   }
  71   else
  72   {
  73     DALI_LOG_ERROR("WindowBase is invalid!!!\n");
  74   }
  75 }
  76
  77 EventHandler::~EventHandler()
  78 {
  79 }
  80
  81 void EventHandler::SendEvent(StyleChange::Type styleChange)
  82 {
  83   DALI_ASSERT_DEBUG(mStyleMonitor && "StyleMonitor Not Available");
  84   GetImplementation(mStyleMonitor).StyleChanged(styleChange);
  85 }
  86
  87 void EventHandler::SendEvent(const DamageArea& area)
  88 {
  89   mDamageObserver.OnDamaged(area);
  90 }
  91
  92 void EventHandler::Pause()
  93 {
  94   mPaused = true;
  95 }
  96
  97 void EventHandler::Resume()
  98 {
  99   mPaused = false;
 100 }
 101
 102 void EventHandler::OnTouchEvent(Integration::Point& point, uint32_t timeStamp)
 103 {
 104   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 105   {
 106     (*iter)->OnTouchPoint(point, timeStamp);
 107   }
 108 }
 109
 110 void EventHandler::OnMouseFrameEvent()
 111 {
 112   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 113   {
 114     (*iter)->OnMouseFrameEvent();
 115   }
 116 }
 117
 118 void EventHandler::OnWheelEvent(Integration::WheelEvent& wheelEvent)
 119 {
 120   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 121   {
 122     (*iter)->OnWheelEvent(wheelEvent);
 123   }
 124 }
 125
 126 void EventHandler::OnKeyEvent(Integration::KeyEvent& keyEvent)
 127 {
 128   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 129   {
 130     (*iter)->OnKeyEvent(keyEvent);
 131   }
 132 }
 133
 134 void EventHandler::OnFocusChanged(bool focusIn)
 135 {
 136   // If the window gains focus and we hid the keyboard then show it again.
 137   if(Clipboard::IsAvailable())
 138   {
 139     if(focusIn)
 140     {
 141       Dali::Clipboard clipboard = Clipboard::Get();
 142       if(clipboard)
 143       {
 144         clipboard.HideClipboard();
 145       }
 146     }
 147     else
 148     {
 149       // Hiding clipboard event will be ignored once because window focus out event is always received on showing clipboard
 150       Dali::Clipboard clipboard = Clipboard::Get();
 151       if(clipboard)
 152       {
 153         Clipboard& clipBoardImpl(GetImplementation(clipboard));
 154         clipBoardImpl.HideClipboard(true);
 155       }
 156     }
 157   }
 158 }
 159
 160 void EventHandler::OnRotation(const RotationEvent& event)
 161 {
 162   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 163   {
 164     (*iter)->OnRotation(event);
 165   }
 166 }
 167
 168 void EventHandler::OnWindowDamaged(const DamageArea& area)
 169 {
 170   SendEvent(area);
 171 }
 172
 173 void EventHandler::OnSelectionDataSend(void* event)
 174 {
 175   // Note that the clipboard-related operstions previously available have been moved to Clipboard class.
 176   // It is advised not to handle any clipboard-specific works within this context.
 177   // There are currently no immediate works required in this callback.
 178   // But this function is retained for the purpose of handling the event at the window level, if needed.
 179 }
 180
 181 void EventHandler::OnSelectionDataReceived(void* event)
 182 {
 183   // Note that the clipboard-related operstions previously available have been moved to Clipboard class.
 184   // It is advised not to handle any clipboard-specific works within this context.
 185   // There are currently no immediate works required in this callback.
 186   // But this function is retained for the purpose of handling the event at the window level, if needed.
 187 }
 188
 189 void EventHandler::OnStyleChanged(StyleChange::Type styleChange)
 190 {
 191   SendEvent(styleChange);
 192 }
 193
 194 void EventHandler::AddObserver(Observer& observer)
 195 {
 196   ObserverContainer::iterator match(find(mObservers.begin(), mObservers.end(), &observer));
 197
 198   if(match == mObservers.end())
 199   {
 200     mObservers.push_back(&observer);
 201   }
 202 }
 203
 204 void EventHandler::RemoveObserver(Observer& observer)
 205 {
 206   ObserverContainer::iterator match(find(mObservers.begin(), mObservers.end(), &observer));
 207
 208   if(match != mObservers.end())
 209   {
 210     mObservers.erase(match);
 211   }
 212 }
 213
 214 } // namespace Adaptor
 215
 216 } // namespace Internal
 217
 218 } // namespace Dali