X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fapp.cpp;h=3ee4379c9f7f86ff84b9f6f9936ec0d9575947a9;hb=f7f02a664fc0438f00e6bd09797a3bf4184c123f;hp=53a1a86beb5550469a6bff8ad25722192af969c5;hpb=38da977e18f4b9e9a295119b8bac194a8a87a498;p=staging%2Fwindowmanager.git diff --git a/src/app.cpp b/src/app.cpp index 53a1a86..3ee4379 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -33,41 +33,15 @@ #include #include #include +#include +#include namespace wm { namespace { App *g_app; -using json = nlohmann::json; - -struct wm::area area_from_json(json const &j) { - return wm::area{ - j["name"], - { - j["width"], j["height"], j["x"], j["y"], - }, - j["zorder"], - }; -} - -result layout_from_json(json const &j) { - auto &ja = j["areas"]; - - auto l = layout{j["name"], uint32_t(ja.size()), {}}; - - if (ja.size() > layout::MAX_N_AREAS) { - return Err("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); -} +using nlohmann::json; result file_to_json(char const *filename) { std::ifstream i(filename); @@ -79,26 +53,7 @@ result file_to_json(char const *filename) { return Ok(j); } -// Will throw if parsing fails -struct result load_layout(char const *filename) { - logdebug("loading layout from %s", filename); - - auto j = file_to_json(filename); - if (j.is_err()) { - return Err(j.unwrap_err()); - } - json jlayouts = j.unwrap(); - - auto layouts = layouts_type(); - layouts.reserve(jlayouts.size()); - std::transform(std::cbegin(jlayouts), std::cend(jlayouts), - std::back_inserter(layouts), layout_from_json); - - return Ok(layouts); -} - -struct result - load_layer_map(char const *filename) { +struct result load_layer_map(char const *filename) { logdebug("loading IDs from %s", filename); auto j = file_to_json(filename); @@ -125,12 +80,10 @@ App::App(wl::display *d) controller{}, outputs(), config(), - layouts(), layers(), - pending(), - name_mapping(), id_alloc{}, - last_active() { + pending_events(false), + policy{} { assert(g_app == nullptr); g_app = this; @@ -144,16 +97,6 @@ App::App(wl::display *d) logerror("%s", l.err().value()); } } - - { - auto l = - load_layout(this->config.get_string("layout.json").value().c_str()); - if (l.is_ok()) { - this->layouts = l.unwrap(); - } else { - logerror("%s", l.err().value()); - } - } } catch (std::exception &e) { logerror("Loading of configuration failed: %s", e.what()); } @@ -178,7 +121,8 @@ int App::init() { this->display->add_global_handler( "ivi_controller", [this](wl_registry *r, uint32_t name, uint32_t v) { - this->controller = std::make_unique(r, name, v); + this->controller = + std::make_unique(r, name, v); // Init controller hooks this->controller->chooks = &this->chooks; @@ -198,10 +142,14 @@ int App::init() { // Third level objects this->display->roundtrip(); - return init_layout(); + return init_layers(); } int App::dispatch_events() { + if (this->dispatch_events() == 0) { + return 0; + } + int ret = this->display->dispatch(); if (ret == -1) { logerror("wl_display_dipatch() returned error %d", @@ -210,19 +158,41 @@ int App::dispatch_events() { } this->display->flush(); - // execute pending tasks, that is layout changes etc. - this->execute_pending(); - return 0; } +int App::dispatch_pending_events() { + if (this->pop_pending_events()) { + this->display->dispatch_pending(); + return 0; + } + return -1; +} + +bool App::pop_pending_events() { + bool x{true}; + return this->pending_events.compare_exchange_strong( + x, false, std::memory_order_consume); +} + +void App::set_pending_events() { + this->pending_events.store(true, std::memory_order_release); +} + +optional App::lookup_id(char const *name) { + return this->id_alloc.lookup(std::string(name)); +} +optional App::lookup_name(int id) { + return this->id_alloc.lookup(id); +} + // _ _ _ _ _ ____ // (_)_ __ (_) |_ | | __ _ _ _ ___ _ _| |_ / /\ \ // | | '_ \| | __| | |/ _` | | | |/ _ \| | | | __| | | | // | | | | | | |_ | | (_| | |_| | (_) | |_| | |_| | | | // |_|_| |_|_|\__|___|_|\__,_|\__, |\___/ \__,_|\__| | | | // |_____| |___/ \_\/_/ -int App::init_layout() { +int App::init_layers() { if (!this->controller) { logerror("ivi_controller global not available"); return -1; @@ -252,40 +222,66 @@ int App::init_layout() { // XXX: This likely needs to be sorted by order (note, we don't (yet?) // do any zorder arrangement). for (auto const &i : this->layers.mapping) { - c->layer_create(i.layer_id, o->width, o->height); - auto &l = layers[i.layer_id]; + c->layer_create(i.second.layer_id, o->width, o->height); + auto &l = layers[i.second.layer_id]; l->set_destination_rectangle(0, 0, o->width, o->height); l->set_visibility(1); - logdebug("Setting up layer %s (%d) for surfaces %d-%d", i.name.c_str(), - i.layer_id, i.id_min, i.id_max); + logdebug("Setting up layer %s (%d) for surface role match \"%s\"", + i.second.name.c_str(), i.second.layer_id, i.second.role.c_str()); } // Add layers to screen (XXX: are they sorted correctly?) s->set_render_order(this->layers.layers); - c->commit_changes(); - - this->display->flush(); + this->layout_commit(); return 0; } -void App::surface_set_layout(uint32_t surface_id) { +namespace { + +#ifdef WE_LIKE_NOT_TO_USE_THIS +// This can fix the HomeScreen... +void redraw_fix(App *app, std::unique_ptr &s, int x, int y, + int w, int h) { + { // XXX: Work around weston redraw issues + // trigger an update by changing the source dimensions! + s->set_configuration(w + 1, h); + s->set_source_rectangle(0, 0, w + 1, h); + s->set_destination_rectangle(x, y, w + 1, h); + app->controller->commit_changes(); + app->display->roundtrip(); + + // wait some time, for the process to do its thing... + using namespace std::chrono_literals; + std::this_thread::sleep_for(100ms); + + // Set a different size then what we actually want. + s->set_configuration(w, h); + s->set_source_rectangle(0, 0, w, h); + s->set_destination_rectangle(x, y, w, h); + app->controller->commit_changes(); + app->display->roundtrip(); + } +} +#endif + +} // namespace + +void App::surface_set_layout(int surface_id, optional sub_surface_id) { if (!this->controller->surface_exists(surface_id)) { - logerror("Surface %d does not exist", int(surface_id)); + logerror("Surface %d does not exist", surface_id); return; } auto o_layer_id = this->layers.get_layer_id(surface_id); if (!o_layer_id) { - logerror("Surface %d is not associated with any layer!", int(surface_id)); + logerror("Surface %d is not associated with any layer!", surface_id); return; } - uint32_t layer_id = o_layer_id.value(); - logdebug("surface_set_layout for surface %u on layer %u", surface_id, - layer_id); + uint32_t layer_id = *o_layer_id; auto const &layer = this->layers.get_layer(layer_id); auto rect = layer.value().rect; @@ -305,6 +301,42 @@ void App::surface_set_layout(uint32_t surface_id) { h = this->controller->output_size.h + 1 + h; } + if (sub_surface_id) { + if (o_layer_id != this->layers.get_layer_id(*sub_surface_id)) { + logerror( + "surface_set_layout: layers of surfaces (%d and %d) don't match!", + surface_id, *sub_surface_id); + return; + } + + int x_off = 0; + int y_off = 0; + + // split along major axis + if (w > h) { + w /= 2; + x_off = w; + } else { + h /= 2; + y_off = h; + } + + auto &ss = this->controller->surfaces[*sub_surface_id]; + + logdebug("surface_set_layout for sub surface %u on layer %u", + *sub_surface_id, layer_id); + + // configure surface to wxh dimensions + ss->set_configuration(w, h); + // set source reactangle, even if we should not need to set it. + ss->set_source_rectangle(0, 0, w, h); + // set destination to the display rectangle + ss->set_destination_rectangle(x + x_off, y + y_off, w, h); + } + + logdebug("surface_set_layout for surface %u on layer %u", surface_id, + layer_id); + // configure surface to wxh dimensions s->set_configuration(w, h); // set source reactangle, even if we should not need to set it. @@ -312,100 +344,238 @@ void App::surface_set_layout(uint32_t surface_id) { // set destination to the display rectangle s->set_destination_rectangle(x, y, w, h); - // XXX: The main_surface will be visible regardless - s->set_visibility( - surface_id == static_cast(this->layers.main_surface) ? 1 : 0); - this->controller->layers[layer_id]->add_surface(s.get()); + // redraw_fix(this, s, x, y, w, h); + // redraw_fix(this, ss, x+x_off, y+y_off, w, h); logdebug("Surface %u now on layer %u with rect { %d, %d, %d, %d }", surface_id, layer_id, x, y, w, h); } -char const *App::activate_surface(uint32_t surface_id) { - if (!this->controller->surface_exists(surface_id)) { +void App::layout_commit() { + this->controller->commit_changes(); + this->display->flush(); +} + +char const *App::api_activate_surface(char const *drawing_name) { + ST(); + auto const &surface_id = this->lookup_id(drawing_name); + + if (!surface_id) { return "Surface does not exist"; } - // This should involve a policy check, but as we do not (yet) have - // such a thing, we will just switch to this surface. - // XXX: input focus missing!!1 + if (!this->controller->surface_exists(*surface_id)) { + return "Surface does not exist in controller!"; + } + + auto layer_id = this->layers.get_layer_id(*surface_id); - // Make it visible, no (or little effect) if already visible - auto &s = this->controller->surfaces[surface_id]; + if (!layer_id) { + return "Surface is not on any layer!"; + } + + auto o_state = *this->layers.get_layout_state(*surface_id); + + if (o_state == nullptr) { + return "Could not find layer for surface"; + } + + struct LayoutState &state = *o_state; + + // disable layers that are above our current layer + for (auto const &l : this->layers.mapping) { + if (l.second.layer_id <= *layer_id) { + continue; + } + + bool flush = false; + if (l.second.state.main != -1) { + this->deactivate(l.second.state.main); + l.second.state.main = -1; + flush = true; + } - // Set all others invisible - for (auto &i : this->controller->surfaces) { - auto &si = this->controller->sprops[i.second->id]; - if (si.visibility == 1 && si.id != s->id && - int(si.id) != this->layers.main_surface) { - i.second->set_visibility(0); + if (l.second.state.sub != -1) { + this->deactivate(l.second.state.sub); + l.second.state.sub = -1; + flush = true; + } + + if (flush) { + this->layout_commit(); } } - s->set_visibility(1); - // commit changes - this->controller->commit_changes(); - this->display->flush(); + if (state.main == *surface_id || state.sub == *surface_id) { + return "Surface already active"; + } - // Current active surface is the first in last_active - this->last_active.push_front(s->id); - /// // XXX: I am not sure I even need 5 elements... - /// this->last_active.resize(std::min(int(this->last_active.size()), 5)); + + if (state.main == -1) { + this->try_layout( + state, LayoutState{*surface_id}, [&] (LayoutState const &nl) { + this->surface_set_layout(*surface_id); + // XXX do we need to activate after enddraw? + this->activate(*surface_id); + state = nl; + this->layout_commit(); + this->emit_syncdraw(drawing_name); + this->enqueue_flushdraw(state.main); + }); + } else { + bool can_split = this->can_split(state, *surface_id); + + if (can_split) { + this->try_layout( + state, + LayoutState{state.main, *surface_id}, + [&] (LayoutState const &nl) { + std::string main = + std::move(*this->lookup_name(state.main)); + + this->surface_set_layout(state.main, surface_id); + this->activate(*surface_id); + if (state.sub != -1) { + this->deactivate(state.sub); + } + state = nl; + + this->layout_commit(); + this->emit_syncdraw(drawing_name); + this->emit_syncdraw(main.c_str()); + this->enqueue_flushdraw(state.main); + this->enqueue_flushdraw(state.sub); + }); + } else { + this->try_layout( + state, LayoutState{*surface_id}, [&] (LayoutState const &nl) { + this->surface_set_layout(*surface_id); + this->deactivate(state.main); + this->activate(*surface_id); + if (state.sub != -1) { + this->deactivate(state.sub); + } + state = nl; + + this->layout_commit(); + this->emit_syncdraw(drawing_name); + this->enqueue_flushdraw(state.main); + }); + } + } // no error return nullptr; } -char const *App::deactivate_surface(uint32_t surface_id) { - if (surface_id == this->layers.main_surface) { - return "Cannot deactivate main_surface"; +char const *App::api_deactivate_surface(char const *drawing_name) { + ST(); + auto const &surface_id = this->lookup_id(drawing_name); + + if (!surface_id) { + return "Surface does not exist"; } - if (this->last_active.empty()) { - return "Cannot deactivate surface (not active)"; + if (*surface_id == this->layers.main_surface) { + return "Cannot deactivate main_surface"; } - // XXX: should an active surface not alsways be front() or - // front+1() of last_active?! + auto o_state = *this->layers.get_layout_state(*surface_id); - // XXX: Should I really be able to deactivate a surface that is not - // front() of last_active? - auto is = std::find(this->last_active.begin(), - this->last_active.end(), - surface_id); + if (o_state == nullptr) { + return "Could not find layer for surface"; + } + + struct LayoutState &state = *o_state; - if (is == this->last_active.end()) { - return "Cannot deactivate surface (not active)"; + if (state.main == -1) { + return "No surface active"; } - this->last_active.erase(is); + // XXX: check against main_surface, main_surface_name is the configuration + // item. + if (*surface_id == this->layers.main_surface) { + logdebug("Refusing to deactivate main_surface %d", *surface_id); + return nullptr; + } - if (! this->last_active.empty()) { - // Should be active already, shouldn't it? - this->activate_surface(this->last_active.front()); + if (state.main == *surface_id) { + if (state.sub != -1) { + this->try_layout( + state, LayoutState{state.sub, -1}, [&] (LayoutState const &nl) { + std::string sub = std::move(*this->lookup_name(state.sub)); + + this->deactivate(*surface_id); + this->surface_set_layout(state.sub); + state = nl; + + this->layout_commit(); + this->emit_syncdraw(sub.c_str()); + this->enqueue_flushdraw(state.sub); + }); + } else { + this->try_layout(state, LayoutState{-1, -1}, [&] (LayoutState const &nl) { + this->deactivate(*surface_id); + state = nl; + this->layout_commit(); + }); + } + } else if (state.sub == *surface_id) { + this->try_layout( + state, LayoutState{state.main, -1}, [&] (LayoutState const &nl) { + std::string main = std::move(*this->lookup_name(state.main)); + + this->deactivate(*surface_id); + this->surface_set_layout(state.main); + state = nl; + + this->layout_commit(); + this->emit_syncdraw(main.c_str()); + this->enqueue_flushdraw(state.main); + }); } else { - this->activate_surface(this->layers.main_surface); + return "Surface is not active"; } return nullptr; } -void App::add_task(char const *name, std::function &&f) { - this->pending.emplace_back(std::make_pair(name, f)); +void App::enqueue_flushdraw(int surface_id) { + this->check_flushdraw(surface_id); + logdebug("Enqueuing EndDraw for surface_id %d", surface_id); + this->pending_end_draw.push_back(surface_id); } -void App::execute_pending() { - if (!this->pending.empty()) { - for (auto &t : this->pending) { - logdebug("executing task '%s'", t.first); - t.second(); +void App::check_flushdraw(int surface_id) { + auto i = std::find(std::begin(this->pending_end_draw), + std::end(this->pending_end_draw), surface_id); + if (i != std::end(this->pending_end_draw)) { + auto n = this->lookup_name(surface_id); + logerror("Application %s (%d) has pending EndDraw call(s)!", + n ? n->c_str() : "unknown-name", surface_id); + std::swap(this->pending_end_draw[std::distance( + std::begin(this->pending_end_draw), i)], + this->pending_end_draw.back()); + this->pending_end_draw.resize(this->pending_end_draw.size() - 1); + } +} + +char const *App::api_enddraw(char const *drawing_name) { + for (unsigned i = 0, iend = this->pending_end_draw.size(); i < iend; i++) { + auto n = this->lookup_name(this->pending_end_draw[i]); + if (n && *n == drawing_name) { + std::swap(this->pending_end_draw[i], this->pending_end_draw[iend - 1]); + this->pending_end_draw.resize(iend - 1); + // XXX: Please tell the compositor to thaw the surface... + this->emit_flushdraw(drawing_name); + return nullptr; } - this->pending.clear(); - this->controller->commit_changes(); - this->display->flush(); } + return "No EndDraw pending for surface"; } +void App::api_ping() { this->dispatch_pending_events(); } + // _ _ _____ _ // _ __ _ __ _____ _(_) ___ __| | | ____|_ _____ _ __ | |_ ___ // | '_ \| '__/ _ \ \/ / |/ _ \/ _` | | _| \ \ / / _ \ '_ \| __/ __| @@ -413,67 +583,89 @@ void App::execute_pending() { // | .__/|_| \___/_/\_\_|\___|\__,_| |_____| \_/ \___|_| |_|\__|___/ // |_| void App::surface_created(uint32_t surface_id) { - surface_id &= id_allocator::id_mask; + auto layer_id = this->layers.get_layer_id(surface_id); + if (!layer_id) { + logdebug("Newly created surfce %d is not associated with any layer!", + surface_id); + return; + } - logdebug("surface_id is %u", surface_id); + logdebug("surface_id is %u, layer_id is %u", surface_id, *layer_id); + + this->controller->layers[*layer_id]->add_surface( + this->controller->surfaces[surface_id].get()); + + // activate the main_surface right away + if (surface_id == static_cast(this->layers.main_surface)) { + logdebug("Activating main_surface (%d)", surface_id); - // We need to execute the surface setup after its creation. - this->add_task("surface_set_layout", - [surface_id, this] { this->surface_set_layout(surface_id); }); + this->api_activate_surface( + this->lookup_name(surface_id).value_or("unknown-name").c_str()); + } } void App::surface_removed(uint32_t surface_id) { - surface_id &= id_allocator::id_mask; - logdebug("surface_id is %u", surface_id); - this->add_task("remove surface ID", - [surface_id, this] { - this->id_alloc.remove_id(surface_id); + // We cannot normally deactivate the main_surface, so be explicit + // about it: + if (int(surface_id) == this->layers.main_surface) { + this->deactivate_main_surface(); + } else { + auto drawing_name = this->lookup_name(surface_id); + if (drawing_name) { + this->api_deactivate_surface(drawing_name->c_str()); + } + } - // Also remove from last_active, if found - auto i = std::find(this->last_active.begin(), - this->last_active.end(), surface_id); - if (i != this->last_active.end()) { - this->last_active.erase(i); - } - }); + this->id_alloc.remove_id(surface_id); + this->layers.remove_surface(surface_id); } void App::emit_activated(char const *label) { - this->api.send_event("activated", json_object_new_string(label)); + this->api.send_event("active", label); } void App::emit_deactivated(char const *label) { - this->api.send_event("deactivated", json_object_new_string(label)); + this->api.send_event("inactive", label); } void App::emit_syncdraw(char const *label) { - this->api.send_event("syncdraw", json_object_new_string(label)); + this->api.send_event("syncdraw", label); +} + +void App::emit_flushdraw(char const *label) { + this->api.send_event("flushdraw", label); } void App::emit_visible(char const *label, bool is_visible) { - this->api.send_event(is_visible ? "visible" : "invisible", json_object_new_string(label)); + this->api.send_event(is_visible ? "visible" : "invisible", label); +} + +void App::emit_invisible(char const *label) { + return emit_visible(label, false); } -result App::request_surface(char const *drawing_name) { +void App::emit_visible(char const *label) { return emit_visible(label, true); } + +result App::api_request_surface(char const *drawing_name) { auto lid = this->layers.get_layer_id(std::string(drawing_name)); if (!lid) { // XXX: to we need to put these applications on the App layer? return Err("Drawing name does not match any role"); } - auto rname = this->id_alloc.lookup(drawing_name); + auto rname = this->lookup_id(drawing_name); if (!rname) { // name does not exist yet, allocate surface id... auto id = int(this->id_alloc.generate_id(drawing_name)); - this->layers.add_surface(id, lid.value()); + this->layers.add_surface(id, *lid); - // XXX: you should fix this! + // XXX: we set the main_surface[_name] here and now, + // not sure if we want this, but it worked so far. if (!this->layers.main_surface_name.empty() && this->layers.main_surface_name == drawing_name) { this->layers.main_surface = id; - this->activate_surface(id); logdebug("Set main_surface id to %u", id); } @@ -484,123 +676,78 @@ result App::request_surface(char const *drawing_name) { return Err("Surface already present"); } -char const *App::activate_surface(char const *drawing_name) { - auto osid = this->id_alloc.lookup(drawing_name); - - if (osid) { - logdebug("ativate surface with name %s and id %u", drawing_name, - osid.value()); - auto ret = this->activate_surface(osid.value()); - if (!ret) { - this->emit_activated(drawing_name); - } - return ret; +void App::activate(int id) { + auto ip = this->controller->sprops.find(id); + if (ip != this->controller->sprops.end() && ip->second.visibility == 0) { + this->controller->surfaces[id]->set_visibility(1); + char const *label = + this->lookup_name(id).value_or("unknown-name").c_str(); + this->emit_activated(label); + this->emit_visible(label); } - - logerror("surface %s unknown", drawing_name); - return "Surface unknown"; } -char const *App::deactivate_surface(char const *drawing_name) { - auto osid = this->id_alloc.lookup(drawing_name); - - if (osid) { - logdebug("deativate surface with name %s and id %u", drawing_name, - osid.value()); - return this->deactivate_surface(osid.value()); +void App::deactivate(int id) { + auto ip = this->controller->sprops.find(id); + if (ip != this->controller->sprops.end() && ip->second.visibility != 0) { + this->controller->surfaces[id]->set_visibility(0); + char const *label = + this->lookup_name(id).value_or("unknown-name").c_str(); + this->emit_deactivated(label); + this->emit_invisible(label); } - - logerror("surface %s unknown", drawing_name); - return "Surface unknown"; } -// _ _ _ _ _ _ _ -// | |__ (_)_ __ __| (_)_ __ __ _ __ _ _ __ (_) (_)_ __ ___ _ __ | | -// | '_ \| | '_ \ / _` | | '_ \ / _` | / _` | '_ \| | | | '_ ` _ \| '_ \| | -// | |_) | | | | | (_| | | | | | (_| | | (_| | |_) | | | | | | | | | |_) | | -// |_.__/|_|_| |_|\__,_|_|_| |_|\__, |___\__,_| .__/|_| |_|_| |_| |_| .__/|_| -// |___/_____| |_| |_| -binding_api::result_type binding_api::request_surface( - char const *drawing_name) { - auto r = this->app->request_surface(drawing_name); - if (r.is_err()) { - return Err(r.unwrap_err()); - } - return Ok(json_object_new_int(r.unwrap())); +void App::deactivate_main_surface() { + this->layers.main_surface = -1; + this->api_deactivate_surface(this->layers.main_surface_name.c_str()); } -binding_api::result_type binding_api::activate_surface( - char const *drawing_name) { - logdebug("%s drawing_name %s", __func__, drawing_name); - auto r = this->app->activate_surface(drawing_name); - if (r != nullptr) { - return Err(r); - } - return Ok(json_object_new_object()); -} +bool App::can_split(struct LayoutState const &state, int new_id) { + if (state.main != -1 && state.main != new_id) { + auto new_id_layer = this->layers.get_layer_id(new_id).value(); + auto current_id_layer = this->layers.get_layer_id(state.main).value(); -binding_api::result_type binding_api::deactivate_surface(char const* drawing_name) { - logdebug("%s drawing_name %s", __func__, drawing_name); - auto r = this->app->deactivate_surface(drawing_name); - if (r != nullptr) { - return Err(r); - } - return Ok(json_object_new_object()); -} + // surfaces are on separate layers, don't bother. + if (new_id_layer != current_id_layer) { + return false; + } -binding_api::result_type binding_api::enddraw(char const* drawing_name) { - logdebug("%s drawing_name %s", __func__, drawing_name); - return Err("not implemented"); -} + std::string const &new_id_str = this->lookup_name(new_id).value(); + std::string const &cur_id_str = this->lookup_name(state.main).value(); -binding_api::result_type binding_api::list_drawing_names() { - logdebug("%s", __func__); - json j = this->app->id_alloc.names; - return Ok(json_tokener_parse(j.dump().c_str())); -} + auto const &layer = this->layers.get_layer(new_id_layer); -binding_api::result_type binding_api::debug_layers() { - logdebug("%s", __func__); - return Ok(json_tokener_parse(this->app->layers.to_json().dump().c_str())); -} - -binding_api::result_type binding_api::debug_surfaces() { - logdebug("%s", __func__); - return Ok(to_json(this->app->controller->sprops)); -} + logdebug("layer info name: %s", layer->name.c_str()); -binding_api::result_type binding_api::debug_status() { - logdebug("%s", __func__); - json_object *jr = json_object_new_object(); - json_object_object_add(jr, "surfaces", - to_json(this->app->controller->sprops)); - json_object_object_add(jr, "layers", to_json(this->app->controller->lprops)); - return Ok(jr); -} - -binding_api::result_type binding_api::debug_terminate() { - logdebug("%s", __func__); - raise(SIGKILL); // XXX afb-daemon kills it's pgroup using TERM, which - // doesn't play well with perf - return Ok(json_object_new_object()); -} + if (layer->layouts.empty()) { + return false; + } -binding_api::result_type binding_api::demo_activate_surface( - uint32_t surfaceid) { - char const *e = this->app->activate_surface(surfaceid); - if (e != nullptr) { - return Err(e); + for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++) { + logdebug("%d main_match '%s'", new_id_layer, i->main_match.c_str()); + auto rem = std::regex(i->main_match); + if (std::regex_match(cur_id_str, rem)) { + // build the second one only if the first already matched + logdebug("%d sub_match '%s'", new_id_layer, i->sub_match.c_str()); + auto res = std::regex(i->sub_match); + if (std::regex_match(new_id_str, res)) { + logdebug("layout matched!"); + return true; + } + } + } } - return Ok(json_object_new_object()); + + return false; } -binding_api::result_type binding_api::demo_activate_all() { - for (auto &s : this->app->controller->surfaces) { - s.second->set_visibility(1); +void App::try_layout(struct LayoutState & /*state*/, + struct LayoutState const &new_layout, + std::function apply) { + if (this->policy.layout_is_valid(new_layout)) { + apply(new_layout); } - this->app->controller->commit_changes(); - this->app->display->flush(); - return Ok(json_object_new_object()); } // _ _ _ _ _ @@ -617,8 +764,13 @@ void controller_hooks::surface_removed(uint32_t surface_id) { this->app->surface_removed(surface_id); } -void controller_hooks::add_task(char const *name, std::function &&f) { - this->app->add_task(name, std::move(f)); -} +void controller_hooks::surface_visibility(uint32_t /*surface_id*/, + uint32_t /*v*/) {} + +void controller_hooks::surface_destination_rectangle(uint32_t /*surface_id*/, + uint32_t /*x*/, + uint32_t /*y*/, + uint32_t /*w*/, + uint32_t /*h*/) {} } // namespace wm