xref: /dports/x11-wm/hikari/hikari-2.2.3/src/view.c

#include <hikari/view.h>

#include <assert.h>
#include <string.h>

#include <wlr/types/wlr_cursor.h>

#include <hikari/color.h>
#include <hikari/configuration.h>
#include <hikari/geometry.h>
#include <hikari/group.h>
#include <hikari/indicator.h>
#include <hikari/layout.h>
#include <hikari/mark.h>
#include <hikari/memory.h>
#include <hikari/operation.h>
#include <hikari/output.h>
#include <hikari/server.h>
#include <hikari/sheet.h>
#include <hikari/tile.h>
#include <hikari/view_config.h>
#include <hikari/workspace.h>
#include <hikari/xdg_view.h>
#include <hikari/xwayland_view.h>

#define VIEW(name, link)                                                       \
  static struct hikari_view *name##_view(void)                                 \
  {                                                                            \
    struct wl_list *views = hikari_server.visible_views.link;                  \
                                                                               \
    if (!wl_list_empty(views)) {                                               \
      struct hikari_view *view;                                                \
      view = wl_container_of(views, view, visible_server_views);               \
      return view;                                                             \
    }                                                                          \
                                                                               \
    return NULL;                                                               \
  }                                                                            \
                                                                               \
  static bool is_##name##_view(struct hikari_view *view)                       \
  {                                                                            \
    return view == name##_view();                                              \
  }

VIEW(first, next)
VIEW(last, prev)
#undef VIEW

static void
move_to_top(struct hikari_view *view)
{
  assert(view != NULL);
  assert(hikari_view_is_mapped(view));

  wl_list_remove(&view->sheet_views);
  wl_list_insert(&view->sheet->views, &view->sheet_views);

  wl_list_remove(&view->group_views);
  wl_list_insert(&view->group->views, &view->group_views);

  wl_list_remove(&view->output_views);
  wl_list_insert(&view->output->views, &view->output_views);
}

static void
place_visibly_above(
    struct hikari_view *view, struct hikari_workspace *workspace)
{
  assert(hikari_view_is_forced(view) ? hikari_view_is_hidden(view)
                                     : !hikari_view_is_hidden(view));

  wl_list_remove(&view->visible_server_views);
  wl_list_insert(&hikari_server.visible_views, &view->visible_server_views);

  wl_list_remove(&view->visible_group_views);
  wl_list_insert(&view->group->visible_views, &view->visible_group_views);

  wl_list_remove(&view->group->visible_server_groups);
  wl_list_insert(
      &hikari_server.visible_groups, &view->group->visible_server_groups);

  wl_list_remove(&view->workspace_views);
  wl_list_insert(&workspace->views, &view->workspace_views);
}

static void
raise_view(struct hikari_view *view)
{
  assert(view != NULL);

  move_to_top(view);
  place_visibly_above(view, view->sheet->workspace);
}

static void
refresh_border_geometry(struct hikari_view *view)
{
  assert(view != NULL);
  hikari_border_refresh_geometry(&view->border, view->current_geometry);
  hikari_indicator_frame_refresh_geometry(&view->indicator_frame, view);
}

static inline void
move_view_constrained(
    struct hikari_view *view, struct wlr_box *geometry, int x, int y)
{
  if (!hikari_view_is_hidden(view)) {
    hikari_view_damage_whole(view);
    hikari_indicator_damage(&hikari_server.indicator, view);
  }

  hikari_geometry_constrain_relative(
      geometry, &view->output->usable_area, x, y);
}

static void
move_view(struct hikari_view *view, struct wlr_box *geometry, int x, int y)
{
  if (view->maximized_state != NULL) {
    struct wlr_box *usable_area;

    switch (view->maximized_state->maximization) {
      case HIKARI_MAXIMIZATION_FULLY_MAXIMIZED:
        return;

      case HIKARI_MAXIMIZATION_VERTICALLY_MAXIMIZED:
        usable_area = &view->output->usable_area;

        if (y != usable_area->y) {
          return;
        }

        move_view_constrained(view, geometry, x, y);
        view->geometry.x = x;
        break;

      case HIKARI_MAXIMIZATION_HORIZONTALLY_MAXIMIZED:
        usable_area = &view->output->usable_area;

        if (x != usable_area->x) {
          return;
        }

        move_view_constrained(view, geometry, x, y);
        view->geometry.y = y;
        break;
    }
  } else {
    move_view_constrained(view, geometry, x, y);
  }

#ifdef HAVE_XWAYLAND
  if (view->move != NULL) {
    view->move(view, geometry->x, geometry->y);
  }
#endif

  refresh_border_geometry(view);

  if (!hikari_view_is_hidden(view)) {
    hikari_view_damage_whole(view);
    hikari_indicator_damage(&hikari_server.indicator, view);
  }
}

static void
increase_group_visiblity(struct hikari_view *view)
{
  assert(hikari_view_is_forced(view) ? hikari_view_is_hidden(view)
                                     : !hikari_view_is_hidden(view));

  struct hikari_group *group = view->group;

  if (wl_list_empty(&group->visible_views)) {
    wl_list_insert(
        &hikari_server.visible_groups, &group->visible_server_groups);
  }

  wl_list_init(&view->visible_group_views);
}

static void
decrease_group_visibility(struct hikari_view *view)
{
  struct hikari_group *group = view->group;

  wl_list_remove(&view->visible_group_views);

  if (wl_list_empty(&group->visible_views)) {
    wl_list_remove(&group->visible_server_groups);
  }
}

static void
hide(struct hikari_view *view)
{
  decrease_group_visibility(view);

  wl_list_remove(&view->workspace_views);
  wl_list_init(&view->workspace_views);

  wl_list_remove(&view->visible_server_views);
  wl_list_init(&view->visible_server_views);

  hikari_view_set_hidden(view);
}

static void
detach_from_group(struct hikari_view *view)
{
  struct hikari_group *group = view->group;

  wl_list_remove(&view->group_views);
  wl_list_init(&view->group_views);

  if (wl_list_empty(&group->views)) {
    hikari_group_fini(group);
    hikari_free(group);
  }
}

static void
remove_from_group(struct hikari_view *view)
{
  assert(!hikari_view_is_hidden(view));

  if (!hikari_view_is_hidden(view)) {
    decrease_group_visibility(view);
  }

  detach_from_group(view);
}

static void
cancel_tile(struct hikari_view *view)
{
  if (hikari_view_is_tiling(view)) {
    struct hikari_tile *tile = view->pending_operation.tile;

    hikari_tile_detach(tile);
    hikari_free(tile);
    view->pending_operation.tile = NULL;
  }
}

static inline void
guarded_resize(struct hikari_view *view,
    struct hikari_operation *op,
    void (*f)(struct hikari_view *, struct hikari_operation *))
{
  op->serial = view->resize(view, op->geometry.width, op->geometry.height);

  if (op->serial == 0) {
    f(view, op);
  } else {
    hikari_view_set_dirty(view);
  }
}

static inline void
resize(struct hikari_view *view,
    struct hikari_operation *op,
    void (*f)(struct hikari_view *, struct hikari_operation *))
{
#ifdef HAVE_XWAYLAND
  if (view->move_resize != NULL) {
    op->serial = 0;
    view->move_resize(view,
        op->geometry.x,
        op->geometry.y,
        op->geometry.width,
        op->geometry.height);

    hikari_view_set_dirty(view);
  } else {
    guarded_resize(view, op, f);
  }
#else
  guarded_resize(view, op, f);
#endif
}

static void
commit_pending_geometry(
    struct hikari_view *view, struct wlr_box *pending_geometry)
{
  hikari_view_refresh_geometry(view, pending_geometry);

  hikari_indicator_damage(&hikari_server.indicator, view);
  hikari_view_damage_whole(view);
}

static void
commit_pending_operation(
    struct hikari_view *view, struct hikari_operation *operation)
{
  if (!hikari_view_is_hidden(view)) {
    if (!hikari_view_is_forced(view)) {
      raise_view(view);
    } else {
      move_to_top(view);
    }

    commit_pending_geometry(view, &operation->geometry);

    if (operation->center) {
      hikari_view_center_cursor(view);
      hikari_server_cursor_focus();
    }
  } else {
    hikari_view_refresh_geometry(view, &operation->geometry);

    if (hikari_sheet_is_visible(view->sheet)) {
      if (!hikari_view_is_forced(view)) {
        hikari_view_show(view);
      } else {
        raise_view(view);
      }

      if (operation->center) {
        hikari_view_center_cursor(view);
        hikari_server_cursor_focus();
      }
    } else {
      if (!hikari_view_is_forced(view)) {
        move_to_top(view);
      } else {
        raise_view(view);
      }
    }
  }
}

static void
commit_reset(struct hikari_view *view, struct hikari_operation *operation)
{
  hikari_indicator_damage(&hikari_server.indicator, view);

  if (hikari_view_is_tiled(view)) {
    assert(!hikari_tile_is_attached(view->tile));
    hikari_free(view->tile);
    view->tile = NULL;
  }

  if (hikari_view_is_maximized(view)) {
    hikari_maximized_state_destroy(view->maximized_state);
    view->maximized_state = NULL;

    if (!view->use_csd) {
      if (view == hikari_server.workspace->focus_view) {
        view->border.state = HIKARI_BORDER_ACTIVE;
      } else {
        view->border.state = HIKARI_BORDER_INACTIVE;
      }
    }
  }

  commit_pending_operation(view, operation);
}

static void
queue_reset(struct hikari_view *view, bool center)
{
  struct wlr_box *view_geometry = hikari_view_geometry(view);
  struct hikari_operation *op = &view->pending_operation;
  struct hikari_tile *tile = view->tile;
  struct wlr_box *geometry = &view->geometry;

  cancel_tile(view);

  if (hikari_view_is_tiled(view) && hikari_tile_is_attached(tile)) {
    hikari_tile_detach(tile);
  }

  op->type = HIKARI_OPERATION_TYPE_RESET;
  op->center = center;
  memcpy(&op->geometry, geometry, sizeof(struct wlr_box));

  if (view_geometry->width == geometry->width &&
      view_geometry->height == geometry->height) {
    hikari_view_set_dirty(view);
    hikari_view_commit_pending_operation(view, view_geometry);
  } else {
    resize(view, op, commit_reset);
  }

  assert(
      hikari_view_is_tiled(view) ? !hikari_tile_is_attached(view->tile) : true);
}

static void
clear_focus(struct hikari_view *view)
{
  if (hikari_view_is_focus_view(view)) {
    if (hikari_view_has_focus(view)) {
      assert(!hikari_server_in_lock_mode());

      if (!hikari_server_in_normal_mode()) {
        hikari_server_enter_normal_mode(NULL);
      }

      hikari_workspace_focus_view(hikari_server.workspace, NULL);
    } else {
      view->sheet->workspace->focus_view = NULL;
    }
  }
}

void
hikari_view_init(
    struct hikari_view *view, bool child, struct hikari_workspace *workspace)
{
#if !defined(NDEBUG)
  printf("VIEW INIT %p\n", view);
#endif
  view->flags = hikari_view_hidden_flag;
  view->border.state = HIKARI_BORDER_INACTIVE;
  view->sheet = NULL;
  view->mark = NULL;
  view->surface = NULL;
  view->maximized_state = NULL;
  view->output = NULL;
  view->group = NULL;
  view->title = NULL;
  view->tile = NULL;
  view->id = NULL;
  view->use_csd = false;
  view->child = child;
  view->current_geometry = &view->geometry;
  view->current_unmaximized_geometry = &view->geometry;

  hikari_view_unset_dirty(view);
  view->pending_operation.tile = NULL;

  wl_list_init(&view->children);
}

void
hikari_view_fini(struct hikari_view *view)
{
  assert(hikari_view_is_hidden(view));
  assert(!hikari_view_is_mapped(view));
  assert(!hikari_view_is_forced(view));

#if !defined(NDEBUG)
  printf("DESTROY VIEW %p\n", view);
#endif

  hikari_free(view->title);
  hikari_free(view->id);

  if (view->group != NULL) {
    detach_from_group(view);
  }

  if (view->sheet != NULL) {
    wl_list_remove(&view->sheet_views);
    wl_list_remove(&view->output_views);
  }

  if (view->maximized_state != NULL) {
    hikari_maximized_state_destroy(view->maximized_state);
  }

  if (view->mark != NULL) {
    hikari_mark_clear(view->mark);
  }

  if (hikari_view_is_tiled(view)) {
    struct hikari_tile *tile = view->tile;
    hikari_tile_detach(tile);
    hikari_free(tile);
    view->tile = NULL;
  }

  cancel_tile(view);
}

void
hikari_view_set_title(struct hikari_view *view, const char *title)
{
  hikari_free(view->title);

  if (title != NULL) {
    view->title = hikari_malloc(strlen(title) + 1);
    strcpy(view->title, title);

    if (hikari_server.workspace->focus_view == view) {
      assert(!hikari_view_is_hidden(view));
      struct hikari_output *output = view->output;
      hikari_indicator_update_title(&hikari_server.indicator, output, title);
    }
  } else {
    view->title = NULL;
  }
}

static void
set_app_id(struct hikari_view *view, const char *id)
{
  assert(view->id == NULL);
  assert(id != NULL);

  view->id = hikari_malloc(strlen(id) + 1);

  strcpy(view->id, id);
}

struct hikari_damage_data {
  struct wlr_box *geometry;
  struct wlr_surface *surface;

  struct hikari_view *view;
  struct hikari_output *output;

  bool whole;
};

static void
damage_whole_surface(struct wlr_surface *surface, int sx, int sy, void *data)
{
  struct hikari_damage_data *damage_data = data;
  struct hikari_output *output = damage_data->output;
  struct hikari_view *view = damage_data->view;

  if (view->surface == surface) {
    hikari_view_damage_border(view);
  } else {
    struct wlr_box geometry;
    memcpy(&geometry, damage_data->geometry, sizeof(struct wlr_box));

    geometry.x += sx;
    geometry.y += sy;
    geometry.width = surface->current.width;
    geometry.height = surface->current.height;

    hikari_output_add_damage(output, &geometry);
  }
}

void
hikari_view_damage_whole(struct hikari_view *view)
{
  assert(view != NULL);

  struct hikari_output *output = view->output;

  // TODO I know, this needs to be done A LOT better
  if (view->use_csd) {
    hikari_output_damage_whole(output);
    return;
  }

  struct hikari_damage_data damage_data;

  damage_data.geometry = hikari_view_geometry(view);
  damage_data.output = output;
  damage_data.view = view;

  hikari_node_for_each_surface(
      (struct hikari_node *)view, damage_whole_surface, &damage_data);
}

static struct wlr_box *
refresh_unmaximized_geometry(struct hikari_view *view)
{
  assert(view != NULL);

  if (hikari_view_is_tiled(view)) {
    return &view->tile->view_geometry;
  } else {
    return &view->geometry;
  }
}

static struct wlr_box *
refresh_geometry(struct hikari_view *view)
{
  assert(view != NULL);

  if (view->maximized_state != NULL) {
    return &view->maximized_state->geometry;
  } else {
    return refresh_unmaximized_geometry(view);
  }
}

static inline int
constrain_size(int min, int max, int value)
{
  if (value > max) {
    return max;
  } else if (value < min) {
    return min;
  } else {
    return value;
  }
}

static void
commit_resize(struct hikari_view *view, struct hikari_operation *operation)
{
  commit_pending_operation(view, operation);
}

static void
queue_resize(struct hikari_view *view,
    struct wlr_box *geometry,
    int requested_x,
    int requested_y,
    int requested_width,
    int requested_height)
{
  struct hikari_operation *op = &view->pending_operation;

  int min_width;
  int min_height;
  int max_width;
  int max_height;

  int new_width;
  int new_height;

  if (view->maximized_state != NULL) {
    switch (view->maximized_state->maximization) {
      case HIKARI_MAXIMIZATION_FULLY_MAXIMIZED:
        return;

      case HIKARI_MAXIMIZATION_VERTICALLY_MAXIMIZED:
        view->constraints(
            view, &min_width, &min_height, &max_width, &max_height);
        new_width = constrain_size(min_width, max_width, requested_width);
        new_height = geometry->height;
        view->geometry.width = new_width;
        break;

      case HIKARI_MAXIMIZATION_HORIZONTALLY_MAXIMIZED:
        view->constraints(
            view, &min_width, &min_height, &max_width, &max_height);
        new_width = geometry->width;
        new_height = constrain_size(min_height, max_height, requested_height);
        view->geometry.height = new_height;
        break;
    }
  } else {
    view->constraints(view, &min_width, &min_height, &max_width, &max_height);
    new_width = constrain_size(min_width, max_width, requested_width);
    new_height = constrain_size(min_height, max_height, requested_height);
  }

  struct hikari_output *output = view->output;

  op->type = HIKARI_OPERATION_TYPE_RESIZE;
  op->geometry.width = new_width;
  op->geometry.height = new_height;
  op->center = false;

  hikari_geometry_constrain_relative(
      &op->geometry, &output->usable_area, requested_x, requested_y);

  resize(view, op, commit_resize);
}

void
hikari_view_resize(struct hikari_view *view, int dwidth, int dheight)
{
  assert(view != NULL);
  assert(view->resize != NULL);
  assert(view->constraints != NULL);

  if (hikari_view_is_dirty(view)) {
    return;
  }

  struct wlr_box *geometry = hikari_view_geometry(view);

  int requested_width = geometry->width + dwidth;
  int requested_height = geometry->height + dheight;

  queue_resize(view,
      geometry,
      geometry->x,
      geometry->y,
      requested_width,
      requested_height);
}

void
hikari_view_resize_absolute(struct hikari_view *view, int width, int height)
{
  assert(view != NULL);
  assert(view->resize != NULL);
  assert(view->constraints != NULL);

  if (hikari_view_is_dirty(view)) {
    return;
  }

  struct wlr_box *geometry = hikari_view_geometry(view);
  queue_resize(view, geometry, geometry->x, geometry->y, width, height);
}

void
hikari_view_move_resize(
    struct hikari_view *view, int x, int y, int width, int height)
{
  assert(view != NULL);
  assert(view->resize != NULL);
  assert(view->constraints != NULL);

  if (hikari_view_is_dirty(view)) {
    return;
  }

  struct wlr_box *geometry = hikari_view_geometry(view);

  int requested_x = geometry->x + x;
  int requested_y = geometry->y + y;
  int requested_width = geometry->width + width;
  int requested_height = geometry->height + height;

  queue_resize(view,
      geometry,
      requested_x,
      requested_y,
      requested_width,
      requested_height);
}

void
hikari_view_move(struct hikari_view *view, int x, int y)
{
  assert(view != NULL);

  struct wlr_box *geometry = hikari_view_geometry(view);

  move_view(view, geometry, geometry->x + x, geometry->y + y);
}

void
hikari_view_move_absolute(struct hikari_view *view, int x, int y)
{
  assert(view != NULL);

  struct wlr_box *geometry = hikari_view_geometry(view);

  move_view(view, geometry, x, y);
}

#define MOVE(pos)                                                              \
  void hikari_view_move_##pos(struct hikari_view *view)                        \
  {                                                                            \
    assert(view != NULL);                                                      \
                                                                               \
    struct hikari_output *output = view->output;                               \
    struct wlr_box *usable_area = &output->usable_area;                        \
    struct wlr_box *border_geometry = hikari_view_border_geometry(view);       \
    struct wlr_box *geometry = hikari_view_geometry(view);                     \
                                                                               \
    int x;                                                                     \
    int y;                                                                     \
    hikari_geometry_position_##pos(border_geometry, usable_area, &x, &y);      \
                                                                               \
    move_view(view, geometry, x, y);                                           \
  }

MOVE(bottom_left)
MOVE(bottom_middle)
MOVE(bottom_right)
MOVE(center_left)
MOVE(center)
MOVE(center_right)
MOVE(top_left)
MOVE(top_middle)
MOVE(top_right)
#undef MOVE

static void
new_subsurface_handler(struct wl_listener *listener, void *data)
{
  struct hikari_view *view = wl_container_of(listener, view, new_subsurface);

  struct wlr_subsurface *wlr_subsurface = data;

  struct hikari_view_subsurface *view_subsurface =
      hikari_malloc(sizeof(struct hikari_view_subsurface));

  hikari_view_subsurface_init(view_subsurface, view, wlr_subsurface);
}

void
hikari_view_map(struct hikari_view *view, struct wlr_surface *surface)
{
  assert(hikari_view_is_hidden(view));
  assert(!hikari_view_is_unmanaged(view));
  assert(!hikari_view_is_mapped(view));

  struct hikari_sheet *sheet = view->sheet;
  struct hikari_output *output = view->output;
  struct hikari_group *group;
  bool focus;

  struct hikari_view_config *view_config =
      hikari_configuration_resolve_view_config(hikari_configuration, view->id);

  view->surface = surface;

  view->new_subsurface.notify = new_subsurface_handler;
  wl_signal_add(&surface->events.new_subsurface, &view->new_subsurface);

  struct wlr_subsurface *wlr_subsurface;
  wl_list_for_each (wlr_subsurface, &surface->subsurfaces, parent_link) {
    struct hikari_view_subsurface *subsurface =
        (struct hikari_view_subsurface *)malloc(
            sizeof(struct hikari_view_subsurface));
    hikari_view_subsurface_init(subsurface, view, wlr_subsurface);
  }

  if (view_config != NULL) {
    struct hikari_mark *mark;
    struct hikari_view_properties *properties =
        hikari_view_config_resolve_properties(view_config, view->child);

    assert(properties != NULL);

    group = hikari_view_properties_resolve_group(properties, view->id);
    mark = properties->mark;

    if (mark != NULL && mark->view == NULL) {
      hikari_mark_set(mark, view);
    }

    focus = properties->focus;
  } else {
    group = hikari_server_find_or_create_group(view->id);
    focus = false;
  }

  view->group = group;

  wl_list_insert(&sheet->views, &view->sheet_views);
  wl_list_insert(&group->views, &view->group_views);
  wl_list_insert(&output->views, &view->output_views);

  if (!hikari_server_in_lock_mode() || hikari_view_is_public(view)) {
    hikari_view_show(view);

    if (focus) {
      hikari_view_center_cursor(view);
    }

    hikari_server_cursor_focus();
  } else {
    hikari_view_set_forced(view);
    increase_group_visiblity(view);
    raise_view(view);
  }
}

void
hikari_view_unmap(struct hikari_view *view)
{
  assert(!hikari_view_is_unmanaged(view));
  assert(hikari_view_is_mapped(view));

  wl_list_remove(&view->new_subsurface.link);

  struct hikari_view_child *child, *child_temp;
  wl_list_for_each_safe (child, child_temp, &view->children, link) {
    struct hikari_view_subsurface *subsurface =
        (struct hikari_view_subsurface *)child;
    hikari_view_subsurface_fini(subsurface);
    hikari_free(subsurface);
  }

  if (hikari_view_is_forced(view)) {
    if (hikari_view_is_hidden(view)) {
      hide(view);
    } else {
      hikari_view_damage_whole(view);
      hikari_view_set_hidden(view);
    }

    hikari_view_unset_forced(view);
  }

  if (!hikari_view_is_hidden(view)) {
    hikari_view_hide(view);
    hikari_server_cursor_focus();
  }

  assert(hikari_view_is_hidden(view));
  assert(!hikari_view_is_forced(view));

  view->surface = NULL;

  struct hikari_mark *mark = view->mark;
  if (mark != NULL) {
    hikari_mark_clear(mark);
  }

  detach_from_group(view);
  view->group = NULL;

  cancel_tile(view);

  if (hikari_view_is_tiled(view)) {
    struct wlr_box geometry;
    struct hikari_tile *tile = view->tile;

    memcpy(&geometry, hikari_view_geometry(view), sizeof(struct wlr_box));

    if (hikari_tile_is_attached(tile)) {
      hikari_tile_detach(tile);
    }

    hikari_free(tile);
    view->tile = NULL;

    hikari_view_refresh_geometry(view, &geometry);
  }

  wl_list_remove(&view->sheet_views);
  wl_list_init(&view->sheet_views);

  wl_list_remove(&view->output_views);
  wl_list_init(&view->output_views);

  hikari_view_unset_dirty(view);

  assert(!hikari_view_is_tiling(view));
  assert(!hikari_view_is_tiled(view));
}

void
hikari_view_show(struct hikari_view *view)
{
  assert(view != NULL);
  assert(hikari_view_is_hidden(view));
  assert(!hikari_view_is_forced(view));

#if !defined(NDEBUG)
  printf("SHOW %p\n", view);
#endif
  hikari_view_unset_hidden(view);

  increase_group_visiblity(view);

  raise_view(view);

  hikari_view_damage_whole(view);

  assert(is_first_view(view));
}

void
hikari_view_hide(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));
  assert(!hikari_view_is_forced(view));

#if !defined(NDEBUG)
  printf("HIDE %p\n", view);
#endif

  clear_focus(view);
  hide(view);

  hikari_view_damage_whole(view);
}

void
hikari_view_raise(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  if (is_first_view(view)) {
    return;
  }

  raise_view(view);
  hikari_view_damage_whole(view);
}

void
hikari_view_lower(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  if (is_last_view(view)) {
    return;
  }

  wl_list_remove(&view->sheet_views);
  wl_list_insert(view->sheet->views.prev, &view->sheet_views);

  wl_list_remove(&view->group_views);
  wl_list_insert(view->group->views.prev, &view->group_views);

  wl_list_remove(&view->output_views);
  wl_list_insert(view->output->views.prev, &view->output_views);

  wl_list_remove(&view->visible_group_views);
  wl_list_insert(view->group->visible_views.prev, &view->visible_group_views);

  wl_list_remove(&view->group->visible_server_groups);
  wl_list_insert(
      hikari_server.visible_groups.prev, &view->group->visible_server_groups);

  wl_list_remove(&view->workspace_views);
  wl_list_insert(view->sheet->workspace->views.prev, &view->workspace_views);

  wl_list_remove(&view->visible_server_views);
  wl_list_insert(hikari_server.visible_views.prev, &view->visible_server_views);

  hikari_view_damage_whole(view);
}

static void
commit_tile(struct hikari_view *view, struct hikari_operation *operation)
{
  if (view->maximized_state) {
    hikari_maximized_state_destroy(view->maximized_state);
    view->maximized_state = NULL;
    if (!view->use_csd) {
      view->border.state = HIKARI_BORDER_INACTIVE;
    }
  }

  assert(hikari_tile_is_attached(operation->tile));

  if (hikari_view_is_tiled(view)) {
    struct hikari_tile *tile = view->tile;

    assert(hikari_tile_is_attached(tile));

    wl_list_remove(&tile->layout_tiles);
    hikari_free(tile);
    view->tile = NULL;
  }

  assert(!hikari_view_is_tiled(view));
  assert(operation->tile != NULL);
  view->tile = operation->tile;
  operation->tile = NULL;

  if (!hikari_view_is_hidden(view)) {
    commit_pending_geometry(view, &operation->geometry);
    if (operation->center) {
      hikari_view_center_cursor(view);
    }
    hikari_server_cursor_focus();
  } else {
    hikari_view_refresh_geometry(view, &operation->geometry);
  }
}

static void
queue_tile(struct hikari_view *view,
    struct hikari_layout *layout,
    struct hikari_tile *tile,
    bool center)
{
  assert(!hikari_view_is_dirty(view));

  struct hikari_operation *op = &view->pending_operation;

  struct wlr_box *current_geometry = hikari_view_geometry(view);

  op->type = HIKARI_OPERATION_TYPE_TILE;
  op->tile = tile;
  op->geometry = tile->view_geometry;
  op->center = center;

  if (current_geometry->width == op->geometry.width &&
      current_geometry->height == op->geometry.height) {
    hikari_view_set_dirty(view);

    hikari_view_commit_pending_operation(view, current_geometry);
  } else {
    resize(view, op, commit_tile);
  }
}

void
hikari_view_tile(
    struct hikari_view *view, struct wlr_box *geometry, bool center)
{
  assert(!hikari_view_is_dirty(view));
  assert(hikari_view_is_tileable(view));

  struct hikari_layout *layout = view->sheet->workspace->sheet->layout;

  struct hikari_tile *tile = hikari_malloc(sizeof(struct hikari_tile));
  hikari_tile_init(tile, view, layout, geometry, geometry);

  queue_tile(view, layout, tile, center);

  wl_list_insert(layout->tiles.prev, &tile->layout_tiles);
}

static void
commit_full_maximize(
    struct hikari_view *view, struct hikari_operation *operation)
{
  if (!view->maximized_state) {
    view->maximized_state =
        hikari_malloc(sizeof(struct hikari_maximized_state));
  }

  view->maximized_state->maximization = HIKARI_MAXIMIZATION_FULLY_MAXIMIZED;
  view->maximized_state->geometry = operation->geometry;

  if (!view->use_csd) {
    view->border.state = HIKARI_BORDER_NONE;
  }

  commit_pending_operation(view, operation);
}

static void
queue_full_maximize(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  struct hikari_operation *op = &view->pending_operation;
  struct hikari_output *output = view->output;

  op->type = HIKARI_OPERATION_TYPE_FULL_MAXIMIZE;
  op->geometry = output->usable_area;
  op->center = true;

  resize(view, op, commit_full_maximize);
}

static void
commit_unmaximize(struct hikari_view *view, struct hikari_operation *operation)
{
  hikari_view_damage_whole(view);

  hikari_free(view->maximized_state);
  view->maximized_state = NULL;

  if (!view->use_csd) {
    view->border.state = HIKARI_BORDER_ACTIVE;
  }

  commit_pending_operation(view, operation);
}

static void
queue_unmaximize(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  struct hikari_operation *op = &view->pending_operation;

  op->type = HIKARI_OPERATION_TYPE_UNMAXIMIZE;
  op->center = true;

  if (view->tile != NULL) {
    op->geometry = view->tile->view_geometry;
  } else {
    op->geometry = view->geometry;
  }

  resize(view, op, commit_unmaximize);
}

void
hikari_view_toggle_full_maximize(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  if (hikari_view_is_dirty(view)) {
    return;
  }

  if (hikari_view_is_fully_maximized(view)) {
    queue_unmaximize(view);
  } else {
    queue_full_maximize(view);
  }
}

void
hikari_view_toggle_public(struct hikari_view *view)
{
  if (hikari_view_is_public(view)) {
    hikari_view_unset_public(view);
  } else {
    hikari_view_set_public(view);
  }
}

static void
commit_horizontal_maximize(
    struct hikari_view *view, struct hikari_operation *operation)
{
  if (!view->maximized_state) {
    view->maximized_state =
        hikari_malloc(sizeof(struct hikari_maximized_state));
  } else {
    switch (view->maximized_state->maximization) {
      case HIKARI_MAXIMIZATION_HORIZONTALLY_MAXIMIZED:
        commit_full_maximize(view, operation);
        return;

      case HIKARI_MAXIMIZATION_FULLY_MAXIMIZED:
        if (!view->use_csd) {
          view->border.state = HIKARI_BORDER_INACTIVE;
        }
        break;

      case HIKARI_MAXIMIZATION_VERTICALLY_MAXIMIZED:
        assert(false);
        break;
    }
  }

  view->maximized_state->maximization =
      HIKARI_MAXIMIZATION_HORIZONTALLY_MAXIMIZED;
  view->maximized_state->geometry = operation->geometry;

  commit_pending_operation(view, operation);
}

static void
queue_horizontal_maximize(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  struct hikari_operation *op = &view->pending_operation;
  struct hikari_output *output = view->output;

  struct wlr_box *geometry = view->current_unmaximized_geometry;

  op->type = HIKARI_OPERATION_TYPE_HORIZONTAL_MAXIMIZE;
  op->geometry.x = output->usable_area.x;
  op->geometry.y = geometry->y;
  op->geometry.height = geometry->height;
  op->geometry.width = output->usable_area.width;
  op->center = true;

  resize(view, op, commit_horizontal_maximize);
}

static void
commit_vertical_maximize(
    struct hikari_view *view, struct hikari_operation *operation)
{
  if (!view->maximized_state) {
    view->maximized_state =
        hikari_malloc(sizeof(struct hikari_maximized_state));
  } else {
    switch (view->maximized_state->maximization) {
      case HIKARI_MAXIMIZATION_HORIZONTALLY_MAXIMIZED:
        commit_full_maximize(view, operation);
        return;

      case HIKARI_MAXIMIZATION_FULLY_MAXIMIZED:
        if (!view->use_csd) {
          view->border.state = HIKARI_BORDER_INACTIVE;
        }
        break;

      case HIKARI_MAXIMIZATION_VERTICALLY_MAXIMIZED:
        assert(false);
        break;
    }
  }

  view->maximized_state->maximization =
      HIKARI_MAXIMIZATION_VERTICALLY_MAXIMIZED;
  view->maximized_state->geometry = operation->geometry;

  commit_pending_operation(view, operation);
}

static void
queue_vertical_maximize(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  struct hikari_operation *op = &view->pending_operation;
  struct hikari_output *output = view->output;

  struct wlr_box *geometry = view->current_unmaximized_geometry;

  op->type = HIKARI_OPERATION_TYPE_VERTICAL_MAXIMIZE;
  op->geometry.x = geometry->x;
  op->geometry.y = output->usable_area.y;
  op->geometry.height = output->usable_area.height;
  op->geometry.width = geometry->width;
  op->center = true;

  resize(view, op, commit_vertical_maximize);
}

void
hikari_view_toggle_vertical_maximize(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  if (hikari_view_is_dirty(view)) {
    return;
  }

  if (view->maximized_state != NULL) {
    switch (view->maximized_state->maximization) {
      case HIKARI_MAXIMIZATION_FULLY_MAXIMIZED:
        queue_horizontal_maximize(view);
        break;

      case HIKARI_MAXIMIZATION_VERTICALLY_MAXIMIZED:
        queue_unmaximize(view);
        break;

      case HIKARI_MAXIMIZATION_HORIZONTALLY_MAXIMIZED:
        queue_full_maximize(view);
        break;
    }
  } else {
    queue_vertical_maximize(view);
  }
}

void
hikari_view_toggle_horizontal_maximize(struct hikari_view *view)
{
  assert(view != NULL);
  assert(!hikari_view_is_hidden(view));

  if (view->maximized_state != NULL) {
    switch (view->maximized_state->maximization) {
      case HIKARI_MAXIMIZATION_FULLY_MAXIMIZED:
        queue_vertical_maximize(view);
        break;

      case HIKARI_MAXIMIZATION_VERTICALLY_MAXIMIZED:
        queue_full_maximize(view);
        break;

      case HIKARI_MAXIMIZATION_HORIZONTALLY_MAXIMIZED:
        queue_unmaximize(view);
        break;
    }
  } else {
    queue_horizontal_maximize(view);
  }
}

void
hikari_view_toggle_floating(struct hikari_view *view)
{
  if (!hikari_view_is_floating(view)) {
    if (hikari_view_is_tiled(view)) {
      hikari_view_reset_geometry(view);
    }
    hikari_view_set_floating(view);
  } else {
    hikari_view_unset_floating(view);
  }
}

void
hikari_view_reset_geometry(struct hikari_view *view)
{
  queue_reset(view, true);
}

void
hikari_view_evacuate(struct hikari_view *view, struct hikari_sheet *sheet)
{
#ifndef NDEBUG
  printf("EVACUATE VIEW %p\n", view);
#endif

  clear_focus(view);

  view->output = sheet->workspace->output;
  view->sheet = sheet;

  if (!hikari_view_is_hidden(view)) {
    if (hikari_view_is_forced(view)) {
      move_to_top(view);
    } else {
      raise_view(view);
    }

    if (hikari_sheet_is_visible(sheet)) {
      hikari_view_damage_whole(view);
      hikari_indicator_damage(&hikari_server.indicator, view);
    } else {
      if (hikari_view_is_forced(view)) {
        move_to_top(view);
      } else {
        hikari_view_hide(view);
      }
    }
  } else {
    if (hikari_view_is_forced(view)) {
      raise_view(view);
    } else {
      move_to_top(view);
    }
  }

  if (hikari_view_is_tiled(view) || hikari_view_is_maximized(view)) {
    queue_reset(view, false);
  }
}

void
hikari_view_pin_to_sheet(struct hikari_view *view, struct hikari_sheet *sheet)
{
  assert(view != NULL);
  assert(sheet != NULL);
  assert(sheet->workspace->output == view->output);

  if (view->sheet == sheet) {
    assert(!hikari_view_is_hidden(view));

    if (view->sheet->workspace->sheet != sheet && sheet->nr != 0) {
      hikari_view_hide(view);
      hikari_server_cursor_focus();

      move_to_top(view);
    } else {
      hikari_view_raise(view);
      hikari_indicator_damage(&hikari_server.indicator, view);
    }
  } else {
    if (hikari_sheet_is_visible(sheet)) {
      place_visibly_above(view, sheet->workspace);

      hikari_view_damage_whole(view);
      hikari_indicator_damage(&hikari_server.indicator, view);
    } else {
      hikari_view_hide(view);
      hikari_server_cursor_focus();
    }

    view->sheet = sheet;

    if (hikari_view_is_tiled(view)) {
      queue_reset(view, true);
    } else {
      move_to_top(view);
    }
  }
}

void
hikari_view_center_cursor(struct hikari_view *view)
{
  assert(view != NULL);

  struct hikari_output *output = view->output;
  struct wlr_box *view_geometry = hikari_view_geometry(view);

  struct wlr_box geometry;
  hikari_geometry_constrain_size(
      view_geometry, &output->usable_area, &geometry);

  hikari_cursor_center(&hikari_server.cursor, output, &geometry);
}

void
hikari_view_top_left_cursor(struct hikari_view *view)
{
  assert(view != NULL);

  struct wlr_box *geometry = hikari_view_geometry(view);
  struct hikari_output *output = view->output;

  int x = output->geometry.x + geometry->x;
  int y = output->geometry.y + geometry->y;

  hikari_cursor_warp(&hikari_server.cursor, x, y);
}

void
hikari_view_bottom_right_cursor(struct hikari_view *view)
{
  assert(view != NULL);

  struct wlr_box *geometry = hikari_view_geometry(view);
  struct hikari_output *output = view->output;

  int x = output->geometry.x + geometry->x + geometry->width;
  int y = output->geometry.y + geometry->y + geometry->height;

  hikari_cursor_warp(&hikari_server.cursor, x, y);
}

void
hikari_view_toggle_invisible(struct hikari_view *view)
{
  if (hikari_view_is_invisible(view)) {
    hikari_view_unset_invisible(view);
  } else {
    if (hikari_view_is_tiled(view)) {
      hikari_view_reset_geometry(view);
    }
    hikari_view_set_invisible(view);
  }
}

void
hikari_view_group(struct hikari_view *view, struct hikari_group *group)
{
  assert(view != NULL);
  assert(group != NULL);
  assert(view->group != NULL);

  if (view->group == group) {
    return;
  }

  remove_from_group(view);
  view->group = group;

  increase_group_visiblity(view);

  raise_view(view);

  hikari_view_damage_whole(view);
}

void
hikari_view_exchange(struct hikari_view *from, struct hikari_view *to)
{
  assert(from != NULL);
  assert(to != NULL);

  if (hikari_view_is_dirty(from) || hikari_view_is_dirty(to)) {
    return;
  }

  assert(from->tile != NULL);
  assert(to->tile != NULL);
  assert(to->tile->view->sheet == from->tile->view->sheet);

  struct hikari_layout *layout = from->sheet->workspace->sheet->layout;

  struct wlr_box *from_geometry = &from->tile->tile_geometry;
  struct wlr_box *to_geometry = &to->tile->tile_geometry;

  struct hikari_tile *from_tile = hikari_malloc(sizeof(struct hikari_tile));
  struct hikari_tile *to_tile = hikari_malloc(sizeof(struct hikari_tile));

  hikari_tile_init(from_tile, from, layout, to_geometry, to_geometry);
  hikari_tile_init(to_tile, to, layout, from_geometry, from_geometry);

  wl_list_insert(&from->tile->layout_tiles, &to_tile->layout_tiles);
  wl_list_insert(&to->tile->layout_tiles, &from_tile->layout_tiles);

  queue_tile(from, layout, from_tile, true);
  queue_tile(to, layout, to_tile, false);
}

static void
destroy_subsurface_handler(struct wl_listener *listener, void *data)
{
  struct hikari_view_subsurface *view_subsurface =
      wl_container_of(listener, view_subsurface, destroy);

  hikari_view_subsurface_fini(view_subsurface);

  hikari_free(view_subsurface);
}

void
hikari_view_subsurface_init(struct hikari_view_subsurface *view_subsurface,
    struct hikari_view *parent,
    struct wlr_subsurface *subsurface)
{
  view_subsurface->subsurface = subsurface;

  view_subsurface->destroy.notify = destroy_subsurface_handler;
  wl_signal_add(
      &subsurface->surface->events.destroy, &view_subsurface->destroy);

  hikari_view_child_init(
      (struct hikari_view_child *)view_subsurface, parent, subsurface->surface);
}

void
hikari_view_child_fini(struct hikari_view_child *view_child)
{
  wl_list_remove(&view_child->link);
  wl_list_remove(&view_child->commit.link);
  wl_list_remove(&view_child->new_subsurface.link);
}

void
hikari_view_subsurface_fini(struct hikari_view_subsurface *view_subsurface)
{
  hikari_view_child_fini(&view_subsurface->view_child);
  wl_list_remove(&view_subsurface->destroy.link);
}

static void
damage_surface(struct wlr_surface *surface, int sx, int sy, void *data)
{
  struct hikari_damage_data *damage_data = data;
  struct hikari_output *output = damage_data->output;

  if (damage_data->whole) {
    damage_whole_surface(surface, sx, sy, data);
  } else {
    struct wlr_box *geometry = damage_data->geometry;

    hikari_output_add_effective_surface_damage(
        output, surface, geometry->x + sx, geometry->y + sy);
  }
}

static void
damage_single_surface(struct wlr_surface *surface, int sx, int sy, void *data)
{
  struct hikari_damage_data *damage_data = data;

  if (damage_data->surface == surface) {
    damage_surface(surface, sx, sy, data);
  }
}

static void
commit_child_handler(struct wl_listener *listener, void *data)
{
  struct hikari_view_child *view_child =
      wl_container_of(listener, view_child, commit);

  struct hikari_view *parent = view_child->parent;
  assert(!hikari_view_is_hidden(parent));

  struct wlr_surface *surface = view_child->surface;

  hikari_view_damage_surface(parent, surface, false);
}

static void
new_subsurface_child_handler(struct wl_listener *listener, void *data)
{
  struct hikari_view_child *view_child =
      wl_container_of(listener, view_child, new_subsurface);

  struct wlr_subsurface *wlr_subsurface = data;

  struct hikari_view_subsurface *view_subsurface =
      hikari_malloc(sizeof(struct hikari_view_subsurface));

  hikari_view_subsurface_init(
      view_subsurface, view_child->parent, wlr_subsurface);
}

void
hikari_view_child_init(struct hikari_view_child *view_child,
    struct hikari_view *parent,
    struct wlr_surface *surface)
{
  view_child->parent = parent;
  view_child->surface = surface;

  view_child->new_subsurface.notify = new_subsurface_child_handler;
  wl_signal_add(&surface->events.new_subsurface, &view_child->new_subsurface);

  view_child->commit.notify = commit_child_handler;
  wl_signal_add(&surface->events.commit, &view_child->commit);

  wl_list_insert(&parent->children, &view_child->link);
}

void
hikari_view_damage_surface(
    struct hikari_view *view, struct wlr_surface *surface, bool whole)
{
  assert(view != NULL);

  // TODO I know, this needs to be done A LOT better
  if (view->use_csd) {
    hikari_output_damage_whole(view->output);
    return;
  }

  struct hikari_damage_data damage_data;

  damage_data.geometry = hikari_view_geometry(view);
  damage_data.output = view->output;
  damage_data.surface = surface;
  damage_data.whole = whole;
  damage_data.view = view;

  hikari_node_for_each_surface(
      (struct hikari_node *)view, damage_single_surface, &damage_data);
}

void
hikari_view_refresh_geometry(struct hikari_view *view, struct wlr_box *geometry)
{
  struct wlr_box *new_geometry = refresh_geometry(view);

  memcpy(new_geometry, geometry, sizeof(struct wlr_box));

  view->current_geometry = new_geometry;
  view->current_unmaximized_geometry = refresh_unmaximized_geometry(view);

  refresh_border_geometry(view);
}

static void
commit_operation(struct hikari_operation *operation, struct hikari_view *view)
{
  switch (operation->type) {
    case HIKARI_OPERATION_TYPE_RESIZE:
      commit_resize(view, operation);
      break;

    case HIKARI_OPERATION_TYPE_RESET:
      commit_reset(view, operation);
      break;

    case HIKARI_OPERATION_TYPE_UNMAXIMIZE:
      commit_unmaximize(view, operation);
      break;

    case HIKARI_OPERATION_TYPE_FULL_MAXIMIZE:
      commit_full_maximize(view, operation);
      break;

    case HIKARI_OPERATION_TYPE_VERTICAL_MAXIMIZE:
      commit_vertical_maximize(view, operation);
      break;

    case HIKARI_OPERATION_TYPE_HORIZONTAL_MAXIMIZE:
      commit_horizontal_maximize(view, operation);
      break;

    case HIKARI_OPERATION_TYPE_TILE:
      commit_tile(view, operation);
      break;
  }
}

void
hikari_view_commit_pending_operation(
    struct hikari_view *view, struct wlr_box *geometry)
{
  assert(view != NULL);
  assert(hikari_view_is_dirty(view));

  view->pending_operation.geometry.width = geometry->width;
  view->pending_operation.geometry.height = geometry->height;

  hikari_indicator_damage(&hikari_server.indicator, view);
  hikari_view_damage_whole(view);

  commit_operation(&view->pending_operation, view);
  hikari_view_unset_dirty(view);
}

void
hikari_view_activate(struct hikari_view *view, bool active)
{
  assert(view != NULL);

  if (view->activate) {
    if (view->border.state != HIKARI_BORDER_NONE) {
      view->border.state =
          active ? HIKARI_BORDER_ACTIVE : HIKARI_BORDER_INACTIVE;
    }
    view->activate(view, active);
  }
}

static void
migrate_view(struct hikari_view *view, struct hikari_sheet *sheet, bool center)
{
  assert(hikari_view_is_hidden(view));

  view->output = sheet->workspace->output;
  view->sheet = sheet;

  move_to_top(view);

  queue_reset(view, center);
}

void
hikari_view_migrate(struct hikari_view *view,
    struct hikari_sheet *sheet,
    int x,
    int y,
    bool center)
{
  struct hikari_output *output = sheet->workspace->output;
  struct wlr_box *view_geometry = hikari_view_geometry(view);

  hikari_indicator_damage(&hikari_server.indicator, view);
  hikari_view_damage_whole(view);

  // only remove view from lists and do not make it lose focus by calling
  // `hikari_view_hide`.
  hide(view);

  hikari_geometry_constrain_relative(
      &view->geometry, &output->usable_area, x, y);
  hikari_geometry_constrain_relative(view_geometry, &output->usable_area, x, y);

  migrate_view(view, sheet, center);

#ifdef HAVE_XWAYLAND
  if (view->move != NULL) {
    view->move(view, view_geometry->x, view_geometry->y);
  }
#endif

  if (hikari_view_is_hidden(view)) {
    hikari_view_show(view);
  }
}

void
hikari_view_configure(struct hikari_view *view,
    const char *app_id,
    struct hikari_view_config *view_config)
{
  assert(view->id == NULL);

  struct hikari_sheet *sheet;
  struct hikari_output *output;
  struct wlr_box *geometry = &view->geometry;
  int x, y;
  bool invisible, floating, publicview;

  set_app_id(view, app_id);

  if (view_config != NULL) {
    struct hikari_view_properties *properties =
        hikari_view_config_resolve_properties(view_config, view->child);

    sheet = hikari_view_properties_resolve_sheet(properties);
    output = sheet->workspace->output;

    invisible = properties->invisible;
    floating = properties->floating;
    publicview = properties->publicview;

    hikari_view_properties_resolve_position(properties, view, &x, &y);
  } else {
    sheet = hikari_server.workspace->sheet;
    output = sheet->workspace->output;

    invisible = false;
    floating = false;
    publicview = false;

    x = hikari_server.cursor.wlr_cursor->x - output->geometry.x;
    y = hikari_server.cursor.wlr_cursor->y - output->geometry.y;
  }

  view->sheet = sheet;
  view->output = output;

  wl_list_init(&view->workspace_views);
  wl_list_init(&view->visible_server_views);

  if (invisible) {
    hikari_view_set_invisible(view);
  }

  if (floating) {
    hikari_view_set_floating(view);
  }

  if (publicview) {
    hikari_view_set_public(view);
  }

  hikari_geometry_constrain_absolute(geometry, &output->usable_area, x, y);
  hikari_view_refresh_geometry(view, geometry);
}