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 2021, 2022 Benjamin Barenblat
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
// X events.
#ifndef GLPLANET_SRC_X_EVENT_H_
#define GLPLANET_SRC_X_EVENT_H_
#include <string.h>
#include <xcb/xcb.h>
#include <array>
#include "src/x/types.h"
#include "third_party/abseil/absl/types/variant.h"
namespace x_internal {
template <typename From, typename To>
void XcbDowncast(const From& from, To& to) noexcept {
static_assert(sizeof(From) >= sizeof(To));
memcpy(&to, &from, sizeof(To));
}
} // namespace x_internal
namespace x {
class ExposeEvent final {
public:
explicit ExposeEvent(const xcb_expose_event_t& event) noexcept
: event_(event) {}
explicit ExposeEvent(const xcb_generic_event_t& event) noexcept {
x_internal::XcbDowncast(event, event_);
}
ExposeEvent(const ExposeEvent&) noexcept = default;
ExposeEvent& operator=(const ExposeEvent&) noexcept = default;
ExposeEvent(ExposeEvent&&) noexcept = default;
ExposeEvent& operator=(ExposeEvent&&) noexcept = default;
xcb_expose_event_t& AsXcbEvent() noexcept { return event_; }
const xcb_expose_event_t& AsXcbEvent() const noexcept { return event_; }
private:
xcb_expose_event_t event_;
};
class ConfigureNotifyEvent final {
public:
explicit ConfigureNotifyEvent(
const xcb_configure_notify_event_t& event) noexcept
: event_(event) {}
explicit ConfigureNotifyEvent(const xcb_generic_event_t& event) noexcept {
x_internal::XcbDowncast(event, event_);
}
ConfigureNotifyEvent(const ConfigureNotifyEvent&) noexcept = default;
ConfigureNotifyEvent& operator=(const ConfigureNotifyEvent&) noexcept =
default;
ConfigureNotifyEvent(ConfigureNotifyEvent&&) noexcept = default;
ConfigureNotifyEvent& operator=(ConfigureNotifyEvent&&) noexcept = default;
int width() const noexcept { return event_.width; }
int height() const noexcept { return event_.height; }
xcb_configure_notify_event_t& AsXcbEvent() noexcept { return event_; }
const xcb_configure_notify_event_t& AsXcbEvent() const noexcept {
return event_;
}
private:
xcb_configure_notify_event_t event_;
};
class ClientMessageEvent final {
public:
explicit ClientMessageEvent(const xcb_client_message_event_t& event) noexcept
: event_(event) {}
explicit ClientMessageEvent(const xcb_generic_event_t& event) noexcept {
x_internal::XcbDowncast(event, event_);
}
ClientMessageEvent(const ClientMessageEvent&) noexcept = default;
ClientMessageEvent& operator=(const ClientMessageEvent&) noexcept = default;
ClientMessageEvent(ClientMessageEvent&&) noexcept = default;
ClientMessageEvent& operator=(ClientMessageEvent&&) noexcept = default;
Id type() const noexcept { return event_.type; }
xcb_client_message_event_t& AsXcbEvent() noexcept { return event_; }
const xcb_client_message_event_t& AsXcbEvent() const noexcept {
return event_;
}
private:
xcb_client_message_event_t event_;
};
// An X event that doesn't fit into any of the previous classes.
class UnknownEvent final {
public:
explicit UnknownEvent(const xcb_generic_event_t& event) : event_(event) {}
UnknownEvent(const UnknownEvent&) noexcept = default;
UnknownEvent& operator=(const UnknownEvent&) noexcept = default;
UnknownEvent(UnknownEvent&&) noexcept = default;
UnknownEvent& operator=(UnknownEvent&&) noexcept = default;
xcb_generic_event_t& AsXcbEvent() noexcept { return event_; }
const xcb_generic_event_t& AsXcbEvent() const noexcept { return event_; }
private:
xcb_generic_event_t event_;
};
using Event = absl::variant<UnknownEvent, ExposeEvent, ConfigureNotifyEvent,
ClientMessageEvent>;
Event FromXcbGenericEvent(const xcb_generic_event_t&) noexcept;
std::array<char, 32> SerializeEvent(const Event&) noexcept;
} // namespace x
#endif // GLPLANET_SRC_X_EVENT_H_
|
