diyac/view.c

280 lines
8.7 KiB
C
Raw Normal View History

2024-03-31 16:09:01 +02:00
#define _POSIX_C_SOURCE 200112L
#include <wlr/util/log.h>
#include <assert.h>
2024-04-01 15:38:57 +02:00
#include "view.h"
2024-03-31 16:09:01 +02:00
#include "node.h"
#include "seat.h"
#include "output.h"
2024-04-01 15:38:57 +02:00
static void raise_to_front(struct diyac_view *view)
{
/* Move the toplevel to the front */
wlr_scene_node_raise_to_top(&view->scene_tree->node);
wl_list_remove(&view->link);
wl_list_insert(&view->server->views, &view->link);
/* Activate the new surface */
wlr_xdg_toplevel_set_activated(view->xdg_toplevel, true);
}
void diyac_focus_view(struct diyac_view *toplevel, bool raise)
2024-03-31 16:09:01 +02:00
{
/* Note: this function only deals with keyboard focus. */
if (toplevel == NULL)
{
return;
}
struct diyac_server *server = toplevel->server;
struct wlr_surface *prev_surface = server->seat.wlr_seat->keyboard_state.focused_surface;
if (prev_surface == toplevel->xdg_toplevel->base->surface)
{
2024-04-01 15:38:57 +02:00
// Don't re-focus an already focused surface.
2024-03-31 16:09:01 +02:00
return;
}
if (prev_surface)
{
/*
* Deactivate the previously focused surface. This lets the client know
* it no longer has focus and the client will repaint accordingly, e.g.
* stop displaying a caret.
*/
struct wlr_xdg_toplevel *prev_toplevel =
wlr_xdg_toplevel_try_from_wlr_surface(prev_surface);
if (prev_toplevel != NULL)
{
wlr_xdg_toplevel_set_activated(prev_toplevel, false);
}
}
2024-04-01 16:07:07 +02:00
if(!toplevel->mapped)
{
return;
}
2024-04-01 15:38:57 +02:00
raise_to_front(toplevel);
if (raise)
{
struct diyac_view **subview = NULL;
struct wl_array subviews;
wl_array_init(&subviews);
diyac_get_children_views(toplevel, &subviews);
wl_array_for_each(subview, &subviews)
{
raise_to_front(*subview);
}
wl_array_release(&subviews);
}
2024-03-31 16:09:01 +02:00
/*
* Tell the seat to have the keyboard enter this surface. wlroots will keep
* track of this and automatically send key events to the appropriate
* clients without additional work on your part.
*/
diyac_seat_focus_surface(&server->seat, toplevel->xdg_toplevel->base->surface);
}
struct diyac_view *diyac_view_at(
struct diyac_server *server, double lx, double ly,
struct wlr_surface **surface, double *sx, double *sy)
{
2024-04-01 15:38:57 +02:00
struct diyac_node_descriptor *node_descriptor = diyac_node_at(server,lx,ly,surface,sx,sy);
2024-03-31 16:09:01 +02:00
if (!node_descriptor || node_descriptor->type != DIYAC_NODE_VIEW)
{
return NULL;
}
return node_descriptor->data;
}
void diyac_focus_topmost_view(struct diyac_server *server)
{
struct diyac_view *view = diyac_topmost_focusable_view(server);
if (view)
{
2024-04-01 15:38:57 +02:00
diyac_focus_view(view, false);
2024-03-31 16:09:01 +02:00
}
else
{
/*
* Defocus previous focused surface/view if no longer
* focusable (e.g. unmapped or on a different workspace).
*/
diyac_seat_focus_surface(&server->seat, NULL);
}
}
struct diyac_view *diyac_topmost_focusable_view(struct diyac_server *server)
{
struct wlr_surface *prev =
server->seat.wlr_seat->keyboard_state.focused_surface;
struct diyac_view *view;
struct wl_list *node_list;
struct wlr_scene_node *node;
node_list = &server->view_tree->children;
wl_list_for_each_reverse(node, node_list, link)
{
if (!node->data)
{
/* We found some non-view, most likely the region overlay */
continue;
}
view = diyac_view_from_node(node);
return view;
2024-04-01 15:38:57 +02:00
if (view->mapped /*&& view_is_focusable_from(view, prev)*/)
2024-03-31 16:09:01 +02:00
{
return view;
2024-04-01 15:38:57 +02:00
}
2024-03-31 16:09:01 +02:00
}
return NULL;
}
void diyac_arrange_all_views(struct diyac_server *server)
{
/*
* Adjust window positions/sizes. Skip views with no size since
* we can't do anything useful with them; they will presumably
* be initialized with valid positions/sizes later.
*
* We do not simply check view->mapped/been_mapped here because
* views can have maximized/fullscreen geometry applied while
* still unmapped. We do want to adjust the geometry of those
* views.
*/
struct diyac_view *view;
wl_list_for_each(view, &server->views, link)
{
2024-04-01 15:38:57 +02:00
diyac_view_update_geometry(view, false);
2024-03-31 16:09:01 +02:00
}
}
2024-04-01 15:38:57 +02:00
bool diyac_view_update_geometry(struct diyac_view *view, bool grabbed)
2024-03-31 16:09:01 +02:00
{
assert(view);
bool adjusted = false;
struct wlr_box geo_box;
2024-04-01 15:38:57 +02:00
struct wlr_box *geometry = &view->original;
2024-03-31 16:09:01 +02:00
// if (wlr_output_layout_intersects(view->server->output_layout,
// view->output->wlr_output, &view->current))
//{
struct wlr_box usable = diyac_output_usable_area(view->output);
2024-04-01 16:07:07 +02:00
wlr_log(WLR_DEBUG, "diyac_view_update_geometry: current: [%d,%d,%d,%d], usable: [%d,%d,%d,%d] ",
2024-03-31 16:09:01 +02:00
geometry->x, geometry->y, geometry->width, geometry->height,
usable.x, usable.y, usable.width, usable.height);
2024-04-01 15:38:57 +02:00
struct diyac_server *server = view->server;
if (!view->mapped)
{
view->state = DIYAC_VIEW_NORMAL;
return false;
}
2024-03-31 16:09:01 +02:00
switch (view->state)
{
case DIYAC_VIEW_MAXIMIZE:
/**
* We dont change the current_view geometry in maximize state
2024-04-01 15:38:57 +02:00
*
2024-03-31 16:09:01 +02:00
*/
wlr_scene_node_set_position(&view->scene_tree->node, usable.x, usable.y);
wlr_xdg_toplevel_set_size(view->xdg_toplevel, usable.width, usable.height);
return true;
case DIYAC_VIEW_MINIMIZE:
2024-04-01 15:38:57 +02:00
view->state = DIYAC_VIEW_NORMAL;
wlr_log(WLR_INFO, "diyac_view_update_geometry: minimize ignore");
2024-03-31 16:09:01 +02:00
return false;
case DIYAC_VIEW_FULL_SCREEN:
2024-04-01 15:38:57 +02:00
/*TODO: implement full-screen */
//view->state = DIYAC_VIEW_NORMAL;
2024-03-31 16:09:01 +02:00
wlr_log(WLR_INFO, "diyac_view_update_geometry: full-screen ignore");
return false;
2024-04-01 15:38:57 +02:00
2024-03-31 16:09:01 +02:00
default:
wlr_xdg_surface_get_geometry(view->xdg_toplevel->base, &geo_box);
2024-04-01 15:38:57 +02:00
if (!wlr_box_equal(geometry, &geo_box))
2024-03-31 16:09:01 +02:00
{
adjusted = true;
}
2024-04-01 15:38:57 +02:00
// if (wlr_output_layout_intersects(view->server->output_layout,
// view->output->wlr_output, &view->current))
//{
2024-03-31 16:09:01 +02:00
/**Normal state, recalculate current geometry*/
2024-04-01 15:38:57 +02:00
if (!grabbed && geometry->x < usable.x)
2024-03-31 16:09:01 +02:00
{
geometry->x = usable.x;
adjusted = true;
}
2024-04-01 15:38:57 +02:00
if (!grabbed && geometry->y < usable.y)
2024-03-31 16:09:01 +02:00
{
2024-04-01 15:38:57 +02:00
geometry->y = usable.y;
2024-03-31 16:09:01 +02:00
adjusted = true;
}
2024-04-01 15:38:57 +02:00
if (grabbed && server->seat.cursor->x <= usable.x)
2024-03-31 16:09:01 +02:00
{
2024-04-01 15:38:57 +02:00
geometry->x = usable.x - server->grab_x;
2024-03-31 16:09:01 +02:00
adjusted = true;
}
2024-04-01 15:38:57 +02:00
if (grabbed && server->seat.cursor->y <= usable.y)
2024-03-31 16:09:01 +02:00
{
2024-04-01 15:38:57 +02:00
geometry->y = usable.y;
2024-03-31 16:09:01 +02:00
adjusted = true;
}
2024-04-01 15:38:57 +02:00
if (grabbed && server->seat.cursor->x >= usable.x + usable.width)
2024-03-31 16:09:01 +02:00
{
2024-04-01 15:38:57 +02:00
geometry->x = usable.x + usable.width - server->grab_x;
2024-03-31 16:09:01 +02:00
adjusted = true;
}
2024-04-01 15:38:57 +02:00
if (grabbed && server->seat.cursor->y >= usable.y + usable.height)
2024-03-31 16:09:01 +02:00
{
2024-04-01 15:38:57 +02:00
geometry->y = usable.y + usable.height - server->grab_y;
2024-03-31 16:09:01 +02:00
adjusted = true;
}
2024-04-01 15:38:57 +02:00
2024-03-31 16:09:01 +02:00
if (adjusted)
{
2024-04-01 16:07:07 +02:00
wlr_log(WLR_DEBUG, "diyac_view_update_geometry: updating geometry: %d %d %d %d", geometry->x, geometry->y, geometry->width, geometry->height);
2024-03-31 16:09:01 +02:00
wlr_scene_node_set_position(&view->scene_tree->node, geometry->x, geometry->y);
wlr_xdg_toplevel_set_size(view->xdg_toplevel, geometry->width, geometry->height);
}
return adjusted;
}
2024-04-01 15:38:57 +02:00
}
void diyac_get_children_views(struct diyac_view *view, struct wl_array *children)
{
struct diyac_view *child;
wl_list_for_each_reverse(child, &view->server->views, link)
{
if (child == view)
{
continue;
}
if (!child->mapped /*&& !view->minimized*/)
{
continue;
}
if (diyac_get_root_view(child) != view)
{
continue;
}
struct diyac_view **item = wl_array_add(children, sizeof(*item));
*item = child;
}
}
struct diyac_view *diyac_get_root_view(struct diyac_view *view)
{
struct wlr_xdg_toplevel *toplevel = view->xdg_toplevel;
while (toplevel->parent)
{
toplevel = toplevel->parent;
}
return toplevel->base->data;
}
struct wlr_box diyac_view_get_geometry(struct diyac_view *view)
{
struct wlr_box box;
switch(view->state)
{
case DIYAC_VIEW_FULL_SCREEN:
wlr_output_layout_get_box(view->server->output_layout, view->output->wlr_output, &box);
return box;
case DIYAC_VIEW_MAXIMIZE:
return view->output->usable_area;
default:
return view->original;
}
2024-03-31 16:09:01 +02:00
}