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
|
/*
* 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 <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;
};
class AGLScreenInfo
{
public:
unsigned long width_dp(void) const { return _width_dp; };
unsigned long height_dp(void) const { return _height_dp; };
unsigned long width_mm(void) const { return _width_mm; };
unsigned long height_mm(void) const { return _height_mm; };
double scale_factor(void) const { return _scale; };
void set_width_dp(unsigned long w) { _width_dp = w; };
void set_height_dp(unsigned long h) { _height_dp = h; };
void set_width_mm(unsigned long w) { _width_mm = w; };
void set_height_mm(unsigned long h) { _height_mm = h; };
void set_scale_factor(double scale) { _scale = scale; };
private:
unsigned long _width_dp;
unsigned long _height_dp;
unsigned long _width_mm;
unsigned long _height_mm;
double _scale = 1.0;
};
class LibWindowmanager {
public:
LibWindowmanager();
~LibWindowmanager();
LibWindowmanager(const LibWindowmanager &) = delete;
LibWindowmanager &operator=(const LibWindowmanager &) = delete;
using handler_fun = std::function<void(json_object *)>;
using visible_handler = std::function<void(const char*)>;
using invisible_handler = std::function<void(const char*)>;
using active_handler = std::function<void(const char*)>;
using inactive_handler = std::function<void(const char*)>;
using sync_draw_handler = std::function<void(const char*, const char*, const Rect&)>;
using flush_draw_handler= std::function<void(const char*)>;
using screen_update_handler = std::function<void(const std::vector<std::string>&)>;
/* DrawingArea name (usage: {layout}.{area}) */
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);
// WM API
int requestSurface(const char* role);
int requestSurfaceXDG(const char* role, unsigned ivi_id);
int activateWindow(const char* role, const char* area);
int deactivateWindow(const char* role);
int endDraw(const char* role);
int getDisplayInfo(AGLScreenInfo *out_info);
int getAreaInfo(const char* role, Rect *out_rect);
void setVisibleHandler(visible_handler f);
void setInvisibleHandler(invisible_handler f);
void setActiveHandler(active_handler f);
void setInactiveHandler(inactive_handler f);
void setSyncDrawHandler(sync_draw_handler f);
void setFlushDrawHandler(flush_draw_handler f);
void setScreenUpdatedHandler(screen_update_handler f);
// 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);
struct Impl;
// 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));
private:
Impl *const d;
};
#endif // LIBWINDOWMANAGER_H
|
