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

   1 /*
   2  * Copyright (c) 2023 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   mClipboardEventNotifier(),
  56   mPaused(false)
  57 {
  58   // Connect signals
  59   if(windowBase)
  60   {
  61     windowBase->WindowDamagedSignal().Connect(this, &EventHandler::OnWindowDamaged);
  62     windowBase->FocusChangedSignal().Connect(this, &EventHandler::OnFocusChanged);
  63     windowBase->RotationSignal().Connect(this, &EventHandler::OnRotation);
  64     windowBase->TouchEventSignal().Connect(this, &EventHandler::OnTouchEvent);
  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::OnWheelEvent(Integration::WheelEvent& wheelEvent)
 111 {
 112   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 113   {
 114     (*iter)->OnWheelEvent(wheelEvent);
 115   }
 116 }
 117
 118 void EventHandler::OnKeyEvent(Integration::KeyEvent& keyEvent)
 119 {
 120   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 121   {
 122     (*iter)->OnKeyEvent(keyEvent);
 123   }
 124 }
 125
 126 void EventHandler::OnFocusChanged(bool focusIn)
 127 {
 128   // If the window gains focus and we hid the keyboard then show it again.
 129   if(Clipboard::IsAvailable())
 130   {
 131     if(focusIn)
 132     {
 133       Dali::Clipboard clipboard = Clipboard::Get();
 134       if(clipboard)
 135       {
 136         clipboard.HideClipboard();
 137       }
 138     }
 139     else
 140     {
 141       // Hiding clipboard event will be ignored once because window focus out event is always received on showing clipboard
 142       Dali::Clipboard clipboard = Clipboard::Get();
 143       if(clipboard)
 144       {
 145         Clipboard& clipBoardImpl(GetImplementation(clipboard));
 146         clipBoardImpl.HideClipboard(true);
 147       }
 148     }
 149   }
 150 }
 151
 152 void EventHandler::OnRotation(const RotationEvent& event)
 153 {
 154   for(ObserverContainer::iterator iter = mObservers.begin(), endIter = mObservers.end(); iter != endIter; ++iter)
 155   {
 156     (*iter)->OnRotation(event);
 157   }
 158 }
 159
 160 void EventHandler::OnWindowDamaged(const DamageArea& area)
 161 {
 162   SendEvent(area);
 163 }
 164
 165 void EventHandler::OnSelectionDataSend(void* event)
 166 {
 167   Dali::Clipboard clipboard = Clipboard::Get();
 168   if(clipboard)
 169   {
 170     Clipboard& clipBoardImpl(GetImplementation(clipboard));
 171     clipBoardImpl.ExcuteBuffered(true, event);
 172   }
 173 }
 174
 175 void EventHandler::OnSelectionDataReceived(void* event)
 176 {
 177   // We have got the selected content, inform the clipboard event listener (if we have one).
 178   Dali::Clipboard clipboard     = Clipboard::Get();
 179   char*           selectionData = NULL;
 180   if(clipboard)
 181   {
 182     Clipboard& clipBoardImpl(GetImplementation(clipboard));
 183     selectionData = clipBoardImpl.ExcuteBuffered(false, event);
 184   }
 185
 186   if(!mClipboardEventNotifier)
 187   {
 188     mClipboardEventNotifier = ClipboardEventNotifier::Get();
 189   }
 190
 191   if(selectionData && mClipboardEventNotifier)
 192   {
 193     ClipboardEventNotifier& clipboardEventNotifier(ClipboardEventNotifier::GetImplementation(mClipboardEventNotifier));
 194     std::string             content(selectionData, strlen(selectionData));
 195
 196     clipboardEventNotifier.SetContent(content);
 197     clipboardEventNotifier.EmitContentSelectedSignal();
 198
 199     DALI_LOG_INFO(gSelectionEventLogFilter, Debug::General, "EcoreEventSelectionNotify: Content(%d): %s\n", strlen(selectionData), selectionData);
 200   }
 201 }
 202
 203 void EventHandler::OnStyleChanged(StyleChange::Type styleChange)
 204 {
 205   SendEvent(styleChange);
 206 }
 207
 208 void EventHandler::AddObserver(Observer& observer)
 209 {
 210   ObserverContainer::iterator match(find(mObservers.begin(), mObservers.end(), &observer));
 211
 212   if(match == mObservers.end())
 213   {
 214     mObservers.push_back(&observer);
 215   }
 216 }
 217
 218 void EventHandler::RemoveObserver(Observer& observer)
 219 {
 220   ObserverContainer::iterator match(find(mObservers.begin(), mObservers.end(), &observer));
 221
 222   if(match != mObservers.end())
 223   {
 224     mObservers.erase(match);
 225   }
 226 }
 227
 228 } // namespace Adaptor
 229
 230 } // namespace Internal
 231
 232 } // namespace Dali