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 5 #ifndef UI_EVENTS_EVENT_DISPATCHER_H_ 6 #define UI_EVENTS_EVENT_DISPATCHER_H_ 7 8 #include "base/auto_reset.h" 9 #include "ui/events/event.h" 10 #include "ui/events/event_constants.h" 11 #include "ui/events/event_handler.h" 12 #include "ui/events/events_export.h" 13 14 namespace ui { 15 16 class EventDispatcher; 17 class EventTarget; 18 class EventTargeter; 19 20 struct EventDispatchDetails { EventDispatchDetailsEventDispatchDetails21 EventDispatchDetails() 22 : dispatcher_destroyed(false), 23 target_destroyed(false) {} 24 bool dispatcher_destroyed; 25 bool target_destroyed; 26 }; 27 28 class EVENTS_EXPORT EventDispatcherDelegate { 29 public: 30 EventDispatcherDelegate(); 31 virtual ~EventDispatcherDelegate(); 32 33 // Returns whether an event can still be dispatched to a target. (e.g. during 34 // event dispatch, one of the handlers may have destroyed the target, in which 35 // case the event can no longer be dispatched to the target). 36 virtual bool CanDispatchToTarget(EventTarget* target) = 0; 37 38 // Returns the event being dispatched (or NULL if no event is being 39 // dispatched). 40 Event* current_event(); 41 42 // Dispatches |event| to |target|. This calls |PreDispatchEvent()| before 43 // dispatching the event, and |PostDispatchEvent()| after the event has been 44 // dispatched. 45 EventDispatchDetails DispatchEvent(EventTarget* target, Event* event) 46 WARN_UNUSED_RESULT; 47 48 protected: 49 // This is called once a target has been determined for an event, right before 50 // the event is dispatched to the target. This function may modify |event| to 51 // prepare it for dispatch (e.g. update event flags, location etc.). 52 virtual EventDispatchDetails PreDispatchEvent( 53 EventTarget* target, 54 Event* event) WARN_UNUSED_RESULT; 55 56 // This is called right after the event dispatch is completed. 57 virtual EventDispatchDetails PostDispatchEvent( 58 EventTarget* target, 59 const Event& event) WARN_UNUSED_RESULT; 60 61 private: 62 // Dispatches the event to the target. 63 EventDispatchDetails DispatchEventToTarget(EventTarget* target, 64 Event* event) WARN_UNUSED_RESULT; 65 66 EventDispatcher* dispatcher_; 67 68 DISALLOW_COPY_AND_ASSIGN(EventDispatcherDelegate); 69 }; 70 71 // Dispatches events to appropriate targets. 72 class EVENTS_EXPORT EventDispatcher { 73 public: 74 explicit EventDispatcher(EventDispatcherDelegate* delegate); 75 virtual ~EventDispatcher(); 76 77 void ProcessEvent(EventTarget* target, Event* event); 78 current_event()79 const Event* current_event() const { return current_event_; } current_event()80 Event* current_event() { return current_event_; } 81 delegate_destroyed()82 bool delegate_destroyed() const { return !delegate_; } details()83 const EventDispatchDetails& details() const { return details_; } 84 85 void OnHandlerDestroyed(EventHandler* handler); 86 void OnDispatcherDelegateDestroyed(); 87 88 private: 89 void DispatchEventToEventHandlers(EventHandlerList* list, Event* event); 90 91 // Dispatches an event, and makes sure it sets ER_CONSUMED on the 92 // event-handling result if the dispatcher itself has been destroyed during 93 // dispatching the event to the event handler. 94 void DispatchEvent(EventHandler* handler, Event* event); 95 96 EventDispatcherDelegate* delegate_; 97 98 Event* current_event_; 99 100 EventHandlerList handler_list_; 101 102 EventDispatchDetails details_; 103 104 DISALLOW_COPY_AND_ASSIGN(EventDispatcher); 105 }; 106 107 } // namespace ui 108 109 #endif // UI_EVENTS_EVENT_DISPATCHER_H_ 110