feat(device-ui): add 320x170 shadcn Bento UI, modals, and keyboard controller

This commit is contained in:
2026-11-18 08:40:56 -05:00
parent 8ea46a26ae
commit 7d369b2c35
7 changed files with 3428 additions and 1 deletions

View File

@@ -11,10 +11,26 @@ option(CP0_UI_TARGET_DEVICE "Target CardputerZero Linux fbdev/evdev instead of S
find_package(SQLite3 REQUIRED)
find_package(Threads REQUIRED)
find_package(PkgConfig QUIET)
# Optional LVGL v9 discovery (never download over network via FetchContent)
set(CP0_LVGL_TARGET "")
find_package(lvgl QUIET)
if(TARGET lvgl::lvgl)
set(CP0_LVGL_TARGET lvgl::lvgl)
elseif(TARGET lvgl)
set(CP0_LVGL_TARGET lvgl)
elseif(PkgConfig_FOUND)
pkg_check_modules(LVGL QUIET IMPORTED_TARGET lvgl)
if(TARGET PkgConfig::LVGL)
set(CP0_LVGL_TARGET PkgConfig::LVGL)
endif()
endif()
add_library(cp0_ui_core STATIC
src/theme.cpp
src/ipc_client.cpp
src/ui_controller.cpp
)
target_include_directories(cp0_ui_core PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/src
@@ -27,7 +43,70 @@ endif()
target_compile_options(cp0_ui_core PRIVATE -Wall -Wextra -Wpedantic)
if(CP0_UI_BUILD_APP)
message(STATUS "CP0_UI_BUILD_APP=ON: app target will be configured in Task 6")
set(CP0_FREETYPE_TARGET "")
find_package(Freetype QUIET)
if(TARGET Freetype::Freetype)
set(CP0_FREETYPE_TARGET Freetype::Freetype)
elseif(PkgConfig_FOUND)
pkg_check_modules(FREETYPE QUIET IMPORTED_TARGET freetype2)
if(TARGET PkgConfig::FREETYPE)
set(CP0_FREETYPE_TARGET PkgConfig::FREETYPE)
endif()
endif()
add_executable(cp0-sync-ui
src/app_ui.cpp
src/main.cpp
)
target_link_libraries(cp0-sync-ui PRIVATE
cp0_ui_core
Threads::Threads
)
target_compile_options(cp0-sync-ui PRIVATE -Wall -Wextra -Wpedantic)
if(CP0_FREETYPE_TARGET)
target_compile_definitions(cp0-sync-ui PRIVATE CP0_HAS_FREETYPE=1)
target_link_libraries(cp0-sync-ui PRIVATE ${CP0_FREETYPE_TARGET})
message(STATUS "FreeType2 enabled via ${CP0_FREETYPE_TARGET}")
else()
message(STATUS "FreeType2 not found: using built-in 5x7 bitmap fallback")
endif()
if(CP0_LVGL_TARGET)
target_compile_definitions(cp0-sync-ui PRIVATE CP0_HAS_LVGL=1)
target_link_libraries(cp0-sync-ui PRIVATE ${CP0_LVGL_TARGET})
message(STATUS "LVGL detected via ${CP0_LVGL_TARGET}")
else()
message(STATUS "LVGL not installed: using built-in 320x170 ShadcnCanvas renderer")
endif()
if(CP0_UI_TARGET_DEVICE)
target_compile_definitions(cp0-sync-ui PRIVATE CP0_UI_TARGET_DEVICE=1)
message(STATUS "Target backend: Linux fbdev + evdev")
else()
set(CP0_SDL2_TARGET "")
if(PkgConfig_FOUND)
pkg_check_modules(SDL2 QUIET IMPORTED_TARGET sdl2)
if(TARGET PkgConfig::SDL2)
set(CP0_SDL2_TARGET PkgConfig::SDL2)
endif()
endif()
if(NOT CP0_SDL2_TARGET)
find_package(SDL2 REQUIRED)
if(TARGET SDL2::SDL2)
set(CP0_SDL2_TARGET SDL2::SDL2)
endif()
endif()
if(CP0_SDL2_TARGET)
target_link_libraries(cp0-sync-ui PRIVATE ${CP0_SDL2_TARGET})
else()
target_include_directories(cp0-sync-ui PRIVATE ${SDL2_INCLUDE_DIRS})
target_link_libraries(cp0-sync-ui PRIVATE ${SDL2_LIBRARIES})
endif()
message(STATUS "Target backend: SDL2 320x170 simulator")
endif()
install(TARGETS cp0-sync-ui RUNTIME DESTINATION bin)
endif()
if(CP0_UI_BUILD_TESTS)
@@ -41,4 +120,14 @@ if(CP0_UI_BUILD_TESTS)
)
target_compile_options(test_ipc_and_theme PRIVATE -Wall -Wextra -Wpedantic)
add_test(NAME test_ipc_and_theme COMMAND test_ipc_and_theme)
add_executable(test_ui_navigation
tests/test_ui_navigation.cpp
)
target_link_libraries(test_ui_navigation PRIVATE
cp0_ui_core
Threads::Threads
)
target_compile_options(test_ui_navigation PRIVATE -Wall -Wextra -Wpedantic)
add_test(NAME test_ui_navigation COMMAND test_ui_navigation)
endif()

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
View 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
View 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
}

View 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

View 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

View File

@@ -0,0 +1,446 @@
#include "ui_controller.hpp"
#include <unistd.h>
#include <cassert>
#include <chrono>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
namespace fs = std::filesystem;
namespace {
struct TempDir {
fs::path path;
explicit TempDir(const std::string& prefix) {
auto base = fs::temp_directory_path();
auto stamp = std::chrono::steady_clock::now().time_since_epoch().count();
path = base / (prefix + "_" + std::to_string(getpid()) + "_" + std::to_string(stamp));
fs::create_directories(path);
}
~TempDir() {
std::error_code ec;
fs::remove_all(path, ec);
}
};
void type_text(cp0::UiController& ctrl, const std::string& text) {
for (char ch : text) {
auto act = ctrl.handle_key(ch, cp0::KeyCode::Char);
assert(act.type == cp0::ActionType::None);
}
}
void test_initial_state_and_global_navigation() {
cp0::UiController ctrl;
assert(ctrl.state().tab == cp0::ActiveTab::Status);
assert(ctrl.state().theme == cp0::ThemeMode::Dark);
assert(ctrl.state().modal == cp0::ModalKind::None);
// Direct tab jumps: 1 / 2 / 3
assert(ctrl.handle_key('2', cp0::KeyCode::Char).type == cp0::ActionType::None);
assert(ctrl.state().tab == cp0::ActiveTab::Folders);
assert(ctrl.handle_key('3', cp0::KeyCode::Char).type == cp0::ActionType::None);
assert(ctrl.state().tab == cp0::ActiveTab::Logs);
assert(ctrl.handle_key('1', cp0::KeyCode::Char).type == cp0::ActionType::None);
assert(ctrl.state().tab == cp0::ActiveTab::Status);
// Left / Right cycle tabs
ctrl.handle_key(0, cp0::KeyCode::Right);
assert(ctrl.state().tab == cp0::ActiveTab::Folders);
ctrl.handle_key(0, cp0::KeyCode::Right);
assert(ctrl.state().tab == cp0::ActiveTab::Logs);
ctrl.handle_key(0, cp0::KeyCode::Right);
assert(ctrl.state().tab == cp0::ActiveTab::Status);
ctrl.handle_key(0, cp0::KeyCode::Left);
assert(ctrl.state().tab == cp0::ActiveTab::Logs);
ctrl.handle_key(0, cp0::KeyCode::Left);
assert(ctrl.state().tab == cp0::ActiveTab::Folders);
ctrl.handle_key(0, cp0::KeyCode::Left);
assert(ctrl.state().tab == cp0::ActiveTab::Status);
// Enter triggers SyncNow on any main tab
auto sync1 = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(sync1.type == cp0::ActionType::SyncNow);
ctrl.handle_key('2', cp0::KeyCode::Char);
auto sync2 = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(sync2.type == cp0::ActionType::SyncNow);
// Esc and Q emit Quit when no modal is open
assert(ctrl.handle_key(0, cp0::KeyCode::Escape).type == cp0::ActionType::Quit);
assert(ctrl.handle_key('q', cp0::KeyCode::Char).type == cp0::ActionType::Quit);
assert(ctrl.handle_key('Q', cp0::KeyCode::Char).type == cp0::ActionType::Quit);
}
void test_theme_toggle_outside_vs_inside_modals() {
cp0::UiController ctrl;
// Initial daemon status seeds theme once
cp0::DaemonStatus st;
st.ok = true;
st.theme = "light";
cp0::FolderStatus f;
f.id = "cam1";
f.path = "/tmp/cam1";
f.label = "Camera";
st.folders.push_back(f);
ctrl.update_status(st);
assert(ctrl.state().theme == cp0::ThemeMode::Light);
// 'T' toggles theme on main tab and emits SetTheme
auto act1 = ctrl.handle_key('t', cp0::KeyCode::Char);
assert(act1.type == cp0::ActionType::SetTheme);
assert(act1.theme == cp0::ThemeMode::Dark);
assert(ctrl.state().theme == cp0::ThemeMode::Dark);
// Stale daemon status with unchanged "light" does not clobber optimistic toggle
ctrl.update_status(st);
assert(ctrl.state().theme == cp0::ThemeMode::Dark);
// Uppercase 'T' toggles back to Light
auto act2 = ctrl.handle_key('T', cp0::KeyCode::Char);
assert(act2.type == cp0::ActionType::SetTheme);
assert(act2.theme == cp0::ThemeMode::Light);
assert(ctrl.state().theme == cp0::ThemeMode::Light);
// Inside DirPicker, 'T' opens TextInput instead of toggling theme
ctrl.handle_key('2', cp0::KeyCode::Char);
ctrl.handle_key('a', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::DirPicker);
auto modal_t = ctrl.handle_key('t', cp0::KeyCode::Char);
assert(modal_t.type == cp0::ActionType::None);
assert(ctrl.state().modal == cp0::ModalKind::TextInput);
assert(ctrl.state().theme == cp0::ThemeMode::Light);
// Inside TextInput, 't' appends 't' instead of toggling theme or opening another modal
auto text_t = ctrl.handle_key('t', cp0::KeyCode::Char);
assert(text_t.type == cp0::ActionType::None);
assert(ctrl.state().text_buffer == "t");
assert(ctrl.state().theme == cp0::ThemeMode::Light);
// Esc closes TextInput without toggling theme or quitting
auto esc1 = ctrl.handle_key(0, cp0::KeyCode::Escape);
assert(esc1.type == cp0::ActionType::None);
assert(ctrl.state().modal == cp0::ModalKind::None);
assert(ctrl.state().theme == cp0::ThemeMode::Light);
// Esc again (modal == None) emits Quit
auto esc2 = ctrl.handle_key(0, cp0::KeyCode::Escape);
assert(esc2.type == cp0::ActionType::Quit);
// Inside TargetPicker, 'T' opens TextInput without toggling theme
ctrl.handle_key('1', cp0::KeyCode::Char);
ctrl.handle_key('c', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::TargetPicker);
ctrl.handle_key('T', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::TextInput);
assert(ctrl.state().theme == cp0::ThemeMode::Light);
ctrl.handle_key(0, cp0::KeyCode::Escape);
assert(ctrl.state().modal == cp0::ModalKind::None);
// Inside ConfirmRemove, 'T' does not toggle theme
ctrl.handle_key('2', cp0::KeyCode::Char);
ctrl.handle_key('d', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::ConfirmRemove);
ctrl.handle_key('t', cp0::KeyCode::Char);
assert(ctrl.state().theme == cp0::ThemeMode::Light);
assert(ctrl.state().modal == cp0::ModalKind::ConfirmRemove);
ctrl.handle_key('n', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::None);
}
void test_target_picker_and_manual_host() {
cp0::UiController ctrl;
std::vector<cp0::TailscalePeer> peers;
cp0::TailscalePeer p1;
p1.id = "1";
p1.hostname = "macbook";
p1.dns_name = "macbook.ts.net";
p1.os = "macOS";
p1.online = true;
p1.tailscale_ips = {"100.64.0.10"};
peers.push_back(p1);
cp0::TailscalePeer p2;
p2.id = "2";
p2.hostname = "studio";
p2.dns_name = "";
p2.os = "macOS";
p2.online = false;
p2.tailscale_ips = {"100.64.0.11"};
peers.push_back(p2);
// 'c' on Status tab opens TargetPicker and requests peer refresh
ctrl.handle_key('c', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::TargetPicker);
assert(ctrl.consume_peer_refresh() == true);
assert(ctrl.consume_peer_refresh() == false);
ctrl.set_peers(peers);
assert(ctrl.state().peers.size() == 2);
assert(ctrl.state().peer_cursor == 0);
// Navigate with j/k and Up/Down (clamped at ends)
ctrl.handle_key('j', cp0::KeyCode::Char);
assert(ctrl.state().peer_cursor == 1);
ctrl.handle_key(0, cp0::KeyCode::Down);
assert(ctrl.state().peer_cursor == 1);
ctrl.handle_key('k', cp0::KeyCode::Char);
assert(ctrl.state().peer_cursor == 0);
ctrl.handle_key(0, cp0::KeyCode::Up);
assert(ctrl.state().peer_cursor == 0);
// Select first peer (uses dns_name + default port 8765)
auto sel1 = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(sel1.type == cp0::ActionType::SetTarget);
assert(sel1.target_host == "macbook.ts.net");
assert(sel1.target_port == 8765);
assert(ctrl.state().modal == cp0::ModalKind::None);
// Select second peer (falls back to IP when dns_name empty)
ctrl.handle_key('c', cp0::KeyCode::Char);
ctrl.set_peers(peers);
ctrl.handle_key(0, cp0::KeyCode::Down);
auto sel2 = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(sel2.type == cp0::ActionType::SetTarget);
assert(sel2.target_host == "100.64.0.11");
assert(sel2.target_port == 8765);
assert(ctrl.state().modal == cp0::ModalKind::None);
// Manual host[:port] via TextInput with Backspace editing
ctrl.handle_key('c', cp0::KeyCode::Char);
ctrl.handle_key('t', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::TextInput);
type_text(ctrl, "imac.ts.net:9000");
ctrl.handle_key(0, cp0::KeyCode::Backspace);
type_text(ctrl, "1");
auto manual_port = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(manual_port.type == cp0::ActionType::SetTarget);
assert(manual_port.target_host == "imac.ts.net");
assert(manual_port.target_port == 9001);
assert(ctrl.state().modal == cp0::ModalKind::None);
// Manual host without port defaults to 8765
ctrl.handle_key('c', cp0::KeyCode::Char);
ctrl.handle_key('t', cp0::KeyCode::Char);
type_text(ctrl, "100.64.0.42");
auto manual_default_port = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(manual_default_port.type == cp0::ActionType::SetTarget);
assert(manual_default_port.target_host == "100.64.0.42");
assert(manual_default_port.target_port == 8765);
// Empty host stays in TextInput without emitting SetTarget
ctrl.handle_key('c', cp0::KeyCode::Char);
ctrl.handle_key('t', cp0::KeyCode::Char);
type_text(ctrl, " ");
auto empty_submit = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(empty_submit.type == cp0::ActionType::None);
assert(ctrl.state().modal == cp0::ModalKind::TextInput);
assert(!ctrl.state().modal_error.empty());
ctrl.handle_key(0, cp0::KeyCode::Escape);
assert(ctrl.state().modal == cp0::ModalKind::None);
// Invalid port stays in TextInput with error
ctrl.handle_key('c', cp0::KeyCode::Char);
ctrl.handle_key('t', cp0::KeyCode::Char);
type_text(ctrl, "mac.ts.net:99999");
auto bad_port = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(bad_port.type == cp0::ActionType::None);
assert(ctrl.state().modal == cp0::ModalKind::TextInput);
assert(!ctrl.state().modal_error.empty());
ctrl.handle_key(0, cp0::KeyCode::Escape);
// TargetPicker with empty peers ignores Enter
ctrl.handle_key('c', cp0::KeyCode::Char);
ctrl.set_peers({});
auto no_peer_enter = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(no_peer_enter.type == cp0::ActionType::None);
assert(ctrl.state().modal == cp0::ModalKind::TargetPicker);
ctrl.handle_key(0, cp0::KeyCode::Escape);
}
void test_dir_picker_traversal_and_manual_path() {
TempDir tmp("cp0_dirpicker");
fs::path root = tmp.path;
fs::create_directories(root / "alpha");
fs::create_directories(root / "beta" / "sub1");
fs::create_directories(root / "gamma");
{
std::ofstream f(root / "IMG_0001.JPG");
f << "not a directory";
}
cp0::UiController ctrl;
ctrl.set_dir_picker_start_path(root.string());
ctrl.handle_key('2', cp0::KeyCode::Char);
// 'a' opens DirPicker at configured start path
ctrl.handle_key('a', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::DirPicker);
assert(fs::path(ctrl.state().dir_current_path) == fs::weakly_canonical(root));
assert(ctrl.state().dir_entries.size() == 3);
assert(fs::path(ctrl.state().dir_entries[0]).filename() == "alpha");
assert(fs::path(ctrl.state().dir_entries[1]).filename() == "beta");
assert(fs::path(ctrl.state().dir_entries[2]).filename() == "gamma");
assert(ctrl.state().dir_cursor == 0);
// Move down to 'beta' and drill in with Enter
ctrl.handle_key('j', cp0::KeyCode::Char);
assert(ctrl.state().dir_cursor == 1);
ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(fs::path(ctrl.state().dir_current_path) == fs::weakly_canonical(root / "beta"));
assert(ctrl.state().dir_entries.size() == 1);
assert(fs::path(ctrl.state().dir_entries[0]).filename() == "sub1");
// Backspace goes up to parent ('root') and restores cursor on 'beta'
ctrl.handle_key(0, cp0::KeyCode::Backspace);
assert(fs::path(ctrl.state().dir_current_path) == fs::weakly_canonical(root));
assert(ctrl.state().dir_entries.size() == 3);
assert(ctrl.state().dir_cursor == 1);
// Drill back into beta and press Space on highlighted subdir 'sub1'
ctrl.handle_key(0, cp0::KeyCode::Enter);
auto add_highlighted = ctrl.handle_key(0, cp0::KeyCode::Space);
assert(add_highlighted.type == cp0::ActionType::AddFolder);
assert(fs::path(add_highlighted.folder_path) == fs::weakly_canonical(root / "beta" / "sub1"));
assert(ctrl.state().modal == cp0::ModalKind::None);
// Drill into empty leaf dir 'sub1' and press Space (' ' char) to watch current dir
ctrl.handle_key('a', cp0::KeyCode::Char);
ctrl.handle_key('j', cp0::KeyCode::Char); // beta
ctrl.handle_key(0, cp0::KeyCode::Enter);
ctrl.handle_key(0, cp0::KeyCode::Enter); // sub1 (empty)
assert(ctrl.state().dir_entries.empty());
assert(ctrl.state().dir_cursor == -1);
auto add_current = ctrl.handle_key(' ', cp0::KeyCode::Char);
assert(add_current.type == cp0::ActionType::AddFolder);
assert(fs::path(add_current.folder_path) == fs::weakly_canonical(root / "beta" / "sub1"));
assert(ctrl.state().modal == cp0::ModalKind::None);
// Manual folder path via [T] inside DirPicker
ctrl.handle_key('a', cp0::KeyCode::Char);
ctrl.handle_key('t', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::TextInput);
type_text(ctrl, "/media/sd/DCIM");
ctrl.handle_key(0, cp0::KeyCode::Backspace);
type_text(ctrl, "M2");
auto add_manual = ctrl.handle_key(0, cp0::KeyCode::Enter);
assert(add_manual.type == cp0::ActionType::AddFolder);
assert(add_manual.folder_path == "/media/sd/DCIM2");
assert(ctrl.state().modal == cp0::ModalKind::None);
}
void test_folders_selection_and_confirm_remove() {
cp0::UiController ctrl;
ctrl.handle_key('2', cp0::KeyCode::Char);
// Empty folders: 'd' and Delete do not open ConfirmRemove
ctrl.handle_key('d', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::None);
ctrl.handle_key(0, cp0::KeyCode::Delete);
assert(ctrl.state().modal == cp0::ModalKind::None);
cp0::DaemonStatus st;
st.ok = true;
cp0::FolderStatus f1;
f1.id = "cam";
f1.path = "/home/pi/Pictures/DCIM/Camera";
f1.label = "Camera";
f1.exists = true;
cp0::FolderStatus f2;
f2.id = "sd";
f2.path = "/media/sd/DCIM";
f2.label = "SD";
f2.exists = false;
st.folders = {f1, f2};
ctrl.update_status(st);
assert(ctrl.state().folder_cursor == 0);
ctrl.handle_key('j', cp0::KeyCode::Char);
assert(ctrl.state().folder_cursor == 1);
ctrl.handle_key(0, cp0::KeyCode::Down);
assert(ctrl.state().folder_cursor == 1);
// 'd' opens ConfirmRemove, 'n' cancels
ctrl.handle_key('d', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::ConfirmRemove);
assert(ctrl.state().confirm_folder_id == "sd");
auto cancel_n = ctrl.handle_key('n', cp0::KeyCode::Char);
assert(cancel_n.type == cp0::ActionType::None);
assert(ctrl.state().modal == cp0::ModalKind::None);
// Delete opens ConfirmRemove, Esc cancels
ctrl.handle_key(0, cp0::KeyCode::Delete);
assert(ctrl.state().modal == cp0::ModalKind::ConfirmRemove);
auto cancel_esc = ctrl.handle_key(0, cp0::KeyCode::Escape);
assert(cancel_esc.type == cp0::ActionType::None);
assert(ctrl.state().modal == cp0::ModalKind::None);
// 'd' -> 'y' emits RemoveFolder
ctrl.handle_key('d', cp0::KeyCode::Char);
assert(ctrl.state().modal == cp0::ModalKind::ConfirmRemove);
auto confirm_y = ctrl.handle_key('y', cp0::KeyCode::Char);
assert(confirm_y.type == cp0::ActionType::RemoveFolder);
assert(confirm_y.folder_id == "sd");
assert(ctrl.state().modal == cp0::ModalKind::None);
}
void test_logs_scrolling_and_retry_failed() {
cp0::UiController ctrl;
cp0::DaemonStatus st;
st.ok = true;
for (int i = 0; i < 10; ++i) {
cp0::LogEntry e;
e.id = 100 - i;
e.ts = 1731900000000LL + i * 1000LL;
e.level = (i % 3 == 0) ? "ERROR" : "INFO";
e.message = "Entry " + std::to_string(i);
st.logs.push_back(e);
}
ctrl.update_status(st);
// 'r' outside Logs tab does not emit RetryFailed
assert(ctrl.handle_key('r', cp0::KeyCode::Char).type == cp0::ActionType::None);
// Switch to Logs tab
ctrl.handle_key('3', cp0::KeyCode::Char);
assert(ctrl.state().tab == cp0::ActiveTab::Logs);
assert(ctrl.state().log_scroll == 0);
ctrl.handle_key('j', cp0::KeyCode::Char);
assert(ctrl.state().log_scroll == 1);
ctrl.handle_key(0, cp0::KeyCode::Down);
assert(ctrl.state().log_scroll == 2);
ctrl.handle_key('k', cp0::KeyCode::Char);
assert(ctrl.state().log_scroll == 1);
ctrl.handle_key(0, cp0::KeyCode::Up);
assert(ctrl.state().log_scroll == 0);
ctrl.handle_key(0, cp0::KeyCode::Up);
assert(ctrl.state().log_scroll == 0);
for (int i = 0; i < 20; ++i) {
ctrl.handle_key('j', cp0::KeyCode::Char);
}
assert(ctrl.state().log_scroll == 9);
auto retry = ctrl.handle_key('r', cp0::KeyCode::Char);
assert(retry.type == cp0::ActionType::RetryFailed);
}
} // namespace
int main() {
test_initial_state_and_global_navigation();
test_theme_toggle_outside_vs_inside_modals();
test_target_picker_and_manual_host();
test_dir_picker_traversal_and_manual_path();
test_folders_selection_and_confirm_remove();
test_logs_scrolling_and_retry_failed();
std::cout << "All test_ui_navigation assertions passed.\n";
return 0;
}