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
|
/*
* 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.
*/
#include <string>
#include <memory>
#include <vector>
#include <unordered_map>
#include <functional>
#include <ilm/ilm_control.h>
#include "wm_error.hpp"
#include "util.hpp"
namespace wm {
class Screen {
public:
Screen(unsigned id, unsigned w, unsigned h) : _screen_id(id), _width(w), _height(h){}
unsigned width() const { return _width; }
unsigned height() const { return _height; }
unsigned id() const { return _screen_id; }
unsigned scale() const { return _scale; }
int offsetX() const { return _offset_x; }
int offsetY() const { return _offset_y; }
void setScale(double scl) { this->_scale = scl; }
void setOffset(int x, int y) { this->_offset_x = x; this->_offset_y = y; }
private:
unsigned _screen_id;
unsigned _width;
unsigned _height;
unsigned _pysical_width = 0;
unsigned _pysical_height = 0;
int _offset_x = 0;
int _offset_y = 0;
double _scale = 1.0;
};
class LayerControlCallbacks {
public:
LayerControlCallbacks() {};
~LayerControlCallbacks() = default;
LayerControlCallbacks(const LayerControlCallbacks &obj) = default;
// callback functions
std::function<void(unsigned, unsigned)> surfaceCreated;
std::function<void(unsigned)> surfaceDestroyed;
/*
std::function<void(unsigned)> layerCreated;
std::function<void(unsigned)> layerDestroyed;
*/
};
class WMLayer;
class LayerState;
class WMAction;
class WMClient;
class LayerControl
{
public:
explicit LayerControl(const std::string& root, const std::string& ecu_name);
~LayerControl() = default;
WMError init(const LayerControlCallbacks& cb);
void createNewLayer(unsigned id);
void createNewRemoteLayer(unsigned id);
unsigned getNewLayerID(const std::string& role, std::string* layer_name);
std::shared_ptr<WMLayer> getWMLayer(unsigned layer);
std::shared_ptr<WMLayer> getWMLayer(std::string layer_name);
struct rect getAreaSize(const std::string& area);
void setupArea(const rectangle& base_rct, double scaling);
Screen getScreenInfo();
double scale();
WMError updateLayer(LayerState& layer_state);
WMError renderLayers();
// WMError renderLayersRemote();
WMError setXDGSurfaceOriginSize(unsigned surface);
void undoUpdate();
WMError layoutChange(const WMAction& action);
WMError visibilityChange(const WMAction &action);
const std::unordered_map<std::string, struct rect>& getAreaList() {return this->area2size;}
WMError updateAreaList(const ChangeAreaReq& req);
WMError getUpdateAreaList(ChangeAreaReq* req);
WMError changeAreaSize(std::shared_ptr<WMClient> client, const std::string& area);
void appTerminated(const std::shared_ptr<WMClient> client);
// Don't use this function.
void dispatchCreateEvent(ilmObjectType object, unsigned id, bool created);
void dispatchSurfacePropChangeEvent(unsigned id, struct ilmSurfaceProperties*, t_ilm_notification_mask);
void dispatchLayerPropChangeEvent(unsigned id, struct ilmLayerProperties*, t_ilm_notification_mask);
bool hasRemoteLayer(unsigned layer);
private:
WMError makeVisible(const std::shared_ptr<WMClient> client);
WMError makeInvisible(const std::shared_ptr<WMClient> client);
bool moveForeGround(const std::shared_ptr<WMClient> client);
bool moveBackGround(const std::shared_ptr<WMClient> client);
bool moveRemote(unsigned layer, const std::string& area);
bool moveLocal(unsigned layer);
int loadWestonSetting(const std::string &path);
WMError loadLayerSetting(const std::string& path);
WMError loadAreasConfigFile(const std::string& path, const std::string& ecu_name);
std::vector<std::shared_ptr<WMLayer>> wm_layers;
std::vector<Screen> wm_screens;
std::unordered_map<unsigned, unsigned> lid2wmlid;
std::unordered_map<std::string, struct rect> area2size;
unsigned screenID;
double scaling;
int offset_x;
int offset_y;
LayerControlCallbacks cb;
long times;
long sleep;
};
} // namespace wm
|
