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

Render layer surfaces and respect exclusive zone

Browse Source
master
Drew DeVault 7 years ago
parent 0c8a64942e
commit 68cfa7ef67
9 changed files with 320 additions and 33 deletions
Show Stats Download Patch File Download Diff File

3
include/sway/layers.h
Unescape View File

@ -21,4 +21,7 @@ struct sway_layer_surface {
struct wlr_box geo; struct wlr_box geo;
}; };
struct sway_output;
void arrange_layers(struct sway_output *output);
#endif #endif

6
include/sway/output.h
Unescape View File

@ -4,6 +4,7 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/types/wlr_box.h> #include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <unistd.h>
struct sway_server; struct sway_server;
struct sway_container; struct sway_container;
@ -18,7 +19,10 @@ struct sway_output {
struct wlr_box usable_area; struct wlr_box usable_area;
struct wl_listener frame; struct wl_listener frame;
struct wl_listener output_destroy; struct wl_listener destroy;
struct wl_listener mode;
pid_t bg_pid;
}; };
#endif #endif

2
sway/commands/output.c
Unescape View File

@ -188,7 +188,7 @@ static struct cmd_results *cmd_output_background(struct output_config *output,
} }
wordexp_t p; wordexp_t p;
char *src = join_args(argv + *i - 1, j); char *src = join_args(argv + *i, j);
if (wordexp(src, &p, 0) != 0 || p.we_wordv[0] == NULL) { if (wordexp(src, &p, 0) != 0 || p.we_wordv[0] == NULL) {
return cmd_results_new(CMD_INVALID, "output", return cmd_results_new(CMD_INVALID, "output",
"Invalid syntax (%s).", src); "Invalid syntax (%s).", src);

31
sway/config/output.c
Unescape View File

@ -1,9 +1,12 @@
#define _XOPEN_SOURCE 700 #define _XOPEN_SOURCE 700
#include <assert.h>
#include <stdbool.h> #include <stdbool.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <signal.h>
#include <sys/wait.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_output_layout.h>
#include <unistd.h>
#include "sway/config.h" #include "sway/config.h"
#include "sway/output.h" #include "sway/output.h"
#include "log.h" #include "log.h"
@ -107,6 +110,16 @@ static void set_mode(struct wlr_output *output, int width, int height,
} }
} }
void terminate_swaybg(pid_t pid) {
int ret = kill(pid, SIGTERM);
if (ret != 0) {
wlr_log(L_ERROR, "Unable to terminate swaybg [pid: %d]", pid);
} else {
int status;
waitpid(pid, &status, 0);
}
}
void apply_output_config(struct output_config *oc, swayc_t *output) { void apply_output_config(struct output_config *oc, swayc_t *output) {
assert(output->type == C_OUTPUT); assert(output->type == C_OUTPUT);
@ -160,12 +173,12 @@ void apply_output_config(struct output_config *oc, swayc_t *output) {
} }
if (oc && oc->background) { if (oc && oc->background) {
// TODO swaybg if (output->sway_output->bg_pid != 0) {
/*if (output->bg_pid != 0) { terminate_swaybg(output->sway_output->bg_pid);
terminate_swaybg(output->bg_pid);
} }
wlr_log(L_DEBUG, "Setting background for output %d to %s", output_i, oc->background); wlr_log(L_DEBUG, "Setting background for output %d to %s",
output_i, oc->background);
size_t bufsize = 12; size_t bufsize = 12;
char output_id[bufsize]; char output_id[bufsize];
@ -173,17 +186,17 @@ void apply_output_config(struct output_config *oc, swayc_t *output) {
output_id[bufsize-1] = 0; output_id[bufsize-1] = 0;
char *const cmd[] = { char *const cmd[] = {
"swaybg", "./swaybg/swaybg",
output_id, output_id,
oc->background, oc->background,
oc->background_option, oc->background_option,
NULL, NULL,
}; };
output->bg_pid = fork(); output->sway_output->bg_pid = fork();
if (output->bg_pid == 0) { if (output->sway_output->bg_pid == 0) {
execvp(cmd[0], cmd); execvp(cmd[0], cmd);
}*/ }
} }
} }

239
sway/desktop/layer_shell.c
Unescape View File

@ -1,40 +1,261 @@
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_layer_shell.h>
#include <wlr/types/wlr_output.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "sway/layers.h" #include "sway/layers.h"
#include "sway/layout.h"
#include "sway/output.h" #include "sway/output.h"
#include "sway/server.h" #include "sway/server.h"
static void arrange_layers(struct sway_output *output) { static void apply_exclusive(struct wlr_box *usable_area,
// TODO uint32_t anchor, int32_t exclusive,
int32_t margin_top, int32_t margin_right,
int32_t margin_bottom, int32_t margin_left) {
if (exclusive <= 0) {
return;
}
struct {
uint32_t anchors;
int *positive_axis;
int *negative_axis;
int margin;
} edges[] = {
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
.positive_axis = &usable_area->y,
.negative_axis = &usable_area->height,
.margin = margin_top,
},
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
.positive_axis = NULL,
.negative_axis = &usable_area->height,
.margin = margin_bottom,
},
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
.positive_axis = &usable_area->x,
.negative_axis = &usable_area->width,
.margin = margin_left,
},
{
.anchors =
ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
.positive_axis = NULL,
.negative_axis = &usable_area->width,
.margin = margin_right,
},
};
for (size_t i = 0; i < sizeof(edges) / sizeof(edges[0]); ++i) {
if ((anchor & edges[i].anchors) == edges[i].anchors) {
if (edges[i].positive_axis) {
*edges[i].positive_axis += exclusive + edges[i].margin;
}
if (edges[i].negative_axis) {
*edges[i].negative_axis -= exclusive + edges[i].margin;
}
}
}
}
static void arrange_layer(struct sway_output *output, struct wl_list *list,
struct wlr_box *usable_area, bool exclusive) {
struct sway_layer_surface *sway_layer;
struct wlr_box full_area = { 0 };
wlr_output_effective_resolution(output->wlr_output,
&full_area.width, &full_area.height);
wl_list_for_each(sway_layer, list, link) {
struct wlr_layer_surface *layer = sway_layer->layer_surface;
struct wlr_layer_surface_state *state = &layer->current;
if (exclusive != (state->exclusive_zone > 0)) {
continue;
}
struct wlr_box bounds;
if (state->exclusive_zone == -1) {
bounds = full_area;
} else {
bounds = *usable_area;
}
struct wlr_box box = {
.width = state->desired_width,
.height = state->desired_height
};
// Horizontal axis
const uint32_t both_horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT
| ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
if ((state->anchor & both_horiz) && box.width == 0) {
box.x = bounds.x;
box.width = bounds.width;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
box.x = bounds.x;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
box.x = bounds.x + (bounds.width - box.width);
} else {
box.x = bounds.x + ((bounds.width / 2) - (box.width / 2));
}
// Vertical axis
const uint32_t both_vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
| ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
if ((state->anchor & both_vert) && box.height == 0) {
box.y = bounds.y;
box.height = bounds.height;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
box.y = bounds.y;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
box.y = bounds.y + (bounds.height - box.height);
} else {
box.y = bounds.y + ((bounds.height / 2) - (box.height / 2));
}
// Margin
if ((state->anchor & both_horiz) == both_horiz) {
box.x += state->margin.left;
box.width -= state->margin.left + state->margin.right;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
box.x += state->margin.left;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
box.x -= state->margin.right;
}
if ((state->anchor & both_vert) == both_vert) {
box.y += state->margin.top;
box.height -= state->margin.top + state->margin.bottom;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
box.y += state->margin.top;
} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
box.y -= state->margin.bottom;
}
if (box.width < 0 || box.height < 0) {
// TODO: Bubble up a protocol error?
wlr_layer_surface_close(layer);
continue;
}
// Apply
sway_layer->geo = box;
apply_exclusive(usable_area, state->anchor, state->exclusive_zone,
state->margin.top, state->margin.right,
state->margin.bottom, state->margin.left);
wlr_layer_surface_configure(layer, box.width, box.height);
}
}
void arrange_layers(struct sway_output *output) {
struct wlr_box usable_area = { 0 };
wlr_output_effective_resolution(output->wlr_output,
&usable_area.width, &usable_area.height);
struct wlr_box usable_area_before = output->usable_area;
// Arrange exclusive surfaces from top->bottom
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
&usable_area, true);
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
&usable_area, true);
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
&usable_area, true);
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
&usable_area, true);
memcpy(&output->usable_area, &usable_area, sizeof(struct wlr_box));
if (memcmp(&usable_area_before,
&usable_area, sizeof(struct wlr_box)) != 0) {
wlr_log(L_DEBUG, "arrange");
arrange_windows(output->swayc, -1, -1);
}
// Arrange non-exlusive surfaces from top->bottom
usable_area.x = usable_area.y = 0;
wlr_output_effective_resolution(output->wlr_output,
&usable_area.width, &usable_area.height);
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
&usable_area, false);
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
&usable_area, false);
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
&usable_area, false);
arrange_layer(output, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
&usable_area, false);
} }
static void handle_output_destroy(struct wl_listener *listener, void *data) { static void handle_output_destroy(struct wl_listener *listener, void *data) {
// TODO struct sway_layer_surface *sway_layer =
wl_container_of(listener, sway_layer, output_destroy);
sway_layer->layer_surface->output = NULL;
wl_list_remove(&sway_layer->output_destroy.link);
wl_list_remove(&sway_layer->output_mode.link);
wlr_layer_surface_close(sway_layer->layer_surface);
} }
static void handle_output_mode(struct wl_listener *listener, void *data) { static void handle_output_mode(struct wl_listener *listener, void *data) {
// TODO struct wlr_output *output = data;
arrange_layers((struct sway_output *)output->data);
} }
static void handle_output_transform(struct wl_listener *listener, void *data) { static void handle_output_transform(struct wl_listener *listener, void *data) {
// TODO struct wlr_output *output = data;
arrange_layers((struct sway_output *)output->data);
} }
static void handle_surface_commit(struct wl_listener *listener, void *data) { static void handle_surface_commit(struct wl_listener *listener, void *data) {
// TODO struct sway_layer_surface *layer =
wl_container_of(listener, layer, surface_commit);
struct wlr_layer_surface *layer_surface = layer->layer_surface;
struct wlr_output *wlr_output = layer_surface->output;
if (wlr_output != NULL) {
struct sway_output *output = wlr_output->data;
struct wlr_box old_geo = layer->geo;
arrange_layers(output);
if (memcmp(&old_geo, &layer->geo, sizeof(struct wlr_box)) != 0) {
// TODO DAMAGE apply whole surface from previous and new geos
} else {
// TODO DAMAGE from surface damage
}
}
}
static void unmap(struct wlr_layer_surface *layer_surface) {
// TODO DAMAGE
} }
static void handle_destroy(struct wl_listener *listener, void *data) { static void handle_destroy(struct wl_listener *listener, void *data) {
// TODO struct sway_layer_surface *sway_layer = wl_container_of(
listener, sway_layer, destroy);
if (sway_layer->layer_surface->mapped) {
unmap(sway_layer->layer_surface);
}
wl_list_remove(&sway_layer->link);
wl_list_remove(&sway_layer->destroy.link);
wl_list_remove(&sway_layer->map.link);
wl_list_remove(&sway_layer->unmap.link);
wl_list_remove(&sway_layer->surface_commit.link);
wl_list_remove(&sway_layer->output_destroy.link);
wl_list_remove(&sway_layer->output_mode.link);
wl_list_remove(&sway_layer->output_transform.link);
struct sway_output *output = sway_layer->layer_surface->output->data;
arrange_layers(output);
free(sway_layer);
} }
static void handle_map(struct wl_listener *listener, void *data) { static void handle_map(struct wl_listener *listener, void *data) {
// TODO // TODO DAMAGE
} }
static void handle_unmap(struct wl_listener *listener, void *data) { static void handle_unmap(struct wl_listener *listener, void *data) {
// TODO struct sway_layer_surface *sway_layer = wl_container_of(
listener, sway_layer, unmap);
unmap(sway_layer->layer_surface);
} }
void handle_layer_shell_surface(struct wl_listener *listener, void *data) { void handle_layer_shell_surface(struct wl_listener *listener, void *data) {

53
sway/desktop/output.c
Unescape View File

@ -4,14 +4,17 @@
#include <time.h> #include <time.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/render/wlr_renderer.h> #include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_box.h>
#include <wlr/types/wlr_matrix.h> #include <wlr/types/wlr_matrix.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_surface.h>
#include <wlr/types/wlr_wl_shell.h> #include <wlr/types/wlr_wl_shell.h>
#include "log.h" #include "log.h"
#include "sway/container.h" #include "sway/container.h"
#include "sway/input/input-manager.h" #include "sway/input/input-manager.h"
#include "sway/input/seat.h" #include "sway/input/seat.h"
#include "sway/layers.h"
#include "sway/layout.h" #include "sway/layout.h"
#include "sway/output.h" #include "sway/output.h"
#include "sway/server.h" #include "sway/server.h"
@ -177,6 +180,20 @@ static void output_frame_view(swayc_t *view, void *data) {
} }
} }
static void render_layer(struct sway_output *output,
const struct wlr_box *output_layout_box,
struct timespec *when,
struct wl_list *layer) {
struct sway_layer_surface *sway_layer;
wl_list_for_each(sway_layer, layer, link) {
struct wlr_layer_surface *layer = sway_layer->layer_surface;
render_surface(layer->surface, output->wlr_output, when,
sway_layer->geo.x + output_layout_box->x,
sway_layer->geo.y + output_layout_box->y, 0);
wlr_surface_send_frame_done(layer->surface, when);
}
}
static void output_frame_notify(struct wl_listener *listener, void *data) { static void output_frame_notify(struct wl_listener *listener, void *data) {
struct sway_output *soutput = wl_container_of(listener, soutput, frame); struct sway_output *soutput = wl_container_of(listener, soutput, frame);
struct wlr_output *wlr_output = data; struct wlr_output *wlr_output = data;
@ -189,6 +206,18 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
wlr_output_make_current(wlr_output, &buffer_age); wlr_output_make_current(wlr_output, &buffer_age);
wlr_renderer_begin(server->renderer, wlr_output->width, wlr_output->height); wlr_renderer_begin(server->renderer, wlr_output->width, wlr_output->height);
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
struct wlr_output_layout *layout = root_container.sway_root->output_layout;
const struct wlr_box *output_box = wlr_output_layout_get_box(
layout, wlr_output);
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND]);
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]);
struct sway_seat *seat = input_manager_current_seat(input_manager); struct sway_seat *seat = input_manager_current_seat(input_manager);
swayc_t *focus = sway_seat_get_focus_inactive(seat, soutput->swayc); swayc_t *focus = sway_seat_get_focus_inactive(seat, soutput->swayc);
swayc_t *workspace = (focus->type == C_WORKSPACE ? swayc_t *workspace = (focus->type == C_WORKSPACE ?
@ -210,22 +239,32 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
} }
} }
// TODO: Consider revising this when fullscreen windows are supported
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]);
render_layer(soutput, output_box, &now,
&soutput->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
wlr_renderer_end(server->renderer); wlr_renderer_end(server->renderer);
wlr_output_swap_buffers(wlr_output, &soutput->last_frame, NULL); wlr_output_swap_buffers(wlr_output, &soutput->last_frame, NULL);
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
soutput->last_frame = now; soutput->last_frame = now;
} }
static void handle_output_destroy(struct wl_listener *listener, void *data) { static void handle_output_destroy(struct wl_listener *listener, void *data) {
struct sway_output *output = wl_container_of(listener, output, output_destroy); struct sway_output *output = wl_container_of(listener, output, destroy);
struct wlr_output *wlr_output = data; struct wlr_output *wlr_output = data;
wlr_log(L_DEBUG, "Output %p %s removed", wlr_output, wlr_output->name); wlr_log(L_DEBUG, "Output %p %s removed", wlr_output, wlr_output->name);
destroy_output(output->swayc); destroy_output(output->swayc);
} }
static void handle_output_mode(struct wl_listener *listener, void *data) {
struct sway_output *output = wl_container_of(listener, output, mode);
arrange_layers(output);
arrange_windows(output->swayc, -1, -1);
}
void handle_new_output(struct wl_listener *listener, void *data) { void handle_new_output(struct wl_listener *listener, void *data) {
struct sway_server *server = wl_container_of(listener, server, new_output); struct sway_server *server = wl_container_of(listener, server, new_output);
struct wlr_output *wlr_output = data; struct wlr_output *wlr_output = data;
@ -260,9 +299,11 @@ void handle_new_output(struct wl_listener *listener, void *data) {
wl_signal_add(&wlr_output->events.frame, &output->frame); wl_signal_add(&wlr_output->events.frame, &output->frame);
output->frame.notify = output_frame_notify; output->frame.notify = output_frame_notify;
wl_signal_add(&wlr_output->events.destroy, &output->destroy);
output->destroy.notify = handle_output_destroy;
wl_signal_add(&wlr_output->events.mode, &output->mode);
output->mode.notify = handle_output_mode;
wl_signal_add(&wlr_output->events.destroy, &output->output_destroy); arrange_layers(output);
output->output_destroy.notify = handle_output_destroy;
arrange_windows(&root_container, -1, -1); arrange_windows(&root_container, -1, -1);
} }

4
sway/desktop/xwayland.c
Unescape View File

@ -84,7 +84,7 @@ static void set_activated(struct sway_view *view, bool activated) {
wlr_xwayland_surface_activate(surface, activated); wlr_xwayland_surface_activate(surface, activated);
} }
static void close(struct sway_view *view) { static void close_view(struct sway_view *view) {
if (!assert_xwayland(view)) { if (!assert_xwayland(view)) {
return; return;
} }
@ -203,7 +203,7 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
sway_view->iface.set_size = set_size; sway_view->iface.set_size = set_size;
sway_view->iface.set_position = set_position; sway_view->iface.set_position = set_position;
sway_view->iface.set_activated = set_activated; sway_view->iface.set_activated = set_activated;
sway_view->iface.close = close; sway_view->iface.close = close_view;
sway_view->wlr_xwayland_surface = xsurface; sway_view->wlr_xwayland_surface = xsurface;
sway_view->sway_xwayland_surface = sway_surface; sway_view->sway_xwayland_surface = sway_surface;
sway_view->surface = xsurface->surface; sway_view->surface = xsurface->surface;

4
sway/tree/container.c
Unescape View File

@ -254,7 +254,9 @@ swayc_t *destroy_output(swayc_t *output) {
} }
} }
wl_list_remove(&output->sway_output->output_destroy.link); wl_list_remove(&output->sway_output->frame.link);
wl_list_remove(&output->sway_output->destroy.link);
wl_list_remove(&output->sway_output->mode.link);
wlr_log(L_DEBUG, "OUTPUT: Destroying output '%s'", output->name); wlr_log(L_DEBUG, "OUTPUT: Destroying output '%s'", output->name);
free_swayc(output); free_swayc(output);

11
sway/tree/layout.c
Unescape View File

@ -204,10 +204,13 @@ void arrange_windows(swayc_t *container, double width, double height) {
case C_WORKSPACE: case C_WORKSPACE:
{ {
swayc_t *output = swayc_parent_by_type(container, C_OUTPUT); swayc_t *output = swayc_parent_by_type(container, C_OUTPUT);
container->width = output->width; struct wlr_box *area = &output->sway_output->usable_area;
container->height = output->height; wlr_log(L_DEBUG, "Usable area for ws: %dx%d@%d,%d",
container->x = x; area->width, area->height, area->x, area->y);
container->y = y; container->width = area->width;
container->height = area->height;
container->x = x = area->x;
container->y = y = area->y;
wlr_log(L_DEBUG, "Arranging workspace '%s' at %f, %f", wlr_log(L_DEBUG, "Arranging workspace '%s' at %f, %f",
container->name, container->x, container->y); container->name, container->x, container->y);
} }

Write Preview
Loading…
Cancel
Save