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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
/*
* Copyright (C) 2017 Mentor Graphics Development (Deutschland) GmbH
*
* 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
*
* http://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.
*/
#ifndef TMCAGLWM_APP_HPP
#define TMCAGLWM_APP_HPP
#include <json-c/json.h>
#include <atomic>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <experimental/optional>
#include "afb_binding_api.hpp"
#include "config.hpp"
#include "controller_hooks.hpp"
#include "layers.hpp"
#include "layout.hpp"
#include "policy.hpp"
#include "result.hpp"
#include "wayland.hpp"
namespace wl {
struct display;
}
namespace genivi {
struct controller;
}
namespace wm {
using std::experimental::optional;
/* DrawingArea name used by "{layout}.{area}" */
static const char *kNameLayoutNormal = "normal";
static const char *kNameLayoutSplit = "split";
static const char *kNameAreaFull = "full";
static const char *kNameAreaMain = "main";
static const char *kNameAreaSub = "sub";
/* Key for json obejct */
static const char *kKeyDrawingName = "drawing_name";
static const char *kKeyDrawingArea = "drawing_area";
struct id_allocator {
unsigned next = 1;
// Surfaces that where requested but not yet created
std::unordered_map<unsigned, std::string> id2name;
// std::unordered_set<unsigned> pending_surfaces;
std::unordered_map<std::string, unsigned> name2id;
id_allocator(id_allocator const &) = delete;
id_allocator(id_allocator &&) = delete;
id_allocator &operator=(id_allocator const &);
id_allocator &operator=(id_allocator &&) = delete;
// Insert and return a new ID
unsigned generate_id(std::string const &name) {
unsigned sid = this->next++;
this->id2name[sid] = name;
// this->pending_surfaces.insert({sid});
this->name2id[name] = sid;
logdebug("allocated new id %u with name %s", sid, name.c_str());
return sid;
}
// Lookup by ID or by name
optional<unsigned> lookup(std::string const &name) const {
auto i = this->name2id.find(name);
return i == this->name2id.end() ? nullopt : optional<unsigned>(i->second);
}
optional<std::string> lookup(unsigned id) const {
auto i = this->id2name.find(id);
return i == this->id2name.end() ? nullopt
: optional<std::string>(i->second);
}
// Remove a surface id and name
void remove_id(std::string const &name) {
auto i = this->name2id.find(name);
if (i != this->name2id.end()) {
this->id2name.erase(i->second);
this->name2id.erase(i);
}
}
void remove_id(unsigned id) {
auto i = this->id2name.find(id);
if (i != this->id2name.end()) {
this->name2id.erase(i->second);
this->id2name.erase(i);
}
}
};
struct App {
enum EventType {
Event_Val_Min = 0,
Event_Active = Event_Val_Min,
Event_Inactive,
Event_Visible,
Event_Invisible,
Event_SyncDraw,
Event_FlushDraw,
Event_Val_Max = Event_FlushDraw,
};
const std::vector<const char *> kListEventName{
"active",
"inactive",
"visible",
"invisible",
"syncdraw",
"flushdraw"
};
struct binding_api api;
struct controller_hooks chooks;
// This is the one thing, we do not own.
struct wl::display *display;
std::unique_ptr<struct genivi::controller> controller;
std::vector<std::unique_ptr<struct wl::output>> outputs;
struct config config;
// track current layouts separately
layer_map layers;
// ID allocation and proxy methods for lookup
struct id_allocator id_alloc;
// Set by AFB API when wayland events need to be dispatched
std::atomic<bool> pending_events;
std::vector<int> pending_end_draw;
Policy policy;
std::map<const char *, struct afb_event> map_afb_event;
explicit App(wl::display *d);
~App() = default;
App(App const &) = delete;
App &operator=(App const &) = delete;
App(App &&) = delete;
App &operator=(App &&) = delete;
int init();
int dispatch_events();
int dispatch_pending_events();
void set_pending_events();
result<int> api_request_surface(char const *drawing_name);
char const *api_activate_surface(char const *drawing_name, char const *drawing_area);
char const *api_deactivate_surface(char const *drawing_name);
char const *api_enddraw(char const *drawing_name);
char const *api_subscribe(afb_req *req, char const *event_name);
void api_ping();
// Events from the compositor we are interested in
void surface_created(uint32_t surface_id);
void surface_removed(uint32_t surface_id);
private:
optional<int> lookup_id(char const *name);
optional<std::string> lookup_name(int id);
bool pop_pending_events();
void enqueue_flushdraw(int surface_id);
void check_flushdraw(int surface_id);
int init_layers();
void surface_set_layout(int surface_id, optional<int> sub_surface_id = nullopt);
void layout_commit();
// TMC WM Events to clients
void emit_activated(char const *label);
void emit_deactivated(char const *label);
void emit_syncdraw(char const *label, char const *area);
void emit_flushdraw(char const *label);
void emit_visible(char const *label, bool is_visible);
void emit_invisible(char const *label);
void emit_visible(char const *label);
void activate(int id);
void deactivate(int id);
void deactivate_main_surface();
bool can_split(struct LayoutState const &state, int new_id);
void try_layout(struct LayoutState &state,
struct LayoutState const &new_layout,
std::function<void(LayoutState const &nl)> apply);
};
} // namespace wm
#endif // TMCAGLWM_APP_HPP
|
