X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fcompositor.c;h=2c8c386cb2182ad9a3069998c4bda59ce0d5a3fa;hb=45b9e2fc90aec09d1598fdc2a9e4e71a3cdd7fd7;hp=7540fe33c4bcbb90b9e21042c09ee27b0b18600b;hpb=1797ef75adcb4c586d51302f69d33995c3878e95;p=src%2Fagl-compositor.git

diff --git a/src/compositor.c b/src/compositor.c
index 7540fe3..2c8c386 100644
--- a/src/compositor.c
+++ b/src/compositor.c
@@ -39,6 +39,9 @@
 
 #include <libweston/backend-drm.h>
 #include <libweston/backend-wayland.h>
+#ifdef HAVE_BACKEND_RDP
+#include <libweston/backend-rdp.h>
+#endif
 #ifdef HAVE_BACKEND_HEADLESS
 #include <libweston/backend-headless.h>
 #endif
@@ -49,7 +52,7 @@
 #include <libweston/windowed-output-api.h>
 #include <libweston/config-parser.h>
 #include <libweston/weston-log.h>
-#include <weston/weston.h>
+#include <weston.h>
 
 #include "shared/os-compatibility.h"
 #include "shared/helpers.h"
@@ -60,10 +63,6 @@
 #include "remote.h"
 #endif
 
-#ifdef HAVE_WALTHAM
-#include <waltham-transmitter/transmitter_api.h>
-#endif
-
 static int cached_tm_mday = -1;
 static struct weston_log_scope *log_scope;
 
@@ -73,6 +72,123 @@ to_ivi_compositor(struct weston_compositor *ec)
 	return weston_compositor_get_user_data(ec);
 }
 
+struct ivi_output_config *
+ivi_init_parsed_options(struct weston_compositor *compositor)
+{
+	struct ivi_compositor *ivi = to_ivi_compositor(compositor);
+	struct ivi_output_config *config;
+
+	config = zalloc(sizeof *config);
+	if (!config)
+		return NULL;
+
+	config->width = 0;
+	config->height = 0;
+	config->scale = 0;
+	config->transform = UINT32_MAX;
+
+	ivi->parsed_options = config;
+
+	return config;
+}
+
+
+
+static void
+sigint_helper(int sig)
+{
+       raise(SIGUSR2);
+}
+
+void
+ivi_layout_save(struct ivi_compositor *ivi, struct ivi_output *output)
+{
+	struct ivi_output *new_output;
+	ivi->need_ivi_output_relayout = true;
+
+	new_output = zalloc(sizeof(*new_output));
+
+	new_output->ivi = ivi;
+	new_output->background = output->background;
+
+	new_output->top = output->top;
+	new_output->bottom = output->bottom;
+	new_output->left = output->left;
+	new_output->right = output->right;
+
+	new_output->active = output->active;
+	new_output->previous_active = output->previous_active;
+	new_output->name = strdup(output->name);
+	if (output->app_ids)
+		new_output->app_ids = strdup(output->app_ids);
+
+	new_output->area = output->area;
+	new_output->area_saved = output->area_saved;
+	new_output->area_activation = output->area_activation;
+
+	weston_log("saving output layout for output %s\n", new_output->name);
+
+	wl_list_insert(&ivi->saved_outputs, &new_output->link);
+}
+
+void
+ivi_layout_restore(struct ivi_compositor *ivi, struct ivi_output *n_output)
+{
+	struct ivi_output *output = NULL;
+	struct ivi_output *iter_output;
+
+	if (!ivi->need_ivi_output_relayout)
+		return;
+
+	ivi->need_ivi_output_relayout = false;
+
+	wl_list_for_each(iter_output, &ivi->saved_outputs, link) {
+		if (strcmp(n_output->name, iter_output->name) == 0) {
+			output = iter_output;
+			break;
+		}
+	}
+
+	if (!output)
+		return;
+
+	weston_log("restoring output layout for output %s\n", output->name);
+	n_output->background = output->background;
+
+	n_output->top = output->top;
+	n_output->bottom = output->bottom;
+	n_output->left = output->left;
+	n_output->right = output->right;
+
+	n_output->active = output->active;
+	n_output->previous_active = output->previous_active;
+	if (output->app_ids)
+		n_output->app_ids = strdup(output->app_ids);
+
+	n_output->area = output->area;
+	n_output->area_saved = output->area_saved;
+	n_output->area_activation = output->area_activation;
+
+	free(output->app_ids);
+	free(output->name);
+	wl_list_remove(&output->link);
+	free(output);
+}
+
+void
+ivi_layout_destroy_saved_outputs(struct ivi_compositor *ivi)
+{
+	struct ivi_output *output, *output_next;
+
+	wl_list_for_each_safe(output, output_next, &ivi->saved_outputs, link) {
+		free(output->app_ids);
+		free(output->name);
+
+		wl_list_remove(&output->link);
+		free(output);
+	}
+}
+
 static void
 handle_output_destroy(struct wl_listener *listener, void *data)
 {
@@ -81,11 +197,14 @@ handle_output_destroy(struct wl_listener *listener, void *data)
 	output = wl_container_of(listener, output, output_destroy);
 	assert(output->output == data);
 
-	if (output->fullscreen_view.fs->view) {
+	if (output->fullscreen_view.fs &&
+	    output->fullscreen_view.fs->view) {
 		weston_surface_destroy(output->fullscreen_view.fs->view->surface);
 		output->fullscreen_view.fs->view = NULL;
 	}
 
+	ivi_layout_save(output->ivi, output);
+
 	output->output = NULL;
 	wl_list_remove(&output->output_destroy.link);
 }
@@ -106,25 +225,26 @@ static void
 ivi_output_configure_app_id(struct ivi_output *ivi_output)
 {
 	if (ivi_output->config) {
-		if (ivi_output->app_id != NULL)
+		if (ivi_output->app_ids != NULL)
 			return;
 
 		weston_config_section_get_string(ivi_output->config,
 						 "agl-shell-app-id",
-						 &ivi_output->app_id,
+						 &ivi_output->app_ids,
 						 NULL);
 
-		if (ivi_output->app_id == NULL)
+		if (ivi_output->app_ids == NULL)
 			return;
 
 		weston_log("Will place app_id %s on output %s\n",
-				ivi_output->app_id, ivi_output->name);
+				ivi_output->app_ids, ivi_output->name);
 	}
 }
 
 static struct ivi_output *
 ivi_ensure_output(struct ivi_compositor *ivi, char *name,
-		  struct weston_config_section *config)
+		  struct weston_config_section *config,
+		  struct weston_head *head)
 {
 	struct ivi_output *output = NULL;
 	wl_list_for_each(output, &ivi->outputs, link) {
@@ -144,11 +264,41 @@ ivi_ensure_output(struct ivi_compositor *ivi, char *name,
 	output->name = name;
 	output->config = config;
 
-	output->output = weston_compositor_create_output(ivi->compositor, name);
-	if (!output->output) {
-		free(output->name);
-		free(output);
-		return NULL;
+	if (ivi->simple_output_configure) {
+		output->output =
+			weston_compositor_create_output_with_head(ivi->compositor,
+								  head);
+		if (!output->output) {
+			free(output->name);
+			free(output);
+			return NULL;
+		}
+
+		int ret = ivi->simple_output_configure(output->output);
+		if (ret < 0) {
+			weston_log("Configuring output \"%s\" failed.\n",
+					weston_head_get_name(head));
+			weston_output_destroy(output->output);
+			ivi->init_failed = true;
+			return NULL;
+		}
+
+		if (weston_output_enable(output->output) < 0) {
+			weston_log("Enabling output \"%s\" failed.\n",
+					weston_head_get_name(head));
+			weston_output_destroy(output->output);
+			ivi->init_failed = true;
+			return NULL;
+		}
+
+	} else {
+		output->output =
+			weston_compositor_create_output(ivi->compositor, name);
+		if (!output->output) {
+			free(output->name);
+			free(output);
+			return NULL;
+		}
 	}
 
 	output->output_destroy.notify = handle_output_destroy;
@@ -321,6 +471,23 @@ parse_transform(const char *transform, uint32_t *out)
 	return -1;
 }
 
+int
+parse_activation_area(const char *geometry, struct ivi_output *output)
+{
+	int n;
+	unsigned width, height, x, y;
+
+	n = sscanf(geometry, "%ux%u+%u,%u", &width, &height, &x, &y);
+	if (n != 4) {
+		return -1;
+	}
+	output->area_activation.width = width;
+	output->area_activation.height = height;
+	output->area_activation.x = x;
+	output->area_activation.y = y;
+	return 0;
+}
+
 static int
 configure_output(struct ivi_output *output)
 {
@@ -344,6 +511,10 @@ configure_output(struct ivi_output *output)
 		if (parse_transform(t, &transform) < 0)
 			weston_log("Invalid transform \"%s\" for output %s\n",
 				   t, output->name);
+		weston_config_section_get_string(section, "activation-area", &t, "");
+		if (parse_activation_area(t, output) < 0)
+			weston_log("Invalid activation-area \"%s\" for output %s\n",
+				   t, output->name);
 		free(t);
 	}
 
@@ -376,7 +547,6 @@ try_attach_heads(struct ivi_output *output)
 			output->add[fail_len++] = tmp;
 		}
 	}
-
 	return fail_len;
 }
 
@@ -426,6 +596,8 @@ try_attach_enable_heads(struct ivi_output *output)
 	for (size_t i = fail_len; i < output->add_len; ++i)
 		add_head_destroyed_listener(output->add[i]);
 
+	ivi_layout_restore(output->ivi, output);
+
 	output->add_len = fail_len;
 	return 0;
 }
@@ -460,8 +632,22 @@ head_disable(struct ivi_compositor *ivi, struct weston_head *head)
 
 	weston_head_detach(head);
 	if (count_heads(ivi_output->output) == 0) {
-		weston_output_disable(ivi_output->output);
+		if (ivi_output->output) {
+			/* ivi_output->output destruction may be deferred in
+			 * some cases (see drm_output_destroy()), so we need to
+			 * forcibly trigger the destruction callback now, or
+			 * otherwise would later access data that we are about
+			 * to free
+			 */
+			struct weston_output *save = ivi_output->output;
+
+			handle_output_destroy(&ivi_output->output_destroy, save);
+			weston_output_destroy(save);
+		}
 	}
+	wl_list_remove(&ivi_output->link);
+	free(ivi_output->app_ids);
+	free(ivi_output);
 }
 
 static struct weston_config_section *
@@ -505,6 +691,7 @@ head_prepare_enable(struct ivi_compositor *ivi, struct weston_head *head)
 	struct ivi_output *output;
 	char *output_name = NULL;
 
+
 	section = find_controlling_output_config(ivi->config, name);
 	if (section) {
 		char *mode;
@@ -525,7 +712,7 @@ head_prepare_enable(struct ivi_compositor *ivi, struct weston_head *head)
 	if (!output_name)
 		return;
 
-	output = ivi_ensure_output(ivi, output_name, section);
+	output = ivi_ensure_output(ivi, output_name, section, head);
 	if (!output)
 		return;
 
@@ -572,38 +759,6 @@ heads_changed(struct wl_listener *listener, void *arg)
 	}
 }
 
-#ifdef HAVE_WALTHAM
-static int
-load_waltham_plugin(struct ivi_compositor *ivi, struct weston_config *config)
-{
-	struct weston_compositor *compositor = ivi->compositor;
-	int (*module_init)(struct weston_compositor *wc);
-
-	module_init = weston_load_module("waltham-transmitter.so",
-					 "wet_module_init");
-	if (!module_init)
-		return -1;
-
-	if (module_init(compositor) < 0)
-		return -1;
-
-	ivi->waltham_transmitter_api = weston_get_transmitter_api(compositor);
-	if (!ivi->waltham_transmitter_api) {
-		weston_log("Failed to load waltham-transmitter plugin.\n");
-		return -1;
-	}
-
-	weston_log("waltham-transmitter plug-in loaded\n");
-	return 0;
-}
-#else
-static int
-load_waltham_plugin(struct ivi_compositor *ivi, struct weston_config *config)
-{
-	return -1;
-}
-#endif
-
 #ifdef HAVE_REMOTING
 static int
 drm_backend_remoted_output_configure(struct weston_output *output,
@@ -703,7 +858,7 @@ remote_output_init(struct ivi_output *ivi_output,
 		goto err;
 	}
 
-	if (weston_output_enable(ivi_output->output) < 0) {
+	if ((ret = weston_output_enable(ivi_output->output)) < 0) {
 		weston_log("Enabling remoted output \"%s\" failed.\n",
 				output_name);
 		goto err;
@@ -780,62 +935,6 @@ ivi_enable_remote_outputs(struct ivi_compositor *ivi)
 	}
 }
 
-static void
-ivi_enable_waltham_outputs(struct ivi_compositor *ivi)
-{
-	struct weston_config_section *transmitter_section = NULL;
-	const char *sect_name;
-	struct weston_config *config = ivi->config;
-
-	while (weston_config_next_section(config, &transmitter_section, &sect_name)) {
-		if (strcmp(sect_name, "transmitter-output"))
-			continue;
-
-		struct ivi_output *ivi_output = NULL;
-		bool output_found = false;
-		char *_name = NULL;
-
-		weston_config_section_get_string(transmitter_section,
-				"name", &_name, NULL);
-		wl_list_for_each(ivi_output, &ivi->outputs, link) {
-			if (!strcmp(ivi_output->name, _name)) {
-				output_found = true;
-				break;
-			}
-		}
-
-		if (output_found) {
-			free(_name);
-			continue;
-		}
-
-		ivi_output = zalloc(sizeof(*ivi_output));
-		if (!ivi_output) {
-			free(_name);
-			continue;
-		}
-
-		ivi_output->ivi = ivi;
-		ivi_output->name = _name;
-		ivi_output->config = transmitter_section;
-
-		if (remote_output_init(ivi_output, ivi->compositor,
-					transmitter_section, ivi->remoting_api)) {
-			free(ivi_output->name);
-			free(ivi_output);
-			continue;
-		}
-
-		ivi_output->type = OUTPUT_WALTHAM;
-		ivi_output->output_destroy.notify = handle_output_destroy;
-		weston_output_add_destroy_listener(ivi_output->output,
-				&ivi_output->output_destroy);
-
-		wl_list_insert(&ivi->outputs, &ivi_output->link);
-		ivi_output_configure_app_id(ivi_output);
-	}
-}
-
 static int
 load_remoting_plugin(struct ivi_compositor *ivi, struct weston_config *config)
 {
@@ -915,7 +1014,6 @@ load_drm_backend(struct ivi_compositor *ivi, int *argc, char *argv[])
 	}
 
 	load_remoting_plugin(ivi, ivi->config);
-	load_waltham_plugin(ivi, ivi->config);
 
 error:
 	free(config.gbm_format);
@@ -1157,6 +1255,140 @@ load_headless_backend(struct ivi_compositor *ivi, int *argc, char **argv)
 }
 #endif
 
+#ifdef HAVE_BACKEND_RDP
+static void
+weston_rdp_backend_config_init(struct weston_rdp_backend_config *config)
+{
+        config->base.struct_version = WESTON_RDP_BACKEND_CONFIG_VERSION;
+        config->base.struct_size = sizeof(struct weston_rdp_backend_config);
+
+        config->bind_address = NULL;
+        config->port = 3389;
+        config->rdp_key = NULL;
+        config->server_cert = NULL;
+        config->server_key = NULL;
+        config->env_socket = 0;
+        config->no_clients_resize = 1;
+        config->force_no_compression = 0;
+}
+
+static int
+rdp_backend_output_configure(struct weston_output *output)
+{
+	struct ivi_compositor *ivi = to_ivi_compositor(output->compositor);
+	struct ivi_output_config *parsed_options = ivi->parsed_options;
+	const struct weston_rdp_output_api *api =
+		weston_rdp_output_get_api(output->compositor);
+	int width = 640;
+	int height = 480;
+	struct weston_config_section *section;
+	uint32_t transform = WL_OUTPUT_TRANSFORM_NORMAL;
+	char *transform_string;
+
+	assert(parsed_options);
+
+	if (!api) {
+		weston_log("Cannot use weston_rdp_output_api.\n");
+		return -1;
+	}
+
+	section = weston_config_get_section(ivi->config, "rdp", NULL, NULL);
+
+	if (parsed_options->width)
+		width = parsed_options->width;
+
+	if (parsed_options->height)
+		height = parsed_options->height;
+
+	weston_output_set_scale(output, 1);
+
+	weston_config_section_get_int(section, "width",
+			&width, width);
+
+	weston_config_section_get_int(section, "height",
+			&height, height);
+
+	if (parsed_options->transform)
+		transform = parsed_options->transform;
+
+	weston_config_section_get_string(section, "transform",
+			&transform_string, "normal");
+
+	if (parse_transform(transform_string, &transform) < 0) {
+		weston_log("Invalid transform \"%s\" for output %s\n",
+			   transform_string, output->name);
+		return -1;
+	}
+
+	weston_output_set_transform(output, transform);
+
+	if (api->output_set_size(output, width, height) < 0) {
+		weston_log("Cannot configure output \"%s\" using weston_rdp_output_api.\n",
+				output->name);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+load_rdp_backend(struct ivi_compositor *ivi, int *argc, char **argv)
+{
+	struct weston_rdp_backend_config config = {};
+	int ret = 0;
+	struct weston_config_section *section;
+
+	struct ivi_output_config *parsed_options = ivi_init_parsed_options(ivi->compositor);
+	if (!parsed_options)
+		return -1;
+
+	weston_rdp_backend_config_init(&config);
+
+	const struct weston_option rdp_options[] = {
+		{ WESTON_OPTION_BOOLEAN, "env-socket", 0, &config.env_socket },
+		{ WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width },
+		{ WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height },
+		{ WESTON_OPTION_INTEGER, "transform", 0, &parsed_options->transform },
+		{ WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale },
+		{ WESTON_OPTION_STRING,  "address", 0, &config.bind_address },
+		{ WESTON_OPTION_INTEGER, "port", 0, &config.port },
+		{ WESTON_OPTION_BOOLEAN, "no-clients-resize", 0, &config.no_clients_resize },
+		{ WESTON_OPTION_STRING,  "rdp4-key", 0, &config.rdp_key },
+		{ WESTON_OPTION_STRING,  "rdp-tls-cert", 0, &config.server_cert },
+		{ WESTON_OPTION_STRING,  "rdp-tls-key", 0, &config.server_key },
+		{ WESTON_OPTION_BOOLEAN, "force-no-compression", 0, &config.force_no_compression },
+	};
+
+	section = weston_config_get_section(ivi->config, "rdp", NULL, NULL);
+
+	weston_config_section_get_string(section, "tls-cert",
+			&config.server_cert, config.server_cert);
+
+	weston_config_section_get_string(section, "tls-key",
+			&config.server_key, config.server_key);
+
+
+	parse_options(rdp_options, ARRAY_LENGTH(rdp_options), argc, argv);
+
+	ivi->simple_output_configure = rdp_backend_output_configure;
+	ret = weston_compositor_load_backend(ivi->compositor, WESTON_BACKEND_RDP, &config.base);
+
+	free(config.bind_address);
+	free(config.rdp_key);
+	free(config.server_cert);
+	free(config.server_key);
+
+	return ret;
+}
+#else
+static int
+load_rdp_backend(struct ivi_compositor *ivi, int *argc, char **argv)
+{
+	return -1;
+}
+#endif
+
+
 static int
 load_backend(struct ivi_compositor *ivi, const char *backend,
 	     int *argc, char *argv[])
@@ -1169,6 +1401,8 @@ load_backend(struct ivi_compositor *ivi, const char *backend,
 		return load_x11_backend(ivi, argc, argv);
 	} else if (strcmp(backend, "headless-backend.so") == 0) {
 		return load_headless_backend(ivi, argc, argv);
+	} else if (strcmp(backend, "rdp-backend.so") == 0) {
+		return load_rdp_backend(ivi, argc, argv);
 	}
 
 	weston_log("fatal: unknown backend '%s'.\n", backend);
@@ -1192,27 +1426,18 @@ load_modules(struct ivi_compositor *ivi, const char *modules,
 		snprintf(buffer, sizeof buffer, "%.*s", (int) (end - p), p);
 
 		if (strstr(buffer, "xwayland.so")) {
-			weston_log("Xwayland plug-in not supported!\n");
-			p = end;
-			while (*p == ',')
-				p++;
-			continue;
-		}
-
-		if (strstr(buffer, "systemd-notify.so")) {
+			*xwayland = true;
+		} else if (strstr(buffer, "systemd-notify.so")) {
 			weston_log("systemd-notify plug-in already loaded!\n");
-			p = end;
-			while (*p == ',')
-				p++;
-			continue;
-		}
+		} else {
+			module_init = weston_load_module(buffer, "wet_module_init");
+			if (!module_init)
+				return -1;
 
-		module_init = weston_load_module(buffer, "wet_module_init");
-		if (!module_init)
-			return -1;
+			if (module_init(ivi->compositor, *argc, argv) < 0)
+				return -1;
 
-		if (module_init(ivi->compositor, *argc, argv) < 0)
-			return -1;
+		}
 
 		p = end;
 		while (*p == ',')
@@ -1239,11 +1464,12 @@ choose_default_backend(void)
 }
 
 static int
-compositor_init_config(struct weston_compositor *compositor,
-		       struct weston_config *config)
+compositor_init_config(struct ivi_compositor *ivi)
 {
 	struct xkb_rule_names xkb_names;
 	struct weston_config_section *section;
+	struct weston_compositor *compositor = ivi->compositor;
+	struct weston_config *config = ivi->config;
 	int repaint_msec;
 	bool vt_switching;
 	bool require_input;
@@ -1276,6 +1502,11 @@ compositor_init_config(struct weston_compositor *compositor,
 	/* agl-compositor.ini [core] */
 	section = weston_config_get_section(config, "core", NULL, NULL);
 
+	weston_config_section_get_bool(section, "disable-cursor",
+				       &ivi->disable_cursor, false);
+	weston_config_section_get_bool(section, "activate-by-default",
+				       &ivi->activate_by_default, true);
+
 	weston_config_section_get_bool(section, "require-input", &require_input, true);
 	compositor->require_input = require_input;
 
@@ -1601,6 +1832,44 @@ copy_command_line(int argc, char * const argv[])
 	return str;
 }
 
+#if !defined(BUILD_XWAYLAND)
+int
+wet_load_xwayland(struct weston_compositor *comp)
+{
+	weston_log("Attempted to load xwayland library but compositor "
+		   "was *not* built with xwayland support!\n");
+	return -1;
+}
+#endif
+
+static void
+weston_log_setup_scopes(struct weston_log_context *log_ctx,
+			struct weston_log_subscriber *subscriber,
+			const char *names)
+{
+	assert(log_ctx);
+	assert(subscriber);
+
+	char *tokenize = strdup(names);
+	char *token = strtok(tokenize, ",");
+	while (token) {
+		weston_log_subscribe(log_ctx, subscriber, token);
+		token = strtok(NULL, ",");
+	}
+	free(tokenize);
+}
+
+static void
+weston_log_subscribe_to_scopes(struct weston_log_context *log_ctx,
+                               struct weston_log_subscriber *logger,
+                               const char *debug_scopes)
+{
+        if (logger && debug_scopes)
+                weston_log_setup_scopes(log_ctx, logger, debug_scopes);
+        else
+                weston_log_subscribe(log_ctx, logger, "log");
+}
+
 WL_EXPORT
 int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_data)
 {
@@ -1616,15 +1885,18 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 	char *log = NULL;
 	char *modules = NULL;
 	char *option_modules = NULL;
+	char *debug_scopes = NULL;
 	int help = 0;
 	int version = 0;
 	int no_config = 0;
 	int debug = 0;
+	bool list_debug_scopes = false;
 	char *config_file = NULL;
 	struct weston_log_context *log_ctx = NULL;
 	struct weston_log_subscriber *logger;
 	int ret = EXIT_FAILURE;
 	bool xwayland = false;
+	struct sigaction action;
 
 	const struct weston_option core_options[] = {
 		{ WESTON_OPTION_STRING, "backend", 'B', &backend },
@@ -1636,9 +1908,12 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 		{ WESTON_OPTION_BOOLEAN, "debug", 0, &debug },
 		{ WESTON_OPTION_STRING, "config", 'c', &config_file },
 		{ WESTON_OPTION_STRING, "modules", 0, &option_modules },
+		{ WESTON_OPTION_STRING, "debug-scopes", 'l', &debug_scopes },
+		{ WESTON_OPTION_STRING, "list-debug-scopes", 'L', &list_debug_scopes },
 	};
 
 	wl_list_init(&ivi.outputs);
+	wl_list_init(&ivi.saved_outputs);
 	wl_list_init(&ivi.surfaces);
 	wl_list_init(&ivi.pending_surfaces);
 	wl_list_init(&ivi.popup_pending_apps);
@@ -1646,6 +1921,8 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 	wl_list_init(&ivi.split_pending_apps);
 	wl_list_init(&ivi.remote_pending_apps);
 	wl_list_init(&ivi.desktop_clients);
+	wl_list_init(&ivi.child_process_list);
+	wl_list_init(&ivi.pending_apps);
 
 	/* Prevent any clients we spawn getting our stdin */
 	os_fd_set_cloexec(STDIN_FILENO);
@@ -1676,7 +1953,7 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 	weston_log_set_handler(vlog, vlog_continue);
 
 	logger = weston_log_subscriber_create_log(logfile);
-	weston_log_subscribe(log_ctx, logger, "log");
+	weston_log_subscribe_to_scopes(log_ctx, logger, debug_scopes);
 
 	weston_log("Command line: %s\n", cmdline);
 	free(cmdline);
@@ -1690,11 +1967,6 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 		if (!backend)
 			backend = choose_default_backend();
 	}
-	/* from [core] */
-	weston_config_section_get_bool(section, "hide-cursor",
-				       &ivi.hide_cursor, false);
-	weston_config_section_get_bool(section, "activate-by-default",
-				       &ivi.activate_by_default, true);
 
 	display = wl_display_create();
 	loop = wl_display_get_event_loop(display);
@@ -1706,11 +1978,26 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 
 	signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
 					      display);
-	signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
+	signals[1] = wl_event_loop_add_signal(loop, SIGUSR2, on_term_signal,
 					      display);
-	signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
+	signals[2] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
 					      display);
 
+	/* When debugging the compositor, if use wl_event_loop_add_signal() to
+	 * catch SIGINT, the debugger can't catch it, and attempting to stop
+	 * the compositor from within the debugger results in weston exiting
+	 * cleanly.
+	 *
+	 * Instead, use the sigaction() function, which sets up the signal in a
+	 * way that gdb can successfully catch, but have the handler for SIGINT
+	 * send SIGUSR2 (xwayland uses SIGUSR1), which we catch via
+	 * wl_event_loop_add_signal().
+	 */
+	action.sa_handler = sigint_helper;
+	sigemptyset(&action.sa_mask);
+	action.sa_flags = 0;
+	sigaction(SIGINT, &action, NULL);
+
 	for (size_t i = 0; i < ARRAY_LENGTH(signals); ++i)
 		if (!signals[i])
 			goto error_signals;
@@ -1721,7 +2008,7 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 		goto error_signals;
 	}
 
-	if (compositor_init_config(ivi.compositor, ivi.config) < 0)
+	if (compositor_init_config(&ivi) < 0)
 		goto error_compositor;
 
 	if (load_backend(&ivi, backend, &argc, argv) < 0) {
@@ -1733,6 +2020,7 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 	weston_compositor_add_heads_changed_listener(ivi.compositor,
 						     &ivi.heads_changed);
 
+	weston_compositor_flush_heads_changed(ivi.compositor);
 	if (ivi_desktop_init(&ivi) < 0)
 		goto error_compositor;
 
@@ -1746,22 +2034,44 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 	if (load_modules(&ivi, option_modules, &argc, argv, &xwayland) < 0)
 		goto error_compositor;
 
+	if (!xwayland) {
+		weston_config_section_get_bool(section, "xwayland", &xwayland,
+					       false);
+	}
+
+	if (ivi_shell_init(&ivi) < 0)
+		goto error_compositor;
+
+	if (xwayland) {
+		if (wet_load_xwayland(ivi.compositor) < 0)
+			goto error_compositor;
+	}
+
 	if (ivi_policy_init(&ivi) < 0)
 		goto error_compositor;
 
-	if (ivi_shell_init(&ivi) < 0)
+
+	if (list_debug_scopes) {
+		struct weston_log_scope *nscope = NULL;
+
+		weston_log("Printing available debug scopes:\n");
+
+		while ((nscope = weston_log_scopes_iterate(log_ctx, nscope))) {
+			weston_log("\tscope name: %s, desc: %s",
+					weston_log_scope_get_name(nscope),
+					weston_log_scope_get_description(nscope));
+		}
+
+		weston_log("\n");
+
 		goto error_compositor;
+	}
 
 	add_bindings(ivi.compositor);
 
-	weston_compositor_flush_heads_changed(ivi.compositor);
-
 	if (ivi.remoting_api)
 		ivi_enable_remote_outputs(&ivi);
 
-	if (ivi.waltham_transmitter_api)
-		ivi_enable_waltham_outputs(&ivi);
-
 	if (create_listening_socket(display, socket_name) < 0)
 		goto error_compositor;
 
@@ -1772,7 +2082,12 @@ int wet_main(int argc, char *argv[], const struct weston_testsuite_data *test_da
 	weston_compositor_wake(ivi.compositor);
 
 	ivi_shell_create_global(&ivi);
-	ivi_launch_shell_client(&ivi);
+
+	ivi_launch_shell_client(&ivi, "shell-client",
+				&ivi.shell_client.client);
+	ivi_launch_shell_client(&ivi, "shell-client-ext",
+				&ivi.shell_client_ext.client);
+
 	if (debug)
 		ivi_screenshooter_create(&ivi);
 	ivi_agl_systemd_notify(&ivi);