mirrors/sway
1
0
Fork 0
mirror of https://github.com/swaywm/sway.git synced 2026-04-28 06:46:26 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge 4af49202c7 into cc5713aee6

Browse source
This commit is contained in:
taiyu 2015-08-21 02:25:36 +00:00
commit 274ab988bf
9 changed files with 425 additions and 330 deletions
Download patch file Download diff file Expand all files Collapse all files

7
include/container.h
View file

@ -2,8 +2,8 @@
#define _SWAY_CONTAINER_H
#include <wlc/wlc.h>
typedef struct sway_container swayc_t;
#include "layout.h"
#include "focus.h"
enum swayc_types{
C_ROOT,
@ -78,10 +78,15 @@ swayc_t *destroy_container(swayc_t *container);
// parent
swayc_t *destroy_view(swayc_t *view);
// Container info
bool swayc_is_fullscreen(swayc_t *view);
// Container Lookup
swayc_t *swayc_parent_by_type(swayc_t *container, enum swayc_types);
swayc_t *swayc_parent_by_layout(swayc_t *container, enum swayc_layouts);
swayc_t *swayc_by_handle(wlc_handle handle);
swayc_t *swayc_by_direction(swayc_t *container, enum movement_direction dir);
swayc_t *find_container(swayc_t *container, bool (*test)(swayc_t *view, void *data), void *data);
void container_map(swayc_t *, void (*f)(swayc_t *, void *), void *);

4
include/layout.h
View file

@ -25,8 +25,4 @@ void unfocus_all(swayc_t *container);
void focus_view(swayc_t *view);
void focus_view_for(swayc_t *ancestor, swayc_t *container);
swayc_t *get_focused_container(swayc_t *parent);
swayc_t *get_swayc_for_handle(wlc_handle handle, swayc_t *parent);
swayc_t *get_swayc_in_direction(swayc_t *container, enum movement_direction dir);
#endif

74
sway/commands.c
View file

@ -294,36 +294,39 @@ static bool cmd_focus(struct sway_config *config, int argc, char **argv) {
} else if (strcasecmp(argv[0], "mode_toggle") == 0) {
int i;
swayc_t *focused = get_focused_view(active_workspace);
if (focused->is_floating) {
if (active_workspace->children->length > 0) {
for (i = 0;i < active_workspace->floating->length; i++) {
if (active_workspace->floating->items[i] == focused) {
floating_toggled_index = i;
break;
// Dont change focus if fullscreen
if (!swayc_is_fullscreen(focused)) {
if (focused->is_floating) {
if (active_workspace->children->length > 0) {
for (i = 0;i < active_workspace->floating->length; i++) {
if (active_workspace->floating->items[i] == focused) {
floating_toggled_index = i;
break;
}
}
if (active_workspace->children->length > tiled_toggled_index) {
set_focused_container(get_focused_view(active_workspace->children->items[tiled_toggled_index]));
} else {
set_focused_container(get_focused_view(active_workspace->children->items[0]));
tiled_toggled_index = 0;
}
}
if (active_workspace->children->length > tiled_toggled_index) {
set_focused_container(get_focused_view(active_workspace->children->items[tiled_toggled_index]));
} else {
set_focused_container(get_focused_view(active_workspace->children->items[0]));
tiled_toggled_index = 0;
}
}
} else {
if (active_workspace->floating->length > 0) {
for (i = 0;i < active_workspace->children->length; i++) {
if (active_workspace->children->items[i] == focused) {
tiled_toggled_index = i;
break;
} else {
if (active_workspace->floating->length > 0) {
for (i = 0;i < active_workspace->children->length; i++) {
if (active_workspace->children->items[i] == focused) {
tiled_toggled_index = i;
break;
}
}
if (active_workspace->floating->length > floating_toggled_index) {
swayc_t *floating = active_workspace->floating->items[floating_toggled_index];
set_focused_container(get_focused_view(floating));
} else {
swayc_t *floating = active_workspace->floating->items[active_workspace->floating->length - 1];
set_focused_container(get_focused_view(floating));
tiled_toggled_index = active_workspace->floating->length - 1;
}
}
if (active_workspace->floating->length > floating_toggled_index) {
swayc_t *floating = active_workspace->floating->items[floating_toggled_index];
set_focused_container(get_focused_view(floating));
} else {
swayc_t *floating = active_workspace->floating->items[active_workspace->floating->length - 1];
set_focused_container(get_focused_view(floating));
tiled_toggled_index = active_workspace->floating->length - 1;
}
}
}
@ -442,6 +445,9 @@ static bool _do_split(struct sway_config *config, int argc, char **argv, int lay
}
swayc_t *focused = get_focused_container(&root_container);
if (focused->is_floating) {
return true;
}
if (focused->type == C_WORKSPACE && focused->children->length <= 1) {
/* Case that focus is on an workspace with 0/1 children.change its layout */
sway_log(L_DEBUG, "changing workspace layout");
@ -505,17 +511,15 @@ static bool cmd_fullscreen(struct sway_config *config, int argc, char **argv) {
return false;
}
//get focused view and check current state.
swayc_t *container = get_focused_view(&root_container);
bool current = (wlc_view_get_state(container->handle) & WLC_BIT_FULLSCREEN) > 0;
bool current = swayc_is_fullscreen(container);
wlc_view_set_state(container->handle, WLC_BIT_FULLSCREEN, !current);
// Resize workspace if going from fullscreen -> notfullscreen
// otherwise just resize container
if (current) {
container = swayc_parent_by_type(container, C_WORKSPACE);
// Resize workspace
container = swayc_parent_by_type(container, C_WORKSPACE);
if (container) {
arrange_windows(container, -1, -1);
}
// Only resize container when going into fullscreen
arrange_windows(container, -1, -1);
return true;
}

132
sway/container.c
View file

@ -11,11 +11,17 @@
#define ASSERT_NONNULL(PTR) \
sway_assert (PTR, "%s: " #PTR "must be non-null", __func__)
static swayc_t *new_swayc(enum swayc_types type) {
static swayc_t *new_swayc(enum swayc_types type, wlc_handle handle) {
swayc_t *c = calloc(1, sizeof(swayc_t));
c->handle = -1;
if (handle > 0) {
c->handle = handle;
wlc_handle_set_user_data(handle, c);
} else {
c->handle = 0;
}
c->layout = L_NONE;
c->type = type;
c->gaps = 0;
if (type != C_VIEW) {
c->children = create_list();
}
@ -26,14 +32,16 @@ static void free_swayc(swayc_t *cont) {
if (!ASSERT_NONNULL(cont)) {
return;
}
// TODO does not properly handle containers with children,
// TODO but functions that call this usually check for that
sway_log(L_DEBUG, "destroying container %p, handle:%ld",cont, cont->handle);
if (cont->handle) {
wlc_handle_set_user_data(cont->handle, 0);
}
// Destroy all children
if (cont->children) {
if (cont->children->length) {
int i;
for (i = 0; i < cont->children->length; ++i) {
free_swayc(cont->children->items[i]);
}
// children remove themselves from parent, so continue until theres no
// more children
while (cont->children->length) {
free_swayc(cont->children->items[0]);
}
list_free(cont->children);
}
@ -58,7 +66,7 @@ static void free_swayc(swayc_t *cont) {
// New containers
static bool workspace_test(swayc_t *view, void *name) {
return strcasecmp(view->name, (char *)name) == 0;
return strcasecmp(view->name, name) == 0;
}
swayc_t *new_output(wlc_handle handle) {
@ -66,12 +74,10 @@ swayc_t *new_output(wlc_handle handle) {
const char *name = wlc_output_get_name(handle);
sway_log(L_DEBUG, "Added output %lu:%s", handle, name);
swayc_t *output = new_swayc(C_OUTPUT);
swayc_t *output = new_swayc(C_OUTPUT, handle);
output->width = size->w;
output->height = size->h;
output->handle = handle;
output->name = name ? strdup(name) : NULL;
output->gaps = config->gaps_outer + config->gaps_inner / 2;
add_child(&root_container, output);
@ -101,9 +107,12 @@ swayc_t *new_output(wlc_handle handle) {
// create and initilize default workspace
swayc_t *ws = new_workspace(output, ws_name);
ws->is_focused = true;
if (!active_workspace) {
active_workspace = ws;
}
free(ws_name);
return output;
}
@ -112,13 +121,14 @@ swayc_t *new_workspace(swayc_t *output, const char *name) {
return NULL;
}
sway_log(L_DEBUG, "Added workspace %s for output %u", name, (unsigned int)output->handle);
swayc_t *workspace = new_swayc(C_WORKSPACE);
swayc_t *workspace = new_swayc(C_WORKSPACE, 0);
workspace->layout = L_HORIZ; // TODO: default layout
workspace->x = output->x;
workspace->y = output->y;
workspace->width = output->width;
workspace->height = output->height;
workspace->gaps = config->gaps_outer;
workspace->name = strdup(name);
workspace->visible = true;
workspace->floating = create_list();
@ -128,10 +138,10 @@ swayc_t *new_workspace(swayc_t *output, const char *name) {
}
swayc_t *new_container(swayc_t *child, enum swayc_layouts layout) {
if (!ASSERT_NONNULL(child)) {
if (!ASSERT_NONNULL(child) || child->is_floating) {
return NULL;
}
swayc_t *cont = new_swayc(C_CONTAINER);
swayc_t *cont = new_swayc(C_CONTAINER, 0);
sway_log(L_DEBUG, "creating container %p around %p", cont, child);
@ -177,11 +187,10 @@ swayc_t *new_view(swayc_t *sibling, wlc_handle handle) {
return NULL;
}
const char *title = wlc_view_get_title(handle);
swayc_t *view = new_swayc(C_VIEW);
swayc_t *view = new_swayc(C_VIEW, handle);
sway_log(L_DEBUG, "Adding new view %lu:%s to container %p %d",
handle, title, sibling, sibling ? sibling->type : 0);
// Setup values
view->handle = handle;
view->name = title ? strdup(title) : NULL;
view->visible = true;
view->is_focused = true;
@ -208,11 +217,10 @@ swayc_t *new_view(swayc_t *sibling, wlc_handle handle) {
swayc_t *new_floating_view(wlc_handle handle) {
const char *title = wlc_view_get_title(handle);
swayc_t *view = new_swayc(C_VIEW);
swayc_t *view = new_swayc(C_VIEW, handle);
sway_log(L_DEBUG, "Adding new view %lu:%x:%s as a floating view",
handle, wlc_view_get_type(handle), title);
// Setup values
view->handle = handle;
view->name = title ? strdup(title) : NULL;
view->visible = true;
@ -241,19 +249,20 @@ swayc_t *new_floating_view(wlc_handle handle) {
// Destroy container
swayc_t *destroy_output(swayc_t *output) {
#define DESTROY_FUNC __attribute__((nonnull)) swayc_t *
DESTROY_FUNC destroy_output(swayc_t *output) {
if (!ASSERT_NONNULL(output)) {
return NULL;
}
if (output->children->length == 0) {
// TODO move workspaces to other outputs
}
sway_log(L_DEBUG, "OUTPUT: Destroying output '%lu'", output->handle);
sway_log(L_DEBUG, "%s:'%lu'", __func__, output->handle);
free_swayc(output);
return &root_container;
}
swayc_t *destroy_workspace(swayc_t *workspace) {
DESTROY_FUNC destroy_workspace(swayc_t *workspace) {
if (!ASSERT_NONNULL(workspace)) {
return NULL;
}
@ -276,12 +285,12 @@ swayc_t *destroy_workspace(swayc_t *workspace) {
return NULL;
}
swayc_t *destroy_container(swayc_t *container) {
DESTROY_FUNC destroy_container(swayc_t *container) {
if (!ASSERT_NONNULL(container)) {
return NULL;
}
while (container->children->length == 0 && container->type == C_CONTAINER) {
sway_log(L_DEBUG, "Container: Destroying container '%p'", container);
sway_log(L_DEBUG, "%s: '%p'", __func__, container);
swayc_t *parent = container->parent;
free_swayc(container);
container = parent;
@ -289,11 +298,11 @@ swayc_t *destroy_container(swayc_t *container) {
return container;
}
swayc_t *destroy_view(swayc_t *view) {
DESTROY_FUNC destroy_view(swayc_t *view) {
if (!ASSERT_NONNULL(view)) {
return NULL;
}
sway_log(L_DEBUG, "Destroying view '%p'", view);
sway_log(L_DEBUG, "%s: '%p'", __func__, view);
swayc_t *parent = view->parent;
free_swayc(view);
@ -303,6 +312,15 @@ swayc_t *destroy_view(swayc_t *view) {
}
return parent;
}
#undef DESTROY_FUNC
// Container info function
bool swayc_is_fullscreen(swayc_t *view) {
return view
&& view->type == C_VIEW
&& (wlc_view_get_state(view->handle) & WLC_BIT_FULLSCREEN);
}
// Container lookup
@ -332,6 +350,61 @@ swayc_t *swayc_parent_by_layout(swayc_t *container, enum swayc_layouts layout) {
return container;
}
swayc_t *swayc_by_handle(wlc_handle handle) {
return wlc_handle_get_user_data(handle);
}
swayc_t *swayc_by_direction(swayc_t *container, enum movement_direction dir) {
swayc_t *parent = container->parent;
if (dir == MOVE_PARENT) {
if (parent->type == C_OUTPUT) {
return NULL;
} else {
return parent;
}
}
while (true) {
// Test if we can even make a difference here
bool can_move = false;
int diff = 0;
if (dir == MOVE_LEFT || dir == MOVE_RIGHT) {
if (parent->layout == L_HORIZ || parent->type == C_ROOT) {
can_move = true;
diff = dir == MOVE_LEFT ? -1 : 1;
}
} else {
if (parent->layout == L_VERT) {
can_move = true;
diff = dir == MOVE_UP ? -1 : 1;
}
}
if (can_move) {
int i;
for (i = 0; i < parent->children->length; ++i) {
swayc_t *child = parent->children->items[i];
if (child == container) {
break;
}
}
int desired = i + diff;
if (desired < 0 || desired >= parent->children->length) {
can_move = false;
} else {
return parent->children->items[desired];
}
}
if (!can_move) {
container = parent;
parent = parent->parent;
if (!parent) {
// Nothing we can do
return NULL;
}
}
}
}
swayc_t *find_container(swayc_t *container, bool (*test)(swayc_t *view, void *data), void *data) {
if (!container->children) {
return NULL;
@ -398,10 +471,11 @@ void reset_gaps(swayc_t *view, void *data) {
if (!ASSERT_NONNULL(view)) {
return;
}
if (view->type == C_OUTPUT) {
if (view->type == C_WORKSPACE) {
view->gaps = config->gaps_outer;
}
if (view->type == C_VIEW) {
view->gaps = config->gaps_inner;
}
}

34
sway/focus.c
View file

@ -54,8 +54,8 @@ static void update_focus(swayc_t *c) {
}
bool move_focus(enum movement_direction direction) {
swayc_t *view = get_swayc_in_direction(
get_focused_container(&root_container), direction);
swayc_t *view = get_focused_container(&root_container);
view = swayc_by_direction(view, direction);
if (view) {
if (direction == MOVE_PARENT) {
set_focused_container(view);
@ -84,10 +84,16 @@ void set_focused_container(swayc_t *c) {
return;
}
sway_log(L_DEBUG, "Setting focus to %p:%ld", c, c->handle);
// Find previous focused view, and the new focused view, if they are the same return
swayc_t *focused = get_focused_view(&root_container);
swayc_t *workspace = active_workspace;
// Get workspace for c, get that workspaces current focused container.
// if that focsued container is fullscreen dont change focus
swayc_t *workspace = c;
if (workspace->type != C_WORKSPACE) {
workspace = swayc_parent_by_type(c, C_WORKSPACE);
}
swayc_t *focused = get_focused_view(workspace);
if (active_workspace == workspace && swayc_is_fullscreen(focused)) {
return;
}
// update container focus from here to root, making necessary changes along
// the way
@ -101,13 +107,6 @@ void set_focused_container(swayc_t *c) {
p->is_focused = false;
}
// if the workspace is the same, and previous focus is fullscreen, dont
// change focus
if (workspace == active_workspace
&& wlc_view_get_state(focused->handle) & WLC_BIT_FULLSCREEN) {
return;
}
// get new focused view and set focus to it.
p = get_focused_view(c);
if (p->type == C_VIEW && !(wlc_view_get_type(p->handle) & WLC_BIT_POPUP)) {
@ -137,6 +136,15 @@ void set_focused_container_for(swayc_t *a, swayc_t *c) {
return;
}
}
// Get workspace for c, get that workspaces current focused container.
// if that focsued container is fullscreen dont change focus
swayc_t *workspace = swayc_parent_by_type(c, C_WORKSPACE);
swayc_t *focused = get_focused_view(workspace);
if (swayc_is_fullscreen(focused)) {
return;
}
// Check if we changing a parent container that will see chnage
bool effective = true;
while (find != &root_container) {

21
sway/handlers.c
View file

@ -113,7 +113,7 @@ static void handle_output_destroyed(wlc_handle output) {
static void handle_output_resolution_change(wlc_handle output, const struct wlc_size *from, const struct wlc_size *to) {
sway_log(L_DEBUG, "Output %u resolution changed to %d x %d", (unsigned int)output, to->w, to->h);
swayc_t *c = get_swayc_for_handle(output, &root_container);
swayc_t *c = swayc_by_handle(output);
if (!c) return;
c->width = to->w;
c->height = to->h;
@ -121,7 +121,7 @@ static void handle_output_resolution_change(wlc_handle output, const struct wlc_
}
static void handle_output_focused(wlc_handle output, bool focus) {
swayc_t *c = get_swayc_for_handle(output, &root_container);
swayc_t *c = swayc_by_handle(output);
// if for some reason this output doesnt exist, create it.
if (!c) {
handle_output_created(output);
@ -139,7 +139,7 @@ static bool handle_view_created(wlc_handle handle) {
// Get parent container, to add view in
if (parent) {
focused = get_swayc_for_handle(parent, &root_container);
focused = swayc_by_handle(parent);
}
if (!focused || focused->type == C_OUTPUT) {
focused = get_focused_container(&root_container);
@ -196,7 +196,7 @@ static bool handle_view_created(wlc_handle handle) {
static void handle_view_destroyed(wlc_handle handle) {
sway_log(L_DEBUG, "Destroying window %lu", handle);
swayc_t *view = get_swayc_for_handle(handle, &root_container);
swayc_t *view = swayc_by_handle(handle);
switch (wlc_view_get_type(handle)) {
// regular view created regularly
@ -230,7 +230,7 @@ static void handle_view_geometry_request(wlc_handle handle, const struct wlc_geo
// If the view is floating, then apply the geometry.
// Otherwise save the desired width/height for the view.
// This will not do anything for the time being as WLC improperly sends geometry requests
swayc_t *view = get_swayc_for_handle(handle, &root_container);
swayc_t *view = swayc_by_handle(handle);
if (view) {
view->desired_width = geometry->size.w;
view->desired_height = geometry->size.h;
@ -246,7 +246,7 @@ static void handle_view_geometry_request(wlc_handle handle, const struct wlc_geo
}
static void handle_view_state_request(wlc_handle view, enum wlc_view_state_bit state, bool toggle) {
swayc_t *c = get_swayc_for_handle(view, &root_container);
swayc_t *c = swayc_by_handle(view);
switch (state) {
case WLC_BIT_FULLSCREEN:
// i3 just lets it become fullscreen
@ -420,10 +420,7 @@ static bool handle_pointer_motion(wlc_handle handle, uint32_t time, const struct
}
}
if (config->focus_follows_mouse && prev_handle != handle) {
// Dont change focus if fullscreen
swayc_t *focused = get_focused_view(view);
if (!(focused->type == C_VIEW && wlc_view_get_state(focused->handle) & WLC_BIT_FULLSCREEN)
&& !(pointer_state.l_held || pointer_state.r_held)) {
if (!(pointer_state.l_held || pointer_state.r_held)) {
set_focused_container(container_under_pointer());
}
}
@ -451,7 +448,7 @@ static bool handle_pointer_button(wlc_handle view, uint32_t time, const struct w
uint32_t button, enum wlc_button_state state, const struct wlc_origin *origin) {
swayc_t *focused = get_focused_container(&root_container);
// dont change focus if fullscreen
if (focused->type == C_VIEW && wlc_view_get_state(focused->handle) & WLC_BIT_FULLSCREEN) {
if (swayc_is_fullscreen(focused)) {
return false;
}
if (state == WLC_BUTTON_STATE_PRESSED) {
@ -516,7 +513,6 @@ static void handle_wlc_ready(void) {
config->active = true;
}
struct wlc_interface interface = {
.output = {
.created = handle_output_created,
@ -544,3 +540,4 @@ struct wlc_interface interface = {
.ready = handle_wlc_ready
}
};

478
sway/layout.c
View file

@ -15,9 +15,11 @@ void init_layout(void) {
root_container.type = C_ROOT;
root_container.layout = L_NONE;
root_container.children = create_list();
root_container.handle = -1;
root_container.handle = 0;
}
// Children of container functions
static int index_child(swayc_t *parent, swayc_t *child) {
int i;
for (i = 0; i < parent->children->length; ++i) {
@ -35,7 +37,8 @@ void add_child(swayc_t *parent, swayc_t *child) {
child->parent = parent;
// set focus for this container
if (parent->children->length == 1) {
set_focused_container_for(parent, child);
parent->focused = child;
set_focused_container_for(parent, get_focused_view(parent));
}
}
@ -46,7 +49,7 @@ void add_floating(swayc_t *ws, swayc_t *child) {
child->parent = ws;
child->is_floating = true;
if (!ws->focused) {
set_focused_container_for(ws, child);
ws->focused = child;
}
}
@ -71,7 +74,7 @@ swayc_t *replace_child(swayc_t *child, swayc_t *new_child) {
new_child->parent = child->parent;
if (child->parent->focused == child) {
set_focused_container_for(child->parent, new_child);
child->parent->focused = new_child;
}
child->parent = NULL;
return parent;
@ -100,267 +103,274 @@ swayc_t *remove_child(swayc_t *child) {
// Set focused to new container
if (parent->focused == child) {
if (parent->children->length > 0) {
set_focused_container_for(parent, parent->children->items[i?i-1:0]);
parent->focused = parent->children->items[i?i-1:0];
} else {
parent->focused = NULL;
}
}
child->parent = NULL;
return parent;
}
void arrange_windows(swayc_t *container, int width, int height) {
int i;
if (width == -1 || height == -1) {
sway_log(L_DEBUG, "Arranging layout for %p", container);
width = container->width;
height = container->height;
}
int x = 0, y = 0;
switch (container->type) {
case C_ROOT:
for (i = 0; i < container->children->length; ++i) {
swayc_t *child = container->children->items[i];
sway_log(L_DEBUG, "Arranging output at %d", x);
child->x = x;
child->y = y;
arrange_windows(child, -1, -1);
// Removed for now because wlc works with relative positions
// Addition can be reconsidered once wlc positions are changed
// x += child->width;
}
return;
case C_OUTPUT:
container->width = width;
container->height = height;
// These lines make x/y negative and result in stuff glitching out
// Their addition can be reconsidered once wlc positions are changed
// x -= container->x;
// y -= container->y;
for (i = 0; i < container->children->length; ++i) {
swayc_t *child = container->children->items[i];
child->x = x + container->gaps;
child->y = y + container->gaps;
child->width = width - container->gaps * 2;
child->height = height - container->gaps * 2;
sway_log(L_DEBUG, "Arranging workspace #%d at %d, %d", i, child->x, child->y);
arrange_windows(child, -1, -1);
}
return;
case C_VIEW:
{
struct wlc_geometry geometry = {
// Fitting functions
#define FIT_FUNC __attribute__((nonnull)) static void
FIT_FUNC _fit_view(swayc_t *view) {
sway_log(L_DEBUG, "%s:%p: (%dx%d@%dx%d)", __func__, view,
view->width, view->height, view->x, view->y);
struct wlc_geometry geo;
if (wlc_view_get_state(view->handle) & WLC_BIT_FULLSCREEN) {
swayc_t *op = swayc_parent_by_type(view, C_OUTPUT);
geo = (struct wlc_geometry){
.origin = { .x = 0, .y = 0 },
.size = { .w = op->width, .h = op->height }
};
} else {
if (view->is_floating) {
geo = (struct wlc_geometry){
.origin = {
.x = container->x + container->gaps / 2,
.y = container->y + container->gaps / 2
.x = view->x,
.y = view->y,
},
.size = {
.w = width - container->gaps,
.h = height - container->gaps
.size = {
.w = view->width,
.h = view->height,
}
};
if (wlc_view_get_state(container->handle) & WLC_BIT_FULLSCREEN) {
swayc_t *parent = swayc_parent_by_type(container, C_OUTPUT);
geometry.origin.x = 0;
geometry.origin.y = 0;
geometry.size.w = parent->width;
geometry.size.h = parent->height;
wlc_view_set_geometry(container->handle, 0, &geometry);
wlc_view_bring_to_front(container->handle);
} else {
wlc_view_set_geometry(container->handle, 0, &geometry);
container->width = width;
container->height = height;
} else {
geo = (struct wlc_geometry){
.origin = {
.x = view->x + view->gaps / 2,
.y = view->y + view->gaps / 2,
},
.size = {
.w = view->width - view->gaps,
.h = view->height - view->gaps
}
};
}
}
wlc_view_set_geometry(view->handle, 0, &geo);
}
FIT_FUNC _fit_container(swayc_t *container) {
sway_log(L_DEBUG, "%s:%p: (%dx%d@%dx%d)", __func__, container,
container->width, container->height, container->x, container->y);
swayc_t **child = (swayc_t **)container->children->items;
int i, len = container->children->length;
// geometry
int x = container->x;
int y = container->y;
int w = container->width;
int h = container->height;
// scaling
double s = 0;
switch (container->layout) {
default:
case L_HORIZ:
// Find scaling amount required to fit children in parent
for (i = 0; i < len; ++i, ++child) {
int *prev_w = &(*child)->width;
if (*prev_w <= 0) {
*prev_w = w / (len > 1 ? len - 1 : 1);
}
sway_log(L_DEBUG, "Set view to %d x %d @ %d, %d", geometry.size.w, geometry.size.h,
geometry.origin.x, geometry.origin.y);
s += *prev_w;
}
if (s < 0.001) {
return;
}
s = w / s;
child = (swayc_t **)container->children->items;
for (i = 0; i < len; ++i, ++child) {
// Set geometry
(*child)->x = x;
(*child)->y = y;
// Scale width to fit in container
(*child)->width *= s;
(*child)->height = h;
// Increment x offset
x += (*child)->width;
// Recursibly resize children, depending on its type
((*child)->type == C_VIEW ? _fit_view : _fit_container)(*child);
}
return;
default:
container->width = width;
container->height = height;
break;
}
x = y = 0;
double scale = 0;
switch (container->layout) {
case L_HORIZ:
default:
// Calculate total width
for (i = 0; i < container->children->length; ++i) {
int *old_width = &((swayc_t *)container->children->items[i])->width;
if (*old_width <= 0) {
if (container->children->length > 1) {
*old_width = width / (container->children->length - 1);
} else {
*old_width = width;
}
}
scale += *old_width;
}
// Resize windows
if (scale > 0.1) {
scale = width / scale;
sway_log(L_DEBUG, "Arranging %p horizontally", container);
for (i = 0; i < container->children->length; ++i) {
swayc_t *child = container->children->items[i];
sway_log(L_DEBUG, "Calculating arrangement for %p:%d (will scale %d by %f)", child, child->type, width, scale);
child->x = x + container->x;
child->y = y + container->y;
arrange_windows(child, child->width * scale, height);
x += child->width;
}
}
break;
case L_VERT:
// Calculate total height
for (i = 0; i < container->children->length; ++i) {
int *old_height = &((swayc_t *)container->children->items[i])->height;
if (*old_height <= 0) {
if (container->children->length > 1) {
*old_height = height / (container->children->length - 1);
} else {
*old_height = height;
}
// Find scaling amount required to fit children in parent
for (i = 0; i < len; ++i, ++child) {
int *prev_h = &(*child)->height;
if (*prev_h <= 0) {
*prev_h = h / (len > 1 ? len - 1 : 1);
}
scale += *old_height;
s += *prev_h;
}
// Resize
if (scale > 0.1) {
scale = height / scale;
sway_log(L_DEBUG, "Arranging %p vertically", container);
for (i = 0; i < container->children->length; ++i) {
swayc_t *child = container->children->items[i];
sway_log(L_DEBUG, "Calculating arrangement for %p:%d (will scale %d by %f)", child, child->type, height, scale);
child->x = x + container->x;
child->y = y + container->y;
arrange_windows(child, width, child->height * scale);
y += child->height;
}
if (s < 0.001) {
return;
}
break;
s = h / s;
child = (swayc_t **)container->children->items;
for (i = 0; i < len; ++i, ++child) {
// Set geometry
(*child)->x = x;
(*child)->y = y;
// Scale height to fit in container
(*child)->height *= s;
(*child)->width = w;
// Increment y offset
y += (*child)->height;
// Recursibly resize children, depending on its type
((*child)->type == C_VIEW ? _fit_view : _fit_container)(*child);
}
return;
}
// Arrage floating layouts for workspaces last
if (container->type == C_WORKSPACE) {
for (i = 0; i < container->floating->length; ++i) {
swayc_t *view = container->floating->items[i];
if (view->type == C_VIEW) {
// Set the geometry
struct wlc_geometry geometry = {
.origin = {
.x = view->x,
.y = view->y
},
.size = {
.w = view->width,
.h = view->height
}
};
if (wlc_view_get_state(view->handle) & WLC_BIT_FULLSCREEN) {
swayc_t *parent = swayc_parent_by_type(view, C_OUTPUT);
geometry.origin.x = 0;
geometry.origin.y = 0;
geometry.size.w = parent->width;
geometry.size.h = parent->height;
wlc_view_set_geometry(view->handle, 0, &geometry);
wlc_view_bring_to_front(view->handle);
} else {
wlc_view_set_geometry(view->handle, 0, &geometry);
// Bring the views to the front in order of the list, the list
// will be kept up to date so that more recently focused views
// have higher indexes
// This is conditional on there not being a fullscreen view in the workspace
if (!container->focused
|| !(wlc_view_get_state(container->focused->handle) & WLC_BIT_FULLSCREEN)) {
wlc_view_bring_to_front(view->handle);
}
}
}
}
}
layout_log(&root_container, 0);
}
swayc_t *get_swayc_for_handle(wlc_handle handle, swayc_t *parent) {
if (parent->children == NULL) {
return NULL;
FIT_FUNC _fit_workspace(swayc_t *workspace) {
workspace->x += workspace->gaps;
workspace->y += workspace->gaps;
workspace->width -= workspace->gaps * 2;
workspace->height -= workspace->gaps * 2;
sway_log(L_DEBUG, "%s:%p: (%dx%d@%dx%d)", __func__, workspace,
workspace->width, workspace->height, workspace->x,workspace->y);
// workspace is treated same as container for tiling
_fit_container(workspace);
// Handle floating containers
swayc_t **child = (swayc_t **)workspace->floating->items;
int i, len = workspace->floating->length;
for (i = 0; i < len; ++i, ++child) {
// Fit floating depending on view
((*child)->type == C_VIEW ? _fit_view : _fit_container)(*child);
}
// Search for floating workspaces
int i;
if (parent->type == C_WORKSPACE) {
for (i = 0; i < parent->floating->length; ++i) {
swayc_t *child = parent->floating->items[i];
if (child->handle == handle) {
return child;
}
}
}
for (i = 0; i < parent->children->length; ++i) {
swayc_t *child = parent->children->items[i];
if (child->handle == handle) {
return child;
} else {
swayc_t *res;
if ((res = get_swayc_for_handle(handle, child))) {
return res;
}
}
}
return NULL;
}
swayc_t *get_swayc_in_direction(swayc_t *container, enum movement_direction dir) {
swayc_t *parent = container->parent;
if (dir == MOVE_PARENT) {
if (parent->type == C_OUTPUT) {
return NULL;
} else {
return parent;
}
FIT_FUNC _fit_output(swayc_t *output) {
sway_log(L_DEBUG, "%s:%p: (%dx%d@%dx%d)", __func__, output, output->width,
output->height, output->x,output->y);
swayc_t **child = (swayc_t **)output->children->items;
int i, len = output->children->length;
int x = output->x;
int y = output->y;
int w = output->width;
int h = output->height;
for (i = 0; i < len; ++i, ++child) {
// Set geometry with gaps
(*child)->x = x;
(*child)->y = y;
(*child)->width = w;
(*child)->height = h;
// recursivly fit children
_fit_workspace(*child);
}
while (true) {
// Test if we can even make a difference here
bool can_move = false;
int diff = 0;
if (dir == MOVE_LEFT || dir == MOVE_RIGHT) {
if (parent->layout == L_HORIZ || parent->type == C_ROOT) {
can_move = true;
diff = dir == MOVE_LEFT ? -1 : 1;
}
} else {
if (parent->layout == L_VERT) {
can_move = true;
diff = dir == MOVE_UP ? -1 : 1;
}
}
FIT_FUNC _fit_root(swayc_t *root) {
sway_log(L_DEBUG, "%s:%p: (%dx%d@%dx%d)", __func__, root, root->width,
root->height, root->x,root->y);
swayc_t **child = (swayc_t **)root->children->items;
int i, len = root->children->length;
for (i = 0; i < len; ++i, ++child) {
(*child)->x = 0;
(*child)->y = 0;
_fit_output(*child);
}
}
FIT_FUNC fit_children_in(swayc_t *swayc) {
switch (swayc->type) {
case C_ROOT: _fit_root(swayc); return;
case C_WORKSPACE: swayc = swayc->parent;
case C_OUTPUT: _fit_output(swayc); return;
case C_VIEW: swayc = swayc->parent;
case C_CONTAINER: _fit_container(swayc); return;
default: sway_assert(false, "%s: invalid type", __func__);
}
}
#undef FIT_FUNC
__attribute__((nonnull)) static wlc_handle order_children(swayc_t *swayc, wlc_handle top) {
// return handle
if (swayc->type == C_VIEW) {
return swayc->handle;
}
// return if no focus
if (swayc->focused == NULL) {
return 0;
}
// TODO fix floating implementation.
// Recurse and get handle of focused container
wlc_handle bottom = order_children(swayc->focused, top);
// TODO Used properly in workspace case
wlc_handle topmost = bottom;
(void) topmost;
// Put handle below current top, or if there is no top, set it as bottom
if (top) {
wlc_view_send_below(bottom, top);
sway_log(L_DEBUG,"putting %ld below %ld", bottom, top);
} else {
top = bottom;
}
// recurse for all children with the current bottom handle as their top.
int i, len = swayc->children->length;
swayc_t **child = (swayc_t **)swayc->children->items;
for (i = 0; i < len; ++i, ++child) {
// Skip over the focused child
if (*child == swayc->focused) {
continue;
}
if (can_move) {
int i;
for (i = 0; i < parent->children->length; ++i) {
swayc_t *child = parent->children->items[i];
if (child == container) {
break;
}
}
int desired = i + diff;
if (desired < 0 || desired >= parent->children->length) {
can_move = false;
// Update current top, send it below previous bottom, and set new bottom
top = order_children(*child, bottom);
wlc_view_send_below(top, bottom);
sway_log(L_DEBUG,"putting %ld below %ld", bottom, top);
bottom = top;
}
// TODO fix floating implementation.
// If we are at a workspace, put floating containers above topmost
if (swayc->type == C_WORKSPACE) {
// TODO using the same hacky implementation as before.
// send floating windows to front
len = swayc->floating->length;
child = (swayc_t **)swayc->floating->items;
// chekc whether to send floating windows to the back or front
swayc_t *focused = get_focused_view(swayc);
bool tofront = swayc->parent->focused == swayc;
// Send focused view to front or back if fullscreen depending on tofront
if (!focused->is_floating && swayc_is_fullscreen(focused)) {
if (tofront) {
wlc_view_bring_to_front(focused->handle);
sway_log(L_DEBUG,"bring %ld to front (fullscreen)", focused->handle);
// we dont want to bring floating windows above fullscreen
// window
tofront = false;
} else {
return parent->children->items[desired];
wlc_view_send_to_back(focused->handle);
}
}
if (!can_move) {
container = parent;
parent = parent->parent;
if (!parent) {
// Nothing we can do
return NULL;
for (i = 0; i < len; ++i, ++child) {
if (tofront) {
wlc_view_bring_to_front((*child)->handle);
sway_log(L_DEBUG,"bring %ld to front (floating)", focused->handle);
} else {
wlc_view_send_to_back((*child)->handle);
sway_log(L_DEBUG,"sending %ld to back (floating)", focused->handle);
}
}
}
// Return the bottom of this, which shall be the top of others,
return bottom;
}
// Arrange layout
void arrange_windows(swayc_t *container, int width, int height) {
fit_children_in(container);
order_children(container, 0);
layout_log(&root_container, 0);
return;
}

3
sway/log.c
View file

@ -16,7 +16,7 @@ static const char *verbosity_colors[] = {
"", // L_SILENT
"\x1B[1;31m", // L_ERROR
"\x1B[1;34m", // L_INFO
"\x1B[1;30m", // L_DEBUG
"\x1B[1;32m", // L_DEBUG
};
void init_log(int verbosity) {
@ -151,6 +151,7 @@ static void container_log(const swayc_t *c) {
void layout_log(const swayc_t *c, int depth) {
int i, d;
int e = c->children ? c->children->length : 0;
if (L_DEBUG > v) return;
container_log(c);
if (e) {
for (i = 0; i < e; ++i) {

2
sway/workspace.c
View file

@ -182,5 +182,5 @@ void workspace_switch(swayc_t *workspace) {
}
sway_log(L_DEBUG, "Switching to workspace %p:%s", workspace, workspace->name);
set_focused_container(get_focused_view(workspace));
arrange_windows(workspace, -1, -1);
arrange_windows(workspace->parent, -1, -1);
}