From d21447d096a320a08b3efb2b8768fad0dcdcfd64 Mon Sep 17 00:00:00 2001 From: Vincent Sanders Date: Thu, 5 May 2016 22:28:51 +0100 Subject: move frontends into sub directory --- frontends/atari/gui.c | 1217 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1217 insertions(+) create mode 100644 frontends/atari/gui.c (limited to 'frontends/atari/gui.c') diff --git a/frontends/atari/gui.c b/frontends/atari/gui.c new file mode 100644 index 000000000..810c7646f --- /dev/null +++ b/frontends/atari/gui.c @@ -0,0 +1,1217 @@ +/* + * Copyright 2010 + * + * 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 . + */ + +/** + * \file + * + * Provides all the mandatory functions prefixed with gui_ for atari + */ + +#include +#include +#include + +#include "utils/log.h" +#include "utils/messages.h" +#include "utils/corestrings.h" +#include "content/urldb.h" +#include "content/content.h" +#include "content/backing_store.h" +#include "content/hlcache.h" +#include "desktop/treeview.h" +#include "desktop/browser.h" +#include "desktop/gui_layout.h" +#include "desktop/gui_window.h" +#include "desktop/gui_clipboard.h" +#include "desktop/gui_fetch.h" +#include "desktop/gui_misc.h" +#include "desktop/netsurf.h" + +#include "atari/gemtk/gemtk.h" +#include "atari/gui.h" +#include "atari/misc.h" +#include "atari/findfile.h" +#include "atari/schedule.h" +#include "atari/rootwin.h" +#include "atari/statusbar.h" +#include "atari/toolbar.h" +#include "atari/hotlist.h" +#include "atari/cookies.h" +#include "atari/certview.h" +#include "atari/history.h" +#include "atari/login.h" +#include "atari/encoding.h" +#include "atari/res/netsurf.rsh" +#include "atari/plot/plot.h" +#include "atari/clipboard.h" +#include "atari/osspec.h" +#include "atari/search.h" +#include "atari/deskmenu.h" +#include "atari/download.h" +#include "atari/file.h" +#include "atari/filetype.h" +#include "atari/bitmap.h" +#include "atari/font.h" +#include "cflib.h" + +static bool atari_quit = false; + +struct gui_window *input_window = NULL; +struct gui_window *window_list = NULL; +void *h_gem_rsrc; +long next_poll; +bool rendering = false; +GRECT desk_area; + +/* Comandline / Options: */ +int option_window_width; +int option_window_height; +int option_window_x; +int option_window_y; + +/* Defaults to option_homepage_url, commandline options overwrites that value */ +const char *option_homepage_url; + +/* path to choices file: */ +char options[PATH_MAX]; + +EVMULT_IN aes_event_in = { + .emi_flags = MU_MESAG | MU_TIMER | MU_KEYBD | MU_BUTTON | MU_M1, + .emi_bclicks = 258, + .emi_bmask = 3, + .emi_bstate = 0, + .emi_m1leave = MO_ENTER, + .emi_m1 = {0,0,0,0}, + .emi_m2leave = 0, + .emi_m2 = {0,0,0,0}, + .emi_tlow = 0, + .emi_thigh = 0 +}; +EVMULT_OUT aes_event_out; +short aes_msg_out[8]; + +bool gui_window_get_scroll(struct gui_window *w, int *sx, int *sy); +static nserror gui_window_set_url(struct gui_window *w, nsurl *url); + +/** + * Core atari event processing. + */ +static void atari_poll(void) +{ + + struct gui_window *tmp; + short mx, my, dummy; + + aes_event_in.emi_tlow = schedule_run(); + + if(rendering){ + aes_event_in.emi_tlow = nsoption_int(atari_gui_poll_timeout); + } + + if(aes_event_in.emi_tlow < 0) { + aes_event_in.emi_tlow = 10000; + printf("long poll!\n"); + } + + if(input_window && input_window->root->redraw_slots.areas_used > 0) { + window_process_redraws(input_window->root); + } + + + graf_mkstate(&mx, &my, &dummy, &dummy); + aes_event_in.emi_m1.g_x = mx; + aes_event_in.emi_m1.g_y = my; + evnt_multi_fast(&aes_event_in, aes_msg_out, &aes_event_out); + if(gemtk_wm_dispatch_event(&aes_event_in, &aes_event_out, aes_msg_out) == 0) { + if( (aes_event_out.emo_events & MU_MESAG) != 0 ) { + LOG("WM: %d\n", aes_msg_out[0]); + switch(aes_msg_out[0]) { + + case MN_SELECTED: + LOG("Menu Item: %d\n", aes_msg_out[4]); + deskmenu_dispatch_item(aes_msg_out[3], aes_msg_out[4]); + break; + + case AP_TERM: + atari_quit = true; + break; + default: + break; + } + } + if((aes_event_out.emo_events & MU_KEYBD) != 0) { + uint16_t nkc = gem_to_norm( (short)aes_event_out.emo_kmeta, + (short)aes_event_out.emo_kreturn); + deskmenu_dispatch_keypress(aes_event_out.emo_kreturn, + aes_event_out.emo_kmeta, nkc); + } + } + + tmp = window_list; + while(tmp){ + if(tmp->root->redraw_slots.areas_used > 0){ + window_process_redraws(tmp->root); + } + tmp = tmp->next; + } + + /** @todo implement generic treeview redraw function. */ + /** @todo rename hl to atari_hotlist or create getter for it... */ + + atari_treeview_flush_redraws(); +} + +/** + * Create and open a gui window for a browsing context. + * + * \param bw bw to create gui_window for + * \param existing an existing gui_window, may be NULL + * \param flags flags for gui window creation + * \return gui window, or NULL on error + * + * If GW_CREATE_CLONE flag is set existing is non-NULL. + * + * The created gui_window must include a reference to the browser + * window passed in the bw param. + */ +static struct gui_window * +gui_window_create(struct browser_window *bw, + struct gui_window *existing, + gui_window_create_flags flags) +{ + struct gui_window *gw=NULL; + LOG("gw: %p, BW: %p, existing %p, flags: %d\n", gw, bw, existing, (int)flags); + + gw = calloc(1, sizeof(struct gui_window)); + if (gw == NULL) + return NULL; + + LOG("new window: %p, bw: %p\n", gw, bw); + window_create(gw, bw, existing, WIDGET_STATUSBAR|WIDGET_TOOLBAR|WIDGET_RESIZE\ + |WIDGET_SCROLL); + if (gw->root->win) { + GRECT pos = { + option_window_x, option_window_y, + option_window_width, option_window_height + }; + gui_window_set_url(gw, corestring_nsurl_about_blank); + gui_window_set_pointer(gw, BROWSER_POINTER_DEFAULT); + gui_set_input_gui_window(gw); + window_open(gw->root, gw, pos); + } + + /* add the window to the window list: */ + if( window_list == NULL ) { + window_list = gw; + gw->next = NULL; + gw->prev = NULL; + } else { + struct gui_window * tmp = window_list; + while( tmp->next != NULL ) { + tmp = tmp->next; + } + tmp->next = gw; + gw->prev = tmp; + gw->next = NULL; + } + + /* Loose focus: */ + window_set_focus(gw->root, WIDGET_NONE, NULL ); + + /* trigger on-focus event (select all text): */ + window_set_focus(gw->root, URL_WIDGET, NULL); + + /* delete selection: */ + toolbar_key_input(gw->root->toolbar, NK_DEL); + + return( gw ); + +} + +/** + * Destroy previously created gui window + * + * \param gw The gui window to destroy. + */ +void gui_window_destroy(struct gui_window *gw) +{ + if (gw == NULL) + return; + + LOG("%s\n", __FUNCTION__); + + if (input_window == gw) { + gui_set_input_gui_window(NULL); + } + + nsatari_search_session_destroy(gw->search); + free(gw->browser); + free(gw->status); + free(gw->title); + free(gw->url); + + /* unlink the window: */ + if(gw->prev != NULL ) { + gw->prev->next = gw->next; + } else { + window_list = gw->next; + } + if( gw->next != NULL ) { + gw->next->prev = gw->prev; + } + + window_unref_gui_window(gw->root, gw); + + free(gw); + gw = NULL; + + if(input_window == NULL) { + gw = window_list; + while( gw != NULL ) { + if(gw->root) { + gui_set_input_gui_window(gw); + break; + } + gw = gw->next; + } + } +} + +/** + * Find the current dimensions of a browser window's content area. + * + * \param w gui_window to measure + * \param width receives width of window + * \param height receives height of window + * \param scaled whether to return scaled values + */ +static void +gui_window_get_dimensions(struct gui_window *w, + int *width, + int *height, + bool scaled) +{ + if (w == NULL) + return; + GRECT rect; + window_get_grect(w->root, BROWSER_AREA_CONTENT, &rect); + *width = rect.g_w; + *height = rect.g_h; +} + +/** + * Set the title of a window. + * + * \param gw window to update + * \param title new window title + */ +static void gui_window_set_title(struct gui_window *gw, const char *title) +{ + if (gw == NULL) + return; + + if (gw->root) { + + int l; + char * conv; + l = strlen(title)+1; + if (utf8_to_local_encoding(title, l-1, &conv) == NSERROR_OK ) { + l = MIN((uint32_t)atari_sysinfo.aes_max_win_title_len, strlen(conv)); + if(gw->title == NULL) + gw->title = malloc(l); + else + gw->title = realloc(gw->title, l); + + strncpy(gw->title, conv, l); + free( conv ); + } else { + l = MIN((size_t)atari_sysinfo.aes_max_win_title_len, strlen(title)); + if(gw->title == NULL) + gw->title = malloc(l); + else + gw->title = realloc(gw->title, l); + strncpy(gw->title, title, l); + } + gw->title[l] = 0; + if(input_window == gw) + window_set_title(gw->root, gw->title); + } +} + +/* exported interface documented in atari/gui.h */ +void atari_window_set_status(struct gui_window *w, const char *text) +{ + int l; + if (w == NULL || text == NULL) + return; + + assert(w->root); + + l = strlen(text)+1; + if(w->status == NULL) + w->status = malloc(l); + else + w->status = realloc(w->status, l); + + strncpy(w->status, text, l); + w->status[l] = 0; + + if(input_window == w) + window_set_stauts(w->root, (char*)text); +} + +static void atari_window_reformat(struct gui_window *gw) +{ + int width = 0, height = 0; + + if (gw != NULL) { + gui_window_get_dimensions(gw, &width, &height, true); + browser_window_reformat(gw->browser->bw, false, width, height); + } +} + +static void gui_window_redraw_window(struct gui_window *gw) +{ + CMP_BROWSER b; + GRECT rect; + if (gw == NULL) + return; + b = gw->browser; + window_get_grect(gw->root, BROWSER_AREA_CONTENT, &rect); + window_schedule_redraw_grect(gw->root, &rect); +} + +static void gui_window_update_box(struct gui_window *gw, const struct rect *rect) +{ + GRECT area; + struct gemtk_wm_scroll_info_s *slid; + + if (gw == NULL) + return; + + slid = gemtk_wm_get_scroll_info(gw->root->win); + + window_get_grect(gw->root, BROWSER_AREA_CONTENT, &area); + area.g_x += rect->x0 - (slid->x_pos * slid->x_unit_px); + area.g_y += rect->y0 - (slid->y_pos * slid->y_unit_px); + area.g_w = rect->x1 - rect->x0; + area.g_h = rect->y1 - rect->y0; + //dbg_grect("update box", &area); + window_schedule_redraw_grect(gw->root, &area); +} + +bool gui_window_get_scroll(struct gui_window *w, int *sx, int *sy) +{ + if (w == NULL) + return false; + + window_get_scroll(w->root, sx, sy); + + return( true ); +} + +static void gui_window_set_scroll(struct gui_window *w, int sx, int sy) +{ + if ( (w == NULL) + || (w->browser->bw == NULL) + || (!browser_window_has_content(w->browser->bw))) + return; + + LOG("scroll (gui_window: %p) %d, %d\n", w, sx, sy); + window_scroll_by(w->root, sx, sy); + return; + +} + +/** + * Update the extent of the inside of a browser window to that of the + * current content. + * + * It seems this method is called when content size got adjusted, so + * that we can adjust scroll info. We also have to call it when tab + * change occurs. + * + * \param gw gui_window to update the extent of + */ +static void gui_window_update_extent(struct gui_window *gw) +{ + + if(browser_window_has_content(gw->browser->bw)) { + /** @todo store content size. */ + if(window_get_active_gui_window(gw->root) == gw) { + int width, height; + GRECT area; + browser_window_get_extents(gw->browser->bw, false, &width, &height); + window_set_content_size(gw->root, width, height); + window_update_back_forward(gw->root); + window_get_grect(gw->root, BROWSER_AREA_CONTENT, &area); + window_schedule_redraw_grect(gw->root, &area); + } + } +} + + +/** + * set the pointer shape + */ +void gui_window_set_pointer(struct gui_window *gw, gui_pointer_shape shape) +{ + if (gw == NULL) + return; + + switch (shape) { + case GUI_POINTER_POINT: /* link */ + gw->cursor = &gem_cursors.hand; + break; + + case GUI_POINTER_MENU: + gw->cursor = &gem_cursors.menu; + break; + + case GUI_POINTER_CARET: /* input */ + gw->cursor = &gem_cursors.ibeam; + break; + + case GUI_POINTER_CROSS: + gw->cursor = &gem_cursors.cross; + break; + + case GUI_POINTER_MOVE: + gw->cursor = &gem_cursors.sizeall; + break; + + case GUI_POINTER_RIGHT: + case GUI_POINTER_LEFT: + gw->cursor = &gem_cursors.sizewe; + break; + + case GUI_POINTER_UP: + case GUI_POINTER_DOWN: + gw->cursor = &gem_cursors.sizens; + break; + + case GUI_POINTER_RU: + case GUI_POINTER_LD: + gw->cursor = &gem_cursors.sizenesw; + break; + + case GUI_POINTER_RD: + case GUI_POINTER_LU: + gw->cursor = &gem_cursors.sizenwse; + break; + + case GUI_POINTER_WAIT: + gw->cursor = &gem_cursors.wait; + break; + + case GUI_POINTER_PROGRESS: + gw->cursor = &gem_cursors.appstarting; + break; + + case GUI_POINTER_NO_DROP: + gw->cursor = &gem_cursors.nodrop; + break; + + case GUI_POINTER_NOT_ALLOWED: + gw->cursor = &gem_cursors.deny; + break; + + case GUI_POINTER_HELP: + gw->cursor = &gem_cursors.help; + break; + + default: + gw->cursor = &gem_cursors.arrow; + break; + } + + if (input_window == gw) { + gem_set_cursor(gw->cursor); + } +} + + +static nserror gui_window_set_url(struct gui_window *w, nsurl *url) +{ + int l; + + if (w == NULL) + return NSERROR_OK; + + l = strlen(nsurl_access(url))+1; + + if (w->url == NULL) { + w->url = malloc(l); + } else { + w->url = realloc(w->url, l); + } + strncpy(w->url, nsurl_access(url), l); + w->url[l] = 0; + if(input_window == w->root->active_gui_window) { + toolbar_set_url(w->root->toolbar, nsurl_access(url)); + } + + return NSERROR_OK; +} + +char * gui_window_get_url(struct gui_window *gw) +{ + if (gw == NULL) { + return(NULL); + } + return(gw->url); +} + +char * gui_window_get_title(struct gui_window *gw) +{ + if (gw == NULL) { + return(NULL); + } + return(gw->title); +} + +static void throbber_advance( void * data ) +{ + + struct gui_window * gw = (struct gui_window *)data; + + if (gw->root == NULL) + return; + if (gw->root->toolbar == NULL) + return; + + if (gw->root->toolbar->throbber.running == false) + return; + + toolbar_throbber_progress(gw->root->toolbar); + atari_schedule(1000, throbber_advance, gw ); +} + +static void gui_window_start_throbber(struct gui_window *w) +{ + if (w == NULL) + return; + + toolbar_set_throbber_state(w->root->toolbar, true); + atari_schedule(1000, throbber_advance, w ); + rendering = true; +} + +static void gui_window_stop_throbber(struct gui_window *w) +{ + if (w == NULL) + return; + if (w->root->toolbar->throbber.running == false) + return; + + atari_schedule(-1, throbber_advance, w); + + toolbar_set_throbber_state(w->root->toolbar, false); + + rendering = false; +} + +/** + * Place caret in window + */ +static void +gui_window_place_caret(struct gui_window *w, int x, int y, int height, + const struct rect *clip) +{ + window_place_caret(w->root, 1, x, y, height, NULL); + w->root->caret.state |= CARET_STATE_ENABLED; + return; +} + + +/** + * clear window caret + */ +static void +gui_window_remove_caret(struct gui_window *w) +{ + if (w == NULL) + return; + + if ((w->root->caret.state & CARET_STATE_ENABLED) != 0) { + //printf("gw hide caret\n"); + window_place_caret(w->root, 0, -1, -1, -1, NULL); + w->root->caret.state &= ~CARET_STATE_ENABLED; + } + return; +} + +/** + * Set a favicon for a gui window. + * + * \param g window to update. + * \param icon handle to object to use as icon. + */ +static void +gui_window_set_icon(struct gui_window *g, hlcache_handle *icon) +{ + struct bitmap *bmp_icon; + + bmp_icon = (icon != NULL) ? content_get_bitmap(icon) : NULL; + g->icon = bmp_icon; + if(input_window == g) { + window_set_icon(g->root, bmp_icon); + } +} + +static void gui_window_new_content(struct gui_window *w) +{ + struct gemtk_wm_scroll_info_s *slid = gemtk_wm_get_scroll_info(w->root->win); + slid->x_pos = 0; + slid->y_pos = 0; + gemtk_wm_update_slider(w->root->win, GEMTK_WM_VH_SLIDER); + gui_window_redraw_window(w); +} + + +/** + * Core asks front end for clipboard contents. + * + * \param buffer UTF-8 text, allocated by front end, ownership yeilded to core + * \param length Byte length of UTF-8 text in buffer + */ +static void gui_get_clipboard(char **buffer, size_t *length) +{ + char *clip; + + *length = 0; + *buffer = 0; + + clip = scrap_txt_read(); + + if(clip == NULL) { + return; + } else { + + // clipboard is in atari encoding, convert it to utf8: + + size_t clip_len; + char *utf8 = NULL; + + clip_len = strlen(clip); + if (clip_len > 0) { + nserror ret; + ret = utf8_to_local_encoding(clip, clip_len, &utf8); + if (ret == NSERROR_OK && utf8 != NULL) { + *buffer = utf8; + *length = strlen(utf8); + } else { + assert(ret == NSERROR_OK && utf8 != NULL); + } + } + + free(clip); + } +} + +/** + * Core tells front end to put given text in clipboard + * + * \param buffer UTF-8 text, owned by core + * \param length Byte length of UTF-8 text in buffer + * \param styles Array of styles given to text runs, owned by core, or NULL + * \param n_styles Number of text run styles in array + */ +static void gui_set_clipboard(const char *buffer, size_t length, + nsclipboard_styles styles[], int n_styles) +{ + if (length > 0 && buffer != NULL) { + + // convert utf8 input to atari encoding: + + nserror ret; + char *clip = NULL; + + ret = utf8_to_local_encoding(buffer,length, &clip); + if (ret == NSERROR_OK) { + scrap_txt_write(clip); + } else { + assert(ret == NSERROR_OK); + } + free(clip); + } +} + +static void gui_401login_open(nsurl *url, const char *realm, + nserror (*cb)(bool proceed, void *pw), void *cbpw) +{ + bool bres; + char * out = NULL; + bres = login_form_do( url, (char*)realm, &out); + if (bres) { + LOG("url: %s, realm: %s, auth: %s\n", nsurl_access(url), realm, out); + urldb_set_auth_details(url, realm, out); + } + if (out != NULL) { + free( out ); + } + if (cb != NULL) { + cb(bres, cbpw); + } + +} + +static void +gui_cert_verify(nsurl *url, const struct ssl_cert_info *certs, + unsigned long num, nserror (*cb)(bool proceed, void *pw), + void *cbpw) +{ + struct sslcert_session_data *data; + LOG("url %s", nsurl_access(url)); + + // TODO: localize string + int b = form_alert(1, "[2][SSL Verify failed, continue?][Continue|Abort|Details...]"); + if(b == 1){ + // Accept + urldb_set_cert_permissions(url, true); + cb(true, cbpw); + } else if(b == 2) { + // Reject + urldb_set_cert_permissions(url, false); + cb(false, cbpw); + } else if(b == 3) { + // Inspect + sslcert_viewer_create_session_data(num, url, cb, cbpw, certs, + &data); + atari_sslcert_viewer_open(data); + } + +} + +void gui_set_input_gui_window(struct gui_window *gw) +{ + LOG("Setting input window from: %p to %p\n", input_window, gw); + input_window = gw; +} + +struct gui_window * gui_get_input_window(void) +{ + return(input_window); +} + +static void gui_quit(void) +{ + LOG("quitting"); + + struct gui_window *gw = window_list; + struct gui_window *tmp = window_list; + + /* Destroy all remaining browser windows: */ + while (gw) { + tmp = gw->next; + browser_window_destroy(gw->browser->bw); + gw = tmp; + } + + /* destroy the treeview windows: */ + atari_global_history_destroy(); + atari_hotlist_destroy(); + atari_cookie_manager_destroy(); + + /* shutdown netsurf treeview framework: */ + treeview_fini(); + + /* shutdown the toolbar framework: */ + toolbar_exit(); + + /* save persistent informations: */ + urldb_save_cookies(nsoption_charp(cookie_file)); + urldb_save(nsoption_charp(url_file)); + + deskmenu_destroy(); + gemtk_wm_exit(); + + rsrc_free(); + + LOG("Shutting down plotter"); + plot_finalise(); + LOG("done"); +} + +/** + * Process commandline parameters. + */ +static bool +process_cmdline(int argc, char** argv) +{ + int opt; + bool set_default_dimensions = true; + + LOG("argc %d, argv %p", argc, argv); + + if ((nsoption_int(window_width) != 0) && (nsoption_int(window_height) != 0)) { + + option_window_width = nsoption_int(window_width); + option_window_height = nsoption_int(window_height); + option_window_x = nsoption_int(window_x); + option_window_y = nsoption_int(window_y); + + if (option_window_width <= desk_area.g_w + && option_window_height < desk_area.g_h) { + set_default_dimensions = false; + } + } + + if (set_default_dimensions) { + if( sys_type() == SYS_TOS ) { + /* on single tasking OS, start as fulled window: */ + option_window_width = desk_area.g_w; + option_window_height = desk_area.g_h; + option_window_x = desk_area.g_w/2-(option_window_width/2); + option_window_y = (desk_area.g_h/2)-(option_window_height/2); + } else { + option_window_width = 600; + option_window_height = 360; + option_window_x = 10; + option_window_y = 30; + } + } + + if (nsoption_charp(homepage_url) != NULL) + option_homepage_url = nsoption_charp(homepage_url); + else + option_homepage_url = NETSURF_HOMEPAGE; + + while((opt = getopt(argc, argv, "w:h:")) != -1) { + switch (opt) { + case 'w': + option_window_width = atoi(optarg); + break; + + case 'h': + option_window_height = atoi(optarg); + break; + + default: + fprintf(stderr, + "Usage: %s [w,h,v] url\n", + argv[0]); + return false; + } + } + + if (optind < argc) { + option_homepage_url = argv[optind]; + } + return true; +} + +static inline void create_cursor(int flags, short mode, void * form, + MFORM_EX * m) +{ + m->flags = flags; + m->number = mode; + if( flags & MFORM_EX_FLAG_USERFORM ) { + m->number = mode; + m->tree = (OBJECT*)form; + } +} + +static nsurl *gui_get_resource_url(const char *path) +{ + char buf[PATH_MAX]; + nsurl *url = NULL; + + atari_find_resource((char*)&buf, path, path); + + netsurf_path_to_nsurl(buf, &url); + + return url; +} + +/** + * Set option defaults for atari frontend + * + * @param defaults The option table to update. + * @return error status. + */ +static nserror set_defaults(struct nsoption_s *defaults) +{ + /* Set defaults for absent option strings */ + nsoption_setnull_charp(cookie_file, strdup("cookies")); + if (nsoption_charp(cookie_file) == NULL) { + LOG("Failed initialising string options"); + return NSERROR_BAD_PARAMETER; + } + return NSERROR_OK; +} + +static char *theapp = (char*)"NetSurf"; + +/** + * Initialise atari gui. + */ +static void gui_init(int argc, char** argv) +{ + char buf[PATH_MAX]; + OBJECT * cursors; + + atari_find_resource(buf, "netsurf.rsc", "./res/netsurf.rsc"); + LOG("Using RSC file: %s ", (char *)&buf); + if (rsrc_load(buf)==0) { + + char msg[1024]; + + snprintf(msg, 1024, "Unable to open GEM Resource file (%s)!", buf); + die(msg); + } + + wind_get_grect(0, WF_WORKXYWH, &desk_area); + + create_cursor(0, POINT_HAND, NULL, &gem_cursors.hand ); + create_cursor(0, TEXT_CRSR, NULL, &gem_cursors.ibeam ); + create_cursor(0, THIN_CROSS, NULL, &gem_cursors.cross); + create_cursor(0, BUSY_BEE, NULL, &gem_cursors.wait); + create_cursor(0, ARROW, NULL, &gem_cursors.arrow); + create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizeall); + create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizenesw); + create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizenwse); + cursors = gemtk_obj_get_tree(CURSOR); + create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_APPSTART, + cursors, &gem_cursors.appstarting); + gem_set_cursor( &gem_cursors.appstarting ); + create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_SIZEWE, + cursors, &gem_cursors.sizewe); + create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_SIZENS, + cursors, &gem_cursors.sizens); + create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_NODROP, + cursors, &gem_cursors.nodrop); + create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_DENY, + cursors, &gem_cursors.deny); + create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_MENU, + cursors, &gem_cursors.menu); + create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_HELP, + cursors, &gem_cursors.help); + + LOG("Enabling core select menu"); + nsoption_set_bool(core_select_menu, true); + + LOG("Loading url.db from: %s", nsoption_charp(url_file)); + if( strlen(nsoption_charp(url_file)) ) { + urldb_load(nsoption_charp(url_file)); + } + + LOG("Loading cookies from: %s", nsoption_charp(cookie_file)); + if( strlen(nsoption_charp(cookie_file)) ) { + urldb_load_cookies(nsoption_charp(cookie_file)); + } + + if (process_cmdline(argc,argv) != true) + die("unable to process command line.\n"); + + LOG("Initializing NKC..."); + nkc_init(); + + LOG("Initializing plotters..."); + plot_init(nsoption_charp(atari_font_driver)); + + aes_event_in.emi_m1leave = MO_LEAVE; + aes_event_in.emi_m1.g_w = 1; + aes_event_in.emi_m1.g_h = 1; + //next_poll = clock() + (CLOCKS_PER_SEC>>3); + + deskmenu_init(); + menu_register( -1, theapp); + if (sys_type() & (SYS_MAGIC|SYS_NAES|SYS_XAAES)) { + menu_register( _AESapid, (char*)" NetSurf "); + } + gemtk_wm_init(); + + /* Initialize the netsurf treeview framework with default font size: */ + treeview_init(0); + + /* Initialize the specific treeview windows: */ + atari_global_history_init(); + atari_hotlist_init(); + atari_cookie_manager_init(); + + /* Initialize the toolbar framework: */ + toolbar_init(); +} + +static struct gui_window_table atari_window_table = { + .create = gui_window_create, + .destroy = gui_window_destroy, + .redraw = gui_window_redraw_window, + .update = gui_window_update_box, + .get_scroll = gui_window_get_scroll, + .set_scroll = gui_window_set_scroll, + .get_dimensions = gui_window_get_dimensions, + .update_extent = gui_window_update_extent, + .reformat = atari_window_reformat, + + .set_title = gui_window_set_title, + .set_url = gui_window_set_url, + .set_icon = gui_window_set_icon, + .set_status = atari_window_set_status, + .set_pointer = gui_window_set_pointer, + .place_caret = gui_window_place_caret, + .remove_caret = gui_window_remove_caret, + .new_content = gui_window_new_content, + .start_throbber = gui_window_start_throbber, + .stop_throbber = gui_window_stop_throbber, +}; + +static struct gui_clipboard_table atari_clipboard_table = { + .get = gui_get_clipboard, + .set = gui_set_clipboard, +}; + +static struct gui_fetch_table atari_fetch_table = { + .filetype = fetch_filetype, + + .get_resource_url = gui_get_resource_url, +}; + +static struct gui_misc_table atari_misc_table = { + .schedule = atari_schedule, + .warning = atari_warn_user, + + .quit = gui_quit, + .cert_verify = gui_cert_verify, + .login = gui_401login_open, +}; + +/* #define WITH_DBG_LOGFILE 1 */ +/** + * Entry point from OS. + * + * /param argc The number of arguments in the string vector. + * /param argv The argument string vector. + * /return The return code to the OS + */ +int main(int argc, char** argv) +{ + char messages[PATH_MAX]; + char store[PATH_MAX]; + const char *addr; + char * file_url = NULL; + struct stat stat_buf; + nsurl *url; + nserror ret; + + struct netsurf_table atari_table = { + .misc = &atari_misc_table, + .window = &atari_window_table, + .clipboard = &atari_clipboard_table, + .download = atari_download_table, + .fetch = &atari_fetch_table, + .file = atari_file_table, + .utf8 = atari_utf8_table, + .search = atari_search_table, + .llcache = filesystem_llcache_table, + .bitmap = atari_bitmap_table, + .layout = atari_layout_table + }; + + ret = netsurf_register(&atari_table); + if (ret != NSERROR_OK) { + die("NetSurf operation table failed registration"); + } + + /** @todo logging file descriptor update belongs in a nslog_init callback */ + setbuf(stderr, NULL); + setbuf(stdout, NULL); +#ifdef WITH_DBG_LOGFILE + freopen("stdout.log", "a+", stdout); + freopen("stderr.log", "a+", stderr); +#endif + + graf_mouse(BUSY_BEE, NULL); + + init_app(NULL); + + init_os_info(); + + atari_find_resource((char*)&messages, "messages", "res/messages"); + atari_find_resource((char*)&options, "Choices", "Choices"); + atari_find_resource((char*)&store, "cache", "res/cache"); + + /* initialise logging - not fatal if it fails but not much we can + * do about it + */ + nslog_init(NULL, &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, NULL); + nsoption_commandline(&argc, argv, NULL); + + ret = messages_add_from_file(messages); + + /* common initialisation */ + LOG("Initialising core..."); + ret = netsurf_init(store); + if (ret != NSERROR_OK) { + die("NetSurf failed to initialise"); + } + + LOG("Initializing GUI..."); + gui_init(argc, argv); + + graf_mouse( ARROW , NULL); + + LOG("Creating initial browser window..."); + addr = option_homepage_url; + if (strncmp(addr, "file://", 7) && strncmp(addr, "http://", 7)) { + if (stat(addr, &stat_buf) == 0) { + file_url = local_file_to_url(addr); + addr = file_url; + } + } + + /* create an initial browser window */ + ret = nsurl_create(addr, &url); + if (ret == NSERROR_OK) { + ret = browser_window_create(BW_CREATE_HISTORY, + url, + NULL, + NULL, + NULL); + nsurl_unref(url); + } + if (ret != NSERROR_OK) { + atari_warn_user(messages_get_errorcode(ret), 0); + } else { + LOG("Entering Atari event mainloop..."); + while (!atari_quit) { + atari_poll(); + } + } + + netsurf_exit(); + + free(file_url); + +#ifdef WITH_DBG_LOGFILE + fclose(stdout); + fclose(stderr); +#endif + LOG("exit_gem"); + exit_gem(); + + return 0; +} -- cgit v1.2.3