634 lines
22 KiB
C++
634 lines
22 KiB
C++
/*
|
|
* launcher.cpp
|
|
* Super + Space launcher
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#include "desktop_internal.hpp"
|
|
#include <gui/mtk/theme.hpp>
|
|
|
|
static constexpr int LAUNCHER_W = 560;
|
|
static constexpr int LAUNCHER_SEARCH_H = 52;
|
|
static constexpr int LAUNCHER_ROW_H = 52;
|
|
static constexpr int LAUNCHER_EMPTY_H = 84;
|
|
static constexpr int LAUNCHER_VISIBLE_ROWS = 7;
|
|
static constexpr int LAUNCHER_TEXT_PAD = 18;
|
|
static constexpr int LAUNCHER_CURSOR_BLINK_MS = 700;
|
|
static constexpr int LAUNCHER_SPECIAL_FOLDER_COUNT = 6;
|
|
|
|
static constexpr Color LAUNCHER_BORDER = Color::from_rgb(0xD4, 0xDB, 0xE4);
|
|
static constexpr Color LAUNCHER_FIELD_BG = Color::from_rgb(0xFF, 0xFF, 0xFF);
|
|
static constexpr Color LAUNCHER_SELECTED_BG_DEFAULT = Color::from_rgb(0xDA, 0xE7, 0xFD);
|
|
static constexpr Color LAUNCHER_HOVER_BG_DEFAULT = Color::from_rgb(0xEC, 0xF3, 0xFE);
|
|
|
|
static Color launcher_selected_bg(Color accent) {
|
|
if (accent.r == colors::ACCENT.r && accent.g == colors::ACCENT.g
|
|
&& accent.b == colors::ACCENT.b)
|
|
return LAUNCHER_SELECTED_BG_DEFAULT;
|
|
return gui::mtk::mix(colors::WHITE, accent, 47);
|
|
}
|
|
|
|
static Color launcher_hover_bg(Color accent) {
|
|
if (accent.r == colors::ACCENT.r && accent.g == colors::ACCENT.g
|
|
&& accent.b == colors::ACCENT.b)
|
|
return LAUNCHER_HOVER_BG_DEFAULT;
|
|
return gui::mtk::mix(colors::WHITE, accent, 20);
|
|
}
|
|
static constexpr Color LAUNCHER_MUTED = Color::from_rgb(0x6F, 0x7B, 0x89);
|
|
static constexpr Color LAUNCHER_PLACEHOLDER = Color::from_rgb(0x98, 0xA1, 0xAD);
|
|
|
|
static const char* launcher_special_folder_names[LAUNCHER_SPECIAL_FOLDER_COUNT] = {
|
|
"Documents", "Desktop", "Music", "Videos", "Pictures", "Downloads"
|
|
};
|
|
|
|
static char fold_ascii(char c) {
|
|
return (c >= 'A' && c <= 'Z') ? (char)(c - 'A' + 'a') : c;
|
|
}
|
|
|
|
static bool launcher_super_down(const DesktopState* ds) {
|
|
return ds->super_left_down || ds->super_right_down;
|
|
}
|
|
|
|
static bool launcher_show_results(const DesktopState* ds) {
|
|
return ds->launcher_query_len > 0;
|
|
}
|
|
|
|
static int launcher_search_y(const DesktopState* ds) {
|
|
int avail_h = ds->screen_h - PANEL_HEIGHT;
|
|
int y = PANEL_HEIGHT + ((avail_h - LAUNCHER_SEARCH_H) * 2) / 10;
|
|
if (y < PANEL_HEIGHT + 8) y = PANEL_HEIGHT + 8;
|
|
if (y + LAUNCHER_SEARCH_H > ds->screen_h - 8) y = ds->screen_h - LAUNCHER_SEARCH_H - 8;
|
|
return y;
|
|
}
|
|
|
|
static int launcher_visible_rows(const DesktopState* ds) {
|
|
if (ds->launcher_result_count <= 0) return 0;
|
|
return gui_min(ds->launcher_result_count, LAUNCHER_VISIBLE_ROWS);
|
|
}
|
|
|
|
static int launcher_scroll_max(const DesktopState* ds) {
|
|
int extra = ds->launcher_result_count - LAUNCHER_VISIBLE_ROWS;
|
|
return extra > 0 ? extra : 0;
|
|
}
|
|
|
|
static Rect launcher_bounds(const DesktopState* ds) {
|
|
int w = gui_min(LAUNCHER_W, ds->screen_w - 16);
|
|
if (w < 260) w = ds->screen_w;
|
|
int result_h = launcher_show_results(ds)
|
|
? (ds->launcher_result_count > 0
|
|
? launcher_visible_rows(ds) * LAUNCHER_ROW_H
|
|
: LAUNCHER_EMPTY_H)
|
|
: 0;
|
|
int h = LAUNCHER_SEARCH_H + result_h;
|
|
int x = (ds->screen_w - w) / 2;
|
|
int y = launcher_search_y(ds);
|
|
return {x, y, w, h};
|
|
}
|
|
|
|
static Rect launcher_search_rect(const DesktopState* ds) {
|
|
Rect bounds = launcher_bounds(ds);
|
|
return {bounds.x, launcher_search_y(ds), bounds.w, LAUNCHER_SEARCH_H};
|
|
}
|
|
|
|
static Rect launcher_results_rect(const DesktopState* ds) {
|
|
Rect search = launcher_search_rect(ds);
|
|
Rect bounds = launcher_bounds(ds);
|
|
int y = search.y + search.h;
|
|
return {
|
|
bounds.x,
|
|
y,
|
|
bounds.w,
|
|
bounds.y + bounds.h - y
|
|
};
|
|
}
|
|
|
|
static int launcher_visible_result_count(const DesktopState* ds) {
|
|
if (!launcher_show_results(ds)) return 0;
|
|
int remaining = ds->launcher_result_count - ds->launcher_scroll;
|
|
if (remaining <= 0) return 0;
|
|
return gui_min(remaining, LAUNCHER_VISIBLE_ROWS);
|
|
}
|
|
|
|
static Rect launcher_row_rect(const DesktopState* ds, int visible_idx) {
|
|
Rect list = launcher_results_rect(ds);
|
|
return {list.x, list.y + visible_idx * LAUNCHER_ROW_H, list.w, LAUNCHER_ROW_H};
|
|
}
|
|
|
|
static bool launcher_contains_folded(const char* haystack, const char* needle) {
|
|
if (!needle[0]) return true;
|
|
|
|
int nlen = montauk::slen(needle);
|
|
if (nlen == 0) return true;
|
|
|
|
for (int i = 0; haystack[i]; i++) {
|
|
int j = 0;
|
|
while (j < nlen && haystack[i + j] &&
|
|
fold_ascii(haystack[i + j]) == fold_ascii(needle[j])) {
|
|
j++;
|
|
}
|
|
if (j == nlen) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void launcher_append_search_term(char* dst, int dst_max, const char* term) {
|
|
if (!term || term[0] == '\0') return;
|
|
if (dst[0] != '\0') str_append(dst, " ", dst_max);
|
|
str_append(dst, term, dst_max);
|
|
}
|
|
|
|
static void launcher_build_search_text(char* dst, int dst_max,
|
|
const char* name, const char* category,
|
|
const char* path, const char* keywords) {
|
|
dst[0] = '\0';
|
|
launcher_append_search_term(dst, dst_max, name);
|
|
launcher_append_search_term(dst, dst_max, category);
|
|
launcher_append_search_term(dst, dst_max, path);
|
|
launcher_append_search_term(dst, dst_max, keywords);
|
|
}
|
|
|
|
static bool launcher_item_matches(const LauncherItem* item, const char* query) {
|
|
if (!query[0]) return false;
|
|
return launcher_contains_folded(item->search_text, query);
|
|
}
|
|
|
|
static int launcher_compare_items(const LauncherItem* a, const LauncherItem* b) {
|
|
for (int i = 0; a->name[i] || b->name[i]; i++) {
|
|
char ca = fold_ascii(a->name[i]);
|
|
char cb = fold_ascii(b->name[i]);
|
|
if (ca != cb) return (int)((unsigned char)ca) - (int)((unsigned char)cb);
|
|
}
|
|
|
|
for (int i = 0; a->category[i] || b->category[i]; i++) {
|
|
char ca = fold_ascii(a->category[i]);
|
|
char cb = fold_ascii(b->category[i]);
|
|
if (ca != cb) return (int)((unsigned char)ca) - (int)((unsigned char)cb);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void launcher_add_item(DesktopState* ds, LauncherItemKind kind,
|
|
const char* name, const char* category,
|
|
SvgIcon* icon, int ref_index,
|
|
const char* path = nullptr,
|
|
const char* keywords = nullptr) {
|
|
if (ds->launcher_item_count >= MAX_LAUNCHER_ITEMS) return;
|
|
|
|
LauncherItem* item = &ds->launcher_items[ds->launcher_item_count++];
|
|
montauk::memset(item, 0, sizeof(LauncherItem));
|
|
montauk::strncpy(item->name, name ? name : "", sizeof(item->name));
|
|
montauk::strncpy(item->category, category ? category : "", sizeof(item->category));
|
|
if (path) montauk::strncpy(item->path, path, sizeof(item->path));
|
|
launcher_build_search_text(item->search_text, sizeof(item->search_text),
|
|
item->name, item->category, item->path, keywords);
|
|
item->icon = icon ? icon : &ds->icon_exec;
|
|
item->kind = kind;
|
|
item->ref_index = ref_index;
|
|
}
|
|
|
|
static void desktop_launch_external_app(DesktopState* ds, const ExternalApp* app) {
|
|
if (!app) return;
|
|
|
|
if (app->launch_with_home) {
|
|
montauk::spawn(app->binary_path, ds->home_dir);
|
|
} else {
|
|
montauk::spawn(app->binary_path);
|
|
}
|
|
}
|
|
|
|
static void desktop_build_launcher_items(DesktopState* ds) {
|
|
ds->launcher_item_count = 0;
|
|
|
|
ensure_filemanager_icons_loaded(ds);
|
|
|
|
launcher_add_item(ds, LAUNCHER_ITEM_BUILTIN_FILES,
|
|
"Files", "Built-in App",
|
|
&ds->icon_filemanager, -1, nullptr,
|
|
"file manager browser");
|
|
|
|
for (int i = 0; i < ds->external_app_count; i++) {
|
|
ExternalApp* app = &ds->external_apps[i];
|
|
SvgIcon* icon = app->icon.pixels ? &app->icon : &ds->icon_exec;
|
|
launcher_add_item(ds, LAUNCHER_ITEM_EXTERNAL_APP,
|
|
app->name, app->category,
|
|
icon, i, nullptr, nullptr);
|
|
}
|
|
|
|
launcher_add_item(ds, LAUNCHER_ITEM_COMMAND_REBOOT,
|
|
"Reboot", "Command",
|
|
&ds->icon_reboot, -1, nullptr,
|
|
"restart reboot power");
|
|
launcher_add_item(ds, LAUNCHER_ITEM_COMMAND_SHUTDOWN,
|
|
"Shutdown", "Command",
|
|
&ds->icon_shutdown, -1, nullptr,
|
|
"power off halt shutdown");
|
|
|
|
if (ds->home_dir[0] != '\0') {
|
|
for (int sf = 0; sf < LAUNCHER_SPECIAL_FOLDER_COUNT; sf++) {
|
|
char folder_path[128];
|
|
montauk::strcpy(folder_path, ds->home_dir);
|
|
int plen = montauk::slen(folder_path);
|
|
if (plen > 0 && folder_path[plen - 1] != '/')
|
|
str_append(folder_path, "/", sizeof(folder_path));
|
|
str_append(folder_path, launcher_special_folder_names[sf], sizeof(folder_path));
|
|
|
|
int probe_fd = montauk::open(folder_path);
|
|
if (probe_fd < 0) continue;
|
|
montauk::close(probe_fd);
|
|
|
|
SvgIcon* icon = ds->icon_special_folder[sf].pixels
|
|
? &ds->icon_special_folder[sf]
|
|
: &ds->icon_folder;
|
|
launcher_add_item(ds, LAUNCHER_ITEM_SPECIAL_FOLDER,
|
|
launcher_special_folder_names[sf], "Folder",
|
|
icon, sf, folder_path, "user folder");
|
|
}
|
|
}
|
|
}
|
|
|
|
static void desktop_update_launcher_results(DesktopState* ds) {
|
|
int selected_item = -1;
|
|
if (ds->launcher_selected >= 0 && ds->launcher_selected < ds->launcher_result_count) {
|
|
selected_item = ds->launcher_results[ds->launcher_selected];
|
|
}
|
|
|
|
ds->launcher_result_count = 0;
|
|
if (ds->launcher_query[0] == '\0') {
|
|
ds->launcher_selected = -1;
|
|
ds->launcher_scroll = 0;
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < ds->launcher_item_count; i++) {
|
|
if (!launcher_item_matches(&ds->launcher_items[i], ds->launcher_query)) continue;
|
|
ds->launcher_results[ds->launcher_result_count++] = i;
|
|
}
|
|
|
|
for (int i = 1; i < ds->launcher_result_count; i++) {
|
|
int item_idx = ds->launcher_results[i];
|
|
int j = i - 1;
|
|
while (j >= 0 &&
|
|
launcher_compare_items(&ds->launcher_items[item_idx],
|
|
&ds->launcher_items[ds->launcher_results[j]]) < 0) {
|
|
ds->launcher_results[j + 1] = ds->launcher_results[j];
|
|
j--;
|
|
}
|
|
ds->launcher_results[j + 1] = item_idx;
|
|
}
|
|
|
|
if (ds->launcher_result_count <= 0) {
|
|
ds->launcher_selected = -1;
|
|
ds->launcher_scroll = 0;
|
|
return;
|
|
}
|
|
|
|
int selected = 0;
|
|
if (selected_item >= 0) {
|
|
for (int i = 0; i < ds->launcher_result_count; i++) {
|
|
if (ds->launcher_results[i] == selected_item) {
|
|
selected = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ds->launcher_selected = gui_clamp(selected, 0, ds->launcher_result_count - 1);
|
|
int max_scroll = launcher_scroll_max(ds);
|
|
if (ds->launcher_scroll > max_scroll) ds->launcher_scroll = max_scroll;
|
|
if (ds->launcher_selected < ds->launcher_scroll) {
|
|
ds->launcher_scroll = ds->launcher_selected;
|
|
}
|
|
if (ds->launcher_selected >= ds->launcher_scroll + LAUNCHER_VISIBLE_ROWS) {
|
|
ds->launcher_scroll = ds->launcher_selected - LAUNCHER_VISIBLE_ROWS + 1;
|
|
}
|
|
}
|
|
|
|
static void desktop_move_launcher_selection(DesktopState* ds, int delta) {
|
|
if (ds->launcher_result_count <= 0) return;
|
|
|
|
if (ds->launcher_selected < 0) {
|
|
ds->launcher_selected = 0;
|
|
} else {
|
|
ds->launcher_selected = gui_clamp(ds->launcher_selected + delta, 0, ds->launcher_result_count - 1);
|
|
}
|
|
|
|
if (ds->launcher_selected < ds->launcher_scroll) {
|
|
ds->launcher_scroll = ds->launcher_selected;
|
|
} else if (ds->launcher_selected >= ds->launcher_scroll + LAUNCHER_VISIBLE_ROWS) {
|
|
ds->launcher_scroll = ds->launcher_selected - LAUNCHER_VISIBLE_ROWS + 1;
|
|
}
|
|
}
|
|
|
|
static void launcher_activate_selected(DesktopState* ds) {
|
|
if (ds->launcher_selected < 0 || ds->launcher_selected >= ds->launcher_result_count) return;
|
|
|
|
int item_idx = ds->launcher_results[ds->launcher_selected];
|
|
if (item_idx < 0 || item_idx >= ds->launcher_item_count) return;
|
|
|
|
LauncherItem* item = &ds->launcher_items[item_idx];
|
|
switch (item->kind) {
|
|
case LAUNCHER_ITEM_EXTERNAL_APP:
|
|
if (item->ref_index >= 0 && item->ref_index < ds->external_app_count) {
|
|
desktop_launch_external_app(ds, &ds->external_apps[item->ref_index]);
|
|
}
|
|
break;
|
|
case LAUNCHER_ITEM_BUILTIN_FILES:
|
|
open_filemanager(ds);
|
|
break;
|
|
case LAUNCHER_ITEM_COMMAND_REBOOT:
|
|
desktop_close_launcher(ds);
|
|
desktop_request_power(montauk::abi::POWER_REQ_REBOOT);
|
|
return;
|
|
case LAUNCHER_ITEM_COMMAND_SHUTDOWN:
|
|
desktop_close_launcher(ds);
|
|
desktop_request_power(montauk::abi::POWER_REQ_SHUTDOWN);
|
|
return;
|
|
case LAUNCHER_ITEM_SPECIAL_FOLDER:
|
|
if (item->path[0] != '\0') {
|
|
open_filemanager_path(ds, item->path);
|
|
}
|
|
break;
|
|
}
|
|
|
|
desktop_close_launcher(ds);
|
|
}
|
|
|
|
static void launcher_update_super_state(DesktopState* ds, const montauk::abi::KeyEvent& key) {
|
|
uint8_t sc = key.scancode & 0x7F;
|
|
if (sc == 0x5B) {
|
|
ds->super_left_down = key.pressed;
|
|
} else if (sc == 0x5C) {
|
|
ds->super_right_down = key.pressed;
|
|
}
|
|
}
|
|
|
|
static const char* fit_trailing_text(const char* text, int max_w) {
|
|
const char* visible = text;
|
|
while (*visible && text_width(visible) > max_w) visible++;
|
|
return visible;
|
|
}
|
|
|
|
static void draw_rounded_panel(Framebuffer& fb, int x, int y, int w, int h,
|
|
int radius, Color border, Color bg) {
|
|
fill_rounded_rect(fb, x, y, w, h, radius, border);
|
|
if (w > 2 && h > 2) {
|
|
int inner_radius = radius > 0 ? radius - 1 : 0;
|
|
fill_rounded_rect(fb, x + 1, y + 1, w - 2, h - 2, inner_radius, bg);
|
|
}
|
|
}
|
|
|
|
void desktop_init_launcher(DesktopState* ds) {
|
|
ds->launcher_open = false;
|
|
ds->launcher_query[0] = '\0';
|
|
ds->launcher_query_len = 0;
|
|
ds->launcher_item_count = 0;
|
|
ds->launcher_result_count = 0;
|
|
ds->launcher_selected = -1;
|
|
ds->launcher_scroll = 0;
|
|
ds->super_left_down = false;
|
|
ds->super_right_down = false;
|
|
}
|
|
|
|
void desktop_open_launcher(DesktopState* ds) {
|
|
desktop_build_launcher_items(ds);
|
|
ds->launcher_open = true;
|
|
ds->launcher_query[0] = '\0';
|
|
ds->launcher_query_len = 0;
|
|
ds->launcher_selected = -1;
|
|
ds->launcher_scroll = 0;
|
|
ds->app_menu_open = false;
|
|
ds->ctx_menu_open = false;
|
|
ds->net_popup_open = false;
|
|
ds->vol_popup_open = false;
|
|
ds->vol_dragging = false;
|
|
desktop_update_launcher_results(ds);
|
|
}
|
|
|
|
void desktop_close_launcher(DesktopState* ds) {
|
|
ds->launcher_open = false;
|
|
ds->launcher_scroll = 0;
|
|
}
|
|
|
|
bool desktop_handle_launcher_keyboard(DesktopState* ds, const montauk::abi::KeyEvent& key) {
|
|
launcher_update_super_state(ds, key);
|
|
uint8_t sc = key.scancode & 0x7F;
|
|
|
|
if (sc == 0x5B || sc == 0x5C) {
|
|
return true;
|
|
}
|
|
|
|
if (ds->screen_locked) {
|
|
return false;
|
|
}
|
|
|
|
if (key.pressed && sc == 0x39 && launcher_super_down(ds)) {
|
|
if (ds->launcher_open) {
|
|
desktop_close_launcher(ds);
|
|
} else {
|
|
desktop_open_launcher(ds);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!ds->launcher_open) {
|
|
return false;
|
|
}
|
|
|
|
if (!key.pressed) return true;
|
|
|
|
if (key.ascii == '\n' || key.ascii == '\r' || sc == 0x1C) {
|
|
launcher_activate_selected(ds);
|
|
return true;
|
|
}
|
|
|
|
if (sc == 0x01) {
|
|
desktop_close_launcher(ds);
|
|
return true;
|
|
}
|
|
|
|
if (key.ascii == '\b' || sc == 0x0E) {
|
|
if (ds->launcher_query_len > 0) {
|
|
ds->launcher_query_len--;
|
|
ds->launcher_query[ds->launcher_query_len] = '\0';
|
|
desktop_update_launcher_results(ds);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (sc == 0x48) {
|
|
desktop_move_launcher_selection(ds, -1);
|
|
return true;
|
|
}
|
|
if (sc == 0x50) {
|
|
desktop_move_launcher_selection(ds, 1);
|
|
return true;
|
|
}
|
|
if (sc == 0x49) {
|
|
desktop_move_launcher_selection(ds, -LAUNCHER_VISIBLE_ROWS);
|
|
return true;
|
|
}
|
|
if (sc == 0x51) {
|
|
desktop_move_launcher_selection(ds, LAUNCHER_VISIBLE_ROWS);
|
|
return true;
|
|
}
|
|
if (sc == 0x47) {
|
|
if (ds->launcher_result_count > 0) {
|
|
ds->launcher_selected = 0;
|
|
ds->launcher_scroll = 0;
|
|
}
|
|
return true;
|
|
}
|
|
if (sc == 0x4F) {
|
|
if (ds->launcher_result_count > 0) {
|
|
ds->launcher_selected = ds->launcher_result_count - 1;
|
|
ds->launcher_scroll = launcher_scroll_max(ds);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (key.ascii >= 0x20 && key.ascii < 0x7F && ds->launcher_query_len < 63) {
|
|
ds->launcher_query[ds->launcher_query_len++] = key.ascii;
|
|
ds->launcher_query[ds->launcher_query_len] = '\0';
|
|
desktop_update_launcher_results(ds);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void desktop_handle_launcher_mouse(DesktopState* ds) {
|
|
int mx = ds->mouse.x;
|
|
int my = ds->mouse.y;
|
|
uint8_t buttons = ds->mouse.buttons;
|
|
uint8_t prev = ds->prev_buttons;
|
|
bool left_pressed = (buttons & 0x01) && !(prev & 0x01);
|
|
bool right_pressed = (buttons & 0x02) && !(prev & 0x02);
|
|
|
|
Rect bounds = launcher_bounds(ds);
|
|
if (right_pressed) {
|
|
desktop_close_launcher(ds);
|
|
return;
|
|
}
|
|
|
|
if (!bounds.contains(mx, my)) {
|
|
if (left_pressed) {
|
|
desktop_close_launcher(ds);
|
|
}
|
|
return;
|
|
}
|
|
|
|
int visible = launcher_visible_result_count(ds);
|
|
for (int i = 0; i < visible; i++) {
|
|
Rect row = launcher_row_rect(ds, i);
|
|
if (!row.contains(mx, my)) continue;
|
|
|
|
ds->launcher_selected = ds->launcher_scroll + i;
|
|
if (left_pressed) {
|
|
launcher_activate_selected(ds);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void desktop_draw_launcher(DesktopState* ds) {
|
|
Framebuffer& fb = ds->fb;
|
|
int sfh = system_font_height();
|
|
bool show_results = launcher_show_results(ds);
|
|
bool cursor_on = ((montauk::get_milliseconds() / LAUNCHER_CURSOR_BLINK_MS) & 1) == 0;
|
|
|
|
Rect bounds = launcher_bounds(ds);
|
|
Rect search = launcher_search_rect(ds);
|
|
Rect list = launcher_results_rect(ds);
|
|
|
|
draw_rounded_panel(fb, bounds.x, bounds.y, bounds.w, bounds.h, 16, LAUNCHER_BORDER, LAUNCHER_FIELD_BG);
|
|
|
|
int count_w = 0;
|
|
int count_x = search.x + search.w - LAUNCHER_TEXT_PAD;
|
|
if (show_results) {
|
|
char count_str[32];
|
|
snprintf(count_str, sizeof(count_str), "%d result%s",
|
|
ds->launcher_result_count,
|
|
ds->launcher_result_count == 1 ? "" : "s");
|
|
count_w = text_width(count_str);
|
|
count_x -= count_w;
|
|
draw_text(fb, count_x, search.y + (search.h - sfh) / 2, count_str, LAUNCHER_MUTED);
|
|
}
|
|
|
|
int query_x = search.x + LAUNCHER_TEXT_PAD;
|
|
int query_y = search.y + (search.h - sfh) / 2;
|
|
int query_max_w = search.w - LAUNCHER_TEXT_PAD * 2 - (show_results ? (count_w + 12) : 0);
|
|
if (query_max_w < 0) query_max_w = 0;
|
|
if (ds->launcher_query_len > 0) {
|
|
const char* visible = fit_trailing_text(ds->launcher_query, query_max_w);
|
|
draw_text(fb, query_x, query_y, visible, colors::TEXT_COLOR);
|
|
if (cursor_on) {
|
|
int cx = query_x + text_width(visible);
|
|
fb.fill_rect(cx + 1, query_y, 2, sfh, ds->settings.accent_color);
|
|
}
|
|
} else {
|
|
if (cursor_on) {
|
|
fb.fill_rect(query_x + 1, query_y, 2, sfh, ds->settings.accent_color);
|
|
}
|
|
draw_text(fb, query_x + 8, query_y, "Search apps, folders, and commands", LAUNCHER_PLACEHOLDER);
|
|
}
|
|
|
|
if (show_results) {
|
|
fb.fill_rect(bounds.x + 2, search.y + search.h - 2, bounds.w - 4, 2, ds->settings.accent_color);
|
|
}
|
|
|
|
if (!show_results) {
|
|
return;
|
|
}
|
|
|
|
if (ds->launcher_result_count <= 0) {
|
|
const char* empty = "No matching results";
|
|
const char* hint = "Try a different name, folder, or command";
|
|
int empty_w = text_width(empty);
|
|
int hint_w = text_width(hint);
|
|
int cy = list.y + (list.h - sfh * 2 - 8) / 2;
|
|
draw_text(fb, list.x + (list.w - empty_w) / 2, cy, empty, colors::TEXT_COLOR);
|
|
draw_text(fb, list.x + (list.w - hint_w) / 2, cy + sfh + 8, hint, LAUNCHER_MUTED);
|
|
return;
|
|
}
|
|
|
|
int visible = launcher_visible_result_count(ds);
|
|
for (int i = 0; i < visible; i++) {
|
|
int result_idx = ds->launcher_scroll + i;
|
|
if (result_idx < 0 || result_idx >= ds->launcher_result_count) continue;
|
|
|
|
Rect row = launcher_row_rect(ds, i);
|
|
int item_idx = ds->launcher_results[result_idx];
|
|
if (item_idx < 0 || item_idx >= ds->launcher_item_count) continue;
|
|
|
|
LauncherItem* item = &ds->launcher_items[item_idx];
|
|
bool selected = (result_idx == ds->launcher_selected);
|
|
bool hovered = row.contains(ds->mouse.x, ds->mouse.y);
|
|
if (selected) {
|
|
fill_rounded_rect(fb, row.x, row.y, row.w, row.h, 8, launcher_selected_bg(ds->settings.accent_color));
|
|
} else if (hovered) {
|
|
fill_rounded_rect(fb, row.x, row.y, row.w, row.h, 8, launcher_hover_bg(ds->settings.accent_color));
|
|
}
|
|
|
|
if (i > 0) {
|
|
fb.fill_rect(row.x + 8, row.y, row.w - 16, 1, Color::from_rgb(0xE3, 0xE8, 0xEF));
|
|
}
|
|
|
|
SvgIcon* icon = item->icon ? item->icon : &ds->icon_exec;
|
|
if (icon && icon->pixels) {
|
|
int ix = row.x + 12;
|
|
int iy = row.y + (row.h - icon->height) / 2;
|
|
fb.blit_alpha(ix, iy, icon->width, icon->height, icon->pixels);
|
|
}
|
|
|
|
int text_x = row.x + 46;
|
|
int name_y = row.y + 9;
|
|
int cat_y = row.y + 27;
|
|
draw_text(fb, text_x, name_y, item->name, colors::TEXT_COLOR);
|
|
draw_text(fb, text_x, cat_y, item->category, LAUNCHER_MUTED);
|
|
}
|
|
}
|
|
|
|
uint64_t desktop_launcher_blink_token(const DesktopState* ds, uint64_t now) {
|
|
return ds->launcher_open ? (now / LAUNCHER_CURSOR_BLINK_MS) : ~0ull;
|
|
}
|