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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_CONNECTION_H_
#define UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_CONNECTION_H_
#include <memory>
#include <vector>
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/ozone/platform/wayland/common/wayland_object.h"
#include "ui/ozone/platform/wayland/host/wayland_clipboard.h"
#include "ui/ozone/platform/wayland/host/wayland_data_drag_controller.h"
#include "ui/ozone/platform/wayland/host/wayland_data_source.h"
#include "ui/ozone/platform/wayland/host/wayland_window_manager.h"
namespace gfx {
class Point;
}
namespace ui {
class WaylandBufferManagerHost;
class WaylandCursor;
class WaylandDrm;
class WaylandEventSource;
class WaylandKeyboard;
class WaylandOutputManager;
class WaylandPointer;
class WaylandShm;
class WaylandTouch;
class WaylandZwpLinuxDmabuf;
class WaylandDataDeviceManager;
class WaylandCursorPosition;
class WaylandWindowDragController;
class GtkPrimarySelectionDeviceManager;
class WaylandConnection {
public:
WaylandConnection();
WaylandConnection(const WaylandConnection&) = delete;
WaylandConnection& operator=(const WaylandConnection&) = delete;
~WaylandConnection();
bool Initialize();
// Schedules a flush of the Wayland connection.
void ScheduleFlush();
wl_display* display() const { return display_.get(); }
wl_compositor* compositor() const { return compositor_.get(); }
uint32_t compositor_version() const { return compositor_version_; }
wl_subcompositor* subcompositor() const { return subcompositor_.get(); }
xdg_wm_base* shell() const { return shell_.get(); }
zxdg_shell_v6* shell_v6() const { return shell_v6_.get(); }
wl_seat* seat() const { return seat_.get(); }
wp_presentation* presentation() const { return presentation_.get(); }
zwp_text_input_manager_v1* text_input_manager_v1() const {
return text_input_manager_v1_.get();
}
void set_serial(uint32_t serial) { serial_ = serial; }
uint32_t serial() const { return serial_; }
void SetCursorBitmap(const std::vector<SkBitmap>& bitmaps,
const gfx::Point& location);
WaylandEventSource* event_source() const { return event_source_.get(); }
// Returns the current touch, which may be null.
WaylandTouch* touch() const { return touch_.get(); }
// Returns the current pointer, which may be null.
WaylandPointer* pointer() const { return pointer_.get(); }
// Returns the current keyboard, which may be null.
WaylandKeyboard* keyboard() const { return keyboard_.get(); }
WaylandClipboard* clipboard() const { return clipboard_.get(); }
WaylandOutputManager* wayland_output_manager() const {
return wayland_output_manager_.get();
}
// Returns the cursor position, which may be null.
WaylandCursorPosition* wayland_cursor_position() const {
return wayland_cursor_position_.get();
}
WaylandBufferManagerHost* buffer_manager_host() const {
return buffer_manager_host_.get();
}
WaylandZwpLinuxDmabuf* zwp_dmabuf() const { return zwp_dmabuf_.get(); }
WaylandDrm* drm() const { return drm_.get(); }
WaylandShm* shm() const { return shm_.get(); }
WaylandWindowManager* wayland_window_manager() {
return &wayland_window_manager_;
}
WaylandDataDeviceManager* data_device_manager() const {
return data_device_manager_.get();
}
GtkPrimarySelectionDeviceManager* primary_selection_device_manager() const {
return primary_selection_device_manager_.get();
}
WaylandDataDragController* data_drag_controller() const {
return data_drag_controller_.get();
}
WaylandWindowDragController* window_drag_controller() const {
return window_drag_controller_.get();
}
// Returns true when dragging is entered or started.
bool IsDragInProgress() const;
private:
void Flush();
void UpdateInputDevices(wl_seat* seat, uint32_t capabilities);
// Initialize data-related objects if required protocol objects are already
// in place, i.e: wl_seat and wl_data_device_manager.
void CreateDataObjectsIfReady();
// Creates WaylandKeyboard with the currently acquired protocol objects, if
// possible. Returns true iff WaylandKeyboard was created.
bool CreateKeyboard();
// wl_registry_listener
static void Global(void* data,
wl_registry* registry,
uint32_t name,
const char* interface,
uint32_t version);
static void GlobalRemove(void* data, wl_registry* registry, uint32_t name);
// wl_seat_listener
static void Capabilities(void* data, wl_seat* seat, uint32_t capabilities);
static void Name(void* data, wl_seat* seat, const char* name);
// zxdg_shell_v6_listener
static void PingV6(void* data, zxdg_shell_v6* zxdg_shell_v6, uint32_t serial);
// xdg_wm_base_listener
static void Ping(void* data, xdg_wm_base* shell, uint32_t serial);
uint32_t compositor_version_ = 0;
wl::Object<wl_display> display_;
wl::Object<wl_registry> registry_;
wl::Object<wl_compositor> compositor_;
wl::Object<wl_subcompositor> subcompositor_;
wl::Object<wl_seat> seat_;
wl::Object<xdg_wm_base> shell_;
wl::Object<zxdg_shell_v6> shell_v6_;
wl::Object<wp_presentation> presentation_;
wl::Object<zcr_keyboard_extension_v1> keyboard_extension_v1_;
wl::Object<zwp_text_input_manager_v1> text_input_manager_v1_;
// Event source instance. Must be declared before input objects so it
// outlives them so thus being able to properly handle their destruction.
std::unique_ptr<WaylandEventSource> event_source_;
// Input device objects.
std::unique_ptr<WaylandKeyboard> keyboard_;
std::unique_ptr<WaylandPointer> pointer_;
std::unique_ptr<WaylandTouch> touch_;
std::unique_ptr<WaylandCursor> cursor_;
std::unique_ptr<WaylandDataDeviceManager> data_device_manager_;
std::unique_ptr<WaylandClipboard> clipboard_;
std::unique_ptr<WaylandOutputManager> wayland_output_manager_;
std::unique_ptr<WaylandCursorPosition> wayland_cursor_position_;
std::unique_ptr<WaylandZwpLinuxDmabuf> zwp_dmabuf_;
std::unique_ptr<WaylandDrm> drm_;
std::unique_ptr<WaylandShm> shm_;
std::unique_ptr<WaylandBufferManagerHost> buffer_manager_host_;
std::unique_ptr<GtkPrimarySelectionDeviceManager>
primary_selection_device_manager_;
std::unique_ptr<WaylandDataDragController> data_drag_controller_;
std::unique_ptr<WaylandWindowDragController> window_drag_controller_;
// Manages Wayland windows.
WaylandWindowManager wayland_window_manager_;
bool scheduled_flush_ = false;
uint32_t serial_ = 0;
};
} // namespace ui
#endif // UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_CONNECTION_H_
|
