daniel/mtkports
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
35e3d1a0bb3e1a9ef49740c12df42be9a17a8228
mtkports/www-client/netsurf/files/montauk_ui.c
T

539 lines
19 KiB
C
Raw Blame History

/* Native MontaukOS browser shell for the NetSurf core. */
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <montauk.h>
#include "utils/errors.h"
#include "utils/nsurl.h"
#include "netsurf/browser_window.h"
#include "netsurf/clipboard.h"
#include "netsurf/search.h"
#include "netsurf/keypress.h"
#include "netsurf/mouse.h"
#include "desktop/browser_history.h"
#include "desktop/search.h"
#include "monkey/browser.h"
#include "monkey/plot.h"
#include "monkey/schedule.h"
#include "monkey/montauk_ui.h"
#include "content/fetchers/montauk_bridge.h"
#include "content/urldb.h"
#define MENU_ITEMS 10
#define MAX_TABS 16
#define MAX_BOOKMARKS 64
#define HOME_URL "https://html.duckduckgo.com/"
static char bookmark_urls[MAX_BOOKMARKS][1024];
static char bookmark_titles[MAX_BOOKMARKS][128];
static size_t bookmark_count;
static char bookmark_path[256];
struct mtk_clipboard_info {
uint32_t text_bytes;
uint32_t pad;
uint64_t serial;
};
static void clipboard_get(char **buffer, size_t *length)
{
struct mtk_clipboard_info info = {0};
uint32_t actual = 0;
*buffer = NULL;
*length = 0;
if (_mtk_syscall1(MTK_SYS_CLIPBOARD_GET_INFO, (long)&info) != 0 ||
info.text_bytes == 0 || info.text_bytes > 4u * 1024u * 1024u)
return;
char *copy = malloc((size_t)info.text_bytes + 1);
if (copy == NULL) return;
if (_mtk_syscall4(MTK_SYS_CLIPBOARD_GET_TEXT, (long)copy,
(long)info.text_bytes, (long)&actual, 0) != 0 || actual > info.text_bytes) {
free(copy);
return;
}
copy[actual] = 0;
*buffer = copy;
*length = actual;
}
static void clipboard_set(const char *buffer, size_t length,
nsclipboard_styles styles[], int n_styles)
{
(void)styles;
(void)n_styles;
if (buffer != NULL && length <= UINT32_MAX)
_mtk_syscall2(MTK_SYS_CLIPBOARD_SET_TEXT, (long)buffer, (long)length);
}
struct gui_clipboard_table monkey_native_clipboard_table = {
.get = clipboard_get,
.set = clipboard_set,
};
static void search_status(bool found, void *private)
{
struct gui_window *g = private;
if (g == NULL) return;
strcpy(g->status, found ? "Match found" : "No matches");
g->dirty = true;
}
static void search_hourglass(bool active, void *private) { (void)active; (void)private; }
static void search_recent(const char *value, void *private) { (void)value; (void)private; }
static void search_state(bool active, void *private) { (void)active; (void)private; }
struct gui_search_table monkey_native_search_table = {
.status = search_status,
.hourglass = search_hourglass,
.add_recent = search_recent,
.forward_state = search_state,
.back_state = search_state,
};
static uint32_t rgb(unsigned r, unsigned g, unsigned b)
{
return 0xff000000u | (r << 16) | (g << 8) | b;
}
static void fill(struct gui_window *g, int x, int y, int w, int h, uint32_t c)
{
if (x < 0) { w += x; x = 0; }
if (y < 0) { h += y; y = 0; }
if (x + w > g->width) w = g->width - x;
if (y + h > g->height) h = g->height - y;
if (w <= 0 || h <= 0) return;
for (int py = y; py < y + h; py++)
for (int px = x; px < x + w; px++)
g->pixels[py * g->width + px] = c;
}
static void new_tab(struct gui_window *g)
{
if (monkey_native_tab_count() >= MAX_TABS) {
strcpy(g->status, "Tab limit reached"); g->dirty = true; return;
}
nsurl *url = NULL;
struct browser_window *created = NULL;
if (nsurl_create("about:blank", &url) != NSERROR_OK) return;
browser_window_create(BW_CREATE_HISTORY | BW_CREATE_TAB |
BW_CREATE_FOREGROUND | BW_CREATE_FOCUS_LOCATION,
url, NULL, g->bw, &created);
nsurl_unref(url);
struct gui_window *active = monkey_native_get_window();
if (active != NULL) {
active->address[0] = 0;
active->address_focus = true;
mtk_netsurf_address_input_focus((uintptr_t)active,
active->address, true);
active->dirty = true;
}
}
static void cycle_tab(struct gui_window *g, bool backwards)
{
size_t count = monkey_native_tab_count();
if (count < 2) return;
size_t current = 0;
for (; current < count; current++)
if (monkey_native_tab_at(current) == g) break;
if (current == count) return;
current = backwards ? (current + count - 1) % count : (current + 1) % count;
monkey_native_activate_window(monkey_native_tab_at(current));
}
static void bookmarks_save(void)
{
if (bookmark_path[0] == 0) return;
int file = mtk_create(bookmark_path);
if (file < 0) return;
unsigned long offset = 0;
for (size_t i = 0; i < bookmark_count; i++) {
size_t len = strlen(bookmark_urls[i]);
mtk_write(file, (const uint8_t *)bookmark_urls[i], offset, len); offset += len;
mtk_write(file, (const uint8_t *)"\n", offset, 1); offset++;
}
mtk_close(file);
}
static void bookmarks_load(void)
{
char user[64] = {0};
if (_mtk_syscall2(MTK_SYS_GETUSER, (long)user, sizeof(user)) < 0 || user[0] == 0)
strcpy(user, "admin");
char directory[224];
snprintf(directory, sizeof(directory), "0:/users/%s/.netsurf", user);
mtk_mkdir(directory);
snprintf(bookmark_path, sizeof(bookmark_path), "%s/bookmarks", directory);
int file = mtk_open(bookmark_path);
if (file < 0) return;
unsigned long size = mtk_getsize(file);
if (size > 128u * 1024u) size = 128u * 1024u;
char *data = malloc(size + 1);
if (data == NULL) { mtk_close(file); return; }
int got = mtk_read(file, (uint8_t *)data, 0, size);
mtk_close(file);
if (got < 0) { free(data); return; }
data[got] = 0;
char *line = data;
while (*line != 0 && bookmark_count < MAX_BOOKMARKS) {
char *end = strchr(line, '\n');
if (end != NULL) *end = 0;
if (line[0] != 0) {
strncpy(bookmark_urls[bookmark_count], line,
sizeof(bookmark_urls[bookmark_count]) - 1);
strncpy(bookmark_titles[bookmark_count], line,
sizeof(bookmark_titles[bookmark_count]) - 1);
bookmark_count++;
}
if (end == NULL) break;
line = end + 1;
}
free(data);
}
static void bookmark_page(struct gui_window *g)
{
nsurl *url = browser_window_access_url(g->bw);
if (url == NULL) { strcpy(g->status, "Could not save bookmark"); g->dirty = true; return; }
const char *value = nsurl_access(url);
for (size_t i = 0; i < bookmark_count; i++) {
if (strcmp(bookmark_urls[i], value) == 0) {
strcpy(g->status, "Already bookmarked"); g->dirty = true; return;
}
}
if (bookmark_count >= MAX_BOOKMARKS) {
strcpy(g->status, "Bookmark limit reached"); g->dirty = true; return;
}
strncpy(bookmark_urls[bookmark_count], value, sizeof(bookmark_urls[0]) - 1);
strncpy(bookmark_titles[bookmark_count], g->title[0] ? g->title : value,
sizeof(bookmark_titles[0]) - 1);
bookmark_count++;
urldb_set_url_persistence(url, true);
bookmarks_save();
strcpy(g->status, "Bookmark saved");
g->dirty = true;
}
static void close_all_tabs(void)
{
while (monkey_native_tab_count() != 0) {
struct gui_window *tab = monkey_native_tab_at(0);
if (tab == NULL) break;
browser_window_destroy(tab->bw);
}
}
void monkey_native_draw_chrome(struct gui_window *g)
{
if (g == NULL || g->pixels == NULL) return;
struct mtk_netsurf_chrome_model model = {0};
model.pixels = g->pixels;
model.width = g->width;
model.height = g->height;
model.scale = g->ui_scale;
model.mouse_x = g->mouse_x;
model.mouse_y = g->mouse_y;
model.can_back = browser_window_history_back_available(g->bw);
model.can_forward = browser_window_history_forward_available(g->bw);
model.loading = g->loading;
model.address_focus = g->address_focus;
model.address_input_key = (uintptr_t)g;
model.address = g->address;
model.menu_mode = g->menu_open;
model.find_focus = g->find_focus;
model.find_text = g->find_text;
model.status = g->status;
model.extent_height = g->extent_height;
model.scroll_y = g->scrolly;
model.scrollbar_hover = g->scrollbar_hover;
model.scrollbar_dragging = g->scrollbar_dragging;
model.tab_count = (int)monkey_native_tab_count();
for (int i = 0; i < model.tab_count && i < MTK_NETSURF_MAX_TABS; i++) {
struct gui_window *tab = monkey_native_tab_at((size_t)i);
model.tab_titles[i] = tab != NULL && tab->title[0] ? tab->title : "New Tab";
if (tab == g) model.active_tab = i;
}
model.bookmark_count = bookmark_count < MTK_NETSURF_MAX_BOOKMARK_ROWS ?
(int)bookmark_count : MTK_NETSURF_MAX_BOOKMARK_ROWS;
for (int i = 0; i < model.bookmark_count; i++)
model.bookmark_titles[i] = bookmark_titles[i];
mtk_netsurf_chrome_draw(&model);
if (g->caret_visible) {
int cx = g->caret_x - g->scrollx;
int cy = g->chrome_height + g->caret_y - g->scrolly;
if (cx >= 0 && cx < mtk_netsurf_page_view_width(g->width) &&
cy >= g->chrome_height &&
cy + g->caret_height < g->height)
fill(g, cx, cy, 1, g->caret_height, rgb(25, 25, 25));
}
}
static void navigate(struct gui_window *g, const char *input)
{
char expanded[2048];
if (strstr(input, "://") == NULL && strncmp(input, "about:", 6) != 0) {
snprintf(expanded, sizeof(expanded), "https://%s", input);
input = expanded;
}
nsurl *url = NULL;
if (nsurl_create(input, &url) == NSERROR_OK) {
browser_window_navigate(g->bw, url, NULL, BW_NAVIGATE_HISTORY,
NULL, NULL, NULL);
nsurl_unref(url);
}
}
static void key_event(struct gui_window *g, const mtk_key_event *key)
{
if (!key->pressed) return;
if (key->scancode == 0x01 && g->menu_open) { g->menu_open = 0; g->dirty = true; return; }
if (key->ctrl && (key->ascii == 't' || key->ascii == 'T' || key->scancode == 0x14)) { new_tab(g); return; }
if (key->ctrl && (key->ascii == 'w' || key->ascii == 'W' || key->scancode == 0x11)) {
browser_window_destroy(g->bw);
return;
}
if (key->ctrl && key->scancode == 0x0f) { cycle_tab(g, key->shift); return; }
if (key->ctrl && (key->ascii == 'f' || key->ascii == 'F')) {
g->find_focus = true; g->dirty = true; return;
}
if (key->ctrl && (key->ascii == 'd' || key->ascii == 'D')) {
bookmark_page(g); return;
}
if (g->find_focus) {
if (key->scancode == 0x01) {
g->find_focus = false; browser_window_search_clear(g->bw); g->dirty = true; return;
}
if (key->scancode == 0x1c || key->ascii == '\r' || key->ascii == '\n') {
if (g->find_text[0]) browser_window_search(g->bw, g, SEARCH_FLAG_FORWARDS, g->find_text);
return;
}
if (key->ascii == '\b' || key->scancode == 0x0e) {
size_t n = strlen(g->find_text); if (n) g->find_text[n-1] = 0;
} else if (key->ascii >= 32 && key->ascii < 127) {
size_t n = strlen(g->find_text);
if (n + 1 < sizeof(g->find_text)) { g->find_text[n] = key->ascii; g->find_text[n+1] = 0; }
}
if (g->find_text[0]) browser_window_search(g->bw, g, SEARCH_FLAG_FORWARDS | SEARCH_FLAG_SHOWALL, g->find_text);
else browser_window_search_clear(g->bw);
g->dirty = true; return;
}
if (key->ctrl && (key->ascii == 'l' || key->ascii == 'L')) {
g->address_focus = true;
mtk_netsurf_address_input_focus((uintptr_t)g, g->address, true);
g->dirty = true; return;
}
if (g->address_focus) {
if (key->scancode == 0x01) { g->address_focus = false; g->dirty = true; return; }
if (key->scancode == 0x1c || key->ascii == '\r' || key->ascii == '\n') {
g->address_focus = false;
navigate(g, g->address); return;
}
int result = mtk_netsurf_address_input_key((uintptr_t)g,
g->address, (int)sizeof(g->address), key->scancode,
key->ascii, key->pressed, key->shift, key->ctrl, key->alt);
if (result != 0) g->dirty = true;
return;
}
if (key->ctrl && (key->ascii == 'r' || key->ascii == 'R')) { browser_window_reload(g->bw, false); return; }
if (key->ctrl && (key->ascii == '+' || key->ascii == '=')) { browser_window_set_scale(g->bw, .1f, false); return; }
if (key->ctrl && key->ascii == '-') { browser_window_set_scale(g->bw, -.1f, false); return; }
if (key->ctrl && key->ascii == '0') { browser_window_set_scale(g->bw, 1.0f, true); return; }
if (key->ctrl && (key->ascii == 'a' || key->ascii == 'A')) { browser_window_key_press(g->bw, NS_KEY_SELECT_ALL); return; }
if (key->ctrl && (key->ascii == 'c' || key->ascii == 'C')) { browser_window_key_press(g->bw, NS_KEY_COPY_SELECTION); return; }
if (key->ctrl && (key->ascii == 'x' || key->ascii == 'X')) { browser_window_key_press(g->bw, NS_KEY_CUT_SELECTION); return; }
if (key->ctrl && (key->ascii == 'v' || key->ascii == 'V')) { browser_window_key_press(g->bw, NS_KEY_PASTE); return; }
uint32_t nskey = 0;
switch (key->scancode) {
case 0x48: nskey = NS_KEY_UP; break; case 0x50: nskey = NS_KEY_DOWN; break;
case 0x4b: nskey = NS_KEY_LEFT; break; case 0x4d: nskey = NS_KEY_RIGHT; break;
case 0x49: nskey = NS_KEY_PAGE_UP; break; case 0x51: nskey = NS_KEY_PAGE_DOWN; break;
case 0x0e: nskey = NS_KEY_DELETE_LEFT; break; case 0x53: nskey = NS_KEY_DELETE_RIGHT; break;
case 0x0f: nskey = key->shift ? NS_KEY_SHIFT_TAB : NS_KEY_TAB; break;
case 0x1c: nskey = NS_KEY_CR; break;
default: if (key->ascii >= 32) nskey = (unsigned char)key->ascii; break;
}
if (nskey != 0 && browser_window_key_press(g->bw, nskey)) return;
if (key->scancode == 0x48) g->scrolly -= 40;
if (key->scancode == 0x50) g->scrolly += 40;
if (key->scancode == 0x49) g->scrolly -= g->height - g->chrome_height - g->status_height;
if (key->scancode == 0x51) g->scrolly += g->height - g->chrome_height - g->status_height;
g->dirty = true;
}
static void clamp_scroll(struct gui_window *g)
{
int view = g->height - g->chrome_height - g->status_height;
int max = g->extent_height > view ? g->extent_height - view : 0;
if (g->scrolly < 0) g->scrolly = 0;
if (g->scrolly > max) g->scrolly = max;
}
static void mouse_event(struct gui_window *g, const mtk_win_event *ev)
{
int x = ev->mouse.x, y = ev->mouse.y;
struct mtk_netsurf_chrome_metrics m;
mtk_netsurf_chrome_metrics(g->ui_scale, g->width,
(int)monkey_native_tab_count(), &m);
int ch = m.chrome_h, sh = m.status_h;
if (g->mouse_x != x || g->mouse_y != y) {
g->mouse_x = x;
g->mouse_y = y;
g->dirty = true;
}
bool left_press = (ev->mouse.buttons & 1) && !(ev->mouse.prev_buttons & 1);
bool left_release = !(ev->mouse.buttons & 1) && (ev->mouse.prev_buttons & 1);
bool address_hit = x >= m.address_x && x < m.address_x + m.address_w &&
y >= m.address_y && y < m.address_y + m.address_h;
if (address_hit && ((ev->mouse.buttons & 3) != 0))
g->address_focus = true;
if (g->address_focus || address_hit) {
int input_result = mtk_netsurf_address_input_mouse((uintptr_t)g,
g->address, (int)sizeof(g->address), x, y,
ev->mouse.buttons, ev->mouse.prev_buttons,
m.address_x, m.address_y, m.address_w, m.address_h,
g->width, g->height, g->address_focus);
if (input_result != 0) {
g->dirty = true;
return;
}
}
int scrollbar_result = mtk_netsurf_page_scrollbar_mouse(x, y,
ev->mouse.buttons, ev->mouse.prev_buttons, g->width, g->height,
ch, g->extent_height, &g->scrolly, &g->scrollbar_hover,
&g->scrollbar_dragging, &g->scrollbar_drag_offset);
if ((scrollbar_result & 2) != 0) g->dirty = true;
if ((scrollbar_result & 1) != 0) return;
if (left_press && !address_hit) g->address_focus = false;
if (ev->mouse.scroll != 0 && y >= ch) {
g->scrolly -= ev->mouse.scroll * 50; clamp_scroll(g); g->dirty = true; return;
}
if (left_press && y >= m.tab_y && y < m.tab_h) {
size_t count = monkey_native_tab_count();
for (size_t i = 0; i < count; i++) {
int tx = m.tab_x + (int)i * m.tab_w;
if (x >= tx && x < tx + m.tab_content_w) {
struct gui_window *tab = monkey_native_tab_at(i);
if (tab != NULL && x >= tx + m.tab_content_w - m.tab_close_w)
browser_window_destroy(tab->bw);
else monkey_native_activate_window(tab);
return;
}
}
if (x >= m.add_x && x < m.add_x + m.add_w) new_tab(g);
return;
}
if (left_press && g->menu_open) {
if (y >= m.button_y && y < m.button_y + m.button_size &&
x >= m.menu_x && x < m.menu_x + m.button_size) {
g->menu_open = false; g->dirty = true; return;
}
if (g->menu_open == 2 && x >= m.popup_x && x < m.popup_x + m.popup_w && y >= m.popup_y) {
int item = (y - m.popup_y - 4) / m.popup_item_h - 1;
if (item >= 0 && item < (int)bookmark_count && item < 8)
navigate(g, bookmark_urls[item]);
g->menu_open = 0; g->dirty = true; return;
}
if (g->menu_open == 1 && x >= m.popup_x && x < m.popup_x + m.popup_w &&
y >= m.popup_y && y < m.popup_y + MENU_ITEMS * m.popup_item_h + 8) {
int item = (y - m.popup_y - 4) / m.popup_item_h;
g->menu_open = 0;
switch (item) {
case 0: new_tab(g); break;
case 1: g->find_focus = true; g->dirty = true; break;
case 2: bookmark_page(g); break;
case 3: g->menu_open = 2; g->dirty = true; break;
case 4: clipboard_set(g->address, strlen(g->address), NULL, 0); break;
case 5: browser_window_set_scale(g->bw, .1f, false); break;
case 6: browser_window_set_scale(g->bw, -.1f, false); break;
case 7: browser_window_set_scale(g->bw, 1.0f, true); break;
case 8: navigate(g, HOME_URL); break;
case 9: close_all_tabs(); break;
}
return;
}
g->menu_open = 0; g->dirty = true;
}
if (left_press && y >= m.button_y && y < m.button_y + m.button_size) {
if (x >= m.back_x && x < m.back_x + m.button_size && browser_window_history_back_available(g->bw))
browser_window_history_back(g->bw, false);
else if (x >= m.forward_x && x < m.forward_x + m.button_size && browser_window_history_forward_available(g->bw))
browser_window_history_forward(g->bw, false);
else if (x >= m.reload_x && x < m.reload_x + m.button_size) {
if (g->loading) browser_window_stop(g->bw); else browser_window_reload(g->bw, false);
} else if (x >= m.address_x && x < m.address_x + m.address_w) {
/* The MTK input handler above owns address-field interaction. */
} else if (x >= m.home_x && x < m.home_x + m.button_size) {
navigate(g, HOME_URL);
} else if (x >= m.menu_x && x < m.menu_x + m.button_size) {
g->menu_open = g->menu_open ? 0 : 1;
}
g->dirty = true; return;
}
if (left_press && y >= ch && y < g->height - sh) {
g->address_focus = false;
browser_window_mouse_click(g->bw, BROWSER_MOUSE_PRESS_1,
x + g->scrollx, y - ch + g->scrolly);
/* A press can dispatch form/content callbacks and invalidate the
* browser window. Continue tracking on the next mouse event, after the
* event loop has reacquired the active gui_window. */
return;
}
if (left_release && y >= ch && y < g->height - sh) {
browser_window_mouse_click(g->bw, BROWSER_MOUSE_CLICK_1,
x + g->scrollx, y - ch + g->scrolly);
/* A click may navigate, replace the current content, or destroy the
* target browser window. Do not dereference g or g->bw afterward. */
return;
}
if (y >= ch && y < g->height - sh)
browser_window_mouse_track(g->bw,
(ev->mouse.buttons & 1) ? BROWSER_MOUSE_HOLDING_1 : BROWSER_MOUSE_HOVER,
x + g->scrollx, y - ch + g->scrolly);
}
void monkey_native_run(const char *initial_url)
{
nsurl *url = NULL;
bookmarks_load();
if (initial_url == NULL || initial_url[0] == 0) initial_url = HOME_URL;
if (nsurl_create(initial_url, &url) != NSERROR_OK) return;
if (browser_window_create(BW_CREATE_HISTORY, url, NULL, NULL, NULL) != NSERROR_OK) {
nsurl_unref(url); return;
}
nsurl_unref(url);
for (;;) {
struct gui_window *g = monkey_native_get_window();
if (g == NULL) break;
monkey_schedule_run();
mtk_win_event ev;
int events = 0;
while (events++ < 32 && mtk_win_poll(g->native_id, &ev) > 0) {
if (ev.type == MTK_EVENT_CLOSE) { close_all_tabs(); g = NULL; break; }
if (ev.type == MTK_EVENT_RESIZE || ev.type == MTK_EVENT_SCALE) {
if (ev.type == MTK_EVENT_RESIZE) {
uint32_t *pixels = (uint32_t *)(uintptr_t)mtk_win_resize(g->native_id,
ev.resize.w, ev.resize.h);
monkey_native_resize_tabs(g, ev.resize.w, ev.resize.h, pixels);
}
if (ev.type == MTK_EVENT_SCALE)
monkey_native_set_scale(g, mtk_win_getscale());
g->dirty = true;
} else if (ev.type == MTK_EVENT_KEY) key_event(g, &ev.key);
else if (ev.type == MTK_EVENT_MOUSE) mouse_event(g, &ev);
g = monkey_native_get_window();
if (g == NULL) break;
}
if (g == NULL) break;
clamp_scroll(g);
if (g->dirty) monkey_native_redraw(g);
mtk_sleep_ms(5);
}
mtk_netsurf_icons_cleanup();
}
Reference in new issue View Git Blame Copy Permalink