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_AURA_WINDOW_TREE_HOST_H_
6#define UI_AURA_WINDOW_TREE_HOST_H_
7
8#include <vector>
9
10#include "base/event_types.h"
11#include "base/message_loop/message_loop.h"
12#include "ui/aura/aura_export.h"
13#include "ui/base/cursor/cursor.h"
14#include "ui/events/event_source.h"
15#include "ui/gfx/native_widget_types.h"
16
17namespace gfx {
18class Insets;
19class Point;
20class Rect;
21class Size;
22class Transform;
23}
24
25namespace ui {
26class Compositor;
27class EventProcessor;
28class ViewProp;
29}
30
31namespace aura {
32namespace test {
33class WindowTreeHostTestApi;
34}
35
36class WindowEventDispatcher;
37class WindowTreeHostObserver;
38
39// WindowTreeHost bridges between a native window and the embedded RootWindow.
40// It provides the accelerated widget and maps events from the native os to
41// aura.
42class AURA_EXPORT WindowTreeHost {
43 public:
44  virtual ~WindowTreeHost();
45
46  // Creates a new WindowTreeHost. The caller owns the returned value.
47  static WindowTreeHost* Create(const gfx::Rect& bounds);
48
49  // Returns the WindowTreeHost for the specified accelerated widget, or NULL
50  // if there is none associated.
51  static WindowTreeHost* GetForAcceleratedWidget(gfx::AcceleratedWidget widget);
52
53  void InitHost();
54
55  void InitCompositor();
56
57  void AddObserver(WindowTreeHostObserver* observer);
58  void RemoveObserver(WindowTreeHostObserver* observer);
59
60  Window* window() { return window_; }
61  const Window* window() const { return window_; }
62
63  ui::EventProcessor* event_processor();
64
65  WindowEventDispatcher* dispatcher() {
66    return const_cast<WindowEventDispatcher*>(
67        const_cast<const WindowTreeHost*>(this)->dispatcher());
68  }
69  const WindowEventDispatcher* dispatcher() const { return dispatcher_.get(); }
70
71  ui::Compositor* compositor() { return compositor_.get(); }
72
73  // Gets/Sets the root window's transform.
74  virtual gfx::Transform GetRootTransform() const;
75  virtual void SetRootTransform(const gfx::Transform& transform);
76  virtual gfx::Transform GetInverseRootTransform() const;
77
78  // Updates the root window's size using |host_size|, current
79  // transform and insets.
80  virtual void UpdateRootWindowSize(const gfx::Size& host_size);
81
82  // Returns the actual size of the screen.
83  // (gfx::Screen only reports on the virtual desktop exposed by Aura.)
84  static gfx::Size GetNativeScreenSize();
85
86  // Converts |point| from the root window's coordinate system to native
87  // screen's.
88  void ConvertPointToNativeScreen(gfx::Point* point) const;
89
90  // Converts |point| from native screen coordinate system to the root window's.
91  void ConvertPointFromNativeScreen(gfx::Point* point) const;
92
93  // Converts |point| from the root window's coordinate system to the
94  // host window's.
95  void ConvertPointToHost(gfx::Point* point) const;
96
97  // Converts |point| from the host window's coordinate system to the
98  // root window's.
99  void ConvertPointFromHost(gfx::Point* point) const;
100
101  // Cursor.
102  // Sets the currently-displayed cursor. If the cursor was previously hidden
103  // via ShowCursor(false), it will remain hidden until ShowCursor(true) is
104  // called, at which point the cursor that was last set via SetCursor() will be
105  // used.
106  void SetCursor(gfx::NativeCursor cursor);
107
108  // Invoked when the cursor's visibility has changed.
109  void OnCursorVisibilityChanged(bool visible);
110
111  // Moves the cursor to the specified location relative to the root window.
112  void MoveCursorTo(const gfx::Point& location);
113
114  // Moves the cursor to the |host_location| given in host coordinates.
115  void MoveCursorToHostLocation(const gfx::Point& host_location);
116
117  gfx::NativeCursor last_cursor() const { return last_cursor_; }
118
119  // Returns the EventSource responsible for dispatching events to the window
120  // tree.
121  virtual ui::EventSource* GetEventSource() = 0;
122
123  // Returns the accelerated widget.
124  virtual gfx::AcceleratedWidget GetAcceleratedWidget() = 0;
125
126  // Shows the WindowTreeHost.
127  virtual void Show() = 0;
128
129  // Hides the WindowTreeHost.
130  virtual void Hide() = 0;
131
132  // Gets/Sets the size of the WindowTreeHost.
133  virtual gfx::Rect GetBounds() const = 0;
134  virtual void SetBounds(const gfx::Rect& bounds) = 0;
135
136  // Sets the OS capture to the root window.
137  virtual void SetCapture() = 0;
138
139  // Releases OS capture of the root window.
140  virtual void ReleaseCapture() = 0;
141
142  // Posts |native_event| to the platform's event queue.
143  virtual void PostNativeEvent(const base::NativeEvent& native_event) = 0;
144
145 protected:
146  friend class TestScreen;  // TODO(beng): see if we can remove/consolidate.
147
148  WindowTreeHost();
149  void DestroyCompositor();
150  void DestroyDispatcher();
151
152  void CreateCompositor(gfx::AcceleratedWidget accelerated_widget);
153
154  // Returns the location of the RootWindow on native screen.
155  virtual gfx::Point GetLocationOnNativeScreen() const = 0;
156
157  void OnHostMoved(const gfx::Point& new_location);
158  void OnHostResized(const gfx::Size& new_size);
159  void OnHostCloseRequested();
160  void OnHostActivated();
161  void OnHostLostWindowCapture();
162
163  // Sets the currently displayed cursor.
164  virtual void SetCursorNative(gfx::NativeCursor cursor) = 0;
165
166  // Moves the cursor to the specified location relative to the root window.
167  virtual void MoveCursorToNative(const gfx::Point& location) = 0;
168
169  // kCalled when the cursor visibility has changed.
170  virtual void OnCursorVisibilityChangedNative(bool show) = 0;
171
172 private:
173  friend class test::WindowTreeHostTestApi;
174
175  // Moves the cursor to the specified location. This method is internally used
176  // by MoveCursorTo() and MoveCursorToHostLocation().
177  void MoveCursorToInternal(const gfx::Point& root_location,
178                            const gfx::Point& host_location);
179
180  // We don't use a scoped_ptr for |window_| since we need this ptr to be valid
181  // during its deletion. (Window's dtor notifies observers that may attempt to
182  // reach back up to access this object which will be valid until the end of
183  // the dtor).
184  Window* window_;  // Owning.
185
186  ObserverList<WindowTreeHostObserver> observers_;
187
188  scoped_ptr<WindowEventDispatcher> dispatcher_;
189
190  scoped_ptr<ui::Compositor> compositor_;
191
192  // Last cursor set.  Used for testing.
193  gfx::NativeCursor last_cursor_;
194  gfx::Point last_cursor_request_position_in_host_;
195
196  scoped_ptr<ui::ViewProp> prop_;
197
198  DISALLOW_COPY_AND_ASSIGN(WindowTreeHost);
199};
200
201}  // namespace aura
202
203#endif  // UI_AURA_WINDOW_TREE_HOST_H_
204