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
14namespace ui {
15
16class EventDispatcher;
17class EventTarget;
18class EventTargeter;
19
20struct EventDispatchDetails {
21  EventDispatchDetails()
22      : dispatcher_destroyed(false),
23        target_destroyed(false) {}
24  bool dispatcher_destroyed;
25  bool target_destroyed;
26};
27
28class 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  // |target| is NULL if the target was deleted during dispatch.
58  virtual EventDispatchDetails PostDispatchEvent(
59      EventTarget* target,
60      const Event& event) WARN_UNUSED_RESULT;
61
62 private:
63  // Dispatches the event to the target.
64  EventDispatchDetails DispatchEventToTarget(EventTarget* target,
65                                             Event* event) WARN_UNUSED_RESULT;
66
67  EventDispatcher* dispatcher_;
68
69  DISALLOW_COPY_AND_ASSIGN(EventDispatcherDelegate);
70};
71
72// Dispatches events to appropriate targets.
73class EVENTS_EXPORT EventDispatcher {
74 public:
75  explicit EventDispatcher(EventDispatcherDelegate* delegate);
76  virtual ~EventDispatcher();
77
78  void ProcessEvent(EventTarget* target, Event* event);
79
80  const Event* current_event() const { return current_event_; }
81  Event* current_event() { return current_event_; }
82
83  bool delegate_destroyed() const { return !delegate_; }
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  DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
103};
104
105}  // namespace ui
106
107#endif  // UI_EVENTS_EVENT_DISPATCHER_H_
108