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
|
/*
* 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 <memory>
#include <unordered_map>
#include <unordered_set>
#include <deque>
#include "afb_binding_api.hpp"
#include "config.hpp"
#include "controller_hooks.hpp"
#include "layers.hpp"
#include "layout.hpp"
#include "result.hpp"
#include "wayland.hpp"
namespace wl {
struct display;
}
namespace genivi {
struct controller;
}
namespace wm {
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> surfaces;
// std::unordered_set<unsigned> pending_surfaces;
std::unordered_map<std::string, unsigned> names;
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->surfaces[sid] = name;
// this->pending_surfaces.insert({sid});
this->names[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->names.find(name);
return i == this->names.end() ? nullopt : optional<unsigned>(i->second);
}
optional<std::string> lookup(unsigned id) const {
auto i = this->surfaces.find(id);
return i == this->surfaces.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->names.find(name);
if (i != this->names.end()) {
this->surfaces.erase(i->second);
this->names.erase(i);
}
}
void remove_id(unsigned id) {
auto i = this->surfaces.find(id);
if (i != this->surfaces.end()) {
this->names.erase(i->second);
this->surfaces.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;
layouts_type layouts;
layer_map layers;
typedef std::pair<char const *, std::function<void()>> name_task_pair;
std::vector<name_task_pair> pending;
typedef std::map<std::string, int> drawing_name_map;
drawing_name_map name_mapping;
struct id_allocator id_alloc;
std::deque<unsigned> last_active;
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 init_layout();
int dispatch_events();
void surface_set_layout(uint32_t surface_id);
char const *activate_surface(uint32_t surface_id);
char const *deactivate_surface(uint32_t surface_id);
// Allocate a surface ID for this role
result<int> request_surface(char const *drawing_name);
// Activate (i.e. make visible, if allowed!) a surface
char const *activate_surface(char const *drawing_name);
char const *deactivate_surface(char const *drawing_name);
// add tasks, executed after dispatch_events()
void add_task(char const *name, std::function<void()> &&f);
void execute_pending();
// Events from the compositor we are interested in
void surface_created(uint32_t surface_id);
void surface_removed(uint32_t surface_id);
// 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_visible(char const *label, bool is_visible);
};
} // namespace wm
#endif // TMCAGLWM_APP_HPP
|
