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
|
/*
* 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;
struct id_allocator {
constexpr static const unsigned id_shift = 22;
constexpr static const unsigned id_mask = (1 << id_shift) - 1;
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
// I don't think I will need this, do I?
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 {
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;
explicit App(wl::display *d);
~App();
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 *api_deactivate_surface(char const *drawing_name);
char const *api_enddraw(char const *drawing_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);
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
|
