TinyGui.hpp

Go to the documentation of this file.

#pragma once
#ifdef __linux__
 
#include <fcntl.h>
#include <linux/fb.h>
#include <linux/input.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
 
#include <cerrno>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
#define NK_INCLUDE_FIXED_TYPES
#define NK_INCLUDE_STANDARD_IO
#define NK_INCLUDE_STANDARD_VARARGS
#define NK_INCLUDE_DEFAULT_ALLOCATOR
#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
#define NK_INCLUDE_FONT_BAKING
#define NK_INCLUDE_DEFAULT_FONT
 
#include <nuklear.h>
 
#include <atomic>
#include <cstring>
#include <mutex>
#include <thread>
 
namespace tinygui {

inline constexpr unsigned K_FB_REQUIRED_BITS_PER_PIXEL = 32;

inline constexpr std::uint32_t K_DEFAULT_FRAME_TIME_MS = 16;

struct TouchCalibration {
  float scale_x{1.0f};
  float scale_y{1.0f};
  bool valid{false};
};

[[nodiscard]] auto detect_touch_calibration(const std::string& device_path)
    -> TouchCalibration;

struct Point {
  int x{0};
  int y{0};
};

struct Size {
  int width{0};
  int height{0};
};

struct Rect {
  int x{0};
  int y{0};
  int w{0};
  int h{0};
 
  [[nodiscard]] auto contains(const Point point) const noexcept -> bool {
    return point.x >= x && point.y >= y && point.x < x + w && point.y < y + h;
  }
};

struct FramebufferView {
  std::uint32_t* pixels{nullptr};
  int width{0};
  int height{0};
  int stride{0};  // в пикселях
  int fb_desc{-1};
 
  FramebufferView() = default;
 
  // Нельзя копировать view, чтобы не было двойного закрытия ресурса.
  FramebufferView(const FramebufferView&) = delete;
  auto operator=(const FramebufferView&) -> FramebufferView& = delete;
 
  // Разрешаем перемещение.
  FramebufferView(FramebufferView&& other) noexcept
      : pixels(other.pixels),
        width(other.width),
        height(other.height),
        stride(other.stride),
        fb_desc(other.fb_desc) {
    other.pixels = nullptr;
    other.width = other.height = other.stride = 0;
    other.fb_desc = -1;
  }
 
  auto operator=(FramebufferView&& other) noexcept -> FramebufferView& {
    if (this != &other) {
      // Освобождаем текущий ресурс.
      if (pixels != nullptr && fb_desc >= 0) {
        // Размер отображения нам тут неизвестен, поэтому предполагаем,
        // что вызывающий код перед уничтожением вызовет munmap/close
        // только через деструктор. Для простоты используем close только
        // по дескриптору, а munmap будем делать в деструкторе.
      }
      pixels = other.pixels;
      width = other.width;
      height = other.height;
      stride = other.stride;
      fb_desc = other.fb_desc;
 
      other.pixels = nullptr;
      other.width = other.height = other.stride = 0;
      other.fb_desc = -1;
    }
    return *this;
  }

  explicit FramebufferView(const std::string& path) {
    const char* fbdev = path.c_str();
    fb_desc = open(fbdev, O_RDWR);
    if (fb_desc < 0) {
      perror("open fb");
      return;
    }
 
    fb_var_screeninfo vinfo{};
    if (ioctl(fb_desc, FBIOGET_VSCREENINFO, &vinfo) < 0) {
      perror("FBIOGET_VSCREENINFO");
      return;
    }
    // vinfo.xres_virtual = vinfo.xres;
    // vinfo.yres_virtual = vinfo.yres;
    // vinfo.nonstd = 0;
    // vinfo.yres_virtual = vinfo.yres * 2;
    vinfo.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE;
    if (ioctl(fb_desc, FBIOPUT_VSCREENINFO, &vinfo) < 0) {
      perror("FBIOGET_VSCREENINFO");
      return;
    }
 
    fb_fix_screeninfo finfo{};
    if (ioctl(fb_desc, FBIOGET_FSCREENINFO, &finfo) < 0) {
      perror("FBIOGET_FSCREENINFO");
      return;
    }
 
    if (vinfo.bits_per_pixel != K_FB_REQUIRED_BITS_PER_PIXEL) {
      fprintf(stderr, "Need 32bpp (ARGB8888), got %u\n", vinfo.bits_per_pixel);
      return;
    }
 
    width = static_cast<int>(vinfo.xres);
    height = static_cast<int>(vinfo.yres);
    // stride в пикселях: длина строки в байтах / 4 байта на пиксель ARGB8888
    stride = static_cast<int>(finfo.line_length / 4);
 
    const size_t screensize = static_cast<size_t>(finfo.line_length) *
                              static_cast<size_t>(vinfo.yres);
    void* const fbp = mmap(nullptr, screensize, PROT_READ | PROT_WRITE,
                           MAP_SHARED, fb_desc, 0);
    if (fbp == MAP_FAILED) {
      perror("mmap");
      pixels = nullptr;
      width = height = stride = 0;
      return;
    }
 
    pixels = static_cast<std::uint32_t*>(fbp);
  }
  explicit FramebufferView(const char* path)
      : FramebufferView(std::string(path)) {}
  [[nodiscard]] auto valid() const noexcept -> bool {
    return pixels != nullptr && width > 0 && height > 0 && stride >= width;
  }

  auto put_pixel_unsafe(const int pos_x, const int pos_y,
                        const std::uint32_t argb) const noexcept -> void {
    pixels[pos_y * stride + pos_x] = argb;
  }

  auto put_pixel(const int pos_x, const int pos_y,
                 const std::uint32_t argb) const noexcept -> void {
    if (pos_x < 0 || pos_y < 0 || pos_x >= width || pos_y >= height) {
      return;
    }
    put_pixel_unsafe(pos_x, pos_y, argb);
  }
 
  ~FramebufferView() {
    if (pixels != nullptr && fb_desc >= 0) {
      // Пытаемся определить размер отображения по текущим параметрам.
      // Предполагаем, что stride – в пикселях, по 4 байта на пиксель.
      const size_t screensize =
          static_cast<size_t>(stride) * static_cast<size_t>(height) * 4;
      if (screensize > 0) {
        munmap(pixels, screensize);
      }
      close(fb_desc);
    }
  }
};

enum class TouchEventType : std::uint8_t {
  DOWN,
  UP,
  MOVE,
};

struct TouchEvent {
  TouchEventType type{};
  Point position{};          
  std::uint32_t id{0};       
  std::uint64_t time_ms{0};  
};

class ITouchInput {
 public:
  virtual ~ITouchInput() = default;

  virtual auto poll(TouchEvent& event) -> bool = 0;
  virtual auto get_path() -> std::string = 0;
  virtual auto set_path(const std::string& new_path) -> bool = 0;
  virtual auto start(std::string path = "") -> bool = 0;
  virtual auto stop() -> bool = 0;
};

class EvdevTouchInput final : public ITouchInput {
 public:
  auto get_path() -> std::string override { return path_; }
  auto start(const std::string PATH = "") -> bool override {
    if (!PATH.empty()) {
      path_ = PATH;
    }
    stop();
    std::scoped_lock lock(poll_mtx_);
    fd_ = open(path_.c_str(), O_RDONLY | O_NONBLOCK);
    if (fd_ < 0) {
      perror("open evdev");
      return false;
    }
    ioctl(fd_, EVIOCGRAB, 1);
    return true;
  }
  auto stop() -> bool override {
    std::scoped_lock lock(poll_mtx_);
    if (fd_ >= 0) {
      ioctl(fd_, EVIOCGRAB, 0);
      close(fd_);
      fd_ = -1;
      return true;
    }
    return false;
  }
  auto set_path(const std::string& new_path) -> bool override {
    stop();
    path_ = new_path;
    return true;
  }
  explicit EvdevTouchInput(const std::string& path) : fd_(-1) {
    EvdevTouchInput::set_path(path);
  }

  explicit EvdevTouchInput(const char* path)
      : EvdevTouchInput(std::string(path)) {}
 
  ~EvdevTouchInput() override { stop(); }
 
  EvdevTouchInput(const EvdevTouchInput&) = delete;
  auto operator=(const EvdevTouchInput&) -> EvdevTouchInput& = delete;
 
  EvdevTouchInput(EvdevTouchInput&& other) noexcept
      : fd_(other.fd_),
        cur_x_(other.cur_x_),
        cur_y_(other.cur_y_),
        touching_(other.touching_) {
    other.fd_ = -1;
    other.cur_x_ = other.cur_y_ = 0;
    other.touching_ = false;
  }
 
  auto operator=(EvdevTouchInput&& other) noexcept -> EvdevTouchInput& {
    if (this != &other) {
      stop();
      fd_ = other.fd_;
      cur_x_ = other.cur_x_;
      cur_y_ = other.cur_y_;
      touching_ = other.touching_;
 
      other.fd_ = -1;
      other.cur_x_ = other.cur_y_ = 0;
      other.touching_ = false;
    }
    return *this;
  }
 
  auto poll(TouchEvent& event) -> bool override {
    std::scoped_lock lock(poll_mtx_);
    if (fd_ < 0) {
      return false;
    }
 
    // В рамках одного вызова poll() читаем поток событий до первого SYN_REPORT
    // и возвращаем максимум одно логическое событие тача.
    bool coord_changed = false;
    bool has_type = false;
    auto next_type = TouchEventType::MOVE;
 
    for (;;) {
      input_event raw{};
      ssize_t n = read(fd_, &raw, sizeof(raw));
      if (n < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
          // Нет данных прямо сейчас.
          return false;
        }
        // Другая ошибка — считаем, что события нет.
        return false;
      }
      if (n != static_cast<ssize_t>(sizeof(raw))) {
        return false;
      }
 
      if (raw.type == EV_ABS) {
        if (raw.code == ABS_X || raw.code == ABS_MT_POSITION_X) {
          cur_x_ = raw.value;
          coord_changed = true;
        } else if (raw.code == ABS_Y || raw.code == ABS_MT_POSITION_Y) {
          cur_y_ = raw.value;
          coord_changed = true;
        }
        // Пока только накапливаем координаты, не возвращаем событие — ждём
        // SYN_REPORT.
        continue;
      }
 
      if (raw.type == EV_KEY && raw.code == BTN_TOUCH) {
        // Фактическое состояние "палец на экране".
        touching_ = raw.value != 0;
        has_type = true;
        next_type = touching_ ? TouchEventType::DOWN : TouchEventType::UP;
        // Координаты могли ещё не прийти, поэтому не возвращаем событие сразу.
        continue;
      }
 
      if (raw.type == EV_SYN && raw.code == SYN_REPORT) {
        // "Кадр" завершён: если что‑то поменялось — генерируем событие.
        if (has_type || (coord_changed && touching_)) {
          event.type = has_type ? next_type : TouchEventType::MOVE;
          event.position = {cur_x_, cur_y_};
          event.id = 0;
          event.time_ms =
              static_cast<std::uint64_t>(raw.time.tv_sec) * 1000ULL +
              static_cast<std::uint64_t>(raw.time.tv_usec) / 1000ULL;
          return true;
        }
 
        // Если никаких значимых изменений не было — читаем дальше.
        coord_changed = false;
        has_type = false;
      }
 
      // Остальные события игнорируем и читаем дальше.
    }
  }
 
 private:
  std::mutex poll_mtx_{};
  std::string path_;
  int fd_;
  int cur_x_{0};
  int cur_y_{0};
  bool touching_{false};
};

struct NkFonts {
  nk_user_font* normal{nullptr};
  nk_user_font* big{nullptr};
  nk_user_font* small{nullptr};
};

struct BackgroundView {
  const std::uint32_t* pixels{nullptr};
  int width{0};
  int height{0};
  int stride{0};  // в пикселях
 
  [[nodiscard]] auto valid() const noexcept -> bool {
    return pixels != nullptr && width > 0 && height > 0 && stride >= width;
  }
};

struct GuiResources {
  NkFonts fonts;
  BackgroundView background;
};

class INkWindow {
 public:
  virtual ~INkWindow() = default;

  virtual auto build_ui(nk_context& ctx, const GuiResources& resources)
      -> void = 0;
 
  virtual auto has_new_data() -> bool = 0;
};

class TinyGui {
 public:
  TinyGui(FramebufferView& fb, ITouchInput& input) noexcept;
  ~TinyGui();

  auto add_window(std::shared_ptr<INkWindow> window) -> void;

  auto clear_windows() -> void;

  auto step() -> void;
  auto is_running() const noexcept -> bool { return running_; }

  auto run(std::uint32_t frame_time_ms = K_DEFAULT_FRAME_TIME_MS) -> void;

  auto stop() noexcept -> void;

  auto set_background_color(const std::uint32_t argb) noexcept -> void {
    background_color_ = argb;
  }

  auto set_use_vsync(const bool value) noexcept -> void { use_vsync_ = value; }

  auto set_use_background_clear(const bool value) noexcept -> void {
    use_background_clear_ = value;
  }
 
 private:
  auto init_nuklear() -> void;
  auto shutdown_nuklear() -> void;

  auto pump_input() -> void;

  auto render_commands() -> void;

  auto clear_background_to(std::uint32_t* dst, int width, int height,
                           int stride) const -> void;

  auto ensure_backbuffer() -> void;

  [[nodiscard]] auto background_view() const -> BackgroundView;
 
  std::thread thread_;
  FramebufferView& fb_;
  ITouchInput& input_;
  std::mutex start_mutex_;
  std::vector<std::shared_ptr<INkWindow>> windows_;
 
  nk_context* ctx_{nullptr};
 
  // Данные атласа шрифта Nuklear.
  std::vector<std::uint8_t> atlas_alpha_;
  int atlas_w_{0};
  int atlas_h_{0};
  nk_user_font* font_normal_{nullptr};
  nk_user_font* font_big_{nullptr};
  nk_user_font* font_small_{nullptr};
 
  // Двойная буферизация и сохранённый фон.
  std::vector<std::uint32_t>
      backbuffer_;  
  std::vector<std::uint32_t>
      saved_background_;               
  bool have_saved_background_{false};  
 
  std::atomic_bool running_{false};
  std::uint32_t background_color_{0xFF202020};  // по умолчанию тёмно-серый фон
  bool use_vsync_{true};
  bool use_background_clear_{
      false};  
 
  int mouse_x_{0};
  int mouse_y_{0};
  bool touch_down_{false};
  std::atomic_bool touch_event_{false};
 
  // Калибровка сырых координат тачскрина под конкретную панель (ilitek_ts
  // vs goodix-ts) - см. TinyGui.cpp::TinyGui() и pump_input(). cal_valid_
  // false означает "координаты не масштабировать" (панель не распознана).
  float cal_scale_x_{1.0f};
  float cal_scale_y_{1.0f};
  bool cal_valid_{false};
};
}  // namespace tinygui
#endif