1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_AURA_WINDOW_TREE_HOST_PLATFORM_H_
#define UI_AURA_WINDOW_TREE_HOST_PLATFORM_H_
#include <memory>
#include "ui/aura/aura_export.h"
#include "ui/aura/client/window_types.h"
#include "ui/aura/window.h"
#include "ui/aura/window_tree_host.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/platform_window/platform_window_delegate.h"
namespace ui {
enum class DomCode : uint32_t;
class PlatformWindow;
class KeyboardHook;
struct PlatformWindowInitProperties;
} // namespace ui
namespace aura {
// The unified WindowTreeHost implementation for platforms
// that implement PlatformWindow.
class AURA_EXPORT WindowTreeHostPlatform : public WindowTreeHost,
public ui::PlatformWindowDelegate {
public:
explicit WindowTreeHostPlatform(ui::PlatformWindowInitProperties properties,
std::unique_ptr<Window> = nullptr);
WindowTreeHostPlatform(const WindowTreeHostPlatform&) = delete;
WindowTreeHostPlatform& operator=(const WindowTreeHostPlatform&) = delete;
~WindowTreeHostPlatform() override;
static WindowTreeHostPlatform* GetHostForWindow(aura::Window* window);
// WindowTreeHost:
ui::EventSource* GetEventSource() override;
gfx::AcceleratedWidget GetAcceleratedWidget() override;
void ShowImpl() override;
void HideImpl() override;
gfx::Rect GetBoundsInPixels() const override;
void SetBoundsInPixels(const gfx::Rect& bounds) override;
void SetCapture() override;
void ReleaseCapture() override;
void SetCursorNative(gfx::NativeCursor cursor) override;
void MoveCursorToScreenLocationInPixels(
const gfx::Point& location_in_pixels) override;
void OnCursorVisibilityChangedNative(bool show) override;
void LockMouse(Window* window) override;
ui::PlatformWindow* platform_window() { return platform_window_.get(); }
const ui::PlatformWindow* platform_window() const {
return platform_window_.get();
}
// Returns `PlatformWindow` for the platform. If
// `PlatformWindowFactoryDelegateForTesting` is set, it uses the delegate.
std::unique_ptr<ui::PlatformWindow> CreatePlatformWindow(
ui::PlatformWindowInitProperties properties);
class PlatformWindowFactoryDelegateForTesting {
public:
virtual ~PlatformWindowFactoryDelegateForTesting() = default;
virtual std::unique_ptr<ui::PlatformWindow> Create(
WindowTreeHostPlatform*) = 0;
};
static void SetPlatformWindowFactoryDelegateForTesting(
PlatformWindowFactoryDelegateForTesting* delegate);
protected:
// NOTE: this does not call CreateCompositor(); subclasses must call
// CreateCompositor() at the appropriate time.
explicit WindowTreeHostPlatform(std::unique_ptr<Window> window = nullptr);
// Creates a ui::PlatformWindow appropriate for the current platform and
// installs it at as the PlatformWindow for this WindowTreeHostPlatform.
void CreateAndSetPlatformWindow(ui::PlatformWindowInitProperties properties);
void SetPlatformWindow(std::unique_ptr<ui::PlatformWindow> window);
// ui::PlatformWindowDelegate:
void OnBoundsChanged(const BoundsChange& change) override;
void OnDamageRect(const gfx::Rect& damaged_region) override;
void DispatchEvent(ui::Event* event) override;
void OnCloseRequest() override;
void OnClosed() override;
void OnWindowStateChanged(ui::PlatformWindowState old_state,
ui::PlatformWindowState new_state) override;
void OnLostCapture() override;
void OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) override;
void OnWillDestroyAcceleratedWidget() override;
void OnAcceleratedWidgetDestroyed() override;
void OnActivationChanged(bool active) override;
void OnMouseEnter() override;
void OnOcclusionStateChanged(
ui::PlatformWindowOcclusionState occlusion_state) override;
int64_t OnStateUpdate(const PlatformWindowDelegate::State& old,
const PlatformWindowDelegate::State& latest) override;
// Overridden from aura::WindowTreeHost:
gfx::Point GetLocationOnScreenInPixels() const override;
bool CaptureSystemKeyEventsImpl(
std::optional<base::flat_set<ui::DomCode>> dom_codes) override;
void ReleaseSystemKeyEventCapture() override;
bool IsKeyLocked(ui::DomCode dom_code) override;
base::flat_map<std::string, std::string> GetKeyboardLayoutMap() override;
void OnVideoCaptureLockCreated() override;
void OnVideoCaptureLockDestroyed() override;
private:
gfx::AcceleratedWidget widget_;
std::unique_ptr<ui::PlatformWindow> platform_window_;
gfx::NativeCursor current_cursor_;
// TODO: use compositor's size.
gfx::Size size_in_pixels_;
std::unique_ptr<ui::KeyboardHook> keyboard_hook_;
// Prop to hold mapping to and `WindowTreeHostPlatform`. Used by
// `GetHostForWindow`.
std::unique_ptr<ui::ViewProp> prop_;
// Tracks how nested OnBoundsChanged() is. That is, on entering
// OnBoundsChanged() this is incremented and on leaving OnBoundsChanged() this
// is decremented.
int on_bounds_changed_recursion_depth_ = 0;
};
} // namespace aura
#endif // UI_AURA_WINDOW_TREE_HOST_PLATFORM_H_
|
