itycodes
/
wlseeds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #128 from acrisci/feature/layout-autoconfiguration

Browse Source 
implement output layout auto configuration
master
Drew DeVault 7 years ago committed by GitHub
parent e91c91d455 6d26fda57c
commit 252a1b9c13
8 changed files with 283 additions and 196 deletions
Show Stats Download Patch File Download Diff File

49
examples/config.c
Unescape View File

@ -255,49 +255,14 @@ void example_config_destroy(struct example_config *config) {
free(config); free(config);
} }
struct wlr_output_layout *configure_layout(struct example_config *config, struct output_config *example_config_get_output(struct example_config *config,
struct wl_list *outputs) { struct wlr_output *output) {
struct wlr_output_layout *layout = wlr_output_layout_init(); struct output_config *o_config;
int max_x = INT_MIN; wl_list_for_each(o_config, &config->outputs, link) {
int max_x_y = INT_MIN; // y value for the max_x output if (strcmp(o_config->name, output->name) == 0) {
return o_config;
// first add all the configured outputs
struct output_state *output;
wl_list_for_each(output, outputs, link) {
struct output_config *conf;
wl_list_for_each(conf, &config->outputs, link) {
if (strcmp(conf->name, output->output->name) == 0) {
wlr_output_layout_add(layout, output->output,
conf->x, conf->y);
wlr_output_transform(output->output, conf->transform);
int width, height;
wlr_output_effective_resolution(output->output, &width,
&height);
if (conf->x + width > max_x) {
max_x = conf->x + width;
max_x_y = conf->y;
} }
break;
}
}
}
if (max_x == INT_MIN) {
// couldn't find a configured output
max_x = 0;
max_x_y = 0;
} }
// now add all the other configured outputs in a sensible position return NULL;
wl_list_for_each(output, outputs, link) {
if (wlr_output_layout_get(layout, output->output)) {
continue;
}
wlr_output_layout_add(layout, output->output, max_x, max_x_y);
int width, height;
wlr_output_effective_resolution(output->output, &width, &height);
max_x += width;
}
return layout;
} }

9
examples/config.h
Unescape View File

@ -34,6 +34,11 @@ struct example_config *parse_args(int argc, char *argv[]);
void example_config_destroy(struct example_config *config); void example_config_destroy(struct example_config *config);
struct wlr_output_layout *configure_layout(struct example_config *config, /**
struct wl_list *outputs); * Get configuration for the output. If the output is not configured, returns
* NULL.
*/
struct output_config *example_config_get_output(struct example_config *config,
struct wlr_output *output);
#endif #endif

124
examples/output-layout.c
Unescape View File

@ -32,42 +32,16 @@ struct sample_state {
struct wlr_output_layout *layout; struct wlr_output_layout *layout;
float x_offs, y_offs; float x_offs, y_offs;
float x_vel, y_vel; float x_vel, y_vel;
struct wlr_output *main_output; struct timespec ts_last;
struct wl_list outputs;
}; };
static void handle_output_frame(struct output_state *output, struct timespec *ts) { static void animate_cat(struct sample_state *sample,
struct compositor_state *state = output->compositor; struct wlr_output *output) {
struct sample_state *sample = state->data; struct timespec ts;
struct wlr_output *wlr_output = output->output; clock_gettime(CLOCK_MONOTONIC, &ts);
long ms = (ts.tv_sec - sample->ts_last.tv_sec) * 1000 +
wlr_output_make_current(wlr_output); (ts.tv_nsec - sample->ts_last.tv_nsec) / 1000000;
wlr_renderer_begin(sample->renderer, wlr_output); // how many seconds have passed since the last time we animated
if (wlr_output_layout_intersects(sample->layout, output->output,
sample->x_offs, sample->y_offs,
sample->x_offs + 128, sample->y_offs + 128)) {
float matrix[16];
// transform global coordinates to local coordinates
double local_x = sample->x_offs;
double local_y = sample->y_offs;
wlr_output_layout_output_coords(sample->layout, output->output, &local_x,
&local_y);
wlr_texture_get_matrix(sample->cat_texture, &matrix,
&wlr_output->transform_matrix, local_x, local_y);
wlr_render_with_matrix(sample->renderer,
sample->cat_texture, &matrix);
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
if (output->output == sample->main_output) {
long ms = (ts->tv_sec - output->last_frame.tv_sec) * 1000 +
(ts->tv_nsec - output->last_frame.tv_nsec) / 1000000;
// how many seconds have passed since the last frame
float seconds = ms / 1000.0f; float seconds = ms / 1000.0f;
if (seconds > 0.1f) { if (seconds > 0.1f) {
@ -88,10 +62,10 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
if (ur_collision && ul_collision && ll_collision && lr_collision) { if (ur_collision && ul_collision && ll_collision && lr_collision) {
// oops we went off the screen somehow // oops we went off the screen somehow
struct wlr_output_layout_output *main_l_output; struct wlr_output_layout_output *l_output =
main_l_output = wlr_output_layout_get(sample->layout, sample->main_output); wlr_output_layout_get(sample->layout, output);
sample->x_offs = main_l_output->x + 20; sample->x_offs = l_output->x + 20;
sample->y_offs = main_l_output->y + 20; sample->y_offs = l_output->y + 20;
} else if (ur_collision && ul_collision) { } else if (ur_collision && ul_collision) {
sample->y_vel = fabs(sample->y_vel); sample->y_vel = fabs(sample->y_vel);
} else if (lr_collision && ll_collision) { } else if (lr_collision && ll_collision) {
@ -117,32 +91,62 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
sample->x_offs += sample->x_vel * seconds; sample->x_offs += sample->x_vel * seconds;
sample->y_offs += sample->y_vel * seconds; sample->y_offs += sample->y_vel * seconds;
sample->ts_last = ts;
} }
static void handle_output_frame(struct output_state *output,
struct timespec *ts) {
struct compositor_state *state = output->compositor;
struct sample_state *sample = state->data;
struct wlr_output *wlr_output = output->output;
wlr_output_make_current(wlr_output);
wlr_renderer_begin(sample->renderer, wlr_output);
animate_cat(sample, output->output);
bool intersects = wlr_output_layout_intersects(sample->layout,
output->output, sample->x_offs, sample->y_offs,
sample->x_offs + 128, sample->y_offs + 128);
if (intersects) {
float matrix[16];
// transform global coordinates to local coordinates
double local_x = sample->x_offs;
double local_y = sample->y_offs;
wlr_output_layout_output_coords(sample->layout, output->output,
&local_x, &local_y);
wlr_texture_get_matrix(sample->cat_texture, &matrix,
&wlr_output->transform_matrix, local_x, local_y);
wlr_render_with_matrix(sample->renderer,
sample->cat_texture, &matrix);
} }
static void set_main_output(struct sample_state *sample, wlr_renderer_end(sample->renderer);
struct wlr_output *output) { wlr_output_swap_buffers(wlr_output);
sample->main_output = output;
struct wlr_output_layout_output *l_output;
l_output = wlr_output_layout_get(sample->layout, output);
sample->x_offs = l_output->x + 200;
sample->y_offs = l_output->y + 200;
} }
static void handle_output_resolution(struct compositor_state *state, struct output_state *output) { static void handle_output_add(struct output_state *ostate) {
struct sample_state *sample = state->data; struct sample_state *sample = ostate->compositor->data;
wlr_output_layout_destroy(sample->layout);
sample->layout = configure_layout(sample->config, &sample->outputs);
set_main_output(sample, output->output);
struct output_config *o_config =
example_config_get_output(sample->config, ostate->output);
if (o_config) {
wlr_output_transform(ostate->output, o_config->transform);
wlr_output_layout_add(sample->layout, ostate->output, o_config->x,
o_config->y);
} else {
wlr_output_layout_add_auto(sample->layout, ostate->output);
}
} }
static void handle_output_add(struct output_state *output) { static void handle_output_remove(struct output_state *ostate) {
struct sample_state *sample = output->compositor->data; struct sample_state *sample = ostate->compositor->data;
wl_list_insert(&sample->outputs, &output->link); wlr_output_layout_remove(sample->layout, ostate->output);
wlr_output_layout_destroy(sample->layout);
sample->layout = configure_layout(sample->config, &sample->outputs);
set_main_output(sample, output->output);
} }
static void update_velocities(struct compositor_state *state, static void update_velocities(struct compositor_state *state,
@ -152,8 +156,8 @@ static void update_velocities(struct compositor_state *state,
sample->y_vel += y_diff; sample->y_vel += y_diff;
} }
static void handle_keyboard_key(struct keyboard_state *kbstate, uint32_t keycode, static void handle_keyboard_key(struct keyboard_state *kbstate,
xkb_keysym_t sym, enum wlr_key_state key_state) { uint32_t keycode, xkb_keysym_t sym, enum wlr_key_state key_state) {
// NOTE: It may be better to simply refer to our key state during each frame // NOTE: It may be better to simply refer to our key state during each frame
// and make this change in pixels/sec^2 // and make this change in pixels/sec^2
// Also, key repeat // Also, key repeat
@ -182,15 +186,15 @@ int main(int argc, char *argv[]) {
state.x_vel = 500; state.x_vel = 500;
state.y_vel = 500; state.y_vel = 500;
state.layout = wlr_output_layout_init(); state.layout = wlr_output_layout_init();
clock_gettime(CLOCK_MONOTONIC, &state.ts_last);
wl_list_init(&state.outputs);
state.config = parse_args(argc, argv); state.config = parse_args(argc, argv);
struct compositor_state compositor = { 0 }; struct compositor_state compositor = { 0 };
compositor.data = &state; compositor.data = &state;
compositor.output_add_cb = handle_output_add; compositor.output_add_cb = handle_output_add;
compositor.output_remove_cb = handle_output_remove;
compositor.output_frame_cb = handle_output_frame; compositor.output_frame_cb = handle_output_frame;
compositor.output_resolution_cb = handle_output_resolution;
compositor.keyboard_key_cb = handle_keyboard_key; compositor.keyboard_key_cb = handle_keyboard_key;
compositor_init(&compositor); compositor_init(&compositor);

34
examples/pointer.c
Unescape View File

@ -132,11 +132,16 @@ static void handle_output_add(struct output_state *ostate) {
struct wlr_output *wlr_output = ostate->output; struct wlr_output *wlr_output = ostate->output;
struct wlr_xcursor_image *image = sample->xcursor->images[0]; struct wlr_xcursor_image *image = sample->xcursor->images[0];
// reset layout struct output_config *o_config =
wlr_output_layout_destroy(sample->layout); example_config_get_output(sample->config, ostate->output);
sample->layout =
configure_layout(sample->config, &ostate->compositor->outputs); if (o_config) {
wlr_cursor_attach_output_layout(sample->cursor, sample->layout); wlr_output_transform(ostate->output, o_config->transform);
wlr_output_layout_add(sample->layout, ostate->output, o_config->x,
o_config->y);
} else {
wlr_output_layout_add_auto(sample->layout, ostate->output);
}
// cursor configuration // cursor configuration
char *mapped_output = sample->config->cursor.mapped_output; char *mapped_output = sample->config->cursor.mapped_output;
@ -159,10 +164,8 @@ static void handle_output_add(struct output_state *ostate) {
static void handle_output_remove(struct output_state *ostate) { static void handle_output_remove(struct output_state *ostate) {
struct sample_state *sample = ostate->compositor->data; struct sample_state *sample = ostate->compositor->data;
wlr_output_layout_destroy(sample->layout);
sample->layout = wlr_output_layout_remove(sample->layout, ostate->output);
configure_layout(sample->config, &ostate->compositor->outputs);
wlr_cursor_attach_output_layout(sample->cursor, sample->layout);
configure_devices(sample); configure_devices(sample);
@ -172,15 +175,6 @@ static void handle_output_remove(struct output_state *ostate) {
} }
} }
static void handle_output_resolution(struct compositor_state *state,
struct output_state *ostate) {
struct sample_state *sample = ostate->compositor->data;
wlr_output_layout_destroy(sample->layout);
sample->layout =
configure_layout(sample->config, &ostate->compositor->outputs);
wlr_cursor_attach_output_layout(sample->cursor, sample->layout);
}
static void handle_input_add(struct compositor_state *state, static void handle_input_add(struct compositor_state *state,
struct wlr_input_device *device) { struct wlr_input_device *device) {
struct sample_state *sample = state->data; struct sample_state *sample = state->data;
@ -341,6 +335,8 @@ int main(int argc, char *argv[]) {
state.config = parse_args(argc, argv); state.config = parse_args(argc, argv);
state.cursor = wlr_cursor_create(); state.cursor = wlr_cursor_create();
state.layout = wlr_output_layout_init();
wlr_cursor_attach_output_layout(state.cursor, state.layout);
wlr_cursor_map_to_region(state.cursor, state.config->cursor.mapped_box); wlr_cursor_map_to_region(state.cursor, state.config->cursor.mapped_box);
wl_list_init(&state.devices); wl_list_init(&state.devices);
@ -380,7 +376,6 @@ int main(int argc, char *argv[]) {
compositor.data = &state; compositor.data = &state;
compositor.output_add_cb = handle_output_add; compositor.output_add_cb = handle_output_add;
compositor.output_remove_cb = handle_output_remove; compositor.output_remove_cb = handle_output_remove;
compositor.output_resolution_cb = handle_output_resolution;
compositor.output_frame_cb = handle_output_frame; compositor.output_frame_cb = handle_output_frame;
compositor.input_add_cb = handle_input_add; compositor.input_add_cb = handle_input_add;
compositor.input_remove_cb = handle_input_remove; compositor.input_remove_cb = handle_input_remove;
@ -407,4 +402,5 @@ int main(int argc, char *argv[]) {
wlr_xcursor_theme_destroy(theme); wlr_xcursor_theme_destroy(theme);
example_config_destroy(state.config); example_config_destroy(state.config);
wlr_cursor_destroy(state.cursor); wlr_cursor_destroy(state.cursor);
wlr_output_layout_destroy(state.layout);
} }

1
include/wlr/types/wlr_output.h
Unescape View File

@ -37,6 +37,7 @@ struct wlr_output {
struct { struct {
struct wl_signal frame; struct wl_signal frame;
struct wl_signal resolution; struct wl_signal resolution;
struct wl_signal destroy;
} events; } events;
struct { struct {

11
include/wlr/types/wlr_output_layout.h
Unescape View File

@ -67,4 +67,15 @@ void wlr_output_layout_closest_point(struct wlr_output_layout *layout,
struct wlr_box *wlr_output_layout_get_box( struct wlr_box *wlr_output_layout_get_box(
struct wlr_output_layout *layout, struct wlr_output *reference); struct wlr_output_layout *layout, struct wlr_output *reference);
/**
* Add an auto configured output to the layout. This will place the output in a
* sensible location in the layout. The coordinates of the output in the layout
* may adjust dynamically when the layout changes. If the output is already in
* the layout, it will become auto configured. If the position of the output is
* set such as with `wlr_output_layout_move()`, the output will become manually
* configured.
*/
void wlr_output_layout_add_auto(struct wlr_output_layout *layout,
struct wlr_output *output);
#endif #endif

3
types/wlr_output.c
Unescape View File

@ -100,6 +100,7 @@ void wlr_output_init(struct wlr_output *output,
output->scale = 1; output->scale = 1;
wl_signal_init(&output->events.frame); wl_signal_init(&output->events.frame);
wl_signal_init(&output->events.resolution); wl_signal_init(&output->events.resolution);
wl_signal_init(&output->events.destroy);
} }
void wlr_output_enable(struct wlr_output *output, bool enable) { void wlr_output_enable(struct wlr_output *output, bool enable) {
@ -176,6 +177,8 @@ void wlr_output_destroy(struct wlr_output *output) {
return; return;
} }
wl_signal_emit(&output->events.destroy, output);
wlr_texture_destroy(output->cursor.texture); wlr_texture_destroy(output->cursor.texture);
wlr_renderer_destroy(output->cursor.renderer); wlr_renderer_destroy(output->cursor.renderer);

190
types/wlr_output_layout.c
Unescape View File

@ -12,7 +12,14 @@ struct wlr_output_layout_state {
}; };
struct wlr_output_layout_output_state { struct wlr_output_layout_output_state {
struct wlr_output_layout *layout;
struct wlr_output_layout_output *l_output;
struct wlr_box *_box; struct wlr_box *_box;
bool auto_configured;
struct wl_listener resolution;
struct wl_listener output_destroy;
}; };
struct wlr_output_layout *wlr_output_layout_init() { struct wlr_output_layout *wlr_output_layout_init() {
@ -26,6 +33,8 @@ struct wlr_output_layout *wlr_output_layout_init() {
static void wlr_output_layout_output_destroy( static void wlr_output_layout_output_destroy(
struct wlr_output_layout_output *l_output) { struct wlr_output_layout_output *l_output) {
wl_list_remove(&l_output->state->resolution.link);
wl_list_remove(&l_output->state->output_destroy.link);
wl_list_remove(&l_output->link); wl_list_remove(&l_output->link);
free(l_output->state->_box); free(l_output->state->_box);
free(l_output->state); free(l_output->state);
@ -47,16 +56,105 @@ void wlr_output_layout_destroy(struct wlr_output_layout *layout) {
free(layout); free(layout);
} }
void wlr_output_layout_add(struct wlr_output_layout *layout, static struct wlr_box *wlr_output_layout_output_get_box(
struct wlr_output *output, int x, int y) { struct wlr_output_layout_output *l_output) {
l_output->state->_box->x = l_output->x;
l_output->state->_box->y = l_output->y;
int width, height;
wlr_output_effective_resolution(l_output->output, &width, &height);
l_output->state->_box->width = width;
l_output->state->_box->height = height;
return l_output->state->_box;
}
/**
* This must be called whenever the layout changes to reconfigure the auto
* configured outputs.
*
* Auto configured outputs are placed to the right of the north east corner of
* the rightmost output in the layout in a horizontal line.
*/
static void wlr_output_layout_reconfigure(struct wlr_output_layout *layout) {
int max_x = INT_MIN;
int max_x_y = INT_MIN; // y value for the max_x output
// find the rightmost x coordinate occupied by a manually configured output
// in the layout
struct wlr_output_layout_output *l_output;
wl_list_for_each(l_output, &layout->outputs, link) {
if (l_output->state->auto_configured) {
continue;
}
struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
if (box->x + box->width > max_x) {
max_x = box->x + box->width;
max_x_y = box->y;
}
}
if (max_x == INT_MIN) {
// there are no manually configured outputs
max_x = 0;
max_x_y = 0;
}
wl_list_for_each(l_output, &layout->outputs, link) {
if (!l_output->state->auto_configured) {
continue;
}
struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
l_output->x = max_x;
l_output->y = max_x_y;
max_x += box->width;
}
}
static void handle_output_resolution(struct wl_listener *listener, void *data) {
struct wlr_output_layout_output_state *state =
wl_container_of(listener, state, resolution);
wlr_output_layout_reconfigure(state->layout);
}
static void handle_output_destroy(struct wl_listener *listener, void *data) {
struct wlr_output_layout_output_state *state =
wl_container_of(listener, state, output_destroy);
struct wlr_output_layout *layout = state->layout;
wlr_output_layout_output_destroy(state->l_output);
wlr_output_layout_reconfigure(layout);
}
static struct wlr_output_layout_output *wlr_output_layout_output_create(
struct wlr_output_layout *layout, struct wlr_output *output) {
struct wlr_output_layout_output *l_output; struct wlr_output_layout_output *l_output;
l_output= calloc(1, sizeof(struct wlr_output_layout_output)); l_output= calloc(1, sizeof(struct wlr_output_layout_output));
l_output->state = calloc(1, sizeof(struct wlr_output_layout_output_state)); l_output->state = calloc(1, sizeof(struct wlr_output_layout_output_state));
l_output->state->l_output = l_output;
l_output->state->_box = calloc(1, sizeof(struct wlr_box)); l_output->state->_box = calloc(1, sizeof(struct wlr_box));
l_output->state->layout = layout;
l_output->output = output; l_output->output = output;
wl_list_insert(&layout->outputs, &l_output->link);
wl_signal_add(&output->events.resolution, &l_output->state->resolution);
l_output->state->resolution.notify = handle_output_resolution;
wl_signal_add(&output->events.destroy, &l_output->state->output_destroy);
l_output->state->output_destroy.notify = handle_output_destroy;
return l_output;
}
void wlr_output_layout_add(struct wlr_output_layout *layout,
struct wlr_output *output, int x, int y) {
struct wlr_output_layout_output *l_output =
wlr_output_layout_get(layout, output);
if (!l_output) {
l_output = wlr_output_layout_output_create(layout, output);
}
l_output->x = x; l_output->x = x;
l_output->y = y; l_output->y = y;
wl_list_insert(&layout->outputs, &l_output->link); l_output->state->auto_configured = false;
wlr_output_layout_reconfigure(layout);
} }
struct wlr_output_layout_output *wlr_output_layout_get( struct wlr_output_layout_output *wlr_output_layout_get(
@ -70,20 +168,13 @@ struct wlr_output_layout_output *wlr_output_layout_get(
return NULL; return NULL;
} }
static bool output_contains_point( struct wlr_output_layout_output *l_output,
int x, int y, int width, int height) {
return x >= l_output->x && x <= l_output->x + width &&
y >= l_output->y && y <= l_output->y + height;
}
bool wlr_output_layout_contains_point(struct wlr_output_layout *layout, bool wlr_output_layout_contains_point(struct wlr_output_layout *layout,
struct wlr_output *reference, int x, int y) { struct wlr_output *reference, int x, int y) {
if (reference) { if (reference) {
struct wlr_output_layout_output *layout_output = struct wlr_output_layout_output *l_output =
wlr_output_layout_get(layout, reference); wlr_output_layout_get(layout, reference);
int width, height; struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
wlr_output_effective_resolution(layout_output->output, &width, &height); return wlr_box_contains_point(box, x, y);
return output_contains_point(layout_output, x, y, width, height);
} else { } else {
return !!wlr_output_layout_output_at(layout, x, y); return !!wlr_output_layout_output_at(layout, x, y);
} }
@ -93,17 +184,17 @@ bool wlr_output_layout_intersects(struct wlr_output_layout *layout,
struct wlr_output *reference, int x1, int y1, int x2, int y2) { struct wlr_output *reference, int x1, int y1, int x2, int y2) {
struct wlr_output_layout_output *l_output = struct wlr_output_layout_output *l_output =
wlr_output_layout_get(layout, reference); wlr_output_layout_get(layout, reference);
if (!l_output) { if (!l_output) {
return false; return false;
} }
int width, height;
wlr_output_effective_resolution(l_output->output, &width, &height);
// the output must contain one of the points // the output box must contain one of the points
return output_contains_point(l_output, x1, y1, width, height) || struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
output_contains_point(l_output, x2, y2, width, height) || return wlr_box_contains_point(box, x1, y1) ||
output_contains_point(l_output, x2, y1, width, height) || wlr_box_contains_point(box, x2, y2) ||
output_contains_point(l_output, y2, x1, width, height); wlr_box_contains_point(box, x2, y1) ||
wlr_box_contains_point(box, y2, x1);
} }
struct wlr_output *wlr_output_layout_output_at(struct wlr_output_layout *layout, struct wlr_output *wlr_output_layout_output_at(struct wlr_output_layout *layout,
@ -111,11 +202,8 @@ struct wlr_output *wlr_output_layout_output_at(struct wlr_output_layout *layout,
struct wlr_output_layout_output *l_output; struct wlr_output_layout_output *l_output;
wl_list_for_each(l_output, &layout->outputs, link) { wl_list_for_each(l_output, &layout->outputs, link) {
if (l_output->output) { if (l_output->output) {
int width, height; struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
wlr_output_effective_resolution(l_output->output, &width, &height); if (wlr_box_contains_point(box, x, y)) {
bool has_x = x >= l_output->x && x <= l_output->x + width;
bool has_y = y >= l_output->y && y <= l_output->y + height;
if (has_x && has_y) {
return l_output->output; return l_output->output;
} }
} }
@ -130,6 +218,10 @@ void wlr_output_layout_move(struct wlr_output_layout *layout,
if (l_output) { if (l_output) {
l_output->x = x; l_output->x = x;
l_output->y = y; l_output->y = y;
l_output->state->auto_configured = false;
wlr_output_layout_reconfigure(layout);
} else {
wlr_log(L_ERROR, "output not found in this layout: %s", output->name);
} }
} }
@ -139,6 +231,7 @@ void wlr_output_layout_remove(struct wlr_output_layout *layout,
l_output= wlr_output_layout_get(layout, output); l_output= wlr_output_layout_get(layout, output);
if (l_output) { if (l_output) {
wlr_output_layout_output_destroy(l_output); wlr_output_layout_output_destroy(l_output);
wlr_output_layout_reconfigure(layout);
} }
} }
@ -158,15 +251,6 @@ void wlr_output_layout_output_coords(struct wlr_output_layout *layout,
} }
} }
static struct wlr_box *wlr_output_layout_output_get_box(
struct wlr_output_layout_output *l_output) {
l_output->state->_box->x = l_output->x;
l_output->state->_box->y = l_output->y;
wlr_output_effective_resolution(l_output->output,
&l_output->state->_box->width, &l_output->state->_box->height);
return l_output->state->_box;
}
void wlr_output_layout_closest_point(struct wlr_output_layout *layout, void wlr_output_layout_closest_point(struct wlr_output_layout *layout,
struct wlr_output *reference, double x, double y, double *dest_x, struct wlr_output *reference, double x, double y, double *dest_x,
double *dest_y) { double *dest_y) {
@ -202,25 +286,30 @@ struct wlr_box *wlr_output_layout_get_box(
if (reference) { if (reference) {
// output extents // output extents
l_output = wlr_output_layout_get(layout, reference); l_output = wlr_output_layout_get(layout, reference);
if (l_output) {
return wlr_output_layout_output_get_box(l_output); return wlr_output_layout_output_get_box(l_output);
} else {
return NULL;
}
} else { } else {
// layout extents // layout extents
int min_x = INT_MAX, min_y = INT_MAX; int min_x = INT_MAX, min_y = INT_MAX;
int max_x = INT_MIN, max_y = INT_MIN; int max_x = INT_MIN, max_y = INT_MIN;
wl_list_for_each(l_output, &layout->outputs, link) { wl_list_for_each(l_output, &layout->outputs, link) {
int width, height; struct wlr_box *box = wlr_output_layout_output_get_box(l_output);
wlr_output_effective_resolution(l_output->output, &width, &height);
if (l_output->x < min_x) { if (box->x < min_x) {
min_x = l_output->x; min_x = box->x;
} }
if (l_output->y < min_y) { if (box->y < min_y) {
min_y = l_output->y; min_y = box->y;
} }
if (l_output->x + width > max_x) { if (box->x + box->width > max_x) {
max_x = l_output->x + width; max_x = box->x + box->width;
} }
if (l_output->y + height > max_y) { if (box->y + box->height > max_y) {
max_y = l_output->y + height; max_y = box->y + box->height;
} }
} }
@ -234,3 +323,16 @@ struct wlr_box *wlr_output_layout_get_box(
// not reached // not reached
} }
void wlr_output_layout_add_auto(struct wlr_output_layout *layout,
struct wlr_output *output) {
struct wlr_output_layout_output *l_output =
wlr_output_layout_get(layout, output);
if (!l_output) {
l_output = wlr_output_layout_output_create(layout, output);
}
l_output->state->auto_configured = true;
wlr_output_layout_reconfigure(layout);
}

Write Preview
Loading…
Cancel
Save