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
|
/*
* Copyright (c) 2017 TOYOTA MOTOR CORPORATION
*
* 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 LIBWINDOWMANAGER_H
#define LIBWINDOWMANAGER_H
#include <functional>
#include <vector>
#include <string>
#include <unordered_map>
#include <json-c/json.h>
class Rect {
public:
Rect() : _x(0), _y(0),_w(0), _h(0) {}
Rect(unsigned x, unsigned y, unsigned w, unsigned h)
: _x(x), _y(y),_w(w), _h(h) {}
~Rect() = default;
unsigned left() const { return _x;}
unsigned top() const { return _y;}
unsigned width() const { return _w;}
unsigned height() const { return _h;}
void set_left (unsigned int x) { _x = x; }
void set_top (unsigned int y) { _y = y; }
void set_width (unsigned int w) { _w = w; }
void set_height(unsigned int h) { _h = h; }
private:
unsigned _x;
unsigned _y;
unsigned _w;
unsigned _h;
};
struct Screen {
unsigned long width_dp;
unsigned long height_dp;
unsigned long width_mm;
unsigned long height_mm;
double scale = 1.0;
};
class WMHandler {
public:
WMHandler();
~WMHandler() = default;
using visible_handler = std::function<void(const char*, bool visible)>;
using active_handler = std::function<void(const char*, bool active)>;
using sync_draw_handler = std::function<void(const char*, const char*, Rect)>;
using flush_draw_handler= std::function<void(const char*)>;
using screen_updated_handler = std::function<void(const std::vector<std::string>&)>;
visible_handler on_visible;
active_handler on_active;
sync_draw_handler on_sync_draw;
flush_draw_handler on_flush_draw;
screen_updated_handler on_screen_updated;
};
class ChangeAreaReq {
public:
ChangeAreaReq() {}
~ChangeAreaReq() = default;
void setAreaReq(const std::unordered_map<std::string, Rect> &area_req) { this->_area_req = area_req; }
void addAreaReq(const std::string& area_name, const Rect& area_size) { this->_area_req[area_name] = area_size; }
void setSaveReq(bool save) { this->_save = save; }
bool getSave() const { return this->_save; }
void addAreaList(const std::string& area_name, const Rect& area_size){ this->_area_list[area_name] = area_size; }
const std::unordered_map<std::string, Rect>& getReq() const { return this->_area_req; }
const std::unordered_map<std::string, Rect>& getList() const { return this->_area_list; }
private:
std::unordered_map<std::string, Rect> _area_req;
std::unordered_map<std::string, Rect> _area_list;
bool _save = false;
};
class LibWindowmanager {
public:
LibWindowmanager();
~LibWindowmanager();
LibWindowmanager(const LibWindowmanager &) = delete;
LibWindowmanager &operator=(const LibWindowmanager &) = delete;
using handler_fun = std::function<void(json_object *)>;
/* DrawingArea name (usage: {layout}.{area}) */
const std::string kDefaultArea = "normal.full";
const std::string kStrLayoutNormal = "normal";
const std::string kStrLayoutSplit = "split";
const std::string kStrAreaFull = "full";
const std::string kStrAreaMain = "main";
const std::string kStrAreaSub = "sub";
/* Key for json obejct */
const char *kKeyDrawingName = "drawing_name";
const char *kKeyDrawingArea = "drawing_area";
const char *kKeyDrawingRect = "drawing_rect";
const char *kKeyIviId = "ivi_id";
enum EventType {
Event_Active = 0,
Event_Inactive,
Event_Visible,
Event_Invisible,
Event_SyncDraw,
Event_FlushDraw,
Event_ScreenUpdated,
Event_Error,
Event_Val_Max = Event_Error
};
int init(int port, char const *token);
int init(int port, const std::string &token);
// WM API
int requestSurface(const char* role);
int requestSurfaceXDG(const char* role, unsigned ivi_id);
int activateWindow(const char* role, const char* area);
int activateWindow(const char* role);
int deactivateWindow(const char* role);
int endDraw(const char* role);
struct Screen getScreenInfo();
int getAreaList(ChangeAreaReq* req);
int changeAreaSize(const ChangeAreaReq& req);
int getAreaInfo(const char* role, Rect *out_rect);
void setEventHandler(const WMHandler& wmh);
// Backward Compatible API
int requestSurface(json_object *object);
int requestSurfaceXDG(json_object *object);
int activateWindow(json_object *object);
int deactivateWindow(json_object *object);
int endDraw(json_object *object);
int getDisplayInfo(json_object *object);
int getAreaInfo(json_object *in_obj, json_object *out_obj);
int getAreaInfo(const char *label, json_object *out_obj);
void set_event_handler(enum EventType et, handler_fun f);
// These APIs are deprecated, please use new API
THIS_FUNCTION_IS_DEPRECATED(int activateSurface(json_object *object));
THIS_FUNCTION_IS_DEPRECATED(int deactivateSurface(json_object *object));
class Impl;
private:
Impl *const d;
};
#endif // LIBWINDOWMANAGER_H
|
