X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fapp.cpp;h=596391c1c1d7b77aaddab39b906617a37b8d82fe;hb=616ac2c0016f3936c1e8634c134807044e7bba68;hp=26dc5f62b7df364af757099920d7203082e9280e;hpb=28ea1b5c23d2814e32ad133ba833d87f73522087;p=staging%2Fwindowmanager.git diff --git a/src/app.cpp b/src/app.cpp index 26dc5f6..596391c 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -32,43 +32,16 @@ #include #include #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); @@ -80,24 +53,6 @@ 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) { logdebug("loading IDs from %s", filename); @@ -128,7 +83,8 @@ App::App(wl::display *d) config(), layouts(), layers(), - id_alloc{} { + id_alloc{}, + pending_events(false) { assert(g_app == nullptr); g_app = this; @@ -142,16 +98,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()); } @@ -176,7 +122,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; @@ -200,6 +147,10 @@ int App::init() { } 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", @@ -208,12 +159,17 @@ 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; +} + // _ _ _ _ _ ____ // (_)_ __ (_) |_ | | __ _ _ _ ___ _ _| |_ / /\ \ // | | '_ \| | __| | |/ _` | | | |/ _ \| | | | __| | | | @@ -254,8 +210,9 @@ int App::init_layers() { auto &l = layers[i.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 surfaces %d-%d and role match \"%s\"", i.name.c_str(), + i.layer_id, i.id_min, i.id_max, i.role.c_str()); + this->layouts[l->id] = LayoutState{}; } // Add layers to screen (XXX: are they sorted correctly?) @@ -270,9 +227,11 @@ int App::init_layers() { 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 +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); @@ -292,10 +251,11 @@ void redraw_fix(App *app, std::unique_ptr &s, int x, int y, int app->display->roundtrip(); } } +#endif } // namespace -void App::surface_init_layout(uint32_t surface_id) { +void App::surface_set_layout_full(uint32_t surface_id) { if (!this->controller->surface_exists(surface_id)) { logerror("Surface %d does not exist", int(surface_id)); return; @@ -339,58 +299,185 @@ void App::surface_init_layout(uint32_t surface_id) { // set destination to the display rectangle s->set_destination_rectangle(x, y, w, h); - s->set_visibility(0); - s->set_opacity(256); + //redraw_fix(this, s, x, y, w, h); - this->controller->commit_changes(); - this->display->roundtrip(); + logdebug("Surface %u now with rect { %d, %d, %d, %d }", + surface_id, x, y, w, h); +} + +void App::surface_set_layout_split(uint32_t surface_id, uint32_t sub_surface_id) { + if (!this->controller->surface_exists(surface_id)) { + logerror("Surface %d does not exist", int(surface_id)); + return; + } - redraw_fix(this, s, x, y, w, h); + auto o_layer_id = this->layers.get_layer_id(surface_id); - this->controller->layers[layer_id]->add_surface(s.get()); + if (!o_layer_id) { + logerror("Surface %d is not associated with any layer!", int(surface_id)); + return; + } - // activate the main_surface right away - if (surface_id == static_cast(this->layers.main_surface)) { - logdebug("Activating main_surface (%d)", surface_id); + uint32_t layer_id = o_layer_id.value(); + logdebug("surface_set_layout for surface %u on layer %u", surface_id, + layer_id); + + auto const &layer = this->layers.get_layer(layer_id); + auto rect = layer.value().rect; + auto &s = this->controller->surfaces[surface_id]; + auto &ss = this->controller->surfaces[sub_surface_id]; - this->activate_surface(this->lookup_name(surface_id).value_or("unknown-name").c_str()); + int x = rect.x; + int y = rect.y; + int w = rect.w; + int h = rect.h; + + // less-than-0 values refer to MAX + 1 - $VALUE + // e.g. MAX is either screen width or height + if (w < 0) { + w = this->controller->output_size.w + 1 + w; + } + if (h < 0) { + h = this->controller->output_size.h + 1 + h; } + 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; + } + + // configure surface to wxh dimensions + s->set_configuration(w, h); + // set source reactangle, even if we should not need to set it. + s->set_source_rectangle(0, 0, w, h); + // set destination to the display rectangle + s->set_destination_rectangle(x, y, w, h); + + // 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); + + //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(char const *drawing_name) { - int surface_id = -1; + ST(); + auto const &surface_id = this->lookup_id(drawing_name); - { - auto oid = this->lookup_id(drawing_name); - if (oid) { - surface_id = oid.value(); - } else { - return "Surface does not exist"; + if (!surface_id) { + return "Surface does not exist"; + } + + if (!this->controller->surface_exists(*surface_id)) { + return "Surface does not exist in controller!"; + } + + auto layer_id = this->layers.get_layer_id(*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) { + 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.layer_id <= *layer_id) { + continue; + } + + bool flush = false; + if (l.state.main != -1) { + this->deactivate(l.state.main); + l.state.main = -1; + flush = true; + } + + if (l.state.sub != -1) { + this->deactivate(l.state.sub); + l.state.sub = -1; + flush = true; + } + + l.state.s = LayoutState::Single; + + if (flush) { + this->controller->commit_changes(); + this->display->flush(); } } - if (!this->controller->surface_exists(surface_id)) { - return "Surface does not exist"; + if (state.main == *surface_id || state.sub == *surface_id) { + return "Surface already active"; } // 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 - // Make it visible, no (or little effect) if already visible - auto &s = this->controller->surfaces[surface_id]; + if (state.main == -1) { + this->emit_syncdraw(drawing_name); + + this->surface_set_layout_full(*surface_id); + this->activate(*surface_id); + state.main = *surface_id; + state.sub = -1; + state.s = LayoutState::Single; + + this->emit_flushdraw(drawing_name); + } else { + bool can_split = this->can_split(state, *surface_id); + + if (state.sub == -1) { + if (can_split) { + if (state.main != *surface_id) { + std::string main = std::move(*this->lookup_name(state.main)); + this->emit_syncdraw(drawing_name); + this->emit_syncdraw(main.c_str()); + + this->surface_set_layout_split(state.main, *surface_id); + this->activate(*surface_id); + state.sub = *surface_id; + + // Should wait for EndDraw event... + this->emit_flushdraw(drawing_name); + this->emit_flushdraw(main.c_str()); + } + } else { + this->emit_syncdraw(drawing_name); - // Set all others invisible - for (auto &i : this->controller->surfaces) { - auto &si = this->controller->sprops[i.second->id]; - if (si.visibility != 0 && int(si.id) != this->layers.main_surface) { - this->deactivate(i.second->id); + this->surface_set_layout_full(*surface_id); + this->deactivate(state.main); + this->activate(*surface_id); + this->deactivate(state.sub); + state.main = *surface_id; + state.sub = -1; + state.s = LayoutState::Single; + + this->emit_flushdraw(drawing_name); + } } } - this->activate(s->id); // commit changes this->controller->commit_changes(); @@ -401,22 +488,64 @@ char const *App::activate_surface(char const *drawing_name) { } char const *App::deactivate_surface(char const *drawing_name) { - int surface_id = -1; + ST(); + auto const &surface_id = this->lookup_id(drawing_name); - { - auto oid = this->lookup_id(drawing_name); - if (oid) { - surface_id = oid.value(); - } else { - return "Surface does not exist"; - } + if (!surface_id) { + return "Surface does not exist"; } - if (surface_id == this->layers.main_surface) { + if (*surface_id == this->layers.main_surface) { return "Cannot deactivate main_surface"; } - this->deactivate(surface_id); + auto o_state = *this->layers.get_layout_state(*surface_id); + + if (! o_state) { + return "Could not find layer for surface"; + } + + struct LayoutState &state = *o_state; + + if (state.main == -1) { + return "No surface active"; + } + + if (*surface_id == this->layers.main_surface) { + logdebug("Refusing to deactivate main_surface %d", *surface_id); + return nullptr; + } + + if (state.main == *surface_id) { + if (state.sub != -1) { + std::string sub = std::move(*this->lookup_name(state.sub)); + this->emit_syncdraw(sub.c_str()); + + this->deactivate(*surface_id); + this->surface_set_layout_full(state.sub); + state.main = state.sub; + state.sub = -1; + state.s = LayoutState::Single; + + this->emit_flushdraw(sub.c_str()); + } else { + this->deactivate(*surface_id); + state.main = -1; + } + }else if (state.sub == *surface_id) { + std::string main = std::move(*this->lookup_name(state.main)); + this->emit_syncdraw(main.c_str()); + + this->deactivate(*surface_id); + this->deactivate(*surface_id); + this->surface_set_layout_full(state.main); + state.sub = -1; + state.s = LayoutState::Single; + + this->emit_flushdraw(main.c_str()); + } else { + return "Surface is not active"; + } this->controller->commit_changes(); this->display->flush(); @@ -431,9 +560,24 @@ char const *App::deactivate_surface(char const *drawing_name) { // | .__/|_| \___/_/\_\_|\___|\__,_| |_____| \_/ \___|_| |_|\__|___/ // |_| void App::surface_created(uint32_t surface_id) { - logdebug("surface_id is %u", surface_id); + 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, layer_id is %u", surface_id, *layer_id); - this->surface_init_layout(surface_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); + + this->activate_surface( + this->lookup_name(surface_id).value_or("unknown-name").c_str()); + } } void App::surface_removed(uint32_t surface_id) { @@ -455,13 +599,17 @@ void App::emit_syncdraw(char const *label) { } void App::emit_flushdraw(char const *label) { - this->api.send_event("syncdraw", 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", label); } +void App::emit_invisible(char const *label) { return emit_visible(label, false); } + +void App::emit_visible(char const *label) { return emit_visible(label, true); } + result App::request_surface(char const *drawing_name) { auto lid = this->layers.get_layer_id(std::string(drawing_name)); if (!lid) { @@ -473,7 +621,7 @@ result App::request_surface(char const *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: we set the main_surface[_name] here and now, // not sure if we want this, but it worked so far. @@ -490,91 +638,65 @@ result App::request_surface(char const *drawing_name) { return Err("Surface already present"); } -void App::activate(unsigned id) { +void App::activate(int id) { if (this->controller->sprops[id].visibility == 0) { this->controller->surfaces[id]->set_visibility(1); - this->emit_activated( - this->lookup_name(id).value_or("unknown-name").c_str()); + char const *label = + this->lookup_name(id).value_or("unknown-name").c_str(); + this->emit_activated(label); + this->emit_visible(label); } } -void App::deactivate(unsigned id) { +void App::deactivate(int id) { if (this->controller->sprops[id].visibility != 0) { this->controller->surfaces[id]->set_visibility(0); - this->emit_deactivated( - this->lookup_name(id).value_or("unknown-name").c_str()); + char const *label = + this->lookup_name(id).value_or("unknown-name").c_str(); + this->emit_deactivated(label); + this->emit_invisible(label); } } -// _ _ _ _ _ _ _ -// | |__ (_)_ __ __| (_)_ __ __ _ __ _ _ __ (_) (_)_ __ ___ _ __ | | -// | '_ \| | '_ \ / _` | | '_ \ / _` | / _` | '_ \| | | | '_ ` _ \| '_ \| | -// | |_) | | | | | (_| | | | | | (_| | | (_| | |_) | | | | | | | | | |_) | | -// |_.__/|_|_| |_|\__,_|_|_| |_|\__, |___\__,_| .__/|_| |_|_| |_| |_| .__/|_| -// |___/_____| |_| |_| -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())); -} +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::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()); -} + // surfaces are on separate layers, don't bother. + if (new_id_layer != current_id_layer) { + return false; + } -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()); -} + 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::enddraw(char const* drawing_name) { - logdebug("%s drawing_name %s", __func__, drawing_name); - return Err("not implemented"); -} + auto const &layer = this->layers.get_layer(new_id_layer); -binding_api::result_type binding_api::list_drawing_names() { - logdebug("%s", __func__); - json j = this->app->id_alloc.name2id; - return Ok(json_tokener_parse(j.dump().c_str())); -} - -binding_api::result_type binding_api::debug_layers() { - logdebug("%s", __func__); - return Ok(json_tokener_parse(this->app->layers.to_json().dump().c_str())); -} + logdebug("layer info name: %s", layer->name.c_str()); -binding_api::result_type binding_api::debug_surfaces() { - logdebug("%s", __func__); - return Ok(to_json(this->app->controller->sprops)); -} + if (layer->layouts.empty()) { + return false; + } -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); -} + 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; + } + } + } + } -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()); + return false; } // _ _ _ _ _