view.c

Go to the documentation of this file.

/*
 * rofi
 *
 * MIT/X11 License
 * Copyright © 2013-2020 Qball Cow <qball@gmpclient.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

#define G_LOG_DOMAIN "View"
 
#include <config.h>
#include <errno.h>
#include <locale.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
 
#include <cairo.h>
 
#include "rofi.h"
#include "settings.h"
#include "timings.h"
 
#include "display.h"
#include "helper-theme.h"
#include "helper.h"
#include "mode.h"
#include "modes/modes.h"
 
#include "view-internal.h"
#include "view.h"
 
#include "theme.h"

static void wayland_rofi_view_update(RofiViewState *state, gboolean qr);
 
void process_result(RofiViewState *state);
static struct {
  MenuFlags flags;
  guint idle_timeout;
  unsigned long long count;
  guint repaint_source;
  gboolean fullscreen;
 
  int monitor_width;
  int monitor_height;
 
  int surface_width;
  int surface_height;
 
  int menu_width;
  int menu_height;
 
  int menu_x;
  int menu_y;
 
} WlState = {
    .flags = MENU_NORMAL,
    .idle_timeout = 0,
    .count = 0L,
    .repaint_source = 0,
    .fullscreen = FALSE,
    .monitor_width = 0,
    .monitor_height = 0,
 
    .surface_width = 0,
    .surface_height = 0,
 
    .menu_width = 0,
    .menu_height = 0,
 
    .menu_x = 0,
    .menu_y = 0,
};
 
static void wayland_rofi_view_get_current_monitor(int *width, int *height) {
  // TODO: handle changing monitor resolution
  if (WlState.monitor_width == 0 && WlState.monitor_height == 0) {
    display_get_surface_dimensions(&WlState.monitor_width,
                                   &WlState.monitor_height);
  }
 
  if (width) {
    *width = WlState.monitor_width;
  }
  if (height) {
    *height = WlState.monitor_height;
  }
}
 
static gboolean wayland_rofi_view_repaint(G_GNUC_UNUSED void *data) {
  RofiViewState *state = rofi_view_get_active();
  if (state) {
    // Repaint the view (if needed).
    // After a resize the edit_pixmap surface might not contain anything
    // anymore. If we already re-painted, this does nothing.
    rofi_view_maybe_update(state);
    WlState.repaint_source = 0;
  }
  return G_SOURCE_REMOVE;
}
 
static const int loc_transtable[9] = {
    WL_CENTER, WL_NORTH | WL_WEST, WL_NORTH, WL_NORTH | WL_EAST,
    WL_EAST,   WL_SOUTH | WL_EAST, WL_SOUTH, WL_SOUTH | WL_WEST,
    WL_WEST};
 
static void wayland_rofi_view_calculate_window_position(
    G_GNUC_UNUSED RofiViewState *state) {}
 
static int rofi_get_location(RofiViewState *state) {
  return rofi_theme_get_position(WIDGET(state->main_window), "location",
                                 loc_transtable[config.location]);
}
 
static int rofi_get_offset_px(RofiViewState *state, RofiOrientation ori) {
  char *property = ori == ROFI_ORIENTATION_HORIZONTAL ? "x-offset" : "y-offset";
 
  RofiDistance offset =
      rofi_theme_get_distance(WIDGET(state->main_window), property, 0);
  return distance_get_pixel(offset, ori);
}
 
static void window_update_size_normal(RofiViewState *state, int offset_x,
                                      int offset_y) {
  WlState.surface_width = state->width;
  WlState.surface_height = state->height;
  WlState.menu_x = 0;
  WlState.menu_y = 0;
 
  display_set_surface_dimensions(state->width, state->height, offset_x,
                                 offset_y, rofi_get_location(state));
}
 
static void window_update_size_with_outside_click(RofiViewState *state,
                                                  int offset_x, int offset_y) {
  int screen_width = 0;
  int screen_height = 0;
  int loc = rofi_get_location(state);
 
  wayland_rofi_view_get_current_monitor(&screen_width, &screen_height);
 
  if (screen_width <= 0 || screen_height <= 0) {
    screen_width = state->width;
    screen_height = state->height;
  }
 
  WlState.surface_width = screen_width;
  WlState.surface_height = screen_height;
 
  switch (loc) {
  case WL_NORTH_WEST:
    WlState.menu_x = offset_x;
    WlState.menu_y = offset_y;
    break;
  case WL_NORTH:
    WlState.menu_x =
        (WlState.surface_width - WlState.menu_width) / 2 + offset_x;
    WlState.menu_y = offset_y;
    break;
  case WL_NORTH_EAST:
    WlState.menu_x = WlState.surface_width - WlState.menu_width - offset_x;
    WlState.menu_y = offset_y;
    break;
  case WL_EAST:
    WlState.menu_x = WlState.surface_width - WlState.menu_width - offset_x;
    WlState.menu_y =
        (WlState.surface_height - WlState.menu_height) / 2 + offset_y;
    break;
  case WL_SOUTH_EAST:
    WlState.menu_x = WlState.surface_width - WlState.menu_width - offset_x;
    WlState.menu_y = WlState.surface_height - WlState.menu_height - offset_y;
    break;
  case WL_SOUTH:
    WlState.menu_x =
        (WlState.surface_width - WlState.menu_width) / 2 + offset_x;
    WlState.menu_y = WlState.surface_height - WlState.menu_height - offset_y;
    break;
  case WL_SOUTH_WEST:
    WlState.menu_x = offset_x;
    WlState.menu_y = WlState.surface_height - WlState.menu_height - offset_y;
    break;
  case WL_WEST:
    WlState.menu_x = offset_x;
    WlState.menu_y =
        (WlState.surface_height - WlState.menu_height) / 2 + offset_y;
    break;
  case WL_CENTER:
  default:
    WlState.menu_x =
        (WlState.surface_width - WlState.menu_width) / 2 + offset_x;
    WlState.menu_y =
        (WlState.surface_height - WlState.menu_height) / 2 + offset_y;
    break;
  }
 
  /* Click-capture is limited to the current output. If the menu is larger than
   * the output and visually overflows onto another output, the overflowed area
   * will not be part of the capture surface and clicks there will not trigger
   * click-to-exit.
   */
  display_set_surface_dimensions(WlState.surface_width, WlState.surface_height,
                                 0, 0, WL_NORTH_WEST);
}
 
static void wayland_rofi_view_window_update_size(RofiViewState *state) {
  if (state == NULL) {
    return;
  }
 
  int offset_x = rofi_get_offset_px(state, ROFI_ORIENTATION_HORIZONTAL);
  int offset_y = rofi_get_offset_px(state, ROFI_ORIENTATION_VERTICAL);
 
  widget_resize(WIDGET(state->main_window), state->width, state->height);
 
  WlState.menu_width = state->width;
  WlState.menu_height = state->height;
 
  if (config.click_to_exit) {
    window_update_size_with_outside_click(state, offset_x, offset_y);
  } else {
    window_update_size_normal(state, offset_x, offset_y);
  }
  rofi_view_pool_refresh();
}
 
static void wayland_rofi_view_set_size(RofiViewState *state, gint width,
                                       gint height) {
  if (width > -1) {
    state->width = width;
  }
  if (height > -1) {
    state->height = height;
  }
  wayland_rofi_view_window_update_size(state);
}
 
static void wayland_rofi_view_get_size(RofiViewState *state, gint *width,
                                       gint *height) {
  *width = state->width;
  *height = state->height;
}
 
static void wayland_rofi_view_ping_mouse(RofiViewState *state) { (void)state; }
 
static gboolean wayland_rofi_view_reload_idle(G_GNUC_UNUSED gpointer data) {
  RofiViewState *state = rofi_view_get_active();
 
  /* Clear before refiltering: a reload signalled during the pass, such as a
   * finished icon fetch, would otherwise coalesce into it and be lost. */
  WlState.idle_timeout = 0;
 
  if (state) {
    // For UI update on this.
    if (state->tb_total_rows) {
      char *r = g_strdup_printf("%u", mode_get_num_entries(state->sw));
      textbox_text(state->tb_total_rows, r);
      g_free(r);
    }
    state->reload = TRUE;
    state->refilter = TRUE;
 
    rofi_view_maybe_update(state);
  }
  return G_SOURCE_REMOVE;
}
 
static void wayland_rofi_view_reload(void) {
  // @TODO add check if current view is equal to the callee
  if (WlState.idle_timeout == 0) {
    WlState.idle_timeout =
        g_timeout_add(1000 / 15, wayland_rofi_view_reload_idle, NULL);
  }
}
static void wayland_rofi_view_queue_redraw(void) {
  RofiViewState *state = rofi_view_get_active();
  if (state && WlState.repaint_source == 0) {
    WlState.count++;
    g_debug("redraw %llu", WlState.count);
 
    widget_queue_redraw(WIDGET(state->main_window));
 
    WlState.repaint_source = g_idle_add_full(
        G_PRIORITY_HIGH_IDLE, wayland_rofi_view_repaint, NULL, NULL);
  }
}
 
static void wayland___create_window(MenuFlags menu_flags) {
 
  input_history_initialize();
 
  TICK_N("create cairo surface");
  PangoContext *p = pango_context_new();
  pango_context_set_font_map(p, pango_cairo_font_map_get_default());
  TICK_N("pango cairo font setup");
 
  WlState.flags = menu_flags;
 
  // Setup dpi
  PangoFontMap *font_map = pango_cairo_font_map_get_default();
  if (config.dpi > 1) {
    pango_cairo_font_map_set_resolution((PangoCairoFontMap *)font_map,
                                        (double)config.dpi);
  } else if (config.dpi == 0 || config.dpi == 1) {
    // This is an heuristic that works well for simple cases (eg single monitor)
    // Accurate dpi information only comes after we display the first surface on
    // the screen when it's too late to use for metric units.
    double dpi = wayland_get_dpi_estimation();
    if (dpi >= 0) {
      config.dpi = dpi;
      pango_cairo_font_map_set_resolution((PangoCairoFontMap *)font_map, dpi);
    } else {
      g_warning(
          "DPI auto-detect failed, the output is not known yet or does not "
          "provide a physical size");
      config.dpi =
          pango_cairo_font_map_get_resolution((PangoCairoFontMap *)font_map);
    }
  } else {
    // default pango is 96.
    config.dpi =
        pango_cairo_font_map_get_resolution((PangoCairoFontMap *)font_map);
  }
  // Setup font.
  // Dummy widget.
  box *win = box_create(NULL, "window", ROFI_ORIENTATION_HORIZONTAL);
  const char *font =
      rofi_theme_get_string(WIDGET(win), "font", config.menu_font);
  if (font) {
    PangoFontDescription *pfd = pango_font_description_from_string(font);
    if (helper_validate_font(pfd, font)) {
      pango_context_set_font_description(p, pfd);
    }
    pango_font_description_free(pfd);
  }
  PangoLanguage *l = pango_language_get_default();
  pango_context_set_language(p, l);
  TICK_N("configure font");
 
  // Tell textbox to use this context.
  textbox_set_pango_context(font, p);
  // cleanup
  g_object_unref(p);
 
  WlState.fullscreen = rofi_theme_get_boolean(WIDGET(win), "fullscreen", FALSE);
 
  if (WlState.fullscreen) {
    display_set_fullscreen_mode();
  }
 
  widget_free(WIDGET(win));
 
  TICK_N("done");
}

static void wayland_rofi_view_calculate_window_width(RofiViewState *state) {
  int screen_width = 1920;
  display_get_surface_dimensions(&screen_width, NULL);
 
  if (WlState.fullscreen == TRUE) {
    state->width = screen_width;
    return;
  }
 
  // Calculate as float to stop silly, big rounding down errors.
  state->width = (screen_width / 100.0f) * DEFAULT_MENU_WIDTH;
  // Use theme configured width, if set.
  RofiDistance width = rofi_theme_get_distance(WIDGET(state->main_window),
                                               "width", state->width);
  state->width = distance_get_pixel(width, ROFI_ORIENTATION_HORIZONTAL);
}
 
static void wayland_rofi_view_update(RofiViewState *state, gboolean qr) {
  if (!widget_need_redraw(WIDGET(state->main_window))) {
    return;
  }
  g_debug("Redraw view");
  TICK();
 
  int buffer_width = state->width;
  int buffer_height = state->height;
 
  if (config.click_to_exit) {
    buffer_width = WlState.surface_width;
    buffer_height = WlState.surface_height;
  }
 
  if (state->pool == NULL) {
    state->pool = display_buffer_pool_new(buffer_width, buffer_height);
  }
 
  cairo_surface_t *surface = display_buffer_pool_get_next_buffer(state->pool);
  if (surface == NULL) {
    // no available buffer, bail out
    return;
  }
 
  cairo_t *d = cairo_create(surface);
  cairo_set_operator(d, CAIRO_OPERATOR_SOURCE);
 
  // Paint the background transparent.
  cairo_set_source_rgba(d, 0, 0, 0, 0);
  guint scale = display_scale();
  cairo_surface_set_device_scale(surface, scale, scale);
  cairo_paint(d);
  TICK_N("Background");
 
  // Always paint as overlay over the background.
  cairo_set_operator(d, CAIRO_OPERATOR_OVER);
 
  if (config.click_to_exit) {
    g_debug("draw capture mode: surface=%dx%d menu=%dx%d pos=(%d,%d)",
            WlState.surface_width, WlState.surface_height, WlState.menu_width,
            WlState.menu_height, WlState.menu_x, WlState.menu_y);
    cairo_translate(d, WlState.menu_x, WlState.menu_y);
  } else {
    g_debug("draw normal mode: surface=%dx%d", buffer_width, buffer_height);
  }
 
  widget_draw(WIDGET(state->main_window), d);
 
  TICK_N("widgets");
  cairo_destroy(d);
  display_surface_commit(surface);
 
  if (qr) {
    wayland_rofi_view_queue_redraw();
  }
}
 
static void wayland_rofi_view_frame_callback(void) {
  if (WlState.repaint_source == 0) {
    WlState.repaint_source = g_idle_add_full(
        G_PRIORITY_HIGH_IDLE, wayland_rofi_view_repaint, NULL, NULL);
  }
}
 
static int wayland_rofi_view_calculate_window_height(RofiViewState *state) {
  if (WlState.fullscreen == TRUE) {
    int height = 1080;
    display_get_surface_dimensions(NULL, &height);
    return height;
  }
 
  RofiDistance h =
      rofi_theme_get_distance(WIDGET(state->main_window), "height", 0);
  unsigned int height = distance_get_pixel(h, ROFI_ORIENTATION_VERTICAL);
  // If height is set, return it.
  if (height > 0) {
    return height;
  }
  // Autosize based on widgets.
  widget *main_window = WIDGET(state->main_window);
 
  return widget_get_desired_height(main_window, state->width);
}
 
static void wayland_rofi_view_hide(void) { display_early_cleanup(); }
 
static void wayland_rofi_view_cleanup(void) {
  g_debug("Cleanup.");
  if (WlState.idle_timeout > 0) {
    g_source_remove(WlState.idle_timeout);
    WlState.idle_timeout = 0;
  }
  if (CacheState.refilter_timeout > 0) {
    g_source_remove(CacheState.refilter_timeout);
    CacheState.refilter_timeout = 0;
  }
  if (CacheState.overlay_timeout) {
    g_source_remove(CacheState.overlay_timeout);
    CacheState.overlay_timeout = 0;
  }
  if (CacheState.user_timeout > 0) {
    g_source_remove(CacheState.user_timeout);
    CacheState.user_timeout = 0;
  }
  if (WlState.repaint_source > 0) {
    g_source_remove(WlState.repaint_source);
    WlState.repaint_source = 0;
  }
 
  input_history_save();
}
 
static void
wayland_rofi_view_set_window_title(G_GNUC_UNUSED const char *title) {}
 
static void wayland_rofi_view_pool_refresh(void) {
  RofiViewState *state = rofi_view_get_active();
  if (state == NULL) {
    return;
  }
  display_buffer_pool_free(state->pool);
  state->pool = NULL;
  wayland_rofi_view_update(state, TRUE);
}
 
static void wayland_rofi_view_get_menu_rect(int *x, int *y, int *w, int *h) {
  if (x)
    *x = WlState.menu_x;
  if (y)
    *y = WlState.menu_y;
  if (w)
    *w = WlState.menu_width;
  if (h)
    *h = WlState.menu_height;
}
 
static view_proxy view_ = {
    .update = wayland_rofi_view_update,
    .temp_configure_notify = NULL,
    .temp_click_to_exit = NULL,
    .frame_callback = wayland_rofi_view_frame_callback,
    .queue_redraw = wayland_rofi_view_queue_redraw,
 
    .set_window_title = wayland_rofi_view_set_window_title,
    .calculate_window_position = wayland_rofi_view_calculate_window_position,
    .calculate_window_height = wayland_rofi_view_calculate_window_height,
    .calculate_window_width = wayland_rofi_view_calculate_window_width,
    .window_update_size = wayland_rofi_view_window_update_size,
    .set_cursor = wayland_display_set_cursor_type,
    .ping_mouse = wayland_rofi_view_ping_mouse,
 
    .cleanup = wayland_rofi_view_cleanup,
    .hide = wayland_rofi_view_hide,
    .reload = wayland_rofi_view_reload,
 
    .__create_window = wayland___create_window,
    .get_window = NULL,
    .get_current_monitor = wayland_rofi_view_get_current_monitor,
 
    .set_size = wayland_rofi_view_set_size,
    .get_size = wayland_rofi_view_get_size,
 
    .pool_refresh = wayland_rofi_view_pool_refresh,
 
    .get_menu_rect = wayland_rofi_view_get_menu_rect,
};
 
const view_proxy *wayland_view_proxy = &view_;