hikari-2.2.3/src/normal_mode.c

#include <hikari/normal_mode.h>

#include <wlr/types/wlr_cursor.h>
#include <wlr/types/wlr_seat.h>

#include <hikari/action.h>
#include <hikari/binding.h>
#include <hikari/binding_group.h>
#include <hikari/configuration.h>
#include <hikari/indicator.h>
#include <hikari/indicator_frame.h>
#include <hikari/keyboard.h>
#include <hikari/renderer.h>
#include <hikari/server.h>
#include <hikari/view.h>

#ifndef NDEBUG
#include <hikari/layout.h>
#include <hikari/sheet.h>
#include <hikari/workspace.h>
#endif

struct cursor_down_state {
  double lx;
  double ly;
  double sx;
  double sy;
};

static struct cursor_down_state cursor_down_state;

static bool
handle_input(struct hikari_binding_group *map, uint32_t code)
{
  int nbindings = map->nbindings;
  struct hikari_binding *bindings = map->bindings;

  for (int i = 0; i < nbindings; i++) {
    struct hikari_binding *binding = &bindings[i];

    if (binding->keycode == code) {
      struct hikari_event_action *event_action;

      if (binding->action->end.action != NULL) {
        hikari_server.normal_mode.pending_action = &binding->action->end;
      }

      event_action = &binding->action->begin;
      if (event_action->action != NULL) {
        event_action->action(event_action->arg);
      }
      return true;
    }
  }

  return false;
}

static bool
handle_pending_action(void)
{
  struct hikari_event_action *pending_action =
      hikari_server.normal_mode.pending_action;

  if (pending_action != NULL) {
    pending_action->action(pending_action->arg);
    hikari_server.normal_mode.pending_action = NULL;
    return true;
  }

  return false;
}

#ifndef NDEBUG
static void
dump_debug(struct hikari_server *server)
{
  struct hikari_view *view;
  printf("---------------------------------------------------------------------"
         "\n");
  printf("VIEWS\n");
  printf("---------------------------------------------------------------------"
         "\n");
  wl_list_for_each (view, &hikari_server.visible_views, visible_server_views) {
    printf("%p ", view);
  }
  printf("\n");
  printf("---------------------------------------------------------------------"
         "\n");
  printf("GROUPS\n");
  printf("---------------------------------------------------------------------"
         "\n");
  struct hikari_group *group;
  wl_list_for_each (group, &hikari_server.groups, server_groups) {
    printf("%s ", group->name);

    wl_list_for_each (view, &group->visible_views, visible_group_views) {
      printf("%p ", view);
    }

    printf("/ ");

    wl_list_for_each (view, &group->views, group_views) {
      printf("%p ", view);
    }

    printf("\n");
  }
  printf("---------------------------------------------------------------------"
         "\n");
  struct hikari_output *output;
  wl_list_for_each (output, &hikari_server.outputs, server_outputs) {
    struct hikari_workspace *workspace = output->workspace;
    const char *output_name = workspace->output->wlr_output->name;
    printf("SHEETS %s (%p)\n", output_name, workspace->focus_view);
    printf(
        "---------------------------------------------------------------------"
        "\n");
    struct hikari_sheet *sheets = workspace->sheets;
    struct hikari_sheet *sheet;
    for (int i = 0; i < 10; i++) {
      sheet = &sheets[i];
      if (!wl_list_empty(&sheet->views)) {
        printf("%d ", sheet->nr);
        wl_list_for_each (view, &sheet->views, sheet_views) {
          printf("%p ", view);
        }
        printf("\n");
      }
    }
    printf(
        "---------------------------------------------------------------------"
        "\n");
    if (workspace->sheet->layout != NULL) {
      printf(
          "-------------------------------------------------------------------"
          "--\n");
      printf("LAYOUT %s\n", output_name);
      struct hikari_tile *tile;
      wl_list_for_each (tile, &workspace->sheet->layout->tiles, layout_tiles) {
        printf("%p ", tile->view);
      }
      printf("\n");
    }
  }
  printf("/////////////////////////////////////////////////////////////////////"
         "\n");
}
#endif

static void
modifiers_handler(struct hikari_keyboard *keyboard)
{
  wlr_seat_set_keyboard(hikari_server.seat, keyboard->device);
  struct hikari_view *focus_view = hikari_server.workspace->focus_view;

  if (hikari_server.keyboard_state.mod_released) {

    if (hikari_server_is_cycling() && focus_view != NULL) {
      hikari_view_raise(focus_view);
      hikari_view_center_cursor(focus_view);
      hikari_server_cursor_focus();
    }

    hikari_server_unset_cycling();
  }

  if (hikari_server.keyboard_state.mod_changed) {
    if (focus_view != NULL) {
      hikari_group_damage(focus_view->group);
      hikari_indicator_damage(&hikari_server.indicator, focus_view);
    }
#ifndef NDEBUG
    dump_debug(&hikari_server);
#endif
  }

  wlr_seat_keyboard_notify_modifiers(
      hikari_server.seat, &keyboard->device->keyboard->modifiers);
}

static void
cancel(void)
{}

static void
cursor_down_move(uint32_t time)
{
  struct wlr_seat *seat = hikari_server.seat;

  double x = hikari_server.cursor.wlr_cursor->x;
  double y = hikari_server.cursor.wlr_cursor->y;

  double moved_x = x - cursor_down_state.lx;
  double moved_y = y - cursor_down_state.ly;

  double sx = cursor_down_state.sx + moved_x;
  double sy = cursor_down_state.sy + moved_y;

  wlr_seat_pointer_notify_motion(seat, time, sx, sy);
}

static void
cursor_move(uint32_t time)
{
  assert(hikari_server_in_normal_mode());

  double sx, sy;
  struct wlr_seat *seat = hikari_server.seat;
  struct wlr_surface *surface;
  struct hikari_workspace *workspace;

  struct hikari_node *node =
      hikari_server_node_at(hikari_server.cursor.wlr_cursor->x,
          hikari_server.cursor.wlr_cursor->y,
          &surface,
          &workspace,
          &sx,
          &sy);

  if (node != NULL) {
    struct hikari_node *focus_node =
        (struct hikari_node *)hikari_server.workspace->focus_view;

    if (node != focus_node) {
      hikari_node_focus(node);
    }

    wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
    wlr_seat_pointer_notify_motion(seat, time, sx, sy);
  } else {
    if (hikari_server.workspace != workspace) {
      struct hikari_view *view = hikari_workspace_first_view(workspace);
      hikari_workspace_focus_view(workspace, view);
    }
    if (seat->pointer_state.focused_surface != NULL) {
      hikari_cursor_reset_image(&hikari_server.cursor);
    }
    wlr_seat_pointer_clear_focus(seat);
  }
}

static inline void
start_cursor_down_handling(struct wlr_event_pointer_button *event)
{
  double lx = hikari_server.cursor.wlr_cursor->x;
  double ly = hikari_server.cursor.wlr_cursor->y;

  double sx;
  double sy;
  struct hikari_workspace *workspace;
  struct wlr_surface *surface;

  struct hikari_node *node =
      hikari_server_node_at(lx, ly, &surface, &workspace, &sx, &sy);

  if (node != NULL) {
    hikari_server.normal_mode.mode.cursor_move = cursor_down_move;
    cursor_down_state.lx = lx;
    cursor_down_state.ly = ly;
    cursor_down_state.sx = sx;
    cursor_down_state.sy = sy;
  }

  wlr_seat_pointer_notify_button(
      hikari_server.seat, event->time_msec, event->button, event->state);
}

static inline void
stop_cursor_down_handling(struct wlr_event_pointer_button *event)
{
  hikari_server.normal_mode.mode.cursor_move = cursor_move;

  wlr_seat_pointer_notify_button(
      hikari_server.seat, event->time_msec, event->button, event->state);

  hikari_server_cursor_focus();
}

static inline bool
is_cursor_down(void)
{
  return hikari_server.normal_mode.mode.cursor_move == cursor_down_move;
}

static void
button_handler(
    struct hikari_cursor *cursor, struct wlr_event_pointer_button *event)
{
  if (handle_pending_action()) {
    if (event->state == WLR_BUTTON_RELEASED && is_cursor_down()) {
      stop_cursor_down_handling(event);
    }
    return;
  }

  if (event->state == WLR_BUTTON_PRESSED) {
    uint32_t modifiers = hikari_server.keyboard_state.modifiers;
    struct hikari_binding_group *map = &cursor->bindings[modifiers];

    if (!handle_input(map, event->button)) {
      start_cursor_down_handling(event);
    }
  } else {
    if (is_cursor_down()) {
      stop_cursor_down_handling(event);
    } else {
      wlr_seat_pointer_notify_button(
          hikari_server.seat, event->time_msec, event->button, event->state);
    }
  }
}

static void
key_handler(
    struct hikari_keyboard *keyboard, struct wlr_event_keyboard_key *event)
{
  if (handle_pending_action()) {
    return;
  }

  if (event->state == WLR_KEY_PRESSED) {
    uint32_t modifiers = hikari_server.keyboard_state.modifiers;
    struct hikari_binding_group *bindings = &keyboard->bindings[modifiers];

    if (handle_input(bindings, event->keycode)) {
      return;
    }
  }

  wlr_seat_set_keyboard(hikari_server.seat, keyboard->device);
  wlr_seat_keyboard_notify_key(
      hikari_server.seat, event->time_msec, event->keycode, event->state);
}

void
hikari_normal_mode_init(struct hikari_normal_mode *normal_mode)
{
  normal_mode->mode.key_handler = key_handler;
  normal_mode->mode.button_handler = button_handler;
  normal_mode->mode.modifiers_handler = modifiers_handler;
  normal_mode->mode.render = hikari_renderer_normal_mode;
  normal_mode->mode.cancel = cancel;
  normal_mode->mode.cursor_move = cursor_move;
  normal_mode->pending_action = NULL;
}

void
hikari_normal_mode_enter(void)
{
  struct hikari_server *server = &hikari_server;

  assert(server->workspace != NULL);

  hikari_server.normal_mode.mode.cursor_move = cursor_move;

  server->mode->cancel();
  server->mode = (struct hikari_mode *)&server->normal_mode;
}