event_dispatcher.cc 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ui/events/event_dispatcher.h"
  5. #include <algorithm>
  6. #include "ui/events/event_target.h"
  7. #include "ui/events/event_targeter.h"
  8. namespace ui {
  9. namespace {
  10. class ScopedDispatchHelper : public Event::DispatcherApi {
  11. public:
  12. explicit ScopedDispatchHelper(Event* event)
  13. : Event::DispatcherApi(event) {
  14. set_result(ui::ER_UNHANDLED);
  15. }
  16. ScopedDispatchHelper(const ScopedDispatchHelper&) = delete;
  17. ScopedDispatchHelper& operator=(const ScopedDispatchHelper&) = delete;
  18. virtual ~ScopedDispatchHelper() {
  19. set_phase(EP_POSTDISPATCH);
  20. }
  21. };
  22. } // namespace
  23. EventDispatcherDelegate::EventDispatcherDelegate() : dispatcher_(nullptr) {}
  24. EventDispatcherDelegate::~EventDispatcherDelegate() {
  25. if (dispatcher_)
  26. dispatcher_->OnDispatcherDelegateDestroyed();
  27. }
  28. Event* EventDispatcherDelegate::current_event() {
  29. return dispatcher_ ? dispatcher_->current_event() : NULL;
  30. }
  31. EventDispatchDetails EventDispatcherDelegate::DispatchEvent(EventTarget* target,
  32. Event* event) {
  33. CHECK(target);
  34. Event::DispatcherApi dispatch_helper(event);
  35. dispatch_helper.set_phase(EP_PREDISPATCH);
  36. dispatch_helper.set_result(ER_UNHANDLED);
  37. EventDispatchDetails details = PreDispatchEvent(target, event);
  38. if (!event->handled() &&
  39. !details.dispatcher_destroyed &&
  40. !details.target_destroyed) {
  41. details = DispatchEventToTarget(target, event);
  42. }
  43. bool target_destroyed_during_dispatch = details.target_destroyed;
  44. if (!details.dispatcher_destroyed) {
  45. details = PostDispatchEvent(target_destroyed_during_dispatch ?
  46. NULL : target, *event);
  47. }
  48. details.target_destroyed |= target_destroyed_during_dispatch;
  49. return details;
  50. }
  51. EventDispatchDetails EventDispatcherDelegate::PreDispatchEvent(
  52. EventTarget* target, Event* event) {
  53. return EventDispatchDetails();
  54. }
  55. EventDispatchDetails EventDispatcherDelegate::PostDispatchEvent(
  56. EventTarget* target, const Event& event) {
  57. return EventDispatchDetails();
  58. }
  59. EventDispatchDetails EventDispatcherDelegate::DispatchEventToTarget(
  60. EventTarget* target,
  61. Event* event) {
  62. EventDispatcher* old_dispatcher = dispatcher_;
  63. EventDispatcher dispatcher(this);
  64. dispatcher_ = &dispatcher;
  65. dispatcher.ProcessEvent(target, event);
  66. if (!dispatcher.delegate_destroyed())
  67. dispatcher_ = old_dispatcher;
  68. else if (old_dispatcher)
  69. old_dispatcher->OnDispatcherDelegateDestroyed();
  70. EventDispatchDetails details;
  71. details.dispatcher_destroyed = dispatcher.delegate_destroyed();
  72. details.target_destroyed =
  73. (!details.dispatcher_destroyed && !CanDispatchToTarget(target));
  74. return details;
  75. }
  76. ////////////////////////////////////////////////////////////////////////////////
  77. // EventDispatcher:
  78. EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
  79. : delegate_(delegate) {}
  80. EventDispatcher::~EventDispatcher() {
  81. // |handler_list_| must be empty, otherwise this has been added to an
  82. // EventHandler that will callback to this when destroyed.
  83. CHECK(handler_list_.empty());
  84. }
  85. void EventDispatcher::OnHandlerDestroyed(EventHandler* handler) {
  86. handler_list_.erase(std::find(handler_list_.begin(),
  87. handler_list_.end(),
  88. handler));
  89. }
  90. void EventDispatcher::ProcessEvent(EventTarget* target, Event* event) {
  91. if (!target || !target->CanAcceptEvent(*event))
  92. return;
  93. ScopedDispatchHelper dispatch_helper(event);
  94. dispatch_helper.set_target(target);
  95. handler_list_.clear();
  96. target->GetPreTargetHandlers(&handler_list_);
  97. dispatch_helper.set_phase(EP_PRETARGET);
  98. DispatchEventToEventHandlers(&handler_list_, event);
  99. // All pre-target handler should have been removed.
  100. CHECK(handler_list_.empty());
  101. if (event->handled())
  102. return;
  103. // If the event hasn't been consumed, trigger the default handler. Note that
  104. // even if the event has already been handled (i.e. return result has
  105. // ER_HANDLED set), that means that the event should still be processed at
  106. // this layer, however it should not be processed in the next layer of
  107. // abstraction.
  108. if (delegate_ && delegate_->CanDispatchToTarget(target) &&
  109. target->target_handler()) {
  110. dispatch_helper.set_phase(EP_TARGET);
  111. DispatchEvent(target->target_handler(), event);
  112. if (event->handled())
  113. return;
  114. }
  115. if (!delegate_ || !delegate_->CanDispatchToTarget(target))
  116. return;
  117. target->GetPostTargetHandlers(&handler_list_);
  118. dispatch_helper.set_phase(EP_POSTTARGET);
  119. DispatchEventToEventHandlers(&handler_list_, event);
  120. }
  121. void EventDispatcher::OnDispatcherDelegateDestroyed() {
  122. delegate_ = nullptr;
  123. }
  124. ////////////////////////////////////////////////////////////////////////////////
  125. // EventDispatcher, private:
  126. void EventDispatcher::DispatchEventToEventHandlers(EventHandlerList* list,
  127. Event* event) {
  128. // Let each EventHandler know this is about to make use of it. This way, if
  129. // during dispatch the EventHandler is destroyed it is removed from |list|
  130. // (OnHandlerDestroyed() is called, which removes from |list|).
  131. for (EventHandler* handler : *list)
  132. handler->dispatchers_.push(this);
  133. while (!list->empty()) {
  134. EventHandler* handler = (*list->begin());
  135. // |this| no longer needs to know if |handler| is destroyed.
  136. CHECK(handler->dispatchers_.top() == this);
  137. handler->dispatchers_.pop();
  138. list->erase(list->begin());
  139. // A null |delegate| means no more events should be dispatched.
  140. if (delegate_ && !event->stopped_propagation())
  141. DispatchEvent(handler, event);
  142. }
  143. }
  144. void EventDispatcher::DispatchEvent(EventHandler* handler, Event* event) {
  145. // If the target has been invalidated or deleted, don't dispatch the event.
  146. if (!delegate_->CanDispatchToTarget(event->target())) {
  147. if (event->cancelable())
  148. event->StopPropagation();
  149. return;
  150. }
  151. base::AutoReset<Event*> event_reset(&current_event_, event);
  152. handler->OnEvent(event);
  153. if (!delegate_ && event->cancelable())
  154. event->StopPropagation();
  155. }
  156. } // namespace ui