2018-11-25 12:12:48 +01:00
|
|
|
#define _POSIX_C_SOURCE 200809L
|
2018-03-28 22:38:11 +02:00
|
|
|
#include <assert.h>
|
2021-09-03 03:45:23 +02:00
|
|
|
#include <drm_fourcc.h>
|
2017-12-29 19:04:16 +01:00
|
|
|
#include <stdbool.h>
|
2017-12-06 12:36:06 +01:00
|
|
|
#include <string.h>
|
2019-02-16 23:30:19 +01:00
|
|
|
#include <sys/socket.h>
|
2018-03-28 22:38:11 +02:00
|
|
|
#include <sys/wait.h>
|
2018-03-29 00:10:43 +02:00
|
|
|
#include <unistd.h>
|
2022-11-26 20:15:52 +01:00
|
|
|
#include <wlr/config.h>
|
2019-08-06 11:33:06 +02:00
|
|
|
#include <wlr/types/wlr_cursor.h>
|
2017-12-06 12:57:13 +01:00
|
|
|
#include <wlr/types/wlr_output_layout.h>
|
2019-02-16 23:30:19 +01:00
|
|
|
#include <wlr/types/wlr_output.h>
|
2017-12-06 12:36:06 +01:00
|
|
|
#include "sway/config.h"
|
2019-08-06 11:33:06 +02:00
|
|
|
#include "sway/input/cursor.h"
|
2017-12-06 12:36:06 +01:00
|
|
|
#include "sway/output.h"
|
2018-08-26 04:05:16 +02:00
|
|
|
#include "sway/tree/root.h"
|
2019-02-11 01:56:57 +01:00
|
|
|
#include "log.h"
|
|
|
|
|
#include "util.h"
|
2017-12-06 12:36:06 +01:00
|
|
|
|
2022-11-26 20:15:52 +01:00
|
|
|
#if WLR_HAS_DRM_BACKEND
|
|
|
|
|
#include <wlr/backend/drm.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-12-06 12:36:06 +01:00
|
|
|
int output_name_cmp(const void *item, const void *data) {
|
|
|
|
|
const struct output_config *output = item;
|
|
|
|
|
const char *name = data;
|
|
|
|
|
|
|
|
|
|
return strcmp(output->name, name);
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-29 19:04:16 +01:00
|
|
|
void output_get_identifier(char *identifier, size_t len,
|
|
|
|
|
struct sway_output *output) {
|
|
|
|
|
struct wlr_output *wlr_output = output->wlr_output;
|
2022-05-26 21:24:46 +02:00
|
|
|
snprintf(identifier, len, "%s %s %s",
|
|
|
|
|
wlr_output->make ? wlr_output->make : "Unknown",
|
|
|
|
|
wlr_output->model ? wlr_output->model : "Unknown",
|
|
|
|
|
wlr_output->serial ? wlr_output->serial : "Unknown");
|
2017-12-29 19:04:16 +01:00
|
|
|
}
|
|
|
|
|
|
2019-11-13 19:23:36 +01:00
|
|
|
const char *sway_output_scale_filter_to_string(enum scale_filter_mode scale_filter) {
|
|
|
|
|
switch (scale_filter) {
|
|
|
|
|
case SCALE_FILTER_DEFAULT:
|
|
|
|
|
return "smart";
|
|
|
|
|
case SCALE_FILTER_LINEAR:
|
|
|
|
|
return "linear";
|
|
|
|
|
case SCALE_FILTER_NEAREST:
|
|
|
|
|
return "nearest";
|
|
|
|
|
case SCALE_FILTER_SMART:
|
|
|
|
|
return "smart";
|
|
|
|
|
}
|
|
|
|
|
sway_assert(false, "Unknown value for scale_filter.");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-27 21:23:30 +01:00
|
|
|
struct output_config *new_output_config(const char *name) {
|
2017-12-06 19:45:43 +01:00
|
|
|
struct output_config *oc = calloc(1, sizeof(struct output_config));
|
|
|
|
|
if (oc == NULL) {
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2017-12-27 21:23:30 +01:00
|
|
|
oc->name = strdup(name);
|
|
|
|
|
if (oc->name == NULL) {
|
|
|
|
|
free(oc);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2017-12-06 12:57:13 +01:00
|
|
|
oc->enabled = -1;
|
2017-12-14 00:45:47 +01:00
|
|
|
oc->width = oc->height = -1;
|
2017-12-06 12:57:13 +01:00
|
|
|
oc->refresh_rate = -1;
|
2019-10-26 22:36:49 +02:00
|
|
|
oc->custom_mode = -1;
|
2021-07-18 12:05:47 +02:00
|
|
|
oc->drm_mode.type = -1;
|
2017-12-06 12:57:13 +01:00
|
|
|
oc->x = oc->y = -1;
|
|
|
|
|
oc->scale = -1;
|
2019-11-13 19:23:36 +01:00
|
|
|
oc->scale_filter = SCALE_FILTER_DEFAULT;
|
2017-12-06 12:57:13 +01:00
|
|
|
oc->transform = -1;
|
2019-02-11 01:56:57 +01:00
|
|
|
oc->subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
|
2019-09-25 12:58:27 +02:00
|
|
|
oc->max_render_time = -1;
|
2020-03-02 15:30:50 +01:00
|
|
|
oc->adaptive_sync = -1;
|
2021-09-03 03:45:23 +02:00
|
|
|
oc->render_bit_depth = RENDER_BIT_DEPTH_DEFAULT;
|
2022-06-23 21:03:32 +02:00
|
|
|
oc->power = -1;
|
2017-12-06 19:45:43 +01:00
|
|
|
return oc;
|
2017-12-06 12:57:13 +01:00
|
|
|
}
|
|
|
|
|
|
2017-12-06 12:36:06 +01:00
|
|
|
void merge_output_config(struct output_config *dst, struct output_config *src) {
|
|
|
|
|
if (src->enabled != -1) {
|
|
|
|
|
dst->enabled = src->enabled;
|
|
|
|
|
}
|
|
|
|
|
if (src->width != -1) {
|
|
|
|
|
dst->width = src->width;
|
|
|
|
|
}
|
|
|
|
|
if (src->height != -1) {
|
|
|
|
|
dst->height = src->height;
|
|
|
|
|
}
|
|
|
|
|
if (src->x != -1) {
|
|
|
|
|
dst->x = src->x;
|
|
|
|
|
}
|
|
|
|
|
if (src->y != -1) {
|
|
|
|
|
dst->y = src->y;
|
|
|
|
|
}
|
|
|
|
|
if (src->scale != -1) {
|
|
|
|
|
dst->scale = src->scale;
|
|
|
|
|
}
|
2019-11-13 19:23:36 +01:00
|
|
|
if (src->scale_filter != SCALE_FILTER_DEFAULT) {
|
|
|
|
|
dst->scale_filter = src->scale_filter;
|
|
|
|
|
}
|
2019-02-11 01:56:57 +01:00
|
|
|
if (src->subpixel != WL_OUTPUT_SUBPIXEL_UNKNOWN) {
|
|
|
|
|
dst->subpixel = src->subpixel;
|
|
|
|
|
}
|
2017-12-06 12:57:13 +01:00
|
|
|
if (src->refresh_rate != -1) {
|
|
|
|
|
dst->refresh_rate = src->refresh_rate;
|
|
|
|
|
}
|
2019-10-26 22:36:49 +02:00
|
|
|
if (src->custom_mode != -1) {
|
|
|
|
|
dst->custom_mode = src->custom_mode;
|
|
|
|
|
}
|
2021-07-18 12:05:47 +02:00
|
|
|
if (src->drm_mode.type != (uint32_t) -1) {
|
|
|
|
|
memcpy(&dst->drm_mode, &src->drm_mode, sizeof(src->drm_mode));
|
|
|
|
|
}
|
2017-12-06 12:57:13 +01:00
|
|
|
if (src->transform != -1) {
|
|
|
|
|
dst->transform = src->transform;
|
|
|
|
|
}
|
2019-09-25 12:58:27 +02:00
|
|
|
if (src->max_render_time != -1) {
|
|
|
|
|
dst->max_render_time = src->max_render_time;
|
|
|
|
|
}
|
2020-03-02 15:30:50 +01:00
|
|
|
if (src->adaptive_sync != -1) {
|
|
|
|
|
dst->adaptive_sync = src->adaptive_sync;
|
|
|
|
|
}
|
2021-09-03 03:45:23 +02:00
|
|
|
if (src->render_bit_depth != RENDER_BIT_DEPTH_DEFAULT) {
|
|
|
|
|
dst->render_bit_depth = src->render_bit_depth;
|
|
|
|
|
}
|
2017-12-06 12:36:06 +01:00
|
|
|
if (src->background) {
|
2017-12-06 19:16:12 +01:00
|
|
|
free(dst->background);
|
2017-12-06 12:36:06 +01:00
|
|
|
dst->background = strdup(src->background);
|
|
|
|
|
}
|
|
|
|
|
if (src->background_option) {
|
2017-12-06 19:16:12 +01:00
|
|
|
free(dst->background_option);
|
2017-12-06 12:36:06 +01:00
|
|
|
dst->background_option = strdup(src->background_option);
|
|
|
|
|
}
|
2018-08-08 19:46:36 +02:00
|
|
|
if (src->background_fallback) {
|
|
|
|
|
free(dst->background_fallback);
|
|
|
|
|
dst->background_fallback = strdup(src->background_fallback);
|
|
|
|
|
}
|
2022-06-23 21:03:32 +02:00
|
|
|
if (src->power != -1) {
|
|
|
|
|
dst->power = src->power;
|
2018-04-17 09:54:02 +02:00
|
|
|
}
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
|
|
|
|
|
2018-07-20 18:32:29 +02:00
|
|
|
static void merge_wildcard_on_all(struct output_config *wildcard) {
|
|
|
|
|
for (int i = 0; i < config->output_configs->length; i++) {
|
|
|
|
|
struct output_config *oc = config->output_configs->items[i];
|
|
|
|
|
if (strcmp(wildcard->name, oc->name) != 0) {
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Merging output * config on %s", oc->name);
|
2018-07-20 18:32:29 +02:00
|
|
|
merge_output_config(oc, wildcard);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-03-15 07:20:07 +01:00
|
|
|
static void merge_id_on_name(struct output_config *oc) {
|
2023-02-28 12:47:40 +01:00
|
|
|
struct sway_output *output = all_output_by_name_or_id(oc->name);
|
|
|
|
|
if (output == NULL) {
|
|
|
|
|
return;
|
2019-03-15 07:20:07 +01:00
|
|
|
}
|
|
|
|
|
|
2023-02-28 12:47:40 +01:00
|
|
|
const char *name = output->wlr_output->name;
|
|
|
|
|
char id[128];
|
|
|
|
|
output_get_identifier(id, sizeof(id), output);
|
|
|
|
|
|
2023-02-28 16:43:05 +01:00
|
|
|
char *id_on_name = format_str("%s on %s", id, name);
|
2019-03-15 07:20:07 +01:00
|
|
|
if (!id_on_name) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int i = list_seq_find(config->output_configs, output_name_cmp, id_on_name);
|
|
|
|
|
if (i >= 0) {
|
|
|
|
|
sway_log(SWAY_DEBUG, "Merging on top of existing id on name config");
|
|
|
|
|
merge_output_config(config->output_configs->items[i], oc);
|
|
|
|
|
} else {
|
|
|
|
|
// If both a name and identifier config, exist generate an id on name
|
|
|
|
|
int ni = list_seq_find(config->output_configs, output_name_cmp, name);
|
|
|
|
|
int ii = list_seq_find(config->output_configs, output_name_cmp, id);
|
|
|
|
|
if ((ni >= 0 && ii >= 0) || (ni >= 0 && strcmp(oc->name, id) == 0)
|
|
|
|
|
|| (ii >= 0 && strcmp(oc->name, name) == 0)) {
|
|
|
|
|
struct output_config *ion_oc = new_output_config(id_on_name);
|
|
|
|
|
if (ni >= 0) {
|
|
|
|
|
merge_output_config(ion_oc, config->output_configs->items[ni]);
|
|
|
|
|
}
|
|
|
|
|
if (ii >= 0) {
|
|
|
|
|
merge_output_config(ion_oc, config->output_configs->items[ii]);
|
|
|
|
|
}
|
|
|
|
|
merge_output_config(ion_oc, oc);
|
|
|
|
|
list_add(config->output_configs, ion_oc);
|
|
|
|
|
sway_log(SWAY_DEBUG, "Generated id on name output config \"%s\""
|
|
|
|
|
" (enabled: %d) (%dx%d@%fHz position %d,%d scale %f "
|
2022-06-23 21:03:32 +02:00
|
|
|
"transform %d) (bg %s %s) (power %d) (max render time: %d)",
|
2019-09-25 12:58:27 +02:00
|
|
|
ion_oc->name, ion_oc->enabled, ion_oc->width, ion_oc->height,
|
2019-03-15 07:20:07 +01:00
|
|
|
ion_oc->refresh_rate, ion_oc->x, ion_oc->y, ion_oc->scale,
|
|
|
|
|
ion_oc->transform, ion_oc->background,
|
2022-06-23 21:03:32 +02:00
|
|
|
ion_oc->background_option, ion_oc->power,
|
2019-09-25 12:58:27 +02:00
|
|
|
ion_oc->max_render_time);
|
2019-03-15 07:20:07 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
free(id_on_name);
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-20 18:32:29 +02:00
|
|
|
struct output_config *store_output_config(struct output_config *oc) {
|
|
|
|
|
bool wildcard = strcmp(oc->name, "*") == 0;
|
|
|
|
|
if (wildcard) {
|
|
|
|
|
merge_wildcard_on_all(oc);
|
2019-03-15 07:20:07 +01:00
|
|
|
} else {
|
|
|
|
|
merge_id_on_name(oc);
|
2018-07-20 18:32:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int i = list_seq_find(config->output_configs, output_name_cmp, oc->name);
|
|
|
|
|
if (i >= 0) {
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Merging on top of existing output config");
|
2018-07-20 18:32:29 +02:00
|
|
|
struct output_config *current = config->output_configs->items[i];
|
|
|
|
|
merge_output_config(current, oc);
|
|
|
|
|
free_output_config(oc);
|
|
|
|
|
oc = current;
|
|
|
|
|
} else if (!wildcard) {
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Adding non-wildcard output config");
|
2018-07-20 18:32:29 +02:00
|
|
|
i = list_seq_find(config->output_configs, output_name_cmp, "*");
|
|
|
|
|
if (i >= 0) {
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Merging on top of output * config");
|
2018-07-20 18:32:29 +02:00
|
|
|
struct output_config *current = new_output_config(oc->name);
|
|
|
|
|
merge_output_config(current, config->output_configs->items[i]);
|
|
|
|
|
merge_output_config(current, oc);
|
|
|
|
|
free_output_config(oc);
|
|
|
|
|
oc = current;
|
|
|
|
|
}
|
|
|
|
|
list_add(config->output_configs, oc);
|
|
|
|
|
} else {
|
|
|
|
|
// New wildcard config. Just add it
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Adding output * config");
|
2018-07-20 18:32:29 +02:00
|
|
|
list_add(config->output_configs, oc);
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Config stored for output %s (enabled: %d) (%dx%d@%fHz "
|
2022-06-23 21:03:32 +02:00
|
|
|
"position %d,%d scale %f subpixel %s transform %d) (bg %s %s) (power %d) "
|
2019-09-25 12:58:27 +02:00
|
|
|
"(max render time: %d)",
|
2018-07-20 18:32:29 +02:00
|
|
|
oc->name, oc->enabled, oc->width, oc->height, oc->refresh_rate,
|
2019-02-11 01:56:57 +01:00
|
|
|
oc->x, oc->y, oc->scale, sway_wl_output_subpixel_to_string(oc->subpixel),
|
2022-06-23 21:03:32 +02:00
|
|
|
oc->transform, oc->background, oc->background_option, oc->power,
|
2019-09-25 12:58:27 +02:00
|
|
|
oc->max_render_time);
|
2018-07-20 18:32:29 +02:00
|
|
|
|
|
|
|
|
return oc;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-07 18:55:26 +02:00
|
|
|
static void set_mode(struct wlr_output *output, struct wlr_output_state *pending,
|
|
|
|
|
int width, int height, float refresh_rate, bool custom) {
|
2021-01-15 21:44:22 +01:00
|
|
|
// Not all floating point integers can be represented exactly
|
|
|
|
|
// as (int)(1000 * mHz / 1000.f)
|
|
|
|
|
// round() the result to avoid any error
|
2022-12-30 08:50:14 +01:00
|
|
|
int mhz = (int)roundf(refresh_rate * 1000);
|
2023-10-18 22:30:10 +02:00
|
|
|
// If no target refresh rate is given, match highest available
|
|
|
|
|
mhz = mhz <= 0 ? INT_MAX : mhz;
|
2019-10-26 22:36:49 +02:00
|
|
|
|
|
|
|
|
if (wl_list_empty(&output->modes) || custom) {
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Assigning custom mode to %s", output->name);
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_custom_mode(pending, width, height,
|
2019-10-26 22:36:49 +02:00
|
|
|
refresh_rate > 0 ? mhz : 0);
|
2019-12-27 11:47:51 +01:00
|
|
|
return;
|
2017-12-11 21:47:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct wlr_output_mode *mode, *best = NULL;
|
2023-10-18 22:30:10 +02:00
|
|
|
int best_diff_mhz = INT_MAX;
|
2017-12-06 12:36:06 +01:00
|
|
|
wl_list_for_each(mode, &output->modes, link) {
|
|
|
|
|
if (mode->width == width && mode->height == height) {
|
2023-10-18 22:30:10 +02:00
|
|
|
int diff_mhz = abs(mode->refresh - mhz);
|
|
|
|
|
if (diff_mhz < best_diff_mhz) {
|
|
|
|
|
best_diff_mhz = diff_mhz;
|
2019-11-05 18:31:41 +01:00
|
|
|
best = mode;
|
2023-10-18 22:30:10 +02:00
|
|
|
if (best_diff_mhz == 0) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
2019-11-05 18:31:41 +01:00
|
|
|
}
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
|
|
|
|
}
|
2023-10-18 22:30:10 +02:00
|
|
|
if (best) {
|
|
|
|
|
sway_log(SWAY_INFO, "Assigning configured mode (%dx%d@%.3fHz) to %s",
|
|
|
|
|
best->width, best->height, best->refresh / 1000.f, output->name);
|
2017-12-06 12:36:06 +01:00
|
|
|
} else {
|
2023-10-18 22:30:10 +02:00
|
|
|
best = wlr_output_preferred_mode(output);
|
|
|
|
|
sway_log(SWAY_INFO, "Configured mode (%dx%d@%.3fHz) not available, "
|
|
|
|
|
"applying preferred mode (%dx%d@%.3fHz)",
|
|
|
|
|
width, height, refresh_rate,
|
|
|
|
|
best->width, best->height, best->refresh / 1000.f);
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_mode(pending, best);
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
|
|
|
|
|
2022-06-07 18:55:26 +02:00
|
|
|
static void set_modeline(struct wlr_output *output,
|
|
|
|
|
struct wlr_output_state *pending, drmModeModeInfo *drm_mode) {
|
2022-11-26 20:15:52 +01:00
|
|
|
#if WLR_HAS_DRM_BACKEND
|
2021-07-18 12:05:47 +02:00
|
|
|
if (!wlr_output_is_drm(output)) {
|
|
|
|
|
sway_log(SWAY_ERROR, "Modeline can only be set to DRM output");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
sway_log(SWAY_DEBUG, "Assigning custom modeline to %s", output->name);
|
|
|
|
|
struct wlr_output_mode *mode = wlr_drm_connector_add_mode(output, drm_mode);
|
|
|
|
|
if (mode) {
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_mode(pending, mode);
|
2021-07-18 12:05:47 +02:00
|
|
|
}
|
2022-11-26 20:15:52 +01:00
|
|
|
#else
|
|
|
|
|
sway_log(SWAY_ERROR, "Modeline can only be set to DRM output");
|
|
|
|
|
#endif
|
2021-07-18 12:05:47 +02:00
|
|
|
}
|
|
|
|
|
|
2019-12-10 14:40:21 +01:00
|
|
|
/* Some manufacturers hardcode the aspect-ratio of the output in the physical
|
|
|
|
|
* size field. */
|
|
|
|
|
static bool phys_size_is_aspect_ratio(struct wlr_output *output) {
|
|
|
|
|
return (output->phys_width == 1600 && output->phys_height == 900) ||
|
|
|
|
|
(output->phys_width == 1600 && output->phys_height == 1000) ||
|
|
|
|
|
(output->phys_width == 160 && output->phys_height == 90) ||
|
|
|
|
|
(output->phys_width == 160 && output->phys_height == 100) ||
|
|
|
|
|
(output->phys_width == 16 && output->phys_height == 9) ||
|
|
|
|
|
(output->phys_width == 16 && output->phys_height == 10);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// The minimum DPI at which we turn on a scale of 2
|
|
|
|
|
#define HIDPI_DPI_LIMIT (2 * 96)
|
|
|
|
|
// The minimum screen height at which we turn on a scale of 2
|
|
|
|
|
#define HIDPI_MIN_HEIGHT 1200
|
|
|
|
|
// 1 inch = 25.4 mm
|
|
|
|
|
#define MM_PER_INCH 25.4
|
|
|
|
|
|
2022-06-07 18:55:26 +02:00
|
|
|
static int compute_default_scale(struct wlr_output *output,
|
|
|
|
|
struct wlr_output_state *pending) {
|
2020-02-10 18:42:45 +01:00
|
|
|
struct wlr_box box = { .width = output->width, .height = output->height };
|
2022-06-07 18:55:26 +02:00
|
|
|
if (pending->committed & WLR_OUTPUT_STATE_MODE) {
|
|
|
|
|
switch (pending->mode_type) {
|
2020-02-10 18:42:45 +01:00
|
|
|
case WLR_OUTPUT_STATE_MODE_FIXED:
|
2022-06-07 18:55:26 +02:00
|
|
|
box.width = pending->mode->width;
|
|
|
|
|
box.height = pending->mode->height;
|
2020-02-10 18:42:45 +01:00
|
|
|
break;
|
|
|
|
|
case WLR_OUTPUT_STATE_MODE_CUSTOM:
|
2022-06-07 18:55:26 +02:00
|
|
|
box.width = pending->custom_mode.width;
|
|
|
|
|
box.height = pending->custom_mode.height;
|
2020-02-10 18:42:45 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
enum wl_output_transform transform = output->transform;
|
2022-06-07 18:55:26 +02:00
|
|
|
if (pending->committed & WLR_OUTPUT_STATE_TRANSFORM) {
|
|
|
|
|
transform = pending->transform;
|
2020-02-10 18:42:45 +01:00
|
|
|
}
|
|
|
|
|
wlr_box_transform(&box, &box, transform, box.width, box.height);
|
|
|
|
|
|
|
|
|
|
int width = box.width;
|
|
|
|
|
int height = box.height;
|
|
|
|
|
|
2019-12-10 14:40:21 +01:00
|
|
|
if (height < HIDPI_MIN_HEIGHT) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (output->phys_width == 0 || output->phys_height == 0) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (phys_size_is_aspect_ratio(output)) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
double dpi_x = (double) width / (output->phys_width / MM_PER_INCH);
|
|
|
|
|
double dpi_y = (double) height / (output->phys_height / MM_PER_INCH);
|
|
|
|
|
sway_log(SWAY_DEBUG, "Output DPI: %fx%f", dpi_x, dpi_y);
|
|
|
|
|
if (dpi_x <= HIDPI_DPI_LIMIT || dpi_y <= HIDPI_DPI_LIMIT) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 2;
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-03 03:45:23 +02:00
|
|
|
/* Lists of formats to try, in order, when a specific render bit depth has
|
|
|
|
|
* been asked for. The second to last format in each list should always
|
|
|
|
|
* be XRGB8888, as a reliable backup in case the others are not available;
|
|
|
|
|
* the last should be DRM_FORMAT_INVALID, to indicate the end of the list. */
|
|
|
|
|
static const uint32_t *bit_depth_preferences[] = {
|
|
|
|
|
[RENDER_BIT_DEPTH_8] = (const uint32_t []){
|
|
|
|
|
DRM_FORMAT_XRGB8888,
|
|
|
|
|
DRM_FORMAT_INVALID,
|
|
|
|
|
},
|
|
|
|
|
[RENDER_BIT_DEPTH_10] = (const uint32_t []){
|
|
|
|
|
DRM_FORMAT_XRGB2101010,
|
|
|
|
|
DRM_FORMAT_XBGR2101010,
|
|
|
|
|
DRM_FORMAT_XRGB8888,
|
|
|
|
|
DRM_FORMAT_INVALID,
|
|
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
|
2020-04-08 11:22:51 +02:00
|
|
|
static void queue_output_config(struct output_config *oc,
|
2022-06-07 18:55:26 +02:00
|
|
|
struct sway_output *output, struct wlr_output_state *pending) {
|
2021-10-04 16:04:46 +02:00
|
|
|
if (output == root->fallback_output) {
|
2020-04-08 11:22:51 +02:00
|
|
|
return;
|
2019-01-20 10:05:28 +01:00
|
|
|
}
|
|
|
|
|
|
Implement type safe arguments and demote sway_container
This commit changes the meaning of sway_container so that it only refers
to layout containers and view containers. Workspaces, outputs and the
root are no longer known as containers. Instead, root, outputs,
workspaces and containers are all a type of node, and containers come in
two types: layout containers and view containers.
In addition to the above, this implements type safe variables. This
means we use specific types such as sway_output and sway_workspace
instead of generic containers or nodes. However, it's worth noting that
in a few places places (eg. seat focus and transactions) referring to
them in a generic way is unavoidable which is why we still use nodes in
some places.
If you want a TL;DR, look at node.h, as well as the struct definitions
for root, output, workspace and container. Note that sway_output now
contains a workspaces list, and workspaces now contain a tiling and
floating list, and containers now contain a pointer back to the
workspace.
There are now functions for seat_get_focused_workspace and
seat_get_focused_container. The latter will return NULL if a workspace
itself is focused. Most other seat functions like seat_get_focus and
seat_set_focus now accept and return nodes.
In the config->handler_context struct, current_container has been
replaced with three pointers: node, container and workspace. node is the
same as what current_container was, while workspace is the workspace
that the node resides on and container is the actual container, which
may be NULL if a workspace itself is focused.
The global root_container variable has been replaced with one simply
called root, which is a pointer to the sway_root instance.
The way outputs are created, enabled, disabled and destroyed has
changed. Previously we'd wrap the sway_output in a container when it is
enabled, but as we don't have containers any more it needs a different
approach. The output_create and output_destroy functions previously
created/destroyed the container, but now they create/destroy the
sway_output. There is a new function output_disable to disable an output
without destroying it.
Containers have a new view property. If this is populated then the
container is a view container, otherwise it's a layout container. Like
before, this property is immutable for the life of the container.
Containers have both a `sway_container *parent` and
`sway_workspace *workspace`. As we use specific types now, parent cannot
point to a workspace so it'll be NULL for containers which are direct
children of the workspace. The workspace property is set for all
containers, except those which are hidden in the scratchpad as they have
no workspace.
In some cases we need to refer to workspaces in a container-like way.
For example, workspaces have layout and children, but when using
specific types this makes it difficult. Likewise, it's difficult for a
container to get its parent's layout when the parent could be another
container or a workspace. To make it easier, some helper functions have
been created: container_parent_layout and container_get_siblings.
container_remove_child has been renamed to container_detach and
container_replace_child has been renamed to container_replace.
`container_handle_fullscreen_reparent(con, old_parent)` has had the
old_parent removed. We now unfullscreen the workspace when detaching the
container, so this function is simplified and only needs one argument
now.
container_notify_subtree_changed has been renamed to
container_update_representation. This is more descriptive of its
purpose. I also wanted to be able to call it with whatever container was
changed rather than the container's parent, which makes bubbling up to
the workspace easier.
There are now state structs per node thing. ie. sway_output_state,
sway_workspace_state and sway_container_state.
The focus, move and layout commands have been completely refactored to
work with the specific types. I considered making these a separate PR,
but I'd be backporting my changes only to replace them again, and it's
easier just to test everything at once.
2018-08-30 13:00:10 +02:00
|
|
|
struct wlr_output *wlr_output = output->wlr_output;
|
2018-04-04 03:06:13 +02:00
|
|
|
|
2022-06-23 21:03:32 +02:00
|
|
|
if (oc && (!oc->enabled || oc->power == 0)) {
|
2020-04-08 11:22:51 +02:00
|
|
|
sway_log(SWAY_DEBUG, "Turning off output %s", wlr_output->name);
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_enabled(pending, false);
|
2020-04-08 11:22:51 +02:00
|
|
|
return;
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
|
|
|
|
|
2020-04-09 10:01:21 +02:00
|
|
|
sway_log(SWAY_DEBUG, "Turning on output %s", wlr_output->name);
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_enabled(pending, true);
|
2020-04-09 10:01:21 +02:00
|
|
|
|
2021-07-18 12:05:47 +02:00
|
|
|
if (oc && oc->drm_mode.type != 0 && oc->drm_mode.type != (uint32_t) -1) {
|
|
|
|
|
sway_log(SWAY_DEBUG, "Set %s modeline",
|
|
|
|
|
wlr_output->name);
|
2022-06-07 18:55:26 +02:00
|
|
|
set_modeline(wlr_output, pending, &oc->drm_mode);
|
2021-07-18 12:05:47 +02:00
|
|
|
} else if (oc && oc->width > 0 && oc->height > 0) {
|
2020-04-09 10:01:21 +02:00
|
|
|
sway_log(SWAY_DEBUG, "Set %s mode to %dx%d (%f Hz)",
|
|
|
|
|
wlr_output->name, oc->width, oc->height, oc->refresh_rate);
|
2022-06-07 18:55:26 +02:00
|
|
|
set_mode(wlr_output, pending, oc->width, oc->height,
|
2020-04-09 10:01:21 +02:00
|
|
|
oc->refresh_rate, oc->custom_mode == 1);
|
|
|
|
|
} else if (!wl_list_empty(&wlr_output->modes)) {
|
2021-07-30 23:00:10 +02:00
|
|
|
sway_log(SWAY_DEBUG, "Set preferred mode");
|
|
|
|
|
struct wlr_output_mode *preferred_mode =
|
|
|
|
|
wlr_output_preferred_mode(wlr_output);
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_mode(pending, preferred_mode);
|
2021-07-30 23:00:10 +02:00
|
|
|
|
2022-06-07 18:55:26 +02:00
|
|
|
if (!wlr_output_test_state(wlr_output, pending)) {
|
2021-07-30 23:00:10 +02:00
|
|
|
sway_log(SWAY_DEBUG, "Preferred mode rejected, "
|
|
|
|
|
"falling back to another mode");
|
|
|
|
|
struct wlr_output_mode *mode;
|
|
|
|
|
wl_list_for_each(mode, &wlr_output->modes, link) {
|
|
|
|
|
if (mode == preferred_mode) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_mode(pending, mode);
|
|
|
|
|
if (wlr_output_test_state(wlr_output, pending)) {
|
2021-07-30 23:00:10 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
2019-01-17 22:30:24 +01:00
|
|
|
|
2019-02-11 01:56:57 +01:00
|
|
|
if (oc && (oc->subpixel != WL_OUTPUT_SUBPIXEL_UNKNOWN || config->reloading)) {
|
|
|
|
|
sway_log(SWAY_DEBUG, "Set %s subpixel to %s", oc->name,
|
|
|
|
|
sway_wl_output_subpixel_to_string(oc->subpixel));
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_subpixel(pending, oc->subpixel);
|
2019-02-11 01:56:57 +01:00
|
|
|
}
|
|
|
|
|
|
2021-09-19 16:37:50 +02:00
|
|
|
enum wl_output_transform tr = WL_OUTPUT_TRANSFORM_NORMAL;
|
2017-12-06 12:57:13 +01:00
|
|
|
if (oc && oc->transform >= 0) {
|
2021-09-19 16:37:50 +02:00
|
|
|
tr = oc->transform;
|
2022-11-26 20:15:52 +01:00
|
|
|
#if WLR_HAS_DRM_BACKEND
|
2021-09-19 16:37:50 +02:00
|
|
|
} else if (wlr_output_is_drm(wlr_output)) {
|
|
|
|
|
tr = wlr_drm_connector_get_panel_orientation(wlr_output);
|
|
|
|
|
sway_log(SWAY_DEBUG, "Auto-detected output transform: %d", tr);
|
2022-11-26 20:15:52 +01:00
|
|
|
#endif
|
2021-09-19 16:37:50 +02:00
|
|
|
}
|
|
|
|
|
if (wlr_output->transform != tr) {
|
|
|
|
|
sway_log(SWAY_DEBUG, "Set %s transform to %d", oc->name, tr);
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_transform(pending, tr);
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
|
|
|
|
|
2020-02-10 18:42:45 +01:00
|
|
|
// Apply the scale last before the commit, because the scale auto-detection
|
|
|
|
|
// reads the pending output size
|
|
|
|
|
float scale;
|
|
|
|
|
if (oc && oc->scale > 0) {
|
|
|
|
|
scale = oc->scale;
|
2023-02-20 18:56:43 +01:00
|
|
|
|
|
|
|
|
// The factional-scale-v1 protocol uses increments of 120ths to send
|
|
|
|
|
// the scale factor to the client. Adjust the scale so that we use the
|
|
|
|
|
// same value as the clients'.
|
|
|
|
|
float adjusted_scale = round(scale * 120) / 120;
|
|
|
|
|
if (scale != adjusted_scale) {
|
|
|
|
|
sway_log(SWAY_INFO, "Adjusting output scale from %f to %f",
|
|
|
|
|
scale, adjusted_scale);
|
|
|
|
|
scale = adjusted_scale;
|
|
|
|
|
}
|
2020-02-10 18:42:45 +01:00
|
|
|
} else {
|
2022-06-07 18:55:26 +02:00
|
|
|
scale = compute_default_scale(wlr_output, pending);
|
2020-02-10 18:42:45 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Auto-detected output scale: %f", scale);
|
|
|
|
|
}
|
|
|
|
|
if (scale != wlr_output->scale) {
|
2020-02-13 12:54:48 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Set %s scale to %f", wlr_output->name, scale);
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_scale(pending, scale);
|
2020-02-10 18:42:45 +01:00
|
|
|
}
|
|
|
|
|
|
2020-03-02 15:30:50 +01:00
|
|
|
if (oc && oc->adaptive_sync != -1) {
|
2020-04-08 11:22:51 +02:00
|
|
|
sway_log(SWAY_DEBUG, "Set %s adaptive sync to %d", wlr_output->name,
|
|
|
|
|
oc->adaptive_sync);
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_adaptive_sync_enabled(pending, oc->adaptive_sync == 1);
|
2022-06-28 17:47:15 +02:00
|
|
|
if (oc->adaptive_sync == 1 && !wlr_output_test_state(wlr_output, pending)) {
|
|
|
|
|
sway_log(SWAY_DEBUG, "Adaptive sync failed, ignoring");
|
|
|
|
|
wlr_output_state_set_adaptive_sync_enabled(pending, false);
|
|
|
|
|
}
|
2020-03-02 15:30:50 +01:00
|
|
|
}
|
2021-09-03 03:45:23 +02:00
|
|
|
|
|
|
|
|
if (oc && oc->render_bit_depth != RENDER_BIT_DEPTH_DEFAULT) {
|
|
|
|
|
const uint32_t *fmts = bit_depth_preferences[oc->render_bit_depth];
|
|
|
|
|
assert(fmts);
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0; fmts[i] != DRM_FORMAT_INVALID; i++) {
|
2022-06-07 18:55:26 +02:00
|
|
|
wlr_output_state_set_render_format(pending, fmts[i]);
|
|
|
|
|
if (wlr_output_test_state(wlr_output, pending)) {
|
2021-09-03 03:45:23 +02:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sway_log(SWAY_DEBUG, "Preferred output format 0x%08x "
|
|
|
|
|
"failed to work, falling back to next in "
|
|
|
|
|
"list, 0x%08x", fmts[i], fmts[i + 1]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-04-08 11:22:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool apply_output_config(struct output_config *oc, struct sway_output *output) {
|
2021-10-04 16:04:46 +02:00
|
|
|
if (output == root->fallback_output) {
|
2020-04-08 11:22:51 +02:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct wlr_output *wlr_output = output->wlr_output;
|
|
|
|
|
|
2020-07-10 18:04:45 +02:00
|
|
|
// Flag to prevent the output mode event handler from calling us
|
|
|
|
|
output->enabling = (!oc || oc->enabled);
|
2020-04-08 11:22:51 +02:00
|
|
|
|
2022-06-07 18:55:26 +02:00
|
|
|
struct wlr_output_state pending = {0};
|
|
|
|
|
queue_output_config(oc, output, &pending);
|
2020-04-08 11:22:51 +02:00
|
|
|
|
2019-12-27 11:47:51 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Committing output %s", wlr_output->name);
|
2022-06-07 18:55:26 +02:00
|
|
|
if (!wlr_output_commit_state(wlr_output, &pending)) {
|
2020-04-08 11:22:51 +02:00
|
|
|
// Failed to commit output changes, maybe the output is missing a CRTC.
|
|
|
|
|
// Leave the output disabled for now and try again when the output gets
|
|
|
|
|
// the mode we asked for.
|
|
|
|
|
sway_log(SWAY_ERROR, "Failed to commit output %s", wlr_output->name);
|
2020-07-10 18:04:45 +02:00
|
|
|
output->enabling = false;
|
2019-12-27 11:47:51 +01:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-10 18:04:45 +02:00
|
|
|
output->enabling = false;
|
|
|
|
|
|
2020-04-09 10:18:40 +02:00
|
|
|
if (oc && !oc->enabled) {
|
2020-07-10 18:04:45 +02:00
|
|
|
sway_log(SWAY_DEBUG, "Disabling output %s", oc->name);
|
|
|
|
|
if (output->enabled) {
|
|
|
|
|
output_disable(output);
|
|
|
|
|
wlr_output_layout_remove(root->output_layout, wlr_output);
|
|
|
|
|
}
|
2020-04-09 10:18:40 +02:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-11 14:23:29 +01:00
|
|
|
if (oc) {
|
|
|
|
|
enum scale_filter_mode scale_filter_old = output->scale_filter;
|
|
|
|
|
switch (oc->scale_filter) {
|
|
|
|
|
case SCALE_FILTER_DEFAULT:
|
|
|
|
|
case SCALE_FILTER_SMART:
|
|
|
|
|
output->scale_filter = ceilf(wlr_output->scale) == wlr_output->scale ?
|
|
|
|
|
SCALE_FILTER_NEAREST : SCALE_FILTER_LINEAR;
|
|
|
|
|
break;
|
|
|
|
|
case SCALE_FILTER_LINEAR:
|
|
|
|
|
case SCALE_FILTER_NEAREST:
|
|
|
|
|
output->scale_filter = oc->scale_filter;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (scale_filter_old != output->scale_filter) {
|
|
|
|
|
sway_log(SWAY_DEBUG, "Set %s scale_filter to %s", oc->name,
|
|
|
|
|
sway_output_scale_filter_to_string(output->scale_filter));
|
2023-08-16 23:45:01 +02:00
|
|
|
wlr_damage_ring_add_whole(&output->scene_output->damage_ring);
|
2020-02-11 14:23:29 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-06 12:36:06 +01:00
|
|
|
// Find position for it
|
2017-12-06 12:57:13 +01:00
|
|
|
if (oc && (oc->x != -1 || oc->y != -1)) {
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Set %s position to %d, %d", oc->name, oc->x, oc->y);
|
Implement type safe arguments and demote sway_container
This commit changes the meaning of sway_container so that it only refers
to layout containers and view containers. Workspaces, outputs and the
root are no longer known as containers. Instead, root, outputs,
workspaces and containers are all a type of node, and containers come in
two types: layout containers and view containers.
In addition to the above, this implements type safe variables. This
means we use specific types such as sway_output and sway_workspace
instead of generic containers or nodes. However, it's worth noting that
in a few places places (eg. seat focus and transactions) referring to
them in a generic way is unavoidable which is why we still use nodes in
some places.
If you want a TL;DR, look at node.h, as well as the struct definitions
for root, output, workspace and container. Note that sway_output now
contains a workspaces list, and workspaces now contain a tiling and
floating list, and containers now contain a pointer back to the
workspace.
There are now functions for seat_get_focused_workspace and
seat_get_focused_container. The latter will return NULL if a workspace
itself is focused. Most other seat functions like seat_get_focus and
seat_set_focus now accept and return nodes.
In the config->handler_context struct, current_container has been
replaced with three pointers: node, container and workspace. node is the
same as what current_container was, while workspace is the workspace
that the node resides on and container is the actual container, which
may be NULL if a workspace itself is focused.
The global root_container variable has been replaced with one simply
called root, which is a pointer to the sway_root instance.
The way outputs are created, enabled, disabled and destroyed has
changed. Previously we'd wrap the sway_output in a container when it is
enabled, but as we don't have containers any more it needs a different
approach. The output_create and output_destroy functions previously
created/destroyed the container, but now they create/destroy the
sway_output. There is a new function output_disable to disable an output
without destroying it.
Containers have a new view property. If this is populated then the
container is a view container, otherwise it's a layout container. Like
before, this property is immutable for the life of the container.
Containers have both a `sway_container *parent` and
`sway_workspace *workspace`. As we use specific types now, parent cannot
point to a workspace so it'll be NULL for containers which are direct
children of the workspace. The workspace property is set for all
containers, except those which are hidden in the scratchpad as they have
no workspace.
In some cases we need to refer to workspaces in a container-like way.
For example, workspaces have layout and children, but when using
specific types this makes it difficult. Likewise, it's difficult for a
container to get its parent's layout when the parent could be another
container or a workspace. To make it easier, some helper functions have
been created: container_parent_layout and container_get_siblings.
container_remove_child has been renamed to container_detach and
container_replace_child has been renamed to container_replace.
`container_handle_fullscreen_reparent(con, old_parent)` has had the
old_parent removed. We now unfullscreen the workspace when detaching the
container, so this function is simplified and only needs one argument
now.
container_notify_subtree_changed has been renamed to
container_update_representation. This is more descriptive of its
purpose. I also wanted to be able to call it with whatever container was
changed rather than the container's parent, which makes bubbling up to
the workspace easier.
There are now state structs per node thing. ie. sway_output_state,
sway_workspace_state and sway_container_state.
The focus, move and layout commands have been completely refactored to
work with the specific types. I considered making these a separate PR,
but I'd be backporting my changes only to replace them again, and it's
easier just to test everything at once.
2018-08-30 13:00:10 +02:00
|
|
|
wlr_output_layout_add(root->output_layout, wlr_output, oc->x, oc->y);
|
2017-12-06 12:36:06 +01:00
|
|
|
} else {
|
Implement type safe arguments and demote sway_container
This commit changes the meaning of sway_container so that it only refers
to layout containers and view containers. Workspaces, outputs and the
root are no longer known as containers. Instead, root, outputs,
workspaces and containers are all a type of node, and containers come in
two types: layout containers and view containers.
In addition to the above, this implements type safe variables. This
means we use specific types such as sway_output and sway_workspace
instead of generic containers or nodes. However, it's worth noting that
in a few places places (eg. seat focus and transactions) referring to
them in a generic way is unavoidable which is why we still use nodes in
some places.
If you want a TL;DR, look at node.h, as well as the struct definitions
for root, output, workspace and container. Note that sway_output now
contains a workspaces list, and workspaces now contain a tiling and
floating list, and containers now contain a pointer back to the
workspace.
There are now functions for seat_get_focused_workspace and
seat_get_focused_container. The latter will return NULL if a workspace
itself is focused. Most other seat functions like seat_get_focus and
seat_set_focus now accept and return nodes.
In the config->handler_context struct, current_container has been
replaced with three pointers: node, container and workspace. node is the
same as what current_container was, while workspace is the workspace
that the node resides on and container is the actual container, which
may be NULL if a workspace itself is focused.
The global root_container variable has been replaced with one simply
called root, which is a pointer to the sway_root instance.
The way outputs are created, enabled, disabled and destroyed has
changed. Previously we'd wrap the sway_output in a container when it is
enabled, but as we don't have containers any more it needs a different
approach. The output_create and output_destroy functions previously
created/destroyed the container, but now they create/destroy the
sway_output. There is a new function output_disable to disable an output
without destroying it.
Containers have a new view property. If this is populated then the
container is a view container, otherwise it's a layout container. Like
before, this property is immutable for the life of the container.
Containers have both a `sway_container *parent` and
`sway_workspace *workspace`. As we use specific types now, parent cannot
point to a workspace so it'll be NULL for containers which are direct
children of the workspace. The workspace property is set for all
containers, except those which are hidden in the scratchpad as they have
no workspace.
In some cases we need to refer to workspaces in a container-like way.
For example, workspaces have layout and children, but when using
specific types this makes it difficult. Likewise, it's difficult for a
container to get its parent's layout when the parent could be another
container or a workspace. To make it easier, some helper functions have
been created: container_parent_layout and container_get_siblings.
container_remove_child has been renamed to container_detach and
container_replace_child has been renamed to container_replace.
`container_handle_fullscreen_reparent(con, old_parent)` has had the
old_parent removed. We now unfullscreen the workspace when detaching the
container, so this function is simplified and only needs one argument
now.
container_notify_subtree_changed has been renamed to
container_update_representation. This is more descriptive of its
purpose. I also wanted to be able to call it with whatever container was
changed rather than the container's parent, which makes bubbling up to
the workspace easier.
There are now state structs per node thing. ie. sway_output_state,
sway_workspace_state and sway_container_state.
The focus, move and layout commands have been completely refactored to
work with the specific types. I considered making these a separate PR,
but I'd be backporting my changes only to replace them again, and it's
easier just to test everything at once.
2018-08-30 13:00:10 +02:00
|
|
|
wlr_output_layout_add_auto(root->output_layout, wlr_output);
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
|
|
|
|
|
2019-03-11 11:45:01 +01:00
|
|
|
// Update output->{lx, ly, width, height}
|
2022-01-29 21:11:54 +01:00
|
|
|
struct wlr_box output_box;
|
|
|
|
|
wlr_output_layout_get_box(root->output_layout, wlr_output, &output_box);
|
|
|
|
|
output->lx = output_box.x;
|
|
|
|
|
output->ly = output_box.y;
|
|
|
|
|
output->width = output_box.width;
|
|
|
|
|
output->height = output_box.height;
|
2018-10-08 15:08:33 +02:00
|
|
|
|
2020-07-10 18:04:45 +02:00
|
|
|
if (!output->enabled) {
|
|
|
|
|
output_enable(output);
|
2020-02-11 14:17:33 +01:00
|
|
|
}
|
|
|
|
|
|
2019-09-25 12:58:27 +02:00
|
|
|
if (oc && oc->max_render_time >= 0) {
|
|
|
|
|
sway_log(SWAY_DEBUG, "Set %s max render time to %d",
|
|
|
|
|
oc->name, oc->max_render_time);
|
|
|
|
|
output->max_render_time = oc->max_render_time;
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-26 01:06:51 +02:00
|
|
|
// Reconfigure all devices, since input config may have been applied before
|
|
|
|
|
// this output came online, and some config items (like map_to_output) are
|
|
|
|
|
// dependent on an output being present.
|
2023-11-16 14:56:46 +01:00
|
|
|
input_manager_configure_all_input_mappings();
|
2021-02-24 19:50:34 +01:00
|
|
|
// Reconfigure the cursor images, since the scale may have changed.
|
|
|
|
|
input_manager_configure_xcursor();
|
2019-01-17 22:30:24 +01:00
|
|
|
return true;
|
2017-12-06 12:36:06 +01:00
|
|
|
}
|
|
|
|
|
|
2020-04-08 11:22:51 +02:00
|
|
|
bool test_output_config(struct output_config *oc, struct sway_output *output) {
|
2021-10-04 16:04:46 +02:00
|
|
|
if (output == root->fallback_output) {
|
2020-04-08 11:22:51 +02:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-07 18:55:26 +02:00
|
|
|
struct wlr_output_state pending = {0};
|
|
|
|
|
queue_output_config(oc, output, &pending);
|
|
|
|
|
return wlr_output_test_state(output->wlr_output, &pending);
|
2020-04-08 11:22:51 +02:00
|
|
|
}
|
|
|
|
|
|
2018-12-12 18:13:03 +01:00
|
|
|
static void default_output_config(struct output_config *oc,
|
|
|
|
|
struct wlr_output *wlr_output) {
|
|
|
|
|
oc->enabled = 1;
|
2022-06-23 21:03:32 +02:00
|
|
|
oc->power = 1;
|
2019-11-05 08:11:13 +01:00
|
|
|
struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);
|
|
|
|
|
if (mode != NULL) {
|
2019-08-07 08:13:15 +02:00
|
|
|
oc->width = mode->width;
|
|
|
|
|
oc->height = mode->height;
|
2019-10-20 23:10:39 +02:00
|
|
|
oc->refresh_rate = mode->refresh / 1000.f;
|
2018-12-12 18:13:03 +01:00
|
|
|
}
|
|
|
|
|
oc->x = oc->y = -1;
|
2019-12-10 14:40:21 +01:00
|
|
|
oc->scale = 0; // auto
|
2019-11-13 19:23:36 +01:00
|
|
|
oc->scale_filter = SCALE_FILTER_DEFAULT;
|
2019-02-11 01:56:57 +01:00
|
|
|
struct sway_output *output = wlr_output->data;
|
|
|
|
|
oc->subpixel = output->detected_subpixel;
|
2018-12-12 18:13:03 +01:00
|
|
|
oc->transform = WL_OUTPUT_TRANSFORM_NORMAL;
|
2019-09-25 12:58:27 +02:00
|
|
|
oc->max_render_time = 0;
|
2018-12-12 18:13:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct output_config *get_output_config(char *identifier,
|
|
|
|
|
struct sway_output *sway_output) {
|
|
|
|
|
const char *name = sway_output->wlr_output->name;
|
2018-07-21 04:17:20 +02:00
|
|
|
|
2019-03-15 07:20:07 +01:00
|
|
|
struct output_config *oc_id_on_name = NULL;
|
|
|
|
|
struct output_config *oc_name = NULL;
|
2018-12-03 03:49:09 +01:00
|
|
|
struct output_config *oc_id = NULL;
|
2019-03-15 07:20:07 +01:00
|
|
|
|
2023-02-28 16:43:05 +01:00
|
|
|
char *id_on_name = format_str("%s on %s", identifier, name);
|
2019-03-15 07:20:07 +01:00
|
|
|
int i = list_seq_find(config->output_configs, output_name_cmp, id_on_name);
|
2018-07-21 04:17:20 +02:00
|
|
|
if (i >= 0) {
|
2019-03-15 07:20:07 +01:00
|
|
|
oc_id_on_name = config->output_configs->items[i];
|
|
|
|
|
} else {
|
|
|
|
|
i = list_seq_find(config->output_configs, output_name_cmp, name);
|
|
|
|
|
if (i >= 0) {
|
|
|
|
|
oc_name = config->output_configs->items[i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
i = list_seq_find(config->output_configs, output_name_cmp, identifier);
|
|
|
|
|
if (i >= 0) {
|
|
|
|
|
oc_id = config->output_configs->items[i];
|
|
|
|
|
}
|
2018-07-21 04:17:20 +02:00
|
|
|
}
|
|
|
|
|
|
2019-02-26 20:49:42 +01:00
|
|
|
struct output_config *result = new_output_config("temp");
|
2018-12-12 18:13:03 +01:00
|
|
|
if (config->reloading) {
|
|
|
|
|
default_output_config(result, sway_output->wlr_output);
|
|
|
|
|
}
|
2019-03-15 07:20:07 +01:00
|
|
|
if (oc_id_on_name) {
|
|
|
|
|
// Already have an identifier on name config, use that
|
|
|
|
|
free(result->name);
|
|
|
|
|
result->name = strdup(id_on_name);
|
|
|
|
|
merge_output_config(result, oc_id_on_name);
|
|
|
|
|
} else if (oc_name && oc_id) {
|
2018-12-03 03:49:09 +01:00
|
|
|
// Generate a config named `<identifier> on <name>` which contains a
|
|
|
|
|
// merged copy of the identifier on name. This will make sure that both
|
|
|
|
|
// identifier and name configs are respected, with identifier getting
|
|
|
|
|
// priority
|
2019-03-15 07:20:07 +01:00
|
|
|
struct output_config *temp = new_output_config(id_on_name);
|
|
|
|
|
merge_output_config(temp, oc_name);
|
|
|
|
|
merge_output_config(temp, oc_id);
|
|
|
|
|
list_add(config->output_configs, temp);
|
2018-12-03 03:49:09 +01:00
|
|
|
|
2018-12-12 18:13:03 +01:00
|
|
|
free(result->name);
|
2019-03-15 07:20:07 +01:00
|
|
|
result->name = strdup(id_on_name);
|
|
|
|
|
merge_output_config(result, temp);
|
2018-12-03 03:49:09 +01:00
|
|
|
|
2019-01-20 19:51:12 +01:00
|
|
|
sway_log(SWAY_DEBUG, "Generated output config \"%s\" (enabled: %d)"
|
2018-12-03 03:49:09 +01:00
|
|
|
" (%dx%d@%fHz position %d,%d scale %f transform %d) (bg %s %s)"
|
2022-06-23 21:03:32 +02:00
|
|
|
" (power %d) (max render time: %d)", result->name, result->enabled,
|
2019-09-25 12:58:27 +02:00
|
|
|
result->width, result->height, result->refresh_rate,
|
|
|
|
|
result->x, result->y, result->scale, result->transform,
|
2022-06-23 21:03:32 +02:00
|
|
|
result->background, result->background_option, result->power,
|
2019-09-25 12:58:27 +02:00
|
|
|
result->max_render_time);
|
2018-12-03 03:49:09 +01:00
|
|
|
} else if (oc_name) {
|
|
|
|
|
// No identifier config, just return a copy of the name config
|
2018-12-12 18:13:03 +01:00
|
|
|
free(result->name);
|
|
|
|
|
result->name = strdup(name);
|
2018-12-03 03:49:09 +01:00
|
|
|
merge_output_config(result, oc_name);
|
|
|
|
|
} else if (oc_id) {
|
|
|
|
|
// No name config, just return a copy of the identifier config
|
2018-12-12 18:13:03 +01:00
|
|
|
free(result->name);
|
|
|
|
|
result->name = strdup(identifier);
|
2018-12-03 03:49:09 +01:00
|
|
|
merge_output_config(result, oc_id);
|
2019-03-17 03:45:06 +01:00
|
|
|
} else {
|
2018-12-12 18:13:03 +01:00
|
|
|
i = list_seq_find(config->output_configs, output_name_cmp, "*");
|
|
|
|
|
if (i >= 0) {
|
2019-03-17 03:45:06 +01:00
|
|
|
// No name or identifier config, but there is a wildcard config
|
|
|
|
|
free(result->name);
|
|
|
|
|
result->name = strdup("*");
|
2018-12-12 18:13:03 +01:00
|
|
|
merge_output_config(result, config->output_configs->items[i]);
|
2019-03-17 03:45:06 +01:00
|
|
|
} else if (!config->reloading) {
|
|
|
|
|
// No name, identifier, or wildcard config. Since we are not
|
|
|
|
|
// reloading with defaults, the output config will be empty, so
|
|
|
|
|
// just return NULL
|
|
|
|
|
free_output_config(result);
|
|
|
|
|
result = NULL;
|
2018-12-12 18:13:03 +01:00
|
|
|
}
|
2018-12-03 03:49:09 +01:00
|
|
|
}
|
|
|
|
|
|
2019-03-15 07:20:07 +01:00
|
|
|
free(id_on_name);
|
2018-12-03 03:49:09 +01:00
|
|
|
return result;
|
2018-07-21 04:17:20 +02:00
|
|
|
}
|
|
|
|
|
|
Fix output config retrieval for new outputs
This removes `output_find_config`, which would take the first matching
output config it found. This is fine if only a name output config,
identifier output config, or even just wildcard exist, but if there is
a name output config and identifier output config, they are not merged.
Instead, this introduces find_output_config, which is just a wrapper
for `get_output_config`. This ensures that both the name and identifier
output configs are respected.
This fixes the following case:
- For simplicity in this example, remove all output configs from config
- Run `swaymsg output <name> bg #ff0000 solid_color`
- Run `swaymsg output <identifier> scale 2`
- Disconnect and reconnect output
Without this, the output will have the background, but not the scale.
With this, the output will have both the background and scale
2019-03-15 20:09:55 +01:00
|
|
|
struct output_config *find_output_config(struct sway_output *output) {
|
|
|
|
|
char id[128];
|
|
|
|
|
output_get_identifier(id, sizeof(id), output);
|
|
|
|
|
return get_output_config(id, output);
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-21 04:17:20 +02:00
|
|
|
void apply_output_config_to_outputs(struct output_config *oc) {
|
|
|
|
|
// Try to find the output container and apply configuration now. If
|
|
|
|
|
// this is during startup then there will be no container and config
|
|
|
|
|
// will be applied during normal "new output" event from wlroots.
|
|
|
|
|
bool wildcard = strcmp(oc->name, "*") == 0;
|
2020-01-17 03:26:15 +01:00
|
|
|
struct sway_output *sway_output, *tmp;
|
|
|
|
|
wl_list_for_each_safe(sway_output, tmp, &root->all_outputs, link) {
|
2023-02-28 12:51:59 +01:00
|
|
|
if (output_match_name_or_id(sway_output, oc->name)) {
|
|
|
|
|
char id[128];
|
|
|
|
|
output_get_identifier(id, sizeof(id), sway_output);
|
2019-03-15 07:20:07 +01:00
|
|
|
struct output_config *current = get_output_config(id, sway_output);
|
|
|
|
|
if (!current) {
|
|
|
|
|
// No stored output config matched, apply oc directly
|
|
|
|
|
sway_log(SWAY_DEBUG, "Applying oc directly");
|
|
|
|
|
current = new_output_config(oc->name);
|
|
|
|
|
merge_output_config(current, oc);
|
2018-07-21 04:17:20 +02:00
|
|
|
}
|
Implement type safe arguments and demote sway_container
This commit changes the meaning of sway_container so that it only refers
to layout containers and view containers. Workspaces, outputs and the
root are no longer known as containers. Instead, root, outputs,
workspaces and containers are all a type of node, and containers come in
two types: layout containers and view containers.
In addition to the above, this implements type safe variables. This
means we use specific types such as sway_output and sway_workspace
instead of generic containers or nodes. However, it's worth noting that
in a few places places (eg. seat focus and transactions) referring to
them in a generic way is unavoidable which is why we still use nodes in
some places.
If you want a TL;DR, look at node.h, as well as the struct definitions
for root, output, workspace and container. Note that sway_output now
contains a workspaces list, and workspaces now contain a tiling and
floating list, and containers now contain a pointer back to the
workspace.
There are now functions for seat_get_focused_workspace and
seat_get_focused_container. The latter will return NULL if a workspace
itself is focused. Most other seat functions like seat_get_focus and
seat_set_focus now accept and return nodes.
In the config->handler_context struct, current_container has been
replaced with three pointers: node, container and workspace. node is the
same as what current_container was, while workspace is the workspace
that the node resides on and container is the actual container, which
may be NULL if a workspace itself is focused.
The global root_container variable has been replaced with one simply
called root, which is a pointer to the sway_root instance.
The way outputs are created, enabled, disabled and destroyed has
changed. Previously we'd wrap the sway_output in a container when it is
enabled, but as we don't have containers any more it needs a different
approach. The output_create and output_destroy functions previously
created/destroyed the container, but now they create/destroy the
sway_output. There is a new function output_disable to disable an output
without destroying it.
Containers have a new view property. If this is populated then the
container is a view container, otherwise it's a layout container. Like
before, this property is immutable for the life of the container.
Containers have both a `sway_container *parent` and
`sway_workspace *workspace`. As we use specific types now, parent cannot
point to a workspace so it'll be NULL for containers which are direct
children of the workspace. The workspace property is set for all
containers, except those which are hidden in the scratchpad as they have
no workspace.
In some cases we need to refer to workspaces in a container-like way.
For example, workspaces have layout and children, but when using
specific types this makes it difficult. Likewise, it's difficult for a
container to get its parent's layout when the parent could be another
container or a workspace. To make it easier, some helper functions have
been created: container_parent_layout and container_get_siblings.
container_remove_child has been renamed to container_detach and
container_replace_child has been renamed to container_replace.
`container_handle_fullscreen_reparent(con, old_parent)` has had the
old_parent removed. We now unfullscreen the workspace when detaching the
container, so this function is simplified and only needs one argument
now.
container_notify_subtree_changed has been renamed to
container_update_representation. This is more descriptive of its
purpose. I also wanted to be able to call it with whatever container was
changed rather than the container's parent, which makes bubbling up to
the workspace easier.
There are now state structs per node thing. ie. sway_output_state,
sway_workspace_state and sway_container_state.
The focus, move and layout commands have been completely refactored to
work with the specific types. I considered making these a separate PR,
but I'd be backporting my changes only to replace them again, and it's
easier just to test everything at once.
2018-08-30 13:00:10 +02:00
|
|
|
apply_output_config(current, sway_output);
|
2018-12-03 03:49:09 +01:00
|
|
|
free_output_config(current);
|
2018-07-21 04:17:20 +02:00
|
|
|
|
|
|
|
|
if (!wildcard) {
|
|
|
|
|
// Stop looking if the output config isn't applicable to all
|
|
|
|
|
// outputs
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-08-06 11:33:06 +02:00
|
|
|
|
|
|
|
|
struct sway_seat *seat;
|
|
|
|
|
wl_list_for_each(seat, &server.input->seats, link) {
|
2020-05-21 03:20:19 +02:00
|
|
|
wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
|
2019-08-06 11:33:06 +02:00
|
|
|
cursor_rebase(seat->cursor);
|
|
|
|
|
}
|
2018-07-21 04:17:20 +02:00
|
|
|
}
|
|
|
|
|
|
2019-02-16 22:14:27 +01:00
|
|
|
void reset_outputs(void) {
|
|
|
|
|
struct output_config *oc = NULL;
|
|
|
|
|
int i = list_seq_find(config->output_configs, output_name_cmp, "*");
|
|
|
|
|
if (i >= 0) {
|
|
|
|
|
oc = config->output_configs->items[i];
|
|
|
|
|
} else {
|
|
|
|
|
oc = store_output_config(new_output_config("*"));
|
|
|
|
|
}
|
|
|
|
|
apply_output_config_to_outputs(oc);
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-06 12:36:06 +01:00
|
|
|
void free_output_config(struct output_config *oc) {
|
|
|
|
|
if (!oc) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
free(oc->name);
|
|
|
|
|
free(oc->background);
|
|
|
|
|
free(oc->background_option);
|
|
|
|
|
free(oc);
|
|
|
|
|
}
|
2019-04-04 03:53:43 +02:00
|
|
|
|
|
|
|
|
static void handle_swaybg_client_destroy(struct wl_listener *listener,
|
|
|
|
|
void *data) {
|
2019-05-04 05:26:18 +02:00
|
|
|
struct sway_config *sway_config =
|
|
|
|
|
wl_container_of(listener, sway_config, swaybg_client_destroy);
|
|
|
|
|
wl_list_remove(&sway_config->swaybg_client_destroy.link);
|
|
|
|
|
wl_list_init(&sway_config->swaybg_client_destroy.link);
|
|
|
|
|
sway_config->swaybg_client = NULL;
|
2019-04-04 03:53:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool _spawn_swaybg(char **command) {
|
|
|
|
|
if (config->swaybg_client != NULL) {
|
|
|
|
|
wl_client_destroy(config->swaybg_client);
|
|
|
|
|
}
|
|
|
|
|
int sockets[2];
|
|
|
|
|
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) != 0) {
|
|
|
|
|
sway_log_errno(SWAY_ERROR, "socketpair failed");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2019-10-29 06:54:16 +01:00
|
|
|
if (!sway_set_cloexec(sockets[0], true) || !sway_set_cloexec(sockets[1], true)) {
|
2019-04-04 03:53:43 +02:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
config->swaybg_client = wl_client_create(server.wl_display, sockets[0]);
|
|
|
|
|
if (config->swaybg_client == NULL) {
|
|
|
|
|
sway_log_errno(SWAY_ERROR, "wl_client_create failed");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
config->swaybg_client_destroy.notify = handle_swaybg_client_destroy;
|
|
|
|
|
wl_client_add_destroy_listener(config->swaybg_client,
|
|
|
|
|
&config->swaybg_client_destroy);
|
|
|
|
|
|
|
|
|
|
pid_t pid = fork();
|
|
|
|
|
if (pid < 0) {
|
|
|
|
|
sway_log_errno(SWAY_ERROR, "fork failed");
|
|
|
|
|
return false;
|
|
|
|
|
} else if (pid == 0) {
|
2021-10-21 21:52:17 +02:00
|
|
|
restore_nofile_limit();
|
|
|
|
|
|
2019-04-04 03:53:43 +02:00
|
|
|
pid = fork();
|
|
|
|
|
if (pid < 0) {
|
|
|
|
|
sway_log_errno(SWAY_ERROR, "fork failed");
|
|
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
|
} else if (pid == 0) {
|
2019-10-29 06:54:16 +01:00
|
|
|
if (!sway_set_cloexec(sockets[1], false)) {
|
2019-04-04 03:53:43 +02:00
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char wayland_socket_str[16];
|
|
|
|
|
snprintf(wayland_socket_str, sizeof(wayland_socket_str),
|
|
|
|
|
"%d", sockets[1]);
|
|
|
|
|
setenv("WAYLAND_SOCKET", wayland_socket_str, true);
|
|
|
|
|
|
|
|
|
|
execvp(command[0], command);
|
2023-12-12 22:54:31 +01:00
|
|
|
sway_log_errno(SWAY_ERROR, "failed to execute '%s' "
|
|
|
|
|
"(background configuration probably not applied)",
|
|
|
|
|
command[0]);
|
2019-04-04 03:53:43 +02:00
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
_exit(EXIT_SUCCESS);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (close(sockets[1]) != 0) {
|
|
|
|
|
sway_log_errno(SWAY_ERROR, "close failed");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2023-12-12 22:54:31 +01:00
|
|
|
int fork_status = 0;
|
|
|
|
|
if (waitpid(pid, &fork_status, 0) < 0) {
|
2019-04-04 03:53:43 +02:00
|
|
|
sway_log_errno(SWAY_ERROR, "waitpid failed");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2023-12-12 22:54:31 +01:00
|
|
|
return WIFEXITED(fork_status) && WEXITSTATUS(fork_status) == EXIT_SUCCESS;
|
2019-04-04 03:53:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool spawn_swaybg(void) {
|
|
|
|
|
if (!config->swaybg_command) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size_t length = 2;
|
|
|
|
|
for (int i = 0; i < config->output_configs->length; i++) {
|
|
|
|
|
struct output_config *oc = config->output_configs->items[i];
|
|
|
|
|
if (!oc->background) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (strcmp(oc->background_option, "solid_color") == 0) {
|
|
|
|
|
length += 4;
|
|
|
|
|
} else if (oc->background_fallback) {
|
|
|
|
|
length += 8;
|
|
|
|
|
} else {
|
|
|
|
|
length += 6;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-02 18:46:11 +02:00
|
|
|
char **cmd = calloc(length, sizeof(char *));
|
2019-04-04 03:53:43 +02:00
|
|
|
if (!cmd) {
|
|
|
|
|
sway_log(SWAY_ERROR, "Failed to allocate spawn_swaybg command");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size_t i = 0;
|
|
|
|
|
cmd[i++] = config->swaybg_command;
|
|
|
|
|
for (int j = 0; j < config->output_configs->length; j++) {
|
|
|
|
|
struct output_config *oc = config->output_configs->items[j];
|
|
|
|
|
if (!oc->background) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (strcmp(oc->background_option, "solid_color") == 0) {
|
|
|
|
|
cmd[i++] = "-o";
|
|
|
|
|
cmd[i++] = oc->name;
|
|
|
|
|
cmd[i++] = "-c";
|
|
|
|
|
cmd[i++] = oc->background;
|
|
|
|
|
} else {
|
|
|
|
|
cmd[i++] = "-o";
|
|
|
|
|
cmd[i++] = oc->name;
|
|
|
|
|
cmd[i++] = "-i";
|
|
|
|
|
cmd[i++] = oc->background;
|
|
|
|
|
cmd[i++] = "-m";
|
|
|
|
|
cmd[i++] = oc->background_option;
|
|
|
|
|
if (oc->background_fallback) {
|
|
|
|
|
cmd[i++] = "-c";
|
|
|
|
|
cmd[i++] = oc->background_fallback;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
assert(i <= length);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (size_t k = 0; k < i; k++) {
|
2019-04-08 21:18:42 +02:00
|
|
|
sway_log(SWAY_DEBUG, "spawn_swaybg cmd[%zd] = %s", k, cmd[k]);
|
2019-04-04 03:53:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool result = _spawn_swaybg(cmd);
|
|
|
|
|
free(cmd);
|
|
|
|
|
return result;
|
|
|
|
|
}
|