mirror of
https://github.com/cottongin/cardputerzero-sync.git
synced 2026-11-20 14:44:47 -06:00
feat(device-ui): add 320x170 shadcn Bento UI, modals, and keyboard controller
This commit is contained in:
1364
device-ui/src/app_ui.cpp
Normal file
1364
device-ui/src/app_ui.cpp
Normal file
File diff suppressed because it is too large
Load Diff
49
device-ui/src/app_ui.hpp
Normal file
49
device-ui/src/app_ui.hpp
Normal file
@@ -0,0 +1,49 @@
|
||||
#pragma once
|
||||
|
||||
#include "theme.hpp"
|
||||
#include "ui_controller.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
namespace cp0 {
|
||||
|
||||
/// 320x170 shadcn/ui Zinc Bento Card & Segmented Tabs view renderer.
|
||||
/// Supports LVGL v9 when CP0_HAS_LVGL is defined, and a built-in zero-external-LVGL
|
||||
/// FreeType2 + anti-aliased RGBA framebuffer renderer otherwise.
|
||||
class LvglAppView {
|
||||
public:
|
||||
static constexpr int kWidth = 320;
|
||||
static constexpr int kHeight = 170;
|
||||
|
||||
LvglAppView();
|
||||
~LvglAppView();
|
||||
|
||||
LvglAppView(const LvglAppView&) = delete;
|
||||
LvglAppView& operator=(const LvglAppView&) = delete;
|
||||
|
||||
/// Swap active Zinc Dark / Zinc Light palette tokens without recreating view objects.
|
||||
void apply_theme(ThemeMode mode);
|
||||
|
||||
/// Re-render the 320x170 view from the current UiState.
|
||||
void render(const UiState& state);
|
||||
|
||||
/// Return 320*170 ARGB8888 (0xAARRGGBB) framebuffer pixels.
|
||||
const uint32_t* pixels() const;
|
||||
|
||||
/// Write current 320x170 framebuffer as a binary PPM (P6) image.
|
||||
bool save_ppm(const std::string& path) const;
|
||||
|
||||
/// True if at least one FreeType font (.ttf/.ttc/.otf) was loaded.
|
||||
bool using_freetype() const;
|
||||
|
||||
/// Return currently applied theme mode.
|
||||
ThemeMode active_theme() const;
|
||||
|
||||
private:
|
||||
struct Impl;
|
||||
std::unique_ptr<Impl> impl_;
|
||||
};
|
||||
|
||||
} // namespace cp0
|
||||
676
device-ui/src/main.cpp
Normal file
676
device-ui/src/main.cpp
Normal file
@@ -0,0 +1,676 @@
|
||||
#include "app_ui.hpp"
|
||||
#include "ipc_client.hpp"
|
||||
#include "ui_controller.hpp"
|
||||
|
||||
#include <chrono>
|
||||
#include <csignal>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#if defined(CP0_UI_TARGET_DEVICE) && defined(__linux__)
|
||||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <linux/fb.h>
|
||||
#include <linux/input.h>
|
||||
#include <poll.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/mman.h>
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <SDL.h>
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
volatile std::sig_atomic_t g_signal_stop = 0;
|
||||
|
||||
void handle_signal(int /*sig*/) {
|
||||
g_signal_stop = 1;
|
||||
}
|
||||
|
||||
void print_usage(const char* argv0) {
|
||||
std::cout << "Usage: " << argv0 << " [options]\n"
|
||||
<< " --sim Run desktop 320x170 SDL2 simulator\n"
|
||||
<< " --scale <1..4> Integer window scale factor (default: 1)\n"
|
||||
<< " --render-test <path> Render 320x170 snapshot to PPM file and exit\n"
|
||||
<< " --theme <dark|light> Theme override for --render-test\n"
|
||||
<< " --tab <status|folders|logs> Initial tab for --render-test\n"
|
||||
<< " --help Show this help message\n";
|
||||
}
|
||||
|
||||
cp0::DaemonStatus make_sample_status(const std::string& theme_str) {
|
||||
cp0::DaemonStatus st;
|
||||
st.ok = true;
|
||||
st.target_host = "macbook-pro.ts.net";
|
||||
st.target_port = 8765;
|
||||
st.theme = theme_str;
|
||||
st.mac_online = true;
|
||||
st.mac_dest_root = "/Users/user/Pictures/CardputerZero";
|
||||
st.syncing = false;
|
||||
st.pending_count = 3;
|
||||
st.pending_bytes = 4404019;
|
||||
st.synced_count = 148;
|
||||
st.failed_count = 0;
|
||||
st.last_synced_file = "IMG_0148.JPG";
|
||||
|
||||
cp0::FolderStatus f1;
|
||||
f1.id = "camera";
|
||||
f1.path = "/home/pi/Pictures/DCIM/Camera";
|
||||
f1.label = "Camera";
|
||||
f1.exists = true;
|
||||
f1.pending = 3;
|
||||
f1.synced = 148;
|
||||
st.folders.push_back(f1);
|
||||
|
||||
cp0::FolderStatus f2;
|
||||
f2.id = "sd";
|
||||
f2.path = "/media/pi/SDCARD/DCIM";
|
||||
f2.label = "SD Card";
|
||||
f2.exists = true;
|
||||
f2.pending = 0;
|
||||
f2.synced = 64;
|
||||
st.folders.push_back(f2);
|
||||
|
||||
cp0::LogEntry l1;
|
||||
l1.id = 2;
|
||||
l1.ts = 1731900500000LL;
|
||||
l1.level = "INFO";
|
||||
l1.message = "Synced IMG_0148.JPG (1.4 MB)";
|
||||
cp0::LogEntry l2;
|
||||
l2.id = 1;
|
||||
l2.ts = 1731900490000LL;
|
||||
l2.level = "WARN";
|
||||
l2.message = "Mac sleeping, retry in 10s";
|
||||
st.logs = {l1, l2};
|
||||
return st;
|
||||
}
|
||||
|
||||
bool dispatch_action(
|
||||
const cp0::IpcClient& ipc,
|
||||
cp0::UiController& ctrl,
|
||||
cp0::LvglAppView& view,
|
||||
const cp0::IpcAction& action,
|
||||
bool& running,
|
||||
std::chrono::steady_clock::time_point& feedback_until
|
||||
) {
|
||||
using cp0::ActionType;
|
||||
if (action.type == ActionType::None) {
|
||||
return false;
|
||||
}
|
||||
|
||||
auto set_timed_feedback = [&](const std::string& msg) {
|
||||
ctrl.set_feedback(msg);
|
||||
feedback_until = std::chrono::steady_clock::now() + std::chrono::seconds(3);
|
||||
};
|
||||
|
||||
switch (action.type) {
|
||||
case ActionType::Quit:
|
||||
running = false;
|
||||
return true;
|
||||
case ActionType::SyncNow: {
|
||||
auto res = ipc.sync_now();
|
||||
set_timed_feedback(res.ok ? "Sync triggered" : res.error);
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
return true;
|
||||
}
|
||||
case ActionType::AddFolder: {
|
||||
auto res = ipc.add_folder(action.folder_path, action.folder_label);
|
||||
set_timed_feedback(res.ok ? "Folder added" : res.error);
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
return true;
|
||||
}
|
||||
case ActionType::RemoveFolder: {
|
||||
auto res = ipc.remove_folder(action.folder_id);
|
||||
set_timed_feedback(res.ok ? "Folder removed" : res.error);
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
return true;
|
||||
}
|
||||
case ActionType::SetTarget: {
|
||||
auto res = ipc.set_target(action.target_host, action.target_port);
|
||||
set_timed_feedback(res.ok ? ("Target: " + action.target_host) : res.error);
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
return true;
|
||||
}
|
||||
case ActionType::SetTheme: {
|
||||
view.apply_theme(action.theme);
|
||||
ipc.set_theme(action.theme);
|
||||
return true;
|
||||
}
|
||||
case ActionType::RetryFailed: {
|
||||
auto res = ipc.retry_failed();
|
||||
set_timed_feedback(res.ok ? "Retrying failed files" : res.error);
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
return true;
|
||||
}
|
||||
case ActionType::None:
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
#if defined(CP0_UI_TARGET_DEVICE) && defined(__linux__)
|
||||
|
||||
char map_evdev_code(uint16_t code, bool shift) {
|
||||
switch (code) {
|
||||
case KEY_1: return shift ? '!' : '1';
|
||||
case KEY_2: return shift ? '@' : '2';
|
||||
case KEY_3: return shift ? '#' : '3';
|
||||
case KEY_4: return shift ? '$' : '4';
|
||||
case KEY_5: return shift ? '%' : '5';
|
||||
case KEY_6: return shift ? '^' : '6';
|
||||
case KEY_7: return shift ? '&' : '7';
|
||||
case KEY_8: return shift ? '*' : '8';
|
||||
case KEY_9: return shift ? '(' : '9';
|
||||
case KEY_0: return shift ? ')' : '0';
|
||||
case KEY_A: return shift ? 'A' : 'a';
|
||||
case KEY_B: return shift ? 'B' : 'b';
|
||||
case KEY_C: return shift ? 'C' : 'c';
|
||||
case KEY_D: return shift ? 'D' : 'd';
|
||||
case KEY_E: return shift ? 'E' : 'e';
|
||||
case KEY_F: return shift ? 'F' : 'f';
|
||||
case KEY_G: return shift ? 'G' : 'g';
|
||||
case KEY_H: return shift ? 'H' : 'h';
|
||||
case KEY_I: return shift ? 'I' : 'i';
|
||||
case KEY_J: return shift ? 'J' : 'j';
|
||||
case KEY_K: return shift ? 'K' : 'k';
|
||||
case KEY_L: return shift ? 'L' : 'l';
|
||||
case KEY_M: return shift ? 'M' : 'm';
|
||||
case KEY_N: return shift ? 'N' : 'n';
|
||||
case KEY_O: return shift ? 'O' : 'o';
|
||||
case KEY_P: return shift ? 'P' : 'p';
|
||||
case KEY_Q: return shift ? 'Q' : 'q';
|
||||
case KEY_R: return shift ? 'R' : 'r';
|
||||
case KEY_S: return shift ? 'S' : 's';
|
||||
case KEY_T: return shift ? 'T' : 't';
|
||||
case KEY_U: return shift ? 'U' : 'u';
|
||||
case KEY_V: return shift ? 'V' : 'v';
|
||||
case KEY_W: return shift ? 'W' : 'w';
|
||||
case KEY_X: return shift ? 'X' : 'x';
|
||||
case KEY_Y: return shift ? 'Y' : 'y';
|
||||
case KEY_Z: return shift ? 'Z' : 'z';
|
||||
case KEY_MINUS: return shift ? '_' : '-';
|
||||
case KEY_EQUAL: return shift ? '+' : '=';
|
||||
case KEY_LEFTBRACE: return shift ? '{' : '[';
|
||||
case KEY_RIGHTBRACE: return shift ? '}' : ']';
|
||||
case KEY_SEMICOLON: return shift ? ':' : ';';
|
||||
case KEY_APOSTROPHE: return shift ? '"' : '\'';
|
||||
case KEY_COMMA: return shift ? '<' : ',';
|
||||
case KEY_DOT: return shift ? '>' : '.';
|
||||
case KEY_SLASH: return shift ? '?' : '/';
|
||||
case KEY_BACKSLASH: return shift ? '|' : '\\';
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void blit_fbdev(
|
||||
uint8_t* fb_mem,
|
||||
const fb_var_screeninfo& vinfo,
|
||||
const fb_fix_screeninfo& finfo,
|
||||
const uint32_t* pixels
|
||||
) {
|
||||
int fb_w = static_cast<int>(vinfo.xres);
|
||||
int fb_h = static_cast<int>(vinfo.yres);
|
||||
int copy_w = std::min(fb_w, cp0::LvglAppView::kWidth);
|
||||
int copy_h = std::min(fb_h, cp0::LvglAppView::kHeight);
|
||||
int bpp = static_cast<int>(vinfo.bits_per_pixel);
|
||||
int stride = static_cast<int>(finfo.line_length);
|
||||
|
||||
for (int y = 0; y < copy_h; ++y) {
|
||||
uint8_t* row = fb_mem + (y + static_cast<int>(vinfo.yoffset)) * stride +
|
||||
static_cast<int>(vinfo.xoffset) * (bpp / 8);
|
||||
const uint32_t* src = pixels + y * cp0::LvglAppView::kWidth;
|
||||
if (bpp == 32) {
|
||||
std::memcpy(row, src, static_cast<size_t>(copy_w) * 4);
|
||||
} else if (bpp == 16) {
|
||||
auto* dst16 = reinterpret_cast<uint16_t*>(row);
|
||||
for (int x = 0; x < copy_w; ++x) {
|
||||
uint32_t c = src[x];
|
||||
uint16_t r = static_cast<uint16_t>((c >> 19) & 0x1fU);
|
||||
uint16_t g = static_cast<uint16_t>((c >> 10) & 0x3fU);
|
||||
uint16_t b = static_cast<uint16_t>((c >> 3) & 0x1fU);
|
||||
dst16[x] = static_cast<uint16_t>((r << 11) | (g << 5) | b);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<int> open_keyboard_evdevs() {
|
||||
std::vector<int> fds;
|
||||
if (const char* override_dev = std::getenv("CP0_EVDEV_DEVICE")) {
|
||||
int fd = ::open(override_dev, O_RDONLY | O_NONBLOCK);
|
||||
if (fd >= 0) {
|
||||
fds.push_back(fd);
|
||||
}
|
||||
return fds;
|
||||
}
|
||||
|
||||
DIR* dir = ::opendir("/dev/input");
|
||||
if (dir == nullptr) {
|
||||
return fds;
|
||||
}
|
||||
struct dirent* ent = nullptr;
|
||||
while ((ent = ::readdir(dir)) != nullptr) {
|
||||
if (std::strncmp(ent->d_name, "event", 5) != 0) {
|
||||
continue;
|
||||
}
|
||||
std::string dev_path = std::string("/dev/input/") + ent->d_name;
|
||||
int fd = ::open(dev_path.c_str(), O_RDONLY | O_NONBLOCK);
|
||||
if (fd < 0) {
|
||||
continue;
|
||||
}
|
||||
unsigned long ev_bits[4]{};
|
||||
if (::ioctl(fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) >= 0 &&
|
||||
(ev_bits[0] & (1UL << EV_KEY)) != 0) {
|
||||
fds.push_back(fd);
|
||||
} else {
|
||||
::close(fd);
|
||||
}
|
||||
}
|
||||
::closedir(dir);
|
||||
return fds;
|
||||
}
|
||||
|
||||
int run_device_loop(cp0::IpcClient& ipc, cp0::UiController& ctrl, cp0::LvglAppView& view) {
|
||||
const char* fb_dev = std::getenv("CP0_FB_DEVICE");
|
||||
if (fb_dev == nullptr || fb_dev[0] == '\0') {
|
||||
fb_dev = "/dev/fb0";
|
||||
}
|
||||
int fb_fd = ::open(fb_dev, O_RDWR);
|
||||
if (fb_fd < 0) {
|
||||
std::cerr << "Failed to open framebuffer " << fb_dev << "\n";
|
||||
return 1;
|
||||
}
|
||||
|
||||
fb_var_screeninfo vinfo{};
|
||||
fb_fix_screeninfo finfo{};
|
||||
if (::ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ||
|
||||
::ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) < 0) {
|
||||
std::cerr << "Failed to query framebuffer info\n";
|
||||
::close(fb_fd);
|
||||
return 1;
|
||||
}
|
||||
|
||||
size_t map_size = finfo.smem_len;
|
||||
void* mapped = ::mmap(nullptr, map_size, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
|
||||
if (mapped == MAP_FAILED) {
|
||||
std::cerr << "Failed to mmap framebuffer\n";
|
||||
::close(fb_fd);
|
||||
return 1;
|
||||
}
|
||||
auto* fb_mem = static_cast<uint8_t*>(mapped);
|
||||
|
||||
std::vector<int> ev_fds = open_keyboard_evdevs();
|
||||
std::vector<pollfd> pfds;
|
||||
pfds.reserve(ev_fds.size());
|
||||
for (int fd : ev_fds) {
|
||||
pfds.push_back(pollfd{fd, POLLIN, 0});
|
||||
}
|
||||
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
view.apply_theme(ctrl.state().theme);
|
||||
view.render(ctrl.state());
|
||||
blit_fbdev(fb_mem, vinfo, finfo, view.pixels());
|
||||
|
||||
bool running = true;
|
||||
bool shift_down = false;
|
||||
auto last_poll = std::chrono::steady_clock::now();
|
||||
auto feedback_until = std::chrono::steady_clock::time_point{};
|
||||
|
||||
while (running && !g_signal_stop) {
|
||||
bool dirty = false;
|
||||
if (!pfds.empty()) {
|
||||
int prc = ::poll(pfds.data(), static_cast<nfds_t>(pfds.size()), 50);
|
||||
if (prc > 0) {
|
||||
for (const auto& p : pfds) {
|
||||
if ((p.revents & POLLIN) == 0) {
|
||||
continue;
|
||||
}
|
||||
struct input_event ev{};
|
||||
while (::read(p.fd, &ev, sizeof(ev)) == sizeof(ev)) {
|
||||
if (ev.type != EV_KEY) {
|
||||
continue;
|
||||
}
|
||||
if (ev.code == KEY_LEFTSHIFT || ev.code == KEY_RIGHTSHIFT) {
|
||||
shift_down = (ev.value != 0);
|
||||
continue;
|
||||
}
|
||||
if (ev.value != 1 && ev.value != 2) {
|
||||
continue;
|
||||
}
|
||||
cp0::IpcAction act;
|
||||
bool handled = true;
|
||||
switch (ev.code) {
|
||||
case KEY_UP:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Up);
|
||||
break;
|
||||
case KEY_DOWN:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Down);
|
||||
break;
|
||||
case KEY_LEFT:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Left);
|
||||
break;
|
||||
case KEY_RIGHT:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Right);
|
||||
break;
|
||||
case KEY_ENTER:
|
||||
case KEY_KPENTER:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Enter);
|
||||
break;
|
||||
case KEY_ESC:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Escape);
|
||||
break;
|
||||
case KEY_BACKSPACE:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Backspace);
|
||||
break;
|
||||
case KEY_DELETE:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Delete);
|
||||
break;
|
||||
case KEY_SPACE:
|
||||
act = ctrl.handle_key(' ', cp0::KeyCode::Space);
|
||||
break;
|
||||
default: {
|
||||
char c = map_evdev_code(ev.code, shift_down);
|
||||
if (c != 0) {
|
||||
act = ctrl.handle_key(c, cp0::KeyCode::Char);
|
||||
} else {
|
||||
handled = false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (handled) {
|
||||
dirty = true;
|
||||
if (ctrl.consume_peer_refresh()) {
|
||||
ctrl.set_peers(ipc.list_tailscale_peers());
|
||||
}
|
||||
dispatch_action(ipc, ctrl, view, act, running, feedback_until);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
::usleep(50000);
|
||||
}
|
||||
|
||||
auto now = std::chrono::steady_clock::now();
|
||||
if (!ctrl.state().feedback_banner.empty() && now >= feedback_until) {
|
||||
ctrl.clear_feedback();
|
||||
dirty = true;
|
||||
}
|
||||
if (now - last_poll >= std::chrono::milliseconds(1000)) {
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
last_poll = now;
|
||||
dirty = true;
|
||||
}
|
||||
if (dirty) {
|
||||
view.render(ctrl.state());
|
||||
blit_fbdev(fb_mem, vinfo, finfo, view.pixels());
|
||||
}
|
||||
}
|
||||
|
||||
for (int fd : ev_fds) {
|
||||
::close(fd);
|
||||
}
|
||||
::munmap(mapped, map_size);
|
||||
::close(fb_fd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int run_sdl_loop(
|
||||
cp0::IpcClient& ipc,
|
||||
cp0::UiController& ctrl,
|
||||
cp0::LvglAppView& view,
|
||||
int scale
|
||||
) {
|
||||
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) != 0) {
|
||||
std::cerr << "SDL_Init failed: " << SDL_GetError() << "\n";
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL_Window* window = SDL_CreateWindow(
|
||||
"CardputerZero Photo Sync",
|
||||
SDL_WINDOWPOS_CENTERED,
|
||||
SDL_WINDOWPOS_CENTERED,
|
||||
cp0::LvglAppView::kWidth * scale,
|
||||
cp0::LvglAppView::kHeight * scale,
|
||||
SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE
|
||||
);
|
||||
if (window == nullptr) {
|
||||
std::cerr << "SDL_CreateWindow failed: " << SDL_GetError() << "\n";
|
||||
SDL_Quit();
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL_Renderer* renderer = SDL_CreateRenderer(
|
||||
window,
|
||||
-1,
|
||||
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC
|
||||
);
|
||||
if (renderer == nullptr) {
|
||||
renderer = SDL_CreateRenderer(window, -1, 0);
|
||||
}
|
||||
if (renderer == nullptr) {
|
||||
std::cerr << "SDL_CreateRenderer failed: " << SDL_GetError() << "\n";
|
||||
SDL_DestroyWindow(window);
|
||||
SDL_Quit();
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL_RenderSetLogicalSize(renderer, cp0::LvglAppView::kWidth, cp0::LvglAppView::kHeight);
|
||||
SDL_Texture* texture = SDL_CreateTexture(
|
||||
renderer,
|
||||
SDL_PIXELFORMAT_ARGB8888,
|
||||
SDL_TEXTUREACCESS_STREAMING,
|
||||
cp0::LvglAppView::kWidth,
|
||||
cp0::LvglAppView::kHeight
|
||||
);
|
||||
if (texture == nullptr) {
|
||||
std::cerr << "SDL_CreateTexture failed: " << SDL_GetError() << "\n";
|
||||
SDL_DestroyRenderer(renderer);
|
||||
SDL_DestroyWindow(window);
|
||||
SDL_Quit();
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL_StartTextInput();
|
||||
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
view.apply_theme(ctrl.state().theme);
|
||||
view.render(ctrl.state());
|
||||
|
||||
auto present = [&]() {
|
||||
SDL_UpdateTexture(
|
||||
texture,
|
||||
nullptr,
|
||||
view.pixels(),
|
||||
cp0::LvglAppView::kWidth * static_cast<int>(sizeof(uint32_t))
|
||||
);
|
||||
SDL_RenderClear(renderer);
|
||||
SDL_RenderCopy(renderer, texture, nullptr, nullptr);
|
||||
SDL_RenderPresent(renderer);
|
||||
};
|
||||
present();
|
||||
|
||||
bool running = true;
|
||||
auto last_poll = std::chrono::steady_clock::now();
|
||||
auto feedback_until = std::chrono::steady_clock::time_point{};
|
||||
|
||||
while (running && !g_signal_stop) {
|
||||
bool dirty = false;
|
||||
SDL_Event ev;
|
||||
if (SDL_WaitEventTimeout(&ev, 50) != 0) {
|
||||
do {
|
||||
if (ev.type == SDL_QUIT) {
|
||||
running = false;
|
||||
break;
|
||||
}
|
||||
if (ev.type == SDL_WINDOWEVENT &&
|
||||
(ev.window.event == SDL_WINDOWEVENT_EXPOSED ||
|
||||
ev.window.event == SDL_WINDOWEVENT_RESIZED)) {
|
||||
dirty = true;
|
||||
continue;
|
||||
}
|
||||
if (ev.type == SDL_TEXTINPUT) {
|
||||
for (int i = 0; ev.text.text[i] != '\0'; ++i) {
|
||||
char ch = ev.text.text[i];
|
||||
cp0::IpcAction act = ctrl.handle_key(ch, cp0::KeyCode::Char);
|
||||
dirty = true;
|
||||
if (ctrl.consume_peer_refresh()) {
|
||||
ctrl.set_peers(ipc.list_tailscale_peers());
|
||||
}
|
||||
dispatch_action(ipc, ctrl, view, act, running, feedback_until);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (ev.type == SDL_KEYDOWN) {
|
||||
SDL_Keycode sym = ev.key.keysym.sym;
|
||||
uint16_t mod = ev.key.keysym.mod;
|
||||
if ((mod & (KMOD_CTRL | KMOD_GUI)) != 0 && sym == SDLK_q) {
|
||||
running = false;
|
||||
break;
|
||||
}
|
||||
cp0::IpcAction act;
|
||||
bool handled = true;
|
||||
switch (sym) {
|
||||
case SDLK_UP:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Up);
|
||||
break;
|
||||
case SDLK_DOWN:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Down);
|
||||
break;
|
||||
case SDLK_LEFT:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Left);
|
||||
break;
|
||||
case SDLK_RIGHT:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Right);
|
||||
break;
|
||||
case SDLK_RETURN:
|
||||
case SDLK_KP_ENTER:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Enter);
|
||||
break;
|
||||
case SDLK_ESCAPE:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Escape);
|
||||
break;
|
||||
case SDLK_BACKSPACE:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Backspace);
|
||||
break;
|
||||
case SDLK_DELETE:
|
||||
act = ctrl.handle_key(0, cp0::KeyCode::Delete);
|
||||
break;
|
||||
default:
|
||||
handled = false;
|
||||
break;
|
||||
}
|
||||
if (handled) {
|
||||
dirty = true;
|
||||
if (ctrl.consume_peer_refresh()) {
|
||||
ctrl.set_peers(ipc.list_tailscale_peers());
|
||||
}
|
||||
dispatch_action(ipc, ctrl, view, act, running, feedback_until);
|
||||
}
|
||||
}
|
||||
} while (running && SDL_PollEvent(&ev) != 0);
|
||||
}
|
||||
|
||||
auto now = std::chrono::steady_clock::now();
|
||||
if (!ctrl.state().feedback_banner.empty() && now >= feedback_until) {
|
||||
ctrl.clear_feedback();
|
||||
dirty = true;
|
||||
}
|
||||
if (now - last_poll >= std::chrono::milliseconds(1000)) {
|
||||
ctrl.update_status(ipc.fetch_status());
|
||||
last_poll = now;
|
||||
dirty = true;
|
||||
}
|
||||
if (running && dirty) {
|
||||
view.render(ctrl.state());
|
||||
present();
|
||||
}
|
||||
}
|
||||
|
||||
SDL_StopTextInput();
|
||||
SDL_DestroyTexture(texture);
|
||||
SDL_DestroyRenderer(renderer);
|
||||
SDL_DestroyWindow(window);
|
||||
SDL_Quit();
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
std::signal(SIGINT, handle_signal);
|
||||
std::signal(SIGTERM, handle_signal);
|
||||
|
||||
int scale = 1;
|
||||
std::string render_test_path;
|
||||
std::string render_theme = "dark";
|
||||
std::string render_tab = "status";
|
||||
|
||||
for (int i = 1; i < argc; ++i) {
|
||||
std::string arg = argv[i];
|
||||
if (arg == "--help" || arg == "-h") {
|
||||
print_usage(argv[0]);
|
||||
return 0;
|
||||
}
|
||||
if (arg == "--sim") {
|
||||
continue;
|
||||
}
|
||||
if (arg == "--scale" && i + 1 < argc) {
|
||||
int parsed = std::atoi(argv[++i]);
|
||||
if (parsed >= 1 && parsed <= 4) {
|
||||
scale = parsed;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (arg == "--render-test" && i + 1 < argc) {
|
||||
render_test_path = argv[++i];
|
||||
continue;
|
||||
}
|
||||
if (arg == "--theme" && i + 1 < argc) {
|
||||
render_theme = argv[++i];
|
||||
continue;
|
||||
}
|
||||
if (arg == "--tab" && i + 1 < argc) {
|
||||
render_tab = argv[++i];
|
||||
continue;
|
||||
}
|
||||
std::cerr << "Unknown option: " << arg << "\n";
|
||||
print_usage(argv[0]);
|
||||
return 2;
|
||||
}
|
||||
|
||||
cp0::UiController ctrl;
|
||||
cp0::LvglAppView view;
|
||||
|
||||
if (!render_test_path.empty()) {
|
||||
ctrl.update_status(make_sample_status(render_theme));
|
||||
if (render_tab == "folders") {
|
||||
ctrl.handle_key('2', cp0::KeyCode::Char);
|
||||
} else if (render_tab == "logs") {
|
||||
ctrl.handle_key('3', cp0::KeyCode::Char);
|
||||
}
|
||||
view.apply_theme(ctrl.state().theme);
|
||||
view.render(ctrl.state());
|
||||
if (!view.save_ppm(render_test_path)) {
|
||||
std::cerr << "Failed to write PPM to " << render_test_path << "\n";
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
cp0::IpcClient ipc;
|
||||
#if defined(CP0_UI_TARGET_DEVICE) && defined(__linux__)
|
||||
(void)scale;
|
||||
return run_device_loop(ipc, ctrl, view);
|
||||
#else
|
||||
return run_sdl_loop(ipc, ctrl, view, scale);
|
||||
#endif
|
||||
}
|
||||
658
device-ui/src/ui_controller.cpp
Normal file
658
device-ui/src/ui_controller.cpp
Normal file
@@ -0,0 +1,658 @@
|
||||
#include "ui_controller.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cstdlib>
|
||||
#include <filesystem>
|
||||
#include <system_error>
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
namespace cp0 {
|
||||
|
||||
namespace {
|
||||
|
||||
std::string trim_ascii(const std::string& s) {
|
||||
size_t start = 0;
|
||||
while (start < s.size() && std::isspace(static_cast<unsigned char>(s[start]))) {
|
||||
++start;
|
||||
}
|
||||
size_t end = s.size();
|
||||
while (end > start && std::isspace(static_cast<unsigned char>(s[end - 1]))) {
|
||||
--end;
|
||||
}
|
||||
return s.substr(start, end - start);
|
||||
}
|
||||
|
||||
std::string to_lower_ascii(std::string s) {
|
||||
for (char& ch : s) {
|
||||
ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
std::string expand_tilde(const std::string& path) {
|
||||
if (path.empty() || path[0] != '~') {
|
||||
return path;
|
||||
}
|
||||
if (path.size() == 1 || path[1] == '/') {
|
||||
const char* home = std::getenv("HOME");
|
||||
if (home != nullptr && home[0] != '\0') {
|
||||
return std::string(home) + path.substr(1);
|
||||
}
|
||||
}
|
||||
return path;
|
||||
}
|
||||
|
||||
bool is_valid_dir(const std::string& path) {
|
||||
if (path.empty()) {
|
||||
return false;
|
||||
}
|
||||
std::error_code ec;
|
||||
return fs::is_directory(fs::path(path), ec);
|
||||
}
|
||||
|
||||
bool parse_strict_port(const std::string& s, int& port_out) {
|
||||
if (s.empty()) {
|
||||
return false;
|
||||
}
|
||||
long val = 0;
|
||||
for (char ch : s) {
|
||||
if (!std::isdigit(static_cast<unsigned char>(ch))) {
|
||||
return false;
|
||||
}
|
||||
val = val * 10 + (ch - '0');
|
||||
if (val > 65535) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (val < 1 || val > 65535) {
|
||||
return false;
|
||||
}
|
||||
port_out = static_cast<int>(val);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool parse_host_port(
|
||||
const std::string& raw,
|
||||
std::string& host_out,
|
||||
int& port_out,
|
||||
std::string& err_out
|
||||
) {
|
||||
std::string trimmed = trim_ascii(raw);
|
||||
if (trimmed.empty()) {
|
||||
err_out = "Host cannot be empty";
|
||||
return false;
|
||||
}
|
||||
|
||||
port_out = 8765;
|
||||
if (trimmed.front() == '[') {
|
||||
size_t close = trimmed.find(']');
|
||||
if (close == std::string::npos || close <= 1) {
|
||||
err_out = "Invalid bracketed host";
|
||||
return false;
|
||||
}
|
||||
host_out = trimmed.substr(1, close - 1);
|
||||
if (close + 1 < trimmed.size()) {
|
||||
if (trimmed[close + 1] != ':') {
|
||||
err_out = "Invalid host:port syntax";
|
||||
return false;
|
||||
}
|
||||
if (!parse_strict_port(trimmed.substr(close + 2), port_out)) {
|
||||
err_out = "Port must be 1..65535";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
size_t first_colon = trimmed.find(':');
|
||||
size_t last_colon = trimmed.rfind(':');
|
||||
if (first_colon != std::string::npos && first_colon == last_colon) {
|
||||
host_out = trim_ascii(trimmed.substr(0, first_colon));
|
||||
std::string port_str = trim_ascii(trimmed.substr(first_colon + 1));
|
||||
if (!parse_strict_port(port_str, port_out)) {
|
||||
err_out = "Port must be 1..65535";
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
host_out = trimmed;
|
||||
}
|
||||
}
|
||||
|
||||
if (host_out.empty() || host_out.find('/') != std::string::npos) {
|
||||
err_out = "Invalid target host";
|
||||
return false;
|
||||
}
|
||||
for (char ch : host_out) {
|
||||
if (std::isspace(static_cast<unsigned char>(ch))) {
|
||||
err_out = "Host cannot contain spaces";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string resolve_peer_host(const TailscalePeer& peer) {
|
||||
if (!peer.dns_name.empty()) {
|
||||
return peer.dns_name;
|
||||
}
|
||||
if (!peer.tailscale_ips.empty()) {
|
||||
return peer.tailscale_ips[0];
|
||||
}
|
||||
return peer.hostname;
|
||||
}
|
||||
|
||||
KeyCode normalize_key(char ch, KeyCode key) {
|
||||
if (key != KeyCode::Char) {
|
||||
return key;
|
||||
}
|
||||
if (ch == ' ') {
|
||||
return KeyCode::Space;
|
||||
}
|
||||
if (ch == '\n' || ch == '\r') {
|
||||
return KeyCode::Enter;
|
||||
}
|
||||
if (ch == '\b' || static_cast<unsigned char>(ch) == 0x7f) {
|
||||
return KeyCode::Backspace;
|
||||
}
|
||||
if (static_cast<unsigned char>(ch) == 0x1b) {
|
||||
return KeyCode::Escape;
|
||||
}
|
||||
return KeyCode::Char;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void UiController::update_status(const DaemonStatus& status) {
|
||||
state_.status = status;
|
||||
|
||||
if (status.ok && !status.theme.empty()) {
|
||||
if (!initial_status_applied_) {
|
||||
state_.theme = theme_from_string(status.theme);
|
||||
initial_status_applied_ = true;
|
||||
last_daemon_theme_ = status.theme;
|
||||
} else if (status.theme != last_daemon_theme_) {
|
||||
state_.theme = theme_from_string(status.theme);
|
||||
last_daemon_theme_ = status.theme;
|
||||
}
|
||||
}
|
||||
|
||||
if (state_.status.folders.empty()) {
|
||||
state_.folder_cursor = 0;
|
||||
} else if (state_.folder_cursor >= static_cast<int>(state_.status.folders.size())) {
|
||||
state_.folder_cursor = static_cast<int>(state_.status.folders.size()) - 1;
|
||||
} else if (state_.folder_cursor < 0) {
|
||||
state_.folder_cursor = 0;
|
||||
}
|
||||
|
||||
if (state_.status.logs.empty()) {
|
||||
state_.log_scroll = 0;
|
||||
} else if (state_.log_scroll >= static_cast<int>(state_.status.logs.size())) {
|
||||
state_.log_scroll = static_cast<int>(state_.status.logs.size()) - 1;
|
||||
} else if (state_.log_scroll < 0) {
|
||||
state_.log_scroll = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void UiController::set_peers(const std::vector<TailscalePeer>& peers) {
|
||||
state_.peers = peers;
|
||||
state_.needs_peer_refresh = false;
|
||||
if (state_.peers.empty()) {
|
||||
state_.peer_cursor = 0;
|
||||
} else if (state_.peer_cursor >= static_cast<int>(state_.peers.size())) {
|
||||
state_.peer_cursor = static_cast<int>(state_.peers.size()) - 1;
|
||||
} else if (state_.peer_cursor < 0) {
|
||||
state_.peer_cursor = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void UiController::set_dir_picker_start_path(const std::string& path) {
|
||||
dir_picker_start_path_ = path;
|
||||
}
|
||||
|
||||
void UiController::set_feedback(const std::string& message) {
|
||||
state_.feedback_banner = message;
|
||||
}
|
||||
|
||||
void UiController::clear_feedback() {
|
||||
state_.feedback_banner.clear();
|
||||
}
|
||||
|
||||
bool UiController::consume_peer_refresh() {
|
||||
bool v = state_.needs_peer_refresh;
|
||||
state_.needs_peer_refresh = false;
|
||||
return v;
|
||||
}
|
||||
|
||||
IpcAction UiController::handle_key(char ch, KeyCode key) {
|
||||
if (state_.modal == ModalKind::TextInput) {
|
||||
return handle_text_input_key(ch, key);
|
||||
}
|
||||
|
||||
KeyCode norm = normalize_key(ch, key);
|
||||
switch (state_.modal) {
|
||||
case ModalKind::None:
|
||||
return handle_global_key(ch, norm);
|
||||
case ModalKind::TargetPicker:
|
||||
return handle_target_picker_key(ch, norm);
|
||||
case ModalKind::DirPicker:
|
||||
return handle_dir_picker_key(ch, norm);
|
||||
case ModalKind::ConfirmRemove:
|
||||
return handle_confirm_remove_key(ch, norm);
|
||||
case ModalKind::TextInput:
|
||||
return handle_text_input_key(ch, key);
|
||||
}
|
||||
return IpcAction{};
|
||||
}
|
||||
|
||||
void UiController::open_target_picker() {
|
||||
state_.modal = ModalKind::TargetPicker;
|
||||
state_.peer_cursor = 0;
|
||||
state_.modal_error.clear();
|
||||
state_.needs_peer_refresh = true;
|
||||
}
|
||||
|
||||
void UiController::open_dir_picker() {
|
||||
std::string start = "/";
|
||||
if (is_valid_dir(dir_picker_start_path_)) {
|
||||
start = dir_picker_start_path_;
|
||||
} else {
|
||||
const char* home = std::getenv("HOME");
|
||||
if (home != nullptr && is_valid_dir(home)) {
|
||||
start = home;
|
||||
}
|
||||
}
|
||||
state_.modal = ModalKind::DirPicker;
|
||||
state_.modal_error.clear();
|
||||
load_directory(start);
|
||||
}
|
||||
|
||||
void UiController::load_directory(const std::string& path, const std::string& select_name) {
|
||||
std::error_code ec;
|
||||
fs::path resolved = fs::weakly_canonical(fs::path(path), ec);
|
||||
if (ec || resolved.empty()) {
|
||||
resolved = fs::path(path);
|
||||
}
|
||||
|
||||
state_.dir_current_path = resolved.string();
|
||||
state_.dir_entries.clear();
|
||||
|
||||
fs::directory_iterator it(
|
||||
resolved,
|
||||
fs::directory_options::skip_permission_denied,
|
||||
ec
|
||||
);
|
||||
if (!ec) {
|
||||
for (const auto& entry : it) {
|
||||
std::error_code entry_ec;
|
||||
if (!entry.is_directory(entry_ec) || entry_ec) {
|
||||
continue;
|
||||
}
|
||||
std::string name = entry.path().filename().string();
|
||||
if (name.empty() || name[0] == '.') {
|
||||
continue;
|
||||
}
|
||||
state_.dir_entries.push_back(entry.path().string());
|
||||
}
|
||||
}
|
||||
|
||||
std::sort(
|
||||
state_.dir_entries.begin(),
|
||||
state_.dir_entries.end(),
|
||||
[](const std::string& a, const std::string& b) {
|
||||
std::string na = fs::path(a).filename().string();
|
||||
std::string nb = fs::path(b).filename().string();
|
||||
std::string la = to_lower_ascii(na);
|
||||
std::string lb = to_lower_ascii(nb);
|
||||
if (la != lb) {
|
||||
return la < lb;
|
||||
}
|
||||
return na < nb;
|
||||
}
|
||||
);
|
||||
|
||||
if (state_.dir_entries.empty()) {
|
||||
state_.dir_cursor = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
state_.dir_cursor = 0;
|
||||
if (!select_name.empty()) {
|
||||
for (size_t i = 0; i < state_.dir_entries.size(); ++i) {
|
||||
if (fs::path(state_.dir_entries[i]).filename().string() == select_name) {
|
||||
state_.dir_cursor = static_cast<int>(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void UiController::open_text_input(TextInputPurpose purpose) {
|
||||
state_.modal = ModalKind::TextInput;
|
||||
state_.text_purpose = purpose;
|
||||
state_.text_buffer.clear();
|
||||
state_.modal_error.clear();
|
||||
}
|
||||
|
||||
void UiController::close_modal() {
|
||||
state_.modal = ModalKind::None;
|
||||
state_.text_purpose = TextInputPurpose::None;
|
||||
state_.text_buffer.clear();
|
||||
state_.modal_error.clear();
|
||||
state_.confirm_folder_id.clear();
|
||||
state_.confirm_folder_path.clear();
|
||||
state_.confirm_folder_label.clear();
|
||||
}
|
||||
|
||||
IpcAction UiController::handle_global_key(char ch, KeyCode key) {
|
||||
IpcAction action;
|
||||
|
||||
if (key == KeyCode::Escape) {
|
||||
action.type = ActionType::Quit;
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Enter) {
|
||||
action.type = ActionType::SyncNow;
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Left) {
|
||||
int idx = static_cast<int>(state_.tab);
|
||||
state_.tab = static_cast<ActiveTab>((idx + 2) % 3);
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Right) {
|
||||
int idx = static_cast<int>(state_.tab);
|
||||
state_.tab = static_cast<ActiveTab>((idx + 1) % 3);
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Up || (key == KeyCode::Char && std::tolower(static_cast<unsigned char>(ch)) == 'k')) {
|
||||
if (state_.tab == ActiveTab::Folders && state_.folder_cursor > 0) {
|
||||
--state_.folder_cursor;
|
||||
} else if (state_.tab == ActiveTab::Logs && state_.log_scroll > 0) {
|
||||
--state_.log_scroll;
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Down || (key == KeyCode::Char && std::tolower(static_cast<unsigned char>(ch)) == 'j')) {
|
||||
if (state_.tab == ActiveTab::Folders) {
|
||||
int max_idx = static_cast<int>(state_.status.folders.size()) - 1;
|
||||
if (state_.folder_cursor < max_idx) {
|
||||
++state_.folder_cursor;
|
||||
}
|
||||
} else if (state_.tab == ActiveTab::Logs) {
|
||||
int max_idx = static_cast<int>(state_.status.logs.size()) - 1;
|
||||
if (state_.log_scroll < max_idx) {
|
||||
++state_.log_scroll;
|
||||
}
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Delete) {
|
||||
if (state_.tab == ActiveTab::Folders && !state_.status.folders.empty()) {
|
||||
const auto& f = state_.status.folders[static_cast<size_t>(state_.folder_cursor)];
|
||||
state_.confirm_folder_id = f.id;
|
||||
state_.confirm_folder_path = f.path;
|
||||
state_.confirm_folder_label = f.label;
|
||||
state_.modal = ModalKind::ConfirmRemove;
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key != KeyCode::Char) {
|
||||
return action;
|
||||
}
|
||||
|
||||
char lower = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
|
||||
switch (lower) {
|
||||
case '1':
|
||||
state_.tab = ActiveTab::Status;
|
||||
break;
|
||||
case '2':
|
||||
state_.tab = ActiveTab::Folders;
|
||||
break;
|
||||
case '3':
|
||||
state_.tab = ActiveTab::Logs;
|
||||
break;
|
||||
case 't':
|
||||
state_.theme = toggle_theme(state_.theme);
|
||||
action.type = ActionType::SetTheme;
|
||||
action.theme = state_.theme;
|
||||
break;
|
||||
case 'q':
|
||||
action.type = ActionType::Quit;
|
||||
break;
|
||||
case 'c':
|
||||
if (state_.tab == ActiveTab::Status) {
|
||||
open_target_picker();
|
||||
}
|
||||
break;
|
||||
case 'a':
|
||||
if (state_.tab == ActiveTab::Folders) {
|
||||
open_dir_picker();
|
||||
}
|
||||
break;
|
||||
case 'd':
|
||||
if (state_.tab == ActiveTab::Folders && !state_.status.folders.empty()) {
|
||||
const auto& f = state_.status.folders[static_cast<size_t>(state_.folder_cursor)];
|
||||
state_.confirm_folder_id = f.id;
|
||||
state_.confirm_folder_path = f.path;
|
||||
state_.confirm_folder_label = f.label;
|
||||
state_.modal = ModalKind::ConfirmRemove;
|
||||
}
|
||||
break;
|
||||
case 'r':
|
||||
if (state_.tab == ActiveTab::Logs) {
|
||||
action.type = ActionType::RetryFailed;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return action;
|
||||
}
|
||||
|
||||
IpcAction UiController::handle_target_picker_key(char ch, KeyCode key) {
|
||||
IpcAction action;
|
||||
|
||||
if (key == KeyCode::Escape) {
|
||||
close_modal();
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Up || (key == KeyCode::Char && std::tolower(static_cast<unsigned char>(ch)) == 'k')) {
|
||||
if (state_.peer_cursor > 0) {
|
||||
--state_.peer_cursor;
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Down || (key == KeyCode::Char && std::tolower(static_cast<unsigned char>(ch)) == 'j')) {
|
||||
int max_idx = static_cast<int>(state_.peers.size()) - 1;
|
||||
if (state_.peer_cursor < max_idx) {
|
||||
++state_.peer_cursor;
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Enter) {
|
||||
if (!state_.peers.empty() && state_.peer_cursor >= 0 &&
|
||||
state_.peer_cursor < static_cast<int>(state_.peers.size())) {
|
||||
std::string host = resolve_peer_host(state_.peers[static_cast<size_t>(state_.peer_cursor)]);
|
||||
if (!host.empty()) {
|
||||
action.type = ActionType::SetTarget;
|
||||
action.target_host = host;
|
||||
action.target_port = 8765;
|
||||
close_modal();
|
||||
}
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Char && std::tolower(static_cast<unsigned char>(ch)) == 't') {
|
||||
open_text_input(TextInputPurpose::TargetHost);
|
||||
}
|
||||
|
||||
return action;
|
||||
}
|
||||
|
||||
IpcAction UiController::handle_dir_picker_key(char ch, KeyCode key) {
|
||||
IpcAction action;
|
||||
|
||||
if (key == KeyCode::Escape) {
|
||||
close_modal();
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Up || (key == KeyCode::Char && std::tolower(static_cast<unsigned char>(ch)) == 'k')) {
|
||||
if (state_.dir_cursor > 0) {
|
||||
--state_.dir_cursor;
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Down || (key == KeyCode::Char && std::tolower(static_cast<unsigned char>(ch)) == 'j')) {
|
||||
int max_idx = static_cast<int>(state_.dir_entries.size()) - 1;
|
||||
if (state_.dir_cursor < max_idx) {
|
||||
++state_.dir_cursor;
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Enter) {
|
||||
if (state_.dir_cursor >= 0 &&
|
||||
state_.dir_cursor < static_cast<int>(state_.dir_entries.size())) {
|
||||
load_directory(state_.dir_entries[static_cast<size_t>(state_.dir_cursor)]);
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Backspace) {
|
||||
fs::path cur(state_.dir_current_path);
|
||||
fs::path parent = cur.parent_path();
|
||||
if (!parent.empty() && parent != cur) {
|
||||
load_directory(parent.string(), cur.filename().string());
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Space) {
|
||||
std::string chosen = state_.dir_current_path;
|
||||
if (state_.dir_cursor >= 0 &&
|
||||
state_.dir_cursor < static_cast<int>(state_.dir_entries.size())) {
|
||||
chosen = state_.dir_entries[static_cast<size_t>(state_.dir_cursor)];
|
||||
}
|
||||
if (!chosen.empty()) {
|
||||
action.type = ActionType::AddFolder;
|
||||
action.folder_path = chosen;
|
||||
close_modal();
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Char) {
|
||||
char lower = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
|
||||
if (lower == 't') {
|
||||
open_text_input(TextInputPurpose::FolderPath);
|
||||
} else if (lower == '.') {
|
||||
if (!state_.dir_current_path.empty()) {
|
||||
action.type = ActionType::AddFolder;
|
||||
action.folder_path = state_.dir_current_path;
|
||||
close_modal();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return action;
|
||||
}
|
||||
|
||||
IpcAction UiController::handle_confirm_remove_key(char ch, KeyCode key) {
|
||||
IpcAction action;
|
||||
|
||||
if (key == KeyCode::Escape) {
|
||||
close_modal();
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Char) {
|
||||
char lower = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
|
||||
if (lower == 'y') {
|
||||
action.type = ActionType::RemoveFolder;
|
||||
action.folder_id = state_.confirm_folder_id;
|
||||
close_modal();
|
||||
} else if (lower == 'n') {
|
||||
close_modal();
|
||||
}
|
||||
}
|
||||
|
||||
return action;
|
||||
}
|
||||
|
||||
IpcAction UiController::handle_text_input_key(char ch, KeyCode key) {
|
||||
IpcAction action;
|
||||
|
||||
if (key == KeyCode::Escape || (key == KeyCode::Char && static_cast<unsigned char>(ch) == 0x1b)) {
|
||||
close_modal();
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Backspace ||
|
||||
(key == KeyCode::Char && (ch == '\b' || static_cast<unsigned char>(ch) == 0x7f))) {
|
||||
if (!state_.text_buffer.empty()) {
|
||||
state_.text_buffer.pop_back();
|
||||
state_.modal_error.clear();
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Enter || (key == KeyCode::Char && (ch == '\n' || ch == '\r'))) {
|
||||
if (state_.text_purpose == TextInputPurpose::TargetHost) {
|
||||
std::string host;
|
||||
int port = 8765;
|
||||
std::string err;
|
||||
if (!parse_host_port(state_.text_buffer, host, port, err)) {
|
||||
state_.modal_error = err;
|
||||
return action;
|
||||
}
|
||||
action.type = ActionType::SetTarget;
|
||||
action.target_host = host;
|
||||
action.target_port = port;
|
||||
close_modal();
|
||||
} else if (state_.text_purpose == TextInputPurpose::FolderPath) {
|
||||
std::string path = expand_tilde(trim_ascii(state_.text_buffer));
|
||||
if (path.empty()) {
|
||||
state_.modal_error = "Path cannot be empty";
|
||||
return action;
|
||||
}
|
||||
action.type = ActionType::AddFolder;
|
||||
action.folder_path = path;
|
||||
close_modal();
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Space) {
|
||||
if (state_.text_buffer.size() < 256) {
|
||||
state_.text_buffer.push_back(' ');
|
||||
state_.modal_error.clear();
|
||||
}
|
||||
return action;
|
||||
}
|
||||
|
||||
if (key == KeyCode::Char) {
|
||||
unsigned char uch = static_cast<unsigned char>(ch);
|
||||
if (uch >= 0x20 && uch <= 0x7e && state_.text_buffer.size() < 256) {
|
||||
state_.text_buffer.push_back(ch);
|
||||
state_.modal_error.clear();
|
||||
}
|
||||
}
|
||||
|
||||
return action;
|
||||
}
|
||||
|
||||
} // namespace cp0
|
||||
145
device-ui/src/ui_controller.hpp
Normal file
145
device-ui/src/ui_controller.hpp
Normal file
@@ -0,0 +1,145 @@
|
||||
#pragma once
|
||||
|
||||
#include "ipc_client.hpp"
|
||||
#include "theme.hpp"
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace cp0 {
|
||||
|
||||
/// Top-level segmented tab views on the 320x170 UI.
|
||||
enum class ActiveTab {
|
||||
Status = 0,
|
||||
Folders = 1,
|
||||
Logs = 2,
|
||||
};
|
||||
|
||||
/// Active overlay modal state.
|
||||
enum class ModalKind {
|
||||
None,
|
||||
TargetPicker,
|
||||
DirPicker,
|
||||
ConfirmRemove,
|
||||
TextInput,
|
||||
};
|
||||
|
||||
/// Purpose of the shared TextInput modal.
|
||||
enum class TextInputPurpose {
|
||||
None,
|
||||
TargetHost,
|
||||
FolderPath,
|
||||
};
|
||||
|
||||
/// Normalized physical/simulator key events handled by UiController.
|
||||
enum class KeyCode {
|
||||
Char,
|
||||
Enter,
|
||||
Escape,
|
||||
Up,
|
||||
Down,
|
||||
Left,
|
||||
Right,
|
||||
Backspace,
|
||||
Delete,
|
||||
Space,
|
||||
};
|
||||
|
||||
/// Side-effect actions emitted by UiController for the event loop / IPC client.
|
||||
enum class ActionType {
|
||||
None,
|
||||
Quit,
|
||||
SyncNow,
|
||||
AddFolder,
|
||||
RemoveFolder,
|
||||
SetTarget,
|
||||
SetTheme,
|
||||
RetryFailed,
|
||||
};
|
||||
|
||||
/// Structured command emitted by UiController::handle_key.
|
||||
struct IpcAction {
|
||||
ActionType type = ActionType::None;
|
||||
std::string target_host;
|
||||
int target_port = 8765;
|
||||
std::string folder_path;
|
||||
std::string folder_label;
|
||||
std::string folder_id;
|
||||
ThemeMode theme = ThemeMode::Dark;
|
||||
};
|
||||
|
||||
/// Complete view-model state rendered by LvglAppView.
|
||||
struct UiState {
|
||||
ActiveTab tab = ActiveTab::Status;
|
||||
ThemeMode theme = ThemeMode::Dark;
|
||||
ModalKind modal = ModalKind::None;
|
||||
TextInputPurpose text_purpose = TextInputPurpose::None;
|
||||
|
||||
DaemonStatus status;
|
||||
std::vector<TailscalePeer> peers;
|
||||
int peer_cursor = 0;
|
||||
|
||||
int folder_cursor = 0;
|
||||
int log_scroll = 0;
|
||||
|
||||
std::string dir_current_path;
|
||||
std::vector<std::string> dir_entries;
|
||||
int dir_cursor = -1;
|
||||
|
||||
std::string confirm_folder_id;
|
||||
std::string confirm_folder_path;
|
||||
std::string confirm_folder_label;
|
||||
|
||||
std::string text_buffer;
|
||||
std::string modal_error;
|
||||
std::string feedback_banner;
|
||||
|
||||
bool needs_peer_refresh = false;
|
||||
};
|
||||
|
||||
/// Pure keyboard-first UI state machine decoupled from graphics/display backends.
|
||||
class UiController {
|
||||
public:
|
||||
UiController() = default;
|
||||
|
||||
const UiState& state() const { return state_; }
|
||||
|
||||
/// Apply a freshly polled DaemonStatus snapshot, preserving active cursors safely.
|
||||
void update_status(const DaemonStatus& status);
|
||||
|
||||
/// Populate Tailscale peers for TargetPicker.
|
||||
void set_peers(const std::vector<TailscalePeer>& peers);
|
||||
|
||||
/// Override starting directory for DirPicker (defaults to $HOME or /).
|
||||
void set_dir_picker_start_path(const std::string& path);
|
||||
|
||||
/// Set or clear transient status feedback displayed in the UI.
|
||||
void set_feedback(const std::string& message);
|
||||
void clear_feedback();
|
||||
|
||||
/// Return true once when TargetPicker was opened and needs peer discovery.
|
||||
bool consume_peer_refresh();
|
||||
|
||||
/// Process a normalized key event and return any resulting IPC/lifecycle action.
|
||||
IpcAction handle_key(char ch, KeyCode key = KeyCode::Char);
|
||||
|
||||
private:
|
||||
void open_target_picker();
|
||||
void open_dir_picker();
|
||||
void load_directory(const std::string& path, const std::string& select_name = "");
|
||||
void open_text_input(TextInputPurpose purpose);
|
||||
void close_modal();
|
||||
|
||||
IpcAction handle_global_key(char ch, KeyCode key);
|
||||
IpcAction handle_target_picker_key(char ch, KeyCode key);
|
||||
IpcAction handle_dir_picker_key(char ch, KeyCode key);
|
||||
IpcAction handle_confirm_remove_key(char ch, KeyCode key);
|
||||
IpcAction handle_text_input_key(char ch, KeyCode key);
|
||||
|
||||
UiState state_;
|
||||
std::string dir_picker_start_path_;
|
||||
bool initial_status_applied_ = false;
|
||||
std::string last_daemon_theme_;
|
||||
};
|
||||
|
||||
} // namespace cp0
|
||||
Reference in New Issue
Block a user