gui.cpp

Go to the documentation of this file.

/*
 * 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 <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>
#ifdef __HAIKU__
#include <LocaleRoster.h>
#endif
 
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 "utils/nsurl.h"
#include "netsurf/misc.h"
#include "netsurf/clipboard.h"
#include "netsurf/search.h"
#include "netsurf/fetch.h"
#include "netsurf/netsurf.h"
#include "netsurf/content.h"
#include "netsurf/browser_window.h"
#include "netsurf/cookie_db.h"
#include "netsurf/url_db.h"
#include "content/fetch.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)
{
        NSLOG(netsurf, INFO, "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. */
                NSLOG(netsurf, INFO,
                      "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) {
                NSLOG(netsurf, INFO, "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;
        NSLOG(netsurf, INFO, "(%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 beos frontend
 *
 * @param defaults The option table to update.
 * @return error status.
 */
static nserror set_option_defaults(struct nsoption_s *defaults)
{
        /* set system colours for beos ui */
        struct {
                color_which ui;
                colour dflt;
                enum nsoption_e option;
        } entries[] = {
                {
                        B_DOCUMENT_TEXT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_AccentColor
                }, {
                        B_CONTROL_HIGHLIGHT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_AccentColorText
                }, {
                        B_SHINE_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_ActiveText
                }, {
                        B_CONTROL_BORDER_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_ButtonBorder
                }, {
                        B_CONTROL_BACKGROUND_COLOR,
                        0x00aaaaaa,
                        NSOPTION_sys_colour_ButtonFace
                }, {
                        B_CONTROL_TEXT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_ButtonText
                }, {
                        B_DOCUMENT_BACKGROUND_COLOR,
                        0x00aaaaaa,
                        NSOPTION_sys_colour_Canvas
                }, {
                        B_DOCUMENT_TEXT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_CanvasText
                }, {
                        B_CONTROL_BACKGROUND_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_Field
                }, {
                        B_CONTROL_TEXT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_FieldText
                }, {
                        NOCOL,
                        0x00777777,
                        NSOPTION_sys_colour_GrayText
                }, {
                        NOCOL,
                        0x00ee0000,
                        NSOPTION_sys_colour_Highlight
                }, {
                        NOCOL,
                        0x00000000,
                        NSOPTION_sys_colour_HighlightText
                }, {
                        B_LINK_TEXT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_LinkText
                }, {
                        B_CONTROL_MARK_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_Mark
                }, {
                        B_CONTROL_TEXT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_MarkText
                }, {
                        B_TOOL_TIP_BACKGROUND_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_SelectedItem
                }, {
                        B_TOOL_TIP_TEXT_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_SelectedItemText
                }, {
                        B_LINK_VISITED_COLOR,
                        0x00000000,
                        NSOPTION_sys_colour_VisitedText
                }, {
                        NOCOL,
                        0x00000000,
                        NSOPTION_LISTEND
                },
        };
 
        int idx;
 
        for (idx=0; entries[idx].option != NSOPTION_LISTEND; idx++) {
                set_colour_from_ui(defaults,
                                   entries[idx].ui,
                                   entries[idx].option,
                                   entries[idx].dflt);
        }
 
        return NSERROR_OK;
}
 
void nsbeos_update_system_ui_colors(void)
{
        set_option_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);
        BString lang;
#ifdef __HAIKU__
        BMessage preferredLangs;
        if (BLocaleRoster::Default()->GetPreferredLanguages(&preferredLangs) == B_OK) {
                preferredLangs.FindString("language", 0, &lang);
                lang.Truncate(2);
        }
#endif
        if (lang.Length() < 1) {
                lang.SetTo(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");
        NSLOG(netsurf, INFO, "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");
                NSLOG(netsurf, INFO, "Using '%s' as Cookies file", buf);
                nsoption_set_charp(cookie_file, strdup(buf));
        }
        if (nsoption_charp(cookie_jar) == NULL) {
                find_resource(buf, "Cookies", "%/Cookies");
                NSLOG(netsurf, INFO, "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");
                NSLOG(netsurf, INFO, "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");
                NSLOG(netsurf, INFO, "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;
 
        /* run the scheduler */
        schedule_run();
 
        /* get any active fetcher fd */
        fetch_fdset(&read_fd_set, &write_fd_set, &exc_fd_set, &max_fd);
 
        // 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);
 
        NSLOG(netsurf, DEEPDEBUG,
              "gui_poll: select(%d, ..., %Ldus",
              max_fd, next_schedule);
        fd_count = select(max_fd, &read_fd_set, &write_fd_set, &exc_fd_set, 
                &timeout);
        NSLOG(netsurf, DEEPDEBUG, "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 *));
                NSLOG(netsurf, DEEPDEBUG, "gui_poll: BMessage ? %d read", len);
                if (len == sizeof(void *)) {
                        NSLOG(netsurf, DEEPDEBUG,
                              "gui_poll: BMessage.what %-4.4s\n",
                              (char *)&(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;
        char *path = NULL;
 
        if (url_unescape(url, 0, NULL, &url_path) == NSERROR_OK) {
                /* return the absolute path including leading / */
                path = strdup(url_path + (FILE_SCHEME_PREFIX_LEN - 1));
                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 uint8_t *source;
 
        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. */
                BString filename(filename_request());
                if (filename.IsEmpty()) {
                        beos_warn_user("NoMemory", 0);
                        return;
                }
 
                lwc_string *mime = content_get_mime_type(content);
 
                /* provide an extension, as Pe still doesn't sniff the MIME */
                if (mime) {
                        BMimeType type(lwc_string_data(mime));
                        BMessage extensions;
                        if (type.GetFileExtensions(&extensions) == B_OK) {
                                BString ext;
                                if (extensions.FindString("extensions", &ext) == B_OK)
                                        filename << "." << ext;
                        }
                        /* we unref(mime) later on, we just leak on error */
                }
 
                path.SetTo(TEMP_FILENAME_PREFIX);
                path.Append(filename.String());
                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;
                }
 
                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[] = {
                "text/x-source-code",
                "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 || err == B_ALREADY_RUNNING)
                        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, // get_resource_data
        NULL, // release_resource_data
        NULL, // fetch_mimetype
        NULL, // socket open
        NULL, // socket close
};
 
static struct gui_misc_table beos_misc_table = {
        beos_schedule,
        gui_quit,
        gui_launch_url,
        NULL, //401login
        NULL, // pdf_password (if we have Haru support)
        NULL, // present_cookies
};
 
 
/** 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,
                NULL, /* corewindow */
                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_option_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;
 
        BString lang;
#ifdef __HAIKU__
        BMessage preferredLangs;
        if (BLocaleRoster::Default()->GetPreferredLanguages(&preferredLangs) == B_OK) {
                preferredLangs.FindString("language", 0, &lang);
        }
#endif
        if (lang.Length() < 1)
                lang.SetTo(getenv("LC_MESSAGES"));
 
        char path[12];
        sprintf(path,"%.2s/Messages", lang.String());
        NSLOG(netsurf, INFO, "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();
 
        /* finalise options */
        nsoption_finalise(nsoptions, nsoptions_default);
 
        /* finalise logging */
        nslog_finalise();
 
        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,
                NULL, /* corewindow */
                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_option_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;
}