#include "app.hpp"
#include "json_helper.hpp"
+#include "layers.hpp"
+#include "layout.hpp"
#include "util.hpp"
#include "wayland.hpp"
+#include <cstdio>
+#include <memory>
+
#include <cassert>
#include <json-c/json.h>
+#include <fstream>
+#include <json.hpp>
+
namespace wm {
namespace {
App *g_app;
+
+using json = nlohmann::json;
+
+struct wm::area area_from_json(json const &j) {
+ DB(j);
+ return wm::area{
+ j["name"].get<std::string>(),
+ {
+ get<uint32_t>(j["width"]), get<uint32_t>(j["height"]),
+ get<int32_t>(j["x"]), get<int32_t>(j["y"]),
+ },
+ get<uint32_t>(j["zorder"]),
+ };
+}
+
+result<struct layout> layout_from_json(json const &j) {
+ DB(j);
+ auto &ja = j["areas"];
+
+ auto l = wm::layout{j["name"].get<std::string>(), uint32_t(ja.size()), {}};
+
+ if (ja.size() > layout::MAX_N_AREAS) {
+ return Err<struct layout>("Invalid number of areas in layout");
+ }
+
+ logdebug("Loading layout '%s' with %u areas", l.name.c_str(),
+ unsigned(ja.size()));
+
+ std::transform(std::cbegin(ja), std::cend(ja), std::begin(l.areas),
+ area_from_json);
+
+ return Ok(l);
+}
+
+struct result<layouts_type> load_layout(char const *filename) {
+ DB("loading layout from " << filename);
+
+ json jlayouts;
+ std::ifstream i(filename);
+ i >> jlayouts;
+
+ auto layouts = layouts_type();
+ std::transform(std::cbegin(jlayouts), std::cend(jlayouts),
+ std::back_inserter(layouts), layout_from_json);
+
+ return Ok(layouts);
+}
+
+struct result<surface_id_to_layer_map>
+ load_layer_ids(char const *filename) {
+ DB("loading IDs from " << filename);
+
+ json jids;
+ std::ifstream i(filename);
+ i >> jids;
+
+ auto m = to_surface_id_to_layer_map(jids["mappings"]);
+
+ if (m.is_ok()) {
+ auto i = m.unwrap();
+
+ auto jtests = jids.value("tests", json());
+
+ std::vector<std::pair<int, int>> tests;
+ std::transform(std::cbegin(jtests), std::cend(jtests),
+ std::back_inserter(tests), [](json const &j) {
+ return std::make_pair(get<int>(j["surface_id"]),
+ get<int>(j["expect_layer_id"]));
+ });
+
+ for (auto sid : tests) {
+ if (i.get_layer_for_surface(sid.first).value_or(-1) != sid.second) {
+ return Err<surface_id_to_layer_map>("ID Map embedded test failed!");
+ }
+ }
+ }
+
+ return m;
+}
+
} // namespace
-App::App(wl::display *d) : api{this}, display{d}, controller{}, outputs() {
+App::App(wl::display *d)
+ : api{this}, display{d}, controller{} {
+ // layouts(load_layout("../layout.json").unwrap()) {
assert(g_app == nullptr);
g_app = this;
+
+ auto a = load_layout("../layout.json");
+ auto b = a.map_err([](char const *e) -> char const * {
+ DB("Could not load layout: " << e);
+ return e;
+ });
+
+ auto c = load_layer_ids("../ids.json");
+ auto e = c.map_err([](char const *e) -> char const * {
+ DB("Could not load ids: " << e);
+ return e;
+ });
}
+App::~App() { g_app = nullptr; }
+
int App::init() {
if (!this->display->ok()) {
return -1;
}
- this->display->r.add_global_handler(
- "wl_output", [](wl_registry *r, uint32_t name, uint32_t v) {
- g_app->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
+ this->display->add_global_handler(
+ "wl_output", [this](wl_registry *r, uint32_t name, uint32_t v) {
+ this->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
});
- this->display->r.add_global_handler(
- "ivi_controller", [](wl_registry *r, uint32_t name, uint32_t v) {
- g_app->controller = std::make_unique<genivi::controller>(r, name, v);
+ this->display->add_global_handler(
+ "ivi_controller", [this](wl_registry *r, uint32_t name, uint32_t v) {
+ this->controller = std::make_unique<genivi::controller>(r, name, v);
// XXX: This protocol needs the output, so lets just add our mapping
// here...
- g_app->controller->add_proxy_to_id_mapping(
- g_app->outputs.back()->proxy.get(),
+ this->controller->add_proxy_to_id_mapping(
+ this->outputs.back()->proxy.get(),
wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
- g_app->outputs.back()->proxy.get())));
+ this->outputs.back()->proxy.get())));
});
// First level objects