diff options
Diffstat (limited to 'frontends/beos/gui.cpp')
-rw-r--r-- | frontends/beos/gui.cpp | 1109 |
1 files changed, 1109 insertions, 0 deletions
diff --git a/frontends/beos/gui.cpp b/frontends/beos/gui.cpp new file mode 100644 index 000000000..2e0aa4cc5 --- /dev/null +++ b/frontends/beos/gui.cpp @@ -0,0 +1,1109 @@ +/* + * Copyright 2015 Adrián Arroyo Calle <adrian.arroyocalle@gmail.com> + * Copyright 2008 François Revol <mmu_man@users.sourceforge.net> + * Copyright 2005 James Bursa <bursa@users.sourceforge.net> + * + * This file is part of NetSurf, http://www.netsurf-browser.org/ + * + * NetSurf is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * NetSurf is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#define __STDBOOL_H__ 1 +#include <assert.h> +#include <ctype.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <limits.h> +#include <sys/select.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <curl/curl.h> + +#include <Alert.h> +#include <Application.h> +#include <BeBuild.h> +#include <FindDirectory.h> +#include <Mime.h> +#include <Path.h> +#include <PathFinder.h> +#include <Resources.h> +#include <Roster.h> +#include <Screen.h> +#include <String.h> + +extern "C" { + +#include "utils/nsoption.h" +#include "utils/filename.h" +#include "utils/log.h" +#include "utils/messages.h" +#include "utils/url.h" +#include "utils/corestrings.h" +#include "utils/utf8.h" +#include "utils/utils.h" + +#include "content/content.h" +#include "content/content_protected.h" +#include "content/fetch.h" +#include "content/fetchers.h" +#include "content/fetchers/resource.h" +#include "content/hlcache.h" +#include "content/urldb.h" +#include "desktop/browser.h" +#include "desktop/gui_misc.h" +#include "desktop/gui_clipboard.h" +#include "desktop/gui_search.h" +#include "desktop/gui_fetch.h" +#include "desktop/netsurf.h" + +} + +#include "beos/gui.h" +#include "beos/gui_options.h" +//#include "beos/completion.h" +#include "beos/window.h" +#include "beos/throbber.h" +#include "beos/filetype.h" +#include "beos/download.h" +#include "beos/schedule.h" +#include "beos/fetch_rsrc.h" +#include "beos/scaffolding.h" +#include "beos/bitmap.h" +#include "beos/font.h" + +//TODO: use resources +// enable using resources instead of files +#define USE_RESOURCES 1 + +bool nsbeos_done = false; + +bool replicated = false; /**< if we are running as a replicant */ + +char *options_file_location; +char *glade_file_location; + +struct gui_window *search_current_window = 0; + +BWindow *wndAbout; +BWindow *wndWarning; +//GladeXML *gladeWindows; +BWindow *wndTooltip; +//beosLabel *labelTooltip; +BFilePanel *wndOpenFile; + +static thread_id sBAppThreadID; + +static BMessage *gFirstRefsReceived = NULL; + +static int sEventPipe[2]; + +// #pragma mark - class NSBrowserFrameView + + +/* exported function defined in beos/gui.h */ +nserror beos_warn_user(const char *warning, const char *detail) +{ + LOG("warn_user: %s (%s)", warning, detail); + BAlert *alert; + BString text(warning); + if (detail) + text << ":\n" << detail; + + alert = new BAlert("NetSurf Warning", text.String(), "Debug", "Ok", + NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT); + if (alert->Go() < 1) { + debugger("warn_user"); + } + + return NSERROR_OK; +} + +NSBrowserApplication::NSBrowserApplication() + : BApplication("application/x-vnd.NetSurf") +{ +} + + +NSBrowserApplication::~NSBrowserApplication() +{ +} + + +void +NSBrowserApplication::MessageReceived(BMessage *message) +{ + switch (message->what) { + case B_REFS_RECEIVED: + case B_UI_SETTINGS_CHANGED: + // messages for top-level + // we'll just send them to the first window + case 'back': + case 'forw': + case 'stop': + case 'relo': + case 'home': + case 'urlc': + case 'urle': + case 'sear': + case 'menu': + // NetPositive messages + case B_NETPOSITIVE_OPEN_URL: + case B_NETPOSITIVE_BACK: + case B_NETPOSITIVE_FORWARD: + case B_NETPOSITIVE_HOME: + case B_NETPOSITIVE_RELOAD: + case B_NETPOSITIVE_STOP: + case B_NETPOSITIVE_DOWN: + case B_NETPOSITIVE_UP: + //DetachCurrentMessage(); + //nsbeos_pipe_message(message, this, fGuiWindow); + break; + default: + BApplication::MessageReceived(message); + } +} + + +void +NSBrowserApplication::ArgvReceived(int32 argc, char **argv) +{ + NSBrowserWindow *win = nsbeos_find_last_window(); + if (!win) { + return; + } + win->Unlock(); + BMessage *message = DetachCurrentMessage(); + nsbeos_pipe_message_top(message, win, win->Scaffolding()); +} + + +void +NSBrowserApplication::RefsReceived(BMessage *message) +{ + DetachCurrentMessage(); + NSBrowserWindow *win = nsbeos_find_last_window(); + if (!win) { + gFirstRefsReceived = message; + return; + } + win->Unlock(); + nsbeos_pipe_message_top(message, win, win->Scaffolding()); +} + + +void +NSBrowserApplication::AboutRequested() +{ + nsbeos_pipe_message(new BMessage(B_ABOUT_REQUESTED), NULL, NULL); +} + + +bool +NSBrowserApplication::QuitRequested() +{ + // let it notice it + nsbeos_pipe_message(new BMessage(B_QUIT_REQUESTED), NULL, NULL); + // we'll let the main thread Quit() ourselves when it's done. + return false; +} + + +// #pragma mark - implementation + + + +/* realpath fallback on R5 */ +#if !defined(__HAIKU__) && !defined(B_BEOS_VERSION_DANO) +extern "C" char *realpath(const char *f, char *buf); +char *realpath(const char *f, char *buf) +{ + BPath path(f, NULL, true); + if (path.InitCheck() < 0) { + strncpy(buf, f, MAXPATHLEN); + return NULL; + } + //printf("RP: '%s'\n", path.Path()); + strncpy(buf, path.Path(), MAXPATHLEN); + return buf; +} +#endif + +/* finds the NetSurf binary image ID and path + * + */ +image_id nsbeos_find_app_path(char *path) +{ + image_info info; + int32 cookie = 0; + while (get_next_image_info(0, &cookie, &info) == B_OK) { +//fprintf(stderr, "%p <> %p, %p\n", (char *)&find_app_resources, (char *)info.text, (char *)info.text + info.text_size); + if (((char *)&nsbeos_find_app_path >= (char *)info.text) + && ((char *)&nsbeos_find_app_path < (char *)info.text + info.text_size)) { +//fprintf(stderr, "match\n"); + if (path) { + memset(path, 0, B_PATH_NAME_LENGTH); + strncpy(path, info.name, B_PATH_NAME_LENGTH-1); + } + return info.id; + } + } + return B_ERROR; +} + +/** + * Locate a shared resource file by searching known places in order. + * + * Search order is: ~/config/settings/NetSurf/, ~/.netsurf/, $NETSURFRES/ + * (where NETSURFRES is an environment variable), and finally the path + * specified by the macro at the top of this file. + * + * \param buf buffer to write to. must be at least PATH_MAX chars + * \param filename file to look for + * \param def default to return if file not found + * \return path to resource. + */ +char *find_resource(char *buf, const char *filename, const char *def) +{ + const char *cdir = NULL; + status_t err; + BPath path; + char t[PATH_MAX]; + + err = find_directory(B_USER_SETTINGS_DIRECTORY, &path); + path.Append("NetSurf"); + if (err >= B_OK) + cdir = path.Path(); + if (cdir != NULL) { + strcpy(t, cdir); + strcat(t, "/"); + strcat(t, filename); + realpath(t, buf); + if (access(buf, R_OK) == 0) + return buf; + } + + cdir = getenv("HOME"); + if (cdir != NULL) { + strcpy(t, cdir); + strcat(t, "/.netsurf/"); + strcat(t, filename); + realpath(t, buf); + if (access(buf, R_OK) == 0) + return buf; + } + + cdir = getenv("NETSURFRES"); + + if (cdir != NULL) { + realpath(cdir, buf); + strcat(buf, "/"); + strcat(buf, filename); + if (access(buf, R_OK) == 0) + return buf; + } + + + BPathFinder f((void*)find_resource); + + BPath p; + if (f.FindPath(B_FIND_PATH_APPS_DIRECTORY, "netsurf/res", p) == B_OK) { + strcpy(t, p.Path()); + strcat(t, filename); + realpath(t, buf); + if (access(buf, R_OK) == 0) + return buf; + } + + if (def[0] == '%') { + snprintf(t, PATH_MAX, "%s%s", path.Path(), def + 1); + if (realpath(t, buf) == NULL) { + strcpy(buf, t); + } + } else if (def[0] == '~') { + snprintf(t, PATH_MAX, "%s%s", getenv("HOME"), def + 1); + if (realpath(t, buf) == NULL) { + strcpy(buf, t); + } + } else { + if (realpath(def, buf) == NULL) { + strcpy(buf, def); + } + } + + return buf; +} + +/** + * Check that ~/.netsurf/ exists, and if it doesn't, create it. + */ +static void check_homedir(void) +{ + status_t err; + + BPath path; + err = find_directory(B_USER_SETTINGS_DIRECTORY, &path, true); + + if (err < B_OK) { + /* we really can't continue without a home directory. */ + LOG("Can't find user settings directory - nowhere to store state!"); + die("NetSurf needs to find the user settings directory in order to run.\n"); + } + + path.Append("NetSurf"); + err = create_directory(path.Path(), 0644); + if (err < B_OK) { + LOG("Unable to create %s", path.Path()); + die("NetSurf could not create its settings directory.\n"); + } +} + +static int32 bapp_thread(void *arg) +{ + be_app->Lock(); + be_app->Run(); + return 0; +} + +static nsurl *gui_get_resource_url(const char *path) +{ + nsurl *url = NULL; + BString u("rsrc:///"); + + /* default.css -> beosdefault.css */ + if (strcmp(path, "default.css") == 0) + path = "beosdefault.css"; + + /* favicon.ico -> favicon.png */ + if (strcmp(path, "favicon.ico") == 0) + path = "favicon.png"; + + u << path; + LOG("(%s) -> '%s'\n", path, u.String()); + nsurl_create(u.String(), &url); + return url; +} + + + +#if !defined(__HAIKU__) && !defined(B_BEOS_VERSION_DANO) +/* more ui_colors, R5 only had a few defined... */ +#define B_PANEL_TEXT_COLOR ((color_which)10) +#define B_DOCUMENT_BACKGROUND_COLOR ((color_which)11) +#define B_DOCUMENT_TEXT_COLOR ((color_which)12) +#define B_CONTROL_BACKGROUND_COLOR ((color_which)13) +#define B_CONTROL_TEXT_COLOR ((color_which)14) +#define B_CONTROL_BORDER_COLOR ((color_which)15) +#define B_CONTROL_HIGHLIGHT_COLOR ((color_which)16) +#define B_NAVIGATION_BASE_COLOR ((color_which)4) +#define B_NAVIGATION_PULSE_COLOR ((color_which)17) +#define B_SHINE_COLOR ((color_which)18) +#define B_SHADOW_COLOR ((color_which)19) +#define B_MENU_SELECTED_BORDER_COLOR ((color_which)9) +#define B_TOOL_TIP_BACKGROUND_COLOR ((color_which)20) +#define B_TOOL_TIP_TEXT_COLOR ((color_which)21) +#define B_SUCCESS_COLOR ((color_which)100) +#define B_FAILURE_COLOR ((color_which)101) +#define B_MENU_SELECTED_BACKGROUND_COLOR B_MENU_SELECTION_BACKGROUND_COLOR +#define B_RANDOM_COLOR ((color_which)0x80000000) +#define B_MICHELANGELO_FAVORITE_COLOR ((color_which)0x80000001) +#define B_DSANDLER_FAVORITE_SKY_COLOR ((color_which)0x80000002) +#define B_DSANDLER_FAVORITE_INK_COLOR ((color_which)0x80000003) +#define B_DSANDLER_FAVORITE_SHOES_COLOR ((color_which)0x80000004) +#define B_DAVE_BROWN_FAVORITE_COLOR ((color_which)0x80000005) +#endif +#if defined(B_BEOS_VERSION_DANO) +#define B_TOOL_TIP_BACKGROUND_COLOR B_TOOLTIP_BACKGROUND_COLOR +#define B_TOOL_TIP_TEXT_COLOR B_TOOLTIP_TEXT_COLOR +#define +#endif +#define NOCOL ((color_which)0) + +/** + * set option from pen + */ +static nserror +set_colour_from_ui(struct nsoption_s *opts, + color_which ui, + enum nsoption_e option, + colour def_colour) +{ + if (ui != NOCOL) { + rgb_color c; + if (ui == B_DESKTOP_COLOR) { + BScreen s; + c = s.DesktopColor(); + } else { + c = ui_color(ui); + } + + def_colour = ((((uint32_t)c.blue << 16) & 0xff0000) | + ((c.green << 8) & 0x00ff00) | + ((c.red) & 0x0000ff)); + } + + opts[option].value.c = def_colour; + + return NSERROR_OK; +} + +/** + * Set option defaults for framebuffer frontend + * + * @param defaults The option table to update. + * @return error status. + */ +static nserror set_defaults(struct nsoption_s *defaults) +{ + /* set system colours for beos ui */ + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_ActiveBorder, 0x00000000); + set_colour_from_ui(defaults, B_WINDOW_TAB_COLOR, NSOPTION_sys_colour_ActiveCaption, 0x00dddddd); + set_colour_from_ui(defaults, B_PANEL_BACKGROUND_COLOR, NSOPTION_sys_colour_AppWorkspace, 0x00eeeeee); + set_colour_from_ui(defaults, B_DESKTOP_COLOR, NSOPTION_sys_colour_Background, 0x00aa0000); + set_colour_from_ui(defaults, B_CONTROL_BACKGROUND_COLOR, NSOPTION_sys_colour_ButtonFace, 0x00aaaaaa); + set_colour_from_ui(defaults, B_CONTROL_HIGHLIGHT_COLOR, NSOPTION_sys_colour_ButtonHighlight, 0x00cccccc); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_ButtonShadow, 0x00bbbbbb); + set_colour_from_ui(defaults, B_CONTROL_TEXT_COLOR, NSOPTION_sys_colour_ButtonText, 0x00000000); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_CaptionText, 0x00000000); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_GrayText, 0x00777777); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_Highlight, 0x00ee0000); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_HighlightText, 0x00000000); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_InactiveBorder, 0x00000000); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_InactiveCaption, 0x00ffffff); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_InactiveCaptionText, 0x00cccccc); + set_colour_from_ui(defaults, B_TOOL_TIP_BACKGROUND_COLOR, NSOPTION_sys_colour_InfoBackground, 0x00aaaaaa); + set_colour_from_ui(defaults, B_TOOL_TIP_TEXT_COLOR, NSOPTION_sys_colour_InfoText, 0x00000000); + set_colour_from_ui(defaults, B_MENU_BACKGROUND_COLOR, NSOPTION_sys_colour_Menu, 0x00aaaaaa); + set_colour_from_ui(defaults, B_MENU_ITEM_TEXT_COLOR, NSOPTION_sys_colour_MenuText, 0x00000000); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_Scrollbar, 0x00aaaaaa); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_ThreeDDarkShadow, 0x00555555); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_ThreeDFace, 0x00dddddd); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_ThreeDHighlight, 0x00aaaaaa); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_ThreeDLightShadow, 0x00999999); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_ThreeDShadow, 0x00777777); + set_colour_from_ui(defaults, B_DOCUMENT_BACKGROUND_COLOR, NSOPTION_sys_colour_Window, 0x00aaaaaa); + set_colour_from_ui(defaults, NOCOL, NSOPTION_sys_colour_WindowFrame, 0x00000000); + set_colour_from_ui(defaults, B_DOCUMENT_TEXT_COLOR, NSOPTION_sys_colour_WindowText, 0x00000000); + + return NSERROR_OK; +} + +void nsbeos_update_system_ui_colors(void) +{ + set_defaults(nsoptions); +} + +/** + * Ensures output logging stream is correctly configured + */ +static bool nslog_stream_configure(FILE *fptr) +{ + /* set log stream to be non-buffering */ + setbuf(fptr, NULL); + + return true; +} + +static BPath get_messages_path() +{ + BPathFinder f((void*)get_messages_path); + + BPath p; + f.FindPath(B_FIND_PATH_APPS_DIRECTORY, "netsurf/res", p); + // TODO: use Haiku's BLocale stuff + BString lang(getenv("LC_MESSAGES")); + lang.Truncate(2); + BDirectory d(p.Path()); + if (!d.Contains(lang.String(), B_DIRECTORY_NODE)) + lang = "en"; + p.Append(lang.String()); + p.Append("Messages"); + return p; +} + + +static void gui_init(int argc, char** argv) +{ + const char *addr; + nsurl *url; + nserror error; + char buf[PATH_MAX]; + + if (pipe(sEventPipe) < 0) + return; + if (!replicated) { + sBAppThreadID = spawn_thread(bapp_thread, "BApplication(NetSurf)", B_NORMAL_PRIORITY, (void *)find_thread(NULL)); + if (sBAppThreadID < B_OK) + return; /* #### handle errors */ + if (resume_thread(sBAppThreadID) < B_OK) + return; + } + + nsbeos_update_system_ui_colors(); + + fetch_rsrc_register(); + + check_homedir(); + + // make sure the cache dir exists + create_directory(TEMP_FILENAME_PREFIX, 0700); + + //nsbeos_completion_init(); + + + /* This is an ugly hack to just get the new-style throbber going. + * It, along with the PNG throbber loader, need making more generic. + */ + { +#define STROF(n) #n +#define FIND_THROB(n) filenames[(n)] = \ + "throbber/throbber" STROF(n) ".png"; + const char *filenames[9]; + FIND_THROB(0); + FIND_THROB(1); + FIND_THROB(2); + FIND_THROB(3); + FIND_THROB(4); + FIND_THROB(5); + FIND_THROB(6); + FIND_THROB(7); + FIND_THROB(8); + nsbeos_throbber_initialise_from_png(9, + filenames[0], filenames[1], filenames[2], filenames[3], + filenames[4], filenames[5], filenames[6], filenames[7], + filenames[8]); +#undef FIND_THROB +#undef STROF + } + + if (nsbeos_throbber == NULL) + die("Unable to load throbber image.\n"); + + find_resource(buf, "Choices", "%/Choices"); + LOG("Using '%s' as Preferences file", buf); + options_file_location = strdup(buf); + nsoption_read(buf, NULL); + + + /* check what the font settings are, setting them to a default font + * if they're not set - stops Pango whinging + */ +#define SETFONTDEFAULT(OPTION,y) if (nsoption_charp(OPTION) == NULL) nsoption_set_charp(OPTION, strdup((y))) + + //XXX: use be_plain_font & friends, when we can check if font is serif or not. +/* + font_family family; + font_style style; + be_plain_font->GetFamilyAndStyle(&family, &style); + SETFONTDEFAULT(font_sans, family); + SETFONTDEFAULT(font_serif, family); + SETFONTDEFAULT(font_mono, family); + SETFONTDEFAULT(font_cursive, family); + SETFONTDEFAULT(font_fantasy, family); +*/ +#ifdef __HAIKU__ + SETFONTDEFAULT(font_sans, "DejaVu Sans"); + SETFONTDEFAULT(font_serif, "DejaVu Serif"); + SETFONTDEFAULT(font_mono, "DejaVu Mono"); + SETFONTDEFAULT(font_cursive, "DejaVu Sans"); + SETFONTDEFAULT(font_fantasy, "DejaVu Sans"); +#else + SETFONTDEFAULT(font_sans, "Bitstream Vera Sans"); + SETFONTDEFAULT(font_serif, "Bitstream Vera Serif"); + SETFONTDEFAULT(font_mono, "Bitstream Vera Sans Mono"); + SETFONTDEFAULT(font_cursive, "Bitstream Vera Serif"); + SETFONTDEFAULT(font_fantasy, "Bitstream Vera Serif"); +#endif + + nsbeos_options_init(); + + /* We don't yet have an implementation of "select" form elements (they should use a popup menu) + * So we use the cross-platform code instead. */ + nsoption_set_bool(core_select_menu, true); + + if (nsoption_charp(cookie_file) == NULL) { + find_resource(buf, "Cookies", "%/Cookies"); + LOG("Using '%s' as Cookies file", buf); + nsoption_set_charp(cookie_file, strdup(buf)); + } + if (nsoption_charp(cookie_jar) == NULL) { + find_resource(buf, "Cookies", "%/Cookies"); + LOG("Using '%s' as Cookie Jar file", buf); + nsoption_set_charp(cookie_jar, strdup(buf)); + } + if ((nsoption_charp(cookie_file) == NULL) || + (nsoption_charp(cookie_jar) == NULL)) + die("Failed initialising cookie options"); + + if (nsoption_charp(url_file) == NULL) { + find_resource(buf, "URLs", "%/URLs"); + LOG("Using '%s' as URL file", buf); + nsoption_set_charp(url_file, strdup(buf)); + } + + if (nsoption_charp(ca_path) == NULL) { + find_resource(buf, "certs", "/etc/ssl/certs"); + LOG("Using '%s' as certificate path", buf); + nsoption_set_charp(ca_path, strdup(buf)); + } + + //find_resource(buf, "mime.types", "/etc/mime.types"); + beos_fetch_filetype_init(); + + urldb_load(nsoption_charp(url_file)); + urldb_load_cookies(nsoption_charp(cookie_file)); + + //nsbeos_download_initialise(); + + if (!replicated) + be_app->Unlock(); + + if (argc > 1) { + addr = argv[1]; + } else if (nsoption_charp(homepage_url) != NULL) { + addr = nsoption_charp(homepage_url); + } else { + addr = NETSURF_HOMEPAGE; + } + + /* create an initial browser window */ + error = nsurl_create(addr, &url); + if (error == NSERROR_OK) { + error = browser_window_create( + BW_CREATE_HISTORY, + url, + NULL, + NULL, + NULL); + nsurl_unref(url); + } + if (error != NSERROR_OK) { + beos_warn_user(messages_get_errorcode(error), 0); + } + + if (gFirstRefsReceived) { + // resend the refs we got before having a window to send them to + be_app_messenger.SendMessage(gFirstRefsReceived); + delete gFirstRefsReceived; + gFirstRefsReceived = NULL; + } + +} + + + + +void nsbeos_pipe_message(BMessage *message, BView *_this, struct gui_window *gui) +{ + if (message == NULL) { + fprintf(stderr, "%s(NULL)!\n", __FUNCTION__); + return; + } + if (_this) + message->AddPointer("View", _this); + if (gui) + message->AddPointer("gui_window", gui); + write(sEventPipe[1], &message, sizeof(void *)); +} + + +void nsbeos_pipe_message_top(BMessage *message, BWindow *_this, struct beos_scaffolding *scaffold) +{ + if (message == NULL) { + fprintf(stderr, "%s(NULL)!\n", __FUNCTION__); + return; + } + if (_this) + message->AddPointer("Window", _this); + if (scaffold) + message->AddPointer("scaffolding", scaffold); + write(sEventPipe[1], &message, sizeof(void *)); +} + + +void nsbeos_gui_poll(void) +{ + fd_set read_fd_set, write_fd_set, exc_fd_set; + int max_fd; + struct timeval timeout; + unsigned int fd_count = 0; + bigtime_t next_schedule = 0; + + /* get any active fetcher fd */ + fetcher_fdset(&read_fd_set, &write_fd_set, &exc_fd_set, &max_fd); + + /* run the scheduler */ + schedule_run(); + + // our own event pipe + FD_SET(sEventPipe[0], &read_fd_set); + + // max of all the fds in the set, plus one for select() + max_fd = MAX(max_fd, sEventPipe[0]) + 1; + + // compute schedule timeout + if (earliest_callback_timeout != B_INFINITE_TIMEOUT) { + next_schedule = earliest_callback_timeout - system_time(); + } else { + next_schedule = earliest_callback_timeout; + } + + // we're quite late already... + if (next_schedule < 0) + next_schedule = 0; + + timeout.tv_sec = (long)(next_schedule / 1000000LL); + timeout.tv_usec = (long)(next_schedule % 1000000LL); + + //LOG("gui_poll: select(%d, ..., %Ldus", max_fd, next_schedule); + fd_count = select(max_fd, &read_fd_set, &write_fd_set, &exc_fd_set, + &timeout); + //LOG("select: %d\n", fd_count); + + if (fd_count > 0 && FD_ISSET(sEventPipe[0], &read_fd_set)) { + BMessage *message; + int len = read(sEventPipe[0], &message, sizeof(void *)); + //LOG("gui_poll: BMessage ? %d read", len); + if (len == sizeof(void *)) { + //LOG("gui_poll: BMessage.what %-4.4s\n", &(message->what)); + nsbeos_dispatch_event(message); + } + } +} + + +static void gui_quit(void) +{ + urldb_save_cookies(nsoption_charp(cookie_jar)); + urldb_save(nsoption_charp(url_file)); + //options_save_tree(hotlist,nsoption_charp(hotlist_file),messages_get("TreeHotlist")); + + free(nsoption_charp(cookie_file)); + free(nsoption_charp(cookie_jar)); + beos_fetch_filetype_fin(); + fetch_rsrc_unregister(); +} + +static char *url_to_path(const char *url) +{ + char *url_path = curl_unescape(url, 0); + char *path; + + /* return the absolute path including leading / */ + path = strdup(url_path + (FILE_SCHEME_PREFIX_LEN - 1)); + curl_free(url_path); + + return path; +} + +/** + * Send the source of a content to a text editor. + */ + +void nsbeos_gui_view_source(struct hlcache_handle *content) +{ + char *temp_name; + bool done = false; + BPath path; + status_t err; + size_t size; + const char *source = content_get_source_data(content, &size); + + if (!content || !source) { + beos_warn_user("MiscError", "No document source"); + return; + } + + /* try to load local files directly. */ + temp_name = url_to_path(nsurl_access(hlcache_handle_get_url(content))); + if (temp_name) { + path.SetTo(temp_name); + BEntry entry; + if (entry.SetTo(path.Path()) >= B_OK + && entry.Exists() && entry.IsFile()) + done = true; + } + if (!done) { + /* We cannot release the requested filename until after it + * has finished being used. As we can't easily find out when + * this is, we simply don't bother releasing it and simply + * allow it to be re-used next time NetSurf is started. The + * memory overhead from doing this is under 1 byte per + * filename. */ + const char *filename = filename_request(); + if (!filename) { + beos_warn_user("NoMemory", 0); + return; + } + path.SetTo(TEMP_FILENAME_PREFIX); + path.Append(filename); + BFile file(path.Path(), B_WRITE_ONLY | B_CREATE_FILE); + err = file.InitCheck(); + if (err < B_OK) { + beos_warn_user("IOError", strerror(err)); + return; + } + err = file.Write(source, size); + if (err < B_OK) { + beos_warn_user("IOError", strerror(err)); + return; + } + lwc_string *mime = content_get_mime_type(content); + if (mime) { + file.WriteAttr("BEOS:TYPE", B_MIME_STRING_TYPE, 0LL, + lwc_string_data(mime), lwc_string_length(mime) + 1); + lwc_string_unref(mime); + } + + } + + entry_ref ref; + if (get_ref_for_path(path.Path(), &ref) < B_OK) + return; + + BMessage m(B_REFS_RECEIVED); + m.AddRef("refs", &ref); + + + // apps to try + const char *editorSigs[] = { + "application/x-vnd.beunited.pe", + "application/x-vnd.XEmacs", + "application/x-vnd.Haiku-StyledEdit", + "application/x-vnd.Be-STEE", + "application/x-vnd.yT-STEE", + NULL + }; + int i; + for (i = 0; editorSigs[i]; i++) { + team_id team = -1; + { + BMessenger msgr(editorSigs[i], team); + if (msgr.SendMessage(&m) >= B_OK) + break; + } + + err = be_roster->Launch(editorSigs[i], (BMessage *)&m, &team); + if (err >= B_OK) + break; + } +} + +/** + * Broadcast an URL that we can't handle. + */ + +static nserror gui_launch_url(struct nsurl *url) +{ + status_t status; + // try to open it as an URI + BString mimeType = "application/x-vnd.Be.URL."; + BString arg(nsurl_access(url)); + + mimeType.Append(arg, arg.FindFirst(":")); + + // special case, text/x-email is used traditionally + // use it instead + if (arg.IFindFirst("mailto:") == 0) + mimeType = "text/x-email"; + + // the protocol should be alphanum + // we just check if it's registered + // if not there is likely no supporting app anyway + if (!BMimeType::IsValid(mimeType.String())) + return NSERROR_NO_FETCH_HANDLER; + char *args[2] = { (char *)nsurl_access(url), NULL }; + status = be_roster->Launch(mimeType.String(), 1, args); + if (status < B_OK) + beos_warn_user("Cannot launch url", strerror(status)); + return NSERROR_OK; +} + + + +void die(const char * const error) +{ + fprintf(stderr, "%s", error); + BAlert *alert; + BString text("Cannot continue:\n"); + text << error; + + alert = new BAlert("NetSurf Error", text.String(), "Debug", "Ok", NULL, + B_WIDTH_AS_USUAL, B_STOP_ALERT); + if (alert->Go() < 1) + debugger("die"); + + exit(EXIT_FAILURE); +} + + +static struct gui_fetch_table beos_fetch_table = { + fetch_filetype, + gui_get_resource_url, + NULL, // ??? + NULL, // release_resource_data + NULL, // fetch_mimetype +}; + +static struct gui_misc_table beos_misc_table = { + beos_schedule, + beos_warn_user, + gui_quit, + gui_launch_url, + NULL, //cert_verify + gui_401login_open, + NULL, // pdf_password (if we have Haru support) +}; + + +/** Normal entry point from OS */ +int main(int argc, char** argv) +{ + nserror ret; + BPath options; + struct netsurf_table beos_table = { + &beos_misc_table, + beos_window_table, + beos_download_table, + beos_clipboard_table, + &beos_fetch_table, + NULL, /* use POSIX file */ + NULL, /* default utf8 */ + NULL, /* default search */ + NULL, /* default web search */ + NULL, /* default low level cache persistant storage */ + beos_bitmap_table, + beos_layout_table + }; + + ret = netsurf_register(&beos_table); + if (ret != NSERROR_OK) { + die("NetSurf operation table failed registration"); + } + + if (find_directory(B_USER_SETTINGS_DIRECTORY, &options, true) == B_OK) { + options.Append("x-vnd.NetSurf"); + } + + if (!replicated) { + // create the Application object before trying to use messages + // so we can open an alert in case of error. + new NSBrowserApplication; + } + + /* initialise logging. Not fatal if it fails but not much we + * can do about it either. + */ + nslog_init(nslog_stream_configure, &argc, argv); + + /* user options setup */ + ret = nsoption_init(set_defaults, &nsoptions, &nsoptions_default); + if (ret != NSERROR_OK) { + die("Options failed to initialise"); + } + nsoption_read(options.Path(), NULL); + nsoption_commandline(&argc, argv, NULL); + + /* common initialisation */ + BResources resources; + resources.SetToImage((const void*)main); + size_t size = 0; + + char path[12]; + sprintf(path,"%.2s/Messages", getenv("LC_MESSAGES")); + fprintf(stderr, "Loading messages from resource %s\n", path); + + const uint8_t* res = (const uint8_t*)resources.LoadResource('data', path, &size); + if (size > 0 && res != NULL) { + ret = messages_add_from_inline(res, size); + } else { + BPath messages = get_messages_path(); + ret = messages_add_from_file(messages.Path()); + } + + ret = netsurf_init(NULL); + if (ret != NSERROR_OK) { + die("NetSurf failed to initialise"); + } + + gui_init(argc, argv); + + while (!nsbeos_done) { + nsbeos_gui_poll(); + } + + netsurf_exit(); + + return 0; +} + +/** called when replicated from NSBaseView::Instantiate() */ +int gui_init_replicant(int argc, char** argv) +{ + nserror ret; + BPath options; + struct netsurf_table beos_table = { + &beos_misc_table, + beos_window_table, + beos_download_table, + beos_clipboard_table, + &beos_fetch_table, + NULL, /* use POSIX file */ + NULL, /* default utf8 */ + NULL, /* default search */ + NULL, /* default web search */ + NULL, /* default low level cache persistant storage */ + beos_bitmap_table, + beos_layout_table + }; + + ret = netsurf_register(&beos_table); + if (ret != NSERROR_OK) { + die("NetSurf operation table failed registration"); + } + + if (find_directory(B_USER_SETTINGS_DIRECTORY, &options, true) == B_OK) { + options.Append("x-vnd.NetSurf"); + } + + /* initialise logging. Not fatal if it fails but not much we + * can do about it either. + */ + nslog_init(nslog_stream_configure, &argc, argv); + + // FIXME: use options as readonly for replicants + /* user options setup */ + ret = nsoption_init(set_defaults, &nsoptions, &nsoptions_default); + if (ret != NSERROR_OK) { + // FIXME: must not die when in replicant! + die("Options failed to initialise"); + } + nsoption_read(options.Path(), NULL); + nsoption_commandline(&argc, argv, NULL); + + /* common initialisation */ + BPath messages = get_messages_path(); + ret = messages_add_from_file(messages.Path()); + + ret = netsurf_init(NULL); + if (ret != NSERROR_OK) { + // FIXME: must not die when in replicant! + die("NetSurf failed to initialise"); + } + + gui_init(argc, argv); + + return 0; +} |