+void App::surface_removed(uint32_t surface_id) {
+ logdebug("surface_id is %u", 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());
+ }
+ }
+
+ 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", label);
+}
+
+void App::emit_deactivated(char const *label) {
+ this->api.send_event("deactivated", label);
+}
+
+void App::emit_syncdraw(char const *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", 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<int> 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<int>("Drawing name does not match any role");
+ }
+
+ 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);
+
+ // 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;
+ logdebug("Set main_surface id to %u", id);
+ }
+
+ return Ok<int>(id);
+ }
+
+ // Check currently registered drawing names if it is already there.
+ return Err<int>("Surface already present");
+}
+
+void App::activate(int id) {
+ if (this->controller->sprops[id].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);
+ }
+}
+
+void App::deactivate(int id) {
+ if (this->controller->sprops[id].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);
+ }
+}
+
+void App::deactivate_main_surface() {
+ this->layers.main_surface = -1;
+ this->api_deactivate_surface(this->layers.main_surface_name.c_str());
+}
+
+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();
+
+ // surfaces are on separate layers, don't bother.
+ if (new_id_layer != current_id_layer) {
+ return false;
+ }
+
+ std::string const &new_id_str = this->lookup_name(new_id).value();
+ std::string const &cur_id_str = this->lookup_name(state.main).value();
+
+ auto const &layer = this->layers.get_layer(new_id_layer);
+
+ logdebug("layer info name: %s", layer->name.c_str());
+
+ if (layer->layouts.empty()) {
+ return false;
+ }
+
+ 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 false;
+}
+
+void App::try_layout(struct LayoutState &state,
+ struct LayoutState const &new_layout,
+ std::function<void(LayoutState const &nl)> apply) {
+ if (this->policy.layout_is_valid(new_layout)) {
+ apply(new_layout);
+ }